rodbot 0.1.0

data/lib/rodbot/dispatcher.rb

@@ -0,0 +1,125 @@
+# frozen-string-literal: true
+
+module Rodbot
+
+  # Dispatcher infrastructure to run and supervise tasks
+  class Dispatcher
+
+    # Which signals detached processes trap in order to exit
+    TRAPS = %w(INT TERM).freeze
+
+    # @return [String] name of the group of tasks
+    attr_reader :group
+
+    # @return [String] registered tasks
+    attr_reader :tasks
+
+    # @param group [String] name of the group of tasks
+    # @param refork_delay [Integer] seconds to wait before re-forking dead tasks
+    def initialize(group, refork_delay: 5)
+      @group, @refork_delay = group, refork_delay
+      @tasks = {}
+    end
+
+    # Register a task
+    #
+    # @param task [String] task name
+    # @yield block for the task to run
+    # @return self
+    def register(task)
+      tasks[task] = Proc.new do
+        detach task
+        unless Rodbot::Log.std?
+          logger = Rodbot::Log.logger("dispatcher #{group}.#{task}]")
+          $stdout = Rodbot::Log::LoggerIO.new(logger, Logger::INFO)
+          $stderr = Rodbot::Log::LoggerIO.new(logger, Logger::WARN)
+          $stdin.reopen(File::NULL)
+        end
+        yield
+      end
+      self
+    end
+
+    # Run the registered tasks
+    #
+    # @param daemonize [Boolean] whether to run and supervise the tasks in
+    #   the background
+    def run(daemonize: false)
+      if daemonize
+        Process.daemon(false, true)
+        detach 'supervisor'
+        dispatch
+        supervise
+      else
+        Process.setproctitle("#{group}.supervisor")
+        dispatch
+        sleep
+      end
+    ensure
+      cleanup
+    end
+
+    # Interrupt the registered tasks
+    def interrupt
+      Process.kill('INT', pid_file('supervisor').read.to_i)
+    rescue Errno::ESRCH
+    end
+
+    private
+
+    # Dispatch all registered tasks
+    def dispatch
+      tasks.each_value { fork &_1 }
+    end
+
+    # Supervise all dispatched tasks
+    def supervise
+      loop do
+        pid = Process.wait
+        sleep @refork_delay
+        fork &tasks[task(pid)]
+      end
+    end
+
+    # Remove all artefacts
+    def cleanup
+      Rodbot.env.tmp.glob("#{group}.*.pid").each do |pid_file|
+        pid = pid_file.read.to_i
+        Process.kill('INT', pid) unless pid == Process.pid
+      rescue Errno::ESRCH
+      ensure
+        pid_file.delete
+      end
+    end
+
+    # Perform operations to properly detach the task
+    #
+    # @param task [String] task name
+    def detach(task)
+      pid_file(task).write Process.pid
+      Process.setproctitle("#{group}.#{task}")
+      TRAPS.each { trap(_1) { exit } }
+    end
+
+    # PID file of the given task should be
+    #
+    # @param task [String] task name
+    # @return [Pathname] PID file
+    def pid_file(task)
+      Rodbot.env.tmp.join("#{group}.#{task}.pid")
+    end
+
+    # Fetch a task name for a process ID from the PID files
+    #
+    # @param pid [Integer] process ID
+    # @return [String] task name
+    def task(pid)
+      Rodbot.env.tmp.glob("#{group}.*.pid").find do |pid_file|
+        pid_file.read.to_i == pid
+      end.then do |pid_file|
+        pid_file.basename.to_s.split('.')[1] if pid_file
+      end
+    end
+
+  end
+end

data/lib/rodbot/env.rb

@@ -0,0 +1,48 @@
+# frozen-string-literal: true
+
+module Rodbot
+
+  # Environment the bot is currently living in
+  #
+  # @note Use the +Rodbot.env+ shortcut to access these methods!
+  class Env
+
+    # Supported environments
+    ENVS = %w(production development test).freeze
+
+    # @return [Pathname] root directory
+    attr_reader :root
+
+    # @return [Pathname] root directory
+    attr_reader :tmp
+
+    # @return [Pathname] gem root directory
+    attr_reader :gem
+
+    # @return [String] current environment - any of {ENVS}
+    attr_reader :current
+
+    # @param root [Pathname, String] root path (default: current directory)
+    def initialize(root: nil)
+      @root = root ? Pathname(root).realpath : Pathname.pwd
+      @tmp = @root.join('tmp')
+      @gem = Pathname(__dir__).join('..', '..').realpath
+      @current = ENV['RODBOT_ENV']
+      @current = 'development' unless ENVS.include? @current
+    end
+
+    # @!method production?
+    # @!method development?
+    # @!method test?
+    #
+    # Inquire the env based on RODBOT_ENV
+    #
+    # @return [Boolean]
+    ENVS.each do |env|
+      define_method "#{env}?" do
+        env == current
+      end
+    end
+
+  end
+end

data/lib/rodbot/error.rb

@@ -0,0 +1,19 @@
+# frozen-string-literal: true
+
+module Rodbot
+  class Error < StandardError
+    def initialize(message, details=nil)
+      @details = details
+      super(message)
+    end
+
+    def detailed_message
+      [message, @details].compact.join(': ')
+    end
+  end
+
+  GeneratorError = Class.new(Error)
+  PluginError = Class.new(Error)
+  ServiceError = Class.new(Error)
+  RelayError = Class.new(Error)
+end

data/lib/rodbot/generator.rb

@@ -0,0 +1,108 @@
+# frozen-string-literal: true
+
+require 'fileutils'
+require 'erb'
+require 'pastel'
+
+module Rodbot
+
+  # Generators for new bots, deployments and such
+  #
+  # All files inside the +templates_path+ are honoured provided they match the
+  # {GLOB}. Files with the extension ".gerb" are parsed like ERB files, however,
+  # GERB tags must use square brackets.
+  #
+  #   ERB:  <%= 'foobar' %>
+  #   GERB: [%= 'foobar' %]
+  #
+  # It's therefore possible to generate ERB files such as +index.erb.gerb+.
+  #
+  # Helpers available in GERB templates have to be defined in
+  # {Rodbot::Generator::Helpers}.
+  class Generator
+
+    # Glob to filter relevant template files
+    GLOB = "**/{*,.ruby-version,.gitignore,.keep}"
+
+    # Colors used by +info+ to color part of the output
+    TAG_COLORS = {
+      create: :green
+    }.freeze
+
+    # @param templates_path [Pathname] root path of the templates to generate from
+    def initialize(templates_path)
+      @templates_path = templates_path
+      @helpers_binding = Helpers.new.instance_eval('binding')
+      @pastel = Pastel.new
+    end
+
+    # Print the interpolated template to STDOUT
+    def display
+      each_template_path do |template_path, target_path, content|
+        puts "# #{target_path}", (content || template_path.read)
+      end
+    end
+
+    # Write the interpolated template to directory
+    #
+    # @param directory [Pathname] where to write the files to
+    def write(directory)
+      fail(Rodbot::GeneratorError, "cowardly refusing to write to existing #{directory}") if directory.exist?
+      each_template_path do |template_path, target_path, content|
+        absolute_target_path = directory.join(target_path)
+        absolute_target_path.dirname.mkpath
+        puts tag(:create, target_path)
+        if content
+          absolute_target_path.write(content)
+        else
+          FileUtils.copy(template_path, absolute_target_path)
+        end
+      end
+    end
+
+    private
+
+    def each_template_path
+      @templates_path.glob(GLOB).each do |template_path|
+        next unless template_path.file?
+        target_path = template_path.relative_path_from(@templates_path)
+        content = if template_path.extname == '.gerb'
+          target_path = target_path.dirname.join(target_path.basename('.gerb'))
+          eval_gerb(template_path.read)
+        end
+        yield(template_path, target_path, content)
+      end
+    end
+
+    def eval_gerb(string)
+      ungerbify(ERB.new(gerbify(string), trim_mode: '-').result(@helpers_binding))
+    end
+
+    def gerbify(string)
+      string.gsub('<%', '{%').gsub('%>', '%}').gsub('[%', '<%').gsub('%]', '%>')
+    end
+
+    def ungerbify(string)
+      string.gsub('{%', '<%').gsub('%}', '%>')
+    end
+
+    def tag(tag, string)
+      padded_tag = '[' + tag.to_s.ljust(6, ' ') + '] '
+      @pastel.decorate(padded_tag, TAG_COLORS[tag]) + string.to_s.strip
+    end
+
+    class Helpers
+      def timezone
+        Rodbot.config(:timezone)
+      end
+
+      def relay_extensions
+        Rodbot.plugins.extend_relay
+        Rodbot.plugins.extensions[:relay].to_h do |name, _|
+          [name, URI(Rodbot::Services::Relay.url(name)).port]
+        end
+      end
+    end
+
+  end
+end

data/lib/rodbot/log.rb

@@ -0,0 +1,67 @@
+# frozen-string-literal: true
+
+module Rodbot
+
+  # Log facilities
+  class Log
+
+    # Default logger
+    attr_reader :default_logger
+
+    # Black hole logger
+    attr_reader :null_logger
+
+    def initialize
+      @default_logger = self.class.logger('rodbot')
+      @null_logger = Logger.new(File::NULL)
+    end
+
+    # Add a log entry to the default log
+    #
+    # @note Use the +Rodbot.log+ shortcut to access this method!
+    #
+    # @param message [String] log message
+    # @param level [Integer] any log level from {Logger}
+    def log(message, level: Logger::INFO)
+      @default_logger.log(level, message)
+    end
+
+    # Create a logger instance for the given scope
+    #
+    # @param progname [String] progname used as default scope
+    def self.logger(progname)
+      Logger.new(Rodbot.config(:log, :to), progname: progname).tap do |logger|
+        logger.level = Rodbot.config(:log, :level)
+      end
+    end
+
+    # Whether currently configured to log to a std device (+STDOUT+ or +STDERR+)
+    #
+    # @return [Boolean]
+    def self.std?
+      [STDOUT, STDERR].include? Rodbot.config(:log, :to)
+    end
+
+    # Simple wrapper to decorate a logger for use with $stdout and $stderr
+    class LoggerIO
+
+      # @ param logger [Logger] logger instance
+      # @ param level [Integer] any log level from +Logger+
+      def initialize(logger, level)
+        @logger, @level = logger, level
+      end
+
+      # Write to the log
+      #
+      # @param message [String] log entry to add
+      def write(message)
+        @logger.log(@level, message.strip)
+      end
+
+      # Swallow any other method such as +sync+ or +flush+
+      def method_missing(*)
+      end
+    end
+
+  end
+end

data/lib/rodbot/memoize.rb

@@ -0,0 +1,86 @@
+# frozen-string-literal: true
+
+module Rodbot
+
+  # Memoize the return value of a specific method
+  #
+  # The method signature is taken into account, therefore calls of the same
+  # method with different positional and/or keyword arguments are cached
+  # independently. On the other hand, when calling the method with a block,
+  # no memoization is performed at all.
+  #
+  # @example Explicit declaration
+  #   class Either
+  #     include Rodbot::Memoize
+  #
+  #     def either(argument=nil, keyword: nil, &block)
+  #       $entropy || argument || keyword || (block.call if block)
+  #     end
+  #     memoize :either
+  #   end
+  #
+  # @example Prefixed declaration
+  #   class Either
+  #     include Rodbot::Memoize
+  #
+  #     memoize def either(argument=nil, keyword: nil, &block)
+  #       $entropy || argument || keyword || (block.call if block)
+  #     end
+  #   end
+  #
+  # @example Behaviour of either of the above
+  #   e = Either.new
+  #   $entropy = nil
+  #   e.either(1)                 # => 1
+  #   e.either(keyword: 2)        # => 2
+  #   e.either { 3 }              # => 3
+  #   $entropy = :not_nil
+  #   e.either(1)                 # => 1          (memoized)
+  #   e.either(keyword: 2)        # => 2          (memoized)
+  #   e.either { 3 }              # => :not_nil   (cannot be memoized)
+  #   Rodbot::Memoize.suspend do
+  #     e.either(1)               # => 1          (calculated, not memoized)
+  #   end
+  module Memoize
+    module ClassMethods
+      def memoize(method)
+        unmemoized_method = :"_unmemoized_#{method}"
+        alias_method unmemoized_method, method
+        define_method method do |*args, **kargs, &block|
+          if Rodbot::Memoize.suspended? || block
+            send(unmemoized_method, *args, **kargs, &block)
+          else
+            id = method.hash ^ args.hash ^ kargs.hash
+            @_memoize_cache ||= {}
+            if @_memoize_cache.has_key? id
+              @_memoize_cache[id]
+            else
+              @_memoize_cache[id] = send(unmemoized_method, *args, **kargs)
+            end
+          end
+        end
+        method
+      end
+    end
+
+    class << self
+      def suspend
+        @suspended = true
+        yield
+      ensure
+        @suspended = false
+      end
+
+      def suspended?
+        @suspended = false if @suspended.nil?
+        @suspended
+      end
+
+      def included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+
+  end
+

data/lib/rodbot/plugins/github_webhook/README.github_webhook.md

@@ -0,0 +1,42 @@
+# Rodbot Plugin – GitHub Webhook
+
+Pipeline event announcements from GitHub
+
+## Preparation
+
+The Rodbot app binds to `localhost` by default which cannot be reached from GitHub. Make sure this connection is possible by setting a different IP in `config/rodbot.rb`:
+
+```ruby
+app do
+  host '0.0.0.0'
+end
+```
+
+To authenticate the webhook calls from GitHub, create a new random secret token:
+
+```
+ruby -r securerandom -e "puts SecureRandom.alphanumeric(20)"
+```
+
+## Activation
+
+Activate and configure this plugin in `config/rodbot.rb`:
+
+```ruby
+plugin :github_webhook do
+  secret_tokens '<TOKEN>'
+end
+```
+
+You can set any number of secure tokens here separated with colons.
+
+## Add Repositories
+
+Add a webhook to every GitHub repository you'd like to see pipeline event announcements for. Go to `https://github.com/<USER>/<REPO>/settings/hooks` and create a new webhook with the following properties:
+
+* Payload URL: `https://<RODBOT-APP>/github_webhook`
+* Content type: `application/json`
+* Secret: `<TOKEN>`
+* SSL verification: (o) Enable SSL verification
+* Which events? (o) Let me select individual events: [x] Workflow runs
+* And... [x] Active

data/lib/rodbot/plugins/github_webhook/app.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Rodbot
+  class Plugins
+    class GithubWebhook
+      module App
+
+        class Routes < ::App
+          route do |r|
+            r.post '' do
+              r.halt 200 if request.env['HTTP_X_GITHUB_EVENT'] == 'ping'
+              r.halt 400 unless request.env['HTTP_X_GITHUB_EVENT'] == 'workflow_run'
+              r.halt 401 unless authorized? request
+              json = JSON.parse(request.body.read)
+              project = json.dig('repository', 'full_name')
+              status = json.dig('workflow_run', 'status')
+              status = json.dig('workflow_run', 'conclusion') if status == 'completed'
+              Rodbot.say [emoji_for(status), project, status.gsub('_', ' ')].join(' ')
+              r.halt 200
+            end
+          end
+
+          private
+
+          def authorized?(request)
+            Rodbot.config(:plugin, :github_webhook, :secret_tokens).to_s.split(':').any? do |secret|
+              signature = 'sha256=' + OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new('sha256'), secret, request.body.read)
+              request.body.rewind
+              ::Rack::Utils.secure_compare(signature, request.env['HTTP_X_HUB_SIGNATURE_256'])
+            end
+          end
+
+          def emoji_for(status)
+            case status
+              when 'requested' then '🟡'
+              when 'success' then '🟢'
+              when 'failure' then '🔴'
+              else '⚪️'
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/rodbot/plugins/gitlab_webhook/README.gitlab_webhook.md

@@ -0,0 +1,40 @@
+# Rodbot Plugin – GitLab Webhook
+
+Pipeline event announcements from GitLab
+
+## Preparation
+
+The Rodbot app binds to `localhost` by default which cannot be reached from GitLab. Make sure this connection is possible by setting a different IP in `config/rodbot.rb`:
+
+```ruby
+app do
+  host '0.0.0.0'
+end
+```
+
+To authenticate the webhook calls from GitLab, create a new random secret token:
+
+```
+ruby -r securerandom -e "puts SecureRandom.alphanumeric(20)"
+```
+
+## Activation
+
+Activate and configure this plugin in `config/rodbot.rb`:
+
+```ruby
+plugin :gitlab_webhook do
+  secret_tokens '<TOKEN>'
+end
+```
+
+You can set any number of secure tokens here separated with colons.
+
+## Add Repositories
+
+Add a webhook to every GitLab repository you'd like to see pipeline event announcements for. Go to `https://gitlab.com/<USER>/<REPO>/-/hooks` and create a new webhook with the following properties:
+
+* URL: `https://<RODBOT-APP>/gitlab_webhook`
+* Secret token: `<TOKEN>`
+* Trigger: [x] Pipeline events
+* SSL verification: [x] Enable SSL verification

data/lib/rodbot/plugins/gitlab_webhook/app.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Rodbot
+  class Plugins
+    class GitlabWebhook
+      module App
+
+        class Routes < ::App
+          route do |r|
+            r.post '' do
+              r.halt 401 unless authorized? request
+              json = JSON.parse(request.body.read)
+              r.halt 400 unless json['object_kind'] == 'pipeline'
+              project = json.dig('project', 'path_with_namespace')
+              status = json.dig('object_attributes', 'detailed_status')
+              Rodbot.say [emoji_for(status), project, status.gsub('_', ' ')].join(' ')
+              r.halt 200
+            end
+          end
+
+          private
+
+          def authorized?(request)
+            Rodbot.config(:plugin, :gitlab_webhook, :secret_tokens).to_s.split(':').include?(request.env['HTTP_X_GITLAB_TOKEN'])
+          end
+
+          def emoji_for(status)
+            case status
+              when 'running' then '🟡'
+              when 'passed' then '🟢'
+              when 'failed' then '🔴'
+              else '⚪️'
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/rodbot/plugins/hal/README.hal.md

@@ -0,0 +1,15 @@
+# Rodbot Plugin – HAL 9000
+
+Feel like Dave
+
+## Setup
+
+Activate this plugin in `config/rodbot.rb`:
+
+```ruby
+plugin :hal
+```
+
+## Usage
+
+Send the "hal" command, on most communication networks with `!hal`.

data/lib/rodbot/plugins/hal/app.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Rodbot
+  class Plugins
+    class Hal
+      module App
+
+        class Routes < ::App
+          route do |r|
+            r.root do
+              response['Content-Type'] = 'text/markdown; charset=utf-8'
+              <<~END
+                [🔴](https://www.youtube.com/watch?v=ARJ8cAGm6JE) I'm sorry [[SENDER]], I'm afraid I can't do that.
+              END
+            end
+          end
+        end
+
+      end
+    end
+  end
+end