fog 1.9.0 → 1.10.0

data/lib/fog/rackspace/models/compute_v2/servers.rb

@@ -9,18 +9,36 @@ module Fog
 
         model Fog::Compute::RackspaceV2::Server
 
+        # Returns list of servers 
+        # @return [Array<Fog::Compute::RackspaceV2::Server>] Retrieves a list servers.
+        # @note Fog's current implementation only returns 1000 servers
+        # @see http://docs.rackspace.com/servers/api/v2/cs-devguide/content/List_Servers-d1e2078.html
         def all
           data = service.list_servers.body['servers']
           load(data)
         end
 
+        # Creates a new server and populates ssh keys
+        # @note This method is incompatible with Cloud Servers utlizing RackConnect. RackConnect users 
+        #     should use server personalization to install keys.  Please see Server#personality for more information.
+        # @example
+        #   service.servers.bootstrap :name => 'bootstrap-server',
+        #                             :flavor_id => service.flavors.first.id,
+        #                             :image_id => service.images.find {|img| img.name =~ /Ubuntu/}.id,
+        #                             :public_key_path => '~/.ssh/fog_rsa.pub',
+        #                             :private_key_path => '~/.ssh/fog_rsa'
+        #        
         def bootstrap(new_attributes = {})
           server = create(new_attributes)
-          server.wait_for { ready? }
+          server.wait_for(1500) { ready? && !public_ip_address.empty? }
           server.setup(:password => server.password)
           server
         end
 
+        # Retrieves server
+        # @param [String] server_id for server to be returned
+        # @return [Fog::Compute::RackspaceV2:Server]
+        # @see http://docs.rackspace.com/servers/api/v2/cs-devguide/content/Get_Server_Details-d1e2623.html
         def get(server_id)
           data = service.get_server(server_id).body['server']
           new(data)

data/lib/fog/rackspace/models/dns/zones.rb

@@ -8,11 +8,44 @@ module Fog
 
         model Fog::DNS::Rackspace::Zone
 
-        def all
+        def all(options={})
           clear
-          data = service.list_domains.body['domains']
+          data = service.list_domains(options).body['domains']
           load(data)
         end
+        
+        # Returns all domains containing the given substring. Still limited 
+        # by the 100-domain pagination limit. Returns an empty array if
+        # no matches.
+        def find(substring)
+          clear
+          data = service.list_domains(:name => substring).body['domains']
+          load(data)
+        end
+        
+        alias :each_zone_this_page :each
+        def each
+          if !block_given?
+            self
+          else
+            body = service.list_domains.body
+            subset = dup.all
+
+            subset.each_zone_this_page {|f| yield f}
+            if body.has_key?('links')
+              while !body['links'].select{|l| l['rel'] == 'next'}.empty?
+                url = body['links'].select{|l| l['rel'] == 'next'}.first['href']
+                query = url.match(/\?(.+)/)
+                parsed = CGI.parse($1)
+                
+                body = service.list_domains(:offset => parsed['offset'], :limit => parsed['limit']).body
+                subset = dup.all(:offset => parsed['offset'], :limit => parsed['limit'])
+                subset.each_zone_this_page {|f| yield f}
+              end
+            end
+            self
+          end
+        end
 
         def get(zone_id)
           if zone_id.nil? or zone_id.to_s.empty?

data/lib/fog/rackspace/models/identity/credentials.rb

@@ -17,14 +17,15 @@ module Fog
 
         def get(id)
           requires :user
-          data = retrieve_credentials.find{ |credential| credential['id'] == id }
+          data = retrieve_credentials.find { |credential| credential['apiKey'] == id }
           data && new(data)
         end
 
         private
 
         def retrieve_credentials
-          data = service.list_credentials(user.identity).body['credentials']
+          raw_credentials = service.list_credentials(user.identity).body['credentials']
+          raw_credentials.map { |c| c['RAX-KSKEY:apiKeyCredentials'] }
         end
       end
     end

data/lib/fog/rackspace/models/storage/account.rb

