fog 1.9.0 → 1.10.0

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

@@ -14,10 +14,39 @@ module Fog
           load(data)
         end
 
+        def head(key, options = {})
+          data = service.head_container(key)
+          directory = create_directory(key, data)
+          # set the cdn state for the directory
+          directory.cdn_enabled?
+
+          directory
+        rescue Fog::Storage::HP::NotFound
+          nil
+        end
+
         def get(key, options = {})
+          data = service.get_container(key, options)
+          directory = create_directory(key, data)
+          # set the files for the directory
+          directory.files.merge_attributes(options)
+          directory.files.instance_variable_set(:@loaded, true)
+          data.body.each do |file|
+            directory.files << directory.files.new(file)
+          end
+          # set the cdn state for the directory
+          directory.cdn_enabled?
+
+          directory
+        rescue Fog::Storage::HP::NotFound
+          nil
+        end
+
+        private
+
+        def create_directory(key, data)
           read_header = nil
           write_header = nil
-          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)
@@ -31,16 +60,12 @@ module Fog
           end
           # set the acl on the directory based on the headers
           if !(read_header.nil? && write_header.nil?)
-            directory.acl = service.header_to_acl(read_header, write_header)
-          end
-          directory.files.merge_attributes(options)
-          directory.files.instance_variable_set(:@loaded, true)
-          data.body.each do |file|
-            directory.files << directory.files.new(file)
+            read_acl, write_acl = service.header_to_perm_acl(read_header, write_header)
+            # do not want to expose the read_acl and write_acl as writable attributes
+            directory.instance_variable_set(:@read_acl, read_acl)
+            directory.instance_variable_set(:@write_acl, write_acl)
           end
           directory
-        rescue Fog::Storage::HP::NotFound
-          nil
         end
 
       end

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

@@ -12,15 +12,86 @@ module Fog
         attribute :bytes, :aliases => 'X-Container-Bytes-Used'
         attribute :count, :aliases => 'X-Container-Object-Count'
 
-        def acl=(new_acl)
-          if new_acl.nil?
-            new_acl = "private"
+        def initialize(attributes = {})
+            @read_acl  = []
+            @write_acl = []
+            super
+        end
+
+        def read_acl
+          @read_acl || []
+        end
+
+        def write_acl
+          @write_acl || []
+        end
+
+        def can_read?(user)
+          return false if @read_acl.nil?
+          list_users_with_read.include?(user)
+        end
+
+        def can_write?(user)
+          return false if @write_acl.nil?
+          list_users_with_write.include?(user)
+        end
+
+        def can_read_write?(user)
+          can_read?(user) && can_write?(user)
+        end
+
+        def list_users_with_read
+          users = []
+          users = @read_acl.map  {|acl| acl.split(':')[1]} unless @read_acl.nil?
+          return users
+        end
+
+        def list_users_with_write
+          users = []
+          users = @write_acl.map  {|acl| acl.split(':')[1]} unless @write_acl.nil?
+          return users
+        end
+
+        def grant(perm, users=nil)
+          # support passing in a list of users in a comma-separated list or as an Array
+          if users.is_a?(String)
+            user_list = users.split(',')
+          else
+            user_list = users
+          end
+          r_acl, w_acl = service.perm_to_acl(perm, user_list)
+          unless r_acl.nil? || r_acl.empty?
+            @read_acl = [] if @read_acl.nil?
+            @read_acl = @read_acl + r_acl
+            @read_acl.uniq!
+          end
+          unless w_acl.nil? || w_acl.empty?
+            @write_acl = [] if @write_acl.nil?
+            @write_acl = @write_acl + w_acl
+            @write_acl.uniq!
           end
-          valid_acls = ['private', 'public-read', 'public-write', 'public-read-write']
-          unless valid_acls.include?(new_acl)
-            raise ArgumentError.new("acl must be one of [#{valid_acls.join(', ')}]")
+          true
+        end
+
+        def revoke(perm, users=nil)
+          # support passing in a list of users in a comma-separated list or as an Array
+          if users.is_a?(String)
+            user_list = users.split(',')
+          else
+            user_list = users
+          end
+          r_acl, w_acl = service.perm_to_acl(perm, user_list)
+          unless r_acl.nil? || r_acl.empty?
+            @read_acl = [] if @read_acl.nil?
+            @read_acl = @read_acl - r_acl
+            @read_acl.uniq!
           end
-          @acl = new_acl
+          unless w_acl.nil? || w_acl.empty?
+            @write_acl = [] if @write_acl.nil?
+            @write_acl = @write_acl - w_acl
+            @write_acl.uniq!
+          end
+          true
         end
 
         def destroy
