plugins/org.argeo.slc.client.ui.dist/src/main/java/org/argeo/slc/client/ui/dist/views/DistributionsView.java

   1 /*
   2  * Copyright (C) 2007-2012 Argeo GmbH
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *         http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.argeo.slc.client.ui.dist.views;
  17
  18 import java.util.ArrayList;
  19 import java.util.HashMap;
  20 import java.util.List;
  21 import java.util.Map;
  22
  23 import javax.jcr.Credentials;
  24 import javax.jcr.NoSuchWorkspaceException;
  25 import javax.jcr.Node;
  26 import javax.jcr.NodeIterator;
  27 import javax.jcr.Property;
  28 import javax.jcr.Repository;
  29 import javax.jcr.RepositoryException;
  30 import javax.jcr.RepositoryFactory;
  31 import javax.jcr.Session;
  32 import javax.jcr.nodetype.NodeType;
  33 import javax.jcr.query.Query;
  34 import javax.jcr.query.QueryResult;
  35
  36 import org.apache.commons.logging.Log;
  37 import org.apache.commons.logging.LogFactory;
  38 import org.argeo.ArgeoMonitor;
  39 import org.argeo.eclipse.ui.EclipseArgeoMonitor;
  40 import org.argeo.eclipse.ui.ErrorFeedback;
  41 import org.argeo.eclipse.ui.TreeParent;
  42 import org.argeo.jcr.ArgeoJcrUtils;
  43 import org.argeo.jcr.ArgeoNames;
  44 import org.argeo.jcr.ArgeoTypes;
  45 import org.argeo.jcr.JcrUtils;
  46 import org.argeo.jcr.UserJcrUtils;
  47 import org.argeo.slc.SlcException;
  48 import org.argeo.slc.client.ui.dist.DistPlugin;
  49 import org.argeo.slc.client.ui.dist.commands.CopyWorkspace;
  50 import org.argeo.slc.client.ui.dist.commands.CreateWorkspace;
  51 import org.argeo.slc.client.ui.dist.commands.DeleteWorkspace;
  52 import org.argeo.slc.client.ui.dist.commands.ManageWorkspaceAuth;
  53 import org.argeo.slc.client.ui.dist.commands.NormalizeDistribution;
  54 import org.argeo.slc.client.ui.dist.editors.DistributionEditor;
  55 import org.argeo.slc.client.ui.dist.editors.DistributionEditorInput;
  56 import org.argeo.slc.client.ui.dist.utils.CommandHelpers;
  57 import org.argeo.slc.jcr.SlcNames;
  58 import org.argeo.slc.repo.RepoConstants;
  59 import org.argeo.slc.repo.RepoUtils;
  60 import org.argeo.util.security.Keyring;
  61 import org.eclipse.core.runtime.IProgressMonitor;
  62 import org.eclipse.core.runtime.IStatus;
  63 import org.eclipse.core.runtime.Status;
  64 import org.eclipse.core.runtime.jobs.Job;
  65 import org.eclipse.jface.action.IMenuListener;
  66 import org.eclipse.jface.action.IMenuManager;
  67 import org.eclipse.jface.action.MenuManager;
  68 import org.eclipse.jface.dialogs.MessageDialog;
  69 import org.eclipse.jface.viewers.ColumnLabelProvider;
  70 import org.eclipse.jface.viewers.DoubleClickEvent;
  71 import org.eclipse.jface.viewers.IDoubleClickListener;
  72 import org.eclipse.jface.viewers.IStructuredSelection;
  73 import org.eclipse.jface.viewers.ITreeContentProvider;
  74 import org.eclipse.jface.viewers.TreeViewer;
  75 import org.eclipse.jface.viewers.TreeViewerColumn;
  76 import org.eclipse.jface.viewers.Viewer;
  77 import org.eclipse.jface.viewers.ViewerDropAdapter;
  78 import org.eclipse.swt.SWT;
  79 import org.eclipse.swt.dnd.DND;
  80 import org.eclipse.swt.dnd.DragSourceAdapter;
  81 import org.eclipse.swt.dnd.DragSourceEvent;
  82 import org.eclipse.swt.dnd.TextTransfer;
  83 import org.eclipse.swt.dnd.Transfer;
  84 import org.eclipse.swt.dnd.TransferData;
  85 import org.eclipse.swt.widgets.Composite;
  86 import org.eclipse.swt.widgets.Menu;
  87 import org.eclipse.swt.widgets.Tree;
  88 import org.eclipse.ui.IWorkbenchWindow;
  89 import org.eclipse.ui.PartInitException;
  90 import org.eclipse.ui.part.ViewPart;
  91
  92 /**
  93  * Browse and manipulate distributions (like merge, rename, etc.). Only support
  94  * one single repository currently.
  95  */
  96 public class DistributionsView extends ViewPart implements SlcNames, ArgeoNames {
  97         private final static Log log = LogFactory.getLog(DistributionsView.class);
  98         public final static String ID = DistPlugin.ID + ".distributionsView";
  99
 100         private Repository nodeRepository;
 101         private RepositoryFactory repositoryFactory;
 102         private Keyring keyring;
 103
 104         private TreeViewer viewer;
 105
 106         @Override
 107         public void createPartControl(Composite parent) {
 108                 // Define the TableViewer
 109                 viewer = new TreeViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL
 110                                 | SWT.FULL_SELECTION | SWT.BORDER);
 111
 112                 TreeViewerColumn col = new TreeViewerColumn(viewer, SWT.NONE);
 113                 col.getColumn().setWidth(200);
 114                 col.setLabelProvider(new ColumnLabelProvider() {
 115                         @Override
 116                         public String getText(Object element) {
 117                                 if (element instanceof RepoElem)
 118                                         return ((RepoElem) element).getLabel();
 119                                 return element.toString();
 120                         }
 121                 });
 122
 123                 final Tree table = viewer.getTree();
 124                 table.setHeaderVisible(false);
 125                 table.setLinesVisible(false);
 126
 127                 viewer.setContentProvider(new DistributionsContentProvider());
 128                 viewer.addDoubleClickListener(new DistributionsDCL());
 129
 130                 // Drag'n drop
 131                 Transfer[] tt = new Transfer[] { TextTransfer.getInstance() };
 132                 int operations = DND.DROP_COPY | DND.DROP_MOVE;
 133                 viewer.addDragSupport(operations, tt, new ViewDragListener());
 134                 viewer.addDropSupport(operations, tt, new ViewDropListener(viewer));
 135
 136                 MenuManager menuManager = new MenuManager();
 137                 Menu menu = menuManager.createContextMenu(viewer.getTree());
 138                 menuManager.addMenuListener(new IMenuListener() {
 139                         public void menuAboutToShow(IMenuManager manager) {
 140                                 contextMenuAboutToShow(manager);
 141                         }
 142                 });
 143                 viewer.getTree().setMenu(menu);
 144                 getSite().registerContextMenu(menuManager, viewer);
 145
 146                 Session nodeSession = null;
 147                 try {
 148                         nodeSession = nodeRepository.login();
 149
 150                         // make sure base directory is available
 151                         Node repos = JcrUtils.mkdirs(nodeSession,
 152                                         UserJcrUtils.getUserHome(nodeSession).getPath()
 153                                                         + RepoConstants.REPOSITORIES_BASE_PATH);
 154                         nodeSession.save();
 155
 156                         // register default local java repository
 157                         String alias = RepoConstants.DEFAULT_JAVA_REPOSITORY_ALIAS;
 158                         Repository javaRepository = ArgeoJcrUtils.getRepositoryByAlias(
 159                                         repositoryFactory, alias);
 160                         if (javaRepository != null) {
 161                                 if (!repos.hasNode(alias)) {
 162                                         Node repoNode = repos.addNode(alias,
 163                                                         ArgeoTypes.ARGEO_REMOTE_REPOSITORY);
 164                                         repoNode.setProperty(ARGEO_URI, "vm:///" + alias);
 165                                         repoNode.addMixin(NodeType.MIX_TITLE);
 166                                         repoNode.setProperty(Property.JCR_TITLE, "Internal "
 167                                                         + alias + " repository");
 168                                         nodeSession.save();
 169                                 }
 170                         }
 171                 } catch (RepositoryException e) {
 172                         throw new SlcException("Cannot register repository", e);
 173                 } finally {
 174                         JcrUtils.logoutQuietly(nodeSession);
 175                 }
 176
 177                 viewer.setInput(nodeRepository);
 178
 179         }
 180
 181         /** Programatically configure the context menu */
 182         protected void contextMenuAboutToShow(IMenuManager menuManager) {
 183                 IWorkbenchWindow window = DistPlugin.getDefault().getWorkbench()
 184                                 .getActiveWorkbenchWindow();
 185                 // Get Current selected item :
 186                 Object firstElement = ((IStructuredSelection) viewer.getSelection())
 187                                 .getFirstElement();
 188
 189                 if (firstElement instanceof TreeParent) {
 190                         TreeParent tp = (TreeParent) firstElement;
 191                         String wsName = tp.getName();
 192
 193                         // Build conditions depending on element type (repo or distribution
 194                         // for the time being)
 195                         boolean isDistribElem = false; // , isRepoElem = false;
 196
 197                         // if (tp instanceof RepositoryElem){
 198                         // isRepoElem = true;
 199                         // } else
 200                         if (tp instanceof DistributionElem) {
 201                                 isDistribElem = true;
 202                         }
 203
 204                         // create workspace
 205                         CommandHelpers.refreshCommand(menuManager, window,
 206                                         CreateWorkspace.ID, CreateWorkspace.DEFAULT_LABEL,
 207                                         CreateWorkspace.DEFAULT_ICON_PATH, !isDistribElem);
 208
 209                         // Normalize workspace
 210                         Map<String, String> params = new HashMap<String, String>();
 211                         params.put(NormalizeDistribution.PARAM_WORKSPACE, wsName);
 212                         CommandHelpers.refreshParameterizedCommand(menuManager, window,
 213                                         NormalizeDistribution.ID,
 214                                         NormalizeDistribution.DEFAULT_LABEL,
 215                                         NormalizeDistribution.DEFAULT_ICON_PATH, isDistribElem,
 216                                         params);
 217
 218                         // Copy workspace
 219                         params = new HashMap<String, String>();
 220                         params.put(CopyWorkspace.PARAM_WORKSPACE_NAME, wsName);
 221                         CommandHelpers.refreshParameterizedCommand(menuManager, window,
 222                                         CopyWorkspace.ID, CopyWorkspace.DEFAULT_LABEL,
 223                                         CopyWorkspace.DEFAULT_ICON_PATH, isDistribElem, params);
 224
 225                         // Delete Workspace
 226                         params = new HashMap<String, String>();
 227                         params.put(DeleteWorkspace.PARAM_WORKSPACE_NAME, wsName);
 228                         CommandHelpers.refreshParameterizedCommand(menuManager, window,
 229                                         DeleteWorkspace.ID, DeleteWorkspace.DEFAULT_LABEL,
 230                                         DeleteWorkspace.DEFAULT_ICON_PATH, isDistribElem, params);
 231
 232                         // Manage workspace authorizations
 233                         params = new HashMap<String, String>();
 234                         params.put(ManageWorkspaceAuth.PARAM_WORKSPACE_NAME, wsName);
 235                         CommandHelpers.refreshParameterizedCommand(menuManager, window,
 236                                         ManageWorkspaceAuth.ID, ManageWorkspaceAuth.DEFAULT_LABEL,
 237                                         ManageWorkspaceAuth.DEFAULT_ICON_PATH, isDistribElem,
 238                                         params);
 239                 }
 240         }
 241
 242         @Override
 243         public void setFocus() {
 244                 viewer.getTree().setFocus();
 245         }
 246
 247         /*
 248          * DEPENDENCY INJECTION
 249          */
 250         /**
 251          * Force refresh of the whole view
 252          */
 253         public void refresh() {
 254                 viewer.setContentProvider(new DistributionsContentProvider());
 255         }
 256
 257         public void setNodeRepository(Repository repository) {
 258                 this.nodeRepository = repository;
 259         }
 260
 261         public void setRepositoryFactory(RepositoryFactory repositoryFactory) {
 262                 this.repositoryFactory = repositoryFactory;
 263         }
 264
 265         public void setKeyring(Keyring keyring) {
 266                 this.keyring = keyring;
 267         }
 268
 269         /*
 270          * INTERNAL CLASSES
 271          */
 272         /** Content provider */
 273         private class DistributionsContentProvider implements ITreeContentProvider {
 274                 Session nodeSession;
 275                 List<RepoElem> repositories = new ArrayList<RepoElem>();
 276
 277                 public Object[] getElements(Object input) {
 278                         Repository nodeRepository = (Repository) input;
 279                         try {
 280                                 if (nodeSession != null)
 281                                         dispose();
 282                                 nodeSession = nodeRepository.login();
 283
 284                                 String reposPath = UserJcrUtils.getUserHome(nodeSession)
 285                                                 .getPath() + RepoConstants.REPOSITORIES_BASE_PATH;
 286                                 NodeIterator repos = nodeSession.getNode(reposPath).getNodes();
 287                                 while (repos.hasNext()) {
 288                                         Node repoNode = repos.nextNode();
 289                                         if (repoNode.isNodeType(ArgeoTypes.ARGEO_REMOTE_REPOSITORY)) {
 290                                                 repositories.add(new RepoElem(repoNode));
 291                                         }
 292                                 }
 293                         } catch (RepositoryException e) {
 294                                 throw new SlcException("Cannot get base elements", e);
 295                         }
 296                         return repositories.toArray();
 297                 }
 298
 299                 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 300
 301                 }
 302
 303                 public Object[] getChildren(Object parentElement) {
 304                         if (parentElement instanceof RepoElem) {
 305                                 return ((RepoElem) parentElement).getChildren();
 306                         } else if (parentElement instanceof DistributionElem) {
 307                                 return ((DistributionElem) parentElement).getChildren();
 308                         }
 309                         return null;
 310                 }
 311
 312                 public Object getParent(Object element) {
 313                         // TODO register repo elem in distirbution elem?
 314                         return null;
 315                 }
 316
 317                 public boolean hasChildren(Object element) {
 318                         if (element instanceof RepoElem) {
 319                                 return true;
 320                         } else if (element instanceof DistributionElem) {
 321                                 return false;
 322                         }
 323                         return false;
 324                 }
 325
 326                 public void dispose() {
 327                         for (RepoElem repoElem : repositories)
 328                                 repoElem.dispose();
 329                         repositories = new ArrayList<RepoElem>();
 330                         JcrUtils.logoutQuietly(nodeSession);
 331                 }
 332
 333         }
 334
 335         /** A software repository */
 336         private class RepoElem {
 337                 private Node repoNode;
 338
 339                 private Repository repository;
 340                 private Credentials credentials;
 341
 342                 public RepoElem(Node repoNode) {
 343                         this.repoNode = repoNode;
 344                 }
 345
 346                 /** Lazily connects to repository */
 347                 protected void connect() {
 348                         if (repository != null)
 349                                 return;
 350                         repository = RepoUtils.getRepository(repositoryFactory, keyring,
 351                                         repoNode);
 352                         credentials = RepoUtils.getRepositoryCredentials(keyring, repoNode);
 353                 }
 354
 355                 public String getLabel() {
 356                         try {
 357                                 if (repoNode.isNodeType(NodeType.MIX_TITLE)) {
 358                                         return repoNode.getProperty(Property.JCR_TITLE).getString();
 359                                 } else {
 360                                         return repoNode.getName();
 361                                 }
 362                         } catch (RepositoryException e) {
 363                                 throw new SlcException("Cannot read label of " + repoNode, e);
 364                         }
 365                 }
 366
 367                 public String toString() {
 368                         return repoNode.toString();
 369                 }
 370
 371                 public Object[] getChildren() {
 372                         connect();
 373                         Session session = null;
 374                         try {
 375                                 session = repository.login(credentials);
 376                                 String[] workspaceNames = session.getWorkspace()
 377                                                 .getAccessibleWorkspaceNames();
 378                                 List<DistributionElem> distributionElems = new ArrayList<DistributionElem>();
 379                                 for (String workspaceName : workspaceNames) {
 380                                         Node workspaceNode = repoNode.hasNode(workspaceName) ? repoNode
 381                                                         .getNode(workspaceName) : repoNode
 382                                                         .addNode(workspaceName);
 383                                         repoNode.getSession().save();
 384                                         distributionElems.add(new DistributionElem(this,
 385                                                         workspaceNode));
 386                                         // FIXME remove deleted workspaces
 387                                 }
 388                                 return distributionElems.toArray();
 389                         } catch (RepositoryException e) {
 390                                 throw new SlcException(
 391                                                 "Cannot list workspaces for " + repoNode, e);
 392                         } finally {
 393                                 JcrUtils.logoutQuietly(session);
 394                         }
 395                 }
 396
 397                 public void dispose() {
 398                 }
 399
 400                 public Node getRepoNode() {
 401                         return repoNode;
 402                 }
 403
 404                 public String getRepoPath() {
 405                         try {
 406                                 return repoNode.getPath();
 407                         } catch (RepositoryException e) {
 408                                 throw new SlcException("Cannot get path for " + repoNode, e);
 409                         }
 410                 }
 411
 412                 public Repository getRepository() {
 413                         connect();
 414                         return repository;
 415                 }
 416
 417                 public Credentials getCredentials() {
 418                         return credentials;
 419                 }
 420
 421         }
 422
 423         /** Abstracts a distribution, that is a workspace */
 424         private static class DistributionElem extends TreeParent {
 425                 private final RepoElem repoElem;
 426                 private final Node workspaceNode;
 427
 428                 public DistributionElem(RepoElem repoElem, Node workspaceNode) {
 429                         super(JcrUtils.getNameQuietly(workspaceNode));
 430                         this.repoElem = repoElem;
 431                         this.workspaceNode = workspaceNode;
 432                 }
 433
 434                 public Node getWorkspaceNode() {
 435                         return workspaceNode;
 436                 }
 437
 438                 public String getWorkspaceName() {
 439                         return JcrUtils.getNameQuietly(workspaceNode);
 440                 }
 441
 442                 public String getWorkspacePath() {
 443                         try {
 444                                 return workspaceNode.getPath();
 445                         } catch (RepositoryException e) {
 446                                 throw new SlcException("Cannot get or add workspace path "
 447                                                 + getWorkspaceName(), e);
 448                         }
 449                 }
 450
 451                 public String getRepoPath() {
 452                         try {
 453                                 return workspaceNode.getParent().getPath();
 454                         } catch (RepositoryException e) {
 455                                 throw new SlcException("Cannot get or add workspace path "
 456                                                 + getWorkspaceName(), e);
 457                         }
 458                 }
 459
 460                 public RepoElem getRepoElem() {
 461                         return repoElem;
 462                 }
 463
 464                 public Credentials getCredentials() {
 465                         return repoElem.getCredentials();
 466                 }
 467         }
 468
 469         /** Listens to drag */
 470         class ViewDragListener extends DragSourceAdapter {
 471                 public void dragSetData(DragSourceEvent event) {
 472                         IStructuredSelection selection = (IStructuredSelection) viewer
 473                                         .getSelection();
 474                         if (selection.getFirstElement() instanceof DistributionElem) {
 475                                 DistributionElem de = (DistributionElem) selection
 476                                                 .getFirstElement();
 477                                 if (TextTransfer.getInstance().isSupportedType(event.dataType)) {
 478                                         event.data = de.getWorkspacePath();
 479                                 }
 480                         }
 481                 }
 482         }
 483
 484         /** Listens to drop */
 485         class ViewDropListener extends ViewerDropAdapter {
 486
 487                 public ViewDropListener(Viewer viewer) {
 488                         super(viewer);
 489                 }
 490
 491                 @Override
 492                 public boolean performDrop(Object data) {
 493                         DistributionElem sourceDist = (DistributionElem) getSelectedObject();
 494                         RepoElem targetRepo = (RepoElem) getCurrentTarget();
 495
 496                         Boolean ok = MessageDialog.openConfirm(getSite().getShell(),
 497                                         "Confirm distribution merge", "Do you want to merge "
 498                                                         + sourceDist.getWorkspaceName() + " (from repo "
 499                                                         + sourceDist.getRepoElem().getLabel()
 500                                                         + ") to repo " + targetRepo.getLabel() + "?");
 501                         if (!ok)
 502                                 return false;
 503
 504                         try {
 505                                 String sourceWorkspace = sourceDist.getWorkspaceName();
 506                                 Repository sourceRepository = RepoUtils.getRepository(
 507                                                 repositoryFactory, keyring, sourceDist
 508                                                                 .getWorkspaceNode().getParent());
 509                                 Credentials sourceCredentials = RepoUtils
 510                                                 .getRepositoryCredentials(keyring, sourceDist
 511                                                                 .getWorkspaceNode().getParent());
 512
 513                                 String targetWorkspace = sourceWorkspace;
 514                                 Repository targetRepository = RepoUtils.getRepository(
 515                                                 repositoryFactory, keyring, targetRepo.getRepoNode());
 516                                 Credentials targetCredentials = RepoUtils
 517                                                 .getRepositoryCredentials(keyring,
 518                                                                 targetRepo.getRepoNode());
 519
 520                                 // Open sessions here since the background thread
 521                                 // won't necessarily be authenticated.
 522                                 // Job should close the sessions.
 523                                 Session sourceSession = sourceRepository.login(
 524                                                 sourceCredentials, sourceWorkspace);
 525                                 Session targetSession;
 526                                 try {
 527                                         targetSession = targetRepository.login(targetCredentials,
 528                                                         targetWorkspace);
 529                                 } catch (NoSuchWorkspaceException e) {
 530                                         Session defaultSession = targetRepository
 531                                                         .login(targetCredentials);
 532                                         try {
 533                                                 defaultSession.getWorkspace().createWorkspace(
 534                                                                 targetWorkspace);
 535                                         } catch (Exception e1) {
 536                                                 throw new SlcException("Cannot create new workspace "
 537                                                                 + targetWorkspace, e);
 538                                         } finally {
 539                                                 JcrUtils.logoutQuietly(defaultSession);
 540                                         }
 541                                         targetSession = targetRepository.login(targetCredentials,
 542                                                         targetWorkspace);
 543                                 }
 544
 545                                 Job workspaceMergeJob = new WorkspaceMergeJob(sourceSession,
 546                                                 targetSession);
 547                                 workspaceMergeJob.setUser(true);
 548                                 workspaceMergeJob.schedule();
 549                                 return true;
 550                         } catch (RepositoryException e) {
 551                                 throw new SlcException("Cannot process drop from " + sourceDist
 552                                                 + " to " + targetRepo, e);
 553                         }
 554                 }
 555
 556                 @Override
 557                 public boolean validateDrop(Object target, int operation,
 558                                 TransferData transferType) {
 559                         if (target instanceof RepoElem) {
 560                                 if (getSelectedObject() instanceof DistributionElem) {
 561                                         // check if not same repository
 562                                         String srcRepoPath = ((DistributionElem) getSelectedObject())
 563                                                         .getRepoPath();
 564                                         String targetRepoPath = ((RepoElem) target).getRepoPath();
 565                                         return !targetRepoPath.equals(srcRepoPath);
 566                                 }
 567                         }
 568                         return false;
 569                 }
 570         }
 571
 572         private static class WorkspaceMergeJob extends Job {
 573                 private Session sourceSession;
 574                 private Session targetSession;
 575
 576                 public WorkspaceMergeJob(Session sourceSession, Session targetSession) {
 577                         super("Workspace merge");
 578                         this.sourceSession = sourceSession;
 579                         this.targetSession = targetSession;
 580                 }
 581
 582                 @Override
 583                 protected IStatus run(IProgressMonitor eclipseMonitor) {
 584                         long begin = System.currentTimeMillis();
 585                         try {
 586                                 // Not implemented in Davex Jackrabbit v2.2
 587                                 // Query countQuery = sourceSession.getWorkspace()
 588                                 // .getQueryManager()
 589                                 // .createQuery("//element(*, nt:file)", Query.XPATH);
 590                                 // QueryResult result = countQuery.execute();
 591                                 // Long expectedCount = result.getNodes().getSize();
 592
 593                                 Query countQuery = sourceSession
 594                                                 .getWorkspace()
 595                                                 .getQueryManager()
 596                                                 .createQuery("select file from [nt:file] as file",
 597                                                                 Query.JCR_SQL2);
 598                                 QueryResult result = countQuery.execute();
 599                                 Long expectedCount = result.getNodes().getSize();
 600                                 // Long expectedCount =
 601                                 // result.getRows().nextRow().getValues()[0]
 602                                 // .getLong();
 603
 604                                 // Long expectedCount = JcrUtils.countFiles(sourceSession
 605                                 // .getRootNode());
 606                                 if (log.isDebugEnabled())
 607                                         log.debug("Will copy " + expectedCount + " files...");
 608
 609                                 ArgeoMonitor monitor = new EclipseArgeoMonitor(eclipseMonitor);
 610                                 eclipseMonitor
 611                                                 .beginTask("Copy files", expectedCount.intValue());
 612
 613                                 Long count = JcrUtils.copyFiles(sourceSession.getRootNode(),
 614                                                 targetSession.getRootNode(), true, monitor);
 615
 616                                 monitor.done();
 617                                 long duration = (System.currentTimeMillis() - begin) / 1000;// in
 618                                                                                                                                                         // s
 619                                 if (log.isDebugEnabled())
 620                                         log.debug("Copied " + count + " files in "
 621                                                         + (duration / 60) + "min " + (duration % 60) + "s");
 622
 623                                 return Status.OK_STATUS;
 624                         } catch (RepositoryException e) {
 625                                 return new Status(IStatus.ERROR, DistPlugin.ID, "Cannot merge",
 626                                                 e);
 627                         } finally {
 628                                 JcrUtils.logoutQuietly(sourceSession);
 629                                 JcrUtils.logoutQuietly(targetSession);
 630                         }
 631                 }
 632         }
 633
 634         /** Listen to double-clicks */
 635         private class DistributionsDCL implements IDoubleClickListener {
 636
 637                 public void doubleClick(DoubleClickEvent event) {
 638                         if (event.getSelection() == null || event.getSelection().isEmpty())
 639                                 return;
 640                         Object obj = ((IStructuredSelection) event.getSelection())
 641                                         .getFirstElement();
 642                         if (obj instanceof DistributionElem) {
 643                                 DistributionElem distributionElem = (DistributionElem) obj;
 644                                 DistributionEditorInput dei = new DistributionEditorInput(
 645                                                 distributionElem.getName(), distributionElem
 646                                                                 .getRepoElem().getRepository(),
 647                                                 distributionElem.getWorkspaceName(),
 648                                                 distributionElem.getCredentials());
 649                                 try {
 650                                         DistPlugin.getDefault().getWorkbench()
 651                                                         .getActiveWorkbenchWindow().getActivePage()
 652                                                         .openEditor(dei, DistributionEditor.ID);
 653                                 } catch (PartInitException e) {
 654                                         ErrorFeedback.show("Cannot open editor for "
 655                                                         + distributionElem.getWorkspaceName(), e);
 656                                 }
 657                         }
 658                 }
 659         }
 660
 661         //
 662         // try {
 663         // nodeSession = nodeRepository.login();
 664         // NodeIterator repos = JcrUtils.mkdirs(
 665         // nodeSession,
 666         // UserJcrUtils.getUserHome(nodeSession).getPath()
 667         // + RepoConstants.REPOSITORIES_BASE_PATH).getNodes();
 668         // while (repos.hasNext()) {
 669         // Node repository = repos.nextNode();
 670         // String label = null;
 671         // if (repository.isNodeType(NodeType.MIX_TITLE)) {
 672         // label = repository.getProperty(Property.JCR_TITLE)
 673         // .getString();
 674         // }
 675         //
 676         // if (repository.isNodeType(ArgeoTypes.ARGEO_REMOTE_REPOSITORY)) {
 677         // String uri = repository.getProperty(ARGEO_URI).getString();
 678         // Credentials credentials = null;
 679         // if (repository.hasProperty(ARGEO_USER_ID)) {
 680         // String userId = repository.getProperty(ARGEO_USER_ID)
 681         // .getString();
 682         // credentials = new SimpleCredentials(userId,
 683         // "".toCharArray());
 684         // }
 685         // Repository remoteRepository = ArgeoJcrUtils
 686         // .getRepositoryByUri(repositoryFactory, uri);
 687         // if (label == null)
 688         // label = repository.getName();
 689         // repositories.add(new RepositoryElem(label,
 690         // remoteRepository, credentials));
 691         // }
 692         // }
 693         // } catch (RepositoryException e) {
 694         // throw new ArgeoException("Cannot read registered repositories", e);
 695         // }
 696
 697         // Remote
 698         // String uri = null;
 699         // Credentials credentials = null;
 700         // Repository remoteRepository = null;
 701
 702         // try {
 703         // uri = "http://dev.argeo.org/org.argeo.jcr.webapp/pub/java";
 704         // credentials = new GuestCredentials();
 705         // remoteRepository =
 706         // ArgeoJcrUtils.getRepositoryByUri(repositoryFactory, uri);
 707         // repositories.add(new RepositoryElem("anonymous@dev.argeo.org//java",
 708         // remoteRepository, credentials));
 709         // } catch (Exception e) {
 710         // e.printStackTrace();
 711         // }
 712
 713         // uri = "http://localhost:7070/org.argeo.jcr.webapp/pub/java";
 714         // credentials = new GuestCredentials();
 715         // remoteRepository =
 716         // ArgeoJcrUtils.getRepositoryByUri(repositoryFactory, uri);
 717         // repositories.add(new RepositoryElem("anonymous@localhost//java",
 718         // remoteRepository, credentials));
 719
 720         // uri = "http://localhost:7070/org.argeo.jcr.webapp/remoting/java";
 721         // credentials = new SimpleCredentials(System.getProperty("user.name"),
 722         // "".toCharArray());
 723         // remoteRepository =
 724         // ArgeoJcrUtils.getRepositoryByUri(repositoryFactory, uri);
 725         // repositories.add(new RepositoryElem("@localhost//java",
 726         // remoteRepository, credentials));
 727
 728 }