Key Benefits
Software Architecture
Programming Methods
Use Cases

Software Architecture

click to view image

SDE has been designed from the ground up to be modular and an enabling engine for service composition.  Higher level service enablers (CCXML scripts) are built upon low level enablers (connectors and their exposed primitives), and those high level enablers can then be used to create further services, by writing new scripts using them as components. This creates a layered architecture where each layer is a set of enablers that is exposed as components to be blended together at the higher layer to create services. These services can then be used as re-usable components or enablers by even higher layers to create more advanced services.

Therefore, SDE is composed of multiple layers stacked on top of each other, thus resulting in a modular, separation of concerns based design.

Click bellow headings to Expand / Collaspe

CCXML Scripting Layer

The top-most layer is a set of service specific call-flows, many examples of which are given in the above figure. This is the main Service Orchestration and composition layer. This layer is implemented using CCXML language.

Pre-bundled Scripts as Service Enablers

Some CCXML scripts are bundled with SDE to promote re-use and enable more complex and advanced services by using them as components. We call such scripts as Service Enablers. In other words, these are enablers of more advanced services.
SDE comes with a set of Service Enabler CCXML scripts as well as a set of sample services CCXML scripts. Users are free to modify Enablers or service scripts as required.

Primitives and Connectors Layer

The next layer is a set of low level service enablers that implement the actual protocol stacks. We call these protocol stacks as Connectors. These connectors are in fact internal enablers for service delivery. Examples of connectors include SIP, Media Services, RADIUS client, DIAMETER client, XML over socket, HTTP, Database Stored Procedures and query interface.
The Connectors layer uses the core API exposed by asynchronous middleware called AMPS. All SDE protocols stacks are implemented in this layer. This makes SDE independent of the Operating Systems and it can thus be easily compiled on multiple Operating Systems such as Windows and Linux.
Connectors expose their own services to the CCXML scripting layer through a set of primitives.
Primitives are core level atomic operations invoked by CCXML scripts. They run to completion asynchronously and fire events for the scripts when they complete or fail. The scripts may catch events fired by the Primitives and act upon them according to their service logic.

Each Primitive belongs to one and only one Connector. For example, CreateCall is a primitive operation to create a SIP call leg. This Primitive operation is exposed by the SIP Connector.
Each Primitive has its own Internal State Machine that runs independently of the script but runs within the context of the session running the CCXML script. When the State Machine terminates it fires an event for the calling script


AMPS is an asynchronous event-driven application development framework and library that provides APIs for several tasks for application developers. It is similar in functionality to libasync and other such libraries. Applications built on AMPS are high performance, scalable and highly concurrent. More information on AMPS can be found at www.OpenAMPS.org.

The bottom layer is the Operating system itself. Current release runs on all 64-bit multi-core Linux flavors.


In order to interface with third party applications written in any programming language of developer’s choice, SDE enables access to its services via RESTFUL APIs. These APIs enable access to SDE primitives and service enabler scripts through well defined APIs in XML format. This opens up a world of possibilities for developers developing their applications in any run-time environment external to the platform to access the platform services including protocol stacks, primitives and re-usable script logic via well known HTTP protocol with XML payload.


AdvOSS Webinar