fog-rackspace 0.1.0

data/lib/fog/rackspace/cdn.rb

@@ -0,0 +1,198 @@
+require 'fog/rackspace/core'
+
+module Fog
+  module CDN
+    class Rackspace < Fog::Service
+      requires :rackspace_api_key, :rackspace_username
+      recognizes :rackspace_auth_url, :persistent, :rackspace_cdn_ssl, :rackspace_region, :rackspace_cdn_url
+
+      request_path 'fog/rackspace/requests/cdn'
+      request :get_containers
+      request :head_container
+      request :post_container
+      request :put_container
+      request :delete_object
+
+      module Base
+        URI_HEADERS = {
+          "X-Cdn-Ios-Uri" => :ios_uri,
+          "X-Cdn-Uri" => :uri,
+          "X-Cdn-Streaming-Uri" => :streaming_uri,
+          "X-Cdn-Ssl-Uri" => :ssl_uri
+        }.freeze
+
+        def apply_options(options)
+          # 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]
+          @rackspace_region = options[:rackspace_region]
+        end
+
+        def service_name
+          :cloudFilesCDN
+        end
+
+        def region
+          @rackspace_region
+        end
+
+        def request_id_header
+          "X-Trans-Id"
+        end
+
+        # Returns true if CDN service is enabled
+        # @return [Boolean]
+        def enabled?
+          @enabled
+        end
+
+        def endpoint_uri(service_endpoint_url=nil)
+          @uri = super(@rackspace_cdn_url || service_endpoint_url, :rackspace_cdn_url)
+        end
+
+        # Publish container to CDN
+        # @param [Fog::Storage::Rackspace::Directory] container directory to publish
+        # @param [Boolean] publish If true directory is published. If false directory is unpublished.
+        # @return [Hash] hash containing urls for published container
+        # @raise [Fog::Storage::Rackspace::NotFound] - HTTP 404
+        # @raise [Fog::Storage::Rackspace::BadRequest] - HTTP 400
+        # @raise [Fog::Storage::Rackspace::InternalServerError] - HTTP 500
+        # @raise [Fog::Storage::Rackspace::ServiceError]
+        def publish_container(container, publish = true)
+          enabled = publish ? 'True' : 'False'
+          response = put_container(container.key, 'X-Cdn-Enabled' => enabled)
+          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
+        # @raise [Fog::Storage::Rackspace::BadRequest] - HTTP 400
+        # @raise [Fog::Storage::Rackspace::InternalServerError] - HTTP 500
+        # @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
+            response = head_container(container.key)
+            return {} unless response.headers['X-Cdn-Enabled'] == 'True'
+            urls_from_headers response.headers
+          rescue Fog::Service::NotFound
+            {}
+          end
+        end
+
+        private
+
+        def urls_from_headers(headers)
+          h = {}
+          URI_HEADERS.keys.each do | header |
+            key = URI_HEADERS[header]
+            h[key] = headers[header]
+          end
+          h
+        end
+      end
+
+      class Mock < Fog::Rackspace::Service
+        include Base
+
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {}
+          end
+        end
+
+        def self.reset
+          @data = nil
+        end
+
+        def initialize(options={})
+          apply_options(options)
+          authenticate(options)
+          @enabled = !! endpoint_uri
+        end
+
+        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
+        end
+
+        def reset_data
+          self.class.data.delete(@rackspace_username)
+        end
+      end
+
+      class Real < Fog::Rackspace::Service
+        include Base
+
+        def initialize(options={})
+          apply_options(options)
+          authenticate(options)
+          @enabled = false
+          @persistent = options[:persistent] || false
+
+          if endpoint_uri
+            @connection = Fog::Core::Connection.new(endpoint_uri.to_s, @persistent, @connection_options)
+            @enabled = true
+          end
+        end
+
+        # Resets CDN connection
+        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
+        def purge(file)
+          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
+
+        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
+          raise Fog::Storage::Rackspace::BadRequest.slurp(error, self)
+        rescue Excon::Errors::InternalServerError => error
+          raise Fog::Storage::Rackspace::InternalServerError.slurp(error, self)
+        rescue Excon::Errors::HTTPStatusError => error
+          raise Fog::Storage::Rackspace::ServiceError.slurp(error, self)
+        end
+
+        private
+
+        def authenticate_v1(options)
+          credentials = Fog::Rackspace.authenticate(options, @connection_options)
+          endpoint_uri credentials['X-CDN-Management-Url']
+          @auth_token = credentials['X-Auth-Token']
+        end
+
+        # Fix for invalid auth_token, likely after 24 hours.
+        def authenticate(options={})
+         super({
+           :rackspace_api_key  => @rackspace_api_key,
+           :rackspace_username => @rackspace_username,
+           :rackspace_auth_url => @rackspace_auth_url,
+           :connection_options => @connection_options
+         })
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/cdn_v2.rb

