megam_api 0.75 → 0.77

data/lib/megam/core/sensors_collection.rb

@@ -0,0 +1,143 @@
+##
+## Copyright [2013-2015] [Megam Systems]
+##
+## 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 SensorsCollection
+    include Enumerable
+
+    attr_reader :iterator
+    def initialize
+      @sensors = []
+      @sensors_by_name = {}
+      @insert_after_idx = nil
+    end
+
+    def all_sensor
+      @sensors
+    end
+
+    def [](index)
+      @sensors[index]
+    end
+
+    def []=(index, arg)
+      is_megam_sensors(arg)
+      @sensors[index] = arg
+      @sensors_by_name[arg.id] = index
+    end
+
+    def <<(*args)
+      args.flatten.each do |a|
+        is_megam_sensors(a)
+        @sensors << a
+        @sensors_by_name[a.id] = @sensors.length - 1
+      end
+      self
+    end
+
+    # 'push' is an alias method to <<s
+    alias_method :push, :<<
+
+    def insert(sensors)
+      is_megam_sensors(sensors)
+      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
+        # sensors
+        @sensors.insert(@insert_after_idx + 1, sensors)
+        # update name -> location mappings and register new sensors
+        @sensors_by_name.each_key do |key|
+          @sensors_by_name[key] += 1 if@sensors_by_name[key] > @insert_after_idx
+        end
+        @sensors_by_name[sensors.id] = @insert_after_idx + 1
+        @insert_after_idx += 1
+      else
+        @sensors << sensors
+        @sensors_by_name[sensors.id] = @sensors.length - 1
+      end
+    end
+
+    def each
+      @sensors.each do |sensors|
+        yield sensors
+      end
+    end
+
+    def each_index
+      @sensors.each_index do |i|
+        yield i
+      end
+    end
+
+    def empty?
+      @sensors.empty?
+    end
+
+    def lookup(sensors)
+      lookup_by = nil
+      if sensors.is_a?(Megam.sensors)
+        lookup_by = sensors.id
+      elsif sensors.is_a?(String)
+        lookup_by = sensors
+      else
+        fail ArgumentError, 'Must pass a Megam::sensors or String to lookup'
+      end
+      res = @sensors_by_name[lookup_by]
+      unless res
+        fail ArgumentError, "Cannot find a sensors matching #{lookup_by} (did you define it first?)"
+      end
+      @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
+    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 = new
+      o['results'].each do |sensors_list|
+        sensors_array = sensors_list.is_a?(Array) ? sensors_list : [sensors_list]
+        sensors_array.each do |sensors|
+          collection.insert(sensors)
+        end
+      end
+      collection
+    end
+
+    private
+
+    def is_megam_sensors(arg)
+      unless arg.is_a?(Megam::Sensors)
+        fail ArgumentError, "Members must be Megam::sensors's"
+      end
+      true
+    end
+
+    def to_s
+      Megam::Stuff.styled_hash(to_hash)
+    end
+  end
+end

data/lib/megam/mixins/assemblies.rb

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

data/lib/megam/mixins/assemblys.rb

@@ -0,0 +1,42 @@
+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 Assemblys
+      attr_reader :components, :policies, :outputs, :mixins
+
+      def initialize(params)
+	params = Hash[params.map{ |k, v| [k.to_sym, v] }]
+        @mixins = CommonDeployable.new(params)
+        @outputs = Outputs.new(params)
+        @components = add_components(params)
+        @policies = []
+      end
+
+      def to_hash
+        result = @mixins.to_hash
+        result[:components]  = @components if @components
+        result[:outputs] = @outputs.to_array  if @outputs
+        result[:policies] = @policies if @policies
+        [result]
+      end
+
+      private
+      # If @components_enabled for type
+      def components_enabled?
+        true # enable if its not a TORPEDO
+      end
+
+      def add_components(params)
+        unless components_enabled?
+          @components = Components.new(params)
+	else
+	  @components = []
+        end
+      end
+
+    end
+  end
+end

data/lib/megam/mixins/common_deployable.rb

@@ -0,0 +1,72 @@
+require File.expand_path("#{File.dirname(__FILE__)}/megam_attributes")
+
+module Megam
+  class Mixins
+    class CommonDeployable
+      include Nilavu::MegamAttributes
+      attr_reader :assemblyname, :componentname, :status, :inputs, :tosca_type
+
+  DEFAULT_TOSCA_PREFIX = 'tosca'.freeze
+  # this is a mutable string, if nothing exists then we use ubuntu
+  DEFAULT_TOSCA_SUFFIX = 'ubuntu'.freeze
+
+      ATTRIBUTES = [
+        :assemblyname,
+        :componentname,
+        :tosca_type,
+        :status,
+        :inputs]
+
+	def attributes
+		ATTRIBUTES
+	end
+      def initialize(params)
+        @assemblyname = ""
+        @tosca_type = ""
+        @status = "launching"
+	bld_toscatype(params)
+        @inputs = InputGroupData.new(params)
+        set_attributes(params)
+      end
+
+
+      def to_hash
+        h = {
+          :name => assemblyname,
+          :status => status,
+          :tosca_type => tosca_type,
+          :inputs => inputs.to_hash  
+        }
+      end
+
+  def bld_toscatype(mkp)
+    tosca_suffix = DEFAULT_TOSCA_SUFFIX
+    tosca_suffix = "#{mkp[:mkp_name]}" unless mkp[:cattype] != 'TORPEDO'.freeze
+    @tosca_type = DEFAULT_TOSCA_PREFIX + ".#{mkp[:cattype].downcase}.#{mkp[:mkp_name].downcase}"
+  end
+ end
+
+    class InputGroupData
+      include Nilavu::MegamAttributes
+      attr_reader :domain, :sshkey, :provider, :cpu, :ram, :hdd, :version, :display_name, :password
+      ATTRIBUTES = [
+        :domain,
+        :sshkey,
+        :provider,
+        :cpu,
+        :ram,
+        :hdd,
+        :version,
+        :display_name,
+      :password]
+
+	def attributes
+		ATTRIBUTES
+	end
+
+      def initialize(params)
+        set_attributes(params)
+      end
+    end
+  end
+end

