Esempio n. 1
0
 /** Shut down all the service components in the reverse order that they were added. */
 void shutdownServices() {
   // reverse the list of services
   ArrayList<Object> list = new ArrayList<Object>();
   for (Object service : serviceComponents) {
     list.add(service);
   }
   Collections.reverse(list);
   for (Object service : list) {
     ((Service) service).shutdown();
   }
 }
  /**
   * Creates each of the <code>Service</code>s in order, in preparation for starting up an
   * application. At completion, this schedules an <code>AppStartupRunner</code> to finish
   * application startup.
   */
  public void run() {
    if (logger.isLoggable(Level.CONFIG))
      logger.log(Level.CONFIG, "{0}: starting services", appName);

    // create an empty context and register with the scheduler
    ComponentRegistryImpl services = new ComponentRegistryImpl();
    ComponentRegistryImpl managers = new ComponentRegistryImpl();
    AppKernelAppContext ctx = new AppKernelAppContext(appName, services, managers);
    MasterTaskScheduler scheduler = systemRegistry.getComponent(MasterTaskScheduler.class);
    try {
      scheduler.registerApplication(ctx, appProperties);
    } catch (Exception e) {
      if (logger.isLoggable(Level.SEVERE))
        logger.logThrow(Level.SEVERE, e, "{0}: failed app scheduler " + "setup", appName);
      return;
    }

    // create the application's identity, and set as the current owner
    IdentityImpl id = new IdentityImpl("app:" + appName);
    TaskOwnerImpl owner = new TaskOwnerImpl(id, ctx);
    ThreadState.setCurrentOwner(owner);

    // get the managers and services that we're using
    HashSet<Object> managerSet = new HashSet<Object>();
    try {
      fetchServices(services, managerSet);
    } catch (Exception e) {
      if (logger.isLoggable(Level.SEVERE))
        logger.logThrow(Level.SEVERE, e, "{0}: failed to create " + "services", appName);

      ctx.shutdownServices();
      return;
    }

    // register any profiling managers and fill in the manager registry
    for (Object manager : managerSet) {
      if (profileRegistrar != null) {
        if (manager instanceof ProfileProducer)
          ((ProfileProducer) manager).setProfileRegistrar(profileRegistrar);
      }
      managers.addComponent(manager);
    }

    // with the managers created, setup the final context and owner
    ctx = new AppKernelAppContext(appName, services, managers);
    owner = new TaskOwnerImpl(id, ctx);
    ThreadState.setCurrentOwner(owner);

    // notify all of the services that the application state is ready
    try {
      for (Object s : services) ((Service) s).ready();
    } catch (Exception e) {
      logger.logThrow(
          Level.SEVERE,
          e,
          "{0}: failed when notifying services that application is " + "ready",
          appName);
      // shutdown all of the services
      ctx.shutdownServices();
      return;
    }

    // At this point the services are now created, so the final step
    // is to try booting the application by running a special
    // KernelRunnable in an unbounded transaction. Note that if we're
    // running as a "server" then we don't actually start an app
    if (!appProperties
        .getProperty(StandardProperties.APP_LISTENER)
        .equals(StandardProperties.APP_LISTENER_NONE)) {
      AppStartupRunner startupRunner = new AppStartupRunner(ctx, appProperties);
      UnboundedTransactionRunner unboundedTransactionRunner =
          new UnboundedTransactionRunner(startupRunner);
      try {
        if (logger.isLoggable(Level.CONFIG))
          logger.log(Level.CONFIG, "{0}: starting application", appName);
        // run the startup task, notifying the kernel on success
        scheduler.runTask(unboundedTransactionRunner, owner, true);
        kernel.contextReady(owner, true);
      } catch (Exception e) {
        if (logger.isLoggable(Level.CONFIG))
          logger.logThrow(Level.CONFIG, e, "{0}: failed to " + "start application", appName);
        return;
      }
    } else {
      // we're running without an application, so we're finished
      kernel.contextReady(owner, false);
    }

    if (logger.isLoggable(Level.CONFIG))
      logger.log(Level.CONFIG, "{0}: finished service config runner", appName);
  }
Esempio n. 3
0
 /**
  * Notifies all included Services that the system is now ready.
  *
  * @throws Exception if there is any failure during notification
  */
 void notifyReady() throws Exception {
   for (Object service : serviceComponents) ((Service) service).ready();
 }