Feature: Support multi user per irc network (#78)

* feat: delete irc network in transaction

* feat: use compound key for irc handlers

* chore: update deps

* refactor: start network

* refactor: init irc handler

* indexers: update network name

internal/database/irc.go

@@ -49,25 +49,25 @@ func (r *IrcRepo) GetNetworkByID(id int64) (*domain.IrcNetwork, error) {
 }
 
 func (r *IrcRepo) DeleteNetwork(ctx context.Context, id int64) error {
-	tx, err := r.db.handler.BeginTx(ctx, nil)
+	tx, err := r.db.BeginTx(ctx, nil)
 	if err != nil {
 		return err
 	}
 
 	defer tx.Rollback()
 
-	_, err = tx.ExecContext(ctx, `DELETE FROM irc_network WHERE id = ?`, id)
-	if err != nil {
-		log.Error().Stack().Err(err).Msgf("error deleting network: %v", id)
-		return err
-	}
-
 	_, err = tx.ExecContext(ctx, `DELETE FROM irc_channel WHERE network_id = ?`, id)
 	if err != nil {
 		log.Error().Stack().Err(err).Msgf("error deleting channels for network: %v", id)
 		return err
 	}
 
+	_, err = tx.ExecContext(ctx, `DELETE FROM irc_network WHERE id = ?`, id)
+	if err != nil {
+		log.Error().Stack().Err(err).Msgf("error deleting network: %v", id)
+		return err
+	}
+
 	err = tx.Commit()
 	if err != nil {
 		log.Error().Stack().Err(err).Msgf("error deleting network: %v", id)

internal/database/sqlite.go

@@ -79,3 +79,20 @@ func (db *SqliteDB) Close() error {
 	}
 	return nil
 }
+
+func (db *SqliteDB) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error) {
+	tx, err := db.handler.BeginTx(ctx, opts)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Tx{
+		Tx:      tx,
+		handler: db,
+	}, nil
+}
+
+type Tx struct {
+	*sql.Tx
+	handler *SqliteDB
+}

internal/http/irc.go

@@ -19,7 +19,6 @@ type ircService interface {
 	StoreNetwork(ctx context.Context, network *domain.IrcNetwork) error
 	UpdateNetwork(ctx context.Context, network *domain.IrcNetwork) error
 	StoreChannel(networkID int64, channel *domain.IrcChannel) error
-	StopNetwork(name string) error
 }
 
 type ircHandler struct {
@@ -39,7 +38,6 @@ func (h ircHandler) Routes(r chi.Router) {
 	r.Post("/", h.storeNetwork)
 	r.Put("/network/{networkID}", h.updateNetwork)
 	r.Post("/network/{networkID}/channel", h.storeChannel)
-	r.Get("/network/{networkID}/stop", h.stopNetwork)
 	r.Get("/network/{networkID}", h.getNetworkByID)
 	r.Delete("/network/{networkID}", h.deleteNetwork)
 }
@@ -132,20 +130,6 @@ func (h ircHandler) storeChannel(w http.ResponseWriter, r *http.Request) {
 	h.encoder.StatusResponse(ctx, w, nil, http.StatusCreated)
 }
 
-func (h ircHandler) stopNetwork(w http.ResponseWriter, r *http.Request) {
-	var (
-		ctx       = r.Context()
-		networkID = chi.URLParam(r, "networkID")
-	)
-
-	err := h.service.StopNetwork(networkID)
-	if err != nil {
-		//
-	}
-
-	h.encoder.StatusResponse(ctx, w, nil, http.StatusCreated)
-}
-
 func (h ircHandler) deleteNetwork(w http.ResponseWriter, r *http.Request) {
 	var (
 		ctx       = r.Context()

internal/indexer/definitions/hd-torrents.yaml

@@ -20,7 +20,7 @@ settings:
     help: "Check how to get cookies in your browser and find the uid and pass cookies. Example: uid=1234; pass=asdf12347asdf13"
 
 irc:
-  network: P2P-NET
+  network: P2P-Network
   server: irc.p2p-network.net
   port: 6697
   tls: true

internal/indexer/definitions/milkie.yaml

@@ -20,7 +20,7 @@ settings:
     regex: /([a-zA-Z0-9\+])
 
 irc:
-  network: p2p-network.net
+  network: P2P-Network
   server: irc.p2p-network.net
   port: 6697
   tls: true

internal/indexer/definitions/mock1.yaml

@@ -0,0 +1,63 @@
+---
+#id: tracker01
+name: Mock1
+identifier: mock1
+description: Mock1 is just a mock indexer
+language: en-us
+urls:
+  - http://localhost.test
+privacy: private
+protocol: torrent
+supports:
+  - irc
+  - rss
+source: custom
+settings:
+  - name: rsskey
+    type: secret
+    label: RSS key
+    help: "Go to your profile and copy your RSS key"
+    regex: /([\da-fA-F]{20})
+
+irc:
+  network: LocalHost
+  server: localhost
+  port: 6697
+  tls: true
+  channels:
+    - "#announces"
+  announcers:
+    - _AnnounceBot_
+  settings:
+    - name: nickserv.account
+      type: text
+      required: true
+      label: NickServ Account
+      help: NickServ account. Make sure to group your user and bot. Eg. user_bot
+    - name: nickserv.password
+      type: secret
+      required: false
+      label: NickServ Password
+      help: NickServ password
+
+parse:
+  type: single
+  lines:
+    - test:
+        - "New Torrent Announcement: <PC :: Iso>  Name:'debian live 10 6 0 amd64 standard iso' uploaded by 'Anonymous' -  http://www.tracker01.test/torrent/000000"
+        - "New Torrent Announcement: <PC :: Iso>  Name:'debian live 10 6 0 amd64 standard iso' uploaded by 'Anonymous' freeleech -  http://www.tracker01.test/torrent/000000"
+      pattern: New Torrent Announcement:\s*<([^>]*)>\s*Name:'(.*)' uploaded by '([^']*)'\s*(freeleech)*\s*-\s*(https?\:\/\/[^\/]+\/)torrent\/(\d+)
+      vars:
+        - category
+        - torrentName
+        - uploader
+        - freeleech
+        - baseUrl
+        - torrentId
+
+  match:
+    torrenturl: "{{ .baseUrl }}rss/download/{{ .torrentId }}/{{ .rsskey }}/{{ .torrentName }}.torrent"
+    encode:
+      - torrentName
+
+

internal/indexer/definitions/mock2.yaml

@@ -0,0 +1,63 @@
+---
+#id: tracker01
+name: Mock2
+identifier: mock2
+description: Mock2 is just a mock indexer
+language: en-us
+urls:
+  - http://localhost.test
+privacy: private
+protocol: torrent
+supports:
+  - irc
+  - rss
+source: custom
+settings:
+  - name: rsskey
+    type: secret
+    label: RSS key
+    help: "Go to your profile and copy your RSS key"
+    regex: /([\da-fA-F]{20})
+
+irc:
+  network: LocalHost
+  server: localhost
+  port: 6697
+  tls: true
+  channels:
+    - "#mannounces"
+  announcers:
+    - Jerry
+  settings:
+    - name: nickserv.account
+      type: text
+      required: true
+      label: NickServ Account
+      help: NickServ account. Make sure to group your user and bot. Eg. user_bot
+    - name: nickserv.password
+      type: secret
+      required: false
+      label: NickServ Password
+      help: NickServ password
+
+parse:
+  type: single
+  lines:
+    - test:
+        - "New Torrent Announcement: <PC :: Iso>  Name:'debian live 10 6 0 amd64 standard iso' uploaded by 'Anonymous' -  http://www.tracker01.test/torrent/000000"
+        - "New Torrent Announcement: <PC :: Iso>  Name:'debian live 10 6 0 amd64 standard iso' uploaded by 'Anonymous' freeleech -  http://www.tracker01.test/torrent/000000"
+      pattern: New Torrent Announcement:\s*<([^>]*)>\s*Name:'(.*)' uploaded by '([^']*)'\s*(freeleech)*\s*-\s*(https?\:\/\/[^\/]+\/)torrent\/(\d+)
+      vars:
+        - category
+        - torrentName
+        - uploader
+        - freeleech
+        - baseUrl
+        - torrentId
+
+  match:
+    torrenturl: "{{ .baseUrl }}rss/download/{{ .torrentId }}/{{ .rsskey }}/{{ .torrentName }}.torrent"
+    encode:
+      - torrentName
+
+

