attachment_zen 1.0.1

data/lib/technoweenie/attachment_fu/backends/backend_delegator.rb

@@ -0,0 +1,19 @@
+module Technoweenie # :nodoc:
+  module AttachmentFu # :nodoc:
+    module Backends
+      class BackendDelegator < Delegator
+        attr_accessor :attachment_options
+
+        def initialize(obj, opts)
+          @obj = obj
+          @attachment_options = opts
+        end
+        
+        def __getobj__
+          @obj
+        end
+      end
+    end
+  end
+end
+

data/lib/technoweenie/attachment_fu/backends/cloud_file_backend.rb

@@ -0,0 +1,245 @@
+module Technoweenie # :nodoc:
+  module AttachmentFu # :nodoc:
+    module Backends
+      # = CloudFiles Storage Backend
+      #
+      # Enables use of {Rackspace Cloud Files}[http://www.mosso.com/cloudfiles.jsp] as a storage mechanism
+      #
+      # Based heavily on the Amazon S3 backend.
+      #
+      # == Requirements
+      #
+      # Requires the {Cloud Files Gem}[http://www.mosso.com/cloudfiles.jsp] by Rackspace
+      #
+      # == Configuration
+      #
+      # Configuration is done via <tt>RAILS_ROOT/config/rackspace_cloudfiles.yml</tt> and is loaded according to the <tt>RAILS_ENV</tt>.
+      # The minimum connection options that you must specify are a container name, your Mosso login name and your Mosso API key.
+      # You can sign up for Cloud Files and get access keys by visiting https://www.mosso.com/buy.htm
+      #
+      # Example configuration (RAILS_ROOT/config/rackspace_cloudfiles.yml)
+      #
+      #   development:
+      #     container_name: appname_development
+      #     username: <your key>
+      #     api_key: <your key>
+      #
+      #   test:
+      #     container_name: appname_test
+      #     username: <your key>
+      #     api_key: <your key>
+      #
+      #   production:
+      #     container_name: appname
+      #     username: <your key>
+      #     apik_key: <your key>
+      #
+      # You can change the location of the config path by passing a full path to the :cloudfiles_config_path option.
+      #
+      #   has_attachment :storage => :cloud_files, :cloudfiles_config_path => (RAILS_ROOT + '/config/mosso.yml')
+      #
+      # === Required configuration parameters
+      #
+      # * <tt>:username</tt> - The username for your Rackspace Cloud (Mosso) account. Provided by Rackspace.
+      # * <tt>:secret_access_key</tt> - The api key for your Rackspace Cloud account. Provided by Rackspace.
+      # * <tt>:container_name</tt> - The name of a container in your Cloud Files account.
+      #
+      # If any of these required arguments is missing, a AuthenticationException will be raised from CloudFiles::Connection.
+      #
+      # == Usage
+      #
+      # To specify Cloud Files as the storage mechanism for a model, set the acts_as_attachment <tt>:storage</tt> option to <tt>:cloud_files/tt>.
+      #
+      #   class Photo < ActiveRecord::Base
+      #     has_attachment :storage => :cloud_files
+      #   end
+      #
+      # === Customizing the path
+      #
+      # By default, files are prefixed using a pseudo hierarchy in the form of <tt>:table_name/:id</tt>, which results
+      # in Cloud Files object names (and urls) that look like: http://:server/:container_name/:table_name/:id/:filename with :table_name
+      # representing the customizable portion of the path. You can customize this prefix using the <tt>:path_prefix</tt>
+      # option:
+      #
+      #   class Photo < ActiveRecord::Base
+      #     has_attachment :storage => :cloud_files, :path_prefix => 'my/custom/path'
+      #   end
+      #
+      # Which would result in public URLs like <tt>http(s)://:server/:container_name/my/custom/path/:id/:filename.</tt>
+      #
+      # === Permissions
+      #
+      # File permisisons are determined by the permissions of the container.  At present, the options are public (and distributed
+      # by the Limelight CDN), and private (only available to your login)
+      #
+      # === Other options
+      #
+      # Of course, all the usual configuration options apply, such as content_type and thumbnails:
+      #
+      #   class Photo < ActiveRecord::Base
+      #     has_attachment :storage => :cloud_files, :content_type => ['application/pdf', :image], :resize_to => 'x50'
+      #     has_attachment :storage => :cloud_files, :thumbnails => { :thumb => [50, 50], :geometry => 'x50' }
+      #   end
+      #
+      # === Accessing Cloud Files URLs
+      #
+      # You can get an object's public URL using the cloudfiles_url accessor. For example, assuming that for your postcard app
+      # you had a container name like 'postcard_world_development', and an attachment model called Photo:
+      #
+      #   @postcard.cloudfiles_url # => http://cdn.cloudfiles.mosso.com/c45182/uploaded_files/20/london.jpg
+      #
+      # The resulting url is in the form: http://:server/:container_name/:table_name/:id/:file.
+      # The optional thumbnail argument will output the thumbnail's filename (if any).
+      #
+      # Additionally, you can get an object's base path relative to the container root using
+      # <tt>base_path</tt>:
+      #
+      #   @photo.file_base_path # => uploaded_files/20
+      #
+      # And the full path (including the filename) using <tt>full_filename</tt>:
+      #
+      #   @photo.full_filename # => uploaded_files/20/london.jpg
+      #
+      # Niether <tt>base_path</tt> or <tt>full_filename</tt> include the container name as part of the path.
+      # You can retrieve the container name using the <tt>container_name</tt> method.
+      class CloudFileBackend < BackendDelegator
+        class RequiredLibraryNotFoundError < StandardError; end
+        class ConfigFileNotFoundError < StandardError; end
+
+        cattr_reader :cloudfiles_config, :container_name
+        def self.included_in_base(base) #:nodoc:
+
+          begin
+            require 'cloudfiles'
+          rescue LoadError
+            raise RequiredLibraryNotFoundError.new('CloudFiles could not be loaded')
+          end
+
+          opts = base.attachment_options
+          if opts[:cloudfiles_options]
+            @@cloudfiles_config = opts[:cloudfiles_options]
+          elsif opts[:cloudfiles_username] && opts[:cloudfiles_api_key] && opts[:cloudfiles_container_name]
+            @@cloudfiles_config = {:container_name => opts[:cloudfiles_container_name],
+                                   :username => opts[:cloudfiles_username],
+                                   :api_key => opts[:cloudfiles_api_key]}
+          else
+            @@cloudfiles_config_path = base.attachment_options[:cloudfiles_config_path] || Rails.root.join('config/rackspace_cloudfiles.yml').to_s
+            @@cloudfiles_config = @@cloudfiles_config = YAML.load(ERB.new(File.read(@@cloudfiles_config_path)).result)[ENV['RAILS_ENV']].symbolize_keys
+            base.attachment_options[:cloudfiles_container_name] = @@cloudfiles_config[:container_name]
+          end
+        end
+
+        def container_name
+          return @obj.database_container_name if @obj.respond_to?(:database_container_name) && @obj.database_container_name
+          @@cloudfiles_config[:container_name]
+        end
+
+        def self.connection
+          @@cf ||= CloudFiles::Connection.new(@@cloudfiles_config)
+        end
+
+        def container
+          self.class.connection.container(container_name)
+        end
+
+        def cloudfiles_authtoken
+          self.class.connection.authtoken
+        end
+
+        def cloudfiles_storage_url
+          cx = self.class.connection
+          cx.storagescheme + "://" + (cx.storageport ? "" : ":#{cx.storageport}") + cx.storagehost + cx.storagepath
+        end
+
+        # Overwrites the base filename writer in order to store the old filename
+        def notify_rename
+          @old_filename = filename unless filename.nil? || @old_filename
+        end
+
+        # The attachment ID used in the full path of a file
+        def attachment_path_id
+          ((respond_to?(:parent_id) && parent_id) || @obj.id).to_s
+        end
+
+        # The pseudo hierarchy containing the file relative to the container name
+        # Example: <tt>:table_name/:id</tt>
+        def base_path
+          File.join(attachment_options[:path_prefix], attachment_path_id)
+        end
+
+        # The full path to the file relative to the container name
+        # Example: <tt>:table_name/:id/:filename</tt>
+        def full_filename(thumbnail = nil)
+          File.join(base_path, thumbnail_name_for(thumbnail))
+        end
+
+        # All public objects are accessible via a GET request to the Cloud Files servers. You can generate a
+        # url for an object using the cloudfiles_url method.
+        #
+        #   @photo.cloudfiles_url
+        #
+        # The resulting url is in the CDN URL for the object
+        #
+        # The optional thumbnail argument will output the thumbnail's filename (if any).
+        #
+        # If you are trying to get the URL for a nonpublic container, nil will be returned.
+        def cloudfiles_url(thumbnail = nil)
+          if container.public?
+            File.join(container.cdn_url, full_filename(thumbnail))
+          else
+            nil
+          end
+        end
+        alias :public_url :cloudfiles_url
+
+        def create_temp_file
+          write_to_temp_file current_data
+        end
+
+        def current_data
+          container.get_object(full_filename).data
+        end
+
+        # Called in the after_destroy callback
+        def destroy_file
+          retried = false
+          begin
+            container.delete_object(full_filename)
+          rescue CloudFiles::Exception::NoSuchObject => e
+          rescue CloudFiles::Exception::InvalidResponse => e
+            if retried
+              raise e
+            else
+              retried = true
+              retry
+            end
+          end
+        end
+
+        def rename_file
+          # Cloud Files doesn't rename right now, so we'll just nuke.
+          return unless @old_filename && @old_filename != filename
+
+          old_full_filename = File.join(base_path, @old_filename)
+          begin
+            container.delete_object(old_full_filename)
+          rescue CloudFiles::Exception::NoSuchObject => e
+          end
+
+          @old_filename = nil
+          true
+        end
+
+        def save_to_storage
+          if save_attachment?
+            @object = container.create_object(full_filename)
+            @object.write((temp_path ? File.open(temp_path) : temp_data))
+          end
+
+          @old_filename = nil
+          true
+        end
+      end
+    end
+  end
+end

