Application development framework¶

Create a one-component single-server application¶

To create a simple application deployed on a single server:

1. Include the following lines to the code of the application class:

   Namespaces:
     =: my.new.ns
     apps: io.murano.applications
   
   Name: AppName
   Extends: apps:SingleServerApplication
   

2. Provide an input for the application server property in your ui.yaml file:

   Application:
     ?:
       type: my.new.ns.AppName
     server:
       ?:
         type: io.murano.resources.LinuxMuranoInstance
       name: generateHostname($.instanceConfiguration.unitNamingPattern, 1)
       flavor: $.instanceConfiguration.flavor
       ... <other instance properties>
   

   Now you already have the app that creates a server ready for installing software on it.

3. To create a fully functional app, add an installation script to the body of the onInstallServer method:

   Methods:
     onInstallServer:
       Arguments:
         - server:
             Contract: $.class(res:Instance).notNull()
         - serverGroup:
             Contract: $.class(apps:ServerGroup).notNull()
       Body:
         - $file: sys:Resources.string('installScript.sh')
         - conf:Linux.runCommand($server.agent, $file)
   

4. Optional. Add other methods that handle certain stages of the application workflow, such as onBeforeInstall, onCompleteInstallation, onConfigureServer, onCompleteConfiguration, and others. For details about these methods, see the Software components section.

Create a one-component multi-server application¶

To create an application that is intended to be installed on several servers:

1. Make it inherit the MultiServerApplication class:

   Namespaces:
     =: my.new.ns
     apps: io.murano.applications
   
   Name: AppName
   Extends: apps:MultiServerApplication
   

2. Instead of the server property in SingleServerApplication, provide an input for the servers property that accepts the instance of one of the inheritors of the ServerGroup class. The ui.yaml file in this case may look as follows:

   Application:
     ?:
       type: my.new.ns.AppName
     servers:
       ?:
         type: io.murano.applications.ServerList
       servers:
         - ?:
             type: io.murano.resources.LinuxMuranoInstance
           name: "Server-1"
           flavor: $.instanceConfiguration.flavor
           ... <other instance properties>
   
         - ?:
             type: io.murano.resources.LinuxMuranoInstance
           name: "Server-2"
           flavor: $.instanceConfiguration.flavor
           ... <other instance properties>
   

3. Define the custom logic of the application in the handler methods, and it will be applied to the whole app, exactly like with SingleServerApplication.

Create a scalable multi-server application¶

To provide the application with the ability to scale:

1. Make the app extend the MultiServerApplicationWithScaling class:

   Namespaces:
     =: my.new.ns
     apps: io.murano.applications
   
   Name: AppName
   Extends: apps:MultiServerApplicationWithScaling
   

2. Provide the ui.yaml file:

   Application:
     ?:
       type: my.new.ns.AppName
     servers:
       ?:
         type: io.murano.applications.ServerReplicationGroup
       numItems: $.appConfiguration.numNodes
       provider:
         ?:
           type: io.murano.applications.TemplateServerProvider
         template:
           ?:
             type: io.murano.resources.LinuxMuranoInstance
           flavor: $.instanceConfiguration.flavor
           ... <other instance properties>
         serverNamePattern: $.instanceConfiguration.unitNamingPattern
   

   The servers property accepts instance of the ServerReplicationGroup class, and in turn it requires input of the numItems and provider properties.

After the deployment, the scaleOut and scaleIn public methods (actions) become available in the dashboard UI.

For a working example of such application, see the com.example.apache.ApacheHttpServer package version 1.0.0.

Scaling primitives¶

There is an ability to group similar resources together, produce new copies of the same resources or release the existing ones on request. Now it is implemented for instances only, other resources may be added later.

The following is the hierarchy of classes that provide grouping and replication of resources:

+-------+
| +-------+
| | +--------+        +------------------+        +-----------------+
| | |        |        |                  |        |                 |
+-+ | Object <--------+ ReplicationGroup +--------> ReplicaProvider |
  +-+        |        |                  |        |                 |
    +--------+        +---+--------------+        +-+--------+------+
                          ^                         ^        ^
                          |                         |        |
                          |      +------------------+-----+  |
                          |      |                        |  |
+-------+                 |      |  CloneReplicaProvider  |  |
| +-------+               |      |        + other         |  |
| | +----------+          |      +------------------------+  |
| | |          |          |                                  |
+-+ | Instance |          |                                  |
  +-+          |          |                                  |
    +----+-----+          |                                  |
         |                |                                  |
   +-----+-------+        |                                  |
   |             |        |                                  |
   | ServerGroup |        |                  +---------------+--+
   |             |        |                  |     Template     |
   +-----^-------+    +---+----------+       |      Server      +--+
         |            |    Server    +------->     Provider     |  |
         +------------+  Replication |       +-----+------------+  +---+
                      |    Group     |             |               |   |
                      +--------------+             +---+---other---+   |
                                                       |               |
                                                       +---------------+

ReplicationGroup

A base class which holds the collection of objects generated in runtime in its items output property and contains a reference to a ReplicaProvider object in its provider property which is used to dynamically generate the objects in runtime.

