wiki:FCI

Federation Computing Interface (FCI): An API for accessing resources of the federation

Introduction

In many testing scenarios there is a need to configure resources or even get monitoring status data properly after the VCT is provisioned while the testing is in progress. What is critical with the operational part of a VCT is the proper and valid run-time configuration of the participating resources. The reason is that, while the VCT is operated by the federation’s customer, the federation must ensure all terms of the requested SLA of the VCT are fulfilled and nothing is violated or falls out of the scope of the SLA. To this end, the SLA must be constantly audited (or monitored) for different parameters (i.e. metering, service quality, security, etc).

Federation Computing Interface (FCI) is an API for accessing resources of the federation. It is an SDK for developing applications that access VCT requested resources through the Panlab office services during operation of testing. It is quite easy to embed it into your application/ SUT in order to gain control of the requested resources during testing.

The FCI is delivered to the customer after the generation of the SLA and not only does it contain the necessary libraries but also the alias of the resources that are used in the VCT scenario. This allows the User-Application/SUT to access the testbed resources during execution of the experiment in order to manage and configure various environment parameters or to get status of the resources.

In brief these are the requirements and the process:

  • FCI is an Eclipse based SDK.
  • You need to download from Panlab the FCI plugins and the FCI Core libraries and install
  • You need to modify your application (SUT) to access resources in the federation (if you need to do this) according to your initial VCT request
  • Execute your application either at your premises or inside a resource
  • You can also operate the requested VCT even from another application while your tests execute (i.e. external triggers)

NEW: FCI now suports the management of resources (ie create, update, delete)

NEW: Check also the Hello World section.


A small example

FCI Java example - An example using the FCI within Java


A Hello World

In the url: http://svn.panlab.net/PII/repos/Software/download/binaries/FCI/Java/HelloPanlabWorld.java there is a hello world application for Panlab. Check the example on how to create and manage resources through the java FCI API.

It’s a quick a dirty solution just for now to quick test your resources. (there is no sophisticated installation)

  1. Go to Eclipse and create a normal Java Project
  2. In the src folder copy the attached java file
  3. Download from svn the archive http://svn.panlab.net/PII/repos/Software/download/binaries/FCI/Java/fciarchive.zip and un-compress it.
  4. Go to build path of your project and add the external jars
  5. Run as java application the HelloPanlabWorld?.java

It will take some time each time you run the application since it needs to connect to the repo and download info and translate it. Many system.out will inform you (no sophisticated logging for now)

You can create now whatever complex resource scenario you wish and control the resources


Exploiting the web services of Panlab

FCI fully exploits the available web services of Panlab. Your application/SUT makes requests to the reserved VCT resources while testing through the single federal access point the Panlab Office Teagle services.
The Panlab architecture exposes resources of partners through resource adapters. In many testing scenarios, the customer cannot access the resources in no other way other than making requests through the RA. Of course there are much more reasons of making the requests through the central federal entity and the potential of this will be presented in a next section.

So, as it appears in the next image, the Customer needs to embed into his application an FCI core and a VCT definition. The VCT definition contains all the objects to be imported to the customer’s application/SUT. The FCI core is a library (currently available in Java or C) that is just linked into the application. Read the installation and usage section. After embedding the FCI core and VCT definitions the application accesses the requested reserved resources during operation.

Again, as it appears in the next image, it is essential to mention that all the requests go through the Panlab office and then are redirected down to the proper resource.


How it works

The following image describes how the FCI for a requested VCT is automatically generated.


After you have created and provisioned a VCT through the VCT tool your requested resources are there waiting for you to be accessed. The VCT description resides inside the repository of the Teagle services. FCI generator (an Eclipse plugin) access the repository (you just provide your Panlab credentials and the requested VCT).

Having access to your VCT, the FCI generator with a Model-to-Model transformation, transforms the VCT from the repository model to an internal model representation of the VCT inside Eclipse.

The next step is to transform the VCT model to code. This is done with a model-to-text transformation. Currently VCT code is generated in Java and C.

Finally you are able to import the classes and libraries into your code, either in your SUT or to an external control application


Advantages of using such an approach while testing execution

Using such an API while testing and managing resources through the Panlab office Teagle web services during testing enables (when of course internal architectural components implement these):

  • Security: Access resources in a uniform manner, from a single point ensures encapsulation and denial of resource interfaces during testing
  • Auditing: Does Panlab assure the VCT’s SLA during the execution? Panlab can check and match the requests if the SLA is fulfilled
  • Governance: Make sure that policies are enforced during the execution even on different levels from Teagle down to PTMs and resources
  • Metering: Determine who uses the services and to what extent
  • Billing: Determine the use of services and apply proper billing according to run-time info (i.e. per usage)
  • Elasticity: Re-configure or even request resources (if allowed) during execution of testing

Developing Apps for testing in the federation with the Federation Computing Interface: An example

Here we will give a step by step process for using FCI for your VCTs.

Step 1: Create your VCT as usually in the VCT tool.

Here is our example VCT which has the name academic06:

Step 2: Provision your VCT

Again as usual press the Book button

Step 3: Save your VCT

Save your VCT after provisioning. If you wish you can check in the VCT tool the aliases of your reserved resource (the IDs) for example the following image displays the resource-ID of the rubis_proxy resource. In our example the reserved resource has the alias uop.rubis_proxy-15

