JBossDeveloper

"alesj" wrote:

* OSGi services will be exposed as MC beans

"alesj" wrote:

* MC beans will be listed as a OSGi services

I'm not following what you are talking about?

Anything you getTarget() during the install() phase should have
a corresponding ungetTarget() during the uninstall() of the lifecycle.

If somebody is using the api manually (either the MC api directly or the OSGi api)
then it is up to them to make sure they don't have stale references.

With OSGi the references can go stale at anytime anyway, which is why the
service notification mechanism exists (in principle we should automatically
respond those if IOC is used and "redeploy" whatever it was injected into?)

Even if they do, they will/should be tidied up at Deployment/Bundle.stop()
when the ServiceTracking for that context should be disabled/cleaned up.

The ServiceFactory is just a lazy version of the service. i.e. you only construct it
if somebody wants to use it. Its still a singleton. It only controls when the object
is constructed (first access instead of upfront).

On the blueprint stuff, I'll repeat from an earlier thread.

This should just be another facade on the MC like the spring-int project is.
There is no reason to re-implement it when we already know there
is a mapping from the spring-int example.

Its just a change of namespace and some xml element/attribute names. :-)

Any missing features/metadata should be implemented in the MC.

In fact, from my (incomplete ;-) understanding of blueprint, its basically two different
injection mechanisms in one xml file.
One using a "Spring" type api and one using an "OSGi" type for the two different
mechanisms.

When Ales has this working, you should able to use either type to inject any service
within JBoss. Just choose your poison. ;-)

Of course, if you are already in the uninstall lifecycle like the uninstalls or stop/destroy
then you effectively do:

Object parameter = dependency.getTarget(me);
try
{
 invokeStop(parameter);
}
finally
{
 dependency.ungetTarget(me);
}

"adrian@jboss.org" wrote:

As part of the OSGi stuff, I've made the DeploymentUnit part of the MDR's
deployment level metadata. You should extend this concept so that the
dependency project can look for a "ServiceTracker" in the MDR rather than
a DeploymentUnit. The deployers project would then add the ServiceTracker
attachment by the default to the deployment level metadata.

"adrian" wrote:

The ServiceFactory is just a lazy version of the service. i.e. you only construct it
if somebody wants to use it. Its still a singleton. It only controls when the object
is constructed (first access instead of upfront).

"alesj" wrote:

I fail to see why I would need two different levels of ServiceTracker.
As I also always have to check the "global" list.

When would I check just deployment level ServiceTracker?
For non-system bundle, to lookup non-osgi services that belong just to this bundle / jar / deployment?

It should be done on the calls to (un)getTarget()
Having the calling code do all this work would inefficient and error prone.

And besides a context may want to change the way this work, e.g. by providing
a specific ServiceTracker rather than using the one determined from the MDR.

You need a signature like I suggested above,
i.e. something like the following:

// Mixin interface for service tracking
public interface ServiceTracking
{
/**
 * Get the service tracker associated with this context
 *
 * @return the tracker or null if it doesn't have one
 */
ServiceTracker getServiceTracker();

/**
 * Get the target and update the service tracking
 *
 * @param me the controller context that will use the target
 * @return the object
 * @throws Exception for any error
 */
Object getTarget(ControllerContext me) throws Exception;

/**
 * Unget the target and update the service tracking
 *
 * @param me the controller context that used the target
 */
void ungetTarget(ControllerContext me);
}

public Object ControllerContext::getTarget(ControllerContext me) throws Exception
{
 Object result = getTarget();
 if (result != null)
 {
 ServiceTracker myTracker = getServiceTracker();
 if (myTracker != null)
 myTracker.incrementInUse(me, this);
 if (me instanceOf ServiceTracking)
 {
 ServiceTracker otherTracker = me.getServiceTracker();
 if (otherTracker != null)
 otherTracker.incrementUsing(this);
 }
 }
 return result;
}

public void ControllerContext::ungetTarget(ControllerContext me)
{
 Object result = getTarget();
 if (result != null)
 {
 ServiceTracker myTracker = getServiceTracker();
 if (myTracker != null)
 myTracker.decrementInUse(me, this);
 if (me instanceOf ServiceTracking)
 {
 ServiceTracker otherTracker = me.getServiceTracker();
 if (otherTracker != null)
 otherTracker.decrementUsing(this);
 }
 }
}