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