CmsState.java

   1 package org.argeo.cms.internal.kernel;
   2
   3 import static bitronix.tm.TransactionManagerServices.getTransactionManager;
   4 import static bitronix.tm.TransactionManagerServices.getTransactionSynchronizationRegistry;
   5 import static java.util.Locale.ENGLISH;
   6
   7 import java.io.File;
   8 import java.net.InetAddress;
   9 import java.net.UnknownHostException;
  10 import java.nio.file.spi.FileSystemProvider;
  11 import java.util.ArrayList;
  12 import java.util.List;
  13 import java.util.Locale;
  14 import java.util.UUID;
  15
  16 import javax.jcr.RepositoryFactory;
  17 import javax.transaction.TransactionManager;
  18 import javax.transaction.TransactionSynchronizationRegistry;
  19 import javax.transaction.UserTransaction;
  20
  21 import org.apache.commons.logging.Log;
  22 import org.apache.commons.logging.LogFactory;
  23 import org.argeo.cms.CmsException;
  24 import org.argeo.cms.i18n.LocaleUtils;
  25 import org.argeo.node.NodeConstants;
  26 import org.argeo.node.NodeState;
  27 import org.argeo.transaction.simple.SimpleTransactionManager;
  28 import org.argeo.util.LangUtils;
  29 import org.osgi.framework.Bundle;
  30 import org.osgi.framework.BundleContext;
  31 import org.osgi.framework.Constants;
  32 import org.osgi.framework.FrameworkUtil;
  33 import org.osgi.framework.ServiceReference;
  34 import org.osgi.service.cm.ManagedServiceFactory;
  35
  36 import bitronix.tm.BitronixTransactionManager;
  37 import bitronix.tm.BitronixTransactionSynchronizationRegistry;
  38 import bitronix.tm.TransactionManagerServices;
  39
  40 public class CmsState implements NodeState {
  41         private final static Log log = LogFactory.getLog(CmsState.class);
  42         private final BundleContext bc = FrameworkUtil.getBundle(CmsState.class).getBundleContext();
  43
  44         // REFERENCES
  45         private Long availableSince;
  46
  47         // i18n
  48         private Locale defaultLocale;
  49         private List<Locale> locales = null;
  50
  51         private ThreadGroup threadGroup = new ThreadGroup("CMS");
  52         private KernelThread kernelThread;
  53         private List<Runnable> stopHooks = new ArrayList<>();
  54
  55         private final String stateUuid;
  56         private final boolean cleanState;
  57         private String hostname;
  58
  59         public CmsState(String stateUuid) {
  60                 this.stateUuid = stateUuid;
  61                 String frameworkUuid = KernelUtils.getFrameworkProp(Constants.FRAMEWORK_UUID);
  62                 this.cleanState = stateUuid.equals(frameworkUuid);
  63                 try {
  64                         this.hostname = InetAddress.getLocalHost().getHostName();
  65                 } catch (UnknownHostException e) {
  66                         log.error("Cannot set hostname: " + e);
  67                 }
  68
  69                 availableSince = System.currentTimeMillis();
  70                 if (log.isDebugEnabled())
  71                         log.debug("## CMS starting... stateUuid=" + this.stateUuid + (cleanState ? " (clean state) " : " "));
  72
  73                 initI18n();
  74                 initServices();
  75
  76                 // kernel thread
  77                 kernelThread = new KernelThread(threadGroup, "Kernel Thread");
  78                 kernelThread.setContextClassLoader(getClass().getClassLoader());
  79                 kernelThread.start();
  80         }
  81
  82         private void initI18n() {
  83                 Object defaultLocaleValue = KernelUtils.getFrameworkProp(NodeConstants.I18N_DEFAULT_LOCALE);
  84                 defaultLocale = defaultLocaleValue != null ? new Locale(defaultLocaleValue.toString())
  85                                 : new Locale(ENGLISH.getLanguage());
  86                 locales = LocaleUtils.asLocaleList(KernelUtils.getFrameworkProp(NodeConstants.I18N_LOCALES));
  87         }
  88
  89         private void initServices() {
  90                 // JTA
  91                 String tmType = KernelUtils.getFrameworkProp(NodeConstants.TRANSACTION_MANAGER,
  92                                 NodeConstants.TRANSACTION_MANAGER_SIMPLE);
  93                 if (NodeConstants.TRANSACTION_MANAGER_SIMPLE.equals(tmType)) {
  94                         initSimpleTransactionManager();
  95                 } else if (NodeConstants.TRANSACTION_MANAGER_BITRONIX.equals(tmType)) {
  96                         initBitronixTransactionManager();
  97                 } else {
  98                         throw new CmsException("Usupported transaction manager type " + tmType);
  99                 }
 100
 101                 // POI
 102 //              POIXMLTypeLoader.setClassLoader(CTConnection.class.getClassLoader());
 103
 104                 // Tika
 105 //              OpenDocumentParser odfParser = new OpenDocumentParser();
 106 //              bc.registerService(Parser.class, odfParser, new Hashtable());
 107 //              PDFParser pdfParser = new PDFParser();
 108 //              bc.registerService(Parser.class, pdfParser, new Hashtable());
 109 //              OOXMLParser ooxmlParser = new OOXMLParser();
 110 //              bc.registerService(Parser.class, ooxmlParser, new Hashtable());
 111 //              TesseractOCRParser ocrParser = new TesseractOCRParser();
 112 //              ocrParser.setLanguage("ara");
 113 //              bc.registerService(Parser.class, ocrParser, new Hashtable());
 114
 115                 // JCR
 116                 RepositoryServiceFactory repositoryServiceFactory = new RepositoryServiceFactory();
 117                 stopHooks.add(() -> repositoryServiceFactory.shutdown());
 118                 bc.registerService(ManagedServiceFactory.class, repositoryServiceFactory,
 119                                 LangUtils.dico(Constants.SERVICE_PID, NodeConstants.NODE_REPOS_FACTORY_PID));
 120
 121                 NodeRepositoryFactory repositoryFactory = new NodeRepositoryFactory();
 122                 bc.registerService(RepositoryFactory.class, repositoryFactory, null);
 123
 124                 // Security
 125                 NodeUserAdmin userAdmin = new NodeUserAdmin(NodeConstants.ROLES_BASEDN);
 126                 stopHooks.add(() -> userAdmin.destroy());
 127                 bc.registerService(ManagedServiceFactory.class, userAdmin,
 128                                 LangUtils.dico(Constants.SERVICE_PID, NodeConstants.NODE_USER_ADMIN_PID));
 129
 130                 // File System
 131                 CmsFsProvider cmsFsProvider = new CmsFsProvider();
 132 //              ServiceLoader<FileSystemProvider> fspSl = ServiceLoader.load(FileSystemProvider.class);
 133 //              for (FileSystemProvider fsp : fspSl) {
 134 //                      log.debug("FileSystemProvider " + fsp);
 135 //                      if (fsp instanceof CmsFsProvider) {
 136 //                              cmsFsProvider = (CmsFsProvider) fsp;
 137 //                      }
 138 //              }
 139 //              for (FileSystemProvider fsp : FileSystemProvider.installedProviders()) {
 140 //                      log.debug("Installed FileSystemProvider " + fsp);
 141 //              }
 142                 bc.registerService(FileSystemProvider.class, cmsFsProvider,
 143                                 LangUtils.dico(Constants.SERVICE_PID, NodeConstants.NODE_FS_PROVIDER_PID));
 144         }
 145
 146         private void initSimpleTransactionManager() {
 147                 SimpleTransactionManager transactionManager = new SimpleTransactionManager();
 148                 bc.registerService(TransactionManager.class, transactionManager, null);
 149                 bc.registerService(UserTransaction.class, transactionManager, null);
 150                 // TODO TransactionSynchronizationRegistry
 151         }
 152
 153         private void initBitronixTransactionManager() {
 154                 // TODO manage it in a managed service, as startup could be long
 155                 ServiceReference<TransactionManager> existingTm = bc.getServiceReference(TransactionManager.class);
 156                 if (existingTm != null) {
 157                         if (log.isDebugEnabled())
 158                                 log.debug("Using provided transaction manager " + existingTm);
 159                         return;
 160                 }
 161
 162                 if (!TransactionManagerServices.isTransactionManagerRunning()) {
 163                         bitronix.tm.Configuration tmConf = TransactionManagerServices.getConfiguration();
 164                         tmConf.setServerId(UUID.randomUUID().toString());
 165
 166                         Bundle bitronixBundle = FrameworkUtil.getBundle(bitronix.tm.Configuration.class);
 167                         File tmBaseDir = bitronixBundle.getDataFile(KernelConstants.DIR_TRANSACTIONS);
 168                         File tmDir1 = new File(tmBaseDir, "btm1");
 169                         tmDir1.mkdirs();
 170                         tmConf.setLogPart1Filename(new File(tmDir1, tmDir1.getName() + ".tlog").getAbsolutePath());
 171                         File tmDir2 = new File(tmBaseDir, "btm2");
 172                         tmDir2.mkdirs();
 173                         tmConf.setLogPart2Filename(new File(tmDir2, tmDir2.getName() + ".tlog").getAbsolutePath());
 174                 }
 175                 BitronixTransactionManager transactionManager = getTransactionManager();
 176                 stopHooks.add(() -> transactionManager.shutdown());
 177                 BitronixTransactionSynchronizationRegistry transactionSynchronizationRegistry = getTransactionSynchronizationRegistry();
 178                 // register
 179                 bc.registerService(TransactionManager.class, transactionManager, null);
 180                 bc.registerService(UserTransaction.class, transactionManager, null);
 181                 bc.registerService(TransactionSynchronizationRegistry.class, transactionSynchronizationRegistry, null);
 182                 if (log.isDebugEnabled())
 183                         log.debug("Initialised default Bitronix transaction manager");
 184         }
 185
 186         void shutdown() {
 187                 if (log.isDebugEnabled())
 188                         log.debug("CMS stopping...  stateUuid=" + this.stateUuid + (cleanState ? " (clean state) " : " "));
 189
 190                 if (kernelThread != null)
 191                         kernelThread.destroyAndJoin();
 192                 // In a different state in order to avois interruptions
 193                 new Thread(() -> applyStopHooks(), "Apply Argeo Stop Hooks").start();
 194                 // applyStopHooks();
 195
 196                 long duration = ((System.currentTimeMillis() - availableSince) / 1000) / 60;
 197                 log.info("## ARGEO CMS STOPPED after " + (duration / 60) + "h " + (duration % 60) + "min uptime ##");
 198         }
 199
 200         /** Apply shutdown hoos in reverse order. */
 201         private void applyStopHooks() {
 202                 for (int i = stopHooks.size() - 1; i >= 0; i--) {
 203                         try {
 204                                 stopHooks.get(i).run();
 205                         } catch (Exception e) {
 206                                 log.error("Could not run shutdown hook #" + i);
 207                         }
 208                 }
 209                 // Clean hanging Gogo shell thread
 210                 new GogoShellKiller().start();
 211         }
 212
 213         @Override
 214         public boolean isClean() {
 215                 return cleanState;
 216         }
 217
 218         @Override
 219         public Long getAvailableSince() {
 220                 return availableSince;
 221         }
 222
 223         /*
 224          * ACCESSORS
 225          */
 226         public Locale getDefaultLocale() {
 227                 return defaultLocale;
 228         }
 229
 230         public List<Locale> getLocales() {
 231                 return locales;
 232         }
 233
 234         public String getHostname() {
 235                 return hostname;
 236         }
 237 }