Restructure telnet package

stream/telnet/convert.go

@@ -0,0 +1,103 @@
+package telnet
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"io"
+	"log"
+	"os/exec"
+
+	"gitlab.crans.org/nounous/ghostream/stream"
+)
+
+// Convert rawvideo to ANSI text
+func streamToTextStream(stream *stream.Stream, text *[]byte, cfg *Options) {
+	// Start ffmpeg
+	video := make(chan []byte)
+	stream.Register(video)
+	_, rawvideo, err := startFFmpeg(video, cfg)
+	if err != nil {
+		log.Printf("Error while starting ffmpeg: %s", err)
+	}
+
+	pixelBuff := make([]byte, cfg.Width*cfg.Height)
+	textBuff := bytes.Buffer{}
+	for {
+		n, err := (*rawvideo).Read(pixelBuff)
+		if err != nil {
+			log.Printf("An error occurred while reading input: %s", err)
+			break
+		}
+		if n == 0 {
+			// Stream is finished
+			break
+		}
+
+		// Header
+		textBuff.Reset()
+		textBuff.Grow((40*cfg.Width+6)*cfg.Height + 47)
+		for i := 0; i < 42; i++ {
+			textBuff.WriteByte('\n')
+		}
+
+		// Convert image to ASCII
+		for i, pixel := range pixelBuff {
+			if i%cfg.Width == 0 {
+				// New line
+				textBuff.WriteString("\033[49m\n")
+			}
+
+			// Print two times the character to make a square
+			text := fmt.Sprintf("\033[48;2;%d;%d;%dm ", pixel, pixel, pixel)
+			textBuff.WriteString(text)
+			textBuff.WriteString(text)
+		}
+		textBuff.WriteString("\033[49m")
+
+		*text = textBuff.Bytes()
+	}
+}
+
+// Start a ffmpeg instance to convert stream into rawvideo
+func startFFmpeg(in <-chan []byte, cfg *Options) (*exec.Cmd, *io.ReadCloser, error) {
+	bitrate := fmt.Sprintf("%dk", cfg.Width*cfg.Height/cfg.Delay)
+	ffmpegArgs := []string{"-hide_banner", "-loglevel", "error", "-i", "pipe:0",
+		"-an", "-vf", fmt.Sprintf("scale=%dx%d", cfg.Width, cfg.Height),
+		"-b:v", bitrate, "-minrate", bitrate, "-maxrate", bitrate, "-bufsize", bitrate,
+		"-q", "42", "-pix_fmt", "gray", "-f", "rawvideo", "pipe:1"}
+	ffmpeg := exec.Command("ffmpeg", ffmpegArgs...)
+
+	// Handle errors output
+	errOutput, err := ffmpeg.StderrPipe()
+	if err != nil {
+		return nil, nil, err
+	}
+	go func() {
+		scanner := bufio.NewScanner(errOutput)
+		for scanner.Scan() {
+			log.Printf("[TELNET FFMPEG %s] %s", "demo", scanner.Text())
+		}
+	}()
+
+	// Handle text output
+	output, err := ffmpeg.StdoutPipe()
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// Handle stream input
+	input, err := ffmpeg.StdinPipe()
+	if err != nil {
+		return nil, nil, err
+	}
+	go func() {
+		for data := range in {
+			input.Write(data)
+		}
+	}()
+
+	// Start process
+	err = ffmpeg.Start()
+	return ffmpeg, &output, nil
+}

stream/telnet/handler.go

@@ -0,0 +1,82 @@
+package telnet
+
+import (
+	"log"
+	"net"
+	"strings"
+	"time"
+
+	"gitlab.crans.org/nounous/ghostream/stream"
+)
+
+func handleViewer(s net.Conn, streams map[string]*stream.Stream, textStreams map[string]*[]byte, cfg *Options) {
+	// Prompt user about stream name
+	if _, err := s.Write([]byte("[GHOSTREAM]\nEnter stream name: ")); err != nil {
+		log.Printf("Error while writing to TCP socket: %s", err)
+		s.Close()
+		return
+	}
+	buff := make([]byte, 255)
+	n, err := s.Read(buff)
+	if err != nil {
+		log.Printf("Error while requesting stream ID to telnet client: %s", err)
+		s.Close()
+		return
+	}
+	name := strings.TrimSpace(string(buff[:n]))
+	if len(name) < 1 {
+		// Too short, exit
+		s.Close()
+		return
+	}
+
+	// Wait a bit
+	time.Sleep(time.Second)
+
+	// Get requested stream
+	st, ok := streams[name]
+	if !ok {
+		log.Println("Stream does not exist, kicking new Telnet viewer")
+		if _, err := s.Write([]byte("This stream is inactive.\n")); err != nil {
+			log.Printf("Error while writing to TCP socket: %s", err)
+		}
+		s.Close()
+		return
+	}
+
+	// Register new client
+	log.Printf("New Telnet viewer for stream %s", name)
+	st.IncrementClientCount()
+
+	// Hide terminal cursor
+	if _, err = s.Write([]byte("\033[?25l")); err != nil {
+		log.Printf("Error while writing to TCP socket: %s", err)
+		s.Close()
+		return
+	}
+
+	// Send stream
+	for {
+		text, ok := textStreams[name]
+		if !ok {
+			log.Println("Stream is not converted to text, kicking Telnet viewer")
+			if _, err := s.Write([]byte("This stream cannot be opened.\n")); err != nil {
+				log.Printf("Error while writing to TCP socket: %s", err)
+			}
+			break
+		}
+
+		// Send text to client
+		n, err := s.Write(*text)
+		if err != nil || n == 0 {
+			log.Printf("Error while sending TCP data: %s", err)
+			break
+		}
+
+		time.Sleep(time.Duration(cfg.Delay) * time.Millisecond)
+	}
+
+	// Close connection
+	s.Close()
+	st.DecrementClientCount()
+}

