fog 0.9.0 → 0.10.0

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

@@ -92,9 +92,9 @@ module Fog
           requires :directory, :key
           if connection.get_object_acl(directory.key, key).body['AccessControlList'].detect {|grant| grant['Grantee']['URI'] == 'http://acs.amazonaws.com/groups/global/AllUsers' && grant['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}.s3.amazonaws.com/#{key}"
+              "https://#{directory.key}.s3.amazonaws.com/#{Fog::AWS.escape(key)}"
             else
-              "https://s3.amazonaws.com/#{directory.key}/#{key}"
+              "https://s3.amazonaws.com/#{directory.key}/#{Fog::AWS.escape(key)}"
             end
           else
             nil
@@ -113,7 +113,7 @@ module Fog
           options['Content-MD5'] = content_md5 if content_md5
           options['Content-Type'] = content_type if content_type
           options['Expires'] = expires if expires
-          options.merge(metadata)
+          options.merge!(metadata)
           options['x-amz-storage-class'] = storage_class if storage_class
 
           data = connection.put_object(directory.key, key, body, options)

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

@@ -6,6 +6,8 @@ module Fog
     class AWS
 
       class Files < Fog::Collection
+        extend Fog::Deprecation
+        deprecate :get_url, :get_https_url
 
         attribute :common_prefixes, :aliases => 'CommonPrefixes'
         attribute :delimiter,       :aliases => 'Delimiter'
@@ -76,9 +78,14 @@ module Fog
           end
         end
 
-        def get_url(key, expires)
+        def get_http_url(key, expires)
           requires :directory
-          connection.get_object_url(directory.key, key, expires)
+          connection.get_object_http_url(directory.key, key, expires)
+        end
+
+        def get_https_url(key, expires)
+          requires :directory
+          connection.get_object_https_url(directory.key, key, expires)
         end
 
         def head(key, options = {})

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

@@ -6,6 +6,8 @@ module Fog
     class Google
 
       class Files < Fog::Collection
+        extend Fog::Deprecation
+        deprecate :get_url, :get_https_url
 
         attribute :common_prefixes, :aliases => 'CommonPrefixes'
         attribute :delimiter,       :aliases => 'Delimiter'
@@ -68,9 +70,14 @@ module Fog
           nil
         end
 
-        def get_url(key, expires)
+        def get_http_url(key, expires)
           requires :directory
-          connection.get_object_url(directory.key, key, expires)
+          connection.get_object_http_url(directory.key, key, expires)
+        end
+
+        def get_https_url(key, expires)
+          requires :directory
+          connection.get_object_https_url(directory.key, key, expires)
         end
 
         def head(key, options = {})

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

@@ -0,0 +1,48 @@
+require 'fog/core/collection'
+require 'fog/storage/models/ninefold/directory'
+
+module Fog
+  module Storage
+    class Ninefold
+
+      class Directories < Fog::Collection
+
+        attribute :directory
+
+        model Fog::Storage::Ninefold::Directory
+
+        def all
+          directory ? ns = directory.key : ns = ''
+          ns = ns + '/' unless ns =~ /\/$/
+          data = connection.get_namespace(ns).body[:DirectoryList]
+          data = {:DirectoryEntry => []} if data.kind_of? String
+          data[:DirectoryEntry] = [data[:DirectoryEntry]] if data[:DirectoryEntry].kind_of? Hash
+          dirs = data[:DirectoryEntry].select {|de| de[:FileType] == 'directory'}
+          dirs.each do |d|
+            d[:Filename] = ns + d[:Filename] if directory
+            d[:Filename] += '/' unless d[:Filename] =~ /\/$/
+          end
+          load(dirs)
+        end
+
+        def get(key, options = {})
+          return nil if key == '' # Root dir shouldn't be retrieved like this.
+          key =~ /\/$/ ? ns = key : ns = key + '/'
+          res = connection.get_namespace ns
+          emc_meta = res.headers['x-emc-meta']
+          obj_id = emc_meta.scan(/objectid=(\w+),/).flatten[0]
+          new(:objectid => obj_id, :key => ns)
+        rescue Fog::Storage::Ninefold::NotFound
+          nil
+        end
+
+        def new(attributes ={})
+          attributes = {:directory => directory}.merge(attributes) if directory
+          super(attributes)
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+require 'fog/core/model'
+
+module Fog
+  module Storage
+    class Ninefold
+
+      class Directory < Fog::Model
+
+        identity :key, :aliases => :Filename
+        attribute :objectid, :aliases => :ObjectID
+
+        def files
+          @files ||= begin
+                       Fog::Storage::Ninefold::Files.new(
+                                                          :directory    => self,
+                                                          :connection   => connection
+                                                          )
+          end
+        end
+
+        def directories
+          @directories ||= begin
+                       Fog::Storage::Ninefold::Directories.new(
+                                                               :directory    => self,
+                                                               :connection   => connection
+                                                               )
+          end
+        end
+
+        def save
+          self.key = attributes[:directory].key + key if attributes[:directory]
+          self.key = key + '/' unless key =~ /\/$/
+          res = connection.post_namespace key
+          reload
+        end
+
+        def destroy(opts={})
+          if opts[:recursive]
+            files.each {|f| f.destroy }
+            directories.each do |d|
+              d.files.each {|f| f.destroy }
+              d.destroy(opts)
+            end
+          end
+          connection.delete_namespace key
+        end
+
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+require 'fog/core/model'
+
+module Fog
+  module Storage
+    class Ninefold
+
+      class File < Fog::Model
+
+        identity  :key,             :aliases => :Filename
+
+        attribute :content_length,  :aliases => ['bytes', 'Content-Length'], :type => :integer
+        attribute :content_type,    :aliases => ['content_type', 'Content-Type']
+        attribute :objectid,        :aliases => :ObjectID
+
+        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 destroy
+          requires :directory, :key
+          connection.delete_namespace([directory.key, key].join('/'))
+          true
+        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)
+          # NOOP - we don't need to flag files as public, getting the public URL for a file handles it.
+        end
+
+        # By default, expire in 5 years
+        def public_url(expires = (Time.now + 5 * 365 * 24 * 60 * 60))
+          requires :objectid
+          # TODO - more efficient method to get this?
+          storage = Fog::Storage.new(:provider => 'Ninefold')
+          uri = URI::HTTP.build(:scheme => Fog::Storage::Ninefold::STORAGE_SCHEME, :host => Fog::Storage::Ninefold::STORAGE_HOST, :port => Fog::Storage::Ninefold::STORAGE_PORT.to_i, :path => "/rest/objects/#{objectid}" )
+          Fog::Storage.new(:provider => 'Ninefold').uid
+
+
+          sb = "GET\n"
+          sb += uri.path.downcase + "\n"
+          sb += storage.uid + "\n"
+          sb += String(expires.to_i())
+
+          signature = storage.sign( sb )
+          uri.query = "uid=#{CGI::escape(storage.uid)}&expires=#{expires.to_i()}&signature=#{CGI::escape(signature)}"
+          uri.to_s
+        end
+
+        def save(options = {})
+          requires :body, :directory, :key
+          directory.kind_of?(Directory) ? ns = directory.key : ns = directory
+          ns += key
+          options[:headers] ||= {}
+          options[:headers]['Content-Type'] = content_type if content_type
+          options[:body] = body
+          p options
+          if objectid
+            # pre-existing file, do a PUT
+            data = connection.put_namespace(ns, options)
+          else
+            # new file, POST
+            data = connection.post_namespace(ns, options)
+            self.objectid = data.headers['location'].split('/')[-1]
+          end
+          # merge_attributes(data.headers)
+          true
+        end
+
+        private
+
+        def directory=(new_directory)
+          @directory = new_directory
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+require 'fog/core/collection'
+require 'fog/storage/models/ninefold/file'
+
+module Fog
+  module Storage
+    class Ninefold
+
+      class Files < Fog::Collection
+
+        attribute :directory
+        attribute :limit
+        attribute :marker
+        attribute :path
+        attribute :prefix
+
+        model Fog::Storage::Ninefold::File
+
+        def all(options = {})
+          requires :directory
+          directory ? ns = directory.key : ns = ''
+          ns = ns + '/' unless ns =~ /\/$/
+          data = connection.get_namespace(ns).body[:DirectoryList]
+          data = {:DirectoryEntry => []} if data.kind_of? String
+          data[:DirectoryEntry] = [data[:DirectoryEntry]] if data[:DirectoryEntry].kind_of? Hash
+          files = data[:DirectoryEntry].select {|de| de[:FileType] == 'regular'}
+          files.each do |s|
+            s[:directory] = directory
+          end
+          # TODO - Load additional file meta?
+          load(files)
+        end
+
+        def get(key, &block)
+          requires :directory
+          data = connection.get_namespace(directory.key + key, :parse => false)#, &block)
+          file_data = data.headers.merge({
+            :body => data.body,
+            :key  => key
+          })
+          new(file_data)
+        rescue Fog::Storage::Ninefold::NotFound
+          nil
+        end
+
+        def get_url(key)
+          requires :directory
+          if self.directory.public_url
+            "#{self.directory.public_url}/#{key}"
+          end
+        end
+
+        def head(key, options = {})
+          requires :directory
+          data = connection.head_object(directory.key, key)
+          file_data = data.headers.merge({
+            :key => key
+          })
+          new(file_data)
+        rescue Fog::Storage::Rackspace::NotFound
+          nil
+        end
+
+        def new(attributes = {})
+          requires :directory
+          super({ :directory => directory }.merge!(attributes))
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -55,11 +55,16 @@ module Fog
         def save
           requires :key
           connection.put_container(key)
-          if @public
+
+          if @connection.cdn && @public
+            # if public and CDN connection then update cdn to public
             @public_url = connection.cdn.put_container(key, 'X-CDN-Enabled' => 'True').headers['X-CDN-URI']
-          else
+          elsif @connection.cdn && !@public
             connection.cdn.put_container(key, 'X-CDN-Enabled' => 'False')
             @public_url = nil
+          elsif !@connection.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
           true
         end

data/lib/fog/storage/ninefold.rb

@@ -0,0 +1,149 @@
+require 'base64'
+require 'hmac-sha1'
+
+module Fog
+  module Storage
+    class Ninefold < Fog::Service
+      STORAGE_HOST = "onlinestorage.ninefold.com" #"api.ninefold.com"
+      STORAGE_PATH = "" #"/storage/v1.0"
+      STORAGE_PORT = "80" # "443"
+      STORAGE_SCHEME = "http" # "https"
+
+      requires :ninefold_storage_token, :ninefold_storage_secret
+
+      model_path 'fog/storage/models/ninefold'
+      model       :directory
+      collection  :directories
+      model       :file
+      collection  :files
+
+      request_path 'fog/storage/requests/ninefold'
+      # request :delete_container
+      request :get_namespace
+      request :post_namespace
+      request :put_namespace
+      request :delete_namespace
+
+      module Utils
+      end
+
+      class Mock
+        include Utils
+
+        def initialize(options={})
+          require 'mime/types'
+          @ninefold_storage_token = options[:ninefold_storage_token]
+          @ninefold_storage_secret = options[:ninefold_storage_secret]
+        end
+
+        def request(options)
+          raise "Ninefold Storage mocks not implemented"
+        end
+
+      end
+
+      class Real
+        include Utils
+
+        def initialize(options={})
+          require 'mime/types'
+          @ninefold_storage_token = options[:ninefold_storage_token]
+          @ninefold_storage_secret = options[:ninefold_storage_secret]
+          @ninefold_storage_secret_decoded = Base64.decode64( @ninefold_storage_secret )
+
+          Excon.ssl_verify_peer = false if options[:rackspace_servicenet] == true
+          @connection = Fog::Connection.new("#{Fog::Storage::Ninefold::STORAGE_SCHEME}://#{Fog::Storage::Ninefold::STORAGE_HOST}:#{Fog::Storage::Ninefold::STORAGE_PORT}", true) # persistent
+        end
+
+        def uid
+          @ninefold_storage_token#.split('/')[-1]
+        end
+
+        def sign(string)
+          value = ::HMAC::SHA1.digest( @ninefold_storage_secret_decoded, string )
+          Base64.encode64( value ).chomp()
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        def request(params, &block)
+          req_path = params[:path]
+          # Force set host and port
+          params.merge!({
+                          :host     => Fog::Storage::Ninefold::STORAGE_HOST,
+                          :path     => "#{Fog::Storage::Ninefold::STORAGE_PATH}/rest/#{params[:path]}",
+                        })
+          # Set default method and headers
+          params = {:method => 'GET', :headers => {}}.merge params
+
+          params[:headers]["Content-Type"] ||= "application/octet-stream"
+
+          # Add request date
+          params[:headers]["date"] = Time.now().httpdate()
+          params[:headers]["x-emc-uid"] = @ninefold_storage_token
+
+          # Build signature string
+          signstring = ""
+          signstring += params[:method]
+          signstring += "\n"
+          signstring += params[:headers]["Content-Type"]
+          signstring += "\n"
+          if( params[:headers]["range"] )
+            signstring += params[:headers]["range"]
+          end
+          signstring += "\n"
+          signstring += params[:headers]["date"]
+          signstring += "\n"
+
+          signstring += "/rest/" + URI.unescape( req_path ).downcase
+          query_str = params[:query].map{|k,v| "#{k}=#{v}"}.join('&')
+          signstring += '?' + query_str unless query_str.empty?
+          signstring += "\n"
+
+          customheaders = {}
+          params[:headers].each { |key,value|
+            if key == "x-emc-date"
+              #skip
+            elsif key =~ /^x-emc-/
+              customheaders[ key.downcase ] = value
+            end
+          }
+          header_arr = customheaders.sort()
+          first = true
+          header_arr.each { |key,value|
+            # Values are lowercase and whitespace-normalized
+            signstring += key + ":" + value.strip.chomp.squeeze( " " ) + "\n"
+          }
+
+          digest = ::HMAC::SHA1.digest( @ninefold_storage_secret_decoded, signstring.chomp() )
+          signature = Base64.encode64( digest ).chomp()
+          params[:headers]["x-emc-signature"] = signature
+
+          begin
+            response = @connection.request(params, &block)
+          rescue Excon::Errors::HTTPStatusError => error
+            raise case error
+            when Excon::Errors::NotFound
+              Fog::Storage::Ninefold::NotFound.slurp(error)
+            else
+              error
+            end
+          end
+          unless response.body.empty?
+            if params[:parse]
+              document = Fog::ToHashDocument.new
+              parser = Nokogiri::XML::SAX::PushParser.new(document)
+              parser << response.body
+              parser.finish
+              response.body = document.body
+            end
+          end
+          response
+        end
+
+      end
+    end
+  end
+end