Danny's tech notebook | 丹尼技術手札

Big Switch Netwoks give a brief introduction about the new with OpenFlow v1.2 as the following URL:
What is new with OpenFlow v1.2?

I also paste the summary from that and aslo add a few comments by my point of view.

OpenFlow 1.0: Dec 2010

First “official” release
Basic QoS – minimum bandwidth guarantees
Flow Cookies – store metadata in flow table
Broadly implemented

OpenFlow 1.1: Feb 2011

Multiple tables
Group table – ECMP, fast failover, Multicast
MPLS/QinQ support
Few implementaKon, less deployment

Openflow 1.2: Dec 2011

More flexible packet matching

Makes specification easier to extend
Allows third-parties to define their own match types

Basic IPv6 support

Match on src/dst IPv6 address + flow label
No support for matching IPv6 extensions

Improved controller failover mechanism

Enables “active-active” fast-failover

It needs switch to co-operate with controller.

v1.2 is inherent from most of the features from v1.1
v1.1 and v1.2 are not compatible with v1.0

The flow table is different from v1.0. In v1.2, it has "Match Fields", "Counters", and "Instructions" instead of "Actions"

Openflow 1.3 Apr 2012:

introduces per flow meters, IPv6 extension header

handling, flexible table miss support, enhanced/refactored
capability negotiation, multipart requests, MPLS BoS matching,
push/pop for PBB, tunnel-ID meta-data, cookies for packet_in
messages, augmented flow table entry (adds cookie), among others

Configuration Protocol under co-development

Monday, October 29, 2012

[VirtualBox] Daily Operation in Linux VM ( VDI file ) with tip and trick

If you use VirtulBox on Windows for your virtual machine environment, you will encounter some daily operation issues that are kind of tedious. Here I want to provide some useful commands for quickly solving some common operation in Linux VM.

When you want to duplicate original VDI file to use in other VirtualBox environment, you need to execute this:

> "C:\Program Files\Oracle\VirtualBox\VBoxManage" clonevdi source.vdi output.vdi

To clean up the empty space in your VDI file ( it could reduce the size of your VDI file ), there are 2 steps:

On Linux VM
> dd if=/dev/zero of=fillfile bs=1M ( running on
> rm fillfile
On VirtualBox Host ( Windows )
"C:\Program Files\Oracle\VirtualBox\VBoxManage" modifyhd your_VDI.vdi --compact

To change the size of your VirtualBox VDI file

"C:\Program Files\Oracle\VirtualBox\VBoxManage"--resize SIZE_IN_MB
YOUR_HARD_DISK.vdi

Tuesday, October 9, 2012

[Trema] How to sync threads using ZeroMQ in Trema

If someone is familiar with Trema, then he/she knows that the socket mode in Trema is non-blocking, which means there is no waiting when sending the request message. But, here is an question. If we want to use ZeroMQ ( in different thread ) to receive the flow stats request from outside world and how do we sync threads and get flow stats info from OFSwitch?

My approach uses "pthread mutex". The key point is in the red box as following picture. When Zmq_Responder receives flow stats request, it will run a callback function, lock the mutex variable, and send flow stats request to OF Switch ( it is non-blocking socket mode ). After sending, Zmq_Responder will be locked and will wait for OF Switch to reply flow stats message. Once it replies, Routing Switch in the main thread will produce the reply message and unlock the mutex variable and let Zmq_Responder to reply to outside world.

The approach can sync these two threads in the sequence, but also has some kind of dead-lock risk. If some one has a better solution, let me know if you are willing.

Tuesday, October 2, 2012

[Trema] Try the cucumber scenarios in Trema

When you install Trema ready, you can try this in Trema path:
trema> sudo cucumber -r features

And then you will get a lot of log and info on screen. For instance, this is what I got:

Failing Scenarios:
cucumber features/example.message.echo_reply.feature:8 # Scenario: Send echo reply x 10
cucumber features/example.message.echo_reply.feature:18 # Scenario: Send echo reply x 10 in Ruby
cucumber features/example.message.echo_request.feature:8 # Scenario: Send echo request x 10
cucumber features/example.message.echo_request.feature:18 # Scenario: Send echo request x 10 in Ruby
cucumber features/example.message.features_request.feature:8 # Scenario: Send a features request
cucumber features/example.message.features_request.feature:48 # Scenario: Send a features request in Ruby
cucumber features/example.message.hello.feature:8 # Scenario: Hello trema
cucumber features/example.message.hello.feature:18 # Scenario: Hello trema in Ruby
cucumber features/example.message.set_config.feature:8 # Scenario: set config x 10
cucumber features/example.message.set_config.feature:19 # Scenario: set config x 10 in Ruby
cucumber features/example.packetin_filter_config.feature:8 # Scenario: add filter
cucumber features/example.packetin_filter_config.feature:23 # Scenario: dump filter
cucumber features/example.packetin_filter_config.feature:40 # Scenario: dump filter strict
cucumber features/example.packetin_filter_config.feature:62 # Scenario: delete filter strict
cucumber features/example.packetin_filter_config.feature:83 # Scenario: delete filter
cucumber features/packetin_filter.feature:8 # Scenario: packetin_filter --help
cucumber features/packetin_filter.feature:33 # Scenario: packetin_filter -h
cucumber features/switch_manager.feature:8 # Scenario: switch_manager --help
cucumber features/switch_manager.feature:26 # Scenario: switch_manager -h

84 scenarios (19 failed, 65 passed)

417 steps (19 failed, 47 skipped, 351 passed)

7m0.821s

Or if you want to further test Trema/Apps, for instance, sliceable_switch app, you can do this:
trema> sudo cucumber -r features -r ../apps/sliceable_switch/features /home/liudanny/SourceCode/apps/sliceable_switch/features/port_binding.feature
But, I am not sure it is correct way or not and will figure it out.

[Cucumber] how to use cucumber with a simple example

As my early post [Cucumber] An brief introduction, Cucumber is an amazing testing tool and it is about Behaviour-Driven Development instead of Test-Driven Development.

The book "The Cucumber Book" gives a very good explanation and useful of examles to illustrate the usages and functionalities in depths.

Based on that book's a good simple example, the following picture give the dictionary structure (left hand side ) and 3 of important files ( right hand side ) as follows:

"adding.feature" is file contained scenario ( test case )
"calc.rb" provides the calculation function for calculator_steps.rb
" calculator_steps.rb" provide the functions mapping to feature's script based on the key words: Given, When, and Then

Under the path, we run "cucumber" and then get the information as below:

Feature: Adding

Scenario Outline: Add two numbers      # features/adding.feature:3
    Given the input "<input>"            # features/step_definitions/calculator_steps.rb:9
    When the calculator is run           # features/step_definitions/calculator_steps.rb:13
    Then the output should be "<output>" # features/step_definitions/calculator_steps.rb:18

    Examples:
      | input | output |
      | 2+2    | 4    |
      | 98+1 | 99      |

2 scenarios (2 passed)
6 steps (6 passed)
0m0.012s

Wednesday, September 26, 2012

[JSON] How to use jansson lib to generate JSON data in C

This exmple method will generate the result string below:

{ "command":"link_status",
"result":["AAABBBCCC"] }

char* 
generate_json_data() {
  
  char *ret_strings = NULL;
  char *ret_string = "AAABBBCCC";
  
  json_t *root = json_object();
  json_t *result_json_arr = json_array();
  
  json_object_set_new( root, "command", json_string( "link_status" ) );
  json_object_set_new( root, "result", result_json_arr );
  
  ...
    
  json_array_append( result_json_arr, json_string( ret_string ) );
  free( ret_string );
  ret_strings = json_dumps( root, 0 );
  json_decref( root );
  return ret_strings;
}


For more example in details: 

#include <stdio.h>
#include <jansson.h>

void add_2array_to_json( json_t* obj, const char* name, const int*
marr, size_t dim1, size_t dim2 )
{
    size_t i, j;
    json_t* jarr1 = json_array();

    for( i=0; i<dim1; ++i ) {
        json_t* jarr2 = json_array();

        for( j=0; j<dim2; ++j ) {
            int val = marr[ i*dim2 + j ];
            json_t* jval = json_integer( val );
            json_array_append_new( jarr2, jval );
        }
        json_array_append_new( jarr1, jarr2 );
    }
    json_object_set_new( obj, name, jarr1 );
    return;
}

int main()
{
    json_t* jdata;
    char* s;
    int arr1[2][3] = { {1,2,3}, {4,5,6} };
    int arr2[4][4] = { {1,2,3,4}, {5,6,7,8}, {9,10,11,12}, {13,14,15,16} };

    jdata = json_object();
    add_2array_to_json( jdata, "arr1", &arr1[0][0], 2, 3 );
    add_2array_to_json( jdata, "arr2", &arr2[0][0], 4, 4 );

    s = json_dumps( jdata, 0 );
    puts( s );
    free( s );
    json_decref( jdata );

    return 0;
}


When run it outputs:
{"arr1": [[1, 2, 3], [4, 5, 6]], "arr2": [[1, 2, 3, 4], [5, 6, 7, 8],
[9, 10, 11, 12], [13, 14, 15, 16]]}

Another example:

#include "jansson.h"  
   
 ...  
   
 json_error_t error;  
 json_t *root = json_loads( reply->data.buffer, 0, &error );  
 if( root )  
 {  
   json_t *jsonData = json_object_get( root, "data" );  
   if( json_is_array( jsonData ) )  
   {  
     const uint length = json_array_size( jsonData );  
     for( uint i=0; i<length; ++i ) // Iterates over the sequence elements.  
     {  
       json_t *jsonObject = json_array_get( jsonData, i );  
         
       json_t *jsonID = json_object_get( jsonObject, "id" );  
       const char *jsonStringID = json_string_value( jsonID );  
         
       json_t *jsonName = json_object_get( jsonObject, "name" );  
       const char *jsonStringName = json_string_value( jsonName );  
         
       // We can now do something with our Name and ID  
     }  
   }  
   json_decref( root ); 
 }  