Example #1
1
  private static void showThreads(PrintStream pw, ThreadGroup g, Thread current) {
    int nthreads = g.activeCount();
    pw.println("\nThread Group = " + g.getName() + " activeCount= " + nthreads);
    Thread[] tarray = new Thread[nthreads];
    int n = g.enumerate(tarray, false);

    for (int i = 0; i < n; i++) {
      Thread thread = tarray[i];
      ClassLoader loader = thread.getContextClassLoader();
      String loaderName = (loader == null) ? "Default" : loader.getClass().getName();
      Thread.State state = thread.getState();
      long id = thread.getId();
      pw.print("   " + id + " " + thread.getName() + " " + state + " " + loaderName);
      if (thread == current) pw.println(" **** CURRENT ***");
      else pw.println();
    }

    int ngroups = g.activeGroupCount();
    ThreadGroup[] garray = new ThreadGroup[ngroups];
    int ng = g.enumerate(garray, false);
    for (int i = 0; i < ng; i++) {
      ThreadGroup nested = garray[i];
      showThreads(pw, nested, current);
    }
  }
Example #2
0
 static {
   Attributes m = null;
   final URL loc = Prop.LOCATION;
   if (loc != null) {
     final String jar = loc.getFile();
     try {
       final ClassLoader cl = JarManifest.class.getClassLoader();
       final Enumeration<URL> list = cl.getResources("META-INF/MANIFEST.MF");
       while (list.hasMoreElements()) {
         final URL url = list.nextElement();
         if (!url.getFile().contains(jar)) continue;
         final InputStream in = url.openStream();
         try {
           m = new Manifest(in).getMainAttributes();
           break;
         } finally {
           in.close();
         }
       }
     } catch (final IOException ex) {
       Util.errln(ex);
     }
   }
   MAP = m;
 }
Example #3
0
  /**
   * Replacement for <code>Class.forName()</code> that also returns Class instances for primitives
   * (like "int") and array class names (like "String[]").
   *
   * @param name the name of the Class
   * @param classLoader the class loader to use (may be <code>null</code>, which indicates the
   *     default class loader)
   * @return Class instance for the supplied name
   * @throws ClassNotFoundException if the class was not found
   * @throws LinkageError if the class file could not be loaded
   * @see Class#forName(String, boolean, ClassLoader)
   */
  public static Class<?> forName(String name, ClassLoader classLoader)
      throws ClassNotFoundException, LinkageError {

    Class<?> clazz = resolvePrimitiveClassName(name);
    if (clazz != null) {
      return clazz;
    }

    // "java.lang.String[]" style arrays
    if (name.endsWith(ARRAY_SUFFIX)) {
      String elementClassName = name.substring(0, name.length() - ARRAY_SUFFIX.length());
      Class<?> elementClass = forName(elementClassName, classLoader);
      return Array.newInstance(elementClass, 0).getClass();
    }

    // "[Ljava.lang.String;" style arrays
    int internalArrayMarker = name.indexOf(INTERNAL_ARRAY_PREFIX);
    if (internalArrayMarker != -1 && name.endsWith(";")) {
      String elementClassName = null;
      if (internalArrayMarker == 0) {
        elementClassName = name.substring(INTERNAL_ARRAY_PREFIX.length(), name.length() - 1);
      } else if (name.startsWith("[")) {
        elementClassName = name.substring(1);
      }
      Class<?> elementClass = forName(elementClassName, classLoader);
      return Array.newInstance(elementClass, 0).getClass();
    }

    ClassLoader classLoaderToUse = classLoader;
    if (classLoaderToUse == null) {
      classLoaderToUse = getClassLoader();
    }
    return classLoaderToUse.loadClass(name);
  }
