virtengine_api 0.1.0

data/lib/megam/core/subscriptions_collection.rb

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

data/lib/megam/core/text.rb

@@ -0,0 +1,87 @@
+require "megam/core/text_formatter"
+module Megam
+    class Text
+
+        attr_reader :stdout
+        attr_reader :stderr
+        attr_reader :stdin
+        attr_reader :config
+
+        def initialize(stdout, stderr, stdin, config)
+            @stdout, @stderr, @stdin, @config = stdout, stderr, stdin, config
+        end
+
+        def highline
+            @highline ||= begin
+                require 'highline'
+                HighLine.new
+            end
+        end
+
+        # Summarize the data. Defaults to text format output,
+        # which may not be very summary-like
+        def summarize(data)
+            text_format(data)
+        end
+
+        # Converts the +data+ to a String in the text format. Uses
+        # Chef::Knife::Core::TextFormatter
+        def text_format(data)
+            Megam::TextFormatter.new(data, self).formatted_data
+        end
+
+        def msg(message)
+            stdout.puts message
+        end
+
+        # Prints a message to stdout. Aliased as +info+ for compatibility with
+        # the logger API.
+
+        def info(message)
+            stdout.puts("#{color('INFO:', :green, :bold)} #{message}")
+        end
+
+        # Prints a msg to stderr. Used for warn, error, and fatal.
+        def err(message)
+            stderr.puts message
+        end
+
+        # Print a warning message
+        def warn(message)
+            err("#{color('WARNING:', :yellow, :bold)} #{message}")
+        end
+
+        # Print an error message
+        def error(message)
+            err("#{color('ERROR:', :red, :bold)} #{message}")
+        end
+
+        # Print a message describing a fatal error.
+        def fatal(message)
+            err("#{color('FATAL:', :red, :bold)} #{message}")
+        end
+
+        def color(string, *colors)
+            if color?
+                highline.color(string, *colors)
+            else
+                string
+            end
+        end
+
+        # Should colored output be used ?. When output is not to a
+        # terminal, colored output is never used
+        def color?
+            stdout.tty?
+        end
+
+        def list(*args)
+            highline.list(*args)
+        end
+
+        def pretty_print(data)
+            stdout.puts data
+        end
+
+    end
+end

data/lib/megam/core/text_formatter.rb

@@ -0,0 +1,64 @@
+module Megam
+  class TextFormatter
+
+    attr_reader :data
+    attr_reader :ui
+    
+    def initialize(data, ui)
+      @ui = ui
+      @data = if data.respond_to?(:display_hash)
+            data.display_hash
+          elsif data.kind_of?(Array)
+            data
+          elsif data.respond_to?(:to_hash)
+            data.to_hash
+          else
+            data
+          end
+    end
+
+    def formatted_data
+      @formatted_data ||= text_format(data)
+    end
+
+    def text_format(data)
+      buffer = ''
+
+      if data.respond_to?(:keys)
+        justify_width = data.keys.map {|k| k.to_s.size }.max.to_i + 1
+        data.sort.each do |key, value|
+        # key: ['value'] should be printed as key: value
+          if value.kind_of?(Array) && value.size == 1 && is_singleton(value[0])
+          value = value[0]
+          end
+          if is_singleton(value)
+            # Strings are printed as key: value.
+            justified_key = ui.color("#{key}:".ljust(justify_width), :cyan)
+            buffer << "#{justified_key} #{value}\n"
+          else
+          # Arrays and hashes get indented on their own lines.
+            buffer << ui.color("#{key}:\n", :cyan)
+            lines = text_format(value).split("\n")
+            lines.each { |line| buffer << "  #{line}\n" }
+          end
+        end
+      elsif data.kind_of?(Array)
+        data.each_index do |index|
+          item = data[index]
+          buffer << text_format(data[index])
+          # Separate items with newlines if it's an array of hashes or an
+          # array of arrays
+          buffer << "\n" if !is_singleton(data[index]) && index != data.size-1
+        end
+      else
+        buffer << "#{data}\n"
+      end
+      buffer
+    end
+
+    def is_singleton(value)
+      !(value.kind_of?(Array) || value.respond_to?(:keys))
+    end
+
+  end
+end

data/lib/megam/mixins/assemblies.rb

@@ -0,0 +1,16 @@
+require File.expand_path("#{File.dirname(__FILE__)}/assembly")
+
+module Megam
+    class Mixins
+        class Assemblies
+            attr_reader :assembly
+            def initialize(params)
+                @assembly = Assembly.new(params)
+            end
+
+            def to_hash
+                assembly.to_hash
+            end
+        end
+    end
+end

data/lib/megam/mixins/assembly.rb

