org.argeo.slc.client.ui.dist/src/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.HashMap;
  19 import java.util.Map;
  20
  21 import javax.jcr.Repository;
  22 import javax.jcr.RepositoryException;
  23
  24 import org.argeo.eclipse.ui.TreeParent;
  25 import org.argeo.eclipse.ui.workbench.CommandUtils;
  26 import org.argeo.jcr.ArgeoNames;
  27 import org.argeo.slc.SlcException;
  28 import org.argeo.slc.client.ui.dist.DistPlugin;
  29 import org.argeo.slc.client.ui.dist.commands.CopyLocalJavaWorkspace;
  30 import org.argeo.slc.client.ui.dist.commands.CopyWorkspace;
  31 import org.argeo.slc.client.ui.dist.commands.CreateLocalJavaWorkspace;
  32 import org.argeo.slc.client.ui.dist.commands.CreateWorkspace;
  33 import org.argeo.slc.client.ui.dist.commands.DeleteWorkspace;
  34 import org.argeo.slc.client.ui.dist.commands.DisplayRepoInformation;
  35 import org.argeo.slc.client.ui.dist.commands.Fetch;
  36 import org.argeo.slc.client.ui.dist.commands.NormalizeDistribution;
  37 import org.argeo.slc.client.ui.dist.commands.NormalizeWorkspace;
  38 import org.argeo.slc.client.ui.dist.commands.OpenGenerateBinariesWizard;
  39 import org.argeo.slc.client.ui.dist.commands.PublishWorkspace;
  40 import org.argeo.slc.client.ui.dist.commands.RegisterRepository;
  41 import org.argeo.slc.client.ui.dist.commands.RunInOsgi;
  42 import org.argeo.slc.client.ui.dist.commands.UnregisterRemoteRepo;
  43 import org.argeo.slc.client.ui.dist.controllers.DistTreeComparator;
  44 import org.argeo.slc.client.ui.dist.controllers.DistTreeComparer;
  45 import org.argeo.slc.client.ui.dist.controllers.DistTreeContentProvider;
  46 import org.argeo.slc.client.ui.dist.controllers.DistTreeDoubleClickListener;
  47 import org.argeo.slc.client.ui.dist.controllers.DistTreeLabelProvider;
  48 import org.argeo.slc.client.ui.dist.model.DistParentElem;
  49 import org.argeo.slc.client.ui.dist.model.ModularDistVersionBaseElem;
  50 import org.argeo.slc.client.ui.dist.model.ModularDistVersionElem;
  51 import org.argeo.slc.client.ui.dist.model.RepoElem;
  52 import org.argeo.slc.client.ui.dist.model.WkspGroupElem;
  53 import org.argeo.slc.client.ui.dist.model.WorkspaceElem;
  54 import org.argeo.slc.jcr.SlcNames;
  55 import org.eclipse.jface.action.IContributionItem;
  56 import org.eclipse.jface.action.IMenuListener;
  57 import org.eclipse.jface.action.IMenuManager;
  58 import org.eclipse.jface.action.MenuManager;
  59 import org.eclipse.jface.viewers.IStructuredSelection;
  60 import org.eclipse.jface.viewers.TreeViewer;
  61 import org.eclipse.jface.viewers.TreeViewerColumn;
  62 import org.eclipse.jface.viewers.ViewerComparator;
  63 import org.eclipse.swt.SWT;
  64 import org.eclipse.swt.widgets.Composite;
  65 import org.eclipse.swt.widgets.Menu;
  66 import org.eclipse.swt.widgets.Tree;
  67 import org.eclipse.ui.IWorkbenchWindow;
  68 import org.eclipse.ui.part.ViewPart;
  69
  70 /**
  71  * Browse, manipulate and manage distributions across multiple repositories
  72  * (like fetch, merge, publish, etc.).
  73  */
  74 public class DistributionsView extends ViewPart implements SlcNames, ArgeoNames {
  75         // private final static Log log =
  76         // LogFactory.getLog(DistributionsView.class);
  77
  78         public final static String ID = DistPlugin.ID + ".distributionsView";
  79
  80         /* DEPENDENCY INJECTION */
  81         private Repository nodeRepository;
  82         private DistTreeContentProvider treeContentProvider;
  83
  84         private TreeViewer viewer;
  85
  86         @Override
  87         public void createPartControl(Composite parent) {
  88                 // Define the TableViewer
  89                 viewer = new TreeViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL
  90                                 | SWT.FULL_SELECTION | SWT.BORDER);
  91
  92                 TreeViewerColumn col = new TreeViewerColumn(viewer, SWT.NONE);
  93                 col.getColumn().setWidth(400);
  94                 col.setLabelProvider(new DistTreeLabelProvider());
  95
  96                 final Tree tree = viewer.getTree();
  97                 tree.setHeaderVisible(false);
  98                 tree.setLinesVisible(false);
  99
 100                 // viewer.setContentProvider(new DistTreeContentProvider());
 101                 viewer.setContentProvider(treeContentProvider);
 102                 viewer.addDoubleClickListener(new DistTreeDoubleClickListener(viewer));
 103                 viewer.setComparer(new DistTreeComparer());
 104
 105                 viewer.setComparator(new DistTreeComparator());
 106
 107                 @SuppressWarnings("unused")
 108                 ViewerComparator vc = viewer.getComparator();
 109
 110                 // Enable retrieving current tree selected items from outside the view
 111                 getSite().setSelectionProvider(viewer);
 112
 113                 MenuManager menuManager = new MenuManager();
 114                 Menu menu = menuManager.createContextMenu(viewer.getTree());
 115                 menuManager.addMenuListener(new IMenuListener() {
 116                         public void menuAboutToShow(IMenuManager manager) {
 117                                 contextMenuAboutToShow(manager);
 118                         }
 119                 });
 120                 viewer.getTree().setMenu(menu);
 121                 getSite().registerContextMenu(menuManager, viewer);
 122
 123                 // Initialize
 124                 refresh();
 125         }
 126
 127         /** Programatically configure the context menu */
 128         protected void contextMenuAboutToShow(IMenuManager menuManager) {
 129                 IWorkbenchWindow window = DistPlugin.getDefault().getWorkbench()
 130                                 .getActiveWorkbenchWindow();
 131
 132                 // Most of the implemented commands support only one selected
 133                 // element
 134                 boolean singleElement = ((IStructuredSelection) viewer.getSelection())
 135                                 .size() == 1;
 136                 // Get Current selected item :
 137                 Object firstElement = ((IStructuredSelection) viewer.getSelection())
 138                                 .getFirstElement();
 139
 140                 try {
 141
 142                         if (firstElement instanceof TreeParent
 143                                         || firstElement instanceof DistParentElem) {
 144
 145                                 String targetRepoPath = null, workspaceName = null, workspacePrefix = null;
 146                                 String modularDistBasePath = null;
 147                                 String modularDistPath = null;
 148                                 // String targetRepoUri = null;
 149                                 // Build conditions depending on element type
 150                                 boolean isDistribElem = false, isModularDistVersionBaseElem = false, isRepoElem = false, isDistribGroupElem = false;
 151                                 boolean isLocal = false, isReadOnly = true;
 152
 153                                 RepoElem re = null;
 154
 155                                 if (firstElement instanceof RepoElem) {
 156                                         re = (RepoElem) firstElement;
 157                                         isRepoElem = true;
 158                                         isLocal = re.inHome();
 159                                         isReadOnly = re.isReadOnly();
 160                                 } else if (firstElement instanceof WkspGroupElem) {
 161                                         WkspGroupElem wge = (WkspGroupElem) firstElement;
 162                                         isReadOnly = wge.isReadOnly();
 163                                         isDistribGroupElem = true;
 164                                         re = (RepoElem) wge.getParent();
 165                                         workspacePrefix = wge.getName();
 166                                 } else if (firstElement instanceof WorkspaceElem) {
 167                                         WorkspaceElem we = (WorkspaceElem) firstElement;
 168                                         re = we.getRepoElem();
 169                                         isDistribElem = true;
 170                                         isReadOnly = we.isReadOnly();
 171                                         workspaceName = we.getWorkspaceName();
 172                                         isLocal = we.inHome();
 173                                 } else if (firstElement instanceof ModularDistVersionBaseElem) {
 174                                         ModularDistVersionBaseElem mdbe = (ModularDistVersionBaseElem) firstElement;
 175                                         isModularDistVersionBaseElem = true;
 176                                         re = mdbe.getWkspElem().getRepoElem();
 177                                         isLocal = re.inHome();
 178                                         isReadOnly = re.isReadOnly();
 179                                         workspaceName = mdbe.getWkspElem().getWorkspaceName();
 180                                         modularDistBasePath = mdbe.getModularDistBase().getPath();
 181                                 } else if (firstElement instanceof ModularDistVersionElem) {
 182                                         ModularDistVersionElem mdbe = (ModularDistVersionElem) firstElement;
 183                                         re = mdbe.getWorkspaceElem().getRepoElem();
 184                                         isLocal = re.inHome();
 185                                         isReadOnly = re.isReadOnly();
 186                                         workspaceName = mdbe.getWorkspaceElem().getWorkspaceName();
 187                                         modularDistPath = mdbe.getModularDistVersionNode()
 188                                                         .getPath();
 189                                 }
 190
 191                                 if (re != null) {
 192                                         targetRepoPath = re.getRepoNodePath();
 193                                 }
 194
 195                                 // Display repo info
 196                                 CommandUtils.refreshCommand(menuManager, window,
 197                                                 DisplayRepoInformation.ID,
 198                                                 DisplayRepoInformation.DEFAULT_LABEL,
 199                                                 DisplayRepoInformation.DEFAULT_ICON, isRepoElem
 200                                                                 && singleElement);
 201
 202                                 // create workspace
 203                                 Map<String, String> params = new HashMap<String, String>();
 204                                 params.put(CreateWorkspace.PARAM_TARGET_REPO_PATH,
 205                                                 targetRepoPath);
 206                                 params.put(CreateWorkspace.PARAM_WORKSPACE_PREFIX,
 207                                                 workspacePrefix);
 208                                 CommandUtils.refreshParametrizedCommand(menuManager, window,
 209                                                 CreateWorkspace.ID, CreateWorkspace.DEFAULT_LABEL,
 210                                                 CreateWorkspace.DEFAULT_ICON,
 211                                                 (isRepoElem || isDistribGroupElem) && singleElement
 212                                                                 && !isReadOnly && !isLocal, params);
 213
 214                                 // TODO Manage the case where it is not a java workspace
 215                                 params = new HashMap<String, String>();
 216                                 params.put(CreateLocalJavaWorkspace.PARAM_WORKSPACE_PREFIX,
 217                                                 workspacePrefix);
 218                                 CommandUtils.refreshParametrizedCommand(menuManager, window,
 219                                                 CreateLocalJavaWorkspace.ID,
 220                                                 CreateLocalJavaWorkspace.DEFAULT_LABEL,
 221                                                 CreateLocalJavaWorkspace.DEFAULT_ICON,
 222                                                 (isRepoElem || isDistribGroupElem) && singleElement
 223                                                                 && !isReadOnly && isLocal, params);
 224
 225                                 // Register a remote repository
 226                                 CommandUtils.refreshCommand(menuManager, window,
 227                                                 RegisterRepository.ID,
 228                                                 RegisterRepository.DEFAULT_LABEL,
 229                                                 RegisterRepository.DEFAULT_ICON, isRepoElem
 230                                                                 && singleElement);
 231
 232                                 // Unregister a remote repository
 233                                 params = new HashMap<String, String>();
 234                                 params.put(UnregisterRemoteRepo.PARAM_REPO_PATH, targetRepoPath);
 235                                 CommandUtils.refreshParametrizedCommand(menuManager, window,
 236                                                 UnregisterRemoteRepo.ID,
 237                                                 UnregisterRemoteRepo.DEFAULT_LABEL,
 238                                                 UnregisterRemoteRepo.DEFAULT_ICON, isRepoElem
 239                                                                 && !isLocal && singleElement, params);
 240
 241                                 // Fetch repository
 242                                 params = new HashMap<String, String>();
 243                                 params.put(Fetch.PARAM_TARGET_REPO_PATH, targetRepoPath);
 244                                 CommandUtils.refreshParametrizedCommand(menuManager, window,
 245                                                 Fetch.ID, Fetch.DEFAULT_LABEL, Fetch.DEFAULT_ICON,
 246                                                 isRepoElem && isLocal && singleElement && !isReadOnly,
 247                                                 params);
 248
 249                                 // Normalize workspace
 250                                 params = new HashMap<String, String>();
 251                                 params.put(NormalizeWorkspace.PARAM_TARGET_REPO_PATH,
 252                                                 targetRepoPath);
 253                                 params.put(NormalizeWorkspace.PARAM_WORKSPACE_NAME,
 254                                                 workspaceName);
 255
 256                                 CommandUtils.refreshParametrizedCommand(menuManager, window,
 257                                                 NormalizeWorkspace.ID, "Normalize...",
 258                                                 NormalizeWorkspace.DEFAULT_ICON, isDistribElem
 259                                                                 && singleElement && !isReadOnly, params);
 260
 261                                 // Copy workspace
 262                                 params = new HashMap<String, String>();
 263                                 params.put(CopyWorkspace.PARAM_TARGET_REPO_PATH, targetRepoPath);
 264                                 params.put(CopyWorkspace.PARAM_SOURCE_WORKSPACE_NAME,
 265                                                 workspaceName);
 266                                 CommandUtils.refreshParametrizedCommand(menuManager, window,
 267                                                 CopyWorkspace.ID, CopyWorkspace.DEFAULT_LABEL,
 268                                                 CopyWorkspace.DEFAULT_ICON, isDistribElem
 269                                                                 && singleElement && !isLocal, params);
 270
 271                                 params = new HashMap<String, String>();
 272                                 params.put(CopyLocalJavaWorkspace.PARAM_SOURCE_WORKSPACE_NAME,
 273                                                 workspaceName);
 274                                 CommandUtils.refreshParametrizedCommand(menuManager, window,
 275                                                 CopyLocalJavaWorkspace.ID,
 276                                                 CopyLocalJavaWorkspace.DEFAULT_LABEL,
 277                                                 CopyLocalJavaWorkspace.DEFAULT_ICON, isDistribElem
 278                                                                 && singleElement && isLocal, params);
 279
 280                                 // Clear Workspace
 281                                 params = new HashMap<String, String>();
 282                                 params.put(DeleteWorkspace.PARAM_TARGET_REPO_PATH,
 283                                                 targetRepoPath);
 284                                 params.put(DeleteWorkspace.PARAM_WORKSPACE_NAME, workspaceName);
 285                                 CommandUtils.refreshParametrizedCommand(menuManager, window,
 286                                                 DeleteWorkspace.ID, DeleteWorkspace.DEFAULT_LABEL,
 287                                                 DeleteWorkspace.DEFAULT_ICON, isDistribElem
 288                                                                 && singleElement && !isReadOnly, params);
 289
 290                                 // Advanced submenu
 291                                 MenuManager submenu = new MenuManager("Advanced", DistPlugin.ID
 292                                                 + ".advancedSubmenu");
 293                                 IContributionItem ici = menuManager.find(DistPlugin.ID
 294                                                 + ".advancedSubmenu");
 295                                 if (ici != null)
 296                                         menuManager.remove(ici);
 297
 298                                 // Publish workspace
 299                                 params = new HashMap<String, String>();
 300                                 params.put(PublishWorkspace.PARAM_TARGET_REPO_PATH,
 301                                                 targetRepoPath);
 302                                 params.put(PublishWorkspace.PARAM_WORKSPACE_NAME, workspaceName);
 303                                 CommandUtils.refreshParametrizedCommand(submenu, window,
 304                                                 PublishWorkspace.ID, PublishWorkspace.DEFAULT_LABEL,
 305                                                 PublishWorkspace.DEFAULT_ICON, isDistribElem
 306                                                                 && singleElement && !isReadOnly, params);
 307
 308                                 // Normalize distribution (Legacy)
 309                                 params = new HashMap<String, String>();
 310                                 params.put(NormalizeDistribution.PARAM_TARGET_REPO_PATH,
 311                                                 targetRepoPath);
 312                                 params.put(NormalizeDistribution.PARAM_WORKSPACE_NAME,
 313                                                 workspaceName);
 314                                 CommandUtils.refreshParametrizedCommand(submenu, window,
 315                                                 NormalizeDistribution.ID,
 316                                                 NormalizeDistribution.DEFAULT_LABEL,
 317                                                 NormalizeDistribution.DEFAULT_ICON, isDistribElem
 318                                                                 && singleElement && !isReadOnly, params);
 319
 320                                 // Run in OSGi
 321                                 params = new HashMap<String, String>();
 322                                 params.put(RunInOsgi.PARAM_MODULE_PATH, modularDistPath);
 323                                 params.put(RunInOsgi.PARAM_WORKSPACE_NAME, workspaceName);
 324                                 CommandUtils.refreshParametrizedCommand(submenu, window,
 325                                                 RunInOsgi.ID, RunInOsgi.DEFAULT_LABEL,
 326                                                 RunInOsgi.DEFAULT_ICON, modularDistPath!=null
 327                                                                 && singleElement && isLocal, params);
 328
 329                                 // Open generate binaries
 330                                 params = new HashMap<String, String>();
 331                                 params.put(OpenGenerateBinariesWizard.PARAM_REPO_NODE_PATH,
 332                                                 targetRepoPath);
 333                                 params.put(OpenGenerateBinariesWizard.PARAM_MODULE_PATH,
 334                                                 modularDistBasePath);
 335                                 params.put(OpenGenerateBinariesWizard.PARAM_WORKSPACE_NAME,
 336                                                 workspaceName);
 337
 338                                 CommandUtils.refreshParametrizedCommand(submenu, window,
 339                                                 OpenGenerateBinariesWizard.ID,
 340                                                 OpenGenerateBinariesWizard.DEFAULT_LABEL,
 341                                                 OpenGenerateBinariesWizard.DEFAULT_ICON,
 342                                                 isModularDistVersionBaseElem && !isReadOnly, params);
 343
 344                                 if (submenu.getSize() > 0)
 345                                         menuManager.add(submenu);
 346
 347                                 // // Manage workspace authorizations
 348                                 // params = new HashMap<String, String>();
 349                                 // params.put(ManageWorkspaceAuth.PARAM_WORKSPACE_NAME, wsName);
 350                                 // CommandHelpers.refreshParameterizedCommand(menuManager,
 351                                 // window,
 352                                 // ManageWorkspaceAuth.ID, ManageWorkspaceAuth.DEFAULT_LABEL,
 353                                 // ManageWorkspaceAuth.DEFAULT_ICON_PATH, isDistribElem
 354                                 // && singleElement && !isReadOnly, params);
 355                         }
 356                 } catch (RepositoryException e) {
 357                         throw new SlcException("unexpected errror while "
 358                                         + "building context menu for element " + firstElement, e);
 359                 }
 360         }
 361
 362         @Override
 363         public void setFocus() {
 364                 viewer.getTree().setFocus();
 365         }
 366
 367         /**
 368          * Force refresh of the whole view
 369          */
 370         public void refresh() {
 371                 viewer.setInput(nodeRepository);
 372                 viewer.expandToLevel(2);
 373         }
 374
 375         /*
 376          * DEPENDENCY INJECTION
 377          */
 378         public void setNodeRepository(Repository repository) {
 379                 this.nodeRepository = repository;
 380         }
 381
 382         public void setTreeContentProvider(
 383                         DistTreeContentProvider treeContentProvider) {
 384                 this.treeContentProvider = treeContentProvider;
 385         }
 386 }