condo 1.0.6 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 335bdd9a275e2321248b001a74b6e123d50358ad
-  data.tar.gz: 2f13c901661a82d195d0bd090bb549d00c6de4e5
+  metadata.gz: 92cc7003ecce7499b7c92bc3aed7facde40cf79d
+  data.tar.gz: a4b4e8d9a93bace70e3c236d13d23d97116dd44e
 SHA512:
-  metadata.gz: a842e8e7fd460e1345205e3e73d5e74efdd28b5962b6a990320b919c4f5b68b58300b5249a0df31a48354ac78b8eeb788c23f95d32353ea0409179e13b1542c7
-  data.tar.gz: 8e9e92aa03407f99aecfb0ac2cba68f5ba077d2d19834cc75668ad992d46b8c9436c2e40e26e434b5c146ff31dc943992f09d6319f7f6700f2193fab624af14d
+  metadata.gz: c45dcf3f6aed9abe71705db52d83ffd3731c105259d10d43672f2deff33d2e19bcb6e3d7e77a7b47e373ef882ddf3ffc9949661363460a103f25356787e402cc
+  data.tar.gz: bbd682e45ad4a9f651d77abd5cae57e14b163ca476d38cc89c78ff8b3678c35ab37a9c6df36a601e2f28339a605ff67958a2bef7faf82d59f661aad6a6ba3ebd

data/README.textile

@@ -3,6 +3,7 @@ h1. Condominios aka Condo
 A "Rails plugin":http://guides.rubyonrails.org/plugins.html and "AngularJS application":http://angularjs.org/ that makes direct uploads to multiple cloud storage providers easy.
 Only supports "XMLHttpRequest Level 2":http://en.wikipedia.org/wiki/XMLHttpRequest capable browsers and cloud providers that have a "RESTful API":http://en.wikipedia.org/wiki/Representational_state_transfer with "CORS":http://en.wikipedia.org/wiki/Cross-origin_resource_sharing support.
 
+
 Why compromise?
 
 Get started now: @gem install condo@ or checkout the "example application":https://github.com/cotag/condo_example
@@ -22,18 +23,23 @@ The API is RESTful, providing an abstraction layer and signed URLs that can be u
 The main advantages are:
 * Off-loads processing to client machines
 * Better guarantees against upload corruption
-** file hashing on the client side instead of an intermediary where it probably won't be hashed either
-* Upload results are guaranteed if the cloud provider provides atomic operations
+** file hashing on the client side
+* Upload results are guaranteed
 ** user is always aware of any failures in the process
 * Detailed progress and control over the upload
  
 This has numerous advantages over traditional Form Data style post uploads too.
 * Progress bars
 * Resumability when uploading large files
+* Optional parallel uploads (multiple parts of the file simultaneously)
 
 
 Support for all major browsers
-* Tested in Firefox latest stable, Chromes latest stable, Safari 6, Opera 12 and IE10
+* Chrome
+* Firefox
+* Safari
+* Opera
+* IE10+
 
 
 h2. Usage
@@ -88,12 +94,11 @@ In an initialiser do the following:
 
 <pre><code class="ruby">
 Condo::Configuration.add_residence(:AmazonS3, {
-	:access_id => ENV['S3_KEY'],
-	:secret_key => ENV['S3_SECRET']
-	# :location => 'us-west-1'	# or 'ap-southeast-1' etc (see http://docs.amazonwebservices.com/general/latest/gr/rande.html#s3_region)
-								# Defaults to 'us-east-1' or US Standard - not required for Google
-	# :namespace => :admin_resident	# Allows you to assign different defaults to different controllers
-									# Controller must have the following line 'set_namespace :admin_resident'
+    :access_id => ENV['S3_KEY'],
+    :secret_key => ENV['S3_SECRET']
+    # :location => 'us-west-1'    # or 'ap-southeast-1' etc (see http://docs.amazonwebservices.com/general/latest/gr/rande.html#s3_region)
+                                # Defaults to 'us-east-1' or US Standard - not required for Google
+    # :namespace => :admin_resident    # Allows you to assign different defaults to different controllers or users etc
 })
 
 </code></pre>
@@ -102,32 +107,14 @@ The first residence to be defined in a namespace will be the default. To change
 Currently available residencies:
 * :AmazonS3
 * :GoogleCloudStorage
