omf_rc 6.0.0.pre.5 → 6.0.0.pre.6

data/lib/omf_rc/resource_proxy/wlan.rb

@@ -0,0 +1,20 @@
+module OmfRc::ResourceProxy::Wlan
+  include OmfRc::ResourceProxyDSL
+
+  register_proxy :wlan
+
+  utility :ip
+  utility :mod
+  utility :iw
+
+  hook :before_release do |device|
+    case device.property.mode.to_sym
+    when :master
+      device.stop_hostapd
+    when :managed
+      device.stop_wpa
+    end
+    #TODO need to remove all virtual interfaces of that phy device
+    #device.remove_all_interfaces
+  end
+end

data/lib/omf_rc/resource_proxy_dsl.rb

@@ -14,6 +14,9 @@ module OmfRc::ResourceProxyDSL
     # Register a named proxy entry with factory class, normally this should be done in the proxy module
     #
     # @param [Symbol] name of the resource proxy
+    # @param [Hash] opts options to be passed to proxy registration
+    # @option opts [String, Array] :create_by resource can only be created by these resources.
+    #
     # @example suppose we define a module for wifi
     #
     #   module OmfRc::ResourceProxy::Wifi
@@ -21,19 +24,26 @@ module OmfRc::ResourceProxyDSL
     #
     #     # Let the factory know it is available
     #     register_proxy :wifi
+    #
+    #     # or use option :create_by
+    #     register_proxy :wifi, :create_by => :node
     #   end
     #
-    def register_proxy(name)
+    def register_proxy(name, opts = {})
       name = name.to_sym
-      OmfRc::ResourceFactory.register_proxy(name)
+      if opts[:create_by] && !opts[:create_by].kind_of?(Array)
+        opts[:create_by] = [opts[:create_by]]
+      end
+      OmfRc::ResourceFactory.register_proxy(name => opts)
     end
 
     # Register some hooks which can be called at certain stage of the operation
     #
-    # Currently the system supports two hooks:
+    # Currently the system supports these hooks:
     #
     # * before_ready, called when a resource created, before creating an associated pubsub topic
     # * before_release, called before a resource released
+    # * before_create, called before parent creates the child resource. (in the context of parent resource)
     #
     # @param [Symbol] name hook name. :before_create or :before_release
     # @yieldparam [AbstractResource] resource pass the current resource object to the block
@@ -44,6 +54,26 @@ module OmfRc::ResourceProxyDSL
     #
     #    register_proxy :node
     #
+    #    # before_create hook
+    #    #
+    #    # the optional block will have access to three variables:
+    #    # * resource: the parent resource itself
+    #    # * new_resource_type: a string or symbol represents the new resource to be created
+    #    # * new_resource_options: the options hash to be passed to the new resource
+    #    #
+    #    # this hook enable us to do things like:
+    #    # * validating child resources: e.g. if parent could create this new resource
+    #    # * setting up default child properties based on parent's property value
+    #    hook :before_create do |resource, new_resource_type, new_resource_options|
+    #      if new_resource_type.to_sym == :wifi
+    #        logger.info "Resource type wifi is allowed"
+    #      else
+    #        raise "Go away, I can't create #{new_resource_type}"
+    #      end
+    #      new_resource_options.property ||= Hashie::Mash.new
+    #      new_resource_options.property.node_info = "Node #{resource.uid}"
+    #    end
+    #
     #    hook :before_ready do |resource|
     #      logger.info "#{resource.uid} is now ready"
     #    end
@@ -53,8 +83,8 @@ module OmfRc::ResourceProxyDSL
     #    end
     #   end
     def hook(name, &register_block)
-      define_method(name) do
-        register_block.call(self) if register_block
+      define_method(name) do |*args, &block|
+        register_block.call(self, *args, block) if register_block
       end
     end
 
@@ -76,11 +106,13 @@ module OmfRc::ResourceProxyDSL
       begin
         # In case of module defined inline
         include "OmfRc::Util::#{name.camelize}".constantize
+        extend "OmfRc::Util::#{name.camelize}".constantize
       rescue NameError
         begin
           # Then we try to require the file and include the module
           require "#{UTIL_DIR}/#{name}"
           include "OmfRc::Util::#{name.camelize}".constantize
+          extend "OmfRc::Util::#{name.camelize}".constantize
         rescue LoadError => le
           logger.error le.message
         rescue NameError => ne
@@ -122,7 +154,8 @@ module OmfRc::ResourceProxyDSL
     #
     def configure(name, &register_block)
       define_method("configure_#{name.to_s}") do |*args, &block|
-      register_block.call(self, *args, block) if register_block
+        args[0] = Hashie::Mash.new(args[0]) if args[0].class == Hash
+        register_block.call(self, *args, block) if register_block
       end
     end
 
@@ -146,9 +179,110 @@ module OmfRc::ResourceProxyDSL
     #     end
     #   end
     def request(name, &register_block)
-      define_method("request_#{name.to_s}") do |*args|
-        register_block.call(self) if register_block
+      define_method("request_#{name.to_s}") do |*args, &block|
+        args[0] = Hashie::Mash.new(args[0]) if args[0].class == Hash
+        register_block.call(self, *args, block) if register_block
+      end
+    end
+
+    # Define an arbitrary method to do some work, can be included in configure & request block
+    #
+    # @param (see #configure)
+    # @yieldparam [AbstractResource] resource pass the current resource object to the block
+    # @example suppose we define a simple os checking method
+    #
+    #   work :os do
+    #     Command.execute("uname")
+    #   end
+    #
+    #   # then this os method will be available in all proxy definitions which includes this work method definition.
+    #   # if for some reason you need to call 'os' method within the same module, you need to access it via the resource instance.
+    #
+    #   work :install_software do |resource|
+    #     raise 'Can not support non-linux distro yet' if resource.os == 'Linux'
+    #   end
+    def work(name, &register_block)
+      define_method(name) do |*args, &block|
+        register_block.call(self, *args, block) if register_block
       end
     end
+
+    # Extend existing hook definition by alias existing method name as "orig_[method_name]"
+    #
+    # @param [#to_s] hook_name name of existing hook
+    # @example extend a hook definition
+    #
+    #   # suppose existing hook defined as this:
+    #   hook :before_ready do |resource|
+    #     logger.info "I am ready"
+    #   end
+    #
+    #   # now in a new proxy where we want to extend this hook, add more functionality:
+    #
+    #   extend_hook :before_ready
+    #
+    #   hook :before_ready do |resource|
+    #     resource.orig_before_ready
+    #
+    #     logger.info "Now I am really ready"
+    #   end
+    #
+    #   # if we simply want to overwrite the existing hook, just define the same hook without using extend_hook
+    #
+    #   hook :before_ready do |resource|
+    #     logger.info "Not sure if I am ready or not"
+    #   end
+    #
+    def extend_hook(hook_name)
+      hook_name = hook_name.to_s
+      alias_method "orig_#{hook_name}", hook_name
+    end
+
+    # Extend existing work definition by alias existing method name as "orig_[method_name]"
+    #
+    # @see #extend_hook
+    #
+    def extend_work(work_name)
+      work_name = work_name.to_s
+      alias_method "orig_#{work_name}", work_name
+    end
+
+    # Extend existing configure definition
+    #
+    # @param [#to_s] configure_name name of existing configurable property
+    #
+    # Slightly different to extend_hook, the actual method_name defined by a configure property is "configure_[configurable_property_name]"
+    #
+    # @example to extend a configurable property
+    #
+    #   configure :bob do |resource, value|
+    #     resource.property.bob = value
+    #   end
+    #
+    #   # To extend this, simply do
+    #
+    #   extend_configure :bob
+    #
+    #   configure :bob do |resource, value|
+    #     resource.orig_configure_bob(value)
+    #     resource.property.bob = "New value: #{value}"
+    #   end
+    #
+    # @see #extend_hook
+    #
+    def extend_configure(configure_name)
+      configure_name = configure_name.to_s
+      alias_method "orig_configure_#{configure_name}", "configure_#{configure_name}"
+    end
+
+    # Extend existing request definition
+    #
+    # @see #extend_hook
+    # @see #extend_configure
+    def extend_request(request_name)
+      request_name = request_name.to_s
+      alias_method "orig_request_#{request_name}", "request_#{request_name}"
+    end
+
   end
 end

data/lib/omf_rc/util/common_tools.rb

@@ -0,0 +1,61 @@
+#
+# Copyright (c) 2012 National ICT Australia (NICTA), Australia
+#
+# 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.
+#
+
+#
+# This module defines a Utility with some common work blocks that could be
+# useful to any type of Resource Proxy (RP)
+#
+module OmfRc::Util::CommonTools
+  include OmfRc::ResourceProxyDSL
+
+  # This utility block logs an error/warn String S on the resource proxy side
+  # and publish an INFORM message on the resources pubsub topic. This INFORM
+  # message will have the type ERROR/WARN, and its 'reason' element set to the
+  # String S
+  #
+  # @yieldparam [String] msg the error or warning message
+  #
+  %w(error warn).each do |type|
+    work("log_inform_#{type}") do |res, msg|
+      logger.send(type, msg)
+      res.comm.publish(
+        res.uid,
+        OmfCommon::Message.inform(type.upcase) do |message|
+          message.element('reason' , msg)
+        end
+      )
+    end
+  end
+
+  # This utility block returns true if its given value parameter is a Boolean,
+  # which in Ruby means that it is either of the class TrueClass or FalseClass
+  #
+  # @yieldparam [Object] obj the Object to test as Boolean
+  #
+  # [Boolean] true or fals
+  #
+  work('boolean?') do |res,obj|
+    result = false
+    result = true if obj.kind_of?(TrueClass) || obj.kind_of?(FalseClass)
+    result
+  end
+end

