OSGi Architecture

OSGi is a standard that defining Dynamic Component Development for Java.

Its specification that define the API to develop dynamic components in java application development. As per OSGi application composed of several components and components are packaged as bundle.

Java to build complex application is big challenge where OSGi defining way to divide application into several bundles and each bundle composed with several components.

OSGi is providing environment where all these bundles and components can communicate each other such way we can run complex application.

Component:

Component is small unit of application and it called as some feature in the application. Component cam work independently or it can collaborate with other component to full fill the requirement in the application.

Bundle:

Bundle is composed with several components and OSGi we package components as bundles and we will deploy bundles into OSGi container.

Services:

Services are part of component and it will full fill one more tasks. OSGi we can export and import services such as way we can make available services to other components or bundles.

Modules:

Module is basic terminology in OSGi modular development and these modularity concept achieved through bundles. Modules and bundles are same.

 OSGi Layers.

OSGi architecture divided into several layers. I have taken the following picture from enRoute.

Source of image: enroute

Bundles:

Bundles are packaged components developed by OSGi developers. Bundle is packaged as JAR file and we can deploy into OSGi containers.

Services:

Services layer provide mechanism to share services between bundles. It will provide environment to register services and make available to other bundles. We have concept called publish-find-bind. We have different framework to achieve this concept. Declarative Services and Apache Service Component Runtime are the implementation for this concept.

Life Cycle:

Life Cycle is responsible to manage lifecycle of bundles. OSGi bundle have several lifecycle stages install, start, update, stop and uninstall. All these stages handles in this layer.

Module:

Module layer is define the import / export the code of the bundles. Usually we will use export/import headers in the OSGi manifest file that will handle in module layer.

Execution Environment.

Execution Environment layer define the classes and methods are available to the platform.

Security:

Security layer define standards security to the OSGi applications. How your modules available to the other platforms and it will define some permission system.

Java VM

Java VM layer is provide the JAVA run time environment. Its basic layer in the OSGi.

Operating System

It will provide standard Operating System to the OSGi environments.

Deployment

OSGi provide run time container there we can deploy bundles. Bundles are standard package system where we can package all java classes and interfaces. Bundle is JAR file. We have different commands provided by OSGi command line interface to deploy bundles.

Implementation

OSGi specification implemented by several vendors’ popular vendors Equinox and Apache Felix. We can develop OSGi application which target to anyone of these implementations. Both implementations are followed the OSGi standard specification. There may be few features vendor specific but most of the implementation as per OSGi specification.

Reference:

http://enroute.osgi.org/doc/100-about-osgi.html

Author

Meera Prince

Liferay Contributor of the Year 2016
Liferay Top Contributor Award Winner 2015

Liferay Contributor of the Year 2014

Liferay Top Contributor Award Winner 2013

http://www.liferaysavvy.com 

Read More

Open Services Gateway Initiative (OSGi) Introduction

The Open Services Gateway Initiative (OSGi) is specification that defines modular based software management and its execution. OSGi makes software management and its execution simpler by making large application into small bunch of pieces and we call it as module. These modules are working independent way so that when we need we can start module and we can stop module. As for OSGi a module is Bundle or Plugin-in

OSGi provides execution environment so that we can install, start and stop module whenever we required such a way OSGi provides OSGi containers to manage lifecycle of these bundles.

Bundle/Plug-In/Software component

Bundle is a collection Java classes and resources make it as package then we call it as bundle and these bundle can be working as independent or it can be depends on other bundle or plugin. We can say bundle is small piece of software and as for OSGi we can specify as OSGi bundle.

Note:

As for our understand bundle is java jar file.

OSGi specification

https://www.osgi.org/developer/specifications/

OSGi implementations

After release of OSGi specification by OSGi Alliance in March 1999 then people implemented specifications as software and the following are popular implementation software open source groups.

Equinox