-* :RackspaceCloudFiles
-
+* :RackspaceCloudFiles (Works with Swift left as rackspace for backwards compatibility)
 
-You can also define a dynamic residence each request (maybe clients provided you with access information for their storage provider)
 
-<pre><code class="ruby">
-set_residence(:AmazonS3, {
-	:access_id => user.s3_key,
-	:secret_key => user.s3_secret,
-	:dynamic => true	# Otherwise the same as add_residence
-});
-	
-
-</code></pre>
+Note:: There is also a callback to dynamically set storage provider. Which is useful if your users use:
+* Their own bucket
+* Different cloud providers etc
 
 
 h3. Callbacks
 
-These are pretty well defined "here":https://github.com/cotag/condo_example/blob/master/app/controllers/uploads_controller.rb
-
-
-h2. TODO::
-
-# Write tests... So many tests
-# Create a wiki describing things in more detail
-# Implement API for more residencies
-# Sign other useful requests (bucket listings with search etc)
-#* For Dropbox or Megaupload style applications
-
+These are pretty well defined "here":https://github.com/cotag/Condominios/blob/master/lib/condo/configuration.rb

data/lib/condo.rb

@@ -1,3 +1,6 @@
+# encoding: utf-8
+
+require 'fog'
 require 'condo/engine'
 require 'condo/errors'
 require 'condo/configuration'
@@ -6,14 +9,12 @@ require 'condo/configuration'
 module Condo
     def self.included(base)
         base.class_eval do
-            
-            
+
+
             def new
-                #
                 # Returns the provider that will be used for this file upload
                 resident = current_resident
 
-                #
                 # Ensure parameters are correct
                 params.require(:file_size)
                 params.require(:file_name)
@@ -23,30 +24,25 @@ module Condo
                     file_name: @@callbacks[:sanitize_filename].call(permitted[:file_name])
                 }
                 @upload[:file_path] = @@callbacks[:sanitize_filepath].call(permitted[:file_path]) if permitted[:file_path]
-                
+
                 valid, errors = instance_exec(@upload, &@@callbacks[:pre_validation])       # Ensure the upload request is valid before uploading
                 
-                if !!valid
-                    set_residence(nil, {:resident => resident, :params => @upload}) if condo_config.dynamic_provider_present?(@@namespace)
+                if valid
                     residence = current_residence
-                    
-                    render :json => {:residence => residence.name}
-                    
+
+                    render json: {residence: residence.name}
                 elsif errors.is_a? Hash
-                    render :json => errors, :status => :not_acceptable
+                    render json: errors, status: :not_acceptable
                 else
-                    render :nothing => true, :status => :not_acceptable
+                    render nothing: true, status: :not_acceptable
                 end
             end
-            
+
             def create
-                #
                 # Check for existing upload or create a new one
                 # => mutually exclusive so can send back either the parts signature from show or a bucket creation signature and the upload_id
-                #
                 resident = current_resident
-                
-                #
+
                 # Ensure parameters are correct
                 params.require(:file_size)
                 params.require(:file_name)
@@ -59,54 +55,48 @@ module Condo
                     user_id: resident
                 }
                 @upload[:file_path] = @@callbacks[:sanitize_filepath].call(permitted[:file_path]) if permitted[:file_path]
-                
-                #
+
                 # Check for existing uploads
                 upload = condo_backend.check_exists(@upload)
-                
+
                 if upload.present?
-                    residence = set_residence(upload.provider_name, {
-                        :location => upload.provider_location,
-                        :upload => upload
-                    })
-                    
-                    #
+                    residence = current_residence(upload)
+
                     # Return the parts or direct upload sig
-                    #
                     request = nil
                     if upload.resumable_id.present? && upload.resumable
                         request = residence.get_parts({
-                            :bucket_name => upload.bucket_name,
-                            :object_key => upload.object_key,
-                            :object_options => upload.object_options,
-                            :file_size => upload.file_size,
-                            :resumable_id => upload.resumable_id
+                            bucket_name: upload.bucket_name,
+                            object_key: upload.object_key,
+                            object_options: upload.object_options,
+                            file_size: upload.file_size,
+                            resumable_id: upload.resumable_id
                         })
