legacy/org.argeo.slc.client.ui.dist/src/org/argeo/slc/client/ui/dist/wizards/GenerateBinariesWizard.java

   1 package org.argeo.slc.client.ui.dist.wizards;
   2
   3 import java.util.ArrayList;
   4 import java.util.List;
   5
   6 import javax.jcr.Node;
   7 import javax.jcr.NodeIterator;
   8 import javax.jcr.RepositoryException;
   9 import javax.jcr.Session;
  10
  11 import org.apache.commons.logging.Log;
  12 import org.apache.commons.logging.LogFactory;
  13 import org.argeo.cms.ui.workbench.util.PrivilegedJob;
  14 import org.argeo.eclipse.ui.EclipseJcrMonitor;
  15 import org.argeo.jcr.JcrMonitor;
  16 import org.argeo.jcr.JcrUtils;
  17 import org.argeo.slc.SlcException;
  18 import org.argeo.slc.SlcTypes;
  19 import org.argeo.slc.client.ui.dist.DistPlugin;
  20 import org.argeo.slc.client.ui.dist.utils.ViewerUtils;
  21 import org.argeo.slc.repo.RepoConstants;
  22 import org.argeo.slc.repo.RepoService;
  23 import org.argeo.slc.repo.RepoUtils;
  24 import org.argeo.slc.repo.maven.GenerateBinaries;
  25 import org.eclipse.aether.artifact.Artifact;
  26 import org.eclipse.core.runtime.IProgressMonitor;
  27 import org.eclipse.core.runtime.IStatus;
  28 import org.eclipse.core.runtime.Status;
  29 import org.eclipse.jface.dialogs.IMessageProvider;
  30 import org.eclipse.jface.dialogs.MessageDialog;
  31 import org.eclipse.jface.viewers.ColumnLabelProvider;
  32 import org.eclipse.jface.viewers.IStructuredContentProvider;
  33 import org.eclipse.jface.viewers.TableViewer;
  34 import org.eclipse.jface.viewers.TableViewerColumn;
  35 import org.eclipse.jface.viewers.Viewer;
  36 import org.eclipse.jface.viewers.ViewerComparator;
  37 import org.eclipse.jface.wizard.IWizardPage;
  38 import org.eclipse.jface.wizard.Wizard;
  39 import org.eclipse.jface.wizard.WizardPage;
  40 import org.eclipse.swt.SWT;
  41 import org.eclipse.swt.layout.GridData;
  42 import org.eclipse.swt.layout.GridLayout;
  43 import org.eclipse.swt.widgets.Button;
  44 import org.eclipse.swt.widgets.Composite;
  45 import org.eclipse.swt.widgets.Label;
  46 import org.eclipse.swt.widgets.Table;
  47 import org.eclipse.swt.widgets.Text;
  48
  49 /**
  50  * Define parameters to asynchronously generate binaries, sources and sdk pom
  51  * artifacts for this group using a {@link GenerateBinaries} runnable
  52  */
  53 public class GenerateBinariesWizard extends Wizard {
  54         private final static Log log = LogFactory
  55                         .getLog(GenerateBinariesWizard.class);
  56
  57         // Business objects
  58         private final RepoService repoService;
  59         private final String repoNodePath;
  60         private String wkspName;
  61         private String groupNodePath;
  62
  63         // The pages
  64         private RecapPage recapPage;
  65
  66         // Controls with parameters
  67         private Text versionTxt;
  68         private Text latestVersionTxt;
  69         private Text highestArtifactVersionTxt;
  70
  71         public GenerateBinariesWizard(RepoService repoService, String repoNodePath,
  72                         String wkspName, String groupNodePath) {
  73                 super();
  74                 this.repoService = repoService;
  75                 this.repoNodePath = repoNodePath;
  76                 this.wkspName = wkspName;
  77                 this.groupNodePath = groupNodePath;
  78         }
  79
  80         @Override
  81         public void dispose() {
  82                 super.dispose();
  83         }
  84
  85         @Override
  86         public void addPages() {
  87                 try {
  88                         recapPage = new RecapPage();
  89                         addPage(recapPage);
  90                         setWindowTitle("Define Binary Generation Procedure");
  91                 } catch (Exception e) {
  92                         throw new SlcException("Cannot add page to wizard ", e);
  93                 }
  94         }
  95
  96         @Override
  97         public boolean performFinish() {
  98                 if (!canFinish())
  99                         return false;
 100                 try {
 101                         String msg = "Your are about to generate binaries, sources and sdk "
 102                                         + "pom artifacts for this group, "
 103                                         + "do you really want to proceed ?";
 104
 105                         boolean result = MessageDialog.openConfirm(DistPlugin.getDefault()
 106                                         .getWorkbench().getDisplay().getActiveShell(),
 107                                         "Confirm Launch", msg);
 108
 109                         if (result) {
 110                                 GenerateBinaryJob job = new GenerateBinaryJob(repoService,
 111                                                 repoNodePath, wkspName, groupNodePath,
 112                                                 versionTxt.getText());
 113                                 job.setUser(true);
 114                                 job.schedule();
 115                         }
 116                 } catch (Exception e) {
 117                         throw new SlcException(
 118                                         "Unexpected error while launching the fetch", e);
 119                 }
 120                 return true;
 121         }
 122
 123         // ///////////////////////////////
 124         // ////// THE PAGES
 125         private class RecapPage extends WizardPage {
 126                 private static final long serialVersionUID = 904196417910874087L;
 127                 private TableViewer recapViewer;
 128
 129                 public RecapPage() {
 130                         super("Define parameters and launch");
 131                         setTitle("Define parameters and launch");
 132                 }
 133
 134                 @Override
 135                 public boolean isPageComplete() {
 136                         return isCurrentPage();
 137                 }
 138
 139                 public IWizardPage getNextPage() {
 140                         return null; // always last
 141                 }
 142
 143                 private void refreshValues() {
 144                         Session session = null;
 145                         try {
 146                                 session = repoService.getRemoteSession(repoNodePath, null,
 147                                                 wkspName);
 148                                 Node groupNode = session.getNode(groupNodePath);
 149                                 GenerateBinaries gb = GenerateBinaries.preProcessGroupNode(
 150                                                 groupNode, null);
 151
 152                                 List<Artifact> binaries = new ArrayList<Artifact>();
 153                                 binaries.addAll(gb.getBinaries());
 154
 155                                 Artifact highestVersion = gb.getHighestArtifactVersion();
 156                                 if (highestVersion != null)
 157                                         highestArtifactVersionTxt.setText(highestVersion
 158                                                         .getBaseVersion());
 159
 160                                 if (groupNode.hasNode(RepoConstants.BINARIES_ARTIFACT_ID)) {
 161                                         Node binaryNode = groupNode
 162                                                         .getNode(RepoConstants.BINARIES_ARTIFACT_ID);
 163                                         Artifact currHighestVersion = null;
 164                                         for (NodeIterator ni = binaryNode.getNodes(); ni.hasNext();) {
 165                                                 Node currN = ni.nextNode();
 166                                                 if (currN
 167                                                                 .isNodeType(SlcTypes.SLC_ARTIFACT_VERSION_BASE)) {
 168                                                         Artifact currVersion = RepoUtils.asArtifact(currN);
 169
 170                                                         if (currHighestVersion == null
 171                                                                         || currVersion.getBaseVersion()
 172                                                                                         .compareTo(
 173                                                                                                         currHighestVersion
 174                                                                                                                         .getBaseVersion()) > 0)
 175                                                                 currHighestVersion = currVersion;
 176                                                 }
 177                                         }
 178                                         if (currHighestVersion != null)
 179                                                 latestVersionTxt.setText(currHighestVersion
 180                                                                 .getBaseVersion());
 181                                 }
 182                                 recapViewer.setInput(binaries);
 183                                 recapViewer.refresh();
 184                         } catch (RepositoryException re) {
 185                                 throw new SlcException("Unable to get repositories URIs", re);
 186                         } finally {
 187                                 JcrUtils.logoutQuietly(session);
 188                         }
 189                 }
 190
 191                 public void createControl(Composite parent) {
 192                         setMessage("Configure Maven Indexing", IMessageProvider.NONE);
 193
 194                         Composite composite = new Composite(parent, SWT.NO_FOCUS);
 195                         composite.setLayout(new GridLayout(2, false));
 196
 197                         versionTxt = createLT(composite, "Version");
 198                         versionTxt
 199                                         .setToolTipText("Enter a version for the new Modular Distribution");
 200
 201                         latestVersionTxt = createLT(composite, "Latest version");
 202                         latestVersionTxt.setEditable(false);
 203                         latestVersionTxt
 204                                         .setToolTipText("The actual latest version of this modular distribution");
 205
 206                         highestArtifactVersionTxt = createLT(composite,
 207                                         "Highest version in current category");
 208                         highestArtifactVersionTxt.setEditable(false);
 209                         highestArtifactVersionTxt
 210                                         .setToolTipText("The highest version among all version of the below listed modules.");
 211
 212                         // Creates the table
 213                         Table table = new Table(composite, SWT.H_SCROLL | SWT.V_SCROLL
 214                                         | SWT.BORDER);
 215                         table.setLinesVisible(true);
 216                         table.setHeaderVisible(true);
 217                         table.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 2,
 218                                         1));
 219                         recapViewer = new TableViewer(table);
 220
 221                         TableViewerColumn column = ViewerUtils.createTableViewerColumn(
 222                                         recapViewer, "Name", SWT.NONE, 250);
 223                         column.setLabelProvider(new ColumnLabelProvider() {
 224                                 private static final long serialVersionUID = -9145709097621022043L;
 225
 226                                 @Override
 227                                 public String getText(Object element) {
 228                                         return ((Artifact) element).getArtifactId();
 229                                 }
 230                         });
 231
 232                         column = ViewerUtils.createTableViewerColumn(recapViewer,
 233                                         "Version", SWT.NONE, 250);
 234                         column.setLabelProvider(new ColumnLabelProvider() {
 235                                 private static final long serialVersionUID = 5524185741667651628L;
 236
 237                                 @Override
 238                                 public String getText(Object element) {
 239                                         return ((Artifact) element).getBaseVersion();
 240                                 }
 241                         });
 242
 243                         recapViewer.setContentProvider(new IStructuredContentProvider() {
 244                                 private static final long serialVersionUID = -4579434453554442858L;
 245
 246
 247                                 List<Artifact> artifacts;
 248
 249                                 @SuppressWarnings("unchecked")
 250                                 public void inputChanged(Viewer viewer, Object oldInput,
 251                                                 Object newInput) {
 252                                         artifacts = (List<Artifact>) newInput;
 253                                         if (artifacts != null)
 254                                                 recapViewer.refresh();
 255                                 }
 256
 257                                 public void dispose() {
 258                                 }
 259
 260                                 public Object[] getElements(Object inputElement) {
 261                                         return artifacts == null ? null : artifacts.toArray();
 262                                 }
 263                         });
 264
 265                         // A basic comparator
 266                         recapViewer.setComparator(new ViewerComparator());
 267                         refreshValues();
 268                         setControl(composite);
 269                 }
 270         }
 271
 272         /**
 273          * Define the privileged job that will be run asynchronously generate
 274          * corresponding artifacts
 275          */
 276         private class GenerateBinaryJob extends PrivilegedJob {
 277
 278                 private final RepoService repoService;
 279                 private final String repoNodePath;
 280                 private final String wkspName;
 281                 private final String groupNodePath;
 282                 private final String version;
 283
 284                 public GenerateBinaryJob(RepoService repoService, String repoNodePath,
 285                                 String wkspName, String groupNodePath, String version) {
 286                         super("Fetch");
 287                         this.version = version;
 288                         this.repoService = repoService;
 289                         this.repoNodePath = repoNodePath;
 290                         this.wkspName = wkspName;
 291                         this.groupNodePath = groupNodePath;
 292                 }
 293
 294                 @Override
 295                 protected IStatus doRun(IProgressMonitor progressMonitor) {
 296                         Session session = null;
 297                         try {
 298                                 JcrMonitor monitor = new EclipseJcrMonitor(progressMonitor);
 299                                 session = repoService.getRemoteSession(repoNodePath, null,
 300                                                 wkspName);
 301                                 Node groupBaseNode = session.getNode(groupNodePath);
 302                                 GenerateBinaries.processGroupNode(groupBaseNode, version,
 303                                                 monitor);
 304                         } catch (Exception e) {
 305                                 if (log.isDebugEnabled())
 306                                         e.printStackTrace();
 307                                 return new Status(IStatus.ERROR, DistPlugin.PLUGIN_ID,
 308                                                 "Cannot normalize group", e);
 309                         } finally {
 310                                 JcrUtils.logoutQuietly(session);
 311                         }
 312                         return Status.OK_STATUS;
 313                 }
 314         }
 315
 316         // ////////////////////////////
 317         // // Helpers
 318         /** Creates label and text. */
 319         protected Text createLT(Composite parent, String label) {
 320                 new Label(parent, SWT.NONE).setText(label);
 321                 Text text = new Text(parent, SWT.SINGLE | SWT.LEAD | SWT.BORDER
 322                                 | SWT.NONE);
 323                 text.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
 324                 return text;
 325         }
 326
 327         /** Creates label and check. */
 328         protected Button createLC(Composite parent, String label) {
 329                 new Label(parent, SWT.NONE).setText(label);
 330                 Button check = new Button(parent, SWT.CHECK);
 331                 check.setSelection(false);
 332                 check.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
 333                 return check;
 334         }
 335 }