@@ -0,0 +1,24 @@
+require 'fog/core/model'
+
+module Fog
+  module Storage
+    class Rackspace
+      class Account < Fog::Model
+        attribute :meta_temp_url_key, :aliases => 'X-Account-Meta-Temp-Url-Key'
+        attribute :container_count, :aliases => 'X-Account-Container-Count', :type => :integer
+        attribute :bytes_used, :aliases => 'X-Account-Bytes-Used', :type => :integer
+        attribute :object_count, :aliases => 'X-Account-Object-Count', :type => :integer        
+        
+        def save
+          service.post_set_meta_temp_url_key meta_temp_url_key
+          true
+        end
+        
+        def reload
+          response = service.head_containers
+          merge_attributes response.headers
+        end
+      end
+    end
+  end
+end

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

@@ -26,8 +26,11 @@ module Fog
               directory.merge_attributes(key => value)
             end
           end
+          
+          directory.metadata = Metadata.from_headers(directory, data.headers)
           directory.files.merge_attributes(options)
           directory.files.instance_variable_set(:@loaded, true)
+          
           data.body.each do |file|
             directory.files << directory.files.new(file)
           end

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

@@ -1,5 +1,6 @@
 require 'fog/core/model'
 require 'fog/rackspace/models/storage/files'
+require 'fog/rackspace/models/storage/metadata'
 
 module Fog
   module Storage
@@ -9,14 +10,33 @@ module Fog
 
         identity  :key, :aliases => 'name'
 
-        attribute :bytes, :aliases => 'X-Container-Bytes-Used'
-        attribute :count, :aliases => 'X-Container-Object-Count'
+        attribute :bytes, :aliases => 'X-Container-Bytes-Used', :type => :integer
+        attribute :count, :aliases => 'X-Container-Object-Count', :type => :integer
         attribute :cdn_cname
+        
+        attr_writer :public, :public_url
+
+        def metadata=(hash)
+          if hash.is_a? Fog::Storage::Rackspace::Metadata
+            attributes[:metadata] = hash
+          else
+            attributes[:metadata] = Fog::Storage::Rackspace::Metadata.new(self, hash)
+          end
+          attributes[:metadata]
+        end
+        
+        def metadata
+          unless attributes[:metadata]
+             response = service.head_container(key)
+             attributes[:metadata] = Fog::Storage::Rackspace::Metadata.from_headers(self, response.headers)
+          end
+          attributes[:metadata]
+        end
 
         def destroy
           requires :key
           service.delete_container(key)
-          service.cdn.post_container(key, 'X-CDN-Enabled' => 'False')
+          service.cdn.publish_container(self, false) if cdn_enabled?
           true
         rescue Excon::Errors::NotFound
           false
@@ -31,50 +51,59 @@ module Fog
           end
         end
 
-        def public=(new_public)
-          @public = new_public
-        end
-
-        def public_url
-          requires :key
-          @public_url ||= begin
-            begin response = service.cdn.head_container(key)
-              if response.headers['X-Cdn-Enabled'] == 'True'
-                if service.rackspace_cdn_ssl == true
-                  response.headers['X-Cdn-Ssl-Uri']
-                else
-                  cdn_cname || response.headers['X-Cdn-Uri']
-                end
-              end
-            rescue Fog::Service::NotFound
-              nil
-            end
+        def public?
+          if @public.nil?
+            @public ||= (key && public_url) ? true : false
           end
+          @public
+        end
+        
+        def reload
+          @public = nil
+          @urls = nil
+          @files = nil
+          super
+        end
+        
+        def public_url          
+          return nil if urls.empty?
+          return urls[:ssl_uri] if service.ssl?          
+          cdn_cname || urls[:uri]
+        end
+        
+        def ios_url
+          urls[:ios_uri]
+        end
+        
+        def streaming_url
+          urls[:streaming_uri]
         end
 
         def save
           requires :key
