oahu-dragonfly 0.8.2

data/lib/dragonfly/job_builder.rb

@@ -0,0 +1,39 @@
+module Dragonfly
+  class JobBuilder
+
+    def initialize(&block)
+      @block = block
+    end
+
+    def build(job, *args)
+      evaluate_block(job, false, *args)
+    end
+
+    def build!(job, *args)
+      evaluate_block(job, true, *args)
+    end
+
+    Job.step_names.each do |step|
+      
+      # fetch, process, etc.
+      define_method step do |*args|
+        if @perform_with_bangs
+          @job.send("#{step}!", *args)
+        else
+          @job = @job.send(step, *args)
+        end
+      end
+      
+    end
+    
+    private
+    
+    def evaluate_block(job, perform_with_bangs, *args)
+      @job = job
+      @perform_with_bangs = perform_with_bangs
+      instance_exec(*args, &@block)
+      @job
+    end
+
+  end
+end

data/lib/dragonfly/job_definitions.rb

@@ -0,0 +1,26 @@
+module Dragonfly
+  class JobDefinitions < Module
+
+    def initialize
+      @job_definitions = {}
+    end
+
+    def add(name, &definition_proc)
+      job_definitions[name] = JobBuilder.new(&definition_proc)
+      jd = job_definitions # Needed because we're about to change 'self'
+      
+      define_method name do |*args|
+        jd[name].build(self, *args)
+      end
+      
+      define_method "#{name}!" do |*args|
+        jd[name].build!(self, *args)
+      end
+    end
+
+    private
+
+    attr_reader :job_definitions
+
+  end
+end

data/lib/dragonfly/job_endpoint.rb

@@ -0,0 +1,15 @@
+module Dragonfly
+  class JobEndpoint
+
+    def initialize(job)
+      @job = job
+    end
+
+    def call(env={})
+      Response.new(job, env).to_response
+    end
+
+    attr_reader :job
+
+  end
+end

data/lib/dragonfly/loggable.rb

@@ -0,0 +1,28 @@
+require 'logger'
+
+module Dragonfly
+  module Loggable
+
+    def log
+      case @log_object
+      when nil
+        @log_object = Logger.new($stdout)
+      when Proc
+        @log_object[]
+      when Logger
+        @log_object
+      end
+    end
+
+    def log=(object)
+      @log_object = object
+    end
+    
+    attr_reader :log_object
+
+    def use_same_log_as(object)
+      self.log = proc{ object.log }
+    end
+
+  end
+end

data/lib/dragonfly/middleware.rb

@@ -0,0 +1,20 @@
+module Dragonfly
+  class Middleware
+
+    def initialize(app, dragonfly_app_name, deprecated_arg=nil)
+      raise ArgumentError, "mounting Dragonfly::Middleware with a mount point is deprecated - just use Dragonfly::Middleware, #{dragonfly_app_name.inspect}" if deprecated_arg
+      @app = app
+      @dragonfly_app_name = dragonfly_app_name
+    end
+
+    def call(env)
+      response = Dragonfly[@dragonfly_app_name].call(env)
+      if response[1]['X-Cascade'] == 'pass'
+        @app.call(env)
+      else
+        response
+      end
+    end
+
+  end
+end

data/lib/dragonfly/processing/image_magick_processor.rb

@@ -0,0 +1,6 @@
+module Dragonfly
+  module Processing
+    puts "WARNING: Dragonfly::Processing::ImageMagickProcessor is DEPRECATED and will soon be removed. Please use Dragonfly::ImageMagick::Processor instead."
+    ImageMagickProcessor = ImageMagick::Processor
+  end
+end

data/lib/dragonfly/processor.rb

@@ -0,0 +1,9 @@
+module Dragonfly
+  class Processor < FunctionManager
+
+    def process(temp_object, method, *args)
+      call_last(method, temp_object, *args)
+    end
+
+  end
+end

data/lib/dragonfly/rails/images.rb

@@ -0,0 +1,27 @@
+require 'dragonfly'
+require 'uri'
+
+### The dragonfly app ###
+app = Dragonfly[:images]
+app.configure_with(:rails)
+app.configure_with(:imagemagick)
+
+### Extend active record ###
+if defined?(ActiveRecord::Base)
+  app.define_macro(ActiveRecord::Base, :image_accessor)
+  app.define_macro(ActiveRecord::Base, :file_accessor)
+end
+
+### Insert the middleware ###
+Rails.application.middleware.insert 0, 'Dragonfly::Middleware', :images
+
+begin
+  require 'rack/cache'
+  Rails.application.middleware.insert_before 'Dragonfly::Middleware', 'Rack::Cache', {
+    :verbose     => true,
+    :metastore   => URI.encode("file:#{Rails.root}/tmp/dragonfly/cache/meta"), # URI encoded because Windows
+    :entitystore => URI.encode("file:#{Rails.root}/tmp/dragonfly/cache/body")  # has problems with spaces
+  }
+rescue LoadError => e  
+  app.log.warn("Warning: couldn't find rack-cache for caching dragonfly content")
+end

