first version with gosrc.io/xmpp

output/xmpp/main.go

@@ -3,11 +3,9 @@ package xmpp
 import (
 	"regexp"
 
-	xmpp_client "dev.sum7.eu/genofire/yaja/client"
-	xmpp "dev.sum7.eu/genofire/yaja/xmpp"
-	"dev.sum7.eu/genofire/yaja/xmpp/base"
 	"github.com/bdlm/log"
 	"github.com/mitchellh/mapstructure"
+	"gosrc.io/xmpp"
 
 	"dev.sum7.eu/genofire/logmania/bot"
 	"dev.sum7.eu/genofire/logmania/database"
@@ -20,8 +18,6 @@ const (
 	nickname   = "logmania"
 )
 
-var historyMaxChars = 0
-
 var logger = log.WithField("output", proto)
 
 type Output struct {
@@ -29,7 +25,7 @@ type Output struct {
 	defaults []*database.Notify
 	channels map[string]bool
 	bot      *bot.Bot
-	client   *xmpp_client.Client
+	client   *xmpp.Client
 	botOut   chan interface{}
 	logOut   chan interface{}
 }
@@ -47,26 +43,30 @@ func Init(configInterface interface{}, db *database.DB, bot *bot.Bot) output.Out
 		return nil
 	}
 
-	jid := xmppbase.NewJID(config.JID)
+	out := &Output{
-	client, err := xmpp_client.NewClient(jid, config.Password)
+		channels: make(map[string]bool),
+		bot:      bot,
+	}
+
+	router := xmpp.NewRouter()
+	router.HandleFunc("message", out.recvMessage)
+	router.HandleFunc("presence", out.recvPresence)
+
+	client, err := xmpp.NewClient(xmpp.Config{
+		Jid:      config.JID,
+		Password: config.Password,
+	}, router)
 
 	if err != nil {
 		logger.Error(err)
 		return nil
 	}
+	out.client = client
+	cm := xmpp.NewStreamManager(client, nil)
 	go func() {
-		client.Start()
+		cm.Run()
 		log.Panic("closed connection")
 	}()
-	out := &Output{
-		channels: make(map[string]bool),
-		bot:      bot,
-		client:   client,
-		botOut:   make(chan interface{}),
-		logOut:   make(chan interface{}),
-	}
-	go out.sender()
-	go out.receiver()
 
 	logger.WithField("jid", config.JID).Info("startup")
 
@@ -97,17 +97,19 @@ func (out *Output) Default() []*database.Notify {
 
 func (out *Output) Close() {
 	for jid := range out.channels {
-		toJID := xmppbase.NewJID(jid)
+		toJID, err := xmpp.NewJid(jid)
-		toJID.Resource = nickname
-		err := out.client.Send(&xmpp.PresenceClient{
-			To:   toJID,
-			Type: xmpp.PresenceTypeUnavailable,
-		})
 		if err != nil {
-			logger.Error("xmpp could not leave ", toJID.String(), " error:", err)
+			logger.Error("xmpp could generate jid to leave ", jid, " error:", err)
+		}
+		toJID.Resource = nickname
+		err = out.client.Send(xmpp.Presence{Attrs: xmpp.Attrs{
+			To:   toJID.Full(),
+			Type: xmpp.PresenceTypeUnavailable,
+		}})
+		if err != nil {
+			logger.Error("xmpp could not leave ", toJID.Full(), " error:", err)
 		}
 	}
-	out.client.Close()
 }
 
 func init() {

output/xmpp/recv.go

@@ -1,75 +1,78 @@
 package xmpp
 
 import (
-	xmpp "dev.sum7.eu/genofire/yaja/xmpp"
 	"github.com/bdlm/log"
+	"gosrc.io/xmpp"
 )
 
-func (out *Output) receiver() {
+func (out *Output) recvMessage(s xmpp.Sender, p xmpp.Packet) {
-	for {
+	msg, ok := p.(xmpp.Message)
-		element, more := out.client.Recv()
+	if !ok {
-		if !more {
+		log.Errorf("blame gosrc.io/xmpp for routing: %s", p)
-			log.Warn("could not receive new message, try later")
+		return
-			continue
+	}
-		}
+	from, err := xmpp.NewJid(msg.From)
-		out.recv(element)
+	if err != nil {
-	}
+		log.Errorf("blame gosrc.io/xmpp for jid encoding: %s", msg.From)
-}
+		return
-func (out *Output) recv(element interface{}) {
+	}
-
+	fromBare := from.Bare()
-	switch element.(type) {
+	fromLogmania := ""
-	case *xmpp.PresenceClient:
+	if msg.Type == xmpp.MessageTypeGroupchat {
-		pres := element.(*xmpp.PresenceClient)
+		fromLogmania = protoGroup + ":" + fromBare
-		sender := pres.From
+	} else {
-		logPres := logger.WithField("from", sender.Full())
+		fromLogmania = proto + ":" + fromBare
-		switch pres.Type {
+	}
-		case xmpp.PresenceTypeSubscribe:
+
-			logPres.Debugf("recv presence subscribe")
+	answer := out.bot.Handle(fromLogmania, msg.Body)
-			pres.Type = xmpp.PresenceTypeSubscribed
+	if answer == "" {
-			pres.To = sender
+		return
-			pres.From = nil
+	}
-			out.botOut <- pres
+	reply := xmpp.Message{Attrs: xmpp.Attrs{To: fromBare, Type: msg.Type}, Body: msg.Body}
-			logPres.Debugf("accept new subscribe")
+	s.Send(reply)
-
+}
-			pres.Type = xmpp.PresenceTypeSubscribe
+
-			pres.ID = ""
+func (out *Output) recvPresence(s xmpp.Sender, p xmpp.Packet) {
-			out.botOut <- pres
+	pres, ok := p.(xmpp.Presence)
-			logPres.Info("request also subscribe")
+	if !ok {
-		case xmpp.PresenceTypeSubscribed:
+		log.Errorf("blame gosrc.io/xmpp for routing: %s", p)
-			logPres.Info("recv presence accepted subscribe")
+		return
-		case xmpp.PresenceTypeUnsubscribe:
+	}
-			logPres.Info("recv presence remove subscribe")
+	from, err := xmpp.NewJid(pres.From)
-		case xmpp.PresenceTypeUnsubscribed:
+	if err != nil {
-			logPres.Info("recv presence removed subscribe")
+		log.Errorf("blame gosrc.io/xmpp for jid encoding: %s", pres.From)
-		case xmpp.PresenceTypeUnavailable:
+		return
-			logPres.Debug("recv presence unavailable")
+	}
-		case "":
+	fromBare := from.Bare()
-			logPres.Debug("recv empty presence, maybe from joining muc")
+	logPres := logger.WithField("from", from)
-			return
+
-		default:
+	switch pres.Type {
-			logPres.Warnf("recv presence unsupported: %s -> %s", pres.Type, xmpp.XMLChildrenString(pres))
+	case xmpp.PresenceTypeSubscribe:
-		}
+		logPres.Debugf("recv presence subscribe")
-	case *xmpp.MessageClient:
+		s.Send(xmpp.Presence{Attrs: xmpp.Attrs{
-		msg := element.(*xmpp.MessageClient)
+			Type: xmpp.PresenceTypeSubscribed,
-		from := msg.From.Bare().String()
+			To:   fromBare,
-		if msg.Type == xmpp.MessageTypeGroupchat {
+			Id:   pres.Id,
-			from = protoGroup + ":" + from
+		}})
-		} else {
+		logPres.Debugf("accept new subscribe")
-			from = proto + ":" + from
+
-		}
+		s.Send(xmpp.Presence{Attrs: xmpp.Attrs{
-
+			Type: xmpp.PresenceTypeSubscribe,
-		answer := out.bot.Handle(from, msg.Body)
+			To:   fromBare,
-		if answer == "" {
+		}})
-			return
+		logPres.Info("request also subscribe")
-		}
+	case xmpp.PresenceTypeSubscribed:
-		to := msg.From
+		logPres.Info("recv presence accepted subscribe")
-		if msg.Type == xmpp.MessageTypeGroupchat && !to.IsBare() {
+	case xmpp.PresenceTypeUnsubscribe:
-			to = to.Bare()
+		logPres.Info("recv presence remove subscribe")
-		}
+	case xmpp.PresenceTypeUnsubscribed:
-		out.botOut <- &xmpp.MessageClient{
+		logPres.Info("recv presence removed subscribe")
-			Type: msg.Type,
+	case xmpp.PresenceTypeUnavailable:
-			To:   to,
+		logPres.Debug("recv presence unavailable")
-			Body: answer,
+	case "":
-		}
+		logPres.Debug("recv empty presence, maybe from joining muc")
+		return
+	default:
+		logPres.Warnf("recv presence unsupported: %s -> %s", pres.Type, pres)
 	}
 }

output/xmpp/send.go

@@ -1,50 +1,34 @@
 package xmpp
 
 import (
-	"encoding/xml"
 	"strings"
 
-	xmpp "dev.sum7.eu/genofire/yaja/xmpp"
-	"dev.sum7.eu/genofire/yaja/xmpp/base"
-	"dev.sum7.eu/genofire/yaja/xmpp/x/muc"
 	"github.com/bdlm/log"
+	"gosrc.io/xmpp"
 
 	"dev.sum7.eu/genofire/logmania/database"
 )
 
 func (out *Output) Join(to string) {
-	toJID := xmppbase.NewJID(to)
+	toJID, err := xmpp.NewJid(to)
+	if err != nil {
+		logger.Error("xmpp could not generate jid to join ", to, " error:", err)
+		return
+	}
 	toJID.Resource = nickname
-	err := out.client.Send(&xmpp.PresenceClient{
+	err = out.client.Send(xmpp.Presence{Attrs: xmpp.Attrs{To: toJID.Full()},
-		To: toJID,
+		Extensions: []xmpp.PresExtension{
-		MUC: &xmuc.Base{
+			xmpp.MucPresence{
-			History: &xmuc.History{
+				History: xmpp.History{MaxStanzas: 0},
-				MaxChars: &historyMaxChars,
+			}},
-			},
-		},
 	})
 	if err != nil {
-		logger.Error("xmpp could not join ", toJID.String(), " error:", err)
+		logger.Error("xmpp could not join ", toJID.Full(), " error:", err)
 	} else {
 		out.channels[to] = true
 	}
 }
 
-func (out *Output) sender() {
-	// priority of bot higher: https://groups.google.com/forum/#!topic/golang-nuts/M2xjN_yWBiQ
-	for {
-		select {
-		case el := <-out.botOut:
-			out.client.Send(el)
-		default:
-			select {
-			case el := <-out.logOut:
-				out.client.Send(el)
-			default:
-			}
-		}
-	}
-}
 func (out *Output) Send(e *log.Entry, to *database.Notify) bool {
 	html, text := formatLog(e)
 	if html == "" || text == "" {
@@ -52,44 +36,28 @@ func (out *Output) Send(e *log.Entry, to *database.Notify) bool {
 		return false
 	}
 	html = strings.TrimRight(to.RunReplace(html), "\n")
-	var body xmpp.XMLElement
-	xml.Unmarshal([]byte(html), &body)
-
 	text = strings.TrimRight(to.RunReplace(text), "\n")
 
+	msg := xmpp.Message{
+		Attrs: xmpp.Attrs{
+			To: to.To,
+		},
+		Body: text,
+		Extensions: []xmpp.MsgExtension{
+			xmpp.HTML{Body: xmpp.HTMLBody{InnerXML: html}},
+		},
+	}
 	if to.Protocol == protoGroup {
 		if _, ok := out.channels[to.To]; ok {
-			toJID := xmppbase.NewJID(to.To)
+			out.Join(to.To)
-			toJID.Resource = nickname
-			err := out.client.Send(&xmpp.PresenceClient{
-				To: toJID,
-				MUC: &xmuc.Base{
-					History: &xmuc.History{
-						MaxChars: &historyMaxChars,
-					},
-				},
-			})
-			if err != nil {
-				logger.Error("xmpp could not join ", toJID.String(), " error:", err)
-			} else {
-				out.channels[to.To] = true
-			}
-		}
-		out.logOut <- &xmpp.MessageClient{
-			Type: xmpp.MessageTypeGroupchat,
-			To:   xmppbase.NewJID(to.To),
-			Body: text,
-			HTML: &xmpp.HTML{Body: xmpp.HTMLBody{Body: body}},
 		}
+		msg.Type = xmpp.MessageTypeGroupchat
+		out.client.Send(msg)
 		return true
 	}
 	if to.Protocol == proto {
-		out.logOut <- &xmpp.MessageClient{
+		msg.Type = xmpp.MessageTypeChat
-			Type: xmpp.MessageTypeChat,
+		out.client.Send(msg)
-			To:   xmppbase.NewJID(to.To),
-			Body: text,
-			HTML: &xmpp.HTML{Body: xmpp.HTMLBody{Body: body}},
-		}
 		return true
 	}
 	return false