codebot 1.2.0

data/lib/codebot/network_manager.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require 'codebot/command_error'
+
+module Codebot
+  # This class manages the networks associated with a configuration.
+  class NetworkManager
+    # @return [Config] the configuration managed by this class
+    attr_reader :config
+
+    # Constructs a new network manager for a specified configuration.
+    #
+    # @param config [Config] the configuration to manage
+    def initialize(config)
+      @config = config
+    end
+
+    # Creates a new network from the given parameters.
+    #
+    # @param params [Hash] the parameters to initialize the network with
+    def create(params)
+      network = Network.new(params.merge(config: {}))
+      @config.transaction do
+        check_name_available!(network.name)
+        @config.networks << network
+        network_feedback(network, :created) unless params[:quiet]
+      end
+    end
+
+    # Updates a network with the given parameters.
+    #
+    # @param name [String] the current name of the network to update
+    # @param params [Hash] the parameters to update the network with
+    def update(name, params)
+      @config.transaction do
+        network = find_network!(name)
+        unless params[:name].nil?
+          check_name_available_except!(params[:name], network)
+        end
+        network.update!(params)
+        network_feedback(network, :updated) unless params[:quiet]
+      end
+    end
+
+    # Destroys a network.
+    #
+    # @param name [String] the name of the network to destroy
+    # @param params [Hash] the command-line options
+    def destroy(name, params)
+      @config.transaction do
+        network = find_network!(name)
+        @config.networks.delete network
+        network_feedback(network, :destroyed) unless params[:quiet]
+      end
+    end
+
+    # Lists all networks, or networks with names containing the given search
+    # term.
+    #
+    # @param search [String, nil] an optional search term
+    def list(search)
+      @config.transaction do
+        networks = @config.networks.dup
+        unless search.nil?
+          networks.select! { |net| net.name.downcase.include? search.downcase }
+        end
+        puts 'No networks found' if networks.empty?
+        networks.each { |net| show_network net }
+      end
+    end
+
+    # Finds a network given its name.
+    #
+    # @param name [String] the name to search for
+    # @return [Network, nil] the network, or +nil+ if none was found
+    def find_network(name)
+      @config.networks.find { |net| net.name_eql? name }
+    end
+
+    # Finds a network given its name.
+    #
+    # @param name [String] the name to search for
+    # @raise [CommandError] if no network with the given name exists
+    # @return [Network] the network
+    def find_network!(name)
+      network = find_network(name)
+      return network unless network.nil?
+
+      raise CommandError, "a network with the name #{name.inspect} " \
+                          'does not exist'
+    end
+
+    # Checks that all channels associated with an integration belong to a valid
+    # network.
+    #
+    # @param integration [Integration] the integration to check
+    def check_channels!(integration)
+      integration.channels.map(&:network).map(&:name).each do |network|
+        find_network!(network)
+      end
+    end
+
+    private
+
+    # Checks that the specified name is available for use.
+    #
+    # @param name [String] the name to check for
+    # @raise [CommandError] if the name is already taken
+    def check_name_available!(name)
+      return if name.nil? || !find_network(name)
+
+      raise CommandError, "a network with the name #{name.inspect} " \
+                          'already exists'
+    end
+
+    # Checks that the specified name is available for use by the specified
+    # network.
+    #
+    # @param name [String] the name to check for
+    # @param network [Network] the network to ignore
+    # @raise [CommandError] if the name is already taken
+    def check_name_available_except!(name, network)
+      return if name.nil? || network.name_eql?(name) || !find_network(name)
+
+      raise CommandError, "a network with the name #{name.inspect} " \
+                          'already exists'
+    end
+
+    # Displays feedback about a change made to a network.
+    #
+    # @param network [Network] the network
+    # @param action [#to_s] the action (+:created+, +:updated+ or +:destroyed+)
+    def network_feedback(network, action)
+      puts "Network was successfully #{action}"
+      show_network(network)
+    end
+
+    # Prints information about a network.
+    #
+    # @param network [Network] the network
+    def show_network(network) # rubocop:disable Metrics/AbcSize
+      puts "Network: #{network.name}"
+      security = "#{network.secure ? 'secure' : 'insecure'} connection"
+      password = network.server_password
+      puts "\tServer:     #{network.host}:#{network.real_port} (#{security})"
+      puts "\tPassword:   #{'*' * password.length}" unless password.to_s.empty?
+      puts "\tNickname:   #{network.nick}"
+      puts "\tBind to:    #{network.bind}" unless network.bind.to_s.empty?
+      puts "\tUser modes: #{network.modes}" unless network.modes.to_s.empty?
+      show_network_sasl(network)
+      show_network_nickserv(network)
+    end
+
+    # Prints information about the SASL authentication settings for a network.
+    #
+    # @param network [Network] the network
+    def show_network_sasl(network)
+      puts "\tSASL authentication #{network.sasl? ? 'enabled' : 'disabled'}"
+      return unless network.sasl?
+
+      puts "\t\tUsername: #{network.sasl_username}"
+      puts "\t\tPassword: #{'*' * network.sasl_password.to_s.length}"
+    end
+
+    def nickserv_status(network)
+      network.nickserv? ? 'enabled' : 'disabled'
+    end
+
+    # Prints information about the NickServ authentication
+    #                  settings for a network.
+    #
+    # @param network [Network] the network
+    def show_network_nickserv(network)
+      puts "\tNickServ authentication #{nickserv_status(network)}"
+      return unless network.nickserv?
+
+      puts "\t\tUsername: #{network.nickserv_username}"
+      puts "\t\tPassword: #{'*' * network.nickserv_password.to_s.length}"
+    end
+  end
+end

