omf_rc_openflow 6.0.0.pre

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in omf_rc_foo.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Jack C Hong
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# OmfRcOpenflow
+
+OMF Resource Controllers related to Openflow
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'omf_rc_openflow'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install omf_rc_openflow
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/bin/omf_rc_openflow_slice_factory

@@ -0,0 +1,83 @@
+#!/usr/bin/env ruby
+
+require "optparse"
+require 'omf_rc'
+require 'omf_rc/resource_factory'
+require 'omf_rc_openflow'
+
+$stdout.sync = true
+
+options = {
+  uid: `hostname`.chomp
+}
+
+executable_name = File.basename($PROGRAM_NAME)
+oml_enabled = false
+
+begin
+  oml_enabled = OML4R::init(ARGV, :appName => executable_name) do |opts|
+    opts.banner = "usage: #{executable_name} [options]"
+
+    opts.on("-u USER", "Username") do |user|
+      options[:user] = user
+    end
+
+    opts.on("-p PASSWORD", "Password") do |password|
+      options[:password] = password
+    end
+
+    opts.on("-s SERVER", "PubSub server") do |server|
+      options[:server] = server
+    end
+
+    opts.on("-t TOPIC", "PubSub topic to create, also becomes the uid of the resource, default to hostname") do |topic|
+      options[:uid] = topic
+    end
+
+    opts.on("-d", "--debug", "Debug mode") do
+      options[:debug] = true
+    end
+
+    opts.on("-l LOG_FILE_DIR", "Write log file to this folder") do |file_dir|
+      options[:log_file_dir] = file_dir
+    end
+  end
+rescue => e
+  # Right now OML4R does not raise proper exceptions :(
+  # OML4R requires --oml-noop to be set if we want to run without doing any
+  # measurements... this is too restrictive here, we want to run without OML
+  # if no OML parameters were set and this even if --oml-noop is not set.
+  if e.message.include?('OML4R: Missing values for parameters :expID ')
+    puts "Warning: Missing some OML options to instrument this RC, so it will "+
+      "run without instrumentation. (see --oml-help)"
+  else
+    puts e.message
+    exit(1)
+  end
+end
+
+OmfCommon::Measure.enable if oml_enabled
+
+unless options[:server] && options[:user] && options[:password]
+  puts "Error: Missing parameters to connect to a PubSub Server (see --help)"
+  exit(1)
+end
+
+Logging.logger.root.level = :debug if options[:debug]
+Blather.logger = logger
+
+if options[:log_file_dir] && File.exist?(options[:log_file_dir])
+  Logging.logger.root.add_appenders(
+    Logging.appenders.file(
+      "#{options[:log_file_dir]}/omf_rc.log",
+      :layout => Logging.layouts.pattern(:date_pattern => '%F %T %z',
+                                         :pattern => '[%d] %-5l %c: %m\n')))
+end
+
+EM.run do
+  openflow_slice_factory = OmfRc::ResourceFactory.new(:openflow_slice_factory, options)
+  openflow_slice_factory.connect
+
+  trap(:INT) { openflow_slice_factory.disconnect }
+  trap(:TERM) { openflow_slice_factory.disconnect }
+end

data/example/openflow_slice_factory_controller.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+require 'omf_rc'
+require 'omf_rc/resource_factory'
+#require 'omf_rc_openflow'
+$stdout.sync = true
+
+Blather.logger = logger
+
+opts = {
+  # XMPP server domain
+  server: 'srv.mytestbed.net',
+  user: 'flowvisor',
+  password: 'pw',
+  uid: 'flowvisor',
+  # Debug mode of not
+  debug: false
+}
+
+Logging.logger.root.level = :debug if opts[:debug]
+
+OmfRc::ResourceFactory.load_addtional_resource_proxies(File.dirname(__FILE__)+"/../lib/omf_rc/resource_proxy")
+
+EM.run do
+  # Use resource factory method to initialise a new instance of garage
+  info "Starting #{opts[:uid]}"
+  flowvisor = OmfRc::ResourceFactory.new(:openflow_slice_factory, opts)
+  flowvisor.connect
+
+  # Disconnect garage from XMPP server, when these two signals received
+  trap(:INT) { flowvisor.disconnect }
+  trap(:TERM) { flowvisor.disconnect }
+end

