aqute r4 by peter kriens ceo aqute osgi technology officer and osgi fellow

aQute R4

By Peter KriensCEO aQute

OSGi Technology Officer andOSGi Fellow

©1999-2004 aQute, All Rights Reserved slide #2

Preliminar

ya

Contents


Preliminar

ya

Bundle Changes

• In R3 there is no distinction between the classloader and the JAR file.

• Impossible to get resources from a JAR without creating a class loader: expensive– Bundle.getEntryPaths(String prefix)– Bundle.getEntry(String path)

• Not possible to load a class explicitly from a bundle– Necessary for the Class.forName pattern– Bundle.loadClass(String class)


Preliminar

ya

Versions

• In R3 versions are treated as strings

• In R4, versions will have well defined semantics– <major>. <minor>.<micro>.<qualifier>

• A version class holds those semantics

• Versions can now also be expressed as ranges:– version-range ::= ('”' interval '”') | atleast– interval ::= [ '[‘ | '(‘ ] floor ’,’ ceiling [ ']‘ | ')‘ ]– atleast ::= floor | ('”' floor '”')– floor ::= version– ceiling ::= version


Preliminar

ya

Versions

• Range Inequality Test

• [floor,ceiling) floor ≤ x < ceiling

• [floor,ceiling] floor ≤ x ≤ ceiling

• (floor,ceiling) floor < x < ceiling

• (floor,ceiling] floor < x ≤ ceiling

• floor floor ≤ x


Preliminar

ya

New Events

• Bundle RESOLVED/UNRESOLVED Event– Send out when the bundle is resolved/unresolved to

BundleListeners

• Framework INFO and WARNING events– Send out when there are issues in the Framework that

are not not errors but are interesting to know for the operator


Preliminar

ya

Manifest Localization

• The current bundle manifest contains information about the bundle.

• Some of this information is human readable.

• There is no means for this information to be localized when retrieved such as via Bundle.getHeaders()

• Translations will be supported by using a name starting with a % in the value part of the header

• This name is then searched in properties file in the bundle


Preliminar

ya


• META-INF/MANIFEST.MF– Bundle-Name: %acmebundle– Bundle-Vendor: %acmecorporation– Bundle-Description: %acmedescription– Bundle-Activator: com.acme.bundle.Activator– Bundle-Localization: localization/bundlemanifest– Acme-Defined-Header: %acme special header

• localization/bundle_en.properties– acmebundle=The ACME Bundle– acmecorporation=The ACME Corporation– acmedescription=The ACME Bundle provides all of the

ACME services– acme special header=User Defined Acme Data


Preliminar

ya


• The Bundle interface defines the following methods to retrieve manifest header information: – getHeaders() - Returns a Dictionary object that contains the bundle’s manifest

headers and values as key/value pairs. The values returned are localized according to the locale returned by java.util.Locale.getDefault.

– getHeaders(String locale). - Returns a Dictionary object that contains the bundle’s manifest headers and values as key/value pairs. The values returned are localized using the specified locale.

– getHeaders(null) - The locale returned by java.util.Locale.getDefault is used. – getHeaders(“”) - Will return the raw (unlocalized) manifest headers including

any leading ‘%’.

• The getHeaders() methods must continue to provide the manifest header information after the bundle enters the UNINSTALLED state. After the bundle has been uninstalled, this method will only return manifest headers localized for the default locale at the time the bundle was uninstalled.

• A framework implementation must use only the raw (unlocalized) manifest headers when processing manifest headers that have semantic meaning.


Preliminar

ya

Package Admin

• Providing Bundle– Information about the bundle that provides a package

• getProvidingBundles(String symbolicName)

• getBundles(String symbolicName, String versionRange)

• getFragments(Bundle host)

• getHosts(Bundle fragment)

• getBundleType(Bundle bundle)– BUNDLE_TYPE_FRAGMENT

• resolveBundles(Bundle[])


Preliminar

ya

Modularization

• The standard Java platform provides limited support for packaging, deploying, and validating Java-based applications and components.

• The .NET platform explicitly addresses these issues by introducing assemblies and the Global Assembly Cache (GAC). Assemblies define how applications and application components are packaged and deployed, while the GAC manages the dependencies among assemblies to ensure that they are validly resolved.

• In Java, the closest analogy to an assembly is a JAR file, but there is no analogy to the GAC. As a result of this, many Java-based projects, such as jBoss and NetBeans, have resorted to creating custom module-oriented layers with specialized class loaders for packaging, deploying, and validating applications and components.


Preliminar

ya

Modularization

• As an alternative, the OSGi R3 framework provides capabilities that are useful in a generic Java module framework. – A unit of modularization (i.e. a bundle), where the modules

export and import packages among each other. – A simple module life cycle. – A framework to manage the module life cycle to ensure validity

