Refactor to send message to all relays

Keep connections open and refactor sending outbound messages to all connections.

Author: hoffmabc

net/web_relay_manager.go

@@ -14,8 +14,9 @@ import (
 )
 
 type WebRelayManager struct {
-	webrelays []string
-	peerID    string
+	webrelays   []string
+	peerID      string
+	connections []*websocket.Conn
 }
 
 type EncryptedMessage struct {
@@ -34,34 +35,25 @@ type SubscribeMessage struct {
 }
 
 func NewWebRelayManager(webrelays []string, sender string) *WebRelayManager {
-	return &WebRelayManager{webrelays, sender}
-}
 
-func (wrm *WebRelayManager) SendRelayMessage(ciphertext string, recipient string) {
-	encryptedmessage := EncryptedMessage{
-		Message:   ciphertext,
-		Recipient: recipient,
-	}
+	// Establish connections
+	var conns []*websocket.Conn
+	for _, relay := range webrelays {
 
-	data, _ := json.Marshal(encryptedmessage)
+		// Connect and subscribe to websocket server
+		conn, err := connectToServer(relay, sender)
+		if err != nil {
+			log.Error("Could not connect to: %s", relay)
+		}
 
-	typedmessage := TypedMessage{
-		Type: "EncryptedMessage",
-		Data: data,
+		conns = append(conns, conn)
 	}
-
-	outgoing, _ := json.Marshal(typedmessage)
-	fmt.Println(string(outgoing))
-
-	// Transmit the encrypted message to the webrelay
-	wrm.authToWebRelay(wrm.webrelays[0], outgoing)
-
+	return &WebRelayManager{webrelays, sender, conns}
 }
 
-func (wrm *WebRelayManager) authToWebRelay(server string, msg []byte) {
-
+func connectToServer(relay string, sender string) (*websocket.Conn, error) {
 	// Generate subscription key for web relay
-	peerIDMultihash, _ := multihash.FromB58String(wrm.peerID)
+	peerIDMultihash, _ := multihash.FromB58String(sender)
 	decoded, _ := multihash.Decode(peerIDMultihash)
 	digest := decoded.Digest
 	prefix := digest[:8]
@@ -81,7 +73,7 @@ func (wrm *WebRelayManager) authToWebRelay(server string, msg []byte) {
 
 	// Generate subscribe message
 	subscribeMessage := SubscribeMessage{
-		UserID:          wrm.peerID,
+		UserID:          sender,
 		SubscriptionKey: base58.Encode(subscriptionKey),
 	}
 
@@ -90,29 +82,60 @@ func (wrm *WebRelayManager) authToWebRelay(server string, msg []byte) {
 		Type: "SubscribeMessage",
 		Data: data,
 	}
-	fmt.Println(typedmessage)
+	fmt.Println("Sending SubscribeMessage:", typedmessage)
 
 	socketmessage, _ := json.Marshal(typedmessage)
 
 	// Connect to websocket server
-	fmt.Printf("connecting to %s\n", server)
+	fmt.Printf("Connecting to relay server: %s\n", relay)
 
-	c, _, err := websocket.DefaultDialer.Dial(server, nil)
+	c, _, err := websocket.DefaultDialer.Dial(relay, nil)
 	if err != nil {
 		log.Fatal("dial:", err)
+		return nil, err
 	}
-	defer c.Close()
 
 	err = c.WriteMessage(websocket.TextMessage, socketmessage)
 	if err != nil {
 		fmt.Println("write:", err)
-		return
+		return nil, err
 	}
 
-	err = c.WriteMessage(websocket.TextMessage, msg)
-	if err != nil {
-		fmt.Println("write:", err)
-		return
+	fmt.Printf("Successfully connected and subscribed to: %s\n", relay)
+
+	return c, nil
+}
+
+func (wrm *WebRelayManager) SendRelayMessage(ciphertext string, recipient string) {
+	encryptedmessage := EncryptedMessage{
+		Message:   ciphertext,
+		Recipient: recipient,
+	}
+
+	data, _ := json.Marshal(encryptedmessage)
+
+	typedmessage := TypedMessage{
+		Type: "EncryptedMessage",
+		Data: data,
+	}
+
+	outgoing, _ := json.Marshal(typedmessage)
+	fmt.Println(string(outgoing))
+
+	// Transmit the encrypted message to the webrelay
+	wrm.authToWebRelay(wrm.webrelays[0], outgoing)
+
+}
+
+func (wrm *WebRelayManager) authToWebRelay(server string, msg []byte) {
+
+	for _, conn := range wrm.connections {
+		err := conn.WriteMessage(websocket.TextMessage, msg)
+		if err != nil {
+			fmt.Println("write:", err)
+			return
+		}
+		fmt.Printf("Successfully sent message to relay: %s\n", conn.RemoteAddr())
 	}
 
 }