ahoward-helene 0.0.3

data/lib/helene/s3.rb

@@ -0,0 +1,34 @@
+module Helene
+  module S3
+    class << S3
+      def thread
+        Thread.current
+      end
+
+      def establish_connection(aws_access_key_id=Helene.aws_access_key_id, aws_secret_access_key=Helene.aws_secret_access_key, options={})
+        options.to_options!
+        thread[:helene_s3_interface] = RightAws::S3Interface.new(aws_access_key_id, aws_secret_access_key, options)
+        raise Error, 'Connection to S3 is not established' unless thread[:helene_s3_interface]
+
+        thread[:helene_s3_generator] = RightAws::S3Generator.new(aws_access_key_id, aws_secret_access_key)
+        raise Error, 'Connection to S3 is not established' unless thread[:helene_s3_generator]
+      end
+
+      def interface
+        establish_connection unless thread[:helene_s3_interface]
+        thread[:helene_s3_interface]
+      end
+      alias_method 'connection', 'interface'
+
+      def s3g
+        establish_connection unless thread[:helene_s3_generator]
+        thread[:helene_s3_generator]
+      end
+
+      load 'helene/s3/bucket.rb'
+      load 'helene/s3/key.rb'
+      load 'helene/s3/owner.rb'
+      load 'helene/s3/grantee.rb'
+    end
+  end
+end

data/lib/helene/s3/bucket.rb

