func RealAPIContext() *CommandContext {
config, err := config.GetConfig()
if err != nil {
logrus.Warnf("RealAPIContext: failed to call config.GetConfig(): %v", err)
return nil
}
apiClient, err := api.NewScalewayAPI(config.ComputeAPI, config.AccountAPI, config.Organization, config.Token)
if err != nil {
logrus.Warnf("RealAPIContext: failed to call api.NewScalewayAPI(): %v", err)
return nil
}
stdout := bytes.Buffer{}
stderr := bytes.Buffer{}
ctx := CommandContext{
Streams: Streams{
Stdin: os.Stdin,
Stdout: &stdout,
Stderr: &stderr,
},
Env: []string{
"HOME" + os.Getenv("HOME"),
},
RawArgs: []string{},
API: apiClient,
}
return &ctx
}
// RealAPIContext returns a CommandContext with a configured API
func RealAPIContext() *CommandContext {
if os.Getenv("TEST_WITH_REAL_API") == "0" {
return nil
}
config, err := config.GetConfig()
if err != nil {
logrus.Warnf("RealAPIContext: failed to call config.GetConfig(): %v", err)
return nil
}
apiClient, err := api.NewScalewayAPI(config.Organization, config.Token, scwversion.UserAgent(), "par1")
if err != nil {
logrus.Warnf("RealAPIContext: failed to call api.NewScalewayAPI(): %v", err)
return nil
}
stdout := bytes.Buffer{}
stderr := bytes.Buffer{}
ctx := CommandContext{
Streams: Streams{
Stdin: os.Stdin,
Stdout: &stdout,
Stderr: &stderr,
},
Env: []string{
"HOME" + os.Getenv("HOME"),
},
RawArgs: []string{},
API: apiClient,
}
return &ctx
}
// getScalewayAPI returns a ScalewayAPI using the user config file
func getScalewayAPI() (*api.ScalewayAPI, error) {
// We already get config globally, but whis way we can get explicit error when trying to create a ScalewayAPI object
config, err := config.GetConfig()
if err != nil {
return nil, err
}
return api.NewScalewayAPI(config.Organization, config.Token, scwversion.UserAgent())
}
// getScalewayAPI returns a ScalewayAPI using the user config file
func getScalewayAPI() (*api.ScalewayAPI, error) {
// We already get config globally, but whis way we can get explicit error when trying to create a ScalewayAPI object
config, err := config.GetConfig()
if err != nil {
return nil, err
}
return api.NewScalewayAPI(os.Getenv("scaleway_api_endpoint"), config.AccountAPI, config.Organization, config.Token)
}
// RunLogin is the handler for 'scw login'
func RunLogin(ctx CommandContext, args LoginArgs) error {
if config, cfgErr := config.GetConfig(); cfgErr == nil {
if TestConnection, err := api.NewScalewayAPI(config.Organization, config.Token, scwversion.UserAgent(), "", clilogger.SetupLogger); err == nil {
if user, err := TestConnection.GetUser(); err == nil {
fmt.Println("You are already logged as", user.Fullname)
}
}
}
if args.Organization == "" || args.Token == "" {
var err error
args.Organization, args.Token, err = connectAPI()
if err != nil {
return err
}
}
cfg := &config.Config{
Organization: strings.Trim(args.Organization, "\n"),
Token: strings.Trim(args.Token, "\n"),
}
apiConnection, err := api.NewScalewayAPI(cfg.Organization, cfg.Token, scwversion.UserAgent(), "", clilogger.SetupLogger)
if err != nil {
return fmt.Errorf("Unable to create ScalewayAPI: %s", err)
}
err = apiConnection.CheckCredentials()
if err != nil {
return fmt.Errorf("Unable to contact ScalewayAPI: %s", err)
}
if !args.SkipSSHKey {
if err = selectKey(&args); err != nil {
logrus.Errorf("Unable to select a key: %v", err)
} else {
if args.SSHKey != "" {
uploadSSHKeys(apiConnection, args.SSHKey)
}
}
}
name := "."
user, err := apiConnection.GetUser()
if err == nil {
name = "as " + user.Fullname + "."
}
fmt.Println("")
fmt.Println("You are now authenticated on Scaleway.com", name)
fmt.Println("You can list your existing servers using `scw ps` or create a new one using `scw run ubuntu-xenial`.")
fmt.Println("You can get a list of all available commands using `scw -h` and get more usage examples on github.com/scaleway/scaleway-cli.")
fmt.Println("Happy cloud riding.")
return cfg.Save()
}
// Start is the entrypoint
func Start(rawArgs []string, streams *commands.Streams) (int, error) {
checkVersion()
if streams == nil {
streams = &commands.Streams{
Stdin: os.Stdin,
Stdout: os.Stdout,
Stderr: os.Stderr,
}
}
flag.CommandLine.Parse(rawArgs)
config, cfgErr := config.GetConfig()
if cfgErr != nil && !os.IsNotExist(cfgErr) {
return 1, fmt.Errorf("unable to open .scwrc config file: %v", cfgErr)
}
if *flVersion {
fmt.Fprintf(streams.Stderr, "scw version %s, build %s\n", scwversion.VERSION, scwversion.GITCOMMIT)
return 0, nil
}
if *flSensitive {
os.Setenv("SCW_SENSITIVE", "1")
}
if *flDebug {
os.Setenv("DEBUG", "1")
}
utils.Quiet(*flQuiet)
initLogging(os.Getenv("DEBUG") != "", *flVerbose, streams)
args := flag.Args()
if len(args) < 1 {
CmdHelp.Exec(CmdHelp, []string{})
return 1, nil
}
name := args[0]
args = args[1:]
// Apply default values
for _, cmd := range Commands {
cmd.streams = streams
}
for _, cmd := range Commands {
if cmd.Name() == name {
cmd.Flag.SetOutput(ioutil.Discard)
err := cmd.Flag.Parse(args)
if err != nil {
return 1, fmt.Errorf("usage: scw %s", cmd.UsageLine)
}
switch cmd.Name() {
case "login", "help", "version":
// commands that don't need API
case "_userdata":
// commands that may need API
api, _ := getScalewayAPI()
cmd.API = api
default:
// commands that do need API
if cfgErr != nil {
if name != "login" && config == nil {
logrus.Debugf("cfgErr: %v", cfgErr)
fmt.Fprintf(streams.Stderr, "You need to login first: 'scw login'\n")
return 1, nil
}
}
api, errGet := getScalewayAPI()
if errGet != nil {
return 1, fmt.Errorf("unable to initialize scw api: %v", errGet)
}
cmd.API = api
}
// clean cache between versions
if cmd.API != nil && config.Version != scwversion.VERSION {
cmd.API.ClearCache()
config.Save()
}
err = cmd.Exec(cmd, cmd.Flag.Args())
switch err {
case nil:
case ErrExitFailure:
return 1, nil
case ErrExitSuccess:
return 0, nil
default:
return 1, fmt.Errorf("cannot execute '%s': %v", cmd.Name(), err)
}
if cmd.API != nil {
cmd.API.Sync()
}
return 0, nil
}
}
return 1, fmt.Errorf("scw: unknown subcommand %s\nRun 'scw help' for usage", name)
}
func Start(rawArgs []string, streams *commands.Streams) (int, error) {
if streams == nil {
streams = &commands.Streams{
Stdin: os.Stdin,
Stdout: os.Stdout,
Stderr: os.Stderr,
}
}
flag.CommandLine.Parse(rawArgs)
config, cfgErr := config.GetConfig()
if cfgErr != nil && !os.IsNotExist(cfgErr) {
return 1, fmt.Errorf("unable to open .scwrc config file: %v", cfgErr)
}
if config != nil {
defaultComputeAPI := os.Getenv("scaleway_api_endpoint")
if defaultComputeAPI == "" {
defaultComputeAPI = config.ComputeAPI
}
if flAPIEndPoint == nil {
flAPIEndPoint = flag.String([]string{"-api-endpoint"}, defaultComputeAPI, "Set the API endpoint")
}
}
if *flVersion {
fmt.Fprintf(streams.Stderr, "scw version %s, build %s\n", scwversion.VERSION, scwversion.GITCOMMIT)
return 0, nil
}
if flAPIEndPoint != nil {
os.Setenv("scaleway_api_endpoint", *flAPIEndPoint)
}
if *flSensitive {
os.Setenv("SCW_SENSITIVE", "1")
}
if *flDebug {
os.Setenv("DEBUG", "1")
}
utils.Quiet(*flQuiet)
initLogging(os.Getenv("DEBUG") != "", *flVerbose, streams)
args := flag.Args()
if len(args) < 1 {
CmdHelp.Exec(CmdHelp, []string{})
return 1, nil
}
name := args[0]
args = args[1:]
// Apply default values
for _, cmd := range Commands {
cmd.streams = streams
}
for _, cmd := range Commands {
if cmd.Name() == name {
cmd.Flag.SetOutput(ioutil.Discard)
err := cmd.Flag.Parse(args)
if err != nil {
return 1, fmt.Errorf("usage: scw %s", cmd.UsageLine)
}
if cmd.Name() != "login" && cmd.Name() != "help" && cmd.Name() != "version" {
if cfgErr != nil {
if name != "login" && config == nil {
logrus.Debugf("cfgErr: %v", cfgErr)
fmt.Fprintf(streams.Stderr, "You need to login first: 'scw login'\n")
return 1, nil
}
}
api, err := getScalewayAPI()
if err != nil {
return 1, fmt.Errorf("unable to initialize scw api: %s", err)
}
cmd.API = api
}
err = cmd.Exec(cmd, cmd.Flag.Args())
switch err {
case nil:
case ErrExitFailure:
return 1, nil
case ErrExitSuccess:
return 0, nil
default:
return 1, fmt.Errorf("cannot execute '%s': %v", cmd.Name(), err)
}
if cmd.API != nil {
cmd.API.Sync()
}
return 0, nil
}
}
return 1, fmt.Errorf("scw: unknown subcommand %s\nRun 'scw help' for usage.", name)
}