miasma 0.0.1 → 0.1.0

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

@@ -0,0 +1,38 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    class Orchestration
+      class Stack
+
+        # Stack event
+        class Event < Types::Model
+
+          attribute :time, Time, :required => true
+          attribute :resource_id, [String, Numeric], :required => true
+          attribute :resource_logical_id, [String, Numeric]
+          attribute :resource_name, String
+          attribute :resource_state, Symbol, :allowed_values => Orchestration::VALID_RESOURCE_STATES
+          attribute :resource_status, String
+          attribute :resource_status_reason, String
+
+          attr_reader :stack
+
+          def initialize(stack, args={})
+            @stack = stack
+            super stack.api, args
+          end
+
+          # @return [Resource]
+          def resource
+            stack.resources.get(self.resource_id)
+          end
+
+          include Utils::Immutable
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    class Orchestration
+      class Stack
+
+        # Abstract stack resources collection
+        class Events < Types::Collection
+
+          # @return [Miasma::Models::Orchestration::Stack]
+          attr_reader :stack
+
+          # Override to capture originating stack
+          #
+          # @param stack [Stack]
+          def initialize(stack)
+            @stack = stack
+            super stack.api
+          end
+
+          # Return events matching given filter
+          #
+          # @param options [Hash] filter options
+          # @return [Array<Event>]
+          def filter(options={})
+            raise NotImplementedError
+          end
+
+          # Build a new event instance
+          #
+          # @param args [Hash] creation options
+          # @return [Event]
+          def build(args={})
+            Event.new(stack, args.to_smash)
+          end
+
+          # @return [Event] collection item class
+          def model
+            Event
+          end
+
+          # Fetch any new events and add to collection
+          #
+          # @return [Array<Event>] new events fetched
+          def update!
+            new_events = api.event_all_new(self)
+            self.all += new_events
+            new_events
+          end
+
+          protected
+
+          # @return [Array<Event>]
+          def perform_population
+            api.event_all(stack)
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    class Orchestration
+      class Stack
+
+        # Stack resource
+        class Resource < Types::Model
+
+          attribute :name, String, :required => true
+          attribute :type, String, :required => true
+          attribute :logical_id, [String, Numeric]
+          attribute :state, Symbol, :required => true, :allowed_values => Orchestration::VALID_RESOURCE_STATES
+          attribute :status, [String, Symbol], :required => true, :coerce => lambda{|v| v.to_s.to_sym}
+          attribute :status_reason, String
+          attribute :updated_time, Time, :coerce => lambda{|v| Time.parse(v.to_s)}
+
+          attr_reader :stack
+
+          def initialize(stack, args={})
+            @stack = stack
+            super stack.api, args
+          end
+
+          # @return [Miasma::Types::Model] provides mapped resource class
+          def dereference
+            # Insert provider to namespace
+            provider_const = self.class.name.split('::').insert(3, Utils.camel(api.provider))
+            provider_const.slice!(-2, 2)
+            # Insert mapping constant name and fetch
+           const = provider_const.push(:RESOURCE_MAPPING).inject(Object) do |memo, konst|
+              res = memo.const_get(konst)
+              break unless res
+              res
+            end
+            unless(const[self.type])
+              raise KeyError.new "Failed to locate requested mapping! (`#{self.type}`)"
+            end
+            const[self.type]
+          end
+
+          # Provide proper instance from resource
+          #
+          # @return [Miasma::Types::Model]
+          def expand
+            info = dereference
+            api.api_for(info[:api]).send(info[:collection]).get(self.id)
+          end
+          alias_method :instance, :expand
+
+          # Proxy reload action up to the API
+          def perform_reload
+            api.resource_reload(self)
+          end
+
+          # Resource is within the collection on the api
+          #
+          # @param api [Symbol] api type (:compute, :auto_scale, etc)
+          # @param collection [Symbol] collection within api (:servers, :groups, etc)
+          # @return [TrueClass, FalseClass]
+          def within?(api, collection)
+            begin
+              info = dereference
+              info[:api] == api &&
+                info[:collection] == collection
+            rescue KeyError
+              false
+            end
+          end
+
+          include Utils::Immutable
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    class Orchestration
+      class Stack
+
+        # Abstract stack resources collection
+        class Resources < Types::Collection
+
+          # @return [Miasma::Models::Orchestration::Stack]
+          attr_reader :stack
+
+          # Override to capture originating stack
+          #
+          # @param stack [Stack]
+          def initialize(stack)
+            @stack = stack
+            super stack.api
+          end
+
+          # Return resources matching given filter
+          #
+          # @param options [Hash] filter options
+          # @return [Array<Resources>]
+          def filter(options={})
+            raise NotImplementedError
+          end
+
+          # Build a new resource instance
+          #
+          # @param args [Hash] creation options
+          # @return [Resource]
+          def build(args={})
+            Resource.new(stack, args.to_smash)
+          end
+
+          # @return [Resource] collection item class
+          def model
+            Resource
+          end
+
+          protected
+
+          # @return [Array<Resources>]
+          def perform_population
+            api.resource_all(stack)
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,144 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    class Orchestration
+      # 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'
+
+        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={})
+            @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 :status, String
+        attribute :status_reason, String
+        attribute :creation_time, Time, :coerce => lambda{|v| Time.parse(v.to_s)}
+        attribute :updated_time, 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 :disable_rollback, [TrueClass, FalseClass]
+        attribute :notification_topics, String, :multiple => true
+        attribute :capabilities, String, :multiple => true
+
+        on_missing :reload
+
+        # Overload the loader so we can extract resources,
+        # events, and outputs
+        def load_data(args={})
+          args = args.to_smash
+          @resources = (args.delete(:resources) || []).each do |r|
+            Resource.new(r)
+          end
+          @events = (args.delete(:events) || []).each do |e|
+            Event.new(e)
+          end
+          super args
+        end
+
+        # Validate the stack template
+        #
+        # @return [TrueClass]
+        # @raises [Miasma::Error::OrchestrationError::InvalidTemplate]
+        def validate
+          perform_template_validate
+        end
+
+        # Override to scrub custom caches
+        #
+        # @return [self]
+        def reload
+          clear_memoizations!
+          remove = data.keys.find_all do |k|
+            ![:id, :name].include?(k.to_sym)
+          end
+          remove.each do |k|
+            data.delete(k)
+          end
+          super
+        end
+
+        # @return [Events]
+        def events
+          memoize(:events) do
+            Events.new(self)
+          end
+        end
+
+        # @return [Resources]
+        def resources
+          memoize(:resources) do
+            Resources.new(self)
+          end
+        end
+
+        # Always perform save. Remove dirty check
+        # provided by default.
+        def save
+          perform_save
+        end
+
+        protected
+
+        # Proxy save action up to the API
+        def perform_save
+          api.stack_save(self)
+        end
+
+        # Proxy reload action up to the API
+        def perform_reload
+          api.stack_reload(self)
+        end
+
+        # Proxy destroy action up to the API
+        def perform_destroy
+          api.stack_destroy(self)
+        end
+
+        # Proxy validate action up to API
+        def perform_template_validate
+          error = api.stack_template_validate(self)
+          if(error)
+            raise Error::OrchestrationError::InvalidTemplate.new(error)
+          end
+          true
+        end
+
+        # Proxy template loading up to the API
+        def perform_template_load
+          memoize(:template) do
+            self.data[:template] = api.stack_template_load(self)
+            true
+          end
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    class Orchestration
+
+      # Abstract stack collection
+      class Stacks < Types::Collection
+
+        # Locate stack by name or ID
+        #
+        # @param ident [String, Numeric] name or ID
+        # @return [Stack]
+        def get(ident)
+          all.detect do |stack|
+            stack.id.to_s == ident.to_s ||
+              stack.name.to_s == ident.to_s
+          end
+        end
+
+        # Return stacks matching given filter
+        #
+        # @param options [Hash] filter options
+        # @option options [String] :state current stack state
+        # @return [Array<Stack>]
+        def filter(options={})
+          raise NotImplementedError
+        end
+
+        # @return [Stack] collection items class
+        def model
+          Stack
+        end
+
+        protected
+
+        # @return [Array<Stack>]
+        def perform_population
+          api.stack_all
+        end
+
+      end
+
+    end
+  end
+end

