fog-softlayer 0.0.5 → 0.0.7

data/fog-softlayer.gemspec

@@ -34,5 +34,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency('shindo', '~> 0.3.4')
   spec.add_development_dependency('fission')
   spec.add_development_dependency('pry')
+  spec.add_development_dependency('pry-debugger')
   spec.add_development_dependency('google-api-client', '~> 0.6', '>= 0.6.2')
 end

data/gemfiles/Gemfile-edge

@@ -0,0 +1,14 @@
+source "https://rubygems.org"
+
+# Shared components
+gem "fog-core", :github => "fog/fog-core"
+gem "fog-json", :github => "fog/fog-json"
+
+group :development, :test do
+  # This is here because gemspec doesn't support require: false
+  gem "coveralls", :require => false
+  gem "netrc", :require => false
+  gem "octokit", :require => false
+end
+
+gemspec :path => "../"

data/gemfiles/Gemfile-ruby-1.8.7

@@ -0,0 +1,14 @@
+source "https://rubygems.org"
+
+gem 'nokogiri', '~>1.5.11'
+gem 'mime-types', '~>1.16'
+
+group :development, :test do
+  # This is here because gemspec doesn't support require: false
+  gem 'coveralls', :require => false
+  gem "netrc", :require => false
+  gem "octokit", '~> 2.7.2', :require => false
+  gem 'rake', '~> 10.1.0'
+end
+
+gemspec :path => "../"

data/lib/fog/softlayer.rb

@@ -7,3 +7,4 @@
 require 'fog'
 require 'fog/softlayer'
 require 'fog/softlayer/compute'
+require 'fog/softlayer/storage'

data/lib/fog/softlayer/compute.rb

@@ -101,7 +101,7 @@ module Fog
           # default HTTP method to get if not passed
           http_method = options[:http_method] || :get
           # set the target base url
-          @request_url = options[:softlayer_api_url] || Fog::Softlayer::API_URL
+          @request_url = options[:softlayer_api_url] || Fog::Softlayer::SL_API_URL
           # tack on the username and password
           credentialize_url(@credentials[:username], @credentials[:api_key])
           # set the SoftLayer Service name

data/lib/fog/softlayer/compute/shared.rb

@@ -25,7 +25,7 @@ module Fog
         #   Password for user based authentication
         #
         def initialize(options)
-          @api_url             = options[:softlayer_api_url]   || API_URL
+          @api_url             = options[:softlayer_api_url] || SL_API_URL
           @credentials   = { :username => options[:softlayer_username], :api_key => options[:softlayer_api_key] }
           @default_domain = options[:softlayer_default_domain]
         end

data/lib/fog/softlayer/core.rb

@@ -6,15 +6,18 @@
 #
 require 'fog/core'
 require 'fog/json'
+require 'fog/softlayer/version'
 require 'time'
 
 module Fog
   module Softlayer
     extend Fog::Provider
 
-    API_URL = 'api.softlayer.com/rest/v3' unless defined? API_URL
+    SL_API_URL = 'api.softlayer.com/rest/v3' unless defined? SL_API_URL
+    SL_STORAGE_AUTH_URL = 'objectstorage.softlayer.net/auth/v1.0' unless defined? SL_STORAGE_AUTH_URL
 
     service(:compute, 'Compute')
+    service(:storage, 'Storage')
 
     def self.mock_account_id
       Fog.mocking? and @sl_account_id ||= Fog::Mock.random_numbers(7)
@@ -32,5 +35,18 @@ module Fog
       required.all? {|k| k = k.to_sym; passed.key?(k) and !passed[k].nil?}
     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
+
+class Hash
+  def deep_merge(second)
+    merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
+    self.merge(second, &merger)
   end
 end

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

@@ -0,0 +1,40 @@
+require 'fog/core/collection'
+require 'fog/softlayer/models/storage/directory'
+
+module Fog
+  module Storage
+    class Softlayer
+
+      class Directories < Fog::Collection
+
+        model Fog::Storage::Softlayer::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::Softlayer::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+require 'fog/core/model'
+require 'fog/softlayer/models/storage/files'
+
+module Fog
+  module Storage
+    class Softlayer
+
+      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::Softlayer::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/softlayer/models/storage/file.rb

@@ -0,0 +1,166 @@
+require 'fog/core/model'
+
+module Fog
+  module Storage
+    class Softlayer
+
+      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 :content_disposition, :aliases => ['content_disposition', 'Content-Disposition']
+        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
+
+        # Get a url for file.
+        #
+        #     required attributes: key
+        #
+        # @param expires [String] number of seconds (since 1970-01-01 00:00) before url expires
+        # @param options [Hash]
+        # @return [String] url
+        #
+        def url(expires, options = {})
+          requires :directory, :key
+          self.service.create_temp_url(directory.key, key, expires, "GET", options)
+        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['Content-Disposition'] = content_disposition if content_disposition
+          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

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

@@ -0,0 +1,99 @@
+require 'fog/core/collection'
+require 'fog/softlayer/models/storage/file'
+
+module Fog
+  module Storage
+    class Softlayer
+
+      class Files < Fog::Collection
+
+        attribute :directory
+        attribute :limit
+        attribute :marker
+        attribute :path
+        attribute :prefix
+
+        model Fog::Storage::Softlayer::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}
+            while 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 = service.get_object(directory.key, key, &block)
+          file_data = data.headers.merge({
+            :body => data.body,
+            :key  => key
+          })
+          new(file_data)
+        rescue Fog::Storage::Softlayer::NotFound
+          nil
+        end
+
+        def get_url(key)
+          requires :directory
+          if self.directory.public_url
+            "#{self.directory.public_url}/#{Fog::Softlayer.escape(key, '/')}"
+          end
+        end
+
+        def get_https_url(key, expires, options = {})
+          requires :directory
+          service.get_object_https_url(directory.key, key, expires, options)
+        end
+
+        def head(key, options = {})
+          requires :directory
+          data = service.head_object(directory.key, key)
+          file_data = data.headers.merge({
+            :key => key
+          })
+          new(file_data)
+        rescue Fog::Storage::Softlayer::NotFound
+          nil
+        end
+
+        def new(attributes = {})
+          requires :directory
+          super({ :directory => directory }.merge!(attributes))
+        end
+
+      end
+
+    end
+  end
+end