Input properties of this class include the minItems and maxItems allowing to limit the number of objects it holds in its collection.

An input-output property numItems allows to declaratively change the set of objects in the collection by setting its size.

The deploy() method is used to apply the replica settings: it drops the objects from the collection if their number exceeds the number specified by the numItems or generate some new if there are not enough of them.

The scale() method is used to increase or decrease the numItems by some number specified in the delta argument of the method, but in range between maxItems and minItems.

ReplicaProvider

A class which does the object replication. The base one is abstract, its inheritors should implement the abstract createReplica method to create the actual object. The method accepts the index parameter to properly parametrize the newly created copy and optional owner parameter to use it as an owner for the newly created objects.

The concrete implementations of this class should define all the input properties needed to create new instances of object. Thus the provider actually acts as a template of the object it generates.

CloneReplicaProvider

An implementation of ReplicaProvider capable to create replicas by cloning some user-provided object, making use of the template() contract.

PoolReplicaProvider

Replica provider that takes replicas from the prepopulated pool instead of creating them.

RoundrobinReplicaProvider

Replica provider with a load balancing that returns replica from the prepopulated list. Once the provider runs out of free items it goes to the beginning of the list and returns the same replicas again.

CompositeReplicaProvider

Replica provider which is a composition of other replica providers. It holds the collection of providers in its providers input property. Its ReplicaProvider method returns a new replica created by the first provider in that list. If that value is null, the replica created by the second provider is returned, and so on. If no not-null replicas are created by all providers, the method returns null.

This provider can be used to have some default provider with the ability to fall back to the next options if the preferable one is not successful.

Servers replication¶

ServerGroup

A class that provides static methods for deployment and releasing resources on the group of instances.

The deployServers() static method accepts instance of ServerGroup class and a list of servers as the parameters and deploys all servers from the list in the environment which owns the server group, unless server is already deployed.

The releaseServers() static method accepts a list of servers as the parameter and consequentially calls beginReleaseResources() and endReleaseResources() methods on each server.

ServerList

A class that extends the ServerGroup class and holds a group of prepopulated servers in its servers input property.

The deploy() method calls the deployServers() method with the servers defined in the servers property.

The .destroy() method calls the releaseServers() method with the servers defined in the servers property.

SingleServerGroup

Degenerate case of a ServerGroup which consists of a single server. Has the server input property to hold a single server.

CompositeServerGroup

A server group that is composed of other server groups.

ServerReplicationGroup

A subclass of the ReplicationGroup class and the ServerGroup class to replicate the Instance objects it holds.

The deploy() method of this group not only generates new instances of servers but also deploys them if needed.

TemplateServerProvider

A subclass of ReplicaProvider which is used to produce the objects of one of the Instance class inheritors by creating them from the provided template with parameterization of the hostnames. The resulting hostname looks like ‘Server {index}{groupName}’.

May be passed as provider property to objects of the ServerReplicationGroup class.

other replica providers

Other subclasses of ReplicaProvider may be created to produce different objects of Instance class and its subclasses depending on particular application needs.

Classes for grouping and replication of other kinds of resources are to be implemented later.

Software Components¶

The class to handle the lifecycle of the application is the SoftwareComponent class which is a subclass of Installable and Configurable:

+-----------+-+           +-+------------+
|             |           |              |
| Installable |           | Configurable |
|             |           |              |
+-----------+-+           +-+------------+
            ^               ^
            |               |
            |               |
          +-+---------------+-+
          |                   |
          | SoftwareComponent |
          |                   |
          +-------------------+

The hierarchy of the SoftwareComponent classes is used to define the workflows of different application lifecycles. The general logic of the application behaviour is contained in the methods of the base classes and the derived classes are able to implement the handlers for the custom logic. The model is event-driven: the workflow consists of the multiple steps, and most of the steps invoke appropriate on%StepName% methods intended to provide application-specific logic.

Now ‘internal’ steps logic and their ‘public’ handlers are split into the separate methods. It should improve the developers’ experience and simplify the code of the derived classes.

The standard workflows (such as Installation and Configuration) are defined by the Installable and Configurable classes respectively. The SoftwareComponent class inherits both these classes and defines its deployment workflow as a sequence of Installation and Configuration flows. Other future implementations may add new workflow interfaces and mix them in to change the deployment workflow or add new actions.

Installation workflow consists of the following methods:

+----------------------------------------------------------------------------------------------------------------------+
| INSTALL                                                                                                              |
|                                                                                                                      |
|      +------------------------------+                               +---------------+                                |
|    +------------------------------+ |                             +---------------+ |                                |
|  +------------------------------+ | |      +---------------+    +---------------+ | |      +----------------------+  |
|  |                              | | |      |               |    |               | | |      |                      |  |
|  |    checkServerIsInstalled    | +-+ +----> beforeInstall +----> installServer | +-+ +----> completeInstallation |  |
|  |                              +-+        |               |    |               +-+        |                      |  |
|  +------------------------------+          +------+--------+    +------+--------+          +-----------+----------+  |
|                                                   |                    |                               |             |
+----------------------------------------------------------------------------------------------------------------------+
                                                    |                    |                               |
                                                    |                    |                               |
                                                    |                    |                               |
                                                    v                    v                               v
                                              onBeforeInstall      onInstallServer              onCompleteInstallation