Equinox is reference implementation of OSGi from eclipse and they have implanted OSGi software so that it provides runtime environment for OSGi based software development.

http://www.eclipse.org/equinox/documents/quickstart.php

Apache Felix

Felix is also implemented OSGi specification from Apache and its open source implementation.

http://felix.apache.org/

Knopflerfish

Knopflerfish is another Open source Implementation for OSGi

https://www.knopflerfish.org/

Note:

All above implementation covered all specifications of OSGi R3 and OSGi R4 specifications.

Software Developers can use any one of the implementation to implement their software as modular based way. We can also inherited features from above all implementations.

All OSGi implementations they packages as jar file so that it will provide execution environment for OSGi bundles. OSGi have basic standalone container to execute bundles and if we want other environments support we need to take relevant environment support bundle so that it will provide execution environment for different kind of environment.

Basic OSGi implementation Jars

From Apache Felix

felix.jar

Start the framework

From the installation directory by typing in the terminal

java -jar bin/felix.jar

From Eclipse Equinox

org.eclipse.osgi_3.2.0.jar

Start OSGi Framework

java -jar org.eclipse.osgi_3.2.0.jar –console

The above implementation jars covered all specification that defined by OSGi so that we can develop OSGi bundles then we can run it on OSGi containers.

OSGi bundle Lifecycle

As for software development mode each software component have its own lifecycle same way OSGi bundle also have its own lifecycle and these lifecycle will be manged by OSGi Framework implementation software or we can say OSGi containers.

The following are OSGi bundle lifecycle stages

Install Resolved Uninstall Start Active Stop

Install

Install is start point to OSGi bundle and we need to install OSGi bundle with help OSGi commands then Bundle will be available in OSGi container.

Resolve

In the resolve stage it will check all dependent bundles and its required bundles if everything satisfied then it will moved to other stage otherwise it will be uninstalled.

Uninstall

Uninstall is completely removing OSGi bundle from OSGi container and this we can manually uninstall with command or If the bundle not resolved by all decencies then it’s automatically uninstalled.

Start

After all dependencies and required bundles are resolved then bundle will be started, once bundle is started then it will be available for use.

Active

Once bundle available to use in OSGi container then we will make it active so that it will be under real usage and it we can experience as end user.

Stop

Stop stage we can make OSGi bundle inactive so that it will not available for real use but still Bundle available for OSGi container.

The following are the commands to working with OSGi Bundle lifecycle

Apache Felix

The following are the commands to working with bundle lifecycle and we need to provide bundle path as variable for each command.

felix:install file:/path/to/bundle/bundle.jar felix:start file:/path/to/bundle/bundle.jar felix:stop file:/path/to/bundle/bundle.jar felix:update file:/path/to/bundle/bundle.jar felix:uninstall file:/path/to/bundle/bundle.jar

To work with shell based commands Apache Felix uses another OSGi bundle called Apache Felix GOGO

Apache Felix GOGO

Apache Felix GOGO is sub project of Apache Felix and it provide command based interface to working with OSGi bundles lifecycle.

http://felix.apache.org/documentation/subprojects/apache-felix-gogo.html

The Gogo subproject of Apache Felix and its consists of three bundles

Runtime

Implements the core command processing functionality.

The following is Bundle implemented Runtime

org.apache.felix.gogo.runtime.jar

Shell

 Provides a simple textual user interface to interact with the command processor.

The following is Bundle implemented Shell

org.apache.felix.gogo.shell.jar

Command

 Implements a set of basic commands.

org.apache.felix.gogo.command.jar

Note:

Apache Felix GoGo is already included in the Apache Felix Framework Software so as soon as we start Felix OSGi jar file then it will be available as console so that we can use above specified commands to manage bundle lifecycle.

Example Gogo Console

Open your terminal in you system start Felix Framework jar file then you can see Apache Felix GoGo console.

