snapimage 0.0.1

data/lib/snapimage/middleware.rb

@@ -0,0 +1,27 @@
+module SnapImage
+  # SnapImage API Rack Middleware to handle all SnapImage API calls.
+  class Middleware
+    # Arguments:
+    # * app:: Rack application
+    # * path:: The URL path to access the SnapImage API (defaults to "/snapimage_api")
+    # * config:: Filename of the YAML or JSON config file or a config Hash
+    def initialize(app, options = {})
+      @app = app
+      @path = options[:path] || "/snapimage_api"
+      # TODO: If no config is given, set defaults.
+      # For example, if it's a Rails app, set the filename to
+      # config/snapimage.yml.
+      raise SnapImage::MissingConfig, "Missing config." if options[:config].nil?
+      @config = SnapImage::Config.new(options[:config])
+    end
+
+    def call(env)
+      request = SnapImage::Request.new(env)
+      if request.path_info == @path
+        SnapImage::Server.new(request, @config).call
+      else
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/snapimage/rack/request.rb

@@ -0,0 +1,19 @@
+module SnapImage
+  class Request < Rack::Request
+    def bad_request?
+      !(self.post? && self.POST["json"] && self.json["action"] && self.json["resource_identifier"])
+    end
+
+    # NOTE: Call bad_request? first to make sure there is json to parse.
+    def json
+      @json ||= JSON.parse(self.POST["json"])
+    end
+
+    # Returns a SnapImage::RequestFile which encapsulates the file that Rack
+    # provides. Returns nil if there is no file.
+    def file
+      return nil unless self.POST["file"]
+      @file ||= SnapImage::RequestFile.new(self.POST["file"])
+    end
+  end
+end

data/lib/snapimage/rack/request_file.rb

@@ -0,0 +1,26 @@
+module SnapImage
+  class RequestFile
+    # The file comes through Rack's request's POST like this:
+    # {
+    #   :filename=>"jpeg.jpeg",
+    #   :type=>"image/jpeg",
+    #   :name=>"file", 
+    #   :tempfile=>#<File:/tmp/RackMultipart20120628-19317-1w4ouxp>,
+    #   :head=>"Content-Disposition: form-data; name=\"file\"; filename=\"jpeg.jpeg\"\r\nContent-Type: image/jpeg\r\n"}
+    # }
+    def initialize(file)
+      @file = file
+    end
+
+    def file
+      @file[:tempfile]
+    end
+
+    def type
+      return @type if @type
+      @type = File.extname(@file[:filename])[1..-1]
+      @type = "jpg" if type == "jpeg"
+      @type
+    end
+  end
+end

data/lib/snapimage/rack/response.rb

@@ -0,0 +1,51 @@
+module SnapImage
+  class Response < Rack::Response
+    attr_accessor  :content_type, :template, :json
+
+    def initialize(options = {})
+      @content_type = options[:content_type] || "text/json"
+      @template = options[:template] || "{{json}}"
+      @json = {}
+      super
+    end
+
+    def set_success(info = {})
+      info[:message] ||= "Success"
+      @json = { status_code: 200 }.merge(info)
+    end
+
+    def set_bad_request
+      @json = { status_code: 400, message: "Bad Request" }
+    end
+
+    def set_authorization_required
+      @json = { status_code: 401, message: "Authorization Required" }
+    end
+
+    def set_authorization_failed
+      @json = { status_code: 402, message: "Authorization Failed" }
+    end
+
+    def set_invalid_image_identifier
+      @json = { status_code: 403, message: "Invalid Image Identifier" }
+    end
+
+    def set_invalid_resource_identifier
+      @json = { status_code: 404, message: "Invalid Resource Identifier" }
+    end
+
+    def set_internal_server_error
+      @json = { status_code: 500, message: "Internal Server Error" }
+    end
+
+    def set_not_implemented
+      @json = { status_code: 501, message: "Not Implemented" }
+    end
+
+    def finish
+      self.body = [@template.gsub(/{{json}}/, @json.to_json)]
+      self["Content-Type"] = @content_type
+      super
+    end
+  end
+end

