snapimage 0.0.1

data/lib/snapimage/server_actions/server_actions.sync_resource.rb

@@ -0,0 +1,78 @@
+module SnapImage
+  module ServerActions
+    class SyncResource
+      include SnapImage::ServerActions::Authorize
+
+      def initialize(config, request, response)
+        @config = config
+        @storage = config.storage
+        @request = request
+        @response = response
+      end
+
+      def call
+        authorize(:server)
+        if request_valid?
+          @response.set_success(
+            message: "Image Sync Successful",
+            deleted_image_urls: sync
+          )
+        else
+          @response.set_bad_request
+        end
+        @response
+      end
+
+      private
+
+      # Returns true if the request is valid. False otherwise.
+      def request_valid?
+        !!(content_valid? && @request.json["sync_date_time"])
+      end
+
+      # Returns true if "content" in the request is valid. False otherwise.
+      def content_valid?
+        content = @request.json["content"]
+        !!(content && content.is_a?(Hash) && !content.empty?)
+      end
+
+      # Concatenates all the content and returns it.
+      def get_content
+        @request.json["content"].values.inject("") { |result, element| result + element }
+      end
+
+      def urls_to_keep
+        content = get_content
+        keep = {}
+        @storage.url_regexps.each do |regexp|
+          # We use #scan instead of #match because #match returns only the
+          # first match. #scan will return all matches that don't overlap.
+          # However, #scan does not behave like #match. If the regexp contains
+          # groupings, #scan returns only the matched groups. Otherwise, it
+          # returns the entire match.
+          # To normalize, we take the given regexp and always wrap it in a
+          # group to ensure that the regexp always has a group and we always
+          # get back the entire match.
+          content.scan(Regexp.new("(#{regexp.source})", regexp.options)).each do |match|
+            keep[match[0]] = true
+            # If the image is modified, make sure to keep the base image too.
+            if !SnapImage::ImageNameUtils.base_image?(match[0])
+              keep[SnapImage::ImageNameUtils.get_base_image_path(match[0])] = true
+            end
+          end
+        end
+        keep.keys
+      end
+
+      def sync
+        urls_to_delete = @storage.get_resource_urls(
+          @request.json["resource_identifier"],
+          # DateTime only deals with years and days. We need to convert to a
+          # Time first to handle seconds, then convert back to a DateTime.
+          (DateTime.parse(@request.json["sync_date_time"]).to_time - 3).to_datetime
+        ) - urls_to_keep
+        urls_to_delete.each { |url| @storage.delete(url) }
+      end
+    end
+  end
+end

data/lib/snapimage/storage/storage.rb

@@ -0,0 +1,120 @@
+module SnapImage
+  class Storage
+    TYPES = %w{LOCAL}
+    FILE_TYPES = %w{png jpg gif}
+
+
+    def initialize(server_configs, primary_server_name, max_width, max_height)
+      @server_configs = server_configs
+      # TODO: Remove this once we figure out how to handle multiple servers.
+      raise SnapImage::InvalidConfig, "Only one storage server can be specified at the moment" unless @server_configs.size == 1
+      @primary_server_name = primary_server_name
+      @max_width = max_width
+      @max_height = max_height
+    end
+
+    # Returns an array of all the url regexps that are handled by the storage.
+    def url_regexps
+      @url_regexps ||= servers.values.map { |s| s.url_regexp }
+    end
+
+    # Returns true if the url is local to the storage. False otherwise.
+    def local?(url)
+      !!get_server_by_url(url)
+    end
+
+    # Adds the image to the storage and returns the public url to the file.
+    # Arguments:
+    # * file:: SnapImage::RequestFile
+    # * resource_id:: Resource identifier
+    def add_upload(file, resource_id)
+      raise UnknownFileType, "Unknown file type for upload: #{file.type}" unless FILE_TYPES.include?(file.type)
+      primary_server.store_file(file.file, file.type, resource_id)
+    end
+
+    # Adds the image to the storage from the url.
+    # If the image is from a storage server, nothing happens.
+    # If the image is from another place, the image is downloaded and added to
+    # the primary storage server.
+    # The image is returned.
+    # Arguments:
+    # * url:: A full url to the image
+    # * resource_id:: Resource identifier
+    def add_url(url, resource_id)
+      # If the url is local, then the image should already be in the storage.
+      return get(url) if get_server_by_url(url)
+      type = ImageNameUtils.get_image_type(url)
+      raise UnknownFileType, "Unknown file type for upload: #{type}" unless FILE_TYPES.include?(type)
+      primary_server.store_url(url, type, resource_id)
+    end
+
+    # Adds the image to the storage.
+    # Arguments:
+    # * image:: SnapImage::Image object
+    # * name:: Name of the image
+    # * resource_id:: Resource identifier
+    def add_image(image, name, resource_id)
+      primary_server.store_image(image, name, resource_id)
+    end
+
+    # Returns a SnapImage::Image using the url.
+    def get(url)
+      get_server_by_url(url).get(url)
+    end
+
+    # Returns all the image urls for the given resource in the storage.
+    # Arguments:
+    # * resource_id:: Filter by resource identifier
+    # * timestamp:: Only images that were updated before the DateTime
+    def get_resource_urls(resource_id, timestamp = nil)
+      servers.values.inject([]) { |urls, server| urls + server.get_resource_urls(resource_id, timestamp) }
+    end
+
+    # Deletes the given url from the storage.
+    # Arguments:
+    # * url:: URL to delete
+    def delete(url)
+      get_server_by_url(url).delete(url)
+    end
+
+    # Deletes all the image related to the resource.
+    # Arugments:
+    # * resource_id:: Resource identifier
+    def delete_resource_images(resource_id)
+      deleted_urls = []
+      servers.each do |name, server|
+        deleted_urls += server.delete_resource_images(resource_id)
+      end
+      deleted_urls
+    end
+
+    private
+
+    def servers
+      return @servers if @servers
+      @servers = {}
+      @server_configs.each do |config|
+        type = config["type"]
+        @servers[config["name"]] = get_server_class(type).new(config.merge("max_width" => @max_width, "max_height" => @max_height))
+      end
+      @servers
+    end
+
+    def primary_server
+      servers[@primary_server_name]
+    end
+
+    def get_server_class(type)
+      raise SnapImage::InvalidStorageConfig, "Storage server type not supported: #{type}" unless TYPES.include?(type)
+      klassname = type.downcase.split("_").map { |t| t.capitalize }.join("")
+      SnapImage::StorageServer.const_get(klassname)
+    end
+
+    def get_server_by_url(url)
+      servers.each do |name, server|
+        return server if server.local?(url)
+      end
+      return nil
+    end
+  end
+end

data/lib/snapimage/storage/storage_server.local.rb

