sinicum 0.5.0

data/lib/sinicum/imaging/converter.rb

@@ -0,0 +1,81 @@
+require 'digest/md5'
+require 'open3'
+
+module Sinicum
+  module Imaging
+    # Collection of helper methods common to Converters
+    module Converter
+      CONVERTER_VERSION = "1" # change to change Hash signature
+      PNG_OPTIMIZER_SUFFIX = "-fs8.png"
+
+      attr_writer :document
+
+      def initialize(configuration)
+        @x = configuration['x'] || ''
+        @y = configuration['y'] || ''
+        @render_type = configuration['render_type']
+        @hires_factor = configuration['hires_factor'] || 1.0
+        @configuration = configuration
+      end
+
+      # Computes a standard hash for a converted image, consisting of `x`, `y`, `render_type`
+      # and `format`.
+      #
+      # @return [String] A hash based on the current converter's configuration
+      def config_hash
+        digest = Digest::MD5.hexdigest(
+          "#{@x}-#{@y}-#{@hires_factor}-#{@render_type}-#{@format}-#{CONVERTER_VERSION}")
+        digest
+      end
+
+      # Returns the interlace command line option if an image is large enough
+      # (> 80px x 80px)
+      #
+      # @param [String, Fixnum] x the x size of an image
+      # @param [String, Fixnum] y the y size of an image
+      # @return [String] the command line option to interlace an image or an empty String
+      def interlace_option(x, y)
+        x.to_i * y.to_i > 80 * 80 ? "-interlace plane" : ""
+      end
+
+      def ratio(x, y)
+        x.to_f / y.to_f
+      end
+
+      private
+
+      def device_pixel_size(pixel)
+        px = pixel.to_f * @hires_factor.to_f
+        if px == 0
+          ''
+        else
+          px.round
+        end
+      end
+
+      def quality_option
+        "-quality 50" if @hires_factor && @hires_factor > 1.5
+      end
+
+      def optimize_png_outfile(outfile_path)
+        return unless format == "png"
+        cmd = "pngquant -- \"#{outfile_path}\""
+        exec_command(cmd)
+        cmd = "mv \"#{outfile_path}#{PNG_OPTIMIZER_SUFFIX}\" \"#{outfile_path}\""
+        exec_command(cmd)
+      rescue
+        # Fail silently
+      end
+
+      def exec_command(command)
+        status = nil
+        Open3.popen2(command) do |stdin, stdout, wait_thr|
+          status = wait_thr.value.exitstatus
+        end
+        if status != 0
+          fail "Command '#{command}' failed with exit status #{status}"
+        end
+      end
+    end
+  end
+end

data/lib/sinicum/imaging/default_converter.rb

@@ -0,0 +1,20 @@
+module Sinicum
+  module Imaging
+    # Internal: Simple converter that simply serves a copy of the original file.
+    class DefaultConverter
+      include Converter
+      include Sinicum::Logger
+
+      def initialize(configuration)
+      end
+
+      def convert(infile_path, outfile_path)
+        `cp #{infile_path} #{outfile_path}`
+      end
+
+      def format
+        ".#{@document[:document][:extension]}" if @document && @document[:document]
+      end
+    end
+  end
+end

data/lib/sinicum/imaging/image_size_converter.rb

@@ -0,0 +1,52 @@
+module Sinicum
+  module Imaging
+    # Public: Calculates the size of an image based on the converter used to
+    # render the image.
+    class ImageSizeConverter
+      DEFAULT_WORKSPACE = "dam"
+
+      def initialize(image_or_jcr_path, converter_name, options = {})
+        if image_or_jcr_path.is_a?(String)
+          workspace = options[:workspace].presence || DEFAULT_WORKSPACE
+          @image = Sinicum::Jcr::Node.find_by_path(workspace, image_or_jcr_path)
+        elsif image_or_jcr_path.respond_to?(:width) && image_or_jcr_path.respond_to?(:height)
+          @image = image_or_jcr_path
+        end
+        @converter_name = converter_name
+      end
+
+      def width
+        unless defined?(@width)
+          if converter.respond_to?(:converted_size)
+            @width = converter.converted_size[0]
+          else
+            @width = @image.width
+          end
+        end
+        @width
+      end
+
+      def height
+        unless defined?(@height)
+          if converter.respond_to?(:converted_size)
+            @height = converter.converted_size[1]
+          else
+            @height = @image.height
+          end
+        end
+        @height
+      end
+
+      private
+
+      def converter
+        unless defined?(@converter)
+          conf = Config.read_configuration
+          @converter = conf.converter(@converter_name)
+          @converter.document = @image if @converter
+        end
+        @converter
+      end
+    end
+  end
+end