Example #4
0
  /**
   * Given an provider interface name register instance classes. The class path is searched for
   * service provider lists as described by the JAR File specification for service providers
   *
   * @param interfaceName name of the implemented interface.
   * @return boolean true if at least one instance class could be registered with this factory.
   */
  protected boolean registerProviders(String interfaceName) {
    ClassLoader loader = getClass().getClassLoader();
    boolean registeredSomething = false;

    try {
      Enumeration<URL> providerLists = loader.getResources("META-INF/services/" + interfaceName);

      while (providerLists.hasMoreElements()) {
        try {
          URI providerList = providerLists.nextElement().toURI();

          registeredSomething |= registerFromFile(providerList);
        } catch (URISyntaxException badURI) {
          if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
            LOG.log(Level.WARNING, "Failed to convert service URI", badURI);
          }
        }
      }
    } catch (IOException ex) {
      if (Logging.SHOW_WARNING && LOG.isLoggable(Level.WARNING)) {
        LOG.log(Level.WARNING, "Failed to locate provider lists", ex);
      }
    }

    return registeredSomething;
  }
 /** Copy one predefined Template from resources to a file. */
 static void migrateTemplate(String template) throws IOException {
   File dir = TemplateDatabase.TemplateDir;
   File file = new File(dir, template);
   ClassLoader loader = TemplateDeployer.class.getClassLoader();
   InputStream in = loader.getResourceAsStream("com/lightcrafts/templates/resources/" + template);
   if (in == null) {
     throw new IOException("Couldn't find resource for template " + template);
   }
   OutputStream out = new FileOutputStream(file);
   byte[] buffer = new byte[10000]; // bigger than any template
   try {
     int count;
     do {
       count = in.read(buffer);
       if (count > 0) {
         out.write(buffer, 0, count);
       }
     } while (count >= 0);
   } finally {
     try {
       out.close();
     } catch (IOException e) {
       System.out.println("Failed to close template " + template);
     }
   }
 }
Example #6
0
  public String readFileFromJAR(String filepath) {

    String out = "";

    try {

      // setup input buffer
      ClassLoader cl = this.getClass().getClassLoader();
      InputStream instream = cl.getResourceAsStream(filepath);
      BufferedReader filereader = new BufferedReader(new InputStreamReader(instream));

      // read lines
      String line = filereader.readLine();
      while (line != null) {
        out += "\n" + line;
        line = filereader.readLine();
      }

      filereader.close();

    } catch (Exception e) {
      // e.printStackTrace();
    }

    return out;
  }
Example #7
0
  /**
   * Executes a query.
   *
   * @param query query to be executed
   * @return list of serialized result items
   * @throws IOException error during query execution
   */
  private StringList execute(final WebDAVQuery query) throws IOException {
    final ClassLoader cl = getClass().getClassLoader();
    final InputStream s = cl.getResourceAsStream(FILE);
    if (s == null) throw new IOException("WebDAV module not found");
    final byte[] module = new IOStream(s).read();

    final QueryProcessor qp = new QueryProcessor(query.toString(), http.context());
    try {
      for (final Entry<String, Object> entry : query.entries()) {
        qp.bind(entry.getKey(), entry.getValue());
      }
      qp.ctx.parseLibrary(string(module), FILE, qp.sc);

      final Result r = qp.execute();
      final int n = (int) r.size();
      final StringList items = new StringList(n);
      for (int i = 0; i < n; i++) {
        final ArrayOutput ao = new ArrayOutput();
        r.serialize(Serializer.get(ao), 0);
        items.add(ao.toString());
      }
      return items;
    } catch (final QueryException ex) {
      throw new BaseXException(ex);
    } catch (final Exception ex) {
      Util.debug(ex);
      throw new BaseXException(ex);
    } finally {
      qp.close();
    }
  }
  /**
   * Load from resource. url = ZeppelinConfiguration.class.getResource(ZEPPELIN_SITE_XML);
   *
   * @throws ConfigurationException
   */
  public static ZeppelinConfiguration create() {
    if (conf != null) {
      return conf;
    }

    ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
    URL url;

    url = ZeppelinConfiguration.class.getResource(ZEPPELIN_SITE_XML);
    if (url == null) {
      ClassLoader cl = ZeppelinConfiguration.class.getClassLoader();
      if (cl != null) {
        url = cl.getResource(ZEPPELIN_SITE_XML);
      }
    }
    if (url == null) {
      url = classLoader.getResource(ZEPPELIN_SITE_XML);
    }

    if (url == null) {
      LOG.warn("Failed to load configuration, proceeding with a default");
      conf = new ZeppelinConfiguration();
    } else {
      try {
        LOG.info("Load configuration from " + url);
        conf = new ZeppelinConfiguration(url);
      } catch (ConfigurationException e) {
        LOG.warn("Failed to load configuration from " + url + " proceeding with a default", e);
        conf = new ZeppelinConfiguration();
      }
    }

    return conf;
  }