Step 4: Get the FCI for your VCT

In Eclipse create as usual a new Java project. In our example we name it gr.panlab.FCI.myApplication.

From the Toolbar press the Generate FCI button, or go from the menu Panlab, or right click in the src folder and select from the popup menu Generate Federation Computing Interface.

The following window will appear where you should fill with values. For our example we select to generate Java code for our VCT:


Press Finish

Step 5: Import the FCI core and the libraries

Get (see Download section) the FCI core library for Java (or C) and also the Java third library parties. You need to configure your build path of your project (In Eclipse:Properties, Build Path, Add external Jars) and import these libraries. Your project should look like the following:

Step 6: Get access through your code to the resources

When the transformation and generation finishes you will see an example Main.java application, just to show you how you can access your VCT resources. We have modified the request to the following example code:


In the above example, from our code we dynamically change the resource parameters and we start a traffic generator.
We make a get to the resource ( myvct.getuop_rubis_app_19().getMON_CPU_UTILIZATION() ) in order to give us back some values for monitoring. Finally we set dynamically a new CPU capacity to the resource.

It is important to remember that all these requests are going through the Teagle services down to the resources.
If you run the Java small application Main.java you will see responses from the resources like the following image:


Installation

FCI Core has been tested with the latest Eclipse Helios version (RC4). You need the Eclipse Modeling Tools edition so please go to http://www.eclipse.org/downloads/index-helios.php and download it.

Lunch Eclipse and go to Help-> Install Modeling components. Make sure to check XPand (and any others you wish). After installation restart Eclipse.

Download the FCI sdk (see download section on fci-sdk) and unzip it somewhere to your computer. You will see there an fciplugins.zip file

On Eclipse go to Help->Install New Software…

Press the Add button, Press the Archive button and locate the file fciplugins.zip. Press OK.

You will see a similar window like the following:


Just proceed with the Installation and restart Eclipse.

After restarting you will have a menu Panlab, and a button Generate FCI!


Future work

There are still much to do.

  • Some architectural elements are missing from our architecture and are under development.
  • FCI should provide a secure https interface towards the Panlab web services.
  • Performance is a major issue which highly depends on the response time of the underlying resources
  • More target languages, like Python, will soon be offered

Downloads

Eclipse SDK FCI Generator plugins and FCI Core Library for Java
http://svn.panlab.net/PII/repos/Software/download/binaries/FCI/Java/onebundle-java-fci-1.0.0.zip

FCI Core Library for C and some examples
http://svn.panlab.net/PII/repos/Software/download/binaries/FCI/C/libfci-0.0.2.tar.gz


Important notes to be considered for RA developers in order to give back proper response on GET requests of the PTM.

[if you use RADL to develop RAs you can skip this section]

In order for your RAs to provide proper feedback on GET requests, they should respond an XML like the following:

<rubis_app>
   <uuid type="string">uop.rubis_app-19</uuid>
   <APP_VLANID>23</APP_VLANID>
   <APP_IP>10.0.0.152</APP_IP>
   <APP_GW>10.0.0.254</APP_GW>
   <APP_MEM>192</APP_MEM>
   <APP_DISKSPACE>2000</APP_DISKSPACE>
   <APP_DBIP>10.0.0.150</APP_DBIP>
   <CPU_CAPACITY>50</CPU_CAPACITY>
   <MON_CPU_UTILIZATION>0.0
   </MON_CPU_UTILIZATION>
</rubis_app>

This is implemented in your RA in the {{{ public String query(String conf_data) }}} procedure in the following section like:

if(top.equalsIgnoreCase("get"))
return  XMLUtil.xmlHeader+
                    "<"+m_type+">"+
                        "<uuid type=\"string\">"+m_id+"</uuid>"+
                        
         				"<APP_VLANID>"+m_configuration.get("APP_VLANID")+"</APP_VLANID>"	+
         				"<APP_IP>"+m_configuration.get("APP_IP")+"</APP_IP>"	+
         				"<APP_GW>"+m_configuration.get("APP_GW")+"</APP_GW>"	+
         				"<APP_MEM>"+m_configuration.get("APP_MEM")+"</APP_MEM>"	+
         				"<APP_DISKSPACE>"+m_configuration.get("APP_DISKSPACE")+"</APP_DISKSPACE>"	+
         				"<APP_DBIP>"+m_configuration.get("APP_DBIP")+"</APP_DBIP>"	+
         				"<CPU_CAPACITY>"+m_configuration.get("CPU_CAPACITY")+"</CPU_CAPACITY>"	+
         				"<MON_CPU_UTILIZATION>"+getCPUTutilization()+"</MON_CPU_UTILIZATION>"
					+
                    "</"+m_type+">";


Of course if you use RADL you don’t need to worry. This is automatically generated


License

Please read the license files included in the binaries.


Contact

If you need some more info either submit an issue to trac or e-mail to tranoris (at) ece.upatras.gr

For the C FCI core library e-mail Pierpaolo Giacomin: yrz (at) anche.no

Last modified 6 years ago Last modified on Oct 11, 2011, 4:43:43 PM

Attachments (10)

Download all attachments as: .zip