fog 1.5.0 → 1.6.0

data/docs/storage/index.markdown

@@ -5,9 +5,9 @@ title:  Storage
 
 Having Ruby experience makes you hirable; but how can you stand out? You need to demonstrate your abilities. What better way than using Ruby and "the cloud" to store and serve your resume!
 
-In this blog post you will learn to use <a href="http://github.com/fog/fog">fog</a> - the cloud computing library - to upload your resume to Amazon's <a href="http://aws.amazon.com/s3/">Simple Storage Service</a> (S3), Rackspace's <a href="http://www.rackspacecloud.com/cloud_hosting_products/files">CloudFiles</a> or Google's <a href="http://code.google.com/apis/storage/">Storage for Developers</a>.
+In this blog post you will learn to use <a href="http://github.com/fog/fog">fog</a> - the cloud computing library - to upload your resume to Amazon's <a href="http://aws.amazon.com/s3/">Simple Storage Service</a> (S3), Rackspace's <a href="http://www.rackspacecloud.com/cloud_hosting_products/files">CloudFiles</a> or Google's <a href="http://code.google.com/apis/storage/">Cloud Storage</a>.
 
-Here's my out of date resume stored on <a href="http://geemus.s3.amazonaws.com/resume.html">S3</a>, <a href="http://c0023559.cdn2.cloudfiles.rackspacecloud.com/resume.html">CloudFiles</a> and <a href="https://geemus.commondatastorage.googleapis.com/resume.html">Google Storage</a>; programmatically stored in the cloud using this tutorial. NOTE: my boss would like me to add that I'm not currently looking for a new gig ;)
+Here's my out of date resume stored on <a href="http://geemus.s3.amazonaws.com/resume.html">S3</a>, <a href="http://c0023559.cdn2.cloudfiles.rackspacecloud.com/resume.html">CloudFiles</a> and <a href="https://geemus.storage.googleapis.com/resume.html">Google Storage</a>; programmatically stored in the cloud using this tutorial. NOTE: my boss would like me to add that I'm not currently looking for a new gig ;)
 
 Check out those cloud-specific URLs! You could put all three in your job application, add the Ruby source for how you did it, and have your choice of Ruby jobs for being so awesome!
 
@@ -125,9 +125,9 @@ Pop that link in an email and you should be ready to cruise job ads and send you
 
 More clouds? How much extra stuff will you have to do for these services!?! Hardly anything needs to change, you just have to pass slightly different credentials in, but I'm getting ahead of myself.
 
-## Google Storage for Developers
+## Google Cloud Storage
 
