syncthing/cmd/stcli/main.go

// Copyright (C) 2019 The Syncthing Authors.
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this file,
// You can obtain one at https://mozilla.org/MPL/2.0/.

package main

import (
	"bufio"
	"crypto/tls"
	"encoding/json"
	"flag"
	"log"
	"os"
	"reflect"
	"strings"

	"github.com/AudriusButkevicius/recli"
	"github.com/flynn-archive/go-shlex"
	"github.com/mattn/go-isatty"
	"github.com/pkg/errors"
	"github.com/syncthing/syncthing/lib/build"
	"github.com/syncthing/syncthing/lib/config"
	"github.com/syncthing/syncthing/lib/locations"
	"github.com/syncthing/syncthing/lib/protocol"
	"github.com/urfave/cli"
)

func main() {
	// This is somewhat a hack around a chicken and egg problem.
	// We need to set the home directory and potentially other flags to know where the syncthing instance is running
	// in order to get it's config ... which we then use to construct the actual CLI ... at which point it's too late
	// to add flags there...
	homeBaseDir := locations.GetBaseDir(locations.ConfigBaseDir)
	guiCfg := config.GUIConfiguration{}

	flags := flag.NewFlagSet("", flag.ContinueOnError)
	flags.StringVar(&guiCfg.RawAddress, "gui-address", guiCfg.RawAddress, "Override GUI address (e.g. \"http://192.0.2.42:8443\")")
	flags.StringVar(&guiCfg.APIKey, "gui-apikey", guiCfg.APIKey, "Override GUI API key")
	flags.StringVar(&homeBaseDir, "home", homeBaseDir, "Set configuration directory")

	// Implement the same flags at the lower CLI, with the same default values (pre-parse), but do nothing with them.
	// This is so that we could reuse os.Args
	fakeFlags := []cli.Flag{
		cli.StringFlag{
			Name:  "gui-address",
			Value: guiCfg.RawAddress,
			Usage: "Override GUI address (e.g. \"http://192.0.2.42:8443\")",
		},
		cli.StringFlag{
			Name:  "gui-apikey",
			Value: guiCfg.APIKey,
			Usage: "Override GUI API key",
		},
		cli.StringFlag{
			Name:  "home",
			Value: homeBaseDir,
			Usage: "Set configuration directory",
		},
	}

	// Do not print usage of these flags, and ignore errors as this can't understand plenty of things
	flags.Usage = func() {}
	_ = flags.Parse(os.Args[1:])

	// Now if the API key and address is not provided (we are not connecting to a remote instance),
	// try to rip it out of the config.
	if guiCfg.RawAddress == "" && guiCfg.APIKey == "" {
		// Update the base directory
		err := locations.SetBaseDir(locations.ConfigBaseDir, homeBaseDir)
		if err != nil {
			log.Fatal(errors.Wrap(err, "setting home"))
		}

		// Load the certs and get the ID
		cert, err := tls.LoadX509KeyPair(
			locations.Get(locations.CertFile),
			locations.Get(locations.KeyFile),
		)
		if err != nil {
			log.Fatal(errors.Wrap(err, "reading device ID"))
		}

		myID := protocol.NewDeviceID(cert.Certificate[0])

		// Load the config
		cfg, err := config.Load(locations.Get(locations.ConfigFile), myID)
		if err != nil {
			log.Fatalln(errors.Wrap(err, "loading config"))
		}

		guiCfg = cfg.GUI()
	} else if guiCfg.Address() == "" || guiCfg.APIKey == "" {
		log.Fatalln("Both -gui-address and -gui-apikey should be specified")
	}

	if guiCfg.Address() == "" {
		log.Fatalln("Could not find GUI Address")
	}

	if guiCfg.APIKey == "" {
		log.Fatalln("Could not find GUI API key")
	}

	client := getClient(guiCfg)

	cfg, err := getConfig(client)
	original := cfg.Copy()
	if err != nil {
		log.Fatalln(errors.Wrap(err, "getting config"))
	}

	// Copy the config and set the default flags
	recliCfg := recli.DefaultConfig
	recliCfg.IDTag.Name = "xml"
	recliCfg.SkipTag.Name = "json"

	commands, err := recli.New(recliCfg).Construct(&cfg)
	if err != nil {
		log.Fatalln(errors.Wrap(err, "config reflect"))
	}

	// Construct the actual CLI
	app := cli.NewApp()
	app.Name = "stcli"
	app.HelpName = app.Name
	app.Author = "The Syncthing Authors"
	app.Usage = "Syncthing command line interface"
	app.Version = strings.Replace(build.LongVersion, "syncthing", app.Name, 1)
	app.Flags = fakeFlags
	app.Metadata = map[string]interface{}{
		"client": client,
	}
	app.Commands = []cli.Command{
		{
			Name:        "config",
			HideHelp:    true,
			Usage:       "Configuration modification command group",
			Subcommands: commands,
		},
		showCommand,
		operationCommand,
		errorsCommand,
	}

	tty := isatty.IsTerminal(os.Stdin.Fd()) || isatty.IsCygwinTerminal(os.Stdin.Fd())
	if !tty {
		// Not a TTY, consume from stdin
		scanner := bufio.NewScanner(os.Stdin)
		for scanner.Scan() {
			input, err := shlex.Split(scanner.Text())
			if err != nil {
				log.Fatalln(errors.Wrap(err, "parsing input"))
			}
			if len(input) == 0 {
				continue
			}
			err = app.Run(append(os.Args, input...))
			if err != nil {
				log.Fatalln(err)
			}
		}
		err = scanner.Err()
		if err != nil {
			log.Fatalln(err)
		}
	} else {
		err = app.Run(os.Args)
		if err != nil {
			log.Fatalln(err)
		}
	}

	if !reflect.DeepEqual(cfg, original) {
		body, err := json.MarshalIndent(cfg, "", "  ")
		if err != nil {
			log.Fatalln(err)
		}
		resp, err := client.Post("system/config", string(body))
		if err != nil {
			log.Fatalln(err)
		}
		if resp.StatusCode != 200 {
			body, err := responseToBArray(resp)
			if err != nil {
				log.Fatalln(err)
			}
			log.Fatalln(string(body))
		}
	}
}