codebot 1.2.0

data/lib/codebot/integration_manager.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require 'codebot/network_manager'
+require 'codebot/command_error'
+
+module Codebot
+  # This class manages the integrations associated with a configuration.
+  class IntegrationManager # rubocop:disable Metrics/ClassLength
+    # @return [Config] the configuration managed by this class
+    attr_reader :config
+
+    # Constructs a new integration manager for a specified configuration.
+    #
+    # @param config [Config] the configuration to manage
+    def initialize(config)
+      @config = config
+    end
+
+    # Creates a new integration from the given parameters.
+    #
+    # @param params [Hash] the parameters to initialize the integration with
+    def create(params)
+      integration = Integration.new(
+        params.merge(config: { networks: @config.networks })
+      )
+      @config.transaction do
+        check_available!(integration.name, integration.endpoint)
+        NetworkManager.new(@config).check_channels!(integration)
+        @config.integrations << integration
+        integration_feedback(integration, :created) unless params[:quiet]
+      end
+    end
+
+    # Updates an integration with the given parameters.
+    #
+    # @param name [String] the current name of the integration to update
+    # @param params [Hash] the parameters to update the integration with
+    def update(name, params)
+      @config.transaction do
+        integration = find_integration!(name)
+        check_available_except!(params[:name], params[:endpoint], integration)
+        update_channels!(integration, params)
+        NetworkManager.new(@config).check_channels!(integration)
+        integration.update!(params)
+        integration_feedback(integration, :updated) unless params[:quiet]
+      end
+    end
+
+    # Destroys an integration.
+    #
+    # @param name [String] the name of the integration to destroy
+    # @param params [Hash] the command-line options
+    def destroy(name, params)
+      @config.transaction do
+        integration = find_integration!(name)
+        @config.integrations.delete integration
+        integration_feedback(integration, :destroyed) unless params[:quiet]
+      end
+    end
+
+    # Lists all integrations, or integrations with names containing the given
+    # search term.
+    #
+    # @param search [String, nil] an optional search term
+    def list(search)
+      @config.transaction do
+        integrations = @config.integrations.dup
+        unless search.nil?
+          integrations.select! do |intg|
+            intg.name.downcase.include? search.downcase
+          end
+        end
+        puts 'No integrations found' if integrations.empty?
+        integrations.each { |intg| show_integration intg }
+      end
+    end
+
+    # Finds an integration given its name.
+    #
+    # @param name [String] the name to search for
+    # @return [Integration, nil] the integration, or +nil+ if none was found
+    def find_integration(name)
+      @config.integrations.find { |intg| intg.name_eql? name }
+    end
+
+    # Finds an integration given its endpoint.
+    #
+    # @param endpoint [String] the endpoint to search for
+    # @return [Integration, nil] the integration, or +nil+ if none was found
+    def find_integration_by_endpoint(endpoint)
+      @config.integrations.find { |intg| intg.endpoint_eql? endpoint }
+    end
+
+    # Finds an integration given its name.
+    #
+    # @param name [String] the name to search for
+    # @raise [CommandError] if no integration with the given name exists
+    # @return [Integration] the integration
+    def find_integration!(name)
+      integration = find_integration(name)
+      return integration unless integration.nil?
+
+      raise CommandError, "an integration with the name #{name.inspect} " \
+                          'does not exist'
+    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 unless find_integration(name)
+
+      raise CommandError, "an integration with the name #{name.inspect} " \
+                          'already exists'
+    end
+
+    # Checks that the specified endpoint is available for use.
+    #
+    # @param endpoint [String] the endpoint to check for
+    # @raise [CommandError] if the endpoint is already taken
+    def check_endpoint_available!(endpoint)
+      return unless find_integration_by_endpoint(endpoint)
+
+      raise CommandError, 'an integration with the endpoint ' \
+                          "#{endpoint.inspect} already exists"
+    end
+
+    # Checks that the specified name and endpoint are available for use.
+    #
+    # @param name [String] the name to check for
+    # @param endpoint [String] the endpoint to check for
+    # @raise [CommandError] if name or endpoint are already taken
+    def check_available!(name, endpoint)
+      check_name_available!(name) unless name.nil?
+      check_endpoint_available!(endpoint) unless endpoint.nil?
+    end
+
+    # Checks that the specified name and endpoint are available for use by the
+    # specified integration.
+    #
+    # @param name [String] the name to check for
+    # @param endpoint [String] the endpoint to check for
+    # @param intg [Integration] the integration to ignore
+    # @raise [CommandError] if name or endpoint are already taken
+    def check_available_except!(name, endpoint, intg)
+      check_name_available!(name) unless name.nil? || intg.name_eql?(name)
+      return if endpoint.nil? || intg.endpoint_eql?(endpoint)
+
+      check_endpoint_available!(endpoint)
+    end
+
+    # Updates the channels associated with an integration from the specified
+    # parameters.
+    #
+    # @param integration [Integration] the integration
+    # @param params [Hash] the parameters to update the integration with. Valid
+    #                      keys are +:clear_channels+ to clear the channel list
+    #                      before proceeding, +:add_channel+ to add the given
+    #                      channels, and +:delete_channel+ to delete the given
+    #                      channels from the integration. All keys are optional.
+    #                      The value of +:clear_channels+ should be a boolean.
+    #                      The value of +:add_channel+ should be a hash of the
+    #                      form +identifier => params+, and +:remove_channel+
+    #                      should be an array of channel identifiers to remove.
+    def update_channels!(integration, params)
+      integration.channels.clear if params[:clear_channels]
+      if params[:delete_channel]
+        integration.delete_channels!(params[:delete_channel])
+      end
+      return unless params[:add_channel]
+
+      integration.add_channels!(params[:add_channel],
+                                networks: @config.networks)
+    end
+
+    # Displays feedback about a change made to an integration.
+    #
+    # @param integration [Integration] the integration
+    # @param action [#to_s] the action (+:created+, +:updated+ or +:destroyed+)
+    def integration_feedback(integration, action)
+      puts "Integration was successfully #{action}"
+      show_integration(integration)
+    end
+
+    # Prints information about an integration.
+    #
+    # @param integration [Integration] the integration
+    def show_integration(integration)
+      puts "Integration: #{integration.name}"
+      puts "\tEndpoint: #{integration.endpoint}"
+      puts "\tSecret:   #{show_integration_secret(integration)}"
+      if integration.channels.empty?
+        puts "\tChannels: (none)"
+      else
+        puts "\tChannels:"
+        show_integration_channels(integration)
+      end
+    end
+
+    # Returns an integration secret, or "(none required)" if payload integrity
+    # verification is disabled.
+    #
+    # @param integration [Integration] the integration
+    # @return [String] the secret or placeholder
+    def show_integration_secret(integration)
+      return '(none required)' unless integration.verify_payloads?
+
+      integration.secret.to_s
+    end
+
+    # Prints information about the channels associated with an integration.
+    #
+    # @param integration [Integration] the integration
+    def show_integration_channels(integration)
+      integration.channels.each do |channel|
+        puts "\t\t- #{channel.name} on #{channel.network.name}"
+        puts "\t\t\tKey: #{channel.key}" if channel.key?
+        puts "\t\t\tMessages are sent without joining" if channel.send_external
+      end
+    end
+  end
+end

data/lib/codebot/ipc_client.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'timeout'
+
+module Codebot
+  # A pipe-based IPC client used for communicating with a running Codebot
+  # instance.
+  class IPCClient
+    # @return [String] the path to the named pipe
+    attr_reader :pipe
+
+    # Creates a new IPC client.
+    #
+    # @param pipe [String] the path to the named pipe, or +nil+ to use the
+    #                      default pipe for this user
+    def initialize(pipe = nil)
+      @pipe = pipe || IPCServer.default_pipe
+    end
+
+    # Sends a REHASH command to the named pipe.
+    #
+    # @param explicit [Boolean] whether this command was invoked explicitly
+    def send_rehash(explicit = true)
+      command('REHASH', explicit)
+    end
+
+    # Sends a STOP command to the named pipe.
+    #
+    # @param explicit [Boolean] whether this command was invoked explicitly
+    def send_stop(explicit = true)
+      command('STOP', explicit)
+    end
+
+    # Checks whether the named pipe exists.
+    #
+    # @return [Boolean] +true+ if the pipe exists, +false+ otherwise
+    def pipe_exist?
+      File.pipe? @pipe
+    end
+
+    private
+
+    # Sends a command to the named pipe.
+    #
+    # @param cmd [String] the command
+    # @param explicit [Boolean] whether this command was invoked explicitly
+    # @return [Boolean] whether the command was sent successfully
+    def command(cmd, explicit)
+      return false unless check_pipe_exist(explicit)
+
+      Timeout.timeout 5 do
+        File.open @pipe, 'w' do |p|
+          p.puts cmd
+        end
+      end
+      true
+    rescue Timeout::Error
+      communication_error! 'no response'
+    end
+
+    # Checks whether the named pipe exists.
+    #
+    # @param should_raise [Boolean] whether to raise an exception if the pipe
+    #                               does not exist
+    # @return [Boolean] +true+ if the pipe exists, +false+ otherwise
+    def check_pipe_exist(should_raise)
+      return true if pipe_exist?
+
+      communication_error! "missing pipe #{@pipe.inspect}" if should_raise
+      false
+    end
+
+    # Raise a {CommandError} with a message stating that communication with
+    # an active instance failed.
+    #
+    # @param msg [String] the error message
+    # @raise [CommandError] the requested error
+    def communication_error!(msg)
+      raise CommandError, "unable to communicate with the bot: #{msg} " \
+                          '(is the bot running?)'
+    end
+  end
+end

data/lib/codebot/ipc_server.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Codebot
+  # A pipe-based IPC server used for communicating with a running Codebot
+  # instance.
+  class IPCServer < ThreadController
+    # @return [Core] the bot this server belongs to
+    attr_reader :core
+
+    # @return [String] the path to the named pipe
+    attr_reader :pipe
+
+    # Creates a new IPC server.
+    #
+    # @param core [Core] the bot this server belongs to
+    # @param pipe [String] the path to the named pipe, or +nil+ to use the
+    #                      default pipe for this user
+    def initialize(core, pipe = nil)
+      super()
+      @core = core
+      @pipe = pipe || self.class.default_pipe
+    end
+
+    # Stops the managed thread if a thread is currently running, then deletes
+    # the named pipe.
+    #
+    # @return [Thread, nil] the stopped thread, or +nil+ if
+    #                       no thread was running
+    def stop
+      thr = super
+      delete_pipe
+      thr
+    end
+
+    # Returns the path to the default pipe for the current user.
+    #
+    # @return [String] the path to the named pipe
+    def self.default_pipe
+      File.join Dir.home, '.codebot.ipc'
+    end
+
+    private
+
+    # Creates the named pipe.
+    def create_pipe
+      return if File.pipe? @pipe
+
+      delete_pipe
+      File.mkfifo @pipe
+    end
+
+    # Deletes the named pipe.
+    def delete_pipe
+      File.delete @pipe if File.exist? @pipe
+    end
+
+    # Starts this IPC server.
+    def run(*)
+      create_pipe
+      file = File.open @pipe, 'r+'
+      while (line = file.gets.strip)
+        handle_command line
+      end
+    ensure
+      delete_pipe
+    end
+
+    # Handles an incoming IPC command.
+    #
+    # @param command [String] the command
+    def handle_command(command)
+      case command
+      when 'REHASH'  then @core.config.load!
+      when 'STOP'    then Thread.new { @core.stop }
+      else STDERR.puts "Unknown IPC command: #{command.inspect}"
+      end
+    end
+  end
+end

data/lib/codebot/irc_client.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'codebot/irc_connection'
+
+module Codebot
+  # This class manages an IRC client.
+  class IRCClient
+    # Creates a new IRC client.
+    #
+    # @param core [Core] the bot this client belongs to
+    def initialize(core)
+      @active = false
+      @checkpoint = []
+      @connections = []
+      @core = core
+      @semaphore = Mutex.new
+    end
+
+    # Dispatches a new request.
+    #
+    # @param request [Request] the request to dispatch
+    def dispatch(request)
+      request.each_network do |network, channels|
+        connection = connection_to(network)
+        next if connection.nil?
+
+        channels.each do |channel|
+          message = request.to_message_for channel
+          connection.enqueue message
+        end
+      end
+    end
+
+    # Starts the IRC client.
+    def start
+      @active = true
+      migrate!
+    end
+
+    # Stops the IRC client.
+    def stop
+      @active = false
+      @checkpoint.clear
+      @connections.each(&:stop)
+      join
+      @connections.clear
+    end
+
+    # Waits for active connections to finish.
+    def join
+      @connections.each(&:join)
+    end
+
+    # Connects to and disconnects from networks as necessary in order for the
+    # list of connections to reflect changes to the configuration.
+    def migrate!
+      @semaphore.synchronize do
+        return unless @active
+
+        networks = @core.config.networks
+        (@checkpoint - networks).each { |network| disconnect_from network }
+        (networks - @checkpoint).each { |network| connect_to      network }
+        @checkpoint = networks
+      end
+    end
+
+    private
+
+    # Finds the connection to a given network.
+    #
+    # @param network [Network] the network
+    # @return [IRCConnection, nil] the connection, or +nil+ if none was found
+    def connection_to(network)
+      @connections.find { |con| con.network.eql? network }
+    end
+
+    # Checks whether the client is connected to a given network.
+    #
+    # @param network [Network] the network
+    # @return [Boolean] +true+ if the client is connected, +false+ otherwise
+    def connected_to?(network)
+      !connection_to(network).nil?
+    end
+
+    # Connects to a given network if the same network is not already connected.
+    #
+    # @param network [Network] the network to connect to
+    def connect_to(network)
+      return if connected_to? network
+
+      @connections << IRCConnection.new(@core, network).tap(&:start)
+    end
+
+    # Disconnects from a given network if the network is currently connected.
+    #
+    # @param network [Network] the network to disconnected from
+    def disconnect_from(network)
+      connection = @connections.delete connection_to(network)
+      connection.tap(&:stop).tap(&:join) unless connection.nil?
+    end
+  end
+end