data/lib/technoweenie/attachment_fu/backends/db_file_backend.rb

@@ -0,0 +1,36 @@
+module Technoweenie # :nodoc:
+  module AttachmentFu # :nodoc:
+    module Backends
+      # Methods for DB backed attachments
+      class DbFileBackend < BackendDelegator
+        def self.included_in_base(base)
+          Object.const_set(:DbFile, Class.new(ActiveRecord::Base)) unless Object.const_defined?(:DbFile)
+          base.belongs_to  :db_file, :class_name => '::DbFile', :foreign_key => 'db_file_id'
+        end
+
+        def rename_file ; end
+
+        # Gets the current data from the database
+        def current_data
+          db_file && db_file.data
+        end
+
+        # Destroys the file.  Called in the after_destroy callback
+        def destroy_file
+          db_file.destroy if db_file
+        end
+
+        # Saves the data to the DbFile model
+        def save_to_storage
+          if save_attachment?
+            (db_file || build_db_file).data = temp_data
+            db_file.save!
+            @obj.db_file_id = db_file.id
+            @obj.class.where(id: @obj.id).update_all db_file_id: db_file.id
+          end
+          true
+        end
+      end
+    end
+  end
+end

data/lib/technoweenie/attachment_fu/backends/file_system_backend.rb

@@ -0,0 +1,125 @@
+require 'fileutils'
+require 'digest/sha2'
+
+module Technoweenie # :nodoc:
+  module AttachmentFu # :nodoc:
+    module Backends
+      # Methods for file system backed attachments
+      class FileSystemBackend < BackendDelegator
+        def self.included_in_base(base)
+        end
+
+        # Gets the full path to the filename in this format:
+        #
+        #   # This assumes a model name like MyModel
+        #   # public/#{table_name} is the default filesystem path
+        #   RAILS_ROOT/public/my_models/5/blah.jpg
+        #
+        # Overwrite this method in your model to customize the filename.
+        # The optional thumbnail argument will output the thumbnail's filename.
+        def full_filename(thumbnail = nil)
+          file_system_path = (thumbnail ? thumbnail_class : self).attachment_options[:path_prefix].to_s
+          Rails.root.join(file_system_path, *partitioned_path(thumbnail_name_for(thumbnail))).to_s
+        end
+
+        # Used as the base path that #public_filename strips off full_filename to create the public path
+        def base_path
+          @base_path ||= Rails.root.join('public').to_s
+        end
+
+        # The attachment ID used in the full path of a file
+        def attachment_path_id
+          ((respond_to?(:parent_id) && parent_id) || read_attribute(:id)) || 0
+        end
+
+        # Partitions the given path into an array of path components.
+        #
+        # For example, given an <tt>*args</tt> of ["foo", "bar"], it will return
+        # <tt>["0000", "0001", "foo", "bar"]</tt> (assuming that that id returns 1).
+        #
+        # If the id is not an integer, then path partitioning will be performed by
+        # hashing the string value of the id with SHA-512, and splitting the result
+        # into 4 components. If the id a 128-bit UUID (as set by :uuid_primary_key => true)
+        # then it will be split into 2 components.
+        #
+        # To turn this off entirely, set :partition => false.
+        def partitioned_path(*args)
+          if respond_to?(:attachment_options) && attachment_options[:partition] == false
+            args
+          elsif attachment_options[:uuid_primary_key]
+            # Primary key is a 128-bit UUID in hex format. Split it into 2 components.
+            path_id = attachment_path_id.to_s
+            component1 = path_id[0..15] || "-"
+            component2 = path_id[16..-1] || "-"
+            [component1, component2] + args
+          else
+            path_id = attachment_path_id
+            if path_id.is_a?(Integer)
+              partitioned_path_for_fixnum(path_id, args)
+            else
+              # Primary key is a String. Hash it, then split it into 4 components.
+              hash = Digest::SHA512.hexdigest(path_id.to_s)
+              [hash[0..31], hash[32..63], hash[64..95], hash[96..127]] + args
+            end
+          end
+        end
+
+        def partitioned_path_for_fixnum(path_id, args)
+          if path_id <= 9999_9999
+            ("%08d" % path_id).scan(/..../) + args
+          else
+            ("%012d" % path_id).scan(/..../) + args
+          end
+        end
+
+        # Gets the public path to the file
+        # The optional thumbnail argument will output the thumbnail's filename.
+        def public_filename(thumbnail = nil)
+          full_filename(thumbnail).gsub %r(^#{Regexp.escape(base_path)}), ''
+        end
+
+        def notify_rename
+          @old_filename = full_filename unless filename.nil? || @old_filename
+        end
+
+        # Destroys the file.  Called in the after_destroy callback
+        def destroy_file
+          FileUtils.rm full_filename
+          # remove directory also if it is now empty
+          Dir.rmdir(File.dirname(full_filename)) if (Dir.entries(File.dirname(full_filename))-['.','..']).empty?
+        rescue
+          logger.info "Exception destroying  #{full_filename.inspect}: [#{$!.class.name}] #{$1.to_s}"
+          logger.warn $!.backtrace.collect { |b| " > #{b}" }.join("\n")
+        end
+
+        # Renames the given file before saving
+        def rename_file
+          return unless @old_filename && @old_filename != full_filename
+          if save_attachment? && File.exists?(@old_filename)
+            FileUtils.rm @old_filename
+          elsif File.exists?(@old_filename)
+            FileUtils.mv @old_filename, full_filename
+          end
+          @old_filename =  nil
+          true
+        end
+
+        # Saves the file to the file system
+        def save_to_storage
+          if save_attachment?
+            # TODO: This overwrites the file if it exists, maybe have an allow_overwrite option?
+            FileUtils.mkdir_p(File.dirname(full_filename))
+            FileUtils.cp(temp_path, full_filename)
+            FileUtils.chmod(attachment_options[:chmod] || 0644, full_filename)
+          end
+          @old_filename = nil
+          true
+        end
+
+        def current_data
+          File.file?(full_filename) ? File.read(full_filename) : nil
+        end
+      end
+    end
+  end
+end

data/lib/technoweenie/attachment_fu/backends/mogile_fs_backend.rb

@@ -0,0 +1,99 @@
+module Technoweenie # :nodoc:
+  module AttachmentFu # :nodoc:
+    module Backends
+      class MogileFSBackend < BackendDelegator
+        class ConfigFileNotFoundError < StandardError; end
+
+        class RequiredLibraryNotFoundError < StandardError; end
+        attr_reader :mogile_domain_name
+        def initialize(obj, opts)
+          @domain_name = opts[:mogile_domain_name] || @@mogile_config[:domain_name]
+          super(obj, opts)
+        end
+
+        def self.included_in_base(base) #:nodoc:
+          begin
+            require 'mogilefs'
+          rescue LoadError
+            raise RequiredLibraryNotFoundError.new('mogilefs could not be loaded')
+          end
+
+          mogile_config = nil
+          if base.attachment_options[:mogile_hosts] && base.attachment_options[:mogile_domain_name]
+            mogile_config = base.attachment_options.inject({}) do |memo, arr|
+              k, v = arr
+              memo[k.to_s.gsub(/^mogile_/, '').to_sym] = v if k.to_s =~ /^mogile_/
+              memo
+            end
+          else
+            mogile_config_path = base.attachment_options[:mogile_config_path] || Rails.root.join('config/mogilefs.yml').to_s
+            mogile_config = YAML.load(ERB.new(File.read(mogile_config_path)).result)[RAILS_ENV].symbolize_keys
+          end
+
+          @@mogile_config = mogile_config
+          @@mogile = MogileFS::MogileFS.new(:domain => @@mogile_config[:domain_name], :hosts => @@mogile_config[:hosts])
+        end
+
+        # called by the ActiveRecord class from filename=
+        def notify_rename
+          @old_filename = filename unless filename.nil? || @old_filename
+        end
+
+        # The attachment ID used in the full path of a file
+        def attachment_path_id
+          ((respond_to?(:parent_id) && parent_id) || @obj.id).to_s
+        end
+
+        # The pseudo hierarchy containing the file relative to the bucket name
+        # Example: <tt>:table_name/:id</tt>
+        def base_path
+          File.join(attachment_options[:path_prefix], attachment_path_id)
+        end
+
+        def full_filename(thumbnail = nil)
+          File.join(base_path, thumbnail_name_for(thumbnail))
+        end
+
+        def current_data
+          @@mogile.get_file_data(full_filename)
+        end
+
+        # Called in the after_destroy callback
+        def destroy_file
+          @@mogile.delete(full_filename)
+        end
+
+        def rename_file
+          return unless @old_filename && @old_filename != filename
+
+          old_full_filename = File.join(base_path, @old_filename)
+
+          begin
+            @@mogile.rename(old_full_filename, full_filename)
+          rescue MogileFS::Backend::KeyExistsError
+            # this is hacky.  It's at first blush actually a limitation of the mogilefs-client gem,
+            # which always tries to create a new key instead of exposing "set" semantics.
+            @@mogile.delete(full_filename)
+            retry
+          end
+
+          @old_filename = nil
+          true
+        end
+
+        def save_to_storage
+          if save_attachment?
+            if temp_path
+              @@mogile.store_file(full_filename, @@mogile_config[:mogile_storage_class], temp_path)
+            else
+              @@mogile.store_content(full_filename, @@mogile_config[:mogile_storage_class], temp_data)
+            end
+          end
+
+          @old_filename = nil
+          true
+        end
+      end
+    end
+  end
+end