data/lib/omf_rc/util/hostapd.rb

@@ -0,0 +1,52 @@
+require 'hashie'
+require 'cocaine'
+
+module OmfRc::Util::Hostapd
+  include OmfRc::ResourceProxyDSL
+  include Cocaine
+
+  # Initialise access point conf and pid location
+  #
+  work :init_ap_conf_pid do |device|
+    device.property.ap_conf = "/tmp/hostapd.#{device.hrn}.conf"
+    device.property.ap_pid = "/tmp/hostapd.#{device.hrn}.pid"
+  end
+  # Set up and run a hostapd instance
+  #
+  work :hostapd do |device|
+    device.init_ap_conf_pid
+
+    File.open(device.property.ap_conf, "w") do |f|
+      f << "driver=nl80211\ninterface=#{device.hrn}\nssid=#{device.property.essid}\nchannel=#{device.property.channel}\n"
+      f << "hw_mode=#{device.property.hw_mode}\n" if %w(a b g).include? device.property.hw_mode
+      if device.property.hw_mode == 'n'
+        if device.property.channel.to_i < 15
+          f << "hw_mode=g\n"
+        else device.property.channel.to_i > 15
+          f << "hw_mode=a\n"
+        end
+        f << "wmm_enabled=1\nieee80211n=1\nht_capab=[HT20-]\n"
+      end
+    end
+
+    CommandLine.new("hostapd", "-B -P :ap_pid :ap_conf",
+                    :ap_pid => device.property.ap_pid,
+                    :ap_conf => device.property.ap_conf).run
+  end
+
+  work :stop_hostapd do |device|
+    begin
+      File.open(device.property.ap_pid,'r') do |f|
+        logger.debug "Stopping hostapd process at PID: #{device.property.ap_pid}"
+        CommandLine.new("kill", "-9 :pid", :pid => f.read.chomp).run
+      end
+
+      CommandLine.new("rm", "-f :ap_pid :ap_conf",
+                      :ap_pid => device.property.ap_pid,
+                      :ap_conf => device.property.ap_conf).run
+    rescue => e
+      logger.warn "Failed to clean hostapd and its related files '#{device.property.ap_pid}' and '#{device.property.ap_conf}'!"
+      logger.warn e.message
+    end
+  end
+end

data/lib/omf_rc/util/ip.rb

@@ -0,0 +1,28 @@
+require 'cocaine'
+
+module OmfRc::Util::Ip
+  include OmfRc::ResourceProxyDSL
+  include Cocaine
+
+  request :ip_addr do |resource|
+    addr = CommandLine.new("ip", "addr show dev :device", :device => resource.hrn).run
+    addr && addr.chomp.match(/inet ([[0-9]\:\/\.]+)/) && $1
+  end
+
+  request :mac_addr do |resource|
+    addr = CommandLine.new("ip", "addr show dev :device", :device => resource.hrn).run
+    addr && addr.chomp.match(/link\/ether ([\d[a-f][A-F]\:]+)/) && $1
+  end
+
+  configure :ip_addr do |resource, value|
+    CommandLine.new("ip",  "addr add :ip_address dev :device",
+                    :ip_address => value,
+                    :device => resource.hrn
+                   ).run
+    resource.request_ip_addr
+  end
+
+  work :interface_up do |resource|
+    CommandLine.new("ip", "link set :dev up", :dev => resource.hrn).run
+  end
+end

data/lib/omf_rc/util/iw.rb

@@ -1,18 +1,34 @@
 require 'hashie'
+require 'cocaine'
 
 module OmfRc::Util::Iw
   include OmfRc::ResourceProxyDSL
+  include Cocaine
+  include Hashie
 
-  OmfCommon::Command.execute("iw help").chomp.gsub(/^\t/, '').split("\n").map {|v| v.match(/[phy|dev] <.+> set (\w+) .*/) && $1 }.compact.uniq.each do |p|
-    configure p do |resource, value|
-      OmfCommon::Command.execute("iw #{resource.hrn} set #{p} #{value}")
+  utility :ip
+  utility :wpa
+  utility :hostapd
+
+  # Parse iw help page and set up all configure methods available for iw command
+  #
+  CommandLine.new("iw", "help").run.chomp.gsub(/^\t/, '').split("\n").map {|v| v.match(/[phy|dev] <.+> set (\w+) .*/) && $1 }.compact.uniq.each do |p|
+    configure p do |device, value|
+      CommandLine.new("iw", "dev :dev set :property :value",
+                      :dev => device.hrn,
+                      :property => p,
+                      :value => value).run
     end
   end
 
