havox 0.11.1

data/lib/havox/modules/openflow10/ovs/actions.rb

@@ -0,0 +1,41 @@
+module Havox
+  module OpenFlow10
+    module OVS
+      module Actions
+        extend Havox::FieldParser
+
+        def self.treat(actions_array, opts = {})
+          of_actions = []
+          actions_array.each do |obj|
+            of_actions <<
+              case obj[:action]
+              when 'Output' then basic_action(:output, obj[:arg_a])
+              when 'Enqueue' then output_or_enqueue(obj, opts[:output])
+              when 'SetField' then basic_action_from_set_field(obj)
+              else raise_unknown_action(obj)
+              end
+          end
+          of_actions
+        end
+
+        private
+
+        def self.basic_action_from_set_field(obj)
+          if obj[:arg_a].eql?('vlan')
+            obj[:arg_b].eql?('<none>') ? basic_action(:strip_vlan) : basic_action(:mod_vlan_vid, obj[:arg_b])
+          else
+            raise_unknown_action(obj)
+          end
+        end
+
+        def self.output_or_enqueue(obj, change_to_output)
+          if change_to_output
+            basic_action(:output, obj[:arg_a])
+          else
+            basic_action(:enqueue, obj[:arg_a], obj[:arg_b])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/havox/modules/openflow10/ovs/matches.rb

@@ -0,0 +1,35 @@
+# This dictionary structure translates Merlin match fields to OpenVSwitch
+# readable fields. More details can be found at:
+# http://www.pica8.com/document/v2.3/pdf/ovs-commands-reference.pdf
+
+module Havox
+  module OpenFlow10
+    module OVS
+      module Matches
+        extend Havox::FieldParser
+
+        FIELDS = {
+          'ethSrc'     => :dl_src,
+          'ethDst'     => :dl_dst,
+          'ethTyp'     => :dl_type,
+          'ipSrc'      => :nw_src,
+          'ipDst'      => :nw_dst,
+          'ipProto'    => :nw_proto,
+          'nwProto'    => :nw_proto,
+          'port'       => :in_port,
+          'switch'     => :dp_id,
+          'tcpSrcPort' => :tp_src,
+          'tcpDstPort' => :tp_dst,
+          'vlanId'     => :dl_vlan,
+          'vlanPcp'    => :dl_vlan_pcp
+        }
+
+        def self.treat(hash)
+          hash[:nw_src] = parsed_ipv4(hash[:nw_src]) unless hash[:nw_src].nil?
+          hash[:nw_dst] = parsed_ipv4(hash[:nw_dst]) unless hash[:nw_dst].nil?
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/havox/modules/openflow10/routeflow/actions.rb

@@ -0,0 +1,45 @@
+module Havox
+  module OpenFlow10
+    module RouteFlow
+      module Actions
+        extend Havox::FieldParser
+
+        def self.treat(actions_array, opts = {})
+          of_actions = []
+          actions_array.each do |obj|
+            of_actions <<
+              case obj[:action]
+              when 'Output' then basic_action(:output, obj[:arg_a].to_i)
+              when 'Enqueue' then output_or_enqueue(obj, opts[:output])
+              when 'SetField' then basic_action_from_set_field(obj)
+              else raise_unknown_action(obj)
+              end
+          end
+          of_actions
+        end
+
+        private
+
+        def self.basic_action_from_set_field(obj)
+          if obj[:arg_a].eql?('vlan')
+            if obj[:arg_b].eql?('<none>')
+              basic_action(:strip_vlan)                      # Inferred (vandervecken).
+            else
+              basic_action(:set_vlan_id, obj[:arg_b].to_i)   # Inferred (vandervecken).
+            end
+          else
+            raise_unknown_action(obj)
+          end
+        end
+
+        def self.output_or_enqueue(obj, change_to_output)
+          if change_to_output
+            basic_action(:output, obj[:arg_a].to_i)
+          else
+            basic_action(:enqueue, obj[:arg_a].to_i, obj[:arg_b].to_i)   # Inferred.
+          end
+        end
+      end
+    end
+  end
+end

data/lib/havox/modules/openflow10/routeflow/matches.rb

