kronos-ruby 0.1.0.alpha.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bb53d58571c884a14d1d1089f4b8ac3fd6512133
+  data.tar.gz: dcec1ad5fc215fab5ac52eb05dfcf226b7dcb393
+SHA512:
+  metadata.gz: bbff4ed34107685fcc68e14d02c4a8e7307700923bb0ca4900e89334e29a29cf974f7187568db3e5a4cc9b57f2782cb04ee886a97ea0a2b2c855a36e3c3b7f19
+  data.tar.gz: e7bb79b5218489cbd2bf6a05c1cb78822faaf167575d3b6d5275c93fb65d09cefde77c4a6c2daf9b7c554faf3ec36f10add28c9aafe26b34aa7b2c6386899949

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.reek

@@ -0,0 +1,5 @@
+IrresponsibleModule:
+  enabled: false
+
+exclude_paths:
+  - vendor/bundle

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,26 @@
+AllCops:
+  TargetRubyVersion: 2.4
+
+Style/Documentation:
+  Enabled: false
+
+Metrics/LineLength:
+  Max: 120
+
+Metrics/ClassLength:
+  Max: 150
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/MethodLength:
+  Max: 15
+
+Style/RegexpLiteral:
+  Enabled: false
+
+Layout/IndentArray:
+  Enabled: false
+
+Layout/IndentHash:
+  Enabled: false

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.1
+before_install: gem install bundler -v 1.15.3

data/CHANGELOG.md

