virtengine_api 0.1.0

data/lib/megam/core/flavors_collection.rb

@@ -0,0 +1,121 @@
+module Megam
+    class FlavorsCollection
+        include Enumerable
+
+        attr_reader :iterator
+        def initialize
+            @flavors = Array.new
+            @flavors_by_name = Hash.new
+            @insert_after_idx = nil
+        end
+
+        def all_flavors
+            @flavors
+        end
+
+        def [](index)
+            @flavors[index]
+        end
+
+        def []=(index, arg)
+            is_megam_flavors(arg)
+            @flavors[index] = arg
+            @flavors_by_name[arg.account_id] = index
+        end
+
+        def <<(*args)
+            args.flatten.each do |a|
+                is_megam_flavors(a)
+                @flavors << a
+                @flavors_by_name[a.account_id] = @flavors.length - 1
+            end
+            self
+        end
+
+        # 'push' is an alias method to <<
+        alias_method :push, :<<
+
+        def insert(flavors)
+            is_megam_flavors(flavors)
+            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
+                @flavors.insert(@insert_after_idx + 1, flavors)
+                # update name -> location mappings and register new node
+                @flavors_by_name.each_key do |key|
+                    @flavors_by_name[key] += 1 if @flavors_by_name[key] > @insert_after_idx
+                end
+                @flavors_by_name[flavors.account_id] = @insert_after_idx + 1
+                @insert_after_idx += 1
+            else
+                @flavors << flavors
+                @flavors_by_name[flavors.account_id] = @flavors.length - 1
+            end
+        end
+
+        def each
+            @flavors.each do |flavors|
+                yield flavors
+            end
+        end
+
+        def each_index
+            @flavors.each_index do |i|
+                yield i
+            end
+        end
+
+        def empty?
+            @flavors.empty?
+        end
+
+        def lookup(flavors)
+            lookup_by = nil
+            if events.kind_of?(Megam::Flavors)
+                lookup_by = flavors.account_id
+            elsif flavors.kind_of?(String)
+                lookup_by = flavors
+            else
+                raise ArgumentError, "Must pass a Megam::Flavors or String to lookup"
+            end
+            res = @flavors_by_name[lookup_by]
+            unless res
+                raise ArgumentError, "Cannot find a node matching #{lookup_by} (did you define it first?)"
+            end
+            @flavors[res]
+        end
+
+        def to_s
+            @flavors.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 |flavors_list|
+                flavors_array = flavors_list.kind_of?(Array) ? flavors_list : [ flavors_list ]
+                flavors_array.each do |flavors|
+                    collection.insert(flavors)
+                end
+            end
+            collection
+        end
+
+        private
+
+        def is_megam_flavors(arg)
+            unless arg.kind_of?(Megam::Flavors)
+                raise ArgumentError, "Members must be Megam::Flavors's"
+            end
+            true
+        end
+    end
+end

data/lib/megam/core/json_compat.rb

