scales-worker 0.0.1.beta.1

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Thomas Fankhauser
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/bin/scales-worker

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'scales-worker'
+
+Scales.try_to_setup_env!
+Scales::Worker.run!

data/lib/scales-worker.rb

@@ -0,0 +1,19 @@
+require "scales-worker/boot/autoload"
+
+module Scales
+  module Worker
+    autoload :Application,  "scales-worker/application"
+    autoload :Job,          "scales-worker/job"
+    autoload :Response,     "scales-worker/response"
+    autoload :Worker,       "scales-worker/worker"
+    autoload :Pusher,       "scales-worker/pusher"
+    autoload :Cache,        "scales-worker/cache"
+    autoload :Path,         "scales-worker/path"
+    autoload :Status,       "scales-worker/status"
+  end
+  
+  autoload :Up,             "scales/up"
+end
+
+require "scales-worker/version"
+require "scales-worker/base"

data/lib/scales-worker/application.rb

@@ -0,0 +1,7 @@
+module Scales
+  module Worker
+    module Application
+      autoload :Rails, "scales-worker/application/rails"
+    end
+  end
+end

data/lib/scales-worker/application/rails.rb

@@ -0,0 +1,38 @@
+module Scales
+  module Worker
+    module Application
+      module Rails
+        ENV['RAILS_ENV'] ||= Scales.env
+        
+        class << self
+        
+          @@app = nil
+        
+          def initialize_app!
+            @@app ||= load_application.initialize!
+            raise "Could not load Rails Application" if @@app.nil?
+            @@app
+          end
+          alias_method :app,                      :initialize_app!
+          alias_method :initialize_environment!,  :initialize_app!
+          
+          def name
+            "Rails #{app.class.to_s.split("::").first} (#{ENV['RAILS_ENV']})"
+          end
+    
+          private
+          
+          def load_application
+            before_modules = Object.constants
+            require './config/application.rb'
+            after_modules  = Object.constants
+            delta_modules  = after_modules - before_modules
+            
+            Kernel.const_get(delta_modules.last)::Application
+          end
+    
+        end
+      end
+    end
+  end
+end

data/lib/scales-worker/base.rb

@@ -0,0 +1,52 @@
+module Scales
+  module Worker
+    class << self
+      
+      def run!
+        Worker.new.work!
+      end
+      
+    end
+  end
+  
+  # Cache Methods
+  class << self
+    
+    def push(params)
+      Worker::Cache::Push.push(params)
+    end
+    
+    def append(params)
+      Worker::Cache.class_for(params).append(params)
+    end
+    
+    def prepend(params)
+      Worker::Cache.class_for(params).prepend(params)
+    end
+    
+    def set(params)
+      Worker::Cache.class_for(params).set(params)
+    end
+    
+    def replace(params)
+      Worker::Cache.class_for(params).replace(params)
+    end
+    
+    def remove(format, params)
+      Worker::Cache.class_for(format).remove(params)
+    end
+    
+    def destroy(*paths)
+      Worker::Cache::Destroy.destroy(*paths)
+    end
+    
+    def update(*paths, params)
+      Worker::Cache::Update.update(*paths, params)
+    end
+    
+    def get(path)
+      Storage::Sync::get_content(path)
+    end
+        
+  end
+end

data/lib/scales-worker/boot/autoload.rb

@@ -0,0 +1,9 @@
+require 'scales-core'
+
+autoload :Rake,     "scales-worker/boot/initializers/rake"
+autoload :Nokogiri, "scales-worker/boot/initializers/nokogiri"
+autoload :JsonPath, "scales-worker/boot/initializers/jsonpath"
+
+module Rake
+  autoload :TaskLib, "scales-worker/boot/initializers/rake"
+end

data/lib/scales-worker/boot/initializers/jsonpath.rb

@@ -0,0 +1 @@
+require 'jsonpath'

data/lib/scales-worker/boot/initializers/nokogiri.rb

@@ -0,0 +1 @@
+require 'nokogiri'

data/lib/scales-worker/boot/initializers/rake.rb

@@ -0,0 +1,2 @@
+require 'rake'
+require 'rake/tasklib'

data/lib/scales-worker/cache.rb

