miasma 0.0.1 → 0.1.0

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

@@ -0,0 +1,255 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    class Orchestration
+      class Rackspace < Orchestration
+
+        include Contrib::RackspaceApiCore::ApiCommon
+
+        # @return [Smash] external to internal resource mapping
+        RESOURCE_MAPPING = Smash.new(
+          'Rackspace::Cloud::Server' => Smash.new(
+            :api => :compute,
+            :collection => :servers
+          ),
+          'Rackspace::AutoScale::Group' => Smash.new(
+            :api => :auto_scale,
+            :collection => :groups
+          )
+        )
+
+        # Save the stack
+        #
+        # @param stack [Models::Orchestration::Stack]
+        # @return [Models::Orchestration::Stack]
+        def stack_save(stack)
+          if(stack.persisted?)
+            stack.load_data(stack.attributes)
+            result = request(
+              :expects => 202,
+              :method => :put,
+              :path => "/stacks/#{stack.name}/#{stack.id}",
+              :json => {
+                :stack_name => stack.name,
+                :template => MultiJson.dump(stack.template),
+                :parameters => stack.parameters || {}
+              }
+            )
+            stack.valid_state
+          else
+            stack.load_data(stack.attributes)
+            result = request(
+              :expects => 201,
+              :method => :post,
+              :path => '/stacks',
+              :json => {
+                :stack_name => stack.name,
+                :template => MultiJson.dump(stack.template),
+                :parameters => stack.parameters || {},
+                :disable_rollback => (!!stack.disable_rollback).to_s
+              }
+            )
+            stack.id = result.get(:body, :stack, :id)
+            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?)
+            result = request(
+              :method => :get,
+              :path => "/stacks/#{stack.name}/#{stack.id}",
+              :expects => 200
+            )
+            stk = result.get(:body, :stack)
+            stack.load_data(
+              :id => stk[:id],
+              :capabilities => stk[:capabilities],
+              :creation_time => Time.parse(stk[:creation_time]),
+              :description => stk[:description],
+              :disable_rollback => stk[:disable_rollback].to_s.downcase == 'true',
+              :notification_topics => stk[:notification_topics],
+              :name => stk[:stack_name],
+              :state => stk[:stack_status].downcase.to_sym,
+              :status => stk[:stack_status],
+              :status_reason => stk[:stack_status_reason],
+              :template_description => stk[:template_description],
+              :timeout_in_minutes => stk[:timeout_mins].to_s.empty? ? nil : stk[:timeout_mins].to_i,
+              :updated_time => stk[:updated_time].to_s.empty? ? nil : Time.parse(stk[:updated_time]),
+              :parameters => stk.fetch(:parameters, Smash.new),
+              :outputs => stk.fetch(:outputs, []).map{ |output|
+                Smash.new(
+                  :key => output[:output_key],
+                  :value => output[:output_value],
+                  :description => output[:description]
+                )
+              }
+            ).valid_state
+          end
+          stack
+        end
+
+        # Delete the stack
+        #
+        # @param stack [Models::Orchestration::Stack]
+        # @return [TrueClass, FalseClass]
+        def stack_destroy(stack)
+          if(stack.persisted?)
+            request(
+              :method => :delete,
+              :path => "/stacks/#{stack.name}/#{stack.id}",
+              :expects => 204
+            )
+            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(
+              :method => :get,
+              :path => "/stacks/#{stack.name}/#{stack.id}/template"
+            )
+            result.fetch(:body, Smash.new)
+          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 => '/validate',
+              :json => Smash.new(
+                :template => stack.template
+              )
+            )
+            nil
+          rescue Error::ApiError::RequestError => e
+            MultiJson.load(e.response.body.to_s).to_smash.get(: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(options={})
+          result = request(
+            :method => :get,
+            :path => '/stacks'
+          )
+          result.fetch(:body, :stacks, []).map do |s|
+            Stack.new(
+              self,
+              :id => s[:id],
+              :creation_time => Time.parse(s[:creation_time]),
+              :description => s[:description],
+              :name => s[:stack_name],
+              :state => s[:stack_status].downcase.to_sym,
+              :status => s[:stack_status],
+              :status_reason => s[:stack_status_reason],
+              :updated_time => s[:updated_time].to_s.empty? ? nil : Time.parse(s[:updated_time])
+            ).valid_state
+          end
+        end
+
+        # Return all resources for stack
+        #
+        # @param stack [Models::Orchestration::Stack]
+        # @return [Array<Models::Orchestration::Stack::Resource>]
+        def resource_all(stack)
+          result = request(
+            :method => :get,
+            :path => "/stacks/#{stack.name}/#{stack.id}/resources",
+            :expects => 200
+          )
+          result.fetch(:body, :resources, []).map do |resource|
+            Stack::Resource.new(
+              stack,
+              :id => resource[:physical_resource_id],
+              :name => resource[:resource_name],
+              :type => resource[:resource_type],
+              :logical_id => resource[:logical_resource_id],
+              :state => resource[:resource_status].downcase.to_sym,
+              :status => resource[:resource_status],
+              :status_reason => resource[:resource_status_reason],
+              :updated_time => Time.parse(resource[:updated_time])
+            ).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, marker = nil)
+          params = marker ? {:marker => marker} : {}
+          result = request(
+            :path => "/stacks/#{stack.name}/#{stack.id}/events",
+            :method => :get,
+            :expects => 200,
+            :params => params
+          )
+          result.fetch(:body, :events, []).map do |event|
+            Stack::Event.new(
+              stack,
+              :id => event[:id],
+              :resource_id => event[:physical_resource_id],
+              :resource_name => event[:resource_name],
+              :resource_logical_id => event[:logical_resource_id],
+              :resource_state => event[:resource_status].downcase.to_sym,
+              :resource_status => event[:resource_status],
+              :resource_status_reason => event[:resource_status_reason],
+              :time => Time.parse(event[:event_time])
+            ).valid_state
+          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