data/lib/sinicum/imaging/imaging.rb

@@ -0,0 +1,171 @@
+require 'tempfile'
+require 'fileutils'
+
+module Sinicum
+  module Imaging
+    # Internal: Class that handles more or less all of the imaging
+    # functionality.
+    class Imaging
+      RENDER_MUTEX = Mutex.new
+      include Sinicum::Logger
+
+      attr_reader :fingerprint
+
+      # Render the image from path `original_path` with the renderer `renderer`
+      #
+      # @param [String] original_path The original path of the image.
+      # @param [String] renderer The name of the renderer
+      # @return [RenderResult] The result of the conversion
+      def self.rendered_resource(original_path, extension, renderer, fingerprint, workspace = nil)
+        imaging = Imaging.new(original_path, extension, renderer, fingerprint, workspace)
+        result = imaging.fetch_image
+        result
+      end
+
+      def initialize(original_path, extension, renderer, fingerprint, workspace = nil)
+        @original_path = original_path
+        @extension = extension
+        @renderer = renderer
+        @fingerprint = fingerprint
+        @workspace = workspace
+      end
+
+      def fetch_image
+        result = nil
+        @image, @doc = find_image_objects_by_path(@original_path)
+        if @image && @doc
+          if convert_file?
+            result = perform_conversion
+          else
+            format = converter.format
+            mime_type =
+              case format
+              when "gif" then "image/gif"
+              when "png" then "image/png"
+              when "ogv" then "video/ogg"
+              when "mp4" then "video/mp4"
+              when "m4a" then "audio/mp4"
+              when "ogg" then "audio/ogg"
+              when "webm" then "audio/webm"
+              else "image/jpeg"
+              end
+            result = RenderResult.new(
+              file_rendered, mime_type,
+              "#{@doc[:fileName]}.#{@doc[:extension]}", fingerprint)
+          end
+        end
+        result
+      end
+
+      # The temporary file as it comes out of the repository
+      def file_out
+        @_file_out ||= File.join(config_data.tmp_dir, @renderer + "-" + "out" + "-" + random)
+      end
+
+      # The temporary file the converter writes to
+      def file_converted
+        @_file_converted ||= File.join(config_data.tmp_dir, @renderer + "-" + "converted" +
+          "-" + random + "." + converter.format)
+      end
+
+      # The "final" file to be sent to the client
+      def file_rendered
+        @_file_rendered ||= File.join(config_data.file_dir, "/" + @renderer + "-" +
+          converter.config_hash + "-" + @image.uuid + "." +
+          converter.format)
+      end
+
+      # Finds the image objects by path
+      #
+      # @param [String] original_path The original path
+      # @return [Array] An `Array` in the form `[Image, Document]`
+      def find_image_objects_by_path(original_path)
+        result = [nil, nil]
+        if @workspace == :dam
+          image_node_path = original_path.gsub(/^\/dam/, "")
+          image = Sinicum::Jcr::Node.find_by_path("dam", image_node_path)
+        elsif @workspace == :dms
+          image_node_path = original_path.gsub(/^\/dms/, "")
+          image = Sinicum::Jcr::Node.find_by_path("dms", image_node_path)
+        end
+        if image
+          doc = image.properties
+          result = [image, doc]
+        end
+        result
+      end
+
+      private
+
+      def perform_conversion
+        RENDER_MUTEX.synchronize {
+          out_file = File.open(file_out, "wb")
+          out_file.close
+          in_file = File.open(file_converted, "wb")
+          begin
+            write_doc_to_tempfile(in_file)
+            in_file.close
+            convert(in_file.path, out_file.path)
+            FileUtils.mv(out_file.path, file_rendered)
+            FileUtils.chmod(0644, file_rendered)
+            RenderResult.new(
+              file_rendered, @doc["jcr:mimeType"],
+              "#{@doc[:fileName]}.#{@doc[:extension]}", fingerprint)
+          rescue => e
+            FileUtils.rm(out_file.path) if File.exist?(out_file.path)
+            raise e
+          ensure
+            FileUtils.rm(in_file.path) if File.exist?(in_file.path)
+          end
+        }
+      end
+
+      def convert(infile_path, outfile_path)
+        converter.convert(infile_path, outfile_path)
+      end
+
+      def write_doc_to_tempfile(tempfile)
+        begin
+          Sinicum::Jcr::Node.stream_attribute(@doc.jcr_workspace, @doc.path, "jcr:data", tempfile)
+        rescue => e
+          logger.error("Cannot write to tempfile: " + e.to_s)
+        end
+      end
+
+      def convert_file?
+        last_modified = @doc["jcr:lastModified"]
+        # File.size == 0 is related to a (temporary?) bug on one server
+        # should be possible to remove
+        result = !File.exist?(file_rendered) || File.mtime(file_rendered) <
+          last_modified || File.size(file_rendered) == 0
+        result
+      end
+
+      def random
+        @random ||= "#{Process.pid}-#{rand(1_000_000_000)}"
+      end
+
+      def config_data
+        Config.read_configuration
+      end
+
+      def converter
+        conv = config_data.converter(@renderer)
+        conv.document = @image if conv
+        conv
+      end
+    end
+
+    # Internal: Simple wrapper around imaging results.
+    class RenderResult
+      attr_accessor :path, :mime_type, :filename, :fingerprint
+
+      def initialize(path, mime_type, filename, fingerprint = nil)
+        @path = path
+        @mime_type = mime_type
+        @filename = filename
+        @fingerprint = fingerprint
+      end
+    end
+  end
+end

data/lib/sinicum/imaging/imaging_file.rb

@@ -0,0 +1,115 @@
+# encoding: utf-8
+module Sinicum
+  module Imaging
+    # Representation of a DAM file as seen by the imaging middleware.
+    class ImagingFile
+      ORIGINAL_DAM_PATH_START = ::Sinicum::Imaging.dam_path_prefix + "/"
+      ORIGINAL_DAM_PATH_REPLACEMENT = ::Sinicum::Imaging.path_prefix + "/" +
+        ::Sinicum::Imaging.default_converter_name + "/"
+      ORIGINAL_DMS_PATH_START = ::Sinicum::Imaging.dms_path_prefix + "/"
+      ORIGINAL_DMS_PATH_REPLACEMENT = ::Sinicum::Imaging.path_prefix_mgnl4 + "/" +
+        ::Sinicum::Imaging.default_converter_name + "/"
+      DEFAULT_CACHE_TIME = 24 * 60 * 60
+      FINGERPRINT_CACHE_TIME = 7 * 24 * 60 * 60
+
+      attr_reader :normalized_request_path, :extension, :fingerprint, :workspace
+
+      # Public: Create a new instance
+      #
+      # path_info - The request's path_info
+      def initialize(path_info)
+        @path_info = path_info
+        set_up
+      end
+
+      def result?
+        !!imaging_result
+      end
+
+      def path
+        imaging_result.path
+      end
+
+      def filename
+        imaging_result.filename
+      end
+
+      def cache_time
+        if fingerprint
+          FINGERPRINT_CACHE_TIME
+        else
+          DEFAULT_CACHE_TIME
+        end
+      end
+
+      private
+
+      def imaging_result
+        @imaging_result ||= create_imaging_result
+      end
+
+      def create_imaging_result
+        result = ::Sinicum::Imaging::Imaging.rendered_resource(
+          @file_asset_path, extension, @renderer, fingerprint, @workspace)
+        result
+      end
+
+      # Private: "Normalizes" the request path. In particular, a request
+      # to "/dam/something" gets converted to
+      # "/damfiles/default/something".
+      #
+      # Then it extracts the fingerprint and extension, if any of them
+      # exist.
+      def set_up
+        if @path_info.index(ORIGINAL_DAM_PATH_START) == 0
+          path = @path_info.sub(ORIGINAL_DAM_PATH_START, ORIGINAL_DAM_PATH_REPLACEMENT)
+          path = cutoff_document_path_repetition(path)
+        elsif @path_info.index(ORIGINAL_DMS_PATH_START) == 0
+          path = @path_info.sub(ORIGINAL_DMS_PATH_START, ORIGINAL_DMS_PATH_REPLACEMENT)
+          path = cutoff_document_path_repetition(path)
+        else
+          path = @path_info.dup
+        end
+        if path =~ /^\/dam/
+          @workspace = :dam
+        elsif path =~ /^\/dms/
+          @workspace = :dms
+        end
+        @normalized_request_path, @extension, @fingerprint = extract_fingerprint(path)
+        renderer_image = normalized_request_path[
+          ::Sinicum::Imaging.path_prefix.size + 1, normalized_request_path.size]
+        @renderer = renderer_image[0, renderer_image.index("/")]
+        @file_asset_path = renderer_image[@renderer.size, renderer_image.size]
+        nil
+      end
+
+      def extract_fingerprint(path)
+        if match = path.match(/(.+?)-(\h{32})(\.\w+)?$/)
+          extension = nil
+          extension = match[3][1..match[3].length] if match[3]
+          [match[1], extension, match[2]]
+        else
+          extension = nil
+          if match = path.match(/(.+)\.(\w+)$/)
+            extension = match[2]
+            path = match[1]
+          end
+          [path, extension, nil]
+        end
+      end
+
+      def cutoff_document_path_repetition(path)
+        parts = path.split("/")
+        if parts.size > 3
+          if match = parts.last.match(/(.+)(\.\w+)$/)
+            last_part = match[1]
+            if last_part == parts[parts.size - 2]
+              path = path[0..(path.rindex("/") - 1)] + match[2]
+            end
+          end
+        end
+        path
+      end
+    end
+  end
+end

