fog 1.3.1 → 1.4.0

data/lib/fog/{slicehost → hp}/models/compute/servers.rb

@@ -1,16 +1,16 @@
 require 'fog/core/collection'
-require 'fog/slicehost/models/compute/server'
+require 'fog/hp/models/compute/server'
 
 module Fog
   module Compute
-    class Slicehost
+    class HP
 
       class Servers < Fog::Collection
 
-        model Fog::Compute::Slicehost::Server
+        model Fog::Compute::HP::Server
 
         def all
-          data = connection.get_slices.body['slices']
+          data = connection.list_servers_detail.body['servers']
           load(data)
         end
 
@@ -22,12 +22,10 @@ module Fog
         end
 
         def get(server_id)
-          if server_id && server = connection.get_slice(server_id).body
+          if server = connection.get_server_details(server_id).body['server']
             new(server)
-          elsif !server_id
-            nil
           end
-        rescue Excon::Errors::Forbidden
+        rescue Fog::Compute::HP::NotFound
           nil
         end
 

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

@@ -0,0 +1,50 @@
+require 'fog/core/collection'
+require 'fog/hp/models/storage/directory'
+
+module Fog
+  module Storage
+    class HP
+
+      class Directories < Fog::Collection
+
+        model Fog::Storage::HP::Directory
+
+        def all
+          data = connection.get_containers.body
+          load(data)
+        end
+
+        def get(key, options = {})
+          read_header = nil
+          write_header = nil
+          data = connection.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
+            if key == 'X-Container-Read'
+              read_header = value
+            elsif key == 'X-Container-Write'
+              write_header = value
+            end
+          end
+          # set the acl on the directory based on the headers
+          if !(read_header.nil? && write_header.nil?)
+            directory.acl = connection.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)
+          end
+          directory
+        rescue Fog::Storage::HP::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,160 @@
+require 'fog/core/model'
+require 'fog/hp/models/storage/files'
+
+module Fog
+  module Storage
+    class HP
+
+      class Directory < Fog::Model
+
+        identity  :key, :aliases => 'name'
+
+        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"
+          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(', ')}]")
+          end
+          @acl = new_acl
+        end
+
+        def destroy
+          requires :key
+          connection.delete_container(key)
+          # If CDN service is available, try to delete the container if it was CDN-enabled
+          if cdn_enabled?
+            begin
+              connection.cdn.delete_container(key)
+            rescue Fog::CDN::HP::NotFound
+              # ignore if cdn container not found
+            end
+          end
+          true
+        rescue Excon::Errors::NotFound, Fog::Storage::HP::NotFound
+          false
+        end
+
+        def files
+          @files ||= begin
+            Fog::Storage::HP::Files.new(
+              :directory    => self,
+              :connection   => connection
+            )
+          end
+        end
+
+        def public=(new_public)
+          if new_public
+            @acl = 'public-read'
+          else
+            @acl = 'private'
+          end
+          @public = new_public
+        end
+
+        def public?
+          if @acl.nil?
+            false
+          else
+            @acl == 'public-read'
+          end
+        end
+
+        def public_url
+          requires :key
+          @public_url ||= begin
+            begin response = connection.head_container(key)
+              # escape the key to cover for special char. in container names
+              url = "#{connection.url}/#{Fog::HP.escape(key)}"
+            rescue Fog::Storage::HP::NotFound => err
+              nil
+            end
+          end
+        end
+
+        def cdn_enable=(new_cdn_enable)
+          @cdn_enable ||= false
+          if (!connection.cdn.nil? && connection.cdn.enabled?)
+            @cdn_enable = new_cdn_enable
+          else
+            # since cdn service is not activated, container cannot be cdn-enabled
+            @cdn_enable = false
+          end
+        end
+
+        def cdn_enabled?
+          if (!connection.cdn.nil? && connection.cdn.enabled?)
+            begin response = connection.cdn.head_container(key)
+              cdn_header = response.headers.fetch('X-Cdn-Enabled', nil)
+              if (!cdn_header.nil? && cdn_header == 'True')
+                @cdn_enable = true
+              else
+                @cdn_enable = false
+              end
+            rescue Fog::CDN::HP::NotFound => err
+              @cdn_enable = false
+            end
+          else
+            @cdn_enable = false
+          end
+        end
+
+        def cdn_public_url
+          requires :key
+          @cdn_public_url ||= begin
+            # return the CDN public url from the appropriate uri from the header
+            begin response = connection.cdn.head_container(key)
+              if response.headers['X-Cdn-Enabled'] == 'True'
+                if connection.hp_cdn_ssl == true
+                  response.headers.fetch('X-Cdn-Ssl-Uri', nil)
+                else
+                  response.headers.fetch('X-Cdn-Uri', nil)
+                end
+              end
+            rescue Fog::CDN::HP::NotFound => err
+              nil
+            end
+          end
+        end
+
+        def save
+          requires :key
+          options = {}
+          if @acl
+            options.merge!(connection.acl_to_header(@acl))
+          end
+          connection.put_container(key, options)
+          # Added an extra check to see if CDN is enabled for the container
+          if (!connection.cdn.nil? && connection.cdn.enabled?)
+            # If CDN available, set the container to be CDN-enabled or not based on if it is marked as cdn_enable.
+            if @cdn_enable
+              # check to make sure that the container exists. If yes, cdn enable it.
+              begin response = connection.cdn.head_container(key)
+                ### Deleting a container from CDN is much more expensive than flipping the bit to disable it
+                connection.cdn.post_container(key, {'X-CDN-Enabled' => 'True'})
+              rescue Fog::CDN::HP::NotFound => err
+                connection.cdn.put_container(key)
+              end
+            else
+              # check to make sure that the container exists. If yes, cdn disable it.
+              begin response = connection.cdn.head_container(key)
+                ### Deleting a container from CDN is much more expensive than flipping the bit to disable it
+                connection.cdn.post_container(key, {'X-CDN-Enabled' => 'False'})
+              rescue Fog::CDN::HP::NotFound => err
+                # just continue, as container is not cdn-enabled.
+              end
+            end
+          end
+          true
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+require 'fog/core/model'
+
+module Fog
+  module Storage
+    class HP
+
+      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 :etag,            :aliases => ['hash', 'Etag']
+        attribute :last_modified,   :aliases => ['last_modified', 'Last-Modified'], :type => :time
+
+        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)
+          requires :directory, :key
+          target_directory = connection.directories.new(:key => target_directory_key)
+          connection.put_object(target_directory_key, target_file_key, nil, {'X-Copy-From' => "/#{directory.key}/#{key}" })
+          target_directory.files.get(target_file_key)
+        end
+
+        def destroy
+          requires :directory, :key
+          connection.delete_object(directory.key, key)
+          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)
+        #  new_public
+        #end
+
+        def public_url
+          requires :key
+          self.collection.get_url(self.key)
+        end
+
+        def cdn_public_url
+          requires :key
+          self.collection.get_cdn_url(self.key)
+        end
+
+        def save(options = {})
+          requires :body, :directory, :key
+          options['Content-Type'] = content_type if content_type
+          data = connection.put_object(directory.key, key, body, options)
+          merge_attributes(data.headers)
+          self.content_length = Fog::Storage.get_body_size(body)
+          true
+        end
+
+        private
+
+        def directory=(new_directory)
+          @directory = new_directory
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+require 'fog/core/collection'
+require 'fog/hp/models/storage/file'
+
+module Fog
+  module Storage
+    class HP
+
+      class Files < Fog::Collection
+
+        attribute :directory
+        attribute :limit
+        attribute :marker
+        attribute :path
+        attribute :prefix
+
+        model Fog::Storage::HP::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::HP::NotFound
+          nil
+        end
+
+        def get_url(key)
+          requires :directory
+          if self.directory.public_url
+            # escape the key to cover for special char. in object names
+            "#{self.directory.public_url}/#{Fog::HP.escape(key)}"
+          end
+        end
+
+        def get_cdn_url(key)
+          requires :directory
+          if self.directory.cdn_public_url
+            # escape the key to cover for special char. in object names
+            "#{self.directory.cdn_public_url}/#{Fog::HP.escape(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::HP::NotFound
+          nil
+        end
+
+        def new(attributes = {})
+          requires :directory
+          super({ :directory => directory }.merge!(attributes))
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/hp/requests/cdn/delete_container.rb

@@ -0,0 +1,38 @@
+module Fog
+  module CDN
+    class HP
+      class Real
+
+        # Delete an existing container
+        #
+        # ==== Parameters
+        # * name<~String> - Name of container to delete
+        #
+        def delete_container(name)
+          response = request(
+            :expects  => 204,
+            :method   => 'DELETE',
+            :path     => Fog::HP.escape(name)
+          )
+          response
+        end
+
+      end
+
+      class Mock # :nodoc:all
+        def delete_container(name)
+          response = Excon::Response.new
+          if self.data[:cdn_containers][name]
+            self.data[:cdn_containers].delete(name)
+            response.status = 204
+            response.body = ""
+            response
+          else
+            raise Fog::CDN::HP::NotFound
+          end
+        end
+      end
+
+    end
+  end
+end