Automatically Managing Service Dependencies in an OSGi Environment - Marcel Oﬀermans, Senior Software Engineer, Luminis

Automatically Managing
Service Dependencies in
an OSGi Environment
Marcel OffermansMarcel Offermans

About me...About me...
•• Marcel OffermansMarcel Offermans
•• Senior Software Engineer at luminisSenior Software Engineer at luminis®®
•• Our mission is to provide knowledge and products toOur mission is to provide knowledge and products to
organisations who create software intensiveorganisations who create software intensive
products, to help them adopt software technologyproducts, to help them adopt software technology
innovations.innovations.
•• We use OSGi at the core of the architecture forWe use OSGi at the core of the architecture for
managable, embedded systems.managable, embedded systems.

AgendaAgenda
•• Dependencies in OSGiDependencies in OSGi
•• Goals for a dependency managerGoals for a dependency manager
•• Architecture, illustrated by examplesArchitecture, illustrated by examples
•• ConclusionsConclusions

Dependencies in OSGiDependencies in OSGi
•• Package dependencies, which in R4 have beenPackage dependencies, which in R4 have been
extended with requiring, fragment and extensionextended with requiring, fragment and extension
bundles. These are all resolved in the module layer.bundles. These are all resolved in the module layer.
•• Service dependencies, which are resolved in theService dependencies, which are resolved in the
service layer.service layer.

Service DependenciesService Dependencies
•• Need to be managed at runtimeNeed to be managed at runtime
•• The OSGi framework offers basic tools:The OSGi framework offers basic tools:
–– Service listenerService listener
–– Service trackerService tracker
•• Third party tools:Third party tools:
–– Service binderService binder
–– ...probably there are more :)...probably there are more :)

Goals for the Dependency ManagerGoals for the Dependency Manager
•• Minimize the amount of code that needs to beMinimize the amount of code that needs to be
written.written.
•• Provide a clean separation between the serviceProvide a clean separation between the service
implementation andimplementation and ““glueglue”” code.code.
•• Be dynamic. Allow the programmer to add servicesBe dynamic. Allow the programmer to add services
and dependencies at any time.and dependencies at any time.

Types of dependenciesTypes of dependencies
•• Required dependencies, which need to be resolvedRequired dependencies, which need to be resolved
before the service can work at all.before the service can work at all.
•• Optional dependencies, which are used whenOptional dependencies, which are used when
available but are not essential for the service toavailable but are not essential for the service to
work.work.

Architecture: state diagramArchitecture: state diagram

Standard use caseStandard use case
•• A service with two required dependencies and oneA service with two required dependencies and one
optional one.optional one.
public class Activator extends DependencyActivatorBase {
public void init(BundleContext bc, DependencyManager dm) {
dm.add(createService()
.setInterface(MyService.class.getName(), null)
.setImplementation(MyServiceImpl.class)
.add(createServiceDependency()
.setService(HttpService.class)
.setRequired(true))
.setService(SomeOtherService.class)
.setRequired(true))
.setService(LogService.class)
.setRequired(false))
);
}
public void destroy(BundleContext bc, DependencyManager dm) {
}
}

Standard use caseStandard use case
•• Implementation instantiated lazily, invokes callbacksImplementation instantiated lazily, invokes callbacks
as part of lifeas part of life--cycle: init, start, stop, destroycycle: init, start, stop, destroy
•• Dependencies are injected using reflectionDependencies are injected using reflection
•• Null object pattern used for optional dependenciesNull object pattern used for optional dependencies
public class MyServiceImpl implements MyService {
private HttpService httpService;
private SomeOtherService someOtherService;
private LogService logService;
public void start() {
logService.log(LogService.LOG_INFO, “Starting”);
}
public void stop() {
logService.log(LogService.LOG_INFO, “Stopping”);
}
}

