khronos 0.0.0 → 0.0.1.pre1

data/.gitignore

@@ -0,0 +1 @@
+deploy

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+
+rvm:
+  - 1.9.3

data/Gemfile

@@ -2,17 +2,28 @@ source :rubygems
 gemspec
 
 group :test do
-  # Used for time functions
-  gem 'activesupport', "~> 3.2.8"
-
+  gem 'thin'
   gem 'simplecov', '= 0.6.4'
 
-  gem 'rspec'
-  gem 'rack-test'
+  # Testing
+  gem "rspec", "~> 2.11.0"
+  gem 'rack-test', '~> 0.6.1'
   gem "fakefs", "~> 0.4.0"
   gem "delorean", "~> 2.0.0"
+  gem "factory_girl", "~> 4.0.0"
+  gem "webmock", "~> 1.8.9"
+  #gem "em-spec", ''
+
+  #
+  # Used for time functions
+  #
+  gem 'activesupport', "~> 3.2.8"
 
-  gem 'redis'
-  gem 'memcached'
+  #
+  # Database support testing
+  #
   gem 'mongo'
+  gem "mysql2", "~> 0.3.11"
+  gem 'sqlite3'
+  gem 'pg'
 end

data/Rakefile

@@ -0,0 +1,36 @@
+$: << 'lib'
+
+require 'bundler/setup'
+
+ENV['RACK_ENV'] = ENV['ENV'] || 'test'
+require 'khronos'
+
+def load_migrations!
+  require 'khronos/storage/adapter/activerecord/migrations/schedule'
+  require 'khronos/storage/adapter/activerecord/migrations/schedule_log'
+end
+
+namespace :db do
+
+  desc 'Create the database.'
+  task :create do
+    adapter = Khronos::Storage::Adapter.get(ENV['KHRONOS_STORAGE'])
+    if adapter.name =~ /ActiveRecord/
+      load_migrations!
+      CreateSchedule.up
+      CreateScheduleLog.up
+    end
+  end
+
+  desc 'Destroy entire database.'
+  task :drop do
+    adapter = Khronos::Storage::Adapter.get(ENV['KHRONOS_STORAGE'])
+    if adapter.name =~ /ActiveRecord/
+      load_migrations!
+      CreateSchedule.down
+      CreateScheduleLog.down
+    end
+  end
+
+end
+

data/bin/khronos

@@ -6,4 +6,5 @@ ENV['RACK_ENV'] ||= 'production'
 require 'readline'
 require 'khronos'
 
-run Khronos::Server
+
+run Khronos::Server::Scheduler

data/config.ru

@@ -4,4 +4,12 @@ require 'bundler/setup'
 require 'active_support/all'
 require 'khronos'
 
-run Khronos::Server
+#controller = Khronos::Controller.new
+#controller.start!
+
+run Khronos::Server::Scheduler
+
+# Note that this will block current thread.
+#EventMachine.run {
+  #EventMachine.start_server "127.0.0.1", 8081, Khronos::Server::Runner
+#}

data/config/environment.yml

@@ -1,11 +1,33 @@
 production:
-  storage: redis://localhost:6379/0
+  storage: mongodb://localhost:27017/khronos
   interval: 5
+  controller:
+    interval: 1
+  runner:
+    host: 'localhost'
+    port: '7243'
+  scheduler:
+    host: 'localhost'
+    port: '8080'
 
 development:
-  storage: redis://localhost:6379/0
-  interval: 1
+  storage: mongodb://localhost:27017/khronos_development
+  controller:
+    interval: 1
+  runner:
+    host: 'localhost'
+    port: '7243'
+  scheduler:
+    host: 'localhost'
+    port: '8080'
 
 test:
-  storage: redis://localhost:6379/10
-  interval: 1
+  storage: sqlite3://localhost/db/test.db
+  controller:
+    interval: 1
+  runner:
+    host: 'localhost'
+    port: '7243'
+  scheduler:
+    host: 'localhost'
+    port: '8080'

data/khronos.gemspec

@@ -8,17 +8,20 @@ Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Endel Dreyer"]
   s.email       = ["endel@ocapi.com.br"]
-  s.homepage    = "http://github.com/ocapi/scraper"
+  s.homepage    = "http://github.com/ocapi/khronos"
 
   s.summary     = "Ruby HTTP Job Scheduler Interface."
-  s.description = "Advanced Cron replacement for the cloud."
+  s.description = "Ruby HTTP Job Scheduler Interface. An advanced Cron replacement for the cloud."
   s.licenses    = ['MIT']
 
-  s.add_dependency "sinatra",       '~> 1.3.3'
-  s.add_dependency 'mongoid',       '~> 3.0.5'
-  s.add_dependency 'activerecord',  '~> 3.2.8'
-  s.add_dependency 'json',          '~> 1.7.5'
-  s.add_dependency 'activesupport', '~> 3.2.8'
+  s.add_dependency "sinatra",         "~> 1.3.3"
+  s.add_dependency "mongoid",         "~> 3.0.5"
+  s.add_dependency "bson_ext",        "~> 1.6.4"
+  s.add_dependency "activerecord",    "~> 3.2.8"
+  s.add_dependency "json",            "~> 1.7.5"
+  s.add_dependency "activesupport",   "~> 3.2.8"
+  s.add_dependency "eventmachine",    "~> 1.0.0.beta.4"
+  s.add_dependency "em-http-request", "~> 1.0.3"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/lib/khronos.rb

@@ -2,19 +2,16 @@ require 'rubygems'
 require 'bundler'
 require 'bundler/setup'
 require 'json'
+require 'logger'
 
 module Khronos
   autoload :Config,     'khronos/config'
+  autoload :Logger,     'khronos/logger'
+  autoload :Scheduler,  'khronos/scheduler'
 
   autoload :Storage,    'khronos/storage'
   autoload :Server,     'khronos/server'
-
-  autoload :Scheduler,  'khronos/scheduler'
-  autoload :Runner,     'khronos/runner'
-  autoload :Controller, 'khronos/controller'
 end
 
+Khronos::Logger.setup!(Logger.new(STDOUT))
 Khronos::Config.instance.load!('config/environment.yml', ENV['RACK_ENV'])
-
-controller = Khronos::Controller.new
-controller.start!

data/lib/khronos/config.rb

@@ -24,5 +24,3 @@ module Khronos
     end
   end
 end
-
-Khronos::Config.instance.load('config.yml')

data/lib/khronos/logger.rb

@@ -0,0 +1,16 @@
+module Khronos
+  class Logger
+
+    class << self
+      def setup!(logger)
+        @logger = logger
+      end
+
+      def method_missing(method, *args, &block)
+        @logger.send(method, *args, &block)
+      end
+
+    end
+
+  end
+end

data/lib/khronos/scheduler.rb

@@ -1,12 +1,26 @@
-require 'observer'
+require 'socket'
+require 'json'
 
 module Khronos
   class Scheduler
-    include Observable
+    module Methods
+      def run(schedule)
+        client = TCPSocket.new( Config.instance.runner['host'], Config.instance.runner['port'] )
+        client.puts( schedule.to_json )
 
-    def run
+        while !(client.closed?) && (message = client.gets)
+          puts message.inspect
+          client.close
+        end
+      end
+
+      def fetch(target_time=Time.now)
+        Storage::Schedule.where(['at <= ?', target_time]).where(:active => true)
+      end
     end
 
+    include Methods
+    extend Methods
   end
 end
 

data/lib/khronos/server.rb

@@ -1,34 +1,7 @@
-require 'sinatra'
-
 module Khronos
-  class Server < Sinatra::Base
-    set :storage, Storage.new
-
-    # Retrieves scheduling data from a context
-    #
-    # @return [Hash] JSON
-    get '/' do
-      context = retrieve_context!
-      settings.storage.get(context).to_json
-    end
-
-    # Creates or updates a schedule from a context
-    #
-    # @param [String]
-    #
-    # @return [Hash] Context JSON status hash
-    put '/' do
-      context = retrieve_context!
-      puts params.inspect
-      context.to_json
-    end
-
-    private
-
-      def retrieve_context!
-        halt 400, "Missing 'context' on query string." unless params[:context]
-        (params[:namespace].nil?) ? params[:context] : "#{params[:namespace]}:#{params[:context]}"
-      end
-
+  module Server
+    autoload :Runner,     'khronos/server/runner'
+    autoload :Scheduler,  'khronos/server/scheduler'
+    autoload :Controller, 'khronos/server/controller'
   end
 end

