fog 0.11.0 → 1.0.0

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

@@ -1,87 +0,0 @@
-require 'fog/core/collection'
-require 'fog/storage/models/local/file'
-
-module Fog
-  module Storage
-    class Local
-
-      class Files < Fog::Collection
-
-        attribute :directory
-
-        model Fog::Storage::Local::File
-
-        def all
-          requires :directory
-          if directory.collection.get(directory.key)
-            pwd = Dir.pwd
-            Dir.chdir(connection.path_to(directory.key))
-            data = Dir.glob('**/*').reject do |file|
-              ::File.directory?(file)
-            end.map do |key|
-              path = file_path(key)
-              {
-                :content_length => ::File.size(path),
-                :key            => key,
-                :last_modified  => ::File.mtime(path)
-              }
-            end
-            Dir.chdir(pwd)
-            load(data)
-          else
-            nil
-          end
-        end
-
-        def get(key, &block)
-          requires :directory
-          path = file_path(key)
-          if ::File.exists?(path)
-            data = {
-              :content_length => ::File.size(path),
-              :key            => key,
-              :last_modified  => ::File.mtime(path)
-            }
-            if block_given?
-              file = ::File.open(path)
-              while (chunk = file.read(Excon::CHUNK_SIZE)) && yield(chunk); end
-              file.close
-              new(data)
-            else
-              body = ::File.read(path)
-              new(data.merge!(:body => body))
-            end
-          else
-            nil
-          end
-        end
-
-        def head(key)
-          requires :directory
-          path = file_path(key)
-          if ::File.exists?(path)
-            new({
-              :content_length => ::File.size(path),
-              :key            => key,
-              :last_modified  => ::File.mtime(path)
-            })
-          else
-            nil
-          end
-        end
-
-        def new(attributes = {})
-          requires :directory
-          super({ :directory => directory }.merge!(attributes))
-        end
-
-        private
-
-        def file_path(key)
-          connection.path_to(::File.join(directory.key, key))
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-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/files.rb

@@ -1,72 +0,0 @@
-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/directories.rb

@@ -1,43 +0,0 @@
-require 'fog/core/collection'
-require 'fog/storage/models/rackspace/directory'
-
-module Fog
-  module Storage
-    class Rackspace
-
-      class Directories < Fog::Collection
-
-        model Fog::Storage::Rackspace::Directory
-
-        def all
-          data = connection.get_containers.body
-          load(data)
-        end
-
-        # Supply the :cdn_cname option to use the Rackspace CDN CNAME functionality on the public_url.
-        #
-        # > fog.directories.get('video', :cdn_cname => 'http://cdn.lunenburg.org').files.first.public_url
-        # => 'http://cdn.lunenburg.org/hayley-dancing.mov'
-        def get(key, options = {})
-          data = connection.get_container(key, options)
-          directory = new(:key => key, :cdn_cname => options[:cdn_cname])
-          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::Rackspace::NotFound
-          nil
-        end
-
-      end
-
-    end
-  end
-end

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

@@ -1,76 +0,0 @@
-require 'fog/core/model'
-require 'fog/storage/models/rackspace/files'
-
-module Fog
-  module Storage
-    class Rackspace
-
-      class Directory < Fog::Model
-
-        identity  :key, :aliases => 'name'
-
-        attribute :bytes, :aliases => 'X-Container-Bytes-Used'
-        attribute :count, :aliases => 'X-Container-Object-Count'
-        attribute :cdn_cname
-
-        def destroy
-          requires :key
-          connection.delete_container(key)
-          connection.cdn.post_container(key, 'X-CDN-Enabled' => 'False')
-          true
-        rescue Excon::Errors::NotFound
-          false
-        end
-
-        def files
-          @files ||= begin
-            Fog::Storage::Rackspace::Files.new(
-              :directory    => self,
-              :connection   => connection
-            )
-          end
-        end
-
-        def public=(new_public)
-          @public = new_public
-        end
-
-        def public_url
-          requires :key
-          @public_url ||= begin
-            begin response = connection.cdn.head_container(key)
-              if response.headers['X-CDN-Enabled'] == 'True'
-                if connection.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
-          end
-        end
-
-        def save
-          requires :key
-          connection.put_container(key)
-
-          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']
-          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
-        
-      end
-
-    end
-  end
-end

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

@@ -1,94 +0,0 @@
-require 'fog/core/collection'
-require 'fog/storage/models/rackspace/file'
-
-module Fog
-  module Storage
-    class Rackspace
-
-      class Files < Fog::Collection
-
-        attribute :directory
-        attribute :limit
-        attribute :marker
-        attribute :path
-        attribute :prefix
-
-        model Fog::Storage::Rackspace::File
-
-        def all(options = {})
-          requires :directory
-          options = {
-            'limit'   => limit,
-            'marker'  => marker,
-            'path'    => path,
-            'prefix'  => prefix
-          }.merge!(options)
-          merge_attributes(options)
-          parent = directory.collection.get(
-            directory.key,
-            options
-          )
-          if parent
-            load(parent.files.map {|file| file.attributes})
-          else
-            nil
-          end
-        end
-
-        alias :each_file_this_page :each
-        def each
-          if !block_given?
-            self
-          else
-            subset = dup.all
-
-            subset.each_file_this_page {|f| yield f}
-            until subset.empty? || subset.length == (subset.limit || 10000)
-              subset = subset.all(:marker => subset.last.key)
-              subset.each_file_this_page {|f| yield f}
-            end
-
-            self
-          end
-        end
-
-        def get(key, &block)
-          requires :directory
-          data = connection.get_object(directory.key, key, &block)
-          file_data = data.headers.merge({
-            :body => data.body,
-            :key  => key
-          })
-          new(file_data)
-        rescue Fog::Storage::Rackspace::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/ninefold.rb

@@ -1,149 +0,0 @@
-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