data/lib/megam/mixins/components.rb

@@ -0,0 +1,85 @@
+require File.expand_path("#{File.dirname(__FILE__)}/megam_attributes")
+module Megam
+  class Mixins
+    class Components
+      attr_reader :mixins, :repo, :related_components, :operations, :artifacts
+
+      def initialize(params)
+        @mixins = CommonDeployable.new(params)
+        @artifacts = Outputs.new(params)
+        add_repo(params)
+        add_operations(params)
+        add_related_components(params)
+        add_artifacts(params)
+      end
+
+      private
+      def add_repo(params)
+      end
+
+      def add_related_components(params)
+        related_components = [ "#{params[:assemblyname]}.#{params[:domain]}/#{params[:componentname]}"]
+      end
+
+      def add_operations(params)
+        create_operation(Operations.CI, Operations.CI_DESCRIPTON, [:type, :token, :username])
+        create_operation(Operations.BIND, Operations.BIND_DESCRIPTON, [:type, :token, :username])
+      end
+
+      def create_operation(type, desc,properties)
+        Operations.new.add_operation(type, desc, properties)
+      end
+
+      def add_artifacts(params)
+      end
+    end
+
+    class Repo
+       include Nilavu::MegamAttributes
+      ATTRIBUTES = [
+        :type,
+        :source,
+        :oneclick,
+      :url]
+
+      def initialize(params)
+        set_attributes(params)
+      end
+    end
+
+    class Operations
+      include Nilavu::MegamAttributes
+      ATTRIBUTES = []
+
+      CI = "ci".freeze
+      CI_DESCRIPTON = "always up to date code. sweet."
+
+      def initialize(params)
+        set_attributes(params)
+      end
+
+      def add_operation(type, desc, properties)
+        ATTRIBUTES.merge(properties)
+        set_attributes(properties)
+      end
+
+      def to_hash
+        #{   'type' => 'ci',
+        #   'description' => 'Continous Integration',
+        #   'properties' => self.to_hash
+      end
+    end
+
+    class Artifacts
+      include Nilavu::MegamAttributes
+      ATTRIBUTES = [
+        :type,
+        :content,
+      :requirements]
+
+      def initialize(params)
+        set_attributes(params)
+      end
+    end
+  end
+end

data/lib/megam/mixins/megam_attributes.rb

@@ -0,0 +1,30 @@
+module Nilavu
+  module MegamAttributes
+    ATTRIBUTES = []
+	KEY = "key".freeze
+	VALUE = "value".freeze
+    attr_accessor *ATTRIBUTES
+
+	def attributes
+		NotImplementedError
+	end
+    def initialize(control_data={})
+      set_attributes(control_data)
+    end
+
+    def set_attributes(control_data)
+      #control_data.symbolize_keys!
+      #control_data = Hash[control_data.map{ |k, v| [k.to_sym, v] }]
+      attributes.each { |a| instance_variable_set("@#{a}", control_data[a]) unless control_data[a].nil? }
+    end
+
+    def to_hash
+      h = attributes.reduce([]) do |res, key|
+        val = instance_variable_get("@#{key}".to_sym)
+        res << { KEY => key.to_s, VALUE => val } unless val.nil?
+        res
+      end
+      h
+    end
+  end
+end

data/lib/megam/mixins/outputs.rb

@@ -0,0 +1,24 @@
+require File.expand_path("#{File.dirname(__FILE__)}/megam_attributes")
+module Megam
+    class Outputs
+      include Nilavu::MegamAttributes
+
+      attr_reader :nodeip, :publicip, :privateip, :lastsuccessfulupdate, :laststatus
+
+      ATTRIBUTES = [
+        ]
+
+	def attributes
+		ATTRIBUTES
+	end
+
+      def initialize(params)
+        set_attributes(params)
+      end
+
+      def to_array
+        array = []
+      end
+
+    end
+end

data/lib/megam/mixins/policies.rb

@@ -0,0 +1,29 @@
+module Megam
+  class Mixins
+    class Policies
+      attr_reader :bind_type, :policymembers
+
+      def initialize(params)
+	@bind_type = params[:bind_type] if params.key?(:bind_type)
+	@policymembers = params[:policymembers] if params.key?(:policymembers)
+      end
+
+      def to_array
+    com = []
+    if @bind_type && @bind_type != 'Unbound service'
+      value = {
+        name: 'bind policy',
+        ptype: 'colocated',
+        members: [
+          @policymembers
+        ]
+      }
+      com << value
+    end
+    com
+      end
+
+
+    end
+  end
+end