Go Stdout logging daemon, listen to logs on telnet port 9900

logd.go

package main

import (
	"flag"
	"io"
	"log"
	"os"
	"os/exec"
	"net"
	"stressd/config"
	"strings"
	"time"
)

var conf = config.New()

func init() {
	flag.StringVar(&conf.Address, "addr", "0.0.0.0", "the IP address for the tcp listener")
	flag.StringVar(&conf.Port, "port", "9900", "the port for the tcp listener")
	flag.BoolVar(&conf.HelpRequested, "help", conf.HelpRequested, "display this help information")
}
var commandArgs []string

func parseArgs() {
	flag.Parse()
	commandArgs = flag.Args()
	if conf.HelpRequested {
		flag.Usage()
		os.Exit(1)
	}
	config.Config = conf
}

var stdout io.ReadCloser
var stderr io.ReadCloser
var startDevNull chan bool
var stopDevNull chan bool

func flushToDevNull(){
	var devNull os.File
	for {
		select {
		case <-startDevNull:
			devNull, err := os.OpenFile("/dev/null", os.O_WRONLY, 0666)
			if err != nil {
				log.Fatal(err)
			}
			pipeOutputToFile(devNull)
		case <-stopDevNull:
			devNull.Close()
		}
	}
}

// either: there are active connections
// or: pipe everything to /dev/null

func startStdOutListener() {
	cmd := exec.Command(commandArgs[0], commandArgs[1])
	var err error
	stdout, err = cmd.StdoutPipe()
	if err != nil {
		log.Fatal(err)
	}
	stderr, err = cmd.StderrPipe()
	if err := cmd.Start(); err != nil {
		log.Fatal(err)
	}
	go flushToDevNull()
	startDevNull <- true
}

func pipeOutputToFile(conn io.Writer){

	go func(){
		_, err := io.Copy(conn, stdout)
		if err != nil {
			log.Fatal(err)
		}
	}()
	go func(){
		_, err := io.Copy(conn, stderr)
		if err != nil {
			log.Fatal(err)
		}
	}()
}

func handleConnection(conn net.Conn){
	pipeOutputToFile(conn)
	c := conn
	for {
		select {
		default:
			var b []byte 
			one := b[0:0]
			c.SetReadDeadline(time.Now())
			if _, err := c.Read(one); err == io.EOF {
				log.Fatal(c, "detected closed LAN connection")
				c.Close()
				c = nil
				startDevNull <- true
			} else {
				c.SetReadDeadline(time.Time{})
			}
		}
	}
}

func startTcpServer() {
	ln, err := net.Listen("tcp", ":" + conf.Port)
	if err != nil {
		log.Fatal(err)
	}
	for {
		conn, err := ln.Accept()
		if err != nil {
			log.Fatal(err)
			continue
		}
		stopDevNull <- true
		go handleConnection(conn)
	}
}

func main() {
	parseArgs()
	log.Println("logd [ cmd:", strings.Join(commandArgs, " "), "- pid:", os.Getpid(), "- ver:", config.VERSION, "]")
	startDevNull = make(chan bool, 1)
	stopDevNull = make(chan bool, 1)


	go startTcpServer()
	startStdOutListener()
}