megam_api 0.100 → 1.5.beta2

data/lib/megam/core/organizations.rb

@@ -15,7 +15,7 @@
 #
 
 module Megam
-  class Organizations < Megam::ServerAPI
+  class Organizations < Megam::RestAdapter
     def initialize(o)
       @id = nil
       @name = nil

data/lib/megam/core/organizations_collection.rb

@@ -101,45 +101,18 @@ module Megam
       @organizations[res]
     end
 
-    # Transform the ruby obj ->  to a Hash
-    def to_hash
-      index_hash = Hash.new
-      self.each do |organizations|
-        index_hash[organizations.name] = organizations.to_s
-      end
-      index_hash
+    def to_s
+        @organizations.join(", ")
+    end
+
+    def for_json
+      to_a.map { |item| item.to_s }
     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)
+      Megam::JSONCompat.to_json(for_json, *a)
     end
 
-=begin
-{
-"json_claz":"Megam::PredefCloudCollection",
-"results":[{
-"id":"NOD362554470640386048",
-"name":"ec2_rails",
-"account_id":"ACT362544229488001024",
-"json_claz":"Megam::PredefCloud",
-"spec":{
-"type_name":"sensor-type",
-"groups":"sens-group",
-"image":"sens-image",
-"flavor":"sens-flvr"
-},
-"access":{
-"ssh_key":"sens-ssh",
-"identity_file":"sens-identity-file",
-"ssh_user":"sens-sshuser"
-},
-"ideal":"",
-"performance":""
-}]
-}
-=end
     def self.json_create(o)
       collection = self.new()
       o["results"].each do |organizations_list|
@@ -159,10 +132,5 @@ module Megam
       end
       true
     end
-
-    def to_s
-      Megam::Stuff.styled_hash(to_hash)
-    end
-
   end
-end
+end

data/lib/megam/core/promos.rb

@@ -14,7 +14,7 @@
 ## limitations under the License.
 ##
 module Megam
-  class Promos < Megam::ServerAPI
+  class Promos < Megam::RestAdapter
     def initialize(email=nil, api_key=nil, host=nil)
       @id = nil
       @code = nil

data/lib/megam/core/request.rb

@@ -14,7 +14,7 @@
 # limitations under the License.
 #
 module Megam
-  class Request < Megam::ServerAPI
+  class Request < Megam::RestAdapter
     def initialize(params)
       @id = nil
       @cat_id = nil

data/lib/megam/core/request_collection.rb

@@ -101,21 +101,17 @@ module Megam
       @requests[res]
     end
 
-    # Transform the ruby obj ->  to a Hash
-    def to_hash
-      index_hash = Hash.new
-      self.each do |request|
-        index_hash[request.node_name] = request.to_s
-      end
-      index_hash
+    def to_s
+        @requests.join(", ")
     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)
+    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()
@@ -136,10 +132,5 @@ module Megam
       end
       true
     end
-
-    def to_s
-      Megam::Stuff.styled_hash(to_hash)
-    end
-
   end
 end

data/lib/megam/core/rest_adapter.rb

@@ -0,0 +1,54 @@
+# Copyright:: Copyright (c) 2013-2016 Megam Systems
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module Megam
+    class RestAdapter
+        attr_reader :email
+        attr_reader :api_key
+        attr_reader :host
+        attr_reader :password
+        attr_reader :org_id
+        attr_reader :headers
+
+
+        ## clean up this module later.
+        def initialize(o)
+            @email = o[:email]
+            @api_key = o[:api_key] || nil
+            @host = o[:host]
+            @password = o[:password] || nil
+            @org_id = o[:org_id]
+            @headers = o[:headers]
+        end
+
+        # Build a megam api client
+        #
+        # === Parameters
+        # api:: The Megam::API client
+        def megam_rest
+            options = {
+              :email => email,
+              :api_key => api_key,
+              :org_id => org_id,
+              :password => password,
+              :host => host
+            }
+            if headers
+              options[:headers] = headers
+            end
+            Megam::API.new(options)
+        end
+    end
+end

data/lib/megam/core/sensors.rb

@@ -15,7 +15,7 @@
 #
 
 module Megam
-  class Sensors < Megam::ServerAPI
+  class Sensors < Megam::RestAdapter
     def initialize(email = nil, api_key = nil, host = nil)
       @id = nil
       @sensor_type = nil

data/lib/megam/core/sensors_collection.rb

@@ -101,19 +101,16 @@ module Megam
       @sensors[res]
     end
 
-    # Transform the ruby obj ->  to a Hash
-    def to_hash
-      index_hash = {}
-      each do |sensors|
-        index_hash[sensors.id] = sensors.to_s
-      end
-      index_hash
+    def to_s
+        @sensors.join(", ")
+    end
+
+    def for_json
+      to_a.map { |item| item.to_s }
     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)
+      Megam::JSONCompat.to_json(for_json, *a)
     end
 
     def self.json_create(o)
@@ -135,9 +132,5 @@ module Megam
       end
       true
     end
-
-    def to_s
-      Megam::Stuff.styled_hash(to_hash)
-    end
   end
 end

data/lib/megam/core/sshkey.rb

@@ -14,7 +14,7 @@
 # limitations under the License.
 #
 module Megam
-  class SshKey < Megam::ServerAPI
+  class SshKey < Megam::RestAdapter
     def initialize(o)
       @id = nil
       @name = nil

data/lib/megam/core/sshkey_collection.rb

@@ -14,131 +14,124 @@
 # limitations under the License.
 #
 module Megam
-  class SshKeyCollection
-    include Enumerable
-
-    attr_reader :iterator
-    def initialize
-      @sshkeys = Array.new
-      @sshkeys_by_name = Hash.new
-      @insert_after_idx = nil
-    end
+    class SshKeyCollection
+        include Enumerable
 
-    def all_sshkeys
-      @sshkeys
-    end
+        attr_reader :iterator
 
-    def [](index)
-      @sshkeys[index]
-    end
+        def initialize
+            @sshkeys = Array.new
+            @sshkeys_by_name = Hash.new
+            @insert_after_idx = nil
+        end
 
-    def []=(index, arg)
-      is_megam_sshkeys(arg)
-      @sshkeys[index] = arg
-      @sshkeys_by_name[arg.name] = index
-    end
+        def all_sshkeys
+            @sshkeys
+        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
+        def [](index)
+            @sshkeys[index]
+        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
+        def []=(index, arg)
+            is_megam_sshkeys(arg)
+            @sshkeys[index] = arg
+            @sshkeys_by_name[arg.name] = index
         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 <<(*args)
+            args.flatten.each do |a|
+                is_megam_sshkeys(a)
+                @sshkeys << a
+                @sshkeys_by_name[a.name] =@sshkeys.length - 1
+            end
+            self
+        end
 
-    def each_index
-      @sshkeys.each_index do |i|
-        yield i
-      end
-    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 empty?
-      @sshkeys.empty?
-    end
+        def each
+            @sshkeys.each do |sshkeys|
+                yield sshkeys
+            end
+        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 each_index
+            @sshkeys.each_index do |i|
+                yield i
+            end
+        end
 
-    # Transform the ruby obj ->  to a Hash
-    def to_hash
-      index_hash = Hash.new
-      self.each do |sshkeys|
-        index_hash[sshkeys.name] = sshkeys.to_s
-      end
-      index_hash
-    end
+        def empty?
+            @sshkeys.empty?
+        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 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 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)
+        def to_s
+            @sshkeys.join(", ")
         end
-      end
-      collection
-    end
 
-    private
+        def for_json
+            to_a.map { |item| item.to_s }
+        end
 
-    def is_megam_sshkeys(arg)
-      unless arg.kind_of?(Megam::SshKey)
-        raise ArgumentError, "Members must be Megam::SshKeys's"
-      end
-      true
-    end
+        def to_json(*a)
+            Megam::JSONCompat.to_json(for_json, *a)
+        end
 
-    def to_s
-      Megam::Stuff.styled_hash(to_hash)
-    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
 
-  end
-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