David Savage

OSGi & The Cloud (Part 2)

This is the second blog entry in a series documenting the underlying points I made in my recent talk at the OSGi Community Event in London.  Entitled “OSGi And Private Cloud”,  the slides are available here and the agenda is as follows:

  • Where is Cloud computing today? (Part 1)
  • Where does OSGi fit in the Cloud architecture?
  • What are the challenges of using OSGi in the Cloud?
  • What does an OSGi Cloud platform look like?

In this section of the talk I look at where OSGi fits into the Cloud architecture. However, as the community event was co-hosted with JAX London it wasn’t a given that everyone at my talk would know OSGi. This is also possibly true for others reading this blog, so to make sure we’re all starting from a similar page, I’ll briefly explain the basics of what OSGi is about for those who have not come across it before. (more…)

OSGi & The Cloud (Part 1)

I recently attended the OSGi Community Event where I gave a talk entitled “OSGi And Private Cloud” the slides for which are available here. However as has been pointed out, if you watch the slide deck they’re a little on the zen side, so if you weren’t at the event then it’s a bit difficult to guess the underlying points I was trying to make.

To address this I’ve decided to create a couple of blog entries that discuss the ideas I was trying to get across. Hopefully this will be of interest to others.

In the talk the agenda was as follows:

  • Where is Cloud computing today?
  • Where does OSGi fit in the Cloud architecture? (Part 2)
  • What are the challenges of using OSGi in the Cloud?
  • What does an OSGi cloud platform look like?

I’ll stick to this flow but break these sections up into separate blog entries. So here goes with the first section… (more…)

How to make enterprise software Nimble

Chelonia mydas is going for the air by Mila ZinkovaWith the release of the OSGi Enterprise Specification a whole new set of developers will be trying to figure just what the hell you can do with this OSGi technology anyway?

Those who have started to explore it will have found that surprisingly OSGi doesn’t tend (initially) to make development easier, it also doesn’t tend (initially) to reduce the amount of code you need to write. So what then is it good for?

The key feature of OSGi is that it allows for proper modularization of Java software. There’s a lot of good information out there on the interweb about why modularization is important – but the key message is that modularization allows you to decide what are the building blocks of your application. Not at the nuts and bolts level that is Object Orientation and not at the red car or blue car level that is SOA, but at the intermediate level of engines, tires and gearboxes – where most engineers really like to play…

OSGi makes the task of building sets of applications easier. It is not about building one application but about building applications from applications, software reuse, yada yada, or as I like to think of it – turtles all the way down.

All this sounds great, but (more…)

Zen and the Art of OSGi Dependency Resolution

In a previous post I showed how it is possible to use Nimble to deploy the Spring Simple WebApp using a trivial command:

posh -kc "repos -l springdm;add org.springframework.osgi.samples.simplewebapp@active"
open http://localhost:8080/simple-web-app/

This actually relies on some pretty advanced features of the Nimble Resolver that allow us to perform some interesting gymnastic tricks with regard to OSGi dependency resolution. The previous post glossed over these details but in this post I’ll delve a little deeper into what’s going on underneath the hood.

To understand what’s going on in this example it’s worth looking at a greatly simplified model of the bundles deployed to make this application work.

In this simplified view we can see that there are (more…)

Hello Tatooine

So in my last couple of posts I’ve been showing the power of Nimble. You will have noticed that it is primarily a console environment. As such you may be wondering how you can provide your own commands to execute in the Nimble shell – Posh (Paremus OSGi Shell).

Posh is an implementation of the command line interface specified in RFC-147 from the OSGi alliance. If you are familiar with OSGi development you will know that to date every framework implementation has defined it’s own particular API for providing command line utilities within an OSGi runtime. This has meant that there is significant duplication of effort when writing commands to work in the various environments.

To this end the alliance proposed RFC 147 in order to provide a common standard that different frameworks could implement such that a command that worked in one framework could work unchanged in another. The initial implementation of RFC 147 was developed primarily by Peter Kriens and donated to the Felix project earlier this year. Since then there have been a number of maintenance releases and it has been included as a component of the Felix Karaf container and the Nimble container from Paremus.

This gives you some background, so now the standard thing for me to do would be to write a trivial hello world application. But that’s no fun, so instead of conforming to the norm I thought it would be more interesting to port the Starwars Asciimation work to run in OSGi as an RFC 147 command line interface. (more…)