lux/main.go

package main

import (
	"encoding/xml"
	"flag"
	"fmt"
	"lux/crypto"
	"lux/node"
	"lux/proto"
	"lux/rpc"
	"os"
	"os/signal"
	"strconv"
	"strings"
	"syscall"

	"github.com/op/go-logging"
	"github.com/sevlyar/go-daemon"
)

var isNode bool
var isHost bool
var isRpc bool
var configPath string
var bootstrap bool
var justNodeId bool
var daemonize bool
var pidPath string

type LogConfig struct {
	XMLName xml.Name `xml:"log"`
	Level   string   `xml:"level,attr"`
	LogPath string   `xml:",innerxml"`
}

type NodeConfig struct {
	XMLName   xml.Name `xml:"node"`
	KeyStore  string   `xml:"keystore"`
	ID        string   `xml:"id"`
	Interior  []string `xml:"interior"`
	Exterior  []string `xml:"exterior"`
	Neighbors []struct {
		XMLName xml.Name `xml:"neighbor"`
		ID      string   `xml:"id"`
		Address string   `xml:"address"`
	} `xml:"neighbor"`

	RPCEndpoints []string `xml:"rpc"`

	Log LogConfig `xml:"log"`
}

func setupLogging(log LogConfig) {
	var level logging.Level
	switch log.Level {
	case "critical":
		level = logging.CRITICAL
	case "error":
		level = logging.ERROR
	case "warning":
		level = logging.WARNING
	case "notice":
		level = logging.NOTICE
	case "info":
		level = logging.INFO
	case "debug":
		level = logging.DEBUG
	default:
		level = logging.INFO
	}

	// if log tag has file path, then it open file in append mode,
	// otherwise it will use default stdout logger
	if log.LogPath != "" {
		logFile, err := os.OpenFile(log.LogPath, os.O_WRONLY|os.O_CREATE|os.O_APPEND, os.FileMode(0600))
		if err != nil {
			fmt.Fprintf(os.Stderr, "failed to open log file: %v\n", err)
			os.Exit(1)
		}

		logging.SetBackend(logging.NewLogBackend(logFile, "", 0))
	}

	logging.SetLevel(level, "")
}

func bootstrapNode() {
	xmlBytes, err := os.ReadFile(configPath)
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}

	var config NodeConfig
	if err := xml.Unmarshal(xmlBytes, &config); err != nil {
		fmt.Fprintf(os.Stderr, "failed to parse xml: %v", err)
		os.Exit(1)
	}

	// create keystore, generate node key
	ks := crypto.NewLuxKeyStore(config.KeyStore)
	nodeKey, err := crypto.NewLuxKey(proto.LuxTypeNode)
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
	if err := ks.Put(nodeKey); err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}

	if justNodeId {
		fmt.Println(nodeKey.Id.String())
	} else {
		fmt.Printf("Your node key ID is: %s\nAdd <id>%s</id> to your node config!\n",
			nodeKey.Id.String(), nodeKey.Id.String())
	}
}

var log = logging.MustGetLogger("main")

func becomeDaemon() {
	cwd, err := os.Getwd()
	if err != nil {
		log.Criticalf("Getwd failed: %v", err)
		os.Exit(1)
	}

	ctx := &daemon.Context{
		PidFileName: pidPath,
		PidFilePerm: 0644,
		WorkDir:     cwd,
		Umask:       002,
	}

	dmn, err := ctx.Reborn()
	if err != nil {
		log.Criticalf("ctx.Reborn failed: %v", err)
		os.Exit(1)
	}
	if dmn != nil {

		// parent process no longer needed
		os.Exit(0)
	}

	// -- WE ARE NOW THE DAEMON --

	// write pid
	if pidPath != "" {
		pidFile, err := os.OpenFile(pidPath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, os.FileMode(0644))
		if err != nil {
			log.Errorf("failed to create pidfile: %v", err)
		}
		defer pidFile.Close()

		pidBytes := []byte(strconv.Itoa(os.Getpid()))
		_, err = pidFile.Write(pidBytes)
		if err != nil {
			log.Errorf("failed to write pidfile: %v", err)
		}
	}
}

func nodeMain() {
	xmlBytes, err := os.ReadFile(configPath)
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}

	var config NodeConfig
	if err := xml.Unmarshal(xmlBytes, &config); err != nil {
		log.Criticalf("failed to parse xml: %v", err)
		os.Exit(1)
	}

	// setup logging
	setupLogging(config.Log)

	// only after logging setup, we may became daemon
	if daemonize {
		becomeDaemon()
	}

	// check presense of keystore and id in config
	if config.KeyStore == "" {
		log.Critical("no keystore path specified!")
		os.Exit(1)
	}
	if config.ID == "" {
		log.Critical("no ID in config! You need to --bootstrap")
		os.Exit(1)
	}

	nodeId, err := proto.ParseLuxID(config.ID)
	if err != nil {
		log.Criticalf("failed to parse node id: %v", err)
		os.Exit(1)
	}

	// load keystore
	ks := crypto.NewLuxKeyStore(config.KeyStore)
	if err := ks.Load(); err != nil {
		log.Criticalf("failed to laod keystore: %v", err)
		os.Exit(1)
	}

	nodeKey, ok := ks.Get(nodeId)
	if !ok {
		log.Critical("node key is not present in key store!")
		os.Exit(1)
	}

	// create node
	node := node.NewLuxNode(nodeKey, ks)

	// add interior exterior channels
	for _, interior := range config.Interior {
		if err := node.AddInterior(interior); err != nil {
			log.Criticalf("failed to add interior %s: %v", interior, err)
			os.Exit(1)
		}
	}
	for _, exterior := range config.Exterior {
		if err := node.AddExterior(exterior); err != nil {
			log.Criticalf("failed to add exterior %s: %v", exterior, err)
			os.Exit(1)
		}
	}

	// add neighbors
	for _, neighbor := range config.Neighbors {
		neighId, err := proto.ParseLuxID(neighbor.ID)
		if err != nil {
			log.Criticalf("failed to parse neigh id %s: %v", neighbor.ID, err)
			os.Exit(1)
		}

		if err := node.AddNeighbor(neighId, neighbor.Address); err != nil {
			log.Criticalf("failed to add neighbor %s: %v", neighbor.ID, err)
			os.Exit(1)
		}
	}

	// create rpc server
	sv := rpc.NewLuxRpcServer()
	sv.RegisterController(&node)

	// parse and and spawn rpc endpoints
	for _, rpcPath := range config.RPCEndpoints {
		if strings.HasPrefix(rpcPath, "unix://") {
			path := rpcPath[7:]

			if err := sv.AddEndpoint("unix", path, rpc.LuxRpcTypeRoot); err != nil {
				log.Criticalf("failed to add root rpc %s: %v", path, err)
				os.Exit(1)
			}
		} else if strings.HasPrefix(rpcPath, "tcp://") {
			path := rpcPath[6:]

			if err := sv.AddEndpoint("tcp", path, rpc.LuxRpcTypeQuery); err != nil {
				log.Criticalf("failed to add query rpc %s: %v", path, err)
				os.Exit(1)
			}
		} else {
			log.Criticalf("unknown rpc type %s. It must be either unix:// or tcp://\n", rpcPath)
			os.Exit(1)
		}
	}

	// start node
	node.Start()

	// TODO: daemonize

	// register go channel to receive unix signals,
	// while hogging main thread to read them and take action.
	// its important to keep main thread alive for process to run
	sigs := make(chan os.Signal, 1)
	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)

signaling:
	for {
		sig := <-sigs
		log.Debug(sig)
		switch sig {
		case syscall.SIGINT:
			break signaling
		case syscall.SIGTERM:
			break signaling
		}
	}

	// stop daemon
	node.Stop()
}

func hostMain() {

}

var rpcPath string
var rpcNewHost string
var rpcNewNode string
var rpcQueryHost string
var rpcQueryHostname string
var rpcGetRoutes bool
var rpcGetKeys bool