@@ -0,0 +1,22 @@
+# Kronos
+
+## CHANGELOG
+
+### Unreleased
+- [Added] Logger structure (Stdout and Slack)
+- [Added] Storage structure (InMemory)
+- [Added] Runner structure (Synchronous/Asynchronous)
+- [Added] Config structure
+- [Added] Docs
+- [Added] Continuous Integration
+- [Added] Project basis
+
+## Additional Information
+- All notable changes to this project will be documented in this file.
+- This project uses [Semantic Versioning](http://semver.org/) and to the [Keep-a-Changelog](https://github.com/olivierlacan/keep-a-changelog) guidelines.
+   - [Added] To new features
+   - [Changed] To changes in existing features
+   - [Deprecated] To features that will be removed in the future
+   - [Removed] To removed features
+   - [Fixed] To any bugfix
+   - [Security] To security fixes or improvements

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in kronos.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Gabriel Teles
+
+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/README.md

@@ -0,0 +1,60 @@
+# Kronos
+[![Build Status](https://semaphoreci.com/api/v1/pdvend/kronos/branches/master/badge.svg)](https://semaphoreci.com/pdvend/kronos)
+[![Coverage Status](https://coveralls.io/repos/github/pdvend/kronos/badge.svg?branch=master)](https://coveralls.io/github/pdvend/kronos?branch=master)
+
+This project allows you to use a scheduler with well defined concepts of runners, storage and tasks. It can work in various storage engines, like memory, redis, disk, database, etc. Also, it supports running in synchronous or asynchronous flows.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'kronos'
+```
+
+And then execute:
+
+`$ bundle`
+
+Or install it yourself as:
+
+`$ gem install kronos`
+
+
+## Usage
+
+```ruby
+# Define your environment preferences (runner and storage) and register your tasks
+Kronos
+  .config
+  .runner(Kronos::Runner::Synchronous) # or .runner(Kronos::Runner::Asynchronous)
+  .storage(Kronos::Storage::InMemory)
+  .logger(Kronos::Logger::Stdout) # or .logger(Kronos::Logger::Slack, "Your Slack Webhook URL here")
+  .register(:say_good_morning, '8am') { puts 'Good Morning, Team!' }
+  .register(:wish_happy_weekend, 'friday, 6pm') { puts 'Happy Weekend, Team!' }
+  # ...
+
+# Then start Kronos (This method can be sync or async, acording to the runner you selected)
+Kronos.start
+```
+
+### Web dashboard
+To view Krono's web dashboard, simply mount it into your Rack stack:
+```ruby
+mount Kronos::Web::App, at: '/kronos-dashboard'
+```
+
+## Developing
+- Clone this repository
+- Run `bin/setup` to install dependencies
+- You can also run `bin/console` to start an iteractive console to test Kronos
+- To install this gem onto your local machine, run `bundle exec rake install`.
+- To release a new version, update `lib/version.rb` and [CHANGELOG.md](/CHANGELOG.md)
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/pdvend/kronos.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task(default: [:spec])

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'kronos'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+require 'pry'
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/kronos-ruby.gemspec

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'kronos/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'kronos-ruby'
+  pre_release        = ENV['SEMAPHORE'] && ENV['PRE_RELEASE']
+  spec.version       = Kronos::VERSION + (pre_release ? ".alpha.#{ENV['SEMAPHORE_DEPLOY_NUMBER']}" : '')
+  spec.authors       = ['Gabriel Teles']
+  spec.email         = ['gabriel@pdvend.com.br']
+
+  spec.summary       = 'Persistent cron jobs manager'
+  spec.homepage      = 'https://github.com/pdvend/kronos'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'concurrent-ruby'
+  spec.add_dependency 'chronic'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'coveralls'
+  spec.add_development_dependency 'fasterer'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rack'
+  spec.add_development_dependency 'reek'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'timecop'
+  spec.add_development_dependency 'webmock'
+end

data/lib/kronos/config_agent.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Kronos
+  class ConfigAgent
+    attr_reader :tasks
+
+    def initialize
+      @tasks = []
+      @instance = {}
+    end
+
+    def register(id, timestamp, &block)
+      raise(Kronos::Exception::AlreadyRegisteredId) if @tasks.lazy.map(&:id).include?(id)
+
+      task = Kronos::Task.new(id, timestamp, block)
+      tasks.push(task)
+
+      self
+    end
+
+    def storage(storage, *config)
+      @instance[:storage] = storage.new(*config)
+      self
+    end
+
+    def logger(logger, *config)
+      @instance[:logger] = logger.new(*config)
+      self
+    end
+
+    def runner(runner)
+      @_runner = runner
+      @instance[:runner] = nil
+      self
+    end
+
+    def runner_instance
+      @instance[:runner] ||= begin
+        raise(Kronos::Exception::NoRunnerRegistered) unless _runner
+
+        dependencies = Kronos::Dependencies.new(
+          storage: storage_instance,
+          logger: logger_instance
+        )
+
+        _runner.new(tasks, dependencies)
+      end
+    end
+
+    def storage_instance
+      @instance[:storage] || raise(Kronos::Exception::NoStorageRegistered)
+    end
+
+    def logger_instance
+      @instance[:logger] || raise(Kronos::Exception::NoLoggerRegistered)
+    end
+
+    private
+
+    attr_accessor :_runner, :_storage
+  end
+end

data/lib/kronos/dependencies.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Kronos
+  class Dependencies
+    attr_reader :storage, :logger
+
+    def initialize(storage: nil, logger: nil)
+      @storage = storage
+      @logger = logger
+    end
+  end
+end

data/lib/kronos/exception/already_registered_id.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Kronos
+  class Exception
+    class AlreadyRegisteredId < Kronos::Exception
+    end
+  end
+end

data/lib/kronos/exception/no_logger_registered.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Kronos
+  class Exception
+    class NoLoggerRegistered < Kronos::Exception
+    end
+  end
+end

data/lib/kronos/exception/no_runner_registered.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Kronos
+  class Exception
+    class NoRunnerRegistered < Kronos::Exception
+    end
+  end
+end

data/lib/kronos/exception/no_storage_registered.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Kronos
+  class Exception
+    class NoStorageRegistered < Kronos::Exception
+    end
+  end
+end

data/lib/kronos/exception/unrecognized_time_format.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Kronos
+  class Exception
+    class UnrecognizedTimeFormat < Kronos::Exception
+    end
+  end
+end

data/lib/kronos/exception.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Kronos
+  class Exception < StandardError
+  end
+end
+
+require 'kronos/exception/already_registered_id'
+require 'kronos/exception/no_logger_registered'
+require 'kronos/exception/no_runner_registered'
+require 'kronos/exception/no_storage_registered'
+require 'kronos/exception/unrecognized_time_format'

data/lib/kronos/logger/slack.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+
+module Kronos
+  module Logger
+    class Slack
+      def initialize(slack_webhook_url)
+        @slack_uri = URI.parse(slack_webhook_url)
+        @use_ssl = @slack_uri.scheme == 'https'
+      end
+
+      def info(msg)
+        send_to_slack("[`Kronos`][`INFO`][`#{Time.now.iso8601}`] #{msg}", ':information_source:')
+      end
+
+      def error(msg)
+        send_to_slack("[`Kronos`][`ERROR`][`#{Time.now.iso8601}`] #{msg}", ':red_circle:')
+      end
+
+      def success(msg)
+        send_to_slack("[`Kronos`][`SUCCESS`][`#{Time.now.iso8601}`] #{msg}", ':white_check_mark:')
+      end
+
+      private
+
+      def send_to_slack(message, emoji)
+        request = Net::HTTP::Post.new(@slack_uri)
+        request.body = { text: message, icon_emoji: emoji }.to_json
+        Net::HTTP.start(@slack_uri.host, @slack_uri.port, use_ssl: @use_ssl) { |http| http.request(request) }
+      end
+    end
+  end
+end

data/lib/kronos/logger/stdout.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Kronos
+  module Logger
+    class Stdout
+      def info(msg)
+        puts "[Kronos][INFO][#{Time.now.iso8601}] #{msg}"
+      end
+
+      def error(msg)
+        puts "[Kronos][ERROR][#{Time.now.iso8601}] #{msg}"
+      end
+
+      def success(msg)
+        puts "[Kronos][SUCCESS][#{Time.now.iso8601}] #{msg}"
+      end
+    end
+  end
+end

data/lib/kronos/logger.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Kronos
+  module Logger
+  end
+end
+
+require 'kronos/logger/stdout'
+require 'kronos/logger/slack'

data/lib/kronos/report.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Kronos
+  class Report < ::OpenStruct
+    STATUSES = { success: 0, failure: 1 }.freeze
+
+    class << self
+      def success_from(task_id, metadata, timestamp = Time.now)
+        new(
+          task_id: check_task_id(task_id),
+          status: Kronos::Report::STATUSES[:success],
+          timestamp: check_timestamp(timestamp),
+          metadata: check_metadata(metadata)
+        )
+      end
+
+      def failure_from(task_id, exception, timestamp = Time.now)
+        new(
+          task_id: check_task_id(task_id),
+          status: Kronos::Report::STATUSES[:failure],
+          timestamp: check_timestamp(timestamp),
+          exception: check_exception(exception)
+        )
+      end
+
+      private :new
+
+      private
+
+      def check_timestamp(timestamp)
+        timestamp.is_a?(Time) ? timestamp : raise_invalid_argument('timestamp', timestamp, Time)
+      end
+
+      def check_task_id(task)
+        task.is_a?(Symbol) ? task : raise_invalid_argument('Task ID', task, Symbol)
+      end
+
+      def check_metadata(metadata)
+        raise_invalid_argument('metadata', metadata, Hash) unless metadata.is_a?(Hash)
+        return metadata if metadata.values.all? { |value| value.is_a?(String) }
+        raise(ArgumentError, 'Expected all values in metadata to be strings')
+      end
+
+      def check_exception(exception)
+        if exception.is_a?(Hash)
+          return exception if valid_exception_format(exception)
+          raise(ArgumentError, 'Invalid exception format')
+        elsif exception.is_a?(::Exception)
+          exception_hash_from(exception)
+        else
+          raise_invalid_argument('exception', exception, Hash)
+        end
+      end
+
+      def exception_hash_from(exception)
+        {
+          type: exception.class.name,
+          message: exception.message,
+          stacktrace: exception.backtrace
+        }
+      end
+
+      def valid_exception_format(exception)
+        type = exception[:type]
+        message = exception[:message]
+        stacktrace = exception[:stacktrace]
+
+        type.is_a?(String) &&
+          !type.empty? &&
+          message.is_a?(String) &&
+          !message.empty? &&
+          stacktrace.is_a?(Array) &&
+          stacktrace.all? { |line| line.is_a?(String) }
+      end
+
+      def raise_invalid_argument(name, received, expectation)
+        raise(ArgumentError, "Invalid #{name} given (#{received.class}). #{expectation} expected.")
+      end
+    end
+
+    def success?
+      status == Kronos::Report::STATUSES[:success]
+    end
+
+    def failure?
+      status == Kronos::Report::STATUSES[:failure]
+    end
+  end
+end

data/lib/kronos/runner/asynchronous.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Kronos
+  module Runner
+    class Asynchronous < Synchronous
+      include Concurrent::Async
+      alias original_start start
+
+      def start
+        async.original_start
+      end
+    end
+  end
+end

data/lib/kronos/runner/synchronous.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Kronos
+  module Runner
+    class Synchronous
+      # TODO: Let consumer configure it
+      METADATA_COLLECTORS = [
+        lambda do |block|
+          start = Time.now
+          result = block.call
+          finish = Time.now
+
+          { **result, start: start.to_s, finish: finish.to_s, duration: (finish - start).to_s }
+        end
+      ].freeze
+
+      ID_FUNC = lambda do |block|
+        lambda do
+          block.call
+          {}
+        end
+      end
+
+      def initialize(tasks, dependencies)
+        @tasks = tasks
+        @dependencies = dependencies
+      end
+
+      def start
+        loop do
+          run_resolved_tasks
+          schedule_current_tasks
+
+          # TODO: Configurable sleep between runs
+          sleep(1)
+        end
+      end
+
+      private
+
+      def schedule_current_tasks
+        @tasks.each(&method(:schedule_task))
+      end
+
+      def schedule_task(task)
+        schedule_next_run(task) unless @dependencies.storage.pending?(task)
+      end
+
+      def run_resolved_tasks
+        @dependencies.storage.resolved_tasks.each(&method(:process_task))
+      end
+
+      def process_task(task_id)
+        task = find_task(task_id)
+        return remove_task_from_schedule(task_id) unless task
+        run_task(task)
+        schedule_next_run(task)
+      end
+
+      def remove_task_from_schedule(task_id)
+        @dependencies.logger.info("Task `#{task_id}` was removed from definitions. Removing from schedule too.")
+        storage = @dependencies.storage
+        storage.remove(task_id)
+        storage.remove_reports_for(task_id)
+      end
+
+      # rubocop:disable RescueException
+      def run_task(task)
+        raw_execute_task(task)
+      rescue ::Exception => error
+        register_task_failure(task.id, error)
+      end
+      # rubocop:enable
+
+      def raw_execute_task(task)
+        metadata = collect_metadata { task.block.call }
+        task_id = task.id
+        @dependencies.logger.success("Task `#{task_id}` ran successfully.")
+        @dependencies.storage.register_report(Kronos::Report.success_from(task_id, metadata))
+      end
+
+      def register_task_failure(task_id, error)
+        @dependencies.logger.error("Task `#{task_id}` failed.")
+        @dependencies.storage.register_report(Kronos::Report.failure_from(task_id, error))
+      end
+
+      def collect_metadata(&block)
+        METADATA_COLLECTORS
+          .reverse
+          .reduce(ID_FUNC[block]) { |chain, collector| -> () { collector[chain] } }
+          .call
+      end
+
+      def schedule_next_run(task)
+        next_run = task.time
+        return @dependencies.storage.remove(task.id) if next_run < Time.now
+        schedule(task, next_run)
+      end
+
+      def schedule(task, next_run)
+        task_id = task.id
+        @dependencies.logger.info("Scheduling `#{task_id}` to run `#{next_run.iso8601}`")
+        @dependencies.storage.schedule(Kronos::ScheduledTask.new(task_id, next_run))
+      end
+
+      def find_task(task_id)
+        @tasks.find { |task| task.id == task_id }
+      end
+    end
+  end
+end