public DeploymentInfo(URL url,
    DeploymentInfo parent,
    MBeanServer server) throws DeploymentException 
{
        
      this.server = server;
      // The key url the deployment comes from
      this.url = url;
      // this may be changed by deployers in case of directory and xml file following
      this.watch = url;
      // Whether we are part of a subdeployment or not
      this.parent = parent;
      // Is it a directory?
      if (url.getProtocol().startsWith("file") && new File(url.getFile()).isDirectory())
         this.isDirectory = true;
      // Does it even exist?
      if (!isDirectory)
      {
         try
         {
            url.openStream().close();
         }
         catch (Exception e)
         {
            throw new DeploymentException("url " + url + " could not be opened, does it exist?");
         }
      }
      if (parent != null)
      {
         parent.subDeployments.add(this);
         // Use the repository of our topmost parent
         repositoryConfig = getTopRepositoryConfig();
      }
      // The "short name" for the deployment http://myserver/mybean.ear should yield "mybean.ear"
      shortName = getShortName(url.getPath());
      // Do we have an XML descriptor only deployment?
      isXML = shortName.toLowerCase().endsWith(".xml");
      // Do we have a stand-olone script deployment?
      isScript = shortName.toLowerCase().endsWith(".bsh");
}

CTOR

 public  void addLibraryJar(URL libJar) 
{
      DeploymentInfo current = this;
      while (current.parent != null)
      {
         current = current.parent;
      }
      /* If the UCL exists add the jar to it else use the classpath to
      indicate that the jars need to be added when the ucl is created.
      */
      if( current.ucl != null )
         current.ucl.addURL(libJar);
      else
         classpath.add(libJar);
}

All library jars referenced through either the manifest references or sar classpaths are added to the root DeploymentInfo class loader. This is neccessary to avoid IllegalAccessErrors due to classes in a pkg being split across jars

 public  void cleanup() 
{
      // Remove the deployment UCL
      if( parent == null && ucl != null )
         ucl.unregister();
      ucl = null;
      // Remove any deployment specific repository
      if ( repositoryConfig != null )
      {
         LoaderRepositoryFactory.destroyLoaderRepository(server,
            repositoryConfig.repositoryName);
      }
      subDeployments.clear();
      mbeans.clear();
      context.clear();
      if (localUrl == null || localUrl.equals(url))
      {
         log.debug("Not deleting localUrl, it is null or not a copy: " + localUrl);
      }
      else if (Files.delete(localUrl.getFile()))
      {
         log.debug("Cleaned Deployment: " + localUrl);
      }
      else
      {
         log.debug("Could not delete " + localUrl + " restart will delete it");
      }
      // Clean up references to other objects
      localCl = null;
      annotationsCl = null;
      localUrl = null;
      repositoryConfig = null;
      watch = null;
      parent = null;
      manifest = null;
      document = null;
      metaData = null;
      server = null;
      classpath.clear();
      state = DeploymentState.DESTROYED;
      // Who is using this after clear?
      // deployer = null;
}

 public  void createClassLoaders() throws Exception 
{
      // create a local classloader for local files, don't go with the UCL for ejb-jar.xml
      if( localCl == null )
         localCl = new URLClassLoader(new URL[] {localUrl});
      /* Walk the deployment tree to find the parent deployment and obtain its
       url to use as our URL from which this deployment unit originated. This
       is used to determine permissions using the original URL namespace.
       Also pick up the LoaderRepository from the topmost ancestor.
      */
      URL origUrl = url;
      DeploymentInfo current = this;
      while (current.parent != null)
      {
         current = current.parent;
      }
      origUrl = current.url;
      repositoryConfig = current.repositoryConfig;
      if( parent == null )
      {
         if( repositoryConfig == null )
            repositoryConfig = new LoaderRepositoryConfig();
         // Make sure the specified LoaderRepository exists.
         LoaderRepositoryFactory.createLoaderRepository(server, repositoryConfig);
         log.debug("createLoaderRepository from config: "+repositoryConfig);
         // the classes are passed to a UCL that will share the classes with the whole base
         Object[] args = { isXML ? null : localUrl, origUrl, Boolean.TRUE };
         String[] sig =  { "java.net.URL", "java.net.URL", "boolean" };
         ucl = (RepositoryClassLoader) server.invoke(repositoryConfig.repositoryName,
            "newClassLoader",args, sig);
      }
      else
      {
         // Add a reference to the LoaderRepository
         LoaderRepositoryFactory.createLoaderRepository(server, repositoryConfig);
         // Add the deployment URL to the parent UCL
         ucl = parent.ucl;
         ucl.addURL(localUrl);
      }
      // Add any library jars seen before the UCL was created
      if( classpath.size()  > 0 )
      {
         Iterator jars = classpath.iterator();
         while( jars.hasNext() )
         {
            URL jar = (URL) jars.next();
            ucl.addURL(jar);
         }
      }
}