func rpcMain() {
	var cl rpc.LuxRpcClient
	var err error

	if strings.HasPrefix(rpcPath, "unix://") {
		cl, err = rpc.LuxDialRpc("unix", rpcPath[7:])
	} else if strings.HasPrefix(rpcPath, "tcp://") {
		cl, err = rpc.LuxDialRpc("tcp", rpcPath[6:])
	} else {
		fmt.Fprintln(os.Stderr, "unknown RPC network (must be unix:// or tcp://)")
		os.Exit(1)
	}

	if err != nil {
		fmt.Fprintf(os.Stderr, "failed to dial RPC: %v\n", err)
		os.Exit(1)
	}

	defer cl.Close()

	// now we send requests
	counter := 0

	if rpcGetRoutes {
		rpcRes, rpcErr, err := cl.Execute(rpc.LuxRpcRequest{
			RequestID:  counter,
			Controller: "router",
			Command:    "get",
		})
		if err != nil {
			fmt.Fprintf(os.Stderr, "failed to send request: %v\n", err)
			os.Exit(1)
		}
		counter++

		if rpcErr.ErrorCode != 0 {
			// we got error
			fmt.Fprintf(os.Stderr, "RPC error %d: %s\n", rpcErr.ErrorCode, rpcErr.Message)
			os.Exit(1)
		}

		// pretty print routes
		for _, route := range rpcRes.Routes {
			fmt.Println(route)
		}
	}

	if rpcGetKeys {
		rpcRes, rpcErr, err := cl.Execute(rpc.LuxRpcRequest{
			RequestID:  counter,
			Controller: "ks",
			Command:    "get",
		})
		if err != nil {
			fmt.Fprintf(os.Stderr, "failed to send request: %v\n", err)
			os.Exit(1)
		}
		counter++

		if rpcErr.ErrorCode != 0 {
			// we got error
			fmt.Fprintf(os.Stderr, "RPC error %d: %s\n", rpcErr.ErrorCode, rpcErr.Message)
			os.Exit(1)
		}

		// pretty print keys
		for _, node := range rpcRes.Keystore.Nodes {
			fmt.Printf("node %s\n", node.ID)
		}
		for _, host := range rpcRes.Keystore.Hosts {
			fmt.Printf("host %s\n", host.ID)
		}
	}

	if rpcNewHost != "" {
		rpcRes, rpcErr, err := cl.Execute(rpc.LuxRpcRequest{
			RequestID:  counter,
			Controller: "node",
			Command:    "new-host",
		})
		if err != nil {
			fmt.Fprintf(os.Stderr, "failed to send request: %v\n", err)
			os.Exit(1)
		}
		counter++

		if rpcErr.ErrorCode != 0 {
			// we got error
			fmt.Fprintf(os.Stderr, "RPC error %d: %s\n", rpcErr.ErrorCode, rpcErr.Message)
			os.Exit(1)
		}

		// deserialize keystore
		_, err = crypto.LuxKeyStoreFromRpc(rpcRes.Keystore, rpcNewHost)
		if err != nil {
			fmt.Fprintf(os.Stderr, "failed to save host keystore: %v\n", err)
		}
	}

	if rpcNewNode != "" {
		rpcRes, rpcErr, err := cl.Execute(rpc.LuxRpcRequest{
			RequestID:  counter,
			Controller: "node",
			Command:    "new-node",
		})
		if err != nil {
			fmt.Fprintf(os.Stderr, "failed to send request: %v\n", err)
			os.Exit(1)
		}
		counter++

		if rpcErr.ErrorCode != 0 {
			// we got error
			fmt.Fprintf(os.Stderr, "RPC error %d: %s\n", rpcErr.ErrorCode, rpcErr.Message)
			os.Exit(1)
		}

		// deserialize keystore
		_, err = crypto.LuxKeyStoreFromRpc(rpcRes.Keystore, rpcNewHost)
		if err != nil {
			fmt.Fprintf(os.Stderr, "failed to save node keystore: %v\n", err)
		}
	}
}

func main() {
	// first, we need to determine who we are: node, host or rpc.
	// determine by executable name (lux binary will be symlinked to lux-node, lux-host, luc-rpc),
	// or by explicit cli flag (--node, --host, --rpc)
	flag.BoolVar(&isNode, "node", false, "LUX node")
	flag.BoolVar(&isHost, "host", false, "LUX host")
	flag.StringVar(&configPath, "config", "", "node or host config")
	flag.BoolVar(&bootstrap, "bootstrap", false, "bootstrap node keystore. config must be specified")
	flag.BoolVar(&justNodeId, "just-node-id", false, "when bootstrapping only output node id to stdout")
	flag.BoolVar(&daemonize, "daemon", false, "run LUX as daemon in background")
	flag.StringVar(&pidPath, "pid", "", "after daemonization LUX will write its PID here")

	flag.StringVar(&rpcPath, "rpc", "", "Run as RPC client, specify path to RPC UNIX socket or TCP socket, must be in unix:// or tcp:// form")
	flag.StringVar(&rpcNewHost, "rpc-new-host", "", "RPC node create new host, specifies path for new keystore")
	flag.StringVar(&rpcNewNode, "rpc-new-node", "", "RPC node create new node, specifies path for new keystore")
	flag.StringVar(&rpcQueryHost, "rpc-query-host", "", "RPC node query host state by ID")
	flag.StringVar(&rpcQueryHostname, "rpc-query-hostname", "", "RPC node querty host state by hostname")
	flag.BoolVar(&rpcGetRoutes, "rpc-get-routes", false, "RPC node list established routes")
	flag.BoolVar(&rpcGetKeys, "rpc-get-keys", false, "RPC node list keys")
	flag.Parse()

	if rpcPath != "" {
		isRpc = true
	} else if !isNode && !isHost {
		// determine by argv[0]
		if strings.Contains(os.Args[0], "node") {
			isNode = true
		} else if strings.Contains(os.Args[0], "host") {
			isHost = true
		}
	}

	if (isNode || isHost) && configPath == "" {
		fmt.Fprintln(os.Stderr, "must provide config path")
		os.Exit(1)
	} else if isRpc && rpcPath == "" {
		fmt.Fprintln(os.Stderr, "must provide RPC socket path")
		os.Exit(1)
	}

	if isNode && bootstrap {
		bootstrapNode()
		return
	}

	if isNode {
		nodeMain()
	} else if isHost {
		hostMain()
	} else if isRpc {
		rpcMain()
	}
}