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

data/lib/omf_rc/resource_proxy/generic_application.rb

@@ -0,0 +1,471 @@
+#
+# 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 Resource Proxy (RP) for a Generic Application
+#
+# Utility dependencies: platform_toos, common_tools
+#
+# This Generic Application Proxy has the following properties:
+#
+# - binary_path (String) the path to the binary of this app
+# - pkg_tarball (String) the URI of the installation tarball of this app 
+# - pkg_ubuntu (String) the name of the Ubuntu package for this app
+# - pkg_fedora (String) the name of the Fedora package for this app
+# - state (String) the state of this Application RP 
+#     (stop, run, pause, install)
+# - installed (Boolean) is this application installed? (default false)
+# - force_tarball_install (Boolean) if true then force the installation 
+#     from tarball even if other distribution-specific 
+#     installation are available (default false)
+# - map_err_to_out (Boolean) if true then map StdErr to StdOut for this 
+#     app (default false)
+# - platform (Symbol) the OS platform where this app is running
+#
+# - environment (Hash) the environment variables to set prior to starting 
+#     this app. {k1 => v1, ...} will result in "env -i K1=v1 ... "
+#     (with k1 being either a String or a Symbol)
+#
+# - parameters (Hash) the command line parameters available for this app.
+#     This hash is of the form: { :param1 => attribut1, ... }
+#     with param1 being the id of this parameter for this Proxy and
+#     with attribut1 being another Hash with the following possible
+#     keys and values (all are optional):
+#     :cmd (String) the command line for this parameter 
+#     :order (Fixnum) the appearance order on the command line, default FIFO 
+#     :dynamic (Boolean) parameter can be dynammically changed, default false
+#     :type (Numeric|String|Boolean) this parameter's type
+#     :default value given by default to this parameter 
+#     :value value to set for this parameter
+#     :mandatory (Boolean) this parameter is mandatory, default false
+#
+# Two examples of valid parameters definition are:
+#
+#     { :host => {:default => 'localhost', :type => 'String', 
+#             :mandatory => true, :order => 2},
+#       :port => {:default => 5000, :type => 'Numeric', :cmd => '-p', 
+#             :mandatory => true, :order => 1}, 
+#       :size => {:default => 512, :type => 'Numeric', :cmd => '--pkt-size', 
+#             :mandatory => true, :dynamic => true}
+#       :title => {:type => 'String', :mandatory => false} 
+#     }
+# 
+# and
+#
+#     { :title => {:value => "My First Application"} }                   
+#
+module OmfRc::ResourceProxy::GenericApplication
+  include OmfRc::ResourceProxyDSL 
+  require 'omf_common/exec_app'
+
+  register_proxy :generic_application
+  utility :platform_tools
+  utility :common_tools
+
+  MAX_PARAMETER_NUMBER = 1000
+  DEFAULT_MANDATORY_PARAMETER = false
+
+  hook :before_ready do |res|
+    res.property.app_id ||= nil 
+    res.property.binary_path ||= nil 
+    res.property.platform ||= nil 
+    res.property.pkg_tarball ||= nil 
+    res.property.tarball_install_path ||= '/' 
+    res.property.force_tarball_install ||= false
+    res.property.pkg_ubuntu ||= nil 
+    res.property.pkg_fedora ||= nil 
+    res.property.state ||= :stop 
+    res.property.installed ||= false 
+    res.property.map_err_to_out ||= false 
+    res.property.event_sequence ||= 0 
+    res.property.parameters ||= Hash.new
+    res.property.environments ||= Hash.new
+    define_method("on_app_event") { |*args| process_event(self, *args) }
+  end
+
+  # This method processes an event coming from the application instance, which
+  # was started by this Resource Proxy (RP). It is a callback, which is usually
+  # called by the ExecApp class in OMF
+  # 
+  # @param [AbstractResource] res this RP
+  # @param [String] event_type the type of event from the app instance
+  #                 (STARTED, DONE.OK, DONE.ERROR, STDOUT, STDERR)
+  # @param [String] app_id the id of the app instance
+  # @param [String] msg the message carried by the event
+  #
+  def process_event(res, event_type, app_id, msg)
+      logger.info "App Event from '#{app_id}' "+
+                  "(##{res.property.event_sequence}) - "+
+                  "#{event_type}: '#{msg}'"
+      res.property.state = :stop if event_type.to_s.include?('DONE')
+      res.comm.publish(res.uid,
+        OmfCommon::Message.inform('STATUS') do |message|
+          message.property('status_type' , 'APP_EVENT')
+          message.property('event' , event_type.to_s.upcase)
+          message.property('app' , app_id)
+          message.property('msg' , "#{msg}")
+          message.property('seq' , "#{res.property.event_sequence}")
+        end)
+      res.property.event_sequence += 1
+      res.property.installed = true if app_id.include?("_INSTALL") &&
+                                       event_type.to_s.include?('DONE.OK')
+  end
+
+  # Request the basic properties of this Generic Application RP. 
+  # @see OmfRc::ResourceProxy::GenericApplication
+  #
+  %w(binary_path pkg_tarball pkg_ubuntu pkg_fedora state installed \
+    force_tarball_install map_err_to_out tarball_install_path).each do |prop|
+    request(prop) { |res| res.property[prop].to_s }
+  end
+  
+  # Request the platform property of this Generic Application RP
+  # @see OmfRc::ResourceProxy::GenericApplication
+  #
+  request :platform do |res|
+    res.property.platform = detect_platform if res.property.platform.nil?
+    res.property.platform.to_s
+  end
+
+  # Configure the basic properties of this Generic Application RP
+  # @see OmfRc::ResourceProxy::GenericApplication
+  #
+  %w(binary_path pkg_tarball pkg_ubuntu pkg_fedora force_tarball_install \
+    map_err_to_out tarball_install_path).each do |prop|
+    configure(prop) { |res, value| res.property[prop] = value }
+  end
+
+  # Configure the environments property of this Generic Application RP
+  # @see OmfRc::ResourceProxy::GenericApplication
+  #
+  configure :environments do |res, envs|
+    if envs.kind_of? Hash
+      res.property.environments = res.property.environments.merge(envs)
+    else
+      res.log_inform_error "Environment configuration failed! "+
+        "Environments not passed as Hash (#{envs.inspect})"
+    end
+    res.property.environments
+  end
+
+  # Configure the parameters property of this Generic Application RP
+  # @see OmfRc::ResourceProxy::GenericApplication
+  #
+  configure :parameters do |res, params|
+    if params.kind_of? Hash
+      params.each do |p,v|
+        if v.kind_of? Hash
+          # if this param has no set order, then assign the highest number to it
+          # this will allow sorting the parameters later
+          v[:order] = MAX_PARAMETER_NUMBER if v[:order].nil?
+          # if this param has no set mandatory field, assign it a default one
+          v[:mandatory] = DEFAULT_MANDATORY_PARAMETER if v[:mandatory].nil?
+          merged_val = res.property.parameters[p].nil? ? v : res.property.parameters[p].merge(v)
+          new_val = res.sanitize_parameter(p,merged_val)
+          # only set this new parameter if it passes the type check
+          if res.pass_type_checking?(new_val) 
+            res.property.parameters[p] = new_val
+            res.dynamic_parameter_update(p,new_val)
+          else
+            res.log_inform_error "Configuration of parameter '#{p}' failed "+
+              "type checking. Defined type is #{new_val[:type]} while assigned "+
+              "value/default are #{new_val[:value].inspect} / "+
+              "#{new_val[:default].inspect}"
+          end
+        else
+          res.log_inform_error "Configuration of parameter '#{p}' failed!"+
+            "Options not passed as Hash (#{v.inspect})"
+        end
+      end
+    else
+      res.log_inform_error "Parameter configuration failed! Parameters not "+
+        "passed as Hash (#{params.inspect})"
+    end
+    res.property.parameters[p]
+  end
+
+  # Configure the state of this Generic Application RP. The valid states are
+  # stop, run, pause, install. The semantic of each states are:
+  #
+  # - stop: the initial state for an Application RP, and the final state for 
+  #         an applicaiton RP, for which the application instance finished 
+  #         its execution or its installation
+  # - run: upon entering in this state, a new instance of the application is 
+  #        started, the Application RP stays in this state until the
+  #        application instance is finished or paused. The Application RP can
+  #        only enter this state from a previous 'pause' or 'stop' state.
+  # - pause: upon entering this state, the currently running instance of this
+  #          application should be paused (it is the responsibility of 
+  #          specialised Application Proxy to ensure that! The default Generic
+  #          Application Proxy does nothing to the application instance when
+  #          entering this state). The Application RP can only enter this 
+  #          state from a previous 'run' state.
+  # - install: upon entering in this state, a new installation of the
+  #            application will be performed by the Application RP, which will
+  #            stay in this state until the installation is finished. The 
+  #            Application RP can only enter this state from a previous 'stop'
+  #            state, and can only enter a 'stop' state once the installation
+  #            is finished.
+  #            Supported install methods are: Tarball, Ubuntu, and Fedora
+  # 
+  # @yieldparam [String] value the state to set this app into
+  #  
+  configure :state do |res, value|
+    case value.to_s.downcase.to_sym
+    when :install then res.switch_to_install
+    when :stop then res.switch_to_stop
+    when :run then res.switch_to_run
+    when :pause then res.switch_to_pause
+    end
+    res.property.state
+  end
+
+  # Swich this Application RP into the 'install' state
+  # (see the description of configure :state)
+  #
+  work('switch_to_install') do |res|
+    if res.property.state.to_sym == :stop
+      if res.property.installed
+        res.log_inform_warn "The application is already installed"
+      else
+        # Select the proper installation method based on the platform
+        # and the value of 'force_tarball_install'
+        res.property.state = :install
+        if res.property.force_tarball_install || 
+          (res.property.platform == :unknown)
+          installing = res.install_tarball(res.property.pkg_tarball, 
+              res.property.tarball_install_path)
+        elsif res.property.platform == :ubuntu 
+          installing = res.install_ubuntu(res.property.pkg_ubuntu)
+        elsif res.property.platform == :fedora 
+          installing = res.install_fedora(res.property.pkg_fedora)
+        end
+        res.property.state = :stop unless installing
+      end
+    else
+      # cannot install as we are not stopped 
+      res.log_inform_warn "Not in STOP state. Cannot switch to INSTALL state!"
+    end
+  end
+
+  # Swich this Application RP into the 'stop' state
+  # (see the description of configure :state)
+  #
+  work('switch_to_stop') do |res|
+    if res.property.state == :run || res.property.state == :pause
+      id = res.property.app_id
+      unless ExecApp[id].nil?
+        # stop this app
+        begin
+          # first, try sending 'exit' on the stdin of the app, and wait
+          # for 4s to see if the app acted on it...
+          ExecApp[id].stdin('exit')
+          sleep 4
+          unless ExecApp[id].nil?
+            # second, try sending TERM signal, wait another 4s to see
+            # if the app acted on it...
+            ExecApp[id].signal('TERM')
+            sleep 4
+            # finally, try sending KILL signal
+            ExecApp[id].kill('KILL') unless ExecApp[id].nil?
+          end
+          res.property.state = :stop
+        rescue => err
+        end
+      end
+    end
+  end
+
+  # Swich this Application RP into the 'run' state
+  # (see the description of configure :state)
+  #
+  work('switch_to_run') do |res|
+    if res.property.state == :stop 
+      # start a new instance of this app 
+      res.property.app_id = res.hrn.nil? ? res.uid : res.hrn 
+      # we need at least a defined binary path to run an app...
+      if res.property.binary_path.nil?
+        res.log_inform_warn "Binary path not set! No Application to run!"
+      else
+        ExecApp.new(res.property.app_id, res, 
+                    res.build_command_line, 
+                    res.property.map_err_to_out)
+        res.property.state = :run
+      end
+    elsif res.property.state == :pause
+      # resume this paused app
+      res.property.state = :run
+      # do more things here...
+    elsif res.property.state == :install
+      # cannot run as we are still installing
+      res.log_inform_warn "Still in INSTALL state. Cannot switch to RUN state!"
+    end
+  end
+
+  # Swich this Application RP into the 'pause' state
+  # (see the description of configure :state)
+  #
+  work('switch_to_pause') do |res|
+    if res.property.state == :run 
+      # pause this app
+      res.property.state = :pause
+      # do more things here...
+    end
+  end
+
+  # Check if a parameter is dynamic, and if so update its value if the
+  # application is currently running
+  #
+  # @yieldparam [String] name the parameter id as known by this app
+  # @yieldparam [Hash] att the Hash holding the parameter's attributs
+  # @see OmfRc::ResourceProxy::GenericApplication
+  #
+  work('dynamic_parameter_update') do |res,name,att|
+    # Only update a parameter if it is dynamic and the application is running
+    dynamic = false
+    dynamic = att[:dynamic] if res.boolean?(att[:dynamic])
+    if dynamic && res.property.state == :run
+      line = ""
+      line += "#{att[:cmd]} " unless att[:cmd].nil?
+      line += "#{att[:value]}"
+      ExecApp[res.property.app_id].stdin(line)
+      logger.info "Updated parameter #{name} with value #{att[:value].inspect}"
+    end
+  end
+
+  # First, convert any 'true' or 'false' strings from the :mandatory and 
+  # :dynamic attributs of a given parameter into TrueClass or FalseClass 
+  # instances.
+  # Second, if that parameter is of a type Boolean, then perform the same
+  # conversion on the assigned default and value of this parameter
+  #
+  #  @yieldparam [String] name the parameter id as known by this app
+  #  @yieldparam [Hash] att the Hash holding the parameter's attributs
+  #
+  # [Hash] a copy of the input Hash with the above conversion performed in it
+  #
+  work('sanitize_parameter') do |res,name,att|
+    begin
+      if !att[:mandatory].nil? && !res.boolean?(att[:mandatory])
+        att[:mandatory] = eval(att[:mandatory].downcase)  
+      end   
+      if !att[:dynamic].nil? && !res.boolean?(att[:dynamic])
+       att[:dynamic] = eval(att[:dynamic].downcase) 
+      end
+      if (att[:type] == 'Boolean')
+        att[:value] = eval(att[:value].downcase) if !att[:value].nil? && !res.boolean?(att[:value])
+        att[:default] = eval(att[:default].downcase) if !att[:default].nil? && !res.boolean?(att[:default])
+      end
+    rescue Exception => ex
+      res.log_inform_error "Cannot sanitize the parameter '#{name}' (#{att.inspect})"
+    end
+    att
+  end
+
+  # Check if a requested value or default for a parameter has the same
+  # type as the type defined for that parameter
+  # The checking procedure is as follows:
+  # - first check if a type was set for this parameter, if not then return true
+  #   Thus if no type was defined for this parameter then return true 
+  #   regardless of the type of the given value or default
+  # - second check if a value is given, if so check if it has the same type as
+  #   the defined type, if so then return true, if not then return false.
+  # - third if no value is given but a default is given, then perform the same 
+  #   check as above but using the default in-place of the value
+  #
+  # @yieldparam [Hash] att the Hash holding the parameter's attributs
+  #
+  # [Boolean] true or false
+  #
+  work('pass_type_checking?') do |res,att|
+    passed = false
+    unless att[:type].nil?
+      if att[:type] == 'Boolean' # HACK: as Ruby does not have a Boolean type
+        if !att[:default].nil? && !att[:value].nil?
+          passed = true if res.boolean?(att[:default]) && res.boolean?(att[:value])
+        elsif att[:default].nil? && att[:value].nil?
+          passed = true
+        elsif att[:default].nil?
+          passed = true if res.boolean?(att[:value]) 
+        elsif att[:value].nil?
+          passed = true if res.boolean?(att[:default]) 
+        end
+      else # HACK: Now for all other types... 
+        klass = Module.const_get(att[:type].capitalize.to_sym)
+        if !att[:default].nil? && !att[:value].nil?
+          passed = true if att[:default].kind_of?(klass) && att[:value].kind_of?(klass)
+        elsif att[:default].nil? && att[:value].nil?
+          passed = true
+        elsif att[:default].nil?
+          passed = true if att[:value].kind_of?(klass)
+        elsif att[:value].nil?
+          passed = true if att[:default].kind_of?(klass)
+        end
+      end
+    else
+      passed = true
+    end
+    passed
+  end
+
+  # Build the command line, which will be used to start this app
+  # This command line will be of the form:
+  # "env -i VAR1=value1 ... application_path parameterA valueA ..." 
+  #
+  # The environment variables and the parameters in that command line are 
+  # taken respectively from the 'environments' and 'parameters' properties of
+  # this Generic Application Resource Proxy.
+  #
+  # [String] the full command line
+  #
+  work('build_command_line') do |res|
+    cmd_line = "env -i " # Start with a 'clean' environments
+    res.property.environments.each do |e,v|
+      val = v.kind_of?(String) ? "'#{v}'" : v
+      cmd_line += "#{e.to_s.upcase}=#{val} "
+    end
+    cmd_line += res.property.binary_path + " "
+    # Add command line parameter in their specified order if any
+    sorted_parameters = res.property.parameters.sort_by {|k,v| v[:order]}
+    sorted_parameters.each do |param,att|
+      needed = false
+      needed = att[:mandatory] if res.boolean?(att[:mandatory])
+      # For mandatory parameter without a value, take the default one
+      val = att[:value]
+      val = att[:default] if needed && att[:value].nil?
+      # Finally add the parameter if is value/default is not nil
+      unless val.nil?
+        if att[:type] == "Boolean"
+          # for Boolean param, only the command is printed if value==true 
+          cmd_line += "#{att[:cmd]} " if val == true 
+        else
+          # for all other type of param, we print "cmd value"
+          # with a user-provided prefix/suffix if defined
+          cmd_line += "#{att[:cmd]} "
+          cmd_line += att[:prefix].nil? ? "#{val}" : "#{att[:prefix]}#{val}"
+          cmd_line += att[:suffix].nil? ? " " : "#{att[:suffix]} "
+        end
+      end
+    end
+    cmd_line
+  end
+
+end

data/lib/omf_rc/resource_proxy/net.rb

@@ -0,0 +1,7 @@
+module OmfRc::ResourceProxy::Net
+  include OmfRc::ResourceProxyDSL
+
+  register_proxy :net
+
+  utility :ip
+end

data/lib/omf_rc/resource_proxy/node.rb

@@ -3,15 +3,41 @@ module OmfRc::ResourceProxy::Node
 
   register_proxy :node
 
-  hook :before_ready do |resource|
-    logger.info "#{resource.uid} is now ready"
+  request :proxies do
+    OmfRc::ResourceFactory.proxy_list
   end
 
-  hook :before_release do |resource|
-    logger.info "#{resource.uid} is now released"
-  end
+  request :devices do |resource|
+    devices = []
+    Dir.chdir("/sys/class") do
+      # Support net devices for now
+      category = "net"
 
-  request :proxies do
-    OmfRc::ResourceFactory.proxy_list
+      Dir.glob("net/eth*").each do |v|
+        File.exist?("#{v}/uevent") && File.open("#{v}/uevent") do |f|
+          subcategory = f.read.match(/DEVTYPE=(.+)/) && $1
+          proxy = "net"
+          File.exist?("#{v}/device/uevent") && File.open("#{v}/device/uevent") do |f|
+            driver = f.read.match(/DRIVER=(.+)/) && $1
+            device = { name: File.basename(v), driver: driver, category: category }
+            device[:subcategory] = subcategory if subcategory
+            device[:proxy] = proxy if resource.request_proxies.include?(proxy.to_sym)
+            devices << device
+          end
+        end
+      end
+
+      Dir.glob("ieee80211/*").each do |v|
+        subcategory = "wlan"
+        proxy = "wlan"
+        File.exist?("#{v}/device/uevent") && File.open("#{v}/device/uevent") do |f|
+          driver = f.read.match(/DRIVER=(.+)/) && $1
+          device = { name: File.basename(v), driver: driver, category: category, subcategory: subcategory }
+          device[:proxy] = proxy if resource.request_proxies.include?(proxy.to_sym)
+          devices << device
+        end
+      end
+    end
+    devices
   end
 end

data/lib/omf_rc/resource_proxy/openflow_slice.rb

@@ -0,0 +1,79 @@
+# 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
+
+  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, parameters|
+    resource.flowvisor_connection.call("api.changeFlowSpace", resource.transformed_parameters(parameters))
+    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,71 @@
+# 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.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