data/example/openflow_slice_factory_test.rb

@@ -0,0 +1,64 @@
+# OMF_VERSIONS = 6.0
+
+@comm = OmfEc.comm
+
+# @comm is default communicator defined in script runner
+#
+@flowvisor_id = "flowvisor"
+@flowvisor_topic = @comm.get_topic(@flowvisor_id)
+
+@slice_id = nil
+@slice_topic = nil
+
+msgs = {
+  create_slice: @comm.create_message([type: 'openflow_slice']),
+  config_slice: @comm.configure_message([name: 'test', contact_email: 'a@a']),
+  slices: @comm.request_message([:slices]),
+  config_flows: @comm.configure_message([flows: [{operation: 'add', device: '00:00:00:00:00:00:00:01', eth_dst: '11:22:33:44:55:66'},
+                                                 {operation: 'add', device: 1, in_port: 10}]]),
+}
+
+@flowvisor_topic.subscribe {msgs[:create_slice].publish @flowvisor_id}
+
+# If flowvisor is not raised, the following rule will be activated.
+@flowvisor_topic.on_message lambda {|m| m.operation == :inform && m.read_content('inform_type') == 'CREATION_FAILED' } do |message|
+  logger.error message.read_content('reason')
+  done!
+end
+
+msgs[:create_slice].on_inform_creation_ok do |message|
+  @slice_id = message.resource_id
+  @slice_topic = @comm.get_topic(@slice_id)
+ 
+  msgs[:release_slice] ||= @comm.release_message {|m| m.element('resource_id', @slice_id)}
+  msgs[:release_slice].on_inform_released do |message|
+    logger.info "Slice (#{@slice_id}) released"
+    m = @comm.request_message([:slices])
+    m.on_inform_status do |message|
+      logger.info "Flowvisor (#{message.read_property('uid')}) requested slices: #{message.read_property('slices').join(', ')}"
+      done!
+    end
+    m.publish @flowvisor_id
+  end
+  
+  logger.info "Slice (#{@slice_id}) created"
+  @slice_topic.subscribe {msgs[:config_slice].publish @slice_id}
+end
+
+msgs[:config_slice].on_inform_status do |message|
+  logger.info "Slice (#{message.read_property('uid')}) configured name: #{message.read_property('name')} & contact_email: #{message.read_property('contact_email')}"
+  msgs[:slices].publish @flowvisor_id
+end
+
+msgs[:slices].on_inform_status do |message|
+  logger.info "Flowvisor (#{message.read_property('uid')}) requested slices: #{message.read_property('slices').join(', ')}"
+  msgs[:config_flows].publish @slice_id
+end
+
+msgs[:config_flows].on_inform_status do |message|
+  logger.info "Slice (#{message.read_property('uid')}) configured flows: "
+  message.read_property('flows').each do |flow|
+    logger.info "  #{flow}"
+  end
+  msgs[:release_slice].publish @flowvisor_id
+end

data/lib/omf_rc/resource_proxy/openflow_slice.rb