Example #9
0
  @Override
  protected synchronized Class<?> loadClass(String className, boolean resolve)
      throws ClassNotFoundException {
    Class<?> c = null;
    try {
      try {
        ClassLoader cl = getParent();
        c = cl.loadClass(className);
        if (c != null) return c;
      } catch (ClassNotFoundException e) {
        /* let the next one handle this */
      }

      try {
        c = findJarClass(className);
        if (c != null) return c;
      } catch (Exception e) {
        System.out.println(
            "Error loading class ["
                + className
                + "] from jars in war file ["
                + outerFile.getName()
                + "]: "
                + e.toString());
        e.printStackTrace();
      }

      throw new ClassNotFoundException("Class [" + className + "] not found");
    } finally {
      if (c != null && resolve) {
        resolveClass(c);
      }
    }
  }
Example #10
0
  /** @param frameName title name for frame */
  public ShowSavedResults(String frameName) {
    super(frameName);
    aboutRes =
        new JTextArea(
            "Select a result set from"
                + "\nthose listed and details"
                + "\nof that analysis will be"
                + "\nshown here. Then you can"
                + "\neither delete or view those"
                + "\nresults using the buttons below.");
    aboutScroll = new JScrollPane(aboutRes);
    ss = new JScrollPane(sp);
    ss.getViewport().setBackground(Color.white);

    //  resMenu.setLayout(new FlowLayout(FlowLayout.LEFT,10,1));
    ClassLoader cl = getClass().getClassLoader();
    rfii = new ImageIcon(cl.getResource("images/Refresh_button.gif"));

    // results status
    resButtonStatus = new JPanel(new BorderLayout());
    Border loweredbevel = BorderFactory.createLoweredBevelBorder();
    Border raisedbevel = BorderFactory.createRaisedBevelBorder();
    Border compound = BorderFactory.createCompoundBorder(raisedbevel, loweredbevel);
    statusField = new JTextField();
    statusField.setBorder(compound);
    statusField.setEditable(false);
  }
 @Test
 public void testResourceLookupWithPrefixAfterLoading() throws Exception {
   assertThat(classLoader.loadClass(Foo.class.getName()).getClassLoader(), is(classLoader));
   assertThat(
       classLoader.getResource("/" + Foo.class.getName().replace('.', '/') + CLASS_FILE),
       expectedResourceLookup ? notNullValue(URL.class) : nullValue(URL.class));
 }
 private ClassLoader getRootLoader() {
   ClassLoader ret;
   for (ret = this.getClass().getClassLoader();
       ret != null && ret.getParent() != null;
       ret = ret.getParent()) {}
   return ret;
 }
