miasma 0.0.1 → 0.1.0

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

@@ -0,0 +1,85 @@
+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 = request(
+            :path => '/',
+            :params => params
+          )
+          [result.get(:body, 'DescribeAutoScalingGroupsResponse', 'DescribeAutoScalingGroupsResult', 'AutoScalingGroups', 'member')].flatten(1).compact.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

@@ -0,0 +1,112 @@
+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 = srv[:instancesSet][:item]
+            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
+
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,185 @@
+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 = request(
+            :path => '/',
+            :params => params
+          )
+          [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

@@ -0,0 +1,338 @@
+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
+          end
+          descriptions = [
+            request(:path => '/', :params => d_params).get(
+              :body, 'DescribeStacksResponse', 'DescribeStacksResult', 'Stacks', 'member'
+            )
+          ].flatten(1).compact
+          lists = request(:path => '/', :params => l_params)
+          [
+            lists.get(
+              :body, 'ListStacksResponse', 'ListStacksResult',
+              'StackSummaries', 'member'
+            )
+          ].flatten(1).compact.map do |stk|
+            desc = descriptions.detect do |d_stk|
+              d_stk['StackId'] == stk['StackId']
+            end || Smash.new
+            stk.merge!(desc)
+            next if stack && stack.id != stk['StackId']
+            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'],
+              :creation_time => stk['CreationTime'],
+              :updated_time => stk['LastUpdatedTime'],
+              :notification_topics => [stk.get('NotificationARNs', 'member')].flatten(1).compact,
+              :timeout_in_minutes => stk['TimeoutInMinutes'],
+              :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 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)
+          result = request(
+            :path => '/',
+            :params => Smash.new(
+              'Action' => 'DescribeStackResources',
+              'StackName' => stack.id
+            )
+          )
+          [
+            result.fetch(
+              :body, 'DescribeStackResourcesResponse',
+              'DescribeStackResourcesResult',
+              'StackResources', 'member', []
+            )
+          ].flatten(1).compact.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_time => 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