pechkin 1.2.2 → 1.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8edc5ca6908ec5bbe30dc46cac568f7461a7cd4a7b8f27edfec4bc9f03c406e
-  data.tar.gz: 181cfaae800da3746168e124faeac2a794d8392c2291cff1ed44f1b2903ed35d
+  metadata.gz: c18e97f32b4fe42a3bd649c43563abc81a13fe49d5c2332f54129b1babc61767
+  data.tar.gz: bcc9dcdbccc1041ed9377b1e4bbce4113a6820ca798efceeefc9476b30eb8499
 SHA512:
-  metadata.gz: a779e1584430ceb11261abfa41c4a3f5a01e688867c43b87824a046c73e1398b1ae12a9aaaa2a565d864241d23effebb429dace47d41d77493e5ebd6f907fbd2
-  data.tar.gz: 1533b9c729bc2b6c3b2498066bbbc027c44e03a106d4260538fb58399fa42565278661e32a426ffb07449ae33dfac6d89b43f96086983f534d33e7ce90240a03
+  metadata.gz: 7d567c46d62df87a39e701f086c51a753616cb3e1acc104829675a1d091a9907110ed1e807f0253782b125a55017918c2ddedf3716ad58af77b0a96296c26a4e
+  data.tar.gz: b7add41faa2da882200c5a47fe4a847a97ea3df7a8c9cb69796e200405e7a3a19fd49cf0e21776484a46dc713ca8312bfce86ab2230c003c9325c4d86ddab526

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/{configuration/model.rb → bot.rb}

@@ -1,4 +1,3 @@
 module Pechkin
   Bot = Struct.new(:token, :connector, :name, keyword_init: true)
-  Channel = Struct.new(:chat_ids, :connector, :messages, keyword_init: true)
 end

data/lib/pechkin/channel.rb

@@ -1,59 +1,3 @@
 module Pechkin
-  # Creates object which can send messages to assigned chanels
-  class Chanel
-    attr_accessor :logger
-
-    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)
-      @logger = logger
-    end
-
-    def send_message(message, data, message_desc)
-      text = message.nil? ? '' : Message.new(data).render(message)
-
-      message_desc = substitute(data, message_desc)
-
-      logger.warn 'Resulting text is empty' if text.empty?
-      results = @channel_list.map do |id|
-        @connector.send_message(id, text, message_desc)
-      end
-
-      process_results(message, results)
-    end
-
-    private
-
-    def substitute(data, message_desc)
-      substitute_recursive(Substitute.new(data), message_desc)
-    end
-
-    def substitute_recursive(substitutions, object)
-      case object
-      when String
-        substitutions.process(object)
-      when Array
-        object.map { |o| substitute_recursive(substitutions, o) }
-      when Hash
-        r = {}
-        object.each { |k, v| r[k] = substitute_recursive(substitutions, v) }
-        r
-      else
-        object
-      end
-    end
-
-    def process_results(message, results)
-      success, error = results.partition { |_chat, code, _body| code < 400 }
-      error.each do |chat, code, body|
-        logger.error "#{message} => #{chat}[HTTP #{code}]: #{body}"
-      end
-
-      {
-        successful: success.map(&:first),
-        errors: error
-      }
-    end
-  end
+  Channel = Struct.new(:chat_ids, :connector, :messages, keyword_init: true)
 end

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/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,16 +61,53 @@ module Pechkin
         message_config = YAML.safe_load(IO.read(file))
         name = File.basename(file, '.yml')
 
+        # Dirty workaround. I need to recursively load templates. When doing it
+        # we looking for {'template': '...path to template..' } objects. But we
+        # don't want to force user write something like:
+        #   text:
+        #     template: '... path to main template...'
+        # because it's too mouthful for such common case.
+        #
+        # So now we pull main template out, then load everyting else. Then put
+        # it back.
+        template = nil
         if message_config.key?('template')
-          message_config['template'] = get_template(message_config['template'])
+          template = get_template(message_config['template'])
+          message_config.delete('template')
         end
 
