Can switch users now.

Author: Joshua Reed

pkg/cloud/client.go

@@ -35,37 +35,38 @@ type Client interface {
 	ZoneIFace
 	IsoNetworkIface
 	UserCredIFace
+	NewClientFromSpec(Config) (Client, error)
 }
 
 type client struct {
 	cs      *cloudstack.CloudStackClient
 	csAsync *cloudstack.CloudStackClient
+	config  Config
 }
 
 // cloud-config ini structure.
-type config struct {
+type Config struct {
 	APIURL    string `ini:"api-url"`
 	APIKey    string `ini:"api-key"`
 	SecretKey string `ini:"secret-key"`
 	VerifySSL bool   `ini:"verify-ssl"`
 }
 
 func NewClient(ccPath string) (Client, error) {
-	c := &client{}
-	cfg := &config{VerifySSL: true}
+	c := &client{config: Config{VerifySSL: true}}
 	if rawCfg, err := ini.Load(ccPath); err != nil {
 		return nil, errors.Wrapf(err, "reading config at path %s:", ccPath)
 	} else if g := rawCfg.Section("Global"); len(g.Keys()) == 0 {
 		return nil, errors.New("section Global not found")
-	} else if err = rawCfg.Section("Global").StrictMapTo(cfg); err != nil {
+	} else if err = rawCfg.Section("Global").StrictMapTo(&c.config); err != nil {
 		return nil, errors.Wrapf(err, "parsing [Global] section from config at path %s:", ccPath)
 	}
 
 	// The client returned from NewAsyncClient works in a synchronous way. On the other hand,
 	// a client returned from NewClient works in an asynchronous way. Dive into the constructor definition
 	// comments for more details
-	c.cs = cloudstack.NewAsyncClient(cfg.APIURL, cfg.APIKey, cfg.SecretKey, cfg.VerifySSL)
-	c.csAsync = cloudstack.NewClient(cfg.APIURL, cfg.APIKey, cfg.SecretKey, cfg.VerifySSL)
+	c.cs = cloudstack.NewAsyncClient(c.config.APIURL, c.config.APIKey, c.config.SecretKey, c.config.VerifySSL)
+	c.csAsync = cloudstack.NewClient(c.config.APIURL, c.config.APIKey, c.config.SecretKey, c.config.VerifySSL)
 
 	_, err := c.cs.APIDiscovery.ListApis(c.cs.APIDiscovery.NewListApisParams())
 	if err != nil && strings.Contains(strings.ToLower(err.Error()), "i/o timeout") {
@@ -74,6 +75,29 @@ func NewClient(ccPath string) (Client, error) {
 	return c, errors.Wrap(err, "checking CloudStack API Client connectivity:")
 }
 
+// NewClientFromSpec generates a new client from an existing client.
+// Unless the passed config contains a new API URL the original one will be used.
+// VerifySSL will be set to true if either the old or new configs is true.
+func (origC *client) NewClientFromSpec(cfg Config) (Client, error) {
+	newC := &client{config: cfg}
+	newC.config.VerifySSL = cfg.VerifySSL || origC.config.VerifySSL // Prefer the most secure setting given.
+	if newC.config.APIURL == "" {
+		newC.config.APIURL = origC.config.APIURL
+	}
+
+	// The client returned from NewAsyncClient works in a synchronous way. On the other hand,
+	// a client returned from NewClient works in an asynchronous way. Dive into the constructor definition
+	// comments for more details
+	newC.cs = cloudstack.NewAsyncClient(newC.config.APIURL, newC.config.APIKey, newC.config.SecretKey, newC.config.VerifySSL)
+	newC.csAsync = cloudstack.NewClient(newC.config.APIURL, newC.config.APIKey, newC.config.SecretKey, newC.config.VerifySSL)
+
+	_, err := newC.cs.APIDiscovery.ListApis(newC.cs.APIDiscovery.NewListApisParams())
+	if err != nil && strings.Contains(strings.ToLower(err.Error()), "i/o timeout") {
+		return newC, errors.Wrap(err, "timeout while checking CloudStack API Client connectivity")
+	}
+	return newC, errors.Wrap(err, "checking CloudStack API Client connectivity:")
+}
+
 func NewClientFromCSAPIClient(cs *cloudstack.CloudStackClient) Client {
 	c := &client{cs: cs, csAsync: cs}
 	return c

pkg/cloud/user_credentials.go

@@ -27,6 +27,7 @@ type UserCredIFace interface {
 	ResolveAccount(*Account) error
 	ResolveUser(*User) error
 	ResolveUserKeys(*User) error
+	GetUserWithKeys(*User) (bool, error)
 }
 
 // Domain contains specifications that identify a domain.
@@ -186,10 +187,10 @@ func (c *client) ResolveUserKeys(user *User) error {
 
 // GetUserWithKeys will search a domain and account for the first user that has api keys.
 // Returns true if a user is found and false otherwise.
-func (c *client) GetUserWithKeys(user *User) (error, bool) {
+func (c *client) GetUserWithKeys(user *User) (bool, error) {
 	// Resolve account prior to any user resolution activity.
 	if err := c.ResolveAccount(&user.Account); err != nil {
-		return errors.Wrap(err, "error encountered when resolving account details"), false
+		return false, errors.Wrap(err, "error encountered when resolving account details")
 	}
 
 	// List users and take first user that has already has api keys.
@@ -199,16 +200,43 @@ func (c *client) GetUserWithKeys(user *User) (error, bool) {
 	p.SetListall(true)
 	resp, err := c.cs.User.ListUsers(p)
 	if err != nil {
-		return err, false
+		return false, err
 	}
 
 	// Return first user with keys.
 	for _, possibleUser := range resp.Users {
 		user.ID = possibleUser.Id
 		if err := c.ResolveUserKeys(user); err == nil {
-			return nil, true
+			return true, nil
 		}
 	}
 	user.ID = ""
-	return nil, false
+	return false, nil
+}
+
+// GetOrCreateUserWithKeys will search a domain and account for the first user that has api keys.
+// Creates a CAPC user if no such user is found.
+func (c *client) GetOrCreateUserWithKeys(user *User) error {
+	return nil
+}
+
+// CreateUserWithKeys will create a CloudStack user in the specified domain and account and generate API keyes for
+// said user.
+func (c *client) CreateUserWithKeys(user *User) error {
+	return nil
+}
+
+// SetupUserAPIKeys adds api keys to a specified user.
+func SetupUserAPIKeys() error {
+	return nil
+}
+
+// Create user creates a user in the specified account and domain.
+func (c *client) CreateUser(user *User) error {
+	return nil
+}
+
+// DeleteUser removes a user from CloudStack.
+func (c *client) DeleteUser(user *User) error {
+	return nil
 }

pkg/cloud/user_credentials_test.go

@@ -77,7 +77,21 @@ var _ = Describe("User Credentials", func() {
 		})
 
 		It("can get an arbitrary user with keys from domain and account specifications alone", func() {
-			Ω(client.ResolveUserKeys(&user)).Should(Succeed())
+			found, err := client.GetUserWithKeys(&user)
+			Ω(err).ShouldNot(HaveOccurred())
+			Ω(found).Should(BeTrue())
+			Ω(user.APIKey).ShouldNot(BeEmpty())
+		})
+
+		It("can get create a new client as another user", func() {
+			found, err := client.GetUserWithKeys(&user)
+			Ω(err).ShouldNot(HaveOccurred())
+			Ω(found).Should(BeTrue())
+			Ω(user.APIKey).ShouldNot(BeEmpty())
+			cfg := cloud.Config{APIKey: user.APIKey, SecretKey: user.SecretKey}
+			newClient, err := client.NewClientFromSpec(cfg)
+			Ω(err).ShouldNot(HaveOccurred())
+			Ω(newClient).ShouldNot(BeNil())
 		})
 	})
 })