private boolean loadTomcatParameters() {
    InitialContext initCtx = null;
    try {
      initCtx = new InitialContext();
      NamingContext envCtx = (NamingContext) initCtx.lookup("java:comp/env");
      try {
        CommandRunner.setServerSettingFromTomcatConfig(
            "app_output_dir", (String) envCtx.lookup("app_output_dir"));
      } catch (NamingException e) {
        File rootFolder = new File(ApplicationSettings.WEBAPP_ROOT_DIRECTORY);
        String appHome = rootFolder.getParentFile().getParentFile().getParent();
        CommandRunner.setServerSettingFromTomcatConfig("app_output_dir", appHome);
      }

      try {
        CommandRunner.setServerSettingFromTomcatConfig(
            "is_test_version", (String) envCtx.lookup("is_test_version"));
      } catch (NameNotFoundException e) {
        // Absent is_test_version variable in context.xml
        CommandRunner.setServerSettingFromTomcatConfig("is_test_version", "false");
      }

      CommandRunner.setServerSettingFromTomcatConfig(
          "backend_url", (String) envCtx.lookup("backend_url"));
      return true;
    } catch (Throwable e) {
      e
          .printStackTrace(); // To change body of catch statement use File | Settings | File
                              // Templates.
      return false;
    }
  }
  /**
   * Creates and binds a new context. Creates a new context with the given name and binds it in the
   * target context (that named by all but terminal atomic component of the name). All intermediate
   * contexts and the target context must already exist.
   *
   * @param name the name of the context to create; may not be empty
   * @return the newly created context
   * @exception NameAlreadyBoundException if name is already bound
   * @exception javax.naming.directory.InvalidAttributesException if creation of the sub-context
   *     requires specification of mandatory attributes
   * @exception NamingException if a naming exception is encountered
   */
  @Override
  public Context createSubcontext(Name name) throws NamingException {
    if (!checkWritable()) {
      return null;
    }

    NamingContext newContext = new NamingContext(env, this.name);
    bind(name, newContext);

    newContext.setExceptionOnFailedWrite(getExceptionOnFailedWrite());

    return newContext;
  }
  /** Create and initialize the JNDI naming context. */
  private void createNamingContext() throws NamingException {

    // Creating the comp subcontext
    if (container instanceof Server) {
      compCtx = namingContext;
      envCtx = namingContext;
    } else {
      compCtx = namingContext.createSubcontext("comp");
      envCtx = compCtx.createSubcontext("env");
    }

    int i;

    if (log.isDebugEnabled()) log.debug("Creating JNDI naming context");

    if (namingResources == null) {
      namingResources = new NamingResourcesImpl();
      namingResources.setContainer(container);
    }

    // Resource links
    ContextResourceLink[] resourceLinks = namingResources.findResourceLinks();
    for (i = 0; i < resourceLinks.length; i++) {
      addResourceLink(resourceLinks[i]);
    }

    // Resources
    ContextResource[] resources = namingResources.findResources();
    for (i = 0; i < resources.length; i++) {
      addResource(resources[i]);
    }

    // Resources Env
    ContextResourceEnvRef[] resourceEnvRefs = namingResources.findResourceEnvRefs();
    for (i = 0; i < resourceEnvRefs.length; i++) {
      addResourceEnvRef(resourceEnvRefs[i]);
    }

    // Environment entries
    ContextEnvironment[] contextEnvironments = namingResources.findEnvironments();
    for (i = 0; i < contextEnvironments.length; i++) {
      addEnvironment(contextEnvironments[i]);
    }

    // EJB references
    ContextEjb[] ejbs = namingResources.findEjbs();
    for (i = 0; i < ejbs.length; i++) {
      addEjb(ejbs[i]);
    }

    // WebServices references
    ContextService[] services = namingResources.findServices();
    for (i = 0; i < services.length; i++) {
      addService(services[i]);
    }

    // Binding a User Transaction reference
    if (container instanceof Context) {
      try {
        Reference ref = new TransactionRef();
        compCtx.bind("UserTransaction", ref);
        ContextTransaction transaction = namingResources.getTransaction();
        if (transaction != null) {
          Iterator<String> params = transaction.listProperties();
          while (params.hasNext()) {
            String paramName = params.next();
            String paramValue = (String) transaction.getProperty(paramName);
            StringRefAddr refAddr = new StringRefAddr(paramName, paramValue);
            ref.add(refAddr);
          }
        }
      } catch (NameAlreadyBoundException e) {
        // Ignore because UserTransaction was obviously
        // added via ResourceLink
      } catch (NamingException e) {
        logger.error(sm.getString("naming.bindFailed", e));
      }
    }

    // Binding the resources directory context
    if (container instanceof Context) {
      try {
        compCtx.bind("Resources", ((Context) container).getResources());
      } catch (NamingException e) {
        logger.error(sm.getString("naming.bindFailed", e));
      }
    }
  }
  /**
   * 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;
      }
    }
  }
  /** Create and initialize the JNDI naming context. */
  private void createNamingContext() throws NamingException {

    // Creating the comp subcontext
    if (container instanceof Server) {
      compCtx = namingContext;
      envCtx = namingContext;
    } else {
      compCtx = namingContext.createSubcontext("comp");
      envCtx = compCtx.createSubcontext("env");
    }

    int i;

    if (debug >= 1) log("Creating JNDI naming context");

    if (namingResources == null) {
      namingResources = new NamingResources();
      namingResources.setContainer(container);
    }

    // Resource links
    ContextResourceLink[] resourceLinks = namingResources.findResourceLinks();
    for (i = 0; i < resourceLinks.length; i++) {
      addResourceLink(resourceLinks[i]);
    }

    // Resources
    ContextResource[] resources = namingResources.findResources();
    for (i = 0; i < resources.length; i++) {
      addResource(resources[i]);
    }

    // Resources Env
    String[] resourceEnvRefs = namingResources.findResourceEnvRefs();
    for (i = 0; i < resourceEnvRefs.length; i++) {
      String key = resourceEnvRefs[i];
      String type = namingResources.findResourceEnvRef(key);
      addResourceEnvRef(key, type);
    }

    // Environment entries
    ContextEnvironment[] contextEnvironments = namingResources.findEnvironments();
    for (i = 0; i < contextEnvironments.length; i++) {
      addEnvironment(contextEnvironments[i]);
    }

    // EJB references
    ContextEjb[] ejbs = namingResources.findEjbs();
    for (i = 0; i < ejbs.length; i++) {
      addEjb(ejbs[i]);
    }

    // Binding a User Transaction reference
    if (container instanceof Context) {
      try {
        Reference ref = new TransactionRef();
        compCtx.bind("UserTransaction", ref);
        addAdditionalParameters(namingResources, ref, "UserTransaction");
      } catch (NamingException e) {
        log(sm.getString("naming.bindFailed", e));
      }
    }

    // Binding the resources directory context
    if (container instanceof Context) {
      try {
        compCtx.bind("Resources", ((Container) container).getResources());
      } catch (NamingException e) {
        log(sm.getString("naming.bindFailed", e));
      }
    }
  }