pechkin 1.2.1 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3447abc49727b844f0c86895242a10aa1c3cee00e1fbdff5deb915ba790ebe98
-  data.tar.gz: 3352b4e61c0a9885d8e0b14b497e41947952b996bd522e238ac519100965ff2d
+  metadata.gz: 3fa8abd425ad6a776104aabeeb6916d4b8b4d77ae0f0d7e24b75f102bb70b016
+  data.tar.gz: 1b5b43910b029f8553f54ddfa5d70a7195b2db86d35a38ba1fcffc37521b7d4b
 SHA512:
-  metadata.gz: 81fbdfd449664ed2715035649db5f3c9f31740ca9ade3295d5eab19415e6cc3ea9eae0652e99810c0ff3317b8815032a10e4e257246802efee3d31e247d4dbe9
-  data.tar.gz: 84ce0aa1dfb906e2bae2221e85fe77bdc48ec160ad6bf494c6ba1fcf64bb6a7c274a479a22825954cf66dad8470546cec9283a120434f85be0b7a17182eb4a22
+  metadata.gz: d636b920cb207c03ce1f96ceeb47ec478214743e0ef4f49895c07982fcf68d2b724d4006058ef00de6903c986c6f40e8678ebbb7ccdaa681d6b552cfb70111a1
+  data.tar.gz: 5254cb1f323cb46af16b889d82ffd565a9a0f30e5665cc6c5487e59926f25e66b8a573e004ffcf4c2a34b8f17187b0e67443ef5bf5ffec3b8e2a68e079557def

data/lib/pechkin/app/app.rb

@@ -0,0 +1,44 @@
+module Pechkin
+  # Rack application to handle requests
+  class App
+    DEFAULT_CONTENT_TYPE = { 'Content-Type' => 'application/json' }.freeze
+    DEFAULT_HEADERS = {}.merge(DEFAULT_CONTENT_TYPE).freeze
+
+    attr_accessor :handler, :logger
+
+    def initialize(logger)
+      @logger = logger
+    end
+
+    def call(env)
+      req = Rack::Request.new(env)
+      result = RequestHandler.new(handler, req, logger).handle
+      response(200, result)
+    rescue AppError => e
+      proces_app_error(req, e)
+    rescue StandardError => e
+      process_unhandled_error(req, e)
+    end
+
+    private
+
+    def response(code, body)
+      [code.to_s, DEFAULT_HEADERS, [body.to_json]]
+    end
+
+    def proces_app_error(req, err)
+      data = { status: 'error', message: err.message }
+      req.body.rewind
+      body = req.body.read
+      logger.error "Can't process message: #{err.message}. Body: '#{body}'"
+      response(err.code, data)
+    end
+
+    def process_unhandled_error(req, err)
+      data = { status: 'error', message: err.message }
+      logger.error("#{err.message}\n\t" + err.backtrace.join("\n\t"))
+      logger.error(req.body.read)
+      response(503, data)
+    end
+  end
+end

data/lib/pechkin/app/app_builder.rb

@@ -0,0 +1,39 @@
+module Pechkin
+  # Application configurator and builder. This creates all needed middleware
+  # and stuff
+  class AppBuilder
+    def build(handler, options)
+      logger = create_logger(options.log_dir)
+      handler.logger = logger
+      app = App.new(logger)
+      app.handler = handler
+      prometheus = Pechkin::PrometheusUtils.registry
+
+      Rack::Builder.app do
+        use Rack::CommonLogger, logger
+        use Rack::Deflater
+        use Prometheus::Middleware::Collector, registry: prometheus
+        # Add Auth check if found htpasswd file or it was excplicitly provided
+        # See CLI class for configuration details
+        use Pechkin::Auth::Middleware, auth_file: options.htpasswd if options.htpasswd
+        use Prometheus::Middleware::Exporter, registry: prometheus
+
+        run app
+      end
+    end
+
+    private
+
+    def create_logger(log_dir)
+      if log_dir
+        raise "Directory #{log_dir} does not exist" unless File.exist?(log_dir)
+
+        log_file = File.join(log_dir, 'pechkin.log')
+        file = File.open(log_file, File::WRONLY | File::APPEND)
+        Logger.new(file)
+      else
+        Logger.new($stdout)
+      end
+    end
+  end
+end