@@ -0,0 +1,123 @@
+require 'fog/rackspace/core'
+
+module Fog
+  module Rackspace
+    class CDNV2 < Fog::Service
+      requires :rackspace_api_key, :rackspace_username
+      recognizes :rackspace_auth_url, :persistent, :rackspace_cdn_ssl, :rackspace_region, :rackspace_cdn_url
+
+      model_path 'fog/rackspace/models/cdn_v2'
+      model :service
+      collection :services
+
+      model :flavor
+      collection :flavors
+
+      request_path 'fog/rackspace/requests/cdn_v2'
+      request :create_service
+      request :delete_assets
+      request :delete_service
+      request :get_flavor
+      request :get_home_document
+      request :get_ping
+      request :get_service
+      request :list_flavors
+      request :list_services
+      request :update_service
+
+      class ServiceError < Fog::Rackspace::Errors::ServiceError; end
+      class InternalServerError < Fog::Rackspace::Errors::InternalServerError; end
+      class BadRequest < Fog::Rackspace::Errors::BadRequest; end
+
+      class Mock < Fog::Rackspace::Service
+        include Fog::Rackspace::MockData
+
+        def initialize(options)
+          @rackspace_api_key = options[:rackspace_api_key]
+        end
+
+        def request(params)
+          Fog::Mock.not_implemented
+        end
+
+        def response(params={})
+          body    = params[:body] || {}
+          status  = params[:status] || 200
+          headers = params[:headers] || {}
+
+          response = Excon::Response.new(:body => body, :headers => headers, :status => status)
+          if params.key?(:expects) && ![*params[:expects]].include?(response.status)
+            raise(Excon::Errors.status_error(params, response))
+          else response
+          end
+        end
+      end
+
+      class Real < Fog::Rackspace::Service
+        def initialize(options = {})
+          @rackspace_api_key = options[:rackspace_api_key]
+          @rackspace_username = options[:rackspace_username]
+          @rackspace_auth_url = options[:rackspace_auth_url]
+          @rackspace_must_reauthenticate = false
+          @connection_options = options[:connection_options] || {}
+
+          authenticate
+
+          @persistent = options[:persistent] || false
+          @connection = Fog::Core::Connection.new(endpoint_uri.to_s, @persistent, @connection_options)
+        end
+
+        def request(params, parse_json = true)
+          super
+        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 request_uri(path, options={})
+          return path if options == {}
+          require "addressable/uri"
+          Addressable::URI.new({:path=>path, :query_values=>options}).request_uri
+        end
+
+        def ping
+          self.get_ping.status == 204
+        end
+
+        def home_document
+          self.get_home_document.body
+        end
+
+        def authenticate(options={})
+          super({
+            :rackspace_api_key => @rackspace_api_key,
+            :rackspace_username => @rackspace_username,
+            :rackspace_auth_url => @rackspace_auth_url,
+            :connection_options => @connection_options
+          })
+        end
+
+        def service_name
+          :rackCDN
+        end
+
+        def request_id_header
+          "x-raxcdn-id"
+        end
+
+        def region
+          @rackspace_region
+        end
+
+        def endpoint_uri(service_endpoint_url=nil)
+          @uri = super(@rackspace_endpoint || service_endpoint_url)
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/compute.rb

