trema 0.1.3

data/ruby/sub-process.rb

@@ -0,0 +1,291 @@
+#
+# Spawns a process and connects pipes to its stdout/stderr and obtain
+# its exit code.
+#
+#
+# == Example:
+#
+#  SubProcess.create do | shell |
+#    # Add some hooks here
+#    shell.on_stdout do | line |
+#      log line
+#      $stdout.puts line
+#    end
+#    shell.on_stderr do | line |
+#      log line
+#      $stderr.puts line
+#    end
+#    shell.on_failure do
+#      raise "'#{ command }' failed."
+#    end
+#
+#    # Spawn a subprocess
+#    shell.exec command
+#  end
+#
+#
+# == Hooks:
+#
+# <tt>on_stdout</tt>:: Executed when a new line arrived from sub-process's stdout.
+# <tt>on_stderr</tt>:: Executed when a new line arrived from sub-process's stderr.
+# <tt>on_exit</tt>:: Executed when sub process exited.
+# <tt>on_success</tt>:: Executed when sub process exited successfully.
+# <tt>on_failure</tt>:: Executed when sub process exited with an error.
+#
+#
+# == Credit:
+#
+# Author: Yasuhito Takamiya <yasuhito@gmail.com>
+#
+# Copyright (C) 2008-2012 NEC Corporation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License, version 2, as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+
+
+module SubProcess
+  class Command
+    attr_reader :command
+    attr_reader :env
+
+
+    def initialize command, env = {}
+      @command = command
+      @env = env
+    end
+
+
+    def start
+      @env.each_pair do | key, value |
+        ENV[ key ]= value
+      end
+      Kernel.exec @command
+    end
+  end
+
+
+  class PipeSet
+    attr_reader :stdin
+    attr_reader :stdout
+    attr_reader :stderr
+
+
+    def initialize stdin, stdout, stderr
+      @stdin = stdin
+      @stdout = stdout
+      @stderr = stderr
+    end
+
+
+    def close
+      [ @stdin, @stdout, @stderr ].each do | each |
+        unless each.closed?
+          each.close
+        end
+      end
+    end
+  end
+
+
+  class Process
+    def initialize
+      stdin, stdout, stderr = Array.new( 3 ) { IO.pipe }
+      @child = SubProcess::PipeSet.new( stdin[ 1 ], stdout[ 0 ], stderr[ 0 ] )
+      @parent = SubProcess::PipeSet.new( stdin[ 0 ], stdout[ 1 ], stderr[ 1 ] )
+    end
+
+
+    def wait
+      ::Process.wait @pid
+    end
+
+
+    def popen command, &block
+      @pid = fork_child( command )
+      # Parent process
+      @parent.close
+      begin
+        yield @child.stdout, @child.stderr
+      ensure
+        @child.close
+      end
+      self
+    end
+
+
+    ############################################################################
+    private
+    ############################################################################
+
+
+    def fork_child command
+      Kernel.fork do
+        @child.close
+        redirect_child_io
+        command.start
+      end
+    end
+
+
+    def redirect_child_io
+      STDIN.reopen @parent.stdin
+      STDOUT.reopen @parent.stdout
+      STDERR.reopen @parent.stderr
+      @parent.close
+    end
+  end
+
+
+  class IoHandlerThread
+    def initialize io, method
+      @io = io
+      @method = method
+    end
+
+
+    def start
+      Thread.new( @io, @method ) do | io, method |
+        while io.gets do
+          method.call $LAST_READ_LINE
+        end
+      end
+    end
+  end
+
+
+  class Shell
+    def self.open debug_options = {}, &block
+      block.call self.new( debug_options )
+    end
+
+
+    def initialize debug_options
+      @debug_options = debug_options
+    end
+
+
+    def child_status
+      $CHILD_STATUS
+    end
+
+
+    def on_stdout &block
+      @on_stdout = block
+    end
+
+
+    def on_stderr &block
+      @on_stderr = block
+    end
+
+
+    def on_exit &block
+      @on_exit = block
+    end
+
+
+    def on_success &block
+      @on_success = block
+    end
+
+
+    def on_failure &block
+      @on_failure = block
+    end
+
+
+    def exec command, env = { "LC_ALL" => "C" }
+      on_failure { raise "command #{ command } failed" } unless @on_failure
+      SubProcess::Process.new.popen SubProcess::Command.new( command, env ) do | stdout, stderr |
+        handle_child_output stdout, stderr
+      end.wait
+      handle_exitstatus
+      self
+    end
+
+
+    ############################################################################
+    private
+    ############################################################################
+
+
+    def handle_child_output stdout, stderr
+      tout = SubProcess::IoHandlerThread.new( stdout, method( :do_stdout ) ).start
+      terr = SubProcess::IoHandlerThread.new( stderr, method( :do_stderr ) ).start
+      tout.join
+      terr.join
+    end
+
+
+    # run hooks ################################################################
+
+
+    def handle_exitstatus
+      do_exit
+      if child_status.exitstatus == 0
+        do_success
+      else
+        do_failure
+      end
+    end
+
+
+    def do_stdout line
+      if @on_stdout
+        @on_stdout.call line
+      end
+    end
+
+
+    def do_stderr line
+      if @on_stderr
+        @on_stderr.call line
+      end
+    end
+
+
+    def do_failure
+      if @on_failure
+        @on_failure.call
+      end
+    end
+
+
+    def do_success
+      if @on_success
+        @on_success.call
+      end
+    end
+
+
+    def do_exit
+      if @on_exit
+        @on_exit.call
+      end
+    end
+  end
+
+
+  def create debug_options = {}, &block
+    Shell.open debug_options, &block
+  end
+  module_function :create
+end
+
+
+### Local variables:
+### mode: Ruby
+### coding: utf-8-unix
+### indent-tabs-mode: nil
+### End:

data/ruby/trema/action-common.c

@@ -0,0 +1,60 @@
+/*
+ * Author: Nick Karanatsios <nickkaranatsios@gmail.com>
+ *
+ * Copyright (C) 2008-2012 NEC Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+
+#include <stdint.h>
+#include "ruby.h"
+
+
+/*
+ * @return [Number] an IPv4 address in its numeric representation.
+ */
+uint32_t
+nw_addr_to_i( VALUE nw_addr ) {
+  return ( uint32_t ) NUM2UINT( rb_funcall( nw_addr, rb_intern( "to_i" ), 0 ) );
+}
+
+
+/*
+ * @return [String] an IPv4 address in its text representation.
+ */
+VALUE
+nw_addr_to_s( VALUE nw_addr ) {
+  return rb_funcall( nw_addr, rb_intern( "to_s" ), 0 );
+}
+
+
+uint8_t *
+dl_addr_short( VALUE dl_addr, uint8_t *ret_dl_addr ) {
+  VALUE mac_arr = rb_funcall( dl_addr, rb_intern( "to_short" ), 0 );
+  int i;
+
+  for ( i = 0; i < RARRAY_LEN( mac_arr); i++ ) {
+    ret_dl_addr[ i ] = ( uint8_t ) ( NUM2INT( RARRAY_PTR( mac_arr )[ i ] ) );
+  }
+  return ret_dl_addr;
+}
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */

data/ruby/trema/action-common.h

@@ -0,0 +1,42 @@
+/*
+ * Author: Nick Karanatsios <nickkaranatsios@gmail.com>
+ *
+ * Copyright (C) 2008-2012 NEC Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+
+#ifndef ACTION_COMMON_H
+#define ACTION_COMMON_H
+
+
+uint32_t nw_addr_to_i( VALUE nw_addr );
+
+
+VALUE nw_addr_to_s( VALUE nw_addr );
+
+
+uint8_t *dl_addr_short( VALUE dl_addr, uint8_t *ret_dl_addr );
+
+
+#endif // ACTION_COMMON_H
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */

data/ruby/trema/action-enqueue.c

