kashi 0.1.0.beta1

data/lib/kashi/dsl/contact_group.rb

@@ -0,0 +1,125 @@
+require 'kashi/utils'
+require 'kashi/client_wrapper'
+
+module Kashi
+  class DSL
+    class ContactGroup
+      attr_reader :result
+
+      class Result
+        PARAMS = %i/ContactID GroupName DesktopAlert Email Boxcar Pushover PingURL Mobile/
+        ATTRIBUTES = %i/contact_id group_name desktop_alert email boxcar pushover ping_url mobile/
+        attr_accessor *ATTRIBUTES
+
+        def initialize(context)
+          @context = context
+          @options = context.options
+        end
+
+        def to_h
+          Hash[ATTRIBUTES.sort.map { |name| [name, public_send(name)] }]
+        end
+
+        def create_params
+          hash = modify_params
+          hash.delete(:ContactID)
+          hash
+        end
+
+        def modify_params
+          hash = to_h.select { |k, _| ATTRIBUTES.include?(k) }
+          ATTRIBUTES.zip(PARAMS).each do |from, to|
+            hash[to] = hash.delete(from)
+          end
+          hash[:Email] = Array(hash[:Email]).join(',')
+          hash
+        end
+
+        def create
+          Kashi.logger.info("Create ContactGroup `#{group_name}`")
+          Kashi.logger.debug(create_params)
+          return { 'Success' => true } if @options[:dry_run]
+
+          client.contactgroups_update(create_params)
+        end
+
+        def cake(sc_contact_group)
+          @sc_contact_group = sc_contact_group
+          self.contact_id = sc_contact_group['ContactID']
+          self
+        end
+
+        def dsl_hash
+          Kashi::Utils.normalize_hash(to_h)
+        end
+
+        def sc_hash
+          hash = @sc_contact_group.to_h.keys.each_with_object({}) do |k, h|
+            h[k.to_s.to_snake.to_sym] = @sc_contact_group.to_h[k]
+          end
+          { emails: :email, mobiles: :mobile }.each do |k, v|
+            hash[v] = hash.delete(k)
+          end
+          Kashi::Utils.normalize_hash(hash)
+        end
+
+        def updated?
+          dsl_hash != sc_hash
+        end
+
+        def modify
+          return unless updated?
+          Kashi.logger.info("Modify ContactGroup `#{group_name}` #{contact_id}")
+          Kashi.logger.info("<diff>\n#{Kashi::Utils.diff(sc_hash, dsl_hash, color: @options[:color])}")
+          Kashi.logger.debug(modify_params)
+          return if @options[:dry_run]
+
+          client.contactgroups_update(modify_params)
+        end
+
+        def client
+          @client ||= ClientWrapper.new(@options)
+        end
+      end
+
+      def initialize(context, contact_id, &block)
+        @context = context.merge(contact_id: contact_id)
+
+        @result = Result.new(@context)
+        @result.contact_id = contact_id
+
+        instance_eval(&block)
+      end
+
+      private
+
+      def group_name(name)
+        @result.group_name = name
+      end
+
+      def desktop_alert(alert)
+        @result.desktop_alert = alert
+      end
+
+      def email(email)
+        @result.email = Array(email)
+      end
+
+      def boxcar(boxcar)
+        @result.boxcar = boxcar
+      end
+
+      def pushover(pushover)
+        @result.pushover = pushover
+      end
+
+      def ping_url(url)
+        @result.ping_url = url
+      end
+
+      def mobile(mobile)
+        @result.mobile = mobile
+      end
+    end
+  end
+end

data/lib/kashi/dsl/test.rb

