miasma 0.3.2 → 0.3.4

data/lib/miasma/models/orchestration/stack.rb

@@ -1,4 +1,4 @@
-require 'miasma'
+require "miasma"
 
 module Miasma
   module Models
@@ -6,57 +6,64 @@ module Miasma
       # Abstract server
       class Stack < Types::Model
 
-        autoload :Resource, 'miasma/models/orchestration/resource'
-        autoload :Resources, 'miasma/models/orchestration/resources'
-        autoload :Event, 'miasma/models/orchestration/event'
-        autoload :Events, 'miasma/models/orchestration/events'
+        # Stack states which are valid to execute update plan
+        VALID_PLAN_STATES = [
+          :create_complete, :update_complete, :update_failed,
+          :rollback_complete, :rollback_failed, :unknown,
+        ]
+
+        autoload :Resource, "miasma/models/orchestration/resource"
+        autoload :Resources, "miasma/models/orchestration/resources"
+        autoload :Event, "miasma/models/orchestration/event"
+        autoload :Events, "miasma/models/orchestration/events"
+        autoload :Plan, "miasma/models/orchestration/plan"
+        autoload :Plans, "miasma/models/orchestration/plans"
 
         include Miasma::Utils::Memoization
 
         # Stack output
         class Output < Types::Data
-
           attribute :key, String, :required => true
           attribute :value, String, :required => true
           attribute :description, String
 
           attr_reader :stack
 
-          def initialize(stack, args={})
+          def initialize(stack, args = {})
             @stack = stack
             super args
           end
-
         end
 
         attribute :name, String, :required => true
         attribute :description, String
-        attribute :state, Symbol, :allowed => Orchestration::VALID_RESOURCE_STATES, :coerce => lambda{|v| v.to_sym}
-        attribute :outputs, Output, :coerce => lambda{|v, stack| Output.new(stack, v) }, :multiple => true
+        attribute :state, Symbol, :allowed => Orchestration::VALID_RESOURCE_STATES, :coerce => lambda { |v| v.to_sym }
+        attribute :outputs, Output, :coerce => lambda { |v, stack| Output.new(stack, v) }, :multiple => true
         attribute :status, String
         attribute :status_reason, String
-        attribute :created, Time, :coerce => lambda{|v| Time.parse(v.to_s)}
-        attribute :updated, Time, :coerce => lambda{|v| Time.parse(v.to_s)}
-        attribute :parameters, Smash, :coerce => lambda{|v| v.to_smash }
-        attribute :template, Smash, :depends => :perform_template_load, :coerce => lambda{|v| v = MultiJson.load(v) if v.is_a?(String); v.to_smash }
+        attribute :created, Time, :coerce => lambda { |v| Time.parse(v.to_s) }
+        attribute :updated, Time, :coerce => lambda { |v| Time.parse(v.to_s) }
+        attribute :parameters, Smash, :coerce => lambda { |v| v.to_smash }
+        attribute :template, Smash, :depends => :perform_template_load, :coerce => lambda { |v| v = MultiJson.load(v) if v.is_a?(String); v.to_smash }
         attribute :template_url, String
         attribute :template_description, String
         attribute :timeout_in_minutes, Integer
-        attribute :tags, Smash, :coerce => lambda{|v| v.to_smash}
+        attribute :tags, Smash, :coerce => lambda { |v| v.to_smash }, :default => Smash.new
         # TODO: This is new in AWS but I like this better for the
         # attribute. For now, keep both but i would like to deprecate
         # out the disable_rollback and provide the same functionality
         # via this attribute.
-        attribute :on_failure, String, :allowed => %w(nothing rollback delete), :coerce => lambda{|v| v.to_s.downcase}
+        attribute :on_failure, String, :allowed => %w(nothing rollback delete), :coerce => lambda { |v| v.to_s.downcase }
         attribute :disable_rollback, [TrueClass, FalseClass]
         attribute :notification_topics, String, :multiple => true
         attribute :capabilities, String, :multiple => true
+        attribute :plan, Plan, :depends => :load_plan
 
         on_missing :reload
 
         # Overload the loader so we can extract resources,
         # events, and outputs
-        def load_data(args={})
+        def load_data(args = {})
           args = args.to_smash
           @resources = (args.delete(:resources) || []).each do |r|
             Resource.new(r)
@@ -75,6 +82,45 @@ module Miasma
           perform_template_validate
         end
 
