"kabir.khan@jboss.com" wrote:

Should I be using something other than the Domain/parentDomain, or is this broken somehow in ASS trunk?

 private ClassLoader getScopedClassLoader(VFSDeploymentUnit unit)
 {
 ...
 Module module = unit.getTopLevel().getAttachment(Module.class);
 ...
 }

With the new classloaders, how do I add a URL to the classloader? i.e. something similar to the old:

 private URL createURLAndAddToLoader(ClassLoader cl, File tempdir) throws IOException
 {
 URL tmpURL = tempdir.toURL();
 URL tmpCP = new URL(tmpURL, "?dynamic=true");

 RepositoryClassLoader ucl = (RepositoryClassLoader) cl;

 // We may be undeploying.
 if (ucl.getLoaderRepository() != null)
 {
 ucl.addURL(tmpCP);
 }

 return tmpCP;
 }

When generating classes, the way it currently works in JBossClassPool.toClass() is that

1) The class file is written to the "dynamic" url, so that it is available both for the classloader and for the ClassPool itself
2) The loader blacklists are cleared
3) The class is loaded through the classloader

The classpool itself should be able to cache the class, so I think the main question is how this will work at classloader level. I will try without this and see what happens.

I seem to need a URL that I can write to. I am currently just loading the generated classes directly with the classloader, which works for most things apart from fetching in the generated parent classes from a child domain. This ends up going through the parent domain and calling getResource () on the classloaders belonging to the domain. Since the class files are never written out the class can never be found.

If I were to add a "dynamic" url as you suggest, I still would have a problem of being able to get hold of it for a given classloader since we don't really have a way to access the underlying classpath?

So my take on this is currently:

1) Implement org.jboss.virtual.plugins.context.memory.
MemoryContextFactory
MemoryContext
MemoryContextHandler

2) Plug the context factory for vfsmemory into VFSContextFactoryLocator

3) VFSTopLevelClassLoaderSystemDeployer
a) When creating the top level classloader pass in a memory virtual file as one of the roots
b) Attach the memory virtual file to the deployment?

4) AspectDeployer
a) Get the memory virtual file from the deployment and output the generated classes to there (possibly using the AssembledXXX stuff?)

Scott,

I have added a vfs uri handler. Can you please see if it looks the way you would expect?
https://svn.jboss.org/repos/jbossas/projects/vfs/trunk/src/test/java/org/jboss/test/virtual/test/MemoryTestCase.java

Currently, the only content that can be set is of type byte[]. Should I instead make it take something more flexible?

I've fixed this and added some more tests to make sure that we cannot add children to leaf nodes, or content to something that has children.

This now works locally. I've modified VFSTopLevelClassLoaderSystemDeployer to pass in the extra root

public class VFSTopLevelClassLoaderSystemDeployer extends AbstractTopLevelClassLoaderSystemDeployer
{
 @Override
 protected VFSClassLoaderPolicy createTopLevelClassLoaderPolicy(DeploymentContext context, Module module) throws Exception
 {
 ClassPathVisitor visitor = new ClassPathVisitor();
 context.visit(visitor);
 Set<VirtualFile> classPath = visitor.getClassPath();

 VirtualFile[] roots = new VirtualFile[classPath.size() + 1];
 int i = 0;
 for (VirtualFile path : classPath)
 roots[i++] = path;

 MemoryContextFactory factory = MemoryContextFactory.getInstance();
 VFSContext ctx = factory.createRoot(module.getDynamicClassRoot());

 URL url = new URL(module.getDynamicClassRoot() + "/classes");
 roots[i++] = factory.createDirectory(url).getVirtualFile();

 VFSClassLoaderPolicy policy = new VFSClassLoaderPolicy(roots);
 policy.setExportAll(module.getExportAll());
 policy.setImportAll(module.isImportAll());
 // TODO JBMICROCONT-182 more policy from "module"
 return policy;
 }
}

 public Class toClass(CtClass cc, ClassLoader loader, ProtectionDomain domain) throws CannotCompileException
 {
 lockInCache(cc);
 final ClassLoader myloader = getClassLoader();
 if (myloader == null || tempURL == null)
 {
 return super.toClass(cc, loader, domain);
 }

 try
 {
 String classFileName = getResourceName(cc.getName());
 URL outputURL = new URL(tempURL.toString() + "/" + classFileName);
 //Write the classfile to the temporary url
 synchronized (tmplock)
 {
 ByteArrayOutputStream byteout = new ByteArrayOutputStream();
 BufferedOutputStream out = new BufferedOutputStream(byteout);
 out.write(cc.toBytecode());
 out.flush();
 out.close();

 byte[] classBytes = byteout.toByteArray();
 MemoryContextFactory factory = MemoryContextFactory.getInstance();
 factory.putFile(outputURL, classBytes);

 clearCacheOnLoaderHack(myloader);

 return myloader.loadClass(cc.getName());
 }
 }
 catch(Exception e)
 {
 ClassFormatError cfe = new ClassFormatError("Failed to load dyn class: " + cc.getName());
 cfe.initCause(e);
 throw cfe;
 }
 }

 private void clearCacheOnLoaderHack(final ClassLoader loader)
 {
 if (loader instanceof BaseClassLoader)
 {
 try
 {
 AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {

 public Object run() throws Exception
 {
 Class clazz = loader.getClass();
 while (clazz != null && clazz != BaseClassLoader.class)
 {
 clazz = clazz.getSuperclass();
 }
 Field field = clazz.getDeclaredField("blackList");
 field.setAccessible(true);
 Set<String> set = (Set<String>)field.get(loader);
 set.clear();
 return null;
 }});
 }
 catch (PrivilegedActionException e)
 {
 // AutoGenerated
 throw new RuntimeException(e.getCause());
 }
 }
 }