+
+                        request[:part_list] = upload.part_list || []
+                        request[:part_data] = upload.part_data if upload.part_data
                     else
                         request = residence.new_upload({
-                            :bucket_name => upload.bucket_name,
-                            :object_key => upload.object_key,
-                            :object_options => upload.object_options,
-                            :file_size => upload.file_size,
-                            :file_id => upload.file_id
+                            bucket_name: upload.bucket_name,
+                            object_key: upload.object_key,
+                            object_options: upload.object_options,
+                            file_size: upload.file_size,
+                            file_id: upload.file_id
                         })
                     end
                     
-                    render :json => request.merge(:upload_id => upload.id, :residence => residence.name)
+                    render json: request.merge!({
+                        upload_id: upload.id,
+                        residence: residence.name
+                    })
                 else
-                    #
                     # Create a new upload
-                    #
                     valid, errors = instance_exec(@upload, &@@callbacks[:pre_validation])               # Ensure the upload request is valid before uploading
-                    
-                    
+
                     if valid
-                        set_residence(nil, {:resident => resident, :params => @upload}) if condo_config.dynamic_provider_present?(@@namespace)
                         residence = current_residence
-                        
-                        #
+
                         # Build the request
-                        #
                         @upload.merge!({
                             bucket_name:    (instance_eval &@@callbacks[:bucket_name]),             # Allow the application to define a custom bucket name
                             object_key:     instance_exec(@upload, &@@callbacks[:object_key]),      # The object key should also be generated by the application
@@ -114,142 +104,155 @@ module Condo
                         })
                         request = residence.new_upload(@upload)
                         resumable = request[:type] == :chunked_upload
-                        
-                        #
+
                         # Save a reference to this upload in the database
                         # => This should throw an error on failure
-                        #
-                        upload = condo_backend.add_entry(@upload.merge!({:provider_name => residence.name, :provider_location => residence.location, :resumable => resumable}))
-                        render :json => request.merge!(:upload_id => upload.id, :residence => residence.name)
+                        upload = condo_backend.add_entry(@upload.merge!({provider_name: residence.name, provider_location: residence.location, resumable: resumable}))
+                        render json: request.merge!(upload_id: upload.id, residence: residence.name)
                         
                     elsif errors.is_a? Hash
-                        render :json => errors, :status => :not_acceptable
+                        render json: errors, status: :not_acceptable
                     else
-                        render :nothing => true, :status => :not_acceptable
+                        render nothing: true, status: :not_acceptable
                     end
                 end
             end
-            
-            
-            #
+
             # Authorization check all of these
-            #
             def edit
-                #
                 # Get the signature for parts + final commit
-                #
                 upload = current_upload
+
                 params.require(:part)
                 safe_params = params.permit(:part, :file_id)
-                
+
                 if upload.resumable_id.present? && upload.resumable
-                    residence = set_residence(upload.provider_name, {:location => upload.provider_location, :upload => upload})
-                    
+                    residence = current_residence(upload)
+
                     request = residence.set_part({
-                        :bucket_name => upload.bucket_name,
-                        :object_key => upload.object_key,
-                        :object_options => upload.object_options,
-                        :resumable_id => upload.resumable_id,
-                        :part => safe_params[:part],                        # part may be called 'finish' for commit signature
-                        :file_size => upload.file_size,
-                        :file_id => safe_params[:file_id]
+                        bucket_name: upload.bucket_name,
+                        object_key: upload.object_key,
+                        object_options: upload.object_options,
+                        resumable_id: upload.resumable_id,
+                        # part may be called 'finish' for commit signature
+                        part: safe_params[:part],
+                        file_size: upload.file_size,
+                        file_id: safe_params[:file_id]
                     })
-                    
-                    render :json => request.merge!(:upload_id => upload.id)
+
+                    render json: request.merge!(upload_id: upload.id)
                 else
-                    render :nothing => true, :status => :not_acceptable
+                    render nothing: true, status: :not_acceptable
                 end
             end
-            
-            
+
+
             def update
-                #
                 # Provide the upload id after creating a resumable upload (may not be completed)
                 # => We then provide the first part signature
                 #
                 # OR
                 #
                 # Complete an upload
-                #
-                if params[:resumable_id]
-                    upload = current_upload
+                upload = current_upload
+
+                safe = params.permit(:resumable_id, {part_list: []}, {part_data: [
+                    :md5,
+                    :size_bytes,
+                    :path,
+                    :part
+                ]})
+                part_list = safe[:part_list]
+                resumable_id = safe[:resumable_id]
+
+                if resumable_id || part_list
                     if upload.resumable
