pechkin 0.2.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b4d225464fc987cff4a7df181e175e4756c60ccc9982582d7906b4f85b194f3d
-  data.tar.gz: 5ca5b0e4c4aacf29e38a51a12217494539f5ef4a31f1eedaf799fc0170f9eb40
+  metadata.gz: 4b9031bb8570fd2ca66241e30271167194aebae7a832ecdc3b98fb07630505e2
+  data.tar.gz: 57685b4ededcd3935e412611750b0ed716f386b5d759f88004993cd64162f90d
 SHA512:
-  metadata.gz: f23b61d62cc9fbf3df9d4e578080147f9de3717f8e924d71329778674dcfa21a0bccd46b45e32d33c9ac30eb515d82b9cceeca2af34da1dea210414f20e6d8b3
-  data.tar.gz: ddc485f1678e2a4d4b6ab61f655dbaf69e7fbeb5e1dcc1ae338f2b039f6f77c4cdad6d7d1bfb828c7087c128d09a47e93cb40eb17b7c9a2aba455bef1ff5cdde
+  metadata.gz: 3d04eab93cb96a74e68a1f3d7b47707c917c8909b20d251180db0dadfa0144b35b38ac6be19dfed89c4fc66f1ab50ae9d83f9f4df7782bd05c1b085e246d388a
+  data.tar.gz: 680509c985a97814062b85d3039268334f8b8b5623a4724c772c2c054f4fdbcddf32d13c2dd94d2932119a9c445c1664472730eb5c2f1ceda982d9314584155b

data/lib/pechkin.rb

@@ -1,32 +1,76 @@
+require 'erb'
 require 'rack'
 require 'logger'
+require 'prometheus/middleware/collector'
+require 'prometheus/middleware/exporter'
 
 require_relative 'pechkin/cli'
-require_relative 'pechkin/message'
+require_relative 'pechkin/exceptions'
+require_relative 'pechkin/handler'
+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/api'
-require_relative 'pechkin/config'
+require_relative 'pechkin/configuration'
 require_relative 'pechkin/substitute'
+require_relative 'pechkin/app'
 
 module Pechkin # :nodoc:
   class << self
     def run
       options = CLI.parse(ARGV)
-      configuration = Config.new(options.config_file)
-      setup_logging(options.log_dir) if options.log_dir
-      app = Pechkin.create(configuration)
-      PechkinAPI.logger.info 'Starting pechkin service...'
-      Rack::Server.start(app: app,
-                         Port: options.port || configuration.port,
-                         pid: options.pid_file)
+      Main.new(options).run
+    rescue StandardError => e
+      warn 'Error: ' + e.message
+      warn "\t" + e.backtrace.reverse.join("\n\t") if options.debug?
+      exit 2
     end
+  end
+
+  class Main # :nodoc:
+    attr_reader :options, :configuration, :handler
+
+    def initialize(options)
+      @options = options
+      @configuration = Configuration.load_from_directory(options.config_file)
+      @handler = Handler.new(@configuration.channels)
+    end
+
+    def run
+      configuration.list if options.list?
+      exit 0 if options.check?
+
+      if options.send_data
+        send_data
+        exit 0
+      end
+
+      run_server
+    end
+
+    def run_server
+      Rack::Server.start(app: AppBuilder.new.build(handler, options),
+                         Port: options.port, pid:  options.pid_file)
+    end
+
+    def send_data
+      ch, msg = options.send_data.match(%r{^([^/]+)/(.+)}) do |m|
+        [m[1], m[2]]
+      end
+
+      raise "#{ch}/#{msg} not found" unless handler.message?(ch, msg)
+
+      data = options.data
+      if data.start_with?('@')
+        f = data[1..-1]
+        raise "File not found #{f}" unless File.exist?(f)
 
-    def setup_logging(log_dir)
-      logger = ::Logger.new(File.join(log_dir, 'pechkin.log'), 'daily')
-      logger.level = ::Logger::INFO
+        data = IO.read(f)
+      end
 
-      PechkinAPI.logger = logger
+      handler.preview = options.preview
+      handler.handle(ch, msg, JSON.parse(data, symbolize_names: true))
     end
   end
 end

data/lib/pechkin/app.rb

@@ -0,0 +1,105 @@
+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
+
+      logger = create_logger(options.log_dir)
+
+      Rack::Builder.app do
+        use Rack::CommonLogger, logger
+        use Rack::Deflater
+        use Prometheus::Middleware::Collector
+        use Prometheus::Middleware::Exporter
+
+        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 + '"'
+      ['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, symbolize_names: true)
+      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 response(code, body)
+      [code.to_s, DEFAULT_HEADERS, body]
+    end
+
+    def post?
+      req.post?
+    end
+  end
+end

data/lib/pechkin/channel.rb

@@ -3,11 +3,11 @@ module Pechkin
   class Chanel
     attr_accessor :logger
 
-    def initialize(connector, channel_list)
+    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.new(STDOUT)
+      @logger = logger
     end
 
     def send_message(message, data, message_desc)

data/lib/pechkin/cli.rb

@@ -5,66 +5,127 @@ require 'ostruct'
 require_relative 'version'
 
 module Pechkin
-  # Command Line parser
-  module CLI
-    # Default values for CLI options
-    DEFAULT_OPTIONS = {
-      config_file: '/etc/pechkin/config.yml'
-    }.freeze
-    # Command Line Parser Builder
-    class CLIBuilder
-      attr_reader :options
-      def initialize(options_keeper)
-        @options = options_keeper
-      end
+  # Helper methods to declare all command line options. This should remove most
+  # optparse configuration boilerplate
+  module CLIHelper
+    # @param name [Symbol] variable name to store values
+    # @opt default [Object] default value
+    # @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)
+      @cli_options ||= []
 
-      def build(parser) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-        # rubocop:disable Metrics/LineLength
-        parser.banner = 'Usage: pechkin [options]'
-        parser.separator ''
+      # raise ':names is nil or empty' if names.nil? || names.empty?
 
-        parser.on('-c', '--config CONFIG_FILE', 'default value is /etc/pechkin/config.yml') do |value|
-          options.config_file = value
-        end
+      @cli_options << { name: name,
+                        default: default,
+                        names: names,
+                        type: type,
+                        desc: desc }
+    end
 
-        parser.on('-p', '--port PORT', Integer) do |value|
-          options.port = value
-        end
+    def separator(string)
+      @cli_options ||= []
+      @cli_options << string
+    end
 
-        parser.on('--pid PID_FILE') do |value|
-          options.pid_file = value
-        end
+    def banner(banner)
+      @cli_banner = banner
+    end
 
-        parser.on('--log-dir LOG_DIR') do |value|
-          options.log_dir = value
-        end
+    def parse(args)
+      values = OpenStruct.new
+      parser = parser_create(values)
 
-        parser.separator ''
-        parser.separator 'Common options:'
-        parser.on_tail('-h', '--help', 'Show this message') do
-          puts parser
-          exit
-        end
+      if args.empty?
+        puts parser.help
+        exit 2
+      else
+        parser.parse(args)
+        values
+      end
+    end
 
-        # Another typical switch to print the version.
-        parser.on_tail('--version', 'Show version') do
-          puts Version.version_string
-          exit
+    def parser_create(values)
+      parser = OptionParser.new
+      parser.banner = @cli_banner
+
+      (@cli_options || []).each do |o|
+        if o.is_a?(String)
+          parser.separator o
+        else
+          values[o[:name]] = o[:default] if o[:default]
+
+          args = []
+          args += o[:names]
+          args << o[:type] if o[:type]
+          args << o[:desc] if o[:desc]
+
+          parser.on(*args) { |v| values[o[:name]] = v }
         end
-        # rubocop:enable Metrics/LineLength
       end
+
+      parser_create_default_opts(parser)
+
+      parser
     end
 
-    class << self
-      def parse(args)
-        options_keeper = OpenStruct.new(DEFAULT_OPTIONS)
-        parser = OptionParser.new do |p|
-          CLIBuilder.new(options_keeper).build(p)
-        end
+    def parser_create_default_opts(parser)
+      parser.separator ''
+      parser.separator 'Common options:'
+      parser.on_tail('-h', '--help', 'Show this message') do
+        puts parser
+        exit 1
+      end
 
-        parser.parse(args)
-        options_keeper
+      # Another typical switch to print the version.
+      parser.on_tail('--version', 'Show version') do
+        puts Version.version_string
+        exit 0
       end
     end
   end
+
+  # Command Line Parser Builder
+  class CLI
+    extend CLIHelper
+
+    separator 'Run options'
+
+    opt :config_file, default: Dir.pwd,
+                      names: ['-c', '--config-dir FILE'],
+                      desc: 'Path to configuration file'
+
+    opt :port, names: ['--port PORT'], default: 9292, type: Integer
+
+    opt :pid_file, names: ['-p', '--pid-file [FILE]'],
+                   desc: 'Path to output PID file'
+
+    opt :log_dir, names: ['--log-dir [DIR]'],
+                  desc: 'Path to log directory. Output will be writen to'  \
+                        'pechkin.log file. If not specified will write to' \
+                        'STDOUT'
+
+    separator 'Utils for configuration maintenance'
+
+    opt :list?, names: ['-l', '--[no-]list'],
+                desc: 'List all endpoints'
+
+    opt :check?, names: ['-k', '--[no-]check'],
+                 desc: 'Load configuration and exit'
+    opt :send_data, names: ['-s', '--send ENDPOINT'],
+                    desc: 'Send data to specified ENDPOINT and exit. Requires' \
+                          '--data to be set.'
+    opt :preview,   names: ['--preview'],
+                    desc: 'Print rendering result to STDOUT and exit. ' \
+                          'Use with send'
+    opt :data, names: ['--data DATA'],
+               desc: 'Data to send with --send flag. Json string or @filename.'
+
+    separator 'Debug options'
+
+    opt :debug?, names: ['--[no-]debug'],
+                 desc: 'Print debug information and stack trace on errors'
+  end
 end

data/lib/pechkin/configuration.rb

@@ -0,0 +1,102 @@
+require 'yaml'
+
+require_relative 'configuration/model'
+require_relative 'configuration/configuration_loader'
+require_relative 'configuration/configuration_loader_bots'
+require_relative 'configuration/configuration_loader_channels'
+require_relative 'configuration/configuration_loader_views'
+
+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
+  #   |   | - bender.yml
+  #   |
+  #   | - channels/              <= Channels description
+  #   |   | - slack-repository-feed
+  #   |       | - commit-hg.yml
+  #   |       | - commit-svn.yml
+  #   |
+  #   | - views/                 <= Template storage
+  #       | - commit-hg.erb
+  #       | - commit-svn.erb
+  #
+  # Bots
+  #  Bots described in YAML files in `bots` directory. Bot described by
+  #  following fields:
+  #    - token - API token used to authorize when doing requests to messenger
+  #              API
+  #    - connector - Connector name to instantiate. For exapmle: 'telegram' or
+  #      'slack'
+  # Channels
+  #  Channel is a description of message group. It used to describe group of
+  #  messages that sould be send to sepceific channel or user. Each
+  #  channel configuration is stored in its own folder. This folder name
+  #  is channel internal id. Channel is described by `_channel.yml` file,
+  #  Channel has following fields to configure:
+  #    - chat_ids - list of ids to send all containing messages. It may be
+  #      single item or list of ids.
+  #    - bot - bot istance to use when messages are handled.
+  #  Other `*.yml` files in channel folder are message descriptions. Message
+  #  description has following fields to configure:
+  #    - template - path to template relative to views/ folder. If no template
+  #      specified then noop template will be used. No-op template returns empty
+  #      string for each render request.
+  #    - variables - predefined variables to use in template rendering. This is
+  #      especialy useful when one wants to use same template in different
+  #      channels. For exapmle when you need to render repository commit and
+  #      want to substitute correct repository link
+  #    - filters - list of rules which allows to deny some messages based on
+  #      their content. For example we do not want to post commit messages from
+  #      branches other than `master`.
+  #
+  #  And other connector speceific fields. For example:
+  #    - telegram_parse_mode
+  #    - slack_attachments
+  #
+  # Views
+  #   'views' folder contains erb templates to render when data arives.
+  class Configuration
+    class << self
+      def load_from_directory(working_dir)
+        bots = ConfigurationLoaderBots.new.load_from_directory(working_dir)
+        views = ConfigurationLoaderViews.new.load_from_directory(working_dir)
+
+        channel_loader = ConfigurationLoaderChannels.new(bots, views)
+        channels = channel_loader.load_from_directory(working_dir)
+
+        Configuration.new(working_dir, bots, views, channels)
+      end
+    end
+
+    attr_accessor :bots, :channels, :views, :working_dir
+
+    def initialize(working_dir, bots, views, channels)
+      @working_dir = working_dir
+      @bots = bots
+      @views = views
+      @channels = channels
+    end
+
+    def list
+      puts "Working dir: #{working_dir}\nBots:"
+
+      bots.each do |name, bot|
+        puts "  #{name}(#{bot.connector}): #{bot.token}"
+      end
+
+      puts "\nChannels:"
+      channels.each do |channel_name, channel|
+        puts "  - name #{channel_name}"
+        puts "    bot: #{channel.connector.name}"
+        puts '    messages: '
+        channel.messages.each do |message_name, _message|
+          puts "     - /#{channel_name}/#{message_name}"
+        end
+        puts
+      end
+    end
+  end
+end

data/lib/pechkin/configuration/configuration_loader.rb

@@ -0,0 +1,28 @@
+module Pechkin
+  # Common code for all configuration loaders. To use this code just include
+  # module in user class.
+  module ConfigurationLoader
+    def check_field(object, field, file)
+      contains = object.key?(field)
+
+      raise ConfigurationError, "#{file}: '#{field}' is missing" unless contains
+
+      object[field]
+    end
+
+    def create_connector(bot)
+      case bot.connector
+      when 'tg', 'telegram'
+        TelegramConnector.new(bot.token, bot.name)
+      when 'slack'
+        SlackConnector.new(bot.token, bot.name)
+      else
+        raise 'Unknown connector ' + bot.connector + ' for ' + bot.name
+      end
+    end
+
+    def yaml_load(file)
+      YAML.safe_load(IO.read(file))
+    end
+  end
+end

data/lib/pechkin/configuration/configuration_loader_bots.rb

@@ -0,0 +1,39 @@
+module Pechkin
+  # Configuration loader for bot descriptions
+  class ConfigurationLoaderBots
+    include ConfigurationLoader
+
+    def load_from_directory(working_directory)
+      bots = {}
+      load_bots_configuration(working_directory, bots)
+
+      bots
+    end
+
+    private
+
+    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
+
+      Dir["#{bots_dir}/*.yml"].each do |bot_file|
+        name = File.basename(bot_file, '.yml')
+        bot = load_bot_configuration(bot_file)
+        bot.name = name
+        bots[name] = bot
+      end
+    end
+
+    def load_bot_configuration(bot_file)
+      bot_configuration = yaml_load(bot_file)
+
+      token = check_field(bot_configuration, 'token', bot_file)
+      connector = check_field(bot_configuration, 'connector', bot_file)
+
+      Bot.new(token: token, connector: connector)
+    end
+  end
+end

data/lib/pechkin/configuration/configuration_loader_channels.rb

@@ -0,0 +1,83 @@
+module Pechkin
+  # Configuration loader for bot descriptions
+  class ConfigurationLoaderChannels
+    include ConfigurationLoader
+
+    attr_reader :bots
+
+    def initialize(bots, views)
+      @bots = bots
+      @views = views
+    end
+
+    def load_from_directory(working_directory)
+      channels = {}
+      load_channels_configuration(working_directory, channels)
+
+      channels
+    end
+
+    private
+
+    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
+
+      Dir["#{channels_dir}/*"].each do |channel_dir|
+        next unless File.directory?(channel_dir)
+
+        name = File.basename(channel_dir)
+        channels[name] = load_channel_configuration(channel_dir)
+      end
+    end
+
+    def load_channel_configuration(channel_dir)
+      channel_file = File.join(channel_dir, '_channel.yml')
+
+      msg = "_channel.yml not found at #{channel_dir}"
+      raise ConfigurationError, msg unless File.exist?(channel_file)
+
+      channel_config = yaml_load(channel_file)
+
+      bot = check_field(channel_config, 'bot', channel_file)
+      chat_ids = check_field(channel_config, 'chat_ids', channel_file)
+      chat_ids = [chat_ids] unless chat_ids.is_a?(Array)
+      messages = load_messages_configuration(channel_dir)
+
+      msg = "#{channel_file}: bot '#{bot}' not found"
+      raise ConfigurationError, msg unless bots.key?(bot)
+
+      connector = create_connector(bots[bot])
+      Channel.new(connector: connector, chat_ids: chat_ids, messages: messages)
+    end
+
+    def load_messages_configuration(channel_dir)
+      messages = {}
+
+      Dir["#{channel_dir}/*.yml"].each do |file|
+        next if File.basename(file) == '_channel.yml'
+
+        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
+
+        messages[name] = message_config
+      end
+
+      messages
+    end
+
+    def get_template(path)
+      msg = "Can't find template: #{path}"
+      raise ConfigurationError, msg unless @views.key?(path)
+
+      @views[path]
+    end
+  end
+end

data/lib/pechkin/configuration/configuration_loader_views.rb

@@ -0,0 +1,28 @@
+module Pechkin
+  # Configuration loader for view descriptions
+  class ConfigurationLoaderViews
+    include ConfigurationLoader
+
+    def load_from_directory(working_dir)
+      views = {}
+      load_views_configuration(working_dir, views)
+
+      views
+    end
+
+    private
+
+    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
+
+      Dir["#{views_dir}/**/*.erb"].each do |f|
+        relative_path = f["#{views_dir}/".length..-1]
+        views[relative_path] = MessageTemplate.new(IO.read(f))
+      end
+    end
+  end
+end

data/lib/pechkin/configuration/model.rb

@@ -0,0 +1,4 @@
+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/connector.rb

@@ -9,8 +9,12 @@ module Pechkin
   class Connector
     def send_message(chat, message, message_desc); end
 
+    def preview(chats, message, _message_desc)
+      puts "Connector: #{self.class.name}; Chats: #{chats.join(', ')}\n"
+      puts "Message:\n#{message}"
+    end
+
     def post_data(url, data, headers: {})
-      puts data.inspect
       uri = URI.parse(url)
       headers = { 'Content-Type' => 'application/json' }.merge(headers)
       http = Net::HTTP.new(uri.host, uri.port)
@@ -22,47 +26,4 @@ module Pechkin
       http.request(request)
     end
   end
-
-  class TelegramConnector < Connector #:nodoc:
-    def initialize(bot_token)
-      @bot_token = bot_token
-    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
-
-  class SlackConnector < Connector # :nodoc:
-    def initialize(bot_token)
-      @headers = { 'Authorization' => "Bearer #{bot_token}" }
-    end
-
-    def send_message(chat, message, message_desc)
-      text = CGI.unescape_html(message)
-
-      attachments = message_desc['slack_attachments'] || {}
-
-      if text.strip.empty? && attachments.empty?
-        return [chat, 400, 'not sent: empty']
-      end
-
-      params = { channel: chat, text: text, attachments: attachments }
-
-      url = 'https://slack.com/api/chat.postMessage'
-      response = post_data(url, params, headers: @headers)
-
-      [chat, response.code.to_i, response.body]
-    end
-  end
 end

data/lib/pechkin/connector_slack.rb

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,24 @@
+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

data/lib/pechkin/exceptions.rb

@@ -0,0 +1,10 @@
+module Pechkin
+  class ChannelNotFoundError < StandardError # :nodoc:
+    def initialize(channel_name)
+      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

@@ -0,0 +1,87 @@
+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_writer :preview
+
+    def initialize(channels)
+      @channels = channels
+    end
+
+    # Handles message request. Each request has three parameters: channel id,
+    # message id, and data object. By channel id we determine where to send
+    # data, by message id we determine how to transform this data to real
+    # message.
+    # @param channel_id [String] channel name from configuration. This name is
+    #  obtained from directory structure we have in configuration directory.
+    # @param msg_id [String] message name from configuration. This name is
+    #  references yml file with message description
+    # @param data [Object] data object to render via template. This is usualy
+    #  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['parameters'] || {}).merge(data)
+      template = message_config['template']
+
+      text = ''
+      text = template.render(data) unless template.nil?
+
+      chats = channel_config.chat_ids
+      connector = channel_config.connector
+      if preview?
+        connector.preview(chats, text, message_config)
+      else
+        chats.map { |chat| connector.send_message(chat, text, message_config) }
+      end
+    end
+
+    def message?(channel_id, msg_id)
+      channels.key?(channel_id) && channels[channel_id].messages.key?(msg_id)
+    end
+
+    def preview?
+      @preview
+    end
+
+    private
+
+    # Find channel by it's id or trow ChannelNotFoundError
+    def fetch_channel(channel_id)
+      raise ChannelNotFoundError, channel_id unless channels.key?(channel_id)
+
+      channels[channel_id]
+    end
+
+    # Find message config by it's id or throw MessageNotFoundError
+    def fetch_message(channel_config, msg_id)
+      message_list = channel_config.messages
+      raise MessageNotFoundError, msg_id unless message_list.key?(msg_id)
+
+      message_list[msg_id]
+    end
+
+    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
+  end
+end

data/lib/pechkin/message_template.rb

@@ -0,0 +1,19 @@
+module Pechkin
+  # Class to provide binding for ERB templating engine
+  class MessageBinding < OpenStruct
+    def render_template(template)
+      template.result(binding)
+    end
+  end
+
+  # Message template to render final message.
+  class MessageTemplate
+    def initialize(erb)
+      @erb_template = ERB.new(erb, trim_mode: '-')
+    end
+
+    def render(data)
+      MessageBinding.new(data).render_template(@erb_template)
+    end
+  end
+end

data/lib/pechkin/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pechkin
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Ilya Arkhanhelsky
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-18 00:00:00.000000000 Z
+date: 2019-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: grape
@@ -38,6 +38,20 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 2.0.6
+- !ruby/object:Gem::Dependency
+  name: prometheus-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
 description: 
 email: ilya.arkhanhelsky at gmail.com
 executables:
@@ -47,12 +61,21 @@ extra_rdoc_files: []
 files:
 - bin/pechkin
 - lib/pechkin.rb
-- lib/pechkin/api.rb
+- lib/pechkin/app.rb
 - lib/pechkin/channel.rb
 - lib/pechkin/cli.rb
-- lib/pechkin/config.rb
+- lib/pechkin/configuration.rb
+- lib/pechkin/configuration/configuration_loader.rb
+- 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/message.rb
+- lib/pechkin/connector_slack.rb
+- lib/pechkin/connector_telegram.rb
+- lib/pechkin/exceptions.rb
+- lib/pechkin/handler.rb
+- lib/pechkin/message_template.rb
 - lib/pechkin/substitute.rb
 - lib/pechkin/version.rb
 homepage: https://github.com/iarkhanhelsky/pechkin

data/lib/pechkin/api.rb

@@ -1,106 +0,0 @@
-require 'grape'
-require 'json'
-
-module Pechkin # :nodoc:
-  # Generates all routes based on configuration
-  module Generator
-    def configure(config)
-      base_path = config['base_path']
-      resource base_path do
-        create_chanels(config['chanels'], config['bots'])
-      end
-
-      self
-    end
-
-    def create_chanels(chanels, bots)
-      chanels.each do |chanel_name, chanel_desc|
-        bot = bots[chanel_desc['bot']]
-
-        raise "'#{chanel_desc['bot']}' not found." unless bot
-
-        connector = create_connector(bot, chanel_name)
-
-        chat_ids = chanel_desc['chat_ids']
-        channel = Chanel.new(connector, chat_ids)
-        channel.logger = logger
-        resource chanel_name do
-          create_chanel(channel, chanel_desc)
-        end
-      end
-    end
-
-    def create_connector(bot, channel_name)
-      case bot['connector']
-      when 'tg', 'telegram'
-        TelegramConnector.new(bot['token'])
-      when 'slack'
-        SlackConnector.new(bot['token'])
-      else
-        raise 'Unknown connector ' + bot['connector'] + ' for ' + channel_name
-      end
-    end
-
-    def create_chanel(channel, chanel_desc)
-      chanel_desc['messages'].each do |message_name, message_desc|
-        generate_endpoint(channel, message_name, message_desc)
-      end
-    end
-
-    # rubocop:disable Metrics/AbcSize
-    def generate_endpoint(channel, message_name, message_desc)
-      params do
-        # TODO: Can't extract this code to method because this block is
-        # evaluated in separate scope
-        (message_desc['filters'] || []).each do |field, filter|
-          filter.match(%r{^/(.*)/$}) do |m|
-            requires field.to_sym, type: String, regexp: Regexp.new(m[1])
-          end
-        end
-      end
-      post message_name do
-        template = message_desc['template']
-        # Some services will send json, but without correct content-type, then
-        # params will be parsed weirdely. So we try parse request body as json
-        params = ensure_json(request.body.read, params)
-        logger.info "Received message #{params.to_json}"
-        logger.info "Will render template file #{template}"
-        # If message description contains any variables will merge them with
-        # received parameters.
-        params = (message_desc['variables'] || {}).merge(params)
-
-        channel.send_message(template, params, message_desc)
-      end
-      # rubocop:enable Metrics/AbcSize
-    end
-  end
-
-  module Helpers # :nodoc:
-    def ensure_json(body, params)
-      if headers['Content-Type'] == 'application/json'
-        params # Expected content type. Do nothing, just return basic params
-      else
-        JSON.parse(body) # Try parse body as json. If it possible will return as
-        # params
-      end
-    rescue JSON::JSONError => _e
-      params
-    end
-
-    def logger
-      PechkinAPI.logger
-    end
-  end
-
-  # Base class for all pechkin apps
-  class PechkinAPI < Grape::API
-    extend Generator
-    helpers Helpers
-  end
-
-  class << self
-    def create(config)
-      Class.new(PechkinAPI).configure(config)
-    end
-  end
-end

data/lib/pechkin/config.rb

@@ -1,10 +0,0 @@
-require 'yaml'
-
-module Pechkin
-  # Loads pechkin configuration
-  class Config < OpenStruct
-    def initialize(file)
-      super(YAML.safe_load(IO.read(file)))
-    end
-  end
-end

data/lib/pechkin/message.rb

@@ -1,8 +0,0 @@
-module Pechkin
-  # Easy way to render erb template
-  class Message < OpenStruct
-    def render(template_file)
-      ERB.new(IO.read(template_file)).result(binding)
-    end
-  end
-end