mirror of
https://github.com/hasura/graphql-engine.git
synced 2024-12-14 17:02:49 +03:00
9335e40d76
PR-URL: https://github.com/hasura/graphql-engine-mono/pull/7068 GitOrigin-RevId: 37735c0020df23857015871890d2f6774166d7b1
238 lines
7.1 KiB
Go
238 lines
7.1 KiB
Go
package cli
|
|
|
|
import (
|
|
"encoding/json"
|
|
stderrors "errors"
|
|
"fmt"
|
|
"io/fs"
|
|
"io/ioutil"
|
|
"os"
|
|
"path/filepath"
|
|
|
|
"github.com/gofrs/uuid"
|
|
homedir "github.com/mitchellh/go-homedir"
|
|
"github.com/spf13/viper"
|
|
|
|
"github.com/hasura/graphql-engine/cli/v2/internal/errors"
|
|
)
|
|
|
|
// Environment defines the environment the CLI is running
|
|
type Environment string
|
|
|
|
const (
|
|
// DefaultEnvironment - CLI running in default mode
|
|
DefaultEnvironment Environment = "default"
|
|
// ServerOnDockerEnvironment - CLI running in cli-migrations image
|
|
ServerOnDockerEnvironment = "server-on-docker"
|
|
)
|
|
|
|
// GlobalConfig is the configuration object stored in the GlobalConfigFile.
|
|
type GlobalConfig struct {
|
|
// UUID used for telemetry, generated on first run.
|
|
UUID string `json:"uuid"`
|
|
|
|
// Indicate if telemetry is enabled or not
|
|
EnableTelemetry bool `json:"enable_telemetry"`
|
|
|
|
// Indicates whether update notifications should be shown or not
|
|
ShowUpdateNotification bool `json:"show_update_notification"`
|
|
|
|
// CLIEnvironment defines the environment the CLI is running
|
|
CLIEnvironment Environment `json:"cli_environment"`
|
|
}
|
|
|
|
type rawGlobalConfig struct {
|
|
UUID *string `json:"uuid"`
|
|
EnableTelemetry *bool `json:"enable_telemetry"`
|
|
ShowUpdateNotification *bool `json:"show_update_notification"`
|
|
CLIEnvironment Environment `json:"cli_environment"`
|
|
|
|
shoudlWrite bool
|
|
}
|
|
|
|
func (c *rawGlobalConfig) read(filename string) error {
|
|
var op errors.Op = "cli.rawGlobalConfig.read"
|
|
b, err := ioutil.ReadFile(filename)
|
|
if err != nil {
|
|
return errors.E(op, fmt.Errorf("read file: %w", err))
|
|
}
|
|
err = json.Unmarshal(b, c)
|
|
if err != nil {
|
|
return errors.E(op, fmt.Errorf("parse file %w", err))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (c *rawGlobalConfig) validateKeys() error {
|
|
var op errors.Op = "cli.rawGlobalConfig.validateKeys"
|
|
// check prescence of uuid, create if doesn't exist
|
|
if c.UUID == nil {
|
|
u, err := uuid.NewV4()
|
|
if err != nil {
|
|
return errors.E(op, fmt.Errorf("failed generating uuid : %w", err))
|
|
}
|
|
uid := u.String()
|
|
c.UUID = &uid
|
|
c.shoudlWrite = true
|
|
}
|
|
|
|
// check enabletelemetry
|
|
if c.EnableTelemetry == nil {
|
|
trueVal := true
|
|
c.EnableTelemetry = &trueVal
|
|
c.shoudlWrite = true
|
|
}
|
|
|
|
// check showupdatenotification
|
|
if c.ShowUpdateNotification == nil {
|
|
trueVal := true
|
|
c.ShowUpdateNotification = &trueVal
|
|
c.shoudlWrite = true
|
|
}
|
|
|
|
if c.CLIEnvironment == "" {
|
|
c.CLIEnvironment = DefaultEnvironment
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (c *rawGlobalConfig) write(filename string) error {
|
|
var op errors.Op = "cli.rawGlobalConfig.write"
|
|
b, err := json.MarshalIndent(c, "", " ")
|
|
if err != nil {
|
|
return errors.E(op, fmt.Errorf("marshal file: %w", err))
|
|
}
|
|
err = ioutil.WriteFile(filename, b, 0644)
|
|
if err != nil {
|
|
return errors.E(op, fmt.Errorf("write file: %w", err))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// setupGlobConfig ensures that global config directory and file exists and
|
|
// reads it into the GlobalConfig object.
|
|
func (ec *ExecutionContext) setupGlobalConfig() error {
|
|
var op errors.Op = "cli.ExecutionContext.setupGlobalConfig"
|
|
// check if the directory name is set, else default
|
|
if len(ec.GlobalConfigDir) == 0 {
|
|
ec.Logger.Debug("global config directory is not pre-set, defaulting")
|
|
home, err := homedir.Dir()
|
|
if err != nil {
|
|
return errors.E(op, fmt.Errorf("cannot get home directory: %w", err))
|
|
}
|
|
globalConfigDir := filepath.Join(home, GlobalConfigDirName)
|
|
ec.GlobalConfigDir = globalConfigDir
|
|
ec.Logger.Debugf("global config directory set as '%s'", ec.GlobalConfigDir)
|
|
}
|
|
|
|
// create the config directory
|
|
err := os.MkdirAll(ec.GlobalConfigDir, os.ModePerm)
|
|
if err != nil {
|
|
return errors.E(op, fmt.Errorf("cannot create global config directory: %w", err))
|
|
}
|
|
|
|
// check if the filename is set, else default
|
|
if len(ec.GlobalConfigFile) == 0 {
|
|
ec.GlobalConfigFile = filepath.Join(ec.GlobalConfigDir, GlobalConfigFileName)
|
|
ec.Logger.Debugf("global config file set as '%s'", ec.GlobalConfigFile)
|
|
}
|
|
|
|
// check if the global config file exist
|
|
_, err = os.Stat(ec.GlobalConfigFile)
|
|
if stderrors.Is(err, fs.ErrNotExist) {
|
|
|
|
// file does not exist, teat as first run and create it
|
|
ec.Logger.Debug("global config file does not exist, this could be the first run, creating it...")
|
|
|
|
// create an empty config object
|
|
gc := &rawGlobalConfig{}
|
|
|
|
// populate the keys
|
|
err := gc.validateKeys()
|
|
if err != nil {
|
|
return errors.E(op, fmt.Errorf("setup global config object: %w", err))
|
|
}
|
|
|
|
// write the file
|
|
err = gc.write(ec.GlobalConfigFile)
|
|
if err != nil {
|
|
return errors.E(op, fmt.Errorf("write global config file: %w", err))
|
|
}
|
|
ec.Logger.Debugf("global config file written at '%s' with content '%v'", ec.GlobalConfigFile, gc)
|
|
|
|
// also show a notice about telemetry
|
|
ec.Logger.Info(TelemetryNotice)
|
|
|
|
} else if stderrors.Is(err, fs.ErrExist) || err == nil {
|
|
|
|
// file exists, verify contents
|
|
ec.Logger.Debug("global config file exists, verifying contents")
|
|
|
|
// initialize the config object
|
|
gc := rawGlobalConfig{}
|
|
err := gc.read(ec.GlobalConfigFile)
|
|
if err != nil {
|
|
return errors.E(op, fmt.Errorf("reading global config file failed: %w", err))
|
|
}
|
|
|
|
// validate keys
|
|
err = gc.validateKeys()
|
|
if err != nil {
|
|
return errors.E(op, fmt.Errorf("validating global config file failed: %w", err))
|
|
}
|
|
|
|
// write the file if there are any changes
|
|
if gc.shoudlWrite {
|
|
err := gc.write(ec.GlobalConfigFile)
|
|
if err != nil {
|
|
return errors.E(op, fmt.Errorf("writing global config file failed: %w", err))
|
|
}
|
|
ec.Logger.Debugf("global config file written at '%s' with content '%+#v'", ec.GlobalConfigFile, gc)
|
|
}
|
|
|
|
}
|
|
err = ec.readGlobalConfig()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// readGlobalConfig reads the configuration from global config file env vars,
|
|
// through viper.
|
|
func (ec *ExecutionContext) readGlobalConfig() error {
|
|
var op errors.Op = "cli.ExecutionContext.readGlobalConfig"
|
|
// need to get existing viper because https://github.com/spf13/viper/issues/233
|
|
v := viper.New()
|
|
v.SetEnvPrefix("HASURA_GRAPHQL")
|
|
v.AutomaticEnv()
|
|
v.SetConfigName("config")
|
|
v.AddConfigPath(ec.GlobalConfigDir)
|
|
v.SetDefault("cli_environment", DefaultEnvironment)
|
|
err := v.ReadInConfig()
|
|
if err != nil {
|
|
return errors.E(op, fmt.Errorf("cannot read global config from file/env: %w", err))
|
|
}
|
|
if ec.GlobalConfig == nil {
|
|
ec.Logger.Debugf("global config is not pre-set, reading from current env")
|
|
ec.GlobalConfig = &GlobalConfig{
|
|
UUID: v.GetString("uuid"),
|
|
EnableTelemetry: v.GetBool("enable_telemetry"),
|
|
ShowUpdateNotification: v.GetBool("show_update_notification"),
|
|
CLIEnvironment: Environment(v.GetString("cli_environment")),
|
|
}
|
|
} else {
|
|
ec.Logger.Debugf("global config is pre-set to %#v", ec.GlobalConfig)
|
|
}
|
|
ec.Logger.Debugf("global config: uuid: %v", ec.GlobalConfig.UUID)
|
|
ec.Logger.Debugf("global config: enableTelemetry: %v", ec.GlobalConfig.EnableTelemetry)
|
|
ec.Logger.Debugf("global config: showUpdateNotification: %v", ec.GlobalConfig.ShowUpdateNotification)
|
|
ec.Logger.Debugf("global config: cliEnvironment: %v", ec.GlobalConfig.CLIEnvironment)
|
|
|
|
// set if telemetry can be beamed or not
|
|
ec.Telemetry.CanBeam = ec.GlobalConfig.EnableTelemetry
|
|
ec.Telemetry.UUID = ec.GlobalConfig.UUID
|
|
return nil
|
|
}
|