Example #13
0
 public <T> List<Class<T>> getInterfaceImplementations(Class<T> interfaceClass, File f)
     throws IOException, ClassNotFoundException {
   ArrayList<Class<T>> list = new ArrayList<>();
   List<String> classes = null;
   if (f.isDirectory()) {
     classes = getClassesFromDir(f);
   } else {
     classes = getClassesFromJar(f);
   }
   URL url = f.toURI().toURL();
   ClassLoader cl = new URLClassLoader(new URL[] {url}, this.getClass().getClassLoader());
   for (String klazz : classes) {
     try {
       Class<?> c = cl.loadClass(klazz);
       if (interfaceClass.isAssignableFrom(c) && !Modifier.isAbstract(c.getModifiers())) {
         list.add((Class<T>) c);
       }
     } catch (Throwable t) {
       LOGGER.warn(
           String.format(
               "Error checking if class %s from file %s is implementing %s: %s",
               klazz, f, interfaceClass.getName(), t.getMessage()));
     }
   }
   return list;
 }
  public void testCreateContextWithPathAndBindings() throws Exception {
    String oxmString = "org/eclipse/persistence/testing/jaxb/jaxbcontext/eclipselink-oxm.xml";
    InputStream oxm = ClassLoader.getSystemClassLoader().getResourceAsStream(oxmString);

    Map<String, Object> props = new HashMap<String, Object>();
    props.put(JAXBContextFactory.ECLIPSELINK_OXM_XML_KEY, oxm);

    // Specify some other, unrelated context path -- we want to ensure that we don't fail
    // due to lack of ObjectFactory/jaxb.index
    JAXBContext ctx =
        JAXBContext.newInstance(
            "org.eclipse.persistence.testing.oxm.jaxb", ClassLoader.getSystemClassLoader(), props);

    Employee e = new Employee();
    e.id = 6;
    e.name = "Jeeves Sobs";
    e.put("tag", "tag-value");

    Document marshalDoc = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();

    Marshaller m = ctx.createMarshaller();
    m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
    m.marshal(e, marshalDoc);

    // Make sure OXM was picked up, "tag" property should have been added.
    Employee e2 = (Employee) ctx.createUnmarshaller().unmarshal(marshalDoc);
    assertEquals(
        "OXM file was not processed during context creation.", e.get("tag"), e2.get("tag"));
  }
Example #15
0
  /**
   * Get classes in given package and subpackages, accessible from the context class loader
   *
   * @param packageName The base package
   * @return The classes
   * @throws ClassNotFoundException
   * @throws IOException
   */
  protected static List<Class> getClasses(String packageName)
      throws ClassNotFoundException, IOException {

    ClassLoader classLoader = Thread.currentThread().getContextClassLoader();

    assert classLoader != null;

    String path = packageName.replace('.', '/');
    Enumeration<URL> resources = classLoader.getResources(path);
    List<File> dirs = new ArrayList<File>();

    while (resources.hasMoreElements()) {

      URL resource = resources.nextElement();

      dirs.add(new File(resource.getFile()));
    }

    List<Class> classList = new ArrayList<Class>();

    for (File directory : dirs) {

      classList.addAll(findClasses(directory, packageName));
    }

    return classList;
  }
  /**
   * There is a possible case that methods of particular object should be executed with classpath
   * different from the one implied by the current class' class loader. External system offers
   * {@link ParametersEnhancer#enhanceLocalProcessing(List)} method for defining that custom
   * classpath.
   *
   * <p>It's also possible that particular implementation of {@link ParametersEnhancer} is compiled
   * using dependency to classes which are provided by the {@link
   * ParametersEnhancer#enhanceLocalProcessing(List) expanded classpath}. E.g. a class <code>'A'
   * </code> might use method of class <code>'B'</code> and 'A' is located at the current
   * (system/plugin) classpath but <code>'B'</code> is not. We need to reload <code>'A'</code> using
   * its expanded classpath then, i.e. create new class loaded with that expanded classpath and load
   * <code>'A'</code> by it.
   *
   * <p>This method allows to do that.
   *
   * @param clazz custom classpath-aware class which instance should be created (is assumed to have
   *     a no-args constructor)
   * @param <T> target type
   * @return newly created instance of the given class loaded by custom classpath-aware loader
   * @throws IllegalAccessException as defined by reflection processing
   * @throws InstantiationException as defined by reflection processing
   * @throws NoSuchMethodException as defined by reflection processing
   * @throws InvocationTargetException as defined by reflection processing
   * @throws ClassNotFoundException as defined by reflection processing
   */
  @NotNull
  public static <T extends ParametersEnhancer> T reloadIfNecessary(@NotNull final Class<T> clazz)
      throws IllegalAccessException, InstantiationException, NoSuchMethodException,
          InvocationTargetException, ClassNotFoundException {
    T instance = clazz.newInstance();
    List<URL> urls = ContainerUtilRt.newArrayList();
    instance.enhanceLocalProcessing(urls);
    if (urls.isEmpty()) {
      return instance;
    }

    final ClassLoader baseLoader = clazz.getClassLoader();
    Method method = baseLoader.getClass().getMethod("getUrls");
    if (method != null) {
      //noinspection unchecked
      urls.addAll((Collection<? extends URL>) method.invoke(baseLoader));
    }
    UrlClassLoader loader =
        new UrlClassLoader(UrlClassLoader.build().urls(urls).parent(baseLoader.getParent())) {
          @Override
          protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
            if (name.equals(clazz.getName())) {
              return super.loadClass(name, resolve);
            } else {
              try {
                return baseLoader.loadClass(name);
              } catch (ClassNotFoundException e) {
                return super.loadClass(name, resolve);
              }
            }
          }
        };
    //noinspection unchecked
    return (T) loader.loadClass(clazz.getName()).newInstance();
  }
