So here's the real question :)

Do attachments to component contexts of an unit get treated the same way? Do 
these attachments to component contexts get passed onto the deployers? From 
what i see this is not the case.

Here's the example:

// This one doesn't do much and is not of much relevance in this
  | // example. It just creates a component which can be consumed
  | // by our component deployer (MyComponentDeployer - see next)
  | public class TestDeployer extends AbstractDeployer
  | {
  | 
  |    public TestDeployer()
  |    {
  |       setStage(DeploymentStages.POST_CLASSLOADER);
  |     // this is our output which is consumed by MyComponentDeployer
  |       setOutput(TestAttachment.class);
  |     // some input - not relevant in this example
  |       setInput(JBossMetaData.class);
  |    }
  | 
  | // creates a component to the unit and adds an attachment to the component
  | // so that the MyComponentDeployer can consume it
  |    public void deploy(DeploymentUnit unit) throws DeploymentException
  |    {
  |       DeploymentUnit comp = unit.addComponent("something");
  |       comp.addAttachment(TestAttachment.class, new TestAttachment("hello"));
  |       logger.info("Added attachment to component in unit " + unit);
  |    }
  | }
  | 


// This one is important - this deployer is a component only deployer
  | // and works on the component that was created by our earlier TestDeployer
  | public class MyComponentDeployer extends AbstractDeployer
  | {
  | 
  | 
  |    public MyComponentDeployer()
  |    {
  |       setStage(DeploymentStages.REAL);
  |     // the attachment that was added to the component by our earlier 
deployer
  |     // will be our input
  |       setInput(TestAttachment.class);
  |     // we work only on components
  |       setComponentsOnly(true);
  |    }
  | 
  |     // Here we just add an attachment to the unit (which acutally is an 
component)
  |     // Any further deployers (MyFinalDeployer - see next) will use this 
attachment 
  |     // as input
  |    public void deploy(DeploymentUnit unit) throws DeploymentException
  |    {
  |       logger.info("Deploying unit : " + unit);
  |       // doesn't work
  |       unit.addAttachment(AnotherType.class, new AnotherType());
  |    }
  | 
  | }
  | 
  | 

// This one (tries to) consumes the attachment that was added by the component
  | // deployer (see above)
  | public class MyFinalDeployer extends AbstractDeployer
  | {
  |    private static Logger logger = Logger.getLogger(OneMoreDeployer.class);
  | 
  |    public MyFinalDeployer()
  |    {
  |       setStage(DeploymentStages.REAL);
  |     // the attachment that was added by the component deployer
  |       setInput(AnotherType.class);
  | 
  |    }
  | 
  |     // never reaches here.
  |    public void deploy(DeploymentUnit unit) throws DeploymentException
  |    {
  |       logger.info("Deploying another type " + unit);
  | 
  |    }
  | 
  | }
  | 
  | 
  | 

There are 3 deployers involved here:

1) The TestDeployer creates a component to an unit and also attaches an 
attachment to the component (works fine)
2) The MyComponentDeployer consumes this component context and additionally 
creates an attachment to it (works fine/or maybe not).
3) MyFinalDeployer is supposed to consume the attachment created in #2, but it 
never does. This deployer is considered "not relevant".

The only way i could get this to work was to add the attachment to the parent 
of the component context in #2. So:

public class MyComponentDeployer extends AbstractDeployer
  | {
  | 
  |     // I don't know why i need to add the attachment to the
  |     // parent. But it works, so let's for the time being do that
  |    public void deploy(DeploymentUnit unit) throws DeploymentException
  |    {
  |       logger.info("Deploying unit : " + unit);
  |     // here - i'm clueless, the attachment needs to be added to parent for 
some reason
  |     // Note, this is a component deployer and works on component context
  |       unit.getParent().addAttachment(AnotherType.class, new AnotherType());
  |    }
  | 
  | }
  | 

Doing this makes MyFinalDeployer (in #3) "relevant" and the unit is passed on 
the deploy method of MyFinalDeployer.

So the question is - what am i missing? :)

View the original post : 
http://www.jboss.org/index.html?module=bb&op=viewtopic&p=4215152#4215152

Reply to the post : 
http://www.jboss.org/index.html?module=bb&op=posting&mode=reply&p=4215152
_______________________________________________
jboss-user mailing list
[email protected]
https://lists.jboss.org/mailman/listinfo/jboss-user

Reply via email to