feat: irc reconnect (#148)

* chore: add and update deps

* feat(irc): change lib add reconnect

* feat: remove irc caps

* feat: add sleep fix irc stop restart

internal/irc/handler.go

@@ -1,22 +1,22 @@
 package irc
 
 import (
-	"context"
 	"crypto/tls"
-	"errors"
 	"fmt"
-	"net"
 	"regexp"
 	"strings"
+	"sync"
 	"time"
 
 	"github.com/autobrr/autobrr/internal/announce"
 	"github.com/autobrr/autobrr/internal/domain"
 	"github.com/autobrr/autobrr/internal/filter"
+	"github.com/autobrr/autobrr/internal/logger"
 	"github.com/autobrr/autobrr/internal/release"
 
+	"github.com/ergochat/irc-go/ircevent"
+	"github.com/ergochat/irc-go/ircmsg"
 	"github.com/rs/zerolog/log"
-	"gopkg.in/irc.v3"
 )
 
 var (
@@ -24,6 +24,8 @@ var (
 )
 
 type channelHealth struct {
+	m sync.RWMutex
+
 	name            string
 	monitoring      bool
 	monitoringSince time.Time
@@ -32,19 +34,25 @@ type channelHealth struct {
 
 // SetLastAnnounce set last announce to now
 func (h *channelHealth) SetLastAnnounce() {
+	h.m.Lock()
 	h.lastAnnounce = time.Now()
+	h.m.Unlock()
 }
 
 // SetMonitoring set monitoring and time
 func (h *channelHealth) SetMonitoring() {
+	h.m.Lock()
 	h.monitoring = true
 	h.monitoringSince = time.Now()
+	h.m.Unlock()
 }
 
 // resetMonitoring remove monitoring and time
 func (h *channelHealth) resetMonitoring() {
+	h.m.Lock()
 	h.monitoring = false
 	h.monitoringSince = time.Time{}
+	h.m.Unlock()
 }
 
 type Handler struct {
@@ -54,11 +62,8 @@ type Handler struct {
 	announceProcessors map[string]announce.Processor
 	definitions        map[string]*domain.IndexerDefinition
 
-	client  *irc.Client
-	conn    net.Conn
-	ctx     context.Context
-	stopped chan struct{}
-	cancel  context.CancelFunc
+	client *ircevent.Connection
+	m      sync.RWMutex
 
 	lastPing       time.Time
 	connected      bool
@@ -73,9 +78,6 @@ type Handler struct {
 func NewHandler(network domain.IrcNetwork, filterService filter.Service, releaseService release.Service, definitions []domain.IndexerDefinition) *Handler {
 	h := &Handler{
 		client:             nil,
-		conn:               nil,
-		ctx:                nil,
-		stopped:            make(chan struct{}),
 		network:            &network,
 		filterService:      filterService,
 		releaseService:     releaseService,
@@ -102,7 +104,7 @@ func (h *Handler) InitIndexers(definitions []domain.IndexerDefinition) {
 
 		h.definitions[definition.Identifier] = &definition
 
-		// indexers can use multiple channels, but it'h not common, but let'h handle that anyway.
+		// indexers can use multiple channels, but it's not common, but let's handle that anyway.
 		for _, channel := range definition.IRC.Channels {
 			// some channels are defined in mixed case
 			channel = strings.ToLower(channel)
@@ -133,177 +135,66 @@ func (h *Handler) removeIndexer() {
 }
 
 func (h *Handler) Run() error {
-	//log.Debug().Msgf("server %+v", h.network)
+	addr := fmt.Sprintf("%v:%d", h.network.Server, h.network.Port)
 
-	if h.network.Server == "" {
-		return errors.New("addr not set")
+	h.client = &ircevent.Connection{
+		Nick:          h.network.NickServ.Account,
+		User:          h.network.NickServ.Account,
+		RealName:      h.network.NickServ.Account,
+		Password:      h.network.Pass,
+		Server:        addr,
+		KeepAlive:     4 * time.Minute,
+		Timeout:       1 * time.Minute,
+		ReconnectFreq: 15 * time.Second,
+		Version:       "autobrr",
+		QuitMessage:   "bye from autobrr",
+		Debug:         true,
+		Log:           logger.StdLeveledLogger,
 	}
 
-	ctx, cancel := context.WithCancel(context.Background())
-	h.ctx = ctx
-	h.cancel = cancel
-
-	dialer := net.Dialer{
-		Timeout: connectTimeout,
-	}
-
-	var netConn net.Conn
-	var err error
-
-	addr := fmt.Sprintf("%v:%v", h.network.Server, h.network.Port)
-
-	// decide to use SSL or not
 	if h.network.TLS {
-		tlsConf := &tls.Config{
-			InsecureSkipVerify: true,
-		}
-
-		netConn, err = dialer.DialContext(h.ctx, "tcp", addr)
-		if err != nil {
-			log.Error().Err(err).Msgf("failed to dial %v", addr)
-			return fmt.Errorf("failed to dial %q: %v", addr, err)
-		}
-
-		netConn = tls.Client(netConn, tlsConf)
-		h.conn = netConn
-	} else {
-		netConn, err = dialer.DialContext(h.ctx, "tcp", addr)
-		if err != nil {
-			log.Error().Err(err).Msgf("failed to dial %v", addr)
-			return fmt.Errorf("failed to dial %q: %v", addr, err)
-		}
-
-		h.conn = netConn
+		h.client.UseTLS = true
+		h.client.TLSConfig = &tls.Config{InsecureSkipVerify: true}
 	}
 
-	log.Info().Msgf("Connected to: %v", addr)
+	h.client.AddConnectCallback(h.onConnect)
+	h.client.AddCallback("MODE", h.handleMode)
+	h.client.AddCallback("INVITE", h.handleInvite)
+	h.client.AddCallback("366", h.handleJoined)
+	h.client.AddCallback("PART", h.handlePart)
+	h.client.AddCallback("PRIVMSG", h.onMessage)
 
-	config := irc.ClientConfig{
-		Nick:    h.network.NickServ.Account,
-		User:    h.network.NickServ.Account,
-		Name:    h.network.NickServ.Account,
-		Pass:    h.network.Pass,
-		Handler: irc.HandlerFunc(h.handleMessage),
-	}
-
-	// Create the client
-	client := irc.NewClient(h.conn, config)
-
-	h.client = client
-
-	// set connected since now
-	h.setConnectionStatus()
-
-	// Connect
-	err = client.RunContext(ctx)
-	if err != nil {
-		log.Error().Err(err).Msgf("could not connect to %v", addr)
+	if err := h.client.Connect(); err != nil {
+		log.Error().Stack().Err(err).Msgf("%v: connect error", h.network.Server)
 
 		// reset connection status on handler and channels
 		h.resetConnectionStatus()
 
-		return err
+		//return err
 	}
 
+	// set connected since now
+	h.setConnectionStatus()
+
+	h.client.Loop()
+
 	return nil
 }
 
-func (h *Handler) handleMessage(c *irc.Client, m *irc.Message) {
-	switch m.Command {
-	case "001":
-		// 001 is a welcome event, so we join channels there
-		err := h.onConnect(h.network.Channels)
-		if err != nil {
-			log.Error().Msgf("error joining channels %v", err)
-		}
-
-	case "372", "375", "376":
-		// Handle MOTD
-
-	// 322 TOPIC
-	// 333 UP
-	// 353 @
-	// 396 Displayed host
-	case "366": // JOINED
-		h.handleJoined(m)
-
-	case "JOIN":
-		if h.isOurNick(m.Prefix.Name) {
-			log.Trace().Msgf("%v: JOIN %v", h.network.Server, m)
-		}
-
-	case "QUIT":
-		if h.isOurNick(m.Prefix.Name) {
-			log.Trace().Msgf("%v: QUIT %v", h.network.Server, m)
-		}
-
-	case "433":
-		// TODO: handle nick in use
-		log.Debug().Msgf("%v: NICK IN USE: %v", h.network.Server, m)
-
-	case "448", "473", "475", "477":
-		// TODO: handle join failed
-		log.Debug().Msgf("%v: JOIN FAILED %v: %v", h.network.Server, m.Params[1], m)
-
-	case "900": // Invite bot logged in
-		log.Debug().Msgf("%v: %v", h.network.Server, m.Trailing())
-
-	case "KICK":
-		log.Debug().Msgf("%v: KICK: %v", h.network.Server, m)
-
-	case "MODE":
-		err := h.handleMode(m)
-		if err != nil {
-			log.Error().Err(err).Msgf("error MODE change: %v", m)
-		}
-
-	case "INVITE":
-		// TODO: handle invite
-		log.Debug().Msgf("%v: INVITE: %v", h.network.Server, m)
-
-	case "PART":
-		// TODO: handle parted
-		if h.isOurNick(m.Prefix.Name) {
-			log.Debug().Msgf("%v: PART: %v", h.network.Server, m)
-		}
-
-	case "PRIVMSG":
-		err := h.onMessage(m)
-		if err != nil {
-			log.Error().Msgf("error on message %v", err)
-		}
-
-	case "CAP":
-		log.Debug().Msgf("%v: CAP: %v", h.network.Server, m)
-
-	case "NOTICE":
-		log.Trace().Msgf("%v: %v", h.network.Server, m)
-
-	case "PING":
-		err := h.handlePing(m)
-		if err != nil {
-			log.Error().Stack().Err(err)
-		}
-
-		//case "372":
-		//	log.Debug().Msgf("372: %v", m)
-		//default:
-		//	log.Trace().Msgf("%v: %v", h.network.Server, m)
-	}
-	return
-}
-
 func (h *Handler) isOurNick(nick string) bool {
 	return h.network.NickServ.Account == nick
 }
 
 func (h *Handler) setConnectionStatus() {
+	h.m.Lock()
 	// set connected since now
 	h.connectedSince = time.Now()
 	h.connected = true
+	h.m.Unlock()
 }
 
 func (h *Handler) resetConnectionStatus() {
+	h.m.Lock()
 	// set connected false if we loose connection or stop
 	h.connectedSince = time.Time{}
 	h.connected = false
@@ -314,6 +205,8 @@ func (h *Handler) resetConnectionStatus() {
 			h.resetMonitoring()
 		}
 	}
+
+	h.m.Unlock()
 }
 
 func (h *Handler) GetNetwork() *domain.IrcNetwork {
@@ -321,121 +214,101 @@ func (h *Handler) GetNetwork() *domain.IrcNetwork {
 }
 
 func (h *Handler) UpdateNetwork(network *domain.IrcNetwork) {
+	h.m.Lock()
 	h.network = network
+	h.m.Unlock()
 }
 
 func (h *Handler) SetNetwork(network *domain.IrcNetwork) {
+	h.m.Lock()
 	h.network = network
+	h.m.Unlock()
 }
 
 func (h *Handler) Stop() {
-	h.cancel()
-
-	if !h.isStopped() {
-		close(h.stopped)
-	}
-
-	if h.conn != nil {
-		h.conn.Close()
-	}
-}
-
-func (h *Handler) isStopped() bool {
-	select {
-	case <-h.stopped:
-		return true
-	default:
-		return false
-	}
+	log.Debug().Msgf("%v: Disconnecting...", h.network.Server)
+	h.client.Quit()
 }
 
 func (h *Handler) Restart() error {
-	h.cancel()
+	log.Debug().Msgf("%v: Restarting network...", h.network.Server)
 
-	if !h.isStopped() {
-		close(h.stopped)
-	}
+	h.client.Quit()
 
-	if h.conn != nil {
-		h.conn.Close()
-	}
-
-	time.Sleep(2 * time.Second)
+	time.Sleep(4 * time.Second)
 
 	return h.Run()
 }
 
-func (h *Handler) onConnect(channels []domain.IrcChannel) error {
+func (h *Handler) onConnect(m ircmsg.Message) {
 	identified := false
 
-	time.Sleep(2 * time.Second)
+	time.Sleep(4 * time.Second)
 
 	if h.network.NickServ.Password != "" {
-		err := h.handleNickServPRIVMSG(h.network.NickServ.Account, h.network.NickServ.Password)
+		err := h.HandleNickServIdentify(h.network.NickServ.Account, h.network.NickServ.Password)
 		if err != nil {
 			log.Error().Stack().Err(err).Msgf("error nickserv: %v", h.network.Name)
-			return err
+			return
 		}
 		identified = true
 	}
 
-	time.Sleep(3 * time.Second)
+	time.Sleep(4 * time.Second)
 
 	if h.network.InviteCommand != "" {
 		err := h.handleConnectCommands(h.network.InviteCommand)
 		if err != nil {
 			log.Error().Stack().Err(err).Msgf("error sending connect command %v to network: %v", h.network.InviteCommand, h.network.Name)
-			return err
+			return
 		}
 
-		time.Sleep(2 * time.Second)
+		time.Sleep(1 * time.Second)
 	}
 
 	if !identified {
-		for _, channel := range channels {
+		for _, channel := range h.network.Channels {
 			err := h.HandleJoinChannel(channel.Name, channel.Password)
 			if err != nil {
-				log.Error().Stack().Err(err)
-				return err
+				log.Error().Stack().Err(err).Msgf("error joining channels %v", err)
+				return
 			}
 		}
 	}
 
-	return nil
 }
 
-func (h *Handler) OnJoin(msg string) (interface{}, error) {
-	return nil, nil
-}
-
-func (h *Handler) onMessage(msg *irc.Message) error {
+func (h *Handler) onMessage(msg ircmsg.Message) {
+	if len(msg.Params) < 2 {
+		return
+	}
 	// parse announce
-	channel := &msg.Params[0]
-	announcer := &msg.Name
-	message := msg.Trailing()
+	announcer := msg.Nick()
+	channel := msg.Params[0]
+	message := msg.Params[1]
 
 	// check if message is from a valid channel, if not return
-	validChannel := h.isValidChannel(*channel)
+	validChannel := h.isValidChannel(channel)
 	if !validChannel {
-		return nil
+		return
 	}
 
 	// check if message is from announce bot, if not return
-	validAnnouncer := h.isValidAnnouncer(*announcer)
+	validAnnouncer := h.isValidAnnouncer(announcer)
 	if !validAnnouncer {
-		return nil
+		return
 	}
 
 	// clean message
 	cleanedMsg := cleanMessage(message)
-	log.Debug().Msgf("%v: %v %v: %v", h.network.Server, *channel, *announcer, cleanedMsg)
+	log.Debug().Msgf("%v: %v %v: %v", h.network.Server, channel, announcer, cleanedMsg)
 
-	if err := h.sendToAnnounceProcessor(*channel, cleanedMsg); err != nil {
+	if err := h.sendToAnnounceProcessor(channel, cleanedMsg); err != nil {
 		log.Error().Stack().Err(err).Msgf("could not queue line: %v", cleanedMsg)
-		return err
+		return
 	}
 
-	return nil
+	return
 }
 
 func (h *Handler) sendToAnnounceProcessor(channel string, msg string) error {
@@ -464,57 +337,64 @@ func (h *Handler) sendToAnnounceProcessor(channel string, msg string) error {
 	return nil
 }
 
-func (h *Handler) sendPrivMessage(msg string) error {
-	msg = strings.TrimLeft(msg, "/")
-	privMsg := fmt.Sprintf("PRIVMSG %h", msg)
+func (h *Handler) HandleJoinChannel(channel string, password string) error {
+	// support channel password
+	ch := channel
+	if password != "" {
+		ch = fmt.Sprintf("%v %v", channel, password)
+	}
 
-	err := h.client.Write(privMsg)
+	log.Trace().Msgf("%v: JOIN sending %v", h.network.Server, ch)
+
+	time.Sleep(1 * time.Second)
+
+	//err := h.client.Write(m.String())
+	err := h.client.Join(ch)
 	if err != nil {
-		log.Error().Err(err).Msgf("could not send priv msg: %v", msg)
+		log.Error().Stack().Err(err).Msgf("error handling join: %v", channel)
 		return err
 	}
 
 	return nil
 }
 
-func (h *Handler) HandleJoinChannel(channel string, password string) error {
-	// support channel password
-	params := []string{channel}
-	if password != "" {
-		params = append(params, password)
+func (h *Handler) handlePart(msg ircmsg.Message) {
+	if !h.isOurNick(msg.Nick()) {
+		log.Debug().Msgf("%v: MODE OTHER USER: %+v", h.network.Server, msg)
+		return
 	}
 
-	m := irc.Message{
-		Command: "JOIN",
-		Params:  params,
-	}
+	channel := msg.Params[0]
 
-	log.Trace().Msgf("%v: sending %v", h.network.Server, m.String())
+	log.Debug().Msgf("%v: PART channel %v", h.network.Server, channel)
 
-	time.Sleep(1 * time.Second)
-
-	err := h.client.Write(m.String())
+	err := h.client.Part(channel)
 	if err != nil {
-		log.Error().Stack().Err(err).Msgf("error handling join: %v", m.String())
-		return err
+		log.Error().Err(err).Msgf("error handling part: %v", channel)
+		return
 	}
 
-	return nil
+	// reset monitoring status
+	v, ok := h.channelHealth[channel]
+	if !ok {
+		return
+	}
+
+	v.resetMonitoring()
+
+	// TODO remove announceProcessor
+
+	log.Info().Msgf("%v: Left channel '%v'", h.network.Server, channel)
+
+	return
 }
 
 func (h *Handler) HandlePartChannel(channel string) error {
-	m := irc.Message{
-		Command: "PART",
-		Params:  []string{channel},
-	}
+	log.Debug().Msgf("%v: PART channel %v", h.network.Server, channel)
 
-	log.Debug().Msgf("%v: %v", h.network.Server, m.String())
-
-	time.Sleep(1 * time.Second)
-
-	err := h.client.Write(m.String())
+	err := h.client.Part(channel)
 	if err != nil {
-		log.Error().Err(err).Msgf("error handling part: %v", m.String())
+		log.Error().Err(err).Msgf("error handling part: %v", channel)
 		return err
 	}
 
@@ -533,19 +413,33 @@ func (h *Handler) HandlePartChannel(channel string) error {
 	return nil
 }
 
-func (h *Handler) handleJoined(msg *irc.Message) {
-	log.Debug().Msgf("%v: JOINED: %v", h.network.Server, msg.Params[1])
+func (h *Handler) handleJoined(msg ircmsg.Message) {
+	if !h.isOurNick(msg.Params[0]) {
+		log.Debug().Msgf("%v: OTHER USER JOINED: %+v", h.network.Server, msg)
+		return
+	}
 
 	// get channel
-	channel := &msg.Params[1]
+	channel := msg.Params[1]
+
+	valid := h.isValidChannel(channel)
+	if !valid {
+		if err := h.HandlePartChannel(channel); err != nil {
+			log.Error().Stack().Err(err).Msgf("%v: Could not part channel: %v", h.network.Server, channel)
+			return
+		}
+		return
+	}
+
+	log.Debug().Msgf("%v: JOINED: %v", h.network.Server, msg.Params[1])
 
 	// set monitoring on current channelHealth, or add new
-	v, ok := h.channelHealth[strings.ToLower(*channel)]
+	v, ok := h.channelHealth[strings.ToLower(channel)]
 	if ok {
 		v.SetMonitoring()
 	} else if v == nil {
-		h.channelHealth[*channel] = &channelHealth{
-			name:            *channel,
+		h.channelHealth[channel] = &channelHealth{
+			name:            channel,
 			monitoring:      true,
 			monitoringSince: time.Now(),
 		}
@@ -561,16 +455,16 @@ func (h *Handler) handleConnectCommands(msg string) error {
 	for _, command := range connectCommands {
 		cmd := strings.TrimSpace(command)
 
-		m := irc.Message{
+		m := ircmsg.Message{
 			Command: "PRIVMSG",
 			Params:  strings.Split(cmd, " "),
 		}
 
 		log.Debug().Msgf("%v: sending connect command", h.network.Server)
 
-		err := h.client.Write(m.String())
+		err := h.client.SendIRCMessage(m)
 		if err != nil {
-			log.Error().Err(err).Msgf("error handling invite: %v", m.String())
+			log.Error().Err(err).Msgf("error handling invite: %v", m)
 			return err
 		}
 	}
@@ -578,52 +472,41 @@ func (h *Handler) handleConnectCommands(msg string) error {
 	return nil
 }
 
-func (h *Handler) handlePRIVMSG(msg string) error {
-	msg = strings.TrimLeft(msg, "/")
-
-	m := irc.Message{
-		Command: "PRIVMSG",
-		Params:  []string{msg},
+func (h *Handler) handleInvite(msg ircmsg.Message) {
+	if len(msg.Params) < 2 {
+		return
 	}
-	log.Debug().Msgf("%v: Handle privmsg: %v", h.network.Server, m.String())
 
-	err := h.client.Write(m.String())
+	// get channel
+	channel := msg.Params[1]
+
+	valid := h.isValidChannel(channel)
+	if !valid {
+		return
+	}
+
+	log.Debug().Msgf("%v: INVITE from %v, joining %v", h.network.Server, msg.Nick(), channel)
+
+	err := h.client.Join(channel)
 	if err != nil {
-		log.Error().Err(err).Msgf("error handling PRIVMSG: %v", m.String())
-		return err
+		log.Error().Stack().Err(err).Msgf("error handling join: %v", channel)
+		return
 	}
 
-	return nil
-}
-
-func (h *Handler) handleNickServPRIVMSG(nick, password string) error {
-	m := irc.Message{
-		Command: "PRIVMSG",
-		Params:  []string{"NickServ", "IDENTIFY", nick, password},
-	}
-
-	log.Debug().Msgf("%v: NickServ: %v", h.network.Server, m.String())
-
-	err := h.client.Write(m.String())
-	if err != nil {
-		log.Error().Err(err).Msgf("error identifying with nickserv: %v", m.String())
-		return err
-	}
-
-	return nil
+	return
 }
 
 func (h *Handler) HandleNickServIdentify(nick, password string) error {
-	m := irc.Message{
+	m := ircmsg.Message{
 		Command: "PRIVMSG",
 		Params:  []string{"NickServ", "IDENTIFY", nick, password},
 	}
 
-	log.Debug().Msgf("%v: NickServ: %v", h.network.Server, m.String())
+	log.Debug().Msgf("%v: NickServ: %v", h.network.Server, m)
 
-	err := h.client.Write(m.String())
+	err := h.client.SendIRCMessage(m)
 	if err != nil {
-		log.Error().Stack().Err(err).Msgf("error identifying with nickserv: %v", m.String())
+		log.Error().Stack().Err(err).Msgf("error identifying with nickserv: %v", m)
 		return err
 	}
 
@@ -631,30 +514,26 @@ func (h *Handler) HandleNickServIdentify(nick, password string) error {
 }
 
 func (h *Handler) HandleNickChange(nick string) error {
-	m := irc.Message{
-		Command: "NICK",
-		Params:  []string{nick},
-	}
+	log.Debug().Msgf("%v: Nick change: %v", h.network.Server, nick)
 
-	log.Debug().Msgf("%v: Nick change: %v", h.network.Server, m.String())
-
-	err := h.client.Write(m.String())
-	if err != nil {
-		log.Error().Stack().Err(err).Msgf("error changing nick: %v", m.String())
-		return err
-	}
+	h.client.SetNick(nick)
 
 	return nil
 }
 
-func (h *Handler) handleMode(msg *irc.Message) error {
-	log.Debug().Msgf("%v: MODE: %v %v", h.network.Server, msg.User, msg.Trailing())
+func (h *Handler) handleMode(msg ircmsg.Message) {
+	log.Debug().Msgf("%v: MODE: %+v", h.network.Server, msg)
+
+	if !h.isOurNick(msg.Params[0]) {
+		log.Debug().Msgf("%v: MODE OTHER USER: %+v", h.network.Server, msg)
+		return
+	}
 
 	time.Sleep(2 * time.Second)
 
-	if h.network.NickServ.Password != "" && !strings.Contains(msg.String(), h.client.CurrentNick()) || !strings.Contains(msg.String(), "+r") {
-		log.Trace().Msgf("%v: MODE: Not correct permission yet: %v", h.network.Server, msg.String())
-		return nil
+	if h.network.NickServ.Password != "" && !strings.Contains(msg.Params[0], h.client.Nick) || !strings.Contains(msg.Params[1], "+r") {
+		log.Trace().Msgf("%v: MODE: Not correct permission yet: %v", h.network.Server, msg.Params)
+		return
 	}
 
 	for _, ch := range h.network.Channels {
@@ -667,28 +546,7 @@ func (h *Handler) handleMode(msg *irc.Message) error {
 		time.Sleep(1 * time.Second)
 	}
 
-	return nil
-}
-
-func (h *Handler) handlePing(msg *irc.Message) error {
-	log.Trace().Msgf("%v: %v", h.network.Server, msg)
-
-	pong := irc.Message{
-		Command: "PONG",
-		Params:  msg.Params,
-	}
-
-	log.Trace().Msgf("%v: %v", h.network.Server, pong.String())
-
-	err := h.client.Write(pong.String())
-	if err != nil {
-		log.Error().Err(err).Msgf("error PING PONG response: %v", pong.String())
-		return err
-	}
-
-	h.setLastPing()
-
-	return nil
+	return
 }
 
 // check if announcer is one from the list in the definition