miasma 0.2.10 → 0.2.12

data/lib/miasma/contrib/aws/auto_scale.rb

@@ -1,86 +0,0 @@
-require 'miasma'
-
-module Miasma
-  module Models
-    class AutoScale
-      class Aws < AutoScale
-
-        # Service name of the API
-        API_SERVICE = 'autoscaling'
-        # Supported version of the AutoScaling API
-        API_VERSION = '2011-01-01'
-
-        include Contrib::AwsApiCore::ApiCommon
-        include Contrib::AwsApiCore::RequestUtils
-
-        # Save auto scale group
-        #
-        # @param group [Models::AutoScale::Group]
-        # @return [Models::AutoScale::Group]
-        def group_save(group)
-          raise NotImplementedError
-        end
-
-        # Reload the group data from the API
-        #
-        # @param group [Models::AutoScale::Group]
-        # @return [Models::AutoScale::Group]
-        def group_reload(group)
-          if(group.id || group.name)
-            load_group_data(group)
-          end
-          group
-        end
-
-        # Delete auto scale group
-        #
-        # @param group [Models::AutoScale::Group]
-        # @return [TrueClass, FalseClass]
-        def group_destroy(group)
-          raise NotImplemented
-        end
-
-        # Fetch groups or update provided group data
-        #
-        # @param group [Models::AutoScale::Group]
-        # @return [Array<Models::AutoScale::Group>]
-        def load_group_data(group=nil)
-          params = Smash.new('Action' => 'DescribeAutoScalingGroups')
-          if(group)
-            params.merge('AutoScalingGroupNames.member.1' => group.id || group.name)
-          end
-          result = all_result_pages(nil, :body, 'DescribeAutoScalingGroupsResponse', 'DescribeAutoScalingGroupsResult', 'AutoScalingGroups', 'member') do |options|
-            request(
-              :path => '/',
-              :params => options.merge(params)
-            )
-          end.map do |grp|
-            (group || Group.new(self)).load_data(
-              :id => grp['AutoScalingGroupName'],
-              :name => grp['AutoScalingGroupName'],
-              :servers => [grp.get('Instances', 'member')].flatten(1).compact.map{|i|
-                Group::Server.new(self, :id => i['InstanceId'])
-              },
-              :minimum_size => grp['MinSize'],
-              :maximum_size => grp['MaxSize'],
-              :status => grp['Status'],
-              :load_balancers => [grp.get('LoadBalancerNames', 'member')].flatten(1).compact.map{|i|
-                Group::Balancer.new(self, :id => i, :name => i)
-              }
-            ).valid_state
-          end
-        end
-
-
-        # Return all auto scale groups
-        #
-        # @param options [Hash] filter
-        # @return [Array<Models::AutoScale::Group>]
-        def group_all(options={})
-          load_group_data
-        end
-
-      end
-    end
-  end
-end

data/lib/miasma/contrib/aws/compute.rb