+        # Create a new stack plan
+        #
+        # @return [Plan]
+        def plan_generate
+          if plan
+            raise Miasma::Error::OrchestrationError::StackPlanExists.new(
+              "Plan already exists for this stack"
+            )
+          else
+            perform_plan
+          end
+        end
+
+        # Execute current execute
+        #
+        # @return [self]
+        def plan_execute
+          if dirty?(:plan)
+            perform_plan_execute
+          else
+            raise Miasma::Error::OrchestrationError::InvalidStackPlan.new(
+              "This stack instance does not have a generated plan"
+            )
+          end
+        end
+
+        # Delete the current plan
+        #
+        # @return [self]
+        def plan_destroy
+          if dirty?(:plan)
+            perform_plan_destroy
+          else
+            raise Miasma::Error::OrchestrationError::InvalidStackPlan.new(
+              "This stack instance does not have a generated plan"
+            )
+          end
+        end
+
         # Override to scrub custom caches
         #
         # @return [self]
@@ -96,6 +142,13 @@ module Miasma
           end
         end
 
+        # @return [Plans]
+        def plans
+          memoize(:plans) do
+            Plans.new(self)
+          end
+        end
+
         # @return [Resources]
         def resources
           memoize(:resources) do
@@ -111,6 +164,41 @@ module Miasma
 
         protected
 
+        # Stack is in valid state to generate plan
+        #
+        # @return [TrueClass, FalseClass]
+        def planable?
+          state.nil? || VALID_PLAN_STATES.include?(state)
+        end
+
+        # Proxy load plan action up to the API
+        def load_plan
+          memoize(:plan) do
+            api.stack_plan_load(self)
+          end
+        end
+
+        # Proxy plan action up to the API
+        def perform_plan
+          if planable?
+            api.stack_plan(self)
+          else
+            raise Error::OrchestrationError::InvalidPlanState.new(
+              "Stack state `#{state}` is not valid for plan generation"
+            )
+          end
+        end
+
+        # Proxy plan execute action up to the API
+        def perform_plan_execute
+          api.stack_plan_execute(self)
+        end
+
+        # Proxy plan delete action up to the API
+        def perform_plan_destroy
+          api.stack_plan_destroy(self)
+        end
+
         # Proxy save action up to the API
         def perform_save
           api.stack_save(self)
@@ -129,7 +217,7 @@ module Miasma
         # Proxy validate action up to API
         def perform_template_validate
           error = api.stack_template_validate(self)
-          if(error)
+          if error
             raise Error::OrchestrationError::InvalidTemplate.new(error)
           end
           true
@@ -142,9 +230,7 @@ module Miasma
             true
           end
         end
-
       end
-
     end
   end
 end

data/lib/miasma/models/orchestration/stacks.rb

@@ -1,4 +1,4 @@
-require 'miasma'
+require "miasma"
 
 module Miasma
   module Models
@@ -12,7 +12,7 @@ module Miasma
         # @param options [Hash] filter options
         # @option options [String] :state current stack state
         # @return [Array<Stack>]
-        def filter(options={})
+        def filter(options = {})
           raise NotImplementedError
         end
 
@@ -30,15 +30,13 @@ module Miasma
 
         # @return [Stack]
         def perform_get(ident)
-          if(api.respond_to?(:stack_get))
+          if api.respond_to?(:stack_get)
             api.stack_get(ident)
           else
             super
           end
         end
-
       end
-
     end
   end
 end

data/lib/miasma/models/queues.rb

@@ -0,0 +1 @@
+

data/lib/miasma/models/queuing.rb

@@ -0,0 +1,72 @@
+require "miasma"
+
+module Miasma
+  module Models
+    # Abstract queue API
+    class Queuing < Types::API
+      autoload :Queue, "miasma/models/queuing/queue"
+      autoload :Queues, "miasma/models/queuing/queues"
+
+      # Queues
+      #
+      # @param filter [Hash] filtering options
+      # @return [Types::Collections<Models::Queuing::Queue>] queues
+      def queues(filter = {})
+        memoize(:queues) do
+          Queues.new(self)
+        end
+      end
+
+      # Save the queue
+      #
+      # @param queue [Models::Queuing::Queue]
+      # @return [Models::Queuing::Queue]
+      def queue_save(queue)
+        raise NotImplementedError
+      end
+
+      # Reload the queue data from the API
+      #
+      # @param queue [Models::Queuing::Queue]
+      # @return [Models::Queuing::Queue]
+      def queue_reload(queue)
+        raise NotImplementedError
+      end
+
+      # Delete the queue
+      #
+      # @param queue [Models::Queuing::Queue]
+      # @return [TrueClass, FalseClass]
+      def queue_destroy(queue)
+        raise NotImplementedError
+      end
+
+      # Return all queues
+      #
+      # @param options [Hash] filter
+      # @return [Array<Models::Queuing::Queue>]
+      def queue_all(options = {})
+        raise NotImplementedError
+      end
+
+      # Deliver message(s) to queue
+      #
+      # @param queue [Models::Queuing::Queue]
+      # @param msg_or_msgs [String, Array<String>] message(s) to deliver
+      # @param options [Hash] delivery options
+      # @return [Receipt]
+      def queue_deliver(queue, msg_or_msgs, options = {})
+        raise NotImplementedError
+      end
+
+      # Receive message(s) from queue
+      #
+      # @param queue [Models::Queuing::Queue]
+      # @param options [Hash] delivery options
+      # @return [Queue::Message, Array<Queue::Message>]
+      def queue_receive(queue, options = {})
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/miasma/models/queuing/queue.rb

@@ -0,0 +1,77 @@
+require "miasma"
+
+module Miasma
+  module Models
+    class Queuing
+      # Abstract balancer
+      class Queue < Types::Model
+        class Message < Types::Data
+          attribute :origin, Queue, :required => true
+          attribute :content, String, :required => true
+          attribute :created, Time
+          attribute :updated, Time
+          attribute :timeout, Integer
+        end
+
+        class Receipt < Types::Data
+          attribute :message, String, :required => true
+          attribute :checksum, String
+        end
+
+        attribute :name, String, :required => true
+        attribute :created, Time, :required => true
+        attribute :updated, Time
+        attribute :maximum_message_size, Integer
+        attribute :messages_available, Integer
+
+        on_missing :reload
+
+        # Deliver message(s) to the queue
+        #
+        # @param msg_or_msgs [String, Array<String>]
+        # @param options [Hash]
+        # @return [Array<Receipt>]
+        def deliver(msg_or_msgs, options = {})
+          result = perform_delivery(msg_or_msgs, options)
+          result.is_a?(Array) ? result : [result]
+        end
+
+        # Receive message(s) from the queue
+        #
+        # @param options [Hash]
+        # @return [Array<Message>]
+        def receive(options = {})
+          result = perform_receive(options)
+          result.is_a?(Array) ? result : [result]
+        end
+
+        protected
+
+        # Proxy delivery action up to the API
+        def perform_delivery(msg, options = {})
+          api.queue_deliver(self, msg, options)
+        end
+
+        # Proxy receive action up to the API
+        def perform_receive(options = {})
+          api.queue_receive(self, options)
+        end
+
+        # Proxy save action up to the API
+        def perform_save
+          api.queue_save(self)
+        end
+
+        # Proxy reload action up to the API
+        def perform_reload
+          api.queue_reload(self)
+        end
+
+        # Proxy destroy action up to the API
+        def perform_destroy
+          api.queue_destroy(self)
+        end
+      end
+    end
+  end
+end

data/lib/miasma/models/queuing/queues.rb

@@ -0,0 +1,32 @@
+require "miasma"
+
+module Miasma
+  module Models
+    class Queuing
+
+      # Abstract queues collection
+      class Queues < Types::Collection
+
+        # Return queues matching given filter
+        #
+        # @param options [Hash] filter options
+        # @return [Array<Queue>]
+        def filter(options = {})
+          raise NotImplementedError
+        end
+
+        # @return [Queue] collection item class
+        def model
+          Queue
+        end
+
+        protected
+
+        # @return [Array<Queue>]
+        def perform_population
+          api.queue_all
+        end
+      end
+    end
+  end
+end

data/lib/miasma/models/storage.rb

@@ -1,4 +1,4 @@
-require 'miasma'
+require "miasma"
 
 module Miasma
   module Models
@@ -6,20 +6,20 @@ module Miasma
     class Storage < Types::Api
 
       # @return [Integer] max bytes allowed for storing body in string
-      MAX_BODY_SIZE_FOR_STRINGIFY = (1024**2) * 10
+      MAX_BODY_SIZE_FOR_STRINGIFY = (1024 ** 2) * 10
       # @return [Integer] chunking size for reading IO
-      READ_BODY_CHUNK_SIZE = (1024**2) * 5
+      READ_BODY_CHUNK_SIZE = (1024 ** 2) * 5
 
-      autoload :Buckets, 'miasma/models/storage/buckets'
-      autoload :Bucket, 'miasma/models/storage/bucket'
-      autoload :Files, 'miasma/models/storage/files'
-      autoload :File, 'miasma/models/storage/file'
+      autoload :Buckets, "miasma/models/storage/buckets"
+      autoload :Bucket, "miasma/models/storage/bucket"
+      autoload :Files, "miasma/models/storage/files"
+      autoload :File, "miasma/models/storage/file"
 
       # Storage buckets
       #
       # @param filter [Hash] filtering options
       # @return [Types::Collection<Models::Storage::Bucket>] buckets
-      def buckets(args={})
+      def buckets(args = {})
         memoize(:buckets) do
           Buckets.new(self)
         end
@@ -87,7 +87,6 @@ module Miasma
       def file_reload(file)
         raise NotImplementedError
       end
-
     end
   end
 end