data/lib/dragonfly/response.rb

@@ -0,0 +1,97 @@
+require 'uri'
+
+module Dragonfly
+  class Response
+
+    DEFAULT_FILENAME = proc{|job, request|
+      if job.basename
+        extname = job.encoded_extname || (".#{job.ext}" if job.ext)
+        "#{job.basename}#{extname}"
+      end
+    }
+
+    def initialize(job, env)
+      @job, @env = job, env
+      @app = @job.app
+    end
+
+    def to_response
+      if !(request.head? || request.get?)
+        [405, method_not_allowed_headers, ["#{request.request_method} method not allowed"]]
+      elsif etag_matches?
+        [304, cache_headers, []]
+      elsif request.head?
+        [200, success_headers.merge(cache_headers), []]
+      elsif request.get?
+        [200, success_headers.merge(cache_headers), job.result]
+      end
+    rescue DataStorage::DataNotFound => e
+      app.log.warn(e.message)
+      [404, {"Content-Type" => 'text/plain'}, ['Not found']]
+    end
+
+    def served?
+      request.get? && !etag_matches?
+    end
+
+    private
+
+    attr_reader :job, :env, :app
+
+    def request
+      @request ||= Rack::Request.new(env)
+    end
+
+    def cache_headers
+      {
+        "Cache-Control" => "public, max-age=#{app.cache_duration}",
+        "ETag" => %("#{job.unique_signature}")
+      }
+    end
+
+    def etag_matches?
+      return @etag_matches unless @etag_matches.nil?
+      if_none_match = env['HTTP_IF_NONE_MATCH']
+      @etag_matches = if if_none_match
+        if_none_match.tr!('"','')
+        if_none_match.split(',').include?(job.unique_signature) || if_none_match == '*'
+      else
+        false
+      end
+    end
+
+    def success_headers
+      {
+        "Content-Type" => job.mime_type,
+        "Content-Length" => job.size.to_s
+      }.merge(content_disposition_header)
+    end
+
+    def content_disposition_header
+      parts = []
+      parts << content_disposition if content_disposition
+      parts << %(filename="#{URI.encode(filename)}") if filename
+      parts.any? ? {"Content-Disposition" => parts.join('; ')} : {}
+    end
+    
+    def method_not_allowed_headers
+      {
+        'Content-Type' => 'text/plain',
+        'Allow' => 'GET, HEAD'
+      }
+    end
+
+    def content_disposition
+      @content_disposition ||= evaluate(app.content_disposition)
+    end
+
+    def filename
+      @filename ||= evaluate(app.content_filename)
+    end
+
+    def evaluate(attribute)
+      attribute.respond_to?(:call) ? attribute.call(job, request) : attribute
+    end
+
+  end
+end

data/lib/dragonfly/routed_endpoint.rb

@@ -0,0 +1,40 @@
+module Dragonfly
+  class RoutedEndpoint
+
+    class NoRoutingParams < RuntimeError; end
+
+    def initialize(app, &block)
+      @app = app
+      @block = block
+    end
+
+    def call(env)
+      params = symbolize_keys_of Rack::Request.new(env).params
+      job = @block.call(params.merge(routing_params(env)), @app)
+      Response.new(job, env).to_response
+    rescue Job::NoSHAGiven => e
+      [400, {"Content-Type" => 'text/plain'}, ["You need to give a SHA parameter"]]
+    rescue Job::IncorrectSHA => e
+      [400, {"Content-Type" => 'text/plain'}, ["The SHA parameter you gave (#{e}) is incorrect"]]
+    end
+
+    private
+
+    def routing_params(env)
+      env['rack.routing_args'] ||
+        env['action_dispatch.request.path_parameters'] ||
+        env['router.params'] ||
+        env['usher.params'] ||
+        env['dragonfly.params'] ||
+        raise(NoRoutingParams, "couldn't find any routing parameters in env #{env.inspect}")
+    end
+
+    def symbolize_keys_of(hash)
+      hash.inject({}) do |h, (key, value)|
+        h[(key.to_sym rescue key) || key] = value
+        h
+      end
+    end
+
+  end
+end