Create a UnifiedClassLoader for the deployment that loads from the localUrl and uses its parent deployments url as its orignal url. Previously xml descriptors simply used the TCL but since the UCLs are now registered as mbeans each must be unique.

 public boolean equals(Object other) 
{
      if (other instanceof DeploymentInfo)
      {
         return ((DeploymentInfo) other).url.equals(this.url);
      }
      return false;
}

 public String getCanonicalName() 
{
      String name = shortName;
      if (parent != null)
         name = parent.getCanonicalName() + "/" + name;
      return name;
}

The sortName concatenated with the canonical names of all parents.

 public Manifest getManifest() 
{
      try
      {
         if (manifest == null)
         {
            File file = new File(localUrl.getFile());
            if (file.isDirectory())
            {
               FileInputStream fis = new FileInputStream(new File(file, "META-INF/MANIFEST.MF"));
               try
               {
                  manifest = new Manifest(fis);
               }
               finally
               {
                  fis.close();
               }
            }
            else if(isXML == false)// a jar
               manifest = new JarFile(file).getManifest();
         }
         return manifest;
      }
      // It is ok to barf at any time in the above, means no manifest
      catch (Exception ignored) { return null;}
}

getManifest returns (if present) the deployment's manifest it is lazy loaded to work from the localURL

 public MBeanServer getServer() 
{
      return server;
}

 public LoaderRepositoryConfig getTopRepositoryConfig() 
{
      LoaderRepositoryConfig topConfig = repositoryConfig;
      DeploymentInfo info = this;
      while( info.parent != null )
      {
         info = info.parent;
         topConfig = info.repositoryConfig;
      }
      return topConfig;
}

The the class loader repository name of the top most DeploymentInfo

 public int hashCode() 
{
      return url.hashCode();
}

 public  void setRepositoryInfo(LoaderRepositoryConfig config) throws Exception 
{
      if( parent != null )
      {
         log.warn("Only the root deployment can set the loader repository, "
            +  "ignoring config="+config);
         return;
      }
      this.repositoryConfig = config;
      // Recreate the ucl if it exists
      if( ucl != null )
      {
         ucl.unregister();
         // Make sure the specified LoaderRepository exists.
         LoaderRepositoryFactory.createLoaderRepository(server, repositoryConfig);
         log.debug("createLoaderRepository from config: "+repositoryConfig);
         // the classes are passed to a UCL that will share the classes with the whole base
         Object[] args = { isXML ? null : localUrl, url, Boolean.TRUE };
         String[] sig =  { "java.net.URL", "java.net.URL", "boolean" };
         ucl = (RepositoryClassLoader) server.invoke(repositoryConfig.repositoryName,
            "newClassLoader",args, sig);
      }
}

Set the UnifiedLoaderRepository info for the deployment. This can only be called for the parent deployment, and must be done early in the Subdeployer init(DeploymentInfo) method prior to any class loading.

 public  void setServer(MBeanServer server) 
{
      this.server = server;
}

 public String toString() 
{
      StringBuffer s = new StringBuffer(super.toString());
      s.append(" { url=" + url + " }\n");
      s.append("  deployer: " + deployer + "\n");
      s.append("  status: " + status + "\n");
      s.append("  state: " + state + "\n");
      s.append("  watch: " + watch + "\n");
      s.append("  altDD: " + alternativeDD + "\n");
      s.append("  lastDeployed: " + lastDeployed + "\n");
      s.append("  lastModified: " + lastModified + "\n");
      s.append("  mbeans:\n");
      for (Iterator i = mbeans.iterator(); i.hasNext(); )
      {
         ObjectName o = (ObjectName)i.next();
         try
         {
            String state = (String)server.getAttribute(o, "StateString");
            s.append("    " + o + " state: " + state + "\n");
         }
         catch (Exception e)
         {
            s.append("    " + o + " (state not available)\n");
         } // end of try-catch
      } // end of for ()
      return s.toString();
}