trema 0.1.3

data/ruby/trema/port.h

@@ -0,0 +1,47 @@
+/*
+ * Physical port class.
+ *
+ * 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.
+ */
+
+
+#ifndef PORT_H
+#define PORT_H
+
+
+#include "ruby.h"
+
+
+extern VALUE cPort;
+
+
+void Init_port( void );
+
+
+VALUE port_from( const struct ofp_phy_port *phy_port );
+
+
+#endif // PORT_H
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */

data/ruby/trema/process.rb

@@ -0,0 +1,76 @@
+#
+# Trema process.
+#
+# 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 Trema
+  class Process
+    def self.read pid_file, name = nil
+      name = File.basename( pid_file, ".pid" ) if name.nil?
+      return new( pid_file, name )
+    end
+
+
+    def initialize pid_file, name
+      @name = name
+      @pid_file = pid_file
+      begin
+        @pid = IO.read( @pid_file ).chomp.to_i
+        @uid = File.stat( @pid_file ).uid
+      rescue
+        @pid_file = nil
+      end
+    end
+
+
+    def kill!
+      return if @pid_file.nil?
+      return if dead?
+      puts "Shutting down #{ @name }..." if $verbose
+      10.times do
+        if @uid == 0
+          sh "sudo kill #{ @pid } 2>/dev/null" rescue nil
+        else
+          sh "kill #{ @pid } 2>/dev/null" rescue nil
+        end
+        return
+        # return if dead?
+      end
+      raise "Failed to shut down #{ @name }"
+    end
+
+
+    ################################################################################
+    private
+    ################################################################################
+
+
+    def dead?
+      `ps ax | grep -E "^[[:blank:]]*#{ @pid }"`.empty?
+    end
+  end
+end
+
+
+### Local variables:
+### mode: Ruby
+### coding: utf-8
+### indent-tabs-mode: nil
+### End:

data/ruby/trema/queue-get-config-reply.c