stream/telnet/telnet.go

@@ -2,20 +2,11 @@
 package telnet
 
 import (
-	"fmt"
-	"io"
 	"log"
 	"net"
-	"strings"
 	"time"
-)
 
-var (
+	"gitlab.crans.org/nounous/ghostream/stream"
-	// Cfg contains the different options of the telnet package, see below
-	// TODO Config should not be exported
-	Cfg            *Options
-	currentMessage map[string]*string
-	clientCount    map[string]int
 )
 
 // Options holds telnet package configuration
@@ -27,152 +18,52 @@ type Options struct {
 	Delay         int
 }
 
-// Serve starts the telnet server and listen to clients
+// Serve Telnet server
-func Serve(config *Options) {
+func Serve(streams map[string]*stream.Stream, cfg *Options) {
-	Cfg = config
+	if !cfg.Enabled {
-
+		// Telnet is not enabled, ignore
-	if !config.Enabled {
 		return
 	}
 
-	currentMessage = make(map[string]*string)
+	// Start conversion routine
-	clientCount = make(map[string]int)
+	textStreams := make(map[string]*[]byte)
+	go autoStartConversion(streams, textStreams, cfg)
 
-	listener, err := net.Listen("tcp", config.ListenAddress)
+	// Start TCP server
+	listener, err := net.Listen("tcp", cfg.ListenAddress)
 	if err != nil {
-		log.Printf("Error while listening to the address %s: %s", config.ListenAddress, err)
+		log.Fatalf("Error while listening to the address %s: %s", cfg.ListenAddress, err)
-		return
 	}
+	log.Printf("Telnet server listening on %s", cfg.ListenAddress)
 
-	go func() {
+	// Handle each new client
-		for {
+	for {
-			s, err := listener.Accept()
+		s, err := listener.Accept()
-			if err != nil {
+		if err != nil {
-				log.Printf("Error while accepting TCP socket: %s", s)
+			log.Printf("Error while accepting TCP socket: %s", s)
+			continue
+		}
+
+		go handleViewer(s, streams, textStreams, cfg)
+	}
+}
+
+// Convertion routine listen to existing stream and start text conversions
+func autoStartConversion(streams map[string]*stream.Stream, textStreams map[string]*[]byte, cfg *Options) {
+	for {
+		for name, stream := range streams {
+			textStream, ok := textStreams[name]
+			if ok {
+				// Everything is fine
 				continue
 			}
 
-			go func(s net.Conn) {
+			// Start conversion
-				streamID := ""
+			log.Print("Starting text conversion of %s", name)
-				// Request for stream ID
+			textStream = &[]byte{}
-				for {
+			textStreams[name] = textStream
-					_, err = s.Write([]byte("[GHOSTREAM]\nEnter stream ID: "))
+			go streamToTextStream(stream, textStream, cfg)
-					if err != nil {
-						log.Println("Error while requesting stream ID to telnet client")
-						_ = s.Close()
-						return
-					}
-					buff := make([]byte, 255)
-					n, err := s.Read(buff)
-					if err != nil {
-						log.Println("Error while requesting stream ID to telnet client")
-						_ = s.Close()
-						return
-					}
-
-					// Avoid bruteforce
-					time.Sleep(3 * time.Second)
-
-					streamID = string(buff[:n])
-					streamID = strings.Replace(streamID, "\r", "", -1)
-					streamID = strings.Replace(streamID, "\n", "", -1)
-
-					if len(streamID) > 0 {
-						if strings.ToLower(streamID) == "exit" {
-							_, _ = s.Write([]byte("Goodbye!\n"))
-							_ = s.Close()
-							return
-						}
-						if _, ok := currentMessage[streamID]; !ok {
-							_, err = s.Write([]byte("Unknown stream ID.\n"))
-							if err != nil {
-								log.Println("Error while requesting stream ID to telnet client")
-								_ = s.Close()
-								return
-							}
-							continue
-						}
-						break
-					}
-				}
-
-				clientCount[streamID]++
-
-				// Hide terminal cursor
-				_, _ = s.Write([]byte("\033[?25l"))
-
-				for {
-					n, err := s.Write([]byte(*currentMessage[streamID]))
-					if err != nil {
-						log.Printf("Error while sending TCP data: %s", err)
-						_ = s.Close()
-						clientCount[streamID]--
-						break
-					}
-					if n == 0 {
-						_ = s.Close()
-						clientCount[streamID]--
-						break
-					}
-					time.Sleep(time.Duration(config.Delay) * time.Millisecond)
-				}
-			}(s)
 		}
-	}()
+		time.Sleep(time.Second)
-
-	log.Println("Telnet server initialized")
-}
-
-// GetNumberConnectedSessions returns the numbers of clients that are viewing the stream through a telnet shell
-func GetNumberConnectedSessions(streamID string) int {
-	if Cfg == nil || !Cfg.Enabled {
-		return 0
-	}
-	return clientCount[streamID]
-}
-
-// StartASCIIArtStream send all packets received by ffmpeg as ASCII Art to telnet clients
-func StartASCIIArtStream(streamID string, reader io.ReadCloser) {
-	if !Cfg.Enabled {
-		_ = reader.Close()
-		return
-	}
-
-	currentMessage[streamID] = new(string)
-	pixelBuff := make([]byte, Cfg.Width*Cfg.Height)
-	textBuff := strings.Builder{}
-	for {
-		n, err := reader.Read(pixelBuff)
-		if err != nil {
-			log.Printf("An error occurred while reading input: %s", err)
-			break
-		}
-		if n == 0 {
-			// Stream is finished
-			break
-		}
-
-		// Header
-		textBuff.Reset()
-		textBuff.Grow((40*Cfg.Width+6)*Cfg.Height + 47)
-		for i := 0; i < 42; i++ {
-			textBuff.WriteByte('\n')
-		}
-
-		// Convert image to ASCII
-		for i, pixel := range pixelBuff {
-			if i%Cfg.Width == 0 {
-				// New line
-				textBuff.WriteString("\033[49m\n")
-			}
-
-			// Print two times the character to make a square
-			text := fmt.Sprintf("\033[48;2;%d;%d;%dm ", pixel, pixel, pixel)
-			textBuff.WriteString(text)
-			textBuff.WriteString(text)
-		}
-		textBuff.WriteString("\033[49m")
-
-		*(currentMessage[streamID]) = textBuff.String()
 	}
 }

stream/telnet/telnet_test.go

@@ -1,41 +1,38 @@
 package telnet
 
 import (
-	"bytes"
-	"io/ioutil"
-	"math/rand"
-	"net"
 	"testing"
-	"time"
+
+	"gitlab.crans.org/nounous/ghostream/stream"
 )
 
 // TestTelnetOutput creates a TCP client that connects to the server and get one image.
 func TestTelnetOutput(t *testing.T) {
 	// Try to start Telnet server while it is disabled
-	Serve(&Options{Enabled: false})
+	streams := make(map[string]*stream.Stream)
-	StartASCIIArtStream("demo", ioutil.NopCloser(bytes.NewReader([]byte{})))
+	go Serve(streams, &Options{Enabled: false})
-	if GetNumberConnectedSessions("demo") != 0 {
+
-		t.Fatalf("Mysteriously found %d connected clients", GetNumberConnectedSessions("demo"))
+	// FIXME test connect
-	}
 
 	// Enable and start Telnet server
-	Serve(&Options{
+	cfg := Options{
 		Enabled:       true,
 		ListenAddress: "127.0.0.1:8023",
 		Width:         80,
 		Height:        45,
 		Delay:         50,
-	})
+	}
+	go Serve(streams, &cfg)
+
+	// FIXME test connect
 
 	// Generate a random image, that should be given by FFMPEG
-	sampleImage := make([]byte, Cfg.Width*Cfg.Height)
+	/*sampleImage := make([]byte, cfg.Width*cfg.Height)
 	rand.Read(sampleImage)
 	reader := ioutil.NopCloser(bytes.NewBuffer(sampleImage))
-	// Send the image to the server
-	StartASCIIArtStream("demo", reader)
 
 	// Connect to the Telnet server
-	client, err := net.Dial("tcp", Cfg.ListenAddress)
+	client, err := net.Dial("tcp", cfg.ListenAddress)
 	if err != nil {
 		t.Fatalf("Error while connecting to the TCP server: %s", err)
 	}
@@ -46,7 +43,7 @@ func TestTelnetOutput(t *testing.T) {
 		t.Fatalf("Error while closing TCP connection: %s", err)
 	}
 
-	client, err = net.Dial("tcp", Cfg.ListenAddress)
+	client, err = net.Dial("tcp", cfg.ListenAddress)
 	if err != nil {
 		t.Fatalf("Error while connecting to the TCP server: %s", err)
 	}
@@ -110,5 +107,5 @@ func TestTelnetOutput(t *testing.T) {
 	time.Sleep(time.Second)
 	if GetNumberConnectedSessions("demo") != 0 {
 		t.Fatalf("Expected no telnet client, found %d", GetNumberConnectedSessions("demo"))
-	}
+	}*/
 }

web/handler.go

@@ -157,7 +157,7 @@ func statisticsHandler(w http.ResponseWriter, r *http.Request) {
 	stream, ok := streams[name]
 	if ok {
 		// Get number of output channels
-		userCount = stream.Count()
+		userCount = stream.ClientCount()
 	}
 
 	// Display connected users statistics