Daemon Mode

Author: codehz

daemon.go

@@ -0,0 +1,130 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"net"
+	"os"
+	"os/signal"
+	"strings"
+	"syscall"
+)
+
+func runDaemon(base, datapath, logfile, socket string) {
+	log, err := os.OpenFile(logfile, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
+	if err != nil {
+		panic(err)
+	}
+	defer log.Close()
+	fmt.Fprintln(log, "Starting...")
+	defer fmt.Fprintln(log, "Stopping...")
+	sigs := make(chan os.Signal, 1)
+	defer close(sigs)
+	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
+	l, err := net.Listen("unix", socket)
+	if err != nil {
+		panic(err)
+	}
+	defer l.Close()
+	defer os.Remove(socket)
+	exec := make(chan string)
+	defer close(exec)
+	conns := make(map[net.Conn]bool)
+	newConns := make(chan net.Conn, 128)
+	deadConns := make(chan net.Conn, 128)
+	publishes := make(chan string, 128)
+	done := make(chan struct{}, 1)
+	defer func() {
+		done <- struct{}{}
+	}()
+	go func() {
+		for {
+			c, err := l.Accept()
+			if err != nil {
+				break
+			}
+			newConns <- c
+		}
+	}()
+	go func() {
+		defer close(newConns)
+		defer close(deadConns)
+		defer close(publishes)
+		defer close(done)
+	outer:
+		for {
+			select {
+			case c := <-newConns:
+				conns[c] = true
+				go func() {
+					bs := bufio.NewScanner(c)
+					for bs.Scan() {
+						exec <- bs.Text()
+					}
+					deadConns <- c
+				}()
+			case c := <-deadConns:
+				_ = c.Close()
+				delete(conns, c)
+			case text := <-publishes:
+				for conn := range conns {
+					go fmt.Fprintln(conn, text)
+				}
+			case <-done:
+				break outer
+			}
+		}
+	}()
+	doLog := func(text string) {
+		fmt.Fprintf(log, "%s\n", text)
+		publishes <- text
+	}
+	for func() bool {
+		f, quit := runImpl(base, datapath)
+		defer f.Close()
+		defer quit()
+		status := make(chan bool)
+		defer close(status)
+		execFn := func(src, cmd string) {
+			fmt.Fprintf(f, "%s\n", cmd)
+			doLog(fmt.Sprintf("%s>%s", src, cmd))
+			switch {
+			case strings.HasPrefix(cmd, ":restart"):
+				status <- true
+			case strings.HasPrefix(cmd, ":quit"):
+				status <- false
+			}
+		}
+		cache := 0
+		go packOutput(f, func(text string) {
+			if strings.HasPrefix(text, "\x07") {
+				execFn("mod", text[1:len(text)-1])
+				cache++
+			} else {
+				if cache == 0 {
+					doLog(fmt.Sprintf("\033[0m%s\033[0m", replacer.Replace(text)))
+				} else {
+					cache--
+				}
+			}
+		})
+		for {
+			select {
+			case x := <-status:
+				return x
+			case <-sigs:
+				return false
+			case line, ok := <-exec:
+				if ok {
+					cache++
+					go execFn("socket", line)
+				} else {
+					return false
+				}
+			}
+		}
+	}() {
+		doLog("Restarting...")
+	}
+	return
+}

main.go

@@ -159,6 +159,41 @@ func (c *modsCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{})
 	return subcommands.ExitSuccess
 }
 
+type daemonCmd struct {
+	bin     string
+	data    string
+	link    string
+	logfile string
+	socket  string
+}
+
+func (*daemonCmd) Name() string     { return "daemon" }
+func (*daemonCmd) Synopsis() string { return "Daemon" }
+func (*daemonCmd) Usage() string {
+	return "daemon [-bin] [-data] [-link] [-daemon]\n\tRun server as daemon"
+}
+func (d *daemonCmd) SetFlags(f *flag.FlagSet) {
+	f.StringVar(&d.data, "data", "data", "Minecraft Data Directory")
+	f.StringVar(&d.bin, "bin", "bin", "Minecraft Server Binary Path")
+	f.StringVar(&d.link, "link", "games", "World Link Path")
+	f.StringVar(&d.logfile, "logfile", "games/mcpeserver.log", "Log File Path")
+	f.StringVar(&d.socket, "socket", "games/mcpeserver.sock", "Socket File Path")
+}
+func (d *daemonCmd) Execute(_ context.Context, f *flag.FlagSet, _ ...interface{}) (ret subcommands.ExitStatus) {
+	defer func() {
+		if r := recover(); r != nil {
+			fmt.Println("\033[5;91mError: \n", r)
+			ret = subcommands.ExitFailure
+		}
+	}()
+	d.data, _ = filepath.Abs(d.data)
+	d.link, _ = filepath.Abs(d.link)
+	d.bin, _ = filepath.Abs(d.bin)
+	prepare(d.data, d.link)
+	runDaemon(d.bin, d.data, d.logfile, d.socket)
+	return subcommands.ExitSuccess
+}
+
 type updateCmd struct {
 	path string
 }
@@ -211,6 +246,7 @@ func main() {
 	subcommands.Register(&downloadCmd{}, "")
 	subcommands.Register(&unpackCmd{}, "")
 	subcommands.Register(&runCmd{}, "")
+	subcommands.Register(&daemonCmd{}, "")
 	subcommands.Register(&updateCmd{}, "")
 	subcommands.Register(&modsCmd{}, "")
 	subcommands.Register(&versionCmd{}, "")

version.go

@@ -1,3 +1,3 @@
 package main
 
-var VERSION = "0.4.3"
+var VERSION = "0.5"