rcarvalho-happening 0.2.5.1

data/CHANGELOG.md

@@ -0,0 +1,28 @@
+Changelog
+=============
+
+- Ability to get objects in bucket
+
+0.2.5.1
+
+- re-license under Apache 2.0
+
+0.2.5
+
+- fix building
+
+0.2.3
+
+- yank older version
+
+0.2.2
+
+- Refactor version and build code
+
+0.2.1
+
+- Return the response object on get so that the data can be streamed [carlism]
+
+0.2.0
+
+- Initial release

data/Gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+gem "em-http-request"
+
+group :development do
+  gem "shoulda", ">= 0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.4"
+  gem "mocha"
+end

data/LICENSE.txt

@@ -0,0 +1,13 @@
+Copyright 2010-2011 Peritor GmbH
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,206 @@
+Amazon S3 Ruby library that leverages [EventMachine](http://rubyeventmachine.com/) and [em-http-request](http://github.com/igrigorik/em-http-request).
+
+By using EventMachine Happening does not block on S3 downloads/uploads thus allowing for a higher concurrency.
+
+Happening was developed by [Peritor](http://www.peritor.com) for usage inside Nanite/EventMachine. 
+Alternatives like RightAws block during the HTTP calls thus blocking the Nanite-Agent.
+
+For now it only supports GET, PUT and DELETE operations on S3 items. The PUT operations support S3 ACLs/permissions.
+Happening will handle redirects and retries on errors by default.
+
+Installation
+============
+
+    gem install happening
+
+Usage
+=============
+
+    require 'happening'
+    
+    EM.run do
+      item = Happening::S3::Item.new('bucket', 'item_id')
+      item.get # non-authenticated download, works only for public-read content
+    
+      item = Happening::S3::Item.new('bucket', 'item_id', :aws_access_key_id => 'Your-ID', :aws_secret_access_key => 'secret')
+      item.get # authenticated download
+      
+      item.put("The new content")
+      
+      item.delete
+    end
+    
+The above examples are a bit useless, as you never get any content back. 
+You need to specify a callback that interacts with the http response:
+
+    EM.run do
+      item = Happening::S3::Item.new('bucket', 'item_id', :aws_access_key_id => 'Your-ID', :aws_secret_access_key => 'secret')
+      item.get do |response|
+        puts "the response content is: #{response.response}"
+        EM.stop
+      end
+    end
+    
+This will enqueue your download and run it in the EventMachine event loop.
+
+You can also react to errors:
+
+    EM.run do
+      on_error = Proc.new {|response| puts "An error occured: #{response.response_header.status}"; EM.stop }
+      item = Happening::S3::Item.new('bucket', 'item_id', :aws_access_key_id => 'Your-ID', :aws_secret_access_key => 'secret')
+      item.get(:on_error => on_error) do |response|
+        puts "the response content is: #{response.response}" 
+        EM.stop
+      end
+    end
+
+If you don't supply an error handler yourself, Happening will be default raise an Exception.
+
+Downloading many files could look like this:
+
+    EM.run do
+      count = 100
+      on_error = Proc.new {|http| puts "An error occured: #{http.response_header.status}"; EM.stop if count <= 0}
+      on_success = Proc.new {|http| puts "the response is: #{http.response}"; EM.stop if count <= 0}
+      
+      count.times do |i|
+        item = Happening::S3::Item.new('bucket', "item_#{i}", :aws_access_key_id => 'Your-ID', :aws_secret_access_key => 'secret')
+        item.get(:on_success => on_success, :on_error => on_error)
+      end
+    end
+    
+Upload
+=============
+
+Happening supports the simple S3 PUT upload:    
+  
+    EM.run do
+      on_error = Proc.new {|http| puts "An error occured: #{http.response_header.status}"; EM.stop }
+      item = Happening::S3::Item.new('bucket', 'item_id', :aws_access_key_id => 'Your-ID', :aws_secret_access_key => 'secret', :on_success => on_success, :on_error => on_error)
+      item.put( File.read('/etc/passwd'), :on_error => on_error ) do |response|
+        puts "Upload finished!"; EM.stop 
+      end
+    end
+    
+Setting permissions looks like this:
+
+    EM.run do
+      on_error = Proc.new {|http| puts "An error occured: #{http.response_header.status}"; EM.stop }
+      on_success = Proc.new {|http| puts "the response is: #{http.response}"; EM.stop }
+      item = Happening::S3::Item.new('bucket', 'item_id', :aws_access_key_id => 'Your-ID', :aws_secret_access_key => 'secret', :permissions => 'public-write')
+      item.get(:on_success => on_success, :on_error => on_error)
+    end
+    
+Custom headers:
+
+    EM.run do
+      on_error = Proc.new {|http| puts "An error occured: #{http.response_header.status}"; EM.stop }
+      on_success = Proc.new {|http| puts "the response is: #{http.response}"; EM.stop }
+      item = Happening::S3::Item.new('bucket', 'item_id', :aws_access_key_id => 'Your-ID', :aws_secret_access_key => 'secret', :permissions => 'public-write')
+      item.put(:on_success => on_success, 
+               :on_error => on_error, 
+               :headers => {
+                 'Cache-Control' => "max-age=252460800", 
+                 'Content-Type' => 'text/html', 
+                 'Expires' => 'Fri, 16 Nov 2018 22:09:29 GMT', 
+                 'x-amz-meta-abc' => 'ABC'
+                })
+    end
+
+
+Deleting
+=============
+
+Happening support the simple S3 PUT upload:    
+  
+    EM.run do
+      on_error = Proc.new {|response| puts "An error occured: #{response.response_header.status}"; EM.stop }
+      item = Happening::S3::Item.new('bucket', 'item_id', :aws_access_key_id => 'Your-ID', :aws_secret_access_key => 'secret')
+      item.delete(:on_error => on_error) do |response|
+        puts "Deleted!"
+        EM.stop
+      end
+    end
+
+Amazon returns no content on delete, so having a success handler is usually not needed for delete operations.
+
+Head
+=============
+
+You can also just load the headers of an S3 item:
+  
+    EM.run do
+      on_error = Proc.new {|response| puts "An error occured: #{response.response_header.status}"; EM.stop }
+      item = Happening::S3::Item.new('bucket', 'item_id', :aws_access_key_id => 'Your-ID', :aws_secret_access_key => 'secret')
+      item.head(:on_error => on_error) do |response|
+        puts "Headers: #{response.inspect}"
+        EM.stop
+      end
+    end
+
+
+    
+Streaming
+=============
+
+The response data can also be streamed:    
+  
+    EM.run do
+      item = Happening::S3::Item.new( bucket...
+	  item.get(:on_error => on_error, :on_success => on_success ).stream do |chunk|
+	    # .. handle the individual chunk          
+	  end
+    end
+    
+List Objects in Bucket
+=======================
+  
+    EM.run do
+      bucket = Happening::S3::Bucket.new('bucket', :aws_access_key_id => 'Your-ID', :aws_secret_access_key => 'secret')
+      bucket.get do |response|
+        puts "Response content: #{response.response}"
+      end
+    end
+
+
+SSL Support
+=============
+
+Happening will use SSL/HTTPS by default. What it cannot do by default is verify the SSL certificate. This means 
+that traffic is encrypted but nobody can say if the SSL-endpoint is the one you except. In order to verify the 
+SSL certificate you need to provide Happening with the path to a certificate CA collection in PEM format:
+
+    Happening::S3.ssl_options[:cert_chain_file] = '/etc/ca-bundle.crt'
+    
+You can also set this option on each item:
+
+    Happening::S3::Item.new('bucket', 'item_id', 
+      :aws_access_key_id => 'A', 
+      :aws_secret_access_key => 'B',
+      :ssl => {
+        :cert_chain_file => '/etc/ca-bundle.crt'
+      }
+      
+Or even on the request:
+
+    item.get(:ssl => {:cert_chain_file => '/etc/ca-bundle.crt'})
+    
+The SSL options are directly passed to EventMachine, see the [EventMachine documentation](http://eventmachine.rubyforge.org/EventMachine/Connection.html#M000296) for more information on the SSL support.
+
+
+Credits
+=============
+
+The AWS signing and canonical request description is based on [RightAws](http://github.com/rightscale/right_aws).
+    
+    
+License
+=============
+
+Happening is licensed under the Apache 2.0 license. See LICENSE.txt
+
+
+About
+=============
+
+Happening was written by [Jonathan Weiss](http://twitter.com/jweiss) for [Peritor](http://www.peritor.com).

data/Rakefile

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+require File.expand_path("./lib/happening")
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "happening"
+  gem.homepage = "http://github.com/peritor/happening"
+  gem.license = "BSD"
+  gem.summary = %Q{An EventMachine based S3 client }
+  gem.description = %Q{An EventMachine based S3 client }
+  gem.email = "jw@innerewut.de"
+  gem.authors = ["Jonathan Weiss"]
+  gem.version = Happening::VERSION
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = "test/**/*_test.rb"
+  t.verbose = true
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "hello-gem #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/benchmark/right_aws.rb

@@ -0,0 +1,106 @@
+require File.dirname(__FILE__) + '/../happening'
+
+require 'benchmark'
+require 'right_aws'
+
+AWS_ACCESS_KEY_ID = ENV['AWS_ACCESS_KEY_ID'] or raise "please set AWS_ACCESS_KEY_ID='your-key'"
+AWS_SECRET_ACCESS_KEY = ENV['AWS_SECRET_ACCESS_KEY'] or raise "please set AWS_SECRET_ACCESS_KEY='your-scret'"
+
+BUCKET = 'happening-benchmark'
+FILE   = 'the_file_name'
+PROTOCOL = 'https'
+
+COUNT = 100
+CONTENT = File.read('/tmp/VzLinuxUG.pdf')
+
+command = ARGV.first || 'get'
+
+puts "running command: #{command}"
+
+if command == 'get'
+  Benchmark.bm(7) do |x|
+    x.report("RightAWS - Get an item") do
+      count = COUNT
+      s3 = RightAws::S3Interface.new(AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, :protocol => PROTOCOL)
+      count.times do |i|
+        s3.get_object(BUCKET, FILE)
+        print '.'; $stdout.flush
+      end
+    end
+  
+    puts ""
+    x.report("Happening - Get an item") do 
+      puts ""
+      count = COUNT
+      on_success = Proc.new do |http|
+        print '.'; $stdout.flush
+        count = count - 1
+        EM.stop if count <= 0
+      end
+
+      on_error = Proc.new do |http|
+        puts "Status: #{http.response_header.status}"
+        puts "Header: #{http.response_header.inspect}"
+        puts "Content:"
+        puts http.response.inspect + "\n"
+        count = count - 1
+        EM.stop if count <= 0
+      end
+    
+      EM.run do
+        count.times do |i|
+          item = Happening::S3::Item.new(BUCKET, FILE, :protocol => PROTOCOL, :on_success => on_success, :on_error => on_error)
+          item.get
+        end
+      end
+    end  
+  end
+
+elsif command == 'put'
+  Benchmark.bm(7) do |x|
+    x.report("RightAWS - Put an item") do
+      count = COUNT
+      s3 = RightAws::S3Interface.new(AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, :protocol => PROTOCOL)
+      count.times do |i|
+        s3.put(BUCKET, "upload_test_right_aws_#{i}", CONTENT)
+        print '.'; $stdout.flush
+      end
+    end
+  
+    puts ""
+    x.report("Happening - Put an item") do 
+      puts ""
+      count = COUNT
+      on_success = Proc.new do |http|
+        #puts "Success"
+        puts "Status: #{http.response_header.status}" unless http.response_header.status == 200
+        #puts "Header: #{http.response_header.inspect}"
+        #puts "Content:"
+        #puts http.response.inspect + "\n"
+        print '.'; $stdout.flush
+        count = count - 1
+        EM.stop if count <= 0
+      end
+
+      on_error = Proc.new do |http|
+        puts "Error"
+        puts "Status: #{http.response_header.status}"
+        puts "Header: #{http.response_header.inspect}"
+        puts "Content:"
+        puts http.response.inspect + "\n"
+        count = count - 1
+        EM.stop if count <= 0
+      end
+    
+      EM.run do        
+        count.times do |i|
+          item = Happening::S3::Item.new(BUCKET, "upload_test_happening_#{i}", :protocol => PROTOCOL, :on_success => on_success, :on_error => on_error, :aws_access_key_id => AWS_ACCESS_KEY_ID, :aws_secret_access_key => AWS_SECRET_ACCESS_KEY)
+          item.put(CONTENT)
+        end
+      end
+    end  
+  end
+
+else
+  puts "unknown command: #{command}"  
+end

data/happening.gemspec

@@ -0,0 +1,70 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rcarvalho-happening}
+  s.version = "0.2.5.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = [%q{Jonathan Weiss}]
+  s.date = %q{2012-07-26}
+  s.description = %q{An EventMachine based S3 client }
+  s.email = %q{jw@innerewut.de}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    "CHANGELOG.md",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "benchmark/right_aws.rb",
+    "happening.gemspec",
+    "lib/happening.rb",
+    "lib/happening/aws.rb",
+    "lib/happening/log.rb",
+    "lib/happening/s3.rb",
+    "lib/happening/s3/item.rb",
+    "lib/happening/s3/request.rb",
+    "lib/happening/utils.rb",
+    "test/aws_test.rb",
+    "test/s3/item_test.rb",
+    "test/s3/request_test.rb",
+    "test/s3_test.rb",
+    "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/peritor/happening}
+  s.licenses = [%q{BSD}]
+  s.require_paths = [%q{lib}]
+  s.rubygems_version = %q{1.8.7}
+  s.summary = %q{An EventMachine based S3 client}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<em-http-request>, [">= 0"])
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
+    else
+      s.add_dependency(%q<em-http-request>, [">= 0"])
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_dependency(%q<mocha>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<em-http-request>, [">= 0"])
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+    s.add_dependency(%q<mocha>, [">= 0"])
+  end
+end
+

data/lib/happening/aws.rb

@@ -0,0 +1,65 @@
+require 'time'
+module Happening
+  class AWS
+    include Utils
+    
+    AMAZON_HEADER_PREFIX   = 'x-amz-'
+    AMAZON_METADATA_PREFIX = 'x-amz-meta-'
+    DIGEST = OpenSSL::Digest.new('sha1')
+    
+    attr_accessor :aws_access_key_id, :aws_secret_access_key
+    
+    def initialize(aws_access_key_id, aws_secret_access_key)
+      @aws_access_key_id = aws_access_key_id
+      @aws_secret_access_key = aws_secret_access_key
+      raise ArgumentError, "need AWS Access Key Id and AWS Secret Key" if blank?(aws_access_key_id) || blank?(aws_secret_access_key)
+    end
+    
+    def sign(method, path, headers={})
+      headers = {
+        'date' => utc_httpdate
+      }.update(headers)
+      
+      request_description = canonical_request_description(method, path, headers)
+      headers.update("Authorization" => "AWS #{aws_access_key_id}:#{generate_signature(request_description)}")
+    end
+    
+  protected
+        
+    def utc_httpdate
+      Time.now.utc.httpdate
+    end
+
+    def generate_signature(request_description)
+      Base64.encode64(OpenSSL::HMAC.digest(DIGEST, aws_secret_access_key, request_description)).strip
+    end
+    
+    def canonical_request_description(method, path, headers = {}, expires = nil)
+      s3_attributes = {}
+      headers.each do |key, value|
+        key = key.downcase
+        s3_attributes[key] = value.to_s.strip if key.match(/^#{AMAZON_HEADER_PREFIX}|^content-md5$|^content-type$|^date$/o)
+      end
+      s3_attributes['content-type'] ||= ''
+      s3_attributes['content-md5']  ||= ''
+      s3_attributes['date'] = '' if s3_attributes.has_key?('x-amz-date')
+      s3_attributes['date'] = expires if expires
+
+      description = "#{method}\n"
+      s3_attributes.sort { |a, b| a[0] <=> b[0] }.each do |key, value|
+        description << (key.match(/^#{AMAZON_HEADER_PREFIX}/o) ? "#{key}:#{value}\n" : "#{value}\n")
+      end
+      
+      # ignore all parameters by default
+      description << path.gsub(/\?.*$/, '')
+      
+      # handle amazon parameters
+      description << '?acl'      if path[/[&?]acl($|&|=)/]
+      description << '?torrent'  if path[/[&?]torrent($|&|=)/]
+      description << '?location' if path[/[&?]location($|&|=)/]
+      description << '?logging'  if path[/[&?]logging($|&|=)/]
+      description
+    end
+    
+  end
+end

data/lib/happening/log.rb

@@ -0,0 +1,40 @@
+module Happening
+  class Log
+    
+    @@logger = Logger.new(STDOUT)
+    @@logger.level = Logger::ERROR
+    
+    def self.logger=(log)
+      @@logger = log
+    end
+    
+    def self.logger
+      @@logger
+    end
+    
+    def self.level=(lev)
+      logger.level = lev
+    end
+    
+    def self.level
+      logger.level
+    end
+    
+    def self.debug(msg)
+      logger.debug("Happening: #{msg}")
+    end
+    
+    def self.info(msg)
+      logger.debug("Happening: #{msg}")
+    end
+    
+    def self.warn(msg)
+      logger.debug("Happening: #{msg}")
+    end
+    
+    def self.error(msg)
+      logger.debug("Happening: #{msg}")
+    end
+    
+  end
+end