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