@@ -0,0 +1,256 @@
+require 'fog/rackspace/core'
+
+module Fog
+  module Compute
+    class Rackspace < 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; end
+
+      requires :rackspace_api_key, :rackspace_username
+      recognizes :rackspace_auth_url, :rackspace_servicenet, :persistent
+      recognizes :rackspace_auth_token, :rackspace_management_url, :rackspace_compute_v1_url, :rackspace_region
+
+      model_path 'fog/rackspace/models/compute'
+      model       :flavor
+      collection  :flavors
+      model       :image
+      collection  :images
+      model       :server
+      collection  :servers
+
+      request_path 'fog/rackspace/requests/compute'
+      request :confirm_resized_server
+      request :create_image
+      request :create_server
+      request :delete_image
+      request :delete_server
+      request :get_flavor_details
+      request :get_image_details
+      request :get_server_details
+      request :list_addresses
+      request :list_private_addresses
+      request :list_public_addresses
+      request :list_flavors
+      request :list_flavors_detail
+      request :list_images
+      request :list_images_detail
+      request :list_servers
+      request :list_servers_detail
+      request :reboot_server
+      request :revert_resized_server
+      request :resize_server
+      request :server_action
+      request :update_server
+
+      class Mock < Fog::Rackspace::Service
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {
+              :last_modified => {
+                :images  => {},
+                :servers => {}
+              },
+                :servers => {},
+                :images  => {
+                  112 =>
+                    {'id' => 112,
+                      'status' => "ACTIVE",
+                      'updated' => "2011-04-21T10:24:01-05:00",
+                      'name' => "Ubuntu 10.04 LTS"},
+                  100 =>
+                    {'id' => 100,
+                      'status' => "ACTIVE",
+                      'updated' => "2011-09-12T09:09:23-05:00",
+                      'name' => "Arch 2011.10"},
+                  31 =>
+                    {'id' => 31,
+                      'status' => "ACTIVE",
+                      'updated' => "2010-01-26T12:07:44-06:00",
+                      'name' => "Windows Server 2008 SP2 x86"},
+                  108 =>
+                    {'id' => 108,
+                      'status' => "ACTIVE",
+                      'updated' => "2011-11-01T08:32:30-05:00",
+                      'name' => "Gentoo 11.0"},
+                  109 =>
+                    {'id' => 109,
+                      'status' => "ACTIVE",
+                      'updated' => "2011-11-03T06:28:56-05:00",
+                      'name' => "openSUSE 12"},
+                  89 =>
+                    {'id' => 89,
+                      'status' => "ACTIVE",
+                      'updated' => "2011-10-04T08:39:34-05:00",
+                      'name' => "Windows Server 2008 R2 x64 - SQL2K8R2 Web"},
+                  24 =>
+                    {'id' => 24,
+                      'status' => "ACTIVE",
+                      'updated' => "2010-01-26T12:07:04-06:00",
+                      'name' => "Windows Server 2008 SP2 x64"},
+                  110 =>
+                    {'id' => 110,
+                      'status' => "ACTIVE",
+                      'updated' => "2011-08-17T05:11:30-05:00",
+                      'name' => "Red Hat Enterprise Linux 5.5"},
+                  57 =>
+                    {'id' => 57,
+                      'status' => "ACTIVE",
+                      'updated' => "2010-09-17T07:16:25-05:00",
+                      'name' => "Windows Server 2008 SP2 x64 - MSSQL2K8R2"},
+                  85 =>
+                    {'id' => 85,
+                      'status' => "ACTIVE",
+                      'updated' => "2010-01-26T12:07:17-06:00",
+                      'name' => "Windows Server 2008 R2 x64"},
+                  111 =>
+                    {'id' => 111,
+                      'status' => "ACTIVE",
+                      'updated' => "2011-09-12T10:53:12-05:00",
+                      'name' => "Red Hat Enterprise Linux 6"},
+                  120 =>
+                    {'id' => 120,
+                      'status' => "ACTIVE",
+                      'updated' => "2012-01-03T04:39:05-06:00",
+                      'name' => "Fedora 16"},
+                  119 =>
+                    {'id' => 119,
+                      'status' => "ACTIVE",
+                      'updated' => "2011-11-03T08:55:15-05:00",
+                      'name' => "Ubuntu 11.10"},
+                  116 =>
+                    {'id' => 116,
+                      'status' => "ACTIVE",
+                      'updated' => "2011-08-17T05:11:30-05:00",
+                      'name' => "Fedora 15"},
+                  56 =>
+                    {'id' => 56,
+                      'status' => "ACTIVE",
+                      'updated' => "2010-09-17T07:12:56-05:00",
+                      'name' => "Windows Server 2008 SP2 x86 - MSSQL2K8R2"},
+                  114 =>
+                    {'id' => 114,
+                      'status' => "ACTIVE",
+                      'updated' => "2011-08-17T05:11:30-05:00",
+                      'name' => "CentOS 5.6"},
+                  86 =>
+                    {'id' => 86,
+                      'status' => "ACTIVE",
+                      'updated' => "2010-09-17T07:19:20-05:00",
+                      'name' => "Windows Server 2008 R2 x64 - MSSQL2K8R2"},
+                  115 =>
+                    {'id' => 115,
+                      'status' => "ACTIVE",
+                      'updated' => "2011-08-17T05:11:30-05:00",
+                      'name' => "Ubuntu 11.04"},
+                  103 =>
+                    {'id' => 103,
+                      'status' => "ACTIVE",
+                      'updated' => "2011-08-17T05:11:30-05:00",
+                      'name' => "Debian 5 (Lenny)"},
+                  104 =>
+                    {'id' => 104,
+                      'status' => "ACTIVE",
+                      'updated' => "2011-08-17T05:11:30-05:00",
+                      'name' => "Debian 6 (Squeeze)"},
+                  118 =>
+                    {'id' => 118,
+                      'status' => "ACTIVE",
+                      'updated' => "2011-08-17T05:11:30-05:00",
+                      'name' => "CentOS 6.0"}
+                    }
+              }
+          end
+        end
+
+        def self.reset
+          @data = nil
+        end
+
+        def initialize(options={})
+          @rackspace_username = options[:rackspace_username]
+        end
+
+        def data
+          self.class.data[@rackspace_username]
+        end
+
+        def reset_data
+          self.class.data.delete(@rackspace_username)
+        end
+      end
+
+      class Real < Fog::Rackspace::Service
+        def initialize(options={})
+          @rackspace_api_key = options[:rackspace_api_key]
+          @rackspace_username = options[:rackspace_username]
+          @rackspace_auth_url = options[:rackspace_auth_url]
+          @rackspace_servicenet = options[:rackspace_servicenet]
+          @rackspace_auth_token = options[:rackspace_auth_token]
+          @rackspace_endpoint = Fog::Rackspace.normalize_url(options[:rackspace_compute_v1_url] || options[:rackspace_management_url])
+          @connection_options = options[:connection_options] || {}
+          authenticate
+          Excon.defaults[:ssl_verify_peer] = false if service_net?
+          @persistent = options[:persistent] || false
+          @connection = Fog::Core::Connection.new(endpoint_uri.to_s, @persistent, @connection_options)
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        def request(params, parse_json = true)
+          super
+        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 service_net?
+           @rackspace_servicenet == true
+        end
+
+         def authenticate(options={})
+            super({
+             :rackspace_api_key  => @rackspace_api_key,
+             :rackspace_username => @rackspace_username,
+             :rackspace_auth_url => @rackspace_auth_url,
+             :connection_options => @connection_options
+           })
+         end
+
+         def service_name
+           :cloudServers
+         end
+
+         def region
+           @rackspace_region
+         end
+
+         def endpoint_uri(service_endpoint_url=nil)
+           return @uri if @uri
+           super(@rackspace_endpoint || service_endpoint_url, :rackspace_compute_v1_url)
+         end
+
+        private
+
+         def deprecation_warnings(options)
+           Fog::Logger.deprecation("The :rackspace_management_url option is deprecated. Please use :rackspace_compute_v1_url for custom endpoints") if options[:rackspace_management_url]
+         end
+
+         def authenticate_v1(options)
+           credentials = Fog::Rackspace.authenticate(options, @connection_options)
+           endpoint_uri credentials['X-Server-Management-Url']
+           @auth_token = credentials['X-Auth-Token']
+         end
+      end
+    end
+  end
+end