OSGi Tutorials

This is a summary of the OSGi tutorials registered on the EclipseCon submission system. Please vote for your preference. This will require registration. If you do not want to vote, you cal also with your preferences. Please not that this is snapshot so that you can quickly get an overview of the possibilities.

Writing your own OSGi adaptor to enhance Eclipse classloading

(View Original) OSGi is a powerful platform that manages access to various resources, and allows users to plug in their own adaptors to change how classes and resources are loaded. Eclipse plugs into OSGi using this very mechanism, and anyone can easily specify their own adaptor to compliment or even replace the default eclipse classloading mechanism.

In this short tutorial, we will show three different adaptors that the presenter has contributed to. Two of them use special characteristics offered by the IBM J9 virtual machine and they load classes not just from a jar but instead load them from a memory mapped archive or from shared memory. The third adaptor implements a disk cache that optimizes startup times of really large Eclipse products.

Furthermore, we will demonstrate how an OSGi adaptor can be used to easily monitor OSGi applications and how an adaptor can be used to implement a full virtualization layer. We will also show other successful adaptors, in particular the one developed by the Eclipse aspect-oriented project.

After attending this tutorial, attendees will know how to write their own OSGI adaptor, how to configure the platform, and how to replace and/or compliment the default Eclipse adaptor with their own policies for class and resource loading.

Server-side OSGi applications -- using the OSGi framework to write server processes

(View Original) The OSGi framework provides modularisation, decoupling of components and dynamic lifecycle management. These features are well suited for a server-side environment, where a server will be up and running over a long period of time and may have modules come and go over the server's uptime.

This tutorial will teach the fundamentals of OSGi and how it can be applied to architecting and building new server platforms. This is not a tutorial about building web applications, and therefore we will focus on a non-web scenario. Our goal in the tutorial will be to build a fully functional and extendable Email (SMTP) server. This will allow us to demonstrate dynamic installation of bundles to implement spam filtering etc.

We assume basic knowledge of building OSGi bundles, eg previous experience of building Eclipse plug-ins. Attendees will learn the following:

• how services compare with Eclipse extensions
• how to offer services to other bundles, and the use of service factories to customize services for each consumer
• how to consume services offered by other bundles, common pitfalls, and the use of service trackers
• avoiding race conditions and starting-order dependencies
• using the OSGi console to inspect the runtime state of services
• design patterns for OSGi services such as the "whiteboard pattern"
• configuring the platform using the Configuration Admin service
• the use of Declarative Services to simplify development
• aspects of concurrency, for example: how threads interact with the OSGi runtime; avoiding blocking operations in threads owned by the framework; using the Event Admin service to post asynchronous notifications.

Finally we will discuss how OSGi can be used to implement servers that minimise downtime, including both planned and unplanned downtime, by distributing services across multiple JVMs.

Building Server-Side Eclipse based web applications

(View Original) Server-Side Eclipse is the latest effort to use the Eclipse architecture and the OSGi platform to develop modular web applications. This tutorial will introduce the technology, concepts and tools to develop Eclipse based web applications.

Audience

This tutorial targets developers and architects who want to develop a better understanding of whats required to build Eclipse-based web applications. They should be familiar with developing Eclipse RCP applications and standard JavaEE web applications.

Contents of tutorial

• Part 1: Introduction to Server-Side Eclipse
  • Basics of Server-Side Eclipse
  • Introduction to OSGi and bundles
  • The ClassLoader pain...
  • What is the OSGi HTTP service and HTTP registry ?
  • What is the Servletbridge ?
• Part 2: How to develop Server-Side Eclipse applications
  • How to setup Eclipse and server target
  • How workspace and projects should be setup
  • My first server bundle
  • Run and debug server bundles
  • Reuse of existing OSGi bundles (e.g. logging)
  • How to use the extension registry and extension points in server-side environments
• Part 3: Introduction to user interfaces
  • Overview of UI frameworks (RSP-UI, RAP, GWT)
  • Comparison of UI concepts
  • My first bundle using JSPs
  • Struts and other JavaEE frameworks</li>
  • A small RAP example
• Part 4: How to deploy Server-Side Eclipse applications
  • Possible deployment scenarios
  • Deploy a standalone server application (embedded HTTP service)
  • Integrate other HTTP services (e.g. Jetty)
  • Deploy a standard WAR application
  • Run within an external application server
• Part 5: Summary
  • Current state of development
  • What will be supported in Eclipse 3.3 and Equinox 3.3
  • Summary, Outlook

Prerequisites

Latest Eclipse 3.3 and Equinox 3.3 milestone builds, standalone application server (e.g. Tomcat 5.5.17 or later, Jetty 5.x or later).</p>

Building Service Oriented Bundle Architectures

(View Original) The OSGi software architecture standards provide a fantastic means for creating highly cohesive, yet loosely coupled applications, frameworks nd components. The Eclipse IDE plugin architecture is built on the OSGi architecture and Equinox provides an OSGi runtime platform. Outside the plugin problem space, OSGi has been used in applications for mobile phones, telematics, industrial automation, building automation, PDAs, healthcare, grid computing, fleet management, and application servers.

This tutorial introduces attendees to the world of the service-oriented bundle architecture (SOBA), where bundle services are imported and exported on demand. The benefit to this style of OSGi development stems from the ease of deployment of new functionality. Effectively delivering SOBA solutions requires a careful mix of disciplined adherence to convention and tooling support.

Attendees will experience building and deploying dynamic service-oriented bundles and applications. The day will cover best practices, suggested workflows, tooling usage, Equinox runtime launching, and client management. Provided with a small set of simulated sensor devices, access to some actual devices, a user interface shell, a client bundle manager, and an off-board communications channel, attendees with build and deploy a new SOBA application. Attendees will be given the option of implementing a scripted set of requirements or integrating the available simulators and real devices into a new scenario. Class instructors will be available throughout the day to work with the tutorial participants.

