fog-dragonfly 0.8.1

data/lib/dragonfly/response.rb

@@ -0,0 +1,82 @@
+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 etag_matches?
+        # Not Modified
+        [304, cache_headers, []]
+      else
+        # Success
+        [200, success_headers.merge(cache_headers), job.result]
+      end
+    rescue DataStorage::DataNotFound => e
+      [404, {"Content-Type" => 'text/plain'}, [e.message]]
+    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?
+      if_none_match = env['HTTP_IF_NONE_MATCH']
+      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.resolve_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 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/simple_cache.rb

@@ -0,0 +1,23 @@
+module Dragonfly
+  class SimpleCache < Hash
+    
+    def initialize(max_size)
+      @max_size = max_size
+      @keys = []
+    end
+    
+    attr_reader :max_size
+    
+    def []=(key, value)
+      if !has_key?(key)
+        @keys << key
+        if size == max_size
+          key_to_purge = @keys.shift
+          delete(key_to_purge)
+        end
+      end
+      super
+    end
+    
+  end
+end

data/lib/dragonfly/simple_endpoint.rb

@@ -0,0 +1,63 @@
+module Dragonfly
+  class SimpleEndpoint
+
+    include Loggable
+
+    # Instance methods
+
+    def initialize(app)
+      @app = app
+      use_same_log_as(app)
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+
+      case request.path_info
+      when '', '/', app.url_path_prefix
+        dragonfly_response
+      else
+        job = Job.from_path(request.path_info, app)
+        job.validate_sha!(request['s']) if app.protect_from_dos_attacks
+        Response.new(job, env).to_response
+      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 required_params_for(job)
+      {'s' => job.sha}
+    end
+
+    private
+
+    attr_reader :app
+
+    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

data/lib/dragonfly/temp_object.rb