data/lib/snapimage/server.rb

@@ -0,0 +1,50 @@
+module SnapImage
+  class Server
+    ACTIONS = ["generate_image", "sync_resource", "delete_resource_images", "list_resource_images"]
+    RESOURCE_ID_REGEXP = /^[a-z0-9_-]+(\/[a-z0-9_-]+)*$/
+
+    # Arguments:
+    # * request:: Rack::Request
+    def initialize(request, config)
+      @request = request
+      @config = config
+      @storage = @config.storage
+    end
+
+    # Handles the request and returns a Rack::Response.
+    def call
+      @response = SnapImage::Response.new
+      begin
+        raise SnapImage::BadRequest if @request.bad_request?
+        raise SnapImage::InvalidResourceIdentifier unless !!@request.json["resource_identifier"].match(SnapImage::Server::RESOURCE_ID_REGEXP)
+        @response.content_type = @request.json["response_content_type"] if @request.json["response_content_type"]
+        @response.template = @request.json["response_template"] if @request.json["response_template"]
+        action = @request.json["action"]
+        raise SnapImage::ActionNotImplemented unless ACTIONS.include?(action)
+        @response = get_action_class(action).new(@config, @request, @response).call
+      rescue SnapImage::BadRequest
+        @response.set_bad_request
+      rescue SnapImage::ActionNotImplemented
+        @response.set_not_implemented
+      rescue SnapImage::AuthorizationRequired
+        @response.set_authorization_required
+      rescue SnapImage::AuthorizationFailed
+        @response.set_authorization_failed
+      rescue SnapImage::InvalidImageIdentifier
+        @response.set_invalid_image_identifier
+      rescue SnapImage::InvalidResourceIdentifier
+        @response.set_invalid_resource_identifier
+      #rescue
+        #@response.set_internal_server_error
+      end
+      @response.finish
+    end
+
+    private
+
+    def get_action_class(action)
+      klassname = action.split("_").map { |t| t.capitalize }.join("")
+      SnapImage::ServerActions.const_get(klassname)
+    end
+  end
+end

data/lib/snapimage/server_actions/server_actions.authorize.rb

@@ -0,0 +1,69 @@
+module SnapImage
+  module ServerActions
+    module Authorize
+      def get_token(role)
+        @request.json["#{role}_security_token"]
+      end
+
+      # Arguments:
+      # * role:: Can be either :client or :server
+      def token_available?(role)
+        !!get_token(role)
+      end
+
+      # A string is generated using
+      # * role:: "client" or "server"
+      # * date:: Date in the format "YYYY-MM-DD"
+      # * salt:: A shared salt
+      # * resource_id:: The resource's identifier
+      # and concatenated as "role:date:salt:resource_id".
+      #
+      # A SHA1 digest is generated off of the string to create a token.
+      #
+      # 3 tokens are generated: [yesterday, today, tomorrow].
+      def generate_tokens(role)
+        salt = @config["security_salt"]
+        now = Time.now
+        yesterday = (now - 24*60*60).strftime("%Y-%m-%d")
+        today = now.strftime("%Y-%m-%d")
+        tomorrow = (now + 24*60*60).strftime("%Y-%m-%d")
+        resource_id = @request.json["resource_identifier"]
+        [
+          Digest::SHA1.hexdigest("#{role}:#{yesterday}:#{salt}:#{resource_id}"),
+          Digest::SHA1.hexdigest("#{role}:#{today}:#{salt}:#{resource_id}"),
+          Digest::SHA1.hexdigest("#{role}:#{tomorrow}:#{salt}:#{resource_id}")
+        ]
+      end
+
+      # If "security_salt" is set in the config, authorization is performed.
+      #
+      # A string is generated using
+      # * role:: "client" or "server"
+      # * date:: Date in the format "YYYY-MM-DD"
+      # * salt:: A shared salt
+      # * resource_id:: The resource's identifier
+      # and concatenated as "role:date:salt:resource_id".
+      #
+      # A SHA1 digest is generated off of the string to create a token. A token
+      # for yesterday, today, and tomorrow are generated and used to compare
+      # with the security token.
+      #
+      # When authorization fails, an error is raised. Authorization can fail in
+      # 2 ways.
+      # * AuthorizationRequired:: The role's security token is missing
+      # * AuthorizationFailed:: The security token did not match the generated token
+      #
+      # If authorization is successful, true is returned.
+      #
+      # Arguments:
+      # * role:: Can be either :client or :server
+      def authorize(role)
+        if @config["security_salt"]
+          raise SnapImage::AuthorizationRequired unless token_available?(role)
+          raise SnapImage::AuthorizationFailed unless generate_tokens(role).include?(get_token(role))
+        end
+        return true
+      end
+    end
+  end
+end