data/lib/dragonfly/serializer.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+require 'base64'
+
+module Dragonfly
+  module Serializer
+    
+    # Exceptions
+    class BadString < RuntimeError; end
+    
+    extend self # So we can do Serializer.b64_encode, etc.
+    
+    def b64_encode(string)
+      Base64.encode64(string).tr("\n=",'')
+    end
+    
+    def b64_decode(string)
+      padding_length = string.length % 4
+      Base64.decode64(string + '=' * padding_length)
+    end
+    
+    def marshal_encode(object)
+      b64_encode(Marshal.dump(object))
+    end
+    
+    def marshal_decode(string)
+      Marshal.load(b64_decode(string))
+    rescue TypeError, ArgumentError => e
+      raise BadString, "couldn't decode #{string} - got #{e}"
+    end
+    
+  end
+end

data/lib/dragonfly/server.rb

@@ -0,0 +1,113 @@
+module Dragonfly
+  class Server
+
+    include Loggable
+    include Configurable
+
+    configurable_attr :dragonfly_url, '/dragonfly'
+    configurable_attr :protect_from_dos_attacks, false
+    configurable_attr :url_format, '/:job/:basename.:format'
+    configurable_attr :url_host
+
+    extend Forwardable
+    def_delegator :url_mapper, :params_in_url
+
+    def initialize(app)
+      @app = app
+      use_same_log_as(app)
+      use_as_fallback_config(app)
+    end
+
+    def before_serve(&block)
+      self.before_serve_callback = block
+    end
+    configuration_method :before_serve
+
+    def after_serve(&block)
+      self.after_serve_callback = block
+    end
+    configuration_method :after_serve
+
+    def call(env)
+      if dragonfly_url == env["PATH_INFO"]
+        dragonfly_response
+      elsif (params = url_mapper.params_for(env["PATH_INFO"], env["QUERY_STRING"])) && params['job']
+        job = Job.deserialize(params['job'], app)
+        job.validate_sha!(params['sha']) if protect_from_dos_attacks
+        response = Response.new(job, env)
+        catch(:halt) do
+          if before_serve_callback && response.served?
+            before_serve_callback.call(job, env)
+          end
+          resp = response.to_response
+          if after_serve_callback && resp[0] == 200 && resp[2].is_a?(Dragonfly::TempObject)
+            after_serve_callback.call(job, env)
+          end
+          resp
+        end
+      else
+        [404, {'Content-Type' => 'text/plain', 'X-Cascade' => 'pass'}, ['Not found']]
+      end
+    rescue Serializer::BadString, Job::InvalidArray => e
+      log.warn(e.message)
+      [404, {'Content-Type' => 'text/plain'}, ['Not found']]
+    rescue Job::NoSHAGiven => e
+      [400, {"Content-Type" => 'text/plain'}, ["You need to give a SHA parameter"]]
+    rescue Job::IncorrectSHA => e
+      [400, {"Content-Type" => 'text/plain'}, ["The SHA parameter you gave (#{e}) is incorrect"]]
+    end
+
+    def url_for(job, opts={})
+      opts = opts.dup
+      host = opts.delete(:host) || url_host
+      params = stringify_keys(opts)
+      params['job'] = job.serialize
+      params['sha'] = job.sha if protect_from_dos_attacks
+      url = url_mapper.url_for(params)
+      "#{host}#{url}"
+    end
+
+    private
+
+    attr_reader :app
+    attr_accessor :before_serve_callback
+    attr_accessor :after_serve_callback
+
+    def url_mapper
+      @url_mapper ||= UrlMapper.new(url_format,
+        :job => '\w',
+        :basename => '[^\/]',
+        :format => '[^\.]'
+      )
+    end
+
+    def stringify_keys(params)
+      params.inject({}) do |hash, (k, v)|
+        hash[k.to_s] = v
+        hash
+      end
+    end
+
+    def dragonfly_response
+      body = <<-DRAGONFLY
+          _o|o_
+  _~~---._(   )_.---~~_
+ (       . \\ / .       )
+  `-.~--'  |=|  '--~.-'
+  _~-.~'" /|=|\\ "'~.-~_
+ (      ./ |=| \\.      )
+  `~~`"`   |=|   `"'ME"
+           |-|
+           <->
+            V
+      DRAGONFLY
+      [200, {
+        'Content-Type' => 'text/plain',
+        'Content-Size' => body.bytesize.to_s
+        },
+        [body]
+      ]
+    end
+
+  end
+end