miasma 0.0.1 → 0.1.0

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

@@ -0,0 +1,34 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    class AutoScale
+
+      # Abstract auto scale group collection
+      class Groups < Types::Collection
+
+        # Return auto scale groups matching given filter
+        #
+        # @param options [Hash] filter options
+        # @return [Array<Group>]
+        def filter(options={})
+          raise NotImplementedError
+        end
+
+        # @return [Group] collection item class
+        def model
+          Group
+        end
+
+        protected
+
+        # @return [Array<Group>]
+        def perform_population
+          api.group_all
+        end
+
+      end
+
+    end
+  end
+end

data/lib/miasma/models/compute.rb

@@ -0,0 +1,70 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    # Abstract compute API
+    class Compute < Types::Api
+
+      autoload :Server, 'miasma/models/compute/server'
+      autoload :Servers, 'miasma/models/compute/servers'
+
+      # All compute instances
+      #
+      # @return [Types::Collection<Models::Compute::Server>] servers
+      def servers
+        memoize(:servers) do
+          Servers.new(self)
+        end
+      end
+
+      # Filtered compute instances
+      #
+      # @param filter [Hash] search filter
+      # @option filter [Symbol] :state state of server `Server::VALID_COMPUTE_STATES`
+      # @return [Array<Server>]
+      def server_filter(filter={})
+      end
+
+      # Create new server instance
+      #
+      # @param server [Models::Compute::Server]
+      # @return [Models::Compute::Server]
+      def server_save(server)
+        raise NotImplementedError
+      end
+
+      # Reload the server data from the API
+      #
+      # @param server [Models::Compute::Server]
+      # @return [Models::Compute::Server]
+      def server_reload(server)
+        raise NotImplementedError
+      end
+
+      # Delete server instance
+      #
+      # @param server [Models::Compute::Server]
+      # @return [TrueClass, FalseClass]
+      def server_destroy(server)
+        raise NotImplementedError
+      end
+
+      # Return all servers
+      #
+      # @return [Array<Models::Compute::Server>]
+      def server_all
+        raise NotImplementedError
+      end
+
+      # Change server to desired state
+      #
+      # @param server [Models::Compute::Server]
+      # @param action [Symbol] :start, :stop, :restart
+      # @return [TrueClass, FalseClass]
+      def server_change_state(server, action)
+        raise NotImplementedError
+      end
+
+    end
+  end
+end

data/lib/miasma/models/compute/server.rb

@@ -0,0 +1,71 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    class Compute
+      # Abstract server
+      class Server < Types::Model
+
+        # @return [Array<Symbol>] valid compute instance states
+        VALID_COMPUTE_STATES = [:running, :stopped, :pending, :terminated]
+
+        # Data container for networks
+        #
+        # @todo add model link
+        class Network < Types::ThinModel
+          attribute :name, String
+        end
+
+        # Data container for IP addresses
+        class Address < Types::Data
+          attribute :version, Integer, :required => true, :default => 4
+          attribute :address, String, :required => true
+          attribute :label, String
+        end
+
+        attribute :name, String, :required => true
+        attribute :image_id, [String, Numeric], :required => true
+        attribute :flavor_id, [String, Numeric], :required => true
+        attribute :state, Symbol, :allowed => VALID_COMPUTE_STATES
+        attribute :status, String
+        attribute :addresses_public, Address, :multiple => true, :coerce => lambda{|v| Address.new(v)}
+        attribute :addresses_private, Address, :multiple => true, :coerce => lambda{|v| Address.new(v)}
+        attribute :networks, Network, :multiple => true, :coerce => lambda{|v| Network.new(v)}
+        attribute :personality, [Hash, String], :default => {}
+        attribute :metadata, Hash, :coerce => lambda{|o| o.to_smash}
+        attribute :key_name, String
+
+        # @return [Array<Smash>]
+        def addresses
+          addresses_public + addresses_private
+        end
+
+        # @return [String] public IP address
+        def address
+          obj = addresses_public.detect do |addr|
+            addr.version == 4
+          end
+          obj.address if obj
+        end
+
+        protected
+
+        # Proxy save action up to the API
+        def perform_save
+          api.server_save(self)
+        end
+
+        # Proxy reload action up to the API
+        def perform_reload
+          api.server_reload(self)
+        end
+
+        # Proxy destroy action up to the API
+        def perform_destroy
+          api.server_destroy(self)
+        end
+      end
+
+    end
+  end
+end