@@ -1,113 +0,0 @@
-require 'miasma'
-
-module Miasma
-
-  module Models
-    class Compute
-      # Compute interface for AWS
-      class Aws < Compute
-
-        # Service name of the API
-        API_SERVICE = 'ec2'
-        # Supported version of the EC2 API
-        API_VERSION = '2014-06-15'
-
-        include Contrib::AwsApiCore::ApiCommon
-        include Contrib::AwsApiCore::RequestUtils
-
-        # @return [Smash] map state to valid internal values
-        SERVER_STATE_MAP = Smash.new(
-          'running' => :running,
-          'pending' => :pending,
-          'shutting-down' => :pending,
-          'terminated' => :terminated,
-          'stopping' => :pending,
-          'stopped' => :stopped
-        )
-
-        # @todo catch bad lookup and clear model
-        def server_reload(server)
-          result = request(
-            :path => '/',
-            :params => {
-              'Action' => 'DescribeInstances',
-              'InstanceId.1' => server.id
-            }
-          )
-          srv = result.get(:body, 'DescribeInstancesResponse', 'reservationSet', 'item', 'instancesSet', 'item')
-          server.load_data(
-            :id => srv[:instanceId],
-            :name => srv.fetch(:tagSet, :item, []).map{|tag| tag[:value] if tag.is_a?(Hash) && tag[:key] == 'Name'}.compact.first,
-            :image_id => srv[:imageId],
-            :flavor_id => srv[:instanceType],
-            :state => SERVER_STATE_MAP.fetch(srv.get(:instanceState, :name), :pending),
-            :addresses_private => [Server::Address.new(:version => 4, :address => srv[:privateIpAddress])],
-            :addresses_public => [Server::Address.new(:version => 4, :address => srv[:ipAddress])],
-            :status => srv.get(:instanceState, :name),
-            :key_name => srv[:keyName]
-          )
-          server.valid_state
-        end
-
-        def server_destroy(server)
-          if(server.persisted?)
-            result = request(
-              :path => '/',
-              :params => {
-                'Action' => 'TerminateInstances',
-                'InstanceId.1' => server.id
-              }
-            )
-          else
-            raise "this doesn't even exist"
-          end
-        end
-
-        def server_save(server)
-          unless(server.persisted?)
-            server.load_data(server.attributes)
-            result = request(
-              :path => '/',
-              :params => {
-                'Action' => 'RunInstances',
-                'ImageId' => server.image_id,
-                'InstanceType' => server.flavor_id,
-                'KeyName' => server.key_name,
-                'MinCount' => 1,
-                'MaxCount' => 1
-              }
-            )
-            server.id = result.get(:body, 'RunInstancesResponse', 'instancesSet', 'item', 'instanceId')
-          else
-            raise 'WAT DO I DO!?'
-          end
-        end
-
-        # @todo need to add auto pagination helper (as common util)
-        def server_all
-          results = all_result_pages(nil, :body, 'DescribeInstancesResponse', 'reservationSet', 'item') do |options|
-            request(:path => '/', :params => options.merge('Action' => 'DescribeInstances'))
-          end
-          results.map do |srv|
-            [srv[:instancesSet][:item]].flatten.compact.map do |srv|
-              Server.new(
-                self,
-                :id => srv[:instanceId],
-                :name => srv.fetch(:tagSet, :item, []).map{|tag| tag[:value] if tag.is_a?(Hash) && tag[:key] == 'Name'}.compact.first,
-                :image_id => srv[:imageId],
-                :flavor_id => srv[:instanceType],
-                :state => SERVER_STATE_MAP.fetch(srv.get(:instanceState, :name), :pending),
-                :addresses_private => [Server::Address.new(:version => 4, :address => srv[:privateIpAddress])],
-                :addresses_public => [Server::Address.new(:version => 4, :address => srv[:ipAddress])],
-                :status => srv.get(:instanceState, :name),
-                :key_name => srv[:keyName]
-              ).valid_state
-            end
-          end.flatten
-        end
-
-      end
-    end
-  end
-
-end

data/lib/miasma/contrib/aws/load_balancer.rb