@@ -0,0 +1,200 @@
+/*
+ * 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 cQueueGetConfigReply;
+
+
+/*
+ * A reply instance of {QueueGetConfigReply} constructed when
+ * +OFPT_QUEUE_GET_CONFIG_REPLY+ message received.
+ *
+ * @overload initialize(options={})
+ *
+ *   @example
+ *     QueueGetConfigReply.new(
+ *       :datapath_id => 0xabc,
+ *       :transaction_id => 1
+ *       :port => 1,
+ *       :queues => [ PacketQueue ]
+ *     )
+ *
+ *   @param [Hash] options
+ *     the options to create a message with.
+ *
+ *   @option options [Number] :datapath_id
+ *     a unique name that identifies an OpenVSwitch, the message originator.
+ *
+ *   @option options [Number] :transaction_id
+ *     value copied from +OPFT_QUEUE_SET_CONFIG_REQUEST+ message.
+ *  
+ *   @option options [Number] :port
+ *     the port the queue is attached to.
+ *
+ *   @option options [Array] :queues
+ *     an array of {PacketQueue} objects.
+ *
+ *   @return [QueueGetConfigReply]
+ *     an object that encapsulates the +OFPT_QUEUE_GET_CONFIG_REPLY+ OpenFlow message.
+ */
+static VALUE
+queue_get_config_reply_init( VALUE self, VALUE options ) {
+  rb_iv_set( self, "@attribute", options );
+  return self;
+}
+
+
+/*
+ * Message originator identifier.
+ *
+ * @return [Number] the value of datapath_id.
+ */
+static VALUE
+queue_get_config_reply_datapath_id( VALUE self ) {
+  return rb_hash_aref( rb_iv_get( self, "@attribute" ), ID2SYM( rb_intern( "datapath_id" ) ) );
+}
+
+
+/*
+ * Transaction ids, message sequence numbers matching requests to replies.
+ *
+ * @return [Number] the value of transaction id.
+ */
+static VALUE
+queue_get_config_reply_transaction_id( VALUE self ) {
+  return rb_hash_aref( rb_iv_get( self, "@attribute" ), ID2SYM( rb_intern( "transaction_id" ) ) );
+}
+
+
+/*
+ * The port the queue is attached to.
+ *
+ * @return [Number] the value of port.
+ */
+static VALUE
+queue_get_config_reply_port( VALUE self ) {
+  return rb_hash_aref( rb_iv_get( self, "@attribute" ), ID2SYM( rb_intern( "port" ) ) );
+}
+
+
+/*
+ * An array of {PacketQueue} objects. A packet queue is further classified
+ * depending on its properties. Currently only a minimum-rate type queue 
+ * supported.
+ *
+ * @return [Array<PacketQueue>] the value of queues.
+ */
+static VALUE
+queue_get_config_reply_queues( VALUE self ) {
+  return rb_hash_aref( rb_iv_get( self, "@attribute" ), ID2SYM( rb_intern( "queues" ) ) );
+}
+
+
+void
+Init_queue_get_config_reply() {
+  rb_require( "trema/packet-queue" );
+  cQueueGetConfigReply = rb_define_class_under( mTrema, "QueueGetConfigReply", rb_cObject );
+  rb_define_method( cQueueGetConfigReply, "initialize", queue_get_config_reply_init, 1 );
+  rb_define_method( cQueueGetConfigReply, "datapath_id", queue_get_config_reply_datapath_id, 0 );
+  rb_define_method( cQueueGetConfigReply, "transaction_id", queue_get_config_reply_transaction_id, 0 );
+  rb_define_method( cQueueGetConfigReply, "port", queue_get_config_reply_port, 0 );
+  rb_define_method( cQueueGetConfigReply, "queues", queue_get_config_reply_queues, 0 );
+}
+
+
+static void
+get_property( struct ofp_packet_queue *pq, VALUE packet_queue ) {
+  size_t offset = offsetof( struct ofp_packet_queue, properties );
+  struct ofp_queue_prop_header *qph;
+  qph = ( struct ofp_queue_prop_header * ) ( ( char * ) pq + offset );
+
+  uint16_t properties_length = ( uint16_t ) ( pq->len - offset );
+  struct ofp_queue_prop_min_rate *qpmr;
+  while ( properties_length > 0 ) {
+    if ( qph->property == OFPQT_MIN_RATE ) {
+      qpmr = ( struct ofp_queue_prop_min_rate * ) qph;
+      rb_funcall( rb_eval_string( "Trema::MinRateQueue" ), rb_intern( "new" ), 4,
+        UINT2NUM( qph->property ),
+        UINT2NUM( qph->len ),
+        UINT2NUM( qpmr->rate ),
+        packet_queue );
+    }
+    properties_length = ( uint16_t ) ( properties_length - pq->len );
+    if ( properties_length > 0 ) {
+      qph = ( struct ofp_queue_prop_header * ) ( ( char * ) qph + qph->len );
+    }
+  }
+}
+
+
+void
+handle_queue_get_config_reply(
+  uint64_t datapath_id,
+  uint32_t transaction_id,
+  uint16_t port,
+  list_element *queues,
+  void *user_data
+) {
+  VALUE controller = ( VALUE ) user_data;
+  if ( rb_respond_to( controller, rb_intern( "queue_get_config_reply" ) ) == Qfalse ) {
+    return;
+  }
+
+  VALUE attributes = rb_hash_new();
+
+  list_element *queue = NULL;
+  struct ofp_packet_queue *pq;
+  VALUE pq_attributes = rb_hash_new();
+  VALUE packet_queue;
+
+
+  rb_hash_aset( attributes, ID2SYM( rb_intern( "datapath_id" ) ), ULL2NUM( datapath_id ) );
+  rb_hash_aset( attributes, ID2SYM( rb_intern( "transaction_id" ) ), UINT2NUM( transaction_id ) );
+  rb_hash_aset( attributes, ID2SYM( rb_intern( "port" ) ), UINT2NUM( port ) );
+
+  if ( queues != NULL ) {
+    queue = queues;
+    while ( queue != NULL ) {
+      pq = ( struct ofp_packet_queue * ) queue->data;
+
+      rb_hash_aset( pq_attributes, ID2SYM( rb_intern( "queue_id" ) ), UINT2NUM( pq->queue_id ) );
+      rb_hash_aset( pq_attributes, ID2SYM( rb_intern( "len" ) ), UINT2NUM( pq->len ) );
+      packet_queue = rb_funcall( rb_eval_string( "Trema::PacketQueue" ), rb_intern( "new" ), 1, pq_attributes );
+
+      get_property( pq, packet_queue );
+      queue = queue->next;
+    }
+    rb_hash_aset( attributes, ID2SYM( rb_intern( "queues" ) ), rb_eval_string( "PacketQueue.queues" ) );
+  }
+  VALUE queue_get_config_reply = rb_funcall( cQueueGetConfigReply, rb_intern( "new" ), 1, attributes );
+  rb_funcall( controller, rb_intern( "queue_get_config_reply" ), 1, queue_get_config_reply );
+}
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */

data/ruby/trema/queue-get-config-reply.h

@@ -0,0 +1,47 @@
+/*
+ * Prototype for queue get configuration reply.
+ *
+ * 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 QUEUE_GET_CONFIG_REPLY_H
+#define QUEUE_GET_CONFIG_REPLY_H
+
+
+void Init_queue_get_config_reply();
+
+
+void handle_queue_get_config_reply(
+        uint64_t datapath_id,
+        uint32_t transaction_id,
+        uint16_t port,
+        const list_element *queues,
+        void *user_data
+        );
+
+
+#endif // QUEUE_GET_CONFIG_REPLY_H
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */

data/ruby/trema/queue-get-config-request.c

