virtengine_api 0.1.0

data/lib/megam/core/sensors.rb

@@ -0,0 +1,141 @@
+module Megam
+    class Sensors < Megam::RestAdapter
+        def initialize(email = nil, api_key = nil, host = nil)
+            @id = nil
+            @sensor_type = nil
+            @payload = {}
+            @created_at = nil
+            super(email, api_key, host)
+        end
+
+        def sensors
+            self
+        end
+
+        def id(arg = nil)
+            if !arg.nil?
+                @id = arg
+            else
+                @id
+            end
+        end
+
+        def sensor_type(arg = nil)
+            if !arg.nil?
+                @sensor_type = arg
+            else
+                @sensor_type
+            end
+        end
+
+        def payload(arg = nil)
+            if !arg.nil?
+                @payload = arg
+            else
+                @payload
+            end
+        end
+
+        def created_at(arg = nil)
+            if !arg.nil?
+                @created_at = arg
+            else
+                @created_at
+            end
+        end
+
+        def error?
+            crocked = true if some_msg.key?(:msg_type) && some_msg[:msg_type] == 'error'
+        end
+
+        # Transform the ruby obj ->  to a Hash
+        def to_hash
+            index_hash = {}
+            index_hash['json_claz'] = self.class.name
+            index_hash['id'] = id
+
+            index_hash['sensor_type'] = sensor_type
+            index_hash['payload'] = payload
+            index_hash['created_at'] = created_at
+            index_hash
+        end
+
+        # Serialize this object as a hash: called from JsonCompat.
+        # Verify if this called from JsonCompat during testing.
+        def to_json(*a)
+            for_json.to_json(*a)
+        end
+
+        def for_json
+            result = {
+                'id' => id,
+                'sensor_type' => sensor_type,
+                'payload' => payload,
+                'created_at' => created_at
+            }
+            result
+        end
+
+        def self.json_create(o)
+            asm = new
+            asm.id(o['id']) if o.key?('id')
+            asm.sensor_type(o['sensor_type']) if o.key?('sensor_type')
+            asm.payload(o['payload']) if o.key?('payload')
+            asm.created_at(o['created_at']) if o.key?('created_at')
+            asm
+        end
+
+        def self.from_hash(o, tmp_email = nil, tmp_api_key = nil, tmp_host = nil)
+            asm = new(tmp_email, tmp_api_key, tmp_host)
+            asm.from_hash(o)
+            asm
+        end
+
+        def from_hash(o)
+            @id = o['id'] if o.key?('id')
+            @sensor_type = o['sensor_type'] if o.key?('sensor_type')
+            @payload = o['payload'] if o.key?('payload')
+            @created_at = o['created_at'] if o.key?('created_at')
+            self
+        end
+
+        def self.create(params)
+            sensors = from_hash(params, params['email'], params['api_key'], params['host'])
+            sensors.create
+        end
+
+        # Load a account by email_p
+        def self.show(params)
+            sensors = new(params['email'], params['api_key'], params['host'])
+            sensors.megam_rest.get_sensor(params['id'])
+        end
+
+        def self.list(params)
+            sensors = self.new(params["email"], params["api_key"], params["host"])
+            sensors.megam_rest.get_sensors
+        end
+
+        def self.update(params)
+            sensors = from_hash(params, params['email'] || params[:email], params['api_key'] || params[:api_key], params['host'] || params[:host])
+            sensors.update
+        end
+
+        def self.list(o)
+            app = self.new(o["email"], o["api_key"], o["host"])
+            app.megam_rest.get_sensors
+        end
+
+        # Create the node via the REST API
+        def update
+            megam_rest.update_(to_hash)
+        end
+
+        def create
+            megam_rest.post_sensors(to_hash)
+        end
+
+        def to_s
+            Megam::Stuff.styled_hash(to_hash)
+        end
+    end
+end

data/lib/megam/core/sensors_collection.rb

@@ -0,0 +1,121 @@
+module Megam
+  class SensorsCollection
+    include Enumerable
+
+    attr_reader :iterator
+    def initialize
+      @sensors = []
+      @sensors_by_name = {}
+      @insert_after_idx = nil
+    end
+
+    def all_sensor
+      @sensors
+    end
+
+    def [](index)
+      @sensors[index]
+    end
+
+    def []=(index, arg)
+      is_megam_sensors(arg)
+      @sensors[index] = arg
+      @sensors_by_name[arg.id] = index
+    end
+
+    def <<(*args)
+      args.flatten.each do |a|
+        is_megam_sensors(a)
+        @sensors << a
+        @sensors_by_name[a.id] = @sensors.length - 1
+      end
+      self
+    end
+
+    # 'push' is an alias method to <<s
+    alias_method :push, :<<
+
+    def insert(sensors)
+      is_megam_sensors(sensors)
+      if @insert_after_idx
+        # in the middle of executing a run, so any predefs inserted now should
+        # be placed after the most recent addition done by the currently executing
+        # sensors
+        @sensors.insert(@insert_after_idx + 1, sensors)
+        # update name -> location mappings and register new sensors
+        @sensors_by_name.each_key do |key|
+          @sensors_by_name[key] += 1 if@sensors_by_name[key] > @insert_after_idx
+        end
+        @sensors_by_name[sensors.id] = @insert_after_idx + 1
+        @insert_after_idx += 1
+      else
+        @sensors << sensors
+        @sensors_by_name[sensors.id] = @sensors.length - 1
+      end
+    end
+
+    def each
+      @sensors.each do |sensors|
+        yield sensors
+      end
+    end
+
+    def each_index
+      @sensors.each_index do |i|
+        yield i
+      end
+    end
+
+    def empty?
+      @sensors.empty?
+    end
+
+    def lookup(sensors)
+      lookup_by = nil
+      if sensors.is_a?(Megam.sensors)
+        lookup_by = sensors.id
+      elsif sensors.is_a?(String)
+        lookup_by = sensors
+      else
+        fail ArgumentError, 'Must pass a Megam::sensors or String to lookup'
+      end
+      res = @sensors_by_name[lookup_by]
+      unless res
+        fail ArgumentError, "Cannot find a sensors matching #{lookup_by} (did you define it first?)"
+      end
+      @sensors[res]
+    end
+
+    def to_s
+        @sensors.join(", ")
+    end
+
+    def for_json
+      to_a.map { |item| item.to_s }
+    end
+
+    def to_json(*a)
+      Megam::JSONCompat.to_json(for_json, *a)
+    end
+
+    def self.json_create(o)
+      collection = new
+      o['results'].each do |sensors_list|
+        sensors_array = sensors_list.is_a?(Array) ? sensors_list : [sensors_list]
+        sensors_array.each do |sensors|
+          collection.insert(sensors)
+        end
+      end
+      collection
+    end
+
+    private
+
+    def is_megam_sensors(arg)
+      unless arg.is_a?(Megam::Sensors)
+        fail ArgumentError, "Members must be Megam::sensors's"
+      end
+      true
+    end
+  end
+end

data/lib/megam/core/snapshots.rb

@@ -0,0 +1,268 @@
+module Megam
+    class Snapshots < Megam::RestAdapter
+        def initialize(o)
+            @id = nil
+            @account_id = nil
+            @asm_id = nil
+            @org_id = nil
+            @tosca_type = nil
+            @inputs = []
+            @outputs = []
+            @name= nil
+            @status=nil
+            @disk_id=nil
+            @snap_id=nil
+            @created_at = nil
+            @updated_at = nil
+            @some_msg = {}
+            super(o)
+        end
+
+        def snapshots
+            self
+        end
+        def id(arg=nil)
+            if arg != nil
+                @id = arg
+            else
+                @id
+            end
+        end
+
+        def account_id(arg=nil)
+            if arg != nil
+                @account_id = arg
+            else
+                @account_id
+            end
+        end
+
+        def asm_id(arg=nil)
+            if arg != nil
+                @asm_id = arg
+            else
+                @asm_id
+            end
+        end
+
+        def org_id(arg=nil)
+            if arg != nil
+                @org_id = arg
+            else
+                @org_id
+            end
+        end
+
+        def tosca_type(arg = nil)
+            if !arg.nil?
+                @tosca_type = arg
+            else
+                @tosca_type
+            end
+        end
+
+        def inputs(arg = [])
+            if arg != []
+                @inputs = arg
+            else
+                @inputs
+            end
+        end
+
+        def outputs(arg = [])
+            if arg != []
+                @outputs = arg
+            else
+                @outputs
+            end
+        end
+
+        def name(arg=nil)
+            if arg != nil
+                @name = arg
+            else
+                @name
+            end
+        end
+
+        def status(arg=nil)
+            if arg != nil
+                @status = arg
+            else
+                @status
+            end
+        end
+
+        def disk_id(arg=nil)
+            if arg != nil
+                @disk_id = arg
+            else
+                @disk_id
+            end
+        end
+
+        def snap_id(arg=nil)
+            if arg != nil
+                @snap_id = arg
+            else
+                @snap_id
+            end
+        end
+
+        def created_at(arg=nil)
+            if arg != nil
+                @created_at = arg
+            else
+                @created_at
+            end
+        end
+
+         def updated_at(arg=nil)
+            if arg != nil
+                @updated_at = arg
+            else
+                @updated_at
+            end
+        end
+
+        def error?
+            crocked  = true if (some_msg.has_key?(:msg_type) && some_msg[:msg_type] == "error")
+        end
+
+
+        def some_msg(arg=nil)
+            if arg != nil
+                @some_msg = arg
+            else
+                @some_msg
+            end
+        end
+
+
+        # Transform the ruby obj ->  to a Hash
+        def to_hash
+            index_hash = Hash.new
+            index_hash["json_claz"] = self.class.name
+            index_hash["id"] = id
+            index_hash["account_id"] = account_id
+            index_hash["asm_id"] = asm_id
+            index_hash["org_id"] = org_id
+            index_hash["tosca_type"] = tosca_type
+            index_hash["inputs"] = inputs
+            index_hash["outputs"] = outputs
+            index_hash["name"] = name
+            index_hash["status"] = status
+            index_hash["disk_id"] = disk_id
+            index_hash["snap_id"] = snap_id
+            index_hash["created_at"] = created_at
+            index_hash["updated_at"] = updated_at
+            index_hash["some_msg"] = some_msg
+            index_hash
+        end
+
+        # Serialize this object as a hash: called from JsonCompat.
+        # Verify if this called from JsonCompat during testing.
+        def to_json(*a)
+            for_json.to_json(*a)
+        end
+
+        def for_json
+            result = {
+              "id" => id,
+                "account_id" => account_id,
+                "asm_id" => asm_id,
+                "org_id" => org_id,
+                "tosca_type" => tosca_type,
+                "inputs" => inputs,
+                "outputs" => outputs,
+                "name" => name,
+                "status" => status,
+                "disk_id" => disk_id,
+                "snap_id" => snap_id,
+                "created_at" => created_at,
+                "updated_at" => updated_at
+            }
+            result
+        end
+
+        def self.json_create(o)
+            sps = new({})
+            sps.id(o["id"]) if o.has_key?("id")
+            sps.account_id(o["account_id"]) if o.has_key?("account_id")
+            sps.asm_id(o["asm_id"]) if o.has_key?("asm_id")
+            sps.org_id(o["org_id"]) if o.has_key?("org_id") #this will be an array? can hash store array?
+            sps.tosca_type(o['tosca_type']) if o.key?('tosca_type')
+            sps.inputs(o['inputs']) if o.key?('inputs')
+            sps.outputs(o['outputs']) if o.key?('outputs')
+            sps.name(o["name"]) if o.has_key?("name")
+            sps.status(o["status"]) if o.has_key?("status")
+            sps.disk_id(o["disk_id"]) if o.has_key?("disk_id")
+            sps.snap_id(o["snap_id"]) if o.has_key?("snap_id")
+            sps.created_at(o["created_at"]) if o.has_key?("created_at")
+            sps.created_at(o["updated_at"]) if o.has_key?("updated_at")
+            sps.some_msg[:code] = o["code"] if o.has_key?("code")
+            sps.some_msg[:msg_type] = o["msg_type"] if o.has_key?("msg_type")
+            sps.some_msg[:msg]= o["msg"] if o.has_key?("msg")
+            sps.some_msg[:links] = o["links"] if o.has_key?("links")
+            sps
+        end
+
+        def self.from_hash(o)
+            sps = self.new(o)
+            sps.from_hash(o)
+            sps
+        end
+
+        def from_hash(o)
+            @id       = o[:id] if o.has_key?(:id)
+            @account_id       = o[:account_id] if o.has_key?(:account_id)
+            @asm_id        = o[:asm_id] if o.has_key?(:asm_id)
+            @org_id        = o[:org_id] if o.has_key?(:org_id)
+            @tosca_type        = o[:tosca_type] if o.key?(:tosca_type)
+            @inputs            = o[:inputs] if o.key?(:inputs)
+            @outputs           = o[:outputs] if o.key?(:outputs)
+            @name            = o[:name] if o.has_key?(:name)
+            @status            = o[:status] if o.has_key?(:status)
+            @disk_id          = o[:disk_id] if o.has_key?(:disk_id)
+            @snap_id          = o[:snap_id] if o.has_key?(:snap_id)
+            @created_at        = o[:created_at] if o.has_key?(:created_at)
+            @updated_at        = o[:updated_at] if o.has_key?(:updated_at)
+            self
+        end
+
+        def self.create(params)
+            sps = from_hash(params)
+            sps.create
+        end
+
+        def self.update(params)
+            sps = from_hash(params)
+            sps.update
+        end
+
+        # Create the node via the REST API
+        def create
+            megam_rest.post_snapshots(to_hash)
+        end
+
+        # Load a account by email_p
+        def self.show(o)
+            sps = self.new(o)
+            sps.megam_rest.get_snapshots(o[:id])
+        end
+
+        def self.list(params)
+            sps = self.new(params)
+            sps.megam_rest.list_snapshots
+        end
+
+        def update
+            megam_rest.update_snapshots(to_hash)
+        end
+
+        def to_s
+            Megam::Stuff.styled_hash(to_hash)
+        end
+
+    end
+end