brightbox-cli 0.13.1 → 0.14.0

data/lib/brightbox-cli/vendor/fog/lib/fog/storage/models/google/files.rb

@@ -1,103 +0,0 @@
-require 'fog/core/collection'
-require 'fog/storage/models/google/file'
-
-module Fog
-  module Storage
-    class Google
-
-      class Files < Fog::Collection
-        extend Fog::Deprecation
-        deprecate :get_url, :get_https_url
-
-        attribute :common_prefixes, :aliases => 'CommonPrefixes'
-        attribute :delimiter,       :aliases => 'Delimiter'
-        attribute :directory
-        attribute :is_truncated,    :aliases => 'IsTruncated'
-        attribute :marker,          :aliases => 'Marker'
-        attribute :max_keys,        :aliases => ['MaxKeys', 'max-keys']
-        attribute :prefix,          :aliases => 'Prefix'
-
-        model Fog::Storage::Google::File
-
-        def all(options = {})
-          requires :directory
-          options = {
-            'delimiter'   => delimiter,
-            'marker'      => marker,
-            'max-keys'    => max_keys,
-            'prefix'      => prefix
-          }.merge!(options)
-          options = options.reject {|key,value| value.nil? || value.to_s.empty?}
-          merge_attributes(options)
-          parent = directory.collection.get(
-            directory.key,
-            options
-          )
-          if parent
-            merge_attributes(parent.files.attributes)
-            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}
-            while subset.is_truncated
-              subset = subset.all(:marker => subset.last.key)
-              subset.each_file_this_page {|f| yield f}
-            end
-
-            self
-          end
-        end
-
-        def get(key, options = {}, &block)
-          requires :directory
-          data = connection.get_object(directory.key, key, options, &block)
-          file_data = data.headers.merge({
-            :body => data.body,
-            :key  => key
-          })
-          new(file_data)
-        rescue Excon::Errors::NotFound
-          nil
-        end
-
-        def get_http_url(key, expires)
-          requires :directory
-          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 = {})
-          requires :directory
-          data = connection.head_object(directory.key, key, options)
-          file_data = data.headers.merge({
-            :key => key
-          })
-          new(file_data)
-        rescue Excon::Errors::NotFound
-          nil
-        end
-
-        def new(attributes = {})
-          requires :directory
-          super({ :directory => directory }.merge!(attributes))
-        end
-
-      end
-
-    end
-  end
-end

data/lib/brightbox-cli/vendor/fog/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/brightbox-cli/vendor/fog/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/brightbox-cli/vendor/fog/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/brightbox-cli/vendor/fog/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/brightbox-cli/vendor/fog/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/brightbox-cli/vendor/fog/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