kashi 0.1.0.beta1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: '055328ffe3f5ea256bb7b5a93ff93b955a87f502'
+  data.tar.gz: 772ae8d3b42689c100d474a375676790f3366377
+SHA512:
+  metadata.gz: af45c16beb5e36f27cfde874292f3f1c659cbc3639376f4aad54b15609f1035c937c17a09a3ea4cd629a8df35c00100b8a23d7e930a64f0e4f182a37268d8acd
+  data.tar.gz: '0928ab0904b4f029cae919d0981216fbad95041e06b952923dd34ecddd20031e80d286ac6d42a936add1075b50cd4819513af5deb807bc6d6d1458d68ed97a94'

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 shinya-watanabe
+
+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,117 @@
+# Kashi
+
+Kashi is a tool to manage StatusCake. It defines the state of StatusCake using DSL, and updates StatusCake according to DSL.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'kashi'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install kashi
+
+## Usage
+
+```
+export KASHI_SC_USER='...'
+export KASHI_SC_API_KEY='...'
+kashi -e # export StatusCake
+vi SCfile
+kashi -a --dry-run
+kashi -a # apply `SCfile` to StatusCake
+```
+
+## Help
+
+```
+Usage: kashi [options]
+    -h, --help                       Show help
+    -a, --apply                      Apply DSL
+    -e, --export                     Export to DSL
+    -n, --dry-run                    Dry run
+        --no-color
+                                     No color
+    -s, --split                      Split export DLS file contact group and tests
+        --split-more
+                                     Split export DLS file to 1 per object
+    -v, --debug                      Show debug log
+```
+
+## SCfile
+
+See Accepted values at documents below.
+
+- Contact Groups
+  - https://www.statuscake.com/api/Contact%20Groups/Add%20or%20Update%20Contact%20Group.md
+- Tests
+  - https://www.statuscake.com/api/Tests/Updating%20Inserting%20and%20Deleting%20Tests.md
+
+```ruby
+cake do
+  contact_group do
+    group_name "Alarm"
+    desktop_alert 0
+    email ["wata.gm@gmail.com"]
+    boxcar ""
+    pushover ""
+    ping_url ""
+    mobile nil
+  end
+
+  test do
+    website_name "your awesome site"
+    website_url "https://example.com/healthcheck"
+
+    paused 0
+    # HTTP,TCP,PING
+    test_type "HTTP"
+    contact_group ["Alarm"]
+    check_rate 300
+    timeout 40
+    website_host ""
+    node_locations ["freeserver2"]
+    find_string ""
+    do_not_find 0
+    logo_image ""
+
+    custom_header(
+      {"Host"=>"example.com"}
+    )
+    confirmation "2"
+
+    basic_user nil
+    basic_pass nil
+
+    use_jar nil
+
+    dns_ip ""
+    dns_server ""
+    trigger_rate "0"
+    test_tags ["Web", "Internal"]
+    status_codes ["204", "205", "206", "303", "400", "401", "403", "404", "405", "406", "408", "410", "413", "444", "429", "494", "495", "496", "499", "500", "501", "502", "503", "504", "505", "506", "507", "508", "509", "510", "511", "521", "522", "523", "524", "520", "598", "599", "302"]
+    enable_ssl_warning 0
+    follow_redirect 1
+  end
+end
+```
+
+## Similar tools
+
+* [Codenize.tools](http://codenize.tools/)
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/wata-gh/kashi.
+
+
+## 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,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "kashi"
+
+# 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.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

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/exe/kashi

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'kashi/cli'
+
+Kashi::CLI.start(ARGV)

data/kashi.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'kashi/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'kashi'
+  spec.version       = Kashi::VERSION
+  spec.authors       = ['wata']
+  spec.email         = ['wata.gm@gmail.com']
+
+  spec.summary       = %q{Codenize StatusCake}
+  spec.description   = %q{Manage StatusCake by DSL}
+  spec.homepage      = 'https://github.com/wata-gh/kashi'
+  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 'statuscake', '~> 0.1.2'
+  spec.add_dependency 'hashie', '~> 3.5', '>= 3.5.5'
+  spec.add_dependency 'diffy', '~> 3.2', '>= 3.2.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.14'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'pry-byebug', '~> 3.4'
+end

data/lib/kashi/cli.rb

@@ -0,0 +1,70 @@
+require 'optparse'
+require 'kashi'
+
+module Kashi
+  class CLI
+    def self.start(argv)
+      new(argv).run
+    end
+
+    def initialize(argv)
+      @argv = argv.dup
+      @help = argv.empty?
+      @filepath = 'SCfile'
+      @options = {
+        color: true,
+      }
+      parser.order!(@argv)
+    end
+
+    def run
+      if @help
+        puts parser.help
+      elsif @apply
+        Apply.new(@filepath, @options).run
+      elsif @export
+        Export.new(@filepath, @options).run
+      end
+    end
+
+    private
+
+    def parser
+      @parser ||= OptionParser.new do |opts|
+        opts.version = VERSION
+        opts.on('-h', '--help', 'Show help') { @help = true }
+        opts.on('-a', '--apply', 'Apply DSL') { @apply = true }
+        opts.on('-e', '--export', 'Export to DSL') { @export = true }
+        opts.on('-n', '--dry-run', 'Dry run') { @options[:dry_run] = true }
+        opts.on('',   '--no-color', 'No color') { @options[:color] = false }
+        opts.on('-s', '--split', 'Split export DLS file contact group and tests') { @options[:split] = true }
+        opts.on('',   '--split-more', 'Split export DLS file to 1 per object') { @options[:split_more] = true }
+        opts.on('-v', '--debug', 'Show debug log') { Kashi.logger.level = Logger::DEBUG }
+      end
+    end
+
+    class Apply
+      def initialize(filepath, options)
+        @filepath = filepath
+        @options = options
+      end
+
+      def run
+        require 'kashi/client'
+        result = Client.new(@filepath, @options).apply
+      end
+    end
+
+    class Export
+      def initialize(filepath, options)
+        @filepath = filepath
+        @options = options
+      end
+
+      def run
+        require 'kashi/client'
+        result = Client.new(@filepath, @options).export
+      end
+    end
+  end
+end

data/lib/kashi/client.rb

@@ -0,0 +1,229 @@
+require 'json'
+require 'kashi'
+require 'kashi/converter'
+require 'kashi/client_wrapper'
+require 'kashi/dsl'
+
+module Kashi
+  class Client
+    MAGIC_COMMENT = <<-EOS
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+    EOS
+
+    def initialize(filepath, options = {})
+      @filepath = filepath
+      @options = options
+    end
+
+    def traverse_contact_groups(dsl_contact_groups, sc_contact_groups_by_id, sc_contact_groups_by_name)
+      dsl_contact_groups_by_name = dsl_contact_groups.group_by(&:group_name)
+      dsl_contact_groups_by_id = dsl_contact_groups.group_by(&:contact_id)
+
+      # create
+      dsl_contact_groups_by_name.reject { |n| sc_contact_groups_by_name[n] }.each do |name, dsl_contact_group|
+        sc_contact_groups_by_name[name] = dsl_contact_group.map(&:create)
+      end
+
+      # modify
+      dsl_contact_groups_by_name.each do |name, dsl_contact_groups|
+        next unless sc_contact_groups = sc_contact_groups_by_name.delete(name)
+
+        if dsl_contact_groups.length == 1 && sc_contact_groups.length == 1
+          next if sc_contact_groups[0]['Success'] # created contact group
+          dsl_contact_groups[0].cake(sc_contact_groups[0]).modify
+        else
+          dsl_contact_groups.each do |dsl_contact_group|
+            sc_contact_group = sc_contact_groups.find { |sc_cg| sc_cg['ContactID'] == dsl_contact_group.contact_id }
+            raise "contact_id must be set if same name contact group exist. `#{name}`" unless sc_contact_group
+            dsl_contact_group.cake(sc_contact_group).modify
+          end
+        end
+      end
+
+      # delete
+      sc_contact_groups_by_name.each do |name, sc_contact_groups|
+        sc_contact_groups.each do |sc_contact_group|
+          Kashi.logger.info("Delete ContactGroup `#{name}` #{sc_contact_group['ContactID']}")
+          next if @options[:dry_run]
+          client.contactgroups_update(method: :delete, ContactID: sc_contact_group['ContactID'])
+        end
+      end
+    end
+
+    def traverse_tests(dsl_tests, sc_tests_by_id, sc_tests_by_name)
+      dsl_tests_by_name = dsl_tests.group_by(&:website_name)
+      dsl_tests_by_id = dsl_tests.group_by(&:test_id)
+
+      # create
+      dsl_tests_by_name.reject { |n, _| sc_tests_by_name[n] }.each do |name, dsl_tests|
+        sc_tests_by_name[name] = dsl_tests.map do |dsl_test|
+          # if test_id exist, its name might been changed
+          if dsl_test.test_id
+            sc_test = sc_tests_by_id[dsl_test.test_id]
+            if sc_test
+              sc_tests_by_name[sc_test['WebsiteName']].delete_if { |sc_test| sc_test['TestID'] == dsl_test.test_id }
+              next sc_test
+            end
+            next
+          end
+          dsl_test.create
+        end
+      end
+
+      # modify
+      dsl_tests_by_name.each do |name, dsl_tests|
+        next unless sc_tests = sc_tests_by_name.delete(name)
+
+        if dsl_tests.length == 1 && sc_tests.length == 1
+          next if sc_tests[0]['Success'] # created test
+          sc_test = client.tests_details(TestID: sc_tests[0]['TestID'])
+          dsl_tests[0].cake(sc_test).modify
+        else
+          dsl_tests.each do |dsl_test|
+            sc_test = sc_tests.find { |sc_t| sc_t['TestID'] == dsl_test.test_id }
+            raise "test_id must be set if same name test exist. `#{name}`" unless sc_test
+            sc_test = client.tests_details(TestID: sc_test['TestID'])
+            dsl_test.cake(sc_test).modify
+          end
+        end
+      end
+
+      # delete
+      sc_tests_by_name.each do |name, sc_tests|
+        sc_tests.each do |sc_test|
+          Kashi.logger.info("Delete Test `#{name}` #{sc_test['TestID']}")
+          next if @options[:dry_run]
+          client.tests_details(method: :delete, TestID: sc_test['TestID'])
+        end
+      end
+    end
+
+    def apply
+      Kashi.logger.info("Applying...")
+      dsl = load_file(@filepath)
+
+      sc_contact_groups = client.contactgroups
+      sc_contact_groups_by_id = sc_contact_groups.each_with_object({}) do |contact_group, h|
+        h[contact_group['ContactID']] = contact_group
+      end
+      sc_contact_groups_by_name = sc_contact_groups.group_by do |contact_group|
+        contact_group['GroupName']
+      end
+
+      sc_tests = client.tests
+      sc_tests_by_id = sc_tests.each_with_object({}) do |test, h|
+        h[test['TestID']] = test
+      end
+      sc_tests_by_name = sc_tests.group_by do |sc_tests|
+        sc_tests['WebsiteName']
+      end
+
+      traverse_contact_groups(dsl.cake.contact_groups, sc_contact_groups_by_id, sc_contact_groups_by_name)
+
+      traverse_tests(dsl.cake.tests, sc_tests_by_id, sc_tests_by_name)
+    end
+
+    def export
+      Kashi.logger.info("Exporting...")
+
+      # API access
+      contact_groups = client.contactgroups(method: :get)
+      contact_groups_by_id = contact_groups.each_with_object({}) do |contact_group, hash|
+        hash[contact_group['ContactID']] = contact_group
+      end
+
+      # API access
+      tests = client.tests(method: :get)
+      tests_by_id = tests.each_with_object({}) do |test, hash|
+        # API access
+        hash[test['TestID']] = client.tests_details(TestID: test['TestID'])
+      end
+
+      path = Pathname.new(@filepath)
+      base_dir = path.parent
+
+      if @options[:split_more]
+        # contact_groups
+        contact_groups_by_id.each do |id, contact_group|
+          Converter.new({}, { id => contact_group }).convert do |dsl|
+            kashi_base_dir = base_dir.join('contact_groups')
+            FileUtils.mkdir_p(kashi_base_dir)
+            sc_file = kashi_base_dir.join("#{contact_group['GroupName'].gsub(/[\/ ]/, '_')}_#{contact_group['ContactID']}.cake")
+            Kashi.logger.info("Export #{sc_file}")
+            open(sc_file, 'wb') do |f|
+              f.puts MAGIC_COMMENT
+              f.puts dsl
+            end
+          end
+        end
+
+        # tests
+        tests_by_id.each do |id, test|
+          Converter.new({ id => test }, {}).convert do |dsl|
+            kashi_base_dir = base_dir.join('tests')
+            FileUtils.mkdir_p(kashi_base_dir)
+            sc_file = kashi_base_dir.join("#{test['WebsiteName'].gsub(/[\/ ]/, '_')}_#{test['TestID']}.cake")
+            Kashi.logger.info("Export #{sc_file}")
+            open(sc_file, 'wb') do |f|
+              f.puts MAGIC_COMMENT
+              f.puts dsl
+            end
+          end
+        end
+      elsif @options[:split]
+        # contact_groups
+        Converter.new({}, contact_groups_by_id).convert do |dsl|
+          sc_file = base_dir.join('contact_groups.cake')
+          Kashi.logger.info("Export #{sc_file}")
+          open(sc_file, 'wb') do |f|
+            f.puts MAGIC_COMMENT
+            f.puts dsl
+          end
+        end
+
+        # test
+        Converter.new(tests_by_id, {}).convert do |dsl|
+          sc_file = base_dir.join('tests.cake')
+          Kashi.logger.info("Export #{sc_file}")
+          open(sc_file, 'wb') do |f|
+            f.puts MAGIC_COMMENT
+            f.puts dsl
+          end
+        end
+      else
+        Converter.new(tests_by_id, contact_groups_by_id).convert do |dsl|
+          FileUtils.mkdir_p(base_dir)
+          Kashi.logger.info("Export #{path}")
+          open(path, 'wb') do |f|
+            f.puts MAGIC_COMMENT
+            f.puts dsl
+          end
+        end
+      end
+    end
+
+    # for develop
+    CACHE_DIR = Pathname.new("./tmp")
+    def cache(key)
+      cache_file = CACHE_DIR.join("#{key}.json")
+      if cache_file.exist?
+        return JSON.parse(cache_file.read)
+      end
+
+      yield.tap do |res|
+        cache_file.write(res.to_json)
+      end
+    end
+
+    def load_file(file)
+      open(file) do |f|
+        DSL.define(f.read, file, @options).result
+      end
+    end
+
+    def client
+      @client ||= ClientWrapper.new(@options)
+    end
+  end
+end

data/lib/kashi/client_wrapper.rb

@@ -0,0 +1,17 @@
+require 'forwardable'
+require 'statuscake'
+
+module Kashi
+  class ClientWrapper
+    extend Forwardable
+
+    def_delegators :@client, *%i/
+      contactgroups contactgroups_update
+      tests tests_details tests_update
+    /
+
+    def initialize(options)
+      @client = StatusCake::Client.new(API: ENV['KASHI_SC_API_KEY'], Username: ENV['KASHI_SC_USER'])
+    end
+  end
+end

data/lib/kashi/converter.rb

@@ -0,0 +1,21 @@
+require 'erb'
+
+module Kashi
+  class Converter
+    def initialize(tests_by_id, contact_groups_by_id)
+      @tests_by_id = tests_by_id
+      @contact_groups_by_id = contact_groups_by_id
+    end
+
+    def convert
+      yield output_test(@tests_by_id, @contact_groups_by_id)
+    end
+
+    private
+
+    def output_test(tests_by_id, contact_groups_by_id)
+      path = Pathname.new(File.expand_path('../', __FILE__)).join('output_test.erb')
+      ERB.new(path.read, nil, '-').result(binding)
+    end
+  end
+end

data/lib/kashi/dsl/cake.rb

@@ -0,0 +1,49 @@
+require 'ostruct'
+require 'kashi/dsl/test'
+require 'kashi/dsl/contact_group'
+
+module Kashi
+  class DSL
+    class Cake
+      attr_reader :result
+
+      def initialize(context, tests = [], contacts = [], &block)
+        @context = context
+
+        @result = OpenStruct.new(tests: tests, contact_groups: contacts)
+
+        @tests = []
+        @contacts = []
+        instance_eval(&block)
+      end
+
+      private
+
+      def test(*args, &block)
+        test_id = nil
+        unless args.empty?
+          if @tests.include?(test_id)
+            raise "#{test_id} is already defined"
+          end
+          test_id = args.first
+        end
+
+        @result.tests << Test.new(@context, test_id, &block).result
+        @tests << test_id
+      end
+
+      def contact_group(*args, &block)
+        contact_id = nil
+        unless args.empty?
+          if @contacts.include?(contact_id)
+            raise "#{contact_id} is already defined"
+          end
+          contact_id = args.first
+        end
+
+        @result.contact_groups << ContactGroup.new(@context, contact_id, &block).result
+        @contacts << contact_id
+      end
+    end
+  end
+end