data/lib/sinicum/imaging/imaging_middleware.rb

@@ -0,0 +1,56 @@
+module Sinicum
+  module Imaging
+    # Public: Rack middleware to handle a request to the imaging fuctionality.
+    class ImagingMiddleware < Rack::File
+      SUFFIX_REGEX = /\.\w+$/
+      DEFAULT_CACHE_TIME = 24 * 60 * 60
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        if on_imaging_path?(env['PATH_INFO'])
+          dup._call(env)
+        else
+          @app.call(env)
+        end
+      end
+
+      def _call(env)
+        unless ALLOWED_VERBS.include? env["REQUEST_METHOD"]
+          return fail(405, "Method Not Allowed")
+        end
+        request = Rack::Request.new(env)
+        imaging_file = ImagingFile.new(request.path_info)
+        if imaging_file.result?
+          @path = imaging_file.path
+          available = begin
+                        F.file?(@path) && F.readable?(@path)
+                      rescue SystemCallError
+                        false
+                      end
+        end
+        if available
+          @headers = {}
+          @headers["Content-Disposition"] = "inline; filename=\"#{imaging_file.filename}\""
+          if Rails.configuration.action_controller.perform_caching
+            @headers["Cache-Control"] = "max-age=#{imaging_file.cache_time}, public"
+          end
+          serving(env)
+        else
+          fail(404, "File not found: #{request.path_info}")
+        end
+      end
+
+      private
+
+      def on_imaging_path?(path)
+        path && (path.index(::Sinicum::Imaging.path_prefix) == 0 ||
+          path.index(ImagingFile::ORIGINAL_DAM_PATH_START) == 0 ||
+          path.index(::Sinicum::Imaging.path_prefix_mgnl4) == 0 ||
+          path.index(ImagingFile::ORIGINAL_DMS_PATH_START) == 0)
+      end
+    end
+  end
+end