fog 1.5.0 → 1.6.0

data/lib/fog/ecloud/requests/compute/virtual_machine_upload_file.rb

@@ -0,0 +1,31 @@
+module Fog
+  module Compute
+    class Ecloud
+      module Shared
+
+        def validate_upload_file_options(options)
+          required_opts = [:file, :path, :credentials]
+          unless required_opts.all? { |opt| options.has_key?(opt) }
+            raise ArgumentError.new("Required data missing: #{(required_opts - options.keys).map(&:inspect).join(", ")}")
+          end
+        end
+
+      end
+
+      class Real
+
+        def virtual_machine_upload_file(vm_uri, options)
+          validate_upload_file_options(options)
+          request(
+            :expects => 204,
+            :method => 'POST',
+            :headers => {'Content-Type' => 'application/octet-stream', 'X-Guest-User' => options[:credentials][:user], 'X-Guest-Password' => options[:credentials][:password], 'Content-Range' => "0-#{options[:file].bytesize - 1}/#{options[:file].bytesize}"},
+            :body => options[:file],
+            :uri => vm_uri + "?path=#{options[:path]}",
+            :parse => true
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/models/storage/directory.rb

@@ -49,9 +49,9 @@ module Fog
           requires :key
           if connection.get_bucket_acl(key).body['AccessControlList'].detect {|entry| entry['Scope']['type'] == 'AllUsers' && entry['Permission'] == 'READ'}
             if key.to_s =~ /^(?:[a-z]|\d(?!\d{0,2}(?:\.\d{1,3}){3}$))(?:[a-z0-9]|\.(?![\.\-])|\-(?![\.])){1,61}[a-z0-9]$/
-              "https://#{key}.commondatastorage.googleapis.com"
+              "https://#{key}.storage.googleapis.com"
             else
-              "https://commondatastorage.googleapis.com/#{key}"
+              "https://storage.googleapis.com/#{key}"
             end
           else
             nil

data/lib/fog/google/models/storage/file.rb

@@ -94,9 +94,9 @@ module Fog
           requires :directory, :key
           if connection.get_object_acl(directory.key, key).body['AccessControlList'].detect {|entry| entry['Scope']['type'] == 'AllUsers' && entry['Permission'] == 'READ'}
             if directory.key.to_s =~ /^(?:[a-z]|\d(?!\d{0,2}(?:\.\d{1,3}){3}$))(?:[a-z0-9]|\.(?![\.\-])|\-(?![\.])){1,61}[a-z0-9]$/
-              "https://#{directory.key}.commondatastorage.googleapis.com/#{key}"
+              "https://#{directory.key}.storage.googleapis.com/#{key}"
             else
-              "https://commondatastorage.googleapis.com/#{directory.key}/#{key}"
+              "https://storage.googleapis.com/#{directory.key}/#{key}"
             end
           else
             nil

data/lib/fog/google/requests/storage/get_bucket.rb

@@ -36,7 +36,6 @@ module Fog
         #         * 'DisplayName'<~String> - Display name of object owner
         #         * 'ID'<~String> - Id of object owner
         #       * 'Size'<~Integer> - Size of object
-        #       * 'StorageClass'<~String> - Storage class of object
         #
         def get_bucket(bucket_name, options = {})
           unless bucket_name
@@ -69,7 +68,7 @@ module Fog
                   (options['prefix'] && object['Key'][0...options['prefix'].length] != options['prefix']) ||
                   (options['marker'] && object['Key'] <= options['marker'])
                 end.map do |object|
-                  data = object.reject {|key, value| !['ETag', 'Key', 'StorageClass'].include?(key)}
+                  data = object.reject {|key, value| !['ETag', 'Key'].include?(key)}
                   data.merge!({
                     'LastModified' => Time.parse(object['Last-Modified']),
                     'Owner'        => bucket['Owner'],

data/lib/fog/google/requests/storage/put_object.rb

@@ -63,8 +63,7 @@ module Fog
               'ETag'            => Fog::Google::Mock.etag,
               'Key'             => object_name,
               'Last-Modified'   => Fog::Time.now.to_date_header,
-              'Content-Length'  => options['Content-Length'] || data[:headers]['Content-Length'],
-              'StorageClass'    => 'STANDARD'
+              'Content-Length'  => options['Content-Length'] || data[:headers]['Content-Length']
             }
 
             for key, value in options

data/lib/fog/google/storage.rb

@@ -191,7 +191,7 @@ module Fog
           @google_storage_secret_access_key = options[:google_storage_secret_access_key]
           @connection_options = options[:connection_options] || {}
           @hmac = Fog::HMAC.new('sha1', @google_storage_secret_access_key)
-          @host = options[:host] || 'commondatastorage.googleapis.com'
+          @host = options[:host] || 'storage.googleapis.com'
           @persistent = options.fetch(:persistent, true)
           @port       = options[:port]        || 443
           @scheme     = options[:scheme]      || 'https'

data/lib/fog/hp/models/compute/image.rb

@@ -16,7 +16,7 @@ module Fog
         attribute :minDisk,     :aliases => 'min_disk'
         attribute :minRam,      :aliases => 'min_ram'
         attribute :server,   :aliases => 'server'
-        #attribute :metadata       #TODO: Need to add it back when Metadata API is done
+        attribute :metadata       
         attribute :links
 
         def destroy

data/lib/fog/hp/models/compute/server.rb

@@ -129,6 +129,10 @@ module Fog
           @security_groups = new_security_groups
         end
 
+        def security_groups   
+          @security_groups
+        end
+        
         def ready?
           self.state == 'ACTIVE'
         end

data/lib/fog/hp/requests/compute/delete_security_group_rule.rb

@@ -25,14 +25,14 @@ module Fog
           response = Excon::Response.new
 
           sg_rule = nil
-
           self.data[:security_groups].each do |_, sgv|
             if sgv['rules']
-              sg_rule = sgv['rules'].delete_if { |r| !r.nil? && r['id'] == security_group_rule_id }
-              break if sg_rule
+              sg_rule_index = sgv['rules'].find_index { |r| !r.nil? && r['id'] == security_group_rule_id }
+              if sg_rule_index
+                sg_rule = sgv['rules'].delete_at sg_rule_index
+              end
             end
           end
-
           if sg_rule && !sg_rule.empty?
             response.status = 202
             response.body = "202 Accepted\n\nThe request is accepted for processing.\n\n   "

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

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

data/lib/fog/hp/storage.rb

@@ -108,6 +108,7 @@ module Fog
 
         def initialize(options={})
           require 'mime/types'
+          puts "Called with #{options}"
           @hp_secret_key = options[:hp_secret_key]
           @hp_account_id = options[:hp_account_id]
         end

data/lib/fog/libvirt/models/compute/server.rb

@@ -240,7 +240,7 @@ module Fog
         # It returns an array of public and private ip addresses
         # Currently only one ip address is returned, but in the future this could be multiple
         # if the server has multiple network interface
-        def addresses(connection, options={})
+        def addresses(connection=connection, options={})
           mac=self.mac
 
           # Aug 24 17:34:41 juno arpwatch: new station 10.247.4.137 52:54:00:88:5a:0a eth0.4

data/lib/fog/libvirt/models/compute/templates/server.xml.erb

@@ -45,7 +45,7 @@
       <target port='0'/>
     </console>
     <input type='mouse' bus='ps2'/>
-     <graphics type='<%= display[:type] %>' port='<%= display[:port] %>' autoport='yes' listen='<%= display[:listen] %>' passwd='<%=display[:password] %>'/>
+    <graphics type='<%= display[:type] %>' port='<%= display[:port] %>' autoport='yes' <% if display[:listen] and !(display[:listen].empty?)  %> listen='<%= display[:listen] %>'<% end %> <% if display[:password] and !(display[:password].empty?) %>passwd='<%=display[:password] %>'<% end %> />
     <video>
       <model type='cirrus' vram='9216' heads='1'/>
     </video>

data/lib/fog/openstack.rb

@@ -80,6 +80,7 @@ module Fog
       @service_name         = options[:openstack_service_name]
       @identity_service_name = options[:openstack_identity_service_name]
       @endpoint_type         = options[:openstack_endpoint_type] || 'publicURL'
+      @openstack_region      = options[:openstack_region]
 
       if @openstack_auth_token
         req_body = {
@@ -133,6 +134,12 @@ module Fog
           detect{|x| @service_name.include?(x['type']) }
       end
 
+      svc['endpoints'] = svc['endpoints'].select{ |x| x['region'] == @openstack_region } if @openstack_region
+      if svc['endpoints'].count > 1
+         regions = svc["endpoints"].map { |x| x['region'] }.uniq.join(',')
+         raise Errors::NotFound.new("Multiple regions available choose one of these '#{regions}'")
+      end
+
       identity_svc = body['access']['serviceCatalog'].
         detect{|x| @identity_service_name.include?(x['type']) } if @identity_service_name
       tenant = body['access']['token']['tenant']

data/lib/fog/openstack/compute.rb

@@ -9,7 +9,7 @@ module Fog
       recognizes :openstack_auth_token, :openstack_management_url,
                  :persistent, :openstack_service_name, :openstack_tenant,
                  :openstack_api_key, :openstack_username, :openstack_identity_endpoint,
-                 :current_user, :current_tenant
+                 :current_user, :current_tenant, :openstack_region
 
       ## MODELS
       #
@@ -249,6 +249,7 @@ module Fog
           @openstack_must_reauthenticate  = false
           @openstack_service_name = options[:openstack_service_name] || ['nova', 'compute']
           @openstack_identity_service_name = options[:openstack_identity_service_name] || 'identity'
+          @openstack_region      = options[:openstack_region]
 
           @connection_options = options[:connection_options] || {}
 
@@ -267,6 +268,7 @@ module Fog
             :openstack_auth_token     => @auth_token,
             :openstack_management_url => @openstack_management_url,
             :openstack_identity_endpoint => @openstack_identity_public_endpoint,
+            :openstack_region         => @openstack_region,
             :current_user             => @current_user,
             :current_tenant           => @current_tenant }
         end
@@ -319,6 +321,7 @@ module Fog
               :openstack_username => @openstack_username,
               :openstack_auth_token => @openstack_auth_token,
               :openstack_auth_uri => @openstack_auth_uri,
+              :openstack_region   => @openstack_region,
               :openstack_tenant   => @openstack_tenant,
               :openstack_service_name => @openstack_service_name,
               :openstack_identity_service_name => @openstack_identity_service_name

data/lib/fog/openstack/models/compute/server.rb

@@ -142,7 +142,7 @@ module Fog
 
         def change_password(admin_password)
           requires :id
-          connection.change_password_server(id, admin_password)
+          connection.change_server_password(id, admin_password)
           true
         end
 

data/lib/fog/openstack/requests/compute/create_server.rb

@@ -13,12 +13,18 @@ module Fog
           }
 
           vanilla_options = ['metadata', 'accessIPv4', 'accessIPv6',
-                             'availability_zone', 'user_data', 'key_name',
-                             'security_groups', 'adminPass']
+                             'availability_zone', 'user_data', 'key_name', 'adminPass']
           vanilla_options.select{|o| options[o]}.each do |key|
             data['server'][key] = options[key]
           end
 