data/lib/miasma/models/storage.rb

@@ -0,0 +1,60 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    # Abstract storage API
+    class Storage < Types::Api
+
+      # Storage buckets
+      #
+      # @param filter [Hash] filtering options
+      # @return [Types::Collection<Models::Storage::Bucket>] buckets
+      def buckets(args={})
+        Buckets.new(self)
+      end
+
+      # Create a new bucket
+      #
+      # @param bucket [Models::Storage::Bucket]
+      # @return [Models::Storage::Bucket]
+      def bucket_create(bucket)
+        raise NotImplementedError
+      end
+
+      # Destroy bucket
+      #
+      # @param bucket [Models::Storage::Bucket]
+      # @return [TrueClass, FalseClass]
+      def bucket_delete(bucket)
+        raise NotImplementedError
+      end
+
+      # Rename bucket
+      #
+      # @param bucket [Models::Storage::Bucket]
+      # @param new_name [String]
+      # @return [Models::Storage::Bucket] new bucket with updated name
+      def bucket_rename(bucket, new_name)
+        raise NotImplementedError
+      end
+
+      # Return all buckets
+      #
+      # @return [Array<Models::Storage::Bucket>]
+      def bucket_all
+        raise NotImplementedError
+      end
+
+      # Return all files within bucket
+      #
+      # @param bucket [Bucket]
+      # @return [Array<File>]
+      def file_all(bucket)
+        raise NotImplementedError
+      end
+
+
+
+    end
+  end
+end