/** * Allow sub classes to fire {@link Lifecycle} events.
     * 
     * @param type  Event type
     * @param data  Data associated with event. */ protected void fireLifecycleEvent(String type, Object data) {
        lifecycle.fireLifecycleEvent(type, data);
    }

/** * Used to handle firing lifecycle events.
     * TODO: Consider merging LifecycleSupport into this class. */ private LifecycleSupport lifecycle = new LifecycleSupport(this);

/** * Notify all lifecycle event listeners that a particular event has
     * occurred for this Container.  The default implementation performs
     * this notification synchronously using the calling thread.
     *
     * @param type Event type
     * @param data Event data */ public void fireLifecycleEvent(String type, Object data) {

        LifecycleEvent event = new LifecycleEvent(lifecycle, type, data);
        LifecycleListener interested[] = listeners; for (int i = 0; i < interested.length; i++)
            interested[i].lifecycleEvent(event);

    }

/** * The set of registered LifecycleListeners for event notifications. */ private LifecycleListener listeners[] = new LifecycleListener[0];

@Override public void addLifecycleListener(LifecycleListener listener) {
        lifecycle.addLifecycleListener(listener);
    }

/** * Add a lifecycle event listener to this component.
     *
     * @param listener The listener to add */ public void addLifecycleListener(LifecycleListener listener) { synchronized (listenersLock) {
          LifecycleListener results[] = new LifecycleListener[listeners.length + 1]; for (int i = 0; i < listeners.length; i++)
              results[i] = listeners[i];
          results[listeners.length] = listener;
          listeners = results;
      }

    }

/** * Primary entry point for startup and shutdown events.
     *
     * @param event The event that has occurred */ public void lifecycleEvent(LifecycleEvent event) { if (Lifecycle.INIT_EVENT.equals(event.getType())) { synchronized (lock) {
                init(); if (aprAvailable) { try {
                        initializeSSL();
                    } catch (Throwable t) {
                        log.info(sm.getString("aprListener.sslInit"));
                    }
                }
            }
        } else if (Lifecycle.AFTER_STOP_EVENT.equals(event.getType())) { synchronized (lock) { if (!aprAvailable) { return;
                } try {
                    terminateAPR();
                } catch (Throwable t) {
                    log.info(sm.getString("aprListener.aprDestroy"));
                }
            }
        }

    }

/** * The current state of the source component. */ private volatile LifecycleState state = LifecycleState.NEW;

public synchronized final void init() throws LifecycleException { if (!state.equals(LifecycleState.NEW)) {
            invalidTransition(Lifecycle.INIT_EVENT);
        }

        initInternal();
        
        setState(LifecycleState.INITIALIZED);
    }

@Override protected void initInternal() throws LifecycleException { super.initInternal(); // Register global String *** // Note although the *** is global, if there are multiple Servers // present in the JVM (may happen when embedding) then the same *** // will be registered under multiple names onameStringCache = register(new StringCache(), "type=StringCache"); // Register the MBeanFactory onameMBeanFactory = register(new MBeanFactory(), "type=MBeanFactory"); // Register the naming resources onameNamingResoucres = register(globalNamingResources, "type=NamingResources"); // Initialize our defined Services for (int i = 0; i < services.length; i++) {
            services[i].init();
        }
    }

@Override protected void initInternal() throws LifecycleException { // If oname is not null then registration has already happened via // preRegister(). if (oname == null) {
            mserver = Registry.getRegistry(null, null).getMBeanServer();
            
            oname = register(this, getObjectNameKeyProperties());
        }
    }

@Override protected final String getObjectNameKeyProperties() { return "type=Server";
    }

protected final ObjectName register(Object obj,
            String objectNameKeyProperties) { // Construct an object name with the right domain StringBuilder name = new StringBuilder(getDomain());
        name.append(':');
        name.append(objectNameKeyProperties);

        ObjectName on = null; try {
            on = new ObjectName(name.toString());
            
            Registry.getRegistry(null, null).registerComponent(obj, on, null);
        } catch (MalformedObjectNameException e) {
            log.warn(sm.getString("lifecycleMBeanBase.registerFail", obj, name),
                    e);
        } catch (Exception e) {
            log.warn(sm.getString("lifecycleMBeanBase.registerFail", obj, name),
                    e);
        } return on;
    }

/** Register a component 
     * XXX make it private 
     * 
     * @param bean
     * @param oname
     * @param type
     * @throws Exception */ public void registerComponent(Object bean, ObjectName oname, String type) throws Exception
    { if( log.isDebugEnabled() ) {
            log.debug( "Managed= "+ oname);
        } if( bean ==null ) {
            log.error("Null component " + oname ); return;
        } try { if( type==null ) {
                type=bean.getClass().getName();
            }

            ManagedBean managed = findManagedBean(bean.getClass(), type); // The real mbean is created and registered DynamicMBean mbean = managed.createMBean(bean); if(  getMBeanServer().isRegistered( oname )) { if( log.isDebugEnabled()) {
                    log.debug("Unregistering existing component " + oname );
                }
                getMBeanServer().unregisterMBean( oname );
            }

            getMBeanServer().registerMBean( mbean, oname);
        } catch( Exception ex) {
            log.error("Error registering " + oname, ex ); throw ex;
        }
    }

@Override public synchronized final void start() throws LifecycleException { if (LifecycleState.STARTING_PREP.equals(state) || LifecycleState.STARTING.equals(state) || LifecycleState.STARTED.equals(state)) { if (log.isDebugEnabled()) {
                Exception e = new LifecycleException();
                log.debug(sm.getString("lifecycleBase.alreadyStarted",
                        toString()), e);
            } else if (log.isInfoEnabled()) {
                log.info(sm.getString("lifecycleBase.alreadyStarted",
                        toString()));
            } return;
        } if (state.equals(LifecycleState.NEW)) {
            init();
        } else if (!state.equals(LifecycleState.INITIALIZED) &&
                !state.equals(LifecycleState.STOPPED)) {
            invalidTransition(Lifecycle.BEFORE_START_EVENT);
        }

        setState(LifecycleState.STARTING_PREP); try {
            startInternal();
        } catch (LifecycleException e) {
            setState(LifecycleState.FAILED); throw e;
        } if (state.equals(LifecycleState.FAILED) || state.equals(LifecycleState.MUST_STOP)) {
            stop();
        } else { // Shouldn't be necessary but acts as a check that sub-classes are // doing what they are supposed to. if (!state.equals(LifecycleState.STARTING)) {
                invalidTransition(Lifecycle.AFTER_START_EVENT);
            }
            
            setState(LifecycleState.STARTED);
        }
    }

@Override protected void startInternal() throws LifecycleException {

        fireLifecycleEvent(CONFIGURE_START_EVENT, null);
        setState(LifecycleState.STARTING); // Start our defined Services synchronized (services) { for (int i = 0; i < services.length; i++) {
                services[i].start();
            }
        }
    }