miasma 0.1.0 → 0.2.0

data/lib/miasma/contrib/open_stack.rb

@@ -0,0 +1,334 @@
+require 'miasma'
+require 'miasma/utils/smash'
+require 'time'
+
+module Miasma
+  module Contrib
+
+    # OpenStack API core helper
+    class OpenStackApiCore
+
+      # Authentication helper class
+      class Authenticate
+
+        # @return [Smash] token info
+        attr_reader :token
+        # @return [Smash] credentials in use
+        attr_reader :credentials
+
+        # Create new instance
+        #
+        # @return [self]
+        def initialize(credentials)
+          @credentials = credentials.to_smash
+        end
+
+        # @return [String] username
+        def user
+          load!
+          @user
+        end
+
+        # @return [Smash] remote service catalog
+        def service_catalog
+          load!
+          @service_catalog
+        end
+
+        # @return [String] current API token
+        def api_token
+          if(token.nil? || Time.now > token[:expires])
+            identify_and_load
+          end
+          token[:id]
+        end
+
+        # Identify with authentication endpoint
+        # and load the service catalog
+        #
+        # @return [self]
+        def identity_and_load
+          raise NotImplementedError
+        end
+
+        # @return [Smash] authentication request body
+        def authentication_request
+          raise NotImplementedError
+        end
+
+        protected
+
+        # @return [TrueClass] load authenticator
+        def load!
+          !!api_token
+        end
+
+        # Authentication implementation compatible for v2
+        class Version2 < Authenticate
+
+          # @return [Smash] authentication request body
+          def authentication_request
+            if(credentials[:open_stack_token])
+              auth = Smash.new(
+                :token => Smash.new(
+                  :id => credentials[:open_stack_token]
+                )
+              )
+            else
+              auth = Smash.new(
+                'passwordCredentials' => Smash.new(
+                  'username' => credentials[:open_stack_username],
+                  'password' => credentials[:open_stack_password]
+                )
+              )
+            end
+            if(credentials[:open_stack_tenant_name])
+              auth['tenantName'] = credentials[:open_stack_tenant_name]
+            end
+            auth
+          end
+
+          # Identify with authentication service and load
+          # token information and service catalog
+          #
+          # @return [TrueClass]
+          def identify_and_load
+            result = HTTP.post(
+              File.join(
+                credentials[:open_stack_identity_url],
+                'tokens'
+              ),
+              :json => Smash.new(
+                :auth => authentication_request
+              )
+            )
+            unless(result.status == 200)
+              raise Error::ApiError::AuthenticationError.new('Failed to authenticate', :response => result)
+            end
+            info = MultiJson.load(result.body.to_s).to_smash
+            info = info[:access]
+            @user = info[:user]
+            @service_catalog = info[:serviceCatalog]
+            @token = info[:token]
+            token[:expires] = Time.parse(token[:expires])
+            true
+          end
+
+        end
+
+        # Authentication implementation compatible for v2
+        class Version3 < Authenticate
+
+          # @return [Smash] authentication request body
+          def authentication_request
+            ident = Smash.new(:methods => [])
+            if(credentials[:open_stack_password])
+              ident[:methods] << 'password'
+              ident[:password] = Smash.new(
+                :user => Smash.new(
+                  :password => credentials[:open_stack_password]
+                )
+              )
+              if(credentials[:open_stack_user_id])
+                ident[:password][:user][:id] = credentials[:open_stack_user_id]
+              else
+                ident[:password][:user][:name] = credentials[:open_stack_username]
+              end
+              if(credentials[:open_stack_domain])
+                ident[:password][:user][:domain] = Smash.new(
+                  :name => credentials[:open_stack_domain]
+                )
+              end
+            end
+            if(credentials[:open_stack_token])
+              ident[:methods] << 'token'
+              ident[:token] = Smash.new(
+                :token => Smash.new(
+                  :id => credentials[:open_stack_token]
+                )
+              )
+            end
+            if(credentials[:open_stack_project_id])
+              scope = Smash.new(
+                :project => Smash.new(
+                  :id => credentials[:open_stack_project_id]
+                )
+              )
+            else
+              if(credentials[:open_stack_domain])
+                scope = Smash.new(
+                  :domain => Smash.new(
+                    :name => credentials[:open_stack_domain]
+                  )
+                )
+                if(credentials[:open_stack_project])
+                  scope[:project] = Smash.new(
+                    :name => credentials[:open_stack_project]
+                  )
+                end
+              end
+            end
+            auth = Smash.new(:identity => ident)
+            if(scope)
+              auth[:scope] = scope
+            end
+            auth
+          end
+
+          # Identify with authentication service and load
+          # token information and service catalog
+          #
+          # @return [TrueClass]
+          def identify_and_load
+            result = HTTP.post(
+              File.join(credentials[:open_stack_identity_url], 'tokens'),
+              :json => Smash.new(
+                :auth => authentication_request
+              )
+            )
+            unless(result.status == 200)
+              raise Error::ApiError::AuthenticationError.new('Failed to authenticate!', result)
+            end
+            info = MultiJson.load(result.body.to_s).to_smash[:token]
+            @service_catalog = info.delete(:catalog)
+            @token = Smash.new(
+              :expires => Time.parse(info[:expires_at]),
+              :id => result.headers['X-Subject-Token']
+            )
+            @user = info[:user][:name]
+            true
+          end
+
+        end
+
+      end
+
+      # Common API methods
+      module ApiCommon
+
+        # Set attributes into model
+        #
+        # @param klass [Class]
+        def self.included(klass)
+          klass.class_eval do
+            attribute :open_stack_identity_url, String, :required => true
+            attribute :open_stack_username, String
+            attribute :open_stack_user_id, String
+            attribute :open_stack_password, String
+            attribute :open_stack_token, String
+            attribute :open_stack_region, String
+            attribute :open_stack_tenant_name, String
+            attribute :open_stack_domain, String
+            attribute :open_stack_project, String
+          end
+        end
+
+        # @return [HTTP] with auth token provided
+        def connection
+          super.with_headers('X-Auth-Token' => token)
+        end
+
+        # @return [String] endpoint URL
+        def endpoint
+          open_stack_api.endpoint_for(
+            Utils.snake(self.class.to_s.split('::')[-2]).to_sym,
+            open_stack_region
+          )
+        end
+
+        # @return [String] valid API token
+        def token
+          open_stack_api.api_token
+        end
+
+        # @return [Miasma::Contrib::OpenStackApiCore]
+        def open_stack_api
+          key = "miasma_open_stack_api_#{attributes.checksum}".to_sym
+          memoize(key, :direct) do
+            Miasma::Contrib::OpenStackApiCore.new(attributes)
+          end
+        end
+
+      end
+
+      # @return [Smash] Mapping to external service name
+      API_MAP = Smash.new(
+        'compute' => 'nova',
+        'orchestration' => 'heat',
+        'network' => 'neutron',
+        'identity' => 'keystone'
+      )
+
+      # @return [Miasma::Contrib::OpenStackApiCore::Authenticate]
+      attr_reader :identity
+
+      # Create a new api instance
+      #
+      # @param creds [Smash] credential hash
+      # @return [self]
+      def initialize(creds)
+        @credentials = creds
+        if(creds[:open_stack_identity_url].include?('v3'))
+          @identity = identity_class('Authenticate::Version3').new(creds)
+        elsif(creds[:open_stack_identity_url].include?('v2'))
+          @identity = identity_class('Authenticate::Version2').new(creds)
+        else
+          # @todo allow attribute to override?
+          raise ArgumentError.new('Failed to determine Identity service version')
+        end
+      end
+
+      # @return [Class] class from instance class, falls back to parent
+      def identity_class(i_name)
+        [self.class, Miasma::Contrib::OpenStackApiCore].map do |klass|
+          i_name.split('::').inject(klass) do |memo, key|
+            if(memo.const_defined?(key))
+              memo.const_get(key)
+            else
+              break
+            end
+          end
+        end.compact.first
+      end
+
+      # Provide end point URL for service
+      #
+      # @param api_name [String] name of api
+      # @param region [String] region in use
+      # @return [String] public URL
+      def endpoint_for(api_name, region)
+        api = self.class.const_get(:API_MAP)[api_name]
+        srv = identity.service_catalog.detect do |info|
+          info[:name] == api
+        end
+        unless(srv)
+          raise NotImplementedError.new("No API mapping found for `#{api_name}`")
+        end
+        if(region)
+          point = srv[:endpoints].detect do |endpoint|
+            endpoint[:region].to_s.downcase == region.to_s.downcase
+          end
+        else
+          point = srv[:endpoints].first
+        end
+        if(point)
+          point.fetch(
+            :publicURL,
+            point[:url]
+          )
+        else
+          raise KeyError.new("Lookup failed for `#{api_name}` within region `#{region}`")
+        end
+      end
+
+      # @return [String] API token
+      def api_token
+        identity.api_token
+      end
+
+    end
+  end
+
+  Models::Compute.autoload :OpenStack, 'miasma/contrib/open_stack/compute'
+  Models::Orchestration.autoload :OpenStack, 'miasma/contrib/open_stack/orchestration'
+end