+          if options['security_groups']
+            # security names requires a hash with a name prefix
+            data['server']['security_groups'] = [options['security_groups']].flatten.map do |sg|
+              { :name => sg.is_a?(Fog::Compute::OpenStack::SecurityGroup) ? sg.name : sg }
+            end
+          end
+
           if options['personality']
             data['server']['personality'] = []
             for file in options['personality']

data/lib/fog/openstack/requests/identity/list_roles_for_user_on_tenant.rb

@@ -14,7 +14,7 @@ module Fog
       class Mock
         def list_roles_for_user_on_tenant(tenant_id, user_id)
           Excon::Response.new(
-            :body   => { 'roles' => self.data[:roles] },
+            :body   => { 'roles' => self.data[:roles].values },
             :status => 200
           )
         end # def list_roles_for_user_on_tenant

data/lib/fog/openstack/requests/identity/list_tenants.rb

@@ -20,6 +20,7 @@ module Fog
         def list_tenants
           Excon::Response.new(
             :body => {
+              'tenants_links' => [],
               'tenants' => [
                 {'id' => '1',
                  'description' => 'Has access to everything',

data/lib/fog/providers.rb

@@ -1,3 +1,4 @@
+require 'fog/atmos'
 require 'fog/aws'
 require 'fog/bluebox'
 require 'fog/brightbox'
@@ -21,6 +22,7 @@ require 'fog/ninefold'
 require 'fog/rackspace'
 require 'fog/openstack'
 require 'fog/ovirt'
+require 'fog/serverlove'
 require 'fog/storm_on_demand'
 require 'fog/vcloud'
 require 'fog/virtual_box'

data/lib/fog/rackspace.rb

@@ -42,13 +42,15 @@ module Fog
       end
     end
 
-    service(:cdn,             'rackspace/cdn',            'CDN')
-    service(:compute,         'rackspace/compute',        'Compute')
-    service(:dns,             'rackspace/dns',            'DNS')
-    service(:storage,         'rackspace/storage',        'Storage')
-    service(:load_balancers,  'rackspace/load_balancers', 'LoadBalancers')
-    service(:identity,        'rackspace/identity',       'Identity')
-    service(:databases,       'rackspace/databases',      'Databases')
+    service(:block_storage,    'rackspace/block_storage',     'BlockStorage')
+    service(:cdn,              'rackspace/cdn',               'CDN')
+    service(:compute,          'rackspace/compute',           'Compute')
+    service(:compute_v2,       'rackspace/compute_v2',        'Compute v2')
+    service(:dns,              'rackspace/dns',               'DNS')
+    service(:storage,          'rackspace/storage',           'Storage')
+    service(:load_balancers,   'rackspace/load_balancers',    'LoadBalancers')
+    service(:identity,         'rackspace/identity',          'Identity')
+    service(:databases,        'rackspace/databases',         'Databases')
 
     def self.authenticate(options, connection_options = {})
       rackspace_auth_url = options[:rackspace_auth_url] || "auth.api.rackspacecloud.com"

data/lib/fog/rackspace/block_storage.rb

@@ -0,0 +1,114 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'rackspace'))
+
+module Fog
+  module Rackspace
+    class BlockStorage < Fog::Service
+
+      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
+
+      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
+        def request(params)
+          Fog::Mock.not_implemented
+        end
+      end
+
+      class Real
+        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] || {}
+
+          endpoint = options[:rackspace_endpoint] || DFW_ENDPOINT
+          uri = URI.parse(endpoint)
+
+          @host = uri.host
+          @persistent = options[:persistent] || false
+          @path = uri.path
+          @port = uri.port
+          @scheme = uri.scheme
+
+          authenticate
+
+          @connection = Fog::Connection.new(uri.to_s, @persistent, @connection_options)
+        end
+
+        def request(params)
+          begin
+            response = @connection.request(params.merge!({
+              :headers  => {
+                'Content-Type' => 'application/json',
+                'X-Auth-Token' => @auth_token
+              }.merge!(params[:headers] || {}),
+              :host     => @host,
+              :path     => "#{@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
+
+        private
+
+        def authenticate
+          options = {
+            :rackspace_api_key  => @rackspace_api_key,
+            :rackspace_username => @rackspace_username,
+            :rackspace_auth_url => @rackspace_auth_url
+          }
+          credentials = Fog::Rackspace.authenticate(options, @connection_options)
+          @auth_token = credentials['X-Auth-Token']
+          account_id = credentials['X-Server-Management-Url'].match(/.*\/([\d]+)$/)[1]
+          @path = "#{@path}/#{account_id}"
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/compute_v2.rb

@@ -0,0 +1,123 @@
+require 'fog/compute'
+
+module Fog
+  module Compute
+    class RackspaceV2 < Fog::Service
+
+      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.servers.api.rackspacecloud.com/v2'
+      ORD_ENDPOINT = 'https://ord.servers.api.rackspacecloud.com/v2'
+      LON_ENDPOINT = 'https://lon.servers.api.rackspacecloud.com/v2'
+
+      requires :rackspace_username, :rackspace_api_key
+      recognizes :rackspace_endpoint
+      recognizes :rackspace_auth_url
+      recognizes :rackspace_auth_token
+
+      model_path 'fog/rackspace/models/compute_v2'
+      model :server
+      collection :servers
+      model :flavor
+      collection :flavors
+      model :image
+      collection :images
+      model :attachments
+      collection :attachments
+
+      request_path 'fog/rackspace/requests/compute_v2'
+      request :list_servers
+      request :get_server
+      request :create_server
+      request :update_server
+      request :delete_server
+      request :change_server_password
+      request :reboot_server
+      request :rebuild_server
+      request :resize_server
+      request :confirm_resize_server
+      request :revert_resize_server
+
+      request :list_images
+      request :get_image
+
+      request :list_flavors
+      request :get_flavor
+
+      request :attach_volume
+      request :get_attachment
+      request :list_attachments
+      request :delete_attachment
+
+      class Mock
+        def request(params)
+          Fog::Mock.not_implemented
+        end
+      end
+
+      class Real
+        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] || {}
+
+          endpoint = options[:rackspace_endpoint] || DFW_ENDPOINT
+          uri = URI.parse(endpoint)
+
+          @host = uri.host
+          @persistent = options[:persistent] || false
+          @path = uri.path
+          @port = uri.port
+          @scheme = uri.scheme
+
+          authenticate
+
+          @connection = Fog::Connection.new(uri.to_s, @persistent, @connection_options)
+        end
+
+        def request(params)
+          begin
+            response = @connection.request(params.merge!({
+              :headers  => {
+                'Content-Type' => 'application/json',
+                'X-Auth-Token' => @auth_token
+              }.merge!(params[:headers] || {}),
+              :host     => @host,
+              :path     => "#{@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
+
+        private
+
+        def authenticate
+          options = {
+            :rackspace_api_key  => @rackspace_api_key,
+            :rackspace_username => @rackspace_username,
+            :rackspace_auth_url => @rackspace_auth_url
+          }
+          credentials = Fog::Rackspace.authenticate(options, @connection_options)
+          @auth_token = credentials['X-Auth-Token']
+          account_id = credentials['X-Server-Management-Url'].match(/.*\/([\d]+)$/)[1]
+          @path = "#{@path}/#{account_id}"
+        end
+      end
+    end
+  end
+end