pechkin 1.3.1 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21153645eb45d32b113d2c95191e79ac5568a10829b3989ccc9f75da7b53bf9e
-  data.tar.gz: d80b4bbbeb7e4bdfeb251e358bb0a9c99d50eae96c5078b688bce5e12a3c73e3
+  metadata.gz: fdd7554b43eb0ac8fa2fdb0fc9d02d31b4acf859c1b66a9470c1fdbd524d0eef
+  data.tar.gz: 224c8857ae9b72a48b91c8342040f9866d30a285a7f6e8595bf27e577f44bdd2
 SHA512:
-  metadata.gz: 30e9654efb5c1a11c4816feb51fc494be1251e106a2fac682be9cb68738faec6e8b45c747329f90cff226ef1fe9df2c097bb0083c79d57d55b020982773dd0b8
-  data.tar.gz: 62d6113f5ef1aedfe36c3eb86bc619d7cbac2cd9e54a37f64cbd293b1856efe47ba572bdf25efcc2a20f7b1affbbffe8cc2e74ad9784091cc69f7fa232ebe19b
+  metadata.gz: 623290e1546eb766cb844203af31e8f3708016199f4b1771e55c468cb252d21ecd874452795dc8417ba06d3be3e096526b3ad6c96826c84fa8189cd522e61ecb
+  data.tar.gz: 61f56c2dc2b400cced01460d977ee216d2c546be2935b3ce968f08c0266ad29d5915b14ea6601ca31f1497f984aba8eb9a1b4cfbbb27f5d358d44f49bd81157a

data/lib/pechkin/app/app.rb

@@ -34,9 +34,10 @@ module Pechkin
       response(err.code, data)
     end
 
-    def process_unhandled_error(_req, err)
+    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

data/lib/pechkin/app/app_builder.rb

@@ -15,9 +15,7 @@ module Pechkin
         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 Pechkin::Auth::Middleware, auth_file: options.htpasswd if options.htpasswd
         use Prometheus::Middleware::Exporter, registry: prometheus
 
         run app
@@ -34,7 +32,7 @@ module Pechkin
         file = File.open(log_file, File::WRONLY | File::APPEND)
         Logger.new(file)
       else
-        Logger.new(STDOUT)
+        Logger.new($stdout)
       end
     end
   end

data/lib/pechkin/app/request_handler.rb

@@ -2,7 +2,7 @@ module Pechkin
   # Http requests handler. We need fresh instance per each request. To keep
   # internal state isolated
   class RequestHandler
-    REQ_PATH_PATTERN = %r{^/(.+)/([^/]+)/?$}
+    REQ_PATH_PATTERN = %r{^/(.+)/([^/]+)/?$}.freeze
 
     attr_reader :req, :handler,
                 :channel_id, :message_id,

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'

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

@@ -5,13 +5,13 @@ module Pechkin
     attr_reader :channels, :message_matcher
     attr_accessor :logger
 
-    def initialize(channels, stdout = STDOUT, stderr = STDERR)
+    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
+      @message_matcher = MessageMatcher.new(@logger)
     end
 
     # Handles message request. Each request has three parameters: channel id,
@@ -35,7 +35,7 @@ module Pechkin
       if message_allowed?(message_config, data)
         chats.map { |chat| connector.send_message(chat, text, message_config) }
       else
-        logger.info "#{channel_id}/#{msg_id}: " \
+        logger.warn "#{channel_id}/#{msg_id}: " \
                     "Skip sending message. Because it's not allowed"
         []
       end
@@ -95,13 +95,8 @@ module Pechkin
     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?
+      message = fetch_message(channel_config, msg_id)
+      message_config, text = message.prepare(data)
 
       [channel_config, message_config, text]
     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

@@ -1,5 +1,6 @@
 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
@@ -10,6 +11,13 @@ module Pechkin
   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.
@@ -23,10 +31,10 @@ module Pechkin
 
       if message_config.key?(KEY_ALLOW)
         rules = message_config[KEY_ALLOW]
-        rules.any? { |r| check_rule(r, data) }
+        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, data) }
+        rules.all? { |r| !check_rule(r, r, data) }
       else
         true
       end
@@ -43,35 +51,43 @@ module Pechkin
     # 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(rule, data)
-      if rule.is_a?(Hash)
-        check_hash_rule(rule, data)
-      elsif rule.is_a?(Array)
-        check_array_rule(rule, data)
-      elsif rule.is_a?(String)
-        check_string_rule(rule, data)
-      else
-        rule.eql?(data)
+    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(hash, data)
+    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(value, data[key])
+        data.key?(key) && check_rule(top_rule, value, data[key])
       end
     end
 
-    def check_array_rule(array, data)
+    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(r, d) }
+      array.zip(data).all? { |r, d| check_rule(top_rule, r, d) }
     end
 
-    def check_string_rule(str, data)
+    def check_string_rule(_top_rule, str, data)
       str.eql? data
     end
   end

data/lib/pechkin/prometheus_utils.rb

@@ -5,6 +5,12 @@ module Pechkin
         registry = ::Prometheus::Client.registry
         registry.gauge(:pechkin_start_time_seconds,
                        docstring: 'Startup timestamp').set(Time.now.to_i)
+
+        version_labels = { version: Pechkin::Version.version_string }
+        registry.gauge(:pechkin_version,
+                       docstring: 'Pechkin version', labels: [:version])
+                .set(1, labels: version_labels)
+
         registry
       end
     end

data/lib/pechkin/version.rb

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

data/lib/pechkin.rb

@@ -8,15 +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'
@@ -30,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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pechkin
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.6.0
 platform: ruby
 authors:
 - Ilya Arkhanhelsky
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-07 00:00:00.000000000 Z
+date: 2021-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: htauth
@@ -16,14 +16,14 @@ dependencies:
     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
@@ -58,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:
@@ -81,6 +81,7 @@ files:
 - 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
@@ -95,12 +96,13 @@ 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
@@ -116,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,28 +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: 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

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: 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