fog 1.9.0 → 1.10.0

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

@@ -53,7 +53,7 @@ module Fog
 
         def resize(flavor)
           requires :id
-          service.resize_machine(id, flavor)
+          service.resize_machine(id, flavor.name)
           true
         end
 

data/lib/fog/joyent/requests/compute/resize_machine.rb

@@ -1,6 +1,7 @@
 module Fog
   module Compute
     class Joyent
+     class Real
       def resize_machine(id, package)
         request(
           :method => "POST",
@@ -8,6 +9,7 @@ module Fog
           :query => {"action" => "resize", "package" => package}
         )
       end
+     end
     end
   end
 end

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

@@ -64,7 +64,7 @@ module Fog
         private
 
         def image_suffix
-          retrun "img" if format_type == "raw"
+          return "img" if format_type == "raw"
           format_type
         end
 

data/lib/fog/network.rb

@@ -9,13 +9,12 @@ module Fog
       attributes = attributes.dup # Prevent delete from having side effects
       provider = attributes.delete(:provider).to_s.downcase.to_sym
 
-      case provider
-      when :openstack
-        require 'fog/openstack/network'
-        Fog::Network::OpenStack.new(attributes)
-      else
-        raise ArgumentError.new("#{provider} has no network service")
+      if self.providers.include?(provider)
+        require "fog/#{provider}/network"
+        return Fog::Network.const_get(Fog.providers[provider]).new(attributes)
       end
+
+      raise ArgumentError.new("#{provider} has no network service")
     end
 
     def self.providers

data/lib/fog/openstack.rb

@@ -42,8 +42,11 @@ module Fog
     end
 
     service(:compute , 'openstack/compute' , 'Compute' )
+    service(:image, 'openstack/image', 'Image')
     service(:identity, 'openstack/identity', 'Identity')
     service(:network, 'openstack/network', 'Network')
+    service(:storage, 'openstack/storage', 'Storage')
+    service(:volume,  'openstack/volume',  'Volume')
 
     # legacy v1.0 style auth
     def self.authenticate_v1(options, connection_options = {})
@@ -199,6 +202,13 @@ module Fog
 
       Fog::JSON.decode(response.body)
     end
