control.go

package fedbox

import (
	"bufio"
	"fmt"
	"io"
	"net/url"
	"os"
	"sync/atomic"

	"git.sr.ht/~mariusor/lw"
	"git.sr.ht/~mariusor/storage-all"
	"github.com/alecthomas/kong"
	"github.com/go-ap/errors"
	ap "github.com/go-ap/fedbox/activitypub"
	"github.com/go-ap/fedbox/internal/config"
	"github.com/go-ap/fedbox/internal/env"
	"golang.org/x/crypto/ssh/terminal"
)

type Storage struct {
	Type storage.Type `help:"Type of the backend to use. Possible values: ${storageTypes}"`

	Reset          ResetCmd       `cmd:"" help:"Reset an existing storage."`
	FixCollections FixCollections `cmd:"" help:"Fix storage collections."`
}

type SSH struct {
	Pub         Pub         `cmd:"" name:"pub" alt:"ap" help:"ActivityPub management helper"`
	OAuth       OAuth       `cmd:"" name:"oauth"`
	Storage     Storage     `cmd:""`
	Accounts    Accounts    `cmd:"" help:"Accounts helper."`
	Debug       Debug       `cmd:"" help:"Toggle debug mode for the running FedBOX server."`
	Maintenance Maintenance `cmd:"" help:"Toggle maintenance mode for the running FedBOX server."`
	Reload      Reload      `cmd:"" help:"Reload the running FedBOX server configuration."`
	Stop        Stop        `cmd:"" help:"Stops the running FedBOX server configuration."`
}

type CTL struct {
	SSH `embed:""`

	Url     *url.URL         `help:"The URL used by the application."`
	Env     env.Type         `enum:"${envTypes}" help:"The environment to use. Expected values: ${envTypes}" default:"${defaultEnv}"`
	Verbose int              `name:"verbose" short:"v" default:"0" type:"counter" help:"Increase verbosity of the log output" `
	Path    string           `path:"" help:"The path for the storage folder or socket" env:"STORAGE_PATH"`
	Version kong.VersionFlag `short:"V"`

	// Commands
	Run Serve `cmd:"" name:"run" help:"Run the ${name} instance server (version: ${version})" default:"withargs"`
}

var DefaultLogLevel = lw.WarnLevel

func InitControl(c *CTL) (*Base, error) {
	opt := config.Options{
		LogLevel: DefaultLogLevel,
		AppName:  AppName,
		Version:  AppVersion,
	}
	if c.Env != opt.Env {
		opt.Env = c.Env
	}
	if c.Url != nil {
		opt.Hostname = c.Url.Hostname()
		opt.Secure = c.Url.Scheme == "https"
		opt.BaseURL = c.Url.String()
	}
	if c.Path != "" {
		opt.StoragePath = c.Path
	}
	ct := Base{
		in:   os.Stdin,
		out:  os.Stdout,
		err:  os.Stderr,
		Conf: opt,
	}
	if err := setup(&ct, opt, c.Verbose); err != nil {
		return nil, err
	}
	errors.SetIncludeBacktrace(opt.LogLevel == lw.TraceLevel)

	return &ct, nil
}

func (ctl *Base) LoadServiceActor() error {
	if ctl.Conf.BaseURL == "" {
		return errors.Errorf("no HOSTNAME configured for service")
	}

	selfIRI := ap.DefaultServiceIRI(ctl.Conf.BaseURL)
	actor, err := ap.LoadActor(ctl.Storage, selfIRI)
	if err != nil {
		return err
	}
	key, err := ctl.Storage.LoadKey(selfIRI)
	if err != nil {
		return err
	}
	ctl.Service = actor
	ctl.ServicePrivateKey = key
	return nil
}

func NewBase(db storage.FullStorage, conf config.Options, l lw.Logger) (*Base, error) {
	return &Base{
		Conf:    conf,
		Storage: db,
		Logger:  l,
		in:      os.Stdin,
		out:     os.Stdout,
		err:     os.Stderr,
	}, nil
}

func setup(ct *Base, conf config.Options, verbose int) error {
	path := conf.StoragePath
	err := config.Load(&conf, path)
	if err != nil {
		return errors.Annotatef(err, "failed to load %s files in path %s", conf.Env, path)
	}

	var out io.WriteCloser
	if conf.LogOutput != "" {
		if out, err = os.Open(conf.LogOutput); err != nil {
			return errors.Newf("Unable to output logs to %s: %s", conf.LogOutput, err)
		}
		defer func() {
			if err := out.Close(); err != nil {
				_, _ = fmt.Fprintf(os.Stderr, "Unable to close log output: %s", err)
			}
		}()
	}
	if ct.Logger == nil {
		if verbose > 0 {
			conf.LogLevel = lw.Level(max(int(lw.TraceLevel), int(conf.LogLevel)-(4*verbose)))
		}
		if conf.Env.IsDev() {
			ct.Logger = lw.Dev(lw.SetLevel(conf.LogLevel), lw.SetOutput(out)).WithContext(lw.Ctx{"host": conf.Hostname})
		} else {
			ct.Logger = lw.Prod(lw.SetLevel(conf.LogLevel), lw.SetOutput(out)).WithContext(lw.Ctx{"host": conf.Hostname})
		}
	}
	_l.Store(ct.Logger)

	typ := conf.Storage
	if typ != "" {
		conf.Storage = typ
	}
	if conf.StoragePath == "" && path != "" {
		conf.StoragePath = path
	}
	ct.Conf = conf

	initFn, err := conf.StorageInitFns(ct.Logger)
	if err != nil {
		return err
	}
	if ct.Storage, err = storage.New(initFn...); err != nil {
		return err
	}

	if metaSaver, ok := ct.Storage.(storage.MetadataStorage); ok {
		keysType := ap.KeyTypeED25519
		if conf.MastodonCompatible {
			keysType = ap.KeyTypeRSA
		}

		ct.Logger.Debugf("Setting actor key generator %T[%s]", metaSaver, keysType)
		ct.keyGenerator = ap.KeyGenerator(metaSaver, keysType)
	}

	return nil
}

type muxReadWriter struct {
	io.Reader
	io.Writer
}

func (w muxReadWriter) Read(p []byte) (n int, err error) {
	if w.Reader != nil {
		return w.Reader.Read(p)
	}
	return 0, nil
}

func (w muxReadWriter) Write(p []byte) (n int, err error) {
	if w.Writer != nil {
		return w.Writer.Write(p)
	}
	return 0, nil
}

var _ io.Reader = muxReadWriter{}

func loadPwFromStdin(rw io.ReadWriter, prompt string) ([]byte, error) {
	term := terminal.NewTerminal(rw, prompt)
	pw1, _ := term.ReadPassword("Password: ")
	if len(pw1) == 0 {
		return nil, errors.Errorf("empty password")
	}
	pw2, _ := term.ReadPassword(" Confirm: ")
	if pw1 != pw2 {
		return nil, errors.Errorf("passwords do not match")
	}
	return []byte(pw1), nil
}

func loadFromStdin(s string, params ...any) ([]byte, error) {
	reader := bufio.NewReader(os.Stdin)
	fmt.Printf(s+": ", params...)
	input, _ := reader.ReadBytes('\n')
	return input[:len(input)-1], nil
}

var _l atomic.Value

func Errf(out io.Writer, s string, par ...any) {
	_, _ = fmt.Fprintf(out, s+"\n", par...)
	return
}