omf_common 6.0.0.pre.10 → 6.0.0.pre.11

data/bin/monitor_topic.rb

@@ -0,0 +1,80 @@
+require 'optparse'
+
+DESCR = %{
+Monitor a set of resources (topics) and print all observed messages.
+
+If the 'follow-children' flag is set, automatically add all resources
+created by the monitored resources to the monitor set. Please note
+that there will be a delay until the new monitors are in place which
+can result in missed messages.
+}
+
+require 'omf_common'
+
+OP_MODE = :development
+
+opts = {
+  communication: {
+    url: 'amqp://srv.mytestbed.net'
+  },
+  eventloop: { type: :em},
+  logging: {
+    level: 'info'
+  }
+}
+
+observed_topic = nil
+$follow_children = true
+
+op = OptionParser.new
+op.banner = "Usage: #{op.program_name} [options] topic1 topic2 ...\n#{DESCR}\n"
+op.on '-c', '--comms-url URL', "URL to communication layer [#{opts[:communication][:url]}]" do |url|
+  opts[:communication][:url] = url
+end
+op.on '-f', "--[no-]follow-children", "Follow all newly created resources [#{$follow_children}]" do |flag|
+  $follow_children = flag
+end
+op.on '-d', '--debug', "Set logging to DEBUG level" do
+  opts[:logging][:level] = 'debug'
+end
+op.on_tail('-h', "--help", "Show this message") { $stderr.puts op; exit }
+observed_topics = op.parse(ARGV)
+
+unless observed_topics
+  $stderr.puts 'Missing declaration of topics to follow'
+  $stderr.puts op
+  exit(-1)
+end
+
+$observed_topics = {}
+
+def observe(tname, comm)
+  return if $observed_topics.key? tname
+
+  info "Observing '#{tname}'"
+  $observed_topics[tname] = true
+  comm.subscribe(tname) do |topic|
+    topic.on_message do |msg|
+      ts = Time.now.strftime('%H:%M:%S')
+      puts "#{ts}  #{msg.type}(#{msg.itype})  #{msg.inspect}"
+      puts "  #{topic.id}"
+      msg.each_property do |name, value|
+        puts "    #{name}: #{value}"
+      end
+      puts "------"
+
+      if $follow_children && msg.itype == 'creation_ok'
+        #puts ">>>>>> #{msg}"
+        observe(msg[:res_id], comm)
+      end
+    end
+  end
+end
+
+OmfCommon.init(OP_MODE, opts) do |el|
+  OmfCommon.comm.on_connected do |comm|
+    observed_topics.each do |topic|
+      observe(topic, comm)
+    end
+  end
+end

data/bin/send_create.rb

@@ -0,0 +1,94 @@
+#
+DESCR = %{
+Send a create to a specific resource (topic) and print out any replies.
+
+Any additional command line arguments are interpreted as paramters to 
+the create.
+}
+
+require 'omf_common'
+
+OP_MODE = :development
+
+opts = {
+  communication: {
+#    url: 'amqp://srv.mytestbed.net'
+  },
+  eventloop: { type: :em},
+  logging: {
+    level: 'info'
+  }  
+}
+
+resource_url = nil
+resource_type = nil
+
+op = OptionParser.new
+op.banner = "Usage: #{op.program_name} [options] type pname1: val1 pname2: val2 ...\n#{DESCR}\n"
+op.on '-r', '--resource-url URL', "URL of resource" do |url|
+  resource_url = url
+end
+op.on '-t', '--type TYPE', "Type of resource to create" do |type|
+  resource_type = type
+end
+op.on '-d', '--debug', "Set logging to DEBUG level" do
+  opts[:logging][:level] = 'debug'
+end
+op.on_tail('-h', "--help", "Show this message") { $stderr.puts op; exit }
+rest = op.parse(ARGV) || []
+
+unless resource_url || resource_type
+  $stderr.puts 'Missing --resource-url --type or'
+  $stderr.puts op
+  exit(-1)
+end
+
+r = resource_url.split('/')
+resource = r.pop
+opts[:communication][:url] = r.join('/')
+
+copts = {}
+key = nil
+def err_exit
+  $stderr.puts("Options need to be of the 'key: value' type")
+  exit(-1)  
+end
+rest.each do |s|
+  sa = s.split(':')
+  if sa.length == 2
+    err_exit if key
+    copts[sa[0]] = sa[1]
+  else
+    if s.end_with?(':')
+      err_exit if key
+      key = s[0]
+    else
+      err_exit unless key
+      copts[key] = s[0]
+      key = nil
+    end
+  end
+end
+err_exit if key
+
+OmfCommon.init(OP_MODE, opts) do |el|
+  OmfCommon.comm.on_connected do |comm|
+    comm.subscribe(resource) do |topic|
+      # topic.on_inform do |msg|
+        # puts "#{resource}   <#{msg.type}(#{msg.itype})>    #{msg.inspect}"
+        # msg.each_property do |name, value|
+          # puts "    #{name}: #{value}"
+        # end
+        # puts "------"
+      # end
+      
+      topic.create(resource_type, copts) do |msg|
+        puts "#{resource}   <#{msg.type}(#{msg.itype})>    #{msg.inspect}"
+        msg.each_property do |name, value|
+          puts "    #{name}: #{value}"
+        end
+        puts "------"
+      end    
+    end
+  end
+end

data/bin/send_request.rb

@@ -0,0 +1,58 @@
+#
+DESCR = %{
+Send a request to a specific resource (topic) and print out any replies.
+
+Any additional command line arguments are interpreted as limiting the request
+to those, otherwise all properties are requested.
+}
+
+require 'omf_common'
+
+OP_MODE = :development
+
+opts = {
+  communication: {
+#    url: 'amqp://srv.mytestbed.net'
+  },
+  eventloop: { type: :em},
+  logging: {
+    level: 'info'
+  }  
+}
+
+resource_url = nil
+
+op = OptionParser.new
+op.banner = "Usage: #{op.program_name} [options] prop1 prop2 ...\n#{DESCR}\n"
+op.on '-r', '--resource-url URL', "URL of resource" do |url|
+  resource_url = url
+end
+op.on '-d', '--debug', "Set logging to DEBUG level" do
+  opts[:logging][:level] = 'debug'
+end
+op.on_tail('-h', "--help", "Show this message") { $stderr.puts op; exit }
+req_properties = op.parse(ARGV) || []
+
+unless resource_url
+  $stderr.puts 'Missing --resource-url'
+  $stderr.puts op
+  exit(-1)
+end
+
+r = resource_url.split('/')
+resource = r.pop
+opts[:communication][:url] = r.join('/')
+
+OmfCommon.init(OP_MODE, opts) do |el|
+  OmfCommon.comm.on_connected do |comm|
+    comm.subscribe(resource) do |topic|
+      topic.request(req_properties) do |msg|
+        puts "#{resource}   <#{msg.type}(#{msg.itype})>    #{msg.inspect}"
+        msg.each_property do |name, value|
+          puts "    #{name}: #{value}"
+        end
+        puts "------"
+      end
+    end
+  end
+end

data/example/engine_alt.rb

@@ -0,0 +1,136 @@
+# OMF_VERSIONS = 6.0
+require 'omf_common'
+
+opts = {
+  communication: {
+    url: 'amqp://localhost',
+  }
+}
+
+# $stdout.sync = true
+# Logging.appenders.stdout(
+  # 'my_format',
+  # :layout => Logging.layouts.pattern(:date_pattern => '%H:%M:%S',
+                                     # :pattern => '%d %5l %c{2}: %m\n',
+                                     # :color_scheme => 'none'))
+# Logging.logger.root.appenders = 'my_format'
+# Logging.logger.root.level = :debug if opts[:debug]
+
+# Environment setup
+#OmfCommon.init(:developement, opts) 
+OmfCommon.init(:local) 
+
+
+
+def create_engine(garage)
+  garage.create(:engine, name: 'mp4') do |msg|
+    if msg.success?
+      engine = msg.resource
+      on_engine_created(engine, garage)
+    else
+      logger.error "Resource creation failed - #{msg[:reason]}"
+    end
+  end
+end
+
+
+# This is an alternative version of creating a new engine.
+# We create teh message first without sending it, then attach various
+# response handlers and finally publish it.
+#
+# TODO: This is most likely NOT working yet
+#
+def create_engine2
+  msg = garage.create_message('mp4')
+  msg.on_created do |engine, emsg|
+    on_engine_created(engine, garage)
+  end
+  msg.on_created_failed do |fmsg|
+      logger.error "Resource creation failed - #{msg[:reason]}"
+  end
+  msg.publish
+end
+
+# This method is called whenever a new engine has been created by the garage.
+#
+# @param [Topic] engine Topic representing the created engine
+# 
+def on_engine_created(engine, garage)
+  # Monitor all status information from teh engine
+  engine.on_inform_status do |msg|
+    msg.each_property do |name, value|
+      logger.info "#{name} => #{value}"
+    end
+  end
+
+  engine.on_inform_failed do |msg|
+    logger.error msg.read_content("reason")
+  end
+
+  # Send a request for specific properties
+  puts ">>> SENDING REQUEST"
+  engine.request([:max_rpm, {:provider => {country: 'japan'}}, :max_power]) do |msg|
+  #engine.request([:max_rpm, :max_power])
+  #engine.request() do |msg|
+    puts ">>> REPLY #{msg.inspect}"
+  end
+            
+              
+
+
+  return 
+  
+  # Now we will apply 50% throttle to the engine
+  engine.configure(throttle: 50)
+
+  # Some time later, we want to reduce the throttle to 0, to avoid blowing up the engine
+  engine.after(5) do
+    engine.configure(throttle: 0)
+    
+    # While we are at it, also test error handling
+    engine.request([:error]) do |msg|
+      if msg.success?
+        logger.error "Expected unsuccessful reply"
+      else
+        logger.info "Received expected fail message - #{msg[:reason]}"
+      end
+    end
+  end
+
+  # 10 seconds later, we will 'release' this engine, i.e. shut it down
+  #engine.after(10) { release_engine(engine, garage) }
+end
+
+def release_engine(engine, garage)
+  logger.info "Time to release engine #{engine}"
+  garage.release engine do |rmsg|
+    puts "===> ENGINE RELEASED: #{rmsg}"
+  end
+end
+
+OmfCommon.eventloop.run do |el|
+  OmfCommon.comm.on_connected do |comm|
+    
+    # Create garage proxy
+    load File.join(File.dirname(__FILE__), '..', '..', 'omf_rc', 'example', 'garage_controller.rb')
+    garage_inst = OmfRc::ResourceFactory.create(:garage, hrn: :garage_1)
+    
+    # Get handle on existing entity
+    comm.subscribe('garage_1') do |garage|
+    
+      garage.on_inform_failed do |msg|
+        logger.error msg
+      end
+      # wait until garage topic is ready to receive
+      garage.on_subscribed do
+        create_engine(garage)
+      end
+    end
+    
+    el.after(20) { el.stop }
+  end
+end
+
+
+puts "DONE"
+

data/example/vm_alt.rb

@@ -0,0 +1,65 @@
+
+# Communication setup
+Comm.init(:xmpp)
+
+def create_vm(vm_name, host)
+  opts = {
+    name: 'my_VM_123',
+    ubuntu_opts: { bridge: 'br0' }, 
+    vmbuilder_opts: {
+      ip: '10.0.0.240', 
+      net: '10.0.0.0',
+      bcast: '10.255.255.255',
+      mask: '255.0.0.0',
+      gw: '10.0.0.200',
+      dns: '10.0.0.200'
+    }
+  }
+  host.create(:vm, opts) do |msg|
+    if msg.success?
+      vm = msg.resource
+      on_vm_created(vm, host)
+    else
+      logger.error "Resource creation failed - #{msg[:reason]}"
+    end
+  end
+end
+
+def on_vm_created(vm, host)
+  logger.info "Created #{vm}"
+  vm.on_inform_status do |msg|
+    msg.each_property do |name, value|
+      logger.info "#{name} => #{value}"
+    end
+    if vm.state == :running
+      puts "HURRAY, vm '#{vm}' is up and running"
+    end
+  end
+  
+  vm.after(10) do
+    vm.configure(state: :run)
+  end
+end
+
+OmfCommon.eventloop.run do |el|
+  OmfCommon.comm.on_connected do |comm|
+    # Get handle on existing entity
+    comm.subscribe('host_1') do |host|
+    
+      host.on_inform_failed do |msg|
+        logger.error msg
+      end
+      # wait until host topic is ready to receive
+      host.on_subscribed do
+        create_vm(host)
+      end
+    end
+    
+    el.after(20) { el.stop }
+  end
+end
+
+
+puts "DONE"
+
+

data/lib/omf_common.rb

@@ -1,17 +1,238 @@
 require 'active_support/core_ext'
+
 require 'omf_common/default_logging'
 require 'omf_common/version'
 require 'omf_common/measure'
 require 'omf_common/message'
 require 'omf_common/comm'
 require 'omf_common/command'
-require 'omf_common/topic'
-require 'omf_common/topic_message'
 require 'omf_common/key'
 require 'omf_common/core_ext/string'
-require 'omf_common/core_ext/object'
+require 'omf_common/eventloop'
 
 include OmfCommon::DefaultLogging
 
 module OmfCommon
+  DEFAULTS = {
+    development: {
+      eventloop: {
+        type: 'em'
+      },
+      logging: {
+        level: 'debug',
+
+        appenders: {
+          stdout: {
+            date_pattern: '%H:%M:%S',
+            pattern: '%d %5l %c{2}: %m\n',
+            color_scheme: 'default'
+          }
+        }
+      }
+    },
+    production: {
+      eventloop: {
+        type: :em
+      },
+      logging: {
+        level: 'info',
+
+        appenders: {
+          file: {
+            log_dir: '/var/log',
+            #log_file: 'foo.log',
+            date_pattern: '%F %T %z',
+            pattern: '[%d] %-5l %c: %m\n'
+          }
+        }
+
+      }
+    },
+    local: {
+      communication: {
+        type: :local,
+      },
+      eventloop: { type: :local},
+      logging: {
+        level: 'debug',
+
+        appenders: {
+          stdout: {
+            date_pattern: '%H:%M:%S',
+            pattern: '%d %5l %c{2}: %m\n',
+            color_scheme: 'none'
+          }
+        }
+      }
+    },
+    test_dev: {
+      daemonize: {
+        dir_mode: :script,
+        dir: '/tmp',
+        backtrace: true,
+        log_dir: '/tmp',
+        log_output: true
+      },
+      eventloop: {
+        type: :local
+      },
+      logging: {
+        level: 'debug',
+        appenders: {
+          file: {
+            log_dir: '/tmp',
+            #log_file: 'foo.log',
+            date_pattern: '%F %T %z',
+            pattern: '[%d] %-5l %c: %m\n'
+          }
+        }
+      }
+    }
+  }
+
+  #
+  # Initialize the OMF runtime.
+  # Options are:
+  #    :communication
+  #      :type
+  #      ... specific opts
+  #    :eventloop
+  #      :type {:em|:local...}
+  #
+  # @param [Hash] opts
+  #
+  def self.init(op_mode, opts = {}, &block)
+    if op_mode && defs = DEFAULTS[op_mode.to_sym]
+      opts = _rec_merge(defs, opts)
+    end
+    if dopts = opts.delete(:daemonize)
+      dopts[:app_name] ||= "#{File.basename($0, File.extname($0))}_daemon"
+      require 'daemons'
+      Daemons.run_proc(dopts[:app_name], dopts) do
+        init(nil, opts, &block)
+      end
+      return
+    end
+
+    if lopts = opts[:logging]
+      _init_logging(lopts) unless lopts.empty?
+    end
+    unless copts = opts[:communication]
+      raise "Missing :communication description"
+    end
+    eopts = opts[:eventloop]
+
+    # Initialise event loop
+    Eventloop.init(eopts)
+    # start eventloop immediately if we received a run block
+    eventloop.run do
+      Comm.init(copts)
+      block.call(eventloop) if block
+    end
+  end
+
+  # Return the communication driver instance
+  #
+  def self.comm()
+    Comm.instance
+  end
+
+  # Return the communication driver instance
+  #
+  def self.eventloop()
+    Eventloop.instance
+  end
+
+  # Load a YAML file and return it as hash.
+  #
+  # options:
+  #   :symbolize_keys FLAG: Symbolize keys if set
+  #   :path:
+  #      :same - Look in the same directory as '$0'
+  #   :remove_root ROOT_NAME: Remove the root node. Throw exception if not ROOT_NAME
+  #   :wait_for_readable SECS: Wait until the yaml file becomes readable. Check every SECS
+  #
+  def self.load_yaml(file_name, opts = {})
+    if path_opt = opts[:path]
+      case path_opt
+      when :same
+        file_name = File.join(File.dirname($0), file_name)
+      else
+        raise "Unknown value '#{path_opt}' for 'path' option"
+      end
+    end
+    if readable_check = opts[:wait_for_readable]
+      while not File.readable?(file_name)
+        puts "WAIT #{file_name}"
+        sleep readable_check # wait until file shows up
+      end
+    end
+    yh = YAML.load_file(file_name)
+    if opts[:symbolize_keys]
+      yh = _rec_sym_keys(yh)
+    end
+    if root = opts[:remove_root]
+      if yh.length != 1 && yh.key?(root)
+        raise "Expected root '#{root}', but found '#{yh.keys.inspect}"
+      end
+      yh = yh.delete(root)
+    end
+    yh
+  end
+
+  # DO NOT CALL DIRECTLY
+  #
+  def self._init_logging(opts = {})
+    logger = Logging.logger.root
+    if appenders = opts[:appenders]
+      logger.clear_appenders
+      appenders.each do |type, topts|
+        case type.to_sym
+        when :stdout
+          $stdout.sync = true
+          logger.add_appenders(
+            Logging.appenders.stdout('custom',
+              :layout => Logging.layouts.pattern(topts)
+          ))
+
+        when :file
+          dir_name = topts.delete(:log_dir) || DEF_LOG_DIR
+          file_name = topts.delete(:log_file) || "#{File.basename($0, File.extname($0))}.log"
+          path = File.join(dir_name, file_name)
+          logger.add_appenders(
+            Logging.appenders.file(path,
+              :layout => Logging.layouts.pattern(topts)
+          ))
+        else
+          raise "Unknown logging appender type '#{type}'"
+        end
+      end
+    end
+    if level = opts[:level]
+      logger.level = level.to_sym
+    end
+  end
+
+  def self._rec_merge(this_hash, other_hash)
+    r = {}
+    this_hash.merge(other_hash) do |key, oldval, newval|
+      r[key] = oldval.is_a?(Hash) ? _rec_merge(oldval, newval) : newval
+    end
+  end
+
+  # Recusively Symbolize keys of hash
+  #
+  def self._rec_sym_keys(hash)
+    h = {}
+    hash.each do |k, v|
+      if v.is_a? Hash
+        v = _rec_sym_keys(v)
+      elsif v.is_a? Array
+        v = v.map {|e| e.is_a?(Hash) ? _rec_sym_keys(e) : e }
+      end
+      h[k.to_sym] = v
+    end
+    h
+  end
+
 end