megam_api 0.1.0

data/lib/megam/core/boltreqs_collection.rb

@@ -0,0 +1,148 @@
+# Copyright:: Copyright (c) 2012, 2013 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 boltlicable 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 BoltreqsCollection
+    include Enumerable
+
+    
+    attr_reader :iterator
+    def initialize
+      @boltreqs = Array.new
+      @boltreqs_by_name = Hash.new
+      @insert_after_idx = nil
+    end
+
+    def all_boltreqs
+      @boltreqs
+    end
+
+    def [](index)
+      @boltreqs[index]
+    end
+
+    def []=(index, arg)
+      is_megam_boltreq(arg)
+      @boltreqs[index] = arg
+      @boltreqs_by_name[arg.id] = index
+    end
+
+    def <<(*args)
+      args.flatten.each do |a|
+        is_megam_boltreq(a)
+        @boltreqs << a
+        @boltreqs_by_name[a.id] = @boltreqs.length - 1
+      end
+      self
+    end
+
+    # 'push' is an alias method to <<
+    alias_method :push, :<<
+
+    def insert(boltreq)
+      is_megam_boltreq(boltreq)
+      if @insert_after_idx
+        # in the middle of executing a run, so any boltreqss inserted now should
+        # be placed after the most recent addition done by the currently executing
+        # boltreqs
+        @boltreqs.insert(@insert_after_idx + 1, boltreq)
+        # update name -> location mboltings and register new boltreqs
+        @boltreqs_by_name.each_key do |key|
+        @boltreqs_by_name[key] += 1 if @boltreqs_by_name[key] > @insert_after_idx
+        end
+        @boltreqs_by_name[boltreq.id] = @insert_after_idx + 1
+        @insert_after_idx += 1
+      else
+      @boltreqs << boltreq
+      @boltreqs_by_name[boltreq.id] = @boltreqs.length - 1 
+      end
+    end
+
+    def each
+      @boltreqs.each do |boltreq|
+        yield boltreq
+      end
+    end
+
+    def each_index
+      @boltreqs.each_index do |i|
+        yield i
+      end
+    end
+
+    def empty?
+      @boltreqs.empty?
+    end
+
+    def lookup(boltreq)
+      lookup_by = nil
+      if boltreq.kind_of?(Megam::Boltreqs)
+      lookup_by = boltreq.id
+      elsif boltreq.kind_of?(String)
+      lookup_by = boltreq
+      else
+        raise ArgumentError, "Must pass a Megam::Boltreqs or String to lookup"
+      end
+      res = @boltreqs_by_name[lookup_by]
+      unless res
+        raise ArgumentError, "Cannot find a boltreq matching #{lookup_by} (did you define it first?)"
+      end
+      @boltreqs[res]
+    end
+    
+     # Transform the ruby obj ->  to a Hash
+    def to_hash
+      index_hash = Hash.new
+      self.each do |boltreq|
+        index_hash[boltreq.id] = boltreq.to_s
+      end
+      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 self.json_create(o)
+      collection = self.new()
+      o["results"].each do |boltreqs_list|
+       boltreqs_array = boltreqs_list.kind_of?(Array) ? boltreqs_list : [ boltreqs_list ]
+        boltreqs_array.each do |boltreq|
+          collection.insert(boltreq)
+        end
+      end
+      collection
+    end
+
+    private
+
+    
+    
+    def is_megam_boltreq(arg)
+      unless arg.kind_of?(Megam::Boltreqs)
+        raise ArgumentError, "Members must be Megam::Boltreq's"
+      end
+      true
+    end
+
+    def to_s
+      Megam::Stuff.styled_hash(to_hash)
+    end
+
+  end
+end

data/lib/megam/core/cloudinstruction.rb

@@ -0,0 +1,110 @@
+# Copyright:: Copyright (c) 2012, 2013 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 CloudInstruction
+    def initialize
+      @action = nil
+      @command = nil
+      @name = nil
+    end
+
+    def cloud_instruction
+      self
+    end
+
+   
+    def action(arg=nil)
+      if arg != nil
+        @action = arg
+      else
+      @action
+      end
+    end
+
+    def command(arg=nil)
+      if arg != nil
+        @command = arg
+      else
+      @command
+      end
+    end
+
+    def name(arg=nil)
+      if arg != nil
+        @name = arg
+      else
+      @name
+      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["action"] = action
+      index_hash["command"] = command
+      index_hash["name"] = name
+      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 = {
+        "action" => action,
+        "command" => command,
+        "name" => name
+      }
+      result
+    end
+
+    #
+    def self.json_create(o)
+      cloudinstruction = new
+      cloudinstruction.action(o["action"]) if o.has_key?("action")
+      cloudinstruction.command(o["command"]) if o.has_key?("command")
+      cloudinstruction.name(o["name"]) if o.has_key?("name")      
+      cloudinstruction
+    end
+
+    def self.from_hash(o)
+      cloudinstruction = self.new()
+      cloudinstruction.from_hash(o)
+      cloudinstruction
+    end
+
+    def from_hash(o)
+      @action   = o[:action] if o.has_key?(:action)
+      @command   = o[:command] if o.has_key?(:command)
+      @name  = o[:name] if o.has_key?(:name)
+      self
+    end
+
+    
+    def to_s
+      Megam::Stuff.styled_hash(to_hash)
+    end
+
+  end
+end

data/lib/megam/core/cloudinstruction_collection.rb

@@ -0,0 +1,145 @@
+# Copyright:: Copyright (c) 2012, 2013 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 CloudInstructionCollection
+    include Enumerable
+
+    attr_reader :iterator
+    def initialize
+      @cloudinstructions = Array.new
+      @cloudinstructions_by_name = Hash.new
+      @insert_after_idx = nil
+    end
+
+    def all_cloudinstructions
+      @cloudinstructions
+    end
+
+    def [](index)
+      @cloudinstructions[index]
+    end
+
+    def []=(index, arg)
+      is_megam_cloudinstruction(arg)
+      @cloudinstructions[index] = arg
+      @cloudinstructions_by_name[arg.action] = index
+    end
+
+    def <<(*args)
+      args.flatten.each do |a|
+        is_megam_cloudinstruction(a)
+        @cloudinstructions << a
+        @cloudinstructions_by_name[a.action] =@cloudinstructions.length - 1
+      end
+      self
+    end
+
+    # 'push' is an alias method to <<
+    alias_method :push, :<<
+
+    def insert(cloudinstruction)
+      is_megam_cloudinstruction(cloudinstruction)
+      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
+        # cloudinstructions
+        @cloudinstructions.insert(@insert_after_idx + 1, cloudinstruction)
+        # update name -> location mappings and register new cloudinstructions
+        @cloudinstructions_by_name.each_key do |key|
+        @cloudinstructions_by_name[key] += 1 if@cloudinstructions_by_name[key] > @insert_after_idx
+        end
+        @cloudinstructions_by_name[cloudinstruction.action] = @insert_after_idx + 1
+        @insert_after_idx += 1
+      else
+      @cloudinstructions << cloudinstruction
+      @cloudinstructions_by_name[cloudinstruction.action] =@cloudinstructions.length - 1
+      end
+    end
+
+    def each
+      @cloudinstructions.each do |cloudinstruction|
+        yield cloudinstruction
+      end
+    end
+
+    def each_index
+      @cloudinstructions.each_index do |i|
+        yield i
+      end
+    end
+
+    def empty?
+      @cloudinstructions.empty?
+    end
+
+    def lookup(cloudinstruction)
+      lookup_by = nil
+      if cloudinstruction.kind_of?(Megam::CloudInstruction)
+      lookup_by = cloudinstruction.action
+      elsif cloudinstruction.kind_of?(String)
+      lookup_by = cloudinstruction
+      else
+        raise ArgumentError, "Must pass a Megam::CloudInstruction or String to lookup"
+      end
+      res =@cloudinstructions_by_name[lookup_by]
+      unless res
+        raise ArgumentError, "Cannot find a cloudinstruction matching #{lookup_by} (did you define it first?)"
+      end
+      @cloudinstructions[res]
+    end
+
+    # Transform the ruby obj ->  to a Hash
+    def to_hash
+      index_hash = Hash.new
+      self.each do |cloudinstruction|
+        index_hash[cloudinstruction.action] = cloudinstruction
+      end
+      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 self.json_create(o)
+      collection = self.new()
+      o["results"].each do |cloudinstructions_list|
+        cloudinstructions_array = cloudinstructions_list.kind_of?(Array) ? cloudinstructions_list : [ cloudinstructions_list ]
+        cloudinstructions_array.each do |cloudinstruction|
+          collection.insert(cloudinstruction)
+        end
+      end
+      collection
+    end
+
+    private
+
+    def is_megam_cloudinstruction(arg)
+      unless arg.kind_of?(Megam::CloudInstruction)
+        raise ArgumentError, "Members must be Megam::CloudInstruction's"
+      end
+      true
+    end
+
+    def to_s      
+      Megam::Stuff.styled_hash(to_hash)
+    end
+
+  end
+end

data/lib/megam/core/cloudinstruction_group.rb

@@ -0,0 +1,99 @@
+# Copyright:: Copyright (c) 2012, 2013 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 CloudInstructionGroup
+    def initialize
+      @group = nil
+      @cloud_instructions_array = nil
+    end
+
+    def cloudinstruction_group
+      self
+    end
+
+    def group(arg=nil)
+      if arg != nil
+        @group = arg
+      else
+      @group
+      end
+    end
+    
+    def cloud_instructions_array(arg=nil)
+      if arg != nil
+        @cloud_instructions_array = arg
+      else
+      @cloud_instructions_array
+      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["group"] = group
+      cloud_instructions_array.each do |single_cig|
+        index_hash[""] = single_cig
+      end
+      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 = {
+        "group" => group
+      }
+      result
+    end
+
+    #
+    def self.json_create(o)
+      cloudinstruction_group = new
+      cloudinstruction_group.group(o["group"]) if o.has_key?("group")
+      cloudinstruction_group.cloud_instructions_array(o["results"]) if o.has_key?("results")
+      cloudinstruction_group
+    end
+
+    def self.from_hash(o)
+      cloudinstruction_group = self.new()
+      cloudinstruction_group.from_hash(o)
+      cloudinstruction_group
+    end
+
+    def from_hash(o)
+      @group  = o[:group] if o.has_key?(:group)
+      @cloudinstructions = o[:cloud_instructions_array] if o.has_key?(:cloud_instructions_array)
+      self
+    end
+
+    def to_s
+      Megam::Stuff.styled_hash(to_hash)
+    end
+
+  end
+end