data/lib/miasma/contrib/open_stack/compute.rb

@@ -0,0 +1,105 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    class Compute
+      class OpenStack < Compute
+
+        include Contrib::OpenStackApiCore::ApiCommon
+
+        # @return [Smash] map state to valid internal values
+        SERVER_STATE_MAP = Smash.new(
+          'ACTIVE' => :running,
+          'DELETED' => :terminated,
+          'SUSPENDED' => :stopped,
+          'PASSWORD' => :running
+        )
+
+        def server_save(server)
+          unless(server.persisted?)
+            server.load_data(server.attributes)
+            result = request(
+              :expects => 202,
+              :method => :post,
+              :path => '/servers',
+              :json => {
+                :server => {
+                  :flavorRef => server.flavor_id,
+                  :name => server.name,
+                  :imageRef => server.image_id,
+                  :metadata => server.metadata,
+                  :personality => server.personality,
+                  :key_pair => server.key_name
+                }
+              }
+            )
+            server.id = result.get(:body, :server, :id)
+          else
+            raise "WAT DO I DO!?"
+          end
+        end
+
+        def server_destroy(server)
+          if(server.persisted?)
+            result = request(
+              :expects => 204,
+              :method => :delete,
+              :path => "/servers/#{server.id}"
+            )
+            true
+          else
+            false
+          end
+        end
+
+        def server_change_state(server, state)
+        end
+
+        def server_reload(server)
+          res = servers.reload.all
+          node = res.detect do |s|
+            s.id == server.id
+          end
+          if(node)
+            server.load_data(node.data.dup)
+            server.valid_state
+          else
+            server.data[:state] = :terminated
+            server.dirty.clear
+            server
+          end
+        end
+
+        def server_all
+          result = request(
+            :method => :get,
+            :path => '/servers/detail'
+          )
+          result[:body].fetch(:servers, []).map do |srv|
+            Server.new(
+              self,
+              :id => srv[:id],
+              :name => srv[:name],
+              :image_id => srv.get(:image, :id),
+              :flavor_id => srv.get(:flavor, :id),
+              :state => SERVER_STATE_MAP.fetch(srv[:status], :pending),
+              :addresses_private => srv.fetch(:addresses, :private, []).map{|a|
+                Server::Address.new(
+                  :version => a[:version].to_i, :address => a[:addr]
+                )
+              },
+              :addresses_public => srv.fetch(:addresses, :public, []).map{|a|
+                Server::Address.new(
+                  :version => a[:version].to_i, :address => a[:addr]
+                )
+              },
+              :status => srv[:status],
+              :key_name => srv[:key_name]
+            ).valid_state
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,255 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    class Orchestration
+      class OpenStack < Orchestration
+
+        include Contrib::OpenStackApiCore::ApiCommon
+
+        # @return [Smash] external to internal resource mapping
+        RESOURCE_MAPPING = Smash.new(
+          'OS::Nova::Server' => Smash.new(
+            :api => :compute,
+            :collection => :servers
+          )
+          # 'OS::Heat::AutoScalingGroup' => 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],
+              :created => 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 => 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 => 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.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