apphunkd 0.9.0

data/config/environment.rb

@@ -0,0 +1,23 @@
+# Be sure to restart your daemon when you modify this file
+
+# Uncomment below to force your daemon into production mode
+#ENV['DAEMON_ENV'] ||= 'production'
+
+# Boot up
+require File.join(File.dirname(__FILE__), 'boot')
+
+DaemonKit::Initializer.run do |config|
+
+  # The name of the daemon as reported by process monitoring tools
+  config.daemon_name = 'apphunkd'
+
+  # Force the daemon to be killed after X seconds from asking it to
+  # config.force_kill_wait = 30
+
+  # Log backraces when a thread/daemon dies (Recommended)
+  # config.backtraces = true
+
+  # Configure the safety net (see DaemonKit::Safety)
+  # config.safety_net.handler = :mail # (or :hoptoad )
+  # config.safety_net.mail.host = 'localhost'
+end

data/config/environments/development.rb

@@ -0,0 +1,2 @@
+# This is the same context as the environment.rb file, it is only
+# loaded afterwards and only in the development environment

data/config/environments/production.rb

@@ -0,0 +1,2 @@
+config.pid_file = '/var/run/apphunkd.pid'
+config.log_path = '/var/log/apphunkd.log'

data/config/environments/test.rb

@@ -0,0 +1,2 @@
+# This is the same context as the environment.rb file, it is only
+# loaded afterwards and only in the test environment

data/config/post-daemonize/readme

@@ -0,0 +1,5 @@
+# You can place files in here to be loaded after the code is daemonized.
+#
+# All the files placed here will just be required into the running
+# process. This is the correct place to open any IO objects, establish
+# database connections, etc.

data/config/pre-daemonize/readme

@@ -0,0 +1,12 @@
+# You can place files in here to be loaded before the code is daemonized.
+#
+# DaemonKit looks for a file named '<config.daemon_name>.rb' and loads
+# that file first, and inside a DaemonKit::Initializer block. The
+# remaning files then simply required into the running process.
+# 
+# These files are mostly useful for operations that should fail blatantly
+# before daemonizing, like loading gems.
+#
+# Be careful not to open any form of IO in here and expecting it to be
+# open inside the running daemon since all IO instances are closed when
+# daemonizing (including STDIN, STDOUT & STDERR).

data/config/pre-daemonize/requires.rb

@@ -0,0 +1,2 @@
+require 'rubygems'
+require 'sinatra/base'

data/lib/apphunkd.rb

@@ -0,0 +1,25 @@
+module Apphunkd
+  
+  autoload :API,    'apphunkd/api'
+  autoload :Queue,  'apphunkd/queue'
+  autoload :Remote, 'apphunkd/remote'
+  
+  class << self
+
+    attr_accessor :queue
+
+    def run!
+      initialize_queue
+      initialize_api_service
+    end
+
+    def initialize_queue
+      self.queue = Queue.new
+      self.queue.activate!
+    end
+
+    def initialize_api_service
+      API::Service.run! :port => '8212', :host => '127.0.0.1'
+    end
+  end
+end

data/lib/apphunkd/api.rb

@@ -0,0 +1,5 @@
+module Apphunkd
+  module API
+    autoload :Service, 'apphunkd/api/service'
+  end
+end

data/lib/apphunkd/api/service.rb

@@ -0,0 +1,27 @@
+module Apphunkd
+  module API
+
+    class Service < Sinatra::Base
+      set :sessions, false
+      set :environment, DaemonKit.env.to_sym
+
+      post '/api/messages' do
+        if Apphunkd.queue.store(params)
+          status 201
+        else
+          status 400
+        end
+      end
+
+      not_found do
+        "Not found. The requested resources doesn't exist."
+      end
+
+      error do
+        'Hoppla. Some internal stuff has crashed.'
+      end
+    end
+
+  end
+end
+

data/lib/apphunkd/queue.rb

@@ -0,0 +1,96 @@
+module Apphunkd
+  class Queue
+
+    attr_accessor :items
+    attr_accessor :mutex
+    attr_accessor :worker
+
+    def initialize
+      @items = []
+      @mutex = Mutex.new
+    end
+
+    def activate!
+      @worker = initialize_worker
+    end
+
+    def store(message = {})
+      return false if message[:body].blank? || message[:token].blank?
+      message[:stored_at] = Time.now
+
+      @mutex.synchronize do
+        @items = @items[-9999..-1] if @items.size >= 9999
+        @items << message
+      end
+
+      @worker.wakeup
+      return true
+    end
+
+    def initialize_worker
+      Thread.new do
+        begin
+          loop do
+            unless @items.empty?
+              items = get_items_from_stack
+              items.each do |item|
+                result = push_item_to_remote_service(item)
+                if result.status == :ok
+                  case result.response.code
+                  when '201'
+                    # Everything fine
+                  when '400', '403'
+                    log_error "Remote Service refused to store item: #{result.response.code} / #{result.response.body}. Dropped."
+                  else
+                    put_item_to_stack(item)
+                    log_error "Remote Service went crazy. Put item back in queue: #{result.response.code} / #{result.response.body}"
+                  end
+                else
+                  put_item_to_stack(item)
+                  log_error "Could not push to Remote Service: Connection Error. Put item back in queue."
+                end
+              end
+            end
+            sleep
+          end
+        rescue => e
+          log_error "Error: #{e}"
+        end
+      end
+    end
+
+
+    private
+
+      def get_items_from_stack
+        copied_items = []
+        @mutex.synchronize do
+          copied_items = @items.dup
+          @items.clear
+        end
+        return copied_items
+      end
+
+      def put_item_to_stack(item)
+        @mutex.synchronize { @items << item }
+      end
+
+      def push_item_to_remote_service(item)
+        url = generate_api_messages_url(item.delete('token'))
+        result = Apphunkd::Remote.post(url, item, 300)
+      end
+
+      def generate_api_messages_url(token)
+        path = "api/v1/#{token}/messages"
+        if DaemonKit.env.to_s == 'production'
+          "http://apphunk.com/#{path}"
+        else
+          "http://apphunk.local/#{path}"
+        end
+      end
+
+      def log_error(message)
+        DaemonKit.logger.info message
+      end
+  end
+end

data/lib/apphunkd/remote.rb

@@ -0,0 +1,29 @@
+require 'net/http'
+require 'timeout'
+require 'uri'
+
+module Apphunkd
+  module Remote
+    
+    autoload :Result, 'apphunkd/remote/result'
+    
+    class << self
+      
+      def post(url, payload = {}, post_timeout = 30)
+        begin
+          Timeout.timeout(post_timeout) do
+            uri = URI.parse(url)
+            result = Remote::Result.new(:response => Net::HTTP.post_form(uri, payload))
+            result.status = :ok
+            return result
+          end
+        rescue SocketError
+          Remote::Result.new(:status => :connection_error)
+        rescue Timeout::Error
+          Remote::Result.new(:status => :timeout)
+        end
+      end
+      
+    end
+  end
+end

data/lib/apphunkd/remote/result.rb

@@ -0,0 +1,15 @@
+module Apphunkd
+  module Remote
+    class Result
+      
+      attr_accessor :status
+      attr_accessor :response
+      
+      def initialize(opts = {})
+        self.status = opts.delete(:status)
+        self.response = opts.delete(:response)
+      end
+      
+    end
+  end
+end

data/libexec/apphunkd-daemon.rb

@@ -0,0 +1,13 @@
+# Do your post daemonization configuration here
+
+# At minimum you need just the first line (without the block), or a lot
+# of strange things might start happening...
+DaemonKit::Application.running! do |config|
+  # Trap signals with blocks or procs
+  # config.trap( 'INT' ) do
+  #   # do something clever
+  # end
+  # config.trap( 'TERM', Proc.new { puts 'Going down' } )
+end
+
+Apphunkd.run!

data/script/console

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../config/boot'
+require 'daemon_kit/commands/console'

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:daemon, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:daemon]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/spec/lib/apphunkd/api/service_spec.rb

@@ -0,0 +1,47 @@
+require File.dirname(__FILE__) + '/../../../spec_helper.rb'
+require 'rack/test'
+
+describe Apphunkd::API::Service do
+  include Rack::Test::Methods
+
+  def app
+    Apphunkd::API::Service
+  end
+
+  before(:each) do
+    @queue = mock('Queue')
+    Apphunkd.queue = @queue
+  end
+
+  it 'should be an instance of Sinatra::Base' do
+    Apphunkd::API::Service.new.should be_kind_of(Sinatra::Base)
+  end
+
+  describe 'POST /api/messages' do
+    it 'should store a message in the queue' do
+      @queue.should_receive(:store).with("params" => 'test')
+      post '/api/messages', :params => 'test'
+    end
+  
+    it 'should return status 201 on success' do
+      @queue.stub!(:store).and_return(true)
+      post '/api/messages', :params => 'test'
+      last_response.status.should eql(201)
+    end
+  
+    it 'should return status 400 on failure' do
+      @queue.stub!(:store).and_return(false)
+      post '/api/messages'
+      last_response.status.should eql(400)
+    end
+  end
+
+  context 'error handling' do
+    it 'should return status 404 not found' do
+      post '/api/not-existing-resource'
+      last_response.status.should eql(404)
+      last_response.body.should include('Not found')
+    end
+  end
+end
+

