ungulate 0.1.4 → 0.2.0

data/VERSION

@@ -1 +1 @@
-0.1.4
+0.2.0

data/bin/ungulate_server.rb

@@ -1,18 +1,33 @@
 #!/usr/bin/env ruby
 
-require 'ungulate/server'
+require File.expand_path('../lib/ungulate', File.dirname(__FILE__))
+require 'optparse'
 
-if ARGV[0].nil?
-  $stderr.puts "Must provide a queue name after calling the server"
-  exit 1
+logger = Logger.new $stderr
+
+options = {
+  :config => File.expand_path('../config/ungulate', File.dirname(__FILE__))
+}
+
+cmdline_options = OptionParser.new do |opts|
+  opts.banner = "Usage: ungulate_server.rb [options]"
+
+  opts.on '-c', '--config CONFIG' do |config|
+    options[:config] = config
+  end
 end
 
-logger = Logger.new STDERR
+cmdline_options.parse!
+
+require options[:config]
 
 loop do
   begin
-    processed_something = Ungulate::Server.run(ARGV[0]) 
-    sleep(ENV['SLEEP'] || 2) unless processed_something
+    processed_something = Ungulate::Server.run
+    sleep(Ungulate.configuration.server_sleep || 2) unless processed_something
+  rescue Ungulate::MissingConfiguration => e
+    logger.error e.message
+    exit 1
   rescue StandardError => e
     logger.error e.message
   end

data/features/image_resize.feature

@@ -5,19 +5,9 @@ Feature: Image resize
 
   Background:
     Given an empty queue
+    And an empty bucket
 
-  Scenario: Run queue on image key with no path separator
-    Given a request to resize "image.jpg" to sizes:
-      | label | width | height  |
-      | large | 200   | 100     |
-      | small | 100   | 50      |
-    When I run Ungulate
-    Then there should be the following public versions:
-      | key             |
-      | image_large.jpg |
-      | image_small.jpg |
-
-  Scenario: Run queue on image key with path separator
+  Scenario: Run queue that has one image job
     Given a request to resize "some/path/to/image.jpg" to sizes:
       | label | width | height  |
       | large | 200   | 100     |

data/features/notification_url.feature

@@ -0,0 +1,14 @@
+Feature: Notification URL
+  As a developer
+  I want Ungulate to PUT to a URL when it's finished a job
+  So that I don't have to poll for the completed resource
+
+  Background:
+    Given an empty queue
+    And an empty bucket
+
+  Scenario: Run queue that has one image job
+    Given a request that has a notification URL
+    When I run Ungulate
+    Then the notification URL should receive a PUT
+

data/features/resize_then_composite.feature

@@ -1,10 +1,11 @@
-Feature: Image resize
+Feature: Image resize then composite
   As a site owner
   I want Ungulate to resize then composite images
   So that I don't have to watermark images by hand
 
   Scenario: Run queue on image key with no path separator
     Given an empty queue
+    And an empty bucket
     And a request to resize "image.jpg" and then composite with "https://dmxno528jhfy0.cloudfront.net/superhug-watermark.png"
     When I run Ungulate
     Then there should be a public watermarked version

data/features/step_definitions/bucket_steps.rb

@@ -0,0 +1,4 @@
+Given /^an empty bucket$/ do
+  bucket.clear
+end
+

data/features/step_definitions/command_steps.rb

@@ -1,9 +1,18 @@
 require 'ostruct'
+require 'ungulate'
 
 When /^I run Ungulate$/ do
   @errors = OpenStruct.new :write => ''
   $stderr = @errors
-  Ungulate::Server.run @queue_name
+
+  Ungulate.configure do |config|
+    config.queue_name = QUEUE_NAME
+    config.queue_server = sqs_server
+  end
+
+  10.times do
+    break if Ungulate::Server.run
+  end
 end
 
 Then /^there should be no errors$/ do

data/features/step_definitions/notification_steps.rb

@@ -0,0 +1,23 @@
+Given /^a request that has a notification URL$/ do
+  key = 'bobbyjpeg'
+
+  bucket.put key, File.open('features/camels.jpg').read
+
+  message = {
+    :bucket => BUCKET_NAME,
+    :key => key,
+    :notification_url => 'http://localhost:9999/bob',
+    :versions => {
+      :medium => [
+        [:resize_to_fill, 100, 100],
+      ]
+    }
+  }.to_yaml
+
+  send_message(message)
+end
+
+Then /^the notification URL should receive a PUT$/ do
+  File.read(TEST_FILE.path).should == 'http://localhost:9999/bob'
+end
+

data/features/step_definitions/queue_steps.rb

@@ -1,19 +1,10 @@
 Given /^an empty queue$/ do
