uniform default bufferflow and 🧹

Author: umbynos

Diff for: bufferflow.go

@@ -14,6 +14,5 @@ type Bufferflow interface {
 	Init()
 	BlockUntilReady(cmd string, id string) (bool, bool) // implement this method
 	OnIncomingData(data string)                         // implement this method
-	IsBufferGloballySendingBackIncomingData() bool      // implement this method
 	Close()                                             // implement this method
 }

Diff for: bufferflow_default.go

@@ -1,21 +1,47 @@
 package main
 
 import (
+	"encoding/json"
+
 	log "github.com/sirupsen/logrus"
 )
 
 type BufferflowDefault struct {
-	port string
+	port   string
+	output chan []byte
+	input  chan string
+	done   chan bool
 }
 
-func NewBufferflowDefault(port string) *BufferflowDefault {
+func NewBufferflowDefault(port string, output chan []byte) *BufferflowDefault {
 	return &BufferflowDefault{
-		port: port,
+		port:   port,
+		output: output,
+		input:  make(chan string),
+		done:   make(chan bool),
 	}
 }
 
 func (b *BufferflowDefault) Init() {
 	log.Println("Initting default buffer flow (which means no buffering)")
+	go b.consumeInput()
+}
+
+func (b *BufferflowDefault) consumeInput() {
+Loop:
+	for {
+		select {
+		case data := <-b.input:
+			m := SpPortMessage{b.port, data}
+			message, _ := json.Marshal(m)
+			// data is now encoded in base64 format
+			// need a decoder on the other side
+			b.output <- message
+		case <-b.done:
+			break Loop //this is required, a simple break statement would only exit the innermost switch statement
+		}
+	}
+	close(b.input) // close the input channel at the end of the computation
 }
 
 func (b *BufferflowDefault) BlockUntilReady(cmd string, id string) (bool, bool) {
@@ -24,12 +50,10 @@ func (b *BufferflowDefault) BlockUntilReady(cmd string, id string) (bool, bool)
 }
 
 func (b *BufferflowDefault) OnIncomingData(data string) {
-	//log.Printf("OnIncomingData() start. data:%v\n", data)
-}
-
-func (b *BufferflowDefault) IsBufferGloballySendingBackIncomingData() bool {
-	return false
+	b.input <- data
 }
 
 func (b *BufferflowDefault) Close() {
+	b.done <- true
+	close(b.done)
 }

Diff for: bufferflow_timed.go

@@ -68,10 +68,6 @@ func (b *BufferflowTimed) OnIncomingData(data string) {
 	b.input <- data
 }
 
-func (b *BufferflowTimed) IsBufferGloballySendingBackIncomingData() bool {
-	return true
-}
-
 func (b *BufferflowTimed) Close() {
 	b.ticker.Stop()
 	b.done <- true

Diff for: bufferflow_timedraw.go

@@ -68,10 +68,6 @@ func (b *BufferflowTimedRaw) OnIncomingData(data string) {
 	b.input <- data
 }
 
-func (b *BufferflowTimedRaw) IsBufferGloballySendingBackIncomingData() bool {
-	return true
-}
-
 func (b *BufferflowTimedRaw) Close() {
 	b.ticker.Stop()
 	b.done <- true

Diff for: serialport.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"bytes"
-	"encoding/json"
 	"io"
 	"strconv"
 	"time"
@@ -121,6 +120,10 @@ func (p *serport) reader(buftype string) {
 			switch buftype {
 			case "timedraw", "timed", "timedbinary":
 				data = string(bufferPart[:n])
+				// give the data to our bufferflow so it can do it's work
+				// to read/translate the data to see if it wants to block
+				// writes to the serialport. each bufferflow type will decide
+				// this on its own based on its logic
 				p.bufferwatcher.OnIncomingData(data)
 			case "default": // the bufferbuftype is actually called default 🤷‍♂️
 				// save the left out bytes for the next iteration due to UTF-8 encoding
@@ -139,41 +142,10 @@ func (p *serport) reader(buftype string) {
 					data += string(runeValue)
 					w = width
 				}
-				// give the data to our bufferflow so it can do it's work
-				// to read/translate the data to see if it wants to block
-				// writes to the serialport. each bufferflow type will decide
-				// this on its own based on its logic, i.e. tinyg vs grbl vs others
 				p.bufferwatcher.OnIncomingData(data)
 			default:
 				log.Panicf("unknown buffer type %s", buftype)
 			}
-
-			// see if the OnIncomingData handled the broadcast back
-			// to the user. this option was added in case the OnIncomingData wanted
-			// to do something fancier or implementation specific, i.e. TinyG Buffer
-			// actually sends back data on a perline basis rather than our method
-			// where we just send the moment we get it. the reason for this is that
-			// the browser was sometimes getting back packets out of order which
-			// of course would screw things up when parsing
-
-			if p.bufferwatcher.IsBufferGloballySendingBackIncomingData() == false {
-				//m := SpPortMessage{"Alice", "Hello"}
-				m := SpPortMessage{p.portConf.Name, data}
-				//log.Print("The m obj struct is:")
-				//log.Print(m)
-
-				//b, err := json.MarshalIndent(m, "", "\t")
-				b, err := json.Marshal(m)
-				if err != nil {
-					log.Println(err)
-					h.broadcastSys <- []byte("Error creating json on " + p.portConf.Name + " " +
-						err.Error() + " The data we were trying to convert is: " + string(ch[:n]))
-					break
-				}
-				//log.Print("Printing out json byte data...")
-				//log.Print(string(b))
-				h.broadcastSys <- b
-			}
 		}
 
 		// double check that we got characters in the buffer
@@ -332,7 +304,7 @@ func spHandlerOpen(portname string, baud int, buftype string) {
 	case "timedbinary":
 		bw = NewBufferflowTimedBinary(portname, h.broadcastSys)
 	case "default":
-		bw = NewBufferflowDefault(portname)
+		bw = NewBufferflowDefault(portname, h.broadcastSys)
 	default:
 		log.Panicf("unknown buffer type: %s", buftype)
 	}