data/lib/miasma/models/compute/servers.rb

@@ -0,0 +1,35 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    class Compute
+
+      # Abstract server collection
+      class Servers < Types::Collection
+
+        # Return servers matching given filter
+        #
+        # @param options [Hash] filter options
+        # @option options [String] :state current instance state
+        # @return [Array<Server>]
+        def filter(options={})
+          raise NotImplementedError
+        end
+
+        # @return [Server] collection item class
+        def model
+          Server
+        end
+
+        protected
+
+        # @return [Array<Server>]
+        def perform_population
+          api.server_all
+        end
+
+      end
+
+    end
+  end
+end

data/lib/miasma/models/load_balancer.rb

@@ -0,0 +1,55 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    # Abstract load balancer API
+    class LoadBalancer < Types::Api
+
+      autoload :Balancer, 'miasma/models/load_balancer/balancer'
+      autoload :Balancers, 'miasma/models/load_balancer/balancers'
+
+      # Load balancers
+      #
+      # @param filter [Hash] filtering options
+      # @return [Types::Collection<Models::LoadBalancer::Balancer>] auto scale groups
+      def balancers(filter={})
+        memoize(:balancers) do
+          Balancers.new(self)
+        end
+      end
+
+      # Save load balancer
+      #
+      # @param balancer [Models::LoadBalancer::Balancer]
+      # @return [Models::LoadBalancer::Balancer]
+      def balancer_save(balancer)
+        raise NotImplementedError
+      end
+
+      # Reload the balancer data from the API
+      #
+      # @param balancer [Models::LoadBalancer::Balancer]
+      # @return [Models::LoadBalancer::Balancer]
+      def balancer_reload(balancer)
+        raise NotImplementedError
+      end
+
+      # Delete load balancer
+      #
+      # @param balancer [Models::LoadBalancer::Balancer]
+      # @return [TrueClass, FalseClass]
+      def balancer_destroy(balancer)
+        raise NotImplementedError
+      end
+
+      # Return all load balancers
+      #
+      # @param options [Hash] filter
+      # @return [Array<Models::LoadBalancer::Balancer>]
+      def balancer_all(options={})
+        raise NotImplementedError
+      end
+
+    end
+  end
+end

data/lib/miasma/models/load_balancer/balancer.rb

@@ -0,0 +1,72 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    class LoadBalancer
+      # Abstract balancer
+      class Balancer < Types::Model
+
+        class Server < Types::ThinModel
+          model Miasma::Models::Compute::Server
+        end
+
+        class Address < Types::Data
+          attribute :address, String, :required => true
+          attribute :version, Integer, :default => 4
+        end
+
+        class HealthCheck < Types::Data
+          attribute :interval, Integer
+          attribute :target, String, :required => true
+          attribute :healthy_threshold, Integer
+          attribute :unhealthy_threshold, Integer
+          attribute :timeout, Integer
+        end
+
+        class Listener < Types::Data
+          attribute :protocol, String, :required => true
+          attribute :load_balancer_port, Integer, :required => true
+          attribute :instance_protocol, String, :required => true
+          attribute :instance_port, Integer, :required => true
+          attribute :ssl_certificate_id, [Integer, String]
+        end
+
+        attribute :name, String
+        attribute :state, Symbol, :allowed_values => [:active, :pending]
+        attribute :status, String
+        attribute :servers, Server, :multiple => true, :coerce => lambda{|v| Server.new(v)}
+        attribute :public_addresses, Address, :multiple => true, :coerce => lambda{|v| Address.new(v)}
+        attribute :private_addresses, Address, :multiple => true, :coerce => lambda{|v| Address.new(v)}
+        attribute :health_check, HealthCheck, :coerce => lambda{|v| HealthCheck.new(v)}
+        attribute :listeners, Listener, :coerce => lambda{|v| Listener.new(v)}, :multiple => true
+        attribute :created, Time, :coerce => lambda{|v| Time.parse(v.to_s)}
+        attribute :updated, Time, :coerce => lambda{|v| Time.parse(v.to_s)}
+
+        on_missing :reload
+
+        # @return [Array<Address>] all addresses
+        def addresses
+          public_addresses + private_addresses
+        end
+
+        protected
+
+        # Proxy save action up to the API
+        def perform_save
+          api.balancer_save(self)
+        end
+
+        # Proxy reload action up to the API
+        def perform_reload
+          api.balancer_reload(self)
+        end
+
+        # Proxy destroy action up to the API
+        def perform_destroy
+          api.balancer_destroy(self)
+        end
+
+      end
+    end
+  end
+end