+    
+    # CGI.escape, but without special treatment on spaces
+    def self.escape(str,extra_exclude_chars = '')
+      str.gsub(/([^a-zA-Z0-9_.-#{extra_exclude_chars}]+)/) do
+        '%' + $1.unpack('H2' * $1.bytesize).join('%').upcase
+      end
+    end
 
   end
 end

data/lib/fog/openstack/compute.rb

@@ -10,7 +10,8 @@ module Fog
                  :persistent, :openstack_service_type, :openstack_service_name,
                  :openstack_tenant,
                  :openstack_api_key, :openstack_username, :openstack_identity_endpoint,
-                 :current_user, :current_tenant, :openstack_region
+                 :current_user, :current_tenant, :openstack_region,
+                 :openstack_endpoint_type
 
       ## MODELS
       #
@@ -99,6 +100,10 @@ module Fog
       request :update_metadata
       request :delete_metadata
 
+      # Metadatam
+      request :delete_meta
+      request :update_meta
+
       # Address
       request :list_addresses
       request :list_address_pools
@@ -294,6 +299,7 @@ module Fog
           @openstack_service_type = options[:openstack_service_type] || ['nova', 'compute']
           @openstack_service_name = options[:openstack_service_name]
           @openstack_identity_service_type = options[:openstack_identity_service_type] || 'identity'
+          @openstack_endpoint_type = options[:openstack_endpoint_type] || 'publicURL'
           @openstack_region      = options[:openstack_region]
 
           @connection_options = options[:connection_options] || {}
@@ -371,7 +377,8 @@ module Fog
               :openstack_tenant     => @openstack_tenant,
               :openstack_service_type => @openstack_service_type,
               :openstack_service_name => @openstack_service_name,
-              :openstack_identity_service_type => @openstack_identity_service_type
+              :openstack_identity_service_type => @openstack_identity_service_type,
+              :openstack_endpoint_type => @openstack_endpoint_type
             }
 
             if @openstack_auth_uri.path =~ /\/v2.0\//
@@ -405,9 +412,9 @@ module Fog
           @scheme = uri.scheme
            
           # Not all implementations have identity service in the catalog
-          if @openstack_identity_public_endpoint
+          if @openstack_identity_public_endpoint || @openstack_management_url
             @identity_connection = Fog::Connection.new(
-              @openstack_identity_public_endpoint,
+              @openstack_identity_public_endpoint || @openstack_management_url,
               false, @connection_options)
           end
 

data/lib/fog/openstack/identity.rb

@@ -8,7 +8,8 @@ module Fog
       recognizes :openstack_auth_token, :openstack_management_url, :persistent,
                  :openstack_service_type, :openstack_service_name, :openstack_tenant,
                  :openstack_api_key, :openstack_username, :openstack_current_user_id,
-                 :current_user, :current_tenant
+                 :current_user, :current_tenant,
+                 :openstack_endpoint_type
 
       model_path 'fog/openstack/models/identity'
       model       :tenant
@@ -192,6 +193,8 @@ module Fog
           @connection_options = options[:connection_options] || {}
 
           @openstack_current_user_id = options[:openstack_current_user_id]
+          
+          @openstack_endpoint_type = options[:openstack_endpoint_type] || 'adminURL'
 
           @current_user = options[:current_user]
           @current_tenant = options[:current_tenant]
@@ -263,7 +266,7 @@ module Fog
               :openstack_tenant   => @openstack_tenant,
               :openstack_service_type => @openstack_service_type,
               :openstack_service_name => @openstack_service_name,
-              :openstack_endpoint_type => 'adminURL'
+              :openstack_endpoint_type => @openstack_endpoint_type
             }
 
             credentials = Fog::OpenStack.authenticate_v2(options, @connection_options)

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

@@ -13,10 +13,11 @@ module Fog
 
         def all
           data = service.list_images_detail.body['images']
-          load(data)
+          images = load(data)
           if server
             self.replace(self.select {|image| image.server_id == server.id})
           end
+          images
         end
 
         def get(image_id)

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

@@ -24,7 +24,7 @@ module Fog
 
         def get(key)
           requires :parent
-          data = service.get_meta(collection_name, @parent.id, key).body["meta"]
+          data = service.get_metadata(collection_name, @parent.id, key).body["meta"]
           metas = []
           data.each_pair {|k,v| metas << {"key" => k, "value" => v} }
           new(metas[0])
@@ -34,12 +34,12 @@ module Fog
 
         def update(data=nil)
           requires :parent
-          service.update_metadata(collection_name, @parent.id, meta_hash(data))
+          service.update_metadata(collection_name, @parent.id, to_hash(data))
         end
 
         def set(data=nil)
           requires :parent
-          service.set_metadata(collection_name, @parent.id, meta_hash(data))
+          service.set_metadata(collection_name, @parent.id, to_hash(data))
         end
 
         def new(attributes = {})
@@ -47,8 +47,7 @@ module Fog
           super({ :parent => @parent }.merge!(attributes))
         end
 
-        private
-        def meta_hash(data=nil)
+        def to_hash(data=nil)
           if data.nil?
             data={}
             self.each do |meta|

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

@@ -46,7 +46,6 @@ module Fog
         def initialize(attributes={})
           # Old 'connection' is renamed as service and should be used instead
           prepare_service_value(attributes)
-          attributes[:metadata] = {}
 
           self.security_groups = attributes.delete(:security_groups)
           self.min_count = attributes.delete(:min_count)
@@ -66,9 +65,10 @@ module Fog
         end
 
         def metadata=(new_metadata={})
+          return unless new_metadata
           metas = []
           new_metadata.each_pair {|k,v| metas << {"key" => k, "value" => v} }
-          metadata.load(metas)
+          @metadata = metadata.load(metas)
         end
 
         def user_data=(ascii_userdata)
@@ -86,24 +86,41 @@ module Fog
           service.images(:server => self)
         end
 
-        def private_ip_address
-          if addresses['private']
-            #assume only a single private
-            return addresses['private'].first
-          elsif addresses['internet']
-            #assume no private IP means private cloud
-            return addresses['internet'].first
-          end
+        def all_addresses
+          # currently openstack API does not tell us what is a floating ip vs a fixed ip for the vm listing,
+          # we fall back to get all addresses and filter sadly.
+          @all_addresses ||= service.list_all_addresses.body["floating_ips"].select{|data| data['instance_id'] == id}
         end
 
-        def public_ip_address
-          if addresses['public']
-            #assume last is either original or assigned from floating IPs
-            return addresses['public'].last
-          elsif addresses['internet']
-            #assume no public IP means private cloud
-            return addresses['internet'].first
-          end
+        def reload
+          @all_addresses = nil
+          super
+        end
+
+        # returns all ip_addresses for a given instance
+        # this includes both the fixed ip(s) and the floating ip(s)
+        def ip_addresses
+          addresses.values.flatten.map{|x| x['addr']}
+        end
+
+        def floating_ip_addresses
+          all_addresses.map{|addr| addr["ip"]}
+        end
+
+        alias_method :public_ip_addresses, :floating_ip_addresses
+
+        def floating_ip_address
+          floating_ip_addresses.first
+        end
+
+        alias_method :public_ip_address, :floating_ip_address
+
+        def private_ip_addresses
+          ip_addresses - floating_ip_addresses
+        end
+
+        def private_ip_address
+          private_ip_addresses.first
         end
 
         def image_ref
@@ -229,10 +246,7 @@ module Fog
         def save
           raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
           requires :flavor_ref, :image_ref, :name
-          meta_hash = {}
-          metadata.each { |meta| meta_hash.store(meta.key, meta.value) }
           options = {
-            'metadata'    => meta_hash,
             'personality' => personality,
             'accessIPv4' => accessIPv4,
             'accessIPv6' => accessIPv6,
@@ -244,6 +258,7 @@ module Fog
             'max_count'   => @max_count,
             'os:scheduler_hints' => @os_scheduler_hints
           }
+          options['metadata'] = metadata.to_hash unless @metadata.nil?
           options = options.reject {|key, value| value.nil?}
           data = service.create_server(name, image_ref, flavor_ref, options)
           merge_attributes(data.body['server'])

data/lib/fog/openstack/models/identity/role.rb

@@ -37,7 +37,7 @@ module Fog
           when :add
             service.create_user_role(tenant_id, user_id, id).status == 200
           when :remove
-            service.delete_user_role(tenant_id, user_id, id).status == 200
+            service.delete_user_role(tenant_id, user_id, id).status == 204
           end
         end
 

data/lib/fog/openstack/models/network/floating_ip.rb

@@ -32,7 +32,7 @@ module Fog
           merge_attributes(connection.create_floating_ip(self.floating_network_id,
 
 
-                                                    self.attributes).body['floating_ip'])
+                                                    self.attributes).body['floatingip'])
           self
         end
 