@@ -0,0 +1,82 @@
+# This resource is created from the parent :openflow_slice_factory resource.
+# It is related with a slice of a flowvisor instance, and behaves as a proxy between experimenter and the actual flowvisor slice.
+#
+module OmfRc::ResourceProxy::OpenflowSlice
+  include OmfRc::ResourceProxyDSL
+
+  # The default parameters of a new slice. The openflow controller is assumed to be in the same working station with flowvisor instance
+  SLICE_DEFAULTS = {
+    passwd: "1234",
+    url:    "tcp:127.0.0.1:9933",
+    email:  "nothing@nowhere"
+  }
+
+
+  register_proxy :openflow_slice, :create_by => :openflow_slice_factory
+
+  utility :openflow_tools
+
+
+  # Slice's name is initiated with value "nil"
+  hook :before_ready do |resource|
+    resource.property.name = nil
+  end
+
+  # Before release, the related flowvisor instance should also remove the corresponding slice
+  hook :before_release do |resource|
+    resource.flowvisor_connection.call("api.deleteSlice", resource.property.name)
+  end
+
+
+  # The name is one-time configured
+  configure :name do |resource, name|
+    raise "The name cannot be changed" if resource.property.name
+    resource.property.name = name.to_s
+    begin
+      resource.flowvisor_connection.call("api.createSlice", name.to_s, *SLICE_DEFAULTS.values)
+    rescue Exception => e
+      if e.message["Cannot create slice with existing name"]
+        logger.warn message = "The requested slice already existed in Flowvisor"
+      else
+        raise e
+      end
+    end
+    resource.property.name
+  end
+
+  # Configures the slice password
+  configure :passwd do |resource, passwd|
+    resource.flowvisor_connection.call("api.changePasswd", resource.property.name, passwd.to_s)
+    passwd.to_s
+  end
+
+  # Configures the slice parameters
+  [:contact_email, :drop_policy, :controller_hostname, :controller_port].each do |configure_sym|
+    configure configure_sym do |resource, value|
+      resource.flowvisor_connection.call("api.changeSlice", resource.property.name, configure_sym.to_s, value.to_s)
+      value.to_s
+    end
+  end
+
+  # Adds/removes a flow to this slice, specified by device, port, etc.
+  configure :flows do |resource, array_parameters|
+    array_parameters = [array_parameters] if !array_parameters.kind_of?(Array)
+    array_parameters.each do |parameters|
+      resource.flowvisor_connection.call("api.changeFlowSpace", resource.transformed_parameters(parameters))
+    end
+    resource.flows
+  end
+
+
+  # Returns a hash table with the name of this slice, its controller (ip and port) and other related information
+  request :info do |resource|
+    result = resource.flowvisor_connection.call("api.getSliceInfo", resource.property.name)
+    result[:name] = resource.property.name
+    result
+  end
+
+  # Returns a string with statistics about the use of this slice
+  request :stats do |resource|
+    resource.flowvisor_connection.call("api.getSliceStats", resource.property.name)
+  end
+end

data/lib/omf_rc/resource_proxy/openflow_slice_factory.rb

@@ -0,0 +1,72 @@
+# This resourse is related with a flowvisor instance and behaves as a proxy between experimenter and flowvisor.
+#
+module OmfRc::ResourceProxy::OpenflowSliceFactory
+  include OmfRc::ResourceProxyDSL
+
+  # The default arguments of the communication between this resource and the flowvisor instance
+  FLOWVISOR_CONNECTION_DEFAULTS = {
+    host:       "localhost",
+    path:       "/xmlrc",
+    port:       "8080",
+    proxy_host: nil,
+    proxy_port: nil,
+    user:       "fvadmin",
+    password:   "openflow",
+    use_ssl:    "true",
+    timeout:    nil
+  }
+
+
+  register_proxy :openflow_slice_factory
+
+  utility :openflow_tools
+
+
+  # Checks if the created child is an :openflow_slice resource and passes the connection arguments that are essential for the connection with flowvisor instance
+  hook :before_create do |resource, type, opts = nil|
+    if type.to_sym != :openflow_slice
+      raise "This resource doesn't create resources of type "+type
+    end
+    begin
+      resource.flowvisor_connection
+    rescue
+      raise "This resource is not connected with a flowvisor instance, so it cannot create openflow slices"
+    end
+    opts.property ||= Hashie::Mash.new
+    opts.property.provider = ">> #{resource.uid}"
+    opts.property.flowvisor_connection_args = resource.property.flowvisor_connection_args
+  end
+
+
+  # A new resource uses the default connection arguments (ip adress, port, etc) to connect with a flowvisor instance
+  hook :before_ready do |resource|
+    resource.property.flowvisor_connection_args = FLOWVISOR_CONNECTION_DEFAULTS
+  end
+
+
+  # Configures the flowvisor connection arguments (ip adress, port, etc)
+  configure :flowvisor_connection do |resource, flowvisor_connection_args|
+    raise "Connection with a new flowvisor instance is not allowed if there exist created slices" if !resource.children.empty?
+    resource.property.flowvisor_connection_args.update(flowvisor_connection_args)
+  end
+
+
+  # Returns the flowvisor connection arguments (ip adress, port, etc)
+  request :flowvisor_connection do |resource|
+    resource.property.flowvisor_connection_args
+  end
+
+  # Returns a list of the existed slices or the connected devices
+  {:slices => "listSlices", :devices => "listDevices"}.each do |request_sym, handler_name|
+    request request_sym do |resource|
+      resource.flowvisor_connection.call("api.#{handler_name}")
+    end
+  end
+
+  # Returns information or statistics for a device specified by the given id
+  {:device_info => "getDeviceInfo", :device_stats => "getSwitchStats"}.each do |request_sym, handler_name|
+    request request_sym do |resource, device|
+      resource.flowvisor_connection.call("api.#{handler_name}", device.to_s)
+    end
+  end
+end