-        messages[name] = message_config
+        message_config = load_templates(message_config)
+        message_config['template'] = template unless template.nil?
+
+        messages[name] = Message.new(message_config)
       end
 
       messages
     end
 
+    def load_templates(object)
+      case object
+      when String
+        object
+      when Array
+        object.map { |o| load_templates(o) }
+      when Hash
+        if object.key?('template')
+          msg = 'When using template only 1 KV pair allowed'
+          raise ConfigurationError, msg unless object.size == 1
+
+          # Replace whole object with created template.
+          get_template(object['template'])
+        else
+          r = {}
+          object.each { |k, v| r[k] = load_templates(v) }
+          r
+        end
+      else
+        object
+      end
+    end
+
     def get_template(path)
       msg = "Can't find template: #{path}"
       raise ConfigurationError, msg unless @views.key?(path)

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

@@ -1,6 +1,5 @@
 require 'yaml'
 
-require_relative 'configuration/model'
 require_relative 'configuration/configuration_loader'
 require_relative 'configuration/configuration_loader_bots'
 require_relative 'configuration/configuration_loader_channels'
@@ -10,16 +9,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,19 @@ 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 = fetch_message(channel_config, msg_id)
+      message_config, text = message.prepare(data)
+
+      [channel_config, message_config, text]
+    end
+
     def substitute(data, message_desc)
       substitute_recursive(Substitute.new(data), message_desc)
     end

data/lib/pechkin/message.rb

@@ -0,0 +1,64 @@
+module Pechkin
+  # Message object
+  #
+  # TBD
+  class Message
+    def initialize(message)
+      @message = message
+    end
+
+    def prepare(data)
+      data = (@message['variables'] || {}).merge(data)
+      # Find message and try substitute values to message parameters.
+      message_config = render(data, substitute(data, @message))
+      text = ''
+      text = message_config.delete('template') if message_config.key?('template')
+
+      [message_config, text]
+    end
+
+    def to_h
+      Marshal.load(Marshal.dump(@message))
+    end
+
+    private
+
+    def substitute(data, message_desc)
+      substitute_recursive(Substitute.new(data), message_desc)
+    end
+
+    def substitute_recursive(substitutions, object)
+      case object
+      when String
+        substitutions.process(object)
+      when Array
+        object.map { |o| substitute_recursive(substitutions, o) }
+      when Hash
+        r = {}
+        object.each { |k, v| r[k] = substitute_recursive(substitutions, v) }
+        r
+      else
+        object
+      end
+    end
+
+    def render(data, message_desc)
+      render_recursive(data, message_desc)
+    end
+
+    def render_recursive(data, object)
+      case object
+      when MessageTemplate
+        object.render(data)
+      when Array
+        object.map { |o| render_recursive(data, o) }
+      when Hash
+        r = {}
+        object.each { |k, v| r[k] = render_recursive(data, v) }
+        r
+      else
+        object
+      end
+    end
+  end
+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, 2].freeze
+    VERSION = [1, 5, 1].freeze
     class << self
       def version_string
         VERSION.join('.')

data/lib/pechkin.rb

@@ -8,14 +8,15 @@ require 'htauth'
 require 'base64'
 
 require_relative 'pechkin/cli'
+require_relative 'pechkin/bot'
+require_relative 'pechkin/channel'
+require_relative 'pechkin/message'
 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'
 require_relative 'pechkin/prometheus_utils'
@@ -29,8 +30,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.2
+  version: 1.5.1
 platform: ruby
 authors:
 - Ilya Arkhanhelsky
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-04 00:00:00.000000000 Z
+date: 2021-10-26 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,7 +76,12 @@ 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/bot.rb
 - lib/pechkin/channel.rb
 - lib/pechkin/cli.rb
 - lib/pechkin/command.rb
@@ -105,12 +96,14 @@ files:
 - lib/pechkin/configuration/configuration_loader_bots.rb
 - lib/pechkin/configuration/configuration_loader_channels.rb
 - 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.rb
+- lib/pechkin/message_matcher.rb
 - lib/pechkin/message_template.rb
 - lib/pechkin/prometheus_utils.rb
 - lib/pechkin/substitute.rb
@@ -125,16 +118,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