data/lib/fog/openstack/models/network/floating_ips.rb

@@ -17,11 +17,11 @@ module Fog
 
         def all(filters = filters)
           self.filters = filters
-          load(connection.list_floating_ips(filters).body['floating_ips'])
+          load(connection.list_floating_ips(filters).body['floatingips'])
         end
 
         def get(floating_network_id)
-          if floating_ip = connection.get_floating_ip(floating_network_id).body['floating_ip']
+          if floating_ip = connection.get_floating_ip(floating_network_id).body['floatingip']
             new(floating_ip)
           end
         rescue Fog::Network::OpenStack::NotFound

data/lib/fog/openstack/models/network/network.rb

@@ -12,6 +12,14 @@ module Fog
         attribute :status
         attribute :admin_state_up
         attribute :tenant_id
+        attribute :provider_network_type,       
+                  :aliases =>  'provider:network_type'
+        attribute :provider_physical_network,
+                  :aliases => 'provider:physical_network'
+        attribute :provider_segmentation_id,
+                  :aliases => 'provider:segmentation_id'
+        attribute :router_external,
+                  :aliases => 'router:external'
 
         def initialize(attributes)
           # Old 'connection' is renamed as service and should be used instead

data/lib/fog/openstack/models/storage/directories.rb

@@ -0,0 +1,39 @@
+require 'fog/core/collection'
+require 'fog/openstack/models/storage/directory'
+
+module Fog
+  module Storage
+    class OpenStack
+
+      class Directories < Fog::Collection
+
+        model Fog::Storage::OpenStack::Directory
+
+        def all
+          data = service.get_containers.body
+          load(data)
+        end
+
+        def get(key, options = {})
+          data = service.get_container(key, options)
+          directory = new(:key => key)
+          for key, value in data.headers
+            if ['X-Container-Bytes-Used', 'X-Container-Object-Count'].include?(key)
+              directory.merge_attributes(key => value)
+            end
+          end
+          directory.files.merge_attributes(options)
+          directory.files.instance_variable_set(:@loaded, true)
+          data.body.each do |file|
+            directory.files << directory.files.new(file)
+          end
+          directory
+        rescue Fog::Storage::OpenStack::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+require 'fog/core/model'
+require 'fog/openstack/models/storage/files'
+
+module Fog
+  module Storage
+    class OpenStack
+
+      class Directory < Fog::Model
+
+        identity  :key, :aliases => 'name'
+
+        attribute :bytes, :aliases => 'X-Container-Bytes-Used'
+        attribute :count, :aliases => 'X-Container-Object-Count'
+
+        def destroy
+          requires :key
+          service.delete_container(key)
+          true
+        rescue Excon::Errors::NotFound
+          false
+        end
+
+        def files
+          @files ||= begin
+            Fog::Storage::OpenStack::Files.new(
+              :directory    => self,
+              :service   => service
+            )
+          end
+        end
+
+        def public=(new_public)
+          @public = new_public
+        end
+
+        def public_url
+          raise NotImplementedError
+        end
+
+        def save
+          requires :key
+          service.put_container(key)
+          true
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,150 @@
+require 'fog/core/model'
+
+module Fog
+  module Storage
+    class OpenStack
+
+      class File < Fog::Model
+
+        identity  :key,             :aliases => 'name'
+
+        attribute :content_length,  :aliases => ['bytes', 'Content-Length'], :type => :integer
+        attribute :content_type,    :aliases => ['content_type', 'Content-Type']
+        attribute :etag,            :aliases => ['hash', 'Etag']
+        attribute :last_modified,   :aliases => ['last_modified', 'Last-Modified'], :type => :time
+        attribute :access_control_allow_origin, :aliases => ['Access-Control-Allow-Origin']
+        attribute :origin,          :aliases => ['Origin']
+
+        def body
+          attributes[:body] ||= if last_modified
+            collection.get(identity).body
+          else
+            ''
+          end
+        end
+
+        def body=(new_body)
+          attributes[:body] = new_body
+        end
+
+        def directory
+          @directory
+        end
+
+        def copy(target_directory_key, target_file_key, options={})
+          requires :directory, :key
+          options['Content-Type'] ||= content_type if content_type
+          options['Access-Control-Allow-Origin'] ||= access_control_allow_origin if access_control_allow_origin
+          options['Origin'] ||= origin if origin
+          service.copy_object(directory.key, key, target_directory_key, target_file_key, options)
+          target_directory = service.directories.new(:key => target_directory_key)
+          target_directory.files.get(target_file_key)
+        end
+
+        def destroy
+          requires :directory, :key
+          service.delete_object(directory.key, key)
+          true
+        end
+
+        def metadata
+          @metadata ||= headers_to_metadata
+        end
+
+        def owner=(new_owner)
+          if new_owner
+            attributes[:owner] = {
+              :display_name => new_owner['DisplayName'],
+              :id           => new_owner['ID']
+            }
+          end
+        end
+
+        def public=(new_public)
+          new_public
+        end
+
+        def public_url
+          requires :key
+          self.collection.get_url(self.key)
+        end
+
+        def save(options = {})
+          requires :body, :directory, :key
+          options['Content-Type'] = content_type if content_type
+          options['Access-Control-Allow-Origin'] = access_control_allow_origin if access_control_allow_origin
+          options['Origin'] = origin if origin
+          options.merge!(metadata_to_headers)
+
+          data = service.put_object(directory.key, key, body, options)
+          update_attributes_from(data)
+          refresh_metadata
+
+          self.content_length = Fog::Storage.get_body_size(body)
+          self.content_type ||= Fog::Storage.get_content_type(body)
+          true
+        end
+
+        private
+
+        def directory=(new_directory)
+          @directory = new_directory
+        end
+
+        def refresh_metadata
+          metadata.reject! {|k, v| v.nil? }
+        end
+
+        def headers_to_metadata
+          key_map = key_mapping
+          Hash[metadata_attributes.map {|k, v| [key_map[k], v] }]
+        end
+
+        def key_mapping
+          key_map = metadata_attributes
+          key_map.each_pair {|k, v| key_map[k] = header_to_key(k)}
+        end
+
+        def header_to_key(opt)
+          opt.gsub(metadata_prefix, '').split('-').map {|k| k[0, 1].downcase + k[1..-1]}.join('_').to_sym
+        end
+
+        def metadata_to_headers
+          header_map = header_mapping
+          Hash[metadata.map {|k, v| [header_map[k], v] }]
+        end
+
+        def header_mapping
+          header_map = metadata.dup
+          header_map.each_pair {|k, v| header_map[k] = key_to_header(k)}
+        end
+
+        def key_to_header(key)
+          metadata_prefix + key.to_s.split(/[-_]/).map(&:capitalize).join('-')
+        end
+
+        def metadata_attributes
+          if last_modified
+            headers = service.head_object(directory.key, self.key).headers
+            headers.reject! {|k, v| !metadata_attribute?(k)}
+          else
+            {}
+          end
+        end
+
+        def metadata_attribute?(key)
+          key.to_s =~ /^#{metadata_prefix}/
+        end
+
+        def metadata_prefix
+          "X-Object-Meta-"
+        end
+
+        def update_attributes_from(data)
+          merge_attributes(data.headers.reject {|key, value| ['Content-Length', 'Content-Type'].include?(key)})
+        end
+      end
+
+    end
+  end
+end