data/lib/pechkin/app/app_error.rb

@@ -0,0 +1,27 @@
+module Pechkin
+  # Generic application error class.
+  #
+  # Allows us return meaningful error messages
+  class AppError < StandardError
+    attr_reader :code
+
+    def initialize(code, msg)
+      super(msg)
+      @code = code
+    end
+
+    class << self
+      def bad_request(message)
+        AppError.new(503, message)
+      end
+
+      def message_not_found
+        AppError.new(404, 'message not found')
+      end
+
+      def http_method_not_allowed
+        AppError.new(405, 'method not allowed')
+      end
+    end
+  end
+end

data/lib/pechkin/app/request_handler.rb

@@ -0,0 +1,49 @@
+module Pechkin
+  # Http requests handler. We need fresh instance per each request. To keep
+  # internal state isolated
+  class RequestHandler
+    REQ_PATH_PATTERN = %r{^/(.+)/([^/]+)/?$}.freeze
+
+    attr_reader :req, :handler,
+                :channel_id, :message_id,
+                :logger
+
+    def initialize(handler, req, logger)
+      @handler = handler
+      @req = req
+      @logger = logger
+
+      @channel_id, @message_id = req.path_info.match(REQ_PATH_PATTERN) do |m|
+        [m[1], m[2]]
+      end
+    end
+
+    def handle
+      raise AppError.http_method_not_allowed unless post?
+      raise AppError.message_not_found unless message?
+
+      data = parse_data(req.body.read)
+      handler.handle(channel_id, message_id, data).each do |i|
+        logger.info "Sent #{channel_id}/#{message_id}: #{i.to_json}"
+      end
+    end
+
+    private
+
+    def parse_data(data)
+      JSON.parse(data)
+    rescue JSON::JSONError => e
+      raise AppError.bad_request(e.message)
+    end
+
+    def message?
+      return false unless @channel_id && @message_id
+
+      handler.message?(@channel_id, @message_id)
+    end
+
+    def post?
+      req.post?
+    end
+  end
+end

data/lib/pechkin/app.rb

@@ -1,114 +1,4 @@
-module Pechkin
-  # Application configurator and builder. This creates all needed middleware
-  # and stuff
-  class AppBuilder
-    def build(handler, options)
-      app = App.new
-      app.handler = handler
-      prometheus = Pechkin::PrometheusUtils.registry
-      logger = create_logger(options.log_dir)
-
-      Rack::Builder.app do
-        use Rack::CommonLogger, logger
-        use Rack::Deflater
-        use Prometheus::Middleware::Collector, registry: prometheus
-        # Add Auth check if found htpasswd file or it was excplicitly provided
-        # See CLI class for configuration details
-        if options.htpasswd
-          use Pechkin::Auth::Middleware, auth_file: options.htpasswd
-        end
-        use Prometheus::Middleware::Exporter, registry: prometheus
-
-        run app
-      end
-    end
-
-    private
-
-    def create_logger(log_dir)
-      if log_dir
-        raise "Directory #{log_dir} does not exist" unless File.exist?(log_dir)
-
-        log_file = File.join(log_dir, 'pechkin.log')
-        file = File.open(log_file, File::WRONLY | File::APPEND)
-        Logger.new(file)
-      else
-        Logger.new(STDOUT)
-      end
-    end
-  end
-
-  # Rack application to handle requests
-  class App
-    attr_accessor :handler
-
-    def call(env)
-      RequestHandler.new(handler, env).handle
-    rescue StandardError => e
-      body = { status: 'error', reason: e.message }.to_json
-      ['503', { 'Content-Type' => 'application/json' }, [body]]
-    end
-  end
-
-  # Http requests handler. We need fresh instance per each request. To keep
-  # internal state isolated
-  class RequestHandler
-    REQ_PATH_PATTERN = %r{^/(.+)/([^/]+)/?$}
-    DEFAULT_CONTENT_TYPE = { 'Content-Type' => 'application/json' }.freeze
-    DEFAULT_HEADERS = {}.merge(DEFAULT_CONTENT_TYPE).freeze
-
-    attr_reader :req, :env, :handler,
-                :channel_id, :message_id
-
-    def initialize(handler, env)
-      @handler = handler
-      @env = env
-      @req = Rack::Request.new(env)
-
-      @channel_id, @message_id = req.path_info.match(REQ_PATH_PATTERN) do |m|
-        [m[1], m[2]]
-      end
-    end
-
-    def handle
-      return not_allowed unless post?
-      return not_found unless message?
-
-      begin
-        data = JSON.parse(req.body.read)
-      rescue JSON::JSONError => e
-        return bad_request(e.message)
-      end
-
-      response(200, handler.handle(channel_id, message_id, data).to_json)
-    end
-
-    private
-
-    def message?
-      return false unless @channel_id && @message_id
-
-      handler.message?(@channel_id, @message_id)
-    end
-
-    def not_allowed
-      response(405, '{"status":"error", "reason":"method not allowed"}')
-    end
-
-    def not_found
-      response(404, '{"status":"error", "reason":"message not found"}')
-    end
-
-    def bad_request(body)
-      response(503, body)
-    end
-
-    def response(code, body)
-      [code.to_s, DEFAULT_HEADERS, [body]]
-    end
-
-    def post?
-      req.post?
-    end
-  end
-end
+require_relative 'app/app_builder'
+require_relative 'app/app_error'
+require_relative 'app/app'
+require_relative 'app/request_handler'

data/lib/pechkin/auth.rb

@@ -5,6 +5,7 @@ module Pechkin
     # Utility class for altering htpasswd files
     class Manager
       attr_reader :htpasswd
+
       def initialize(htpasswd)
         @htpasswd = htpasswd
       end

data/lib/pechkin/channel.rb

@@ -3,7 +3,7 @@ module Pechkin
   class Chanel
     attr_accessor :logger
 
-    def initialize(connector, channel_list, logger = ::Logger.new(STDOUT))
+    def initialize(connector, channel_list, logger = ::Logger.new($stdout))
       @connector = connector
       @channel_list = channel_list
       @channel_list = [channel_list] unless channel_list.is_a?(Array)

data/lib/pechkin/cli.rb

@@ -13,7 +13,7 @@ module Pechkin
     # @opt names [Array<String>] list of command line keys
     # @opt desc [String] option description
     # @opt type [Class] argument type to parse from command line, e.g. Integer
-    def opt(name, default: nil, names:, desc: '', type: nil)
+    def opt(name, names:, default: nil, desc: '', type: nil)
       @cli_options ||= []
 
       # raise ':names is nil or empty' if names.nil? || names.empty?

data/lib/pechkin/command/base.rb

@@ -9,7 +9,7 @@ module Pechkin
       #   command behaviour
       # @opt stdout [IO] IO object which represents STDOUT
       # @opt stderr [IO] IO object which represents STDERR
-      def initialize(options, stdout: STDOUT, stderr: STDERR)
+      def initialize(options, stdout: $stdout, stderr: $stderr)
         @options = options
         @stdout = stdout
         @stderr = stderr

data/lib/pechkin/command/run_server.rb

@@ -8,7 +8,7 @@ module Pechkin
 
       def execute
         Rack::Server.start(app: AppBuilder.new.build(handler, options),
-                           Host: options.bind_adress,
+                           Host: options.bind_address,
                            Port: options.port,
                            pid: options.pid_file)
       end

data/lib/pechkin/command/send_data.rb

@@ -29,6 +29,7 @@ module Pechkin
         d = if data.start_with?('@')
               file = data[1..-1]
               raise "File not found #{file}" unless File.exist?(file)
+
               IO.read(file)
             else
               data

data/lib/pechkin/configuration/configuration_loader.rb

@@ -13,11 +13,11 @@ module Pechkin
     def create_connector(bot)
       case bot.connector
       when 'tg', 'telegram'
-        TelegramConnector.new(bot.token, bot.name)
+        Connector::Telegram.new(bot.token, bot.name)
       when 'slack'
-        SlackConnector.new(bot.token, bot.name)
+        Connector::Slack.new(bot.token, bot.name)
       else
-        raise 'Unknown connector ' + bot.connector + ' for ' + bot.name
+        raise "Unknown connector #{bot.connector} for #{bot.name}"
       end
     end
 

data/lib/pechkin/configuration/configuration_loader_bots.rb

@@ -15,9 +15,7 @@ module Pechkin
     def load_bots_configuration(working_dir, bots)
       bots_dir = File.join(working_dir, 'bots')
 
-      unless File.directory?(bots_dir)
-        raise ConfigurationError, "'#{bots_dir}' is not a directory"
-      end
+      raise ConfigurationError, "'#{bots_dir}' is not a directory" unless File.directory?(bots_dir)
 
       Dir["#{bots_dir}/*.yml"].each do |bot_file|
         name = File.basename(bot_file, '.yml')

data/lib/pechkin/configuration/configuration_loader_channels.rb

@@ -22,9 +22,7 @@ module Pechkin
     def load_channels_configuration(working_dir, channels)
       channels_dir = File.join(working_dir, 'channels')
 
-      unless File.directory?(channels_dir)
-        raise ConfigurationError, "'#{channels_dir}' is not a directory"
-      end
+      raise ConfigurationError, "'#{channels_dir}' is not a directory" unless File.directory?(channels_dir)
 
       Dir["#{channels_dir}/*"].each do |channel_dir|
         next unless File.directory?(channel_dir)
@@ -63,9 +61,7 @@ module Pechkin
         message_config = YAML.safe_load(IO.read(file))
         name = File.basename(file, '.yml')
 
-        if message_config.key?('template')
-          message_config['template'] = get_template(message_config['template'])
-        end
+        message_config['template'] = get_template(message_config['template']) if message_config.key?('template')
 
         messages[name] = message_config
       end

data/lib/pechkin/configuration/configuration_loader_views.rb

@@ -15,9 +15,7 @@ module Pechkin
     def load_views_configuration(working_dir, views)
       views_dir = File.join(working_dir, 'views')
 
-      unless File.directory?(views_dir)
-        raise ConfigurationError, "'#{views_dir}' is not a directory"
-      end
+      raise ConfigurationError, "'#{views_dir}' is not a directory" unless File.directory?(views_dir)
 
       Dir["#{views_dir}/**/*.erb"].each do |f|
         relative_path = f["#{views_dir}/".length..-1]

data/lib/pechkin/configuration.rb

@@ -10,16 +10,16 @@ module Pechkin
   # Pechkin reads its configuration from provided directory structure. Basic
   # layout expected to be as follows:
   #   .
-  #   | - bots/                  <= Bots configuration
-  #   |   | - marvin.yml         <= Each bot described by yaml file
+  #   | - bots/                  <- Bots configuration
+  #   |   | - marvin.yml         <- Each bot described by yaml file
   #   |   | - bender.yml
   #   |
-  #   | - channels/              <= Channels description
+  #   | - channels/              <- Channels description
   #   |   | - slack-repository-feed
   #   |       | - commit-hg.yml
   #   |       | - commit-svn.yml
   #   |
-  #   | - views/                 <= Template storage
+  #   | - views/                 <- Template storage
   #       | - commit-hg.erb
   #       | - commit-svn.erb
   #

data/lib/pechkin/connector/base.rb

@@ -0,0 +1,29 @@
+module Pechkin
+  module Connector
+    # Base connector
+    class Base
+      DEFAULT_HEADERS = {
+        'Content-Type' => 'application/json; charset=UTF-8'
+      }.freeze
+
+      def send_message(chat, message, message_desc); end
+
+      def preview(chats, message, _message_desc)
+        "Connector: #{self.class.name}; Chats: #{chats.join(', ')}\n" \
+        "Message:\n#{message}"
+      end
+
+      def post_data(url, data, headers: {})
+        uri = URI.parse(url)
+        headers = DEFAULT_HEADERS.merge(headers)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = url.start_with?('https://')
+
+        request = Net::HTTP::Post.new(uri.request_uri, headers)
+        request.body = data.to_json
+
+        http.request(request)
+      end
+    end
+  end
+end

data/lib/pechkin/connector/slack.rb

@@ -0,0 +1,32 @@
+module Pechkin
+  module Connector
+    class Slack < Connector::Base # :nodoc:
+      attr_reader :name
+
+      def initialize(bot_token, name)
+        super()
+
+        @headers = { 'Authorization' => "Bearer #{bot_token}" }
+        @name = name
+      end
+
+      def send_message(channel, message, message_desc)
+        text = CGI.unescape_html(message)
+
+        attachments = message_desc['slack_attachments'] || {}
+
+        if text.strip.empty? && attachments.empty?
+          return { channel: channel, code: 400,
+                   response: 'Internal error: message is empty' }
+        end
+
+        params = { channel: channel, text: text, attachments: attachments }
+
+        url = 'https://slack.com/api/chat.postMessage'
+        response = post_data(url, params, headers: @headers)
+
+        { channel: channel, code: response.code.to_i, response: response.body }
+      end
+    end
+  end
+end

data/lib/pechkin/connector/telegram.rb

@@ -0,0 +1,28 @@
+module Pechkin
+  module Connector
+    class Telegram < Connector::Base # :nodoc:
+      attr_reader :name
+
+      def initialize(bot_token, name)
+        super()
+
+        @bot_token = bot_token
+        @name = name
+      end
+
+      def send_message(chat_id, message, message_desc)
+        options = { parse_mode: message_desc['telegram_parse_mode'] || 'HTML' }
+        params = options.update(chat_id: chat_id, text: message)
+
+        response = post_data(method_url('sendMessage'), params)
+        { chat_id: chat_id, code: response.code.to_i, response: response.body }
+      end
+
+      private
+
+      def method_url(method)
+        "https://api.telegram.org/bot#{@bot_token}/#{method}"
+      end
+    end
+  end
+end

data/lib/pechkin/connector.rb

@@ -4,26 +4,6 @@ require 'uri'
 require 'json'
 require 'cgi'
 
-module Pechkin
-  # Base connector
-  class Connector
-    def send_message(chat, message, message_desc); end
-
-    def preview(chats, message, _message_desc)
-      "Connector: #{self.class.name}; Chats: #{chats.join(', ')}\n" \
-      "Message:\n#{message}"
-    end
-
-    def post_data(url, data, headers: {})
-      uri = URI.parse(url)
-      headers = { 'Content-Type' => 'application/json' }.merge(headers)
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = url.start_with?('https://')
-
-      request = Net::HTTP::Post.new(uri.request_uri, headers)
-      request.body = data.to_json
-
-      http.request(request)
-    end
-  end
-end
+require_relative 'connector/base'
+require_relative 'connector/slack'
+require_relative 'connector/telegram'

data/lib/pechkin/exceptions.rb

@@ -4,7 +4,10 @@ module Pechkin
       super("No such channel #{channel_name}")
     end
   end
+
   class MessageNotFoundError < StandardError; end
+
   class MessageContentIsEmptyError < StandardError; end
+
   class ConfigurationError < StandardError; end
 end

data/lib/pechkin/handler.rb

@@ -2,10 +2,16 @@ module Pechkin
   # Processes feeded data chunks and sends them via connectors to needed IM
   # services. Can skip some requests acording to filters.
   class Handler
-    attr_reader :channels
+    attr_reader :channels, :message_matcher
+    attr_accessor :logger
 
-    def initialize(channels)
+    def initialize(channels, stdout = $stdout, stderr = $stderr)
       @channels = channels
+      # Create empty logger by default
+      @logger = Logger.new(IO::NULL)
+      @stdout = stdout
+      @stderr = stderr
+      @message_matcher = MessageMatcher.new(@logger)
     end
 
     # Handles message request. Each request has three parameters: channel id,
@@ -21,20 +27,18 @@ module Pechkin
     #  deserialized json.
     # @see Configuration
     def handle(channel_id, msg_id, data)
-      channel_config = fetch_channel(channel_id)
-      # Find message and try substitute values to message parameters.
-      message_config = substitute(data, fetch_message(channel_config, msg_id))
-
-      data = (message_config['variables'] || {}).merge(data)
-      template = message_config['template']
-
-      text = ''
-      text = template.render(data) unless template.nil?
-
+      channel_config, message_config, text =
+        prepare_message(channel_id, msg_id, data)
       chats = channel_config.chat_ids
       connector = channel_config.connector
 
-      chats.map { |chat| connector.send_message(chat, text, message_config) }
+      if message_allowed?(message_config, data)
+        chats.map { |chat| connector.send_message(chat, text, message_config) }
+      else
+        logger.warn "#{channel_id}/#{msg_id}: " \
+                    "Skip sending message. Because it's not allowed"
+        []
+      end
     end
 
     # Executes message handling and renders template using connector logic
@@ -47,20 +51,16 @@ module Pechkin
     #  deserialized json.
     # @see Configuration
     def preview(channel_id, msg_id, data)
-      channel_config = fetch_channel(channel_id)
-      # Find message and try substitute values to message parameters.
-      message_config = substitute(data, fetch_message(channel_config, msg_id))
-
-      data = (message_config['variables'] || {}).merge(data)
-      template = message_config['template']
-
-      text = ''
-      text = template.render(data) unless template.nil?
-
+      channel_config, message_config, text =
+        prepare_message(channel_id, msg_id, data)
       chats = channel_config.chat_ids
       connector = channel_config.connector
 
-      connector.preview(chats, text, message_config)
+      if message_allowed?(message_config, data)
+        connector.preview(chats, text, message_config)
+      else
+        puts "No message sent beacuse it's not allowed"
+      end
     end
 
     def message?(channel_id, msg_id)
@@ -69,6 +69,10 @@ module Pechkin
 
     private
 
+    def puts(msg)
+      @stdout.puts(msg)
+    end
+
     # Find channel by it's id or trow ChannelNotFoundError
     def fetch_channel(channel_id)
       raise ChannelNotFoundError, channel_id unless channels.key?(channel_id)
@@ -84,6 +88,24 @@ module Pechkin
       message_list[msg_id]
     end
 
+    def message_allowed?(message_config, data)
+      message_matcher.matches?(message_config, data)
+    end
+
+    def prepare_message(channel_id, msg_id, data)
+      channel_config = fetch_channel(channel_id)
+      # Find message and try substitute values to message parameters.
+      message_config = substitute(data, fetch_message(channel_config, msg_id))
+
+      data = (message_config['variables'] || {}).merge(data)
+      template = message_config['template']
+
+      text = ''
+      text = template.render(data) unless template.nil?
+
+      [channel_config, message_config, text]
+    end
+
     def substitute(data, message_desc)
       substitute_recursive(Substitute.new(data), message_desc)
     end

data/lib/pechkin/message_matcher.rb

@@ -0,0 +1,94 @@
+module Pechkin
+  class MessageMatchError < StandardError; end
+
+  # Allows to match message configuration against received data.
+  #
+  # Data is checked againts either allow or forbid rules. But not both at the
+  # same time. Each field can contain list of rules to check. 'allow' list means
+  # we need at least one matching rule to allow data processing. And 'forbid'
+  # list respectievly means we need at least one matching rule to decline data
+  # processing.
+  class MessageMatcher
+    KEY_ALLOW = 'allow'.freeze
+    KEY_FORBID = 'forbid'.freeze
+
+    attr_reader :logger
+
+    def initialize(logger)
+      @logger = logger
+    end
+
+    # Checks data object against allow / forbid rule sets in message
+    # configuration. If data object matches rules it means we can process this
+    # data and send message.
+    #
+    # @param message_config [Hash] message description.
+    # @param data [Hash] request object that need to be inspected whether we
+    #   should process this data or not
+    # @return [Boolean] is data object matches message_config rules or not
+    def matches?(message_config, data)
+      check(message_config)
+
+      if message_config.key?(KEY_ALLOW)
+        rules = message_config[KEY_ALLOW]
+        rules.any? { |r| check_rule(r, r, data) }
+      elsif message_config.key?(KEY_FORBID)
+        rules = message_config[KEY_FORBID]
+        rules.all? { |r| !check_rule(r, r, data) }
+      else
+        true
+      end
+    end
+
+    private
+
+    def check(msg)
+      return unless msg.key?(KEY_ALLOW) && msg.key?(KEY_FORBID)
+
+      raise MessageMatchError, 'Both allow and forbid present in message config'
+    end
+
+    # Check rule object against data. Rules are checked recursievly, i.e. we
+    # can take one field in rule and check it separately as new rule. If all
+    # fields are passed check then whole rule passed.
+    def check_rule(top_rule, sub_rule, data)
+      result = case sub_rule
+               when Hash
+                 check_hash_rule(top_rule, sub_rule, data)
+               when Array
+                 check_array_rule(top_rule, sub_rule, data)
+               when String
+                 check_string_rule(top_rule, sub_rule, data)
+               else
+                 sub_rule.eql?(data)
+               end
+
+      unless result
+        logger.info "Expected #{sub_rule.to_json} got #{data.to_json} when" \
+                    " checking #{top_rule.to_json}"
+      end
+
+      result
+    end
+
+    def check_hash_rule(top_rule, hash, data)
+      return false unless data.is_a?(Hash)
+
+      hash.all? do |key, value|
+        data.key?(key) && check_rule(top_rule, value, data[key])
+      end
+    end
+
+    def check_array_rule(top_rule, array, data)
+      return false unless data.is_a?(Array)
+
+      # Deep array check needs to be done against all elements so we zip arrays
+      # to pair each rule with data element
+      array.zip(data).all? { |r, d| check_rule(top_rule, r, d) }
+    end
+
+    def check_string_rule(_top_rule, str, data)
+      str.eql? data
+    end
+  end
+end

data/lib/pechkin/version.rb

@@ -1,7 +1,7 @@
 module Pechkin
   # Keeps actual version
   module Version
-    VERSION = [1, 2, 1].freeze
+    VERSION = [1, 4, 0].freeze
     class << self
       def version_string
         VERSION.join('.')

data/lib/pechkin.rb

@@ -11,10 +11,9 @@ require_relative 'pechkin/cli'
 require_relative 'pechkin/command'
 require_relative 'pechkin/exceptions'
 require_relative 'pechkin/handler'
+require_relative 'pechkin/message_matcher'
 require_relative 'pechkin/message_template'
 require_relative 'pechkin/connector'
-require_relative 'pechkin/connector_slack'
-require_relative 'pechkin/connector_telegram'
 require_relative 'pechkin/channel'
 require_relative 'pechkin/configuration'
 require_relative 'pechkin/substitute'
@@ -29,8 +28,8 @@ module Pechkin # :nodoc:
       cmd = Command::Dispatcher.new(options).dispatch
       cmd.execute
     rescue StandardError => e
-      warn 'Error: ' + e.message
-      warn "\t" + e.backtrace.reverse.join("\n\t") if options.debug?
+      warn "Error: #{e.message}"
+      warn "\t#{e.backtrace.reverse.join("\n\t")}" if options.debug?
       exit 2
     end
   end

metadata

@@ -1,43 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: pechkin
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.4.0
 platform: ruby
 authors:
 - Ilya Arkhanhelsky
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-04 00:00:00.000000000 Z
+date: 2021-10-16 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: grape
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 1.1.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: htauth
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: 2.1.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: 2.1.1
 - !ruby/object:Gem::Dependency
   name: powerpack
   requirement: !ruby/object:Gem::Requirement
@@ -72,14 +58,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.0.8
+        version: 2.2.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.0.8
+        version: 2.2.3
 description: 
 email: ilya.arkhanhelsky at gmail.com
 executables:
@@ -90,6 +76,10 @@ files:
 - bin/pechkin
 - lib/pechkin.rb
 - lib/pechkin/app.rb
+- lib/pechkin/app/app.rb
+- lib/pechkin/app/app_builder.rb
+- lib/pechkin/app/app_error.rb
+- lib/pechkin/app/request_handler.rb
 - lib/pechkin/auth.rb
 - lib/pechkin/channel.rb
 - lib/pechkin/cli.rb
@@ -107,10 +97,12 @@ files:
 - lib/pechkin/configuration/configuration_loader_views.rb
 - lib/pechkin/configuration/model.rb
 - lib/pechkin/connector.rb
-- lib/pechkin/connector_slack.rb
-- lib/pechkin/connector_telegram.rb
+- lib/pechkin/connector/base.rb
+- lib/pechkin/connector/slack.rb
+- lib/pechkin/connector/telegram.rb
 - lib/pechkin/exceptions.rb
 - lib/pechkin/handler.rb
+- lib/pechkin/message_matcher.rb
 - lib/pechkin/message_template.rb
 - lib/pechkin/prometheus_utils.rb
 - lib/pechkin/substitute.rb
@@ -125,16 +117,16 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.2.22
 signing_key: 
 specification_version: 4
 summary: Web service to proxy webhooks to Telegram Bot API

data/lib/pechkin/connector_slack.rb

@@ -1,27 +0,0 @@
-module Pechkin # :nodoc:
-  class SlackConnector < Connector # :nodoc:
-    attr_reader :name
-
-    def initialize(bot_token, name)
-      @headers = { 'Authorization' => "Bearer #{bot_token}" }
-      @name = name
-    end
-
-    def send_message(channel, message, message_desc)
-      text = CGI.unescape_html(message)
-
-      attachments = message_desc['slack_attachments'] || {}
-
-      if text.strip.empty? && attachments.empty?
-        return [channel, 400, 'Internal error: message is empty']
-      end
-
-      params = { channel: channel, text: text, attachments: attachments }
-
-      url = 'https://slack.com/api/chat.postMessage'
-      response = post_data(url, params, headers: @headers)
-
-      [channel, response.code.to_i, response.body]
-    end
-  end
-end

data/lib/pechkin/connector_telegram.rb

@@ -1,24 +0,0 @@
-module Pechkin
-  class TelegramConnector < Connector #:nodoc:
-    attr_reader :name
-
-    def initialize(bot_token, name)
-      @bot_token = bot_token
-      @name = name
-    end
-
-    def send_message(chat_id, message, message_desc)
-      options = { parse_mode: message_desc['telegram_parse_mode'] || 'HTML' }
-      params = options.update(chat_id: chat_id, text: message)
-
-      response = post_data(method_url('sendMessage'), params)
-      [chat_id, response.code.to_i, response.body]
-    end
-
-    private
-
-    def method_url(method)
-      "https://api.telegram.org/bot#{@bot_token}/#{method}"
-    end
-  end
-end