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.i18n.LocaleUtils;
  24 import org.argeo.node.NodeConstants;
  25 import org.argeo.node.NodeState;
  26 import org.argeo.util.LangUtils;
  27 import org.osgi.framework.Bundle;
  28 import org.osgi.framework.BundleContext;
  29 import org.osgi.framework.Constants;
  30 import org.osgi.framework.FrameworkUtil;
  31 import org.osgi.framework.ServiceReference;
  32 import org.osgi.service.cm.ManagedServiceFactory;
  33
  34 import bitronix.tm.BitronixTransactionManager;
  35 import bitronix.tm.BitronixTransactionSynchronizationRegistry;
  36 import bitronix.tm.TransactionManagerServices;
  37
  38 public class CmsState implements NodeState {
  39         private final Log log = LogFactory.getLog(CmsState.class);
  40         private final BundleContext bc = FrameworkUtil.getBundle(CmsState.class).getBundleContext();
  41
  42         // REFERENCES
  43         private Long availableSince;
  44
  45         // i18n
  46         private Locale defaultLocale;
  47         private List<Locale> locales = null;
  48
  49         private ThreadGroup threadGroup = new ThreadGroup("CMS");
  50         private KernelThread kernelThread;
  51         private List<Runnable> shutdownHooks = new ArrayList<>();
  52
  53         private final String stateUuid;
  54         private final boolean cleanState;
  55         private String hostname;
  56
  57         public CmsState(String stateUuid) {
  58                 this.stateUuid = stateUuid;
  59                 String frameworkUuid = KernelUtils.getFrameworkProp(Constants.FRAMEWORK_UUID);
  60                 this.cleanState = stateUuid.equals(frameworkUuid);
  61                 try {
  62                         this.hostname = InetAddress.getLocalHost().getHostName();
  63                 } catch (UnknownHostException e) {
  64                         log.error("Cannot set hostname: " + e);
  65                 }
  66
  67                 availableSince = System.currentTimeMillis();
  68                 if (log.isDebugEnabled())
  69                         log.debug("## CMS STARTED " + this.stateUuid + (cleanState ? " (clean state) " : " "));
  70
  71                 initI18n();
  72                 initServices();
  73
  74                 // kernel thread
  75                 kernelThread = new KernelThread(threadGroup, "Kernel Thread");
  76                 kernelThread.setContextClassLoader(getClass().getClassLoader());
  77                 kernelThread.start();
  78         }
  79
  80         private void initI18n() {
  81                 Object defaultLocaleValue = KernelUtils.getFrameworkProp(NodeConstants.I18N_DEFAULT_LOCALE);
  82                 defaultLocale = defaultLocaleValue != null ? new Locale(defaultLocaleValue.toString())
  83                                 : new Locale(ENGLISH.getLanguage());
  84                 locales = LocaleUtils.asLocaleList(KernelUtils.getFrameworkProp(NodeConstants.I18N_LOCALES));
  85         }
  86
  87         private void initServices() {
  88                 // JTA
  89                 initTransactionManager();
  90
  91                 // JCR
  92                 RepositoryServiceFactory repositoryServiceFactory = new RepositoryServiceFactory();
  93                 shutdownHooks.add(() -> repositoryServiceFactory.shutdown());
  94                 bc.registerService(ManagedServiceFactory.class, repositoryServiceFactory,
  95                                 LangUtils.dico(Constants.SERVICE_PID, NodeConstants.NODE_REPOS_FACTORY_PID));
  96
  97                 NodeRepositoryFactory repositoryFactory = new NodeRepositoryFactory();
  98                 bc.registerService(RepositoryFactory.class, repositoryFactory, null);
  99
 100                 // Security
 101                 NodeUserAdmin userAdmin = new NodeUserAdmin(NodeConstants.ROLES_BASEDN);
 102                 shutdownHooks.add(() -> userAdmin.destroy());
 103                 bc.registerService(ManagedServiceFactory.class, userAdmin,
 104                                 LangUtils.dico(Constants.SERVICE_PID, NodeConstants.NODE_USER_ADMIN_PID));
 105
 106                 // File System
 107                 CmsFsProvider cmsFsProvider = new CmsFsProvider();
 108                 bc.registerService(FileSystemProvider.class, cmsFsProvider,
 109                                 LangUtils.dico(Constants.SERVICE_PID, NodeConstants.NODE_FS_PROVIDER_PID));
 110         }
 111
 112         private void initTransactionManager() {
 113                 // TODO manage it in a managed service, as startup could be long
 114                 ServiceReference<TransactionManager> existingTm = bc.getServiceReference(TransactionManager.class);
 115                 if (existingTm != null) {
 116                         if (log.isDebugEnabled())
 117                                 log.debug("Using provided transaction manager " + existingTm);
 118                         return;
 119                 }
 120
 121                 if (!TransactionManagerServices.isTransactionManagerRunning()) {
 122                         bitronix.tm.Configuration tmConf = TransactionManagerServices.getConfiguration();
 123                         tmConf.setServerId(UUID.randomUUID().toString());
 124
 125                         Bundle bitronixBundle = FrameworkUtil.getBundle(bitronix.tm.Configuration.class);
 126                         File tmBaseDir = bitronixBundle.getDataFile(KernelConstants.DIR_TRANSACTIONS);
 127                         File tmDir1 = new File(tmBaseDir, "btm1");
 128                         tmDir1.mkdirs();
 129                         tmConf.setLogPart1Filename(new File(tmDir1, tmDir1.getName() + ".tlog").getAbsolutePath());
 130                         File tmDir2 = new File(tmBaseDir, "btm2");
 131                         tmDir2.mkdirs();
 132                         tmConf.setLogPart2Filename(new File(tmDir2, tmDir2.getName() + ".tlog").getAbsolutePath());
 133                 }
 134                 BitronixTransactionManager transactionManager = getTransactionManager();
 135                 shutdownHooks.add(() -> transactionManager.shutdown());
 136                 BitronixTransactionSynchronizationRegistry transactionSynchronizationRegistry = getTransactionSynchronizationRegistry();
 137                 // register
 138                 bc.registerService(TransactionManager.class, transactionManager, null);
 139                 bc.registerService(UserTransaction.class, transactionManager, null);
 140                 bc.registerService(TransactionSynchronizationRegistry.class, transactionSynchronizationRegistry, null);
 141                 if (log.isDebugEnabled())
 142                         log.debug("Initialised default Bitronix transaction manager");
 143         }
 144
 145         void shutdown() {
 146                 if (kernelThread != null)
 147                         kernelThread.destroyAndJoin();
 148
 149                 applyShutdownHooks();
 150
 151                 if (log.isDebugEnabled())
 152                         log.debug("## CMS STOPPED");
 153         }
 154
 155         /** Apply shutdown hoos in reverse order. */
 156         private void applyShutdownHooks() {
 157                 for (int i = shutdownHooks.size() - 1; i >= 0; i--) {
 158                         try {
 159                                 shutdownHooks.get(i).run();
 160                         } catch (Exception e) {
 161                                 log.error("Could not run shutdown hook #" + i);
 162                         }
 163                 }
 164                 // Clean hanging Gogo shell thread
 165                 new GogoShellKiller().start();
 166         }
 167
 168         @Override
 169         public boolean isClean() {
 170                 return cleanState;
 171         }
 172
 173         @Override
 174         public Long getAvailableSince() {
 175                 return availableSince;
 176         }
 177
 178         /*
 179          * ACCESSORS
 180          */
 181         public Locale getDefaultLocale() {
 182                 return defaultLocale;
 183         }
 184
 185         public List<Locale> getLocales() {
 186                 return locales;
 187         }
 188
 189         public String getHostname() {
 190                 return hostname;
 191         }
 192
 193         /** Workaround for blocking Gogo shell by system shutdown. */
 194         private class GogoShellKiller extends Thread {
 195
 196                 public GogoShellKiller() {
 197                         super("Gogo Shell Killer");
 198                         setDaemon(true);
 199                 }
 200
 201                 @Override
 202                 public void run() {
 203                         ThreadGroup rootTg = getRootThreadGroup(null);
 204                         Thread gogoShellThread = findGogoShellThread(rootTg);
 205                         if (gogoShellThread == null)
 206                                 return;
 207                         while (getNonDaemonCount(rootTg) > 2) {
 208                                 try {
 209                                         Thread.sleep(100);
 210                                 } catch (InterruptedException e) {
 211                                         // silent
 212                                 }
 213                         }
 214                         gogoShellThread = findGogoShellThread(rootTg);
 215                         if (gogoShellThread == null)
 216                                 return;
 217                         System.exit(0);
 218                 }
 219         }
 220
 221         private static ThreadGroup getRootThreadGroup(ThreadGroup tg) {
 222                 if (tg == null)
 223                         tg = Thread.currentThread().getThreadGroup();
 224                 if (tg.getParent() == null)
 225                         return tg;
 226                 else
 227                         return getRootThreadGroup(tg.getParent());
 228         }
 229
 230         private static int getNonDaemonCount(ThreadGroup rootThreadGroup) {
 231                 Thread[] threads = new Thread[rootThreadGroup.activeCount()];
 232                 rootThreadGroup.enumerate(threads);
 233                 int nonDameonCount = 0;
 234                 for (Thread t : threads)
 235                         if (t != null && !t.isDaemon())
 236                                 nonDameonCount++;
 237                 return nonDameonCount;
 238         }
 239
 240         private static Thread findGogoShellThread(ThreadGroup rootThreadGroup) {
 241                 Thread[] threads = new Thread[rootThreadGroup.activeCount()];
 242                 rootThreadGroup.enumerate(threads, true);
 243                 for (Thread thread : threads) {
 244                         if (thread.getName().equals("Gogo shell"))
 245                                 return thread;
 246                 }
 247                 return null;
 248         }
 249
 250 }