Do not hardcode connection parameters anymore

at.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"encoding/json"
+	"flag"
 	"fmt"
 	"log"
 	"time"
@@ -11,6 +12,8 @@ import (
 
 type atMonitor struct {
 	previousUserList []string
+	channel          string
+	apiAddress       string
 }
 
 type atUsers struct {
@@ -53,7 +56,7 @@ func (a *atMonitor) Run(c *irc.Client, done chan bool) {
 			return
 		case <-ticker.C:
 			var diffText string
-			atHS, err := at()
+			atHS, err := a.at()
 
 			if err != nil {
 				log.Println(err)
@@ -74,7 +77,7 @@ func (a *atMonitor) Run(c *irc.Client, done chan bool) {
 			}
 
 			if len(diffText) > 0 {
-				msg := fmt.Sprintf("NOTICE #hswaw-members :%s\n", diffText)
+				msg := fmt.Sprintf("NOTICE %s :%s\n", a.channel, diffText)
 				log.Println(diffText)
 				c.Write(msg)
 				a.previousUserList = current
@@ -83,10 +86,10 @@ func (a *atMonitor) Run(c *irc.Client, done chan bool) {
 	}
 }
 
-func at() (at atResponse, err error) {
+func (a *atMonitor) at() (at atResponse, err error) {
 	var values atResponse = atResponse{}
 
-	data, err := httpGet("https://at.hackerspace.pl/api")
+	data, err := httpGet(a.apiAddress)
 	if err != nil {
 		return values, fmt.Errorf("Unable to access checkinator api:", err)
 	}
@@ -98,3 +101,14 @@ func at() (at atResponse, err error) {
 
 	return values, nil
 }
+
+var (
+	atMonitorInstance atMonitor
+)
+
+func init() {
+	flag.StringVar(&atMonitorInstance.channel, "at.channel", "#hswaw-members", "Channel to send entrance/exit notices")
+	flag.StringVar(&atMonitorInstance.apiAddress, "at.api", "https://at.hackerspace.pl/api", "Checkinator API address")
+
+	Runners.Add(atMonitorInstance.Run)
+}

helpers.go

@@ -3,6 +3,7 @@ package main
 import (
 	"io"
 	"net/http"
+	"strings"
 	"time"
 )
 
@@ -56,3 +57,14 @@ func httpGet(link string) ([]byte, error) {
 
 	return buf, nil
 }
+
+type arrayFlags []string
+
+func (i *arrayFlags) String() string {
+	return strings.Join(*i, ",")
+}
+
+func (i *arrayFlags) Set(value string) error {
+	*i = append(*i, value)
+	return nil
+}

notifier.go

@@ -1,63 +1,60 @@
 package main
 
 import (
+	"flag"
 	"log"
 	"net"
 
 	"gopkg.in/irc.v3"
 )
 
-type dispatchFunc func(*irc.Client, *irc.Message)
+var (
+	channels arrayFlags
+	server   string
+	nickname string
+	password string
+	user     string
+	name     string
+)
 
-func handlerFactory(dispatchers []dispatchFunc) func(*irc.Client, *irc.Message) {
-	return func(c *irc.Client, m *irc.Message) {
-		for _, f := range dispatchers {
-			go f(c, m.Copy())
-		}
-	}
-}
-
-func logger(_ *irc.Client, m *irc.Message) {
-	log.Println(m)
-}
-
-func joinerFactory(channels []string) func(*irc.Client, *irc.Message) {
-	return func(c *irc.Client, m *irc.Message) {
-		if m.Command == "001" {
-			for _, ch := range channels {
-				c.Write("JOIN " + ch)
-			}
-		}
-	}
+func init() {
+	flag.StringVar(&server, "server", "irc.libera.chat:6667", "Server to connect to")
+	flag.StringVar(&nickname, "nickname", "notbot", "Bot nickname")
+	flag.StringVar(&password, "password", "", "Bot nickserv password")
+	flag.StringVar(&user, "user", "bot", "Bot user parameter")
+	flag.StringVar(&name, "name", "bot notbot", "Bot real name parameter")
+	flag.Var(&channels, "channels", "Channel to join; may be specified multiple times")
 }
 
 func main() {
-	done := make(chan bool)
-	var a atMonitor
-	var dispatchers = []dispatchFunc{
-		logger,
-		joinerFactory([]string{"#hswaw-members"}),
-	}
+	done := make([]chan bool, len(Runners.list))
 
-	conn, err := net.Dial("tcp", "irc.libera.chat:6667")
+	flag.Parse()
+
+	conn, err := net.Dial("tcp", server)
 	if err != nil {
 		log.Fatalln(err)
 	}
 
 	config := irc.ClientConfig{
-		Nick:    "notbot",
-		Pass:    "***",
-		User:    "bot",
-		Name:    "notbot",
-		Handler: irc.HandlerFunc(handlerFactory(dispatchers)),
+		Nick:    nickname,
+		Pass:    password,
+		User:    user,
+		Name:    name,
+		Handler: irc.HandlerFunc(handlerFactory(Dispatchers.list)),
 	}
 
 	client := irc.NewClient(conn, config)
-	go a.Run(client, done)
+
+	for i, runner := range Runners.list {
+		go runner(client, done[i])
+	}
 
 	err = client.Run()
 	if err != nil {
-		done <- true
+		for _, ch := range done {
+			ch <- true
+		}
 		log.Fatalln(err)
 	}
 }

plugins.go

@@ -0,0 +1,64 @@
+package main
+
+import (
+	"log"
+	"sync"
+
+	"gopkg.in/irc.v3"
+)
+
+type dispatchFunc func(*irc.Client, *irc.Message)
+type dispatchers struct {
+	lock sync.Mutex
+	list []dispatchFunc
+}
+
+func (d *dispatchers) Add(f dispatchFunc) {
+	d.lock.Lock()
+	defer d.lock.Unlock()
+
+	d.list = append(d.list, f)
+}
+
+type runFunc func(c *irc.Client, done chan bool)
+type runners struct {
+	lock sync.Mutex
+	list []runFunc
+}
+
+func (r *runners) Add(f runFunc) {
+	r.lock.Lock()
+	defer r.lock.Unlock()
+
+	r.list = append(r.list, f)
+}
+
+var (
+	Dispatchers dispatchers
+	Runners     runners
+)
+
+func handlerFactory(dispatchers []dispatchFunc) func(*irc.Client, *irc.Message) {
+	return func(c *irc.Client, m *irc.Message) {
+		for _, f := range dispatchers {
+			go f(c, m.Copy())
+		}
+	}
+}
+
+func logger(_ *irc.Client, m *irc.Message) {
+	log.Println(m)
+}
+
+func joiner(c *irc.Client, m *irc.Message) {
+	if m.Command == "001" {
+		for _, ch := range channels {
+			c.Write("JOIN " + ch)
+		}
+	}
+}
+
+func init() {
+	Dispatchers.Add(logger)
+	Dispatchers.Add(joiner)
+}