xmpp-webhook

main.go (4007B)

---

 package main
 
 import (
 	"flag"
 	"fmt"
 	"log"
 	"net/http"
 	"os"
 	"regexp"
 	"strings"
 
 	"github.com/emgee/go-xmpp/src/xmpp"
 )
 
 var (
 	Version   string
 	Build     string
 	BuildDate string
 )
 
 // starts xmpp session and returns the xmpp client
 func xmppLogin(id string, pass string) (*xmpp.XMPP, error) {
 	// parse jid structure
 	jid, err := xmpp.ParseJID(id)
 	if err != nil {
 		return nil, err
 	}
 
 	// extract/generate address:port from jid
 	addr, err := xmpp.HomeServerAddrs(jid)
 	if err != nil {
 		return nil, err
 	}
 
 	// create xml stream to address
 	stream, err := xmpp.NewStream(addr[0], nil)
 	if err != nil {
 		return nil, err
 	}
 
 	// create client (login)
 	client, err := xmpp.NewClientXMPP(stream, jid, pass, nil)
 	if err != nil {
 		return nil, err
 	}
 
 	return client, nil
 }
 
 func main() {
 	verF := flag.Bool("version", false, "Prints version and exit")
 	flag.Parse()
 
 	if *verF {
 		fmt.Printf("xmpp-webhook v%s, built on: %s\n", Version, BuildDate)
 		fmt.Printf("Git rev: %s\n", Build)
 		os.Exit(0)
 	}
 
 	// get xmpp credentials and message receivers from env
 	xi := os.Getenv("XMPP_ID")
 	xp := os.Getenv("XMPP_PASS")
 	xr := os.Getenv("XMPP_RECEIVERS")
 	port := os.Getenv("XMPP_HOOK_PORT")
 	flagsFolder := os.Getenv("XMPP_HOOK_FLAGS_FOLDER")
 
 	// check if xmpp credentials and receiver list are supplied
 	if len(xi) < 1 || len(xp) < 1 || len(xr) < 1 {
 		log.Fatal("XMPP_ID, XMPP_PASS or XMPP_RECEIVERS not set")
 	}
 
 	if len(port) < 1 {
 		port = "4321"
 	}
 
 	if len(flagsFolder) < 1 {
 		flagsFolder = "/tmp/xmpp_flags"
 	}
 
 	// connect to xmpp server
 	xc, err := xmppLogin(xi, xp)
 	if err != nil {
 		log.Fatal(err)
 	}
 
 	// announce initial presence
 	xc.Out <- xmpp.Presence{}
 
 	// listen for incoming xmpp stanzas
 	go func() {
 		for stanza := range xc.In {
 			// check if stanza is a message
 			m, ok := stanza.(*xmpp.Message)
 			if ok && len(m.Body) > 0 {
 				/* echo the message only if it's from me
 				   get first the id from the full From and then check if it's on
 				   the list of XMPP_RECEIVERS */
 				fromId := strings.Split(m.From, "/")
 				if strings.Contains(xr, fromId[0]) {
 					mybody := "Parsing command ..."
 					xc.Out <- xmpp.Message{
 						To:   m.From,
 						Body: []xmpp.MessageBody{{Value: mybody}},
 						Type: "chat",
 					}
 					if err := parseMessage(m.Body, flagsFolder); err != nil {
 						mybody = err.Error()
 					} else {
 						mybody = "Command executed"
 					}
 					xc.Out <- xmpp.Message{
 						To:   m.From,
 						Body: []xmpp.MessageBody{{Value: mybody}},
 						Type: "chat",
 					}
 				} else {
 					log.Printf("%s tried to contact and is not on XMPP_RECEIVERS\n", m.From)
 				}
 			}
 		}
 		// xc.In is closed when the server closes the stream
 		log.Fatal("connection lost")
 	}()
 
 	// create chan for messages (webhooks -> xmpp)
 	messages := make(chan string)
 
 	// wait for messages from the webhooks and send them to all receivers
 	go func() {
 		for m := range messages {
 			for _, r := range strings.Split(xr, ",") {
 				re := regexp.MustCompile(`AC:\d{4}`)
 				alertCode := re.FindString(m)
 				if len(alertCode) > 0 {
 					log.Printf("Found alert code %s", alertCode)
 					if err := createFolder(flagsFolder); err != nil {
 						m = m + "\n" + err.Error()
 						log.Printf("ERROR: %s", err.Error())
 					}
 					err = writeFileFlag(flagsFolder+"/"+alertCode, alertCode)
 					if err != nil {
 						m = m + "\n" + err.Error()
 						log.Printf("ERROR (on file creation): %s", err.Error())
 					}
 				}
 				xc.Out <- xmpp.Message{
 					To: r,
 					Body: []xmpp.MessageBody{
 						{
 							Value: m,
 						},
 					},
 					Type: "chat",
 				}
 			}
 		}
 	}()
 
 	// initialize handler for grafana alerts
 	http.Handle("/grafana", newMessageHandler(messages, grafanaParserFunc))
 
 	// initialize handler for custom alerts
 	http.Handle("/prometheus", newMessageHandler(messages, prometheusParserFunc))
 
 	// initialize handler for custom alerts
 	http.Handle("/custom", newMessageHandler(messages, customParserFunc))
 
 	// listen for requests
 	http.ListenAndServe(":"+port, nil)
 }