khronos 0.0.3.pre4 → 0.1.0

data/Gemfile

@@ -12,7 +12,7 @@ group :test do
   gem "delorean", "~> 2.0.0"
   gem "factory_girl", "~> 4.0.0"
   gem "webmock", "~> 1.8.9"
-  #gem "em-spec", ''
+  gem "database_cleaner"
 
   #
   # Used for time functions

data/Gemfile.lock

@@ -0,0 +1,129 @@
+PATH
+  remote: .
+  specs:
+    khronos (0.1.0)
+      activerecord (~> 3.2.8)
+      activesupport (~> 3.2.8)
+      bson_ext (~> 1.6.4)
+      em-http-request (~> 1.0.3)
+      eventmachine (~> 1.0.0.beta.4)
+      girl_friday (~> 0.10.0)
+      json (~> 1.7.5)
+      mongoid (~> 3.0.5)
+      rest-client (~> 1.6.7)
+      sinatra (~> 1.3.3)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.2.8)
+      activesupport (= 3.2.8)
+      builder (~> 3.0.0)
+    activerecord (3.2.8)
+      activemodel (= 3.2.8)
+      activesupport (= 3.2.8)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activesupport (3.2.8)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    addressable (2.3.2)
+    arel (3.0.2)
+    bson (1.6.4)
+    bson_ext (1.6.4)
+      bson (~> 1.6.4)
+    builder (3.0.3)
+    chronic (0.7.0)
+    connection_pool (0.9.2)
+    cookiejar (0.3.0)
+    crack (0.3.1)
+    daemons (1.1.8)
+    database_cleaner (0.8.0)
+    delorean (2.0.0)
+      chronic
+    diff-lcs (1.1.3)
+    em-http-request (1.0.3)
+      addressable (>= 2.2.3)
+      cookiejar
+      em-socksify
+      eventmachine (>= 1.0.0.beta.4)
+      http_parser.rb (>= 0.5.3)
+    em-socksify (0.2.1)
+      eventmachine (>= 1.0.0.beta.4)
+    eventmachine (1.0.0.rc.4)
+    factory_girl (4.0.0)
+      activesupport (>= 3.0.0)
+    fakefs (0.4.0)
+    girl_friday (0.10.0)
+      connection_pool (~> 0.9.0)
+    http_parser.rb (0.5.3)
+    i18n (0.6.1)
+    json (1.7.5)
+    mime-types (1.19)
+    mongo (1.6.4)
+      bson (~> 1.6.4)
+    mongoid (3.0.5)
+      activemodel (~> 3.1)
+      moped (~> 1.1)
+      origin (~> 1.0)
+      tzinfo (~> 0.3.22)
+    moped (1.2.1)
+    multi_json (1.3.6)
+    mysql2 (0.3.11)
+    netrc (0.7.7)
+    origin (1.0.8)
+    pg (0.14.1)
+    rack (1.4.1)
+    rack-protection (1.2.0)
+      rack
+    rack-test (0.6.1)
+      rack (>= 1.0)
+    rest-client (1.6.8)
+      mime-types (>= 1.16)
+      netrc
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.2)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.2)
+    simplecov (0.6.4)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.5.3)
+    simplecov-html (0.5.3)
+    sinatra (1.3.3)
+      rack (~> 1.3, >= 1.3.6)
+      rack-protection (~> 1.2)
+      tilt (~> 1.3, >= 1.3.3)
+    sqlite3 (1.3.6)
+    thin (1.4.1)
+      daemons (>= 1.0.9)
+      eventmachine (>= 0.12.6)
+      rack (>= 1.0.0)
+    tilt (1.3.3)
+    tzinfo (0.3.33)
+    webmock (1.8.9)
+      addressable (>= 2.2.7)
+      crack (>= 0.1.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport (~> 3.2.8)
+  database_cleaner
+  delorean (~> 2.0.0)
+  factory_girl (~> 4.0.0)
+  fakefs (~> 0.4.0)
+  khronos!
+  mongo
+  mysql2 (~> 0.3.11)
+  pg
+  rack-test (~> 0.6.1)
+  rspec (~> 2.11.0)
+  simplecov (= 0.6.4)
+  sqlite3
+  thin
+  webmock (~> 1.8.9)

data/README.md

@@ -1,8 +1,54 @@
 khronos
 ===
 
-Job scheduling for the cloud.
+Simple HTTP-based Job scheduling for the cloud.
 
+Features
+---
+
+  - Schedule of HTTP Requests
+  - Configure recurrency per request
+  - Log HTTP status code for every request made
+  - Query the database via REST API
+  - Postgresql, MySQL and SQLite supported. (mongodb will be supported soon)
+
+How it works
+---
+
+Khronos use a rack app to schedule and query for scheduled tasks, and a worker
+process to execute them in the background.
+
+At 'examples' directory you find two rackup files for these processes.
+
+How to use
+---
+
+Create a scheduled task:
+
+    RestClient.post('http://localhost:3000/task', {
+      :context => 'test',
+      :at => 24.hours.from_now,
+      :task_url => "http://myapp.com/do-something-awesome",
+      :recurrency => 12.hours
+    })
+    # => "{\"active\":true,\"at\":\"2012-09-15T21:24:56-03:00\",\"context\":\"test\",\"id\":1,\"recurrency\":1,\"task_url\":\"http://myapp.com/do-something-awesome\"}"
+
+Query for a scheduled task:
+
+    RestClient.get('http://localhost:3000/task', :params => { :context => 'test' })
+    # => "{\"active\":true,\"at\":\"2012-09-15T21:24:56-03:00\",\"context\":\"test\",\"id\":1,\"recurrency\":1,\"task_url\":\"http://myapp.com/do-something-awesome\"}"
+
+Query for logs for tasks that already ran.
+
+    RestClient.get('http://localhost:3000/schedule/logs', :params => { :status_code => 500 })
+    # => "[{\"id\":3,\"schedule_id\":1,\"started_at\":\"2012-09-15T13:38:48-03:00\",\"status_code\":500},{\"id\":5,\"schedule_id\":2,\"started_at\":\"2012-09-15T13:38:48-03:00\",\"status_code\":500}]"
+
+Note: these examples are using [rest-client](https://github.com/archiloque/rest-client/) and [activesupport](https://github.com/rails/rails/tree/master/activesupport).
+
+Contributing
+---
+
+Feel free to fork and send pull requests with features and/or bug fixes.
 
 License
 ---

data/examples/runner_server.ru

@@ -0,0 +1,17 @@
+ENV['RACK_ENV'] = 'production'
+
+require 'rubygems'
+require 'khronos'
+require 'khronos/version'
+
+require 'girl_friday'
+require 'redis'
+require 'connection_pool'
+
+ENV['REDISTOGO_URL'] ||= "redis://127.0.0.1:6379/0"
+
+$redis = ConnectionPool::Wrapper.new(:size => 2, :timeout => 3) { Redis.connect(:url => ENV["REDISTOGO_URL"]) }
+runner = Khronos::Server::Runner.new(:runner, :store => GirlFriday::Store::Redis, :store_config => { :pool => $redis })
+
+Khronos::Config.instance.load!('config/environment.yml', ENV['RACK_ENV'])
+Khronos::Server::Controller.new(runner).start!

data/examples/scheduler_server.ru

@@ -0,0 +1,8 @@
+ENV['RACK_ENV'] = 'production'
+
+require 'rubygems'
+require 'khronos'
+
+Khronos::Config.instance.load!('config/environment.yml', ENV['RACK_ENV'])
+run Khronos::Server::Scheduler
+

data/khronos.gemspec

@@ -7,11 +7,11 @@ Gem::Specification.new do |s|
   s.version     = Khronos::VERSION
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Endel Dreyer"]
-  s.email       = ["endel@ocapi.com.br"]
-  s.homepage    = "http://github.com/ocapi/khronos"
+  s.email       = ["endel.dreyer@gmail.com"]
+  s.homepage    = "http://github.com/endel/khronos"
 
-  s.summary     = "Ruby HTTP Job Scheduler Interface."
-  s.description = "Ruby HTTP Job Scheduler Interface. An advanced Cron replacement for the cloud."
+  s.summary     = "Simple HTTP-based Job scheduling for the cloud."
+  s.description = "Simple HTTP-based Job scheduling for the cloud."
   s.licenses    = ['MIT']
 
   s.add_dependency "sinatra",         "~> 1.3.3"

data/lib/khronos/scheduler.rb

@@ -8,7 +8,7 @@ module Khronos
       puts "Khronos::Scheduler#run => #{schedule.inspect}"
       schedule.update_attributes(:active => false)
       schedule.save
-      runner.enqueue(schedule)
+      runner.enqueue(schedule) if runner
     end
 
     def self.fetch(target_time=Time.now)

data/lib/khronos/server/runner.rb

@@ -16,32 +16,41 @@ module Khronos
       end
 
       def enqueue(schedule)
-        puts "Khronos::Server::Runner#enqueue => #{schedule.inspect}"
         @queue.push(schedule.to_json)
       end
 
       def process(json)
         schedule = JSON.parse(json)
-        puts "Khronos::Server::Runner#process => #{schedule.inspect}"
-
-        if (url = schedule['task_url'])
-          begin
-            response = RestClient.get(url)
-            puts "Callback: success. response length: #{response.length.inspect}"
-          rescue Exception => e
-            puts "Callback: error. (#{e.inspect})"
-          end
-          calculate_recurrency!(schedule)
-        end
+        schedule_log = { :started_at => Time.now, :schedule_id => schedule['id'] }
+
+        response = RestClient.get(schedule['task_url'])
+        schedule_log[:status_code] = response.code
+
+      rescue RestClient::Exception => e
+        schedule_log[:status_code] = e.http_code
+
+      ensure
+        log_schedule!(schedule_log)
+        calculate_recurrency!(schedule) if schedule['recurrency'].to_i > 0
       end
 
       def calculate_recurrency!(schedule)
-        url = "http://#{Config.instance.scheduler['host']}"
-        url += ":#{Config.instance.scheduler['port']}" if Config.instance.scheduler['port']
-        url += "/task"
-        RestClient.put(url, :id => schedule['id'], :patch => true)
+        RestClient.put(scheduler_route('/task'), :id => schedule['id'], :patch => true)
       end
 
+      def log_schedule!(schedule_log)
+        puts "Log schedule! #{schedule_log.inspect}"
+        RestClient.post( scheduler_route('/schedule/log'), schedule_log )
+      end
+
+      protected
+
+        def scheduler_route(route)
+          url = "http://#{Config.instance.scheduler['host']}"
+          url += ":#{Config.instance.scheduler['port']}" if Config.instance.scheduler['port']
+          url += route
+        end
+
     end
 
   end

data/lib/khronos/server/scheduler.rb

@@ -5,23 +5,16 @@ module Khronos
 
     class Scheduler < Sinatra::Base
       set :storage, Storage.new
+      before { content_type 'application/json' }
 
-      # Introduction
+      # Greetings
+      #
       get '/' do
-        <<-EOF
-        <html>
-          <head>
-            <title>Khronos #{Khronos::VERSION}</title>
-          </head>
-          <body>
-            <h1>HTTP Job Scheduler Interface.</h1>
-            <p>
-              <a href="http://rubygems.org/gems/khronos">Khronos #{Khronos::VERSION}</a><br />
-              by <a href="https://github.com/endel">Endel Dreyer</a>
-            </p>
-          </body>
-        </html>
-        EOF
+        {
+          :name => "Khronos - HTTP Job Scheduler Interface.",
+          :version => Khronos::VERSION,
+          :link => "https://github.com/endel/khronos"
+        }
       end
 
       # Creates a schedule
@@ -97,14 +90,6 @@ module Khronos
         schedule.to_json
       end
 
-      # Checks recurrency and reactivates a schedule if necessary
-      #
-      # @param [String] id
-      #
-      # @return [Hash] data
-      patch '/task' do
-      end
-
       # Force a task to be scheduled right now
       #
       # @param [Integer] id
@@ -116,7 +101,31 @@ module Khronos
         {:queued => !schedule.nil?}.to_json
       end
 
-      # Log requests
+      # Schedule logs querying interface
+      #
+      # @param [Integer] started_at
+      # @param [Integer] schedule_id
+      # @param [Integer] status_code
+      #
+      # @return [Array] list of schedule logs
+      #
+      get '/schedule/logs' do
+        limit = params.delete('limit')
+        offset = params.delete('offset')
+
+        relation = Storage::ScheduleLog.where(params)
+        relation = relation.limit(limit) if limit
+        relation = relation.offset(offset) if offset
+        relation.to_json
+      end
+
+      # Create a schedule log
+      #
+      # @param [Integer] started_at
+      # @param [Integer] status_code
+      post '/schedule/log' do
+        Storage::ScheduleLog.create(params).to_json
+      end
 
     end
 

data/lib/khronos/storage/adapter/activerecord/migrations/schedule.rb

@@ -9,7 +9,7 @@ module Khronos
               t.string    :context,    :null => false, :limit => 100
               t.datetime  :at,         :null => false
               t.string    :task_url,   :null => false
-              t.integer   :recurrency, :null => false
+              t.integer   :recurrency, :null => true,  :default => 0
               t.string    :callbacks,  :null => true,  :limit => 500
               t.boolean   :active,     :null => false, :default => true
             end

data/lib/khronos/storage/adapter/activerecord/migrations/schedule_log.rb

@@ -8,7 +8,8 @@ module Khronos
             create_table :schedule_logs do |t|
               t.integer  :schedule_id,   :null => false
               t.datetime :started_at,    :null => false
-              t.datetime :finished_at,   :null => true
+              t.integer  :status_code,   :null => false
+              t.string   :callbacks
             end
           end
 

data/lib/khronos/storage/adapter/activerecord/schedule_log.rb

@@ -4,7 +4,7 @@ module Khronos
 
       module ActiveRecord
         class ScheduleLog < ::ActiveRecord::Base
-          attr_accessible :schedule_id, :started_at, :finished_at
+          attr_accessible :schedule_id, :started_at, :status_code
           belongs_to :schedule
         end
       end

data/lib/khronos/storage/adapter/mongoid/schedule_log.rb

@@ -7,7 +7,8 @@ module Khronos
           include ::Mongoid::Document
 
           field :started_at,  :type => DateTime
-          field :finished_at, :type => DateTime
+          field :status_code, :type => Integer
+          field :callbacks,   :type => String
 
           belongs_to :schedule
         end

data/lib/khronos/version.rb

@@ -1,3 +1,3 @@
 module Khronos
-  VERSION = '0.0.3.pre4'
+  VERSION = '0.1.0'
 end

data/spec/functional/scheduler_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Khronos::Scheduler do
   subject { Khronos::Scheduler }
-  let(:scheduler) { subject.new }
+  let(:scheduler) { subject }
 
   before(:all) do
     ENV['KHRONOS_STORAGE'] = 'sqlite3://localhost/spec/tmp/scheduler.db'

data/spec/integration/runner_server_spec.rb

@@ -2,25 +2,42 @@ require 'spec_helper'
 
 describe Khronos::Server::Runner do
   subject { Khronos::Server::Runner }
-  let(:recurrency_check_url) { "http://localhost:8080/task?id=1" }
-  let(:task_url) { 'http://test.com' }
+  let(:recurrency_check_url) { "http://localhost:8080/task" }
+  let(:schedule_log_url) { "http://localhost:8080/schedule/log" }
+  let(:valid_task_url) { 'http://test.com' }
+  let(:invalid_task_url) { 'http://test.com/404' }
 
   before(:each) do
-    Khronos::Server::Runner.any_instance.stub(:new)
-    Khronos::Server::Runner.any_instance.stub(:send_data)
-    Khronos::Server::Runner.any_instance.stub(:close_connection)
-
-    stub_request(:get, task_url).to_return(:body => 'it works!', :status => 200)
-    stub_request(:patch, recurrency_check_url).to_return(:status => 200, :body => "", :headers => {})
+    stub_request(:get, valid_task_url).to_return(:body => 'it works!', :status => 200)
+    stub_request(:get, invalid_task_url).to_return(:status => 404)
+    stub_request(:put, recurrency_check_url).with(:id => 1, :patch => true).to_return(:status => 200, :body => "", :headers => {})
   end
 
   it "should run a task" do
+    stub_request(:post, schedule_log_url).with(:schedule_id => 1).to_return(:status => 200, :body => "", :headers => {})
+    stub_request(:post, schedule_log_url).with(:schedule_id => 2, :status_code => 404).to_return(:status => 200, :body => "", :headers => {})
+
     runner = subject.new(nil)
-    EM.run_block do
-      runner.receive_data({:id => 1, :task_url => task_url, :recurrency => 0}.to_json)
+    runner.process({:id => 1, :task_url => valid_task_url, :recurrency => 0}.to_json)
+    runner.process({:id => 2, :task_url => invalid_task_url, :recurrency => 60}.to_json)
+
+    a_request(:get, valid_task_url).should have_been_made
+    a_request(:get, invalid_task_url).should have_been_made
+    a_request(:post, schedule_log_url).with {|r| r.body =~ /schedule_id=2/ && r.body =~ /status_code=404/ }.should have_been_made
+    a_request(:post, schedule_log_url).with {|r| r.body =~ /schedule_id=1/ && r.body =~ /status_code=200/ }.should have_been_made
+    a_request(:put, recurrency_check_url).should have_been_made
+  end
+
+  context "callbacks" do
+
+    xit "should trigger error callback" do
+      # not implemented yet
+    end
+
+    xit "should trigger success callback" do
+      # not implemented yet
     end
-    a_request(:get, task_url).should have_been_made
-    a_request(:patch, recurrency_check_url).should have_been_made
+
   end
 
 end

data/spec/integration/scheduler_server_spec.rb

@@ -7,64 +7,127 @@ describe Khronos::Server::Scheduler do
     Khronos::Server::Scheduler
   end
 
-  it "should return 404 for invalid task requests" do
-    get('/task')
-    last_response.status.should == 404
+  context "tasks" do
+    it "should return 404 for invalid task requests" do
+      get('/task')
+      last_response.status.should == 404
 
-    get('/task', {:context => "invalid"})
-    last_response.status.should == 404
+      get('/task', {:context => "invalid"})
+      last_response.status.should == 404
 
-    get('/task', {:id => 99})
-    last_response.status.should == 404
-  end
+      get('/task', {:id => 99})
+      last_response.status.should == 404
+    end
 
-  it "should schedule context to 1 week" do
-    post('/task', {
-      :context => "1-week-test",
-      :schedule => 1.week,
-      :at => Time.now,
-      :recurrency => 1.week,
-      :task_url => "http://fake"
-    })
-    last_response.status.should == 200
-    Khronos::Storage::Schedule.where(:context => "1-week-test").count.should == 1
-  end
+    it "should schedule context to 1 week" do
+      post('/task', {
+        :context => "1-week-test",
+        :schedule => 1.week,
+        :at => Time.now,
+        :recurrency => 1.week,
+        :task_url => "http://fake"
+      })
+      last_response.status.should == 200
+      Khronos::Storage::Schedule.where(:context => "1-week-test").count.should == 1
 
-  it "should enqueue schedule to run immediatelly" do
-    mock_tcp_next_request("")
-    dummy_schedule = FactoryGirl.create(:schedule)
-    post('/task/run', :id => dummy_schedule.id)
-    last_response.status.should == 200
-    JSON.parse(last_response.body).should == {'queued' => true}
-  end
+      post('/task', {
+        :context => "2-weeks-test",
+        :schedule => 2.weeks,
+        :at => Time.now,
+        :task_url => "http://fake"
+      })
+      last_response.status.should == 200
+      Khronos::Storage::Schedule.where(:context => "2-weeks-test").count.should == 1
+    end
+
+    it "should enqueue schedule to run immediatelly" do
+      dummy_schedule = FactoryGirl.create(:schedule)
+      post('/task/run', :id => dummy_schedule.id)
+      last_response.status.should == 200
+      JSON.parse(last_response.body).should == {'queued' => true}
+    end
+
+    it "should update schedule data" do
+      dummy_schedule = FactoryGirl.create(:schedule, {
+        :context => "will be updated",
+        :at => Time.now,
+        :active => true,
+        :recurrency => 0
+      })
+      request('/task', :method => 'PUT', :params => {:id => dummy_schedule.id, :context => "updated"})
+      schedule = Khronos::Storage::Schedule.find(dummy_schedule.id)
+      schedule.active.should == true
+      schedule.context.should == 'updated'
+    end
+
+    it "should update recurring time" do
+      dummy_schedule = FactoryGirl.create(:schedule, {
+        :at => Time.now,
+        :active => false,
+        :recurrency => 1.day
+      })
+      request('/task', :method => 'PUT', :params => {:id => dummy_schedule.id, :patch => true})
+      schedule = Khronos::Storage::Schedule.find(dummy_schedule.id)
+      schedule.active.should == true
+      schedule.at.to_i.should == 1.day.from_now.to_i
+    end
+
+    it "should retrieve a list of schedules by context pattern" do
+      FactoryGirl.create(:schedule, {:context => "namespaced"})
+      FactoryGirl.create(:schedule, {:context => "namespaced:1"})
+      FactoryGirl.create(:schedule, {:context => "namespaced:2"})
+      FactoryGirl.create(:schedule, {:context => "namespaced:3"})
+      FactoryGirl.create(:schedule, {:context => "namespaced:4"})
+      FactoryGirl.create(:schedule, {:context => "namespaced:5"})
 
-  it "should update recurring time" do
-    dummy_schedule = FactoryGirl.create(:schedule, {
-      :at => Time.now,
-      :active => false,
-      :recurrency => 1.day
-    })
-    request('/task', :method => 'PATCH', :params => {:id => dummy_schedule.id})
-    schedule = Khronos::Storage::Schedule.find(dummy_schedule.id)
-    schedule.active.should == true
-    schedule.at.to_i.should == 1.day.from_now.to_i
+      get('/tasks', {:context => "namespaced%"})
+      last_response.status.should == 200
+      JSON.parse(last_response.body).length.should == 6
+
+      get('/tasks', {:context => "namespaced"})
+      last_response.status.should == 200
+      JSON.parse(last_response.body).length.should == 1
+    end
   end
 
-  it "should retrieve a list of schedules by context pattern" do
-    FactoryGirl.create(:schedule, {:context => "namespaced"})
-    FactoryGirl.create(:schedule, {:context => "namespaced:1"})
-    FactoryGirl.create(:schedule, {:context => "namespaced:2"})
-    FactoryGirl.create(:schedule, {:context => "namespaced:3"})
-    FactoryGirl.create(:schedule, {:context => "namespaced:4"})
-    FactoryGirl.create(:schedule, {:context => "namespaced:5"})
-
-    get('/tasks', {:context => "namespaced%"})
-    last_response.status.should == 200
-    JSON.parse(last_response.body).length.should == 6
-
-    get('/tasks', {:context => "namespaced"})
-    last_response.status.should == 200
-    JSON.parse(last_response.body).length.should == 1
+  context "logs" do
+    it "should record schedule logs" do
+      data = { :schedule_id => 1, :started_at => Time.at(1347727128), :status_code => 404 }
+      post('/schedule/log', data)
+      last_response.status.should == 200
+
+      schedule_log = Khronos::Storage::ScheduleLog.find(JSON.parse(last_response.body)['id'])
+      schedule_log.schedule_id.should == data[:schedule_id]
+      schedule_log.started_at.should == data[:started_at]
+      schedule_log.status_code.should == data[:status_code]
+    end
+
+    it "should query for schedule logs" do
+      FactoryGirl.create(:schedule_log, {:started_at => Time.at(1347727128), :status_code => 200, :schedule_id => 1})
+      FactoryGirl.create(:schedule_log, {:started_at => Time.at(1347727128), :status_code => 500, :schedule_id => 1})
+      FactoryGirl.create(:schedule_log, {:started_at => Time.at(1347727128), :status_code => 200, :schedule_id => 1})
+      FactoryGirl.create(:schedule_log, {:started_at => Time.at(1347727128), :status_code => 500, :schedule_id => 2})
+      FactoryGirl.create(:schedule_log, {:started_at => Time.at(1347727128), :status_code => 200, :schedule_id => 2})
+      FactoryGirl.create(:schedule_log, {:started_at => Time.at(1347727128), :status_code => 404, :schedule_id => 2})
+      FactoryGirl.create(:schedule_log, {:started_at => Time.at(1347727128), :status_code => 200, :schedule_id => 3})
+
+      get('/schedule/logs', {:status_code => 200})
+      last_response.status.should == 200
+      JSON.parse(last_response.body).length.should == 4
+
+      get('/schedule/logs', {:schedule_id => 2})
+      last_response.status.should == 200
+      logs = JSON.parse(last_response.body)
+      logs.length.should == 3
+
+      get('/schedule/logs', {:status_code => 200, :limit => 1})
+      JSON.parse(last_response.body).length.should == 1
+
+      get('/schedule/logs', {:status_code => 500})
+      puts "status_code => #{last_response.body.inspect}"
+      #logs = JSON.parse(last_response.body)
+      #logs.first['schedule_id'].should == 2
+    end
   end
 
 end

data/spec/support/mocks.rb

@@ -1,23 +0,0 @@
-require 'socket'
-TCP_NEW = TCPSocket.method(:new) unless defined? TCP_NEW
-
-#
-# Example:
-#   mock_tcp_next_request("<xml>junk</xml>")
-#
-class FakeTCPSocket
-  def puts(*args); end
-  def closed?; true; end
-  def write(some_text = nil); end
-end
-
-def mock_tcp_next_request(string)
-  TCPSocket.stub!(:new).and_return {
-    cm = FakeTCPSocket.new
-    cm
-  }
-end
-
-def unmock_tcp
-  TCPSocket.stub!(:new).and_return { TCP_NEW.call }
-end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: khronos
 version: !ruby/object:Gem::Version
-  version: 0.0.3.pre4
-  prerelease: 6
+  version: 0.1.0
+  prerelease: 
 platform: ruby
 authors:
 - Endel Dreyer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-10 00:00:00.000000000 Z
+date: 2012-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sinatra
@@ -171,10 +171,9 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: 0.10.0
-description: Ruby HTTP Job Scheduler Interface. An advanced Cron replacement for the
-  cloud.
+description: Simple HTTP-based Job scheduling for the cloud.
 email:
-- endel@ocapi.com.br
+- endel.dreyer@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -183,6 +182,7 @@ files:
 - .rspec
 - .travis.yml
 - Gemfile
+- Gemfile.lock
 - LICENSE
 - README.md
 - Rakefile
@@ -190,6 +190,8 @@ files:
 - config.ru
 - config/environment.yml
 - db/test.db
+- examples/runner_server.ru
+- examples/scheduler_server.ru
 - khronos.gemspec
 - lib/.scheduler.rb.swp
 - lib/khronos.rb
@@ -198,7 +200,6 @@ files:
 - lib/khronos/scheduler.rb
 - lib/khronos/server.rb
 - lib/khronos/server/controller.rb
-- lib/khronos/server/em_runner.rb
 - lib/khronos/server/runner.rb
 - lib/khronos/server/scheduler.rb
 - lib/khronos/storage.rb
@@ -228,7 +229,7 @@ files:
 - spec/support/mocks.rb
 - spec/tmp/scheduler.db
 - spec/tmp/sqlite3.db
-homepage: http://github.com/ocapi/khronos
+homepage: http://github.com/endel/khronos
 licenses:
 - MIT
 post_install_message: 
@@ -244,15 +245,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>'
+  - - ! '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: Ruby HTTP Job Scheduler Interface.
+summary: Simple HTTP-based Job scheduling for the cloud.
 test_files:
 - spec/functional/adapters_spec.rb
 - spec/functional/controller_spec.rb

data/lib/khronos/server/em_runner.rb

@@ -1,56 +0,0 @@
-require 'json'
-require 'eventmachine'
-require 'em-http'
-
-#
-# DEPRECATED:
-# This class was used just for testing purpose.
-#
-
-module Khronos
-  module Server
-
-    class Runner < EventMachine::Connection
-      def post_init
-        puts "-- someone connected to the server!"
-      end
-
-      def receive_data json
-        puts "Receive data to run: #{json}"
-        schedule = JSON.parse(json)
-        send_data ">>> you sent: #{schedule.inspect}"
-
-        # Close connection with client immediatelly
-        close_connection
-
-        if (url = schedule['task_url'])
-          http = EventMachine::HttpRequest.new(url).get :redirects => 5
-          http.callback do
-            puts "#{url}\n#{http.response_header.status} - #{http.response.length} bytes\n"
-            puts http.response
-          end
-
-          http.errback do
-            puts "#{url}\n" + http.error
-          end
-
-          enqueue_recurrency!(schedule)
-        end
-
-      end
-
-      def enqueue_recurrency!(schedule)
-        url = "http://#{Config.instance.scheduler['host']}"
-        url += ":#{Config.instance.scheduler['port']}" if Config.instance.scheduler['port']
-        url += "/task?id=#{schedule['id']}"
-        EventMachine::HttpRequest.new(url).patch :redirects => 2
-      end
-
-      def unbind
-        puts "-- someone disconnected from the echo server!"
-      end
-
-    end
-
-  end
-end