@@ -1,187 +0,0 @@
-require 'miasma'
-
-module Miasma
-  module Models
-    class LoadBalancer
-      class Aws < LoadBalancer
-
-        include Contrib::AwsApiCore::ApiCommon
-        include Contrib::AwsApiCore::RequestUtils
-
-        # Service name of API
-        API_SERVICE = 'elasticloadbalancing'
-        # Supported version of the ELB API
-        API_VERSION = '2012-06-01'
-
-        # Save load balancer
-        #
-        # @param balancer [Models::LoadBalancer::Balancer]
-        # @return [Models::LoadBalancer::Balancer]
-        def balancer_save(balancer)
-          unless(balancer.persisted?)
-            params = Smash.new(
-              'LoadBalancerName' => balancer.name
-            )
-            availability_zones.each_with_index do |az, i|
-              params["AvailabilityZones.member.#{i+1}"] = az
-            end
-            if(balancer.listeners)
-              balancer.listeners.each_with_index do |listener, i|
-                key = "Listeners.member.#{i + 1}"
-                params["#{key}.Protocol"] = listener.protocol
-                params["#{key}.InstanceProtocol"] = listener.instance_protocol
-                params["#{key}.LoadBalancerPort"] = listener.load_balancer_port
-                params["#{key}.InstancePort"] = listener.instance_port
-                if(listener.ssl_certificate_id)
-                  params["#{key}.SSLCertificateId"] = listener.ssl_certificate_id
-                end
-              end
-            end
-            result = request(
-              :path => '/',
-              :params => params.merge(
-                Smash.new(
-                  'Action' => 'CreateLoadBalancer'
-                )
-              )
-            )
-            balancer.public_addresses = [
-              :address => result.get(:body, 'CreateLoadBalancerResponse', 'CreateLoadBalancerResult', 'DNSName')
-            ]
-            balancer.load_data(:id => balancer.name).valid_state
-            if(balancer.health_check)
-              balancer_health_check(balancer)
-            end
-            if(balancer.servers && !balancer.servers.empty?)
-              balancer_set_instances(balancer)
-            end
-          else
-            if(balancer.dirty?)
-              if(balancer.dirty?(:health_check))
-                balancer_health_check(balancer)
-              end
-              if(balancer.dirty?(:servers))
-                balancer_set_instances(balancer)
-              end
-              balancer.reload
-            end
-            balancer
-          end
-        end
-
-        # Save the load balancer health check
-        #
-        # @param balancer [Models::LoadBalancer::Balancer]
-        # @return [Models::LoadBalancer::Balancer]
-        def balancer_health_check(balancer)
-          balancer
-        end
-
-        # Save the load balancer attached servers
-        #
-        # @param balancer [Models::LoadBalancer::Balancer]
-        # @return [Models::LoadBalancer::Balancer]
-        def balancer_set_instances(balancer)
-          balancer
-        end
-
-        # Reload the balancer data from the API
-        #
-        # @param balancer [Models::LoadBalancer::Balancer]
-        # @return [Models::LoadBalancer::Balancer]
-        def balancer_reload(balancer)
-          if(balancer.persisted?)
-            load_balancer_data(balancer)
-          end
-          balancer
-        end
-
-        # Fetch balancers or update provided balancer data
-        #
-        # @param balancer [Models::LoadBalancer::Balancer]
-        # @return [Array<Models::LoadBalancer::Balancer>]
-        def load_balancer_data(balancer=nil)
-          params = Smash.new('Action' => 'DescribeLoadBalancers')
-          if(balancer)
-            params.merge('LoadBalancerNames.member.1' => balancer.id || balancer.name)
-          end
-          result = all_result_pages(nil, :body, 'DescribeAutoScalingGroupsResponse', 'DescribeAutoScalingGroupsResult', 'AutoScalingGroups', 'member') do |options|
-            request(
-              :path => '/',
-              :params => options.merge(params)
-            )
-          end
-          [result.get(:body, 'DescribeLoadBalancersResponse', 'DescribeLoadBalancersResult', 'LoadBalancerDescriptions', 'member')].flatten.compact.map do |blr|
-            (balancer || Balancer.new(self)).load_data(
-              :id => blr['LoadBalancerName'],
-              :name => blr['LoadBalancerName'],
-              :state => :active,
-              :status => 'ACTIVE',
-              :created => blr['CreatedTime'],
-              :updated => blr['CreatedTime'],
-              :public_addresses => [
-                Balancer::Address.new(
-                  :address => blr['DNSName'],
-                  :version => 4
-                )
-              ],
-              :servers => [blr.get('Instances', 'member')].flatten(1).compact.map{|i|
-                Balancer::Server.new(self.api_for(:compute), :id => i['InstanceId'])
-              }
-            ).valid_state
-          end
-        end
-
-        # Delete load balancer
-        #
-        # @param balancer [Models::LoadBalancer::Balancer]
-        # @return [TrueClass, FalseClass]
-        def balancer_destroy(balancer)
-          if(balancer.persisted?)
-            request(
-              :path => '/',
-              :params => Smash.new(
-                'Action' => 'DeleteLoadBalancer',
-                'LoadBalancerName' => balancer.name
-              )
-            )
-            balancer.state = :pending
-            balancer.status = 'DELETE_IN_PROGRESS'
-            balancer.valid_state
-            true
-          else
-            false
-          end
-        end
-
-        # Return all load balancers
-        #
-        # @param options [Hash] filter
-        # @return [Array<Models::LoadBalancer::Balancer>]
-        def balancer_all(options={})
-          load_balancer_data
-        end
-
-        protected
-
-        # @return [Array<String>] availability zones
-        def availability_zones
-          memoize(:availability_zones) do
-            res = api_for(:compute).request(
-              :path => '/',
-              :params => Smash.new(
-                'Action' => 'DescribeAvailabilityZones'
-              )
-            ).fetch(:body, 'DescribeAvailabilityZonesResponse', 'availabilityZoneInfo', 'item', [])
-            [res].flatten.compact.map do |item|
-              if(item['zoneState'] == 'available')
-                item['zoneName']
-              end
-            end.compact
-          end
-        end
-
-      end
-    end
-  end
-end

