// 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
}