@@ -0,0 +1,59 @@
+require File.expand_path("#{File.dirname(__FILE__)}/common_deployable")
+require File.expand_path("#{File.dirname(__FILE__)}/components")
+require File.expand_path("#{File.dirname(__FILE__)}/outputs")
+
+module Megam
+    class Mixins
+        class Assembly
+            attr_reader :id, :name, :components, :policies, :outputs, :envs, :mixins
+            DEFAULT_VERTICE_PREFIX  = 'vertice'.freeze
+            DEFAULT_DOCKER_PREFIX   = 'docker'.freeze
+            TORPEDO = 'TORPEDO'.freeze
+            def initialize(params)
+                params = Hash[params.map { |k, v| [k.to_sym, v] }]
+                @id = params[:id] || params[:assemblyID] || ''
+                @name = params[:assemblyname]
+                @mixins = CommonDeployable.new(params)
+                @outputs = Outputs.new(params)
+                @components = add_components(params)
+                @tosca_type = add_assembly_tosca_type(params)
+                @policies = []
+            end
+
+            def to_hash
+                result = @mixins.to_hash
+                result[:id] = @id if @id
+                result[:name] = @name if @name
+                result[:components] = @components if @components
+                result[:outputs] = @outputs.to_array if @outputs
+                result[:policies] = @policies if @policies
+                result[:tosca_type] = @tosca_type if @tosca_type
+                result
+            end
+
+            private
+
+            # If @components_enabled for type
+            def components_enabled?(params)
+                true if params[:cattype] != 'TORPEDO'.freeze
+            end
+
+            def add_components(params)
+                if components_enabled?(params)
+                    @components = Components.new(params).to_a
+                else
+                    @components = []
+                end
+            end
+
+            def add_assembly_tosca_type(params)
+                if params[:scm_name] == DEFAULT_DOCKER_PREFIX
+                    @tosca_type = params[:scm_name] + ".#{TORPEDO.downcase}.#{params[:os_name].downcase}" if params[:os_name] != nil
+                else
+                    @tosca_type = DEFAULT_VERTICE_PREFIX + ".#{TORPEDO.downcase}.#{params[:os_name].downcase}" if params[:os_name] != nil
+                end
+            end
+
+        end
+    end
+end

data/lib/megam/mixins/common_deployable.rb

@@ -0,0 +1,78 @@
+require File.expand_path("#{File.dirname(__FILE__)}/megam_attributes")
+
+module Megam
+    class Mixins
+        class CommonDeployable
+            include Nilavu::MegamAttributes
+            attr_reader :status, :state, :inputs
+            ATTRIBUTES = [
+                :status,
+                :state,
+            :inputs]
+
+            def attributes
+                ATTRIBUTES
+            end
+
+            def initialize(params)
+                @status = 'initialized'
+                @state = 'initialized'
+                set_attributes(params)
+                @inputs = InputGroupData.new(params)
+
+            end
+
+            def to_hash
+                h = {
+                    status: status,
+                    state: state,
+                    inputs: inputs.to_hash
+                }
+            end
+        end
+
+        class InputGroupData
+            include Nilavu::MegamAttributes
+
+            attr_reader :domain, :keypairoption, :root_password, :sshkey, :provider, :cpu, :ram, :hdd,
+            :version, :display_name, :password, :region, :flavor_id, :storage_hddtype,
+            :public_ipv4, :private_ipv4, :public_ipv6, :private_ipv6, :bitnami_username, :bitnami_password, :root_username, :backup, :backup_name, :backup_id, :quota_ids,:app_username, :app_password, :user_launch_patternname, :flavor_id
+
+            ATTRIBUTES = [
+                :domain,
+                :keypairoption,
+                :root_password,
+                :sshkey,
+                :provider,
+                :version,
+                :display_name,
+                :password,
+                :region,
+                :flavor_id,
+                :storage_hddtype,
+                :private_ipv4,
+                :public_ipv4,
+                :private_ipv6,
+                :public_ipv6,
+                :bitnami_password,
+                :bitnami_username,
+                :app_username,
+                :app_password,
+                :root_username,
+                :backup,
+                :backup_name,
+                :backup_id,
+                :quota_ids,
+		            :user_launch_patternname,]
+
+            def attributes
+                ATTRIBUTES
+            end
+
+            def initialize(params)
+                set_attributes(params)
+            end
+
+        end
+    end
+end

data/lib/megam/mixins/components.rb

@@ -0,0 +1,182 @@
+require File.expand_path("#{File.dirname(__FILE__)}/megam_attributes")
+require File.expand_path("#{File.dirname(__FILE__)}/common_deployable")
+require File.expand_path("#{File.dirname(__FILE__)}/outputs")
+
+module Megam
+    class Mixins
+        class Components
+            attr_reader :mixins, :name, :repo, :related_components, :operations, :artifacts, :envs, :outputs, :id, :tosca_type
+              DEFAULT_VERTICE_PREFIX  = 'vertice'.freeze
+            def initialize(params)
+                @mixins = CommonDeployable.new(params)
+                @id = params[:id] if params[:id]
+                @name = params[:componentname] || params[:name] || ''
+                @outputs = Outputs.new(params)
+                @operations = add_operations(params)
+                @related_components = add_related_components(params)
+                @artifacts = add_artifacts(params)
+                @repo = add_repo(params)
+                @envs = params[:envs]
+                @tosca_type = add_components_tosca_type(params)
+            end
+
+            def to_hash
+                result = @mixins.to_hash
+                result[:id] = @id if @id
+                result[:name] = @name if @name
+                result[:artifacts] = @artifacts if @artifacts
+                result[:repo] = @repo if @repo
+                result[:operations] = @operations if @operations
+                result[:outputs] = @outputs.to_array if @outputs
+                result[:related_components] = @related_components if @related_components
+                result[:envs] = @envs if @envs
+                result[:tosca_type] = @tosca_type if @tosca_type
+                result.to_hash
+            end
+
+            def to_a
+                [to_hash]
+            end
+
+            private
+
+            def add_repo(params)
+                Repo.new(params).tohash
+            end
+
+            def add_related_components(params)
+                @related_components = []
+                @related_components << "#{params[:bind_type]}" if params.key?(:bind_type)
+            end
+
+            def add_operations(params)
+                operations = []
+                operations.push(create_operation(Operations::CI, Operations::CI_DESCRIPTON, params)) if params.key?(:scm_name) && params.key?(:scmtoken)
+                operations.push(create_operation(Operations::BIND, Operations::BIND_DESCRIPTON, params)) if params.key?(:bind_type)
+                operations
+            end
+
+            def create_operation(type, desc, params)
+                Operations.new(params, type, desc).tohash
+            end
+
+            def add_artifacts(params)
+                Artifacts.new(params).tohash
+            end
+
+            def add_components_tosca_type(params)
+                if params[:scm_name] !=nil
+                    @tosca_type = params[:scm_name] + ".#{params[:cattype].downcase}.#{params[:mkp_name].downcase}" if params[:cattype] != nil  && params[:mkp_name] != nil
+                else
+                    @tosca_type = DEFAULT_VERTICE_PREFIX + ".#{params[:cattype].downcase}.#{params[:mkp_name].downcase}" if params[:cattype] != nil  && params[:mkp_name] != nil
+                end
+            end
+
+        end
+
+        class Repo
+            include Nilavu::MegamAttributes
+            attr_reader :type, :source, :url, :oneclick, :branch
+            ATTRIBUTES = [
+                :type,
+                :source,
+                :oneclick,
+                :url,
+            :branch]
+
+            def attributes
+                ATTRIBUTES
+            end
+
+            def initialize(params)
+                set_attributes(params)
+                @type = params[:type] || ""
+                @source = params[:scm_name] || ""
+                @url = params[:source] || ""
+                @oneclick = params[:oneclick] || ""
+                @branch = params[:scmbranch] || ""
+            end
+
+            def tohash
+                {  rtype: @type,
+                    source: @source,
+                    oneclick: @oneclick,
+                    url: @url,
+                    branch: @branch
+                }
+            end
+        end
+
+        class Operations
+            include Nilavu::MegamAttributes
+            attr_reader :type, :desc, :prop, :status
+
+            ATTRIBUTES = [
+                :type,
+                :desc,
+                :prop,
+            :status]
+
+            def attributes
+                ATTRIBUTES
+            end
+
+            CI = 'CI'.freeze
+            CI_DESCRIPTON = 'always up to date code. sweet.'
+            NOTBOUND = "notbound".freeze
+            BIND = 'bind'.freeze
+            BIND_DESCRIPTON = 'bind. sweet.'
+
+            def initialize(params, type, desc)
+                @type = type
+                @desc = desc
+                @prop = prop(params)
+            end
+
+            def attributes
+                ATTRIBUTES
+            end
+
+            def tohash
+                {   operation_type: @type,
+                    description: @desc,
+                    properties: @prop,
+                    status: NOTBOUND
+                }
+            end
+
+            # Key_name mismatch. Key_name is to be changed.
+            def prop(params)
+                op = []
+                op << { 'key' => 'type', 'value' => params[:scm_name] } if params.key?(:scm_name)
+                op << { 'key' => 'token', 'value' => params[:scmtoken] } if params.key?(:scmtoken)
+                op << { 'key' => 'username', 'value' => params[:scmowner] } if params.key?(:scmowner)
+                op << { 'key' => 'related_component', 'value' => params[:bind_type] } if params.key?(:bind_type)
+                op
+            end
+        end
+
+        class Artifacts
+            include Nilavu::MegamAttributes
+            ATTRIBUTES = [
+                :type,
+                :content,
+            :requirements]
+
+            def attributes
+                ATTRIBUTES
+            end
+
+            def initialize(params)
+                set_attributes(params)
+            end
+
+            def tohash
+                {   artifact_type: '',
+                    content: '',
+                    requirements: []
+                }
+            end
+        end
+    end
+end