@@ -0,0 +1,44 @@
+# This dictionary structure translates Merlin match fields to RouteFlow
+# readable fields. Since the current version of RouteFlow does not support
+# all returned fields yet, some of them were inferred based on the others
+# (those are marked as 'inferred'). As RouteFlow gets updated, the inferred
+# names can be updated as well. RouteFlow's main repo can be accessed at:
+# https://github.com/routeflow/RouteFlow.
+
+module Havox
+  module OpenFlow10
+    module RouteFlow
+      module Matches
+        extend Havox::FieldParser
+
+        FIELDS = {
+          'ethSrc'     => :ethernet_src, # Inferred.
+          'ethDst'     => :ethernet,
+          'ethTyp'     => :ethertype,
+          'ipSrc'      => :ipv4_src,     # Inferred.
+          'ipDst'      => :ipv4,
+          'ipProto'    => :nw_proto,
+          'nwProto'    => :nw_proto,
+          'port'       => :in_port,      # Inferred.
+          'switch'     => :dp_id,
+          'tcpSrcPort' => :tp_src,
+          'tcpDstPort' => :tp_dst,
+          'vlanId'     => :vlan_id,      # Inferred (vandervecken).
+          'vlanPcp'    => :vlan_pcp      # Inferred.
+        }
+
+        def self.treat(hash)
+          hash[:ethertype] = hash[:ethertype].to_i unless hash[:ethertype].nil?
+          hash[:ipv4_src]  = parsed_ipv4(hash[:ipv4_src]) unless hash[:ipv4_src].nil?
+          hash[:ipv4]      = parsed_ipv4(hash[:ipv4]) unless hash[:ipv4].nil?
+          hash[:nw_proto]  = hash[:nw_proto].to_i unless hash[:nw_proto].nil?
+          hash[:in_port]   = hash[:in_port].to_i unless hash[:in_port].nil?
+          hash[:tp_src]    = hash[:tp_src].to_i unless hash[:tp_src].nil?
+          hash[:tp_dst]    = hash[:tp_dst].to_i unless hash[:tp_dst].nil?
+          hash[:vlan_id]   = hash[:vlan_id].to_i unless hash[:vlan_id].nil?
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/havox/modules/openflow10/trema/actions.rb

@@ -0,0 +1,45 @@
+module Havox
+  module OpenFlow10
+    module Trema
+      module Actions
+        extend Havox::FieldParser
+
+        def self.treat(actions_array, opts = {})
+          of_actions = []
+          actions_array.each do |obj|
+            of_actions <<
+              case obj[:action]
+              when 'Output' then basic_action(:output, obj[:arg_a].to_i)
+              when 'Enqueue' then output_or_enqueue(obj, opts[:output])
+              when 'SetField' then basic_action_from_set_field(obj)
+              else raise_unknown_action(obj)
+              end
+          end
+          of_actions
+        end
+
+        private
+
+        def self.basic_action_from_set_field(obj)
+          if obj[:arg_a].eql?('vlan')
+            if obj[:arg_b].eql?('<none>')
+              basic_action(:strip_vlan)
+            else
+              basic_action(:set_vlan_vid, obj[:arg_b].to_i)
+            end
+          else
+            raise_unknown_action(obj)
+          end
+        end
+
+        def self.output_or_enqueue(obj, change_to_output)
+          if change_to_output
+            basic_action(:output, obj[:arg_a].to_i)
+          else
+            basic_action(:enqueue, obj[:arg_a].to_i, obj[:arg_b].to_i)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/havox/modules/openflow10/trema/matches.rb

@@ -0,0 +1,43 @@
+# This dictionary module translates Merlin match fields to Trema readable
+# fields, based on the official OpenFlow 1.0 nomenclatures, as described in the
+# OpenFlow specifications at:
+# http://archive.openflow.org/documents/openflow-spec-v1.0.0.pdf
+
+module Havox
+  module OpenFlow10
+    module Trema
+      module Matches
+        extend Havox::FieldParser
+
+        FIELDS = {
+          'ethSrc'     => :source_mac_address,
+          'ethDst'     => :destination_mac_address,
+          'ethTyp'     => :ether_type,                                          # https://www.iana.org/assignments/ieee-802-numbers/ieee-802-numbers.xhtml
+          'ipSrc'      => :source_ip_address,
+          'ipDst'      => :destination_ip_address,
+          'ipProto'    => :ip_protocol,                                         # http://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml
+          'nwProto'    => :ip_protocol,
+          'port'       => :in_port,
+          'switch'     => :dp_id,
+          'tcpSrcPort' => :transport_source_port,
+          'tcpDstPort' => :transport_destination_port,
+          'vlanId'     => :vlan_vid,
+          'vlanPcp'    => :vlan_priority
+        }
+
+        def self.treat(hash)
+          hash[:ether_type]                 = hash[:ether_type].to_i unless hash[:ether_type].nil?
+          hash[:source_ip_address]          = parsed_ipv4(hash[:source_ip_address]) unless hash[:source_ip_address].nil?
+          hash[:destination_ip_address]     = parsed_ipv4(hash[:destination_ip_address]) unless hash[:destination_ip_address].nil?
+          hash[:ip_protocol]                = hash[:ip_protocol].to_i unless hash[:ip_protocol].nil?
+          hash[:in_port]                    = hash[:in_port].to_i unless hash[:in_port].nil?
+          hash[:transport_source_port]      = hash[:transport_source_port].to_i unless hash[:transport_source_port].nil?
+          hash[:transport_destination_port] = hash[:transport_destination_port].to_i unless hash[:transport_destination_port].nil?
+          hash[:vlan_vid]                   = hash[:vlan_vid].to_i unless hash[:vlan_vid].nil?
+          hash[:vlan_priority]              = hash[:vlan_priority].to_i unless hash[:vlan_priority].nil?
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/havox/modules/routeflow.rb

@@ -0,0 +1,50 @@
+module Havox
+  module RouteFlow
+    class << self
+      ENTRY_REGEX = /[A-Z>\*\s]{3}.*(via|is).*,.*$/
+
+      private
+
+      def config
+        Havox.configuration
+      end
+
+      def cmd
+        Havox::Command
+      end
+
+      def ssh_connection
+        Net::SSH.start(config.rf_host, config.rf_user, password: config.rf_password) do |ssh|
+          yield(ssh)
+        end
+      end
+
+      def parse(output)
+        result = output.each_line.map { |l| l.match(ENTRY_REGEX) }.compact
+        result.map(&:to_s)
+      end
+    end
+
+    def self.run(command)
+      output = nil
+      ssh_connection { |ssh| output = ssh.exec!(command) }
+      output
+    end
+
+    def self.fetch(vm_name, protocol = nil)
+      result = run(cmd.show_ip_route(vm_name, protocol))
+      result = parse(result)
+      result = Havox::RouteFiller.new(result).filled_routes
+      result
+    end
+
+    def self.ribs(vm_names, opts = {})
+      routes = []
+      vm_names.each do |vm_name|
+        raw_routes = fetch(vm_name)
+        routes += raw_routes.map { |rr| Havox::Route.new(rr, vm_name, opts) }
+      end
+      routes
+    end
+  end
+end

data/lib/havox/version.rb

@@ -0,0 +1,3 @@
+module Havox
+  VERSION = '0.11.1'
+end

data/lib/merlin/policies/common.mln

@@ -0,0 +1,9 @@
+srcs := { h1; h2; h3; h4; h5; h6 };
+exits_a := { h20 };
+exits_b := { h60 };
+
+foreach (s, d): cross(srcs, exits_a)
+  ipProto = 17 and ethTyp = 2048 and tcpDstPort = 80 -> .* s2 at min(100 Mbps);
+
+foreach (s, d): cross(srcs, exits_b)
+  ipProto = 17 and ethTyp = 2048 and tcpDstPort = 25 -> .* s6 at min(100 Mbps);

data/lib/merlin/policies/defense.mln

@@ -0,0 +1,5 @@
+fire1 := { h1; h2 };
+fire2 := { h1; h2 };
+
+foreach (s, d) : cross({h1}, {h2})
+* -> ( .* fire1 .* fire2 .* ) | ( .* fire2 .* fire1 .* ) at min(1 Bps);

data/lib/merlin/policies/max.mln

@@ -0,0 +1,2 @@
+foreach (s,d) : cross({h1}, {h2})
+* ->  s1 at max(50 Mbps);