data/lib/miasma/error.rb

@@ -0,0 +1,89 @@
+require 'miasma'
+
+module Miasma
+  # Generic Error class
+  class Error < StandardError
+
+    # Create new error instance
+    #
+    # @param msg [String] error message
+    # @param args [Hash] optional arguments
+    # @return [self]
+    def initialize(msg, args={})
+      super msg
+    end
+
+    # Api related errors
+    class ApiError < Error
+
+      # @return [HTTP::Response] result of bad request
+      attr_reader :response
+      # @return [String] response error message
+      attr_reader :response_error_msg
+
+      # Create new API error instance
+      #
+      # @param msg [String] error message
+      # @param args [Hash] optional arguments
+      # @option args [HTTP::Response] :response response from request
+      def initialize(msg, args={})
+        super
+        @response = args.to_smash[:response]
+        extract_error_message(@response)
+      end
+
+      # @return [String] provides response error suffix
+      def message
+        [@message, @response_error_msg].compact.join(' - ')
+      end
+
+      # Attempt to extract error message from response
+      #
+      # @param response [HTTP::Response]
+      # @return [String, NilClass]
+      def extract_error_message(response)
+        begin
+          begin
+            content = MultiJson.load(response.body.to_s).to_smash
+            msgs = content.values.map do |arg|
+              arg[:message]
+            end.compact
+            unless(msgs.empty?)
+              @response_error_msg = msgs.join(' - ')
+            end
+          rescue MultiJson::ParseError
+            begin
+              content = MultiXml.parse(response.body.to_s).to_smash
+              if(content.get('ErrorResponse', 'Error'))
+                @response_error_msg = "#{content.get('ErrorResponse', 'Error', 'Code')}: #{content.get('ErrorResponse', 'Error', 'Message')}"
+              end
+            rescue MultiXml::ParseError
+              content = Smash.new
+            end
+          rescue
+            # do nothing
+          end
+        end
+        @response_error_msg
+      end
+
+      # Api request error
+      class RequestError < ApiError; end
+
+      # Api authentication error
+      class AuthenticationError < ApiError; end
+
+    end
+
+    # Orchestration error
+    class OrchestrationError < Error
+      # Template failed to validate
+      class InvalidTemplate < OrchestrationError
+      end
+    end
+
+    # Invalid modification request
+    class ImmutableError < Error; end
+
+  end
+end

