SOF - A modularization framework for C++

• Download source with examples (sof_8070.zip) - 327.63 KB

Introduction

SOF (Service Oriented Framework) provides a OS independent infrastructure for developing component based software. That means the framework helps developers to build software systems consisting of modules which are communicating via clearly defined service interfaces with other modules of the system. Components can be started and stopped at runtime and the components are notified about the lifecycle of other components if necessary. It can be chosen whether the components are loaded locally (here the component code is linked to the class which starts the framework) or loaded dynamically from shared libraries (UNIX) or dynamic link libraries (Windows) for example. SOF is implemented in standard C++ and the SOF API is very similar to the OSGI API (see OSGI).

Using the Code

What does a module consist of?

Each module (also called 'bundle') consists of following code parts:

• A class which implements the sof::framework::IBundleActivator interface.
• One or several service interfaces which can be called by other bundles.
• Optionally: A class providing an interface for loading a dynamic link library or shared library
• Classes implementing the business logic

The IBundleActivator interface

#ifndef BUNDLE_ACTIVATOR
#define BUNDLE_ACTIVATOR1_H

#include "sof/framework/IBundleActivator.h"
#include "sof/framework/IBundleContext.h"

using namespace sof::framework;

class BundleActivator1 : public IBundleActivator
{
    public:
        virtual ~BundleActivator1();
        virtual void start( IBundleContext::ConstPtr context )
        virtual void stop( IBundleContext::ConstPtr context );
};
#endif

#include "BundleActivator1.h"

#include "sof/instantiation/ObjectCreator.h"

using namespace sof::instantiation;
using namespace sof::framework;

BundleActivator1::~BundleActivator1() 
{
    // Deallocate memory
}

void BundleActivator1::start(IBundleContext::ConstPtr context) 
{
    // Add code for registering services and service listeners
}

void BundleActivator1::stop(IBundleContext::ConstPtr context) 
{
    // Add code for deregistering services and service listeners
}

REGISTER_BUNDLE_ACTIVATOR_CLASS( "BundleActivator1", BundleActivator1 )

Only the framework calls the start and stop methods for starting and stopping the bundle. When these methods are called, a parameter of type IBundleContext is passed which allows communicating with the framework (registering/deregistering services, service listeners etc.). The framework is also responsible for creating an instance of the bundle activator class, before the bundle is started. For this the type and the name of the bundle activator class (here BundleActivator1) have to be registered at the framework by using the REGISTER_BUNDLE_ACTIVATOR_CLASS macro.

Services

#ifndef IMULTIPLIER_H
#define IMULTIPLIER_H

#include "sof/framework/IService.h"

using namespace sof::framework;

class IMultiplier : public IService
{
    public:
        virtual int multiply( int x, int y ) = 0;
};

#endif

Registering and Deregistering Services

• The name of the service (typically the name of the service class)
• The service object itself
• The Properties object

#include "BundleActivator1.h"

#include "sof/instantiation/ObjectCreator.h"
#include "sof/framework/Properties.h"

#include "IMultiplier.h"
#include "IMultiplierImpl.h"

using namespace sof::instantiation;
using namespace sof::framework;

BundleActivator1::~BundleActivator1() 
{
    // Deallocate memory
}

void BundleActivator1::start(IBundleContext::ConstPtr context) 
{    
    this->service = new IMultiplierImpl();    

    Properties props;
    props.put( "instance", "1" );

    this->serviceReg = context->registerService( "IMultiplier", this->service, props ); 
}

void BundleActivator1::stop(IBundleContext::ConstPtr context) 
{
    this->serviceReg->unregister();
    delete this->serviceReg;
    delete this->service;
}

REGISTER_BUNDLE_ACTIVATOR_CLASS( "BundleActivator1", BundleActivator1 )

Registering and Deregistering Service Listeners

• The IBundleContext object
• The name of the service which has to be found (here the name of the service class)
• An object implementing the IServiceTrackerCustomizer interface (in the following example it is implemented by the bundle activator class)

#include "BundleActivator2.h"

#include <iostream>

#include "sof/instantiation/ObjectCreator.h"

#include "IServiceA.h"

using namespace std;
using namespace sof::instantiation;

BundleActivator2::~BundleActivator2() 
{
    // Deallocate memory
}

void BundleActivator2::start(IBundleContext::ConstPtr context) 
{
    this->tracker = new ServiceTracker( context, "IMultiplier", this );
    this->tracker->startTracking();
}

void BundleActivator2::stop(IBundleContext::ConstPtr context) 
{
    this->tracker->stopTracking();
    delete ( this->tracker );
}

bool BundleActivator2::addingService( const ServiceReference& ref )
{
    if ( ref.getServiceName() == "IMultiplier" )
    {
        Properties props = ref.getServiceProperties();
        if ( props.get( "instance" ) == "1" )
        {
            this->service = static_cast<IMultiplier*> ( ref.getService() );
            cout << "[BundleActivator2#addingService] Calling IMultiplier..." << endl;
            int value = this->service->multiply( 47, 11 );
            cout << "[BundleActivator2#addingService] Returned value of IMultiplier: " << value << endl;
            return true;
        }
        else
        {
            return false;
        }
    }
    else
    {
        return false;
    }
}

void BundleActivator2::removedService( const ServiceReference& ref )
{
}

REGISTER_BUNDLE_ACTIVATOR_CLASS( "BundleActivator2", BundleActivator2 )

Creating Bundle Libraries

#include <windows.h>

#include <stdlib.h>
#include <string>
#include <iostream>

#include "sof/instantiation/ObjectCreator.h"
#include "sof/framework/IBundleActivator.h"

#define DLL extern "C" __declspec(dllexport)

using namespace std;
using namespace sof::instantiation;
using namespace sof::framework;

BOOL APIENTRY DllMain( HANDLE hModule, 
                       DWORD  ul_reason_for_call, 
                       LPVOID lpReserved
                     )
{                
    return TRUE;
}


DLL IBundleActivator* createObject( const string &className )
{    
    ObjectCreator<IBundleActivator> OC_BUNDLE_ACTIVATOR;
    return OC_BUNDLE_ACTIVATOR.createObject( className );                    
}

The dllMain method represents the entry point for the DLL where initialization calls (not necessary) can be done. The dllMain method is defined by the Windows platform and is called when the DLL is loaded. SOF itself requires an implementation of the createObject method which provides the functionality for creating IBundleActivator instances. This 'dll.cpp' file does not have to be changed for the implementation of other bundles. It can be always reused.



The picture above shows a snapshot of the project view in Visual Studio. The first bundle is implemented in the 'sof_examples_bundle1' project and contains following files:

• The header and source file of the bundle activator (BundleActivator1)
• The interface definition (IMultiplier.h) and implementation (IMultiplierImpl.h) of the service interface
• The definition of the DLL interface ('dll.cpp')

• The bundle activator
• Only the service interface (IMultiplier.h) (not an implementation of the service)
• The definition of the DLL interface

Starting the Framework

• Threading policy
• Influences the threading behaviour of the framework.
• Creation policy
• Defines the way a bundle is loaded from a library (e.g. Windows DLL, Unix shared library etc.).

• The name of the bundle
• The name of the bundle activator class
• The directory where the bundle library is located, e.g. '.' for the current directory or 'c:/temp'
• The name of the bundle library

#include <iostream>
#include <vector>

#include "sof/framework/Launcher.h"
#include "sof/framework/Global.h"
#include "sof/config/BundleConfiguration.h"
#include "sof/instantiation/win/WinDllCreator.h"
#include "sof/util/threading/SingleThreaded.h"

using namespace std;

using namespace sof::framework;
using namespace sof::config;
using namespace sof::util::threading;
using namespace sof::instantiation::win;

int main(int argc, char* argv[])
{
    Launcher<SingleThreaded,WinDllCreator> launcher;

    // Specifying the bundle configuration
    BundleConfiguration bundle1( "bundle1", "BundleActivator1", ".", "sof_examples_bundle1.dll" );
    BundleConfiguration bundle2( "bundle2", "BundleActivator2", ".", "sof_examples_bundle2.dll" );

    vector<BundleConfiguration> configuration;
    configuration.push_back( bundle1 );
    configuration.push_back( bundle2 );

    // Starting the framework
    launcher.start( configuration );

    // Starting the administration console for interacting with the framework
    launcher.startAdministrationBundle();

    return 0;
}

• Showing all relevant information of a bundle (e.g. registered services, service listeners and used services)

• Starting and stopping further bundles

• Listing the names of all started bundles

Conclusion

• It can be configured which bundles ought to be started at framework startup.
• Software modules can be started and stopped during runtime (via SOF console), so a bundle implementation can be replaced by an other one.
• Loose coupling between modules (bundles): Software modules only communicate via service interfaces.
• The framework can be easily adapted to specific operating systems by using templates.

History