require File.expand_path(File.join(File.dirname(__FILE__), '..', 'rackspace')) module Fog module Rackspace class BlockStorage < Fog::Service class IdentifierTaken < Fog::Errors::Error; end class ServiceError < Fog::Rackspace::Errors::ServiceError; end class InternalServerError < Fog::Rackspace::Errors::InternalServerError; end class BadRequest < Fog::Rackspace::Errors::BadRequest; end DFW_ENDPOINT = 'https://dfw.blockstorage.api.rackspacecloud.com/v1' LON_ENDPOINT = 'https://lon.blockstorage.api.rackspacecloud.com/v1' ORD_ENDPOINT = 'https://ord.blockstorage.api.rackspacecloud.com/v1' requires :rackspace_api_key, :rackspace_username recognizes :rackspace_auth_url recognizes :rackspace_endpoint recognizes :rackspace_region recognizes :rackspace_block_storage_url model_path 'fog/rackspace/models/block_storage' model :volume collection :volumes model :volume_type collection :volume_types model :snapshot collection :snapshots model :snapshot collection :snapshots request_path 'fog/rackspace/requests/block_storage' request :create_volume request :delete_volume request :get_volume request :list_volumes request :get_volume_type request :list_volume_types request :create_snapshot request :delete_snapshot request :get_snapshot request :list_snapshots 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.has_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] || {} setup_custom_endpoint(options) authenticate deprecation_warnings(options) @persistent = options[:persistent] || false @connection = Fog::Connection.new(endpoint_uri.to_s, @persistent, @connection_options) end def request(params) begin response = @connection.request(params.merge!({ :headers => { 'Content-Type' => 'application/json', 'Accept' => 'application/json', 'X-Auth-Token' => auth_token }.merge!(params[:headers] || {}), :host => endpoint_uri.host, :path => "#{endpoint_uri.path}/#{params[:path]}" })) rescue Excon::Errors::NotFound => error raise NotFound.slurp error rescue Excon::Errors::BadRequest => error raise BadRequest.slurp error rescue Excon::Errors::InternalServerError => error raise InternalServerError.slurp error rescue Excon::Errors::HTTPStatusError => error raise ServiceError.slurp error end unless response.body.empty? response.body = Fog::JSON.decode(response.body) end response end def authenticate options = { :rackspace_api_key => @rackspace_api_key, :rackspace_username => @rackspace_username, :rackspace_auth_url => @rackspace_auth_url } super(options) end def service_name :cloudBlockStorage end def region @rackspace_region end def endpoint_uri(service_endpoint_url=nil) @uri = super(@rackspace_endpoint || service_endpoint_url, :rackspace_block_storage_url) end private def setup_custom_endpoint(options) @rackspace_endpoint = Fog::Rackspace.normalize_url(options[:rackspace_block_storage_url] || options[:rackspace_endpoint]) if v2_authentication? case @rackspace_endpoint when DFW_ENDPOINT @rackspace_endpoint = nil @rackspace_region = :dfw when ORD_ENDPOINT @rackspace_endpoint = nil @rackspace_region = :ord when LON_ENDPOINT @rackspace_endpoint = nil @rackspace_region = :lon else @rackspace_region = options[:rackspace_region] || :dfw end else #if we are using auth1 and the endpoint is not set, default to DFW_ENDPOINT for historical reasons @rackspace_endpoint ||= DFW_ENDPOINT end end def deprecation_warnings(options) Fog::Logger.deprecation("The :rackspace_endpoint option is deprecated. Please use :rackspace_block_storage_url for custom endpoints") if options[:rackspace_endpoint] if [DFW_ENDPOINT, ORD_ENDPOINT, LON_ENDPOINT].include?(@rackspace_endpoint) && v2_authentication? regions = @identity_service.service_catalog.display_service_regions(service_name) Fog::Logger.deprecation("Please specify region using :rackspace_region rather than :rackspace_endpoint. Valid region for :rackspace_region are #{regions}.") end end def append_tenant_v1(credentials) account_id = credentials['X-Server-Management-Url'].match(/.*\/([\d]+)$/)[1] endpoint = @rackspace_endpoint || credentials['X-Server-Management-Url'] || DFW_ENDPOINT @uri = URI.parse(endpoint) @uri.path = "#{@uri.path}/#{account_id}" end def authenticate_v1(options) credentials = Fog::Rackspace.authenticate(options, @connection_options) append_tenant_v1 credentials @auth_token = credentials['X-Auth-Token'] end end end end end