@@ -0,0 +1,275 @@
+require 'ostruct'
+
+module Kashi
+  class DSL
+    class Test
+      class Result
+        PARAMS = %i/
+          TestID Paused WebsiteName WebsiteURL Port NodeLocations Timeout CustomHeader Confirmation CheckRate
+          DNSServer DNSIP BasicUser BasicPass LogoImage UseJar WebsiteHost Virus FindString DoNotFind
+          TestType ContactGroup TriggerRate TestTags StatusCodes EnableSSLWarning FollowRedirect
+        / # PingURL RealBrowser Public Branding
+        ATTRIBUTES = %i/
+          test_id paused website_name website_url port node_locations timeout custom_header confirmation check_rate
+          dns_server dns_ip basic_user basic_pass logo_image use_jar website_host virus find_string do_not_find
+          test_type contact_group trigger_rate test_tags status_codes enable_ssl_warning follow_redirect
+        / # ping_url real_browser public branding
+        attr_accessor *ATTRIBUTES
+
+        def initialize(context)
+          @context = context
+          @options = context.options
+        end
+
+        def to_h
+          Hash[ATTRIBUTES.sort.map { |name| [name, public_send(name)] }]
+        end
+
+        def modify_params
+          hash = to_h.select { |k, _| ATTRIBUTES.include?(k) }
+          ATTRIBUTES.zip(PARAMS).each do |from, to|
+            hash[to] = hash.delete(from)
+          end
+          %i/NodeLocations TestTags StatusCodes/.each do |k|
+            hash[k] = Array(hash[k]).join(',')
+          end
+          contact_group_id_by_group_name = client.contactgroups.each_with_object({}) do |contact_group, h|
+            h[contact_group['GroupName']] = contact_group['ContactID']
+          end
+          hash[:ContactGroup] = contact_group.map { |name|
+            contact_group_id_by_group_name[name]
+          }.compact.join(',')
+          hash
+        end
+
+        def create_params
+          hash = modify_params
+          hash.delete(:TestID)
+          hash
+        end
+
+        def create
+          Kashi.logger.info("Create Test `#{website_name}`")
+          Kashi.logger.debug(create_params)
+          return { 'Success' => true } if @options[:dry_run]
+
+          client.tests_update(create_params)
+        end
+
+        def cake(sc_test)
+          @sc_test = sc_test
+          self.test_id = sc_test['TestID']
+          self
+        end
+
+        def dsl_hash
+          Kashi::Utils.normalize_hash(to_h)
+        end
+
+        def sc_hash
+          hash = @sc_test.to_h.keys.each_with_object({}) do |k, h|
+            next if %w/DownTimes LastTested NextLocation Processing ProcessingOn ProcessingState Sensitive Status Uptime Method ContactGroup ContactID/.include?(k)
+            h[k.to_s.to_snake.to_sym] = @sc_test.to_h[k]
+          end
+          # rename
+          { uri: :website_url, dnsip: :dns_ip, tags: :test_tags }.each do |k, v|
+            hash[v] = hash.delete(k)
+          end
+          %i/basic_user basic_pass/.each do |k|
+            hash[k] = ''
+          end
+          %i/port use_jar virus/.each do |k|
+            hash[k] = '' unless hash.key?(k)
+          end
+          %i/paused enable_ssl_warning follow_redirect do_not_find/.each do |k|
+            hash[k] = hash[k] ? 1 : 0
+          end
+          hash[:contact_group] = hash.delete(:contact_groups).map { |contact_group| contact_group['Name'] }
+          hash[:test_tags] = Array(hash[:test_tags])
+          if hash[:custom_header] == false || hash[:custom_header] == ''
+            hash[:custom_header] = ''
+          else
+            hash[:custom_header] = JSON.parse(hash[:custom_header]).to_json
+          end
+          Kashi::Utils.normalize_hash(hash)
+        end
+
+        def updated?
+          dsl_hash != sc_hash
+        end
+
+        def modify
+          return unless updated?
+          Kashi.logger.info("Modify Test `#{website_name}` #{test_id}")
+          Kashi.logger.info("<diff>\n#{Kashi::Utils.diff(sc_hash, dsl_hash, color: @options[:color])}")
+          Kashi.logger.debug(modify_params)
+          return if @options[:dry_run]
+
+          client.tests_update(modify_params)
+        end
+
+        def client
+          @client ||= ClientWrapper.new(@options)
+        end
+      end
+
+      attr_reader :result
+
+      def initialize(context, test_id, &block)
+        @context = context.merge(test_id: test_id)
+
+        @result = Result.new(@context)
+        @result.test_id = test_id
+
+        # default values
+        @result.paused = 0
+        @result.timeout = 30
+        @result.confirmation = 0
+        @result.check_rate = 300
+        # @result.public = 0
+        # @result.use_jar = 0
+        # @result.branding = 0
+        @result.do_not_find = 0
+        # @result.real_browser = 0
+        @result.trigger_rate = 5
+        @result.enable_ssl_warning = 1
+        @result.follow_redirect = 1
+        @result.test_tags = []
+        @result.node_locations = ['']
+        @result.status_codes = []
+        @result.virus = ''
+
+        instance_eval(&block)
+      end
+
+      private
+
+      def paused(paused)
+        @result.paused = paused
+      end
+
+      def website_url(url)
+        @result.website_url = url
+      end
+
+      def website_name(name)
+        @result.website_name = name
+      end
+
+      def port(port)
+        @result.port = port
+      end
+
+      # def ping_url(url)
+      #   @result.ping_url = url
+      # end
+
+      def custom_header(header)
+        if header == '' || header == nil
+          @result.custom_header = ''
+        else
+          @result.custom_header = header.to_json
+        end
+      end
+
+      def confirmation(confirmation)
+        @result.confirmation = confirmation
+      end
+
+      def test_type(type)
+        @result.test_type = type
+      end
+
+      def contact_group(groups)
+        @result.contact_group = Array(groups)
+      end
+
+      def check_rate(rate)
+        @result.check_rate = rate
+      end
+
+      def timeout(timeout)
+        @result.timeout = timeout
+      end
+
+      def website_host(host)
+        @result.website_host = host
+      end
+
+      def node_locations(locations)
+        @result.node_locations = locations
+      end
+
+      def find_string(str)
+        @result.find_string = str
+      end
+
+      def do_not_find(do_not_find)
+        @result.do_not_find = do_not_find
+      end
+
+      def basic_user(user)
+        @result.basic_user = user
+      end
+
+      def basic_pass(pass)
+        @result.basic_pass = pass
+      end
+
+      # def public(pub)
+      #   @result.public = pub
+      # end
+
+      def logo_image(logo)
+        @result.logo_image = logo
+      end
+
+      def use_jar(use_jar)
+        @result.use_jar = use_jar
+      end
+
+      # def branding(branding)
+      #   @result.branding = branding
+      # end
+
+      def virus(virus)
+        @result.virus = virus
+      end
+
+      # def real_browser(real_browser)
+      #   @result.real_browser = real_browser
+      # end
+
+      def dns_server(dns_server)
+        @result.dns_server = dns_server
+      end
+
+      def dns_ip(ip)
+        @result.dns_ip = ip
+      end
+
+      def trigger_rate(rate)
+        @result.trigger_rate = rate
+      end
+
+      def test_tags(tags)
+        if tags == nil
+          @result.test_tags = []
+        end
+        @result.test_tags = Array(tags)
+      end
+
+      def status_codes(codes)
+        @result.status_codes = codes
+      end
+
+      def enable_ssl_warning(enable_ssl_warning)
+        @result.enable_ssl_warning = enable_ssl_warning
+      end
+
+      def follow_redirect(follow_redirect)
+        @result.follow_redirect = follow_redirect
+      end
+    end
+  end
+end

data/lib/kashi/dsl.rb

@@ -0,0 +1,54 @@
+require 'ostruct'
+require 'hashie'
+require 'kashi/dsl/cake'
+
+module Kashi
+  class DSL
+    class << self
+      def define(source, filepath, options)
+        self.new(filepath, options) do
+          eval(source, binding, filepath)
+        end
+      end
+    end
+
+    attr_reader :result
+
+    def initialize(filepath, options, &block)
+      @filepath = filepath
+      @result = OpenStruct.new(cake: nil)
+
+      @context = Hashie::Mash.new(
+        filepath: filepath,
+        templates: {},
+        options: options,
+      )
+
+      instance_eval(&block)
+    end
+
+    def require(file)
+      scfile = (file =~ %r|\A/|) ? file : File.expand_path(File.join(File.dirname(@filepath), file))
+
+      if File.exist?(scfile)
+        instance_eval(File.read(scfile), scfile)
+      elsif File.exist?("#{scfile}.rb")
+        instance_eval(File.read("#{scfile}.rb"), "#{scfile}.rb")
+      else
+        Kernel.require(file)
+      end
+    end
+
+    def template(name, &block)
+      @context.templates[name.to_s] = block
+    end
+
+    def cake(&block)
+      if @result.cake
+        @result.cake = Cake.new(@context, @result.cake.tests, @result.cake.contact_groups, &block).result
+      else
+        @result.cake = Cake.new(@context, &block).result
+      end
+    end
+  end
+end

data/lib/kashi/ext/string-ext.rb

@@ -0,0 +1,9 @@
+class String
+  def to_snake()
+    self
+      .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+      .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+      .tr("-", "_")
+      .downcase
+  end
+end

data/lib/kashi/output_test.erb