data/lib/khronos/server/controller.rb

@@ -0,0 +1,31 @@
+module Khronos
+  module Server
+    class Controller
+      attr_reader :storage, :scheduler
+
+      def initialize
+        @storage = Storage.new
+        @scheduler = Scheduler.new
+      end
+
+      def logger=(logger)
+        puts "WARNING: Not implemented yet."
+      end
+
+      def start!
+        loop do
+          @scheduler.fetch(Time.now).each do |schedule|
+            schedule.update_attributes(:status => false)
+            schedule.save
+            @scheduler.run(schedule)
+          end
+
+          #
+          # Sleep 'interval' seconds
+          #
+          sleep(Config.instance.controller['interval'])
+        end
+      end
+    end
+  end
+end

data/lib/khronos/server/runner.rb

@@ -0,0 +1,50 @@
+require 'json'
+require 'eventmachine'
+require 'em-http'
+
+module Khronos
+  module Server
+
+    class Runner < EventMachine::Connection
+      def post_init
+        puts "-- someone connected to the server!"
+      end
+
+      def receive_data 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

data/lib/khronos/server/scheduler.rb

@@ -0,0 +1,110 @@
+require 'sinatra'
+
+module Khronos
+  module Server
+
+    class Scheduler < Sinatra::Base
+      set :storage, Storage.new
+
+      # Creates a schedule
+      #
+      # @param [String]       context     application-level identifier
+      # @param [Integer]      at          timestamp which will run for the first time
+      # @param [Integer]      recurrency  next execution interval, in seconds
+      # @param [String]       task_url    url of the task that will run
+      # @param [String, JSON] callbacks   callback urls (e.g. '{"success" : ... , "error" : ...}')
+      #
+      # @return [Hash] created schedule data
+      post '/task' do
+        Storage::Schedule.create(params).to_json
+      end
+
+      # Retrieves scheduling tasks from a context
+      #
+      # @param [Integer] id
+      # @param [String] context
+      #
+      # @return [Hash] JSON
+      get '/task' do
+        schedule = (!params.empty?) ? Storage::Schedule.where(params).first : nil
+        if schedule.nil?
+          # Requested task not found
+          404
+        else
+          schedule.to_json
+        end
+      end
+
+      # Retrieve a list of scheduling tasks
+      get '/tasks' do
+        if Storage::Schedule.name =~ /ActiveRecord/
+          criteria = Storage::Schedule
+          params.each_pair do |field, value|
+            if field == 'context'
+              field = "#{field} LIKE ?"
+            else
+              field = "#{field} = ?"
+            end
+            criteria = criteria.where(field, value)
+          end
+          criteria.to_json
+        else
+          Storage::Schedule.where(params).to_json
+        end
+      end
+
+      # Creates or updates a schedule from a context
+      #
+      # @param [String]
+      #
+      # @return [Hash] Context JSON status hash
+      put '/task' do
+        schedule = Storage::Schedule.where({:id => params.delete(:id)}).first
+
+        # No schedule found for this params.
+        return {}.to_json unless schedule
+
+        schedule.update_attributes(params)
+        schedule.save
+
+        schedule.to_json
+      end
+
+      # Checks recurrency and reactivates a schedule if necessary
+      #
+      # @param [String] id
+      #
+      # @return [Hash] data
+      patch '/task' do
+        schedule = Storage::Schedule.where(params).first
+
+        # No schedule found for this params.
+        return {}.to_json unless schedule
+
+        # Is recurrency check requested
+        if schedule.recurrency > 0
+          schedule.at += schedule.recurrency
+          schedule.active = true
+        end
+        schedule.save
+
+        schedule.to_json
+      end
+
+      # Force a task to be scheduled right now
+      #
+      # @param [Integer] id
+      #
+      # @return [Hash] queued
+      post '/task/run' do
+        schedule = Storage::Schedule.where(:id => params[:id]).first
+        Khronos::Scheduler.run(schedule) if schedule
+        {:queued => !schedule.nil?}.to_json
+      end
+
+      # Log requests
+
+    end
+
+  end
+end