Code size reduction:Code size reduction:
public class Activator implements BundleActivator {
private BundleContext context;
private ServiceRegistration registration;
private AudioBroadcaster audioBroadcaster;
private AudioSource audioSource;
private AudioEncoder audioEncoder;
private ServiceTracker audioSourceTracker;
private ServiceTracker audioEncoderTracker;
private ServiceTracker logTracker;
public void start(BundleContext context) throws Exception {
this.context = context;
audioSourceTracker = new ServiceTracker(context,
AudioSource.class.getName(), customizer);
audioEncoderTracker = new ServiceTracker(context,
AudioEncoder.class.getName(), customizer);
logTracker = new ServiceTracker(context, LogService.class.getName(),
null);
logTracker.open();
audioSourceTracker.open();
audioEncoderTracker.open();
}
public void stop(BundleContext context) throws Exception {
audioSourceTracker.close();
audioEncoderTracker.close();
logTracker.close();
}
private ServiceTrackerCustomizer customizer =
new ServiceTrackerCustomizer() {
public Object addingService(ServiceReference reference) {
Object service = context.getService(reference);
setService(reference, service);
return service;
}
private void setService(ServiceReference reference, Object service) {
// update service references
Object objectclass = reference.getProperty(Constants.OBJECTCLASS);
if (objectclass instanceof String) {
String name = (String) objectclass;
setNamedService(service, name);
}
if (objectclass instanceof String[]) {
String[] names = (String[]) objectclass;
for (int i = 0; i < names.length; i++) {
setNamedService(service, names[i]);
}
}
// register service if necessary
if ((registration == null) && (audioSource != null)
&& (audioEncoder != null)) {
// instantiate the implementation and pass the services
audioBroadcaster = new AudioBroadcasterImpl(audioSource,
audioEncoder, logTracker);
registration = context.registerService(
AudioBroadcaster.class.getName(), audioBroadcaster, null);
}
// unregister service if necessary
if (((audioSource == null) || (audioEncoder == null))
&& (registration != null)) {
registration.unregister();
registration = null;
audioBroadcaster = null;
}
}
private void setNamedService(Object service, String name) {
if (AudioEncoder.class.getName().equals(name)) {
audioEncoder = (AudioEncoder) service;
}
else if (AudioSource.class.getName().equals(name)) {
audioSource = (AudioSource) service;
}
}
public void modifiedService(ServiceReference reference,
Object service) {
}
public void removedService(ServiceReference reference,
Object service) {
setService(reference, null);
context.ungetService(reference);
}
};
}
public void init(BundleContext ctx, DependencyManager manager)
throws Exception {
manager.add(createService()
.setInterface(AudioBroadcaster.class.getName(), null)
.setImplementation(AudioBroadcasterImpl.class));
.setService(AudioSource.class, null)
.setRequired(true))
.setService(AudioEncoder.class, null)
.setRequired(true))
.setService(LogService.class, null)
}
public void destroy(BundleContext ctx, DependencyManager manager)
throws Exception {
}
}

Tracking dependenciesTracking dependencies
•• Setting up a service with an optional dependencySetting up a service with an optional dependency
that can track multiple dependent services:that can track multiple dependent services:
public void init(BundleContext bc, DependencyManager dm) {
dm.add(createService()
.setImplementation(DeviceTracker.class)
.setService(Device.class)
.setAutoConfig(false)
.setCallbacks(“addDevice”, “removeDevice”)
);
}
public void destroy(BundleContext bc, DependencyManager dm) {
}
}

Tracking dependenciesTracking dependencies
•• Implementation:Implementation:
public class DeviceTracker {
private List devs = new ArrayList();
public void addDevice(ServiceReference ref, Object srv) {
devs.add(srv);
}
public void removeDevice(ServiceReference ref, Object srv) {
devs.remove(srv);
}
}

Architecture: class diagramArchitecture: class diagram

Other features:Other features:
•• Injection of BundleContext and ServiceRegistrationInjection of BundleContext and ServiceRegistration
•• New services and dependencies can be added orNew services and dependencies can be added or
removed dynamicallyremoved dynamically
•• Callbacks are configurable and will look for methodsCallbacks are configurable and will look for methods
withwith ““suitablesuitable”” signaturessignatures
•• Service listeners allow you to track the state of aService listeners allow you to track the state of a
serviceservice
•• Manager allows for addition of customizedManager allows for addition of customized
dependencies (so you're not limited to servicedependencies (so you're not limited to service
dependencies)dependencies)

ConclusionsConclusions
•• Clean separation between service implementationClean separation between service implementation
and dependency management, you can use a POJOand dependency management, you can use a POJO
if you wantif you want
•• Dynamic nature of dependencies has proven to beDynamic nature of dependencies has proven to be
useful in several scenariosuseful in several scenarios
•• Substantial code reduction is realized whenSubstantial code reduction is realized when
compared to using service trackerscompared to using service trackers

Further infoFurther info
•• Contacting me:Contacting me:
ee--mail: marcel.offermans@luminis.nlmail: marcel.offermans@luminis.nl
ICQ: 22100024ICQ: 22100024
Skype: marcel_offermansSkype: marcel_offermans
•• Article:Article:
http://www.osgi.org/news_events/articles.asp?section=4http://www.osgi.org/news_events/articles.asp?section=4
•• Development site:Development site:
https://opensource.luminis.net/confluence/x/PwEhttps://opensource.luminis.net/confluence/x/PwE

Automatically Managing Service Dependencies in an OSGi Environment - Marcel Oﬀermans, Senior Software Engineer, Luminis

More Related Content

What's hot (20)

Similar to Automatically Managing Service Dependencies in an OSGi Environment - Marcel Oﬀermans, Senior Software Engineer, Luminis (20)

More from mfrancis (20)

Recently uploaded (20)

Automatically Managing Service Dependencies in an OSGi Environment - Marcel Oﬀermans, Senior Software Engineer, Luminis