fog-maestrodev 1.15.0.20130829165835 → 1.15.0.20130927082724

data/lib/fog/openstack/requests/orchestration/create_stack.rb

@@ -0,0 +1,55 @@
+module Fog
+  module Orchestration
+    class OpenStack
+      class Real
+
+        # Create a stack.
+        #
+        # * stack_name [String] Name of the stack to create.
+        # * options [Hash]:
+        #   * :template_body [String] Structure containing the template body.
+        #   or (one of the two Template parameters is required)
+        #   * :template_url [String] URL of file containing the template body.
+        #   * :disable_rollback [Boolean] Controls rollback on stack creation failure, defaults to false.
+        #   * :parameters [Hash] Hash of providers to supply to template
+        #   * :timeout_in_minutes [Integer] Minutes to wait before status is set to CREATE_FAILED
+        #
+        # @see http://docs.amazonwebservices.com/AWSCloudFormation/latest/APIReference/API_CreateStack.html
+
+        def create_stack(stack_name, options = {})
+          params = {
+            :stack_name => stack_name
+          }.merge(options)
+
+          request(
+            :path => 'stacks',
+            :method => 'POST',
+            :body => MultiJson.encode(params)
+          )
+        end
+
+      end
+      
+      class Mock
+        def create_stack(stack_name, options = {})
+          stack_id = Fog::Mock.random_hex(32)
+          stack = self.data[:stacks][stack_id] = {
+            'id' => stack_id,
+            'stack_name' => stack_name,
+            'links' => [],
+            'description' => options[:description],
+            'stack_status' => 'CREATE_COMPLETE',
+            'stack_status_reason' => 'Stack successfully created',
+            'creation_time' => Time.now,
+            'updated_time' => Time.now
+          }
+
+          response = Excon::Response.new
+          response.status = 202
+          response.body = {}
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/openstack/requests/orchestration/delete_stack.rb

@@ -0,0 +1,36 @@
+module Fog
+  module Orchestration
+    class OpenStack
+      class Real
+
+        # Delete a stack.
+        #
+        # @param stack_name [String] Name of the stack to delete.
+        # @param stack_id [String] ID of the stack to delete.
+        #
+        # @return [Excon::Response]
+        #
+        # @see http://docs.amazonwebservices.com/AWSCloudFormation/latest/APIReference/API_DeleteStack.html
+
+        def delete_stack(stack_name, stack_id)
+          request(
+            :path => "stacks/#{stack_name}/#{stack_id}",
+            :method => 'DELETE'
+          )
+        end
+
+      end
+
+      class Mock
+        def delete_stack(stack_name, stack_id)
+          self.data[:stacks].delete(stack_id)
+
+          response = Excon::Response.new
+          response.status = 202
+          response.body = {}
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/openstack/requests/orchestration/list_stacks.rb