@@ -50,18 +121,19 @@ module Fog
 
         def public=(new_public)
           if new_public
-            @acl = 'public-read'
+            self.grant("pr")
           else
-            @acl = 'private'
+            self.revoke("pr")
           end
           @public = new_public
         end
 
         def public?
-          if @acl.nil?
-            false
+          @read_acl = [] if @read_acl.nil?
+          if @read_acl.include?(".r:*")
+            true
           else
-            @acl == 'public-read'
+            false
           end
         end
 
@@ -70,7 +142,7 @@ module Fog
           @public_url ||= begin
             begin response = service.head_container(key)
               # escape the key to cover for special char. in container names
-              url = "#{service.url}/#{Fog::HP.escape(key)}"
+              url = service.public_url(key)
             rescue Fog::Storage::HP::NotFound => err
               nil
             end
@@ -96,7 +168,8 @@ module Fog
               else
                 @cdn_enable = false
               end
-            rescue Fog::CDN::HP::NotFound => err
+            # If CDN endpoint is unreachable, a SocketError is raised
+            rescue Fog::CDN::HP::NotFound, Excon::Errors::SocketError
               @cdn_enable = false
             end
           else
@@ -110,24 +183,32 @@ module Fog
             # return the CDN public url from the appropriate uri from the header
             begin response = service.cdn.head_container(key)
               if response.headers['X-Cdn-Enabled'] == 'True'
-                if service.hp_cdn_ssl == true
-                  response.headers.fetch('X-Cdn-Ssl-Uri', nil)
-                else
-                  response.headers.fetch('X-Cdn-Uri', nil)
-                end
+                response.headers.fetch('X-Cdn-Uri', nil)
               end
-            rescue Fog::CDN::HP::NotFound => err
+            rescue Fog::CDN::HP::NotFound
               nil
             end
           end
         end
 
-        def save
+        def cdn_public_ssl_url
           requires :key
-          options = {}
-          if @acl
-            options.merge!(service.acl_to_header(@acl))
+          @cdn_public_ssl_url ||= begin
+            # return the CDN public ssl url from the appropriate uri from the header
+            begin response = service.cdn.head_container(key)
+              if response.headers['X-Cdn-Enabled'] == 'True'
+                response.headers.fetch('X-Cdn-Ssl-Uri', nil)
+              end
+            rescue Fog::CDN::HP::NotFound
+              nil
+            end
           end
+        end
+
+        def save(options = {})
+          requires :key
+          # write out the acls into the headers before save
+          options.merge!(service.perm_acl_to_header(@read_acl, @write_acl))
           service.put_container(key, options)
           # Added an extra check to see if CDN is enabled for the container
           if (!service.cdn.nil? && service.cdn.enabled?)
@@ -137,16 +218,20 @@ module Fog
               begin response = service.cdn.head_container(key)
                 ### Deleting a container from CDN is much more expensive than flipping the bit to disable it
                 service.cdn.post_container(key, {'X-CDN-Enabled' => 'True'})
-              rescue Fog::CDN::HP::NotFound => err
+              rescue Fog::CDN::HP::NotFound
                 service.cdn.put_container(key)
+              rescue Excon::Errors::SocketError
+                # means that the CDN endpoint is unreachable
               end
             else
               # check to make sure that the container exists. If yes, cdn disable it.
               begin response = service.cdn.head_container(key)
                 ### Deleting a container from CDN is much more expensive than flipping the bit to disable it
                 service.cdn.post_container(key, {'X-CDN-Enabled' => 'False'})
-              rescue Fog::CDN::HP::NotFound => err
+              rescue Fog::CDN::HP::NotFound
                 # just continue, as container is not cdn-enabled.
+              rescue Excon::Errors::SocketError
+                # means that the CDN endpoint is unreachable
               end
             end
           end

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

@@ -65,6 +65,16 @@ module Fog
           self.collection.get_cdn_url(self.key)
         end
 
+        def cdn_public_ssl_url
+          requires :key
+          self.collection.get_cdn_ssl_url(self.key)
+        end
+
+        def temp_signed_url(expires_secs, method)
+          requires :directory, :key
+          service.get_object_temp_url(directory.key, key, expires_secs, method)
+        end
+
         def save(options = {})
           requires :body, :directory, :key
           options['Content-Type'] = content_type if content_type

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

@@ -80,6 +80,14 @@ module Fog
           end
         end
 