internal/indexer/definitions/trancetraffic.yaml

@@ -19,7 +19,7 @@ settings:
     help: "Go to https://www.trancetraffic.com/links.php, click on RSS Feed and copy your passkey from the url."
 
 irc:
-  network: P2P-NET
+  network: P2P-Network
   server: irc.p2p-network.net
   port: 6697
   tls: true
@@ -35,7 +35,7 @@ irc:
       help: NickServ account. Make sure to group your user and bot. Eg. user|autodl
     - name: nickserv.password
       type: secret
-      required: false
+      required: true
       label: NickServ Password
       help: NickServ password
 

internal/indexer/service.go

@@ -243,6 +243,16 @@ func (s *service) addIndexer(indexer domain.Indexer) error {
 
 	s.mapIRCIndexerLookup(indexer.Identifier, *indexerDefinition)
 
+	// add to irc server lookup table
+	s.mapIRCServerDefinitionLookup(indexerDefinition.IRC.Server, *indexerDefinition)
+
+	// check if it has api and add to api service
+	if indexerDefinition.Enabled && indexerDefinition.HasApi() {
+		if err := s.apiService.AddClient(indexerDefinition.Identifier, indexerDefinition.SettingsMap); err != nil {
+			log.Error().Stack().Err(err).Msgf("indexer.start: could not init api client for: '%v'", indexer.Identifier)
+		}
+	}
+
 	return nil
 }
 

internal/irc/handler.go