@@ -0,0 +1,141 @@
+/*
+ * 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 cQueueGetConfigRequest;
+
+
+static VALUE
+queue_get_config_request_alloc( VALUE klass ) {
+  uint16_t port = 1;
+  buffer *queue_get_config_request = create_queue_get_config_request( get_transaction_id(), port );
+  return Data_Wrap_Struct( klass, NULL, free_buffer, queue_get_config_request );
+}
+
+
+/*
+ * Request message to retrieve configuration about a queue port setting that
+ * quantifies a QoS.
+ * Each flow entry contains a queue that a flow is mapped to set constraints to
+ * define some restriction like maximum/minimum data rate.
+ *
+ * @overload initialize(options={})
+ *   @example
+ *     QueueGetConfigRequest.new
+ *     QueueGetConfigRequest.new( :port => 1 )
+ *     QueueGetConfigRequest.new( :port => 1, :transaction_id => 123 )
+ *
+ *   @param [Hash] options
+ *     the options to create a message with.
+ *
+ *   @option options [Number] :port
+ *     a port number to query (defaults to 1).
+ *
+ *   @option options [Number] :transaction_id
+ *     An unsigned 32-bit integer number associated with this message.
+ *     If not specified, an auto-generated value is set.
+ *
+ *   @raise [ArgumentError] if transaction_id is not an unsigned 32-bit integer.
+ *   @raise [ArgumentError] if port is not an unsigned 16-bit integer.
+ *   @raise [TypeError] if options is not a hash.
+ *
+ *   @return [QueueGetConfigRequest]
+ *     an object that encapsulates the +OFPT_GET_CONFIG_REQUEST+ OpenFlow message.
+ */
+static VALUE
+queue_get_config_request_init( int argc, VALUE *argv, VALUE self ) {
+  buffer *queue_get_config_request;
+  Data_Get_Struct( self, buffer, queue_get_config_request );
+  uint32_t xid = get_transaction_id();
+  uint16_t port = 1;
+
+  VALUE options;
+
+  if ( rb_scan_args( argc, argv, "01", &options ) == 1 ) {
+    Check_Type( options, T_HASH );
+    VALUE xid_ruby;
+    if ( ( xid_ruby = rb_hash_aref( options, ID2SYM( rb_intern( "transaction_id" ) ) ) ) != Qnil ) {
+      if ( rb_funcall( xid_ruby, rb_intern( "unsigned_32bit?" ), 0 ) == Qfalse ) {
+        rb_raise( rb_eArgError, "Transaction ID must be an unsigned 32-bit integer" );
+      }
+      xid = ( uint32_t ) NUM2UINT( xid_ruby );
+    }
+    VALUE port_ruby;
+    if ( ( port_ruby = rb_hash_aref( options, ID2SYM( rb_intern( "port" ) ) ) ) != Qnil ) {
+      if ( rb_funcall( port_ruby, rb_intern( "unsigned_16bit?" ), 0 ) == Qfalse ) {
+        rb_raise( rb_eArgError, "Port must be an unsigned 16-bit integer" );
+      }
+      port = ( uint16_t ) NUM2UINT( port_ruby );
+    }
+  }
+  ( ( struct ofp_header * ) ( queue_get_config_request->data ) )->xid = htonl( xid );
+  ( ( struct ofp_queue_get_config_request * ) ( queue_get_config_request->data ) )->port = htons( port );
+  return self;
+}
+
+
+/*
+ * Transaction ids, message sequence numbers matching requests to replies.
+ *
+ * @return [Number] the value of transaction id.
+ */
+static VALUE
+queue_get_config_request_transaction_id( VALUE self ) {
+  buffer *queue_get_config_request;
+  Data_Get_Struct( self, buffer, queue_get_config_request );
+  uint32_t xid = ntohl( ( ( struct ofp_header * ) ( queue_get_config_request->data ) )->xid );
+  return UINT2NUM( xid );
+}
+
+
+/*
+ * The port the queue is attached to.
+ *
+ * @return [Number] the value of port.
+ */
+static VALUE
+queue_get_config_request_port( VALUE self ) {
+  buffer *queue_get_config_request;
+  Data_Get_Struct( self, buffer, queue_get_config_request );
+  uint16_t port = ntohs( ( ( struct ofp_queue_get_config_request * ) ( queue_get_config_request->data ) )->port );
+  return UINT2NUM( port );
+}
+
+
+void
+Init_queue_get_config_request() {
+  cQueueGetConfigRequest = rb_define_class_under( mTrema, "QueueGetConfigRequest", rb_cObject );
+  rb_define_alloc_func( cQueueGetConfigRequest, queue_get_config_request_alloc );
+  rb_define_method( cQueueGetConfigRequest, "initialize", queue_get_config_request_init, -1 );
+  rb_define_method( cQueueGetConfigRequest, "transaction_id", queue_get_config_request_transaction_id, 0 );
+  rb_define_method( cQueueGetConfigRequest, "port", queue_get_config_request_port, 0 );
+}
+
+
+/*
+ * Local variables:
+ * c-basic-offset: 2
+ * indent-tabs-mode: nil
+ * End:
+ */