Esempio n. 1
1
  protected PsmMethodAction(Class c, String m, Class[] argArray) {
    // This prevents IllegalAccessExceptions when attempting to
    // invoke methods on a class that is in another package and not
    // defined 'public'.
    if (!Modifier.isPublic(c.getModifiers())) {
      throw new IllegalPsmMethodActionException("Action class must be public.");
    }

    try {
      method = c.getMethod(m, argArray);
    } catch (NoSuchMethodException ex) {
      throw new IllegalPsmMethodActionException(ex.toString() + ": method " + m);
    }

    // Check each exception this method declares thrown.  If it declares
    // exceptions, and any of them are not runtime exceptions, abort.
    Class[] exceptionTypes = method.getExceptionTypes();
    for (int i = 0; i < exceptionTypes.length; i++) {
      Class exceptionClass = exceptionTypes[i];
      if (!RuntimeException.class.isAssignableFrom(exceptionClass)) {
        throw new IllegalPsmMethodActionException(
            "Method must not declare non-Runtime " + "exceptions.");
      }
    }

    // Ensure that the method returns PsmEvent
    if (PsmEvent.class != method.getReturnType()) {
      throw new IllegalPsmMethodActionException("Method return type must be PsmEvent");
    }

    // Ensure that both the method is both public and static.
    if (!Modifier.isStatic(method.getModifiers()) || !Modifier.isPublic(method.getModifiers())) {
      throw new IllegalPsmMethodActionException("Method " + m + " must be static and public.");
    }
  }
 /**
  * Builds a new page stream transform using the given PDF operator processors (represented by
  * their class) to process the given PDF operators (represented by their operator string), and
  * imposing a default of {@link SimpleOperatorProcessor} for all others.
  *
  * @param pdfOperatorString1 A PDF operator string.
  * @param pdfOperatorProcessor1 A PDF operator processor class for <code>pdfOperatorString1</code>
  *     .
  * @param pdfOperatorString2 A PDF operator string.
  * @param pdfOperatorProcessor2 A PDF operator processor class for <code>pdfOperatorString2</code>
  *     .
  * @throws IOException if any processing error occurs.
  * @see #PageStreamTransform(Properties)
  * @see PropUtil#fromArgs(String, String, String, String)
  * @deprecated Use {@link #PageStreamTransform(OperatorProcessorFactory, String, Class, String,
  *     Class)}.
  */
 public PageStreamTransform(
     String pdfOperatorString1,
     Class pdfOperatorProcessor1,
     String pdfOperatorString2,
     Class pdfOperatorProcessor2)
     throws IOException {
   this(
       PropUtil.fromArgs(
           pdfOperatorString1, pdfOperatorProcessor1.getName(),
           pdfOperatorString2, pdfOperatorProcessor2.getName()));
 }
 /**
  * Builds a new page stream transform using the given PDF operator processors (represented by
  * their class) to process the given PDF operators (represented by their operator string), and
  * imposing a default of {@link SimpleOperatorProcessor} for all others.
  *
  * @param factory A {@link PdfOperatorProcessor} factory.
  * @param pdfOperatorString1 A PDF operator string.
  * @param pdfOperatorProcessor1 A PDF operator processor class for <code>pdfOperatorString1</code>
  *     .
  * @param pdfOperatorString2 A PDF operator string.
  * @param pdfOperatorProcessor2 A PDF operator processor class for <code>pdfOperatorString2</code>
  *     .
  * @param pdfOperatorString3 A PDF operator string.
  * @param pdfOperatorProcessor3 A PDF operator processor class for <code>pdfOperatorString3</code>
  *     .
  * @throws IOException if any processing error occurs.
  * @see #PageStreamTransform(OperatorProcessorFactory, Properties)
  * @see PropUtil#fromArgs(String, String, String, String, String, String)
  */
 public PageStreamTransform(
     OperatorProcessorFactory factory,
     String pdfOperatorString1,
     Class pdfOperatorProcessor1,
     String pdfOperatorString2,
     Class pdfOperatorProcessor2,
     String pdfOperatorString3,
     Class pdfOperatorProcessor3)
     throws IOException {
   this(
       factory,
       PropUtil.fromArgs(
           pdfOperatorString1, pdfOperatorProcessor1.getName(),
           pdfOperatorString2, pdfOperatorProcessor2.getName(),
           pdfOperatorString3, pdfOperatorProcessor3.getName()));
 }
 /**
  * Returns an instance of the type of MBF indicated by "version" intended to verify a proof of
  * effort.
  *
  * @param nonceVal a byte array containing the nonce
  * @param eVal the effort sizer (# of low-order zeros in destination)
  * @param lVal the effort sizer (length of each path)
  * @param nVal the proof density
  * @param sVal an array of ints containing the proof
  * @param maxPathVal maximum number of steps to verify
  * @throws NoSuchAlgorithmException no such implementation
  * @throws InstantiationException XXX
  * @throws IllegalAccessException XXX
  * @throws MemoryBoundFunctionException could not initialize instance
  */
 public MemoryBoundFunction makeVerifier(
     byte[] nonceVal, int eVal, int lVal, int nVal, int[] sVal, long maxPathVal)
     throws NoSuchAlgorithmException, InstantiationException, IllegalAccessException,
         MemoryBoundFunctionException {
   MemoryBoundFunction ret = null;
   if (classToUse == null) throw new NoSuchAlgorithmException();
   ret = (MemoryBoundFunction) classToUse.newInstance();
   ret.initialize(nonceVal, eVal, lVal, nVal, sVal, maxPathVal, A0, T);
   return (ret);
 }
 /**
  * Public constructor for an object that creates MemoryBoundFunction objects of the requested
  * implementation.
  *
  * @param impl A String specifying the implementation to use.
  * @param A0array The A0 basis array
  * @param Tarray The T basis array
  * @throws NoSuchAlgorithmException if no such implementation
  */
 public MemoryBoundFunctionFactory(String impl, byte[] A0array, byte[] Tarray)
     throws NoSuchAlgorithmException, ClassNotFoundException, MemoryBoundFunctionException {
   classToUse = null;
   implToUse = null;
   for (int i = 0; i < implNames.length; i++) {
     if (implNames[i].equals(impl)) implToUse = impls[i];
   }
   if (implToUse != null) {
     // Found it
     if (A0array == null || Tarray == null) {
       throw new MemoryBoundFunctionException("Array is null");
     }
     classToUse = Class.forName(implToUse);
     logger.info("factory for " + impl + " size " + A0array.length + " / " + Tarray.length);
     A0 = A0array;
     T = Tarray;
   } else {
     throw new NoSuchAlgorithmException(impl);
   }
 }
 /**
  * Builds a new page stream transform using the given PDF operator processor (represented by its
  * class) to process the given PDF operator (represented by its operator string), and imposing a
  * default of {@link SimpleOperatorProcessor} for all others.
  *
  * @param factory A {@link PdfOperatorProcessor} factory.
  * @param pdfOperatorString A PDF operator string.
  * @param pdfOperatorProcessor A PDF operator processor class for <code>pdfOperatorString</code>..
  * @throws IOException if any processing error occurs.
  * @see #PageStreamTransform(OperatorProcessorFactory, Properties)
  * @see PropUtil#fromArgs(String, String)
  */
 public PageStreamTransform(
     OperatorProcessorFactory factory, String pdfOperatorString, Class pdfOperatorProcessor)
     throws IOException {
   this(factory, PropUtil.fromArgs(pdfOperatorString, pdfOperatorProcessor.getName()));
 }
  protected void initResultMap() throws PluginException.InvalidDefinition {
    HttpResultMap hResultMap = new HttpResultMap();
    // XXX Currently this only allows a CacheResultHandler class to
    // initialize the result map.  Instead, don't use a CacheResultMap
    // directly, use either the plugin's CacheResultHandler, if specified,
    // or a default one that wraps the CacheResultMap

    String handler_class = null;
    handler_class = definitionMap.getString(KEY_EXCEPTION_HANDLER, null);
    if (handler_class != null) {
      try {
        resultHandler = (CacheResultHandler) newAuxClass(handler_class, CacheResultHandler.class);
        resultHandler.init(hResultMap);
      } catch (Exception ex) {
        throw new PluginException.InvalidDefinition(
            mapName + " has invalid Exception handler: " + handler_class, ex);
      } catch (LinkageError le) {
        throw new PluginException.InvalidDefinition(
            mapName + " has invalid Exception handler: " + handler_class, le);
      }
    } else {
      // Expect a list of mappings from either result code or exception
      // name to CacheException name
      Collection<String> mappings = definitionMap.getCollection(KEY_EXCEPTION_LIST, null);
      if (mappings != null) {
        // add each entry
        for (String entry : mappings) {
          if (log.isDebug2()) {
            log.debug2("initMap(" + entry + ")");
          }
          String first;
          String ceName;
          try {
            List<String> pair = StringUtil.breakAt(entry, '=', 2, true, true);
            first = pair.get(0);
            ceName = pair.get(1);
          } catch (Exception ex) {
            throw new PluginException.InvalidDefinition(
                "Invalid syntax: " + entry + "in " + mapName);
          }
          Object val;

          // Value should be either a CacheException or CacheResultHandler
          // class name.
          PluginFetchEventResponse resp =
              (PluginFetchEventResponse) newAuxClass(ceName, PluginFetchEventResponse.class, null);
          if (resp instanceof CacheException) {
            val = resp.getClass();
          } else if (resp instanceof CacheResultHandler) {
            val = WrapperUtil.wrap((CacheResultHandler) resp, CacheResultHandler.class);
          } else {
            throw new PluginException.InvalidDefinition(
                "Second arg not a "
                    + "CacheException or "
                    + "CacheResultHandler class: "
                    + entry
                    + ", in "
                    + mapName);
          }
          try {
            int code = Integer.parseInt(first);
            // If parseable as an integer, it's a result code.
            hResultMap.storeMapEntry(code, val);
          } catch (NumberFormatException e) {
            try {
              Class eClass = Class.forName(first);
              // If a class name, it should be an exception class
              if (Exception.class.isAssignableFrom(eClass)) {
                hResultMap.storeMapEntry(eClass, val);
              } else {
                throw new PluginException.InvalidDefinition(
                    "First arg not an " + "Exception class: " + entry + ", in " + mapName);
              }
            } catch (Exception ex) {
              throw new PluginException.InvalidDefinition(
                  "First arg not a " + "number or class: " + entry + ", in " + mapName);
            } catch (LinkageError le) {
              throw new PluginException.InvalidDefinition("Can't load " + first, le);
            }
          }
        }
      }
    }
    resultMap = hResultMap;
  }