data/lib/codebot/options.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'thor'
+
+require 'codebot/options/base'
+
+module Codebot
+  # This module provides functionality for parsing command-line options.
+  module Options
+    # Creates a new {Core} from the specified command-line options. Errors of
+    # type {UserError} are handled if they occur in the given block.
+    #
+    # @param opts [Hash] the options to initialize the core with
+    # @param rehash [Boolean] whether to ask a running instance to rehash its
+    #                         configuration after invoking the block
+    # @yield [Core] the newly created {Core}
+    def self.with_core(opts, rehash = false)
+      core = ::Codebot::Core.new(
+        config_file: opts[:config],
+        ipc_pipe: opts[:pipe]
+      )
+      with_errors { yield core }
+      return unless rehash
+
+      with_ipc_client(opts) do |ipc|
+        break unless ipc.send_rehash(!opts[:pipe].nil?)
+
+        puts 'Rehashing the running instance...' unless opts[:quiet]
+      end
+    end
+
+    # Invokes the given block, handling {UserError} errors.
+    def self.with_errors
+      yield
+    rescue UserError => e
+      STDERR.puts "Error: #{e.message}"
+      exit 1
+    end
+
+    # Creates a new {IPCClient} from the specified command-line options.
+    # Errors of type {UserError} are handled if they occur in the given block.
+    #
+    # @param opts [Hash] the options to initialize the client with
+    # @yield [IPCClient] the newly created {IPCClient}
+    def self.with_ipc_client(opts)
+      with_errors { yield IPCClient.new(opts[:pipe]) }
+    end
+  end
+end

data/lib/codebot/options/base.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'thor'
+
+require 'codebot/options/core'
+require 'codebot/options/network'
+require 'codebot/options/integration'
+require 'codebot/user_error'
+
+module Codebot
+  module Options
+    # A class that handles the +codebot+ command. This class delegates handling
+    # of any commands to the respective class for the appropriate subcommand.
+    class Base < Thor
+      check_unknown_options!
+
+      class_option :config,
+                   banner: 'FILE',
+                   aliases: '-C',
+                   desc: 'Use the specified alternate configuration file'
+      class_option :pipe,
+                   banner: 'FILE',
+                   aliases: '-P',
+                   desc: 'Use the specified alternate named pipe'
+      class_option :quiet,
+                   type: :boolean,
+                   default: false,
+                   aliases: '-q',
+                   desc: 'Hide status information'
+
+      desc 'core [OPTIONS]', 'Manage a Codebot core'
+      subcommand 'core', Core
+
+      desc 'network [OPTIONS]', 'Manage IRC networks'
+      subcommand 'network', Network
+
+      desc 'integration [OPTIONS]', 'Manage integrations'
+      subcommand 'integration', Integration
+
+      # Ensures that thor uses the correct exit code.
+      #
+      # @return true
+      def self.exit_on_failure?
+        true
+      end
+
+      if Process.uid.zero? || Process.euid.zero?
+        STDERR.puts 'Running Codebot as root is extremely dangerous; ' \
+                    "if you're trying to listen on a privileged port " \
+                    'please use a gateway server instead'
+        exit 1
+      end
+    end
+  end
+end

data/lib/codebot/options/core.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'codebot/ipc_client'
+
+module Codebot
+  module Options
+    # A class that handles the +codebot core+ command.
+    class Core < Thor
+      check_unknown_options!
+
+      desc 'interactive', 'Run Codebot interactively'
+
+      # Runs Codebot interactively.
+      def interactive
+        run_core(true)
+      end
+
+      desc 'start', 'Start a new Codebot instance in the background'
+
+      # Starts a new Codebot instance in the background.
+      def start
+        Options.with_errors { check_fork_supported! }
+        check_not_running!(options)
+        fork { run_core(false) }
+      end
+
+      desc 'stop', 'Stop a running Codebot instance'
+
+      # Stops a running Codebot instance.
+      def stop
+        Options.with_ipc_client(options, &:send_stop)
+      end
+
+      desc 'rehash', 'Reload the configuration of a running Codebot instance'
+
+      # Reloads the configuration of a running Codebot instance.
+      def rehash
+        Options.with_ipc_client(options, &:send_rehash)
+      end
+
+      # Ensures that thor uses the correct exit code.
+      #
+      # @return true
+      def self.exit_on_failure?
+        true
+      end
+
+      private
+
+      # Ensures that a Codebot instance using the same pipe is not already
+      # running.
+      #
+      # @param opts [Hash] a hash containing the options that would be used for
+      #                    initializing a new core; specifically, a hash
+      #                    containing the +:pipe+ key to indicate the path to
+      #                    the named pipe used by the IPC server.
+      # @raise [CommandError] if the named pipe already exists
+      def check_not_running!(opts)
+        Options.with_ipc_client(opts) do |ipc|
+          break unless ipc.pipe_exist?
+
+          raise CommandError, 'named pipe already exists; if you are sure a ' \
+                              'Codebot instance is not already running, you ' \
+                              "can delete #{ipc.pipe.inspect}"
+        end
+      end
+
+      # Ensures that the current platform supports the Process::fork method,
+      # raising an error if it does not.
+      #
+      # @raise [CommandError] if forking is not supported
+      def check_fork_supported!
+        return if Process.respond_to?(:fork)
+
+        raise CommandError, 'this feature is not available on ' \
+                            "#{RUBY_PLATFORM}; please use the " \
+                            "'interactive' command instead"
+      end
+
+      # Reopens the standard file descriptors to prevent the forked process
+      # from inheriting the file descriptors of the parent process. This method
+      # reopens streams using a method similar to the Unix dup2 function.
+      #
+      # @param sin [File] the file to redirect into the standard input stream,
+      #                    or +nil+ to detach and immediately close the stream.
+      # @param sout [File] the file to redirect the standard output stream to,
+      #                    or +nil+ to discard any data written to the stream.
+      # @param serr [File] the file to redirect the standard error stream to,
+      #                    or +nil+ to discard any data written to the stream.
+      def dup2_fds(sin: nil, sout: nil, serr: nil)
+        $stdin.reopen(sin || null_file('r'))
+        $stdout.reopen(sout || null_file('w'))
+        $stderr.reopen(serr || null_file('w'))
+      end
+
+      # Creates a new null file.
+      #
+      # @param mode [String] the mode to open the file in
+      # @return [File] the created file
+      def null_file(mode)
+        File.new(File::NULL, mode)
+      end
+
+      # Initializes any missing environment variables to their default values.
+      def initialize_environment
+        ENV['CODEBOT_PORT'] ||= 4567.to_s
+        ENV['RACK_ENV'] ||= 'production'
+      end
+
+      # Starts the bot. Unless started in interactive mode, file descriptors
+      # are reopened from a null file.
+      #
+      # @param interactive [Boolean] whether to start the bot in the foreground
+      def run_core(interactive)
+        initialize_environment
+        check_not_running!(options)
+        dup2_fds unless interactive
+        Options.with_core(options) do |core|
+          core.trap_signals
+          core.start
+          core.join
+        end
+      end
+    end
+  end
+end

data/lib/codebot/options/integration.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'codebot/integration_manager'
+
+module Codebot
+  module Options
+    # A class that handles the +codebot integration+ command.
+    class Integration < Thor
+      check_unknown_options!
+
+      # Sets shared options for specifying properties belonging to the
+      # {::Codebot::Integration} class.
+      def self.shared_propery_options
+        option :endpoint, aliases: '-e',
+                          desc: 'Set the endpoint for incoming webhooks'
+        option :secret, aliases: '-s',
+                        desc: 'Set the secret for verifying webhook payloads'
+      end
+
+      desc 'create NAME', 'Add a new integration'
+      shared_propery_options
+      option :channels, aliases: '-c', type: :array,
+                        desc: 'Set the channels to deliver notifications to'
+
+      # Creates a new integration with the specified name.
+      #
+      # @param name [String] the name of the new integration
+      def create(name)
+        Options.with_core(parent_options, true) do |core|
+          map_channels!(options, :channels)
+          IntegrationManager.new(core.config).create(options.merge(name: name))
+        end
+      end
+
+      desc 'update NAME', 'Edit an integration'
+      option :name, aliases: '-n',
+                    banner: 'NEW-NAME',
+                    desc: 'Rename this integration'
+      shared_propery_options
+      option :add_channel, aliases: '-a', type: :array,
+                           desc: 'Add a channel to this integration'
+      option :clear_channels, aliases: '-c', type: :boolean,
+                              desc: 'Clear the channel list ' \
+                                    '(default: false)'
+      option :delete_channel, aliases: '-d', type: :array,
+                              desc: 'Delete a channel from this integration'
+
+      # Updates the integration with the specified name.
+      #
+      # @param name [String] the name of the integration
+      def update(name)
+        Options.with_core(parent_options, true) do |core|
+          map_channels!(options, :add_channel)
+          IntegrationManager.new(core.config).update(name, options)
+        end
+      end
+
+      desc 'destroy NAME', 'Delete an integration'
+
+      # Destroys the integration with the specified name.
+      #
+      # @param name [String] the name of the integration
+      def destroy(name)
+        Options.with_core(parent_options, true) do |core|
+          IntegrationManager.new(core.config).destroy(name, options)
+        end
+      end
+
+      desc 'list [SEARCH]', 'List integrations'
+
+      # Lists all integrations, or integrations with names containing the given
+      # search term.
+      #
+      # @param search [String, nil] an optional search term
+      def list(search = nil)
+        Options.with_core(parent_options, true) do |core|
+          IntegrationManager.new(core.config).list(search)
+        end
+      end
+
+      # Ensures that thor uses the correct exit code.
+      #
+      # @return true
+      def self.exit_on_failure?
+        true
+      end
+
+      private
+
+      # Destructively converts an array of channel identifiers contained in a
+      # hash into the serialized form of the channels contained in the array.
+      # If the value +hash[key]+ is +nil+, no action is taken.
+      #
+      # @param hash [Hash] the hash containing the array of identifiers
+      # @param key [Object] the key corresponding to the array of identifiers
+      def map_channels!(hash, key)
+        hash[key] = hash[key].map { |id| [id, {}] }.to_h unless hash[key].nil?
+      end
+    end
+  end
+end