/** * 获取版本号 * * @param clazz * @param defaultVersion * @return */ public static String getVersion(Class clazz, String defaultVersion) { try { // 首先查找MANIFEST.MF规范中的版本号 String version = clazz.getPackage().getImplementationVersion(); if (version == null || version.length() == 0) { version = clazz.getPackage().getSpecificationVersion(); } if (version == null || version.length() == 0) { // 如果MANIFEST.MF规范中没有版本号,基于jar包名获取版本号 String file = clazz.getProtectionDomain().getCodeSource().getLocation().getFile(); if (file != null && file.length() > 0 && file.endsWith(".jar")) { Matcher matcher = VERSION_PATTERN.matcher(file); while (matcher.find() && matcher.groupCount() > 0) { version = matcher.group(1); } } } // 返回版本号,如果为空返回缺省版本号 return version == null || version.length() == 0 ? defaultVersion : version; } catch (Throwable e) { // 防御性容错 // 忽略异常,返回缺省版本号 logger.error(e.getMessage(), e); return defaultVersion; } }
public static ClassReader readClass(Class<?> theClass) throws IOException, BenignClassReadException { if (theClass.isArray()) { throw new BenignClassReadException(theClass.getName() + " is an array"); } if (Proxy.isProxyClass(theClass)) { throw new BenignClassReadException(theClass.getName() + " is a Proxy class"); } if (isRMIStubOrProxy(theClass)) { throw new BenignClassReadException(theClass.getName() + " is an RMI Stub or Proxy class"); } if (theClass.getName().startsWith("sun.reflect.")) { throw new BenignClassReadException(theClass.getName() + " is a reflection class"); } if (isJAXBClass(theClass)) { throw new BenignClassReadException(theClass.getName() + " is a JAXB accessor class"); } if ((theClass.getProtectionDomain().getCodeSource() != null) && (theClass.getProtectionDomain().getCodeSource().getLocation() == null)) { throw new BenignClassReadException(theClass.getName() + " is a generated class"); } URL resource = getClassResource(theClass.getClassLoader(), Type.getInternalName(theClass)); if (resource == null) { ClassReader reader = ServiceFactory.getClassTransformerService() .getContextManager() .getClassWeaverService() .getClassReader(theClass); if (reader != null) { return reader; } } return getClassReaderFromResource(theClass.getName(), resource); }
public static LinkedHashSet<String> findJars(LogicalPlan dag, Class<?>[] defaultClasses) { List<Class<?>> jarClasses = new ArrayList<Class<?>>(); for (String className : dag.getClassNames()) { try { Class<?> clazz = Thread.currentThread().getContextClassLoader().loadClass(className); jarClasses.add(clazz); } catch (ClassNotFoundException e) { throw new IllegalArgumentException("Failed to load class " + className, e); } } for (Class<?> clazz : Lists.newArrayList(jarClasses)) { // process class and super classes (super does not require deploy annotation) for (Class<?> c = clazz; c != Object.class && c != null; c = c.getSuperclass()) { // LOG.debug("checking " + c); jarClasses.add(c); jarClasses.addAll(Arrays.asList(c.getInterfaces())); } } jarClasses.addAll(Arrays.asList(defaultClasses)); if (dag.isDebug()) { LOG.debug("Deploy dependencies: {}", jarClasses); } LinkedHashSet<String> localJarFiles = new LinkedHashSet<String>(); // avoid duplicates HashMap<String, String> sourceToJar = new HashMap<String, String>(); for (Class<?> jarClass : jarClasses) { if (jarClass.getProtectionDomain().getCodeSource() == null) { // system class continue; } String sourceLocation = jarClass.getProtectionDomain().getCodeSource().getLocation().toString(); String jar = sourceToJar.get(sourceLocation); if (jar == null) { // don't create jar file from folders multiple times jar = JarFinder.getJar(jarClass); sourceToJar.put(sourceLocation, jar); LOG.debug("added sourceLocation {} as {}", sourceLocation, jar); } if (jar == null) { throw new AssertionError("Cannot resolve jar file for " + jarClass); } localJarFiles.add(jar); } String libJarsPath = dag.getValue(LogicalPlan.LIBRARY_JARS); if (!StringUtils.isEmpty(libJarsPath)) { String[] libJars = StringUtils.splitByWholeSeparator(libJarsPath, LIB_JARS_SEP); localJarFiles.addAll(Arrays.asList(libJars)); } LOG.info("Local jar file dependencies: " + localJarFiles); return localJarFiles; }
/** * From http://stackoverflow.com/questions/320542/how-to-get-the-path-of-a- running-jar-file * * <p>Used to get all classes in the specified package. * * @param caller The class that requests * @param pckgname The package name. * @return The classes contained by the specified package. * @throws ClassNotFoundException */ private static Class<?>[] getClasses(Class<?> caller, String pckgname) throws ClassNotFoundException { String source = caller.getProtectionDomain().getCodeSource().getLocation().getPath(); if (source.toLowerCase().endsWith(".jar")) try { return getClassesFromJARFile( caller.getProtectionDomain().getCodeSource().getLocation().toURI(), pckgname); } catch (URISyntaxException e) { throw new AssertionError(e); } else return getClassesLocal(pckgname); }
public Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException { log.debug("calling loadClass boolean with class " + name + ". I am " + this); // reverse the logic. try myself first, then delgate: Class c = findLoadedClass(name); if (c == null) { try { c = findClass(name); log.debug("Yes! classloader" + this + " did have " + name); } catch (ClassNotFoundException cnfe) { log.debug("No! classloader" + this + " didn't have " + name + " delegating to parent!"); c = super.loadClass(name, resolve); } } if (resolve) { resolveClass(c); } log.debug( "found class " + name + ". I am " + this + " it's classloader is " + c.getClassLoader() + " it's codesource it " + c.getProtectionDomain().getCodeSource()); return c; }
public ClassMeta getClassInfo(Class<?> cls) { final Package pkg = cls.getPackage(); URL loadedFrom = null; try { loadedFrom = cls.getProtectionDomain().getCodeSource().getLocation(); } catch (Throwable t) { Log.warn(t, "Failed to get source for %s", cls); } final API apiAnnotation = pkg.getAnnotation(API.class); final ApiInfo apiInfo = apiAnnotation != null ? new ApiInfo(apiAnnotation) : null; Map<File, Set<String>> mods = Maps.newHashMap(); for (ModCandidate candidate : table.getCandidatesFor(pkg.getName())) { if (!candidate.getClassList().contains(cls.getName().replace('.', '/'))) continue; final File candidateFile = candidate.getModContainer(); Set<String> modIds = Sets.newHashSet(); mods.put(candidateFile, modIds); for (ModContainer mod : candidate.getContainedMods()) modIds.add(mod.getModId()); } return new ClassMeta(cls, loadedFrom, apiInfo, mods); }
public static ClassLoader newClassLoader(final Class... userClasses) throws Exception { Set<URL> userClassUrls = new HashSet<>(); for (Class anyUserClass : userClasses) { ProtectionDomain protectionDomain = anyUserClass.getProtectionDomain(); CodeSource codeSource = protectionDomain.getCodeSource(); URL classLocation = codeSource.getLocation(); userClassUrls.add(classLocation); } StringTokenizer tokenString = new StringTokenizer(System.getProperty("java.class.path"), File.pathSeparator); String pathIgnore = System.getProperty("java.home"); if (pathIgnore == null) { pathIgnore = userClassUrls.iterator().next().toString(); } List<URL> urls = new ArrayList<>(); while (tokenString.hasMoreElements()) { String value = tokenString.nextToken(); URL itemLocation = new File(value).toURI().toURL(); if (!userClassUrls.contains(itemLocation) && itemLocation.toString().indexOf(pathIgnore) >= 0) { urls.add(itemLocation); } } URL[] urlArray = urls.toArray(new URL[urls.size()]); ClassLoader masterClassLoader = URLClassLoader.newInstance(urlArray, null); ClassLoader appClassLoader = URLClassLoader.newInstance(userClassUrls.toArray(new URL[0]), masterClassLoader); return appClassLoader; }
/** * Format a string buffer containing the Class, Interfaces, CodeSource, and ClassLoader * information for the given object clazz. * * @param clazz the Class * @param results, the buffer to write the info to */ public static void displayClassInfo(Class clazz, StringBuffer results) { // Print out some codebase info for the ProbeHome ClassLoader cl = clazz.getClassLoader(); results.append("\n" + clazz.getName() + ".ClassLoader=" + cl); ClassLoader parent = cl; while (parent != null) { results.append("\n.." + parent); URL[] urls = getClassLoaderURLs(parent); int length = urls != null ? urls.length : 0; for (int u = 0; u < length; u++) { results.append("\n...." + urls[u]); } if (parent != null) parent = parent.getParent(); } CodeSource clazzCS = clazz.getProtectionDomain().getCodeSource(); if (clazzCS != null) results.append("\n++++CodeSource: " + clazzCS); else results.append("\n++++Null CodeSource"); results.append("\nImplemented Interfaces:"); Class[] ifaces = clazz.getInterfaces(); for (int i = 0; i < ifaces.length; i++) { results.append("\n++" + ifaces[i]); ClassLoader loader = ifaces[i].getClassLoader(); results.append("\n++++ClassLoader: " + loader); ProtectionDomain pd = ifaces[i].getProtectionDomain(); CodeSource cs = pd.getCodeSource(); if (cs != null) results.append("\n++++CodeSource: " + cs); else results.append("\n++++Null CodeSource"); } }
/** * @param args * @throws IOException */ public static void main(String[] args) throws IOException { // TODO Auto-generated method stub MyClassLocation myLocation = new MyClassLocation(); File file = myLocation.getClassLocationFile(Aladin.class); System.out.println("Result form my location: " + file); Class theClass = Aladin.class; String classResourceName = theClass.getName().replace('.', '/') + ".class"; URL resource = theClass.getResource("/" + classResourceName); System.out.println("resource: " + resource); URL codeSource = theClass.getProtectionDomain().getCodeSource().getLocation(); System.out.println("code source: " + codeSource); // it returns the path to the class that is running System.out.println( "Class loader 1: " + ClassLoader.getSystemClassLoader().getResource(".").getPath()); System.out.println( "Class loader 2: " + ClassLoader.getSystemClassLoader().getResource(classResourceName).getPath()); resource = Aladin.class.getClassLoader().getResource("/" + classResourceName); System.out.println("Class loader 3: " + resource); }
public static String getSourceLocation(final Class<?> cls) { String exMsg = null; java.security.CodeSource codeSource = null; try { codeSource = cls.getProtectionDomain().getCodeSource(); } catch (final Exception e) { exMsg = e.toString(); } final URL classURL = codeSource == null ? getSourceURL(cls) : codeSource.getLocation(); if (classURL == null) { return cls.getName() + ": (missing codeSource and classLoader)"; } final String path = classURL.getPath(); final File file = new File(path); if (!file.isFile()) { return cls.getName() + ": " + path + " (not a file)" + (exMsg == null ? "" : "; " + exMsg); } return String.format( "%s (SN: %s): %s (MD5: %s)%s", cls.getName(), getSerialVersionUID(cls), path, MD5Kit.md5sum(file), exMsg == null ? "" : "; " + exMsg); }
/** * 获取类的class文件位置的URL * * @param cls * @return */ private static URL getClassLocationURL(final Class cls) { if (cls == null) throw new IllegalArgumentException("null input: cls"); URL result = null; final String clsAsResource = cls.getName().replace('.', '/').concat(".class"); final ProtectionDomain pd = cls.getProtectionDomain(); if (pd != null) { final CodeSource cs = pd.getCodeSource(); if (cs != null) result = cs.getLocation(); if (result != null) { if ("file".equals(result.getProtocol())) { try { if (result.toExternalForm().endsWith(".jar") || result.toExternalForm().endsWith(".zip")) result = new URL( "jar:".concat(result.toExternalForm()).concat("!/").concat(clsAsResource)); else if (new File(result.getFile()).isDirectory()) result = new URL(result, clsAsResource); } catch (MalformedURLException ignore) { } } } } if (result == null) { final ClassLoader clsLoader = cls.getClassLoader(); result = clsLoader != null ? clsLoader.getResource(clsAsResource) : ClassLoader.getSystemResource(clsAsResource); } return result; }
private static String getUnmigrationCommandLine(File jenkinsHome) { StringBuilder cp = new StringBuilder(); for (Class<?> c : new Class<?>[] { RunIdMigrator.class, /* TODO how to calculate transitive dependencies automatically? */ Charsets.class, WriterOutputStream.class, BuildException.class, FastDateFormat.class }) { URL location = c.getProtectionDomain().getCodeSource().getLocation(); String locationS = location.toString(); if (location.getProtocol().equals("file")) { try { locationS = new File(location.toURI()).getAbsolutePath(); } catch (URISyntaxException x) { // never mind } } if (cp.length() > 0) { cp.append(File.pathSeparator); } cp.append(locationS); } return String.format( "java -classpath \"%s\" %s \"%s\"", cp, RunIdMigrator.class.getName(), jenkinsHome); }
public URL locateCodeSource(Class<?> clz) { if (clz == null) { throw new IllegalArgumentException("null class"); } ProtectionDomain protectionDomain = null; try { protectionDomain = clz.getProtectionDomain(); } catch (SecurityException e) { // got security error if (reportErrorNoPermission) { throw e; } else { return null; } } if (protectionDomain != null && protectionDomain.getCodeSource() != null) { return protectionDomain.getCodeSource().getLocation(); } if (clz.getClassLoader() == null) { // bootstrap loader String name = Util.resolveName(clz.getName()); URL resourceURL = Util.getDummyLoader().getResource(name); return Util.extractBaseURL(resourceURL, name); } return null; }
public TestResourceLoaderBuilder addClass(final Class<?> aClass) throws Exception { final ClassSpec classSpec = new ClassSpec(); classSpec.setCodeSource(aClass.getProtectionDomain().getCodeSource()); final byte[] classBytes = getClassBytes(aClass); classSpec.setBytes(classBytes); addClassSpec(aClass.getName(), classSpec); return this; }
private static String getSourcePathFromClass(Class<?> containedClass) { File file = new File(containedClass.getProtectionDomain().getCodeSource().getLocation().getPath()); if (!file.isDirectory() && file.getName().endsWith(".class")) { String name = containedClass.getName(); StringTokenizer tokenizer = new StringTokenizer(name, "."); while (tokenizer.hasMoreTokens()) { tokenizer.nextElement(); file = file.getParentFile(); } return file.getPath(); } else { return containedClass.getProtectionDomain().getCodeSource().getLocation().getPath(); } }
/** * Generate the XSD file. First argument is directory where the XSD file should be placed (it will * be named radargun-{version}.xsd. */ public static void main(String[] args) { if (args.length < 1 || args[0] == null) throw new IllegalArgumentException("No schema location directory specified!"); for (Class<? extends Stage> stage : StageHelper.getStages().values()) { stages.put(stage, stage.getProtectionDomain().getCodeSource().getLocation().getPath()); } new ConfigSchemaGenerator().generate(args[0], String.format("radargun-%s.xsd", VERSION)); }
protected static File basedir(Class<?> clazz) { try { ProtectionDomain protectionDomain = clazz.getProtectionDomain(); return new File(new File(protectionDomain.getCodeSource().getLocation().getPath()), "../..") .getCanonicalFile(); } catch (IOException e) { return new File("."); } }
/** * Ce qui charge les natives * * @param c une classe */ private static void loadNatives(Class c) { final File jarFile = new File(c.getProtectionDomain().getCodeSource().getLocation().getPath()); final String path = "res/native/"; if (jarFile.isFile()) { try { // Run with JAR file final JarFile jar = new JarFile(jarFile); final Enumeration<JarEntry> entries = jar.entries(); // gives ALL entries in jar final String nativeFolderPath = jarFile.getParent() + "/native/"; final File nativeFolder = new File(nativeFolderPath); nativeFolder.delete(); nativeFolder.mkdir(); while (entries.hasMoreElements()) { final String name = entries.nextElement().getName(); if (name.startsWith(path)) { // filter according to the path Object temp = null; InputStream is = c.getResourceAsStream("/" + name); String nativeName = name.replace(path, ""); File nativePath = new File(nativeFolderPath + nativeName); if (!nativeName.isEmpty()) { System.out.println("Extracting: " + nativeName); OutputStream os = null; try { os = new FileOutputStream(nativePath); byte[] buffer = new byte[1024]; int length; while ((length = is.read(buffer)) > 0) { os.write(buffer, 0, length); } } finally { is.close(); os.close(); } } } } jar.close(); System.setProperty("org.lwjgl.librarypath", nativeFolderPath); } catch (IOException ex) { Logger.getLogger(c.getName()).log(Level.SEVERE, null, ex); } } else { try { System.setProperty( "org.lwjgl.librarypath", new File(c.getResource("/" + path).toURI()).getAbsolutePath()); } catch (URISyntaxException ex) { Logger.getLogger(c.getName()).log(Level.SEVERE, null, ex); } } }
/** * This static method uses a system property to find and instantiate (via a public constructor) a * provider spe- cific factory implementation class. The name of the provider specific factory * implementation class is obtained from the value of the system property, * * <pre> * javax.security.jacc.PolicyConfigurationFactory.provider. * </pre> * * @return the singleton instance of the provider specific PolicyConfigurationFactory * implementation class. * @throws SecurityException - when called by an AccessControlContext that has not been granted * the “setPolicy” SecurityPermission. * @throws ClassNotFoundException - when the class named by the system property could not be found * including because the value of the system property has not be set. * @throws PolicyContextException - if the implementation throws a checked exception that has not * been accounted for by the getPolicyConfigurationFactory method signature. The exception * thrown by the implementation class will be encapsulated (during construction) in the thrown * PolicyContextException */ public static PolicyConfigurationFactory getPolicyConfigurationFactory() throws ClassNotFoundException, PolicyContextException { // Validate the caller permission SecurityManager sm = System.getSecurityManager(); if (sm != null) sm.checkPermission(new SecurityPermission("setPolicy")); synchronized (PolicyConfigurationFactory.class) { if (factory == null) { String factoryName = null; Class<?> clazz = null; try { LoadAction action = new LoadAction(); try { clazz = AccessController.doPrivileged(action); factoryName = action.getName(); } catch (PrivilegedActionException ex) { factoryName = action.getName(); Exception e = ex.getException(); if (e instanceof ClassNotFoundException) throw (ClassNotFoundException) e; else throw new PolicyContextException("Failure during load of class: " + factoryName, e); } factory = (PolicyConfigurationFactory) clazz.newInstance(); } catch (ClassNotFoundException e) { String msg = "Failed to find PolicyConfigurationFactory : " + factoryName; throw new ClassNotFoundException(msg, e); } catch (IllegalAccessException e) { String msg = "Unable to access class : " + factoryName; throw new PolicyContextException(msg, e); } catch (InstantiationException e) { String msg = "Failed to create instance of: " + factoryName; throw new PolicyContextException(msg, e); } catch (ClassCastException e) { StringBuffer msg = new StringBuffer(factoryName + " Is not a PolicyConfigurationFactory, "); msg.append("PCF.class.CL: " + PolicyConfigurationFactory.class.getClassLoader()); msg.append( "\nPCF.class.CS: " + PolicyConfigurationFactory.class.getProtectionDomain().getCodeSource()); msg.append( "\nPCF.class.hash: " + System.identityHashCode(PolicyConfigurationFactory.class)); msg.append("\nclazz.CL: " + clazz.getClassLoader()); msg.append("\nclazz.CS: " + clazz.getProtectionDomain().getCodeSource()); msg.append("\nclazz.super.CL: " + clazz.getSuperclass().getClassLoader()); msg.append( "\nclazz.super.CS: " + clazz.getSuperclass().getProtectionDomain().getCodeSource()); msg.append("\nclazz.super.hash: " + System.identityHashCode(clazz.getSuperclass())); ClassCastException cce = new ClassCastException(msg.toString()); cce.initCause(e); throw cce; } } } return factory; }
/** * Get the protection domain for a class * * @param clazz the class * @return the protected domain or null if it doesn't have one */ private static final ProtectionDomain getProtectionDomain(final Class<?> clazz) { SecurityManager sm = System.getSecurityManager(); if (sm == null) return clazz.getProtectionDomain(); return AccessController.doPrivileged( new PrivilegedAction<ProtectionDomain>() { public ProtectionDomain run() { return clazz.getProtectionDomain(); } }); }
public void addClassDependency(Class<?> clazz) { CodeSource source = clazz.getProtectionDomain().getCodeSource(); if (source == null) return; Path absolutePath = null; try { absolutePath = Paths.get(source.getLocation().toURI()).toAbsolutePath(); } catch (URISyntaxException e) { e.printStackTrace(); } globalDependencies.add(absolutePath); }
/** * Returns JAR archive structure. * * @param jarClass any class within the JAR * @param allowedExtensions list of extension filters * @param allowedPackgages list of allowed packages * @param listener jar download listener * @return JAR archive structure */ public static JarStructure getJarStructure( final Class jarClass, final List<String> allowedExtensions, final List<String> allowedPackgages, final FileDownloadListener listener) { try { final CodeSource src = jarClass.getProtectionDomain().getCodeSource(); if (src != null) { // Creating structure // Source url final URL jarUrl = src.getLocation(); final URI uri = jarUrl.toURI(); // Source file final File jarFile; final String scheme = uri.getScheme(); if (scheme != null && scheme.equalsIgnoreCase("file")) { // Local jar-file jarFile = new File(uri); } else { // Remote jar-file jarFile = FileUtils.downloadFile( jarUrl.toString(), File.createTempFile("jar_file", ".tmp"), listener); } // Creating final JarEntry jarEntry = new JarEntry(JarEntryType.jarEntry, jarFile.getName()); final JarStructure jarStructure = new JarStructure(jarEntry); jarStructure.setJarLocation(jarFile.getAbsolutePath()); // Reading all entries and parsing them into structure final ZipInputStream zip = new ZipInputStream(jarUrl.openStream()); ZipEntry zipEntry; while ((zipEntry = zip.getNextEntry()) != null) { final String entryName = zipEntry.getName(); if (isAllowedPackage(entryName, allowedPackgages) && (zipEntry.isDirectory() || isAllowedExtension(entryName, allowedExtensions))) { parseElement(jarEntry, entryName, zipEntry); } } zip.close(); return jarStructure; } } catch (final IOException e) { FlatLafLogger.error(ReflectUtils.class, e); } catch (final URISyntaxException e) { FlatLafLogger.error(ReflectUtils.class, e); } return null; }
String getJarFromClass(Class<?> clz) { CodeSource source = clz.getProtectionDomain().getCodeSource(); if (null == source) { throw new RuntimeException("Could not get CodeSource for class"); } URL jarUrl = source.getLocation(); String jar = jarUrl.getPath(); if (!jar.endsWith(".jar")) { throw new RuntimeException("Need to have a jar to run mapreduce: " + jar); } return jar; }
@Test public void testUsePhysicalCodeSource() throws ClassNotFoundException { Class<?> clazz = this.ejb.loadClass(TO_BE_FOUND_CLASS_NAME); Assert.assertTrue( clazz.getProtectionDomain().getCodeSource().getLocation().getProtocol().equals("jar")); Assert.assertTrue( ClassLoadingEJB.class .getProtectionDomain() .getCodeSource() .getLocation() .getProtocol() .equals("jar")); }
public static File locationOf(Class clazz) { String path = clazz.getProtectionDomain().getCodeSource().getLocation().getPath(); path = path.contains("!") ? path.substring(0, path.lastIndexOf('!')) : path; if (!path.isEmpty() && path.charAt(0) == '/') { path = "file:" + path; } try { return getRelativeFile(new File(new URL(path).toURI()), currentDir); } catch (Exception e) { Log.severe("", e); return getRelativeFile(new File(path), currentDir); } }
public static String jarUsage(Class<?> main, String... params) { StringBuilder usage = new StringBuilder("USAGE: java [-cp ...] "); try { String jar = main.getProtectionDomain().getCodeSource().getLocation().getPath(); usage.append("-jar ").append(jar); } catch (Exception ex) { // ignore } usage.append(' ').append(main.getCanonicalName()); for (String param : params) { usage.append(' ').append(param); } return usage.toString(); }
@Test public void testProtectionDomainEquality() throws Exception { Bundle hostA = installBundle(getHostA()); Bundle fragA = installBundle(getFragmentA()); hostA.start(); // Load class provided by the fragment assertLoadClass(hostA, FragBeanA.class.getName()); Class<?> fragBeanClass = hostA.loadClass(FragBeanA.class.getName()); ProtectionDomain fragDomain = fragBeanClass.getProtectionDomain(); // Load a private class from host assertLoadClass(hostA, SubBeanA.class.getName()); Class<?> hostBeanClass = hostA.loadClass(SubBeanA.class.getName()); ProtectionDomain hostDomain = hostBeanClass.getProtectionDomain(); // Assert ProtectionDomain assertNotSame(hostDomain, fragDomain); hostA.uninstall(); fragA.uninstall(); }
private static String getContainerDetails() { StringBuilder result = new StringBuilder(); Class containerClass; for (CdiContainer cdiContainer : ServiceLoader.load(CdiContainer.class)) { containerClass = cdiContainer.getClass(); result.append( containerClass.getProtectionDomain().getCodeSource().getLocation().toExternalForm()); result.append(containerClass.getName()); result.append(System.getProperty("line.separator")); } return result.toString(); }
public Class<?> loadClass(String name) throws ClassNotFoundException { log.debug("calling loadClass with class " + name + ". I am " + this); Class<?> ret = super.loadClass(name); log.debug( "found class " + name + ". I am " + this + " it's classloader is " + ret.getClassLoader() + " it's codesource it " + ret.getProtectionDomain().getCodeSource()); return ret; }
/** * @param clazzToAddToServerCodebase a class that should be in the java.rmi.server.codebase * property. */ @SuppressWarnings("rawtypes") public RmiStarter(Class clazzToAddToServerCodebase) { System.setProperty( "java.rmi.server.codebase", clazzToAddToServerCodebase.getProtectionDomain().getCodeSource().getLocation().toString()); System.setProperty("java.security.policy", PolicyFileLocator.getLocationOfPolicyFile()); if (System.getSecurityManager() == null) { System.setSecurityManager(new SecurityManager()); } handleRMI(); }