data/lib/miasma/contrib/aws/orchestration.rb

@@ -1,350 +0,0 @@
-require 'miasma'
-
-module Miasma
-  module Models
-    class Orchestration
-      class Aws < Orchestration
-
-        # Service name of the API
-        API_SERVICE = 'cloudformation'
-        # Supported version of the AutoScaling API
-        API_VERSION = '2010-05-15'
-
-        # Valid stack lookup states
-        STACK_STATES = [
-          "CREATE_COMPLETE", "CREATE_FAILED", "CREATE_IN_PROGRESS", "DELETE_FAILED",
-          "DELETE_IN_PROGRESS", "ROLLBACK_COMPLETE", "ROLLBACK_FAILED", "ROLLBACK_IN_PROGRESS",
-          "UPDATE_COMPLETE", "UPDATE_COMPLETE_CLEANUP_IN_PROGRESS", "UPDATE_IN_PROGRESS",
-          "UPDATE_ROLLBACK_COMPLETE", "UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS", "UPDATE_ROLLBACK_FAILED",
-          "UPDATE_ROLLBACK_IN_PROGRESS"
-        ]
-
-        include Contrib::AwsApiCore::ApiCommon
-        include Contrib::AwsApiCore::RequestUtils
-
-        # @return [Smash] external to internal resource mapping
-        RESOURCE_MAPPING = Smash.new(
-          'AWS::EC2::Instance' => Smash.new(
-            :api => :compute,
-            :collection => :servers
-          ),
-          'AWS::ElasticLoadBalancing::LoadBalancer' => Smash.new(
-            :api => :load_balancer,
-            :collection => :balancers
-          ),
-          'AWS::AutoScaling::AutoScalingGroup' => Smash.new(
-            :api => :auto_scale,
-            :collection => :groups
-          )
-        )
-
-        # Fetch stacks or update provided stack data
-        #
-        # @param stack [Models::Orchestration::Stack]
-        # @return [Array<Models::Orchestration::Stack>]
-        def load_stack_data(stack=nil)
-          d_params = Smash.new('Action' => 'DescribeStacks')
-          l_params = Smash.new('Action' => 'ListStacks')
-          STACK_STATES.each_with_index do |state, idx|
-            l_params["StackStatusFilter.member.#{idx + 1}"] = state.to_s.upcase
-          end
-          if(stack)
-            d_params['StackName'] = stack.id
-            descriptions = all_result_pages(nil, :body, 'DescribeStacksResponse', 'DescribeStacksResult', 'Stacks', 'member') do |options|
-              request(
-                :path => '/',
-                :params => options.merge(d_params)
-              )
-            end
-          else
-            descriptions = []
-          end
-          lists = all_result_pages(nil, :body, 'ListStacksResponse', 'ListStacksResult', 'StackSummaries', 'member') do |options|
-            request(
-              :path => '/',
-              :params => options.merge(l_params)
-            )
-          end.map do |stk|
-            desc = descriptions.detect do |d_stk|
-              d_stk['StackId'] == stk['StackId']
-            end || Smash.new
-            stk.merge!(desc)
-            if(stack)
-              next if stack.id != stk['StackId'] && stk['StackId'].split('/')[1] != stack.id
-            end
-            new_stack = stack || Stack.new(self)
-            new_stack.load_data(
-              :id => stk['StackId'],
-              :name => stk['StackName'],
-              :capabilities => [stk.get('Capabilities', 'member')].flatten(1).compact,
-              :description => stk['Description'],
-              :created => stk['CreationTime'],
-              :updated => stk['LastUpdatedTime'],
-              :notification_topics => [stk.get('NotificationARNs', 'member')].flatten(1).compact,
-              :timeout_in_minutes => stk['TimeoutInMinutes'] ? stk['TimeoutInMinutes'].to_i : nil,
-              :status => stk['StackStatus'],
-              :status_reason => stk['StackStatusReason'],
-              :state => stk['StackStatus'].downcase.to_sym,
-              :template_description => stk['TemplateDescription'],
-              :disable_rollback => !!stk['DisableRollback'],
-              :outputs => [stk.get('Outputs', 'member')].flatten(1).compact.map{|o|
-                Smash.new(
-                  :key => o['OutputKey'],
-                  :value => o['OutputValue'],
-                  :description => o['Description']
-                )
-              },
-              :parameters => Smash[
-                [stk.fetch('Parameters', 'member', [])].flatten(1).map{|param|
-                  [param['ParameterKey'], param['ParameterValue']]
-                }
-              ]
-            ).valid_state
-          end
-        end
-
-        # Save the stack
-        #
-        # @param stack [Models::Orchestration::Stack]
-        # @return [Models::Orchestration::Stack]
-        def stack_save(stack)
-          params = Smash.new('StackName' => stack.name)
-          (stack.parameters || {}).each_with_index do |pair, idx|
-            params["Parameters.member.#{idx + 1}.ParameterKey"] = pair.first
-            params["Parameters.member.#{idx + 1}.ParameterValue"] = pair.last
-          end
-          (stack.capabilities || []).each_with_index do |cap, idx|
-            params["Capabilities.member.#{idx + 1}"] = cap
-          end
-          (stack.notification_topics || []).each_with_index do |topic, idx|
-            params["NotificationARNs.member.#{idx + 1}"] = topic
-          end
-          if(stack.template.empty?)
-            params['UsePreviousTemplate'] = true
-          else
-            params['TemplateBody'] = MultiJson.dump(stack.template)
-          end
-          if(stack.persisted?)
-            result = request(
-              :path => '/',
-              :method => :post,
-              :params => Smash.new(
-                'Action' => 'UpdateStack'
-              ).merge(params)
-            )
-            stack
-          else
-            if(stack.timeout_in_minutes)
-              params['TimeoutInMinutes'] = stack.timeout_in_minutes
-            end
-            result = request(
-              :path => '/',
-              :method => :post,
-              :params => Smash.new(
-                'Action' => 'CreateStack',
-                'DisableRollback' => !!stack.disable_rollback
-              ).merge(params)
-            )
-            stack.id = result.get(:body, 'CreateStackResponse', 'CreateStackResult', 'StackId')
-            stack.valid_state
-          end
-        end
-
-        # Reload the stack data from the API
-        #
-        # @param stack [Models::Orchestration::Stack]
-        # @return [Models::Orchestration::Stack]
-        def stack_reload(stack)
-          if(stack.persisted?)
-            ustack = Stack.new(self)
-            ustack.id = stack.id
-            load_stack_data(ustack)
-            if(ustack.data[:name])
-              stack.load_data(ustack.attributes).valid_state
-            else
-              stack.status = 'DELETE_COMPLETE'
-              stack.state = :delete_complete
-              stack.valid_state
-            end
-          end
-          stack
-        end
-
-        # Delete the stack
-        #
-        # @param stack [Models::Orchestration::Stack]
-        # @return [TrueClass, FalseClass]
-        def stack_destroy(stack)
-          if(stack.persisted?)
-            request(
-              :path => '/',
-              :params => Smash.new(
-                'Action' => 'DeleteStack',
-                'StackName' => stack.id
-              )
-            )
-            true
-          else
-            false
-          end
-        end
-
-        # Fetch stack template
-        #
-        # @param stack [Stack]
-        # @return [Smash] stack template
-        def stack_template_load(stack)
-          if(stack.persisted?)
-            result = request(
-              :path => '/',
-              :params => Smash.new(
-                'Action' => 'GetTemplate',
-                'StackName' => stack.id
-              )
-            )
-            MultiJson.load(
-              result.get(:body, 'GetTemplateResponse', 'GetTemplateResult', 'TemplateBody')
-            ).to_smash
-          else
-            Smash.new
-          end
-        end
-
-        # Validate stack template
-        #
-        # @param stack [Stack]
-        # @return [NilClass, String] nil if valid, string error message if invalid
-        def stack_template_validate(stack)
-          begin
-            result = request(
-              :method => :post,
-              :path => '/',
-              :params => Smash.new(
-                'Action' => 'ValidateTemplate',
-                'TemplateBody' => MultiJson.dump(stack.template)
-              )
-            )
-            nil
-          rescue Error::ApiError::RequestError => e
-            MultiXml.parse(e.response.body.to_s).to_smash.get(
-              'ErrorResponse', 'Error', 'Message'
-            )
-          end
-        end
-
-        # Return single stack
-        #
-        # @param ident [String] name or ID
-        # @return [Stack]
-        def stack_get(ident)
-          i = Stack.new(self)
-          i.id = ident
-          i.reload
-          i.name ? i : nil
-        end
-
-        # Return all stacks
-        #
-        # @param options [Hash] filter
-        # @return [Array<Models::Orchestration::Stack>]
-        # @todo check if we need any mappings on state set
-        def stack_all
-          load_stack_data
-        end
-
-        # Return all resources for stack
-        #
-        # @param stack [Models::Orchestration::Stack]
-        # @return [Array<Models::Orchestration::Stack::Resource>]
-        def resource_all(stack)
-          results = all_result_pages(nil, :body, 'DescribeStackResourcesResponse', 'DescribeStackResourcesResult', 'StackResources', 'member') do |options|
-            request(
-              :path => '/',
-              :params => options.merge(
-                Smash.new(
-                  'Action' => 'DescribeStackResources',
-                  'StackName' => stack.id
-                )
-              )
-            )
-          end.map do |res|
-            Stack::Resource.new(
-              stack,
-              :id => res['PhysicalResourceId'],
-              :name => res['LogicalResourceId'],
-              :logical_id => res['LogicalResourceId'],
-              :type => res['ResourceType'],
-              :state => res['ResourceStatus'].downcase.to_sym,
-              :status => res['ResourceStatus'],
-              :status_reason => res['ResourceStatusReason'],
-              :updated => res['Timestamp']
-            ).valid_state
-          end
-        end
-
-        # Reload the stack resource data from the API
-        #
-        # @param resource [Models::Orchestration::Stack::Resource]
-        # @return [Models::Orchestration::Resource]
-        def resource_reload(resource)
-          resource.stack.resources.reload
-          resource.stack.resources.get(resource.id)
-        end
-
-        # Return all events for stack
-        #
-        # @param stack [Models::Orchestration::Stack]
-        # @return [Array<Models::Orchestration::Stack::Event>]
-        def event_all(stack, evt_id=nil)
-          results = all_result_pages(nil, :body, 'DescribeStackEventsResponse', 'DescribeStackEventsResult', 'StackEvents', 'member') do |options|
-            request(
-              :path => '/',
-              :params => options.merge(
-                'Action' => 'DescribeStackEvents',
-                'StackName' => stack.id
-              )
-            )
-          end
-          events = results.map do |event|
-            Stack::Event.new(
-              stack,
-              :id => event['EventId'],
-              :resource_id => event['PhysicalResourceId'],
-              :resource_name => event['LogicalResourceId'],
-              :resource_logical_id => event['LogicalResourceId'],
-              :resource_state => event['ResourceStatus'].downcase.to_sym,
-              :resource_status => event['ResourceStatus'],
-              :resource_status_reason => event['ResourceStatusReason'],
-              :time => Time.parse(event['Timestamp'])
-            ).valid_state
-          end
-          if(evt_id)
-            idx = events.index{|d| e.id == evt_id}
-            idx = idx ? idx + 1 : 0
-            events.slice(idx, events.size)
-          else
-            events
-          end
-        end
-
-        # Return all new events for event collection
-        #
-        # @param events [Models::Orchestration::Stack::Events]
-        # @return [Array<Models::Orchestration::Stack::Event>]
-        def event_all_new(events)
-          event_all(events.stack, events.all.first.id)
-        end
-
-        # Reload the stack event data from the API
-        #
-        # @param resource [Models::Orchestration::Stack::Event]
-        # @return [Models::Orchestration::Event]
-        def event_reload(event)
-          event.stack.events.reload
-          event.stack.events.get(event.id)
-        end
-
-      end
-    end
-  end
-end