2018-06-24 16:47:01 +03:00
|
|
|
// Package cli and it's sub packages implements the command line tool for Hasura
|
|
|
|
// GraphQL Engine. The CLI operates on a directory, denoted by
|
|
|
|
// "ExecutionDirectory" in the "ExecutionContext" struct.
|
|
|
|
//
|
|
|
|
// The ExecutionContext is passed to all the subcommands so that a singleton
|
|
|
|
// context is available for the execution. Logger and Spinner comes from the same
|
|
|
|
// context.
|
|
|
|
package cli
|
2018-06-24 16:40:48 +03:00
|
|
|
|
|
|
|
import (
|
2019-02-14 12:37:47 +03:00
|
|
|
"encoding/json"
|
2019-03-20 08:10:06 +03:00
|
|
|
"fmt"
|
2018-07-09 16:47:38 +03:00
|
|
|
"net/url"
|
2018-06-24 16:40:48 +03:00
|
|
|
"os"
|
|
|
|
"path/filepath"
|
|
|
|
"time"
|
|
|
|
|
|
|
|
"github.com/briandowns/spinner"
|
2019-01-28 16:55:28 +03:00
|
|
|
"github.com/gofrs/uuid"
|
2020-01-08 06:06:09 +03:00
|
|
|
"github.com/hasura/graphql-engine/cli/telemetry"
|
|
|
|
"github.com/hasura/graphql-engine/cli/util"
|
2018-07-04 15:43:52 +03:00
|
|
|
"github.com/hasura/graphql-engine/cli/version"
|
2019-07-30 09:55:38 +03:00
|
|
|
"github.com/mattn/go-colorable"
|
2018-06-24 16:40:48 +03:00
|
|
|
"github.com/pkg/errors"
|
|
|
|
"github.com/sirupsen/logrus"
|
2018-06-24 16:47:01 +03:00
|
|
|
"github.com/spf13/viper"
|
2019-12-25 17:44:02 +03:00
|
|
|
"golang.org/x/crypto/ssh/terminal"
|
2018-06-24 16:40:48 +03:00
|
|
|
)
|
|
|
|
|
2018-06-27 15:04:09 +03:00
|
|
|
// Other constants used in the package
|
|
|
|
const (
|
|
|
|
// Name of the global configuration directory
|
2019-02-14 12:37:47 +03:00
|
|
|
GlobalConfigDirName = ".hasura"
|
2018-06-27 15:04:09 +03:00
|
|
|
// Name of the global configuration file
|
2019-02-14 12:37:47 +03:00
|
|
|
GlobalConfigFileName = "config.json"
|
2019-02-04 13:51:29 +03:00
|
|
|
|
|
|
|
// Name of the file to store last update check time
|
|
|
|
LastUpdateCheckFileName = "last_update_check_at"
|
2018-06-27 15:04:09 +03:00
|
|
|
)
|
|
|
|
|
2019-01-28 16:55:28 +03:00
|
|
|
// String constants
|
|
|
|
const (
|
|
|
|
StrTelemetryNotice = `Help us improve Hasura! The cli collects anonymized usage stats which
|
|
|
|
allow us to keep improving Hasura at warp speed. To opt-out or read more,
|
|
|
|
visit https://docs.hasura.io/1.0/graphql/manual/guides/telemetry.html
|
|
|
|
`
|
|
|
|
)
|
|
|
|
|
2019-02-14 12:37:47 +03:00
|
|
|
// ServerConfig has the config values required to contact the server.
|
|
|
|
type ServerConfig struct {
|
|
|
|
// Endpoint for the GraphQL Engine
|
|
|
|
Endpoint string
|
|
|
|
// AdminSecret (optional) required to query the endpoint
|
|
|
|
AdminSecret string
|
|
|
|
|
|
|
|
ParsedEndpoint *url.URL
|
|
|
|
}
|
|
|
|
|
|
|
|
type rawServerConfig struct {
|
2018-06-24 16:47:01 +03:00
|
|
|
// Endpoint for the GraphQL Engine
|
|
|
|
Endpoint string `json:"endpoint"`
|
2019-02-14 12:37:47 +03:00
|
|
|
// AccessKey (deprecated) (optional) Admin secret key required to query the endpoint
|
2018-06-24 16:47:01 +03:00
|
|
|
AccessKey string `json:"access_key,omitempty"`
|
2019-02-14 12:37:47 +03:00
|
|
|
// AdminSecret (optional) Admin secret required to query the endpoint
|
|
|
|
AdminSecret string `json:"admin_secret,omitempty"`
|
2018-07-09 16:47:38 +03:00
|
|
|
|
2018-07-11 12:22:36 +03:00
|
|
|
ParsedEndpoint *url.URL `json:"-"`
|
2018-07-09 16:47:38 +03:00
|
|
|
}
|
|
|
|
|
2019-02-14 12:37:47 +03:00
|
|
|
func (r rawServerConfig) toServerConfig() ServerConfig {
|
|
|
|
s := r.AdminSecret
|
|
|
|
if s == "" {
|
|
|
|
s = r.AccessKey
|
|
|
|
}
|
|
|
|
return ServerConfig{
|
|
|
|
Endpoint: r.Endpoint,
|
|
|
|
AdminSecret: s,
|
|
|
|
ParsedEndpoint: r.ParsedEndpoint,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s ServerConfig) toRawServerConfig() rawServerConfig {
|
|
|
|
return rawServerConfig{
|
|
|
|
Endpoint: s.Endpoint,
|
|
|
|
AccessKey: "",
|
|
|
|
AdminSecret: s.AdminSecret,
|
|
|
|
ParsedEndpoint: s.ParsedEndpoint,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// MarshalJSON converts s to JSON
|
|
|
|
func (s ServerConfig) MarshalJSON() ([]byte, error) {
|
|
|
|
return json.Marshal(s.toRawServerConfig())
|
|
|
|
}
|
|
|
|
|
|
|
|
// UnmarshalJSON converts b to struct s
|
|
|
|
func (s ServerConfig) UnmarshalJSON(b []byte) error {
|
|
|
|
var r rawServerConfig
|
|
|
|
err := json.Unmarshal(b, &r)
|
|
|
|
if err != nil {
|
|
|
|
return errors.Wrap(err, "unmarshal error")
|
|
|
|
}
|
|
|
|
sc := r.toServerConfig()
|
|
|
|
s.Endpoint = sc.Endpoint
|
|
|
|
s.AdminSecret = sc.AdminSecret
|
|
|
|
s.ParsedEndpoint = sc.ParsedEndpoint
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-07-09 16:47:38 +03:00
|
|
|
// ParseEndpoint ensures the endpoint is valid.
|
2019-02-14 12:37:47 +03:00
|
|
|
func (s *ServerConfig) ParseEndpoint() error {
|
|
|
|
nurl, err := url.Parse(s.Endpoint)
|
2018-07-09 16:47:38 +03:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2019-02-14 12:37:47 +03:00
|
|
|
s.ParsedEndpoint = nurl
|
2018-07-09 16:47:38 +03:00
|
|
|
return nil
|
2018-06-24 16:40:48 +03:00
|
|
|
}
|
|
|
|
|
2018-06-24 16:47:01 +03:00
|
|
|
// ExecutionContext contains various contextual information required by the cli
|
|
|
|
// at various points of it's execution. Values are filled in by the
|
|
|
|
// initializers and passed on to each command. Commands can also fill in values
|
|
|
|
// to be used further down the line.
|
2018-06-24 16:40:48 +03:00
|
|
|
type ExecutionContext struct {
|
2018-06-24 16:47:01 +03:00
|
|
|
// CMDName is the name of CMD (os.Args[0]). To be filled in later to
|
|
|
|
// correctly render example strings etc.
|
2018-06-24 16:40:48 +03:00
|
|
|
CMDName string
|
2018-06-24 16:47:01 +03:00
|
|
|
|
2019-01-28 16:55:28 +03:00
|
|
|
// ID is a unique ID for this Execution
|
|
|
|
ID string
|
|
|
|
|
|
|
|
// ServerUUID is the unique ID for the server this execution is contacting.
|
|
|
|
ServerUUID string
|
|
|
|
|
2018-06-24 16:47:01 +03:00
|
|
|
// Spinner is the global spinner object used to show progress across the cli.
|
2018-06-24 16:40:48 +03:00
|
|
|
Spinner *spinner.Spinner
|
2018-06-24 16:47:01 +03:00
|
|
|
// Logger is the global logger object to print logs.
|
|
|
|
Logger *logrus.Logger
|
2018-06-24 16:40:48 +03:00
|
|
|
|
2018-06-24 16:47:01 +03:00
|
|
|
// ExecutionDirectory is the directory in which command is being executed.
|
2018-06-24 16:40:48 +03:00
|
|
|
ExecutionDirectory string
|
2018-06-24 16:47:01 +03:00
|
|
|
// MigrationDir is the name of directory where migrations are stored.
|
|
|
|
MigrationDir string
|
|
|
|
// ConfigFile is the file where endpoint etc. are stored.
|
|
|
|
ConfigFile string
|
2019-03-20 08:10:06 +03:00
|
|
|
// MetadataFile (optional) is a yaml|json file where Hasura metadata is stored.
|
|
|
|
MetadataFile []string
|
2018-06-24 16:47:01 +03:00
|
|
|
|
2019-02-14 12:37:47 +03:00
|
|
|
// ServerConfig is the configuration object storing the endpoint and admin secret
|
2018-06-24 16:47:01 +03:00
|
|
|
// information after reading from config file or env var.
|
2019-02-14 12:37:47 +03:00
|
|
|
ServerConfig *ServerConfig
|
2018-06-24 16:47:01 +03:00
|
|
|
|
|
|
|
// GlobalConfigDir is the ~/.hasura-graphql directory to store configuration
|
|
|
|
// globally.
|
|
|
|
GlobalConfigDir string
|
|
|
|
// GlobalConfigFile is the file inside GlobalConfigDir where values are
|
|
|
|
// stored.
|
|
|
|
GlobalConfigFile string
|
|
|
|
|
2019-01-28 16:55:28 +03:00
|
|
|
// GlobalConfig holds all the configuration options.
|
|
|
|
GlobalConfig *GlobalConfig
|
|
|
|
|
2018-06-24 16:47:01 +03:00
|
|
|
// IsStableRelease indicates if the CLI release is stable or not.
|
|
|
|
IsStableRelease bool
|
2018-07-04 15:43:52 +03:00
|
|
|
// Version indicates the version object
|
|
|
|
Version *version.Version
|
2018-06-24 16:40:48 +03:00
|
|
|
|
2018-06-24 16:47:01 +03:00
|
|
|
// Viper indicates the viper object for the execution
|
|
|
|
Viper *viper.Viper
|
2018-06-24 16:40:48 +03:00
|
|
|
|
2018-06-24 16:47:01 +03:00
|
|
|
// LogLevel indicates the logrus default logging level
|
|
|
|
LogLevel string
|
2019-01-28 16:55:28 +03:00
|
|
|
|
2019-07-30 09:55:38 +03:00
|
|
|
// NoColor indicates if the outputs shouldn't be colorized
|
|
|
|
NoColor bool
|
|
|
|
|
2019-01-28 16:55:28 +03:00
|
|
|
// Telemetry collects the telemetry data throughout the execution
|
|
|
|
Telemetry *telemetry.Data
|
2019-02-04 13:51:29 +03:00
|
|
|
|
|
|
|
// LastUpdateCheckFile is the file where the timestamp of last update check is stored
|
|
|
|
LastUpdateCheckFile string
|
2019-02-14 09:16:36 +03:00
|
|
|
|
|
|
|
// SkipUpdateCheck will skip the auto update check if set to true
|
|
|
|
SkipUpdateCheck bool
|
2019-12-25 17:44:02 +03:00
|
|
|
|
|
|
|
// IsTerminal indicates whether the current session is a terminal or not
|
|
|
|
IsTerminal bool
|
2019-01-28 16:55:28 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// NewExecutionContext returns a new instance of execution context
|
|
|
|
func NewExecutionContext() *ExecutionContext {
|
|
|
|
ec := &ExecutionContext{}
|
|
|
|
ec.Telemetry = telemetry.BuildEvent()
|
|
|
|
ec.Telemetry.Version = version.BuildVersion
|
|
|
|
return ec
|
2018-06-24 16:40:48 +03:00
|
|
|
}
|
|
|
|
|
2018-06-24 16:47:01 +03:00
|
|
|
// Prepare as the name suggests, prepares the ExecutionContext ec by
|
|
|
|
// initializing most of the variables to sensible defaults, if it is not already
|
|
|
|
// set.
|
2018-06-24 16:40:48 +03:00
|
|
|
func (ec *ExecutionContext) Prepare() error {
|
2018-06-24 16:47:01 +03:00
|
|
|
// set the command name
|
2018-06-24 16:40:48 +03:00
|
|
|
cmdName := os.Args[0]
|
|
|
|
if len(cmdName) == 0 {
|
|
|
|
cmdName = "hasura"
|
|
|
|
}
|
|
|
|
ec.CMDName = cmdName
|
|
|
|
|
2019-12-25 17:44:02 +03:00
|
|
|
ec.IsTerminal = terminal.IsTerminal(int(os.Stdout.Fd()))
|
|
|
|
|
2018-06-24 16:40:48 +03:00
|
|
|
// set spinner
|
|
|
|
ec.setupSpinner()
|
|
|
|
|
|
|
|
// set logger
|
|
|
|
ec.setupLogger()
|
|
|
|
|
2018-06-28 08:40:18 +03:00
|
|
|
// populate version
|
|
|
|
ec.setVersion()
|
|
|
|
|
2019-01-28 16:55:28 +03:00
|
|
|
// setup global config
|
|
|
|
err := ec.setupGlobalConfig()
|
|
|
|
if err != nil {
|
2019-02-04 13:51:29 +03:00
|
|
|
return errors.Wrap(err, "setting up global config failed")
|
2019-01-28 16:55:28 +03:00
|
|
|
}
|
|
|
|
|
2019-02-04 13:51:29 +03:00
|
|
|
ec.LastUpdateCheckFile = filepath.Join(ec.GlobalConfigDir, LastUpdateCheckFileName)
|
2018-06-24 16:40:48 +03:00
|
|
|
|
2019-02-04 13:51:29 +03:00
|
|
|
// initialize a blank server config
|
2019-02-14 12:37:47 +03:00
|
|
|
if ec.ServerConfig == nil {
|
|
|
|
ec.ServerConfig = &ServerConfig{}
|
2019-01-28 16:55:28 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// generate an execution id
|
|
|
|
if ec.ID == "" {
|
|
|
|
id := "00000000-0000-0000-0000-000000000000"
|
|
|
|
u, err := uuid.NewV4()
|
|
|
|
if err == nil {
|
|
|
|
id = u.String()
|
|
|
|
} else {
|
|
|
|
ec.Logger.Debugf("generating uuid for execution ID failed, %v", err)
|
|
|
|
}
|
|
|
|
ec.ID = id
|
|
|
|
ec.Logger.Debugf("execution id: %v", ec.ID)
|
|
|
|
}
|
|
|
|
ec.Telemetry.ExecutionID = ec.ID
|
2018-06-24 16:47:01 +03:00
|
|
|
|
2018-06-24 16:40:48 +03:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-06-24 16:47:01 +03:00
|
|
|
// Validate prepares the ExecutionContext ec and then validates the
|
|
|
|
// ExecutionDirectory to see if all the required files and directories are in
|
|
|
|
// place.
|
2018-06-24 16:40:48 +03:00
|
|
|
func (ec *ExecutionContext) Validate() error {
|
|
|
|
|
2018-06-24 16:47:01 +03:00
|
|
|
// validate execution directory
|
2019-02-04 13:51:29 +03:00
|
|
|
err := ec.validateDirectory()
|
2018-06-24 16:40:48 +03:00
|
|
|
if err != nil {
|
2018-06-24 16:47:01 +03:00
|
|
|
return errors.Wrap(err, "validating current directory failed")
|
2018-06-24 16:40:48 +03:00
|
|
|
}
|
|
|
|
|
2018-06-24 16:47:01 +03:00
|
|
|
// set names of files and directories
|
2018-06-24 16:40:48 +03:00
|
|
|
ec.MigrationDir = filepath.Join(ec.ExecutionDirectory, "migrations")
|
|
|
|
ec.ConfigFile = filepath.Join(ec.ExecutionDirectory, "config.yaml")
|
2019-03-20 08:10:06 +03:00
|
|
|
ec.MetadataFile = append(ec.MetadataFile, filepath.Join(ec.MigrationDir, "metadata.yaml"))
|
|
|
|
ec.MetadataFile = append(ec.MetadataFile, filepath.Join(ec.MigrationDir, "metadata.json"))
|
2018-06-24 16:40:48 +03:00
|
|
|
|
2018-06-24 16:47:01 +03:00
|
|
|
// read config and parse the values into Config
|
2018-06-24 16:40:48 +03:00
|
|
|
err = ec.readConfig()
|
|
|
|
if err != nil {
|
|
|
|
return errors.Wrap(err, "cannot read config")
|
|
|
|
}
|
|
|
|
|
2019-02-14 12:37:47 +03:00
|
|
|
ec.Logger.Debug("graphql engine endpoint: ", ec.ServerConfig.Endpoint)
|
|
|
|
ec.Logger.Debug("graphql engine admin_secret: ", ec.ServerConfig.AdminSecret)
|
2018-06-24 16:40:48 +03:00
|
|
|
|
2018-07-03 20:10:13 +03:00
|
|
|
// get version from the server and match with the cli version
|
2019-01-28 16:55:28 +03:00
|
|
|
err = ec.checkServerVersion()
|
|
|
|
if err != nil {
|
|
|
|
return errors.Wrap(err, "version check")
|
|
|
|
}
|
|
|
|
|
2019-02-14 12:37:47 +03:00
|
|
|
state := util.GetServerState(ec.ServerConfig.Endpoint, ec.ServerConfig.AdminSecret, ec.Version.ServerSemver, ec.Logger)
|
2019-01-28 16:55:28 +03:00
|
|
|
ec.ServerUUID = state.UUID
|
|
|
|
ec.Telemetry.ServerUUID = ec.ServerUUID
|
|
|
|
ec.Logger.Debugf("server: uuid: %s", ec.ServerUUID)
|
|
|
|
|
|
|
|
return nil
|
2018-07-03 20:10:13 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func (ec *ExecutionContext) checkServerVersion() error {
|
2019-02-14 12:37:47 +03:00
|
|
|
v, err := version.FetchServerVersion(ec.ServerConfig.Endpoint)
|
2018-07-03 20:10:13 +03:00
|
|
|
if err != nil {
|
2018-07-04 15:43:52 +03:00
|
|
|
return errors.Wrap(err, "failed to get version from server")
|
2018-07-03 20:10:13 +03:00
|
|
|
}
|
2018-07-04 15:43:52 +03:00
|
|
|
ec.Version.SetServerVersion(v)
|
2019-01-28 16:55:28 +03:00
|
|
|
ec.Telemetry.ServerVersion = ec.Version.GetServerVersion()
|
2018-07-04 15:43:52 +03:00
|
|
|
isCompatible, reason := ec.Version.CheckCLIServerCompatibility()
|
|
|
|
ec.Logger.Debugf("versions: cli: [%s] server: [%s]", ec.Version.GetCLIVersion(), ec.Version.GetServerVersion())
|
|
|
|
ec.Logger.Debugf("compatibility check: [%v] %v", isCompatible, reason)
|
|
|
|
if !isCompatible {
|
2020-01-16 06:53:18 +03:00
|
|
|
ec.Logger.Warnf("[cli: %s] [server: %s] version mismatch: %s", ec.Version.GetCLIVersion(), ec.Version.GetServerVersion(), reason)
|
2018-07-03 20:10:13 +03:00
|
|
|
}
|
2018-06-24 16:40:48 +03:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-06-24 16:47:01 +03:00
|
|
|
// readConfig reads the configuration from config file, flags and env vars,
|
|
|
|
// through viper.
|
2018-06-24 16:40:48 +03:00
|
|
|
func (ec *ExecutionContext) readConfig() error {
|
2018-06-24 16:47:01 +03:00
|
|
|
// need to get existing viper because https://github.com/spf13/viper/issues/233
|
|
|
|
v := ec.Viper
|
|
|
|
v.SetEnvPrefix("HASURA_GRAPHQL")
|
|
|
|
v.AutomaticEnv()
|
|
|
|
v.SetConfigName("config")
|
2019-01-28 16:55:28 +03:00
|
|
|
v.SetDefault("endpoint", "http://localhost:8080")
|
2019-02-14 12:37:47 +03:00
|
|
|
v.SetDefault("admin_secret", "")
|
2019-01-28 16:55:28 +03:00
|
|
|
v.SetDefault("access_key", "")
|
2018-06-24 16:47:01 +03:00
|
|
|
v.AddConfigPath(ec.ExecutionDirectory)
|
|
|
|
err := v.ReadInConfig()
|
2018-06-24 16:40:48 +03:00
|
|
|
if err != nil {
|
2019-02-14 12:37:47 +03:00
|
|
|
return errors.Wrap(err, "cannot read config from file/env")
|
|
|
|
}
|
|
|
|
adminSecret := v.GetString("admin_secret")
|
|
|
|
if adminSecret == "" {
|
|
|
|
adminSecret = v.GetString("access_key")
|
2018-06-24 16:40:48 +03:00
|
|
|
}
|
2019-02-14 12:37:47 +03:00
|
|
|
ec.ServerConfig = &ServerConfig{
|
|
|
|
Endpoint: v.GetString("endpoint"),
|
|
|
|
AdminSecret: adminSecret,
|
2018-06-24 16:40:48 +03:00
|
|
|
}
|
2019-02-14 12:37:47 +03:00
|
|
|
return ec.ServerConfig.ParseEndpoint()
|
2018-06-24 16:40:48 +03:00
|
|
|
}
|
|
|
|
|
2018-06-24 16:47:01 +03:00
|
|
|
// setupSpinner creates a default spinner if the context does not already have
|
|
|
|
// one.
|
2018-06-24 16:40:48 +03:00
|
|
|
func (ec *ExecutionContext) setupSpinner() {
|
|
|
|
if ec.Spinner == nil {
|
|
|
|
spnr := spinner.New(spinner.CharSets[7], 100*time.Millisecond)
|
|
|
|
spnr.Writer = os.Stderr
|
|
|
|
ec.Spinner = spnr
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-06-27 15:04:09 +03:00
|
|
|
// Spin stops any existing spinner and starts a new one with the given message.
|
|
|
|
func (ec *ExecutionContext) Spin(message string) {
|
2019-12-25 17:44:02 +03:00
|
|
|
if ec.IsTerminal {
|
|
|
|
ec.Spinner.Stop()
|
|
|
|
ec.Spinner.Prefix = message
|
|
|
|
ec.Spinner.Start()
|
|
|
|
} else {
|
|
|
|
ec.Logger.Println(message)
|
|
|
|
}
|
2018-06-27 15:04:09 +03:00
|
|
|
}
|
|
|
|
|
2018-06-24 16:47:01 +03:00
|
|
|
// setupLogger creates a default logger if context does not have one set.
|
2018-06-24 16:40:48 +03:00
|
|
|
func (ec *ExecutionContext) setupLogger() {
|
|
|
|
if ec.Logger == nil {
|
|
|
|
logger := logrus.New()
|
2019-07-30 09:55:38 +03:00
|
|
|
|
2019-12-25 17:44:02 +03:00
|
|
|
if ec.IsTerminal {
|
|
|
|
if ec.NoColor {
|
|
|
|
logger.Formatter = &logrus.TextFormatter{
|
|
|
|
DisableColors: true,
|
|
|
|
DisableTimestamp: true,
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
logger.Formatter = &logrus.TextFormatter{
|
|
|
|
ForceColors: true,
|
|
|
|
DisableTimestamp: true,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
logger.Formatter = &logrus.JSONFormatter{
|
|
|
|
PrettyPrint: false,
|
|
|
|
}
|
2018-06-24 16:40:48 +03:00
|
|
|
}
|
|
|
|
logger.Out = colorable.NewColorableStdout()
|
|
|
|
ec.Logger = logger
|
|
|
|
}
|
2018-06-24 16:47:01 +03:00
|
|
|
|
|
|
|
if ec.LogLevel != "" {
|
|
|
|
level, err := logrus.ParseLevel(ec.LogLevel)
|
|
|
|
if err != nil {
|
|
|
|
ec.Logger.WithError(err).Error("error parsing log-level flag")
|
|
|
|
return
|
|
|
|
}
|
|
|
|
ec.Logger.SetLevel(level)
|
|
|
|
}
|
2019-01-28 16:55:28 +03:00
|
|
|
|
|
|
|
// set the logger for telemetry
|
|
|
|
if ec.Telemetry.Logger == nil {
|
|
|
|
ec.Telemetry.Logger = ec.Logger
|
|
|
|
}
|
2018-06-24 16:40:48 +03:00
|
|
|
}
|
|
|
|
|
2018-06-28 08:40:18 +03:00
|
|
|
// SetVersion sets the version inside context, according to the variable
|
2018-06-24 16:47:01 +03:00
|
|
|
// 'version' set during build context.
|
|
|
|
func (ec *ExecutionContext) setVersion() {
|
2018-07-04 15:43:52 +03:00
|
|
|
if ec.Version == nil {
|
|
|
|
ec.Version = version.New()
|
2018-06-24 16:47:01 +03:00
|
|
|
}
|
|
|
|
}
|
2019-03-20 08:10:06 +03:00
|
|
|
|
2019-12-25 17:44:02 +03:00
|
|
|
// GetMetadataFilePath returns the file path based on the format.
|
2019-03-20 08:10:06 +03:00
|
|
|
func (ec *ExecutionContext) GetMetadataFilePath(format string) (string, error) {
|
|
|
|
ext := fmt.Sprintf(".%s", format)
|
|
|
|
for _, filePath := range ec.MetadataFile {
|
|
|
|
switch p := filepath.Ext(filePath); p {
|
|
|
|
case ext:
|
|
|
|
return filePath, nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return "", errors.New("unsupported file type")
|
|
|
|
}
|
2019-10-30 16:54:22 +03:00
|
|
|
|
|
|
|
// GetExistingMetadataFile returns the path to the default metadata file that
|
|
|
|
// also exists, json or yaml
|
|
|
|
func (ec *ExecutionContext) GetExistingMetadataFile() (string, error) {
|
|
|
|
filename := ""
|
|
|
|
for _, format := range []string{"yaml", "json"} {
|
|
|
|
f, err := ec.GetMetadataFilePath(format)
|
|
|
|
if err != nil {
|
|
|
|
return "", errors.Wrap(err, "cannot get metadata file")
|
|
|
|
}
|
|
|
|
|
|
|
|
filename = f
|
|
|
|
if _, err := os.Stat(filename); os.IsNotExist(err) {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
break
|
|
|
|
}
|
|
|
|
|
|
|
|
return filename, nil
|
|
|
|
}
|