-  sqs = RightAws::SqsGen2.new(ENV['AMAZON_ACCESS_KEY_ID'],
-                              ENV['AMAZON_SECRET_ACCESS_KEY'])
-  @queue_name = 'ungulate-test-queue'
-  @q = sqs.queue @queue_name
+  @q = sqs.queue QUEUE_NAME
   @q.clear
 end
 
 Given /^a request to resize "([^\"]*)" to sizes:$/ do |key, table|
-  @bucket_name = "ungulate-test"
-
-  @s3 = RightAws::S3.new(ENV['AMAZON_ACCESS_KEY_ID'],
-                         ENV['AMAZON_SECRET_ACCESS_KEY'])
-  @bucket = @s3.bucket @bucket_name
-  @bucket.put key, File.open('features/camels.jpg').read
-
+  bucket.put key, File.open('features/camels.jpg').read
 
   versions = table.rows.inject({}) do |hash, row|
     label, width, height = row
@@ -22,24 +13,19 @@ Given /^a request to resize "([^\"]*)" to sizes:$/ do |key, table|
   end
 
   message = {
-    :bucket => @bucket_name,
+    :bucket => BUCKET_NAME,
     :key => key,
     :versions => versions
   }.to_yaml
 
-  @q.send_message(message)
+  send_message(message)
 end
 
 Given /^a request to resize "([^"]*)" and then composite with "([^"]*)"$/ do |key, composite_url|
-  @bucket_name = "ungulate-test"
-
-  @s3 = RightAws::S3.new(ENV['AMAZON_ACCESS_KEY_ID'],
-                         ENV['AMAZON_SECRET_ACCESS_KEY'])
-  @bucket = @s3.bucket @bucket_name
-  @bucket.put key, File.open('features/camels.jpg').read
+  bucket.put key, File.open('features/camels.jpg').read
 
   message = {
-    :bucket => @bucket_name,
+    :bucket => BUCKET_NAME,
     :key => key,
     :versions => {
       :watermarked => [
@@ -49,5 +35,5 @@ Given /^a request to resize "([^"]*)" and then composite with "([^"]*)"$/ do |ke
     }
   }.to_yaml
 
-  @q.send_message(message)
+  send_message(message)
 end

data/features/step_definitions/version_steps.rb

@@ -1,5 +1,5 @@
 Then /^there should be the following public versions:$/ do |table|
-  Net::HTTP.start("#{@bucket_name}.s3.amazonaws.com", 80) do |http|
+  Net::HTTP.start("#{BUCKET_NAME}.s3.amazonaws.com", 80) do |http|
     table.rows.flatten.each do |key|
       response = http.get("/#{key}")
       response.should be_a(Net::HTTPSuccess)
@@ -8,7 +8,7 @@ Then /^there should be the following public versions:$/ do |table|
 end
 
 Then /^there should be a public watermarked version$/ do
-  Net::HTTP.start("#{@bucket_name}.s3.amazonaws.com", 80) do |http|
+  Net::HTTP.start("#{BUCKET_NAME}.s3.amazonaws.com", 80) do |http|
     response = http.get("/image_watermarked.jpg")
     response.should be_a(Net::HTTPSuccess)
   end

data/features/{support.rb → support/config.rb}

@@ -1,2 +1,6 @@
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'lib/ungulate'
+require 'ruby-debug'
+
+QUEUE_NAME = 'ungulate-test-queue'
+BUCKET_NAME = 'ungulate-test'

data/features/support/helpers.rb

@@ -0,0 +1,21 @@
+require 'right_aws'
+
+def bucket
+  s3 = RightAws::S3.new(ENV['AMAZON_ACCESS_KEY_ID'],
+                        ENV['AMAZON_SECRET_ACCESS_KEY'])
+  s3.bucket BUCKET_NAME
+end
+
+def sqs_server
+  'sqs.eu-west-1.amazonaws.com'
+end
+
+def sqs
+  sqs = RightAws::SqsGen2.new(ENV['AMAZON_ACCESS_KEY_ID'],
+                              ENV['AMAZON_SECRET_ACCESS_KEY'],
+                              :server => sqs_server)
+end
+
+def send_message(message)
+  @q.send_message message
+end

data/features/support/put_server.rb

@@ -0,0 +1,22 @@
+require 'tempfile'
+
+TEST_FILE = Tempfile.new('put request')
+
+pid = fork do
+  require 'webrick'
+
+  class PutServlet < WEBrick::HTTPServlet::AbstractServlet
+    def do_PUT(req, resp)
+      TEST_FILE << req.request_uri
+      TEST_FILE.close
+      raise WEBrick::HTTPStatus::OK
+    end
+  end
+
+  server = WEBrick::HTTPServer.new(:Port => 9999)
+  server.mount('/bob', PutServlet)
+  server.start
+end
+
+at_exit { Process.kill('KILL', pid) }
+

data/lib/ungulate.rb

@@ -1,7 +1,71 @@
 require 'rubygems'
+require 'bundler/setup'
+
+require 'hashie'
 require 'ungulate/server'
+require 'ungulate/job'
+require 'ungulate/sqs_message_queue'
+require 'ungulate/blob_processor'
+require 'ungulate/rmagick_version_creator'
+require 'ungulate/s3_storage'
+require 'ungulate/curl_http'
 
 module Ungulate
+  class Configuration < Hashie::Mash; end
+  class MissingConfiguration < StandardError; end
+
+  def self.configuration
+    @config ||=
+      begin
+        config = Configuration.new
+
+        amazon_credentials = lambda {
+          {
+            :access_key_id => config.access_key_id || ENV['AMAZON_ACCESS_KEY_ID'],
+            :secret_access_key => config.secret_access_key || ENV['AMAZON_SECRET_ACCESS_KEY']
+          }
+        }
+
+        config.queue = lambda {
+          SqsMessageQueue.new(
+            config.queue_name,
+            amazon_credentials.call.merge(:server => config.queue_server)
+          )
+        }
+
+        config.http = lambda {
+          CurlHttp.new
+        }
+
+        config.version_creator = lambda {
+          RmagickVersionCreator.new(:http => config.http.call)
+        }
+
+        config.storage = lambda {
+          S3Storage.new(amazon_credentials.call)
+        }
+
+        config.blob_processor = lambda {
+          BlobProcessor.new(
+            :version_creator => config.version_creator.call
+          )
+        }
+
+        config.job_processor = lambda {
+          Job.new(
+            :blob_processor => config.blob_processor.call,
+            :storage => config.storage.call,
+            :http => config.http.call
+          )
+        }
+
+        config
+      end
+  end
+
+  def self.configure(&block)
+    yield configuration
+  end
 end
 
 if defined? ActionView::Base

data/lib/ungulate/blob_processor.rb

@@ -0,0 +1,34 @@
+module Ungulate
+  class BlobProcessor
+    def initialize(options)
+      @creator = options[:version_creator]
+    end
+
+    def process(options)
+      versions = options.delete(:versions)
+      blob = options.delete(:blob)
+      original_key = options.delete(:original_key)
+      bucket = options.delete(:bucket)
+
+      versions.each_pair do |name, instructions|
+        stored_data = @creator.create(blob, instructions)
+
+        bucket.store(
+          new_key(original_key, name),
+          stored_data[:blob],
+          :version => name,
+          :content_type => stored_data[:content_type]
+        )
+      end
+    end
+
+    protected
+
+    def new_key(original, version)
+      dirname = File.dirname(original)
+      extname = File.extname(original)
+      basename = File.basename(original, extname)
+      "#{dirname}/#{basename}_#{version}#{extname}".sub(/^\.\//, '')
+    end
+  end
+end

data/lib/ungulate/curl_http.rb

@@ -0,0 +1,25 @@
+require 'curb'
+
+module Ungulate
+  class CurlHttp
+    def initialize(options = {})
+      @easy = Curl::Easy
+      @logger = options[:logger] || ::Logger.new($stdout)
+    end
+
+    def get_body(url)
+      @logger.info "GET via HTTP: #{url}"
+      @easy.http_get(url).body_str
+    end
+
+    def put(url)
+      @logger.info "PUT #{url}"
+      @response = @easy.http_put(url, '')
+      self
+    end
+
+    def code
+      @response.response_code
+    end
+  end
+end

data/lib/ungulate/file_upload.rb

@@ -1,23 +1,21 @@
 require 'active_support/core_ext/class/attribute_accessors'
+require 'active_support/json'
+
 class Ungulate::FileUpload
-  attr_accessor(
-    :bucket_url,
-    :key
-  )
+  attr_accessor :bucket_url, :key
 
-  cattr_accessor(
-    :access_key_id,
-    :queue_name,
-    :secret_access_key
-  )
+  class << self
+    def config
+      Ungulate.configuration
+    end
 
-  def self.enqueue(job_description)
-    queue.send_message(job_description.to_yaml)
-  end
+    def queue
+      @queue ||= config.queue.call
+    end
 
-  def self.queue
-    sqs = RightAws::SqsGen2.new(access_key_id, secret_access_key)
-    sqs.queue(queue_name)
+    def enqueue(job_description)
+      queue.push(job_description.to_yaml)
+    end
   end
 
   def initialize(options = {})
@@ -29,6 +27,14 @@ class Ungulate::FileUpload
     end
   end
 
+  def config
+    self.class.config
+  end
+
+  def access_key_id
+    config.access_key_id
+  end
+
   def acl
     condition 'acl'
   end
@@ -62,7 +68,7 @@ class Ungulate::FileUpload
   def signature
     Base64.encode64(
       OpenSSL::HMAC.digest(OpenSSL::Digest::Digest.new('sha1'),
-                           secret_access_key,
+                           config.secret_access_key,
                            policy)
     ).gsub("\n", '')
   end