sublimate 0.1.0 → 0.1.1

data/Readme.md

@@ -0,0 +1,32 @@
+Sublimate
+=========
+
+This is a helper library for uploading extremely large files using Fog. It splits them into chunks and uses multipart uploads on S3 or the manifest file on Rackspace Cloud.
+
+Set the following environment variables to run real, live tests (Mocks don't work for multipart stuff in Fog yet):
+
+* AWS:
+  * AWS_ACCESS_KEY
+  * AWS_SECRET_ACCESS_KEY
+* Rackspace
+  * RACKSPACE_USERNAME
+  * RACKSPACE_API_KEY
+
+
+Usage
+=====
+You'll need an instance of `Sublimate::Uploader`. Just pass it a Fog bucket/directory and call `store_file`
+
+Example:
+
+```ruby
+opts = {
+  :provider => 'AWS',
+  :aws_access_key_id => ENV['AWS_ACCESS_KEY'],
+  :aws_secret_access_key => ENV['AWS_SECRET_ACCESS_KEY']
+}
+s3 = Fog::Storage.new(opts)
+bucket = s3.directories.get('HUGE-FILES')
+uploader = Sublimate::Uploader.new(bucket)
+upload.store_file(path, :key => 'something.iso')
+```

data/lib/sublimate.rb

@@ -1,8 +1,8 @@
-require 'fog'
 # rackspace cloud: http://www.rackspace.com/knowledge_center/index.php/Does_Cloud_Files_support_large_file_transfer
 # s3: https://gist.github.com/908875
 # Google Storage apparently allows single PUTs up to 50GB
 module Sublimate
 end
+require 'fog'
 require 'sublimate/chunked_file'
 require 'sublimate/uploader'

data/lib/sublimate/uploader.rb

@@ -1,62 +1,51 @@
 module Sublimate
   class Uploader
-    def initialize(attrs)
-      @attrs = attrs
-
-      fog_attrs = attrs.clone
-      fog_attrs.delete(:auto_create_bucket)
-      fog_attrs.delete(:multipart_chunk_size)
-      fog_attrs.delete(:bucket)
-
-      @fog_storage = Fog::Storage.new(fog_attrs)
-    end
-
-    def storage
-      @fog_storage
+    def initialize(bucket, opts = {})
+      @bucket = bucket
+      @opts = opts
     end
 
+    attr_accessor :bucket
     def store_file(path, opts = {})
       opts = {:key => path}.merge(opts)
       size = File.size(path)
 
-      bucket = @fog_storage.directories.get(opts[:bucket])
-      if bucket.nil? && @attrs[:auto_create_bucket]
-        bucket = @fog_storage.directories.create(:key => opts[:bucket])
-      elsif bucket.nil?
-        raise "bucket not found"
-      end
-
-      m = "do_multi_#{@attrs[:provider].downcase}"
+      m = multi_method_name
       if respond_to?(m)
-        chunked = ChunkedFile.new(path, :chunk_size => @attrs[:multipart_chunk_size])
-        send(m, bucket, chunked, opts)
+        chunked = ChunkedFile.new(path, :chunk_size => @opts[:multipart_chunk_size])
+        send(m, chunked, opts)
       else
         opts[:body] = File.open(path)
         bucket.files.create(opts)
       end
     end
 
-    def do_multi_aws(bucket, chunked, opts)
-      multi = @fog_storage.initiate_multipart_upload(opts[:bucket], opts[:key])
+    def multi_method_name
+      n = bucket.connection.service.to_s.split('::').last.downcase
+      "do_multi_#{n}"
+    end
+
+    def do_multi_aws(chunked, opts)
+      multi = bucket.connection.initiate_multipart_upload(bucket.key, opts[:key])
       upload_id = multi.body["UploadId"]
       results = []
       chunked.each_chunk do |data, details|
-        part = @fog_storage.upload_part(opts[:bucket], opts[:key], upload_id, details[:counter] + 1, data)
+        part = bucket.connection.upload_part(bucket.key, opts[:key], upload_id, details[:counter] + 1, data)
         etag = part.headers['ETag']
         results << etag
       end
 
-      completed_upload = @fog_storage.complete_multipart_upload(opts[:bucket], opts[:key], upload_id, results)
+      completed_upload = bucket.connection.complete_multipart_upload(bucket.key, opts[:key], upload_id, results)
     end
 
-    def do_multi_rackspace(bucket, chunked, opts)
+    def do_multi_rackspace(chunked, opts)
       count = 1
       chunked.each_chunk do |data, details|
         key = opts[:key] + "/#{count}"
         bucket.files.create(:key => key, :body => data)
         count += 1
       end
-      result = @fog_storage.put_object_manifest(bucket.identity, opts[:key])
+      result = bucket.connection.put_object_manifest(bucket.key, opts[:key])
     end
 
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sublimate
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -10,16 +10,28 @@ autorequire:
 bindir: bin
 cert_chain: []
 date: 2011-12-26 00:00:00.000000000Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fog
+  requirement: &70351569528960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *70351569528960
 description: Store ginormous files on S3 or the Rackspace Cloud using this gem.
 email: mrkurt@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/sublimate.rb
 - lib/sublimate/chunked_file.rb
 - lib/sublimate/uploader.rb
+- lib/sublimate.rb
+- Readme.md
 homepage: https://github.com/mrkurt/sublimate
 licenses: []
 post_install_message: