// 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() }
func getOrganization(token string, email string) (string, error) { FakeConnection, err := api.NewScalewayAPI("", token, scwversion.UserAgent(), "", clilogger.SetupLogger) if err != nil { return "", fmt.Errorf("Unable to create a fake ScalewayAPI: %s", err) } data, err := FakeConnection.GetOrganization() if err != nil { return "", err } orgaID := "" for _, orga := range data.Organizations { for _, user := range orga.Users { if user.Email == email { for i := range user.Organizations { if user.Organizations[i].Name != "OCS" { orgaID = user.Organizations[i].ID goto exit } } } } } if orgaID == "" { return "", fmt.Errorf("Unable to find your organization") } exit: return orgaID, nil }
func getToken(connect api.ScalewayConnect) (string, error) { FakeConnection, err := api.NewScalewayAPI("", "", scwversion.UserAgent(), "", clilogger.SetupLogger) if err != nil { return "", fmt.Errorf("Unable to create a fake ScalewayAPI: %s", err) } FakeConnection.SetPassword(connect.Password) resp, err := FakeConnection.PostResponse(api.AccountAPI, "tokens", connect) if resp != nil { defer resp.Body.Close() } if err != nil { return "", fmt.Errorf("unable to connect %v", err) } // Succeed POST code if resp.StatusCode != 201 { return "", fmt.Errorf("[%d] maybe your email or your password is not valid", resp.StatusCode) } var data api.ScalewayConnectResponse decoder := json.NewDecoder(resp.Body) err = decoder.Decode(&data) if err != nil { return "", err } return data.Token.ID, nil }
// RunLogin is the handler for 'scw login' func RunLogin(ctx CommandContext, args LoginArgs) error { 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()) 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) } } } return cfg.Save() }
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 }
func main() { router := gin.Default() router.LoadHTMLGlob("templates/*") router.GET("/", indexEndpoint) router.GET("/images", imagesEndpoint) router.GET("/images/:name", imageEndpoint) router.GET("/images/:name/dockerfile", imageDockerfileEndpoint) router.GET("/cache", cacheEndpoint) router.GET("/images/:name/new-server", newServerEndpoint) // router.GET("/images/:name/badge", imageBadgeEndpoint) Api, err := api.NewScalewayAPI("https://api.scaleway.com", "", os.Getenv("SCALEWAY_ORGANIZATION"), os.Getenv("SCALEWAY_TOKEN")) if err != nil { logrus.Fatalf("Failed to initialize Scaleway Api: %v", err) } go updateManifestCron(&cache) go updateScwApiImages(Api, &cache) // go updateScwApiBootscripts(Api, &cache) router.Run(":4242") }
// 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) }
func main() { router := gin.Default() router.StaticFile("/", "./static/index.html") router.Static("/static", "./static") router.Static("/bower_components", "./bower_components") // FIXME: favicon router.GET("/api/images", imagesEndpoint) router.GET("/api/images/:name", imageEndpoint) router.GET("/api/images/:name/dockerfile", imageDockerfileEndpoint) router.GET("/api/images/:name/makefile", imageMakefileEndpoint) router.GET("/api/bootscripts", bootscriptsEndpoint) router.GET("/api/bootscripts/:id", bootscriptEndpoint) router.GET("/api/cache", cacheEndpoint) router.GET("/images/:name/new-server", newServerEndpoint) router.GET("/badges/images/:name/scw-build.svg", badgeImageScwBuildEndpoint) // router.GET("/images/:name/badge", imageBadgeEndpoint) Api, err := api.NewScalewayAPI(os.Getenv("SCALEWAY_ORGANIZATION"), os.Getenv("SCALEWAY_TOKEN"), "devhub") if err != nil { logrus.Fatalf("Failed to initialize Scaleway Api: %v", err) } if os.Getenv("GITHUB_TOKEN") != "" { ts := oauth2.StaticTokenSource( &oauth2.Token{AccessToken: os.Getenv("GITHUB_TOKEN")}, ) tc := oauth2.NewClient(oauth2.NoContext, ts) gh := github.NewClient(tc) go devhub.UpdateGitHub(gh, cache) } else { logrus.Errorf("GITHUB_TOKEN empty") } go devhub.UpdateManifestCron(cache) go devhub.UpdateScwApiImages(Api, cache) go devhub.UpdateScwApiBootscripts(Api, cache) go devhub.UpdateDockerHub(cache) port := os.Getenv("PORT") if port == "" { port = "8000" } router.Run(fmt.Sprintf(":%s", port)) }
// Client configures and returns a fully initialized Scaleway client func (c *Config) Client() (*Client, error) { api, err := api.NewScalewayAPI( c.Organization, c.APIKey, scwversion.UserAgent(), func(s *api.ScalewayAPI) { s.Logger = newTerraformLogger() }, ) if err != nil { return nil, err } return &Client{api}, nil }
func testCommandContext() CommandContext { apiClient, err := api.NewScalewayAPI("https://example.org/", "https://example.org/", "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx") if err != nil { panic(err) } ctx := CommandContext{ Streams: Streams{ Stdin: os.Stdin, Stdout: os.Stdout, Stderr: os.Stderr, }, Env: []string{ "HOME" + os.Getenv("HOME"), }, RawArgs: []string{}, API: apiClient, } return ctx }
func testCommandContext() CommandContext { apiClient, err := api.NewScalewayAPI("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", scwversion.UserAgent(), "") if err != nil { panic(err) } ctx := CommandContext{ Streams: Streams{ Stdin: os.Stdin, Stdout: os.Stdout, Stderr: os.Stderr, }, Env: []string{ "HOME" + os.Getenv("HOME"), }, RawArgs: []string{}, API: apiClient, } return ctx }
// NewProvider creates a new Scaleway provider implementation func NewProvider(logger *logging.Logger, config ScalewayProviderConfig) (providers.CloudProvider, error) { if config.Organization == "" { return nil, maskAny(fmt.Errorf("Organization not set")) } if config.Token == "" { return nil, maskAny(fmt.Errorf("Token not set")) } if config.Region == "" { return nil, maskAny(fmt.Errorf("Region not set")) } client, err := api.NewScalewayAPI(config.Organization, config.Token, "quark", config.Region) if err != nil { return nil, maskAny(err) } client.Logger = NewScalewayLogger(logger) return &scalewayProvider{ ScalewayProviderConfig: config, Logger: logger, client: client, }, nil }
func ExampleCommandContext() { apiClient, err := api.NewScalewayAPI("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", scwversion.UserAgent(), "") if err != nil { panic(err) } ctx := CommandContext{ Streams: Streams{ Stdin: os.Stdin, Stdout: os.Stdout, Stderr: os.Stderr, }, Env: []string{ "HOME" + os.Getenv("HOME"), }, RawArgs: []string{}, API: apiClient, } // Do stuff fmt.Println(ctx) }
func Provider() *schema.Provider { return &schema.Provider{ Schema: map[string]*schema.Schema{ "token": &schema.Schema{ Type: schema.TypeString, Required: true, }, "organization": &schema.Schema{ Type: schema.TypeString, Required: true, }, "api_endpoint": &schema.Schema{ Type: schema.TypeString, Optional: true, Default: "https://api.scaleway.com/", }, "account_endpoint": &schema.Schema{ Type: schema.TypeString, Optional: true, Default: "https://account.scaleway.com/", }, }, ResourcesMap: map[string]*schema.Resource{ "scaleway_server": resourceServer(), "scaleway_ip": resourceIp(), }, ConfigureFunc: func(d *schema.ResourceData) (interface{}, error) { return api.NewScalewayAPI( d.Get("api_endpoint").(string), d.Get("account_endpoint").(string), d.Get("organization").(string), d.Get("token").(string), ) }, } }
func runUserdata(cmd *Command, args []string) error { if userdataHelp { return cmd.PrintUsage() } if len(args) < 1 { return cmd.PrintShortUsage() } ctx := cmd.GetContext(args) var Api *api.ScalewayAPI var err error var serverID string if args[0] == "local" { Api, err = api.NewScalewayAPI("", "", "", "") if err != nil { return err } Api.EnableMetadataAPI() } else { if ctx.API == nil { return fmt.Errorf("You need to login first: 'scw login'") } serverID = ctx.API.GetServerID(args[0]) Api = ctx.API } switch len(args) { case 1: // List userdata res, err := Api.GetUserdatas(serverID) if err != nil { return err } for _, key := range res.UserData { fmt.Fprintln(ctx.Stdout, key) } default: parts := strings.Split(args[1], "=") key := parts[0] switch len(parts) { case 1: // Get userdatas res, err := Api.GetUserdata(serverID, key) if err != nil { return err } fmt.Fprintf(ctx.Stdout, "%s\n", res.String()) default: value := parts[1] if value != "" { // Set userdata err := Api.PatchUserdata(serverID, key, []byte(value)) if err != nil { return err } fmt.Fprintln(ctx.Stdout, key) } else { // Delete userdata err := Api.DeleteUserdata(serverID, key) if err != nil { return err } } } } return nil }
func runUserdata(cmd *Command, args []string) error { if userdataHelp { return cmd.PrintUsage() } if len(args) < 1 { return cmd.PrintShortUsage() } metadata := false ctx := cmd.GetContext(args) var API *api.ScalewayAPI var err error var serverID string if args[0] == "local" { API, err = api.NewScalewayAPI("", "", scwversion.UserAgent(), *flRegion) if err != nil { return err } metadata = true } else { if ctx.API == nil { return fmt.Errorf("You need to login first: 'scw login'") } serverID, err = ctx.API.GetServerID(args[0]) if err != nil { return err } API = ctx.API } switch len(args) { case 1: // List userdata res, errGetUserdata := API.GetUserdatas(serverID, metadata) if errGetUserdata != nil { return errGetUserdata } for _, key := range res.UserData { fmt.Fprintln(ctx.Stdout, key) } default: parts := strings.Split(args[1], "=") key := parts[0] switch len(parts) { case 1: // Get userdatas res, errGetUserdata := API.GetUserdata(serverID, key, metadata) if errGetUserdata != nil { return errGetUserdata } fmt.Fprintf(ctx.Stdout, "%s\n", res.String()) default: value := args[1][len(parts[0])+1:] if value != "" { var data []byte // Set userdata if value[0] == '@' { if len(value) > 1 && value[1] == '~' { home, err := config.GetHomeDir() if err != nil { return err } value = "@" + home + value[2:] } data, err = ioutil.ReadFile(value[1:]) if err != nil { return err } } else { data = []byte(value) } err := API.PatchUserdata(serverID, key, data, metadata) if err != nil { return err } fmt.Fprintln(ctx.Stdout, key) } else { // Delete userdata err := API.DeleteUserdata(serverID, key, metadata) if err != nil { return err } } } } return nil }