• It is clear from these capabilities that the R3 framework provides a significant improvement over standard Java.

• However, the R3 framework does have some serious limitations as a generic module framework.


Preliminar

ya

Modularization

• Specifically, the R3 framework is limited to the following characteristics:– Only one version of a shared package can exist in the JVM among

modules at any given time. While it is possible to load multiple versions of a specific package, this can only be accomplished by using private packages that are embedded in the module and which cannot be shared with other modules.

– Importing modules do not have any influence over which provider is used to resolve their dependency, other than by specifying a version number.

– The version compatibility policy when declaring an import is hard-coded to “greater than or equal to” a given version number, which is impractical for many real-world project situations.

– Exporting modules have no way to indicate that they are providing a related set of packages that must be used in an all-or-nothing fashion. This may be necessary if there are implementation dependencies among packages. Consequently, an importer might get the packages from multiple providers, which would break the implementation dependencies.


Preliminar

ya

Modularization

• Many of these characteristics are not truly limitations of the OSGi framework– They result from the fact that the framework was not

designed to be a generic module framework for Java.

• Understanding these limitations does, however, provide insight into the degrees of freedom necessary to create a generic module framework for Java


Preliminar

ya

Requirements

• Static Analysis– Tools

• Class Sharing– Importing– Exporting– Propagating

• Version Constraints

• Provider Selection

• Package Grouping

• Package Multiplicity– Singleton

Importer

Package

Exporter Av1

Exporter Cv2,x=3

Exporter Bv2

Package

Import specification

Export specification


Preliminar

ya

Modularity headers

• Export-Package ::= package-description ( ',' package-description )*

• package-description ::= package-names ( ';' parameter )*

• package-names ::= package-name ( ‘;’ package-name )*

• package-name ::= <fully qualified package name>

• parameter ::= attribute '=' value

• attribute ::= token

• value ::= token | quoted-string


Preliminar

ya

Modularity Attributes

• version – the version of the named packages

• grouping – a string value. Exports, and propagated imports, from a given module with the same value are grouped

• bundle-symbolic-name – The bundle exporting the package must have this name

• bundle-version – the bundle version associated with the export statement

• Arbitrary attributes …


Preliminar

ya

Modularity Import

• version - a version range to select the exporter’s implementation version. The default value is “0.0.0” .

• propagate – Imported packages should be made visible so that they can be imported from the propagating module.

• grouping – Propagated imports, and exports are associated together into an “export group”

• resolution– “static” indicates that the import must be resolved when the

importing module is resolved or otherwise fail– “optional” indicates that the import is optional and the

importing module may be resolved without the import being resolved

– “dynamic” indicates that the importing module may be resolved without the import being resolved. An attempt to resolve the import is made as necessary, e.g. during class loading.


Preliminar

ya

Declarative Service: Why?

• Currently programming for OSGi must take the dynamics of services that come and go into account. This is:– Error prone– Often very disruptive for the

programmer– Albeit powerful

???


Preliminar

ya

Declarative Services: Why?

• Bundles can only be started when their package dependencies are resolved

• There exists an Import-Service and Export-Service header but this is ignored by the Framework

• This dependency must thus be handled by the programmer


Preliminar

ya

Declarative Services: Why?

• Startup time is a significant problem in frameworks like OSGi because of the number of components.

• It would be preferred to defer initialization until the component is actually needed

• This will allow the presence of a large number of components at little cost– Lazy Initialization– Creation of class loader must be done as late as possible

• Eclipse’s Extension Points taught us a lot! (And our services taught Eclipse’s team a lot!)


Preliminar

ya

Declarative Services

• Declarative services use a file in the bundle to specify a Service Component and its dependencies

• What are Service Components?– A piece of code that runs on an OSGi framework– Defined by a Java interface– May provide an OSGi service to the registry– May depend on a number of services– Will always be executed inside the context of a bundle.

I.e. if the bundle is stopped, the component is no longer available

– Inherits the bundle dependencies– Activation can be delayed until the component is used


Preliminar

ya

Example declaration

<?xml version="1.0" encoding="UTF-8"?><bundle> <component name=“com.acme.Quoter"> <implementation class="com.acme.quote.QuoterImpl" /> <service> <provide interface="org.grasso.Quoter"/> </service> <reference name=“queue” interface=“com.ibm.mq.MQ“ cardinality="1..n“ policy="static“ target="(vendor~=IBM)“ /> <reference name=“log” interface=“org.osgi.service.log.LogService“ cardinality="1“ policy=“dynamic“ target="“ /> </component></bundle>

org.grasso.Quoter

Depends on

com.ibm.queue

org.osgi.service.log

IBM Oracle

com.acme.Quoter


Preliminar

ya

Declarative Services: References

• Each reference to another service has– A name (e.g. log). This name is used to bind the

service to the component (push or pull) and/or to configure it