-  request :link do |resource|
-    known_properties = Hashie::Mash.new
+  # Parse iw link command output and return as a mash
+  #
+  request :link do |device|
+    known_properties = Mash.new
+
+    command = CommandLine.new("iw", "dev :dev link", :dev => device.hrn)
 
-    OmfCommon::Command.execute("iw #{resource.hrn} link").chomp.gsub(/^\t/, '').split("\n").drop(1).each do |v|
+    command.run.chomp.gsub(/^\t/, '').split("\n").drop(1).each do |v|
       v.match(/^(.+):\W*(.+)$/).tap do |m|
         m && known_properties[m[1].downcase.gsub(/\W+/, '_')] = m[2].gsub(/^\W+/, '')
       end
@@ -20,4 +36,101 @@ module OmfRc::Util::Iw
 
     known_properties
   end
+
+  # Parse iw info command output and return as a mash
+  #
+  request :info do |device|
+    known_properties = Mash.new
+
+    command = CommandLine.new("iw", "dev :dev info", :dev => device.hrn)
+
+    command.run.chomp.split("\n").drop(1).each do |v|
+      v.match(/^\W*(.+) (.+)$/).tap do |m|
+        m && known_properties[m[1].downcase.gsub(/\W+/, '_')] = m[2].gsub(/^\W+/, '')
+      end
+    end
+
+    known_properties
+  end
+
+  # Delete current interface, clean up
+  #
+  work :delele_interface do |device|
+    CommandLine.new("iw", "dev :dev del", :dev => device.hrn).run
+  end
+
+  # Add interface to device
+  #
+  work :add_interface do |device, type|
+    CommandLine.new("iw", "phy :phy interface add :dev type :type",
+                    :phy => device.property.phy,
+                    :dev => device.hrn,
+                    :type => type.to_s).run
+  end
+
+  # Set up or join a ibss network
+  #
+  work :join_ibss do |device|
+    CommandLine.new("iw", "dev :device ibss join :essid :frequency",
+                      :device => device.hrn.to_s,
+                      :essid => device.property.essid.to_s,
+                      :frequency => device.property.frequency.to_s).run
+  end
+
+  # Validate internal properties based on interface mode
+  #
+  work :validate_iw_properties do |device|
+    raise ArgumentError, "Missing phyical device name" if device.property.phy.nil?
+
+    unless %w(master managed adhoc monitor).include? device.property.mode
+      raise ArgumentError, "Mode must be master, managed, adhoc, or monitor, got #{device.property.mode}"
+    end
+
+    case device.property.mode.to_sym
+    when :master
+      unless %w(a b g n).include? device.property.hw_mode
+        raise ArgumentError, "Hardware mode must be a, b, g, or n, got #{device.property.hw_mode}"
+      end
+      %w(channel essid).each do |p|
+        raise ArgumentError, "#{p} must not be nil" if device.property.send(p).nil?
+      end
+    when :managed
+      %w(essid).each do |p|
+        raise ArgumentError, "#{p} must not be nil" if device.property.send(p).nil?
+      end
+    when :adhoc
+      %w(essid frequency).each do |p|
+        raise ArgumentError, "#{p} must not be nil" if device.property.send(p).nil?
+      end
+    end
+  end
+
+  # Configure the interface with mode managed, master, adhoc or monitor
+  #
+  configure :mode do |device, value|
+    # capture value hash and store internally
+    device.property.update(value)
+
+    device.validate_iw_properties
+
+    device.delele_interface rescue logger.warn "Interface #{device.hrn} not found"
+
+    # TODO should just remove all interfaces from physical device, at least make it optional
+
+    case device.property.mode.to_sym
+    when :master
+      device.add_interface(:managed)
+      device.hostapd
+    when :managed
+      device.add_interface(:managed)
+      device.wpasup
+    when :adhoc
+      device.add_interface(:adhoc)
+      device.interface_up
+      device.join_ibss
+    when :monitor
+      device.add_interface(:monitor)
+      device.interface_up
+    end
+  end
 end

data/lib/omf_rc/util/mock.rb

@@ -5,7 +5,8 @@ module OmfRc::Util::Mock
     resource.uid
   end
 
-  configure :nothing
+  configure :nothing do
+  end
 
   configure :hrn do |resource, hrn|
     resource.hrn = hrn

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