@@ -0,0 +1,289 @@
+
+# Wrapper class for interacting with JSON.
+require "ffi_yajl"
+# We're requiring this to prevent breaking consumers using Hash.to_json
+require "json"
+
+module Megam
+    class JSONCompat
+
+        JSON_MAX_NESTING = 1000
+
+        JSON_CLAZ = 'json_claz'.freeze
+
+        MEGAM_ACCOUNT                         = 'Megam::Account'.freeze
+        MEGAM_ACCOUNTCOLLECTION               = 'Megam::AccountCollection'.freeze
+        MEGAM_ASSEMBLIES                      = 'Megam::Assemblies'.freeze
+        MEGAM_ASSEMBLIESCOLLECTION            = 'Megam::AssembliesCollection'.freeze
+        MEGAM_ASSEMBLY                        = 'Megam::Assembly'.freeze
+        MEGAM_ASSEMBLYCOLLECTION              = 'Megam::AssemblyCollection'.freeze
+        MEGAM_BALANCES                        = 'Megam::Balances'.freeze
+        MEGAM_BALANCESCOLLECTION              = 'Megam::BalancesCollection'.freeze
+        MEGAM_CREDITS                          = 'Megam::Credits'.freeze
+        MEGAM_CREDITSCOLLECTION                = 'Megam::CreditsCollection'.freeze
+        MEGAM_BILLEDHISTORIES                 = 'Megam::Billedhistories'.freeze
+        MEGAM_BILLEDHISTORIESCOLLECTION       = 'Megam::BilledhistoriesCollection'.freeze
+        MEGAM_BILLINGTRANSACTIONS             = 'Megam::BillingTransactions'.freeze
+        MEGAM_BILLINGTRANSACTIONSCOLLECTION   = 'Megam::BillingTransactionsCollection'.freeze
+        MEGAM_COMPONENTS                      = 'Megam::Components'.freeze
+        MEGAM_COMPONENTSCOLLECTION            = 'Megam::ComponentsCollection'.freeze
+        MEGAM_DOMAIN                          = 'Megam::Domains'.freeze
+        MEGAM_DOMAINCOLLECTION                = 'Megam::DomainsCollection'.freeze
+        MEGAM_ERROR                           = 'Megam::Error'.freeze
+        MEGAM_MARKETPLACE                     = 'Megam::MarketPlace'.freeze
+        MEGAM_MARKETPLACECOLLECTION           = 'Megam::MarketPlaceCollection'.freeze
+        MEGAM_ORGANIZATION                    = 'Megam::Organizations'.freeze
+        MEGAM_ORGANIZATIONSCOLLECTION         = 'Megam::OrganizationsCollection'.freeze
+        MEGAM_REQUEST                         = 'Megam::Request'.freeze
+        MEGAM_REQUESTCOLLECTION               = 'Megam::RequestCollection'.freeze
+        MEGAM_SENSORS                         = 'Megam::Sensors'.freeze
+        MEGAM_SENSORSCOLLECTION               = 'Megam::SensorsCollection'.freeze
+        MEGAM_SNAPSHOTS                       = 'Megam::Snapshots'.freeze
+        MEGAM_SNAPSHOTSCOLLECTION             = 'Megam::SnapshotsCollection'.freeze
+        MEGAM_BACKUPS                         = 'Megam::Backups'.freeze
+        MEGAM_BACKUPSCOLLECTION               = 'Megam::BackupsCollection'.freeze
+        MEGAM_DISKS                           = 'Megam::Disks'.freeze
+        MEGAM_DISKSCOLLECTION                 = 'Megam::DisksCollection'.freeze
+        MEGAM_LICENSE                         = 'Megam::License'.freeze
+        MEGAM_LICENSECOLLECTION               = 'Megam::LicenseCollection'.freeze
+        MEGAM_SSHKEY                          = 'Megam::SshKey'.freeze
+        MEGAM_SSHKEYCOLLECTION                = 'Megam::SshKeyCollection'.freeze
+        MEGAM_EVENTSALL                       = 'Megam::EventsAll'.freeze
+        MEGAM_EVENTSALLCOLLECTION             = 'Megam::EventsAllCollection'.freeze
+        MEGAM_EVENTSVM                        = 'Megam::EventsVm'.freeze
+        MEGAM_EVENTSVMCOLLECTION              = 'Megam::EventsVmCollection'.freeze
+        MEGAM_EVENTSCONTAINER                 = 'Megam::EventsContainer'.freeze
+        MEGAM_EVENTSCONTAINERCOLLECTION       = 'Megam::EventsContainerCollection'.freeze
+        MEGAM_EVENTSMARKETPLACE               = 'Megam::EventsMarketplace'.freeze
+        MEGAM_EventsMarketplaceCollection     = 'Megam::EventsMarketplaceCollection'.freeze
+        MEGAM_EVENTSBILLING                   = 'Megam::EventsBilling'.freeze
+        MEGAM_EVENTSBILLINGCOLLECTION         = 'Megam::EventsBillingCollection'.freeze
+        MEGAM_EVENTSSTORAGE                   = 'Megam::EventsStorage'.freeze
+        MEGAM_EVENTSSTORAGECOLLECTION         = 'Megam::EventsStorageCollection'.freeze
+        MEGAM_SUBSCRIPTIONS                   = 'Megam::Subscriptions'.freeze
+        MEGAM_SUBSCRIPTIONSCOLLECTION         = 'Megam::SubscriptionsCollection'.freeze
+        MEGAM_ADDONS                          = 'Megam::Addons'.freeze
+        MEGAM_ADDONSCOLLECTION                = 'Megam::AddonsCollection'.freeze
+        MEGAM_REPORTS                         = 'Megam::Reports'.freeze
+        MEGAM_REPORTSCOLLECTION               = 'Megam::ReportsCollection'.freeze
+        MEGAM_QUOTAS                          = 'Megam::Quotas'.freeze
+        MEGAM_QUOTASCOLLECTION                = 'Megam::QuotasCollection'.freeze
+        MEGAM_FLAVORS                         = 'Megam::Flavors'.freeze
+        MEGAM_FLAVORSCOLLECTION               = 'Megam::FlavorsCollection'.freeze
+        MEGAM_RAWIMAGES                       = 'Megam::Rawimages'.freeze
+        MEGAM_RAWIMAGESCOLLECTION             = 'Megam::RawimagesCollection'.freeze
+        MEGAM_PROMOS                          = 'Megam::Promos'.freeze
+
+
+        class << self
+            # API to use to avoid create_addtions
+            def parse(source, opts = {})
+                begin
+                    FFI_Yajl::Parser.parse(source, opts)
+                rescue FFI_Yajl::ParseError => e
+                    raise StandardError, e.message
+                end
+            end
+
+            # Just call the JSON gem's parse method with a modified :max_nesting field
+            def from_json(source, opts = {})
+                obj = parse(source, opts)
+
+                # JSON gem requires top level object to be a Hash or Array (otherwise
+                # you get the "must contain two octets" error). Yajl doesn't impose the
+                # same limitation. For compatibility, we re-impose this condition.
+                unless obj.kind_of?(Hash) || obj.kind_of?(Array)
+                    raise JSON::ParseError, "Top level JSON object must be a Hash or Array. (actual: #{obj.class})"
+                end
+
+                # The old default in the json gem (which we are mimicing because we
+                # sadly rely on this misfeature) is to "create additions" i.e., convert
+                # JSON objects into ruby objects. Explicit :create_additions => false
+                # is required to turn it off.
+                if opts[:create_additions].nil? || opts[:create_additions]
+                    map_to_rb_obj(obj)
+                else
+                    obj
+                end
+            end
+
+            # Look at an object that's a basic type (from json parse) and convert it
+            # to an instance of Chef classes if desired.
+            def map_to_rb_obj(json_obj)
+                case json_obj
+                when Hash
+                    mapped_hash = map_hash_to_rb_obj(json_obj)
+                    if json_obj.has_key?(JSON_CLAZ) && (class_to_inflate = class_for_json_class(json_obj[JSON_CLAZ]))
+                        class_to_inflate.json_create(mapped_hash)
+                    else
+                        mapped_hash
+                    end
+                when Array
+                    json_obj.map { |e| map_to_rb_obj(e) }
+                else
+                    json_obj
+                end
+            end
+
+            def map_hash_to_rb_obj(json_hash)
+                json_hash.each do |key, value|
+                    json_hash[key] = map_to_rb_obj(value)
+                end
+                json_hash
+            end
+
+            def to_json(obj, opts = nil)
+                begin
+                    FFI_Yajl::Encoder.encode(obj, opts)
+                rescue FFI_Yajl::EncodeError => e
+                    raise JSON::GeneratorError, e.message
+                end
+            end
+
+
+            def to_json_pretty(obj, opts = nil)
+                opts ||= {}
+                options_map = {}
+                options_map[:pretty] = true
+                options_map[:indent] = opts[:indent] if opts.has_key?(:indent)
+                to_json(obj, options_map).chomp
+            end
+
+
+            # Map +JSON_CLAZ+ to a Class object. We use a +case+ instead of a Hash
+            # assigned to a constant because otherwise this file could not be loaded
+            # until all the constants were defined, which means you'd have to load
+            # the world to get json.
+            def class_for_json_class(json_class)
+                case json_class
+                when MEGAM_ERROR
+                    Megam::Error
+                when MEGAM_ACCOUNT
+                    Megam::Account
+                when MEGAM_ACCOUNTCOLLECTION
+                    Megam::AccountCollection
+                when MEGAM_ASSEMBLIES
+                    Megam::Assemblies
+                when MEGAM_ASSEMBLIESCOLLECTION
+                    Megam::AssembliesCollection
+                when MEGAM_ASSEMBLY
+                    Megam::Assembly
+                when MEGAM_ASSEMBLYCOLLECTION
+                    Megam::AssemblyCollection
+                when MEGAM_COMPONENTS
+                    Megam::Components
+                when MEGAM_COMPONENTSCOLLECTION
+                    Megam::ComponentsCollection
+                when MEGAM_REQUEST
+                    Megam::Request
+                when MEGAM_REQUESTCOLLECTION
+                    Megam::RequestCollection
+                when MEGAM_SSHKEY
+                    Megam::SshKey
+                when MEGAM_SSHKEYCOLLECTION
+                    Megam::SshKeyCollection
+                when MEGAM_EVENTSVM
+                    Megam::EventsVm
+                when MEGAM_EVENTSVMCOLLECTION
+                    Megam::EventsVmCollection
+                when MEGAM_EVENTSMARKETPLACE
+                    Megam::EventsMarketplace
+                when MEGAM_EventsMarketplaceCollection
+                    Megam::EventsMarketplaceCollection
+                when MEGAM_LICENSE
+                    Megam::License
+                when MEGAM_LICENSECOLLECTION
+                    Megam::LicenseCollection
+                when MEGAM_FLAVORS
+                    Megam::Flavors
+                when MEGAM_FLAVORSCOLLECTION
+                    Megam::FlavorsCollection
+                when MEGAM_EVENTSALL
+                    Megam::EventsAll
+                when MEGAM_EVENTSALLCOLLECTION
+                    Megam::EventsAllCollection
+                when MEGAM_EVENTSCONTAINER
+                    Megam::EventsContainer
+                when MEGAM_EVENTSCONTAINERCOLLECTION
+                    Megam::EventsContainerCollection
+                when MEGAM_EVENTSBILLING
+                    Megam::EventsBilling
+                when MEGAM_EVENTSBILLINGCOLLECTION
+                    Megam::EventsBillingCollection
+                when MEGAM_EVENTSSTORAGE
+                    Megam::EventsStorage
+                when MEGAM_EVENTSSTORAGECOLLECTION
+                    Megam::EventsStorageCollection
+                when MEGAM_MARKETPLACE
+                    Megam::MarketPlace
+                when MEGAM_MARKETPLACECOLLECTION
+                    Megam::MarketPlaceCollection
+                when MEGAM_ORGANIZATION
+                    Megam::Organizations
+                when MEGAM_ORGANIZATIONSCOLLECTION
+                    Megam::OrganizationsCollection
+                when MEGAM_DOMAIN
+                    Megam::Domains
+                when MEGAM_DOMAINCOLLECTION
+                    Megam::DomainsCollection
+                when MEGAM_SENSORS
+                    Megam::Sensors
+                when MEGAM_SENSORSCOLLECTION
+                    Megam::SensorsCollection
+                when MEGAM_SNAPSHOTS
+                    Megam::Snapshots
+                when MEGAM_SNAPSHOTSCOLLECTION
+                    Megam::SnapshotsCollection
+                  when MEGAM_BACKUPS
+                      Megam::Backups
+                  when MEGAM_BACKUPSCOLLECTION
+                      Megam::BackupsCollection
+                when MEGAM_BALANCES
+                    Megam::Balances
+                when MEGAM_BALANCESCOLLECTION
+                    Megam::BalancesCollection
+                  when MEGAM_CREDITS
+                      Megam::Credits
+                  when MEGAM_CREDITSCOLLECTION
+                      Megam::CreditsCollection
+                when MEGAM_BILLEDHISTORIES
+                    Megam::Billedhistories
+                when MEGAM_BILLEDHISTORIESCOLLECTION
+                    Megam::BilledhistoriesCollection
+                when MEGAM_BILLINGTRANSACTIONS
+                    Megam::Billingtransactions
+                when MEGAM_BILLINGTRANSACTIONSCOLLECTION
+                    Megam::BillingtransactionsCollection
+                when MEGAM_SUBSCRIPTIONS
+                    Megam::Subscriptions
+                when MEGAM_SUBSCRIPTIONSCOLLECTION
+                    Megam::SubscriptionsCollection
+                when MEGAM_DISKS
+                    Megam::Disks
+                when MEGAM_DISKSCOLLECTION
+                    Megam::DisksCollection
+                when MEGAM_ADDONS
+                    Megam::Addons
+                when MEGAM_ADDONSCOLLECTION
+                    Megam::AddonsCollection
+                when MEGAM_REPORTS
+                    Megam::Reports
+                when MEGAM_REPORTSCOLLECTION
+                    Megam::ReportsCollection
+                when MEGAM_QUOTAS
+                    Megam::Quotas
+                when MEGAM_QUOTASCOLLECTION
+                    Megam::QuotasCollection
+                when MEGAM_RAWIMAGES
+                     Megam::Rawimages
+                when MEGAM_RAWIMAGESCOLLECTION
+                    Megam::RawimagesCollection
+                when MEGAM_PROMOS
+                    Megam::Promos
+                else
+                    fail JSON::ParserError, "Unsupported `json_class` type '#{json_class}'"
+                end
+            end
+        end
+    end
+end

data/lib/megam/core/konipai.rb

@@ -0,0 +1,42 @@
+module Megam
+  class KoniPai
+
+    def initialize()
+      @koni = nil
+    end
+
+    def konipai
+      self
+    end
+
+    def koni(arg=nil)
+      if arg != nil
+        @koni = arg
+      else
+      @koni
+      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["koni"] = koni
+      index_hash
+    end
+
+
+    def self.json_create(o)
+      kp  = new
+      kp.koni(o) if o != null
+      kp
+    end
+
+
+    def to_s
+      Megam::Stuff.styled_hash(to_hash)
+    end
+
+  end
+end