– A cardinality (e.g. 1..n). This specifies how many matching services need to be available

– A policy (e.g. static) which indicate if the references may be updated or are required to remain constant during the life of the component

– A target (e.g. vendor~=IBM), which expresses a filter requirement on the referenced services


Preliminar

ya

Declarative services: Configuration

• References have a default target definition

• The default may be overridden with Configuration Admin

• Each component has a unique id

• This id is matched to a Configuration object

• If the Configuration object has a key that matches the reference’s name, that value is used instead

com.acme.Quoter

ConfigurationDatabase

com.ibm.queue

org.osgi.service.log

org.grasso.Quoter

Oracle IBM

target=“vendor~=IBM”

com.acme.quoter:log=“vendor~=Oracle”


Preliminar

ya

Component API

• A component becomes available when its dependencies can be fulfilled– An appropriate service is registered– No actual class loading takes place!

• When the service is used, the component is created by the declarative services runtime

• If the component implements an activate method, it is called to indicate initialization. The ComponentContext is given as a parameter

• If the component has implemented bindXXX methods (where XXX is the name of a reference) the runtime will call these methods according to the cardinality and policy

• The component is then returned as the service• Service Factories will be supported as well where the component can

be customized for a specific bundle• Bind and initialization methods may be private, the runtime will use

reflection to call them– This allows the component to be registered as service without exposing public

functions that could be abused


Preliminar

ya

Lookup

• Instead of using a bind model (push) it is also possible to use a pull model

• The ComponentContext contains a locate() method that allows the component to locate the references. – The parameter of the locate method is the name of

the reference– The indirection through configuration management is

maintained


Preliminar

ya

Declarative Services: Example

• The MyValue Service Component is a business process

• It references two Service Components

• CustomerInfo– Given the customer identification it

provides the symbol of the stock and number of shares.

• StockQuote– Returns the current value of the

stock.

• The MyValue Service Component calls the CustomerInfo, and with the returned symbol it then calls StockQuote.

• After that it multiplies the number of shares returned from the CustomerInfo with the quote returned by the StockQuote

MyValue

service…StockQuote

service…CustomerInfo

squote

cinfo

process…MyValue

StockQuote

CustomerInfo


Preliminar

ya

MyValue



squote

cinfo

process…MyValue

StockQuote

CustomerInfo


• package service.customerinfo;• public interface CustomerInfo { public Customer getCustomerInfo(String

customerID); }• public class Customer { }

• package service.customerinfo.impl;• import service.customerinfo.*;• public class CustomerInfoImpl implements CustomerInfo {• public Customer getCustomerInfo(String customerID) { • Customer cust = new Customer();• cust.setCustNo(customerID);

cust.setName("Victor Hugo");• cust.setSymbol("IBM");

cust.setNumShares(100);• cust.setErrorMsg(""); return cust;• } }

• <?xml version="1.0" encoding="UTF-8"?>• <bundle>• <component name="service/customerinfo/CustomerInfo">• <implementation

class="service.customerinfo.impl.CustomerInfoImpl"/>• <service>• <provide interface="service.customerinfo.CustomerInfo"/>• </service>• </component>• </bundle>


Preliminar

ya


