steamcannon-s3 0.3.2

data/.gitignore

@@ -0,0 +1,7 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg
+*.gem
+.bundle

data/Gemfile

@@ -0,0 +1,4 @@
+source :gemcutter
+
+# Specify your gem's dependencies in s3.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,27 @@
+PATH
+  remote: .
+  specs:
+    s3 (0.3.2)
+      proxies
+      trollop
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    mocha (0.9.8)
+      rake
+    proxies (0.1.1)
+    rake (0.8.7)
+    test-unit (2.1.1)
+    trollop (1.16.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (>= 1.0.0)
+  mocha
+  proxies
+  s3!
+  test-unit (>= 2.0)
+  trollop

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Jakub Kuźma, Mirosław Boruta
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,22 @@
+= S3
+
+S3 library provides access to {Amazon's Simple Storage Service}[http://aws.amazon.com/s3/].
+It supports both: European and US buckets through {REST API}[http://docs.amazonwebservices.com/AmazonS3/latest/RESTAPI.html].
+
+* homepage[http://jah.pl/projects/s3.html]
+* gemcutter[http://gemcutter.org/gems/s3]
+* repository[http://github.com/qoobaa/s3]
+* {issue tracker}[http://github.com/qoobaa/s3/issues]
+* rdoc[http://qoobaa.github.com/s3]
+
+== Installation
+
+  gem install s3
+
+== Usage
+
+See homepage[http://jah.pl/projects/s3.html] for details.
+
+== Copyright
+
+Copyright (c) 2009 Jakub Kuźma, Mirosław Boruta. See LICENSE[http://github.com/qoobaa/s3/raw/master/LICENSE] for details.

data/Rakefile

@@ -0,0 +1,20 @@
+require "bundler"
+Bundler::GemHelper.install_tasks
+
+require "rake/testtask"
+require "rake/rdoctask"
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << "lib" << "test"
+  test.pattern = "test/**/*_test.rb"
+  test.verbose = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title = "s3 #{S3::VERSION}"
+  rdoc.rdoc_files.include("README.rdoc")
+  rdoc.rdoc_files.include("lib/**/*.rb")
+end
+
+task :default => :test

data/bin/s3

@@ -0,0 +1,187 @@
+#!/usr/bin/env ruby
+
+$: << File.expand_path(File.dirname(__FILE__) + "/../lib")
+
+require "trollop"
+require "s3"
+
+# HELPER METHODS
+
+include S3
+
+def list_buckets(service)
+  service.buckets.each do |bucket|
+    puts bucket.name
+  end
+end
+
+def create_bucket(service, name, location)
+  service.buckets.build(name).save(location)
+end
+
+def destroy_bucket(service, name)
+  service.buckets.find(name).destroy
+end
+
+def show_bucket(service, name, options = {})
+  service.buckets.find(name).objects.find_all.each do |object|
+    puts "#{name}/#{object.key}"
+  end
+end
+
+def list_objects(service)
+  service.buckets.each do |bucket|
+    bucket.objects.each do |object|
+      puts "#{bucket.name}/#{object.key}"
+    end
+  end
+end
+
+def create_object(service, name, file_name, options = {})
+  bucket_name, object_name = name.split("/", 2)
+  object = service.buckets.find(bucket_name).objects.build(object_name)
+  object.content_type = options[:type]
+  object.content_encoding = options[:encoding]
+  object.content_disposition = options[:disposition]
+  object.acl = options[:acl]
+  object.content = File.new(file_name)
+  object.save
+end
+
+def destroy_object(service, name)
+  bucket_name, object_name = name.split("/", 2)
+  object = service.buckets.find(bucket_name).objects.find(object_name)
+  object.destroy
+end
+
+def show_object(service, name, file_name = nil)
+  bucket_name, object_name = name.split("/", 2)
+  object = service.buckets.find(bucket_name).objects.find_first(object_name)
+  puts "         object:   #{object.name}/#{object.key}"
+  puts "   content type:   #{object.content_type}"
+  puts "           size:   #{object.size}"
+  puts "           etag:   #{object.etag}"
+  puts "  last modified:   #{object.last_modified}"
+  if file_name
+    if file_name == "-"
+      puts object.content
+    else
+      File.open(file_name, "wb") do |file|
+        file.write(object.content)
+      end
+    end
+  end
+end
+
+# COMMAND LINE PARSER
+
+ACCESS_KEY_ID = ENV["ACCESS_KEY_ID"]
+SECRET_ACCESS_KEY = ENV["SECRET_ACCESS_KEY"]
+COMMANDS = %w(bucket object)
+BUCKET_SUBCOMMANDS = %w(add remove show)
+OBJECT_SUBCOMMANDS = %w(add remove show)
+
+global_options = Trollop::options do
+  banner "s3 command line tool"
+  opt :access_key_id, "Your access key id to AWS", :type => :string, :default => ACCESS_KEY_ID
+  opt :secret_access_key, "Your secret access key to AWS", :type => :string, :default => SECRET_ACCESS_KEY
+  opt :debug, "Debug mode", :type => :flag, :default => false
+  stop_on COMMANDS
+end
+
+Trollop::die "No access key id given" unless global_options[:access_key_id]
+Trollop::die "No secret access key given" unless global_options[:secret_access_key]
+
+service = Service.new(:access_key_id => global_options[:access_key_id],
+                      :secret_access_key => global_options[:secret_access_key],
+                      :debug => global_options[:debug])
+
+command = ARGV.shift
+
+begin
+  case command
+  when "bucket"
+    command_options = Trollop::options do
+      banner "manage buckets"
+      stop_on BUCKET_SUBCOMMANDS
+    end
+    subcommand = ARGV.shift
+    case subcommand
+    when "add"
+      subcommand_options = Trollop::options do
+        banner "add bucket"
+        opt :location, "Location of the bucket - EU or US", :default => "US", :type => :string
+      end
+      name = ARGV.shift
+      Trollop::die "Bucket has not been added because of unknown error" unless create_bucket(service, name, subcommand_options[:location])
+    when "remove"
+      subcommand_options = Trollop::options do
+        banner "remove bucket"
+      end
+      name = ARGV.shift
+      Trollop::die "Bucket name must be given" if name.nil? or name.empty?
+      Trollop::die "Bucket has not been removed because of unknown error" unless destroy_bucket(service, name)
+    when "show"
+      subcommand_options = Trollop::options do
+        banner "show bucket"
+        opt :prefix, "Limits the response to keys which begin with the indicated prefix", :type => :string
+        opt :marker, "Indicates where in the bucket to begin listing", :type => :string
+        opt :max_keys, "The maximum number of keys you'd like to see", :type => :integer
+        opt :delimiter, "Causes keys that contain the same string between the prefix and the first occurrence of the delimiter to be rolled up into a single result element", :type => :string
+      end
+      name = ARGV.shift
+      Trollop::die "Bucket name must be given" if name.nil? or name.empty?
+      show_bucket(service, name, subcommand_options)
+    when nil
+      list_buckets(service)
+    else
+      Trollop::die "Unknown subcommand: #{subcommand.inspect}"
+    end
+  when "object"
+    command_options = Trollop::options do
+      banner "manage objects"
+      stop_on OBJECT_SUBCOMMANDS
+    end
+    subcommand = ARGV.shift
+    case subcommand
+    when "add"
+      subcommand_options = Trollop::options do
+        banner "object add s3_object_name local_file_name"
+        opt :type, "A standard MIME type describing the format of the contents", :default => "binary/octet-stream"
+        opt :disposition, "Specifies presentational information for the object", :type => :string
+        opt :encoding, "Specifies what content encodings have been applied to the object and thus what decoding mechanisms must be applied in order to obtain the media-type referenced by the Content-Type header field", :type => :string
+        opt :acl, "The canned ACL to apply to the object. Options include private, public-read, public-read-write, and authenticated-read", :type => :string
+      end
+      name = ARGV.shift
+      Trollop::die "No object name given" if name.nil? or name.empty?
+      file_name = ARGV.shift
+      Trollop::die "No file name given" if file_name.nil? or file_name.empty?
+      Trollop::die "Object has not been added because of unknown error" unless create_object(service, name, file_name, subcommand_options)
+    when "remove"
+      subcommand_options = Trollop::options do
+        banner "object remove s3_object_name"
+      end
+      name = ARGV.shift
+      Trollop::die "No object name given" if name.nil? or name.empty?
+      Trollop::die "Object has not been removed because of unknown error" unless destroy_object(service, name)
+    when "show"
+      subcommand_options = Trollop::options do
+        banner "object show s3_object_name optional_file_name"
+      end
+      name = ARGV.shift
+      Trollop::die "No object name given" if name.nil? or name.empty?
+      file_name = ARGV.shift
+      show_object(service, name, file_name)
+    when nil
+      list_objects(service)
+    else
+      Trollop::die "Unknown subcommand: #{subcommand.inspect}"
+    end
+  when nil
+    Trollop::die "No command given"
+  else
+    Trollop::die "Unknown command #{command.inspect}"
+  end
+rescue Error::ResponseError => e
+  Trollop::die e.message.sub(/\.+\Z/, "")
+end

data/extra/s3_attachment_fu.rb

@@ -0,0 +1,159 @@
+require "singleton"
+require "s3"
+
+# S3 Backend for attachment-fu plugin. After installing attachment-fu
+# plugin, copy the file to:
+# +vendor/plugins/attachment-fu/lib/technoweenie/attachment_fu/backends+
+#
+# To configure S3Backend create initializer file in your Rails
+# application, e.g. +config/initializers/s3_backend.rb+.
+#
+#   Technoweenie::AttachmentFu::Backends::S3Backend.configuration do |config|
+#     config.access_key_id = "..." # your access key id
+#     config.secret_access_key = "..." # your secret access key
+#     config.bucket_name = "..." # default bucket name to store attachments
+#     config.use_ssl = false # pass true if you want to communicate via SSL
+#   end
+
+module Technoweenie
+  module AttachmentFu
+    module Backends
+      module S3Backend
+
+        # S3Backend configuration class
+        class Configuration
+          include Singleton
+
+          ATTRIBUTES = [:access_key_id, :secret_access_key, :use_ssl, :bucket_name]
+
+          attr_accessor *ATTRIBUTES
+        end
+
+        # Method used to configure S3Backend, see the example above
+        def self.configuration
+          if block_given?
+            yield Configuration.instance
+          end
+          Configuration.instance
+        end
+
+        # :nodoc:
+        def self.included(base)
+          include S3
+
+          service = Service.new(:access_key_id => configuration.access_key_id,
+                                :secret_access_key => configuration.secret_access_key,
+                                :use_ssl => configuration.use_ssl)
+
+          bucket_name = base.attachment_options[:bucket_name] || configuration.bucket_name
+
+          base.cattr_accessor :bucket
+          base.bucket = service.buckets.build(bucket_name) # don't connect
+
+          base.before_update :rename_file
+        end
+
+        # The attachment ID used in the full path of a file
+        def attachment_path_id
+          ((respond_to?(:parent_id) && parent_id) || id).to_s
+        end
+
+        # The pseudo hierarchy containing the file relative to the bucket name
+        # Example: <tt>:table_name/:id</tt>
+        def base_path
+          [attachment_options[:path_prefix], attachment_path_id].join("/")
+        end
+
+        # The full path to the file relative to the bucket name
+        # Example: <tt>:table_name/:id/:filename</tt>
+        def full_filename(thumbnail = nil)
+          [base_path, thumbnail_name_for(thumbnail)].join("/")
+        end
+
+        # All public objects are accessible via a GET request to the S3 servers. You can generate a
+        # url for an object using the s3_url method.
+        #
+        #   @photo.s3_url
+        #
+        # The resulting url is in the form: <tt>http(s)://:server/:bucket_name/:table_name/:id/:file</tt> where
+        # the <tt>:server</tt> variable defaults to <tt>AWS::S3 URL::DEFAULT_HOST</tt> (s3.amazonaws.com) and can be
+        # set using the configuration parameters in <tt>RAILS_ROOT/config/amazon_s3.yml</tt>.
+        #
+        # The optional thumbnail argument will output the thumbnail's filename (if any).
+        def s3_url(thumbnail = nil)
+          if attachment_options[:cname]
+            ["#{s3_protocol}#{bucket.name}", full_filename(thumbnail)].join("/")
+          else
+            ["#{s3_protocol}#{s3_hostname}#{bucket.path_prefix}", full_filename(thumbnail)].join("/")
+          end
+        end
+        alias :public_url :s3_url
+        alias :public_filename :s3_url
+
+        # Name of the bucket used to store attachments
+        def bucket_name
+          self.class.bucket.name
+        end
+
+        # :nodoc:
+        def create_temp_file
+          write_to_temp_file current_data
+        end
+
+        # :nodoc:
+        def current_data
+          # Object.value full_filename, bucket_name
+          object = self.class.bucket.objects.find(full_filename)
+          object.content
+        end
+
+        # Returns http:// or https:// depending on use_ssl setting
+        def s3_protocol
+          attachment_options[:use_ssl] ?  "https://" : "http://"
+        end
+
+        # Returns hostname of the bucket
+        # e.g. +bucketname.com.s3.amazonaws.com+. Additionally you can
+        # pass :cname => true option in has_attachment method to
+        # return CNAME only, e.g. +bucketname.com+
+        def s3_hostname
+          attachment_options[:cname] ? self.class.bucket.name : self.class.bucket.host
+        end
+
+        protected
+
+        # Frees the space in S3 bucket, used by after_destroy callback
+        def destroy_file
+          object = self.class.bucket.objects.find(full_filename)
+          object.destroy
+        end
+
+        # Renames file if filename has been changed - copy the file to
+        # new key and delete old one
+        def rename_file
+          return unless filename_changed?
+
+          old_full_filename = [base_path, filename_was].join("/")
+
+          object = self.class.bucket.objects.find(old_full_filename)
+          new_object = object.copy(:key => full_filename, :acl => attachment_options[:acl])
+          object.destroy
+          true
+        end
+
+        # Saves the file to storage
+        def save_to_storage
+          if save_attachment?
+            object = self.class.bucket.objects.build(full_filename)
+
+            object.content_type = content_type
+            object.acl = attachment_options[:acl]
+            object.content = temp_path ? File.open(temp_path) : temp_data
+            object.save
+          end
+          true
+        end
+      end
+    end
+  end
+end

data/extra/s3_paperclip.rb

@@ -0,0 +1,156 @@
+# S3 backend for paperclip plugin. Copy the file to:
+# +config/initializers/+ directory
+#
+# Example configuration for CNAME bucket:
+#
+#   has_attached_file :image,
+#                     :s3_host_alias => "bucket.domain.tld",
+#                     :url => ":s3_alias_url",
+#                     :styles => {
+#                       :medium => "300x300>",
+#                       :thumb => "100x100>"
+#                     },
+#                     :storage => :s3,
+#                     :s3_credentials => {
+#                       :access_key_id => "...",
+#                       :secret_access_key => "..."
+#                     },
+#                     :bucket => "bucket.domain.tld",
+#                     :path => ":attachment/:id/:style.:extension"
+module Paperclip
+  module Storage
+    module S3
+      def self.extended base
+        begin
+          require "s3"
+        rescue LoadError => e
+          e.message << " (You may need to install the s3 gem)"
+          raise e
+        end
+
+        base.instance_eval do
+          @s3_credentials   = parse_credentials(@options[:s3_credentials])
+          @bucket_name      = @options[:bucket]           || @s3_credentials[:bucket]
+          @bucket_name      = @bucket_name.call(self) if @bucket_name.is_a?(Proc)
+          @s3_options       = @options[:s3_options]       || {}
+          @s3_permissions   = @options[:s3_permissions]   || :public_read
+          @s3_storage_class = @options[:s3_storage_class] || :standard
+          @s3_protocol      = @options[:s3_protocol]      || (@s3_permissions == :public_read ? "http" : "https")
+          @s3_headers       = @options[:s3_headers]       || {}
+          @s3_host_alias    = @options[:s3_host_alias]
+          @url              = ":s3_path_url" unless @url.to_s.match(/^:s3.*url$/)
+          @service = ::S3::Service.new(@s3_options.merge(
+            :access_key_id => @s3_credentials[:access_key_id],
+            :secret_access_key => @s3_credentials[:secret_access_key],
+            :use_ssl => @s3_protocol == "https"
+          ))
+          @bucket = @service.buckets.build(@bucket_name)
+        end
+        Paperclip.interpolates(:s3_alias_url) do |attachment, style|
+          "#{attachment.s3_protocol}://#{attachment.s3_host_alias}/#{attachment.path(style).gsub(%r{^/}, "")}"
+        end
+        Paperclip.interpolates(:s3_path_url) do |attachment, style|
+          "#{attachment.s3_protocol}://s3.amazonaws.com/#{attachment.bucket_name}/#{attachment.path(style).gsub(%r{^/}, "")}"
+        end
+        Paperclip.interpolates(:s3_domain_url) do |attachment, style|
+          "#{attachment.s3_protocol}://#{attachment.bucket_name}.s3.amazonaws.com/#{attachment.path(style).gsub(%r{^/}, "")}"
+        end
+      end
+
+      def expiring_url(style_name = default_style, time = 3600)
+        bucket.objects.build(path(style_name)).temporary_url(Time.now + time)
+      end
+
+      def bucket_name
+        @bucket_name
+      end
+
+      def bucket
+        @bucket
+      end
+
+      def s3_host_alias
+        @s3_host_alias
+      end
+
+      def parse_credentials creds
+        creds = find_credentials(creds).stringify_keys
+        (creds[RAILS_ENV] || creds).symbolize_keys
+      end
+
+      def exists?(style = default_style)
+        if original_filename
+          bucket.objects.build(path(style)).exists?
+        else
+          false
+        end
+      end
+
+      def s3_protocol
+        @s3_protocol
+      end
+
+      # Returns representation of the data of the file assigned to the given
+      # style, in the format most representative of the current storage.
+      def to_file style = default_style
+        return @queued_for_write[style] if @queued_for_write[style]
+        begin
+          file = Tempfile.new(path(style))
+          file.binmode if file.respond_to?(:binmode)
+          file.write(bucket.objects.find(path(style)).content)
+          file.rewind
+        rescue ::S3::Error::NoSuchKey
+          file.close if file.respond_to?(:close)
+          file = nil
+        end
+        file
+      end
+
+      def flush_writes #:nodoc:
+        @queued_for_write.each do |style, file|
+          begin
+            log("saving #{path(style)}")
+            object = bucket.objects.build(path(style))
+            object.content = file.read
+            object.acl = @s3_permissions
+            object.storage_class = @s3_storage_class
+            object.content_type = instance_read(:content_type)
+            object.content_disposition = @s3_headers[:content_disposition]
+            object.content_encoding = @s3_headers[:content_encoding]
+            object.save
+          rescue ::S3::Error::ResponseError => e
+            raise
+          end
+        end
+        @queued_for_write = {}
+      end
+
+      def flush_deletes #:nodoc:
+        @queued_for_delete.each do |path|
+          begin
+            log("deleting #{path}")
+            bucket.objects.find(path).destroy
+          rescue ::S3::Error::ResponseError
+            # Ignore this.
+          end
+        end
+        @queued_for_delete = []
+      end
+
+      def find_credentials creds
+        case creds
+        when File
+          YAML::load(ERB.new(File.read(creds.path)).result)
+        when String
+          YAML::load(ERB.new(File.read(creds)).result)
+        when Hash
+          creds
+        else
+          raise ArgumentError, "Credentials are not a path, file, or hash."
+        end
+      end
+      private :find_credentials
+
+    end
+  end
+end