$ cd felix-framework-3.0.0 $ java -jar bin/felix.jar _______________ Welcome to Apache Felix Gogo g! lb START LEVEL 1    ID|State      |Level|Name     0|Active     |    0|System Bundle (3.0.0)     1|Active     |    1|Apache Felix Bundle Repository (1.6.2)     2|Active     |    1|Apache Felix Gogo Command (0.6.0)     3|Active     |    1|Apache Felix Gogo Runtime (0.6.0)     4|Active     |    1|Apache Felix Gogo Shell (0.6.0)     5|Installed  |    1|Example Bundle (1.0.0) g! start 5 Hello from Bundle 5. g!

lb command list the available bundle in OSGi container and to start the bundle we can specify the bundle order number as argument.

Equinox

Similar to Apache Felix equinox also have similar commands and its console to work with bundle lifecycle

install <bundle URL> Installs the bundle from the given URL start <bundle # or bundle name> Starts the bundle with the given numeric or symbolic id stop <bundle # or bundle name> Stops the bundle with the given numeric or symbolic id ss Reports a summary status of all installed bundles diag <bundle # or bundle name>  Reports any resolution problems for the bundle with the given numeric or symbolic id

Equinox also implemented OSGi console using following bundle

org.eclipse.equinox.console.jar

Internally Equinox also used Apache Felix gogo to provide command line interface and along with Equinox console.

Example of Equinox Console

osgi> ss "Framework is launched." id         State       Bundle 0          ACTIVE      org.eclipse.osgi_3.10.0.v20140606-1445 1          ACTIVE      org.apache.felix.gogo.runtime_0.10.0.v201209301036 2          ACTIVE      org.apache.felix.gogo.command_0.10.0.v201209301215 3          ACTIVE      com.meera.sample.HelloWorld_1.0.0.qualifier 4          ACTIVE      org.apache.felix.gogo.shell_0.10.0.v201212101605 5          ACTIVE      org.eclipse.equinox.console_1.1.0.v20140131-1639 osgi> stop 3 Goodbye World!! osgi> start 3 Hello World!! Osgi

SS will use to list available bundles in OSGi container and we will use Bundle number in to start or stop bundle.

To work with Basic OSGi development using Apache Felix we need following bundles

felix.jar org.apache.felix.gogo.runtime.jar org.apache.felix.gogo.command.jar org.apache.felix.gogo.shell.jar

To work with Basic OSGi development using Equinox we need following bundles

org.eclipse.osgi_3.10.0.jar org.apache.felix.gogo.runtime.jar org.apache.felix.gogo.command.jar org.apache.felix.gogo.shell.jar org.eclipse.equinox.console.jar

If we want work with other environments such as web applications we should have other OSGi bundle to provide execution run time environment.

Example:

To work with web application environment using OSGi we need following OSGi implementation bundles

Apache Felix HTTP Service http://felix.apache.org/documentation/subprojects/apache-felix-web-console.html Apache Felix Web Console http://felix.apache.org/documentation/subprojects/apache-felix-http-service.html Apache Felix Log http://felix.apache.org/documentation/subprojects/apache-felix-log.html

Similarly we need different implementation OSGi bundle to provide different types of environments.

In this case we need to setting up required bundles so that we can create execution environment rather than this there is project from Apache called Apache Arise it will provide all types of pluggable OSGi plugins to create different types of execution environment

Apache Aries

The Aries project consists of a set of pluggable Java components enabling an enterprise OSGi application programming model. This includes implementations (and extensions) of the following Enterprise OSGi specifications

http://aries.apache.org/

Asynchronous Services and Promises Specification Blueprint Specification JTA Transaction Services Specification JMX Management Model Specification JNDI Services Specification JPA Service Specification Service Loader Mediator Specification Subsystem Service Specification

Author

Meera Prince

Liferay Contributor of The Year 2014

Liferay Top Contributor Award Winner 2013

http://www.liferaysavvy.com 

Read More