data/lib/merlin/policies/min.mln

@@ -0,0 +1,2 @@
+foreach (s,d) : cross({h1}, {h2})
+* ->  s1 at min(50 Mbps);

data/lib/merlin/policies/routeflow.mln

@@ -0,0 +1,8 @@
+foreach (s, d): cross({ h1; h3; h4 }, { h2 })
+  tcpDstPort = 80 -> .* s6 at min(100 Mbps);
+
+foreach (s, d): cross({ h1; h3; h4 }, { h2 })
+  ipProto = udp -> .* s6 at min(100 Mbps);
+
+foreach (s, d): cross({ h1; h3; h4 }, { h2 })
+  ipDst = 172.50.0.0 -> .* s6 at min(100 Mbps);

data/lib/merlin/policies/test.mln

@@ -0,0 +1,2 @@
+foreach (s, d): cross({ h1; h2; h3; h4 }, { h1; h2; h3; h4 })
+  tcpDstPort = 80 -> .* s6 .* at min(1 Mbps);

data/lib/merlin/policies/tetrahedron.mln

@@ -0,0 +1,8 @@
+srcs := { h1; h2 };
+dsts := { h4 };
+
+foreach (s, d): cross(srcs, dsts)
+  ethTyp = 2048 and ipProto = 6 and tcpDstPort = 80 -> .* s2 s3 .* at min(100 Mbps);
+
+foreach (s, d): cross(dsts, srcs)
+  ethTyp = 2048 and ipProto = 6 and tcpSrcPort = 80 -> .* s3 s2 .* at min(100 Mbps);

data/lib/merlin/policies/tetrahedron.sample.mln

@@ -0,0 +1,15 @@
+srcs := { h1; h2 };
+dsts := { h4 };
+all  := { h1; h2; h3; h4 };
+
+foreach (s, d): cross(srcs, dsts)
+  ethTyp = 2048 and ipProto = 6 and tcpDstPort = 80 -> .* s2 s3 .* at min(100 Mbps);
+
+foreach (s, d): cross(dsts, srcs)
+  ethTyp = 2048 and ipProto = 6 and tcpSrcPort = 80 -> .* s3 s2 .* at min(100 Mbps);
+
+foreach (s, d): cross(all, all)
+  ethTyp = 2048 and ipProto = 1 -> .* at min(100 Mbps);
+
+foreach (s, d): cross(all, all)
+  ethTyp = 2054 -> .* at min(100 Mbps);

data/lib/merlin/policies/web_balanced.mln

@@ -0,0 +1,7 @@
+foreach (s, d): cross({ h1; h3; h4 }, { h1; h2; h3; h4 })
+  ethTyp = 2048 and ipProto = 6 and tcpDstPort = 80 -> .* s5 at min(100 Mbps);
+
+(*
+foreach (s, d): cross({ h1; h2; h3; h4 }, { h1; h2; h3; h4 })
+  ethTyp = 2048 and ipProto = 6 -> .* s8 at min(100 Mbps);
+*)

data/lib/merlin/policies/web_unbalanced.mln

@@ -0,0 +1,2 @@
+foreach (s, d): cross({ h1; h2; h3; h4 }, { h1; h2; h3; h4 })
+  ethTyp = 2048 and ipProto = 6 and tcpDstPort = 80 -> .* at min(100 Mbps);

data/lib/merlin/topologies/common.dot