@@ -0,0 +1,220 @@
+require 'stringio'
+require 'tempfile'
+
+module Dragonfly
+
+  # A TempObject is used for HOLDING DATA.
+  # It's the thing that is passed between the datastore, the processor and the encoder, and is useful
+  # for separating how the data was created and how it is later accessed.
+  #
+  # You can initialize it various ways:
+  #
+  #   temp_object = Dragonfly::TempObject.new('this is the content')           # with a String
+  #   temp_object = Dragonfly::TempObject.new(File.new('path/to/content'))     # with a File
+  #   temp_object = Dragonfly::TempObject.new(some_tempfile)                   # with a Tempfile
+  #   temp_object = Dragonfly::TempObject.new(some_other_temp_object)          # with another TempObject
+  #
+  # However, no matter how it was initialized, you can always access the data a number of ways:
+  #
+  #   temp_object.data      # returns a data string
+  #   temp_object.file      # returns a file object holding the data
+  #   temp_object.path      # returns a path for the file
+  #
+  # The data/file are created lazily, something which you may wish to take advantage of.
+  #
+  # For example, if a TempObject is initialized with a file, and temp_object.data is never called, then
+  # the data string will never be loaded into memory.
+  #
+  # Conversely, if the TempObject is initialized with a data string, and neither temp_object.file nor temp_object.path
+  # are ever called, then the filesystem will never be hit.
+  #
+  class TempObject
+
+    # Class configuration
+    class << self
+
+      include Configurable
+      configurable_attr :block_size, 8192
+
+    end
+
+    # Instance Methods
+
+    def initialize(obj, opts={})
+      opts ||= {} # in case it's nil
+      initialize_from_object!(obj)
+      validate_options!(opts)
+      extract_attributes_from(opts)
+    end
+
+    def data
+      @data ||= initialized_data || file{|f| f.read }
+    end
+
+    def tempfile
+      @tempfile ||= begin
+        case initialized_with
+        when :tempfile
+          @tempfile = initialized_tempfile
+          @tempfile.close
+        when :data
+          @tempfile = new_tempfile(initialized_data)
+        when :file
+          @tempfile = copy_to_tempfile(initialized_file.path)
+        end
+        @tempfile
+      end
+    end
+
+    def file(&block)
+      f = tempfile.open
+      tempfile.binmode
+      if block_given?
+        ret = yield f
+        tempfile.close
+      else
+        ret = f
+      end
+      ret
+    end
+
+    def path
+      tempfile.path
+    end
+
+    def size
+      if initialized_data
+        initialized_data.bytesize
+      else
+        File.size(path)
+      end
+    end
+
+    attr_accessor :name, :format
+    alias _format format
+    attr_writer :meta
+
+    def meta
+      @meta ||= {}
+    end
+
+    def basename
+      File.basename(name, '.*') if name
+    end
+
+    def ext
+      File.extname(name)[/\.(.*)/, 1] if name
+    end
+
+    def each(&block)
+      to_io do |io|
+        while part = io.read(block_size)
+          yield part
+        end
+      end
+    end
+
+    def to_file(path)
+      if initialized_data
+        File.open(path, 'wb'){|f| f.write(initialized_data) }
+      else
+        FileUtils.cp(self.path, path)
+      end
+      File.new(path, 'rb')
+    end
+
+    def to_io(&block)
+      if initialized_data
+        StringIO.open(initialized_data, 'rb', &block)
+      else
+        file(&block)
+      end
+    end
+
+    def attributes
+      {
+        :name => name,
+        :meta => meta,
+        :format => format
+      }
+    end
+
+    def extract_attributes_from(hash)
+      self.name   = hash.delete(:name)     unless hash[:name].blank?
+      self.format = hash.delete(:format)   unless hash[:format].blank?
+      self.meta.merge!(hash.delete(:meta)) unless hash[:meta].blank?
+    end
+
+    def inspect
+      content_string = case initialized_with
+      when :data
+        data_string = size > 20 ? "#{initialized_data[0..20]}..." : initialized_data
+        "data=#{data_string.inspect}"
+      when :file then "file=#{initialized_file.inspect}"
+      when :tempfile then "tempfile=#{initialized_tempfile.inspect}"
+      end
+      to_s.sub(/>$/, " #{content_string}, @meta=#{@meta.inspect}, @name=#{@name.inspect} >")
+    end
+
+    protected
+
+    attr_accessor :initialized_data, :initialized_tempfile, :initialized_file
+
+    private
+
+    def initialize_from_object!(obj)
+      if obj.is_a? TempObject
+        @initialized_data = obj.initialized_data
+        @initialized_tempfile = copy_to_tempfile(obj.initialized_tempfile.path) if obj.initialized_tempfile
+        @initialized_file = obj.initialized_file
+      elsif obj.is_a? String
+        @initialized_data = obj
+      elsif obj.is_a? Tempfile
+        @initialized_tempfile = obj
+      elsif obj.is_a? File
+        @initialized_file = obj
+        self.name = File.basename(obj.path)
+      elsif obj.respond_to?(:tempfile)
+        @initialized_tempfile = obj.tempfile
+      else
+        raise ArgumentError, "#{self.class.name} must be initialized with a String, a File, a Tempfile, another TempObject, or something that responds to .tempfile"
+      end
+      self.name = obj.original_filename if obj.respond_to?(:original_filename)
+    end
+
+    def initialized_with
+      if initialized_tempfile
+        :tempfile
+      elsif initialized_data
+        :data
+      elsif initialized_file
+        :file
+      end
+    end
+
+    def block_size
+      self.class.block_size
+    end
+
+    def copy_to_tempfile(path)
+      tempfile = new_tempfile
+      FileUtils.cp File.expand_path(path), tempfile.path
+      tempfile
+    end
+
+    def validate_options!(opts)
+      valid_keys = [:name, :meta, :format]
+      invalid_keys = opts.keys - valid_keys
+      raise ArgumentError, "Unrecognised options #{invalid_keys.inspect}" if invalid_keys.any?
+    end
+
+    def new_tempfile(content=nil)
+      tempfile = Tempfile.new('dragonfly')
+      tempfile.binmode
+      tempfile.write(content) if content
+      tempfile.close
+      tempfile
+    end
+
+  end
+end