-          service.put_container(key)
-
-          if service.cdn && @public
-            # if public and CDN connection then update cdn to public
-            uri_header = 'X-CDN-URI'
-            if service.rackspace_cdn_ssl == true
-              uri_header = 'X-CDN-SSL-URI'
-            end
-            @public_url = service.cdn.put_container(key, 'X-CDN-Enabled' => 'True').headers[uri_header]
-          elsif service.cdn && !@public
-            service.cdn.put_container(key, 'X-CDN-Enabled' => 'False')
-            @public_url = nil
-          elsif !service.cdn && @public
-            # if public but no CDN connection then error
-            raise(Fog::Storage::Rackspace::Error.new("Directory can not be set as :public without a CDN provided"))
-          end
+          create_container
+          raise Fog::Storage::Rackspace::Error.new("Directory can not be set as :public without a CDN provided") if public? && !cdn_enabled?
+          @urls = service.cdn.publish_container(self, public?)
           true
         end
-
+        
+        private
+        
+        def cdn_enabled?
+          service.cdn && service.cdn.enabled?
+        end
+        
+        def urls
+          requires :key          
+          return {} unless cdn_enabled?
+          @urls ||= service.cdn.urls(self)
+        end
+           
+        def create_container
+          headers = attributes[:metadata].nil? ? {} : metadata.to_headers           
+          service.put_container(key, headers)        
+        end
       end
-
     end
   end
 end

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

@@ -14,6 +14,11 @@ module Fog
         attribute :last_modified,   :aliases => ['last_modified', 'Last-Modified'], :type => :time
         attribute :access_control_allow_origin, :aliases => ['Access-Control-Allow-Origin']
         attribute :origin,          :aliases => ['Origin']
+        
+        attr_writer :public
+
+        attr_accessor :directory
+        attr_writer :public
 
         def body
           attributes[:body] ||= if last_modified
@@ -27,10 +32,6 @@ module Fog
           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
@@ -47,10 +48,19 @@ module Fog
           true
         end
 
+        def metadata=(hash)
+          if hash.is_a? Fog::Storage::Rackspace::Metadata
+            attributes[:metadata] = hash
+          else
+            attributes[:metadata] = Fog::Storage::Rackspace::Metadata.new(self, hash)
+          end
+          attributes[:metadata]
+        end
+        
         def metadata
-          @metadata ||= headers_to_metadata
+          attributes[:metadata] ||= Fog::Storage::Rackspace::Metadata.new(self)
         end
-
+        
         def owner=(new_owner)
           if new_owner
             attributes[:owner] = {
@@ -60,13 +70,28 @@ module Fog
           end
         end
 
-        def public=(new_public)
-          new_public
+        def public?
+          directory.public?
         end
-
+        
         def public_url
-          requires :key
-          self.collection.get_url(self.key)
+          Files::file_url directory.public_url, key
+        end
+        
+        def ios_url
+          Files::file_url directory.ios_url, key
+        end
+        
+        def streaming_url
+          Files::file_url directory.streaming_url, key
+        end      
+        
+        def purge_from_cdn
+          if public?
+            service.cdn.purge(self)
+          else
+            false
+          end
         end
 
         def save(options = {})
@@ -74,12 +99,11 @@ module Fog
           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)
+          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
@@ -87,59 +111,6 @@ module Fog
 
         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

data/lib/fog/rackspace/models/storage/files.rb

@@ -55,10 +55,13 @@ module Fog
         def get(key, &block)
           requires :directory
           data = service.get_object(directory.key, key, &block)
+          metadata = Metadata.from_headers(self, data.headers)  
           file_data = data.headers.merge({
             :body => data.body,
-            :key  => key
+            :key  => key,
+            :metadata => metadata
           })
+          
           new(file_data)
         rescue Fog::Storage::Rackspace::NotFound
           nil
@@ -67,10 +70,10 @@ module Fog
         def get_url(key)
           requires :directory
           if self.directory.public_url
-            "#{self.directory.public_url}/#{Fog::Rackspace.escape(key, '/')}"
+            Files::file_url directory.public_url, key
           end
         end
-
+        
         def head(key, options = {})
           requires :directory
           data = service.head_object(directory.key, key)
@@ -87,8 +90,12 @@ module Fog
           super({ :directory => directory }.merge!(attributes))
         end
 
-      end
+        def self.file_url(path, key)
+          return nil unless path
+          "#{path}/#{Fog::Rackspace.escape(key, '/')}"
+        end
 
+      end
     end
   end
 end