/**
   * Acknowledge the occurrence of the specified event.
   *
   * @param event LifecycleEvent that has occurred
   */
  public void lifecycleEvent(LifecycleEvent event) {

    container = event.getLifecycle();

    if (container instanceof Context) {
      namingResources = ((Context) container).getNamingResources();
    } else if (container instanceof Server) {
      namingResources = ((Server) container).getGlobalNamingResources();
    } else {
      return;
    }

    if (event.getType() == Lifecycle.START_EVENT) {

      if (initialized) return;

      Hashtable contextEnv = new Hashtable();
      try {
        namingContext = new NamingContext(contextEnv, getName());
      } catch (NamingException e) {
        // Never happens
      }
      ContextAccessController.setSecurityToken(getName(), container);
      ContextBindings.bindContext(container, namingContext, container);

      // Setting the context in read/write mode
      ContextAccessController.setWritable(getName(), container);

      try {
        createNamingContext();
      } catch (NamingException e) {
        log(sm.getString("naming.namingContextCreationFailed", e));
      }

      // Binding the naming context to the class loader
      if (container instanceof Context) {
        // Setting the context in read only mode
        ContextAccessController.setReadOnly(getName());
        try {
          ContextBindings.bindClassLoader(
              container, container, ((Container) container).getLoader().getClassLoader());
        } catch (NamingException e) {
          log(sm.getString("naming.bindFailed", e));
        }
      }

      if (container instanceof Server) {
        namingResources.addPropertyChangeListener(this);
        org.apache.naming.factory.ResourceLinkFactory.setGlobalContext(namingContext);
        try {
          ContextBindings.bindClassLoader(container, container, this.getClass().getClassLoader());
        } catch (NamingException e) {
          log(sm.getString("naming.bindFailed", e));
        }
        if (container instanceof StandardServer) {
          ((StandardServer) container).setGlobalNamingContext(namingContext);
        }
      }

      initialized = true;

    } else if (event.getType() == Lifecycle.STOP_EVENT) {

      if (!initialized) return;

      // Setting the context in read/write mode
      ContextAccessController.setWritable(getName(), container);

      if (container instanceof Context) {
        ContextBindings.unbindClassLoader(
            container, container, ((Container) container).getLoader().getClassLoader());
      }

      if (container instanceof Server) {
        namingResources.removePropertyChangeListener(this);
        ContextBindings.unbindClassLoader(container, container, this.getClass().getClassLoader());
      }

      ContextAccessController.unsetSecurityToken(getName(), container);

      namingContext = null;
      envCtx = null;
      compCtx = null;
      initialized = false;
    }
  }
  /**
   * Acknowledge the occurrence of the specified event.
   *
   * @param event LifecycleEvent that has occurred
   */
  @Override
  public void lifecycleEvent(LifecycleEvent event) {

    container = event.getLifecycle();

    if (container instanceof Context) {
      namingResources = ((Context) container).getNamingResources();
      logger = log;
      token = ((Context) container).getNamingToken();
    } else if (container instanceof Server) {
      namingResources = ((Server) container).getGlobalNamingResources();
      token = ((Server) container).getNamingToken();
    } else {
      return;
    }

    if (Lifecycle.CONFIGURE_START_EVENT.equals(event.getType())) {

      if (initialized) return;

      try {
        Hashtable<String, Object> contextEnv = new Hashtable<>();
        namingContext = new NamingContext(contextEnv, getName());
        ContextAccessController.setSecurityToken(getName(), token);
        ContextAccessController.setSecurityToken(container, token);
        ContextBindings.bindContext(container, namingContext, token);
        if (log.isDebugEnabled()) {
          log.debug("Bound " + container);
        }

        // Configure write when read-only behaviour
        namingContext.setExceptionOnFailedWrite(getExceptionOnFailedWrite());

        // Setting the context in read/write mode
        ContextAccessController.setWritable(getName(), token);

        try {
          createNamingContext();
        } catch (NamingException e) {
          logger.error(sm.getString("naming.namingContextCreationFailed", e));
        }

        namingResources.addPropertyChangeListener(this);

        // Binding the naming context to the class loader
        if (container instanceof Context) {
          // Setting the context in read only mode
          ContextAccessController.setReadOnly(getName());
          try {
            ContextBindings.bindClassLoader(
                container, token, ((Context) container).getLoader().getClassLoader());
          } catch (NamingException e) {
            logger.error(sm.getString("naming.bindFailed", e));
          }
        }

        if (container instanceof Server) {
          org.apache.naming.factory.ResourceLinkFactory.setGlobalContext(namingContext);
          try {
            ContextBindings.bindClassLoader(container, token, this.getClass().getClassLoader());
          } catch (NamingException e) {
            logger.error(sm.getString("naming.bindFailed", e));
          }
          if (container instanceof StandardServer) {
            ((StandardServer) container).setGlobalNamingContext(namingContext);
          }
        }

      } finally {
        // Regardless of success, so that we can do cleanup on configure_stop
        initialized = true;
      }

    } else if (Lifecycle.CONFIGURE_STOP_EVENT.equals(event.getType())) {

      if (!initialized) return;

      try {
        // Setting the context in read/write mode
        ContextAccessController.setWritable(getName(), token);
        ContextBindings.unbindContext(container, token);

        if (container instanceof Context) {
          ContextBindings.unbindClassLoader(
              container, token, ((Context) container).getLoader().getClassLoader());
        }

        if (container instanceof Server) {
          namingResources.removePropertyChangeListener(this);
          ContextBindings.unbindClassLoader(container, token, this.getClass().getClassLoader());
        }

        ContextAccessController.unsetSecurityToken(getName(), token);
        ContextAccessController.unsetSecurityToken(container, token);

        // unregister mbeans.
        if (!objectNames.isEmpty()) {
          Collection<ObjectName> names = objectNames.values();
          Registry registry = Registry.getRegistry(null, null);
          for (ObjectName objectName : names) {
            registry.unregisterComponent(objectName);
          }
        }
      } finally {
        objectNames.clear();

        namingContext = null;
        envCtx = null;
        compCtx = null;
        initialized = false;
      }
    }
  }
 /**
  * Binds a naming context to the current thread's classloader.
  *
  * @param context the catalina context
  */
 @Override
 public void bindToContext(Context context) throws NamingException {
   Object token = getNamingToken(context);
   ContextBindings.bindClassLoader(context, token, Thread.currentThread().getContextClassLoader());
 }