data/lib/snapimage/server_actions/server_actions.delete_resource_images.rb

@@ -0,0 +1,23 @@
+module SnapImage
+  module ServerActions
+    class DeleteResourceImages
+      include SnapImage::ServerActions::Authorize
+
+      def initialize(config, request, response)
+        @config = config
+        @storage = config.storage
+        @request = request
+        @response = response
+      end
+
+      def call
+        authorize(:server)
+        @response.set_success(
+          message: "Delete Resource Images Successful",
+          deleted_image_urls: @storage.delete_resource_images(@request.json["resource_identifier"])
+        )
+        @response
+      end
+    end
+  end
+end

data/lib/snapimage/server_actions/server_actions.generate_image.rb

@@ -0,0 +1,167 @@
+module SnapImage
+  module ServerActions
+    class GenerateImage
+      include SnapImage::ServerActions::Authorize
+
+      def initialize(config, request, response)
+        @config = config
+        @storage = config.storage
+        @request = request
+        @response = response
+      end
+
+      def call
+        authorize(:client)
+        if request_valid?
+          image = get_image_for_modification
+          parts = SnapImage::ImageNameUtils.get_image_name_parts(image.public_url)
+          result = modify_image(image)
+          modified_image = result[:image]
+          modified_image_name = result[:name]
+          stored_image = @storage.add_image(modified_image, modified_image_name, @request.json["resource_identifier"])
+          @response.set_success(
+            message: "Get Modified Image Successful",
+            image_url: stored_image.public_url,
+            image_width: stored_image.width,
+            image_height: stored_image.height
+          )
+        else
+          @response.set_bad_request
+        end
+        @response
+      end
+
+      private
+
+      # Returns true if the request is valid. False otherwise.
+      def request_valid?
+        source_image_defined?
+      end
+
+      # Returns true if either "file" or JSON "url" is defined.
+      def source_image_defined?
+        !!(@request.file || @request.json["url"])
+      end
+
+      # Returns true if the image is being uploaded. False otherwise.
+      def upload?
+        @request.file || !@storage.local?(@request.json["url"])
+      end
+
+      # Returns true if cropping is required. False otherwise.
+      def crop?
+        @request.json["crop_x"] || @request.json["crop_y"] || @request.json["crop_width"] || @request.json["crop_height"]
+      end
+
+      # Returns true if all the cropping values are defined. False otherwise.
+      def crop_valid?
+        @request.json["crop_x"] && @request.json["crop_y"] && @request.json["crop_width"] && @request.json["crop_height"]
+      end
+
+      # Returns true if resizing is required. False otherwise.
+      def resize?
+        @request.json["width"] || @request.json["height"]
+      end
+
+      # Returns true if the image is too large and needs to be resized to fit.
+      # False otherwise.
+      def resize_to_fit?(image)
+        image.width > get_max_width || image.height > get_max_height
+      end
+
+      # Returns true if sharpening is required. False otherwise
+      def sharpen?
+        @request.json["sharpen"]
+      end
+
+      # Gets the max width. Takes the lesser of the JSON "max_width" or the
+      # server max width.
+      def get_max_width
+        server_max_width = @config["max_width"]
+        [(@request.json["max_width"] && @request.json["max_width"].to_i || server_max_width), server_max_width].min
+      end
+
+      # Gets the max height. Takes the lesser of the JSON "max_height" or the
+      # server max height.
+      def get_max_height
+        server_max_height = @config["max_height"]
+        [(@request.json["max_height"] && @request.json["max_height"].to_i || server_max_height), server_max_height].min
+      end
+
+      def get_image_for_modification
+        if upload?
+          # Add the image to the storage.
+          if @request.file
+            image = @storage.add_upload(@request.file, @request.json["resource_identifier"])
+          else
+            image = @storage.add_url(@request.json["url"], @request.json["resource_identifier"])
+          end
+        else
+          # Get the base image.
+          raise SnapImage::InvalidImageIdentifier unless SnapImage::ImageNameUtils.valid?(@request.json["url"])
+          image = @storage.get(SnapImage::ImageNameUtils.get_base_image_path(@request.json["url"]))
+        end
+        image
+      end
+
+      # Arguments:
+      # * image:: SnapImage::Image object that represents the base image
+      def modify_image(image)
+        parts = SnapImage::ImageNameUtils.get_image_name_parts(image.public_url)
+
+        # Crop.
+        cropped = crop?
+        crop = nil
+        if cropped
+          raise SnapImage::BadRequest, "Missing crop values." unless crop_valid?
+          crop = {
+            x: @request.json["crop_x"],
+            y: @request.json["crop_y"],
+            width: @request.json["crop_width"],
+            height: @request.json["crop_height"]
+          }
+          image = image.crop(crop[:x], crop[:y], crop[:width], crop[:height])
+        end
+
+        # Resize.
+        resized = resize?
+        if resized
+          width = @request.json["width"] && @request.json["width"].to_i
+          height = @request.json["height"] && @request.json["height"].to_i
+          if width && height
+            # When both width and height are specified, resize without
+            # maintaining the aspect ratio.
+            image = image.resize(width, height, false)
+          else
+            # When only one of width/height is specified, set the other to the
+            # max and maintain the aspect ratio.
+            image = image.resize(width || @config["max_width"], height || @config["max_height"])
+          end
+        end
+
+        # Resize to fit.
+        resized_to_fit = resize_to_fit?(image)
+        image = image.resize(get_max_width, get_max_height) if resized_to_fit
+
+        # Sharpen.
+        sharpened = sharpen?
+        image = image.sharpen if sharpened
+
+        # Get the dimensions at the end.
+        if cropped || resized || resized_to_fit || sharpened
+          modifications = {
+            crop: crop || { x: 0, y: 0, width: parts[:original_dimensions][0], height: parts[:original_dimensions][1] },
+            width: image.width,
+            height: image.height,
+            sharpen: sharpened
+          }
+          name = SnapImage::ImageNameUtils.generate_image_name(parts[:original_dimensions][0], parts[:original_dimensions][1], parts[:extname], {basename: parts[:basename]}.merge(modifications))
+        else
+          name = parts[:filename]
+        end
+
+        { image: image, name: name }
+      end
+    end
+  end
+end

data/lib/snapimage/server_actions/server_actions.list_resource_images.rb

@@ -0,0 +1,23 @@
+module SnapImage
+  module ServerActions
+    class ListResourceImages
+      include SnapImage::ServerActions::Authorize
+
+      def initialize(config, request, response)
+        @config = config
+        @storage = config.storage
+        @request = request
+        @response = response
+      end
+
+      def call
+        authorize(:server)
+        @response.set_success(
+          message: "List Resource Images Successful",
+          image_urls: @storage.get_resource_urls(@request.json["resource_identifier"])
+        )
+        @response
+      end
+    end
+  end
+end