@@ -0,0 +1,28 @@
+module Scales
+  module Worker
+    module Cache
+      autoload :HTML,     "scales-worker/cache/html"
+      autoload :JSON,     "scales-worker/cache/json"
+      autoload :XML,      "scales-worker/cache/xml"
+      autoload :Push,     "scales-worker/cache/push"
+      autoload :Destroy,  "scales-worker/cache/destroy"
+      autoload :Update,   "scales-worker/cache/update"
+      
+      class << self
+        
+        def class_for params_or_format
+          params = params_or_format.is_a?(Symbol) ? { params_or_format => nil } : params_or_format
+          
+          return HTML if params.keys.include?(:html)
+          return JSON if params.keys.include?(:json)
+          return XML  if params.keys.include?(:xml)
+        end
+        
+        def resource_or_partial?(path)
+          (path =~ /^\//) ? "resource" : "partial"
+        end
+        
+      end
+    end
+  end
+end

data/lib/scales-worker/cache/destroy.rb

@@ -0,0 +1,28 @@
+module Scales
+  module Worker
+    module Cache
+      module Destroy
+        class << self
+        
+          def destroy(*paths)
+            paths.each do |path|
+              publish_destroy(path)
+              Storage::Sync.del_content(path)
+            end
+          end
+          
+          private
+          
+          def publish_destroy(path)
+            data = {
+              :path   => path,
+              :type   => "destroy_#{Cache.resource_or_partial?(path)}"
+            }
+            Storage::Sync.connection.publish "scales_monitor_events", data.to_json
+          end
+          
+        end
+      end
+    end
+  end
+end

data/lib/scales-worker/cache/html.rb

@@ -0,0 +1,72 @@
+module Scales
+  module Worker
+    module Cache
+      module HTML
+        include Helper::ContentTypes
+        
+        class << self
+          
+          def append(params = {})
+            html = params[:html]
+            path = params[:to] || params[:at]
+            change_content_at(path, params[:select]) do |selection|
+              selection.each{ |element| element.children.last.after html }
+            end
+          end
+          
+          def prepend(params = {})
+            html = params[:html]
+            path = params[:to] || params[:at]
+            change_content_at(path, params[:select]) do |selection|
+              selection.each{ |element| element.children.first.before html }
+            end
+          end
+          
+          def set(params = {})
+            html = params[:html]
+            path = params[:to] || params[:at]
+            change_content_at(path, params[:select]) do |selection|
+              selection.each{ |element| element.inner_html = html }
+            end
+          end
+          
+          def replace(params = {})
+            html = params[:html]
+            path = params[:to] || params[:at]
+            change_content_at(path, params[:select]) do |selection|
+              selection.each{ |element| element.replace html }
+            end
+          end
+          
+          def remove(params = {})
+            path = params[:to] || params[:at]
+            change_content_at(path, params[:select]) do |selection|
+              selection.each{ |element| element.remove }
+            end
+          end
+          
+          
+          private
+          
+          def is_html_page?(page)
+            page.match /<html>/
+          end
+          
+          def change_content_at path, selector
+            raise 'No path defined like this :to => "/tracks"'          if path.nil?
+            raise 'No selector defined like this :select => "#tracks"'  if selector.nil?
+
+            html = Storage::Sync.get_content(path)
+            html = is_html_page?(html) ? Nokogiri::HTML.parse(html) : Nokogiri::HTML.fragment(html)
+            
+            yield html.css(selector)
+            
+            Storage::Sync.set_content(path, html.inner_html)
+            html.inner_html
+          end
+                
+        end
+      end
+    end
+  end
+end

data/lib/scales-worker/cache/json.rb

@@ -0,0 +1,68 @@
+module Scales
+  module Worker
+    module Cache
+      module JSON
+        include Helper::ContentTypes
+        
+        class << self
+          
+          def append(params = {})
+            json = params[:json]
+            path = params[:to] || params[:at]
+            change_content_at(path, params[:select]) do |selection, selector|
+              selection.gsub(selector){ |selection| selection << parse(json) }
+            end
+          end
+          
+          def prepend(params = {})
+            json = params[:json]
+            path = params[:to] || params[:at]
+            change_content_at(path, params[:select]) do |selection, selector|
+              selection.gsub(selector){ |selection| (selection.reverse << parse(json)).reverse }
+            end
+          end
+          
+          def set(params = {})
+            json = params[:json]
+            path = params[:to] || params[:at]
+            change_content_at(path, params[:select]) do |selection, selector|
+              selection.gsub(selector){ |selection| selection = parse(json) }
+            end
+          end
+          
+          def replace(params = {})
+            set(params)
+          end
+          
+          def remove(params = {})
+            path = params[:to] || params[:at]
+            change_content_at(path, params[:select]) do |selection, selector|
+              selection.delete(selector)
+            end
+          end
+          
+          
+          private
+          
+          def parse(json)
+            ::JSON.parse(json)
+          end
+          
+          def change_content_at path, selector
+            raise 'No path defined like this :to => "/tracks.json"'          if path.nil?
+            raise 'No selector defined like this :select => "#tracks"'  if selector.nil?
+            
+            json = Storage::Sync.get_content(path)
+            json = JsonPath.for(json)
+            
+            json = yield json, selector
+            
+            Storage::Sync.set_content(path, json.to_hash.to_json)
+            json
+          end
+                
+        end
+      end
+    end
+  end
+end

data/lib/scales-worker/cache/push.rb

@@ -0,0 +1,35 @@
+module Scales
+  module Worker
+    module Cache
+      module Push
+        include Helper::ContentTypes
+        
+        class << self
+        
+          def push(params = {})
+            path = params.delete(:to)
+            format, content = params.to_a.first
+            raise "Don't know where to push, missing :to => '/a/path' parameter"  if path.nil?
+            raise "Unknown format :#{format}"                                     if format.to_content_type.nil?
+            
+            publish_push(path, format)                                    
+            Storage::Sync.set_content(path, content)
+            content
+          end
+          
+          private
+          
+          def publish_push(path, format)
+            data = {
+              :path   => path,
+              :format => format.to_s.upcase,
+              :type   => "push_#{Cache.resource_or_partial?(path)}"
+            }
+            Storage::Sync.connection.publish "scales_monitor_events", data.to_json
+          end
+        
+        end
+      end
+    end
+  end
+end

data/lib/scales-worker/cache/update.rb

@@ -0,0 +1,20 @@
+module Scales
+  module Worker
+    module Cache
+      module Update
+        include Helper::ContentTypes
+        
+        class << self
+        
+          def update(*paths, params)
+            raise "Please define a format like this :format => :html" unless params.is_a?(Hash)
+            format = params.delete(:format)
+            raise "Unknown format :#{format}"                         if format.to_content_type.nil?
+            paths.each{ |path| Thread.current[:post_process_queue] << { :format => format, :to => path }}
+          end
+        
+        end
+      end
+    end
+  end
+end

data/lib/scales-worker/cache/xml.rb

@@ -0,0 +1,68 @@
+module Scales
+  module Worker
+    module Cache
+      module XML
+        include Helper::ContentTypes
+        
+        class << self
+          
+          def append(params = {})
+            xml = params[:xml]
+            path = params[:to] || params[:at]
+            change_content_at(path, params[:select]) do |selection|
+              selection.each{ |element| element.children.last.after xml }
+            end
+          end
+          
+          def prepend(params = {})
+            xml = params[:xml]
+            path = params[:to] || params[:at]
+            change_content_at(path, params[:select]) do |selection|
+              selection.each{ |element| element.children.first.before xml }
+            end
+          end
+          
+          def set(params = {})
+            xml = params[:xml]
+            path = params[:to] || params[:at]
+            change_content_at(path, params[:select]) do |selection|
+              selection.each{ |element| element.inner_html = xml }
+            end
+          end
+          
+          def replace(params = {})
+            xml = params[:xml]
+            path = params[:to] || params[:at]
+            change_content_at(path, params[:select]) do |selection|
+              selection.each{ |element| element.replace xml }
+            end
+          end
+          
+          def remove(params = {})
+            path = params[:to] || params[:at]
+            change_content_at(path, params[:select]) do |selection|
+              selection.each{ |element| element.remove }
+            end
+          end
+          
+          
+          private
+          
+          def change_content_at path, selector
+            raise 'No path defined like this :to => "/tracks.xml"'      if path.nil?
+            raise 'No selector defined like this :select => "/tracks"'  if selector.nil?
+            
+            xml = Storage::Sync.get_content(path)
+            xml = Nokogiri::XML.parse(xml)
+            
+            yield xml.xpath(selector)
+            
+            Storage::Sync.set_content(path, xml.inner_html)
+            xml.inner_html
+          end
+                
+        end
+      end
+    end
+  end
+end

data/lib/scales-worker/job.rb

@@ -0,0 +1,15 @@
+module Scales
+  module Worker
+    module Job
+      class << self
+    
+        def to_env(job)
+          env = JSON.parse(job)
+          env['rack.input'] = StringIO.new(env['rack.input'])
+          env
+        end
+    
+      end
+    end
+  end
+end

data/lib/scales-worker/path.rb

@@ -0,0 +1,89 @@
+module Scales
+  module Worker
+    module Path
+      include Helper::ContentTypes
+      
+      class << self
+        
+        def parse_path(original_path)
+          path, query = original_path.split "?"
+          [original_path, path, query]
+        end
+        
+        def with_options_to_env(options)
+          full, path, query = parse_path(options[:to])
+          content_type      = options[:format].to_content_type
+          
+          {
+            "GATEWAY_INTERFACE"=>"CGI/1.1",
+            "CONTENT_TYPE" => content_type,
+            "PATH_INFO"=>path,
+            "QUERY_STRING"=>query,
+            "REMOTE_ADDR"=>"127.0.0.1",
+            "REMOTE_HOST"=>"loopback",
+            "REQUEST_METHOD"=>"GET",
+            "REQUEST_URI"=>"http://localhost:3000#{full}",
+            "SCRIPT_NAME"=>"",
+            "SERVER_NAME"=>"localhost",
+            "SERVER_PORT"=>"3000",
+            "SERVER_PROTOCOL"=>"HTTP/1.1",
+            "SERVER_SOFTWARE"=>"Scales-Server #{Scales::Worker::VERSION}",
+            "HTTP_HOST"=>"localhost:3000",
+            "HTTP_USER_AGENT"=>"Scales-Worker #{Scales::Worker::VERSION}",
+            "HTTP_ACCEPT"=>"*/*",
+            "HTTP_COOKIE"=>"",
+            "HTTP_ACCEPT_LANGUAGE"=>"en-us",
+            "HTTP_ACCEPT_ENCODING"=>"gzip, deflate",
+            "HTTP_CONNECTION"=>"keep-alive",
+            "rack.version"=>[1, 1],
+            "rack.input"=>StringIO.new,
+            "rack.multithread"=>false,
+            "rack.multiprocess"=>false,
+            "rack.run_once"=>false,
+            "rack.url_scheme"=>"http",
+            "HTTP_VERSION"=>"HTTP/1.1",
+            "REQUEST_PATH"=>path,
+            "ORIGINAL_FULLPATH"=>full
+          }
+        end
+    
+        def to_env(options, env)
+          full, path, query = parse_path(options[:to])
+          content_type      = options[:format].to_content_type rescue env["CONTENT_TYPE"]
+          {
+            "GATEWAY_INTERFACE"=>"CGI/1.1",
+            "CONTENT_TYPE" => content_type,
+            "PATH_INFO"=>path,
+            "QUERY_STRING"=>query,
+            "REMOTE_ADDR"=>"127.0.0.1",
+            "REMOTE_HOST"=>"loopback",
+            "REQUEST_METHOD"=>"GET",
+            "REQUEST_URI"=>"http://localhost:3000#{full}",
+            "SCRIPT_NAME"=>"",
+            "SERVER_NAME"=>"localhost",
+            "SERVER_PORT"=>"3000",
+            "SERVER_PROTOCOL"=>"HTTP/1.1",
+            "SERVER_SOFTWARE"=>"Scales-Server #{Scales::Worker::VERSION}",
+            "HTTP_HOST"=>"localhost:3000",
+            "HTTP_USER_AGENT"=>"Scales-Worker #{Scales::Worker::VERSION}",
+            "HTTP_ACCEPT"=>"*/*",
+            "HTTP_COOKIE"=>env["HTTP_COOKIE"],
+            "HTTP_ACCEPT_LANGUAGE"=>env["HTTP_ACCEPT_LANGUAGE"],
+            "HTTP_ACCEPT_ENCODING"=>env["HTTP_ACCEPT_ENCODING"],
+            "HTTP_CONNECTION"=>"keep-alive",
+            "rack.version"=>[1, 1],
+            "rack.input"=>StringIO.new,
+            "rack.multithread"=>false,
+            "rack.multiprocess"=>false,
+            "rack.run_once"=>false,
+            "rack.url_scheme"=>"http",
+            "HTTP_VERSION"=>"HTTP/1.1",
+            "REQUEST_PATH"=>path,
+            "ORIGINAL_FULLPATH"=>full
+          }
+        end
+    
+      end
+    end
+  end
+end

data/lib/scales-worker/pusher.rb

@@ -0,0 +1,75 @@
+module Scales
+  module Worker
+    class Pusher
+      attr_reader :app
+      attr_reader :type
+      attr_reader :total
+      attr_reader :done
+      attr_reader :progress
+    
+      def initialize(type = Application::Rails)
+        @type, @app = type, type.app
+        reset_progress!
+      end
+      
+      def reset_progress!
+        @total, @done = 0, 0
+      end
+      
+      def progress
+        ((@done.to_f / @total.to_f) * 100).to_i rescue 0
+      end
+
+      def process!(path)
+        env = Path.with_options_to_env(path)
+        
+        response  = @app.call(env)
+        response.last.close
+        
+        Storage::Sync.set_content(path[:to], Response.to_string(response)) if path[:push]
+        
+        env
+      end
+      
+      def post_process!(env)
+        while path = Thread.current[:post_process_queue].pop
+          request = Path.to_env(path, env)
+          
+          begin
+            response  = @app.call(request)
+            response.last.close
+          rescue Exception => e
+            puts e
+          end
+        end
+      end
+      
+      # Process a single path in thread
+      def process_push!(path)
+        Thread.current[:post_process_queue] = []
+        env = process!(path)
+        post_process!(env)
+        @done += 1
+      end
+      
+      def push!(paths)
+        raise "No Paths added".red if paths.nil? or paths.empty?
+        
+        puts "Environment:    #{Scales.env}".green
+        puts "Application:    #{@type.name}".green
+        puts "Path:           #{Dir.pwd}".green
+        puts "Redis:          #{Scales.config.host}:#{Scales.config.port}/#{Scales.config.database}".green
+        
+        @total, @done = paths.size, 0
+        paths.each do |path|
+          print "Pushing paths:  #{progress}% (#{@done}/#{@total})".green
+          process_push!(path)
+          print "\r"
+        end
+        
+        puts "Pushing paths:  #{progress}% (#{@done}/#{@total})".green
+        puts "Done.".green
+      end
+    end
+  end
+end

data/lib/scales-worker/response.rb

@@ -0,0 +1,40 @@
+module Scales
+  module Worker
+    module Response
+      class << self
+    
+        def to_job(id, response)
+          status, headers, chunked_body = response
+          
+          headers = headers.dup.keep_if do |key, value|
+            key.match /^HTTP_/ or
+            [
+              'Location', 
+              'Content-Type', 
+              'Set-Cookie',
+              'REQUEST_METHOD',
+              'SCRIPT_NAME',
+              'PATH_INFO',
+              'QUERY_STRING',
+              'SERVER_NAME',
+              'SERVER_PORT'
+            ].include?(key)
+          end
+          headers['scales.id'] = id
+          
+          body = ""
+          chunked_body.each{ |chunk| body << chunk }
+          
+          [status, headers, body]
+        end
+        
+        def to_string(response)
+          body = ""
+          response.last.each{ |chunk| body << chunk }
+          body
+        end
+    
+      end
+    end
+  end
+end

data/lib/scales-worker/status.rb

@@ -0,0 +1,72 @@
+module Scales
+  module Worker
+    
+    class Status
+      attr_reader :key, :id, :address, :port
+      
+      def initialize address, port = nil
+        @id   = SecureRandom.hex(8)
+        @key  = "scales_worker_#{@id}"
+        @address, @port = address.to_s, port.to_s
+      end
+      
+      def start!
+        data  = {
+          :id         => @id,
+          :key        => @key,
+          :type       => "worker_started",
+          :spawned_at => Time.now.to_i,
+          :env        => Scales.env,
+          :ip         => @address,
+          :port       => @port
+        }
+        json = JSON.generate(data)
+        
+        Storage::Sync.connection.set(@key, json)
+        Storage::Sync.connection.publish("scales_monitor_events", json)
+        @already_stopped = false
+      end
+      
+      def stop!
+        return if @already_stopped
+        
+        data  = {
+          :id         => @id,
+          :key        => @key,
+          :type       => "worker_stopped"
+        }
+        json = JSON.generate(data)
+        Storage::Sync.connection.del(@key)
+        Storage::Sync.connection.publish("scales_monitor_events", json)
+        @already_stopped = true
+      end
+      
+      def took_request_from_queue!(job)
+        data  = {
+          :id         => job['scales.id'],
+          :worker_id  => @id,
+          :type       => "worker_took_request_from_queue",
+          :path       => job['PATH_INFO'],
+          :method     => job['REQUEST_METHOD']
+        }
+        json = JSON.generate(data)
+        Storage::Sync.connection.publish("scales_monitor_events", json)
+      end
+      
+      def put_response_in_queue!(response)
+        data  = {
+          :id         => response[1]['scales.id'],
+          :worker_id  => @id,
+          :type       => "worker_put_response_in_queue",
+          :path       => response[1]['PATH_INFO'],
+          :method     => response[1]['REQUEST_METHOD'],
+          :status     => response[0]
+        }
+        json = JSON.generate(data)
+        Storage::Sync.connection.publish("scales_monitor_events", json)
+      end
+      
+    end  
+    
+  end
+end

data/lib/scales-worker/version.rb

@@ -0,0 +1,5 @@
+module Scales
+  module Worker
+    VERSION = "0.0.1.beta.1" unless defined?(Scales::Worker::VERSION)
+  end
+end

data/lib/scales-worker/worker.rb

@@ -0,0 +1,85 @@
+module Scales
+  module Worker
+    class Worker
+      attr_reader :app
+      attr_reader :type
+    
+      def initialize(type = Application::Rails)
+        @type, @app, @status = type, type.app, Status.new("localhost")
+        at_exit{ @status.stop! }
+      end
+      
+      def parse(job)
+        Job.to_env(job)
+      end
+      
+      def process!(job)
+        env = parse(job)
+        id  = env['scales.id']
+        
+        @status.took_request_from_queue!(env)
+        
+        begin
+          response  = @app.call(env)
+          response.last.close
+          [id, Response.to_job(id, response)]
+        rescue
+          [id, [500, {}, ""]]
+        end
+      end
+      
+      def post_process!(job)
+        env = parse(job)
+        while path = Thread.current[:post_process_queue].pop
+          request = Path.to_env(path, env)
+          
+          begin
+            response  = @app.call(request)
+            response.last.close
+          rescue Exception => e
+            puts e
+          end
+        end
+      end
+      
+      # Wait for a request, process it, publish the response and exit
+      def process_request!(should_wait_for_request_to_finish = false)
+        job = Scales::Queue::Sync.pop
+        id, response = nil, nil
+        
+        Thread.abort_on_exception = true
+        thread = Thread.new do
+          Thread.current[:post_process_queue] = []
+          id, response = process!(job)
+          print "#{id} -> " + "#{response.first}".green + " - #{Thread.current[:post_process_queue].size} post jobs -> "
+          post_process!(job)
+          print "done".green + " - publishing -> "
+          @status.put_response_in_queue!(response)
+          Scales::PubSub::Sync.publish("scales_response_#{id}", JSON.generate(response))
+          puts "done".green
+        end
+        
+        thread.join if should_wait_for_request_to_finish
+        
+        [id, response]
+      end
+      
+      # Loop the processing of requests
+      def work!
+        @status.start!
+        
+        puts "Environment:    #{Scales.env}".green
+        puts "Application:    #{@type.name}".green
+        puts "Path:           #{Dir.pwd}".green
+        puts "Redis:          #{Scales.config.host}:#{Scales.config.port}/#{Scales.config.database}".green
+        
+        begin
+          loop{ process_request! }
+        rescue Interrupt => e
+          puts "Goodbye".green
+        end
+      end
+    
+    end
+  end
+end

data/lib/scales/up.rb

@@ -0,0 +1,51 @@
+module Scales
+  class Up < ::Rake::TaskLib
+    include ::Rake::DSL if defined?(::Rake::DSL)
+    include Helper::ContentTypes
+    
+    attr_reader :name
+    attr_reader :app
+    attr_accessor :paths
+
+    def push format, options
+      paths << { :format => format, :push => true }.merge(options)
+    end
+    
+    def update *new_paths, params
+      raise "Please define a format like this :format => :html" unless params.is_a?(Hash)
+      format = params.delete(:format)
+      raise "Unknown format :#{format}"                         if format.to_content_type.nil?
+      new_paths.each{ |path| paths << { :format => format, :to => path }}
+    end
+
+    def initialize(*args)
+      @name   = args.shift || :up
+      @paths  = []
+      @app    = nil
+      @pusher = Scales::Worker::Pusher.new
+      
+      desc "Scale up task" unless ::Rake.application.last_comment
+      task name do
+        RakeFileUtils.send(:verbose, verbose) do
+          @app = Up.application.initialize_environment!
+
+          yield self if block_given?
+          
+          @pusher.push!(@paths)
+        end
+      end
+    end
+    
+    class << self
+      @@application = Worker::Application::Rails
+      
+      def application
+        @@application
+      end
+      
+      def application=(application)
+        @@application = application
+      end
+    end
+  end
+end

data/lib/scales/up/rails.rb

@@ -0,0 +1,3 @@
+require 'scales-worker'
+
+Scales::Up.application = Scales::Worker::Application::Rails

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification
+name: scales-worker
+version: !ruby/object:Gem::Version
+  version: 0.0.1.beta.1
+  prerelease: 6
+platform: ruby
+authors:
+- Thomas Fankhauser
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: scales-core
+  requirement: &70223081169640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 0.0.1.beta.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *70223081169640
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: &70223081168560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.6
+  type: :runtime
+  prerelease: false
+  version_requirements: *70223081168560
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &70223081167480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.6
+  type: :runtime
+  prerelease: false
+  version_requirements: *70223081167480
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70223081166840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70223081166840
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70223081166000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.2.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *70223081166000
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: &70223081165260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.5.5
+  type: :runtime
+  prerelease: false
+  version_requirements: *70223081165260
+- !ruby/object:Gem::Dependency
+  name: jsonpath
+  requirement: &70223081164100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70223081164100
+description: Super Scale Caching Framework - Worker
+email:
+- tommylefunk@googlemail.com
+executables:
+- scales-worker
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- lib/scales/up/rails.rb
+- lib/scales/up.rb
+- lib/scales-worker/application/rails.rb
+- lib/scales-worker/application.rb
+- lib/scales-worker/base.rb
+- lib/scales-worker/boot/autoload.rb
+- lib/scales-worker/boot/initializers/jsonpath.rb
+- lib/scales-worker/boot/initializers/nokogiri.rb
+- lib/scales-worker/boot/initializers/rake.rb
+- lib/scales-worker/cache/destroy.rb
+- lib/scales-worker/cache/html.rb
+- lib/scales-worker/cache/json.rb
+- lib/scales-worker/cache/push.rb
+- lib/scales-worker/cache/update.rb
+- lib/scales-worker/cache/xml.rb
+- lib/scales-worker/cache.rb
+- lib/scales-worker/job.rb
+- lib/scales-worker/path.rb
+- lib/scales-worker/pusher.rb
+- lib/scales-worker/response.rb
+- lib/scales-worker/status.rb
+- lib/scales-worker/version.rb
+- lib/scales-worker/worker.rb
+- lib/scales-worker.rb
+- !binary |-
+  YmluL3NjYWxlcy13b3JrZXI=
+homepage: http://itscales.org
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Launches an instance of a rack app like Rails and processes jobs from the
+  request queue.
+test_files: []