@@ -0,0 +1,48 @@
+module Fog
+  module Orchestration
+    class OpenStack
+      class Real
+
+        # List stacks.
+        #
+        # @param options [Hash]
+        #
+        # @return [Excon::Response]
+        #   * body [Hash]:
+        #     * stacks [Array] - Matching stacks
+        #       * stack [Hash]:
+        #         * id [String] -
+        #         * stack_name [String] -
+        #         * description [String]
+        #         * links [Array]
+        #         * stack_status [String] -
+        #         * stack_status_reason [String]
+        #         * creation_time [Time] -
+        #         * updated_time [Time] -
+        #
+        #
+        # @see http://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_ListStacks.html
+
+        def list_stacks(options = {})
+          request(
+            :path => 'stacks',
+            :method => 'GET',
+            :query => options
+          )
+        end
+
+      end
+
+      class Mock
+        def list_stacks(options = {})
+          stacks = self.data[:stacks].values
+
+          Excon::Response.new(
+            :body   => { 'stacks' => stacks },
+            :status => 200
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/openstack/requests/orchestration/update_stack.rb

@@ -0,0 +1,41 @@
+module Fog
+  module Orchestration
+    class OpenStack
+      class Real
+
+        # Update a stack.
+        #
+        # @param [String] stack_name Name of the stack to update.
+        # @param [Hash] options
+        #   * :template_body [String] Structure containing the template body.
+        #   or (one of the two Template parameters is required)
+        #   * :template_url [String] URL of file containing the template body.
+        #   * :parameters [Hash] Hash of providers to supply to template.
+        #
+        # @see http://docs.amazonwebservices.com/AWSCloudFormation/latest/APIReference/API_UpdateStack.html
+        #
+        def update_stack(stack_name, options = {})
+          params = {
+            :stack_name => stack_name
+          }.merge(options)
+
+          request(
+            :path => 'stacks',
+            :method => 'PUT',
+            :body => MultiJson.encode(params)
+          )
+        end
+
+      end
+
+      class Mock
+        def update_stack(stack_name, options = {})
+          response = Excon::Response.new
+          response.status = 202
+          response.body = {}
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/openstack/requests/storage/get_object.rb

@@ -10,17 +10,17 @@ module Fog
         # * object<~String> - Name of object to look for
         #
         def get_object(container, object, &block)
-          params = {}
+          params = {
+            :expects  => 200,
+            :method   => 'GET',
+            :path     => "#{Fog::OpenStack.escape(container)}/#{Fog::OpenStack.escape(object)}"
+          }
 
           if block_given?
-            params[:response_block] = Proc.new
+            params[:response_block] = block
           end
 
-          request(params.merge!({
-            :expects  => 200,
-            :method   => 'GET',
-            :path     => "#{Fog::OpenStack.escape(container)}/#{Fog::OpenStack.escape(object)}"
-          }), false)
+          request(params, false)
         end
 
       end

data/lib/fog/openstack/storage.rb

@@ -140,7 +140,7 @@ module Fog
           @path = @original_path
         end
 
-        def request(params, parse_json = true, &block)
+        def request(params, parse_json = true)
           begin
             response = @connection.request(params.merge({
               :headers  => {
@@ -149,7 +149,7 @@ module Fog
               }.merge!(params[:headers] || {}),
               :host     => @host,
               :path     => "#{@path}/#{params[:path]}",
-            }), &block)
+            }))
           rescue Excon::Errors::Unauthorized => error
             if error.response.body != 'Bad username or password' # token expiration
               @openstack_must_reauthenticate = true

data/lib/fog/orchestration.rb

@@ -0,0 +1,25 @@
+module Fog
+  module Orchestration
+
+    def self.[](provider)
+      self.new(:provider => provider)
+    end
+
+    def self.new(attributes)
+      attributes = attributes.dup # Prevent delete from having side effects
+      provider = attributes.delete(:provider).to_s.downcase.to_sym
+
+      if self.providers.include?(provider)
+        require "fog/#{provider}/network"
+        return Fog::Orchestration.const_get(Fog.providers[provider]).new(attributes)
+      end
+
+      raise ArgumentError.new("#{provider} has no orchestration service")
+    end
+
+    def self.providers
+      Fog.services[:orchestration]
+    end
+
+  end
+end

data/lib/fog/rackspace.rb

@@ -81,6 +81,7 @@ module Fog
       end
     end
 
+    service(:auto_scale,       'rackspace/auto_scale',        'AutoScale')
     service(:block_storage,    'rackspace/block_storage',     'BlockStorage')
     service(:cdn,              'rackspace/cdn',               'CDN')
     service(:compute,          'rackspace/compute',           'Compute')

data/lib/fog/rackspace/auto_scale.rb