@@ -52,7 +52,7 @@ type Handler struct {
 	filterService      filter.Service
 	releaseService     release.Service
 	announceProcessors map[string]announce.Processor
-	definitions        []domain.IndexerDefinition
+	definitions        map[string]*domain.IndexerDefinition
 
 	client  *irc.Client
 	conn    net.Conn
@@ -79,22 +79,35 @@ func NewHandler(network domain.IrcNetwork, filterService filter.Service, release
 		network:            &network,
 		filterService:      filterService,
 		releaseService:     releaseService,
-		definitions:        definitions,
+		definitions:        map[string]*domain.IndexerDefinition{},
 		announceProcessors: map[string]announce.Processor{},
 		validAnnouncers:    map[string]struct{}{},
 		validChannels:      map[string]struct{}{},
 		channelHealth:      map[string]*channelHealth{},
 	}
 
+	// init indexer, announceProcessor
+	h.InitIndexers(definitions)
+
+	return h
+}
+
+func (h *Handler) InitIndexers(definitions []domain.IndexerDefinition) {
 	// Networks can be shared by multiple indexers but channels are unique
 	// so let's add a new AnnounceProcessor per channel
 	for _, definition := range definitions {
-		// indexers can use multiple channels, but it's not common, but let's handle that anyway.
+		if _, ok := h.definitions[definition.Identifier]; ok {
+			continue
+		}
+
+		h.definitions[definition.Identifier] = &definition
+
+		// indexers can use multiple channels, but it'h not common, but let'h handle that anyway.
 		for _, channel := range definition.IRC.Channels {
 			// some channels are defined in mixed case
 			channel = strings.ToLower(channel)
 
-			h.announceProcessors[channel] = announce.NewAnnounceProcessor(definition, filterService, releaseService)
+			h.announceProcessors[channel] = announce.NewAnnounceProcessor(definition, h.filterService, h.releaseService)
 
 			h.channelHealth[channel] = &channelHealth{
 				name:       channel,
@@ -110,20 +123,25 @@ func NewHandler(network domain.IrcNetwork, filterService filter.Service, release
 			h.validAnnouncers[announcer] = struct{}{}
 		}
 	}
-
-	return h
 }
 
-func (s *Handler) Run() error {
-	//log.Debug().Msgf("server %+v", s.network)
+func (h *Handler) removeIndexer() {
+	// TODO remove validAnnouncers
+	// TODO remove validChannels
+	// TODO remove definition
+	// TODO remove announceProcessor
+}
 
-	if s.network.Server == "" {
+func (h *Handler) Run() error {
+	//log.Debug().Msgf("server %+v", h.network)
+
+	if h.network.Server == "" {
 		return errors.New("addr not set")
 	}
 
 	ctx, cancel := context.WithCancel(context.Background())
-	s.ctx = ctx
-	s.cancel = cancel
+	h.ctx = ctx
+	h.cancel = cancel
 
 	dialer := net.Dialer{
 		Timeout: connectTimeout,
@@ -132,122 +150,49 @@ func (s *Handler) Run() error {
 	var netConn net.Conn
 	var err error
 
-	addr := fmt.Sprintf("%v:%v", s.network.Server, s.network.Port)
+	addr := fmt.Sprintf("%v:%v", h.network.Server, h.network.Port)
 
 	// decide to use SSL or not
-	if s.network.TLS {
+	if h.network.TLS {
 		tlsConf := &tls.Config{
 			InsecureSkipVerify: true,
 		}
 
-		netConn, err = dialer.DialContext(s.ctx, "tcp", addr)
+		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)
-		s.conn = netConn
+		h.conn = netConn
 	} else {
-		netConn, err = dialer.DialContext(s.ctx, "tcp", addr)
+		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)
 		}
 
-		s.conn = netConn
+		h.conn = netConn
 	}
 
 	log.Info().Msgf("Connected to: %v", addr)
 
 	config := irc.ClientConfig{
-		Nick: s.network.NickServ.Account,
-		User: s.network.NickServ.Account,
-		Name: s.network.NickServ.Account,
-		Pass: s.network.Pass,
-		Handler: irc.HandlerFunc(func(c *irc.Client, m *irc.Message) {
-			switch m.Command {
-			case "001":
-				// 001 is a welcome event, so we join channels there
-				err := s.onConnect(s.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
-				s.handleJoined(m)
-
-			case "JOIN":
-				log.Trace().Msgf("%v: JOIN %v", s.network.Server, m)
-
-			case "433":
-				// TODO: handle nick in use
-				log.Debug().Msgf("%v: NICK IN USE: %v", s.network.Server, m)
-
-			case "448", "473", "475", "477":
-				// TODO: handle join failed
-				log.Debug().Msgf("%v: JOIN FAILED %v: %v", s.network.Server, m.Params[1], m)
-
-			case "900": // Invite bot logged in
-				log.Debug().Msgf("%v: %v", s.network.Server, m.Trailing())
-
-			case "KICK":
-				log.Debug().Msgf("%v: KICK: %v", s.network.Server, m)
-
-			case "MODE":
-				err := s.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", s.network.Server, m)
-
-			case "PART":
-				// TODO: handle parted
-				log.Debug().Msgf("%v: PART: %v", s.network.Server, m)
-
-			case "PRIVMSG":
-				err := s.onMessage(m)
-				if err != nil {
-					log.Error().Msgf("error on message %v", err)
-				}
-
-			case "CAP":
-				log.Debug().Msgf("%v: CAP: %v", s.network.Server, m)
-
-			case "NOTICE":
-				log.Trace().Msgf("%v: %v", s.network.Server, m)
-
-			case "PING":
-				err := s.handlePing(m)
-				if err != nil {
-					log.Error().Stack().Err(err)
-				}
-
-			//case "372":
-			//	log.Debug().Msgf("372: %v", m)
-			default:
-				log.Trace().Msgf("%v: %v", s.network.Server, m)
-			}
-		}),
+		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(s.conn, config)
+	client := irc.NewClient(h.conn, config)
 
-	s.client = client
+	h.client = client
 
 	// set connected since now
-	s.setConnectionStatus()
+	h.setConnectionStatus()
 
 	// Connect
 	err = client.RunContext(ctx)
@@ -255,7 +200,7 @@ func (s *Handler) Run() error {
 		log.Error().Err(err).Msgf("could not connect to %v", addr)
 
 		// reset connection status on handler and channels
-		s.resetConnectionStatus()
+		h.resetConnectionStatus()
 
 		return err
 	}
@@ -263,79 +208,172 @@ func (s *Handler) Run() error {
 	return nil
 }
 
-func (s *Handler) setConnectionStatus() {
-	// set connected since now
-	s.connectedSince = time.Now()
-	s.connected = true
+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 (s *Handler) resetConnectionStatus() {
+func (h *Handler) isOurNick(nick string) bool {
+	return h.network.NickServ.Account == nick
+}
+
+func (h *Handler) setConnectionStatus() {
+	// set connected since now
+	h.connectedSince = time.Now()
+	h.connected = true
+}
+
+func (h *Handler) resetConnectionStatus() {
 	// set connected false if we loose connection or stop
-	s.connectedSince = time.Time{}
-	s.connected = false
+	h.connectedSince = time.Time{}
+	h.connected = false
 
 	// loop over channelHealth and reset each one
-	for _, h := range s.channelHealth {
+	for _, h := range h.channelHealth {
 		if h != nil {
 			h.resetMonitoring()
 		}
 	}
 }
 
-func (s *Handler) GetNetwork() *domain.IrcNetwork {
-	return s.network
+func (h *Handler) GetNetwork() *domain.IrcNetwork {
+	return h.network
 }
 
-func (s *Handler) UpdateNetwork(network *domain.IrcNetwork) {
-	s.network = network
+func (h *Handler) UpdateNetwork(network *domain.IrcNetwork) {
+	h.network = network
 }
 
-func (s *Handler) Stop() {
-	s.cancel()
+func (h *Handler) SetNetwork(network *domain.IrcNetwork) {
+	h.network = network
+}
 
-	if !s.isStopped() {
-		close(s.stopped)
+func (h *Handler) Stop() {
+	h.cancel()
+
+	if !h.isStopped() {
+		close(h.stopped)
 	}
 
-	if s.conn != nil {
-		s.conn.Close()
+	if h.conn != nil {
+		h.conn.Close()
 	}
 }
 
-func (s *Handler) isStopped() bool {
+func (h *Handler) isStopped() bool {
 	select {
-	case <-s.stopped:
+	case <-h.stopped:
 		return true
 	default:
 		return false
 	}
 }
 
-func (s *Handler) Restart() error {
-	s.cancel()
+func (h *Handler) Restart() error {
+	h.cancel()
 
-	if !s.isStopped() {
-		close(s.stopped)
+	if !h.isStopped() {
+		close(h.stopped)
 	}
 
-	if s.conn != nil {
-		s.conn.Close()
+	if h.conn != nil {
+		h.conn.Close()
 	}
 
 	time.Sleep(2 * time.Second)
 
-	return s.Run()
+	return h.Run()
 }
 
-func (s *Handler) onConnect(channels []domain.IrcChannel) error {
+func (h *Handler) onConnect(channels []domain.IrcChannel) error {
 	identified := false
 
 	time.Sleep(2 * time.Second)
 
-	if s.network.NickServ.Password != "" {
-		err := s.handleNickServPRIVMSG(s.network.NickServ.Account, s.network.NickServ.Password)
+	if h.network.NickServ.Password != "" {
+		err := h.handleNickServPRIVMSG(h.network.NickServ.Account, h.network.NickServ.Password)
 		if err != nil {
-			log.Error().Stack().Err(err).Msgf("error nickserv: %v", s.network.Name)
+			log.Error().Stack().Err(err).Msgf("error nickserv: %v", h.network.Name)
 			return err
 		}
 		identified = true
@@ -343,11 +381,10 @@ func (s *Handler) onConnect(channels []domain.IrcChannel) error {
 
 	time.Sleep(3 * time.Second)
 
-	if s.network.InviteCommand != "" {
-
-		err := s.handleInvitePRIVMSG(s.network.InviteCommand)
+	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", s.network.InviteCommand, s.network.Name)
+			log.Error().Stack().Err(err).Msgf("error sending connect command %v to network: %v", h.network.InviteCommand, h.network.Name)
 			return err
 		}
 
@@ -356,7 +393,7 @@ func (s *Handler) onConnect(channels []domain.IrcChannel) error {
 
 	if !identified {
 		for _, channel := range channels {
-			err := s.HandleJoinChannel(channel.Name, channel.Password)
+			err := h.HandleJoinChannel(channel.Name, channel.Password)
 			if err != nil {
 				log.Error().Stack().Err(err)
 				return err
@@ -367,34 +404,33 @@ func (s *Handler) onConnect(channels []domain.IrcChannel) error {
 	return nil
 }
 
-func (s *Handler) OnJoin(msg string) (interface{}, error) {
+func (h *Handler) OnJoin(msg string) (interface{}, error) {
 	return nil, nil
 }
 
-func (s *Handler) onMessage(msg *irc.Message) error {
+func (h *Handler) onMessage(msg *irc.Message) error {
 	// parse announce
 	channel := &msg.Params[0]
 	announcer := &msg.Name
 	message := msg.Trailing()
-	// TODO add network
 
 	// check if message is from a valid channel, if not return
-	validChannel := s.isValidChannel(*channel)
+	validChannel := h.isValidChannel(*channel)
 	if !validChannel {
 		return nil
 	}
 
 	// check if message is from announce bot, if not return
-	validAnnouncer := s.isValidAnnouncer(*announcer)
+	validAnnouncer := h.isValidAnnouncer(*announcer)
 	if !validAnnouncer {
 		return nil
 	}
 
 	// clean message
 	cleanedMsg := cleanMessage(message)
-	log.Debug().Msgf("%v: %v %v: %v", s.network.Server, *channel, *announcer, cleanedMsg)
+	log.Debug().Msgf("%v: %v %v: %v", h.network.Server, *channel, *announcer, cleanedMsg)
 
-	if err := s.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
 	}
@@ -402,11 +438,11 @@ func (s *Handler) onMessage(msg *irc.Message) error {
 	return nil
 }
 
-func (s *Handler) sendToAnnounceProcessor(channel string, msg string) error {
+func (h *Handler) sendToAnnounceProcessor(channel string, msg string) error {
 	channel = strings.ToLower(channel)
 
 	// check if queue exists
-	queue, ok := s.announceProcessors[channel]
+	queue, ok := h.announceProcessors[channel]
 	if !ok {
 		return fmt.Errorf("queue '%v' not found", channel)
 	}
@@ -418,7 +454,7 @@ func (s *Handler) sendToAnnounceProcessor(channel string, msg string) error {
 		return err
 	}
 
-	v, ok := s.channelHealth[channel]
+	v, ok := h.channelHealth[channel]
 	if !ok {
 		return nil
 	}
@@ -428,11 +464,11 @@ func (s *Handler) sendToAnnounceProcessor(channel string, msg string) error {
 	return nil
 }
 
-func (s *Handler) sendPrivMessage(msg string) error {
+func (h *Handler) sendPrivMessage(msg string) error {
 	msg = strings.TrimLeft(msg, "/")
-	privMsg := fmt.Sprintf("PRIVMSG %s", msg)
+	privMsg := fmt.Sprintf("PRIVMSG %h", msg)
 
-	err := s.client.Write(privMsg)
+	err := h.client.Write(privMsg)
 	if err != nil {
 		log.Error().Err(err).Msgf("could not send priv msg: %v", msg)
 		return err
@@ -441,7 +477,7 @@ func (s *Handler) sendPrivMessage(msg string) error {
 	return nil
 }
 
-func (s *Handler) HandleJoinChannel(channel string, password string) error {
+func (h *Handler) HandleJoinChannel(channel string, password string) error {
 	// support channel password
 	params := []string{channel}
 	if password != "" {
@@ -453,82 +489,105 @@ func (s *Handler) HandleJoinChannel(channel string, password string) error {
 		Params:  params,
 	}
 
-	log.Trace().Msgf("%v: sending %v", s.network.Server, m.String())
+	log.Trace().Msgf("%v: sending %v", h.network.Server, m.String())
 
 	time.Sleep(1 * time.Second)
 
-	err := s.client.Write(m.String())
+	err := h.client.Write(m.String())
 	if err != nil {
 		log.Error().Stack().Err(err).Msgf("error handling join: %v", m.String())
 		return err
 	}
 
-	// only set values if channel is found in map
-	v, ok := s.channelHealth[channel]
-	if ok {
-		v.SetMonitoring()
-	}
-
 	return nil
 }
 
-func (s *Handler) HandlePartChannel(channel string) error {
+func (h *Handler) HandlePartChannel(channel string) error {
 	m := irc.Message{
 		Command: "PART",
 		Params:  []string{channel},
 	}
 
-	log.Debug().Msgf("%v: %v", s.network.Server, m.String())
+	log.Debug().Msgf("%v: %v", h.network.Server, m.String())
 
 	time.Sleep(1 * time.Second)
 
-	err := s.client.Write(m.String())
+	err := h.client.Write(m.String())
 	if err != nil {
 		log.Error().Err(err).Msgf("error handling part: %v", m.String())
 		return err
 	}
 
-	log.Info().Msgf("Left channel '%v' on network '%s'", channel, s.network.Server)
+	// reset monitoring status
+	v, ok := h.channelHealth[channel]
+	if !ok {
+		return nil
+	}
+
+	v.resetMonitoring()
+
+	// TODO remove announceProcessor
+
+	log.Info().Msgf("Left channel '%v' on network '%h'", channel, h.network.Server)
 
 	return nil
 }
 
-func (s *Handler) handleJoined(msg *irc.Message) {
-	log.Debug().Msgf("%v: JOINED: %v", s.network.Server, msg.Trailing())
+func (h *Handler) handleJoined(msg *irc.Message) {
+	log.Debug().Msgf("%v: JOINED: %v", h.network.Server, msg.Params[1])
 
-	log.Info().Msgf("%v: Monitoring channel %s", s.network.Server, msg.Params[1])
-}
+	// get channel
+	channel := &msg.Params[1]
 
-func (s *Handler) handleInvitePRIVMSG(msg string) error {
-	msg = strings.TrimPrefix(msg, "/msg")
-	split := strings.Split(msg, " ")
-
-	m := irc.Message{
-		Command: "PRIVMSG",
-		Params:  split,
+	// set monitoring on current channelHealth, or add new
+	v, ok := h.channelHealth[strings.ToLower(*channel)]
+	if ok {
+		v.SetMonitoring()
+	} else if v == nil {
+		h.channelHealth[*channel] = &channelHealth{
+			name:            *channel,
+			monitoring:      true,
+			monitoringSince: time.Now(),
+		}
 	}
 
-	log.Info().Msgf("%v: Invite command: %v", s.network.Server, m.String())
+	log.Info().Msgf("%v: Monitoring channel %v", h.network.Server, msg.Params[1])
+}
 
-	err := s.client.Write(m.String())
-	if err != nil {
-		log.Error().Err(err).Msgf("error handling invite: %v", m.String())
-		return err
+func (h *Handler) handleConnectCommands(msg string) error {
+	connectCommand := strings.ReplaceAll(msg, "/msg", "")
+	connectCommands := strings.Split(connectCommand, ",")
+
+	for _, command := range connectCommands {
+		cmd := strings.TrimSpace(command)
+
+		m := irc.Message{
+			Command: "PRIVMSG",
+			Params:  strings.Split(cmd, " "),
+		}
+
+		log.Debug().Msgf("%v: sending connect command", h.network.Server)
+
+		err := h.client.Write(m.String())
+		if err != nil {
+			log.Error().Err(err).Msgf("error handling invite: %v", m.String())
+			return err
+		}
 	}
 
 	return nil
 }
 
-func (s *Handler) handlePRIVMSG(msg string) error {
+func (h *Handler) handlePRIVMSG(msg string) error {
 	msg = strings.TrimLeft(msg, "/")
 
 	m := irc.Message{
 		Command: "PRIVMSG",
 		Params:  []string{msg},
 	}
-	log.Debug().Msgf("%v: Handle privmsg: %v", s.network.Server, m.String())
+	log.Debug().Msgf("%v: Handle privmsg: %v", h.network.Server, m.String())
 
-	err := s.client.Write(m.String())
+	err := h.client.Write(m.String())
 	if err != nil {
 		log.Error().Err(err).Msgf("error handling PRIVMSG: %v", m.String())
 		return err
@@ -537,15 +596,15 @@ func (s *Handler) handlePRIVMSG(msg string) error {
 	return nil
 }
 
-func (s *Handler) handleNickServPRIVMSG(nick, password string) error {
+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", s.network.Server, m.String())
+	log.Debug().Msgf("%v: NickServ: %v", h.network.Server, m.String())
 
-	err := s.client.Write(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
@@ -554,15 +613,15 @@ func (s *Handler) handleNickServPRIVMSG(nick, password string) error {
 	return nil
 }
 
-func (s *Handler) HandleNickServIdentify(nick, password string) error {
+func (h *Handler) HandleNickServIdentify(nick, password string) error {
 	m := irc.Message{
 		Command: "PRIVMSG",
 		Params:  []string{"NickServ", "IDENTIFY", nick, password},
 	}
 
-	log.Debug().Msgf("%v: NickServ: %v", s.network.Server, m.String())
+	log.Debug().Msgf("%v: NickServ: %v", h.network.Server, m.String())
 
-	err := s.client.Write(m.String())
+	err := h.client.Write(m.String())
 	if err != nil {
 		log.Error().Stack().Err(err).Msgf("error identifying with nickserv: %v", m.String())
 		return err
@@ -571,15 +630,15 @@ func (s *Handler) HandleNickServIdentify(nick, password string) error {
 	return nil
 }
 
-func (s *Handler) HandleNickChange(nick string) error {
+func (h *Handler) HandleNickChange(nick string) error {
 	m := irc.Message{
 		Command: "NICK",
 		Params:  []string{nick},
 	}
 
-	log.Debug().Msgf("%v: Nick change: %v", s.network.Server, m.String())
+	log.Debug().Msgf("%v: Nick change: %v", h.network.Server, m.String())
 
-	err := s.client.Write(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
@@ -588,18 +647,18 @@ func (s *Handler) HandleNickChange(nick string) error {
 	return nil
 }
 
-func (s *Handler) handleMode(msg *irc.Message) error {
-	log.Debug().Msgf("%v: MODE: %v %v", s.network.Server, msg.User, msg.Trailing())
+func (h *Handler) handleMode(msg *irc.Message) error {
+	log.Debug().Msgf("%v: MODE: %v %v", h.network.Server, msg.User, msg.Trailing())
 
 	time.Sleep(2 * time.Second)
 
-	if s.network.NickServ.Password != "" && !strings.Contains(msg.String(), s.client.CurrentNick()) || !strings.Contains(msg.String(), "+r") {
-		log.Trace().Msgf("%v: MODE: Not correct permission yet: %v", s.network.Server, msg.String())
+	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
 	}
 
-	for _, ch := range s.network.Channels {
-		err := s.HandleJoinChannel(ch.Name, ch.Password)
+	for _, ch := range h.network.Channels {
+		err := h.HandleJoinChannel(ch.Name, ch.Password)
 		if err != nil {
 			log.Error().Err(err).Msgf("error joining channel: %v", ch.Name)
 			continue
@@ -611,30 +670,30 @@ func (s *Handler) handleMode(msg *irc.Message) error {
 	return nil
 }
 
-func (s *Handler) handlePing(msg *irc.Message) error {
-	log.Trace().Msgf("%v: %v", s.network.Server, msg)
+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", s.network.Server, pong.String())
+	log.Trace().Msgf("%v: %v", h.network.Server, pong.String())
 
-	err := s.client.Write(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
 	}
 
-	s.setLastPing()
+	h.setLastPing()
 
 	return nil
 }
 
 // check if announcer is one from the list in the definition
-func (s *Handler) isValidAnnouncer(nick string) bool {
-	_, ok := s.validAnnouncers[nick]
+func (h *Handler) isValidAnnouncer(nick string) bool {
+	_, ok := h.validAnnouncers[nick]
 	if !ok {
 		return false
 	}
@@ -643,8 +702,8 @@ func (s *Handler) isValidAnnouncer(nick string) bool {
 }
 
 // check if channel is one from the list in the definition
-func (s *Handler) isValidChannel(channel string) bool {
-	_, ok := s.validChannels[strings.ToLower(channel)]
+func (h *Handler) isValidChannel(channel string) bool {
+	_, ok := h.validChannels[strings.ToLower(channel)]
 	if !ok {
 		return false
 	}
@@ -652,12 +711,12 @@ func (s *Handler) isValidChannel(channel string) bool {
 	return true
 }
 
-func (s *Handler) setLastPing() {
-	s.lastPing = time.Now()
+func (h *Handler) setLastPing() {
+	h.lastPing = time.Now()
 }
 
-func (s *Handler) GetLastPing() time.Time {
-	return s.lastPing
+func (h *Handler) GetLastPing() time.Time {
+	return h.lastPing
 }
 
 // irc line can contain lots of extra stuff like color so lets clean that

internal/irc/service.go

@@ -17,7 +17,7 @@ import (
 type Service interface {
 	StartHandlers()
 	StopHandlers()
-	StopNetwork(name string) error
+	StopNetwork(key handlerKey) error
 	ListNetworks(ctx context.Context) ([]domain.IrcNetwork, error)
 	GetNetworksWithHealth(ctx context.Context) ([]domain.IrcNetworkWithHealth, error)
 	GetNetworkByID(id int64) (*domain.IrcNetwork, error)
@@ -33,7 +33,7 @@ type service struct {
 	indexerService indexer.Service
 	releaseService release.Service
 	indexerMap     map[string]string
-	handlers       map[string]*Handler
+	handlers       map[handlerKey]*Handler
 
 	stopWG sync.WaitGroup
 	lock   sync.Mutex
@@ -45,10 +45,15 @@ func NewService(repo domain.IrcRepo, filterService filter.Service, indexerSvc in
 		filterService:  filterService,
 		indexerService: indexerSvc,
 		releaseService: releaseSvc,
-		handlers:       make(map[string]*Handler),
+		handlers:       make(map[handlerKey]*Handler),
 	}
 }
 
+type handlerKey struct {
+	server string
+	nick   string
+}
+
 func (s *service) StartHandlers() {
 	networks, err := s.repo.FindActiveNetworks(context.Background())
 	if err != nil {
@@ -76,8 +81,9 @@ func (s *service) StartHandlers() {
 		// init new irc handler
 		handler := NewHandler(network, s.filterService, s.releaseService, definitions)
 
-		// TODO use network.Server? + nick? Need a way to use multiple indexers for one network if same nick
-		s.handlers[network.Server] = handler
+		// use network.Server + nick to use multiple indexers with different nick per network
+		// this allows for multiple handlers to one network
+		s.handlers[handlerKey{network.Server, network.NickServ.Account}] = handler
 		s.lock.Unlock()
 
 		log.Debug().Msgf("starting network: %+v", network.Name)
@@ -105,7 +111,7 @@ func (s *service) StopHandlers() {
 
 func (s *service) startNetwork(network domain.IrcNetwork) error {
 	// look if we have the network in handlers already, if so start it
-	if existingHandler, found := s.handlers[network.Server]; found {
+	if existingHandler, found := s.handlers[handlerKey{network.Server, network.NickServ.Account}]; found {
 		log.Debug().Msgf("starting network: %+v", network.Name)
 
 		if existingHandler.conn != nil {
@@ -131,7 +137,7 @@ func (s *service) startNetwork(network domain.IrcNetwork) error {
 		// init new irc handler
 		handler := NewHandler(network, s.filterService, s.releaseService, definitions)
 
-		s.handlers[network.Server] = handler
+		s.handlers[handlerKey{network.Server, network.NickServ.Account}] = handler
 		s.lock.Unlock()
 
 		log.Debug().Msgf("starting network: %+v", network.Name)
@@ -152,9 +158,8 @@ func (s *service) startNetwork(network domain.IrcNetwork) error {
 
 func (s *service) checkIfNetworkRestartNeeded(network *domain.IrcNetwork) error {
 	// look if we have the network in handlers, if so restart it
-	// TODO check if we need to add indexerDefinitions etc
-	if existingHandler, found := s.handlers[network.Server]; found {
-		log.Debug().Msgf("decide if irc network handler needs restart or updating: %+v", network.Name)
+	if existingHandler, found := s.handlers[handlerKey{network.Server, network.NickServ.Account}]; found {
+		log.Debug().Msgf("irc: decide if irc network handler needs restart or updating: %+v", network.Server)
 
 		// if server, tls, invite command, port : changed - restart
 		// if nickserv account, nickserv password : changed - stay connected, and change those
@@ -173,18 +178,20 @@ func (s *service) checkIfNetworkRestartNeeded(network *domain.IrcNetwork) error
 				restartNeeded = true
 			}
 			if restartNeeded {
-				log.Info().Msgf("irc: restarting network: %+v", network.Name)
+				log.Info().Msgf("irc: restarting network: %+v", network.Server)
 
 				// we need to reinitialize with new network config
 				existingHandler.UpdateNetwork(network)
 
+				// todo reset channelHealth?
+
 				go func() {
 					if err := existingHandler.Restart(); err != nil {
 						log.Error().Stack().Err(err).Msgf("failed to restart network %q", existingHandler.network.Name)
 					}
 				}()
 
-				// return now since the restart will read the network again OR FIXME
+				// return now since the restart will read the network again
 				return nil
 			}
 
@@ -230,6 +237,7 @@ func (s *service) checkIfNetworkRestartNeeded(network *domain.IrcNetwork) error
 				channelsToLeave = append(channelsToLeave, handlerChan.Name)
 			}
 
+			// check new channels against handler to see which to join
 			for _, channel := range network.Channels {
 				_, ok := handlerChannels[channel.Name]
 				if ok {
@@ -243,6 +251,7 @@ func (s *service) checkIfNetworkRestartNeeded(network *domain.IrcNetwork) error
 
 			// leave channels
 			for _, leaveChannel := range channelsToLeave {
+				log.Debug().Msgf("%v: part channel %v", network.Server, leaveChannel)
 				err := existingHandler.HandlePartChannel(leaveChannel)
 				if err != nil {
 					log.Error().Stack().Err(err).Msgf("failed to leave channel: %q", leaveChannel)
@@ -251,12 +260,21 @@ func (s *service) checkIfNetworkRestartNeeded(network *domain.IrcNetwork) error
 
 			// join channels
 			for _, joinChannel := range channelsToJoin {
-				// TODO handle invite commands before?
+				log.Debug().Msgf("%v: join new channel %v", network.Server, joinChannel)
 				err := existingHandler.HandleJoinChannel(joinChannel.Name, joinChannel.Password)
 				if err != nil {
 					log.Error().Stack().Err(err).Msgf("failed to join channel: %q", joinChannel.Name)
 				}
 			}
+
+			// update network for handler
+			// TODO move all this restart logic inside handler to let it decide what to do
+			existingHandler.SetNetwork(network)
+
+			// find indexer definitions for network and add
+			definitions := s.indexerService.GetIndexersByIRCNetwork(network.Server)
+
+			existingHandler.InitIndexers(definitions)
 		}
 	} else {
 		err := s.startNetwork(*network)
@@ -270,7 +288,7 @@ func (s *service) checkIfNetworkRestartNeeded(network *domain.IrcNetwork) error
 
 func (s *service) restartNetwork(network domain.IrcNetwork) error {
 	// look if we have the network in handlers, if so restart it
-	if existingHandler, found := s.handlers[network.Server]; found {
+	if existingHandler, found := s.handlers[handlerKey{network.Server, network.NickServ.Account}]; found {
 		log.Info().Msgf("restarting network: %+v", network.Name)
 
 		if existingHandler.conn != nil {
@@ -287,31 +305,31 @@ func (s *service) restartNetwork(network domain.IrcNetwork) error {
 	return nil
 }
 
-func (s *service) StopNetwork(name string) error {
-	if handler, found := s.handlers[name]; found {
+func (s *service) StopNetwork(key handlerKey) error {
+	if handler, found := s.handlers[key]; found {
 		handler.Stop()
-		log.Debug().Msgf("stopped network: %+v", name)
+		log.Debug().Msgf("stopped network: %+v", key.server)
 	}
 
 	return nil
 }
 
-func (s *service) StopAndRemoveNetwork(name string) error {
-	if handler, found := s.handlers[name]; found {
+func (s *service) StopAndRemoveNetwork(key handlerKey) error {
+	if handler, found := s.handlers[key]; found {
 		handler.Stop()
 
 		// remove from handlers
-		delete(s.handlers, name)
-		log.Debug().Msgf("stopped network: %+v", name)
+		delete(s.handlers, key)
+		log.Debug().Msgf("stopped network: %+v", key)
 	}
 
 	return nil
 }
 
-func (s *service) StopNetworkIfRunning(name string) error {
-	if handler, found := s.handlers[name]; found {
+func (s *service) StopNetworkIfRunning(key handlerKey) error {
+	if handler, found := s.handlers[key]; found {
 		handler.Stop()
-		log.Debug().Msgf("stopped network: %+v", name)
+		log.Debug().Msgf("stopped network: %+v", key.server)
 	}
 
 	return nil
@@ -351,8 +369,6 @@ func (s *service) ListNetworks(ctx context.Context) ([]domain.IrcNetwork, error)
 		}
 		n.Channels = append(n.Channels, channels...)
 
-		// TODO get handler channelHealth
-
 		ret = append(ret, n)
 	}
 
@@ -382,7 +398,7 @@ func (s *service) GetNetworksWithHealth(ctx context.Context) ([]domain.IrcNetwor
 			Connected:     false,
 		}
 
-		handler, ok := s.handlers[n.Server]
+		handler, ok := s.handlers[handlerKey{n.Server, n.NickServ.Account}]
 		if ok {
 			// only set connected and connected since if we have an active handler and connection
 			if handler.conn != nil {
@@ -441,7 +457,7 @@ func (s *service) DeleteNetwork(ctx context.Context, id int64) error {
 
 	// Remove network and handler
 	//if err = s.StopNetwork(network.Server); err != nil {
-	if err = s.StopAndRemoveNetwork(network.Server); err != nil {
+	if err = s.StopAndRemoveNetwork(handlerKey{network.Server, network.NickServ.Account}); err != nil {
 		return err
 	}
 
@@ -478,9 +494,8 @@ func (s *service) UpdateNetwork(ctx context.Context, network *domain.IrcNetwork)
 		}
 
 	} else {
-		// TODO take into account multiple channels per network
-		//err := s.StopNetwork(network.Server)
-		err := s.StopAndRemoveNetwork(network.Server)
+		// take into account multiple channels per network
+		err := s.StopAndRemoveNetwork(handlerKey{network.Server, network.NickServ.Account})
 		if err != nil {
 			log.Error().Stack().Err(err).Msgf("could not stop network: %+v", network.Name)
 			return fmt.Errorf("could not stop network: %v", network.Name)
@@ -514,16 +529,23 @@ func (s *service) StoreNetwork(ctx context.Context, network *domain.IrcNetwork)
 		return nil
 	}
 
+	// get channels for existing network
+	existingChannels, err := s.repo.ListChannels(existingNetwork.ID)
+	if err != nil {
+		log.Error().Err(err).Msgf("failed to list channels for network %q", existingNetwork.Server)
+	}
+	existingNetwork.Channels = existingChannels
+
 	if network.Channels != nil {
 		for _, channel := range network.Channels {
-			// TODO store or add. Make sure it doesn't delete before
+			// add channels. Make sure it doesn't delete before
 			if err := s.repo.StoreChannel(existingNetwork.ID, &channel); err != nil {
 				return err
 			}
 		}
 
 		// append channels to existing network
-		network.Channels = append(network.Channels, existingNetwork.Channels...)
+		existingNetwork.Channels = append(existingNetwork.Channels, network.Channels...)
 	}
 
 	if existingNetwork.Enabled {
@@ -531,10 +553,10 @@ func (s *service) StoreNetwork(ctx context.Context, network *domain.IrcNetwork)
 		// if nickserv account, nickserv password : changed - stay connected, and change those
 		// if channels len : changes - join or leave
 
-		err := s.checkIfNetworkRestartNeeded(network)
+		err := s.checkIfNetworkRestartNeeded(existingNetwork)
 		if err != nil {
-			log.Error().Err(err).Msgf("could not restart network: %+v", network.Name)
-			return fmt.Errorf("could not restart network: %v", network.Name)
+			log.Error().Err(err).Msgf("could not restart network: %+v", existingNetwork.Name)
+			return fmt.Errorf("could not restart network: %v", existingNetwork.Name)
 		}
 	}