@@ -0,0 +1,120 @@
+module SnapImage
+  module StorageServer
+    class Local < SnapImage::StorageServer::Base
+      def validate_config
+        super
+        raise InvalidStorageConfig, 'Missing "local_root"' unless @config["local_root"]
+      end
+
+      def store_file(file, type, resource_id)
+        image = SnapImage::Image.from_blob(file.read)
+        name = SnapImage::ImageNameUtils.generate_image_name(image.width, image.height, type)
+        store(image, name, resource_id)
+      end
+
+      def store_url(url, type, resource_id)
+        image = SnapImage::Image.from_blob(URI.parse(url).read)
+        name = SnapImage::ImageNameUtils.generate_image_name(image.width, image.height, type)
+        store(image, name, resource_id)
+      end
+
+      def store_image(image, name, resource_id)
+        store(image, name, resource_id)
+      end
+
+      def get(url)
+        path = public_url_to_local_path(url)
+        raise SnapImage::FileDoesNotExist, "Missing file: #{path}" unless File.exists?(path)
+        SnapImage::Image.from_path(path, url)
+      end
+
+      def get_resource_urls(resource_id, timestamp = nil)
+        urls = []
+        get_resource_filenames(resource_id).each do |filename|
+          urls.push(local_path_to_public_url(filename)) if file_modified_before_timestamp?(filename, timestamp)
+        end
+        urls
+      end
+
+      def delete(url)
+        path = public_url_to_local_path(url)
+        raise SnapImage::FileDoesNotExist, "Missing file: #{path}" unless File.exists?(path)
+        File.delete(path)
+      end
+
+      def delete_resource_images(resource_id)
+        deleted_urls = get_resource_urls(resource_id)
+        FileUtils.rm_rf(File.join(root, resource_id)) if deleted_urls.size > 0
+        deleted_urls
+      end
+
+      private
+
+      # Stores the image and returns a SnapImage::Image object.
+      # If the image does not fit within the server max width/height, the image
+      # is resized and the modified image is returned.
+      # Arguments:
+      # * image:: SnapImage::Image to store
+      # * name:: Suggested name to use
+      # * resource_id:: Resource identifier
+      def store(image, name, resource_id)
+        result = resize_to_fit(image, name)
+        image = result[:image]
+        name = result[:name]
+
+        # Generate the filename and public url.
+        local_path = File.join(resource_id, name)
+        image.public_url = "#{File.join(@config["public_url"], local_path)}"
+
+        # Store the file.
+        path = File.join(root, local_path)
+        # Ensure the directory exists accounting for the resource_id.
+        dir = File.dirname(path)
+        FileUtils.mkdir_p(dir)
+        # Write the file to the storage.
+        File.open(path, "wb") { |f| f.write(image.blob) }
+
+        # Return the image.
+        image
+      end
+
+      def root
+        unless @root_exists
+          FileUtils.mkdir_p(@config["local_root"]) unless File.directory?(@config["local_root"])
+          @root_exists = true
+        end
+        @config["local_root"]
+      end
+
+      def get_local_path_parts(path)
+        match = path.match(/#{root}\/(.+)\/([^\/]+\.(png|jpg|gif))/)
+        return match && {
+          resource_id: match[1],
+          filename: match[2]
+        }
+      end
+
+      def local_path_to_public_url(path)
+        parts = get_local_path_parts(path)
+        "#{File.join(@config["public_url"], parts[:resource_id], parts[:filename])}"
+      end
+
+      def public_url_to_local_path(url)
+        parts = get_url_parts(url)
+        path = File.join(root, parts[:path])
+      end
+
+      def get_resource_filenames(resource_id)
+        Dir.glob(File.join(root, resource_id, "/**/*.{png,jpg,gif}"))
+      end
+
+      # Returns true if no timestamp is given or the file was modified before
+      # the timestamp.
+      def file_modified_before_timestamp?(filename, timestamp = nil)
+        # File.mtime returns a Time object. Convert it to a DateTime because
+        # timestamp is a DateTime.
+        !timestamp || File.mtime(filename).to_datetime < timestamp
+      end
+    end
+  end
+end

data/lib/snapimage/storage/storage_server.rb

@@ -0,0 +1,110 @@
+module SnapImage
+  module StorageServer
+    class Base
+      # Config:
+      # * name:: Name of the storage.
+      # * public_url:: URL to acces the storage.
+      def initialize(config)
+        @config = config
+        validate_config
+      end
+
+      def name
+        @config["name"]
+      end
+
+      # Returns a regular expression for matching urls handled by this storage
+      # server.
+      def url_regexp
+        @url_regexp ||= /#{@config["public_url"]}\/.+?\.(png|gif|jpg)/
+      end
+
+      def local?(url)
+        !!url.match(url_regexp)
+      end
+
+      # Stores the file in the storage and returns a SnapImage::Image object.
+      # Arguments:
+      # * file:: File object representing the file to store.
+      # * type:: File type
+      # * resource_id:: Resource identifier.
+      def store_file(file, type, resource_id)
+        raise "#store_file needs to be overridden."
+      end
+
+      # Downloads the file and adds it to the storage and returns a
+      # SnapImage::Image object.
+      # Arguments:
+      # * url:: Url to get the image
+      # * type:: File type
+      # * resource_id:: Resource identifier.
+      def store_url(url, type, resource_id)
+        raise "#store_url needs to be overridden."
+      end
+
+      # Adds the image to the storage. Overwrites existing file.
+      # Arguments:
+      # * image:: SnapImage::Image object
+      # * name:: Name of the image
+      # * resource_id:: Resource identifier
+      def store_image(image, name, resource_id)
+        raise "#store_image needs to be overridden."
+      end
+
+      # Returns the SnapImage:Image object from the url.
+      def get(url)
+        raise "#get needs to be overriden."
+      end
+
+      # Returns all the image urls for the given resource in the storage.
+      # Arguments:
+      # * resource_id:: Filter by resource identifier
+      # * timestamp:: Only images that were updated before the DateTime
+      def get_resource_urls(resource_id, timestamp = nil)
+        raise "#get_all_urls needs to be overriden."
+      end
+
+      # Deletes the given url.
+      def delete(url)
+        raise "#delete needs to be overridden."
+      end
+
+      # Deletes the given resource images.
+      def delete_resource_images(resource_id)
+        raise "#delete_resource needs to be overridden."
+      end
+
+      private
+
+      # Validates the config. Subclasses should add to this.
+      def validate_config
+        raise InvalidStorageConfig, 'Missing "name"' unless @config["name"]
+        raise InvalidStorageConfig, 'Missing "public_url"' unless @config["public_url"]
+        raise InvalidStorageConfig, 'Missing "max_width"' unless @config["max_width"]
+        raise InvalidStorageConfig, 'Missing "max_height"' unless @config["max_height"]
+      end
+
+      def get_url_parts(url)
+        match = url.match(/^(([a-z]+):|)(#{@config["public_url"]})\/(.+)$/)
+        return match && {
+          protocol: match[2],
+          public_url: match[3],
+          path: match[4]
+        }
+      end
+
+      # Resizes the image if it doesn't fit on the server. Updates the name if
+      # needed.
+      # Returns { image: resized_image, name: resized_name }.
+      def resize_to_fit(image, name)
+        # Resize the image if it's larger than the max width/height.
+        if image.width > @config["max_width"] || image.height > @config["max_height"]
+          resized_image = image.resize([image.width, @config["max_width"]].min, [image.height, @config["max_height"]].min)
+          # Generate a new name.
+          resized_name = SnapImage::ImageNameUtils.get_resized_image_name(name, resized_image.width, resized_image.height)
+        end
+        { image: resized_image || image, name: resized_name || name }
+      end
+    end
+  end
+end

data/lib/snapimage/version.rb

@@ -0,0 +1,3 @@
+module SnapImage
+  VERSION = "0.0.1"
+end

data/snapimage.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/snapimage/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Wesley Wong"]
+  gem.email         = ["wesley@snapeditor.com"]
+  gem.description   = %q{Rack Middleware for handling the SnapImage API}
+  gem.summary       = %q{SnapImage API Rack Middleware}
+  gem.homepage      = "http://SnapEditor.com"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "snapimage"
+  gem.require_paths = ["lib"]
+  gem.version       = SnapImage::VERSION
+
+  gem.add_dependency("rack")
+  gem.add_dependency("rmagick")
+  gem.add_dependency("sinatra")
+  gem.add_dependency("thin")
+  gem.add_dependency("rake")
+
+  gem.add_development_dependency("rspec")
+  gem.add_development_dependency("autotest")
+  gem.add_development_dependency("rack-test")
+end