data/spec/lib/apphunkd/queue_spec.rb

@@ -0,0 +1,129 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+describe Apphunkd::Queue do
+  before(:each) do
+    @queue = Apphunkd::Queue.new
+    @queue.stub!(:initialize_worker).and_return('worker')
+  end
+
+  describe '#initialize' do
+    it 'should create a new Mutex' do
+      @queue.mutex.should be_kind_of(Mutex)
+    end
+
+    it 'should prepare the items list' do
+      @queue.items.should be_kind_of(Array)
+      @queue.items.count.should be(0)
+    end
+
+  end
+
+  describe '#activate!' do
+    it 'should initialize the worker' do
+      @queue.activate!
+      @queue.worker.should eql('worker')
+    end
+  end
+
+  describe '#store' do
+    before(:each) do
+      @queue.worker = mock('Worker instance')
+      @queue.worker.stub!(:wakeup)
+    end
+
+    it 'should return false if message or token is missing' do
+      @queue.store().should be_false
+      @queue.store(:token => 'test').should be_false
+      @queue.store(:body => 'test').should be_false
+    end
+
+    it 'should wrap the store stuff into a mutex' do
+      @queue.mutex.should_receive(:synchronize)
+      store_message
+    end
+    
+    it 'should add stored_at to the message object' do
+      store_message
+      @message[:stored_at].should be_kind_of(Time)
+    end
+
+    it 'should add the message to the end of the items list' do
+      store_message
+      @queue.items.should include(@message)
+    end
+
+    it 'should remove the oldest messages from the list to ensure that there are at max 10000 messages queued' do
+      @queue.items = [1] * 10000
+      store_message
+      @queue.items.size.should eql(10000)
+    end
+
+    it 'should wakeup the worker after appending a message' do
+      @queue.worker.should_receive(:wakeup)
+      store_message
+    end
+
+    it 'should return true after successfully storing a message' do
+      store_message.should be_true
+    end
+    
+    def store_message
+      @message = { :body => 'test', :token => 'test' }
+      @queue.store(@message)
+    end
+  end
+
+  describe '#get_items_from_stack' do
+    before(:each) do
+      @queue.items = ["i1", "i2"]
+    end
+
+    it 'should create a local copy from the items array' do
+      @queue.items.stub!(:clear)
+      items_copy = @queue.send(:get_items_from_stack)
+      items_copy.should eql(@queue.items)
+      items_copy.object_id.should_not be(@queue.items.object_id)
+    end
+
+    it 'should synchronize via mutex during copy' do
+      @queue.mutex.should_receive(:synchronize)
+      @queue.send(:get_items_from_stack)
+    end
+
+    it 'should clear the original items array' do
+      @queue.send(:get_items_from_stack)
+      @queue.items.should be_empty
+    end
+  end
+
+  describe '#put_item_to_stack' do
+    it 'should append an item to the queue stack' do
+      @queue.send(:put_item_to_stack, 'i3')
+      @queue.items.should include('i3')
+    end
+
+    it 'should synchronize via mutex during append' do
+      @queue.mutex.should_receive(:synchronize)
+      @queue.send(:put_item_to_stack, 'i3')
+    end
+  end
+  
+  describe '#push_item_to_remote_service' do
+    before(:each) do
+      @item = { 'token' => 'secret', 'message' => 'hallo welt' }
+      @queue.stub!(:generate_api_messages_url).and_return('http://api.com/secret/')
+      Apphunkd::Remote.stub!(:post)
+    end
+    
+    it "should generate the api url, including the item's token" do
+      @queue.should_receive(:generate_api_messages_url).with('secret')
+      @queue.send(:push_item_to_remote_service, @item)
+      @item.should_not include('token')
+    end
+    
+    it "should post to the url, including the item" do
+      Apphunkd::Remote.should_receive(:post).with('http://api.com/secret/', { 'message' => 'hallo welt' }, 300)
+      @queue.send(:push_item_to_remote_service, @item)
+    end
+  end  
+end