Example #17
0
  /** Install Add and Remove Buttons into the toolbar */
  private void installAddRemovePointButtons() {
    URL imgURL = ClassLoader.getSystemResource("ch/tbe/pics/plus.gif");
    ImageIcon plus = new ImageIcon(imgURL);
    imgURL = ClassLoader.getSystemResource("ch/tbe/pics/minus.gif");
    ImageIcon minus = new ImageIcon(imgURL);
    add = new JButton(plus);
    rem = new JButton(minus);
    add.setToolTipText(workingViewLabels.getString("plus"));
    rem.setToolTipText(workingViewLabels.getString("minus"));
    add.addActionListener(
        new ActionListener() {
          public void actionPerformed(ActionEvent e) {
            WorkingView.this.addRemovePoint(true);
          }
        });
    rem.addActionListener(
        new ActionListener() {
          public void actionPerformed(ActionEvent e) {
            WorkingView.this.addRemovePoint(false);
          }
        });

    add.setContentAreaFilled(false);
    add.setBorderPainted(false);
    rem.setContentAreaFilled(false);
    rem.setBorderPainted(false);
    toolbar.add(add);
    toolbar.add(rem);
  }
Example #18
0
 public static Icon getIcon(String iconName) {
   ClassLoader cl = Thread.currentThread().getContextClassLoader();
   URL url = cl.getResource("test/check/icons/" + iconName + ".gif");
   if (url != null) return new ImageIcon(url);
   url = cl.getResource("test/check/icons/" + iconName + ".png");
   if (url != null) return new ImageIcon(url);
   return null;
 }
Example #19
0
 @Override
 public String call(Integer i) throws Exception {
   ClassLoader ccl = Thread.currentThread().getContextClassLoader();
   InputStream in = ccl.getResourceAsStream("test.resource");
   byte[] bytes = ByteStreams.toByteArray(in);
   in.close();
   return new String(bytes, 0, bytes.length, "UTF-8");
 }
Example #20
0
 protected File[] getMappingFiles(String matchingsDir, String dir, String exclusionFile) {
   URL exclusionFileUrl = ClassLoader.getSystemResource(matchingsDir + exclusionFile);
   File folder = new File(ClassLoader.getSystemResource(matchingsDir + dir).getFile());
   if (exclusionFileUrl == null) return folder.listFiles();
   File incl = new File(exclusionFileUrl.getFile());
   MyFilenameFilter filter = new MyFilenameFilter(incl);
   return folder.listFiles(filter);
 }
 private String getCsvFilePath() {
   ClassLoader classLoader = getClass().getClassLoader();
   URL csvUrl = classLoader.getResource("category_mapping.csv");
   if (csvUrl == null || csvUrl.getFile() == null) {
     throw new RuntimeException("Bad path to category_mapping.csv");
   }
   return csvUrl.getFile();
 }
Example #22
0
 public ViewportRenderer() {
   ClassLoader loader = getClass().getClassLoader();
   surfaceIcon =
       new ImageIcon(loader.getResource(IMAGE_BASE + "/vrjuggler-surface-viewport.png"));
   simIcon = new ImageIcon(loader.getResource(IMAGE_BASE + "/vrjuggler-sim-viewport.png"));
   scaledSurfaceIcon = new ImageIcon();
   scaledSimIcon = new ImageIcon();
 }
 private static Class<?> loadClass(String className) {
   try {
     ClassLoader cl = Thread.currentThread().getContextClassLoader();
     return cl.loadClass(className.replace('/', '.'));
   } catch (ClassNotFoundException e) {
     throw new RuntimeException(e);
   }
 }
