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.node.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.PLUGIN_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                 viewer.setComparator(new DistTreeComparator());
 105
 106                 @SuppressWarnings("unused")
 107                 ViewerComparator vc = viewer.getComparator();
 108
 109                 // Enable retrieving current tree selected items from outside the view
 110                 getSite().setSelectionProvider(viewer);
 111
 112                 MenuManager menuManager = new MenuManager();
 113                 Menu menu = menuManager.createContextMenu(viewer.getTree());
 114                 menuManager.addMenuListener(new IMenuListener() {
 115                         private static final long serialVersionUID = -1454108001335038652L;
 116
 117                         public void menuAboutToShow(IMenuManager manager) {
 118                                 contextMenuAboutToShow(manager);
 119                         }
 120                 });
 121                 viewer.getTree().setMenu(menu);
 122                 getSite().registerContextMenu(menuManager, viewer);
 123
 124                 // Initialize
 125                 refresh();
 126         }
 127
 128         /** Programatically configure the context menu */
 129         protected void contextMenuAboutToShow(IMenuManager menuManager) {
 130                 IWorkbenchWindow window = DistPlugin.getDefault().getWorkbench()
 131                                 .getActiveWorkbenchWindow();
 132
 133                 // Most of the implemented commands support only one selected
 134                 // element
 135                 boolean singleElement = ((IStructuredSelection) viewer.getSelection())
 136                                 .size() == 1;
 137                 // Get Current selected item :
 138                 Object firstElement = ((IStructuredSelection) viewer.getSelection())
 139                                 .getFirstElement();
 140
 141                 try {
 142
 143                         if (firstElement instanceof TreeParent
 144                                         || firstElement instanceof DistParentElem) {
 145
 146                                 String targetRepoPath = null, workspaceName = null, workspacePrefix = null;
 147                                 String modularDistBasePath = null;
 148                                 String modularDistPath = null;
 149                                 // String targetRepoUri = null;
 150                                 // Build conditions depending on element type
 151                                 boolean isDistribElem = false, isModularDistVersionBaseElem = false, isRepoElem = false, isDistribGroupElem = false;
 152                                 boolean isLocal = false, isReadOnly = true;
 153
 154                                 RepoElem re = null;
 155
 156                                 if (firstElement instanceof RepoElem) {
 157                                         re = (RepoElem) firstElement;
 158                                         isRepoElem = true;
 159                                         isLocal = re.inHome();
 160                                         isReadOnly = re.isReadOnly();
 161                                 } else if (firstElement instanceof WkspGroupElem) {
 162                                         WkspGroupElem wge = (WkspGroupElem) firstElement;
 163                                         isReadOnly = wge.isReadOnly();
 164                                         isDistribGroupElem = true;
 165                                         re = (RepoElem) wge.getParent();
 166                                         workspacePrefix = wge.getName();
 167                                 } else if (firstElement instanceof WorkspaceElem) {
 168                                         WorkspaceElem we = (WorkspaceElem) firstElement;
 169                                         re = we.getRepoElem();
 170                                         isDistribElem = true;
 171                                         isReadOnly = we.isReadOnly();
 172                                         workspaceName = we.getWorkspaceName();
 173                                         isLocal = we.inHome();
 174                                 } else if (firstElement instanceof ModularDistVersionBaseElem) {
 175                                         ModularDistVersionBaseElem mdbe = (ModularDistVersionBaseElem) firstElement;
 176                                         isModularDistVersionBaseElem = true;
 177                                         re = mdbe.getWkspElem().getRepoElem();
 178                                         isLocal = re.inHome();
 179                                         isReadOnly = re.isReadOnly();
 180                                         workspaceName = mdbe.getWkspElem().getWorkspaceName();
 181                                         modularDistBasePath = mdbe.getModularDistBase().getPath();
 182                                 } else if (firstElement instanceof ModularDistVersionElem) {
 183                                         ModularDistVersionElem mdbe = (ModularDistVersionElem) firstElement;
 184                                         re = mdbe.getWorkspaceElem().getRepoElem();
 185                                         isLocal = re.inHome();
 186                                         isReadOnly = re.isReadOnly();
 187                                         workspaceName = mdbe.getWorkspaceElem().getWorkspaceName();
 188                                         modularDistPath = mdbe.getModularDistVersionNode()
 189                                                         .getPath();
 190                                 }
 191
 192                                 if (re != null) {
 193                                         targetRepoPath = re.getRepoNodePath();
 194                                 }
 195
 196                                 // Display repo info
 197                                 CommandUtils.refreshCommand(menuManager, window,
 198                                                 DisplayRepoInformation.ID,
 199                                                 DisplayRepoInformation.DEFAULT_LABEL,
 200                                                 DisplayRepoInformation.DEFAULT_ICON, isRepoElem
 201                                                                 && singleElement);
 202
 203                                 // create workspace
 204                                 Map<String, String> params = new HashMap<String, String>();
 205                                 params.put(CreateWorkspace.PARAM_TARGET_REPO_PATH,
 206                                                 targetRepoPath);
 207                                 params.put(CreateWorkspace.PARAM_WORKSPACE_PREFIX,
 208                                                 workspacePrefix);
 209                                 CommandUtils.refreshParameterizedCommand(menuManager, window,
 210                                                 CreateWorkspace.ID, CreateWorkspace.DEFAULT_LABEL,
 211                                                 CreateWorkspace.DEFAULT_ICON,
 212                                                 (isRepoElem || isDistribGroupElem) && singleElement
 213                                                                 && !isReadOnly && !isLocal, params);
 214
 215                                 // TODO Manage the case where it is not a java workspace
 216                                 params = new HashMap<String, String>();
 217                                 params.put(CreateLocalJavaWorkspace.PARAM_WORKSPACE_PREFIX,
 218                                                 workspacePrefix);
 219                                 CommandUtils.refreshParameterizedCommand(menuManager, window,
 220                                                 CreateLocalJavaWorkspace.ID,
 221                                                 CreateLocalJavaWorkspace.DEFAULT_LABEL,
 222                                                 CreateLocalJavaWorkspace.DEFAULT_ICON,
 223                                                 (isRepoElem || isDistribGroupElem) && singleElement
 224                                                                 && !isReadOnly && isLocal, params);
 225
 226                                 // Register a remote repository
 227                                 CommandUtils.refreshCommand(menuManager, window,
 228                                                 RegisterRepository.ID,
 229                                                 RegisterRepository.DEFAULT_LABEL,
 230                                                 RegisterRepository.DEFAULT_ICON, isRepoElem
 231                                                                 && singleElement);
 232
 233                                 // Unregister a remote repository
 234                                 params = new HashMap<String, String>();
 235                                 params.put(UnregisterRemoteRepo.PARAM_REPO_PATH, targetRepoPath);
 236                                 CommandUtils.refreshParameterizedCommand(menuManager, window,
 237                                                 UnregisterRemoteRepo.ID,
 238                                                 UnregisterRemoteRepo.DEFAULT_LABEL,
 239                                                 UnregisterRemoteRepo.DEFAULT_ICON, isRepoElem
 240                                                                 && !isLocal && singleElement, params);
 241
 242                                 // Fetch repository
 243                                 params = new HashMap<String, String>();
 244                                 params.put(Fetch.PARAM_TARGET_REPO_PATH, targetRepoPath);
 245                                 CommandUtils.refreshParameterizedCommand(menuManager, window,
 246                                                 Fetch.ID, Fetch.DEFAULT_LABEL, Fetch.DEFAULT_ICON,
 247                                                 isRepoElem && isLocal && singleElement && !isReadOnly,
 248                                                 params);
 249
 250                                 // Normalize workspace
 251                                 params = new HashMap<String, String>();
 252                                 params.put(NormalizeWorkspace.PARAM_TARGET_REPO_PATH,
 253                                                 targetRepoPath);
 254                                 params.put(NormalizeWorkspace.PARAM_WORKSPACE_NAME,
 255                                                 workspaceName);
 256
 257                                 CommandUtils.refreshParameterizedCommand(menuManager, window,
 258                                                 NormalizeWorkspace.ID, "Normalize...",
 259                                                 NormalizeWorkspace.DEFAULT_ICON, isDistribElem
 260                                                                 && singleElement && !isReadOnly, params);
 261
 262                                 // Copy workspace
 263                                 params = new HashMap<String, String>();
 264                                 params.put(CopyWorkspace.PARAM_TARGET_REPO_PATH, targetRepoPath);
 265                                 params.put(CopyWorkspace.PARAM_SOURCE_WORKSPACE_NAME,
 266                                                 workspaceName);
 267                                 CommandUtils.refreshParameterizedCommand(menuManager, window,
 268                                                 CopyWorkspace.ID, CopyWorkspace.DEFAULT_LABEL,
 269                                                 CopyWorkspace.DEFAULT_ICON, isDistribElem
 270                                                                 && singleElement && !isLocal, params);
 271
 272                                 params = new HashMap<String, String>();
 273                                 params.put(CopyLocalJavaWorkspace.PARAM_SOURCE_WORKSPACE_NAME,
 274                                                 workspaceName);
 275                                 CommandUtils.refreshParameterizedCommand(menuManager, window,
 276                                                 CopyLocalJavaWorkspace.ID,
 277                                                 CopyLocalJavaWorkspace.DEFAULT_LABEL,
 278                                                 CopyLocalJavaWorkspace.DEFAULT_ICON, isDistribElem
 279                                                                 && singleElement && isLocal, params);
 280
 281                                 // Clear Workspace
 282                                 params = new HashMap<String, String>();
 283                                 params.put(DeleteWorkspace.PARAM_TARGET_REPO_PATH,
 284                                                 targetRepoPath);
 285                                 params.put(DeleteWorkspace.PARAM_WORKSPACE_NAME, workspaceName);
 286                                 CommandUtils.refreshParameterizedCommand(menuManager, window,
 287                                                 DeleteWorkspace.ID, DeleteWorkspace.DEFAULT_LABEL,
 288                                                 DeleteWorkspace.DEFAULT_ICON, isDistribElem
 289                                                                 && singleElement && !isReadOnly, params);
 290
 291                                 // Advanced submenu
 292                                 MenuManager submenu = new MenuManager("Advanced",
 293                                                 DistPlugin.PLUGIN_ID + ".advancedSubmenu");
 294                                 IContributionItem ici = menuManager.find(DistPlugin.PLUGIN_ID
 295                                                 + ".advancedSubmenu");
 296                                 if (ici != null)
 297                                         menuManager.remove(ici);
 298
 299                                 // Publish workspace
 300                                 params = new HashMap<String, String>();
 301                                 params.put(PublishWorkspace.PARAM_TARGET_REPO_PATH,
 302                                                 targetRepoPath);
 303                                 params.put(PublishWorkspace.PARAM_WORKSPACE_NAME, workspaceName);
 304                                 CommandUtils.refreshParameterizedCommand(submenu, window,
 305                                                 PublishWorkspace.ID, PublishWorkspace.DEFAULT_LABEL,
 306                                                 PublishWorkspace.DEFAULT_ICON, isDistribElem
 307                                                                 && singleElement && !isReadOnly, params);
 308
 309                                 // Normalize distribution (Legacy)
 310                                 params = new HashMap<String, String>();
 311                                 params.put(NormalizeDistribution.PARAM_TARGET_REPO_PATH,
 312                                                 targetRepoPath);
 313                                 params.put(NormalizeDistribution.PARAM_WORKSPACE_NAME,
 314                                                 workspaceName);
 315                                 CommandUtils.refreshParameterizedCommand(submenu, window,
 316                                                 NormalizeDistribution.ID,
 317                                                 NormalizeDistribution.DEFAULT_LABEL,
 318                                                 NormalizeDistribution.DEFAULT_ICON, isDistribElem
 319                                                                 && singleElement && !isReadOnly, params);
 320
 321                                 // Run in OSGi
 322                                 params = new HashMap<String, String>();
 323                                 params.put(RunInOsgi.PARAM_MODULE_PATH, modularDistPath);
 324                                 params.put(RunInOsgi.PARAM_WORKSPACE_NAME, workspaceName);
 325                                 CommandUtils.refreshParameterizedCommand(submenu, window,
 326                                                 RunInOsgi.ID, RunInOsgi.DEFAULT_LABEL,
 327                                                 RunInOsgi.DEFAULT_ICON, modularDistPath != null
 328                                                                 && singleElement && isLocal, params);
 329
 330                                 // Open generate binaries
 331                                 params = new HashMap<String, String>();
 332                                 params.put(OpenGenerateBinariesWizard.PARAM_REPO_NODE_PATH,
 333                                                 targetRepoPath);
 334                                 params.put(OpenGenerateBinariesWizard.PARAM_MODULE_PATH,
 335                                                 modularDistBasePath);
 336                                 params.put(OpenGenerateBinariesWizard.PARAM_WORKSPACE_NAME,
 337                                                 workspaceName);
 338
 339                                 CommandUtils.refreshParameterizedCommand(submenu, window,
 340                                                 OpenGenerateBinariesWizard.ID,
 341                                                 OpenGenerateBinariesWizard.DEFAULT_LABEL,
 342                                                 OpenGenerateBinariesWizard.DEFAULT_ICON,
 343                                                 isModularDistVersionBaseElem && !isReadOnly, params);
 344
 345                                 if (submenu.getSize() > 0)
 346                                         menuManager.add(submenu);
 347
 348                                 // // Manage workspace authorizations
 349                                 // params = new HashMap<String, String>();
 350                                 // params.put(ManageWorkspaceAuth.PARAM_WORKSPACE_NAME, wsName);
 351                                 // CommandHelpers.refreshParameterizedCommand(menuManager,
 352                                 // window,
 353                                 // ManageWorkspaceAuth.ID, ManageWorkspaceAuth.DEFAULT_LABEL,
 354                                 // ManageWorkspaceAuth.DEFAULT_ICON_PATH, isDistribElem
 355                                 // && singleElement && !isReadOnly, params);
 356                         }
 357                 } catch (RepositoryException e) {
 358                         throw new SlcException("unexpected errror while "
 359                                         + "building context menu for element " + firstElement, e);
 360                 }
 361         }
 362
 363         @Override
 364         public void setFocus() {
 365                 viewer.getTree().setFocus();
 366         }
 367
 368         /**
 369          * Force refresh of the whole view
 370          */
 371         public void refresh() {
 372                 viewer.setInput(nodeRepository);
 373                 viewer.expandToLevel(2);
 374         }
 375
 376         /* DEPENDENCY INJECTION */
 377         public void setNodeRepository(Repository nodeRepository) {
 378                 this.nodeRepository = nodeRepository;
 379         }
 380
 381         public void setTreeContentProvider(
 382                         DistTreeContentProvider treeContentProvider) {
 383                 this.treeContentProvider = treeContentProvider;
 384         }
 385 }