• package service.stockquote;• public interface StockQuote {• public float getQuote(String symbol);• }• package service.stockquote.impl;• import service.stockquote.*;• public class StockQuoteImpl implements StockQuote {• public float getQuote(String symbol) {• // Interaction with business logic would go• return 100.0f;• }• }

• <?xml version="1.0" encoding="UTF-8"?>• <bundle>• <component name="service/stockquote/StockQuote">• <implementation

class="service.stockquote.impl.StockQuoteImpl"/>• <service>• <provide

interface="service.stockquote.StockQuote"/>• </service>• </component>• </bundle>

MyValue



squote

cinfo

process…MyValue

StockQuote

CustomerInfo


Preliminar

ya

Declarative Services: Pop Model

• package process.myvalue;• public interface MyValue {• public float myValue(String customerID) throws

MyValueException;• }

• package process.myvalue.impl;• import process.myvalue.*;• import org.osgi.service.component.ComponentContext;• public class MyValueImpl implements MyValue {• private ComponentContext context;• void activate(ComponentContext context) { this.context =

context;}• public float myValue(String customerID) throws

MyValueException {• Customer customer = null;• float quote = 0, value = 0;• CustomerInfo cInfo =

(CustomerInfo)context.locateService("customerInfo");• customer = cInfo.getCustomerInfo(customerID);• if (customer.getErrorMsg().equals("")) {• StockQuote sQuote =

(StockQuote)context.locateService("stockQuote");• quote = sQuote.getQuote(customer.getSymbol());

value = quote * customer.getNumShares();• } else throw new

MyValueException(customer.getErrorMsg());• return value;• }• private void deactivate(ComponentContext context)

{ this.context = null; }}

MyValue



squote

cinfo

process…MyValue

StockQuote

CustomerInfo


Preliminar

ya


• <?xml version="1.0" encoding="UTF-8"?>• <bundle>• <component name="process/myvalue/MyValue">• <implementation

class="process.myvalue.impl.MyValueImpl" />• <service>• <provide

interface="process.myvalue.MyValue"/>• </service>• <reference name="customerInfo"• interface="service.customerinfo.CustomerInfo"• cardinality="1..1"• policy="static"•

target="(service.name=service/customerinfo/CustomerInfo)"

• />• <reference name="stockQuote"• interface="service.stockquote.StockQuote"• cardinality="1..1"• policy="static"•

target="(service.name=service/stockquote/StockQuote)"• />• </component>• </bundle>

MyValue



squote

cinfo

process…MyValue

StockQuote

CustomerInfo


Preliminar

ya

Declarative Services: Push model

• package process.myvalue.impl;• import process.myvalue.*;• public class MyValueImpl implements MyValue {• private ComponentContext context;• private CustomerInfo cInfo;• private StockQuote sQuote;• private void bindCustomerInfo(CustomerInfo cInfo) { • this.cInfo = cInfo; }• private void unbindCustomerInfo(CustomerInfo cInfo) { • this.cInfo = null; }• private void bindStockQuote(StockQuote sQuote) { • this. sQuote = sQuote; }• private void unbindStockQuote(StockQuote sQuote) { • this. sQuote = null; }• public float myValue(String customerID) throws

MyValueException {• Customer customer = null;• float quote = 0, value = 0;• customer = cInfo.getCustomerInfo(customerID);• if (customer.getErrorMsg().equals("")) {• quote = sQuote.getQuote(customer.getSymbol());• value = quote * customer.getNumShares();• } else throw new

MyValueException(customer.getErrorMsg());• return value;• }• }

MyValue



squote

cinfo

process…MyValue

StockQuote

CustomerInfo


Preliminar

ya

Relation MEG Application Model

• The MEG Application Model (which is in development) will likely use the same model as declarative services

• Current problem is that applications can be launched multiple times and declarative services are singletons


Preliminar

ya

Native Code Changes

• Native Code Matching Enhancements– Operating system name– Operating system version– Processor– Language

• Eclipse showed the need to extend the selection criteria– SWT depends not only on OS, but also on selected higher

layers like Motif– Added an optional filter for additional selection criteria.

• Sometimes libraries are optional, this could not be expressed. A missing library meant the bundle could not resolve– * at end is used to indicate that the header can match

without matching a particularly library


Preliminar

ya

Native Code Changes

• Bundle-NativeCode ::= nativecode-clause ( ’,’ nativecode-clause )* ( ’,’ optional-clause )?

• nativecode-clause ::= nativepath ( ’;’ nativepath )* ( ’;’ parameter )*

• nativepaths ::= jar-path | (’”’jar-path’”’)• parameter ::= ( processordef | osnamedef | osversiondef |

languagedef | filterdef )• processordef ::= ’processor’ ’=’ value• osnamedef ::= ’osname’ ’=’ value• osversiondef ::= ’osversion’ ’=’ version-range• languagedef ::= ’language’ ’=’ value• filterdef ::= ’selection-filter’ ’=’ quoted-string• value ::= token | quoted-string• optional-clause ::= ’*’


Preliminar

ya

Permissions

• Bundles can be signed with public key encryption

• Permission Admin can associate a signer with a set of permissions

• Bundles that are downloaded can also contain a permission file that limits those permissions– Can not extend the signers

scope

• This allows the signer to control the permissions used on the system

• It allows the operator to still control the maximum allowed permissions

Developer

Signer

Operator

SpecifiesNeeded permission

VerifiesPermissionsAnd fixes them

EnclosesPermissions

OSGiEnvironment

Download andCheck permissionsAs defined by signerNot allowing more than signer


Preliminar

ya

AdminPermission

• OSGi R3 has an AdminPermission that is very coarse

– No parameters, i.e. a blank permission– Implicit assumption that there is only a

single management agent

• The enterprise model (where the Enterprise can manage part of the device) collides with this assumption

• R4 will therefore have an AdminPermission that will take parameters

– The target of the permission is the bundle

– The bundle can be identified by the signer or the id

• The action represents all places where AdminPermission is currently used

AdminPermission

AdminPermission

AdminPermission

AdminPermission

AdminPermission

AdminPermission


Preliminar

ya

aQute

www.aQute.biz

+46 300 39800, [email protected]

z

aqute r4 by peter kriens ceo aqute osgi technology officer and osgi fellow

Documents

bundle information

rights reserved slide

expensive bundle

bundle interface

bundle necessary

bundle changes

version slide

current bundle manifest