How Nimble is your OSGi runtime?
Hands up all of you managing OSGi dependencies via an editable list of bundles. Easy isn't it! It just works right!?
Well actually - it 'just works' for a single application running in a small number of containers. From an enterprise perspective you are unintentionally contributing to an impending complexity meltdown; an explosion of dependency and configuration management issues. And if you are unfortunate enough to end up supporting your own composite creations, you may well end up envying the fate of Prometheus and rueing the day you learnt to code.
Possible harsh? But I'm not alone voicing this concern!
In his recent article "Reuse: Is the Dream Dead?", Kirk Knoernschild continues his efforts to educate the industry on the tensions between code 're-use' and 'simplicity of use'. Kirk argues that as you increase potential re-use via lightweight fine-grained components, the complexity of dependencies and necessary environmental configurations corresponding increase, so making these same components harder to use.
A simple concept, yet if unaddressed, an issue that will make your life as an enterprise developer increasing uncomfortable and help edge OSGi closer to that seemingly inevitable 'trough of disillusionment'.
Yet, from a development perspective the issue of dependency management is well understood.
Whilst initially found wanting, a number of projects now exist to address this; including the SIGIL eclipse plug-in which Paremus recently contributed to the Apache Felix project, (SIGIL leveraging Peter Krien's BND tool).
In contrast, the issue of dependency management in Production is less immediately obvious, its impact more profound and generally ignored.
* Will aspects of the runtime environment affect the runtime dependencies within the application?
* Will applications be isolated from each other, or might they run within the same JVM?
* How are the released artifacts subsequently managed in the production environment with respect to ongoing bundle dependency and version management?
Echoing Kirk's concerns, Robert Dunne started his presentation at OSGi DevCon Europe with the observation that; 'whilst modularity was good, its benefits are often undermined by dependency and configuration complexity'. The subject of Robert's presentation? The Paremus Nimble Resolver, which is our response to the concerns posed by Kirk.
Nimble is a high performance runtime dependency resolver. To deploy a composite application to a Nimble enabled runtime (i.e. the Paremus Service Fabric) one specifies:
* The root component of the artifact.
* And a set of associated policies and constraints.
Nimble then does the rest.
Presented with the 'root', Nimble dynamical constructs the target composite; ensuring that the structural dependencies are resolved in a manner consistent with both organizational policies and the runtime environment within which it finds itself.
Nimble's OSGi capabilities include:
* Fragment attachment policies.
* Optional import policies.
* Import version range narrowing.
* The ability to resolve dependencies on extender bundles (DS, 'classic' Spring, Spring DM, iPOJO).
With Nimble policies allowing:
* The configuration of selected extensions.
* Flexible constraint requirement -> capability matching.
* The ability to configure optional dependency resolution behaviors.
Not just OSGi, Nimble is a generic artifact resolver with a plug-able architecture. Any artifact type may be supported, with support currently available for:
* OSGi Bundles
* POJO's, 'classic' Spring & Spring DM
A Nimble enable runtime quite literally dynamically assembles all required runtime application and infrastructure service dependencies around the deployed business components! Specify a WAR artifact and Nimble will instantiate the appropriate Servlet engine dictated by runtime policy attached to the WAR; i.e. Tomcat or Jetty Sir? Specify a 'Configuration', and Nimble responds by installing the target of the configuration, and of-course its dependencies.