Scheduler example

This scheduler triggers periodically the processing passing to the processor all collected data. The Java class implementing the scheduler logic is org.my.first.scheduler.MyPeriodicScheduler. The scheduler name is MyPeriodicScheduler and it belonging to the fr.liglab.adele.cilia.test namespace.

   <scheduler name="MyPeriodicScheduler" namespace="fr.liglab.adele.cilia.test"
              classname="org.my.first.scheduler.MyPeriodicScheduler" />

Configuring processor method

To indicate the processor method, a tag called method must be declared into the processor specification tag.

Processor example

This processor filters data using a threshold value. The Java class implementing the processor logic is org.my.first.processor.MyFilterProcessor, this class must provide the method filter that receives as parameter (and returns) an object of type fr.liglab.adele.cilia.Data. The processor is called MyFilterProcessor and belonging to the fr.liglab.adele.cilia.test namespace.

   <processor name="MyFilterProcessor" namespace="fr.liglab.adele.cilia.test" 
              classname="org.my.first.processor.MyFilterProcessor">
        <method name="filter" data.type="fr.liglab.adele.cilia.Data" />
   </processor>

The Java class implementing this processor has a structure as follow:

package org.my.first.processor;

import fr.liglab.adele.cilia.Data;

public class MyFilterProcessor {

   /**
    * Method to be invoked by the Cilia framework
    * @param dataToProcess
    * @return
    */
   public Data filter(Data dataToProcess) {
      // Processor logig must be defined here 
      ....
   }
   
}

Dispatcher example

This dispatcher will choice the destination based on the received number, odd or even. The Java class implementing the dispatcher logic is org.my.first.dispatcher.MyOddEvenDispatcher. The dispatcher name is MyOddEvenDispatcher and it belonging to the fr.liglab.adele.cilia.test namespace.

   <dispatcher name="MyOddEvenDispatcher" namespace="fr.liglab.adele.cilia.test"
              classname="org.my.first.dispatcher.MyOddEvenDispatcher" />

Example : Scheduler with properties

   <scheduler name="MyPeriodicScheduler" namespace="fr.liglab.adele.cilia.test"
              classname="org.my.first.scheduler.MyPeriodicScheduler" >
      <properties>
         <property name="period" field="m_period" value="10000" />
      </properties>
   </scheduler>
   

package org.my.first.scheduler;
...
public class MyPeriodicScheduler extends CiliaScheduler implements Runnable {
  /**
  *Field injected by the framework.
  */
  private long m_period;
  ...
  /**
  *Method called by the thread.
  */
  public void run() {
     List dataToProcess = new ArrayList(dataList);
     dataList.clear();
     process(dataToProcess);
  }
}

Specifying the mediator’s scheduler

Each mediator must have a scheduler. To define the used scheduler, a scheduler tag is used. The needed attributes when defying the scheduler are:

Specifying the mediator’s processor

Each mediator must have a processor. To define the used processor, a processor tag is used. The needed attributes when defying the processor are:

Specifying the mediator’s dispatcher

Each mediator must have a dispatcher. To define the used dispatcher, a dispatcher tag is used. The needed attributes when defying the dispatcher are:

Specifying the mediator’s port

Each mediator must have a ports for to receive data and ports to deliver the processed data. To define the ports a ports tag is used. And it contains the in-port and out-port. Each in or out port containt the following attributes.

Mediator example

   <mediator-component name="MyFilterMediator" namespace="fr.liglab.adele.cilia.test"
              category="Filter" >
       <scheduler name="MyPeriodicScheduler" namespace="fr.liglab.adele.cilia.test"/>
       <processor name="MyFilterProcessor" namespace="fr.liglab.adele.cilia.test"/>
       <dispatcher name="MyOddEvenDispatcher" namespace="fr.liglab.adele.cilia.test"/>
       <ports>
          <in-port name="default" type="string" />
          <out-port name="default" type="string" />
       </ports>
   </mediator-component>

Mediator specification at run-time

Mediator components could be specified at run-time. First it is necessary to obtain the fr.liglab.adele.cilia.CiliaContext service, there are two ways to obtain it.

...
   ServiceReference[] serv = bundleContext.getAllServiceReferences(CiliaContext.class.getName(), (*));
   if (serv != null && serv.length != 0) {
       ciliaContext = (CiliaContext) bundleContext.getService(serv[0]);
   }
...

...
@Requires
private CiliaContext ciliaContext;
...

...
@ServiceReference
public void setCiliaContext(CiliaContext ccontext) { ... }
...

...
/* The mediator information*/
String mediatorName = "MyNewMediatorStringSplitter";
String defaultNamespace = "fr.liglab.adele.cilia";
String mediatorCategory = "Splitter";
/*Creating the empty mediator specification*/
MediatorSpecification mtype = ciliaContext.createMediatorSpecification(
                      mediatorName,mediatorNamespace, mediatorCategory);

/* Setting up mediator information*/
mtype.setScheduler("immediate-scheduler", defaultNamespace);
mtype.setProcessor("string-splitter", defaultNamespace);
mtype.setDispatcher("content-based-dispatcher", defaultNamespace);
/*Initializing mediator specification*/
mtype.initializeSpecification();
...

...
mtype.stopSpecification();
...

In Adapter

The In Adapters is defined by its collector component.

Collectors are the communication components which collect or receives the data. They could receive the data from an external application or from a communication protocol.

To create a new collector specification, is used the collector tag. The attributes associated to collectors are:

To create a new adapter specification, is used the adapter tag. The attributes associated to adapters are:

   <collector name="MyLogFileCollector" 
              classname="org.my.first.file.collector.MyLogFileCollector" >
      <properties>
         <property name="filename" field="m_filename" />
         <property name="pool.period" field="m_period" />
      </properties>
   </collector>
   <adapter name="file-adapter" pattern="in-only">
      <collector type="MyLogFileCollector"  />
      <ports>
         <out-port name="default" type="string" />
      </ports>
   </adapter>  

package org.my.first.file.collector;
...
public class MyLogFileCollector extends AbstractCollector implements Runnable {
   /**
    * Field injected by the framework, it refers to the ''filename'' property.
    */
   private String m_filename;
   /**
    * Field injected by the framework, it refers to the ''pool.period'' property.
    */
   private String m_period;
   /**
    * Method to be invoked by the thread when collecting data.
    */
   ...
   public void run () {
       Data data = createDataFromFile();
       super.notifyDataArrival(data);
   }
}

Out Adapter

The Out Adapters is defined by its sender component. Senders are the communication components which deliver the processed data. They could send the data to an external application or through a communication protocol.

To create a new sender specification, is used the sender tag. The attributes associated to senders are:

To create a new adapter specification, is used the adapter tag.

The attributes associated to adapters are:

   <sender name="MyLogFileSender" 
              classname="org.my.first.file.sender.MyLogFileSender" >
      <properties>
         <property name="filename" field="m_filename" />
      </properties>
   </sender>
   <adapter name="file-out-adapter" pattern="out-only">
      <sender type="MyLogFileSender" />
      <ports>
         <in-port name="default" type="string" />
      </ports>
    </adapter>

package org.my.first.file.sender;
...
public class MyLogFileSender implements ISender  {
   /**
    * Field injected by the framework, it refers to the ''filename'' property.
    */
   private String m_filename;
   /**
    * Method to be invoked by the Cilia framework.
    * @param data the processed data.
    * @return True if the data has been sent, false if not.
    */
   public boolean send (Data data) {
   //Stock the received data to the file specified in the m_filename field.
   }
}

In-Out Adapter

There is only one synchronous implementation of an IO-Adapter, it will block until the reponse is achieved or a time-out is triggered. See https://github.com/AdeleResearchGroup/Cilia/blob/master/examples/hello-world-example-annotations/hello-mediator/src/main/java/hello/world/example/adapters/GuiAdapter.java for an example.

To create a new IO-Adapter specification, is used the io-adapter tag.

Specifying the io-adapter’s port

Each io-adapter must have at least one port to receive data and one port to deliver the data. To define the ports a ports tag is used. And it contains the in-port and out-port. Each in or out port containt the following attributes.

IO-Adapter example

   <io-adapter classname="org.my.first.io.adapter.GuiAdapter"
                name="gui-adapter">
                <ports>
                        <in-port name="in" type="*" />
                        <out-port name="out" type="*" />
                </ports>
        </io-adapter>

To create the only (blocking-)implementation of the io-adapter the class must inherit the abstract class fr.liglab.adele.cilia.framework.AbstractIOAdapter as follows:

package org.my.first.io.adapter;
...
public class GuiAdapter extends AbstractIOAdapter {

        public void adaptionCode(){
            ...
            Data result = null;
            try {
                result = invokeChain(data); //wait some time for the result.
            } catch (TimeoutException e1) {
                e1.printStackTrace();
            }
            ...
        }

        @Override
        public void receiveData(Data data){
                super.receiveData(data);
        }
        @Override
        public Data dispatchData(Data data) {
                return super.dispatchData(data);
        }
}

One restriction due to the inheritance problems of iPOJO, is that the new adapter class must override the receiveData and dispatchData as presented in the example.