data/lib/omf_rc/util/openflow_tools.rb

@@ -0,0 +1,103 @@
+require 'xmlrpc/client'
+
+module OmfRc::Util::OpenflowTools
+  include OmfRc::ResourceProxyDSL
+
+  # The version of the flowvisor that this resource is able to control 
+  FLOWVISOR_VERSION = "FV version=flowvisor-0.8.4"
+
+  # Parts of the regular expression that describes a flow entry for flowvisor
+  FLOWVISOR_FLOWENTRY_REGEXP_DEVIDED = [
+    /dpid=\[(?<device>.+)\]/,
+    /ruleMatch=\[OFMatch\[(?<match>.+)\]\]/,
+    /actionsList=\[Slice:(?<slice>.+)=(?<actions>.+)\]/,
+    /id=\[(?<id>.+)\]/,
+    /priority=\[(?<priority>.+)\]/
+  ]
+
+  # The regular expression that describes a flow entry for flowvisor
+  FLOWVISOR_FLOWENTRY_REGEXP = /FlowEntry\[#{FLOWVISOR_FLOWENTRY_REGEXP_DEVIDED.join(',')},\]/
+
+  # The names of the flow (or flow entry) features 
+  FLOW_FEATURES = %w{device match slice actions id priority}
+
+  # The names of the flow (or flow entry) features that are specified by the "match" feature
+  FLOW_MATCH_FEATURES = %w{in_port eth_src eth_dst ip_src ip_dst}
+
+  # The default features of a new flow (or flow entry)
+  FLOW_DEFAULTS = {
+    priority: "10",
+    actions:  "4"
+  }
+
+
+  # Returns the flows (flow entries) that exist for this flowvisor
+  request :flows do |resource, filter = nil|
+    resource.flows(filter)
+  end
+
+
+  # Internal function that creates a connection with a flowvisor instance and checks it
+  work :flowvisor_connection do |resource|
+    xmlrpc_client = XMLRPC::Client.new_from_hash(resource.property.flowvisor_connection_args)
+    xmlrpc_client.instance_variable_get("@http").verify_mode = OpenSSL::SSL::VERIFY_NONE
+    ping_msg = "test"
+    pong_msg = "PONG(#{resource.property.flowvisor_connection_args[:user]}): #{FLOWVISOR_VERSION}::#{ping_msg}"
+    raise "Connection with #{FLOWVISOR_VERSION} was not successful" if xmlrpc_client.call("api.ping", ping_msg) != pong_msg
+    xmlrpc_client
+  end
+
+  # Internal function that returns the flows (flow entries) that exist in the connected flowvisor instance
+  work :flows do |resource, filter = nil|
+    result = resource.flowvisor_connection.call("api.listFlowSpace")
+    result.map! do |line|
+      array_values = line.match(FLOWVISOR_FLOWENTRY_REGEXP)[1..-1]
+        # Example of above array's content: %w{00:00:...:01 in_port=1 test 4 30 10}  
+      array_features_values_zipped = FLOW_FEATURES.zip(array_values)
+        # Example of above array's content: %w{device 00:00:...:01 match in_port=1 slice test actions 4 id 30 priority 10}  
+      hash = Hashie::Mash.new(Hash[array_features_values_zipped])
+      # The following code adds extra features that are specified by the "match" feature
+      hash["match"].split(",").each do |couple|
+        array = couple.split("=")
+        hash[array[0]] = array[1]
+      end
+      hash
+    end
+    result.delete_if {|hash| hash["slice"] != resource.property.name} if resource.type.to_sym == :openflow_slice
+    FLOW_FEATURES.each do |feature| 
+      result.delete_if {|hash| hash[feature] != filter[feature].to_s} if filter[feature]
+    end if filter
+    result
+  end
+
+  work :transformed_parameters do |resource, parameters|
+
+    match = []
+    FLOW_MATCH_FEATURES.each do |feature|
+      match << "#{feature}=#{parameters[feature]}" if parameters[feature]
+    end
+    match = match.join(",")
+
+    result = []
+    case parameters.operation
+    when "add"
+      h = Hashie::Mash.new
+      h.operation = parameters.operation.upcase
+      h.priority  = parameters.priority ? parameters.priority.to_s : FLOW_DEFAULTS[:priority]
+      h.dpid      = parameters.device.to_s
+      h.actions   = "Slice:#{resource.property.name}=#{(parameters.actions ? parameters.actions : FLOW_DEFAULTS[:actions])}"
+      h.match     = "OFMatch[#{match}]"
+      result << h
+    when "remove"
+      resource.flows(parameters).each do |f|
+        if f.match == match 
+          h = Hashie::Mash.new
+          h.operation = parameters.operation.upcase
+          h.id = f.id
+          result << h
+        end 
+      end    
+    end
+    result
+  end
+end

data/lib/omf_rc_openflow/version.rb

@@ -0,0 +1,3 @@
+module OmfRcOpenflow
+  VERSION = "6.0.0.pre"
+end

data/lib/omf_rc_openflow.rb

@@ -0,0 +1,5 @@
+require "omf_rc_openflow/version"
+
+require 'omf_rc/resource_proxy/openflow_slice_factory.rb'
+require 'omf_rc/resource_proxy/openflow_slice.rb'
+require 'omf_rc/util/openflow_tools.rb'

data/omf_rc_openflow.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/omf_rc_openflow/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Kostas Choumas"]
+  gem.email         = ["kohoumas@gmail.com"]
+  gem.description   = %q{OMF Resource Controllers related to Openflow}
+  gem.summary       = %q{OMF Resource Controllers related to Openflow}
+  gem.homepage      = "http://nitlab.inf.uth.gr"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "omf_rc_openflow"
+  gem.require_paths = ["lib"]
+  gem.version       = OmfRcOpenflow::VERSION
+  gem.add_runtime_dependency "omf_rc", "~> 6.0.0.pre"
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: omf_rc_openflow
+version: !ruby/object:Gem::Version
+  version: 6.0.0.pre
+  prerelease: 6
+platform: ruby
+authors:
+- Kostas Choumas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: omf_rc
+  requirement: &20473800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 6.0.0.pre
+  type: :runtime
+  prerelease: false
+  version_requirements: *20473800
+description: OMF Resource Controllers related to Openflow
+email:
+- kohoumas@gmail.com
+executables:
+- omf_rc_openflow_slice_factory
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/omf_rc_openflow_slice_factory
+- example/openflow_slice_factory_controller.rb
+- example/openflow_slice_factory_test.rb
+- lib/omf_rc/resource_proxy/openflow_slice.rb
+- lib/omf_rc/resource_proxy/openflow_slice_factory.rb
+- lib/omf_rc/util/openflow_tools.rb
+- lib/omf_rc_openflow.rb
+- lib/omf_rc_openflow/version.rb
+- omf_rc_openflow.gemspec
+homepage: http://nitlab.inf.uth.gr
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: OMF Resource Controllers related to Openflow
+test_files: []
+has_rdoc: