コード例 #1
0
  /**
   * Set the Valve instance that has been distinguished as the basic Valve for this Pipeline (if
   * any). Prior to setting the basic Valve, the Valve's <code>setContainer()</code> will be called,
   * if it implements <code>Contained</code>, with the owning Container as an argument. The method
   * may throw an <code>IllegalArgumentException</code> if this Valve chooses not to be associated
   * with this Container, or <code>IllegalStateException</code> if it is already associated with a
   * different Container.
   *
   * @param valve Valve to be distinguished as the basic Valve
   */
  public void setBasic(GlassFishValve valve) {

    // Change components if necessary
    GlassFishValve oldBasic = null;
    synchronized (this) {
      oldBasic = this.basic;
    }
    if (oldBasic == valve) {
      return;
    }

    // Stop the old component if necessary
    if (oldBasic != null) {
      synchronized (this) {
        if (started && (oldBasic instanceof Lifecycle)) {
          try {
            ((Lifecycle) oldBasic).stop();
          } catch (LifecycleException e) {
            log.log(Level.SEVERE, SET_BASIC_STOP_EXCEPTION, e);
          }
        }
      }
      if (oldBasic instanceof Contained) {
        try {
          ((Contained) oldBasic).setContainer(null);
        } catch (Throwable t) {
          // Ignore
        }
      }
    }

    // Start the new component if necessary
    if (valve == null) {
      return;
    }
    if (valve instanceof Contained) {
      ((Contained) valve).setContainer(this.container);
    }
    /** CR 6411114 if (valve instanceof Lifecycle) { */
    // START CR 6411114
    // Start the valve if the pipeline has already been started
    if (started && (valve instanceof Lifecycle)) {
      // END CR 6411114
      try {
        ((Lifecycle) valve).start();
      } catch (LifecycleException e) {
        log.log(Level.SEVERE, SET_BASIC_START_EXCEPTION, e);
        return;
      }
    }

    synchronized (this) {
      this.basic = valve;
    }
  }
コード例 #2
0
  /**
   * Remove the specified Valve from the pipeline associated with this Container, if it is found;
   * otherwise, do nothing. If the Valve is found and removed, the Valve's <code>setContainer(null)
   * </code> method will be called if it implements <code>Contained</code>.
   *
   * @param valve Valve to be removed
   */
  public void removeValve(GlassFishValve valve) {

    // Locate this Valve in our list
    int j = -1;
    for (int i = 0; i < valves.length; i++) {
      if (valve == valves[i]) {
        j = i;
        break;
      }
    }
    if (j < 0) return;

    // Remove this valve from our list
    GlassFishValve results[] = new GlassFishValve[valves.length - 1];
    int n = 0;
    for (int i = 0; i < valves.length; i++) {
      if (i == j) continue;
      results[n++] = valves[i];
    }
    valves = results;
    try {
      if (valve instanceof Contained) ((Contained) valve).setContainer(null);
    } catch (Throwable t) {;
    }

    // Stop this valve if necessary
    if (started) {
      if (valve instanceof ValveBase) {
        if (((ValveBase) valve).isStarted()) {
          try {
            ((Lifecycle) valve).stop();
          } catch (LifecycleException e) {
            log.log(Level.SEVERE, REMOVE_VALVE_EXCEPTION, e);
          }
        }
      } else if (valve instanceof Lifecycle) {
        try {
          ((Lifecycle) valve).stop();
        } catch (LifecycleException e) {
          log.log(Level.SEVERE, REMOVE_VALVE_EXCEPTION, e);
        }
      }

      /**
       * CR 6411114 (MBean deregistration moved to ValveBase.stop()) // Unregister the removed valve
       * unregisterValve(valve);
       */
    }
  }