Example #24
0
 Class<?> getPluginClass(String packageName, String className)
     throws NameNotFoundException, ClassNotFoundException {
   Context pluginContext =
       this.mAppContext.createPackageContext(
           packageName, Context.CONTEXT_INCLUDE_CODE | Context.CONTEXT_IGNORE_SECURITY);
   ClassLoader pluginCL = pluginContext.getClassLoader();
   return pluginCL.loadClass(className);
 }
  /**
   * Create MBean for Object. Attempts to create an MBean for the object by searching the package
   * and class name space. For example an object of the type
   *
   * <PRE>
   *   class com.acme.MyClass extends com.acme.util.BaseClass
   * </PRE>
   *
   * Then this method would look for the following classes:
   *
   * <UL>
   *   <LI>com.acme.MyClassMBean
   *   <LI>com.acme.jmx.MyClassMBean
   *   <LI>com.acme.util.BaseClassMBean
   *   <LI>com.acme.util.jmx.BaseClassMBean
   * </UL>
   *
   * @param o The object
   * @return A new instance of an MBean for the object or null.
   */
  public static ModelMBean mbeanFor(Object o) {
    try {
      Class oClass = o.getClass();
      ClassLoader loader = oClass.getClassLoader();

      ModelMBean mbean = null;
      boolean jmx = false;
      Class[] interfaces = null;
      int i = 0;

      while (mbean == null && oClass != null) {
        Class focus = interfaces == null ? oClass : interfaces[i];
        String pName = focus.getPackage().getName();
        String cName = focus.getName().substring(pName.length() + 1);
        String mName = pName + (jmx ? ".jmx." : ".") + cName + "MBean";

        try {
          Class mClass = loader.loadClass(mName);
          if (log.isTraceEnabled()) log.trace("mbeanFor " + o + " mClass=" + mClass);
          mbean = (ModelMBean) mClass.newInstance();
          mbean.setManagedResource(o, "objectReference");
          if (log.isDebugEnabled()) log.debug("mbeanFor " + o + " is " + mbean);
          return mbean;
        } catch (ClassNotFoundException e) {
          if (e.toString().endsWith("MBean")) {
            if (log.isTraceEnabled()) log.trace(e.toString());
          } else log.warn(LogSupport.EXCEPTION, e);
        } catch (Error e) {
          log.warn(LogSupport.EXCEPTION, e);
          mbean = null;
        } catch (Exception e) {
          log.warn(LogSupport.EXCEPTION, e);
          mbean = null;
        }

        if (jmx) {
          if (interfaces != null) {
            i++;
            if (i >= interfaces.length) {
              interfaces = null;
              oClass = oClass.getSuperclass();
            }
          } else {
            interfaces = oClass.getInterfaces();
            i = 0;
            if (interfaces == null || interfaces.length == 0) {
              interfaces = null;
              oClass = oClass.getSuperclass();
            }
          }
        }
        jmx = !jmx;
      }
    } catch (Exception e) {
      LogSupport.ignore(log, e);
    }
    return null;
  }