-Sign up <a href="http://gs-signup-redirect.appspot.com/">here</a> and get your credentials <a href="https://sandbox.google.com/storage/m/">here</a>.
+Sign up <a href="http://gs-signup-redirect.appspot.com/">here</a> and get your credentials <a href="https://storage.cloud.google.com/m">here</a> under the section "Interoperable Access".
 
     connection = Fog::Storage.new({
       :provider                         => 'Google',

data/fog.gemspec

@@ -6,8 +6,8 @@ Gem::Specification.new do |s|
   ## If your rubyforge_project name is different, then edit it and comment out
   ## the sub! line in the Rakefile
   s.name              = 'fog'
-  s.version           = '1.5.0'
-  s.date              = '2012-07-28'
+  s.version           = '1.6.0'
+  s.date              = '2012-09-15'
   s.rubyforge_project = 'fog'
 
 

data/lib/fog.rb

@@ -3,7 +3,7 @@ require File.join(File.dirname(__FILE__), 'fog', 'core')
 module Fog
 
   unless const_defined?(:VERSION)
-    VERSION = '1.5.0'
+    VERSION = '1.6.0'
   end
 
 end

data/lib/fog/atmos.rb

@@ -0,0 +1,11 @@
+require 'fog/core'
+
+module Fog
+  module Atmos
+
+    extend Fog::Provider
+
+    service(:storage, 'atmos/storage', 'Storage')
+
+  end
+end

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

@@ -0,0 +1,48 @@
+require 'fog/core/collection'
+require 'fog/atmos/models/storage/directory'
+
+module Fog
+  module Storage
+    class Atmos
+
+      class Directories < Fog::Collection
+
+        attribute :directory
+
+        model Fog::Storage::Atmos::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::Atmos::NotFound
+          nil
+        end
+
+        def new(attributes ={})
+          attributes = {:directory => directory}.merge(attributes) if directory
+          super(attributes)
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+require 'fog/core/model'
+
+module Fog
+  module Storage
+    class Atmos
+
+      class Directory < Fog::Model
+
+        identity :key, :aliases => :Filename
+        attribute :objectid, :aliases => :ObjectID
+
+        def files
+          @files ||= begin
+                       Fog::Storage::Atmos::Files.new(
+                                                          :directory    => self,
+                                                          :connection   => connection
+                                                          )
+          end
+        end
+
+        def directories
+          @directories ||= begin
+                       Fog::Storage::Atmos::Directories.new(
+                                                               :directory    => self,
+                                                               :connection   => connection
+                                                               )
+          end
+        end
+
+        def save
+          self.key = attributes[:directory].key + key if attributes[:directory]
+          self.key = key + '/' unless key =~ /\/$/
+          res = connection.post_namespace key
+          reload
+        end
+
+        def destroy(opts={})
+          if opts[:recursive]
+            files.each {|f| f.destroy }
+            directories.each do |d|
+              d.files.each {|f| f.destroy }
+              d.destroy(opts)
+            end
+          end
+          connection.delete_namespace key
+        end
+
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+require 'fog/core/model'
+
+module Fog
+  module Storage
+    class Atmos
+
+      class File < Fog::Model
+
+        identity  :key,             :aliases => :Filename
+
+        attribute :content_length,  :aliases => ['bytes', 'Content-Length'], :type => :integer
+        attribute :content_type,    :aliases => ['content_type', 'Content-Type']
+        attribute :objectid,        :aliases => :ObjectID
+
+        def body
+          attributes[:body] ||= if objectid
+            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={})
+          target_directory = connection.directories.new(:key => target_directory_key)
+          target_directory.files.create(
+            :key => target_file_key,
+            :body => body
+          )
+        end
+
+        def destroy
+          requires :directory, :key
+          connection.delete_namespace([directory.key, key].join('/'))
+          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)
+          # NOOP - we don't need to flag files as public, getting the public URL for a file handles it.
+        end
+
+        # By default, expire in 5 years
+        def public_url(expires = (Time.now + 5 * 365 * 24 * 60 * 60))
+          requires :objectid
+          # TODO - more efficient method to get this?
+          storage = Fog::Storage.new(:provider => 'Atmos')
+          uri = URI::HTTP.build(:scheme => @prefix, :host => @storage_host, :port => @storage_port.to_i, :path => "/rest/objects/#{objectid}" )
+          Fog::Storage.new(:provider => 'Atmos').uid
+
+          sb = "GET\n"
+          sb += uri.path.downcase + "\n"
+          sb += storage.uid + "\n"
+          sb += String(expires.to_i())
+
+          signature = storage.sign( sb )
+          uri.query = "uid=#{CGI::escape(storage.uid)}&expires=#{expires.to_i()}&signature=#{CGI::escape(signature)}"
+          uri.to_s
+        end
+
+        def save(options = {})
+          requires :body, :directory, :key
+          directory.kind_of?(Directory) ? ns = directory.key : ns = directory
+          ns += key
+          options[:headers] ||= {}
+          options[:headers]['Content-Type'] = content_type if content_type
+          options[:body] = body
+          begin
+            data = connection.post_namespace(ns, options)
+            self.objectid = data.headers['location'].split('/')[-1]
+          rescue => error
+            if error.message =~ /The resource you are trying to create already exists./
+              data = connection.put_namespace(ns, options)
+            else
+              raise error
+            end
+          end
+          # merge_attributes(data.headers)
+          true
+        end
+
+        private
+
+        def directory=(new_directory)
+          @directory = new_directory
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+require 'fog/core/collection'
+require 'fog/atmos/models/storage/file'
+
+module Fog
+  module Storage
+    class Atmos
+
+      class Files < Fog::Collection
+
+        attribute :directory
+        attribute :limit
+        attribute :marker
+        attribute :path
+        attribute :prefix
+
+        model Fog::Storage::Atmos::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::Atmos::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_namespace(directory.key + key, :parse => false)
+          file_data = data.headers.merge({
+            :body => data.body,
+            :key => key
+          })
+          new(file_data)
+        rescue Fog::Storage::Atmos::NotFound
+          nil
+        end
+
+        def new(attributes = {})
+          requires :directory
+          super({ :directory => directory }.merge!(attributes))
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/atmos/requests/storage/delete_namespace.rb

@@ -0,0 +1,19 @@
+module Fog
+  module Storage
+    class Atmos
+      class Real
+
+        def delete_namespace(namespace = '', options = {})
+          options = options.reject {|key, value| value.nil?}
+          request({
+                    :expects  => 204,
+                    :method   => 'DELETE',
+                    :path     => "namespace/" + namespace,
+                    :query    => options
+                  }.merge(options))
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/atmos/requests/storage/get_namespace.rb

@@ -0,0 +1,20 @@
+module Fog
+  module Storage
+    class Atmos
+      class Real
+
+        def get_namespace(namespace = '', options = {})
+          options = options.reject {|key, value| value.nil?}
+          request({
+                    :expects  => 200,
+                    :method   => 'GET',
+                    :path     => "namespace/" + namespace,
+                    :query    => {},
+                    :parse => true
+                  }.merge(options))
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/atmos/requests/storage/head_namespace.rb

@@ -0,0 +1,20 @@
+module Fog
+  module Storage
+    class Atmos
+      class Real
+
+        def head_namespace(namespace = '', options = {})
+          options = options.reject {|key, value| value.nil?}
+          request({
+                    :expects  => 200,
+                    :method   => 'HEAD',
+                    :path     => "namespace/" + namespace,
+                    :query    => {},
+                    :parse => true
+                  }.merge(options))
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/atmos/requests/storage/post_namespace.rb

@@ -0,0 +1,20 @@
+module Fog
+  module Storage
+    class Atmos
+      class Real
+
+        def post_namespace(namespace = '', options = {})
+          options = options.reject {|key, value| value.nil?}
+          request({
+                    :expects  => 201,
+                    :method   => 'POST',
+                    :path     => "namespace/" + namespace,
+                    :query    => {},
+                    :parse => true
+                  }.merge(options))
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/atmos/requests/storage/put_namespace.rb

@@ -0,0 +1,20 @@
+module Fog
+  module Storage
+    class Atmos
+      class Real
+
+        def put_namespace(namespace = '', options = {})
+          options = options.reject {|key, value| value.nil?}
+          request({
+                    :expects  => 200,
+                    :method   => 'PUT',
+                    :path     => "namespace/" + namespace,
+                    :query    => {},
+                    :parse => true
+                  }.merge(options))
+        end
+
+      end
+    end
+  end
+end