virtengine_api 0.1.0

data/lib/megam/core/snapshots_collection.rb

@@ -0,0 +1,122 @@
+module Megam
+  class SnapshotsCollection
+    include Enumerable
+
+    attr_reader :iterator
+    def initialize
+      @snapshots = Array.new
+      @snapshots_by_name = Hash.new
+      @insert_after_idx = nil
+    end
+
+    def all_snapshots
+      @snapshots
+    end
+
+    def [](index)
+      @snapshots[index]
+    end
+
+    def []=(index, arg)
+      is_megam_snapshots(arg)
+      @snapshots[index] = arg
+      @snapshots_by_name[arg.account_id] = index
+    end
+
+    def <<(*args)
+      args.flatten.each do |a|
+        is_megam_snapshots(a)
+        @snapshots << a
+        @snapshots_by_name[a.account_id] = @snapshots.length - 1
+      end
+      self
+    end
+
+    # 'push' is an alias method to <<
+    alias_method :push, :<<
+
+    def insert(snapshots)
+      is_megam_snapshots(snapshots)
+      if @insert_after_idx
+        # in the middle of executing a run, so any nodes inserted now should
+        # be placed after the most recent addition done by the currently executing
+        # node
+        @snapshots.insert(@insert_after_idx + 1, snapshots)
+        # update name -> location mappings and register new node
+        @snapshots_by_name.each_key do |key|
+        @snapshots_by_name[key] += 1 if @snapshots_by_name[key] > @insert_after_idx
+        end
+        @snapshots_by_name[snapshots.account_id] = @insert_after_idx + 1
+        @insert_after_idx += 1
+      else
+      @snapshots << snapshots
+      @snapshots_by_name[snapshots.account_id] = @snapshots.length - 1
+      end
+    end
+
+    def each
+      @snapshots.each do |snapshots|
+        yield snapshots
+      end
+    end
+
+    def each_index
+      @snapshots.each_index do |i|
+        yield i
+      end
+    end
+
+    def empty?
+      @snapshots.empty?
+    end
+
+    def lookup(snapshots)
+      lookup_by = nil
+      if events.kind_of?(Megam::Snapshots)
+      lookup_by = snapshots.account_id
+    elsif snapshots.kind_of?(String)
+      lookup_by = snapshots
+      else
+        raise ArgumentError, "Must pass a Megam::Snapshots or String to lookup"
+      end
+      res = @snapshots_by_name[lookup_by]
+      unless res
+        raise ArgumentError, "Cannot find a node matching #{lookup_by} (did you define it first?)"
+      end
+      @snapshots[res]
+    end
+
+    def to_s
+        @snapshots.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 = self.new()
+      o["results"].each do |snapshots_list|
+        snapshots_array = snapshots_list.kind_of?(Array) ? snapshots_list : [ snapshots_list ]
+        snapshots_array.each do |snapshots|
+          collection.insert(snapshots)
+
+        end
+      end
+      collection
+    end
+
+    private
+
+    def is_megam_snapshots(arg)
+      unless arg.kind_of?(Megam::Snapshots)
+        raise ArgumentError, "Members must be Megam::Snapshots's"
+      end
+      true
+    end
+  end
+end

data/lib/megam/core/sshkey.rb

@@ -0,0 +1,173 @@
+module Megam
+    class SshKey < Megam::RestAdapter
+        def initialize(o)
+            @id = nil
+            @name = nil
+            @org_id = nil
+            @privatekey=nil
+            @publickey=nil
+            @created_at = nil
+            @some_msg = {}
+            super(o)
+        end
+
+        def sshkey
+            self
+        end
+
+        def id(arg=nil)
+            if arg != nil
+                @id = arg
+            else
+                @id
+            end
+        end
+
+        def name(arg=nil)
+            if arg != nil
+                @name = arg
+            else
+                @name
+            end
+        end
+
+        def org_id(arg=nil)
+            if arg != nil
+                @org_id= arg
+            else
+                @org_id
+            end
+        end
+
+        def privatekey(arg=nil)
+            if arg != nil
+                @privatekey = arg
+            else
+                @privatekey
+            end
+        end
+
+        def publickey(arg=nil)
+            if arg != nil
+                @publickey = arg
+            else
+                @publickey
+            end
+        end
+
+
+        def created_at(arg=nil)
+            if arg != nil
+                @created_at = arg
+            else
+                @created_at
+            end
+        end
+
+        def some_msg(arg=nil)
+            if arg != nil
+                @some_msg = arg
+            else
+                @some_msg
+            end
+        end
+
+        def error?
+            crocked  = true if (some_msg.has_key?(:msg_type) && some_msg[:msg_type] == "error")
+        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["name"] = name
+            index_hash["org_id"] = org_id
+            index_hash["privatekey"] = privatekey
+            index_hash["publickey"] = publickey
+            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,
+                "name" => name,
+                "org_id" => org_id,
+                "privatekey" => privatekey,
+                "publickey" => publickey,
+                "created_at" => created_at
+            }
+            result
+        end
+
+        #
+        def self.json_create(o)
+            sshKey = new({})
+            sshKey.id(o["id"]) if o.has_key?("id")
+            sshKey.name(o["name"]) if o.has_key?("name")
+            sshKey.privatekey(o["privatekey"]) if o.has_key?("privatekey")
+            sshKey.publickey(o["publickey"]) if o.has_key?("publickey")
+            sshKey.created_at(o["created_at"]) if o.has_key?("created_at")
+            #success or error
+            sshKey.some_msg[:code] = o["code"] if o.has_key?("code")
+            sshKey.some_msg[:msg_type] = o["msg_type"] if o.has_key?("msg_type")
+            sshKey.some_msg[:msg]= o["msg"] if o.has_key?("msg")
+            sshKey.some_msg[:links] = o["links"] if o.has_key?("links")
+            sshKey
+        end
+
+        def self.from_hash(o)
+            sshKey = self.new(o)
+            sshKey.from_hash(o)
+            sshKey
+        end
+
+        def from_hash(o)
+            @id        = o[:id] if o.has_key?(:id)
+            @name = o[:name] if o.has_key?(:name)
+            @org_id = o[:org_id] if o.has_key?(:org_id)
+            @privatekey = o[:privatekey] if o.has_key?(:privatekey)
+            @publickey = o[:publickey] if o.has_key?(:publickey)
+            @created_at   = o[:created_at] if o.has_key?(:created_at)
+            self
+        end
+
+        def self.create(params)
+            acct = from_hash(params)
+            acct.create
+        end
+
+        # Create the predef via the REST API
+        def create
+            megam_rest.post_sshkey(to_hash)
+        end
+
+        # Load all sshkeys -
+        # returns a sshkeysCollection
+        # don't return self. check if the Megam::SshKeyCollection is returned.
+        def self.list(params)
+            sshKey = self.new(params)
+            sshKey.megam_rest.get_sshkeys
+        end
+
+        # Show a particular sshKey by name,
+        # Megam::SshKey
+        def self.show(params)
+            pre = self.new(params)
+            pre.megam_rest.get_sshkey(params["name"])
+        end
+
+        def to_s
+            Megam::Stuff.styled_hash(to_hash)
+            #"---> Megam::Account:[error=#{error?}]\n"+
+        end
+
+    end
+end

data/lib/megam/core/sshkey_collection.rb

@@ -0,0 +1,122 @@
+module Megam
+    class SshKeyCollection
+        include Enumerable
+
+        attr_reader :iterator
+
+        def initialize
+            @sshkeys = Array.new
+            @sshkeys_by_name = Hash.new
+            @insert_after_idx = nil
+        end
+
+        def all_sshkeys
+            @sshkeys
+        end
+
+        def [](index)
+            @sshkeys[index]
+        end
+
+        def []=(index, arg)
+            is_megam_sshkeys(arg)
+            @sshkeys[index] = arg
+            @sshkeys_by_name[arg.name] = index
+        end
+
+        def <<(*args)
+            args.flatten.each do |a|
+                is_megam_sshkeys(a)
+                @sshkeys << a
+                @sshkeys_by_name[a.name] =@sshkeys.length - 1
+            end
+            self
+        end
+
+        # 'push' is an alias method to <<
+        alias_method :push, :<<
+
+        def insert(sshkeys)
+            is_megam_sshkeys(sshkeys)
+            if @insert_after_idx
+                # in the middle of executing a run, so any sshkeys inserted now should
+                # be placed after the most recent addition done by the currently executing
+                # sshkey
+                @sshkeys.insert(@insert_after_idx + 1, sshkeys)
+                # update name -> location mappings and register new sshkeys
+                @sshkeys_by_name.each_key do |key|
+                    @sshkeys_by_name[key] += 1 if@sshkeys_by_name[key] > @insert_after_idx
+                end
+                @sshkeys_by_name[sshkeys.name] = @insert_after_idx + 1
+                @insert_after_idx += 1
+            else
+                @sshkeys << sshkeys
+                @sshkeys_by_name[sshkeys.name] =@sshkeys.length - 1
+            end
+        end
+
+        def each
+            @sshkeys.each do |sshkeys|
+                yield sshkeys
+            end
+        end
+
+        def each_index
+            @sshkeys.each_index do |i|
+                yield i
+            end
+        end
+
+        def empty?
+            @sshkeys.empty?
+        end
+
+        def lookup(sshkeys)
+            lookup_by = nil
+            if sshkeys.kind_of?(Megam::SshKey)
+                lookup_by = sshkeys.name
+            elsif sshkeys.kind_of?(String)
+                lookup_by = sshkeys
+            else
+                raise ArgumentError, "Must pass a Megam::sshkeys or String to lookup"
+            end
+            res =@sshkeys_by_name[lookup_by]
+            unless res
+                raise ArgumentError, "Cannot find a sshkeys matching #{lookup_by} (did you define it first?)"
+            end
+            @sshkeys[res]
+        end
+
+        def to_s
+            @sshkeys.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 = self.new()
+            o["results"].each do |sshkeys_list|
+                sshkeys_array = sshkeys_list.kind_of?(Array) ? sshkeys_list : [ sshkeys_list ]
+                sshkeys_array.each do |sshkeys|
+                    collection.insert(sshkeys)
+                end
+            end
+            collection
+        end
+
+        private
+
+        def is_megam_sshkeys(arg)
+            unless arg.kind_of?(Megam::SshKey)
+                raise ArgumentError, "Members must be Megam::SshKeys's"
+            end
+            true
+        end
+    end
+end

data/lib/megam/core/stuff.rb

@@ -0,0 +1,22 @@
+module Megam
+    module Stuff
+        extend self
+        def has_git?
+            %x{ git --version }
+            $?.success?
+        end
+
+        def git(args)
+            return "" unless has_git?
+            flattened_args = [args].flatten.compact.join(" ")
+            %x{ git #{flattened_args} 2>&1 }.strip
+        end
+
+        #
+        #left justified keyed hash with newlines.
+        def styled_hash(hash)
+            hash.map{|k,v| "#{k.ljust(15)}=#{v}"}.join("\n")
+        end
+
+    end
+end

data/lib/megam/core/subscriptions.rb

@@ -0,0 +1,167 @@
+module Megam
+    class Subscriptions < Megam::RestAdapter
+        def initialize(o)
+            @id = nil
+            @account_id = nil
+            @model = nil
+            @license = nil
+            @trial_ends = nil
+            @created_at = nil
+            @some_msg = {}
+            super(o)
+        end
+
+        def subscriptions
+            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 model(arg=nil)
+            if arg != nil
+                @model = arg
+            else
+                @model
+            end
+        end
+
+        def license(arg=nil)
+            if arg != nil
+                @license= arg
+            else
+                @license
+            end
+        end
+
+        def trial_ends(arg=nil)
+            if arg != nil
+                @trial_ends = arg
+            else
+                @trial_ends
+            end
+        end
+
+        def created_at(arg=nil)
+            if arg != nil
+                @created_at = arg
+            else
+                @created_at
+            end
+        end
+
+        def some_msg(arg=nil)
+            if arg != nil
+                @some_msg = arg
+            else
+                @some_msg
+            end
+        end
+
+        def error?
+            crocked  = true if (some_msg.has_key?(:msg_type) && some_msg[:msg_type] == "error")
+        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["model"] = model
+            index_hash["license"] = license
+            index_hash["trial_ends"] = trial_ends
+            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,
+                "account_id" => account_id,
+                "model" => model,
+                "license" => license,
+                "trial_ends" => trial_ends,
+                "created_at" => created_at
+            }
+            result
+        end
+
+        #
+        def self.json_create(o)
+            sbs = new({})
+            sbs.id(o["id"]) if o.has_key?("id")
+            sbs.account_id(o["account_id"]) if o.has_key?("account_id")
+            sbs.model(o["model"]) if o.has_key?("model")
+            sbs.license(o["license"]) if o.has_key?("license")
+            sbs.trial_ends(o["trial_ends"]) if o.has_key?("trial_ends")
+            sbs.created_at(o["created_at"]) if o.has_key?("created_at")
+            #success or error
+            sbs.some_msg[:code] = o["code"] if o.has_key?("code")
+            sbs.some_msg[:msg_type] = o["msg_type"] if o.has_key?("msg_type")
+            sbs.some_msg[:msg]= o["msg"] if o.has_key?("msg")
+            sbs.some_msg[:links] = o["links"] if o.has_key?("links")
+            sbs
+        end
+
+        def self.from_hash(o,tmp_email=nil, tmp_api_key=nil, tmp_host=nil)
+            sbs = self.new(tmp_email, tmp_api_key, tmp_host)
+            sbs.from_hash(o)
+            sbs
+        end
+
+        def from_hash(o)
+            @id        = o[:id] if o.has_key?(:id)
+            @account_id = o[:account_id] if o.has_key?(:account_id)
+            @model     = o[:model] if o.has_key?(:model)
+            @license   = o[:license] if o.has_key?(:license)
+            @trial_ends   = o[:trial_ends] if o.has_key?(:trial_ends)
+            @created_at   = o[:created_at] if o.has_key?(:created_at)
+            self
+        end
+
+        def self.create(o,tmp_email=nil, tmp_api_key=nil, tmp_host=nil)
+            acct = from_hash(o,tmp_email, tmp_api_key, tmp_host)
+            acct.create
+        end
+
+        # Create the subscriptions via the REST API
+        def create
+            megam_rest.post_subscriptions(to_hash)
+        end
+
+        # Load all subscriptions -
+        # returns a SubscriptionsCollection
+        # don't return self. check if the Megam::SubscriptionsCollection is returned.
+
+        def self.show(p_name,tmp_email=nil, tmp_api_key=nil, tmp_host=nil)
+            pre = self.new(tmp_email,tmp_api_key, tmp_host)
+            pre.megam_rest.get_subscription
+        end
+
+
+        def to_s
+            Megam::Stuff.styled_hash(to_hash)
+        end
+
+    end
+end