@@ -0,0 +1,63 @@
+digraph g1 {
+  h1  [type = host, mac = "00:00:00:00:00:01", ip = "10.0.0.1"];
+  h2  [type = host, mac = "00:00:00:00:00:02", ip = "10.0.0.2"];
+  h3  [type = host, mac = "00:00:00:00:00:03", ip = "10.0.0.3"];
+  h4  [type = host, mac = "00:00:00:00:00:04", ip = "10.0.0.4"];
+  h5  [type = host, mac = "00:00:00:00:00:05", ip = "10.0.0.5"];
+  h6  [type = host, mac = "00:00:00:00:00:06", ip = "10.0.0.6"];
+  h20 [type = host, mac = "00:00:00:00:00:20", ip = "10.0.0.20"];
+  h60 [type = host, mac = "00:00:00:00:00:60", ip = "10.0.0.60"];
+
+  s1 [type = switch, ip = "11.0.0.1", id = 1];
+  s2 [type = switch, ip = "11.0.0.2", id = 2];
+  s3 [type = switch, ip = "11.0.0.3", id = 3];
+  s4 [type = switch, ip = "11.0.0.4", id = 4];
+  s5 [type = switch, ip = "11.0.0.5", id = 5];
+  s6 [type = switch, ip = "11.0.0.6", id = 6];
+
+  s1 -> h1  [src_port = 1, dst_port = 1, cost = 1, capacity = "1Gbps"];
+  h1 -> s1  [src_port = 1, dst_port = 1, cost = 1, capacity = "1Gbps"];
+
+  s2 -> h2  [src_port = 1, dst_port = 1, cost = 1, capacity = "1Gbps"];
+  h2 -> s2  [src_port = 1, dst_port = 1, cost = 1, capacity = "1Gbps"];
+
+  s3 -> h3  [src_port = 1, dst_port = 1, cost = 1, capacity = "1Gbps"];
+  h3 -> s3  [src_port = 1, dst_port = 1, cost = 1, capacity = "1Gbps"];
+
+  s4 -> h4  [src_port = 1, dst_port = 1, cost = 1, capacity = "1Gbps"];
+  h4 -> s4  [src_port = 1, dst_port = 1, cost = 1, capacity = "1Gbps"];
+
+  s5 -> h5  [src_port = 1, dst_port = 1, cost = 1, capacity = "1Gbps"];
+  h5 -> s5  [src_port = 1, dst_port = 1, cost = 1, capacity = "1Gbps"];
+
+  s6 -> h6  [src_port = 1, dst_port = 1, cost = 1, capacity = "1Gbps"];
+  h6 -> s6  [src_port = 1, dst_port = 1, cost = 1, capacity = "1Gbps"];
+
+  s2 -> h20 [src_port = 5, dst_port = 1, cost = 1, capacity = "1Gbps"];
+  h20 -> s2 [src_port = 5, dst_port = 1, cost = 1, capacity = "1Gbps"];
+
+  s6 -> h60 [src_port = 4, dst_port = 1, cost = 1, capacity = "1Gbps"];
+  h60 -> s6 [src_port = 4, dst_port = 1, cost = 1, capacity = "1Gbps"];
+
+  s1 -> s2  [src_port = 2, dst_port = 2, cost = 1, capacity = "1Gbps"];
+  s1 -> s3  [src_port = 3, dst_port = 2, cost = 1, capacity = "1Gbps"];
+
+  s2 -> s1  [src_port = 2, dst_port = 2, cost = 1, capacity = "1Gbps"];
+  s2 -> s3  [src_port = 3, dst_port = 3, cost = 1, capacity = "1Gbps"];
+  s2 -> s4  [src_port = 4, dst_port = 2, cost = 1, capacity = "1Gbps"];
+
+  s3 -> s1  [src_port = 2, dst_port = 3, cost = 1, capacity = "1Gbps"];
+  s3 -> s2  [src_port = 3, dst_port = 3, cost = 1, capacity = "1Gbps"];
+  s3 -> s4  [src_port = 4, dst_port = 3, cost = 1, capacity = "1Gbps"];
+  s3 -> s5  [src_port = 5, dst_port = 2, cost = 1, capacity = "1Gbps"];
+
+  s4 -> s2  [src_port = 2, dst_port = 4, cost = 1, capacity = "1Gbps"];
+  s4 -> s3  [src_port = 3, dst_port = 4, cost = 1, capacity = "1Gbps"];
+  s4 -> s6  [src_port = 4, dst_port = 2, cost = 1, capacity = "1Gbps"];
+
+  s5 -> s3  [src_port = 2, dst_port = 5, cost = 1, capacity = "1Gbps"];
+  s5 -> s6  [src_port = 3, dst_port = 3, cost = 1, capacity = "1Gbps"];
+
+  s6 -> s4  [src_port = 2, dst_port = 4, cost = 1, capacity = "1Gbps"];
+  s6 -> s5  [src_port = 3, dst_port = 3, cost = 1, capacity = "1Gbps"];
+}