trema 0.3.3 → 0.3.4

data/ruby/trema/flow-removed.c

@@ -223,6 +223,9 @@ flow_removed_byte_count( VALUE self ) {
 void
 Init_flow_removed() {
   cFlowRemoved = rb_define_class_under( mTrema, "FlowRemoved", rb_cObject );
+  rb_define_const( cFlowRemoved, "OFPRR_IDLE_TIMEOUT", INT2NUM( OFPRR_IDLE_TIMEOUT ) );
+  rb_define_const( cFlowRemoved, "OFPRR_HARD_TIMEOUT", INT2NUM( OFPRR_HARD_TIMEOUT ) );
+  rb_define_const( cFlowRemoved, "OFPRR_DELETE", INT2NUM( OFPRR_DELETE ) );
   rb_define_method( cFlowRemoved, "initialize", flow_removed_init, 1 );
   rb_define_method( cFlowRemoved, "datapath_id", flow_removed_datapath_id, 0 );
   rb_define_method( cFlowRemoved, "transaction_id", flow_removed_transaction_id, 0 );

data/ruby/trema/match.c

@@ -564,6 +564,25 @@ void
 Init_match() {
   cMatch = rb_define_class_under( mTrema, "Match", rb_cObject );
   rb_define_alloc_func( cMatch, match_alloc );
+  rb_define_const( cMatch, "OFPFW_IN_PORT", INT2NUM( OFPFW_IN_PORT ) );
+  rb_define_const( cMatch, "OFPFW_DL_VLAN", INT2NUM( OFPFW_DL_VLAN ) );
+  rb_define_const( cMatch, "OFPFW_DL_SRC", INT2NUM( OFPFW_DL_SRC ) );
+  rb_define_const( cMatch, "OFPFW_DL_DST", INT2NUM( OFPFW_DL_DST ) );
+  rb_define_const( cMatch, "OFPFW_DL_TYPE", INT2NUM( OFPFW_DL_TYPE ) );
+  rb_define_const( cMatch, "OFPFW_NW_PROTO", INT2NUM( OFPFW_NW_PROTO ) );
+  rb_define_const( cMatch, "OFPFW_TP_SRC", INT2NUM( OFPFW_TP_SRC ) );
+  rb_define_const( cMatch, "OFPFW_TP_DST", INT2NUM( OFPFW_TP_DST ) );
+  rb_define_const( cMatch, "OFPFW_NW_SRC_SHIFT", INT2NUM( OFPFW_NW_SRC_SHIFT ) );
+  rb_define_const( cMatch, "OFPFW_NW_SRC_BITS", INT2NUM( OFPFW_NW_SRC_BITS ) );
+  rb_define_const( cMatch, "OFPFW_NW_SRC_MASK", INT2NUM( OFPFW_NW_SRC_MASK ) );
+  rb_define_const( cMatch, "OFPFW_NW_SRC_ALL", INT2NUM( OFPFW_NW_SRC_ALL ) );
+  rb_define_const( cMatch, "OFPFW_NW_DST_SHIFT", INT2NUM( OFPFW_NW_DST_SHIFT ) );
+  rb_define_const( cMatch, "OFPFW_NW_DST_BITS", INT2NUM( OFPFW_NW_DST_BITS ) );
+  rb_define_const( cMatch, "OFPFW_NW_DST_MASK", INT2NUM( OFPFW_NW_DST_MASK ) );
+  rb_define_const( cMatch, "OFPFW_NW_DST_ALL", INT2NUM( OFPFW_NW_DST_ALL ) );
+  rb_define_const( cMatch, "OFPFW_DL_VLAN_PCP", INT2NUM( OFPFW_DL_VLAN_PCP ) );
+  rb_define_const( cMatch, "OFPFW_NW_TOS", INT2NUM( OFPFW_NW_TOS ) );
+  rb_define_const( cMatch, "OFPFW_ALL", INT2NUM( OFPFW_ALL ) );
   rb_define_method( cMatch, "initialize", match_init, -1 );
   rb_define_method( cMatch, "compare", match_compare, 1 );
   rb_define_method( cMatch, "replace", match_replace, 1 );

data/ruby/trema/packet-in.c

@@ -1083,6 +1083,9 @@ Init_packet_in() {
   cPacketIn = rb_define_class_under( mTrema, "PacketIn", rb_cObject );
   rb_define_alloc_func( cPacketIn, packet_in_alloc );
 
+  rb_define_const( cPacketIn, "OFPR_NO_MATCH", INT2NUM( OFPR_NO_MATCH ) );
+  rb_define_const( cPacketIn, "OFPR_ACTION", INT2NUM( OFPR_ACTION ) );
+
   rb_define_method( cPacketIn, "initialize_copy", packet_in_init_copy, 1 );
 
   rb_define_method( cPacketIn, "datapath_id", packet_in_datapath_id, 0 );

data/ruby/trema/port.c

@@ -304,6 +304,18 @@ Init_port() {
 
   rb_define_const( cPort, "OFPPC_PORT_DOWN", INT2NUM( OFPPC_PORT_DOWN ) );
   rb_define_const( cPort, "OFPPS_LINK_DOWN", INT2NUM( OFPPS_LINK_DOWN ) );
+  rb_define_const( cPort, "OFPPF_10MB_HD", INT2NUM( OFPPF_10MB_HD ) );
+  rb_define_const( cPort, "OFPPF_10MB_FD", INT2NUM( OFPPF_10MB_FD ) );
+  rb_define_const( cPort, "OFPPF_100MB_HD", INT2NUM( OFPPF_100MB_HD ) );
+  rb_define_const( cPort, "OFPPF_100MB_FD", INT2NUM( OFPPF_100MB_FD ) );
+  rb_define_const( cPort, "OFPPF_1GB_HD", INT2NUM( OFPPF_1GB_HD ) );
+  rb_define_const( cPort, "OFPPF_1GB_FD", INT2NUM( OFPPF_1GB_FD ) );
+  rb_define_const( cPort, "OFPPF_10GB_FD", INT2NUM( OFPPF_10GB_FD ) );
+  rb_define_const( cPort, "OFPPF_COPPER", INT2NUM( OFPPF_COPPER ) );
+  rb_define_const( cPort, "OFPPF_FIBER", INT2NUM( OFPPF_FIBER ) );
+  rb_define_const( cPort, "OFPPF_AUTONEG", INT2NUM( OFPPF_AUTONEG ) );
+  rb_define_const( cPort, "OFPPF_PAUSE", INT2NUM( OFPPF_PAUSE ) );
+  rb_define_const( cPort, "OFPPF_PAUSE_ASYM", INT2NUM( OFPPF_PAUSE_ASYM ) );
 
   rb_define_method( cPort, "initialize", port_init, 1 );
   rb_define_method( cPort, "number", port_number, 0 );

data/ruby/trema/send-out-port.rb

@@ -75,7 +75,7 @@ module Trema
 
 
     def to_s
-      "SendOutPort: port=#{ @port_number }, max_len=#{ @max_len }"
+      "SendOutPort: port_number=#{ @port_number }, max_len=#{ @max_len }"
     end
 
 

data/ruby/trema/version.rb

@@ -17,7 +17,7 @@
 
 
 module Trema
-  VERSION = "0.3.3"
+  VERSION = "0.3.4"
 end
 
 

data/spec/spec_helper.rb

@@ -41,6 +41,14 @@ Dir[ "#{ File.dirname( __FILE__ ) }/support/**/*.rb" ].each do | each |
 end
 
 
+RSpec.configure do | config |
+  config.expect_with :rspec do | c |
+    # Ensure that 'expect' is used and disable 'should' for consistency
+    c.syntax = :expect
+  end
+end
+
+
 include Trema
 
 

data/spec/support/action.rb

@@ -20,20 +20,20 @@ require "rubygems"
 require "rspec"
 
 
-shared_examples_for "option range" do | option, range |
-  context "when #{ option } is within #{ range }" do
+shared_examples_for "option is within range" do | option, range |
+  context "with #{ option } (#{ range })" do
     let( option ) { range.first }
     it { expect { subject }.not_to raise_error( ArgumentError ) }
   end
 
 
-  context "when #{ option } < #{ range.first }" do
+  context "with #{ option } (< #{ range.first })" do
     let( option ) { range.first - 1 }
     it { expect { subject }.to raise_error( ArgumentError ) }
   end
 
 
-  context "when #{ option } > #{ range.last }" do
+  context "with #{ option } (> #{ range.last })" do
     let( option ) { range.last + 1 }
     it { expect { subject }.to raise_error( ArgumentError ) }
   end

data/spec/trema/barrier-request_spec.rb

@@ -28,7 +28,7 @@ shared_examples_for "barrier request message" do
       vswitch( "barrier-request" ) { datapath_id 0xabc }
     }.run( BarrierRequestController ) {
       controller( "BarrierRequestController" ).send_message( 0xabc, subject )
-      IO.read( File.join( Trema.log, "openflowd.barrier-request.log" ) ).should include( "OFPT_BARRIER_REQUEST" )
+      expect( IO.read( File.join( Trema.log, "openflowd.barrier-request.log" ) ) ).to include( "OFPT_BARRIER_REQUEST" )
     }
   end
 end

data/spec/trema/cli_spec.rb

@@ -135,9 +135,7 @@ module Trema
 
 
       it "should raise if both --duration and --n_pkts are specified" do
-        lambda do
-          @cli.send_packets( @dest, :duration => 10, :n_pkts => 10 )
-        end.should raise_error( "--duration and --n_pkts are exclusive." )
+        expect { @cli.send_packets( @dest, :duration => 10, :n_pkts => 10 ) }.to raise_error( "--duration and --n_pkts are exclusive." )
       end
     end
 

data/spec/trema/controller_spec.rb

@@ -58,7 +58,7 @@ module Trema
         }.run( FlowModAddController ) {
           controller( "FlowModAddController" ).send_flow_mod_add( 0xabc )
           sleep 20 # FIXME: wait to send_flow_mod_add
-          vswitch( "0xabc" ).should have( 1 ).flows
+          expect( vswitch( "0xabc" ) ).to have( 1 ).flows
         }
       end
     end

data/spec/trema/dsl/configuration_spec.rb

@@ -32,82 +32,82 @@ module Trema
 
       context "when parsing trema configurations" do
         it "should remember apps" do
-          @context.should have( 0 ).apps
+          expect( @context ).to have( 0 ).apps
 
           Trema::App.add mock( "app #0", :name => "app #0" )
           Trema::App.add mock( "app #1", :name => "app #1" )
           Trema::App.add mock( "app #2", :name => "app #2" )
 
-          @context.should have( 3 ).apps
+          expect( @context ).to have( 3 ).apps
 
-          @context.apps[ "app #0" ].name.should == "app #0"
-          @context.apps[ "app #1" ].name.should == "app #1"
-          @context.apps[ "app #2" ].name.should == "app #2"
+          expect( @context.apps[ "app #0" ].name ).to eq( "app #0" )
+          expect( @context.apps[ "app #1" ].name ).to eq( "app #1" )
+          expect( @context.apps[ "app #2" ].name ).to eq( "app #2" )
         end
 
 
         it "should remember hosts" do
-          @context.should have( 0 ).hosts
+          expect( @context ).to have( 0 ).hosts
 
           Trema::Host.add mock( "host #0", :name => "host #0" )
           Trema::Host.add mock( "host #1", :name => "host #1" )
           Trema::Host.add mock( "host #2", :name => "host #2" )
 
-          @context.should have( 3 ).hosts
+          expect( @context ).to have( 3 ).hosts
 
-          @context.hosts[ "host #0" ].name.should == "host #0"
-          @context.hosts[ "host #1" ].name.should == "host #1"
-          @context.hosts[ "host #2" ].name.should == "host #2"
+          expect( @context.hosts[ "host #0" ].name ).to eq( "host #0" )
+          expect( @context.hosts[ "host #1" ].name ).to eq( "host #1" )
+          expect( @context.hosts[ "host #2" ].name ).to eq( "host #2" )
         end
 
 
         it "should remember links" do
-          @context.should have( 0 ).links
+          expect( @context ).to have( 0 ).links
 
           Trema::Link.add mock( "link #0", :name => "link #0" )
           Trema::Link.add mock( "link #1", :name => "link #1" )
           Trema::Link.add mock( "link #2", :name => "link #2" )
 
-          @context.should have( 3 ).links
+          expect( @context ).to have( 3 ).links
 
-          @context.links[ "link #0" ].name.should == "link #0"
-          @context.links[ "link #1" ].name.should == "link #1"
-          @context.links[ "link #2" ].name.should == "link #2"
+          expect( @context.links[ "link #0" ].name ).to eq( "link #0" )
+          expect( @context.links[ "link #1" ].name ).to eq( "link #1" )
+          expect( @context.links[ "link #2" ].name ).to eq( "link #2" )
         end
 
 
         it "should remember filter settings" do
-          @context.packetin_filter.should be_nil
+          expect( @context.packetin_filter ).to be_nil
 
           packetin_filter = mock( "filter", :name => "filter" )
           Trema::PacketinFilter.add packetin_filter
 
-          @context.packetin_filter.should == packetin_filter
+          expect( @context.packetin_filter ).to eq( packetin_filter )
         end
 
 
         it "should remember switch manager" do
-          @context.switch_manager.should be_nil
+          expect( @context.switch_manager ).to be_nil
 
           switch_manager = mock( "switch manager", :name => "switch manager" )
           Trema::SwitchManager.add switch_manager
 
-          @context.switch_manager.should == switch_manager
+          expect( @context.switch_manager ).to eq( switch_manager )
         end
 
 
         it "should remember switches" do
-          @context.should have( 0 ).switches
+          expect( @context ).to have( 0 ).switches
 
           Trema::OpenflowSwitch.add mock( "switch #0", :name => "switch #0" )
           Trema::OpenflowSwitch.add mock( "switch #1", :name => "switch #1" )
           Trema::OpenflowSwitch.add mock( "switch #2", :name => "switch #2" )
 
-          @context.should have( 3 ).switches
+          expect( @context ).to have( 3 ).switches
 
-          @context.switches[ "switch #0" ].name.should == "switch #0"
-          @context.switches[ "switch #1" ].name.should == "switch #1"
-          @context.switches[ "switch #2" ].name.should == "switch #2"
+          expect( @context.switches[ "switch #0" ].name ).to eq( "switch #0" )
+          expect( @context.switches[ "switch #1" ].name ).to eq( "switch #1" )
+          expect( @context.switches[ "switch #2" ].name ).to eq( "switch #2" )
         end
       end
     end

data/spec/trema/dsl/link_spec.rb

@@ -27,9 +27,7 @@ module Trema
     describe Link do
       context %[when parsing "link peerA peerB"] do
         it %[recognizes "link peerA peerB" directive] do
-          lambda do
-            Link.new "Host", "Switch"
-          end.should_not raise_error
+          expect { Link.new "Host", "Switch" }.not_to raise_error
         end
       end
 
@@ -37,9 +35,9 @@ module Trema
       context "when getting attributes of a link" do
         it "remembers peers" do
           link = Link.new( "Host", "Switch" )
-          link.peers.size.should == 2
-          link.peers.should include( "Host" )
-          link.peers.should include( "Switch" )
+          expect( link.peers.size ).to eq( 2 )
+          expect( link.peers ).to include( "Host" )
+          expect( link.peers ).to include( "Switch" )
         end
       end
     end

data/spec/trema/dsl/run_spec.rb

@@ -32,16 +32,12 @@ module Trema
 
       context %[when parsing "run { ... }"] do
         it %[recognizes "path COMMAND_PATH" directive] do
-          lambda do
-            @run.path "/usr/bin/tremario"
-          end.should_not raise_error
+          expect { @run.path "/usr/bin/tremario" }.not_to raise_error
         end
 
 
         it %[recognizes "options OPTIONS..." directive] do
-          lambda do
-            @run.options "--verbose", "--color"
-          end.should_not raise_error
+          expect { @run.options "--verbose", "--color" }.not_to raise_error
         end
       end
 
@@ -49,21 +45,21 @@ module Trema
       context "when getting the attributes of an run" do
         it "returns its name" do
           @run.path "/usr/bin/tremario"
-          @run[ :name ].should == "tremario"
+          expect( @run[ :name ] ).to eq( "tremario" )
         end
 
 
         it "returns its path" do
           @run.path "/usr/bin/tremario"
-          @run[ :path ].should == "/usr/bin/tremario"
+          expect( @run[ :path ] ).to eq( "/usr/bin/tremario" )
         end
 
 
         it "returns its options" do
           @run.options "--verbose", "--color"
-          @run[ :options ].size.should == 2
-          @run[ :options ].should include( "--verbose" )
-          @run[ :options ].should include( "--color" )
+          expect( @run[ :options ].size ).to eq( 2 )
+          expect( @run[ :options ] ).to include( "--verbose" )
+          expect( @run[ :options ] ).to include( "--color" )
         end
       end
     end

data/spec/trema/dsl/runner_spec.rb

@@ -111,23 +111,23 @@ module Trema
 
           host0.should_receive( :run! ).once
           host0.should_receive( :add_arp_entry ).with do | arg |
-            arg.size.should == 2
-            arg.should include( host1 )
-            arg.should include( host2 )
+            expect( arg.size ).to eq( 2 )
+            expect( arg ).to include( host1 )
+            expect( arg ).to include( host2 )
           end
 
           host1.should_receive( :run! ).once
           host1.should_receive( :add_arp_entry ).with do | arg |
-            arg.size.should == 2
-            arg.should include( host0 )
-            arg.should include( host2 )
+            expect( arg.size ).to eq( 2 )
+            expect( arg ).to include( host0 )
+            expect( arg ).to include( host2 )
           end
 
           host2.should_receive( :run! ).once
           host2.should_receive( :add_arp_entry ).with do | arg |
-            arg.size.should == 2
-            arg.should include( host0 )
-            arg.should include( host1 )
+            expect( arg.size ).to eq( 2 )
+            expect( arg ).to include( host0 )
+            expect( arg ).to include( host1 )
           end
 
           context = mock(

data/spec/trema/dsl/switch_spec.rb

@@ -32,23 +32,17 @@ module Trema
 
       context %[when parsing "switch { ... }"] do
         it %[recognizes "dpid DATAPATH_ID" directive] do
-          lambda do
-            @switch.dpid "0xabc"
-          end.should_not raise_error
+          expect { @switch.dpid "0xabc" }.not_to raise_error
         end
 
 
         it %[recognizes "datapath_id DATAPATH_ID" directive] do
-          lambda do
-            @switch.datapath_id "0xabc"
-          end.should_not raise_error
+          expect { @switch.datapath_id "0xabc" }.not_to raise_error
         end
 
 
         it %[recognizes "ports PORT_NUMBERS" directive] do
-          lambda do
-            @switch.ports "0-4"
-          end.should_not raise_error
+          expect { @switch.ports "0-4" }.not_to raise_error
         end
       end
 
@@ -56,13 +50,13 @@ module Trema
       context "when getting the attributes of a switch" do
         it "returns its dpid in long format" do
           @switch.dpid "0xabc"
-          @switch[ :dpid_long ].should == "0000000000000abc"
+          expect( @switch[ :dpid_long ] ).to eq( "0000000000000abc" )
         end
 
 
         it "returns its dpid in short format" do
           @switch.dpid "0xabc"
-          @switch[ :dpid_short ].should == "0xabc"
+          expect( @switch[ :dpid_short ] ).to eq( "0xabc" )
         end
       end
     end

data/spec/trema/dsl/vhost_spec.rb

@@ -96,9 +96,7 @@ module Trema
 
         context "when promisc INVALID_VALUE" do
           specify do
-            lambda do
-              @vhost.promisc "INVALID_VALUE"
-            end.should raise_error( Trema::DSL::SyntaxError )
+            expect { @vhost.promisc "INVALID_VALUE" }.to raise_error( Trema::DSL::SyntaxError )
           end
         end
       end

data/spec/trema/dsl/vswitch_spec.rb

@@ -32,30 +32,22 @@ module Trema
 
       context %[when parsing "vswitch { ... }"] do
         it %[recognizes "dpid DATAPATH_ID" directive] do
-          lambda do
-            @vswitch.dpid "0xabc"
-          end.should_not raise_error
+          expect { @vswitch.dpid "0xabc" }.not_to raise_error
         end
 
 
         it %[recognizes "datapath_id DATAPATH_ID" directive] do
-          lambda do
-            @vswitch.datapath_id "0xabc"
-          end.should_not raise_error
+          expect { @vswitch.datapath_id "0xabc" }.not_to raise_error
         end
 
 
         it %[recognizes "ports PORT_NUMBERS" directive] do
-          lambda do
-            @vswitch.ports "0-4"
-          end.should_not raise_error
+          expect { @vswitch.ports "0-4" }.not_to raise_error
         end
 
 
         it %[recognizes "ip IP_ADDRESS" directive] do
-          lambda do
-            @vswitch.ip "192.168.0.1"
-          end.should_not raise_error
+          expect { @vswitch.ip "192.168.0.1" }.not_to raise_error
         end
       end
 
@@ -63,19 +55,19 @@ module Trema
       context "when getting the attributes of a vswitch" do
         it "returns its dpid in long format" do
           @vswitch.dpid "0xabc"
-          @vswitch[ :dpid_long ].should == "0000000000000abc"
+          expect( @vswitch[ :dpid_long ] ).to eq( "0000000000000abc" )
         end
 
 
         it "returns its dpid in short format" do
           @vswitch.dpid "0xabc"
-          @vswitch[ :dpid_short ].should == "0xabc"
+          expect( @vswitch[ :dpid_short ] ).to eq( "0xabc" )
         end
 
 
         it "returns its ip address" do
           @vswitch.ip "192.168.0.1"
-          @vswitch[ :ip ].should == "192.168.0.1"
+          expect( @vswitch[ :ip ] ).to eq( "192.168.0.1" )
         end
       end
     end