virtengine_api 0.1.0

data/lib/megam/core/marketplace_collection.rb

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

data/lib/megam/core/monologger.rb

@@ -0,0 +1,89 @@
+require 'logger'
+require 'pp'
+
+module Megam
+  #== MonoLogger
+  # A subclass of Ruby's stdlib Logger with all the mutex and logrotation stuff
+  # ripped out.
+  class MonoLogger < Logger
+    #
+    # === Synopsis
+    #
+    #   Logger.new(name, shift_age = 7, shift_size = 1048576)
+    #   Logger.new(name, shift_age = 'weekly')
+    #
+    # === Args
+    #
+    # +logdev+::
+    #   The log device.  This is a filename (String) or IO object (typically
+    #   +STDOUT+, +STDERR+, or an open file).
+    # +shift_age+::
+    #   Number of old log files to keep, *or* frequency of rotation (+daily+,
+    #   +weekly+ or +monthly+).
+    # +shift_size+::
+    #   Maximum logfile size (only applies when +shift_age+ is a number).
+    #
+    # === Description
+    #
+    # Create an instance.
+    #
+    def initialize(logdev)
+      @progname = nil
+      @level = DEBUG
+      @default_formatter = Formatter.new
+      @formatter = nil
+      @logdev = nil
+      if logdev
+        @logdev = LocklessLogDevice.new(logdev)
+      end
+    end
+
+    class LocklessLogDevice < LogDevice
+      def initialize(log = nil)
+        @dev = @filename = @shift_age = @shift_size = nil
+        if log.respond_to?(:write) and log.respond_to?(:close)
+          @dev = log
+        else
+          @dev = open_logfile(log)
+          @dev.sync = true
+          @filename = log
+        end
+      end
+
+      def write(message)
+        @dev.write(message)
+      rescue Exception => ignored
+        warn("log writing failed. #{ignored}")
+        end
+
+      def close
+        @dev.close rescue nil
+      end
+
+      private
+
+      def open_logfile(filename)
+        if (FileTest.exist?(filename))
+          open(filename, (File::WRONLY | File::APPEND))
+        else
+          create_logfile(filename)
+        end
+      end
+
+      def create_logfile(filename)
+        logdev = open(filename, (File::WRONLY | File::APPEND | File::CREAT))
+        logdev.sync = true
+        add_log_header(logdev)
+        logdev
+      end
+
+      def add_log_header(file)
+        file.write(
+        "# Logfile created on %s by %s\n" % [Time.now.to_s, Logger::ProgName]
+        )
+      end
+
+    end
+
+  end
+end

data/lib/megam/core/organizations.rb

@@ -0,0 +1,142 @@
+module Megam
+  class Organizations < Megam::RestAdapter
+    def initialize(o)
+      @id = nil
+      @name = nil
+      @accounts_id = nil
+      @related_orgs = []
+      @created_at = nil
+      super(o)
+    end
+
+    def organization
+      self
+    end
+
+    def id(arg=nil)
+      if arg != nil
+        @id = arg
+      else
+      @id
+      end
+    end
+
+    def accounts_id(arg=nil)
+      if arg != nil
+        @accounts_id = arg
+      else
+      @accounts_id
+      end
+    end
+
+    def name(arg=nil)
+      if arg != nil
+        @name = arg
+      else
+      @name
+      end
+    end
+
+    def related_orgs(arg=[])
+      if arg != []
+        @related_orgs = arg
+      else
+      @related_orgs
+      end
+    end
+
+    def created_at(arg=nil)
+      if arg != nil
+        @created_at = arg
+      else
+      @created_at
+      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["name"] = name
+      index_hash["accounts_id"] = accounts_id
+      index_hash["related_orgs"] = related_orgs
+      index_hash["created_at"] = created_at
+      index_hash
+    end
+
+    def to_json(*a)
+      for_json.to_json(*a)
+    end
+
+    def for_json
+      result = {
+        "id" => id,
+        "name" => name,
+        "accounts_id" => accounts_id,
+        "related_orgs" => related_orgs,
+        "created_at" => created_at
+      }
+      result
+    end
+
+    # Create a Megam::Organization from JSON (used by the backgroud job workers)
+    def self.json_create(o)
+      org = new({})
+      org.id(o["id"]) if o.has_key?("id")
+      org.name(o["name"]) if o.has_key?("name")
+      org.accounts_id(o["accounts_id"]) if o.has_key?("accounts_id")
+      org.related_orgs(o["related_orgs"]) if o.has_key?("related_orgs")
+      org.created_at(o["created_at"]) if o.has_key?("created_at")
+      org
+    end
+
+    def self.from_hash(o)
+      org = self.new(o)
+      org.from_hash(o)
+      org
+    end
+
+    def from_hash(o)
+      @id        = o[:id] if o.has_key?(:id)
+      @name     = o[:name] if o.has_key?(:name)
+      @accounts_id = o[:accounts_id] if o.has_key?(:accounts_id)
+      @related_orgs  = o[:related_orgs] if o.has_key?(:related_orgs)
+      @created_at = o[:created_at] if o.has_key?(:created_at)
+      self
+    end
+
+    def self.create(o)
+      org = from_hash(o)
+      org.create
+    end
+
+    def self.show(o)
+      org = from_hash(o)
+      org.megam_rest.get_organizations(email)
+    end
+
+    def self.update(o)
+      org = from_hash(o)
+      org.update
+    end
+
+    def update
+      megam_rest.update_organization(to_hash)
+    end
+
+    def self.list(o)
+      org = from_hash(o)
+      org.megam_rest.get_organizations
+    end
+
+    def create
+      megam_rest.post_organization(to_hash)
+    end
+
+    def to_s
+      Megam::Stuff.styled_hash(to_hash)
+    end
+
+  end
+end

data/lib/megam/core/organizations_collection.rb

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