    1   /* ExternalImplDecideRule
    2    *
    3    * Created on May 25, 2005
    4    *
    5    * Copyright (C) 2005 Internet Archive.
    6    *
    7    * This file is part of the Heritrix web crawler (crawler.archive.org).
    8    *
    9    * Heritrix is free software; you can redistribute it and/or modify
    10   * it under the terms of the GNU Lesser Public License as published by
    11   * the Free Software Foundation; either version 2.1 of the License, or
    12   * any later version.
    13   *
    14   * Heritrix is distributed in the hope that it will be useful,
    15   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    16   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    17   * GNU Lesser Public License for more details.
    18   *
    19   * You should have received a copy of the GNU Lesser Public License
    20   * along with Heritrix; if not, write to the Free Software
    21   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
    22   */
    23  package org.archive.crawler.deciderules;
    24
    25  import java.util.logging.Logger;
    26
    27  import javax.management.AttributeNotFoundException;
    28
    29  import org.archive.crawler.settings.SimpleType;
    30
    31  /***
    32   * A rule that can be configured to take alternate implementations
    33   * of the ExternalImplInterface.
    34   * If no implementation specified, or none found, returns
    35   * configured decision.
    36   * @author stack
    37   * @version $Date: 2007-02-18 21:53:01 +0000 (Sun, 18 Feb 2007) $, $Revision: 4914 $
    38   */
    39  public class ExternalImplDecideRule
    40  extends PredicatedDecideRule {
    41
    42      private static final long serialVersionUID = 7727715263469524372L;
    43
    44      private static final Logger LOGGER =
    45          Logger.getLogger(ExternalImplDecideRule.class.getName());
    46      static final String ATTR_IMPLEMENTATION = "implementation-class";
    47      private ExternalImplInterface implementation = null;
    48
    49      /***
    50       * @param name Name of this rule.
    51       */
    52      public ExternalImplDecideRule(String name) {
    53          super(name);
    54          setDescription("ExternalImplDecideRule. Rule that " +
    55              "instantiates implementations of the ExternalImplInterface. " +
    56              "The implementation needs to be present on the classpath. " +
    57              "On initialization, the implementation is instantiated (" +
    58              "assumption is that there is public default constructor).");
    59          addElementToDefinition(new SimpleType(ATTR_IMPLEMENTATION,
    60              "Name of implementation of ExternalImplInterface class to " +
    61              "instantiate.", ""));
    62      }
    63
    64      protected boolean evaluate(Object obj) {
    65          ExternalImplInterface impl = getConfiguredImplementation(obj);
    66          return (impl != null)? impl.evaluate(obj): false;
    67      }
    68
    69      /***
    70       * Get implementation, if one specified.
    71       * If none specified, will keep trying to find one. Will be messy
    72       * if the provided class is not-instantiable or not implementation
    73       * of ExternalImplInterface.
    74       * @param o A context object.
    75       * @return Instance of <code>ExternalImplInterface</code> or null.
    76       */
    77      protected synchronized ExternalImplInterface
    78              getConfiguredImplementation(Object o) {
    79          if (this.implementation != null) {
    80              return this.implementation;
    81          }
    82          ExternalImplInterface result = null;
    83          try {
    84              String className =
    85                  (String)getAttribute(o, ATTR_IMPLEMENTATION);
    86              if (className != null && className.length() != 0) {
    87                  Object obj = Class.forName(className).newInstance();
    88                  if (!(obj instanceof ExternalImplInterface)) {
    89                      LOGGER.severe("Implementation " + className +
    90                          " does not implement ExternalImplInterface");
    91                  }
    92                  result = (ExternalImplInterface)obj;
    93                  this.implementation = result;
    94              }
    95          } catch (AttributeNotFoundException e) {
    96              LOGGER.severe(e.getMessage());
    97          } catch (InstantiationException e) {
    98              LOGGER.severe(e.getMessage());
    99          } catch (IllegalAccessException e) {
    100             LOGGER.severe(e.getMessage());
    101         } catch (ClassNotFoundException e) {
    102             LOGGER.severe(e.getMessage());
    103         }
    104         return result;
    105     }
    106 }