-                        @current_upload = upload.update_entry :resumable_id => params.permit(:resumable_id)[:resumable_id]
-                        edit
+                        if part_list
+                            upload.part_list = part_list || []
+
+                            # We incrementally update this as it might otherwise contain
+                            # sum(1 -> 10,000) parts over the time of the upload
+                            # (as is the case with the largest file amazon supports)
+                            if safe[:part_data]
+                                upload.part_data ||= {}
+                                safe[:part_data].each do |part|
+                                    upload.part_data[part[:part]] = part
+                                end
+                            end
+                        end
+
+                        upload.resumable_id = resumable_id if resumable_id
+                        upload.save!
+
+                        if params[:part_update]
+                            render nothing: true
+                        else
+                            @current_upload = upload
+
+                            # Render is called from edit
+                            edit
+                        end
                     else
-                        render :nothing => true, :status => :not_acceptable
+                        render nothing: true, status: :not_acceptable
                     end
-                else
-                    response = instance_exec current_upload, &@@callbacks[:upload_complete]
+
+                else # We are completeing the upload
+                    response = instance_exec upload, &@@callbacks[:upload_complete]
                     if response
-                        render :nothing => true
+                        render nothing: true
                     else
-                        render :nothing => true, :status => :not_acceptable
+                        render nothing: true, status: :not_acceptable
                     end
                 end
             end
-            
-            
+
             def destroy
-                #
                 # Delete the file from the cloud system - the client is not responsible for this
-                #
                 response = instance_exec current_upload, &@@callbacks[:destroy_upload]
                 if response
-                    render :nothing => true
+                    render nothing: true
                 else
-                    render :nothing => true, :status => :not_acceptable
+                    render nothing: true, status: :not_acceptable
                 end
             end
-            
-            
+
+
             protected
-            
-            
-            #
-            # A before filter can be used to select the cloud provider for the current user
-            #     Otherwise the dynamic residence can be used when users are define their own storage locations
-            #
-            def set_residence(name, options = {})
-                options[:namespace] = @@namespace
-                @current_residence = condo_config.set_residence(name, options)
-            end
-            
-            def current_residence
-                @current_residence ||= condo_config.residencies[0]
+
+
+            def current_residence(upload = nil)
+                @current_residence ||= instance_exec(condo_config, current_resident, upload, &@@callbacks[:select_residence])
             end
-            
+
             def current_upload
                 return @current_upload if @current_upload
 
                 safe_params = params.permit(:upload_id, :id)
-                @current_upload = condo_backend.check_exists({:user_id => current_resident, :upload_id => (safe_params[:upload_id] || safe_params[:id])}).tap do |object|    #current_residence.name && current_residence.location && resident.id.exists?
+                # current_residence.name && current_residence.location && resident.id.exists?
+                @current_upload = condo_backend.check_exists({user_id: current_resident, upload_id: (safe_params[:upload_id] || safe_params[:id])}).tap do |object|
                     raise Condo::Errors::NotYourPlace unless object.present?
                 end
             end
-            
+
             def current_resident
-                @current_resident ||= (instance_eval &@@callbacks[:resident_id]).tap do |object|    # instance_exec for params
+                # instance_exec for params
+                @current_resident ||= (instance_eval &@@callbacks[:resident_id]).tap do |object|
                     raise Condo::Errors::LostTheKeys unless object.present?
                 end
             end
-            
+
             def condo_backend
-                Condo::Store
+                ::Condo::Store
             end
-            
+
             def condo_config
-                Condo::Configuration.instance
+                ::Condo::Configuration
             end
-            
-        
-            #
+
+
             # Defines the default callbacks
-            #
             (@@callbacks ||= {}).merge! Condo::Configuration.callbacks
-            @@namespace ||= :global
-            
-            
+
             def self.condo_callback(name, callback = nil, &block)
                 callback ||= block
                 if callback.respond_to?(:call)
@@ -258,12 +261,6 @@ module Condo
                     raise ArgumentError, 'No callback provided'
                 end
             end
-            
-            
-            def self.condo_namespace(name)
-                @@namespace = name.to_sym
-            end
-        
         end
     end
 end