1 2 Previous Next 15 Replies Latest reply on Jun 18, 2010 8:38 AM by thomas.diesler

    The service-mix dilemma

    thomas.diesler

      The Apache Felix Resolver integration requires that all wiring candidates are registered with the resolver. This is true for ordinary bundles, fragments, the system bundle and our dynamically generated service mix bundles. The resolver will not return a wire to a bundle that is not known to it.

       

      OSGi capabilities and requirements get constructed from the OSGi metadata. Those reqs/caps are mapped to an equvilant notion of resolver reqs/caps. The 1000$ question is, what are the caps/reqs of a deployment that does not contain a valid OSGi manifest.

       

      The MC classloading layer has a notion of ExportAll, which effectivly exports all packages from a given deployment. OSGi on the other hand does not have that notion and neither should it IMHO because it defeats the fundamental concepts of package modularity.

       

      As an example I implemented an OSGiKernelDeploymentDeployer that generates OSGiMetaData from a KernelDeployment. Effectivly, I adds an Export-Package attribute for every top-level bean class

       

               // Add an Export-Package definition from the bean's package
               for (BeanMetaData bmd : beansMetaData)
               {
                  String className = bmd.getBean();
                  if (className != null && className.startsWith("java.") == false)
                  {
                     String packageName = className.substring(0, className.lastIndexOf("."));
                     builder.addExportPackages(packageName);
                  }
                  else
                  {
                     log.debug("Ignore export package for: " + bmd);
                  }
               }
      

       

       

      This code is not meant to be complete not correct. Instead it can serve as a starting point for the discaussion of how arbitrary non-osgi deployments can be mapped to OSGiMetaData.

       

      This code in place, I can successfully run the ServiceMixTestCase . Note, how in some places it is necessary to provide the OSGiMetaData explicitly, because the top level beans do not expose all the packages required by the test.

       

            Deployment beans = createDeployment("beanA", null, A.class, C.class);
            
            BeanMetaDataBuilder bmd = BeanMetaDataBuilder.createBuilder("C", C.class.getName());
            addBeanMetaData(beans, bmd.addPropertyMetaData("a", bmd.createContextualInject()).getBeanMetaData());
            
            // Bundle-SymbolicName: beanA
            // Export-Package: org.jboss.test.osgi.service.support.a,org.jboss.test.osgi.service.support.c
            OSGiMetaDataBuilder osgimd = OSGiMetaDataBuilder.createBuilder(beans.getName());
            addOSGiMetaData(beans, osgimd.addExportPackages(A.class, C.class).getOSGiMetaData());
            
            addDeployment(beans);
      

       

      With this code and the felix resolver in the framework, I then tried to integrate everyting in the OSGi Runtime and JBossAS. As suspected the AS blows through the roof because every deployment that has a KernelDeployment is now subject to OSGi classloading rules and resolver wiring.

       

      What I learned from this lesson is:

       

      #1 The framework testsuite is insufficient to cover even the fundamental use cases that occur in AS

      #2 Until #1 is solved, I cannot merge stuff into master unless I've tried it out in the AS

      #3 The service-mix rules are still very much conceptually undefined

       

      The last item (#3) is a long outstanding issue that we need to resolve in order to go forward with the service-mix idea. IMHO, OSGi metadata provisioning (even conceptionaly) needs to be explicit (i.e. manifest or alternative MD source) or be derrived by clearly defined rules. (i.e. export all packages is likely to be invalid for deployments that want to take part in OSGi wiring)

       

      Currently, the jbosgi code base is quite unstable, which was caused by an invalid update of the framework due to #1. I will now try to move forward with the felix resolver in place, but with service-mix disabled in the OSGi runtimes. (i.e. in AS the framework will be as isolated as felix and equinox). Like with every other OSGi functionality, we can only claim that it is there if it works in AS.

       

      Failures that show up in AS, need to be isolated and added to the framework testsuite. Its important that we reach a level of coverage at the framework level which allows us to be confident that it'll also work in AS.

       

      cheers

      -thomas

        • 1. Re: The service-mix dilemma
          bosschaert

          I think it might help the discussion if we divide the ServiceMix case in a number of sub-cases.

           

          1. There is the use case of an OSGi bundle calling into a non-OSGi deployment. Maybe a Bundle calling an EJB.

          2. There is the use case of a non-OSGi deployment calling into an OSGi Service. Maybe a Servlet calling an OSGi Service to perform a backend operation.

           

          I also think it might be useful to separate what various non-OSGi deployments are:

          a. A library jar used internally by AS

          b. An J2EE interface library defining interfaces and annotations such as javax.ejb.* etc

          c. An EJB-jar

          d. A WAR file

          e. A RAR file

          f. An EAR file

          g. anything else?

           

          Looking at case 1:

          The non-OSGi deployment class or interface that is being invoked on needs to be exported somehow. IMO the best way to do this is to have the deployment use standard OSGi metadata (i.e. Export-Package entries in the Manifest.MF) declaring its public API. If this information is there we can just use it. The nice thing about this metadata is that in non-OSGi contexts it's simply ignored so it's always safe to add this kind of information to your jars. Many existing opensource projects already do this, e.g. Derby or Apache Zookeeper.

          If the exports are not there and we still want to be able to have case 1 work we need to come up with rules (possibly different rules for types a-g) to automagically create export-package statements including version numbers and uses clauses. The question is: is this possible or even desirable?

           

          Case 2:

          This one is easier as the Servlet just needs to import the package from the OSGi bundle. The OSGi bundle has already declared its public API so we have no problems there. We do need to tell the Servlet what to import. Again adding standard OSGi Import-Package statements to the .WAR file would be best. If not present we might be able to do some static analysis on the servlet code and generate these Import-Package statements for us. We could also assume DynamicImport-Package for the servlet but that may turn out to be messy especially when there are multiple versions of a particular package present in the system.

          • 2. Re: The service-mix dilemma
            thomas.diesler

            Yes, that summarizes what we've been discussing. Lets hear the MC view.

            • 3. Re: The service-mix dilemma
              warjort

              I don't understand this? For a change - guesswork to follow... :-)

               

              exportAll means to discover what packages are exported by looking through the (optionally filtered) packages within the roots of the deployment

              and creating capabilities for it. See determineCapabilities() here:

              http://anonsvn.jboss.org/repos/jbossas/projects/jboss-cl/trunk/classloading-vfs/src/main/java/org/jboss/classloading/spi/vfs/dependency/VFSClassLoaderPolicyModule.java

               

              After that they behave exactly the same as if they were specified in jboss-classloading.xml/ClassLoadingMetaData

              One guess is that you have something in your classloader hacks that is breaking this?

               

              I don't understand what your OSGiKernelDeployer is trying to achieve. If there really are classes in that deployment then

              the exportAll would automatically create the capabilities.

              Most likely your problem with the AS blowing up is that you have many "modules" exporting the same packages because you are using some

              bizarre heuristic to guess what is exported, when in fact at most one of them does export it. If it resolves to one of those that

              doesn't export it, it ain't going to work.

               

              I'd also guess your real problem is that there are ClassLoading Modules created by conf/bootstrap/*.xml that are not deployments

              and therefore are not OSGi bundles as far as JBOGSGi is concerned (your deployer isn't going to process these).

               

              If your felix resolver needs a Bundle interface then you need to wrap those Modules in an OSGi facade like what we do for deployments.

              You should be able to discover them from the MC by asking what extends VFSClassLoaderFactory?

               

              <incallback method="addNonDeploymentClassLoader"/>

              <uncallback method="removeNonDeploymentClassLoader"/>

               

              public void addNonDeploymentClassLoader(VFSClassLoaderFactory factory)

              {

                    String contextName = factory.getContextName();
                    if (contextName == null)
                       contextName = factory.getName() + ":" + factory.getVersion();
                    String moduleName = contextName + "$MODULE";

                          ControllerContext ctx = controller.getContext(moduleName);

                          VFSClassLoaderPolicyModule module = (VFSClassLoaderPolicyModule) ctx.getTarget();  

                          OSGiNonDeploymentBundle wrapper = bundleManager.registerNonDeploymentBundle(module);

                          // etc.

              }

              • 4. Re: The service-mix dilemma
                warjort

                David Bosschaert wrote:

                1. There is the use case of an OSGi bundle calling into a non-OSGi deployment. Maybe a Bundle calling an EJB.

                2. There is the use case of a non-OSGi deployment calling into an OSGi Service. Maybe a Servlet calling an OSGi Service to perform a backend operation.


                I wrote some tests for this a while ago, but they got commented out because somebody broke them.

                I don't think it has much chance of working if JBoss OSGi is still creating its own parallel OSGiClassLoaderSystem.

                 

                Even if that was fixed, the osgi resolver rubbish is (or at least was) incompatible with what goes on for non osgi deployments - two different

                resolution algorithms for reasons I still don't understand - I know what it says in the OSGi spec, but the solution is to make jboss classloading

                understand those "heuristics" (e.g. favour already resolved bundles when you have the choice) rather than opting for hacks that

                means osgi/non-osgi are inconsistent.

                 

                The problem with using the osgi metadata tags in the manifest for non bundles is that frameworks that do understand them

                might think it is a real OSGi deployment. The semantics of bundles is different to javaee deployments, e.g. bundles are left in the unresolved

                state (no classloader) by default and need explicit activation.

                • 5. Re: The service-mix dilemma
                  thomas.diesler

                  The underlying issue is that the resolve algorithm in MC

                   

                  Domain.doResolveModule(Module module, Requirement requirement)

                   

                        for (Module other : modules)
                        {
                           List<Capability> capabilities = other.getCapabilities();
                           if (capabilities != null)
                           {
                              for (Capability capability : capabilities)
                              {
                                 if (capability.resolves(module, requirement))
                                 {
                                    if (firstMatch != null && other != result)
                                    {
                                       log.debug("Requirement " + requirement + " resolves agaist " + firstMatch + " and " + capability + " - using first.");
                                    }
                                    if (result == null)
                                    {
                                       firstMatch = capability;
                                       result = other;
                                    }
                                 }
                              }
                           }
                        }

                   

                  is insufficient for even the most basic OSGi use cases. In AS we so far used a BasicResolver that allowed us to run at least the enterprise OSGi examples that we distribute.

                   

                  We discussed two possible solutions to this

                   

                  #1 MC implements a resolver with OSGi semantics that allows us to pass the OSGi core TCK

                  #2 Integrate with a 3rd party OSGi resolver that already passes the TCK

                   

                  As we all know, an OSGi resolver that is efficient and finds good solutions even with a large set of bundles, let alone understands the 'uses' clause is not trivial to implement. Among framework implementors there seems to be a consesus to team up to provide a portable solution for that.

                   

                  I our framework, the approach that we take is to feed the set of bundle caps/reqs into the resolver and let it work out the wiring between them. Then, in

                   

                                             capability.resolves(module, requirement)
                  

                   

                  we call into the resolver to pickup the result. i.e. the above call returns true if there is a wire between the capability and the given requirement.

                   

                  For non-osgi deployments, we also need to feed in their respective caps/reqs so that the resolver can take them into consideration and establish wires from/to them.

                   

                  This discussion is about how to determine the caps/reqs for those non-osgi deployments.

                  • 6. Re: The service-mix dilemma
                    warjort

                    Like I said before, I don't have a problem with you optimizing/changing that alogorithm you posted.

                    It's just a basic linear search that is agnostic to how a requirement resolves a capability.

                     

                    I suggested adding a mixin interface to requirements, so you it could be optimized/modified by individual requirement implementations.

                    But you just decided to change the Requirement interface so it broke backwards capability. You then backed it out, but didn't

                    try to implement it properly.

                     

                    I can't remember where I posted it, so I'll show the pseudo code again:

                     

                    /**

                    * Mixin interface for custom resolution by a requirement

                    */

                    public interface CustomResolution extends Requirement

                    {

                        /**

                         * Resolve the requirement

                         *

                         * @param domain the domain against which to resolve

                         * @return the resolved module or null if it is not resolved

                         */

                        Module resolves(Domain domain);

                    }

                     

                    // The code above would now look like

                     

                    if (requirement instanceof CustomResolution)

                       return requirement.resolves(this);

                    else

                       // do old code

                     

                    I can also imagine it would useful to be able to hold indexes within the domain (similar to what you implemented in BasicResovler but not so hard wired for OSGi) so that instead of doing linear searches over all the capabilities in the domain, you could invoke methods like:

                     

                    public class PackageRequirement

                    {

                    ...

                       public Module resolves(Domain domain)

                       {

                           Collection<Capability> possible = domain.getIndexedCapabilities(PackageCapability.class, getName());

                           //  Stuff

                       }

                    }

                     

                    The above would require building an index by type and name (for everybody to use, rather than just OSGi in your BasicResolver).

                     

                    Another requirement within the OSGi spec is to prefer already resolved modules, so you could add/use a

                    Domain.getModulesForResolving() which puts the already resolved modules at the beginning of the collection

                    and do the same for things like the suggested getIndexCapabilities() above.

                     

                    An alterante would be adding a mixin index to Capability so that you can get the Module, with AbstractCapability implementing it instead for this.

                     

                    e.g.

                     

                    public interface CapabilityModule

                    {

                        Module.getModule();

                    }

                     

                    if (capability instanceof CapabilityModule)

                    {

                        resolved = ((CapabilityModule) capability).getModule().isResovled():

                    }

                     

                    Finally, while it might be interesting that the Felix resolver already passes the TCK, it also doesn't understand everything that

                    JBoss ClassLoading can do. So you've got a choice.

                     

                    1) Use somebody else's code that if you can't write it yourself, you probably can't support it and it will break some features within JBoss

                    because it doesn't understand them and they are unlikey to get implemented/supported within Felix

                    2) Modify what already exists in a backwards compatible way to implement the 4 or 5 heuristics from the OSGi spec

                    in jboss classloading.

                    3) Persuade everybody else to stop using things like importAll=true and properly modularise jbossas (including

                    automatically adding the necessary Requirements to legacy user deployments, otherwise they'll break)

                    • 7. Re: The service-mix dilemma
                      warjort

                      And another thing that needs to happen is to bubble the attribute matching from OSGi to jboss classloading.

                      The only reason I originally created OSGi*Capability/Requirement was to implement the attribute matching without modifying

                      jboss classloading so it could be used in older versions of jboss5. That restriction was broken by other changes a long time ago.

                       

                      We might never have got into this horrible situation if I hadn't done that.

                       

                      You should be able to do things like the following in jboss-classloading.xml:

                       

                      <capabilities>

                         <package name="foo" attributes="a=b,c=d"/>

                      </capabilities>

                       

                      <requirements>

                          <package name="bar" match-attributes="(vendor=acme)"/>

                      </requirements>

                       

                      I'm sure Ales will want to generalize this into any matching mechanism, not just the osgi style. :-)

                      • 8. Re: The service-mix dilemma
                        thomas.diesler

                        exportAll means to discover what packages are exported by looking  through the (optionally filtered) packages within the roots of the  deployment and creating capabilities for it. See  determineCapabilities() here:

                        http://anonsvn.jboss.org/repos/jbossas/projects/jboss-cl/trunk/classloading-vfs/src/main/java/org/jboss/classloading/spi/vfs/dependency/VFSClassLoaderPolicyModule.java

                         

                        After that  they behave exactly the same as if they were specified in  jboss-classloading.xml/ClassLoadingMetaData

                        One guess is that you  have something in your classloader hacks that is breaking this?

                         

                        This effectivly says that every non-osgi deployment should behave like an osgi bundle that exports every package in any version. Although we are aware of this option, we are currently doubtfull that this is the way we want to go forward. Alternatively, we could take a conservative approach by which any deployment must somehow define its capabilities and requirements explicitly.

                        The osgi resolver rubbish is (or at least was) incompatible with  what goes on for non osgi deployments - two different

                        resolution  algorithms for reasons I still don't understand - I know what it says in  the OSGi spec, but the solution is to make jboss classloading understand  those "heuristics" (e.g. favour already resolved bundles when you have  the choice) rather than opting for hacks that means osgi/non-osgi  are inconsistent.

                        Implementing a resolver with osgi heuristics is not trivial, especially when considering the 'uses' clause. You need backtracking, explore different possible solutions, ignore solution paths beyond a certain depth, etc. All of which should work with very large sets of deployments in a timely manner.

                         

                        If we were to implement such a resolver at the MC level, it would undoubtably be based on capabilities and requirements that a given deployment defines. We can already map the MC notion of caps/reqs to the felix resolver and pickup the result from it. What we still need to do however, is to generate the correct set of caps/reqs for non-osgi deployments in a way that it does not compromise the explicitly declared mapping rules in osgi bundles. What you said above about 'exortAll' is an option that we consider.

                         

                        The problem with using the osgi metadata tags in the manifest for non  bundles is that frameworks that do understand them

                        might think it  is a real OSGi deployment.

                         

                        We don't plan to do that.

                         

                        /**
                        * Mixin interface for custom resolution by a requirement
                        */
                        public interface CustomResolution extends Requirement
                        {
                             /**
                             * Resolve the requirement
                             *
                             *  @param domain the domain against which to resolve
                             * @return  the resolved module or null if it is not resolved
                             */
                             Module resolves(Domain domain);
                        }
                        
                        // The code above would now look  like
                        
                        if  (requirement instanceof CustomResolution)
                           return  requirement.resolves(this);
                        else
                           // do old code
                        

                         

                        ok, thanks for reminding me.

                        https://jira.jboss.org/browse/JBCL-167

                         

                        Finally, while it might be interesting that the Felix resolver  already passes the TCK, it also doesn't understand everything that

                        JBoss  ClassLoading can do. So you've got a choice.

                         

                        1) Use somebody else's code that if you can't write it yourself, you  probably can't support it and it will break some features within JBoss

                        because  it doesn't understand them and they are unlikey to get  implemented/supported within Felix

                        2) Modify what already exists  in a backwards compatible way to implement the 4 or 5 heuristics from  the OSGi spec

                        in jboss classloading.

                        3) Persuade everybody  else to stop using things like importAll=true and properly modularise  jbossas (including

                        automatically adding the necessary Requirements  to legacy user deployments, otherwise they'll break)

                        I'll bring this up again to hear what the team says.

                         

                        If consistent classspaces are to be formed, they likely need to be formed on the basis of some caps/reqs definition. Dynamic imports should be avoided where possible, encapsulation/modularity should be maintained by consiously deciding what to export.

                         

                        An alterante would be adding a mixin index to Capability so that you  can get the Module, with AbstractCapability implementing it instead for  this.

                         

                        e.g.

                         

                        public  interface CapabilityModule

                        {

                            Module.getModule();

                        }

                         

                        if  (capability instanceof CapabilityModule)

                        {

                            resolved =  ((CapabilityModule) capability).getModule().isResovled():

                        }

                         

                        Yes, https://jira.jboss.org/browse/JBCL-168

                         

                        And another thing that needs to happen is to bubble the attribute  matching from OSGi to jboss classloading.
                        ...

                        You should be able to do things like the following in  jboss-classloading.xml:

                         

                        <capabilities>

                           <package  name="foo" attributes="a=b,c=d"/>

                        </capabilities>

                         

                        <requirements>

                             <package name="bar" match-attributes="(vendor=acme)"/>

                        </requirements>

                        Yes, https://jira.jboss.org/browse/JBCL-169

                         

                        Thanks for your feedback

                        • 9. Re: The service-mix dilemma
                          bosschaert

                          Thomas Diesler wrote:


                          The problem with using the osgi metadata tags in the manifest for non  bundles is that frameworks that do understand them

                          might think it  is a real OSGi deployment.

                           

                          We don't plan to do that.

                          Why not? An OSGi bundle needs to have at least a Bundle-SymbolicName header, otherwise its not a bundle. I would actually think it better to use metadata that has been defined already as a standard i.e. the OSGi Export-Package and Import-Package manifest entries. Just adding those doesn't turn an artifact in a bundle but it does solve the problem we're discussing here...

                           

                          So here's a potentially controversial idea: how about we only enable servicemix with non-osgi deployments that actually have their exports and imports defined as such. Otherwise they dont get to play in servicemix. Adding a few headers is only a small task and making it a requirement provides yet another reason for people to properly declare this information.

                          Finally, while it might be interesting that the Felix resolver  already passes the TCK, it also doesn't understand everything that

                          JBoss  ClassLoading can do. So you've got a choice.

                           

                          1) Use somebody else's code that if you can't write it yourself, you  probably can't support it and it will break some features within JBoss

                          because  it doesn't understand them and they are unlikey to get  implemented/supported within Felix

                          I'll bring this up again to hear what the team says.

                          What are those JBoss-specific features that are likely not supported by the Felix resolver?

                          • 10. Re: The service-mix dilemma
                            thomas.diesler
                            We don't plan to do that.

                            What I am referning to here is the use of OSGi manifest headers for deployemnts that are not designed to be bundles. (i.e. put in arbitrary osgi manifest headers to make it work in AS). A consumer of such a jar would justifiably think it is a proper osgi bundle designed to work in other frameworks, which it will probably not.

                             

                            A better solution would be to get rid of OSGiCapability and OSGiRequirement (and their family) all together and support the functionality within by the MC directly (i.e JBCL-169 (Support attribute matching from OSGi)).

                             

                            how about we only enable servicemix with non-osgi deployments that  actually have their exports and imports defined as such. Otherwise they  dont get to play in servicemix. Adding a few headers is only a small  task and making it a requirement provides yet another reason for people  to properly declare this information.


                            I can see three ways to come up with valid sets of caps/reqs, which form the basis of the resolution algorithm

                             

                            • osgi manifest headers
                            • explicit classloading metadata
                            • defined rules by which we generate classloading metadata

                             

                            I posted a proposal about a possible way to forward WRT the resolver here: http://community.jboss.org/thread/153287

                            • 11. Re: The service-mix dilemma
                              alesj
                              So here's a potentially controversial idea: how about we only enable servicemix with non-osgi deployments that actually have their exports and imports defined as such. Otherwise they dont get to play in servicemix. Adding a few headers is only a small task and making it a requirement provides yet another reason for people to properly declare this information.

                              No, this would just lead to more hacking -- see existing OSGiX stuff for JBCL, rather then solving the real problem,

                              which is just properly handling corner cases.

                               

                              If we went with this "contorversial idea", it would mean we have to make all of the involved sub-systems aware of

                              "is it part of properly described deployment" or should it be ignored.

                              And I don't see how you can nicely bubble up all of this information into various sub-systems.

                              e.g. context tracking, MDR creation, type matching, resolving, ...

                               

                              I don't see a problem with what Adrian described, which is also what I've been advocating ;-),

                              it just means it needs to be done right, pushing the missing pieces into MC, not hack around in OSGi facade.

                               

                              Definitely the test coverege here is of crucial value, but this is where OSGi facade with its current tests and TCK gives its value.

                              Not to mention very valuable AS integration, which is where most of the issues really expose itself.

                              • 12. Re: The service-mix dilemma
                                warjort

                                David Bosschaert wrote:

                                 

                                Thomas Diesler wrote:


                                The problem with using the osgi metadata tags in the manifest for non  bundles is that frameworks that do understand them

                                might think it  is a real OSGi deployment.

                                 

                                We don't plan to do that.

                                Why not? An OSGi bundle needs to have at least a Bundle-SymbolicName header, otherwise its not a bundle. I would actually think it better to use metadata that has been defined already as a standard i.e. the OSGi Export-Package and Import-Package manifest entries. Just adding those doesn't turn an artifact in a bundle but it does solve the problem we're discussing here...

                                 

                                So here's a potentially controversial idea: how about we only enable servicemix with non-osgi deployments that actually have their exports and imports defined as such. Otherwise they dont get to play in servicemix. Adding a few headers is only a small task and making it a requirement provides yet another reason for people to properly declare this information.

                                 


                                Currently we have a deployer that parses the manifest and if it has a Bundle-SymbolicName we attach OSGiMetaData.

                                From the OSGiMetaData we then create ClassLoadingMetaData.

                                 

                                It would be relatively trivial to do the following:

                                1) Create the OSGiMetaData anyway, but store it under a different key so it doesn't think it is a Bundle

                                2) Use the alternate metadata when creating ClassLoadingMetaData, even though it is not a bundle - but not if it already has

                                a ClassLoadingMetaData

                                 

                                More complicated would be allowing the declarations of dependecies and capabilities to be in nested deployments.

                                OSGi doesn't support nested so we only look at the the top level manifest. But other non OSGi deployments do,

                                so we would have to also look at the manifest of a jar in an ear or war.

                                You'd also have to resolve conflicts between the different manifests.

                                 

                                But like I said before, maybe this is not what the deployer wants? They include some thirdparty jar and find out it is messing

                                with there classloading configuration in ways they don't intend - e.g. older version of some other jar

                                • 13. Re: The service-mix dilemma
                                  warjort

                                  David Bosschaert wrote:

                                  What are those JBoss-specific features that are likely not supported by the Felix resolver?

                                  I can think of the following off the top of my head:

                                   

                                  * import-all=true

                                  * sub-domains

                                  * parent first/last - or more complicated policies

                                  * nested deployments get their own classloader, e.g. wars in ears

                                  * write your own classloading capability/requirement

                                  • 14. Re: The service-mix dilemma
                                    warjort

                                    Adrian Brock wrote:


                                    * write your own classloading capability/requirement

                                    This is effectively what JBoss OSGi is using to implement the attribute matching.

                                    1 2 Previous Next