func (c *createModelCommand) Init(args []string) error {
if len(args) == 0 {
return errors.New("model name is required")
}
c.Name, args = args[0], args[1:]
if c.Owner != "" && !names.IsValidUser(c.Owner) {
return errors.Errorf("%q is not a valid user", c.Owner)
}
if c.CredentialSpec != "" {
parts := strings.Split(c.CredentialSpec, ":")
if len(parts) < 2 {
return errors.Errorf("invalid cloud credential %s, expected <cloud>:<credential-name>", c.CredentialSpec)
}
c.CloudName = parts[0]
if cloud, err := common.CloudOrProvider(c.CloudName, cloud.CloudByName); err != nil {
return errors.Trace(err)
} else {
c.CloudType = cloud.Type
}
c.CredentialName = parts[1]
}
return nil
}
func (c *addCredentialCommand) Run(ctxt *cmd.Context) error {
// Check that the supplied cloud is valid.
var err error
if c.cloud, err = common.CloudOrProvider(c.CloudName, c.cloudByNameFunc); err != nil {
if !errors.IsNotFound(err) {
return err
}
}
if len(c.cloud.AuthTypes) == 0 {
return errors.Errorf("cloud %q does not require credentials", c.CloudName)
}
if c.CredentialsFile == "" {
credentialsProvider, err := environs.Provider(c.cloud.Type)
if err != nil {
return errors.Annotate(err, "getting provider for cloud")
}
return c.interactiveAddCredential(ctxt, credentialsProvider.CredentialSchemas())
}
data, err := ioutil.ReadFile(c.CredentialsFile)
if err != nil {
return errors.Annotate(err, "reading credentials file")
}
specifiedCredentials, err := jujucloud.ParseCredentials(data)
if err != nil {
return errors.Annotate(err, "parsing credentials file")
}
credentials, ok := specifiedCredentials[c.CloudName]
if !ok {
return errors.Errorf("no credentials for cloud %s exist in file %s", c.CloudName, c.CredentialsFile)
}
existingCredentials, err := c.existingCredentialsForCloud()
if err != nil {
return errors.Trace(err)
}
// If there are *any* credentials already for the cloud, we'll ask for the --replace flag.
if !c.Replace && len(existingCredentials.AuthCredentials) > 0 && len(credentials.AuthCredentials) > 0 {
return errors.Errorf("credentials for cloud %s already exist; use --replace to overwrite / merge", c.CloudName)
}
for name, cred := range credentials.AuthCredentials {
existingCredentials.AuthCredentials[name] = cred
}
err = c.store.UpdateCredential(c.CloudName, *existingCredentials)
if err != nil {
return err
}
fmt.Fprintf(ctxt.Stdout, "credentials updated for cloud %s\n", c.CloudName)
return nil
}
func (c *listCredentialsCommand) removeSecrets(cloudName string, cloudCred *jujucloud.CloudCredential) error {
cloud, err := common.CloudOrProvider(cloudName, c.cloudByNameFunc)
if err != nil {
return err
}
provider, err := environs.Provider(cloud.Type)
if err != nil {
return err
}
schemas := provider.CredentialSchemas()
for name, cred := range cloudCred.AuthCredentials {
sanitisedCred, err := jujucloud.RemoveSecrets(cred, schemas)
if err != nil {
return err
}
cloudCred.AuthCredentials[name] = *sanitisedCred
}
return nil
}
func (c *setDefaultCredentialCommand) Run(ctxt *cmd.Context) error {
if _, err := common.CloudOrProvider(c.cloud, jujucloud.CloudByName); err != nil {
return err
}
cred, err := c.store.CredentialForCloud(c.cloud)
if errors.IsNotFound(err) {
cred = &jujucloud.CloudCredential{}
} else if err != nil {
return err
}
if !hasCredential(c.credential, cred.AuthCredentials) {
return errors.NotValidf("credential %q for cloud %s", c.credential, c.cloud)
}
cred.DefaultCredential = c.credential
if err := c.store.UpdateCredential(c.cloud, *cred); err != nil {
return err
}
ctxt.Infof("Default credential for %s set to %q.", c.cloud, c.credential)
return nil
}
func (c *detectCredentialsCommand) promptCloudName(out io.Writer, in io.Reader, defaultCloudName, cloudType string) (string, error) {
text := fmt.Sprintf(`Select the cloud it belongs to, or type Q to quit [%s]: `, defaultCloudName)
fmt.Fprint(out, text)
defer out.Write([]byte{'\n'})
input, err := readLine(in)
if err != nil {
return "", errors.Trace(err)
}
cloudName := strings.TrimSpace(input)
if strings.ToLower(cloudName) == "q" {
return "", nil
}
if cloudName == "" {
return defaultCloudName, nil
}
cloud, err := common.CloudOrProvider(cloudName, c.cloudByNameFunc)
if err != nil {
return "", err
}
if cloud.Type != cloudType {
return "", errors.Errorf("chosen credentials not compatible with a %s cloud", cloud.Type)
}
return cloudName, nil
}