pechkin 1.2.2 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8edc5ca6908ec5bbe30dc46cac568f7461a7cd4a7b8f27edfec4bc9f03c406e
-  data.tar.gz: 181cfaae800da3746168e124faeac2a794d8392c2291cff1ed44f1b2903ed35d
+  metadata.gz: 21153645eb45d32b113d2c95191e79ac5568a10829b3989ccc9f75da7b53bf9e
+  data.tar.gz: d80b4bbbeb7e4bdfeb251e358bb0a9c99d50eae96c5078b688bce5e12a3c73e3
 SHA512:
-  metadata.gz: a779e1584430ceb11261abfa41c4a3f5a01e688867c43b87824a046c73e1398b1ae12a9aaaa2a565d864241d23effebb429dace47d41d77493e5ebd6f907fbd2
-  data.tar.gz: 1533b9c729bc2b6c3b2498066bbbc027c44e03a106d4260538fb58399fa42565278661e32a426ffb07449ae33dfac6d89b43f96086983f534d33e7ce90240a03
+  metadata.gz: 30e9654efb5c1a11c4816feb51fc494be1251e106a2fac682be9cb68738faec6e8b45c747329f90cff226ef1fe9df2c097bb0083c79d57d55b020982773dd0b8
+  data.tar.gz: 62d6113f5ef1aedfe36c3eb86bc619d7cbac2cd9e54a37f64cbd293b1856efe47ba572bdf25efcc2a20f7b1affbbffe8cc2e74ad9784091cc69f7fa232ebe19b

data/lib/pechkin.rb

@@ -11,6 +11,7 @@ require_relative 'pechkin/cli'
 require_relative 'pechkin/command'
 require_relative 'pechkin/exceptions'
 require_relative 'pechkin/handler'
+require_relative 'pechkin/message_matcher'
 require_relative 'pechkin/message_template'
 require_relative 'pechkin/connector'
 require_relative 'pechkin/connector_slack'

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/app/app.rb

@@ -0,0 +1,43 @@
+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"))
+      response(503, data)
+    end
+  end
+end

data/lib/pechkin/app/app_builder.rb

@@ -0,0 +1,41 @@
+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
+        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
+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{^/(.+)/([^/]+)/?$}
+
+    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/configuration.rb

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

data/lib/pechkin/connector_slack.rb

@@ -13,7 +13,8 @@ module Pechkin # :nodoc:
       attachments = message_desc['slack_attachments'] || {}
 
       if text.strip.empty? && attachments.empty?
-        return [channel, 400, 'Internal error: message is empty']
+        return { channel: channel, code: 400,
+                 response: 'Internal error: message is empty' }
       end
 
       params = { channel: channel, text: text, attachments: attachments }
@@ -21,7 +22,7 @@ module Pechkin # :nodoc:
       url = 'https://slack.com/api/chat.postMessage'
       response = post_data(url, params, headers: @headers)
 
-      [channel, response.code.to_i, response.body]
+      { channel: channel, code: response.code.to_i, response: response.body }
     end
   end
 end

data/lib/pechkin/connector_telegram.rb

@@ -12,7 +12,7 @@ module Pechkin
       params = options.update(chat_id: chat_id, text: message)
 
       response = post_data(method_url('sendMessage'), params)
-      [chat_id, response.code.to_i, response.body]
+      { chat_id: chat_id, code: response.code.to_i, response: response.body }
     end
 
     private

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
     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.info "#{channel_id}/#{msg_id}: " \
+                    "Skip sending message. Because it's not allowed"
+        []
+      end
     end
 
     # Executes message handling and renders template using connector logic
@@ -47,20 +51,16 @@ module Pechkin
     #  deserialized json.
     # @see Configuration
     def preview(channel_id, msg_id, data)
-      channel_config = fetch_channel(channel_id)
-      # Find message and try substitute values to message parameters.
-      message_config = substitute(data, fetch_message(channel_config, msg_id))
-
-      data = (message_config['variables'] || {}).merge(data)
-      template = message_config['template']
-
-      text = ''
-      text = template.render(data) unless template.nil?
-
+      channel_config, message_config, text =
+        prepare_message(channel_id, msg_id, data)
       chats = channel_config.chat_ids
       connector = channel_config.connector
 
-      connector.preview(chats, text, message_config)
+      if message_allowed?(message_config, data)
+        connector.preview(chats, text, message_config)
+      else
+        puts "No message sent beacuse it's not allowed"
+      end
     end
 
     def message?(channel_id, msg_id)
@@ -69,6 +69,10 @@ module Pechkin
 
     private
 
+    def puts(msg)
+      @stdout.puts(msg)
+    end
+
     # Find channel by it's id or trow ChannelNotFoundError
     def fetch_channel(channel_id)
       raise ChannelNotFoundError, channel_id unless channels.key?(channel_id)
@@ -84,6 +88,24 @@ module Pechkin
       message_list[msg_id]
     end
 
+    def message_allowed?(message_config, data)
+      message_matcher.matches?(message_config, data)
+    end
+
+    def prepare_message(channel_id, msg_id, data)
+      channel_config = fetch_channel(channel_id)
+      # Find message and try substitute values to message parameters.
+      message_config = substitute(data, fetch_message(channel_config, msg_id))
+
+      data = (message_config['variables'] || {}).merge(data)
+      template = message_config['template']
+
+      text = ''
+      text = template.render(data) unless template.nil?
+
+      [channel_config, message_config, text]
+    end
+
     def substitute(data, message_desc)
       substitute_recursive(Substitute.new(data), message_desc)
     end

data/lib/pechkin/message_matcher.rb

@@ -0,0 +1,78 @@
+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
+    # 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, data) }
+      elsif message_config.key?(KEY_FORBID)
+        rules = message_config[KEY_FORBID]
+        rules.all? { |r| !check_rule(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(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)
+      end
+    end
+
+    def check_hash_rule(hash, data)
+      return false unless data.is_a?(Hash)
+
+      hash.all? do |key, value|
+        data.key?(key) && check_rule(value, data[key])
+      end
+    end
+
+    def check_array_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) }
+    end
+
+    def check_string_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, 3, 1].freeze
     class << self
       def version_string
         VERSION.join('.')

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: pechkin
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.3.1
 platform: ruby
 authors:
 - Ilya Arkhanhelsky
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-04 00:00:00.000000000 Z
+date: 2020-02-07 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
@@ -90,6 +76,10 @@ files:
 - bin/pechkin
 - lib/pechkin.rb
 - lib/pechkin/app.rb
+- lib/pechkin/app/app.rb
+- lib/pechkin/app/app_builder.rb
+- lib/pechkin/app/app_error.rb
+- lib/pechkin/app/request_handler.rb
 - lib/pechkin/auth.rb
 - lib/pechkin/channel.rb
 - lib/pechkin/cli.rb
@@ -111,6 +101,7 @@ files:
 - lib/pechkin/connector_telegram.rb
 - lib/pechkin/exceptions.rb
 - lib/pechkin/handler.rb
+- lib/pechkin/message_matcher.rb
 - lib/pechkin/message_template.rb
 - lib/pechkin/prometheus_utils.rb
 - lib/pechkin/substitute.rb