Example #26
0
    private void load(File jarFile) {
      ClassLoader loader;
      try {
        loader =
            URLClassLoader.newInstance(
                new URL[] {jarFile.toURI().toURL()}, getClass().getClassLoader());
      } catch (MalformedURLException e) {
        Application.LOGGER.error(
            "Error while loading plugin file - " + jarFile.getAbsolutePath(), e);
        return;
      }

      InputStream stream = loader.getResourceAsStream(MANIFEST_FILE);
      Properties properties = new Properties();
      try {
        properties.load(stream);
      } catch (IOException e) {
        Application.LOGGER.error(
            "Manifest file - "
                + MANIFEST_FILE
                + " not found in the plugin jar - "
                + jarFile.getAbsolutePath(),
            e);
        return;
      }

      String pluginClassName = properties.getProperty("plugin.class");
      if (!properties.containsKey("plugin.class")) {
        Application.LOGGER.error(
            "plugin.class not defined in the manifest file in the plugin jar - "
                + jarFile.getAbsolutePath());
        return;
      }

      Class<?> clazz;
      try {
        clazz = Class.forName(pluginClassName, true, loader);
      } catch (ClassNotFoundException e) {
        Application.LOGGER.error(
            "Plugin main class - "
                + pluginClassName
                + " defined in manifest not found in the plugin jar - "
                + jarFile.getAbsolutePath(),
            e);
        return;
      }

      if (!Plugin.class.isAssignableFrom(clazz)) {
        Application.LOGGER.error(
            "Plugin class - "
                + clazz
                + " is not a Plugin, in the plugin jar - "
                + jarFile.getAbsolutePath());
      }

      load((Class<? extends Plugin>) clazz, properties);
    }
 @Test
 public void testLoading() throws Exception {
   Class<?> type = classLoader.loadClass(Foo.class.getName());
   assertThat(type.getClassLoader(), is(classLoader));
   assertEquals(classLoader.loadClass(Foo.class.getName()), type);
   assertNotEquals(Foo.class, type);
   assertThat(type.getPackage(), notNullValue(Package.class));
   assertThat(type.getPackage(), is(Foo.class.getPackage()));
 }
Example #28
0
  // {{{ loadFromParent() method
  private Class loadFromParent(String clazz) throws ClassNotFoundException {
    Class cls;

    ClassLoader parentLoader = getClass().getClassLoader();
    if (parentLoader != null) cls = parentLoader.loadClass(clazz);
    else cls = findSystemClass(clazz);

    return cls;
  } // }}}
Example #29
0
 private static InputStream getAsInputStreamFromClassLoader(String filename) {
   ClassLoader cl = Thread.currentThread().getContextClassLoader();
   InputStream is = cl == null ? null : cl.getResourceAsStream(filename);
   if (is == null) {
     // check system class loader
     is = XmlConfigurator.class.getClassLoader().getResourceAsStream(filename);
   }
   return is;
 }
Example #30
0
  /**
   * return a checker object which can be used to retrieve the super and interfaces of a class from
   * its name and classloader, identifying it from the Class instance if it the class is already
   * loaded otherwise loading the corresponding bytecode and parsing it to obtain the relevant
   * details.
   *
   * @param name the name of the superclass being checked
   * @param baseLoader the class loader of the subclass's bytecode
   * @return the requisite checker or null if the class does not need to be checked or cannot be
   *     loaded
   */
  public org.jboss.byteman.agent.check.ClassChecker getClassChecker(
      String name, ClassLoader baseLoader) {
    // we would like to just do this
    // Class superClazz = baseLoader.loadClass(name)
    // and then access the details using methods of Class
    // however, this fails because we are in the middle of transforming the subclass and the
    // classloader
    // may not have loaded the super. if we force a load now then transforms will not be performed
    // on
    // the super class. this may cause us to miss the chance to apply rule injection into the super

    ClassLoader loader = baseLoader;
    Class clazz = loadCache.lookupClass(name, loader);

    if (clazz != null) {
      return new org.jboss.byteman.agent.check.LoadedClassChecker(clazz);
    }

    // ok, instead try loading the bytecode as a resource - user-defined loaders may not support
    // this but
    // at least the JVM system and boot loaders should

    String resourceName = name.replace('.', '/') + ".class";
    try {
      InputStream is;
      if (baseLoader != null) {
        is = baseLoader.getResourceAsStream(resourceName);
      } else {
        is = ClassLoader.getSystemClassLoader().getResourceAsStream(resourceName);
      }
      if (is != null) {
        int length = is.available();
        int count = 0;
        byte[] bytecode = new byte[length];
        while (count < length) {
          int read = is.read(bytecode, count, length - count);
          if (read < 0) {
            throw new IOException("unexpected end of file");
          }
          count += read;
        }
        return new org.jboss.byteman.agent.check.BytecodeChecker(bytecode);
      } else {
        // throw new IOException("unable to load bytecode for for class " + name);
        if (isVerbose()) {
          System.out.println(
              "Transformer.getClassChecker : unable to load bytecode for for class " + name);
        }
        return null;
      }
    } catch (IOException e) {
      // log the exception and return null
      e.printStackTrace();
      return null;
    }
  }