kyklos 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f870d6a2b3a6d353b324b572bcd4c22e708eb711
+  data.tar.gz: 453611e97f7d6dc3c03b33ee1813c3677088d782
+SHA512:
+  metadata.gz: 319d5f62e36281a8697b43b3bd7e3d77c069a68f5c56d910bd370ee261fb0f1c7bcc6d23eceec5dd554761b6a28ed1909695c7f37694326d00294c4646773ee7
+  data.tar.gz: ba617a19340a3ced8079ddfe63f11647d4f432026d5732fabc3d793100e284647429f8fad9a236821c7084b8b1056b8c17c5bceedb2ece359402b44cde89b424

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# IntelliJ IDEA
+/*.iml
+/.idea

data/.travis.yml

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

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at TODO: Write your email address. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in kyklos.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Yuichi Takeuchi
+
+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,121 @@
+# Kyklos
+
+You can use the Amazon CloudWatch Events to schedule jobs on Ruby.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'kyklos'
+```
+
+And then execute:
+
+```sh
+$ bundle
+```
+
+Or install it yourself as:
+
+```sh
+$ gem install kyklos
+```
+
+## Usage
+
+### 1. Write your config/schedule.rb
+
+```sh
+$ vi config/schedule.rb
+```
+
+#### Example schedule.rb file
+
+```ruby
+cron '0/10 * * * ? *' do
+  Entry.publish_all
+  Entry.unpublish_all
+end
+
+rate '10 minutes' do
+  Temporary.destroy_all
+end
+
+rate '1 day', as: :recontraction do
+  Subscription.recontract_all
+end
+
+rate '1 day', as: :journalize_events do
+  Event.journalize
+end
+```
+
+### 2. Deploy
+
+```sh
+ bundle exec ruby bin/kyklos -c config/schedule.rb --adapter shoryuken --adapter_args=https://sqs.ap-northeast-1.amazonaws.com/accountid/queue_name
+```
+
+#### AWS認証情報について
+
+##### 環境変数として渡す
+
+```sh
+$ AWS_ACCESS_KEY_ID=xxxxxxxxxxxxxxxxxxxx \
+> AWS_SECRET_ACCESS_KEY=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx \
+> AWS_REGION=ap-northeast-1 \
+> kyklos -c config/schedule.rb
+```
+
+##### `aws configure`を使う
+
+```sh
+$ aws configure
+AWS Access Key ID [None]: xxxxxxxxxxxxxxxxxxxx
+AWS Secret Access Key [None]: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+Default region name [None]: ap-northeast-1
+Default output format [None]: json
+$ ls ~/.aws
+config  credentials
+$ kyklos -c config/schedule.rb
+```
+
+### 3. Shoryuken
+
+#### 設定
+
+```sh
+$ vi kyklos_worker.rb
+```
+```ruby
+require 'kyklos'
+Kyklos::Adapters::ShoryukenAdapter::Worker.config_path = 'config/schedule.rb'
+Shoryuken.register_worker 'queue_name', Kyklos::Adapters::ShoryukenAdapter::Worker
+```
+
+```sh
+$ vi shoryuken.yml
+```
+```yaml
+concurrency: 25
+delay: 25
+queues:
+     - [queue_name, 1]
+```
+
+#### ワーカーを開始
+
+```sh
+$ bundle exec shoryuken -r ./kyklos_worker.rb -C shoryuken.yml
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/takeyuweb/kyklos. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+
+## 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,10 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/kyklos

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'optparse'
+require 'kyklos'
+require 'kyklos/version'
+
+options = {}
+OptionParser.new do |opt|
+  opt.version = Kyklos::VERSION
+  opt.on('-c', '--config CONFIG') do |config|
+    options[:config_path] = config
+  end
+  opt.on('--adapter ADAPTER_NAME') do |adapter|
+    options[:adapter] = adapter
+  end
+  opt.on('--adapter_args arg1,args,arg3...', Array) do |adapter_args|
+    options[:adapter_args] = adapter_args
+  end
+  opt.on('--identifier IDENTIFIER') do |identifier|
+    options[:identifier] = identifier
+  end
+  opt.parse!(ARGV)
+end
+
+Kyklos::CLI.new(options).deploy

data/examples/simple.rb

@@ -0,0 +1,13 @@
+cron '* * * * ? *', as: :publish_unpublish do
+  Entry.publish
+  Entry.unpublish
+end
+
+cron '0/2 * * * ? *' do
+  Entry.publish
+  Entry.unpublish
+end
+
+rate '1 day', desc: '契約更新' do
+  Subscription.recontract_all
+end

data/kyklos.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'kyklos/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'kyklos'
+  spec.version       = Kyklos::VERSION
+  spec.authors       = ['Yuichi Takeuchi']
+  spec.email         = ['info@takeyu-web.com']
+
+  spec.summary       = %q{You can use the Amazon CloudWatch Events to schedule jobs on Ruby.}
+  spec.homepage      = 'https://github.com/takeyuweb/kyklos/'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split("\n")
+  spec.test_files    = `git ls-files -- test/unit/*`.split("\n")
+  spec.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'aws-sdk'
+  spec.add_dependency 'shoryuken'
+
+  spec.add_development_dependency 'bundler', '~> 1.13'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'test-unit', '~> 3.2'
+end

data/lib/kyklos.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+require 'kyklos/job_list'
+require 'kyklos/job'
+require 'kyklos/adapters'
+require 'kyklos/adapters/shoryuken_adapter'
+require 'kyklos/cli'
+require 'kyklos/version'
+
+module Kyklos
+
+  module_function
+
+  def parse(code)
+    Kyklos::JobList.new(code)
+  end
+
+end

data/lib/kyklos/adapters.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Kyklos
+  module Adapters
+    autoload :BaseAdapter, 'kyklos/adapters/base_adapter'
+  end
+end

data/lib/kyklos/adapters/base_adapter.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Kyklos
+  module Adapters
+    class BaseAdapter
+
+      def initialize(*args)
+
+      end
+
+      def assign_cloudwatchevents(job_id:, rule:)
+        raise NotImplementedError
+      end
+
+      def unassign_cloudwatchevents(rule:)
+        raise NotImplementedError
+      end
+
+    end
+  end
+end

data/lib/kyklos/adapters/shoryuken_adapter.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+# $ vi kyklos_worker.rb
+# require 'kyklos'
+# Kyklos::Adapters::ShoryukenAdapter::Worker.config_path = 'config/schedule.rb'
+# Shoryuken.register_worker 'queue_name', Kyklos::Adapters::ShoryukenAdapter::Worker
+#
+# $ vi shoryuken.yml
+# concurrency: 25
+# delay: 25
+# queues:
+#     - [queue_name, 1]
+#
+# $ bundle exec shoryuken -r ./kyklos_worker.rb -C shoryuken.yml
+
+# TODO: Aws SDKのラッパークラスを書いてテストしやすくする
+# TODO: ShoryukenAdapter をgemに分離
+
+require 'json'
+require 'aws-sdk'
+require 'digest/md5'
+require 'shoryuken'
+
+module Kyklos
+  module Adapters
+    class ShoryukenAdapter < BaseAdapter
+
+      attr_reader :queue_url
+
+      def initialize(*args)
+        @queue_url = args[0]
+      end
+
+      def assign_cloudwatchevents(job_id:, rule:)
+        assign_queue_policy(job_id, rule.arn)
+        [
+            {
+                id: target_id(job_id),
+                arn: target_arn,
+                input: {
+                    job_id: job_id
+                }.to_json
+            }
+        ]
+      end
+
+      def unassign_cloudwatchevents(rule:)
+        unassign_queue_policy(rule.arn)
+      end
+
+      private
+
+        def target_id(job_id)
+          Digest::MD5.hexdigest(job_id.to_s)
+        end
+
+        def target_arn
+          resp = sqs.get_queue_attributes(
+              queue_url: @queue_url,
+              attribute_names: ['QueueArn']
+          )
+          resp.attributes['QueueArn']
+        end
+
+        def assign_queue_policy(job_id, rule_arn)
+          policy = get_queue_policy
+          new_statement = {
+              'Sid' => job_id.to_s,
+              'Effect' => 'Allow',
+              'Principal' => {
+                  "AWS" => '*'
+              },
+              'Action' =>  'sqs:SendMessage',
+              'Resource' => target_arn,
+              'Condition' => {
+                  'ArnEquals' => {
+                      'aws:SourceArn' => rule_arn
+                  }
+              }
+          }
+          policy['Statement'] = add_statement(policy['Statement'], new_statement)
+
+          sqs.set_queue_attributes(
+              queue_url: queue_url,
+              attributes: {
+                  'Policy' =>  policy.to_json,
+              },
+          )
+        end
+
+        def get_queue_policy
+          policy_str = sqs.get_queue_attributes(
+              queue_url: queue_url,
+              attribute_names: ['Policy']
+          ).attributes['Policy']
+
+          policy = JSON.load(policy_str)
+          unless policy
+            policy = {
+                'Version' => '2012-10-17',
+                'Id' => "#{target_arn}/SQSDefaultPolicy",
+                'Statement'=> []
+            }
+          end
+          policy
+        end
+
+        def add_statement(statements, new_sttement)
+          index = statements.find_index{|statement| statement['Sid'] == new_sttement['Sid'] }
+          if index
+            statements[index] = new_sttement
+          else
+            statements.push(new_sttement)
+          end
+          statements
+        end
+
+        def unassign_queue_policy(rule_arn)
+          policy = get_queue_policy
+          policy['Statement'] = policy['Statement'].reject do |statement|
+            statement['Effect'] == 'Allow' &&
+                statement['Action'] == 'sqs:SendMessage' &&
+                statement['Resource'] == target_arn &&
+                statement['Condition'] &&
+                statement['Condition']['ArnEquals'] &&
+                statement['Condition']['ArnEquals']['aws:SourceArn'] == rule_arn
+          end
+
+          if policy['Statement'].empty?
+            sqs.set_queue_attributes(
+                queue_url: queue_url,
+                attributes: {
+                    'Policy' =>  '',
+                },
+            )
+          else
+            sqs.set_queue_attributes(
+                queue_url: queue_url,
+                attributes: {
+                    'Policy' =>  policy.to_json,
+                },
+            )
+          end
+        end
+
+        def sqs
+          Aws::SQS::Client.new
+        end
+
+
+      class Worker
+        include Shoryuken::Worker
+        shoryuken_options auto_delete: true
+
+        def self.config_path=(config_path)
+          @@config_path = config_path
+        end
+
+        def self.config_path
+          @@config_path
+        end
+
+        def perform(sqs_msg, body)
+          data = JSON.load(body)
+          job_id =data['job_id']
+          if job_id
+            kyklos.run(job_id)
+          end
+        end
+
+        private
+
+        def kyklos
+          Kyklos.parse(File.read(self.class.config_path))
+        end
+
+      end
+
+    end
+  end
+end

data/lib/kyklos/cli.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'aws-sdk'
+require 'digest/md5'
+
+# TODO: Aws SDKのラッパークラスを書いてテストしやすくする
+
+module Kyklos
+  class CLI
+    attr_reader :config_path, :job_list
+
+    def initialize(config_path:, adapter:, adapter_args: [], identifier: 'default')
+      @config_path = config_path.to_s
+      @adapter = adapter
+      @adapter_args = adapter_args
+      @identifier = identifier
+      @job_list = Kyklos.parse(File.read(config_path))
+    end
+
+    def deploy
+      cleanup
+      put_jobs
+    end
+
+    private
+
+      def cloudwatchevents
+        @cloudwatchevents ||= Aws::CloudWatchEvents::Client.new
+      end
+
+      def cleanup
+        names = eventnames
+        find_rules.each do |rule|
+          unless names.include?(rule.name)
+            remove_job(rule)
+          end
+        end
+      end
+
+      def put_jobs
+        job_list.each do |job_id, job|
+          put_job(job_id, job)
+        end
+      end
+
+      def put_job(job_id, job)
+        rule_params = {
+            name: eventname(job_id),
+            event_pattern: '',
+            state: 'DISABLED',
+            description: [@identifier, job.description].compact.join(': '),
+            schedule_expression: job.schedule_expression,
+        }
+        cloudwatchevents.put_rule(rule_params)
+        rule = cloudwatchevents.describe_rule(name: rule_params[:name])
+        targets = adapter.assign_cloudwatchevents(
+            job_id: job_id,
+            rule: rule)
+        cloudwatchevents.put_targets(
+            rule: rule.name,
+            targets: targets
+        )
+        cloudwatchevents.enable_rule(name: rule.name)
+      end
+
+      def remove_job(rule)
+        adapter.unassign_cloudwatchevents(rule: rule)
+
+        target_ids = find_targets(rule.name).map(&:id)
+        unless target_ids.empty?
+          cloudwatchevents.remove_targets(rule: rule.name, ids: target_ids)
+        end
+        cloudwatchevents.delete_rule(name: rule.name)
+      end
+
+      def prefix
+        "kyslos-#{"#{@identifier}/#{Digest::MD5.hexdigest(@identifier)}".sum}-"
+      end
+
+      def eventname(job_id)
+        "#{prefix}#{Digest::MD5.hexdigest(job_id.to_s)}"
+      end
+
+      def eventnames
+        job_list.each.map { |job_id, _job| eventname(job_id) }
+      end
+
+      def adapter
+        adapter_klass = Kyklos::Adapters.const_get("#{@adapter.capitalize}Adapter")
+        adapter_klass.new(*@adapter_args)
+      end
+
+      def find_rules
+        list_rules = ->(next_token) do
+          resp = cloudwatchevents.
+              list_rules(name_prefix: prefix,
+                         next_token: next_token)
+          if resp.next_token
+            resp.rules + list_rules.call(next_token)
+          else
+            resp.rules
+          end
+        end
+        list_rules.call(nil)
+      end
+
+      def find_targets(rule_name)
+        list_targets = ->(next_token) do
+          resp = cloudwatchevents.
+              list_targets_by_rule(rule: rule_name,
+                                   next_token: next_token)
+          if resp.next_token
+            resp.targets + list_targets.call(next_token)
+          else
+            resp.targets
+          end
+        end
+        list_targets.call(nil)
+      end
+
+  end
+end

data/lib/kyklos/job.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+module Kyklos
+  module Job
+    autoload :Base, 'kyklos/job/base'
+    autoload :Cron, 'kyklos/job/cron'
+    autoload :Rate, 'kyklos/job/rate'
+  end
+end

data/lib/kyklos/job/base.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module Kyklos
+  module Job
+    class Base
+
+      attr_reader :expression, :description
+
+      def initialize(expression, closure, description: nil)
+        @expression = expression
+        @description = description
+        @closure = closure
+      end
+
+      def run
+        @closure.call
+      end
+
+      def schedule_expression
+        "#{self.class.name.split('::').last.downcase}(#{expression})"
+      end
+
+    end
+  end
+end

data/lib/kyklos/job/cron.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+module Kyklos
+  module Job
+    class Cron < Base
+
+    end
+  end
+end

data/lib/kyklos/job/rate.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+module Kyklos
+  module Job
+    class Rate < Base
+
+    end
+  end
+end

data/lib/kyklos/job_list.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+module Kyklos
+  class JobList
+    include Enumerable
+
+    attr_reader :jobs
+
+    def initialize(code = nil)
+      @jobs = {}
+      instance_eval(code) unless code.nil?
+    end
+
+    def [](id)
+      @jobs[normalize_id(id)]
+    end
+
+    def each(&block)
+      @jobs.each(&block)
+    end
+
+    def run(id)
+      self[id].run
+    end
+
+    def rate(expression, as: nil, desc: nil, &block)
+      add_job(Kyklos::Job::Rate, expression, block, as: as, desc: desc)
+    end
+
+    def cron(expression, as: nil, desc: nil, &block)
+      add_job(Kyklos::Job::Cron, expression, block, as: as, desc: desc)
+    end
+
+    private
+
+      def add_job(klass, expression, block, as:, desc:)
+        id = as || job_id(klass, expression)
+        normalized_id = normalize_id(id)
+        @jobs[normalized_id] = klass.new(expression, block, description: desc)
+        normalized_id
+      end
+
+      def job_id(klass, expression)
+        [klass, expression].map(&:to_s).join('#')
+      end
+
+      def normalize_id(id)
+        id.to_s.to_sym
+      end
+
+  end
+end

data/lib/kyklos/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module Kyklos
+  VERSION = '0.0.1'
+end

data/test/test_helper.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'kyklos'
+
+require 'aws-sdk'
+
+Aws.config.update(
+    region: 'us-west-2',
+    credentials: Aws::Credentials.new('DUMMY', 'DUMMY')
+)
+
+require 'test/unit'

data/test/unit/kyklos/cli_test.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+require 'test_helper'
+require 'tempfile'
+
+# TODO: リソース操作のテスト
+
+class CLITest < Test::Unit::TestCase
+
+  setup do
+    @config = Tempfile.open(%W(schedule .rb))
+    @config.write <<'CODE'
+# Do nothing
+CODE
+  end
+
+  def test_initialize
+    assert_instance_of(Kyklos::CLI, Kyklos::CLI.new(config_path: @config.path, adapter: 'shoryuken'))
+  end
+
+  def test_deploy
+    cli = Kyklos::CLI.new(config_path: @config.path, adapter: 'shoryuken')
+    Aws.config[:cloudwatchevents] = {
+        stub_responses: {
+            list_rules: {
+                rules: []
+            }
+        }
+    }
+    cli.deploy
+  end
+
+end

data/test/unit/kyklos/job/base_test.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+require 'test_helper'
+
+class BaseTest < Test::Unit::TestCase
+
+  def test_run
+    processed = false
+    closure = ->() { processed = true }
+    job = Kyklos::Job::Base.new('filds', closure)
+
+    job.run
+    assert(processed)
+  end
+
+end

data/test/unit/kyklos/job_list_test.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+require 'test_helper'
+
+class JobListTest < Test::Unit::TestCase
+
+  setup do
+    @schedule = <<'CODE'
+rate '1 minutes' do
+  puts 'Rate'
+end
+cron '* * * * * *' do
+  puts 'Cron'
+end
+CODE
+  end
+
+  teardown do
+    # Do nothing
+  end
+
+  def test_initialize_without_code
+    assert_instance_of(Kyklos::JobList, Kyklos::JobList.new)
+  end
+
+  def test_initialize_with_code
+    assert_instance_of(Kyklos::JobList, Kyklos::JobList.new(@schedule))
+  end
+
+  def test_parse_jobs
+    job_list = Kyklos::JobList.new(@schedule)
+    assert_equal(2, job_list.jobs.values.size)
+  end
+
+  def test_cron
+    job_list = Kyklos::JobList.new
+    job_list.cron('* * * * * *'){ }
+    assert_instance_of(Kyklos::Job::Cron, job_list.jobs.values.last)
+  end
+
+  def test_rate
+    job_list = Kyklos::JobList.new
+    job_list.rate('1 minutes'){ }
+    assert_instance_of(Kyklos::Job::Rate, job_list.jobs.values.last)
+  end
+
+  def test_cron_returns_job_id
+    job_list = Kyklos::JobList.new
+    job_id = job_list.rate('1 minutes'){ }
+    assert_instance_of(Kyklos::Job::Rate, job_list.jobs[job_id])
+  end
+
+  def test_as_option
+    job_list = Kyklos::JobList.new
+    job_list.cron('* * * * * *', as: 'cron_a'){ }
+    assert_instance_of(Kyklos::Job::Cron, job_list.jobs[:cron_a])
+  end
+
+  def test_desc_option
+    job_list = Kyklos::JobList.new
+    job_id = job_list.cron('* * * * * *', desc: 'DESCRIPTION'){ }
+    assert_equal('DESCRIPTION', job_list.jobs[job_id].description)
+  end
+
+  def test_bracket
+    job_list = Kyklos::JobList.new
+    job_id = job_list.rate('1 minutes'){ }
+    assert_equal(job_list[job_id], job_list.jobs[job_id])
+  end
+
+  def test_run
+    job_list = Kyklos::JobList.new
+    processed = false
+    job_list.cron('* * * * * *', as: :cron_a){ processed = true }
+    job_list.run(:cron_a)
+    assert(processed)
+  end
+
+end

data/test/unit/kyklos/task_test.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+require 'test_helper'
+
+class JobTest < Test::Unit::TestCase
+
+end

data/test/unit/kyklos_test.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+require 'test_helper'
+
+class KyklosTest < Test::Unit::TestCase
+
+  # Called before every test method runs. Can be used
+  # to set up fixture information.
+  def setup
+    # Do nothing
+  end
+
+  # Called after every test method runs. Can be used to tear
+  # down fixture information.
+
+  def teardown
+    # Do nothing
+  end
+
+  def test_that_it_has_a_version_number
+    refute_nil Kyklos::VERSION
+  end
+
+  def test_parse
+    schedule = <<'CODE'
+rate '1 minutes' do
+  puts 'Rate'
+end
+cron '* * * * * *' do
+  puts 'Cron'
+end
+CODE
+    assert_instance_of(Kyklos::JobList, Kyklos.parse(schedule))
+  end
+
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: kyklos
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Yuichi Takeuchi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-11-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: shoryuken
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+description: 
+email:
+- info@takeyu-web.com
+executables:
+- kyklos
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/kyklos
+- examples/simple.rb
+- kyklos.gemspec
+- lib/kyklos.rb
+- lib/kyklos/adapters.rb
+- lib/kyklos/adapters/base_adapter.rb
+- lib/kyklos/adapters/shoryuken_adapter.rb
+- lib/kyklos/cli.rb
+- lib/kyklos/job.rb
+- lib/kyklos/job/base.rb
+- lib/kyklos/job/cron.rb
+- lib/kyklos/job/rate.rb
+- lib/kyklos/job_list.rb
+- lib/kyklos/version.rb
+- test/test_helper.rb
+- test/unit/kyklos/cli_test.rb
+- test/unit/kyklos/job/base_test.rb
+- test/unit/kyklos/job_list_test.rb
+- test/unit/kyklos/task_test.rb
+- test/unit/kyklos_test.rb
+homepage: https://github.com/takeyuweb/kyklos/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: You can use the Amazon CloudWatch Events to schedule jobs on Ruby.
+test_files:
+- test/unit/kyklos/cli_test.rb
+- test/unit/kyklos/job/base_test.rb
+- test/unit/kyklos/job_list_test.rb
+- test/unit/kyklos/task_test.rb
+- test/unit/kyklos_test.rb