@@ -0,0 +1,161 @@
+/*
+ * Author: Nick Karanatsios <nickkaranatsios@gmail.com>
+ *
+ * Copyright (C) 2008-2012 NEC Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+
+#include "trema.h"
+#include "ruby.h"
+
+
+extern VALUE mTrema;
+VALUE cActionEnqueue;
+
+
+/*
+ * Enqueues the packet on the specified queue attached to a port. When a queue
+ * is configured the user can associate a flow with this action to forward a
+ * packet through the specific queue in that port.
+ *
+ * @overload initialize(options={})
+ *
+ *   @example
+ *     ActionEnqueue.new( :port => 1, :queue_id => 2 )
+ *
+ *   @param [Hash] options
+ *     the options hash to create this action class instance with.
+ *
+ *   @option options [Number] :port
+ *     the port the queue is attached to.
+ *
+ *   @option options [Number] :queue_id
+ *     the configured queue. Currently only minimum rate queues provided.
+ *
+ *   @raise [ArgumentError] if both port and queue_id arguments not supplied.
+ *   @raise [ArgumentError] if port is not an unsigned 16-bit integer.
+ *   @raise [ArgumentError] if queue id is not an unsigned 32-bit integer.
+ *   @raise [TypeError] if options is not a Hash.
+ *
+ *   @return [ActionEnqueue] self
+ *     an object that encapsulates this action.
+ */
+static VALUE
+action_enqueue_init( int argc, VALUE *argv, VALUE self ) {
+  VALUE options;
+
+  if ( rb_scan_args( argc, argv, "01", &options ) == 1 ) {
+    Check_Type( options, T_HASH );
+    VALUE port;
+    if ( ( port = rb_hash_aref( options, ID2SYM( rb_intern( "port" ) ) ) ) != Qnil ) {
+      if ( rb_funcall( port, rb_intern( "unsigned_16bit?" ), 0 ) == Qfalse ) {
+        rb_raise( rb_eArgError, "Port must be an unsigned 16-bit integer" );
+      }
+      rb_iv_set( self, "@port", port );
+    }
+    else {
+      rb_raise( rb_eArgError, "Port is a mandatory option" );
+    }
+    VALUE queue_id;
+    if ( ( queue_id = rb_hash_aref( options, ID2SYM( rb_intern( "queue_id" ) ) ) ) != Qnil ) {
+      if ( rb_funcall( queue_id, rb_intern( "unsigned_32bit?" ), 0 ) == Qfalse ) {
+        rb_raise( rb_eArgError, "Queue id must be an unsigned 32-bit integer" );
+      }
+      rb_iv_set( self, "@queue_id", queue_id );
+    }
+    else {
+      rb_raise( rb_eArgError, "Queue id is a mandatory option" );
+    }
+  }
+  else {
+    rb_raise( rb_eArgError, "Port, queue id are mandatory options" );
+  }
+  return self;
+}
+
+
+/*
+ * The port the queue is attached to.
+ *
+ * @return [Number] the value of port.
+ */
+static VALUE
+action_enqueue_get_port( VALUE self ) {
+  return rb_iv_get( self, "@port" );
+}
+
+
+/*
+ * The configured queue.
+ *
+ * @return [Number] the value of queue_id.
+ */
+static VALUE
+action_enqueue_get_queue_id( VALUE self ) {
+  return rb_iv_get( self, "@queue_id" );
+}
+
+/*
+ * Appends its action(enqueue) to the list of actions.
+ *
+ * @return [ActionEnqueue] self
+ */
+static VALUE
+action_enqueue_append( VALUE self, VALUE action_ptr ) {
+  uint32_t queue_id = ( uint32_t ) NUM2UINT( action_enqueue_get_queue_id( self ) );
+  uint16_t port = ( uint16_t ) NUM2UINT( action_enqueue_get_port( self ) );
+  
+  openflow_actions *actions;
+  Data_Get_Struct( action_ptr, openflow_actions, actions );
+  append_action_enqueue( actions, port, queue_id );
+  return self;
+}
+
+
+/*
+ * A text representation of its attributes.
+ *
+ * @return [String] 
+ */
+static VALUE
+action_enqueue_inspect( VALUE self ) {
+  uint32_t queue_id = ( uint32_t ) NUM2UINT( action_enqueue_get_queue_id( self ) );
+  uint16_t port = ( uint16_t ) NUM2UINT( action_enqueue_get_port( self ) );
+  
+  char str[ 64 ];
+  sprintf( str, "#<%s port=%u,queue_id=%u>", rb_obj_classname( self ), port,
+          queue_id );
+  return rb_str_new2( str );
+}
+
+
+void
+Init_action_enqueue() {
+  cActionEnqueue = rb_define_class_under( mTrema, "ActionEnqueue", rb_cObject );
+  rb_define_method( cActionEnqueue, "initialize", action_enqueue_init, -1 );
+  rb_define_method( cActionEnqueue, "port", action_enqueue_get_port, 0 );
+  rb_define_method( cActionEnqueue, "queue_id", action_enqueue_get_queue_id, 0 );
+  rb_define_method( cActionEnqueue, "append", action_enqueue_append, 1 );
+  rb_define_method( cActionEnqueue, "inspect", action_enqueue_inspect, 0 );
+}
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */