blur 1.8.6 → 2.1.6

data/library/blur/network/connection.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module Blur
   class Network
@@ -13,14 +13,23 @@ module Blur
     class Connection < EM::Protocols::LineAndTextProtocol
       SSLValidationError = Class.new StandardError
 
+      # @return [Float] the default connection timeout interval in seconds.
+      DEFAULT_CONNECT_TIMEOUT_INTERVAL = 30
+
       # Check whether or not connection is established.
-      def established?; @connected == true end
+      def established?
+        @connected == true
+      end
 
       # EventMachine instantiates this class, and then sends event messages to
       # that instance.
       def initialize network
         @network = network
         @connected = false
+        connect_timeout = network.options.fetch 'connect_timeout',
+                                                DEFAULT_CONNECT_TIMEOUT_INTERVAL
+
+        self.pending_connect_timeout = connect_timeout
 
         super
       end
@@ -28,19 +37,18 @@ module Blur
       # Called when a new connection is being set up, all we're going to use
       # it for is to enable SSL/TLS on our connection.
       def post_init
-        if @network.secure?
-          verify_peer = (@network.options[:ssl_no_verify] ? false : true)
+        return unless @network.secure?
 
-          start_tls verify_peer: verify_peer
-        end
+        verify_peer = (@network.options[:ssl_no_verify] ? false : true)
+        start_tls verify_peer: verify_peer
       end
 
       # Called when a line was received, the connection sends it to the network
       # delegate which then sends it to the client.
       def receive_line line
-        command = Command.parse line
+        message = IRCParser::Message.parse line
 
-        @network.got_command command
+        @network.got_message message
       end
 
       # Called when the SSL handshake was completed with the remote server,
@@ -61,12 +69,8 @@ module Blur
         ssl_cert_file    = @network.options[:ssl_cert_file]
         peer_certificate = OpenSSL::X509::Certificate.new peer_cert
 
-        if ssl_cert_file
-          unless File.readable? ssl_cert_file
-            raise SSLValidationError, "Could not read the CA certificate file."
-
-            return false
-          end
+        if ssl_cert_file && !File.readable?(ssl_cert_file)
+          raise SSLValidationError, 'Could not read the CA certificate file.'
         end
 
         if fingerprint_verification?
@@ -75,9 +79,7 @@ module Blur
 
           if fingerprint != peer_fingerprint
             raise SSLValidationError,
-              "Expected fingerprint '#{fingerprint}', but got '#{peer_fingerprint}'"
-
-            return false
+                  "Expected fingerprint '#{fingerprint}', but got '#{peer_fingerprint}'"
           end
         end
 
@@ -85,11 +87,7 @@ module Blur
           ca_certificate = OpenSSL::X509::Certificate.new File.read ssl_cert_file
           valid_signature = peer_certificate.verify ca_certificate.public_key
 
-          if not valid_signature
-            raise SSLValidationError, "Certificate verify failed"
-
-            return false
-          end
+          raise SSLValidationError, 'Certificate verify failed' unless valid_signature
         end
 
         true
@@ -98,9 +96,7 @@ module Blur
       # Called once the connection is finally established.
       def connection_completed
         # We aren't completely connected yet if the connection is encrypted.
-        unless @network.secure?
-          connected!
-        end
+        connected! unless @network.secure?
       end
 
       # Called just as the connection is being terminated, either by remote or
@@ -112,7 +108,8 @@ module Blur
         super
       end
 
-    private
+      private
+
       # Called when connection has been established.
       def connected!
         @connected = true
@@ -122,12 +119,12 @@ module Blur
 
       # Returns true if we're expected to verify the certificate fingerprint.
       def fingerprint_verification?
-        not @network.options[:ssl_fingerprint].nil?
+        !@network.options[:ssl_fingerprint].nil?
       end
 
       # Returns true if we should verify the peer certificate.
       def certificate_verification?
-        not @network.options[:ssl_cert_file].nil?
+        !@network.options[:ssl_cert_file].nil?
       end
 
       # Get the hexadecimal representation of the certificates public key.
@@ -143,9 +140,8 @@ module Blur
         fingerprint = @network.options[:ssl_fingerprint]
 
         raise SSLValidationError,
-          "Expected fingerprint '#{fingerprint}' but got '#{peer_fingerprint}'"
+              "Expected fingerprint '#{fingerprint}' but got '#{peer_fingerprint}'"
       end
-
     end
   end
 end

data/library/blur/network/isupport.rb

@@ -1,20 +1,22 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
+require 'English'
 
 module Blur
   class Network
     # ISupport class that enables servers to announce what they support.
-    # 
+    #
     # @see https://tools.ietf.org/html/draft-brocklesby-irc-isupport-03
     class ISupport < Hash
       # Return the network reference.
       attr_accessor :network
 
       # ISUPPORT parameters which should always be casted to numeric values.
-      NumericParams = %w[CHANNELLEN MODES NICKLEN KICKLEN TOPICLEN AWAYLEN
-        MAXCHANNELS MAXBANS MAXPARA MAXTARGETS].freeze
+      NUMERIC_PARAMS = %w[CHANNELLEN MODES NICKLEN KICKLEN TOPICLEN AWAYLEN
+                          MAXCHANNELS MAXBANS MAXPARA MAXTARGETS].freeze
 
       # Our parsers for parameters that require special treatment.
-      Parsers = {
+      PARSERS = {
         # CHANLIMIT=pfx:num[,pfx:num,...]
         #
         # This parameter specifies the maximum number of channels that a client
@@ -24,10 +26,10 @@ module Blur
         # the client may join in total. If there is no limit to the number of
         # certain channel type(s) a client may join, the limit should be
         # specified as the empty string, for example "#:".
-        %w[CHANLIMIT] => -> (value) do
-          Hash.new.tap do |result|
-            params = value.split ?,
-            mappings = params.map{|param| param.split ?: }
+        %w[CHANLIMIT] => lambda do |value|
+          {}.tap do |result|
+            params = value.split ','
+            mappings = params.map { |param| param.split ':' }
 
             mappings.each do |prefixes, limit|
               prefixes.each_char do |prefix|
@@ -48,10 +50,12 @@ module Blur
         #
         # The order of the modes is from that which gives most privileges on
         #  the channel, to that which gives the least.
-        %w[PREFIX] => -> (value) do
-          Hash.new.tap do |result|
-            if value =~ /^\((.+)\)(.*)/
-              modes, prefix = $~[1..2]
+        %w[PREFIX] => lambda do |value|
+          {}.tap do |result|
+            match = value.match(/^\((.+)\)(.*)/)
+
+            if match
+              modes, prefix = match[1..2]
 
               modes.chars.each_with_index do |char, index|
                 result[char] = prefix[index]
@@ -77,39 +81,41 @@ module Blur
         #    mode is removed both in the client's and server's MODE command.
         # o  Type D: Modes that change a setting on the channel. These modes
         #    never take a parameter.
-        %w[CHANMODES] => -> (value) do
-          Hash.new.tap do |r|
-            r["A"], r["B"], r["C"], r["D"] = value.split(?,).map &:chars
+        %w[CHANMODES] => lambda do |value|
+          {}.tap do |r|
+            r['A'], r['B'], r['C'], r['D'] = value.split(',').map &:chars
           end
         end,
 
         # Cast known params that are numeric, to a numeric value.
-        NumericParams => -> (value) do
+        NUMERIC_PARAMS => lambda do |value|
           value.to_i
         end
-      }
+      }.freeze
 
       # Initialize a new ISupport with a network reference.
-      # 
+      #
       # @param network [Network] The parent network.
       def initialize network
+        super
+
         @network = network
 
         # Set default ISUPPORT values.
         #
         # @see
         # https://tools.ietf.org/html/draft-brocklesby-irc-isupport-03#appendix-A
-        self["MODES"]       = 3
-        self["PREFIX"]      = { "o" => "@", "v" => "+" }
-        self["KICKLEN"]     = 200
-        self["NICKLEN"]     = 9
-        self["MAXLIST"]     = { "#" => Float::INFINITY, "&" => Float::INFINITY }
+        self['MODES']       = 3
+        self['PREFIX']      = { 'o' => '@', 'v' => '+' }
+        self['KICKLEN']     = 200
+        self['NICKLEN']     = 9
+        self['MAXLIST']     = { '#' => Float::INFINITY, '&' => Float::INFINITY }
         self['TOPICLEN']    = 200
-        self["CHANMODES"]   = {}
-        self["CHANTYPES"]   = %w{# &}
-        self["CHANLIMIT"]   = { "#" => Float::INFINITY, "&" => Float::INFINITY }
-        self["CHANNELLEN"]  = 200
-        self["CASEMAPPING"] = "rfc1459"
+        self['CHANMODES']   = {}
+        self['CHANTYPES']   = %w[# &]
+        self['CHANLIMIT']   = { '#' => Float::INFINITY, '&' => Float::INFINITY }
+        self['CHANNELLEN']  = 200
+        self['CASEMAPPING'] = 'rfc1459'
       end
 
       # Parse a list of parameters to see what the server supports.
@@ -117,12 +123,12 @@ module Blur
       # @param parameters [Array] The list of parameters.
       def parse *params
         params.each do |parameter|
-          name, value = parameter.split ?=
+          name, value = parameter.split '='
 
           if value
-            _, parser = Parsers.find{|key, value| key.include? name }
+            _, parser = PARSERS.find { |key, _value| key.include? name }
 
-            self[name] = parser.nil? ? value : parser.(value)
+            self[name] = parser.nil? ? value : parser.call(value)
           else
             self[name] = true
           end

data/library/blur/network.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module Blur
   # The +Network+ module is to be percieved as an IRC network.
@@ -6,44 +6,81 @@ module Blur
   # Although the connection is a part of the network module, it is mainly used
   # for network-related structures, such as {User}, {Channel} and {Command}.
   class Network
-    include Logging
-    
     # +ConnectionError+ should only be triggered from within {Connection}.
     class ConnectionError < StandardError; end
 
+    DEFAULT_PING_INTERVAL = 30
+    DEFAULT_RECONNECT = true
+
+    # Returns a unique identifier for this network.
+    #
+    # You can override the id in your network configuration by setting an 'id'
+    # key with the id you want.. If no id is specified, the the id will be
+    # constructed from the hostname and port number
+    # in the format "<host>:<port>"
+    #
+    # @return [String] the unique identifier for this network.
+    attr_reader :id
+    # @return [String] the current nickname.
+    attr_accessor :nickname
     # @return [Hash] the network options.
     attr_accessor :options
-    # @return [Array] the list of channels the client is in.
+    # @return [Hash] the map of users that is known.
+    attr_accessor :users
+    # @return [Hash] the map of channels the client is in.
     attr_accessor :channels
-    # @return [Array] the list of private messages the client remembers.
-    attr_accessor :dialogues
-    # @return [Client] the client delegate.
-    attr_accessor :delegate
+    # @return [Client] the client reference.
+    attr_accessor :client
     # @return [Network::Connection] the connection instance.
     attr_accessor :connection
     # @return [Network::ISupport] the network isupport specs.
     attr_accessor :isupport
+    # @return [Array<String>] list of capabilities supported by the network.
+    attr_accessor :capabilities
+    # @return [Boolean] true if we're waiting for a capability negotiation.
+    attr_reader :waiting_for_cap
+    # @return [Time] the last time a pong was sent or received.
+    attr_accessor :last_pong_time
+    # The max PING interval for the server. This is used to determine when the
+    # client will attempt to send its own PING command.
+    #
+    # @note the actual time until a client PING is sent can vary by an
+    #   additional 0-30 seconds.
+    # @return [Number] the max interval between pings from a server.
+    attr_accessor :server_ping_interval_max
 
     # Check whether or not connection is established.
-    def connected?; @connection and @connection.established? end
+    def connected?
+      @connection&.established?
+    end
 
     # Get the remote hostname.
     #
     # @return [String] the remote hostname.
-    def host; @options[:hostname] end
+    def host
+      @options['hostname']
+    end
 
     # Get the remote port.
     # If no port is specified, it returns 6697 if using a secure connection,
     # returns 6667 otherwise.
     #
     # @return [Fixnum] the remote port
-    def port; @options[:port] ||= secure? ? 6697 : 6667 end
-    
+    def port
+      @options['port'] ||= secure? ? 6697 : 6667
+    end
+
     # Check to see if it's a secure connection.
-    def secure?; @options[:secure] == true end
+    def secure?
+      @options['secure'] == true
+    end
 
-    # Check to see if FiSH encryption is enabled.
-    def fish?; not @options[:fish].nil? end
+    # @return [Boolean] whether we want to authenticate with SASL.
+    def sasl?
+      @options['sasl'] &&
+        @options['sasl']['username'] &&
+        @options['sasl']['password']
+    end
 
     # Instantiates the network.
     #
@@ -54,51 +91,64 @@ module Blur
     # @option options [optional, String] :username (Copies :nickname)
     #   The username to use. This is also known as the ident.
     # @option options [optional, String] :realname (Copies :username)
-    #   The “real name” that we want to use. This is usually what shows up
+    #   The "real name" that we want to use. This is usually what shows up
     #   as "Name" when you whois a user.
     # @option options [optional, String] :password The password for the network.
     #   This is sometimes needed for private networks.
-    # @option options [optional, Fixnum] :port (6697 if ssl, otherwise 6667) 
+    # @option options [optional, Fixnum] :port (6697 if ssl, otherwise 6667)
     #   The remote port we want to connect to.
     # @option options [optional, Boolean] :secure Set whether this is a secure
     #   (SSL-encrypted) connection.
     # @option options [optional, String] :ssl_cert_file Local path of a
     #   readable file that contains a X509 CA certificate to validate against.
-    # @option options [optional, String] :ssl_fingerprint Validate that the 
+    # @option options [optional, String] :ssl_fingerprint Validate that the
     #   remote certificate matches the specified fingerprint.
     # @option options [optional, Boolean] :ssl_no_verify Disable verification
     #   alltogether.
-    def initialize options
-      @options  = options
-      @channels = []
+    def initialize options, client = nil
+      @client = client
+      @options = options
+      # @log = ::Logging.logger[self]
+      @users = {}
+      @channels = {}
       @isupport = ISupport.new self
-      
-      unless options[:nickname]
-        raise ArgumentError, "nickname is missing from the networks option block"
+      @capabilities = []
+      @reconnect_interval = 3
+      @server_ping_interval_max = @options.fetch('server_ping_interval',
+                                                 150).to_i
+
+      unless options['nickname']
+        raise ArgumentError, 'Network configuration for ' \
+          "`#{id}' is missing a nickname"
       end
-      
-      @options[:username] ||= @options[:nickname]
-      @options[:realname] ||= @options[:username]
-      @options[:channels] ||= []
+
+      @nickname = options['nickname']
+      @options['username'] ||= @options['nickname']
+      @options['realname'] ||= @options['username']
+      @options['channels'] ||= []
+      @id = options.fetch 'id', "#{host}:#{port}"
     end
-    
+
     # Send a message to a recipient.
     #
     # @param [String, #to_s] recipient the recipient.
     # @param [String] message the message.
     def say recipient, message
-      if recipient.is_a? Channel and recipient.encrypted?
-        message = "+OK #{recipient.encryption.encrypt message}"
-      end
-
       transmit :PRIVMSG, recipient.to_s, message
     end
-    
+
+    # Forwards the received message to the client instance.
+    #
     # Called when the network connection has enough data to form a command.
-    def got_command command
-      @delegate.got_command self, command
+    def got_message message
+      @client.got_message self, message
+    rescue StandardError => e
+      puts "#{e.class}: #{e.message}"
+      puts
+      puts '---'
+      puts e.backtrace
     end
-    
+
     # Find a channel by its name.
     #
     # @param [String] name the channel name.
@@ -106,7 +156,7 @@ module Blur
     def channel_by_name name
       @channels.find { |channel| channel.name == name }
     end
-    
+
     # Find all instances of channels in which there is a user with the nick
     # +nick+.
     #
@@ -120,65 +170,153 @@ module Blur
     #
     # @return [Array<String>] a list of user prefixes.
     def user_prefixes
-      isupport["PREFIX"].values
+      isupport['PREFIX'].values
     end
 
     # Returns a list of user modes that also gives a users nick a prefix.
     #
     # @return [Array<String>] a list of user modes.
     def user_prefix_modes
-      isupport["PREFIX"].keys
+      isupport['PREFIX'].keys
     end
 
     # Returns a list of channel flags (channel mode D).
     #
     # @return [Array<String>] a list of channel flags.
     def channel_flags
-      isupport["CHANMODES"]["D"]
+      isupport['CHANMODES']['D']
     end
 
     # Attempt to establish a connection and send initial data.
     #
     # @see Connection
     def connect
-      @connection = EventMachine.connect host, port, Connection, self
+      # @log.info "Connecting to #{self}"
+
+      begin
+        @connection = EventMachine.connect host, port, Connection, self
+      rescue EventMachine::ConnectionError => e
+        warn "Establishing connection to #{self} failed!"
+        warn e.message
+
+        schedule_reconnect
+        return
+      end
+
+      @ping_timer = EventMachine.add_periodic_timer DEFAULT_PING_INTERVAL do
+        periodic_ping_check
+      end
+    end
+
+    # Schedules a reconnect after a user-specified number of seconds.
+    def schedule_reconnect
+      # @log.info "Reconnecting to #{self} in #{@reconnect_interval} seconds"
+
+      EventMachine.add_timer @reconnect_interval do
+        connect
+      end
+    end
+
+    def server_connection_timeout
+      @connection.close_connection
+
+      warn "Connection to #{self} timed out"
+    end
+
+    def periodic_ping_check
+      now = Time.now
+      seconds_since_pong = now - @last_pong_time
+
+      return unless seconds_since_pong >= @server_ping_interval_max
+
+      # @log.info "No PING request from the server in #{seconds_since_pong}s!"
+
+      transmit 'PING', now.to_s
+
+      # Wait 15 seconds and declare a timeout if we didn't get a PONG.
+      previous_pong_time = @last_pong_time.dup
+
+      EventMachine.add_timer 15 do
+        server_connection_timeout if @last_pong_time == previous_pong_time
+      end
     end
 
     # Called when the connection was successfully established.
     def connected!
-      transmit :PASS, @options[:password] if @options[:password]
-      transmit :NICK, @options[:nickname]
-      transmit :USER, @options[:username], :void, :void, @options[:realname]
+      @waiting_for_cap = true
+      @capabilities.clear
+
+      transmit :CAP, 'LS'
+      transmit :PASS, @options['password'] if @options['password']
+      transmit :NICK, @options['nickname']
+      transmit :USER, @options['username'], 'void', 'void', @options['realname']
+
+      @last_pong_time = Time.now
+    end
+
+    # Called when the server doesn't support capability negotiation.
+    def abort_cap_neg
+      @waiting_for_cap = false
+
+      puts 'Server does not support capability negotiation'
+    end
+
+    # Called when we're done with capability negotiation.
+    def cap_end
+      @waiting_for_cap = false
+
+      transmit :CAP, 'END'
     end
 
     # Called when the connection was closed.
     def disconnected!
-      @channels.each { |channel| channel.users.clear }
+      @channels.each { |_, channel| channel.users.clear }
       @channels.clear
+      @users.clear
+      @ping_timer.cancel
+
+      # @log.debug "Connection to #{self} lost!"
+      @client.network_connection_closed self
 
-      @delegate.network_connection_closed self
+      return unless @options.fetch('reconnect', DEFAULT_RECONNECT)
+
+      schedule_reconnect
     end
-    
+
     # Terminate the connection and clear all channels and users.
     def disconnect
       @connection.close_connection_after_writing
     end
-    
+
     # Transmit a command to the server.
     #
     # @param [Symbol, String] name the command name.
     # @param [...] arguments all the prepended parameters.
     def transmit name, *arguments
-      command = Command.new name, arguments
-      log "#{'→' ^ :red} #{command.name.to_s.ljust(8, ' ') ^ :light_gray} #{command.params.map(&:inspect).join ' '}"
-      
-      @connection.send_data "#{command}\r\n"
+      message = IRCParser::Message.new command: name.to_s, parameters: arguments
+
+      if @client.verbose
+        formatted_command = message.command.to_s.ljust 8, ' '
+        formatted_params = message.parameters.map(&:inspect).join ' '
+        puts "→ #{formatted_command} #{formatted_params}"
+      end
+
+      @connection.send_data "#{message}\r\n"
+    end
+
+    # Send a private message.
+    def send_privmsg recipient, message
+      transmit :PRIVMSG, recipient, message
+    end
+
+    # Join a channel.
+    def join channel
+      transmit :JOIN, channel
     end
 
-    
     # Convert it to a debug-friendly format.
     def to_s
-      %{#<#{self.class.name} "#{host}":#{port}>}
+      %(#<#{self.class.name} "#{host}":#{port}>)
     end
   end
 end