miasma 0.1.0 → 0.2.0

data/lib/miasma/contrib/rackspace.rb

@@ -1,19 +1,38 @@
 require 'miasma'
-require 'miasma/utils/smash'
-require 'time'
+require 'miasma/contrib/open_stack'
 
 module Miasma
   module Contrib
 
     # Rackspace API core helper
-    class RackspaceApiCore
+    class RackspaceApiCore < OpenStackApiCore
+
+      # Authentication helper class
+      class Authenticate < OpenStackApiCore::Authenticate
+        # Authentication implementation compatible for v2
+        class Version2 < OpenStackApiCore::Authenticate::Version2
+
+          # @return [Smash] authentication request body
+          def authentication_request
+            Smash.new(
+              'RAX-KSKEY:apiKeyCredentials' => Smash.new(
+                'username' => credentials[:open_stack_username],
+                'apiKey' => credentials[:open_stack_token]
+              )
+            )
+          end
+
+        end
+      end
 
+      # Common API methods
       module ApiCommon
 
         # Set attributes into model
         #
         # @param klass [Class]
         def self.included(klass)
+          klass.attributes.clear
           klass.class_eval do
             attribute :rackspace_api_key, String, :required => true
             attribute :rackspace_username, String, :required => true
@@ -21,26 +40,8 @@ module Miasma
           end
         end
 
-        # @return [HTTP] with auth token provided
-        def connection
-          super.with_headers('X-Auth-Token' => token)
-        end
-
-        # @return [String] endpoint URL
-        def endpoint
-          rackspace_api.endpoint_for(
-            Utils.snake(self.class.to_s.split('::')[-2]).to_sym,
-            rackspace_region
-          )
-        end
-
-        # @return [String] valid API token
-        def token
-          rackspace_api.api_token
-        end
-
         # @return [Miasma::Contrib::RackspaceApiCore]
-        def rackspace_api
+        def open_stack_api
           key = "miasma_rackspace_api_#{attributes.checksum}".to_sym
           memoize(key, :direct) do
             Miasma::Contrib::RackspaceApiCore.new(attributes)
@@ -70,88 +71,27 @@ module Miasma
         'load_balancer' => 'cloudLoadBalancers'
       )
 
-      # @return [String] username
-      attr_reader :user
-      # @return [Smash] remote service catalog
-      attr_reader :service_catalog
-      # @return [Smash] token information
-      attr_reader :token
-      # @return [Smash] credentials in use
-      attr_reader :credentials
-
       # Create a new api instance
       #
       # @param creds [Smash] credential hash
       # @return [self]
       def initialize(creds)
-        @credentials = creds
-      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)
-        identify_and_load unless service_catalog
-        api = API_MAP[api_name]
-        srv = service_catalog.detect do |info|
-          info[:name] == api
+        if(creds[:rackspace_region].to_s == 'lon')
+          endpoint = AUTH_ENDPOINT[:uk]
+        else
+          endpoint = AUTH_ENDPOINT[:us]
         end
-        unless(srv)
-          raise NotImplementedError.new("No API mapping found for `#{api_name}`")
-        end
-        region = region.to_s.upcase
-        point = srv[:endpoints].detect do |endpoint|
-          endpoint[:region] == region
-        end
-        if(point)
-          point[:publicURL]
-        end
-      end
-
-      # @return [String] API token
-      def api_token
-        if(token.nil? || Time.now > token[:expires])
-          identify_and_load
-        end
-        token[:id]
+        super Smash.new(
+          :open_stack_username => creds[:rackspace_username],
+          :open_stack_token => creds[:rackspace_api_key],
+          :open_stack_region => creds[:rackspace_region],
+          :open_stack_identity_url => endpoint
+        )
       end
 
       # @return [String] ID of account
       def account_id
-        if(token.nil? || Time.now > token[:expires])
-          identify_and_load
-        end
-        token[:tenant][:id]
-      end
-
-      # Identify with authentication service and load
-      # token information and service catalog
-      #
-      # @return [TrueClass]
-      def identify_and_load
-        endpoint = credentials[:rackspace_region].to_s == 'lon' ? AUTH_ENDPOINT[:uk] : AUTH_ENDPOINT[:us]
-        result = HTTP.post(File.join(endpoint, 'tokens'),
-          :json => {
-            'auth' => {
-              'RAX-KSKEY:apiKeyCredentials' => {
-                'username' => credentials[:rackspace_username],
-                'apiKey' => credentials[:rackspace_api_key]
-              }
-            }
-          }
-        )
-        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
+        identity.token[:tenant][:id]
       end
 
     end

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

@@ -3,101 +3,10 @@ require 'miasma'
 module Miasma
   module Models
     class Compute
-      class Rackspace < Compute
+      class Rackspace < OpenStack
 
         include Contrib::RackspaceApiCore::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}"
-            )
-          else
-            raise "this doesn't even exist"
-          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

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

@@ -3,7 +3,7 @@ require 'miasma'
 module Miasma
   module Models
     class Orchestration
-      class Rackspace < Orchestration
+      class Rackspace < OpenStack
 
         include Contrib::RackspaceApiCore::ApiCommon
 
@@ -19,236 +19,6 @@ module Miasma
           )
         )
 
-        # 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