Configuration workflow consists of the following methods:

+----------------------------------------------------------------------------------------------------------------------+
| CONFIGURATION                                                                                                        |
|               +-----------------+                                                                                    |
|               |                 |                                                                                    |
|               |          +---------------+                          +-----------------+                              |
|               |        +---------------+ |                        +-----------------+ |                              |
|  +------------v--+   +---------------+ | |   +--------------+   +-----------------+ | |   +-----------------------+  |
|  |               |   |               | | |   |              |   |                 | | |   |                       |  |
|  | checkCluster\ +---> checkServer\  | +-+---> preConfigure +---> configureServer | +-+---> completeConfiguration |  |
|  | IsConfigured  |   | IsConfigured  +-+     |              |   |                 +-+     |                       |  |
|  +------------+--+   +---------------+       +------+-------+   +--------+--------+       +-----------+-----------+  |
|               |                                     |                    |                            |              |
|               |                                     |                    |                            |              |
|    +----------v----------+                          |                    |                            |              |
|    |                     |                          |                    |                            |              |
|    | getConfigurationKey |                          |                    |                            |              |
|    |                     |                          |                    |                            |              |
|    +---------------------+                          |                    |                            |              |
|                                                     |                    |                            |              |
+----------------------------------------------------------------------------------------------------------------------+
                                                      |                    |                            |
                                                      |                    |                            |
                                                      v                    v                            v
                                              configureSecurity,    onConfigureServer          onCompleteConfiguration
                                                onPreConfigure

The OpenStackSecurityConfigurable class extends Configurable by implementing the configureSecurity method of the base class and adding the empty getSecurityRules method.

Consider the following example of this class usage:

Namespaces:
  =: com.example.apache
  apps: io.murano.applications

Name: ApacheHttpServer

Extends:
  - apps:MultiServerApplicationWithScaling
  - apps:OpenStackSecurityConfigurable

Methods:
  getSecurityRules:
    Body:
      - Return:
          - ToPort: 80
            FromPort: 80
            IpProtocol: tcp
            External: true
          - ToPort: 443
            FromPort: 443
            IpProtocol: tcp
            External: true

In the example above, the ApacheHttpServer class is configured to create a security group with two security rules allowing network traffic over HTTP and HTTPS protocols on its deployment.

The SoftwareComponent class inherits both Installable and Configurable and adds several additional methods.

Event notification pattern¶

The Event class may be used to issue various notifications to other MuranoPL classes in an event-driven manner.

Any object which is going to emit the notifications should declare the instances of the Event class as its public Runtime properties. You can see the examples of such properties in the Installable and Configurable classes:

Name: Installable

Properties:
  beforeInstallEvent:
    Contract: $.class(Event).notNull()
    Usage: Runtime
    Default:
      name: beforeInstall

The object which is going to subscribe for the notifications should pass itself into the subscribe method of the event along with the name of its method which will be used to handle the notification:

$event.subscribe($subscriber, handleFoo)

The specified handler method must be present in the subscriber class (if the method name is missing it will default to handle%Eventname%) and have at least one standard (i.e. not VarArgs or KwArgs) argument which will be treated as sender while invoking.

The unsubscribe method does the opposite and removes object from the subscribers of the event.

The class which is going to emit the notification should call the notify method of the event and pass itself as the first argument (sender). All the optional parameters of the event may be passed as varargs/kwargs of the notify call. They will be passed all the way to the handler methods.

This is how it looks in the Installable class:

beforeInstall:
  Arguments:
    - servers:
        Contract:
          - $.class(res:Instance).notNull()
    - serverGroup:
        Contract: $.class(ServerGroup).notNull()
  Body:
    - ...
    - $this.beforeInstallEvent.notify($this, $servers, $serverGroup)
    - ...

The notifyInParallel method does the same, but invokes all handlers of subscribers in parallel.

Base application classes¶

There are several base classes that extend standard io.murano.Application class and SoftwareComponent class from the application development library.

SingleServerApplication

A base class for applications running a single software component on a single server only. Its deploy method simply creates the SingleServerGroup with the server provided as an application input.

MultiServerApplication

A base class for applications running a single software component on multiple servers. Unlike SingleServerApplication, it has the servers input property instead of server. It accepts instance of on of the inheritors of the ServerGroup class.

MultiServerApplicationWithScaling

Extends MultiServerApplication with the ability to scale the application by increasing (scaling out) or decreasing (scaling in) the number of nodes with the application after it is installed. The differences from MultiServerApplication are:

• the servers property accepts only instances of ServerReplicationGroup rather than any ServerGroup
• the additional optional scaleFactor property accepts the number by which the app is scaled at once; it defaults to 1
• the scaleOut and scaleIn public methods are added

Application developers may as well define their own classes using the same approach and combining base classes behaviour with the custom code to satisfy the needs of their applications.