コード例 #3
0
  /**
   * Add a new Valve to the end of the pipeline associated with this Container. Prior to adding the
   * Valve, the Valve's <code>setContainer()</code> method will be called, if it implements <code>
   * Contained</code>, with the owning Container as an argument. The method may throw an <code>
   * IllegalArgumentException</code> if this Valve chooses not to be associated with this Container,
   * or <code>IllegalStateException</code> if it is already associated with a different Container.
   *
   * @param valve Valve to be added
   * @exception IllegalArgumentException if this Container refused to accept the specified Valve
   * @exception IllegalArgumentException if the specified Valve refuses to be associated with this
   *     Container
   * @exception IllegalStateException if the specified Valve is already associated with a different
   *     Container
   */
  public void addValve(GlassFishValve valve) {

    if (firstTcValve != null) {
      // Wrap GlassFish-style valve inside Tomcat-style valve
      addValve(new TomcatValveAdapter(valve));
      return;
    }

    // Validate that we can add this Valve
    if (valve instanceof Contained) ((Contained) valve).setContainer(this.container);

    // Start the new component if necessary
    if (started) {
      if (valve instanceof Lifecycle) {
        try {
          ((Lifecycle) valve).start();
        } catch (LifecycleException e) {
          log.log(Level.SEVERE, ADD_VALVE_EXCEPTION, e);
        }
      }
      /**
       * CR 6411114 (MBean registration moved to ValveBase.start()) // Register the newly added
       * valve registerValve(valve);
       */
    }

    // Add this Valve to the set associated with this Pipeline
    GlassFishValve results[] = new GlassFishValve[valves.length + 1];
    System.arraycopy(valves, 0, results, 0, valves.length);
    results[valves.length] = valve;
    valves = results;
  }
コード例 #4
0
  /**
   * Gracefully shut down active use of the public methods of this Component.
   *
   * @exception IllegalStateException if this component has not been started
   * @exception LifecycleException if this component detects a fatal error that needs to be reported
   */
  public synchronized void stop() throws LifecycleException {

    // Validate and update our current component state
    if (!started) throw new LifecycleException(rb.getString(PIPLINE_NOT_STARTED));

    started = false;

    // Notify our interested LifecycleListeners
    lifecycle.fireLifecycleEvent(BEFORE_STOP_EVENT, null);

    // Notify our interested LifecycleListeners
    lifecycle.fireLifecycleEvent(STOP_EVENT, null);

    // Stop the Valves in our pipeline (including the basic), if any
    if ((basic != null) && (basic instanceof Lifecycle)) ((Lifecycle) basic).stop();
    /**
     * CR 6411114 (MBean deregistration moved to ValveBase.stop()) if( basic!=null ) {
     * unregisterValve(basic); }
     */
    for (int i = 0; i < valves.length; i++) {
      if (valves[i] instanceof Lifecycle) ((Lifecycle) valves[i]).stop();
      /** CR 6411114 (MBean deregistration moved to ValveBase.stop()) unregisterValve(valves[i]); */
    }

    // Notify our interested LifecycleListeners
    lifecycle.fireLifecycleEvent(AFTER_STOP_EVENT, null);
  }
コード例 #5
0
  /** Add Tomcat-style valve. */
  public synchronized void addValve(Valve valve) {

    /*
     * Check if this is a GlassFish-style valve that was compiled
     * against the old org.apache.catalina.Valve interface (from
     * GlassFish releases prior to V3), which has since been renamed
     * to org.glassfish.web.valve.GlassFishValve (in V3)
     */
    if (isGlassFishValve(valve)) {
      try {
        addValve(new GlassFishValveAdapter(valve));
      } catch (Exception e) {
        String msg = MessageFormat.format(rb.getString(ADD_TOMCAT_STYLE_VALVE_EXCEPTION), valve);
        log.log(Level.SEVERE, msg, e);
      }
      return;
    }

    if (valve instanceof Contained) ((Contained) valve).setContainer(this.container);

    // Start the new Valve if necessary
    if (started) {
      if (valve instanceof Lifecycle) {
        try {
          ((Lifecycle) valve).start();
        } catch (LifecycleException e) {
          log.log(Level.SEVERE, ADD_VALVE_EXCEPTION, e);
        }
      }
    }

    if (firstTcValve == null) {
      firstTcValve = lastTcValve = valve;
    } else {
      lastTcValve.setNext(valve);
      lastTcValve = valve;
    }

    if (basic != null) {
      valve.setNext((Valve) basic);
    }
  }