org.argeo.cms/src/org/argeo/cms/internal/kernel/Kernel.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 import static org.argeo.cms.internal.kernel.KernelUtils.getFrameworkProp;
   7 import static org.argeo.cms.internal.kernel.KernelUtils.getOsgiInstanceDir;
   8 import static org.argeo.jcr.ArgeoJcrConstants.ALIAS_NODE;
   9 import static org.argeo.jcr.ArgeoJcrConstants.JCR_REPOSITORY_ALIAS;
  10 import static org.argeo.util.LocaleChoice.asLocaleList;
  11 import static org.osgi.framework.Constants.FRAMEWORK_UUID;
  12
  13 import java.io.ByteArrayInputStream;
  14 import java.io.ByteArrayOutputStream;
  15 import java.io.File;
  16 import java.io.FileFilter;
  17 import java.io.IOException;
  18 import java.lang.management.ManagementFactory;
  19 import java.security.PrivilegedAction;
  20 import java.util.Dictionary;
  21 import java.util.HashMap;
  22 import java.util.Hashtable;
  23 import java.util.List;
  24 import java.util.Locale;
  25 import java.util.Map;
  26
  27 import javax.jcr.ImportUUIDBehavior;
  28 import javax.jcr.Repository;
  29 import javax.jcr.RepositoryFactory;
  30 import javax.jcr.Session;
  31 import javax.jcr.SimpleCredentials;
  32 import javax.security.auth.Subject;
  33 import javax.security.auth.login.LoginContext;
  34 import javax.security.auth.login.LoginException;
  35 import javax.transaction.TransactionManager;
  36 import javax.transaction.TransactionSynchronizationRegistry;
  37 import javax.transaction.UserTransaction;
  38
  39 import org.apache.commons.io.FileUtils;
  40 import org.apache.commons.logging.Log;
  41 import org.apache.commons.logging.LogFactory;
  42 import org.apache.jackrabbit.api.JackrabbitRepository;
  43 import org.apache.jackrabbit.util.TransientFileFactory;
  44 import org.argeo.ArgeoException;
  45 import org.argeo.ArgeoLogger;
  46 import org.argeo.cms.CmsException;
  47 import org.argeo.cms.maintenance.MaintenanceUi;
  48 import org.argeo.jackrabbit.JackrabbitDataModel;
  49 import org.argeo.jackrabbit.ManagedJackrabbitRepository;
  50 import org.argeo.jackrabbit.OsgiJackrabbitRepositoryFactory;
  51 import org.argeo.jcr.ArgeoJcrConstants;
  52 import org.argeo.jcr.ArgeoJcrUtils;
  53 import org.argeo.jcr.RepoConf;
  54 import org.eclipse.equinox.http.jetty.JettyConfigurator;
  55 import org.eclipse.equinox.http.jetty.JettyConstants;
  56 import org.eclipse.equinox.http.servlet.ExtendedHttpService;
  57 import org.eclipse.rap.rwt.application.ApplicationConfiguration;
  58 import org.osgi.framework.BundleContext;
  59 import org.osgi.framework.Constants;
  60 import org.osgi.framework.ServiceEvent;
  61 import org.osgi.framework.ServiceListener;
  62 import org.osgi.framework.ServiceReference;
  63 import org.osgi.framework.ServiceRegistration;
  64 import org.osgi.framework.startlevel.BundleStartLevel;
  65 import org.osgi.service.cm.Configuration;
  66 import org.osgi.service.cm.ConfigurationAdmin;
  67 import org.osgi.service.cm.ManagedService;
  68 import org.osgi.service.log.LogReaderService;
  69 import org.osgi.service.useradmin.UserAdmin;
  70 import org.osgi.util.tracker.ServiceTracker;
  71
  72 import bitronix.tm.BitronixTransactionManager;
  73 import bitronix.tm.BitronixTransactionSynchronizationRegistry;
  74 import bitronix.tm.TransactionManagerServices;
  75
  76 /**
  77  * Argeo CMS Kernel. Responsible for :
  78  * <ul>
  79  * <li>security</li>
  80  * <li>provisioning</li>
  81  * <li>transaction</li>
  82  * <li>logging</li>
  83  * <li>local and remote file systems access</li>
  84  * <li>OS access</li>
  85  * </ul>
  86  */
  87 final class Kernel implements KernelHeader, KernelConstants, ServiceListener {
  88         /*
  89          * SERVICE REFERENCES
  90          */
  91         private ServiceReference<ConfigurationAdmin> configurationAdmin;
  92         /*
  93          * REGISTERED SERVICES
  94          */
  95         private ServiceRegistration<ArgeoLogger> loggerReg;
  96         private ServiceRegistration<TransactionManager> tmReg;
  97         private ServiceRegistration<UserTransaction> utReg;
  98         private ServiceRegistration<TransactionSynchronizationRegistry> tsrReg;
  99         private ServiceRegistration<? extends Repository> repositoryReg;
 100         private ServiceRegistration<RepositoryFactory> repositoryFactoryReg;
 101         private ServiceRegistration<UserAdmin> userAdminReg;
 102
 103         /*
 104          * SERVICES IMPLEMENTATIONS
 105          */
 106         private NodeLogger logger;
 107         private BitronixTransactionManager transactionManager;
 108         private BitronixTransactionSynchronizationRegistry transactionSynchronizationRegistry;
 109         private OsgiJackrabbitRepositoryFactory repositoryFactory;
 110         JackrabbitRepository repository;
 111         private NodeUserAdmin userAdmin;
 112
 113         // Members
 114         private final static Log log = LogFactory.getLog(Kernel.class);
 115         ThreadGroup threadGroup = new ThreadGroup(Kernel.class.getSimpleName());
 116         private final BundleContext bc = Activator.getBundleContext();
 117         private final NodeSecurity nodeSecurity;
 118         private DataHttp dataHttp;
 119         private NodeHttp nodeHttp;
 120         private KernelThread kernelThread;
 121
 122         private Locale defaultLocale = null;
 123         private List<Locale> locales = null;
 124
 125         public Kernel() {
 126                 // KernelUtils.logFrameworkProperties(log);
 127                 nodeSecurity = new NodeSecurity();
 128         }
 129
 130         final void init() {
 131                 Subject.doAs(nodeSecurity.getKernelSubject(), new PrivilegedAction<Void>() {
 132                         @Override
 133                         public Void run() {
 134                                 doInit();
 135                                 return null;
 136                         }
 137                 });
 138         }
 139
 140         private void doInit() {
 141                 long begin = System.currentTimeMillis();
 142                 // Use CMS bundle classloader
 143                 ClassLoader currentContextCl = Thread.currentThread().getContextClassLoader();
 144                 Thread.currentThread().setContextClassLoader(Kernel.class.getClassLoader());
 145                 try {
 146                         if (nodeSecurity.isFirstInit())
 147                                 firstInit();
 148
 149                         defaultLocale = new Locale(getFrameworkProp(I18N_DEFAULT_LOCALE, ENGLISH.getLanguage()));
 150                         locales = asLocaleList(getFrameworkProp(I18N_LOCALES));
 151
 152                         ServiceTracker<LogReaderService, LogReaderService> logReaderService = new ServiceTracker<LogReaderService, LogReaderService>(
 153                                         bc, LogReaderService.class, null);
 154                         logReaderService.open();
 155                         logger = new NodeLogger(logReaderService.getService());
 156                         logReaderService.close();
 157
 158                         if (isMaintenance())
 159                                 maintenanceInit();
 160                         else
 161                                 normalInit();
 162                 } catch (Exception e) {
 163                         log.error("Cannot initialize Argeo CMS", e);
 164                         throw new ArgeoException("Cannot initialize", e);
 165                 } finally {
 166                         Thread.currentThread().setContextClassLoader(currentContextCl);
 167                         // FIXME better manage lifecycle.
 168                         try {
 169                                 new LoginContext(LOGIN_CONTEXT_KERNEL, nodeSecurity.getKernelSubject()).logout();
 170                         } catch (LoginException e) {
 171                                 e.printStackTrace();
 172                         }
 173                 }
 174
 175                 long jvmUptime = ManagementFactory.getRuntimeMXBean().getUptime();
 176                 log.info("## ARGEO CMS UP in " + (jvmUptime / 1000) + "." + (jvmUptime % 1000) + "s ##");
 177                 long initDuration = System.currentTimeMillis() - begin;
 178                 if (log.isTraceEnabled())
 179                         log.trace("Kernel initialization took " + initDuration + "ms");
 180                 directorsCut(initDuration);
 181         }
 182
 183         private void normalInit() {
 184                 ConfigurationAdmin conf = findConfigurationAdmin();
 185
 186                 // HTTP
 187                 initWebServer(conf);
 188                 ServiceReference<ExtendedHttpService> sr = bc.getServiceReference(ExtendedHttpService.class);
 189                 if (sr != null)
 190                         addHttpService(sr);
 191
 192                 // Initialise services
 193                 initTransactionManager();
 194
 195                 try {
 196                         Configuration nodeConf = conf.getConfiguration(ArgeoJcrConstants.REPO_PID_NODE);
 197                         if (nodeConf.getProperties() == null) {
 198                                 Dictionary<String, ?> props = getNodeConfigFromFrameworkProperties();
 199                                 if(props==null)// TODO interactive configuration
 200                                         return;
 201                                 nodeConf.update(props);
 202                         }
 203                 } catch (IOException e) {
 204                         throw new CmsException("Cannot get configuration", e);
 205                 }
 206
 207                 ManagedJackrabbitRepository nodeRepo = new ManagedJackrabbitRepository();
 208                 String[] clazzes = { ManagedService.class.getName(), Repository.class.getName(),
 209                                 JackrabbitRepository.class.getName() };
 210                 Hashtable<String, String> serviceProps = new Hashtable<String, String>();
 211                 serviceProps.put(Constants.SERVICE_PID, ArgeoJcrConstants.REPO_PID_NODE);
 212                 serviceProps.put(ArgeoJcrConstants.JCR_REPOSITORY_ALIAS, ArgeoJcrConstants.ALIAS_NODE);
 213                 ServiceRegistration<?> nodeSr = bc.registerService(clazzes, nodeRepo, serviceProps);
 214                 nodeRepo.waitForInit();
 215                 new JackrabbitDataModel(bc).prepareDataModel(nodeRepo);
 216
 217                 repository = (JackrabbitRepository) bc.getService(nodeSr.getReference());
 218
 219                 if (repository == null)
 220                         repository = new NodeRepository();
 221                 if (repositoryFactory == null)
 222                         repositoryFactory = new OsgiJackrabbitRepositoryFactory();
 223                 userAdmin = new NodeUserAdmin(transactionManager, repository);
 224
 225                 // ADMIN UIs
 226                 UserUi userUi = new UserUi();
 227                 Hashtable<String, String> props = new Hashtable<String, String>();
 228                 props.put("contextName", "user");
 229                 bc.registerService(ApplicationConfiguration.class, userUi, props);
 230
 231                 // Kernel thread
 232                 kernelThread = new KernelThread(this);
 233                 kernelThread.setContextClassLoader(Kernel.class.getClassLoader());
 234                 kernelThread.start();
 235
 236                 // Publish services to OSGi
 237                 publish();
 238         }
 239
 240         private Dictionary<String, ?> getNodeConfigFromFrameworkProperties() {
 241                 String repoType = KernelUtils
 242                                 .getFrameworkProp(KernelConstants.NODE_REPO_PROP_PREFIX + RepoConf.type.name());
 243                 if (repoType == null)
 244                         return null;
 245
 246                 Hashtable<String, Object> props = new Hashtable<String, Object>();
 247                 for (RepoConf repoConf : RepoConf.values()) {
 248                         String value = KernelUtils.getFrameworkProp(KernelConstants.NODE_REPO_PROP_PREFIX + repoConf.name());
 249                         if (value != null)
 250                                 props.put(repoConf.name(), value);
 251                 }
 252                 return props;
 253         }
 254
 255         private boolean isMaintenance() {
 256                 String startLevel = KernelUtils.getFrameworkProp("osgi.startLevel");
 257                 if (startLevel == null)
 258                         return false;
 259                 int bundleStartLevel = bc.getBundle().adapt(BundleStartLevel.class).getStartLevel();
 260                 // int frameworkStartLevel =
 261                 // bc.getBundle(0).adapt(BundleStartLevel.class)
 262                 // .getStartLevel();
 263                 int frameworkStartLevel = Integer.parseInt(startLevel);
 264                 // int frameworkStartLevel = bc.getBundle(0)
 265                 // .adapt(FrameworkStartLevel.class).getStartLevel();
 266                 return bundleStartLevel == frameworkStartLevel;
 267         }
 268
 269         private void maintenanceInit() {
 270                 log.info("## MAINTENANCE ##");
 271                 bc.addServiceListener(Kernel.this);
 272                 initWebServer(null);
 273                 MaintenanceUi maintenanceUi = new MaintenanceUi();
 274                 Hashtable<String, String> props = new Hashtable<String, String>();
 275                 props.put("contextName", "maintenance");
 276                 bc.registerService(ApplicationConfiguration.class, maintenanceUi, props);
 277         }
 278
 279         private void firstInit() {
 280                 log.info("## FIRST INIT ##");
 281                 String nodeInit = getFrameworkProp(NODE_INIT);
 282                 if (nodeInit == null)
 283                         nodeInit = "../../init";
 284                 if (nodeInit.startsWith("http")) {
 285                         remoteFirstInit(nodeInit);
 286                         return;
 287                 }
 288                 File initDir;
 289                 if (nodeInit.startsWith("."))
 290                         initDir = KernelUtils.getExecutionDir(nodeInit);
 291                 else
 292                         initDir = new File(nodeInit);
 293                 // TODO also uncompress archives
 294                 if (initDir.exists())
 295                         try {
 296                                 FileUtils.copyDirectory(initDir, getOsgiInstanceDir(), new FileFilter() {
 297
 298                                         @Override
 299                                         public boolean accept(File pathname) {
 300                                                 if (pathname.getName().equals(".svn") || pathname.getName().equals(".git"))
 301                                                         return false;
 302                                                 return true;
 303                                         }
 304                                 });
 305                                 log.info("CMS initialized from " + initDir.getCanonicalPath());
 306                         } catch (IOException e) {
 307                                 throw new CmsException("Cannot initialize from " + initDir, e);
 308                         }
 309         }
 310
 311         private void remoteFirstInit(String uri) {
 312                 try {
 313                         repository = new NodeRepository();
 314                         repositoryFactory = new OsgiJackrabbitRepositoryFactory();
 315                         Repository remoteRepository = ArgeoJcrUtils.getRepositoryByUri(repositoryFactory, uri);
 316                         Session remoteSession = remoteRepository.login(new SimpleCredentials("root", "demo".toCharArray()), "main");
 317                         Session localSession = this.repository.login();
 318                         // FIXME register node type
 319                         // if (false)
 320                         // CndImporter.registerNodeTypes(null, localSession);
 321                         ByteArrayOutputStream out = new ByteArrayOutputStream();
 322                         remoteSession.exportSystemView("/", out, true, false);
 323                         ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
 324                         localSession.importXML("/", in, ImportUUIDBehavior.IMPORT_UUID_COLLISION_THROW);
 325                         // JcrUtils.copy(remoteSession.getRootNode(),
 326                         // localSession.getRootNode());
 327                 } catch (Exception e) {
 328                         throw new CmsException("Cannot first init from " + uri, e);
 329                 }
 330         }
 331
 332         /** Can be null */
 333         private ConfigurationAdmin findConfigurationAdmin() {
 334                 configurationAdmin = bc.getServiceReference(ConfigurationAdmin.class);
 335                 if (configurationAdmin == null) {
 336                         return null;
 337                 }
 338                 return bc.getService(configurationAdmin);
 339         }
 340
 341         private void initTransactionManager() {
 342                 bitronix.tm.Configuration tmConf = TransactionManagerServices.getConfiguration();
 343                 tmConf.setServerId(getFrameworkProp(FRAMEWORK_UUID));
 344
 345                 // File tmBaseDir = new File(getFrameworkProp(TRANSACTIONS_HOME,
 346                 // getOsgiInstancePath(DIR_TRANSACTIONS)));
 347                 File tmBaseDir = bc.getDataFile(DIR_TRANSACTIONS);
 348                 File tmDir1 = new File(tmBaseDir, "btm1");
 349                 tmDir1.mkdirs();
 350                 tmConf.setLogPart1Filename(new File(tmDir1, tmDir1.getName() + ".tlog").getAbsolutePath());
 351                 File tmDir2 = new File(tmBaseDir, "btm2");
 352                 tmDir2.mkdirs();
 353                 tmConf.setLogPart2Filename(new File(tmDir2, tmDir2.getName() + ".tlog").getAbsolutePath());
 354                 transactionManager = getTransactionManager();
 355                 transactionSynchronizationRegistry = getTransactionSynchronizationRegistry();
 356         }
 357
 358         private void initWebServer(ConfigurationAdmin conf) {
 359                 String httpPort = getFrameworkProp("org.osgi.service.http.port");
 360                 String httpsPort = getFrameworkProp("org.osgi.service.http.port.secure");
 361                 try {
 362                         if (httpPort != null || httpsPort != null) {
 363                                 Hashtable<String, Object> jettyProps = new Hashtable<String, Object>();
 364                                 if (httpPort != null) {
 365                                         jettyProps.put(JettyConstants.HTTP_PORT, httpPort);
 366                                         jettyProps.put(JettyConstants.HTTP_ENABLED, true);
 367                                 }
 368                                 if (httpsPort != null) {
 369                                         jettyProps.put(JettyConstants.HTTPS_PORT, httpsPort);
 370                                         jettyProps.put(JettyConstants.HTTPS_ENABLED, true);
 371                                         jettyProps.put(JettyConstants.SSL_KEYSTORETYPE, "PKCS12");
 372                                         jettyProps.put(JettyConstants.SSL_KEYSTORE,
 373                                                         nodeSecurity.getHttpServerKeyStore().getCanonicalPath());
 374                                         jettyProps.put(JettyConstants.SSL_PASSWORD, "changeit");
 375                                         jettyProps.put(JettyConstants.SSL_WANTCLIENTAUTH, true);
 376                                 }
 377                                 if (conf != null) {
 378                                         // TODO make filter more generic
 379                                         String filter = "(" + JettyConstants.HTTP_PORT + "=" + httpPort + ")";
 380                                         if (conf.listConfigurations(filter) != null)
 381                                                 return;
 382                                         Configuration jettyConf = conf.createFactoryConfiguration(JETTY_FACTORY_PID, null);
 383                                         jettyConf.update(jettyProps);
 384                                 } else {
 385                                         JettyConfigurator.startServer("default", jettyProps);
 386                                 }
 387                         }
 388                 } catch (Exception e) {
 389                         throw new CmsException("Cannot initialize web server on " + httpPortsMsg(httpPort, httpsPort), e);
 390                 }
 391         }
 392
 393         @SuppressWarnings("unchecked")
 394         private void publish() {
 395                 // Listen to service publication (also ours)
 396                 bc.addServiceListener(Kernel.this);
 397
 398                 // Logging
 399                 loggerReg = bc.registerService(ArgeoLogger.class, logger, null);
 400                 // Transaction
 401                 tmReg = bc.registerService(TransactionManager.class, transactionManager, null);
 402                 utReg = bc.registerService(UserTransaction.class, transactionManager, null);
 403                 tsrReg = bc.registerService(TransactionSynchronizationRegistry.class, transactionSynchronizationRegistry, null);
 404                 // User admin
 405                 userAdminReg = bc.registerService(UserAdmin.class, userAdmin, userAdmin.currentState());
 406                 // JCR
 407                 Hashtable<String, String> regProps = new Hashtable<String, String>();
 408                 regProps.put(JCR_REPOSITORY_ALIAS, ALIAS_NODE);
 409                 repositoryReg = (ServiceRegistration<? extends Repository>) bc.registerService(
 410                                 new String[] { Repository.class.getName(), JackrabbitRepository.class.getName() }, repository,
 411                                 regProps);
 412                 repositoryFactoryReg = bc.registerService(RepositoryFactory.class, repositoryFactory, null);
 413         }
 414
 415         void destroy() {
 416                 long begin = System.currentTimeMillis();
 417                 unpublish();
 418
 419                 kernelThread.destroyAndJoin();
 420
 421                 if (dataHttp != null)
 422                         dataHttp.destroy();
 423                 if (nodeHttp != null)
 424                         nodeHttp.destroy();
 425                 if (userAdmin != null)
 426                         userAdmin.destroy();
 427                 if (repository != null)
 428                         repository.shutdown();
 429                 if (transactionManager != null)
 430                         transactionManager.shutdown();
 431
 432                 bc.removeServiceListener(this);
 433
 434                 // Clean hanging threads from Jackrabbit
 435                 TransientFileFactory.shutdown();
 436
 437                 // Clean hanging Gogo shell thread
 438                 new GogoShellKiller().start();
 439
 440                 nodeSecurity.destroy();
 441                 long duration = System.currentTimeMillis() - begin;
 442                 log.info("## ARGEO CMS DOWN in " + (duration / 1000) + "." + (duration % 1000) + "s ##");
 443         }
 444
 445         private void unpublish() {
 446                 userAdminReg.unregister();
 447                 repositoryFactoryReg.unregister();
 448                 repositoryReg.unregister();
 449                 tmReg.unregister();
 450                 utReg.unregister();
 451                 tsrReg.unregister();
 452                 loggerReg.unregister();
 453         }
 454
 455         @Override
 456         public void serviceChanged(ServiceEvent event) {
 457                 ServiceReference<?> sr = event.getServiceReference();
 458                 Object service = bc.getService(sr);
 459                 if (service instanceof Repository) {
 460                         Object jcrRepoAlias = sr.getProperty(ArgeoJcrConstants.JCR_REPOSITORY_ALIAS);
 461                         if (jcrRepoAlias != null) {// JCR repository
 462                                 String alias = jcrRepoAlias.toString();
 463                                 Repository repository = (Repository) bc.getService(sr);
 464                                 Map<String, Object> props = new HashMap<String, Object>();
 465                                 for (String key : sr.getPropertyKeys())
 466                                         props.put(key, sr.getProperty(key));
 467                                 if (ServiceEvent.REGISTERED == event.getType()) {
 468                                         try {
 469                                                 repositoryFactory.register(repository, props);
 470                                                 dataHttp.registerRepositoryServlets(alias, repository);
 471                                         } catch (Exception e) {
 472                                                 throw new CmsException("Could not publish JCR repository " + alias, e);
 473                                         }
 474                                 } else if (ServiceEvent.UNREGISTERING == event.getType()) {
 475                                         repositoryFactory.unregister(repository, props);
 476                                         dataHttp.unregisterRepositoryServlets(alias);
 477                                 }
 478                         }
 479                 } else if (service instanceof ExtendedHttpService) {
 480                         if (ServiceEvent.REGISTERED == event.getType()) {
 481                                 addHttpService(sr);
 482                         } else if (ServiceEvent.UNREGISTERING == event.getType()) {
 483                                 dataHttp.destroy();
 484                                 dataHttp = null;
 485                         }
 486                 }
 487         }
 488
 489         private void addHttpService(ServiceReference<?> sr) {
 490                 // for (String key : sr.getPropertyKeys())
 491                 // log.debug(key + "=" + sr.getProperty(key));
 492                 ExtendedHttpService httpService = (ExtendedHttpService) bc.getService(sr);
 493                 // TODO find constants
 494                 Object httpPort = sr.getProperty("http.port");
 495                 Object httpsPort = sr.getProperty("https.port");
 496                 dataHttp = new DataHttp(httpService);
 497                 nodeHttp = new NodeHttp(httpService, repository);
 498                 if (log.isDebugEnabled())
 499                         log.debug(httpPortsMsg(httpPort, httpsPort));
 500         }
 501
 502         private String httpPortsMsg(Object httpPort, Object httpsPort) {
 503                 return "HTTP " + httpPort + (httpsPort != null ? " - HTTPS " + httpsPort : "");
 504         }
 505
 506         @Override
 507         public Locale getDefaultLocale() {
 508                 return defaultLocale;
 509         }
 510
 511         /** Can be null. */
 512         @Override
 513         public List<Locale> getLocales() {
 514                 return locales;
 515         }
 516
 517         final private static void directorsCut(long initDuration) {
 518                 // final long ms = 128l + (long) (Math.random() * 128d);
 519                 long ms = initDuration / 100;
 520                 log.info("Spend " + ms + "ms" + " reflecting on the progress brought to mankind" + " by Free Software...");
 521                 long beginNano = System.nanoTime();
 522                 try {
 523                         Thread.sleep(ms, 0);
 524                 } catch (InterruptedException e) {
 525                         // silent
 526                 }
 527                 long durationNano = System.nanoTime() - beginNano;
 528                 final double M = 1000d * 1000d;
 529                 double sleepAccuracy = ((double) durationNano) / (ms * M);
 530                 if (log.isDebugEnabled())
 531                         log.debug("Sleep accuracy: " + String.format("%.2f", 100 - (sleepAccuracy * 100 - 100)) + " %");
 532         }
 533
 534         /** Workaround for blocking Gogo shell by system shutdown. */
 535         private class GogoShellKiller extends Thread {
 536
 537                 public GogoShellKiller() {
 538                         super("Gogo shell killer");
 539                         setDaemon(true);
 540                 }
 541
 542                 @Override
 543                 public void run() {
 544                         ThreadGroup rootTg = getRootThreadGroup(null);
 545                         Thread gogoShellThread = findGogoShellThread(rootTg);
 546                         if (gogoShellThread == null)
 547                                 return;
 548                         while (getNonDaemonCount(rootTg) > 2) {
 549                                 try {
 550                                         Thread.sleep(100);
 551                                 } catch (InterruptedException e) {
 552                                         // silent
 553                                 }
 554                         }
 555                         gogoShellThread = findGogoShellThread(rootTg);
 556                         if (gogoShellThread == null)
 557                                 return;
 558                         System.exit(0);
 559                 }
 560         }
 561
 562         private static ThreadGroup getRootThreadGroup(ThreadGroup tg) {
 563                 if (tg == null)
 564                         tg = Thread.currentThread().getThreadGroup();
 565                 if (tg.getParent() == null)
 566                         return tg;
 567                 else
 568                         return getRootThreadGroup(tg.getParent());
 569         }
 570
 571         private static int getNonDaemonCount(ThreadGroup rootThreadGroup) {
 572                 Thread[] threads = new Thread[rootThreadGroup.activeCount()];
 573                 rootThreadGroup.enumerate(threads);
 574                 int nonDameonCount = 0;
 575                 for (Thread t : threads)
 576                         if (t != null && !t.isDaemon())
 577                                 nonDameonCount++;
 578                 return nonDameonCount;
 579         }
 580
 581         private static Thread findGogoShellThread(ThreadGroup rootThreadGroup) {
 582                 Thread[] threads = new Thread[rootThreadGroup.activeCount()];
 583                 rootThreadGroup.enumerate(threads, true);
 584                 for (Thread thread : threads) {
 585                         if (thread.getName().equals("Gogo shell"))
 586                                 return thread;
 587                 }
 588                 return null;
 589         }
 590
 591 }