@@ -0,0 +1,379 @@
+module Helene
+  module S3
+    class Bucket
+      class << Bucket
+        def interface
+          S3.interface
+        end
+
+        def list(&block)
+          list = []
+          interface.list_all_my_buckets.map! do |entry|
+            owner = Owner.new(entry[:owner_id], entry[:owner_display_name])
+            bucket = allocate
+            name = entry[:name]
+            creation_date = entry[:creation_date]
+            options = {:interface => interface, :owner => owner, :creation_date => creation_date}
+            bucket.send(:initialize, name, options)
+            block ? block.all(bucket) : list.push(bucket)
+          end
+          block ? nil : list
+        end
+        alias_method 'buckets', 'list'
+
+        def create(name, options = {})
+          options.to_options!
+          headers = options.delete(:headers) || {}
+          interface.create_bucket(name, headers)
+          new(name)
+        end
+
+        def new(name, options = {})
+          result = S3.interface.list_bucket(name.to_s)
+          service = result.service
+          owner = Owner.new(service[:owner_id], service[:owner_display_name])
+          bucket = allocate
+          name = service[:name]
+          options[:interface] || S3.interface
+          options[:owner] ||= owner
+          options[:creation_date] ||= service[:creation_date]
+          bucket.send(:initialize, name, options)
+          owner, grantees = Grantee.owner_and_grantees(bucket)
+          bucket.owner = owner
+          bucket
+        end
+        alias_method 'for', 'new'
+
+        def url(*args)
+          options = args.extract_options!.to_options!
+          options.to_options!
+          expires = options[:expires] || 24.hours
+          headers = options.delete(:headers) || {}
+          case args.shift.to_s
+            when '', 'list'
+              interface.list_all_my_buckets_link(expires, headers)
+            when 'create'
+              bucket = args.shift.to_s
+              interface.create_bucket_link(bucket, expires, headers)
+            when 'delete'
+              bucket = args.shift.to_s
+              interface.delete_bucket_link(bucket, expires, headers)
+          end
+        end
+        alias_method 'url_for', 'url'
+
+        def delete(bucket, options ={})
+          options.to_options!
+          force = options.delete(:force)
+          name = bucket.is_a?(Bucket) ? bucket.name : bucket.to_s
+          force ? interface.force_delete_bucket(name) : interface.delete_bucket(name)
+        end
+      end
+
+      attr_accessor :name
+      attr_accessor :interface
+      attr_accessor :owner
+      attr_accessor :creation_date
+      attr :prefix
+
+      def initialize(name, *args)
+        options = args.extract_options!.to_options!
+        @name  = name.to_s
+        @interface = options[:interface] || S3.interface
+        @owner = options[:owner]
+        @creation_date = options[:creation_date]
+        @prefix = cleanpath(options[:prefix]) if options[:prefix]
+        if @creation_date && !@creation_date.is_a?(Time)
+          @creation_date = Time.parse(@creation_date)
+        end
+      end
+
+      def prefix= *prefixes
+        @prefix = cleanpath(*prefixes)
+      end
+
+      def to_s
+        @name.to_s
+      end
+
+      def == other
+        name == other.name and prefix == other.prefix
+      end
+
+      def cleanpath(*paths)
+        path = File.join(*paths.flatten.compact)
+        path = path.to_s.strip
+        path.sub! %r|^[./]+|, ''
+        path.sub! %r|/*$|, '/'
+        path.squeeze! '/'
+        path
+      end
+
+      def prefixed(path, &block)
+        path = path.to_s
+        absolute = path =~ %r|^/|
+        if absolute
+          path[1..-1]
+        else
+          return scoping(path, &block) if block
+          @prefix ? File.join(@prefix, path) : path
+        end
+      end
+
+      def scoping(suffix, &block)
+        old = @prefix
+        @prefix = cleanpath(@prefix, suffix)
+        block.call
+      ensure
+        @prefix = old
+      end
+      alias_method 'suffixing', 'scoping'
+
+      def / suffix
+        bucket = clone
+        bucket.prefix = cleanpath(@prefix, suffix)
+        bucket
+      end
+
+      def put(data, *args, &block)
+        options = args.extract_options!.to_options!
+
+        meta = options.delete(:meta) || {}
+        perms = options.delete(:perms)
+        headers = options.delete(:headers) || {}
+
+        io_for(data) do |io|
+          path = args.shift || path_for(io)
+          key = key_for(path, io, meta)
+          headers = headers_for(path, headers)
+          key.put(io, perms, headers)
+          key
+        end
+      end
+
+      def get(path, *args, &block)
+        options = args.extract_options!.to_options!
+        headers = options.delete(:headers) || {}
+        key = key_for(path)
+        key.get(headers)
+      end
+
+      def io_for(arg)
+        return(arg.respond_to?(:read) ? yield(arg) : open(arg.to_s){|io| yield(io)})
+      end
+
+      def path_for(arg)
+        path = nil
+        %w[ path pathname filename ].each do |msg|
+          if arg.respond_to?(msg)
+            path = File.basename(arg.send(msg).to_s)
+            break path
+          end
+        end
+        raise Errror, "no path from #{ arg.inspect }" if path.blank?
+        cleanpath(path)
+      end
+
+      def key_for(arg, io = nil, meta = {})
+        return arg if arg.is_a?(Key)
+        Key.create(self, prefixed(arg.to_s), io, meta)
+      end
+
+      def headers_for(path, headers = {})
+        headers = HashWithIndifferentAccess.new(headers)
+        content_type = (
+          headers.delete(:content_type) ||
+          headers.delete(:Content_Type) ||
+          headers.delete(:ContentType) ||
+          content_type_for(path)
+        )
+        headers.merge!('Content-Type' => content_type) if content_type
+        headers
+      end
+
+      def content_type_for(basename)
+        Util.content_type_for(basename)
+      end
+
+      def url(*args)
+        options = args.extract_options!.to_options!
+        options.to_options!
+        method = options.delete(:method) || args.shift.to_s
+        path = options.delete(:path) || args.shift
+        data = options.delete(:data) || args.shift
+        expires = options.delete(:expires) || 24.hours
+        query = options.delete(:query)
+        headers = options.delete(:headers) || {}
+
+        case method.to_s
+          when '', 'list'
+            (query ||= {})[:prefix] ||= prefix if prefix
+            interface.list_bucket_link(name, query, expires, headers)
+          when 'put'
+            interface.put_link(name, prefixed(path), data, expires, headers)
+          when 'get'
+            interface.get_link(name, prefixed(path), expires, headers)
+          when 'head'
+            interface.head_link(name, prefixed(path), expires, headers)
+          when 'delete'
+            interface.delete_link(name, prefixed(path), expires, headers)
+          when 'get_acl'
+            interface.get_acl_link(name, prefixed(path), headers)
+          when 'put_acl'
+            interface.put_acl_link(name, prefixed(path), headers)
+          when 'get_bucket_acl'
+            interface.get_bucket_acl_link(name, headers)
+          when 'put_bucket_acl'
+            interface.put_bucket_acl_link(name, headers)
+          else
+            raise ArgumentError, method.inspect
+        end
+      end
+      alias_method 'url_for', 'url'
+      
+      def clear(options = {})
+        options.to_options!
+        prefix = options[:prefix] || @prefix
+        if prefix
+          @interface.delete_folder(@name, prefix)
+        else
+          @interface.clear_bucket(name)
+        end
+      end
+
+      def keys(options={}, &block)
+        options.to_options!
+        options[:prefix] ||= prefix
+        options.delete(:service)
+        keys_and_service(options, &block)
+      end
+      alias_method 'list', 'keys'
+
+      def ls(options = {}, &block)
+        names = []
+        keys do |key|
+          block ? block.call(key.name) : names.push(key.name)
+        end
+        block ? nil : names
+      end
+
+    # TODO - refactor messiness with service
+    #
+      def keys_and_service(options={}, &block)
+        options.to_options!
+        options[:prefix] ||= prefix
+        head = options.delete(:head)
+        wants_service = options.delete(:service)
+        service = {}
+        hash = {}
+        keys = []
+        @interface.incrementally_list_bucket(@name, options.stringify_keys) do |hash|
+          hash[:contents].each do |entry|
+            owner = Owner.new(entry[:owner_id], entry[:owner_display_name])
+            key = Key.new(self, entry[:key], nil, {}, {}, entry[:last_modified], entry[:e_tag], entry[:size], entry[:storage_class], owner)
+            key.head if head
+            block ? block.call(key) : keys.push(key)
+          end
+        end
+        if wants_service
+          hash.each_key do |key|
+            service[key] = hash[key] unless (key == :contents || key == :common_prefixes)
+          end
+          [keys, service]
+        else
+          block ? nil : keys
+        end
+      end
+
+      def key(path, options={}, &block)
+        options.to_options!
+        options[:prefix] ||= prefixed(path.to_s)
+        keys(options).first
+      end
+      alias_method '[]', 'key'
+
+    # TODO - refactor, possibly place in key.rb
+    #
+      def find_or_create_key_by_absolute_path(path, options = {})
+        path = path.to_s
+        options.to_options!
+        head = options.has_key?(:head) ? options.delete(:head) : true
+        key = nil
+        keys(:prefix => path, :head => head).each do |candidate|
+          break(key = candidate) if candidate.name == path
+        end
+        key ||= Key.create(self, path)
+      end
+
+      def has_key?(path)
+        find_or_create_key_by_absolute_path(prefixed(path)).exists?
+      end
+
+      def rename_key(src, dst)
+        src = Key.create(self, prefixed(src.to_s)) unless src.is_a?(Key)
+        src.rename(prefixed(dst))
+        src
+      end
+      alias_method 'rename', 'rename_key'
+
+      def copy_key(src, dst)
+        src = Key.create(self, prefixed(src.to_s)) unless src.is_a?(Key)
+        src.copy(prefixed(dst))
+      end
+      alias_method 'cp', 'copy_key'
+      alias_method 'copy', 'copy_key'
+      
+      def move_key(src, dst)
+        src = Key.create(self, prefixed(src.to_s)) unless src.is_a?(Key)
+        src.move(prefixed(dst))
+      end
+      alias_method 'mv', 'move_key'
+      alias_method 'move', 'move_key'
+
+      def location # '' or 'EU'
+        @location ||= @interface.bucket_location(name)
+      end
+      
+    # TODO - totally untested
+    #
+      def logging_info
+        @interface.get_logging_parse(:bucket => @name)
+      end
+      
+    # TODO - totally untested
+    #
+      def enable_logging(params)
+        AwsUtils.mandatory_arguments([:targetbucket, :targetprefix], params)
+        AwsUtils.allow_only([:targetbucket, :targetprefix], params)
+        xmldoc = 
+          "
+            <?xml version=\"1.0\" encoding=\"UTF-8\"?>
+              <BucketLoggingStatus xmlns=\"http://doc.s3.amazonaws.com/2006-03-01\">
+              <LoggingEnabled>
+                <TargetBucket>#{params[:targetbucket]}</TargetBucket>
+                <TargetPrefix>#{params[:targetprefix]}</TargetPrefix>
+              </LoggingEnabled></BucketLoggingStatus>
+          "
+        @interface.put_logging(:bucket => @name, :xmldoc => xmldoc)
+      end
+      
+    # TODO - totally untested
+    #
+      def disable_logging
+        xmldoc =
+          "
+            <?xml version=\"1.0\" encoding=\"UTF-8\"?>
+              <BucketLoggingStatus xmlns=\"http://doc.s3.amazonaws.com/2006-03-01\">
+              </BucketLoggingStatus>
+          "
+        @interface.put_logging(:bucket => @name, :xmldoc => xmldoc)
+      end
+
+    # TODO - totally untested
+    #
+      def grantees
+        Grantee::grantees(self)
+      end
+    end
+  end
+end

data/lib/helene/s3/grantee.rb

@@ -0,0 +1,134 @@
+module Helene
+  module S3
+    class Grantee
+      attr_reader :thing
+      attr_reader :id
+      attr_reader :name
+      attr_accessor :perms
+        
+      def self.owner_and_grantees(thing)
+        if thing.is_a?(Bucket)
+          bucket, key = thing, ''
+        else
+          bucket, key = thing.bucket, thing
+        end
+        hash = bucket.interface.get_acl_parse(bucket.to_s, key.to_s)
+        owner = Owner.new(hash[:owner][:id], hash[:owner][:display_name])
+        
+        grantees = []
+        hash[:grantees].each do |id, params|
+          grantees << new(thing, id, params[:permissions], nil, params[:display_name])
+        end
+        [owner, grantees]
+      end
+
+      def self.grantees(thing)
+        owner_and_grantees(thing)[1]
+      end
+
+      def self.put_acl(thing, owner, grantees) #:nodoc:
+        if thing.is_a?(Bucket)
+          bucket, key = thing, ''
+        else
+          bucket, key = thing.bucket, thing
+        end
+        body = "<AccessControlPolicy>" +
+               "<Owner>" +
+               "<ID>#{owner.id}</ID>" +
+               "<DisplayName>#{owner.name}</DisplayName>" +
+               "</Owner>" +
+               "<AccessControlList>" +
+               grantees.map{|grantee| grantee.to_xml}.join +
+               "</AccessControlList>" +
+               "</AccessControlPolicy>"
+        bucket.interface.put_acl(bucket.to_s, key.to_s, body)
+      end
+
+      def initialize(thing, id, perms=[], action=:refresh, name=nil)
+        @thing = thing
+        @id    = id
+        @name  = name
+        @perms = perms.to_a
+        case action
+          when :apply:             apply
+          when :refresh:           refresh
+          when :apply_and_refresh: apply; refresh
+        end
+      end
+      
+      def exists?
+        self.class.grantees(@thing).each do |grantee|
+          return true if @id == grantee.id
+        end
+        false
+      end
+      
+      def type
+        @id[/^http:/] ? "Group" : "CanonicalUser"
+      end
+ 
+      def to_s
+        @name || @id
+      end
+      
+      def grant(*permissions)
+        permissions.flatten!
+        old_perms = @perms.dup
+        @perms   += permissions
+        @perms.uniq!
+        return true if @perms == old_perms
+        apply
+      end
+      
+      def revoke(*permissions)
+        permissions.flatten!
+        old_perms = @perms.dup
+        @perms   -= permissions
+        @perms.uniq!
+        return true if @perms == old_perms
+        apply
+      end
+     
+      def drop
+        @perms = []
+        apply
+      end
+         
+      def refresh
+        @perms = []
+        self.class.grantees(@thing).each do |grantee|
+          if @id == grantee.id
+            @name  = grantee.name
+            @perms = grantee.perms
+            return true
+          end
+        end
+        false
+      end
+
+      def apply
+        @perms.uniq!
+        owner, grantees = self.class.owner_and_grantees(@thing)
+        # walk through all the grantees and replace the data for the current one and ...
+        grantees.map! { |grantee| grantee.id == @id ? self : grantee }
+        # ... if this grantee is not known - add this bad boy to a list
+        grantees << self unless grantees.include?(self)
+        # set permissions
+        self.class.put_acl(@thing, owner, grantees)
+      end
+
+      def to_xml
+        id_str = @id[/^http/] ? "<URI>#{@id}</URI>" : "<ID>#{@id}</ID>"
+        grants = ''
+        @perms.each do |perm|
+          grants << "<Grant>"    +
+                    "<Grantee xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" " +
+                      "xsi:type=\"#{type}\">#{id_str}</Grantee>" +
+                    "<Permission>#{perm}</Permission>" +
+                    "</Grant>"
+        end
+        grants
+      end
+    end
+  end
+end