yore 0.0.11 → 0.1.0

data/README.rdoc

@@ -1,6 +1,6 @@
 = yore
 
-* RubyForge Project : http://rubyforge.org/projects/buzzware
+* GitHub Project : http://github.com/buzzware/yore
 * Author : http://www.buzzware.com.au
 
 == DESCRIPTION:
@@ -28,16 +28,19 @@ can be manually configured.
 
 Amazon S3
 
-* Yore relies on s3cmd for S3 access which is contained in the s3sync gem.  
-s3cmd must be configured with keys for a registered Amazon S3 account.  
-Use something like "s3cmd listbuckets" to check that you have that setup 
-correctly before launching yore.  
+* You can and probably should create a seperate Amazon S3 account for backups. Unfortunately 
+you will need to supply your credit card details for this account, event though only your main
+account will be charged. 
 
-* You can and probably should create a seperate Amazon account for 1 or more web servers, 
-and then grant write access to a single bucket for their use, rather than using your main
-S3 keys. You don't need to supply your credit card details for this account - your main 
-account will be charged. This avoids your main Amazon AWS keys getting stolen by someone 
-hacking into the webserver, or even other legitimate users using them.
+Sadly you can't get a useable S3 account without giving them your credit card information,
+even if you never plan to create your own buckets. Build a bridge, get over it and sign 
+up at http://aws.amazon.com/s3/. Then when you have logged in to the AWS website, go to 
+"Your Account" -> "Security Credentials"
+to get an "Access Key ID" and click Show to get its "Secret Access Key"
+
+* Create a bucket with backup permissions for an AWS account
+
+yore new_backup_bucket --backup_email "blah@buzzware.com.au" testbucket
 
 == SYNOPSIS:
 
@@ -48,8 +51,8 @@ eg.
 
 == REQUIREMENTS:
 