What Attendees Will Learn:

• Basics of Service Oriented Bundle Architectures (SOBA)
• Best Practices for Naming, Organization, Testing and Designing SOBA Systems
• Common workflow for specifying, testing, building, and deploying SOBA Systems
• Dynamic client content management of SOBA systems at runtime
• Using the PDE and extensions for building SOBA systems

Requirements

Attendees should already have experience doing Java development in the Eclipse Tooling Environment. A knowledge of basic OSGi principles and terminology is essential to getting the most out of the exercises. Readings will be made available prior to the tutorial to allow those without OSGi knowledge to gain some context.

The Instructors

All of the tutorial instructors have been building SOBA applications for six years, in telematics, defense, healthcare and industrial pplications.

Exercises

We have not yet worked out the specifics of the exercises, but will offer two options:

1. a well scripted exercise for those who like such things, and
2. an open exercise in which the attendee can combine the available service simulators and real devices to implement their own creative scenario.

We will provide a collection of sensor devices (real and simulated) and a means for off-board communications (server and/or peer-to-peer).

We can provide a wide array of simulated and real sensors, such as:

• Healthcare Related: blood pressure, pulse oximeter (heart rate and blood oxygen level)
• Hazardous Gas Sensors: volatile organic compounds, explosive limits, oxygen level
• Location Based: GPS (location, speed, direction, time)
• Others as time and opportunity permit

Notes

• Emphasis will be hands on exercises and actual development
• Slide/presentation content will be light � approximately 25% of total time
• Tutorial instructors will provide wandering assistance to attendees
• Attendees are strongly encouraged to attend in pairs and work as pairs.

Spring and OSGi combined

(View Original) The upcoming version of the Spring Framework will include a module that allows you to implement rich-clients as well as server-side applications combining the benefits of the Spring Framework and the OSGi runtime technology. This combination integrates the OSGi service model with the Spring bean model and allows you to realize bundle-based Spring context definitions, dependency injection across bundles and utilization of all the nice technology abstractions that are included in the Spring framework within the OSGi world. Participants of the tutorial will learn how to use the Spring OSGi integration for client- and server-side use. Examples are implemented during the tutorial using the Equinox OSGi runtime and are deployed as rich-clients based on the RCP and as server-side services within Jetty using the servlet-bridge.

Secure Extensible Applications via Embedded OSGi Frameworks

(View Original) Modern applications and software solutions increasingly center around loosely coupled and extensible architectures. Component or Service orientation is applied in almost all areas of application development including distributed systems, ubiquitous computing, embedded systems, and client-side applications.

The Java based OSGi framework specification lends itself well as a platform for loosely coupled and extensible applications and is rapidly gaining ground as the de-facto plugin solution for Java based applications. It allows for lightweight implementations that limit themselves to the CDC profile and are ideally suited as embedded plugin frameworks.

One of the main drawbacks of dynamically extensible applications, however, are the potential security issues that arise due to executing untrusted code without appropriated safety-measures in place. Secure sandboxes and their restrictions are difficult to get right and often hard to deal with in the development of applications. The OSGi specifications have an extensive and very powerful security model that eases this difficult task.

This Tutorial focuses on embedding various OSGi framework implementations namely, Eclipse Equinox and Apache Felix, into applications as a means of plugin mechanism while taking advantage of the often overlooked benefits of this solution: security.

The goal is to build a fully functional client application that can be extended at runtime through components out of remote repositories that subsequently, run in a secure sandbox. The OSGi Bundle Repository (OBR) service will be used and explained to publish, discover, and deploy plugins together with the transitive closure over the dependencies.

The application will restrict access to system resources as well as to other components and their services based on various criteria ranging from the remote location of an individual component, over its associated digital certificates, to user interaction. This will allow to demonstrate how to allow or deny permissions based on certain conditions, how to embed a security enabled OSGi framework implementation, and how to publish, discover, and deploy OSGi bundles via OBR.

Participants will learn

• how to embed Eclipse Equinox and Apache Felix,
• how to enable and use the OSGi security model,
• how to make use of the OSGi security specific services, like the ConditionalPermissionAdmin;
• how to equip bundles with digital signatures and sets of required permissions
• and last but not least, how to use the OSGi Bundle Repository (OBR).

Requirements for Participants are a basic understanding of the OSGi specifications and hands-on experience with bundles and services. In particular how to offer services to other bundles, and the use of service factories. Knowledge of the Java security model is a plus.

Exercises will focus on creating an extensible application and extensions that can run in a restricted sandbox. The specifics are not yet determined but we plan to have participants work in pairs on different aspects of the application and its extensions. Finally, the application shall be fully functional. We will run the application and extend it at runtime through the developed extensions, published previously, from a remote repository.

Component Programming with OSGi

(View Original) Eclipse vividly demonstrates the success of component oriented programming. As you know so well, Eclipse is based upon a large set of plug-ins that collaborate to deliver the user experience. Not so well known is that the base that enables this collaboration model is lean, flexible, managed and standardized: It is an instance of the Service Platform as specified by the OSGi Alliance. This tutorial will show you hands-on how to develop applications based on OSGi bundles (plug-ins are bundles). We will start with a simple "Hello World" application that highlights the modularity and life cycle features. This application is then further developed into a web based application that uses services from other bundles, as well as providing services to other bundles. We will show you what is under the covers as well as how Eclipse keeps any complexity under those covers. After this tutorial you will be able to write better, more flexible, more standalone, and more dynamic bundles that can be deployed in any OSGi service platform (Eclipse's Equinox or others).