apache_image_resizer 0.0.1

data/ChangeLog

@@ -0,0 +1,5 @@
+= Revision history for apache_image_resizer
+
+== 0.0.1 [2011-10-11]
+
+* Birthday :-)

data/README

@@ -0,0 +1,70 @@
+= apache_image_resizer - Apache module providing image resizing functionality.
+
+== VERSION
+
+This documentation refers to apache_image_resizer version 0.0.1
+
+
+== DESCRIPTION
+
+Place the following snippet in your Apache config:
+
+  <IfModule mod_ruby.c>
+    RubyRequire apache/ruby-run
+
+    RubyRequire /path/to/apache_image_resizer
+    # or
+    #RubyRequire rubygems
+    #RubyRequire apache/image_resizer
+
+    <Location /image_resizer>
+      SetHandler ruby-object
+      RubyHandler "Apache::ImageResizer.new"
+    </Location>
+
+    <Directory /path/to/images>
+      ErrorDocument 404 /image_resizer
+    </Directory>
+  </IfModule>
+
+Expected filesystem layout and URLs:
+
+  /images/bla/original/blob/blub_42-23.jpg
+   `-- base
+          `-- prefix
+              `-- source directory
+                       `-- path --------->
+
+  /$BASE/$PREFIX/r42x23/$PATH
+                 `-- directives
+
+
+== LINKS
+
+<b></b>
+Documentation:: http://blackwinter.github.com/apache_image_resizer
+Source code::   http://github.com/blackwinter/apache_image_resizer
+
+
+== AUTHORS
+
+* Jens Wille <mailto:jens.wille@uni-koeln.de>
+
+
+== LICENSE AND COPYRIGHT
+
+Copyright (C) 2011 University of Cologne,
+Albertus-Magnus-Platz, 50923 Cologne, Germany
+
+apache_image_resizer is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at your
+option) any later version.
+
+apache_image_resizer is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License
+for more details.
+
+You should have received a copy of the GNU Affero General Public License along
+with apache_image_resizer. If not, see <http://www.gnu.org/licenses/>.

data/Rakefile

@@ -0,0 +1,18 @@
+require File.expand_path(%q{../lib/apache/image_resizer/version}, __FILE__)
+
+begin
+  require 'hen'
+
+  Hen.lay! {{
+    :gem => {
+      :name     => %q{apache_image_resizer},
+      :version  => Apache::ImageResizer::VERSION,
+      :summary  => %q{Apache module providing image resizing functionality.},
+      :author   => %q{Jens Wille},
+      :email    => %q{jens.wille@uni-koeln.de},
+      :homepage => :blackwinter
+    }
+  }}
+rescue LoadError => err
+  warn "Please install the `hen' gem. (#{err})"
+end

data/lib/apache/image_resizer.rb

@@ -0,0 +1,90 @@
+#--
+###############################################################################
+#                                                                             #
+# apache_image_resizer -- Apache module providing upload merging              #
+#                         functionality                                       #
+#                                                                             #
+# Copyright (C) 2011 University of Cologne,                                   #
+#                    Albertus-Magnus-Platz,                                   #
+#                    50923 Cologne, Germany                                   #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@uni-koeln.de>                                    #
+#                                                                             #
+# apache_image_resizer is free software: you can redistribute it and/or       #
+# modify it under the terms of the GNU Affero General Public License as       #
+# published by the Free Software Foundation, either version 3 of the          #
+# License, or (at your option) any later version.                             #
+#                                                                             #
+# apache_image_resizer is distributed in the hope that it will be             #
+# useful, but WITHOUT ANY WARRANTY; without even the implied warranty         #
+# of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU         #
+# Affero General Public License for more details.                             #
+#                                                                             #
+# You should have received a copy of the GNU Affero General Public License    #
+# along with apache_image_resizer. If not, see http://www.gnu.org/licenses/.  #
+#                                                                             #
+###############################################################################
+#++
+
+require 'apache/image_resizer/util'
+
+module Apache
+
+  class ImageResizer
+
+    include Util
+
+    # Creates a new RubyHandler instance for the Apache web server. It
+    # is to be installed as a custom 404 ErrorDocument handler.
+    def initialize(options = {})
+      @verbosity   = options[:verbosity]   || DEFAULT_VERBOSITY
+      @max_dim     = options[:max_dim]     || DEFAULT_MAX_DIM
+      @prefix_re   = options[:prefix_re]   || DEFAULT_PREFIX_RE
+      @source_dir  = options[:source_dir]  || DEFAULT_SOURCE_DIR
+      @proxy_cache = options[:proxy_cache] || DEFAULT_PROXY_CACHE
+      @enlarge     = options[:enlarge]
+      @secret      = options[:secret]
+    end
+
+    # If the current +request+ asked for a resource that's not there,
+    # it will be checked for resize directives and treated accordingly.
+    # If no matching resource could be found, the original error will be
+    # thrown.
+    def handler(request, &block)
+      request.add_common_vars  # REDIRECT_URL, REDIRECT_QUERY_STRING
+      env = request.subprocess_env
+
+      url   = env['REDIRECT_URL']
+      query = env['REDIRECT_QUERY_STRING']
+      url  += "?#{query}" unless query.nil? || query.empty?
+
+      block ||= lambda { |msg|
+        log(2) { "#{url} - Elapsed #{Time.now - request.request_time} [#{msg}]" }
+      }
+
+      path, prefix, directives, dir = parse_url(url,
+        base = request.path_info, @prefix_re, &block)
+
+      return DECLINED unless path
+
+      log(2) {{ :Base => base, :Prefix => prefix, :Dir => dir, :Path => path }}
+
+      source, target = get_paths(request, path, base,
+        prefix, @source_dir, dir, @proxy_cache, @secret)
+
+      if source
+        log(2) {{ :Source => source, :Target => target, :Directives => directives }}
+        return DECLINED unless img = resize(source, target, directives, @enlarge, &block)
+      end
+
+      return DECLINED unless send_image(request, target, img, &block)
+
+      log { "#{url} - Elapsed #{Time.now - request.request_time}" }
+
+      OK
+    end
+
+  end
+
+end