@@ -0,0 +1,132 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'rackspace'))
+
+module Fog
+  module Rackspace
+    class AutoScale < Fog::Service
+      include Fog::Rackspace::Errors
+
+      class ServiceError < Fog::Rackspace::Errors::ServiceError; end
+      class InternalServerError < Fog::Rackspace::Errors::InternalServerError; end
+
+      class BadRequest <  Fog::Rackspace::Errors::BadRequest
+        attr_reader :validation_errors
+
+        def self.slurp(error, service=nil)
+          if error && error.response
+            status_code = error.response.status
+            if error.response.body
+              body = Fog::JSON.decode(error.response.body)
+              message = "#{body['type']} - #{body['message']}"
+              details = error.response.body['details']
+            end
+          end
+
+          new_error = new(message)
+          new_error.set_backtrace(error.backtrace)
+          new_error.instance_variable_set(:@validation_errors, details)
+          new_error.instance_variable_set(:@status_code, status_code)
+          new_error.set_transaction_id(error, service)
+          new_error
+        end
+      end
+
+        requires :rackspace_username, :rackspace_api_key
+        recognizes :rackspace_auth_url
+        recognizes :rackspace_region
+        recognizes :rackspace_auto_scale_url
+
+        model_path 'fog/rackspace/models/auto_scale'
+        model :group
+        collection :groups
+        model :group_config
+        model :launch_config
+
+        model :policy
+        collection :policies
+
+        model :webhook
+        collection :webhooks
+
+        request_path 'fog/rackspace/requests/auto_scale'
+        request :list_groups
+        request :create_group
+        request :get_group
+        request :delete_group
+        request :get_group_state
+        request :pause_group_state
+        request :resume_group_state
+
+        request :get_group_config
+        request :update_group_config
+        request :get_launch_config
+        request :update_launch_config
+
+        request :list_policies
+        request :create_policy
+        request :get_policy
+        request :update_policy
+        request :delete_policy
+        request :execute_policy
+
+        request :execute_anonymous_webhook
+
+        request :get_webhook
+        request :list_webhooks
+        request :create_webhook
+        request :update_webhook
+        request :delete_webhook
+
+        class Mock < Fog::Rackspace::Service
+          def initialize(options)
+            @rackspace_api_key = options[:rackspace_api_key]
+          end
+
+          def request(params)
+            Fog::Mock.not_implemented
+          end
+        end
+
+
+        class Real < Fog::Rackspace::Service
+
+          def initialize(options = {})
+            @options = options
+            @options[:connection_options] ||= {}
+            @options[:persistent] ||= false
+
+            authenticate
+
+            @connection = Fog::Connection.new(endpoint_uri.to_s, @options[:persistent], @options[:connection_options])
+          end
+
+          def request(params, parse_json = true, &block)
+            super(params, parse_json, &block)
+          rescue Excon::Errors::NotFound => error
+            raise NotFound.slurp(error, self)
+          rescue Excon::Errors::BadRequest => error
+            raise BadRequest.slurp(error, self)
+          rescue Excon::Errors::InternalServerError => error
+            raise InternalServerError.slurp(error, self)
+          rescue Excon::Errors::HTTPStatusError => error
+            raise ServiceError.slurp(error, self)
+          end
+
+          def endpoint_uri(service_endpoint_url=nil)
+            @uri = super(@options[:rackspace_auto_scale_url], :rackspace_auto_scale_url)
+          end
+
+          def authenticate(options={})
+            super(select_options([:rackspace_username, :rackspace_api_key, :rackspace_auth_url, :connection_options]))
+          end
+
+          def service_name
+            :autoscale
+          end
+
+          def region
+            @options[:rackspace_region]
+          end
+        end
+    end
+  end
+end

data/lib/fog/rackspace/block_storage.rb

@@ -87,8 +87,8 @@ module Fog
           @connection = Fog::Connection.new(endpoint_uri.to_s, @persistent, @connection_options)
         end
 
-        def request(params, parse_json = true, &block)
-          super(params, parse_json, &block)
+        def request(params, parse_json = true)
+          super
         rescue Excon::Errors::NotFound => error
           raise NotFound.slurp(error, self)
         rescue Excon::Errors::BadRequest => error

data/lib/fog/rackspace/cdn.rb

@@ -13,13 +13,13 @@ module Fog
       request :post_container
       request :put_container
       request :delete_object
-      
-      
+
+
       module Base
-        URI_HEADERS = { 
+        URI_HEADERS = {
           "X-Cdn-Ios-Uri" => :ios_uri,
           "X-Cdn-Uri" => :uri,
-          "X-Cdn-Streaming-Uri" => :streaming_uri, 
+          "X-Cdn-Streaming-Uri" => :streaming_uri,
           "X-Cdn-Ssl-Uri" => :ssl_uri
         }.freeze
 
@@ -53,7 +53,7 @@ module Fog
           return {} unless publish
           urls_from_headers(response.headers)
         end
-        
+
         # Returns hash of urls for container
         # @param [Fog::Storage::Rackspace::Directory] container to retrieve urls for
         # @return [Hash] hash containing urls for published container
@@ -62,7 +62,7 @@ module Fog
         # @raise [Fog::Storage::Rackspace::ServiceError]
         # @note If unable to find container or container is not published this method will return an empty hash.
         def urls(container)
-          begin 
+          begin
             response = head_container(container.key)
             return {} unless response.headers['X-Cdn-Enabled'] == 'True'
             urls_from_headers response.headers
@@ -70,17 +70,17 @@ module Fog
             {}
           end
         end
-        
+
         private
-        
+
         def urls_from_headers(headers)
           h = {}
           URI_HEADERS.keys.each do | header |
-            key = URI_HEADERS[header]              
+            key = URI_HEADERS[header]
             h[key] = headers[header]
           end
           h
-        end        
+        end
       end
 
       class Mock < Fog::Rackspace::Service
@@ -103,16 +103,16 @@ module Fog
         def data
           self.class.data[@rackspace_username]
         end
-        
+
         def purge(object)
-          return true if object.is_a? Fog::Storage::Rackspace::File            
-          raise Fog::Errors::NotImplemented.new("#{object.class} does not support CDN purging") if object       
+          return true if object.is_a? Fog::Storage::Rackspace::File
+          raise Fog::Errors::NotImplemented.new("#{object.class} does not support CDN purging") if object
         end
 
         def reset_data
           self.class.data.delete(@rackspace_username)
         end
-        
+
       end
 
       class Real < Fog::Rackspace::Service
@@ -122,7 +122,7 @@ module Fog
           # api_key and username missing from instance variable sets
           @rackspace_api_key = options[:rackspace_api_key]
           @rackspace_username = options[:rackspace_username]
-          
+
           @connection_options = options[:connection_options] || {}
           @rackspace_auth_url = options[:rackspace_auth_url]
           @rackspace_cdn_url = options[:rackspace_cdn_url]
@@ -147,7 +147,7 @@ module Fog
         def reload
           @cdn_connection.reset
         end
-        
+
         # Purges File
         # @param [Fog::Storage::Rackspace::File] file to be purged from the CDN
         # @raise [Fog::Errors::NotImplemented] returned when non file parameters are specified
@@ -155,13 +155,13 @@ module Fog
           unless file.is_a? Fog::Storage::Rackspace::File
             raise Fog::Errors::NotImplemented.new("#{object.class} does not support CDN purging")  if object
           end
-          
+
           delete_object file.directory.key, file.key
           true
-        end        
+        end
 
-        def request(params, parse_json = true, &block)
-          super(params, parse_json, &block)
+        def request(params, parse_json = true)
+          super
         rescue Excon::Errors::NotFound => error
           raise Fog::Storage::Rackspace::NotFound.slurp(error, self)
         rescue Excon::Errors::BadRequest => error
@@ -171,9 +171,9 @@ module Fog
         rescue Excon::Errors::HTTPStatusError => error
           raise Fog::Storage::Rackspace::ServiceError.slurp(error, self)
         end
-        
-        private 
-      
+
+        private
+
         def authenticate_v1(options)
           credentials = Fog::Rackspace.authenticate(options, @connection_options)
           endpoint_uri credentials['X-CDN-Management-Url']