@@ -0,0 +1,89 @@
+cake do
+  <%- contact_groups_by_id.each do |contact_id, contact_group| -%>
+  contact_group <%= contact_id %> do
+    group_name <%= contact_group['GroupName'].inspect %>
+    desktop_alert <%= contact_group['DesktopAlert'].inspect %>
+    email <%= contact_group['Emails'].inspect %>
+    boxcar <%= contact_group['Boxcar'].inspect %>
+    pushover <%= contact_group['Pushover'].inspect %>
+    ping_url <%= contact_group['PingURL'].inspect %>
+    mobile <%= contact_group['Mobiles'].inspect %>
+  end
+    <%- if contact_groups_by_id.keys.last != contact_id -%>
+
+    <%- end -%>
+  <%- end -%>
+  <%- if !contact_groups_by_id.empty? && !tests_by_id.empty? -%>
+
+  <%- end -%>
+  <%- tests_by_id.each do |test_id, test| -%>
+  test <%= test_id.inspect %> do
+    paused <%= test['Paused'] ? 1 : 0 %>
+
+    test_type <%= test['TestType'].inspect %>
+
+    # Required Details
+    website_name <%= test['WebsiteName'].inspect %>
+    website_url <%= test['URI'].inspect %>
+    <%- if %w/SMTP SSH TCP/.include?(test['TestType']) -%>
+    port <%= test['Port'].inspect %>
+    <%- end -%>
+    <%- if test['TestType'] == 'DNS' -%>
+    dns_ip <%= test['DNSIP'].inspect %>
+    dns_server <%= test['DNSServer'].inspect %>
+    <%- end -%>
+    <%- if %w/HTTP HEAD SSH/.include?(test['TestType']) -%>
+    <%- if test['BasicUser'] -%>
+    basic_user <%= test['BasicUser'].inspect %>
+    <%- end -%>
+    <%- if test['BasicPass'] -%>
+    basic_pass <%= test['BasicPass'].inspect %>
+    <%- end -%>
+    <%- end -%>
+
+    contact_group <%= test['ContactGroups'].map { |contact_group| contact_group['Name'] }.inspect %>
+
+    <%- if %w/HTTP HEAD/.include?(test['TestType']) -%>
+    # Scans
+    enable_ssl_warning <%= test['EnableSSLWarning'] ? 1 : 0 %>
+    <%- if test['Virus'] -%>
+    virus 1
+    <%- end -%>
+
+    # HTTP Communication Options
+    find_string <%= test['FindString'].inspect %>
+    do_not_find <%= test['DoNotFind'] ? 1 : 0 %>
+    <%- if test['UseJar'] -%>
+    use_jar <%= test['UseJar'].inspect %>
+    <%- end -%>
+    follow_redirect <%= test['FollowRedirect'] ? 1 : 0 %>
+    custom_header(
+      <%= (test['CustomHeader'] == '' ? '' : JSON.parse(test['CustomHeader'])).inspect %>
+    )
+    status_codes <%= test['StatusCodes'].inspect %>
+    <%- end -%>
+
+    logo_image <%= test['LogoImage'].inspect %>
+
+    <%- if test['NodeLocations'] -%>
+    # Test Locations
+    node_locations <%= test['NodeLocations'].inspect %>
+    <%- end -%>
+
+    # Threshold Control
+    trigger_rate <%= test['TriggerRate'].inspect %>
+    confirmation <%= test['Confirmation'].inspect %>
+
+    # Additional Options
+    check_rate <%= test['CheckRate'].inspect %>
+    timeout <%= test['Timeout'].inspect %>
+    <%- if test['Tags'] -%>
+    test_tags <%= test['Tags'].inspect %>
+    <%- end -%>
+    website_host <%= test['WebsiteHost'].inspect %>
+  end
+    <%- if tests_by_id.keys.last != test_id -%>
+
+    <%- end -%>
+  <%- end -%>
+end

data/lib/kashi/utils.rb

@@ -0,0 +1,52 @@
+require 'diffy'
+require 'pp'
+
+module Kashi
+  class Utils
+    class << self
+      def normalize_hash(hash)
+        hash.dup.each do |k, v|
+          if v.kind_of?(Array)
+            v.sort!
+            if v.first.kind_of?(Hash)
+              hash[k] = v.map { |o| normalize_hash(o) }
+            elsif v.first.respond_to?(:to_h)
+              hash[k] = v.map { |o| normalize_hash(o.to_h) }
+            end
+          elsif v == nil
+            hash[k] = ''
+          elsif v.respond_to?(:to_h)
+            hash[k] = normalize_hash(v.to_h)
+          end
+        end
+        sort_keys(hash)
+      end
+
+      def sort_keys(hash)
+        hash = Hash[hash.sort]
+        hash.each do |k, v|
+          if v.kind_of?(Array)
+            if v.first.kind_of?(Hash)
+              hash[k] = v.map { |h| sort_keys(h) }
+            end
+          elsif v.kind_of?(Hash)
+            hash[k] = sort_keys(v)
+          end
+        end
+        hash
+      end
+
+      def diff(obj1, obj2, options = {})
+        diffy = Diffy::Diff.new(
+          obj1.pretty_inspect,
+          obj2.pretty_inspect,
+          :diff => '-u'
+        )
+
+        out = diffy.to_s(options[:color] ? :color : :text).gsub(/\s+\z/m, '')
+        out.gsub!(/^/, options[:indent]) if options[:indent]
+        out
+      end
+    end
+  end
+end

data/lib/kashi/version.rb

@@ -0,0 +1,3 @@
+module Kashi
+  VERSION = '0.1.0.beta1'
+end

data/lib/kashi.rb

@@ -0,0 +1,15 @@
+require 'logger'
+require 'kashi/version'
+require 'kashi/ext/string-ext'
+
+module Kashi
+  def self.logger
+    @logger ||=
+      begin
+        $stdout.sync = true
+        Logger.new($stdout).tap do |l|
+          l.level = Logger::INFO
+        end
+      end
+  end
+end