data/lib/apache/image_resizer/util.rb

@@ -0,0 +1,302 @@
+#--
+###############################################################################
+#                                                                             #
+# A component of apache_image_resizer.                                        #
+#                                                                             #
+# Copyright (C) 2011 University of Cologne,                                   #
+#                    Albertus-Magnus-Platz,                                   #
+#                    50923 Cologne, Germany                                   #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@uni-koeln.de>                                    #
+#                                                                             #
+# apache_image_resizer is free software: you can redistribute it and/or       #
+# modify it under the terms of the GNU Affero General Public License as       #
+# published by the Free Software Foundation, either version 3 of the          #
+# License, or (at your option) any later version.                             #
+#                                                                             #
+# apache_image_resizer is distributed in the hope that it will be             #
+# useful, but WITHOUT ANY WARRANTY; without even the implied warranty         #
+# of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU         #
+# Affero General Public License for more details.                             #
+#                                                                             #
+# You should have received a copy of the GNU Affero General Public License    #
+# along with apache_image_resizer. If not, see http://www.gnu.org/licenses/.  #
+#                                                                             #
+###############################################################################
+#++
+
+require 'RMagick'
+require 'fileutils'
+require 'filemagic/ext'
+require 'nuggets/uri/redirect'
+require 'apache/secure_download/util'
+
+unless RUBY_VERSION > '1.8.5'
+
+  class String  # :nodoc:
+    def start_with?(prefix)
+      index(prefix) == 0
+    end
+  end
+
+  module Net  # :nodoc:
+    class BufferedIO  # :nodoc:
+      private
+
+      def rbuf_fill
+        timeout(@read_timeout) {
+          @rbuf << @io.readpartial(1024)
+        }
+      end
+    end
+  end
+
+end
+
+module Apache
+
+  class ImageResizer
+
+    module Util
+
+      extend self
+
+      DEFAULT_VERBOSITY   = 0
+      DEFAULT_MAX_DIM     = 8192
+      DEFAULT_HEIGHT      = 999999
+      DEFAULT_PREFIX_RE   = %r{[^/]+/}
+      DEFAULT_SOURCE_DIR  = 'original'
+      DEFAULT_PROXY_CACHE = 'proxy_cache'
+      DEFAULT_FORMAT      = 'jpeg:'
+
+      dimension_pattern = %q{\d+(?:\.\d+)?}
+
+      DIRECTIVES_RE = %r{
+        \A
+        (?:
+          (?:
+            r                              # resize
+            ( #{dimension_pattern} )       # width
+            (?:
+              x
+              ( #{dimension_pattern} )     # height (optional)
+            )?
+          )
+          |
+          (?:
+            o                              # offset
+            ( #{dimension_pattern} )       # width
+            x
+            ( #{dimension_pattern} )       # height
+            ( [pm] #{dimension_pattern} )  # x
+            ( [pm] #{dimension_pattern} )  # y
+          )
+        ){1,2}
+        /
+      }x
+
+      PROXY_RE = %r{\Aproxy:}
+
+      REPLACE = %w[? $@$]
+
+      def secure_resize_url(secret, args = [], options = {})
+        url_for(resize_url(*args), secret, options)
+      end
+
+      def resize_url(size = DEFAULT_SOURCE_DIR, *path)
+        case size
+          when String  then nil
+          when Numeric then size = "r#{size}"
+          when Array   then size = "r#{size.join('x')}"
+          when Hash    then size = size.map { |k, v| case k.to_s
+            when /\A[rs]/
+              "r#{Array(v).join('x')}" if v
+            when /\Ao/
+              x, y, w, h = v
+              "o#{w}x#{h}#{x < 0 ? 'm' : 'p'}#{x.abs}#{y < 0 ? 'm' : 'p'}#{y.abs}"
+          end }.compact.join
+        end
+
+        if path.empty?
+          size
+        else
+          file = path.pop.sub(*REPLACE)
+          File.join(path << size << file)
+        end
+      end
+
+      def parse_url(url, base, prefix_re, &block)
+        block ||= lambda { |*| }
+
+        return block['No URL'] unless url
+
+        path = Apache::SecureDownload::Util.real_path(url)
+        return block['Invalid Format'] unless path.sub!(
+          %r{\A#{Regexp.escape(base)}/(#{prefix_re})}, ''
+        )
+
+        prefix, directives, dir = $1 || '', *extract_directives(path)
+        return block['Invalid Directives'] unless directives
+        return block['No Path'] if path.empty?
+        return block['No File'] if path =~ %r{/\z}
+
+        [path, prefix, directives, dir]
+      end
+
+      def extract_directives(path)
+        return unless path.sub!(DIRECTIVES_RE, '')
+        match, directives, max = Regexp.last_match, {}, @max_dim
+
+        if o = match[3]
+          h, *xy = match.values_at(4, 5, 6)
+
+          if (args = [o.to_f, h.to_f]).all? { |i| i <= max }
+            directives[:offset] = xy.map! { |i|
+              i.tr!('pm', '+-').to_f
+            }.concat(args)
+          else
+            return
+          end
+        end
+
+        if w = match[1]
+          h = match[2]
+
+          args = [w.to_f]
+          args << h.to_f if h
+
+          max *= 2 if o
+
+          if args.all? { |i| i <= max }
+            directives[:resize] = args
+          else
+            return
+          end
+        end
+
+        [directives, match[0]]
+      end
+
+      def get_paths(request, path, base, prefix, source_dir, target_dir, proxy_cache, secret)
+        real_base = request.lookup_uri(base).filename.untaint
+        target    = File.join(real_base, prefix, target_dir, path).untaint
+        return [nil, target] if File.exist?(target)
+
+        source = request.lookup_uri(url_for(File.join(base, prefix,
+          source_dir, path.sub(*REPLACE.reverse)), secret)).filename.untaint
+        return [source, target] unless source.sub!(PROXY_RE, '') && proxy_cache
+
+        cache = File.join(real_base, prefix, proxy_cache, path).untaint
+        return [cache, target] if File.exist?(cache)
+
+        begin
+          URI.get_redirect(source) { |res|
+            if res.is_a?(Net::HTTPSuccess)
+              content = res.body.untaint
+
+              mkdir_for(cache)
+              File.open(cache, 'w') { |f| f.write(content) }
+
+              return [cache, target]
+            end
+          }
+        rescue => err
+          log_err(err, "#{source} => #{cache}")
+        end
+
+        [source, target]
+      end
+
+      def resize(source, target, directives, enlarge, &block)
+        img = do_magick('Read', source, block) { |value|
+          Magick::Image.read(value).first
+        } or return
+
+        resize, offset = directives.values_at(:resize, :offset)
+
+        if resize
+          w, h = resize
+          h  ||= DEFAULT_HEIGHT
+
+          unless enlarge || offset
+            w = [w, img.columns].min
+            h = [h, img.rows   ].min
+          end
+
+          img.resize_to_fit!(w, h)
+        end
+
+        if offset
+          img.crop!(*offset)
+        end
+
+        mkdir_for(target)
+
+        do_magick('Write', target, block) { |value|
+          img.write(value) or raise Magick::ImageMagickError
+        }
+      rescue => err
+        log_err(err)
+        block['Resize Error: %s' % err] if block
+      end
+
+      def send_image(request, target, img = nil)
+        File.open(target) { |f|
+          request.content_type = (t = img && img.format) ?
+            "image/#{t.downcase}" : f.content_type
+
+          request.status = HTTP_OK
+          request.send_fd(f)
+        }
+      rescue IOError => err
+        request.log_reason(err.message, target)
+        yield('Send Error') if block_given?
+      end
+
+      private
+
+      def do_magick(what, value, block)
+        yield value
+      rescue Magick::ImageMagickError => err
+        unless value.start_with?(DEFAULT_FORMAT)
+          value = "#{DEFAULT_FORMAT}#{value}"
+          retry
+        else
+          block['%s Error: %s' % [what, err]] if block
+        end
+      end
+
+      def mkdir_for(path)
+        dir = File.dirname(path).untaint
+        FileUtils.mkdir_p(dir) unless File.exist?(dir)
+      end
+
+      def url_for(url, sec = nil, opt = {})
+        sec ? Apache::SecureDownload::Util.secure_url(sec, url, opt) : url
+      end
+
+      def log_err(err, msg = nil)
+        log(0, 1, err.backtrace) {
+          "[ERROR] #{"#{msg}: " if msg}#{err} (#{err.class})"
+        }
+      end
+
+      def log(level = 1, loc = 0, trace = nil)
+        return if @verbosity < level
+
+        case msg = yield
+          when Array then msg = msg.shift % msg
+          when Hash  then msg = msg.map { |k, v|
+            "#{k} = #{v.inspect}"
+          }.join(', ')
+        end
+
+        warn "#{caller[loc]}: #{msg}#{" [#{trace.join(', ')}]" if trace}"
+      end
+
+    end
+
+  end
+
+end