data/lib/miasma/models.rb

@@ -0,0 +1,14 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    autoload :AutoScale, 'miasma/models/auto_scale'
+    autoload :BlockStorage, 'miasma/models/block_storage'
+    autoload :Compute, 'miasma/models/compute'
+    autoload :Dns, 'miasma/models/dns'
+    autoload :LoadBalancer, 'miasma/models/load_balancer'
+    autoload :Orchestration, 'miasma/models/orchestration'
+    autoload :Queues, 'miasma/models/queues'
+    autoload :Storage, 'miasma/models/storage'
+  end
+end

data/lib/miasma/models/auto_scale.rb

@@ -0,0 +1,55 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    # Abstract auto scale API
+    class AutoScale < Types::Api
+
+      autoload :Group, 'miasma/models/auto_scale/group'
+      autoload :Groups, 'miasma/models/auto_scale/groups'
+
+      # Auto scale groups
+      #
+      # @param filter [Hash] filtering options
+      # @return [Types::Collection<Models::AutoScale::Groups>] auto scale groups
+      def groups(filter={})
+        memoize(:groups) do
+          Groups.new(self)
+        end
+      end
+
+      # 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)
+        raise NotImplementedError
+      end
+
+      # Delete auto scale group
+      #
+      # @param group [Models::AutoScale::Group]
+      # @return [TrueClass, FalseClass]
+      def group_destroy(group)
+        raise NotImplementedError
+      end
+
+      # Return all auto scale groups
+      #
+      # @param options [Hash] filter
+      # @return [Array<Models::AutoScale::Group>]
+      def group_all(options={})
+        raise NotImplementedError
+      end
+
+    end
+  end
+end

data/lib/miasma/models/auto_scale/group.rb

@@ -0,0 +1,64 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    class AutoScale
+      # Abstract group
+      class Group < Types::Model
+
+        class Server < Types::ThinModel
+
+          model Miasma::Models::Compute::Server
+          attribute :name, String
+
+          # @return [Miasma::Models::Compute::Server]
+          def expand
+            api.api_for(:compute).servers.get(self.id || self.name)
+          end
+        end
+
+        class Balancer < Types::ThinModel
+
+          model Miasma::Models::LoadBalancer::Balancer
+          attribute :name, String
+
+          # @return [Miasma::Models::LoadBalancer::Balancer]
+          def expand
+            api.api_for(:load_balancer).balancers.get(self.id || self.name)
+          end
+
+        end
+
+        attribute :name, String, :required => true
+        attribute :created, Time, :coerce => lambda{|v| Time.parse(v.to_s)}
+        attribute :load_balancers, Balancer, :multiple => true, :coerce => lambda{|v,obj| Balancer.new(obj.api, v)}
+        attribute :minimum_size, Integer, :coerce => lambda{|v| v.to_i}
+        attribute :maximum_size, Integer, :coerce => lambda{|v| v.to_i}
+        attribute :desired_size, Integer, :coerce => lambda{|v| v.to_i}
+        attribute :current_size, Integer, :coerce => lambda{|v| v.to_i}
+        attribute :state, Symbol, :allowed_values => []
+        attribute :servers, Server, :multiple => true, :coerce => lambda{|v,obj| Server.new(obj.api, v)}
+
+        on_missing :reload
+
+        protected
+
+        # Proxy save action up to the API
+        def perform_save
+          api.group_save(self)
+        end
+
+        # Proxy reload action up to the API
+        def perform_reload
+          api.group_reload(self)
+        end
+
+        # Proxy destroy action up to the API
+        def perform_destroy
+          api.group_destroy(self)
+        end
+
+      end
+    end
+  end
+end