swt/rcp/org.argeo.cms.swt.rcp.cli/src/org/argeo/cms/swt/rcp/cli/CmsCli.java

   1 package org.argeo.cms.swt.rcp.cli;
   2
   3 import java.lang.management.ManagementFactory;
   4 import java.nio.file.Path;
   5 import java.nio.file.Paths;
   6 import java.util.List;
   7 import java.util.concurrent.ForkJoinPool;
   8
   9 import org.apache.commons.cli.CommandLine;
  10 import org.apache.commons.cli.Option;
  11 import org.apache.commons.cli.Options;
  12 import org.argeo.api.acr.spi.ProvidedRepository;
  13 import org.argeo.api.cli.CommandsCli;
  14 import org.argeo.api.cli.DescribedCommand;
  15 import org.argeo.api.cms.CmsApp;
  16 import org.argeo.cms.runtime.StaticCms;
  17 import org.argeo.cms.swt.app.CmsUserApp;
  18 import org.argeo.cms.ui.rcp.CmsRcpDisplayFactory;
  19 import org.argeo.util.register.Component;
  20 import org.argeo.util.register.ComponentRegister;
  21
  22 public class CmsCli extends CommandsCli {
  23
  24         public CmsCli(String commandName) {
  25                 super(commandName);
  26                 addCommand("static", new Launch());
  27         }
  28
  29         @Override
  30         public String getDescription() {
  31                 return "Argeo CMS utilities.";
  32         }
  33
  34         static class Launch implements DescribedCommand<String> {
  35                 private Option dataOption;
  36                 private Option uiOption;
  37
  38                 @Override
  39                 public Options getOptions() {
  40                         Options options = new Options();
  41                         dataOption = Option.builder().longOpt("data").hasArg().required()
  42                                         .desc("path to the writable data area (mandatory)").build();
  43                         uiOption = Option.builder().longOpt("ui").desc("open a user interface").build();
  44                         options.addOption(dataOption);
  45                         options.addOption(uiOption);
  46                         return options;
  47                 }
  48
  49                 @Override
  50                 public String apply(List<String> args) {
  51                         CommandLine cl = toCommandLine(args);
  52                         String dataPath = cl.getOptionValue(dataOption);
  53                         boolean ui = cl.hasOption(uiOption);
  54
  55                         Path instancePath = Paths.get(dataPath);
  56                         System.setProperty("osgi.instance.area", instancePath.toUri().toString());
  57
  58                         StaticCms staticCms = new StaticCms() {
  59                                 @Override
  60                                 protected void addComponents(ComponentRegister register) {
  61                                         if (ui) {
  62                                                 Component<? extends ProvidedRepository> contentRepositoryC = register
  63                                                                 .find(ProvidedRepository.class, null).first();
  64                                                 CmsUserApp cmsApp = new CmsUserApp();
  65                                                 Component<CmsUserApp> cmsAppC = new Component.Builder<>(cmsApp) //
  66                                                                 .addType(CmsApp.class) //
  67                                                                 .addType(CmsUserApp.class) //
  68                                                                 .addDependency(contentRepositoryC.getType(ProvidedRepository.class),
  69                                                                                 cmsApp::setContentRepository, null) //
  70                                                                 .build(register);
  71
  72                                                 CmsRcpDisplayFactory displayFactory = new CmsRcpDisplayFactory();
  73                                                 Component<CmsRcpDisplayFactory> displayFactoryC = new Component.Builder<>(displayFactory) //
  74                                                                 .addActivation(displayFactory::init) //
  75                                                                 .addDeactivation(displayFactory::destroy) //
  76                                                                 .build(register);
  77
  78                                         }
  79                                 }
  80
  81                                 @Override
  82                                 protected void postActivation(ComponentRegister register) {
  83                                         if (ui) {
  84                                                 Component<? extends CmsUserApp> cmsAppC = register.find(CmsUserApp.class, null).first();
  85                                                 CmsRcpDisplayFactory.openCmsApp(cmsAppC.get(), "data", (e) -> {
  86                                                         // asynchronous in order to avoid deadlock in UI thread
  87                                                         ForkJoinPool.commonPool().execute(() -> stop());
  88                                                 });
  89                                         }
  90                                 }
  91
  92                         };
  93                         Runtime.getRuntime().addShutdownHook(new Thread(() -> staticCms.stop(), "Static CMS Shutdown"));
  94                         staticCms.start();
  95
  96                         long jvmUptime = ManagementFactory.getRuntimeMXBean().getUptime();
  97                         System.out.println("Static CMS available in " + jvmUptime + " ms.");
  98
  99                         staticCms.waitForStop();
 100
 101                         return null;
 102                 }
 103
 104                 @Override
 105                 public String getDescription() {
 106                         return "Launch a static CMS.";
 107                 }
 108
 109         }
 110 }