-* s3sync (http://rubyforge.org/projects/s3sync/)
-* RequirePaths (http://rubyforge.org/projects/blackwhitelogin)
+* AWS S3 (http://github.com/marcel/aws-s3)
+* buzzcore (http://github.com/buzzware/buzzcore)
 * cmdparse (http://cmdparse.rubyforge.org)
 * shairontoledo-popen4 (http://github.com/shairontoledo/popen4)
 * tar, bzip2, openssl, mysql

data/VERSION

@@ -1 +1 @@
-0.0.11
+0.1.0

data/bin/yore

@@ -69,6 +69,15 @@ encrypt_decrypt_option_parser = CmdParse::OptionParserWrapper.new do |opt|
   #end
 end
 
+new_backup_bucket_option_parser = CmdParse::OptionParserWrapper.new do |opt|
+  opt.on( '--backup_id=S3 Access Key ID', String, 'S3 Access Key ID from Amazon' ) do |value|
+    CMD_OPTIONS[:backup_id] = value
+  end
+  opt.on( '--backup_email=AWS Account Email Address', String, 'AWS Account Email Address from Amazon' ) do |value|
+    CMD_OPTIONS[:backup_email] = value
+  end
+end
+
 command(cmd,yore,:backup,"Backup filelist to S3",option_parser)
 
 command(cmd,yore,:save,"Save application data to local file",load_save_option_parser)
@@ -83,6 +92,8 @@ command(cmd,yore,:test_email,"Test email sending\n")
 
 command(cmd,yore,:db_dump,"Dump database by name in job\n")
 
+command(cmd,yore,:new_backup_bucket,"Create a new bucket with permissions for backup\n",new_backup_bucket_option_parser)
+
 cmd.parse
 
 yore.logger.info "\nComplete.\n"

data/lib/yore/AWSS3Client.rb

@@ -0,0 +1,129 @@
+require 'fileutils'
+
+gem 'buzzcore'; require 'buzzcore';
+gem 'aws-s3'; require 'aws/s3'
+
+# although this is implemented as an instantiable object, not a singleton,
+# the AWS gem seems to operate as a singleton, so don't create more than one of these.
+class AWSS3Client
+
+	attr_accessor :credentials
+
+	def initialize(aCredentials=nil)
+		@credentials = aCredentials || Credentials.new()
+		connect
+	end
+
+	def connect(aId=nil,aKey=nil)
+		aId ||= @credentials[:s3_access_key_id]
+		aKey ||= @credentials[:s3_secret_access_key]
+		AWS::S3::Base.establish_connection!(
+			:access_key_id     => aId,
+			:secret_access_key => aKey
+		)
+	end
+
+	def bucket(aName)
+		return AWS::S3::Bucket.find(aName)
+	end
+
+	def bucket_exists?(aName)	
+		AWS::S3::Bucket.find(aName)
+		true
+	rescue
+		false	
+	end
+
+	def ensure_clean_bucket(aName)
+		AWS::S3::Bucket.delete(aName, :force => true) if bucket_exists?(aName)
+		AWS::S3::Bucket.create(aName)
+		AWS::S3::Bucket.find(aName)
+	end
+
+	# ensures the destination bucket exists with the right permissions for upload_backup
+	# eg. @s3client.ensure_backup_bucket('a_bucket',{'email_address' => 'user@domain.com'})
+	def ensure_backup_bucket(aBucketName,aOtherUserAttrs=nil)
+		AWS::S3::Bucket.create(aBucketName) unless bucket_exists?(aBucketName)
+		grant_bucket_permissions(aBucketName,%w(WRITE READ_ACP),aOtherUserAttrs,true) if aOtherUserAttrs
+	end
+	
+	def new_backup_bucket(aBucketName,aOtherUserAttrs)
+		AWS::S3::Bucket.create(aBucketName)
+		grant_bucket_permissions(aBucketName,%w(WRITE READ_ACP),aOtherUserAttrs,true)
+	end
+
+	# eg. policy = policy_add(policy,{'id' => 'dssdfsdf'},%w(READ WRITE))
+	def policy_add(aPolicy,aGranteeAttrs,aPermissions)
+		aPolicy ||= AWS::S3::ACL::Policy.new
+		grantee = AWS::S3::ACL::Grantee.new(aGranteeAttrs)
+		grantee.display_name ||= 'display_name'
+		aPermissions.each do |p|
+			grant = AWS::S3::ACL::Grant.new
+			grant.permission = p
+			grant.grantee = grantee
+			aPolicy.grants << grant
+		end
+		aPolicy
+	end
+
+	def grant_bucket_permissions(aBucketName,aPermissions,aGranteeAttrs,aMerge = false)
+		policy = (aMerge ? AWS::S3::Bucket.acl(aBucketName) : nil)
+		policy = policy_add(policy,aGranteeAttrs,aPermissions)
+		policy.owner ||= Owner.current
+		AWS::S3::Bucket.acl(aBucketName,policy)
+		policy
+	end
+
+ 	def grant_object_permissions(aBucketName,aObjectName,aPermissions,aGranteeAttrs,aMerge = false)
+		policy = (aMerge ? AWS::S3::S3Object.acl(aObjectName,aBucketName) : nil)
+		policy = policy_add(policy,aGranteeAttrs,aPermissions)
+		policy.owner ||= Owner.current
+		AWS::S3::S3Object.acl(aObjectName,aBucketName,policy)  #S3Object.acl('kiss.jpg', 'marcel')
+		policy
+	end
+
+	def put_content(aFilename, aContent, aBucketName)
+		AWS::S3::S3Object.store(aFilename, aContent, aBucketName)
+	end
+	
+	def upload(aFilename,aBucketName,aObjectName=nil)
+		aObjectName ||= File.basename(aFileName)
+		#AWS::S3::S3Object.store(aObjectName, MiscUtils.string_from_file(aFileName), aBucketName)
+		content = MiscUtils.string_from_file(aFileName)
+
+		put_content(aObjectName, content, aBucketName)
+	end	
+	
+	def get_content(aFilename, aBucketName)	
+		return AWS::S3::S3Object.value(aFilename, aBucketName)
+	end
+
+	def download(aFilename,aBucketName,aObjectName=nil)
+		aObjectName ||= File.basename(aFilename)
+		#AWS::S3::S3Object.store(aObjectName, MiscUtils.string_from_file(aFilename), aBucketName)
+		MiscUtils.string_to_file(get_content(aObjectName,aBucketName),aFilename)
+	end	
+
+	# Summary: Uploads the given file to the bucket, then gives up permissions to the bucket owner
+	# Details :
+	#	* intended to allow files to be uploaded to S3, but not allowing the files to be interfered with should 
+	#   the web server get hacked.
+	# 	In truth, S3 permissions aren't adequate and the best we can do is that the file can't be read,
+	# 	but can be written over. The user also can't get a listing of the bucket
+	# * S3 won't allow objects (or buckets) to change owner, but we do everything else ie give FULL_CONTROL,
+	# 	and remove it from self, to hand control to the bucket owner
+	# * This requires the bucket to give WRITE & READ_ACP permissions to this user
+	def upload_backup(aFileName,aBucketName,aObjectName = nil)
+		aObjectName ||= File.basename(aFileName)
+		AWS::S3::S3Object.store(aObjectName, MiscUtils.string_from_file(aFileName), aBucketName)
+		bucket_owner = AWS::S3::Bucket.acl(aBucketName).owner
+		policy = AWS::S3::S3Object.acl(aObjectName,aBucketName)
+		policy.grants.clear
+		policy = policy_add(policy,{'id' => bucket_owner.id, 'display_name' => bucket_owner.display_name},'FULL_CONTROL')
+
+		# replace policy with full control to bucket owner, none to test_user
+ 		AWS::S3::S3Object.acl(aObjectName,aBucketName,policy)
+	end
+
+end
+

data/lib/yore/yore_core.rb

@@ -4,6 +4,9 @@ gem 'buzzcore'; require 'buzzcore';
 require 'fileutils'
 require 'net/smtp'
 
+require 'yore/AWSS3Client'
+
+
 THIS_FILE = File.expand_path(__FILE__)
 THIS_DIR = File.dirname(THIS_FILE)
 
@@ -70,8 +73,10 @@ module YoreCore
   class Yore
 
     DEFAULT_CONFIG = {
-			:kind => '',
-			:basepath => '',
+			:kind => String,
+			:basepath => String,
+			:backup_id => String,
+			:backup_email => String,
       :keep_daily => 14,
       :keep_weekly => 12,
       :keep_monthly => 12,
@@ -80,26 +85,27 @@ module YoreCore
       :first_hour => 4,
       :prefix => 'backup',
       :log_level => 'INFO',
-      :bucket => '',
+      :bucket => String,
 			:email_report => false,
-      :mail_host => '',
+      :mail_host => String,
       :mail_port => 25,
-      :mail_helodomain => '',
-      :mail_user => '',
-      :mail_password => '',
-			:mail_from => '',
-			:mail_from_alias => '',
-			:mail_to => '',
-			:mail_to_alias => '',
+      :mail_helodomain => String,
+      :mail_user => String,
+      :mail_password => String,
+			:mail_from => String,
+			:mail_from_alias => String,
+			:mail_to => String,
+			:mail_to_alias => String,
 			:mail_auth => :plain,
 			:mysqldump => 'mysqldump',
-			:RAILS_ENV => ''
+			:RAILS_ENV => String
 		}
 
     attr_reader :config
     attr_reader :logger
     attr_reader :reporter
     attr_reader :keepers
+    attr_reader :s3client
 
     def initialize(aConfig=nil)
       DEFAULT_CONFIG[:email_report] = false  # fixes some bug where this was nil
@@ -256,6 +262,8 @@ module YoreCore
       @keepers << KeepDaily.new(config[:keep_daily])
       @keepers << KeepWeekly.new(config[:keep_weekly])
       @keepers << KeepMonthly.new(config[:keep_monthly])
+			
+			@s3client = ::AWSS3Client.new()
     end
 		
 		def do_action(aAction,aArgs)
@@ -275,12 +283,6 @@ module YoreCore
       return result[:stdout]
 		end
 		
-		def s3shell(aCommandline)
-			shell(aCommandline) do |r|
-				r[:exitcode] = 1 if r[:stderr].length > 0
-			end
-		end
-
     def get_log
       logger.close
       # read in log and return
@@ -364,22 +366,24 @@ module YoreCore
        shell "openssl enc -d -aes-256-cbc -K #{config[:crypto_key]} -iv #{config[:crypto_iv]} -in #{aFileIn} -out #{aFileOut}"
     end
 
-    def ensure_bucket(aBucket=nil)
+    def ensure_bucket(aBucket=nil,aUserEmail=nil)
       aBucket ||= config[:bucket]
+      aUserEmail ||= config[:bucket_user_email]
 			logger.info "Ensuring S3 bucket #{aBucket} exists ..."
-      s3shell "s3cmd createbucket #{aBucket}"
+			s3client.ensure_backup_bucket(aBucket,aUserEmail ? {'email_address' => aUserEmail} : nil)
     end
 
     # uploads the given file to the current bucket as its basename
     def upload(aFile)
       #ensure_bucket()
+			logger.debug "Uploading #{aFile} to S3 bucket #{config[:bucket]} ..."
 			logger.info "Uploading #{File.basename(aFile)} to S3 bucket #{config[:bucket]} ..."
-      s3shell "s3cmd put #{config[:bucket]}:#{File.basename(aFile)} #{aFile}"
+			s3client.upload_backup(aFile,config[:bucket],File.basename(aFile))
     end
 
     # downloads the given file from the current bucket as its basename
     def download(aFile)
-      s3shell "s3cmd get #{config[:bucket]}:#{File.basename(aFile)} #{aFile}"
+			s3client.download(aFile,config[:bucket],File.basename(aFile))
     end
 
     # calculate the date (with no time component) based on :day_begins_hour and the local time
@@ -613,6 +617,21 @@ module YoreCore
 			uncompress(temp_file,folder)
 		end
 		
+		def new_backup_bucket(aArgs)
+			bucket_name = aArgs[0]
+			if s3client.bucket_exists?(bucket_name)
+				puts "sorry, bucket already exists"
+			else
+				backup_user_attrs = {
+					'id' => config[:backup_id],
+					'display_name' => config[:backup_name] || 'backup_name',
+					'email_address' => config[:backup_email]
+				}
+				raise StandardError.new("Must provide backup_id or backup_email") unless backup_user_attrs['id'] || backup_user_attrs['email_address']
+				s3client.new_backup_bucket(bucket_name,backup_user_attrs)
+			end	
+		end
+		
 		def test_email(*aDb)
 			args = {
         :host => config[:mail_host],

data/test/AWS_gem_test.rb

@@ -0,0 +1,76 @@
+require File.expand_path('test_helper',File.dirname(__FILE__))
+
+class AWSGemTest < Test::Unit::TestCase
+
+	def setup
+		puts "setup"
+		creds = Credentials.new()
+		assert(creds[:s3_access_key_id] && creds[:s3_secret_access_key] && creds[:s3_yore_test_bucket])
+		@s3client = AWSS3Client.new(creds)
+  end	
+
+	should "login" do
+		test_bucket = @s3client.ensure_clean_bucket(@s3client.credentials[:s3_yore_test_bucket])
+		puts test_bucket.inspect
+		assert !test_bucket.nil?
+	end
+
+	should "upload, download and compare" do
+		test_bucket = @s3client.ensure_clean_bucket(@s3client.credentials[:s3_yore_test_bucket])
+		test_filename = 'up_down_compare'
+		test_content = 'abc'
+		#AWS::S3::S3Object.store(test_filename, test_content, test_bucket.name)
+		@s3client.put_content(test_filename, test_content, test_bucket.name)
+		#after_content = AWS::S3::S3Object.value test_filename, test_bucket.name
+		after_content = @s3client.get_content(test_filename, test_bucket.name)
+		assert_equal test_content, after_content
+	end
+	
+
+	should "create bucket writable (and not readable) by another user" do
+		test_user_bucket = @s3client.ensure_clean_bucket(@s3client.credentials[:s3_test_user_bucket])
+		@s3client.ensure_backup_bucket(@s3client.credentials[:s3_test_user_bucket],{'email_address' => @s3client.credentials[:s3_test_user_email]})
+
+		test_filename = 'up_down_compare'
+		test_content = 'xyz'
+		# reconnect as user
+		@s3client.connect(@s3client.credentials[:s3_test_access_id],@s3client.credentials[:s3_test_access_key])
+		temp_file = MiscUtils.make_temp_file(nil, nil, test_content)
+		@s3client.upload_backup(temp_file,@s3client.credentials[:s3_test_user_bucket],test_filename)
+		
+		# should fail reading
+		begin
+			after_content = @s3client.get_content(test_filename, @s3client.credentials[:s3_test_user_bucket])
+			flunk
+		rescue AWS::S3::ResponseError => e
+			assert_equal e.class.to_s,"AWS::S3::AccessDenied"
+		end
+
+		# should fail overwriting
+		#new_content = '123'
+		#begin
+		#	AWS::S3::S3Object.store(test_filename, new_content, @s3client.credentials[:s3_test_user_bucket])
+		#	flunk "succeeded overwriting (should fail)"
+		#rescue AWS::S3::ResponseError => e
+		#	assert_equal e.class.to_s,"AWS::S3::AccessDenied"
+		#end
+
+		# back to normal
+		@s3client.connect
+
+		test_user_bucket = @s3client.bucket(@s3client.credentials[:s3_test_user_bucket])
+		after_content = @s3client.get_content(test_filename, test_user_bucket.name)
+		assert_equal test_content, after_content
+	end
+
+	should "fail with wrong credentials" do
+		test_user_bucket = @s3client.ensure_clean_bucket(@s3client.credentials[:s3_test_user_bucket])
+		begin
+			permission = @s3client.grant_bucket_permissions(test_user_bucket,%w(WRITE READ_ACP),{'email_address' => 'asddsad@sdsddsadsa.com'},true)
+			flunk
+		rescue AWS::S3::ResponseError => e
+			assert_equal e.class.to_s,"AWS::S3::NoSuchBucket"
+		end
+	end
+
+end

data/test/S3_test.rb

@@ -1,16 +1,11 @@
-require 'rubygems'
-gem 'buzzcore'; require 'buzzcore';
-require 'yore/yore_core'
-require 'test/unit'
-gem 'Shoulda'; require 'shoulda'
-require 'fileutils'
+require File.expand_path('test_helper',File.dirname(__FILE__))
 
 def ensure_clean_bucket(aName)
   `s3cmd createbucket #{aName}`
   `s3cmd deleteall #{aName}`
 end
 
-# finwa example : yore backup /var/www/joomla/deploy-system/finwa_yore.xml >/dev/null 2>&1
+# example : yore backup /var/www/joomla/deploy-system/yore.xml >/dev/null 2>&1
 
 class S3Test < Test::Unit::TestCase
 
@@ -24,15 +19,17 @@ class S3Test < Test::Unit::TestCase
 		@yore.configure({
 			:bucket => bucket
 		})
-		content = 'this is my test content'
+		#content = 'this is my test content'
+		orig_file = File.expand_path('upload_test_content.yor',File.dirname(__FILE__))  # MiscUtils.make_temp_file(nil, temp_dir, content)
+		puts @yore.upload(orig_file)
+		#orig_file = temp_file+'.orig'
+		#File.rename(temp_file, orig_file)
 		temp_dir = MiscUtils.make_temp_dir()
-		temp_file = MiscUtils.make_temp_file(nil, temp_dir, content)
-		puts @yore.upload(temp_file)
-		orig_file = temp_file+'.orig'
-		File.rename(temp_file, orig_file)
+		temp_file = File.join(temp_dir,File.basename(orig_file))
 		puts @yore.download(temp_file)
-		down_file_content = MiscUtils.string_from_file(temp_file)
-		assert_equal content, down_file_content
+		#down_file_content = MiscUtils.string_from_file(temp_file)
+		#assert_equal content, down_file_content
+		assert_equal nil, POpen4::shell_out("/usr/bin/diff #{orig_file} #{temp_file}")[:stdout]
 	end
 
 	should "backup and restore multiple directories of file" do
@@ -56,7 +53,6 @@ class S3Test < Test::Unit::TestCase
 			MiscUtils::make_temp_file(f,source2)
 		end
 
-
 		ensure_clean_bucket(bucket)
 
 		# create job file
@@ -67,7 +63,7 @@ class S3Test < Test::Unit::TestCase
 						<Item Name="crypto_iv">3A63775C1E3F291B0925578165EB917E</Item>
 						<Item Name="crypto_key">07692FC8656F04AE5518B80D38681E038A3C12050DF6CC97CEEC33D800D5E2FE</Item>
 						<Item Name="prefix">backup</Item>
-						<Item Name="log_level">INFO</Item>
+						<Item Name="log_level">DEBUG</Item>
 						<Item Name="bucket">${BUCKET}</Item>
 				</SimpleItems>
 			<Sources>
@@ -85,11 +81,10 @@ class S3Test < Test::Unit::TestCase
 		})
 		MiscUtils::string_to_file(job_content,job_file = MiscUtils::temp_file)
 
-		# call yore script with ruby from the command line, then download result and check contents
 		begin
 			_xmlRoot = XmlUtils.get_xml_root(job_content)
 			cmd_options = {:config => job_file}
-			@yore_upload = YoreCore::Yore::launch(_xmlRoot,cmd_options,{:basepath => File.dirname(File.expand_path(job_file))})
+			@yore_upload = YoreCore::Yore::launch(_xmlRoot,cmd_options,{:basepath => File.dirname(File.expand_path(job_file)), :log_level => 'DEBUG'})
 			@yore_upload.backup([job_file])
 		rescue ::StandardError => e
 			flunk e.inspect
@@ -98,7 +93,10 @@ class S3Test < Test::Unit::TestCase
 		#puts result
 		yore = YoreCore::Yore.new()
 		yore.configure({
-			:bucket => bucket
+			:crypto_iv => "3A63775C1E3F291B0925578165EB917E",
+			:crypto_key =>"07692FC8656F04AE5518B80D38681E038A3C12050DF6CC97CEEC33D800D5E2FE",
+			:bucket => bucket,
+			:log_level => 'DEBUG'
 		})
 
 		retrieved_fname = File.expand_path(yore.encode_file_name(), dest_dir)

data/test/test_helper.rb

@@ -4,7 +4,18 @@ require 'shoulda'
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'yore'
 
 class Test::Unit::TestCase
 end
+
+require File.expand_path('../../buzzcore/lib/buzzcore_dev.rb',File.dirname(__FILE__))
+
+require_paths_first '../lib'	# prefer local yore over installed gem
+
+
+require 'yore/AWSS3Client'
+require 'yore/yore_core'
+require 'fileutils'
+
+
+

data/yore.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{yore}
-  s.version = "0.0.11"
+  s.version = "0.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["buzzware"]
-  s.date = %q{2009-10-17}
+  s.date = %q{2009-12-08}
   s.default_executable = %q{yore}
   s.description = %q{yore (as in "days of yore") is a user data management utility for web applications.}
   s.email = %q{contact@buzzware.com.au}
@@ -26,13 +26,16 @@ Gem::Specification.new do |s|
      "Rakefile",
      "VERSION",
      "bin/yore",
+     "lib/yore/AWSS3Client.rb",
      "lib/yore/yore_core.rb",
      "notes.txt",
      "test.crontab",
+     "test/AWS_gem_test.rb",
      "test/S3_test.rb",
      "test/test_helper.rb",
      "test/test_job_a.xml",
      "test/test_job_b.xml",
+     "test/upload_test_content.yor",
      "test/yore_browsercms_loadsave_test.rb",
      "test/yore_spree_loadsave_test.rb",
      "test/yore_test.rb",
@@ -47,7 +50,8 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.5}
   s.summary = %q{yore (as in "days of yore") is a user data management utility for web applications.}
   s.test_files = [
-    "test/S3_test.rb",
+    "test/AWS_gem_test.rb",
+     "test/S3_test.rb",
      "test/test_helper.rb",
      "test/yore_browsercms_loadsave_test.rb",
      "test/yore_spree_loadsave_test.rb",

data/yore.vpw

@@ -1,6 +1,7 @@
 <!DOCTYPE Workspace SYSTEM "http://www.slickedit.com/dtd/vse/10.0/vpw.dtd">
 <Workspace Version="10.0" VendorName="SlickEdit">
 	<Projects>
+		<Project File="../buzzcore/buzzcore.vpj" />
 		<Project File="yore.vpj" />
 	</Projects>
 </Workspace>

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: yore
 version: !ruby/object:Gem::Version 
-  version: 0.0.11
+  version: 0.1.0
 platform: ruby
 authors: 
 - buzzware
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-17 00:00:00 +08:00
+date: 2009-12-08 00:00:00 +08:00
 default_executable: yore
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -49,13 +49,16 @@ files:
 - Rakefile
 - VERSION
 - bin/yore
+- lib/yore/AWSS3Client.rb
 - lib/yore/yore_core.rb
 - notes.txt
 - test.crontab
+- test/AWS_gem_test.rb
 - test/S3_test.rb
 - test/test_helper.rb
 - test/test_job_a.xml
 - test/test_job_b.xml
+- test/upload_test_content.yor
 - test/yore_browsercms_loadsave_test.rb
 - test/yore_spree_loadsave_test.rb
 - test/yore_test.rb
@@ -91,6 +94,7 @@ signing_key:
 specification_version: 3
 summary: yore (as in "days of yore") is a user data management utility for web applications.
 test_files: 
+- test/AWS_gem_test.rb
 - test/S3_test.rb
 - test/test_helper.rb
 - test/yore_browsercms_loadsave_test.rb