data/lib/miasma/models/load_balancer/balancers.rb

@@ -0,0 +1,34 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    class LoadBalancer
+
+      # Abstract load balancer collection
+      class Balancers < Types::Collection
+
+        # Return load balancers matching given filter
+        #
+        # @param options [Hash] filter options
+        # @return [Array<Balancer>]
+        def filter(options={})
+          raise NotImplementedError
+        end
+
+        # @return [Balancer] collection item class
+        def model
+          Balancer
+        end
+
+        protected
+
+        # @return [Array<Balancer>]
+        def perform_population
+          api.balancer_all
+        end
+
+      end
+
+    end
+  end
+end

data/lib/miasma/models/orchestration.rb

@@ -0,0 +1,127 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    # Abstract orchestration API
+    class Orchestration < Types::Api
+
+      autoload :Stack, 'miasma/models/orchestration/stack'
+      autoload :Stacks, 'miasma/models/orchestration/stacks'
+
+      # @return [Smash] mapping of remote type to internal type
+      RESOURCE_MAPPING = Smash.new
+
+      ## mapping example
+      # RESOURCE_MAPPING = Smash.new(
+      #   'AWS::EC2::Instance' => Miasma::Models::Compute::Server
+      # )
+
+      # @return [Array<Symbol>] valid resource states
+      VALID_RESOURCE_STATES = [:create_complete, :create_in_progress, :create_failed,
+        :delete_complete, :delete_in_progress, :delete_failed,
+        :rollback_complete, :rollback_in_progress, :rollback_failed,
+        :update_complete, :update_in_progress, :update_failed,
+        :update_rollback_complete, :update_rollback_in_progress, :update_rollback_failed
+      ]
+
+      # Orchestration stacks
+      #
+      # @param filter [Hash] filtering options
+      # @return [Types::Collection<Models::Orchestration::Stack>] stacks
+      def stacks(args={})
+        memoize(:stacks) do
+          Stacks.new(self)
+        end
+      end
+
+      # Save the stack
+      #
+      # @param stack [Models::Orchestration::Stack]
+      # @return [Models::Orchestration::Stack]
+      def stack_save(stack)
+        raise NotImplementedError
+      end
+
+      # Reload the stack data from the API
+      #
+      # @param stack [Models::Orchestration::Stack]
+      # @return [Models::Orchestration::Stack]
+      def stack_reload(stack)
+        raise NotImplementedError
+      end
+
+      # Delete the stack
+      #
+      # @param stack [Models::Orchestration::Stack]
+      # @return [TrueClass, FalseClass]
+      def stack_destroy(stack)
+        raise NotImplementedError
+      end
+
+      # Return all stacks
+      #
+      # @param options [Hash] filter
+      # @return [Array<Models::Orchestration::Stack>]
+      def stack_all(options={})
+        raise NotImplementedError
+      end
+
+      # Fetch stack template
+      #
+      # @param stack [Stack]
+      # @return [Smash] stack template
+      def stack_template_load(stack)
+        raise NotImplementedError
+      end
+
+      # Validate stack template
+      #
+      # @param stack [Stack]
+      # @return [NilClass, String] nil if valid, string error message if invalid
+      def stack_template_validate(stack)
+        raise NotImplementedError
+      end
+
+      # Return all resources for stack
+      #
+      # @param stack [Models::Orchestration::Stack]
+      # @return [Array<Models::Orchestration::Stack::Resource>]
+      def resource_all(stack)
+        raise NotImplementedError
+      end
+
+      # Reload the stack resource data from the API
+      #
+      # @param resource [Models::Orchestration::Stack::Resource]
+      # @return [Models::Orchestration::Resource]
+      def resource_reload(resource)
+        raise NotImplementedError
+      end
+
+      # Return all events for stack
+      #
+      # @param stack [Models::Orchestration::Stack]
+      # @return [Array<Models::Orchestration::Stack::Event>]
+      def event_all(stack)
+        raise NotImplementedError
+      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)
+        raise NotImplementedError
+      end
+
+      # Reload the stack event data from the API
+      #
+      # @param resource [Models::Orchestration::Stack::Event]
+      # @return [Models::Orchestration::Event]
+      def event_reload(event)
+        raise NotImplementedError
+      end
+
+    end
+  end
+end