edavis10-redmine_s3 0.0.3

data/README.rdoc

@@ -0,0 +1,19 @@
+= S3 plugin for Redmine
+
+== Description
+This Redmine[http://www.redmine.org] plugin makes file attachments be stored on "Amazon S3"[http://aws.amazon.com/s3] rather than on the local filesystem.
+
+== Installation
+1. Make sure Redmine is installed and cd into it's root directory
+2. ruby script/plugin install git://github.com/tigrish/redmine_s3.git
+3. cp vendor/plugins/redmine_s3/config/s3.yml.example config/s3.yml
+4. Edit config/s3.yml with your favourite editor
+5. Restart mongrel/upload to production/whatever
+
+== Options
+* The bucket specified in s3.yml will be created automatically when the plugin is loaded (this is generally when the server starts).
+* If you have created a CNAME entry for your bucket set the cname_bucket option to true in s3.yml and your files will be served from that domain. 
+* After files are uploaded they are made public. This seems acceptable as it is also Redmine's policy for file storage.
+
+== Reporting Bugs and Getting Help
+Bugs and feature requests may be filed at http://projects.tigrish.com/projects/redmine-s3/issues

data/Rakefile

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+require 'redmine_plugin_support'
+
+Dir[File.expand_path(File.dirname(__FILE__)) + "/lib/tasks/**/*.rake"].sort.each { |ext| load ext }
+
+RedminePluginSupport::Base.setup do |plugin|
+  plugin.project_name = 'redmine_s3'
+  plugin.default_task = [:test]
+  plugin.tasks = [:doc, :release, :clean, :test, :db]
+  # TODO: gem not getting this automaticly
+  plugin.redmine_root = File.expand_path(File.dirname(__FILE__) + '/../../../')
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "edavis10-redmine_s3"
+    s.summary = "Plugin to have Redmine store uploads on S3"
+    s.email = "edavis@littlestreamsoftware.com"
+    s.homepage = "http://projects.tigrish.com/projects/redmine-s3"
+    s.description = "Plugin to have Redmine store uploads on S3"
+    s.authors = ["Christopher Dell", "Eric Davis"]
+    s.rubyforge_project = "littlestreamsoftware"
+    s.files =  FileList[
+                        "[A-Z]*",
+                        "init.rb",
+                        "rails/init.rb",
+                        "{bin,generators,lib,test,app,assets,config,lang}/**/*",
+                        'lib/jeweler/templates/.gitignore'
+                       ]
+  end
+  Jeweler::GemcutterTasks.new
+  Jeweler::RubyforgeTasks.new do |rubyforge|
+    rubyforge.doc_task = "rdoc"
+  end
+rescue LoadError
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.3

data/config/locales/en.yml

@@ -0,0 +1,3 @@
+# English strings go here for Rails i18n
+en:
+  my_label: "My label"

data/config/s3.yml.example

@@ -0,0 +1,11 @@
+production:
+  access_key_id: 
+  secret_access_key: 
+  bucket: 
+  cname_bucket: false
+
+development:
+  access_key_id: 
+  secret_access_key: 
+  bucket:
+  cname_bucket: false

data/init.rb

@@ -0,0 +1,25 @@
+require 'redmine'
+require 'dispatcher' # Patches to the Redmine core.
+ 
+Dispatcher.to_prepare :redmine_s3 do
+  require_dependency 'attachment'
+  unless Attachment.included_modules.include? RedmineS3::AttachmentPatch
+    Attachment.send(:include, RedmineS3::AttachmentPatch)
+  end
+
+  app_dependency = Redmine::VERSION.to_a.slice(0,3).join('.') > '0.8.4' ? 'application_controller' : 'application'
+  require_dependency(app_dependency)
+  require_dependency 'attachments_controller'
+  unless AttachmentsController.included_modules.include? RedmineS3::AttachmentsControllerPatch
+    AttachmentsController.send(:include, RedmineS3::AttachmentsControllerPatch)
+  end
+
+  RedmineS3::Connection.create_bucket
+end
+
+Redmine::Plugin.register :redmine_s3_attachments do
+  name 'S3'
+  author 'Chris Dell'
+  description 'Use Amazon S3 as a storage engine for attachments'
+  version '0.0.3'
+end

data/lang/en.yml

@@ -0,0 +1,2 @@
+# English strings go here
+my_label: "My label"

data/lib/S3.rb

@@ -0,0 +1,861 @@
+#!/usr/bin/env ruby
+
+#  This software code is made available "AS IS" without warranties of any
+#  kind.  You may copy, display, modify and redistribute the software
+#  code either by itself or as incorporated into your code; provided that
+#  you do not remove any proprietary notices.  Your use of this software
+#  code is at your own risk and you waive any claim against Amazon
+#  Digital Services, Inc. or its affiliates with respect to your use of
+#  this software code. (c) 2006-2007 Amazon Digital Services, Inc. or its
+#  affiliates.
+
+require 'base64'
+require 'cgi'
+require 'openssl'
+require 'digest/sha1'
+require 'net/https'
+require 'rexml/document'
+require 'time'
+require 'uri'
+
+# this wasn't added until v 1.8.3
+if (RUBY_VERSION < '1.8.3')
+  class Net::HTTP::Delete < Net::HTTPRequest
+    METHOD = 'DELETE'
+    REQUEST_HAS_BODY = false
+    RESPONSE_HAS_BODY = true
+  end
+end
+
+# this module has two big classes: AWSAuthConnection and
+# QueryStringAuthGenerator.  both use identical apis, but the first actually
+# performs the operation, while the second simply outputs urls with the
+# appropriate authentication query string parameters, which could be used
+# in another tool (such as your web browser for GETs).
+module S3
+  DEFAULT_HOST = 's3.amazonaws.com'
+  PORTS_BY_SECURITY = { true => 443, false => 80 }
+  METADATA_PREFIX = 'x-amz-meta-'
+  AMAZON_HEADER_PREFIX = 'x-amz-'
+
+  # Location constraint for CreateBucket
+  module BucketLocation 
+    DEFAULT = nil
+    EU = 'EU'
+  end
+  
+  # builds the canonical string for signing.
+  def S3.canonical_string(method, bucket="", path="", path_args={}, headers={}, expires=nil)
+    interesting_headers = {}
+    headers.each do |key, value|
+      lk = key.downcase
+      if (lk == 'content-md5' or
+          lk == 'content-type' or
+          lk == 'date' or
+          lk =~ /^#{AMAZON_HEADER_PREFIX}/o)
+        interesting_headers[lk] = value.to_s.strip
+      end
+    end
+
+    # these fields get empty strings if they don't exist.
+    interesting_headers['content-type'] ||= ''
+    interesting_headers['content-md5'] ||= ''
+
+    # just in case someone used this.  it's not necessary in this lib.
+    if interesting_headers.has_key? 'x-amz-date'
+      interesting_headers['date'] = ''
+    end
+
+    # if you're using expires for query string auth, then it trumps date
+    # (and x-amz-date)
+    if not expires.nil?
+      interesting_headers['date'] = expires
+    end
+
+    buf = "#{method}\n"
+    interesting_headers.sort { |a, b| a[0] <=> b[0] }.each do |key, value|
+      if key =~ /^#{AMAZON_HEADER_PREFIX}/o
+        buf << "#{key}:#{value}\n"
+      else
+        buf << "#{value}\n"
+      end
+    end
+    
+    # build the path using the bucket and key
+    if not bucket.empty?
+      buf << "/#{bucket}"
+    end
+    # append the key (it might be empty string) 
+    # append a slash regardless
+    buf << "/#{path}"
+
+    # if there is an acl, logging, or torrent parameter
+    # add them to the string
+    if path_args.has_key?('acl')
+      buf << '?acl'
+    elsif path_args.has_key?('torrent')
+      buf << '?torrent'
+    elsif path_args.has_key?('logging')
+      buf << '?logging'
+    elsif path_args.has_key?('location')
+      buf << '?location'
+    end
+    
+    return buf
+  end
+
+  # encodes the given string with the aws_secret_access_key, by taking the
+  # hmac-sha1 sum, and then base64 encoding it.  optionally, it will also
+  # url encode the result of that to protect the string if it's going to
+  # be used as a query string parameter.
+  def S3.encode(aws_secret_access_key, str, urlencode=false)
+    digest = OpenSSL::Digest::Digest.new('sha1')
+    b64_hmac =
+      Base64.encode64(
+        OpenSSL::HMAC.digest(digest, aws_secret_access_key, str)).strip
+
+    if urlencode
+      return CGI::escape(b64_hmac)
+    else
+      return b64_hmac
+    end
+  end
+
+  # build the path_argument string
+  def S3.path_args_hash_to_string(path_args={})
+    arg_string = ''
+    path_args.each { |k, v|
+      arg_string << (arg_string.empty? ? '?' : '&')
+      arg_string << k
+      if not v.nil?
+        arg_string << "=#{CGI::escape(v)}"
+      end
+    }
+    return arg_string
+  end
+
+  # uses Net::HTTP to interface with S3.  note that this interface should only
+  # be used for smaller objects, as it does not stream the data.  if you were
+  # to download a 1gb file, it would require 1gb of memory.  also, this class
+  # creates a new http connection each time.  it would be greatly improved with
+  # some connection pooling.
+  class AWSAuthConnection
+    attr_accessor :calling_format
+    
+    def initialize(aws_access_key_id, aws_secret_access_key, is_secure=true,
+                   server=DEFAULT_HOST, port=PORTS_BY_SECURITY[is_secure],
+                   calling_format=CallingFormat::SUBDOMAIN)
+      @aws_access_key_id = aws_access_key_id
+      @aws_secret_access_key = aws_secret_access_key
+      @server = server
+      @is_secure = is_secure
+      @calling_format = calling_format
+      @port = port
+    end
+
+    def create_bucket(bucket, headers={})
+      return Response.new(make_request('PUT', bucket, '', {}, headers))
+    end
+
+    def create_located_bucket(bucket, location=BucketLocation::DEFAULT, headers={})
+      if (location != BucketLocation::DEFAULT)
+          xmlbody = "<CreateBucketConstraint><LocationConstraint>#{location}</LocationConstraint></CreateBucketConstraint>"
+      end
+      return Response.new(make_request('PUT', bucket, '', {}, headers, xmlbody))
+    end
+
+    def check_bucket_exists(bucket)
+      begin
+        make_request('HEAD', bucket, '', {}, {})
+        return true
+      rescue Net::HTTPServerException
+        response = $!.response
+        return false if (response.code.to_i == 404)
+        raise
+      end
+    end
+      
+    # takes options :prefix, :marker, :max_keys, and :delimiter
+    def list_bucket(bucket, options={}, headers={})
+      path_args = {}
+      options.each { |k, v|
+          path_args[k] = v.to_s
+      }
+
+      return ListBucketResponse.new(make_request('GET', bucket, '', path_args, headers))
+    end
+
+    def delete_bucket(bucket, headers={})
+      return Response.new(make_request('DELETE', bucket, '', {}, headers))
+    end
+
+    def put(bucket, key, object, headers={})
+      object = S3Object.new(object) if not object.instance_of? S3Object
+
+      return Response.new(
+        make_request('PUT', bucket, CGI::escape(key), {}, headers, object.data, object.metadata)
+      )
+    end
+
+    def get(bucket, key, headers={})
+      return GetResponse.new(make_request('GET', bucket, CGI::escape(key), {}, headers))
+    end
+
+    def delete(bucket, key, headers={})
+      return Response.new(make_request('DELETE', bucket, CGI::escape(key), {}, headers))
+    end
+
+    def get_bucket_logging(bucket, headers={})
+      return GetResponse.new(make_request('GET', bucket, '', {'logging' => nil}, headers))
+    end
+
+    def put_bucket_logging(bucket, logging_xml_doc, headers={})
+      return Response.new(make_request('PUT', bucket, '', {'logging' => nil}, headers, logging_xml_doc))
+    end
+
+    def get_bucket_acl(bucket, headers={})
+      return get_acl(bucket, '', headers)
+    end
+
+    # returns an xml document representing the access control list.
+    # this could be parsed into an object.
+    def get_acl(bucket, key, headers={})
+      return GetResponse.new(make_request('GET', bucket, CGI::escape(key), {'acl' => nil}, headers))
+    end
+
+    def put_bucket_acl(bucket, acl_xml_doc, headers={})
+      return put_acl(bucket, '', acl_xml_doc, headers)
+    end
+
+    # sets the access control policy for the given resource.  acl_xml_doc must
+    # be a string in the acl xml format.
+    def put_acl(bucket, key, acl_xml_doc, headers={})
+      return Response.new(
+        make_request('PUT', bucket, CGI::escape(key), {'acl' => nil}, headers, acl_xml_doc, {})
+      )
+    end
+
+    def get_bucket_location(bucket)
+      return LocationResponse.new(make_request('GET', bucket, '', {'location' => nil}, {}))
+    end
+
+    def list_all_my_buckets(headers={})
+      return ListAllMyBucketsResponse.new(make_request('GET', '', '', {}, headers))
+    end
+
+    private
+    def make_request(method, bucket='', key='', path_args={}, headers={}, data='', metadata={})
+      
+      # build the domain based on the calling format
+      server = ''
+      if bucket.empty?
+        # for a bucketless request (i.e. list all buckets)
+        # revert to regular domain case since this operation
+        # does not make sense for vanity domains
+        server = @server
+      elsif @calling_format == CallingFormat::SUBDOMAIN
+        server = "#{bucket}.#{@server}" 
+      elsif @calling_format == CallingFormat::VANITY
+        server = bucket 
+      else
+        server = @server
+      end
+
+      # build the path based on the calling format
+      path = ''
+      if (not bucket.empty?) and (@calling_format == CallingFormat::PATH)
+        path << "/#{bucket}"
+      end
+      # add the slash after the bucket regardless
+      # the key will be appended if it is non-empty
+      path << "/#{key}"
+
+      # build the path_argument string
+      # add the ? in all cases since 
+      # signature and credentials follow path args
+      path << S3.path_args_hash_to_string(path_args) 
+
+      while true
+        http = Net::HTTP.new(server, @port)
+        http.use_ssl = @is_secure
+        http.start do
+          req = method_to_request_class(method).new(path)
+
+          set_headers(req, headers)
+          set_headers(req, metadata, METADATA_PREFIX)
+
+          set_aws_auth_header(req, @aws_access_key_id, @aws_secret_access_key, bucket, key, path_args)
+          if req.request_body_permitted?
+            resp = http.request(req, data)
+          else
+            resp = http.request(req)
+          end
+
+          case resp.code.to_i
+          when 100..299
+            return resp
+          when 300..399 # redirect
+	    location = resp['location']
+	    # handle missing location like a normal http error response
+	    resp.error! if !location
+            uri = URI.parse(resp['location'])
+            server = uri.host
+            path = uri.request_uri
+            # try again...
+          else
+            resp.error!
+          end
+        end # http.start
+      end # while
+    end
+
+    def method_to_request_class(method)
+      case method
+      when 'GET'
+        return Net::HTTP::Get
+      when 'HEAD'
+        return Net::HTTP::Head
+      when 'PUT'
+        return Net::HTTP::Put
+      when 'DELETE'
+        return Net::HTTP::Delete
+      else
+        raise "Unsupported method #{method}"
+      end
+    end
+
+    # set the Authorization header using AWS signed header authentication
+    def set_aws_auth_header(request, aws_access_key_id, aws_secret_access_key, bucket='', key='', path_args={})
+      # we want to fix the date here if it's not already been done.
+      request['Date'] ||= Time.now.httpdate
+
+      # ruby will automatically add a random content-type on some verbs, so
+      # here we add a dummy one to 'supress' it.  change this logic if having
+      # an empty content-type header becomes semantically meaningful for any
+      # other verb.
+      request['Content-Type'] ||= ''
+
+      canonical_string =
+        S3.canonical_string(request.method, bucket, key, path_args, request.to_hash, nil)
+      encoded_canonical = S3.encode(aws_secret_access_key, canonical_string)
+
+      request['Authorization'] = "AWS #{aws_access_key_id}:#{encoded_canonical}"
+    end
+
+    def set_headers(request, headers, prefix='')
+      headers.each do |key, value|
+        request[prefix + key] = value
+      end
+    end
+  end
+
+
+  # This interface mirrors the AWSAuthConnection class above, but instead
+  # of performing the operations, this class simply returns a url that can
+  # be used to perform the operation with the query string authentication
+  # parameters set.
+  class QueryStringAuthGenerator
+    attr_accessor :calling_format
+    attr_accessor :expires
+    attr_accessor :expires_in
+    attr_reader :server
+    attr_reader :port
+    attr_reader :is_secure
+
+    # by default, expire in 1 minute
+    DEFAULT_EXPIRES_IN = 60
+
+    def initialize(aws_access_key_id, aws_secret_access_key, is_secure=true, 
+                   server=DEFAULT_HOST, port=PORTS_BY_SECURITY[is_secure], 
+                   format=CallingFormat::SUBDOMAIN)
+      @aws_access_key_id = aws_access_key_id
+      @aws_secret_access_key = aws_secret_access_key
+      @protocol = is_secure ? 'https' : 'http'
+      @server = server
+      @port = port
+      @calling_format = format 
+      @is_secure = is_secure
+      # by default expire
+      @expires_in = DEFAULT_EXPIRES_IN
+    end
+
+    # set the expires value to be a fixed time.  the argument can
+    # be either a Time object or else seconds since epoch.
+    def expires=(value)
+      @expires = value
+      @expires_in = nil
+    end
+
+    # set the expires value to expire at some point in the future
+    # relative to when the url is generated.  value is in seconds.
+    def expires_in=(value)
+      @expires_in = value
+      @expires = nil
+    end
+
+    def create_bucket(bucket, headers={})
+      return generate_url('PUT', bucket, '', {}, headers)
+    end
+
+    # takes options :prefix, :marker, :max_keys, and :delimiter
+    def list_bucket(bucket, options={}, headers={})
+      path_args = {}
+      options.each { |k, v|
+        path_args[k] = v.to_s
+      }
+      return generate_url('GET', bucket, '', path_args, headers)
+    end
+
+    def delete_bucket(bucket, headers={})
+      return generate_url('DELETE', bucket, '', {}, headers)
+    end
+
+    # don't really care what object data is.  it's just for conformance with the
+    # other interface.  If this doesn't work, check tcpdump to see if the client is
+    # putting a Content-Type header on the wire.
+    def put(bucket, key, object=nil, headers={})
+      object = S3Object.new(object) if not object.instance_of? S3Object
+      return generate_url('PUT', bucket, CGI::escape(key), {}, merge_meta(headers, object))
+    end
+
+    def get(bucket, key, headers={})
+      return generate_url('GET', bucket, CGI::escape(key), {}, headers)
+    end
+
+    def delete(bucket, key, headers={})
+      return generate_url('DELETE', bucket, CGI::escape(key), {}, headers)
+    end
+
+    def get_bucket_logging(bucket, headers={})
+      return generate_url('GET', bucket, '', {'logging' => nil}, headers)
+    end
+
+    def put_bucket_logging(bucket, logging_xml_doc, headers={})
+      return generate_url('PUT', bucket, '', {'logging' => nil}, headers)
+    end
+
+    def get_acl(bucket, key='', headers={})
+      return generate_url('GET', bucket, CGI::escape(key), {'acl' => nil}, headers)
+    end
+
+    def get_bucket_acl(bucket, headers={})
+      return get_acl(bucket, '', headers)
+    end
+
+    # don't really care what acl_xml_doc is.
+    # again, check the wire for Content-Type if this fails.
+    def put_acl(bucket, key, acl_xml_doc, headers={})
+      return generate_url('PUT', bucket, CGI::escape(key), {'acl' => nil}, headers)
+    end
+
+    def put_bucket_acl(bucket, acl_xml_doc, headers={})
+      return put_acl(bucket, '', acl_xml_doc, headers)
+    end
+
+    def list_all_my_buckets(headers={})
+      return generate_url('GET', '', '', {}, headers)
+    end
+
+
+    private
+    # generate a url with the appropriate query string authentication
+    # parameters set.
+    def generate_url(method, bucket="", key="", path_args={}, headers={})
+      expires = 0
+      if not @expires_in.nil?
+        expires = Time.now.to_i + @expires_in
+      elsif not @expires.nil?
+        expires = @expires
+      else
+        raise "invalid expires state"
+      end
+
+      canonical_string =
+        S3::canonical_string(method, bucket, key, path_args, headers, expires)
+      encoded_canonical =
+        S3::encode(@aws_secret_access_key, canonical_string)
+      
+      url = CallingFormat.build_url_base(@protocol, @server, @port, bucket, @calling_format)
+      
+      path_args["Signature"] = encoded_canonical.to_s
+      path_args["Expires"] = expires.to_s
+      path_args["AWSAccessKeyId"] = @aws_access_key_id.to_s
+      arg_string = S3.path_args_hash_to_string(path_args) 
+
+      return "#{url}/#{key}#{arg_string}"
+    end
+
+    def merge_meta(headers, object)
+      final_headers = headers.clone
+      if not object.nil? and not object.metadata.nil?
+        object.metadata.each do |k, v|
+          final_headers[METADATA_PREFIX + k] = v
+        end
+      end
+      return final_headers
+    end
+  end
+
+  class S3Object
+    attr_accessor :data
+    attr_accessor :metadata
+    def initialize(data, metadata={})
+      @data, @metadata = data, metadata
+    end
+  end
+
+  # class for storing calling format constants
+  module CallingFormat 
+    PATH      = 0 # http://s3.amazonaws.com/bucket/key
+    SUBDOMAIN = 1 # http://bucket.s3.amazonaws.com/key
+    VANITY    = 2  # http://<vanity_domain>/key  -- vanity_domain resolves to s3.amazonaws.com
+
+    # build the url based on the calling format, and bucket
+    def CallingFormat.build_url_base(protocol, server, port, bucket, format)
+      build_url_base = "#{protocol}://"
+      if bucket.empty?
+        build_url_base << "#{server}:#{port}"
+      elsif format == SUBDOMAIN
+        build_url_base << "#{bucket}.#{server}:#{port}"
+      elsif format == VANITY
+        build_url_base << "#{bucket}:#{port}"
+      else
+        build_url_base << "#{server}:#{port}/#{bucket}"
+      end
+      return build_url_base 
+    end
+  end
+
+  class Owner
+    attr_accessor :id
+    attr_accessor :display_name
+  end
+
+  class ListEntry
+    attr_accessor :key
+    attr_accessor :last_modified
+    attr_accessor :etag
+    attr_accessor :size
+    attr_accessor :storage_class
+    attr_accessor :owner
+  end
+
+  class ListProperties
+    attr_accessor :name
+    attr_accessor :prefix
+    attr_accessor :marker
+    attr_accessor :max_keys
+    attr_accessor :delimiter
+    attr_accessor :is_truncated
+    attr_accessor :next_marker
+  end
+
+  class CommonPrefixEntry
+    attr_accessor :prefix
+  end
+
+  # Parses the list bucket output into a list of ListEntry objects, and
+  # a list of CommonPrefixEntry objects if applicable.
+  class ListBucketParser
+    attr_reader :properties
+    attr_reader :entries
+    attr_reader :common_prefixes
+
+    def initialize
+      reset
+    end
+
+    def tag_start(name, attributes)
+      if name == 'ListBucketResult'
+        @properties = ListProperties.new
+      elsif name == 'Contents'
+        @curr_entry = ListEntry.new
+      elsif name == 'Owner'
+        @curr_entry.owner = Owner.new
+      elsif name == 'CommonPrefixes'
+        @common_prefix_entry = CommonPrefixEntry.new
+      end      
+    end
+
+    # we have one, add him to the entries list
+    def tag_end(name)
+      text = @curr_text.strip
+      # this prefix is the one we echo back from the request
+      if name == 'Name'
+        @properties.name = text
+      elsif name == 'Prefix' and @is_echoed_prefix
+        @properties.prefix = text       
+        @is_echoed_prefix = nil
+      elsif name == 'Marker'
+        @properties.marker = text
+      elsif name == 'MaxKeys'
+        @properties.max_keys = text.to_i
+      elsif name == 'Delimiter'
+        @properties.delimiter = text
+      elsif name == 'IsTruncated'
+        @properties.is_truncated = text == 'true'
+      elsif name == 'NextMarker'        
+        @properties.next_marker = text
+      elsif name == 'Contents'
+        @entries << @curr_entry
+      elsif name == 'Key'
+        @curr_entry.key = text
+      elsif name == 'LastModified'
+        @curr_entry.last_modified = text
+      elsif name == 'ETag'
+        @curr_entry.etag = text
+      elsif name == 'Size'
+        @curr_entry.size = text.to_i
+      elsif name == 'StorageClass'
+        @curr_entry.storage_class = text
+      elsif name == 'ID'
+        @curr_entry.owner.id = text
+      elsif name == 'DisplayName'
+        @curr_entry.owner.display_name = text
+      elsif name == 'CommonPrefixes'
+        @common_prefixes << @common_prefix_entry         
+      elsif name == 'Prefix'
+        # this is the common prefix for keys that match up to the delimiter
+        @common_prefix_entry.prefix = text
+      end
+      @curr_text = ''
+    end
+
+    def text(text)
+        @curr_text += text
+    end
+
+    def xmldecl(version, encoding, standalone)
+      # ignore
+    end
+
+    # get ready for another parse
+    def reset
+      @is_echoed_prefix = true;
+      @entries = []
+      @curr_entry = nil
+      @common_prefixes = []
+      @common_prefix_entry = nil
+      @curr_text = ''
+    end
+  end
+
+  class ListAllMyBucketsParser
+    attr_reader :entries
+
+    def initialize
+      reset
+    end
+
+    def tag_start(name, attributes)
+      if name == 'Bucket'
+        @curr_bucket = Bucket.new
+      end
+    end
+
+    # we have one, add him to the entries list
+    def tag_end(name)
+      text = @curr_text.strip
+      if name == 'Bucket'
+        @entries << @curr_bucket
+      elsif name == 'Name'
+        @curr_bucket.name = text
+      elsif name == 'CreationDate'
+        @curr_bucket.creation_date = text
+      end
+      @curr_text = ''
+    end
+
+    def text(text)
+        @curr_text += text
+    end
+
+    def xmldecl(version, encoding, standalone)
+      # ignore
+    end
+
+    # get ready for another parse
+    def reset
+      @entries = []
+      @owner = nil
+      @curr_bucket = nil
+      @curr_text = ''
+    end
+  end
+
+  class ErrorResponseParser
+    attr_reader :code
+
+    def self.parse(msg)
+        parser = ErrorResponseParser.new
+        REXML::Document.parse_stream(msg, parser)
+        parser.code
+    end
+
+    def initialize
+      @state = :init
+      @code = nil
+    end
+
+    def tag_start(name, attributes)
+      case @state
+      when :init
+        if name == 'Error'
+          @state = :tag_error
+        else
+          @state = :bad
+        end
+      when :tag_error
+        if name == 'Code'
+          @state = :tag_code
+          @code = ''
+        else
+          @state = :bad
+        end
+      end
+    end
+
+    # we have one, add him to the entries list
+    def tag_end(name)
+      case @state
+      when :tag_code
+        @state = :done
+      end
+    end
+
+    def text(text)
+      @code += text if @state == :tag_code
+    end
+
+    def xmldecl(version, encoding, standalone)
+      # ignore
+    end
+  end
+
+  class LocationParser
+    attr_reader :location
+
+    def self.parse(msg)
+        parser = LocationParser.new
+        REXML::Document.parse_stream(msg, parser)
+        return parser.location
+    end
+
+    def initialize
+      @state = :init
+      @location = nil
+    end
+
+    def tag_start(name, attributes)
+      if @state == :init
+        if name == 'LocationConstraint'
+          @state = :tag_locationconstraint
+          @location = ''
+        else
+          @state = :bad
+        end
+      end
+    end
+
+    # we have one, add him to the entries list
+    def tag_end(name)
+      case @state
+      when :tag_locationconstraint
+        @state = :done
+      end
+    end
+
+    def text(text)
+      @location += text if @state == :tag_locationconstraint
+    end
+
+    def xmldecl(version, encoding, standalone)
+      # ignore
+    end
+  end
+
+  class Response
+    attr_reader :http_response
+    def initialize(response)
+      @http_response = response
+    end
+    
+    def message
+      if @http_response.body
+        @http_response.body
+      else
+        "#{@http_response.code} #{@http_response.message}"
+      end
+    end
+  end
+
+  class Bucket
+    attr_accessor :name
+    attr_accessor :creation_date
+  end
+
+  class GetResponse < Response
+    attr_reader :object
+    def initialize(response)
+      super(response)
+      metadata = get_aws_metadata(response)
+      data = response.body
+      @object = S3Object.new(data, metadata)
+    end
+
+    # parses the request headers and pulls out the s3 metadata into a hash
+    def get_aws_metadata(response)
+      metadata = {}
+      response.each do |key, value|
+        if key =~ /^#{METADATA_PREFIX}(.*)$/oi
+          metadata[$1] = value
+        end
+      end
+      return metadata
+    end
+  end
+
+  class ListBucketResponse < Response
+    attr_reader :properties
+    attr_reader :entries
+    attr_reader :common_prefix_entries
+
+    def initialize(response)
+      super(response)
+      if response.is_a? Net::HTTPSuccess
+        parser = ListBucketParser.new
+        REXML::Document.parse_stream(response.body, parser)
+        @properties = parser.properties
+        @entries = parser.entries
+        @common_prefix_entries = parser.common_prefixes
+      else
+        @entries = []
+      end
+    end
+  end
+
+  class ListAllMyBucketsResponse < Response
+    attr_reader :entries
+    def initialize(response)
+      super(response)
+      if response.is_a? Net::HTTPSuccess
+        parser = ListAllMyBucketsParser.new
+        REXML::Document.parse_stream(response.body, parser)
+        @entries = parser.entries
+      else
+        @entries = []
+      end
+    end
+  end
+
+  class LocationResponse < Response
+    attr_reader :location
+
+    def initialize(response)
+      super(response)
+      if response.is_a? Net::HTTPSuccess
+        @location = LocationParser.parse(response.body)
+      end
+    end
+  end
+end

data/lib/redmine_s3/attachment_patch.rb

@@ -0,0 +1,42 @@
+module RedmineS3
+  module AttachmentPatch
+    def self.included(base) # :nodoc:
+      base.extend(ClassMethods)
+      base.send(:include, InstanceMethods)
+ 
+      # Same as typing in the class 
+      base.class_eval do
+        unloadable # Send unloadable so it will not be unloaded in development
+        attr_accessor :s3_access_key_id, :s3_secret_acces_key, :s3_bucket, :s3_bucket
+        after_validation :put_to_s3
+        before_destroy   :delete_from_s3
+      end
+    end
+    
+    module ClassMethods
+    end
+    
+    module InstanceMethods
+      def put_to_s3
+        if @temp_file && (@temp_file.size > 0)
+          logger.debug("Uploading to #{RedmineS3::Connection.uri}/#{path_to_file}")
+          RedmineS3::Connection.put(path_to_file, @temp_file.read)
+          RedmineS3::Connection.publicly_readable!(path_to_file)
+          md5 = Digest::MD5.new
+          self.digest = md5.hexdigest
+        end
+        @temp_file = nil # so that the model's original after_save block skips writing to the fs
+      end
+
+      def delete_from_s3
+        logger.debug("Deleting #{RedmineS3::Connection.uri}/#{path_to_file}")
+        RedmineS3::Connection.delete(path_to_file)
+      end
+
+      def path_to_file
+        # obscure the filename by using the timestamp for the 'directory'
+        disk_filename.split('_').first + '/' + disk_filename
+      end
+    end
+  end
+end

data/lib/redmine_s3/attachments_controller_patch.rb

@@ -0,0 +1,27 @@
+module RedmineS3
+  module AttachmentsControllerPatch
+    def self.included(base) # :nodoc:
+      base.extend(ClassMethods)
+      base.send(:include, InstanceMethods)
+ 
+      # Same as typing in the class 
+      base.class_eval do
+        unloadable # Send unloadable so it will not be unloaded in development
+        before_filter :redirect_to_s3, :except => :destroy
+        skip_before_filter :file_readable
+      end
+    end
+    
+    module ClassMethods
+    end
+    
+    module InstanceMethods
+      def redirect_to_s3
+        if @attachment.container.is_a?(Version) || @attachment.container.is_a?(Project)
+          @attachment.increment_download
+        end
+        redirect_to("#{RedmineS3::Connection.uri}/#{@attachment.path_to_file}")
+      end
+    end
+  end
+end

data/lib/redmine_s3/connection.rb

@@ -0,0 +1,60 @@
+require 'S3'
+module RedmineS3
+  class Connection
+    @@access_key_id     = nil
+    @@secret_acces_key  = nil
+    @@bucket            = nil
+    @@uri               = nil
+    @@conn              = nil
+    
+    def self.load_options
+      options = YAML::load( File.open(File.join(Rails.root, 'config', 's3.yml')) )
+      @@access_key_id     = options[Rails.env]['access_key_id']
+      @@secret_acces_key  = options[Rails.env]['secret_access_key']
+      @@bucket            = options[Rails.env]['bucket']
+
+      if options[Rails.env]['cname_bucket'] == true
+        @@uri = "http://#{@@bucket}"
+      else
+        @@uri = "http://s3.amazonaws.com/#{@@bucket}"
+      end
+    end
+
+    def self.establish_connection
+      load_options unless @@access_key_id && @@secret_acces_key
+      @@conn = S3::AWSAuthConnection.new(@@access_key_id, @@secret_acces_key, false)
+    end
+
+    def self.conn
+      @@conn || establish_connection
+    end
+
+    def self.bucket
+      load_options unless @@bucket
+      @@bucket
+    end
+
+    def self.uri
+      load_options unless @@uri
+      @@uri
+    end
+
+    def self.create_bucket
+      conn.create_bucket(bucket).http_response.message
+    end
+
+    def self.put(filename, data)
+      conn.put(bucket, filename, data)
+    end
+
+    def self.publicly_readable!(filename)
+      acl_xml = conn.get_acl(bucket, filename).object.data
+      updated_acl = S3Helper.set_acl_public_read(acl_xml)
+      conn.put_acl(bucket, filename, updated_acl).http_response.message
+    end
+
+    def self.delete(filename)
+      conn.delete(bucket, filename)
+    end
+  end
+end

data/lib/s3_helper.rb

@@ -0,0 +1,111 @@
+require 'S3'
+require 'rexml/document' # for ACL Document manipulation
+
+module S3Helper
+
+include REXML
+
+  # returns public URL for key
+  def public_link(bucket_name, key='')
+    url = File.join('http://', S3::DEFAULT_HOST, bucket_name, key)
+    str = link_to(key, url)
+    str
+  end
+  
+  # sets an ACL to public-read
+  def self.set_acl_public_read(acl_doc)
+        # create Document
+        doc = Document.new(acl_doc)
+  
+        # get AccessControlList node
+        acl_node = XPath.first(doc, '//AccessControlList')
+  
+        # delete existing 'AllUsers' Grantee
+        acl_node.delete_element "//Grant[descendant::URI[text()='http://acs.amazonaws.com/groups/global/AllUsers']]"
+  
+        # create a new READ grant node
+        grant_node = Element.new('Grant')
+        grantee = Element.new('Grantee')
+        grantee.attributes['xmlns:xsi'] = 'http://www.w3.org/2001/XMLSchema-instance'
+        grantee.attributes['xsi:type'] = 'Group'
+  
+        uri = Element.new('URI')
+        uri << Text.new('http://acs.amazonaws.com/groups/global/AllUsers')
+        grantee.add_element(uri)
+        grant_node.add_element(grantee)
+        
+        perm = Element.new('Permission')
+        perm << Text.new('READ')
+        grant_node.add_element(perm)
+  
+        # attach the new READ grant node
+        acl_node.add_element(grant_node)
+  
+        return doc.to_s
+  end
+
+  # sets an ACL to private
+  def self.set_acl_private(acl_doc)
+        # create Document
+        doc = Document.new(acl_doc)
+  
+        # get AccessControlList node
+        acl_node = XPath.first(doc, '//AccessControlList')
+  
+        # delete existing 'AllUsers' Grantee
+        acl_node.delete_element "//Grant[descendant::URI[text()='http://acs.amazonaws.com/groups/global/AllUsers']]"
+  
+        return doc.to_s
+  end
+
+  # sets an ACL to public-read-write
+  def self.set_acl_public_read_write(acl_doc)
+        # create Document
+        doc = Document.new(acl_doc)
+  
+        # get AccessControlList node
+        acl_node = XPath.first(doc, '//AccessControlList')
+  
+        # delete existing 'AllUsers' Grantee
+        acl_node.delete_element "//Grant[descendant::URI[text()='http://acs.amazonaws.com/groups/global/AllUsers']]"
+  
+        # create a new READ grant node
+        grant_node = Element.new('Grant')
+        grantee = Element.new('Grantee')
+        grantee.attributes['xmlns:xsi'] = 'http://www.w3.org/2001/XMLSchema-instance'
+        grantee.attributes['xsi:type'] = 'Group'
+  
+        uri = Element.new('URI')
+        uri << Text.new('http://acs.amazonaws.com/groups/global/AllUsers')
+        grantee.add_element(uri)
+        grant_node.add_element(grantee)
+        
+        perm = Element.new('Permission')
+        perm << Text.new('READ')
+        grant_node.add_element(perm)
+  
+        # attach the new grant node
+        acl_node.add_element(grant_node)
+  
+        # create a new WRITE grant node
+        grant_node = Element.new('Grant')
+        grantee = Element.new('Grantee')
+        grantee.attributes['xmlns:xsi'] = 'http://www.w3.org/2001/XMLSchema-instance'
+        grantee.attributes['xsi:type'] = 'Group'
+  
+        uri = Element.new('URI')
+        uri << Text.new('http://acs.amazonaws.com/groups/global/AllUsers')
+        grantee.add_element(uri)
+        grant_node.add_element(grantee)
+        
+        perm = Element.new('Permission')
+        perm << Text.new('WRITE')
+        grant_node.add_element(perm)
+  
+        # attach the new grant tree
+        acl_node.add_element(grant_node)
+  
+        return doc.to_s
+  end
+  
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + "/../init"

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+# Load the normal Rails helper
+require File.expand_path(File.dirname(__FILE__) + '/../../../../test/test_helper')
+
+# Ensure that we are using the temporary fixture path
+Engines::Testing.set_fixture_path

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: edavis10-redmine_s3
+version: !ruby/object:Gem::Version 
+  version: 0.0.3
+platform: ruby
+authors: 
+- Christopher Dell
+- Eric Davis
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-23 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Plugin to have Redmine store uploads on S3
+email: edavis@littlestreamsoftware.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- Rakefile
+- VERSION
+- config/locales/en.yml
+- config/s3.yml.example
+- init.rb
+- lang/en.yml
+- lib/S3.rb
+- lib/redmine_s3/attachment_patch.rb
+- lib/redmine_s3/attachments_controller_patch.rb
+- lib/redmine_s3/connection.rb
+- lib/s3_helper.rb
+- rails/init.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://projects.tigrish.com/projects/redmine-s3
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: littlestreamsoftware
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Plugin to have Redmine store uploads on S3
+test_files: 
+- test/test_helper.rb