+        def get_cdn_ssl_url(key)
+          requires :directory
+          if self.directory.cdn_public_ssl_url
+            # escape the key to cover for special char. in object names
+            "#{self.directory.cdn_public_ssl_url}/#{Fog::HP.escape(key)}"
+          end
+        end
+
         def head(key, options = {})
           requires :directory
           data = service.head_object(directory.key, key)

data/lib/fog/hp/models/storage/shared_directories.rb

@@ -0,0 +1,55 @@
+require 'fog/core/collection'
+require 'fog/hp/models/storage/shared_directory'
+
+module Fog
+  module Storage
+    class HP
+
+      class SharedDirectories < Fog::Collection
+
+        model Fog::Storage::HP::SharedDirectory
+
+        def all
+          nil
+        end
+
+        def head(url)
+          data = service.head_shared_container(url)
+          shared_directory = new(:url => url)
+          for key, value in data.headers
+            if ['X-Container-Bytes-Used', 'X-Container-Object-Count'].include?(key)
+              shared_directory.merge_attributes(key => value)
+            end
+          end
+
+          shared_directory
+        # throws exception Fog::HP::Errors::Forbidden if insufficient access
+        rescue Fog::Storage::HP::NotFound
+          nil
+        end
+
+        def get(url)
+          data = service.get_shared_container(url)
+          shared_directory = new(:url => url)
+          for key, value in data.headers
+            if ['X-Container-Bytes-Used', 'X-Container-Object-Count'].include?(key)
+              shared_directory.merge_attributes(key => value)
+            end
+          end
+          # set the files for the directory
+          shared_directory.files.instance_variable_set(:@loaded, true)
+          data.body.each do |file|
+            shared_directory.files << shared_directory.files.new(file)
+          end
+
+          shared_directory
+        # throws exception Fog::HP::Errors::Forbidden if insufficient access
+        rescue Fog::Storage::HP::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/hp/models/storage/shared_directory.rb

@@ -0,0 +1,39 @@
+require 'fog/core/model'
+require 'fog/hp/models/storage/shared_files'
+
+module Fog
+  module Storage
+    class HP
+
+      class SharedDirectory < Fog::Model
+
+        identity  :url
+
+        attribute :bytes, :aliases => 'X-Container-Bytes-Used'
+        attribute :count, :aliases => 'X-Container-Object-Count'
+
+        def files
+          @files ||= begin
+            Fog::Storage::HP::SharedFiles.new(
+              :shared_directory    => self,
+              :service          => service
+            )
+          end
+        end
+
+        def destroy
+          requires :url
+          # delete is not allowed
+          false
+        end
+
+        def save(options = {})
+          requires :url
+          # put is not allowed
+          false
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/hp/models/storage/shared_file.rb

@@ -0,0 +1,67 @@
+require 'fog/core/model'
+
+module Fog
+  module Storage
+    class HP
+
+      class SharedFile < Fog::Model
+
+        identity  :key,             :aliases => 'name'
+        attribute :url
+
+        attribute :content_length,  :aliases => ['bytes', 'Content-Length'], :type => :integer
+        attribute :content_type,    :aliases => ['content_type', 'Content-Type']
+        attribute :etag,            :aliases => ['hash', 'Etag']
+        attribute :last_modified,   :aliases => ['last_modified', 'Last-Modified'], :type => :time
+
+        def url
+          "#{self.collection.shared_directory.url}/#{key}"
+        end
+
+        def body
+          attributes[:body] ||= if last_modified
+            collection.get(identity).body
+          else
+            ''
+          end
+        end
+
+        def body=(new_body)
+          attributes[:body] = new_body
+        end
+
+        def destroy
+          requires :shared_directory, :key
+          service.delete_shared_object(self.url)
+          true
+        # throws exception Fog::HP::Errors::Forbidden if insufficient access
+        rescue Fog::Storage::HP::NotFound
+          false
+        end
+
+        def shared_directory
+          @shared_directory
+        end
+
+        def save(options = {})
+          requires :shared_directory, :key
+          options['Content-Type'] = content_type if content_type
+          data = service.put_shared_object(shared_directory.url, key, body, options)
+          merge_attributes(data.headers)
+          self.content_length = Fog::Storage.get_body_size(body)
+          true
+        # throws exception Fog::HP::Errors::Forbidden if insufficient access
+        rescue Fog::Storage::HP::NotFound
+          false
+        end
+
+        private
+
+        def shared_directory=(new_shared_directory)
+          @shared_directory = new_shared_directory
+        end
+      end
+
+    end
+  end
+end