func (c *restoreCommand) Init(args []string) error {
if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
return err
}
if c.showDescription {
return cmd.CheckEmpty(args)
}
if len(args) == 0 {
return fmt.Errorf("no backup file specified")
}
c.backupFile = args[0]
return cmd.CheckEmpty(args[1:])
}
func (c *BootstrapCommand) Init(args []string) (err error) {
if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
return err
}
if len(c.Series) > 0 && !c.UploadTools {
return fmt.Errorf("--upload-series requires --upload-tools")
}
if len(c.seriesOld) > 0 && !c.UploadTools {
return fmt.Errorf("--series requires --upload-tools")
}
if len(c.Series) > 0 && len(c.seriesOld) > 0 {
return fmt.Errorf("--upload-series and --series can't be used together")
}
if len(c.seriesOld) > 0 {
c.Series = c.seriesOld
}
// Parse the placement directive. Bootstrap currently only
// supports provider-specific placement directives.
if c.Placement != "" {
_, err = instance.ParsePlacement(c.Placement)
if err != instance.ErrPlacementScopeMissing {
// We only support unscoped placement directives for bootstrap.
return fmt.Errorf("unsupported bootstrap placement directive %q", c.Placement)
}
}
return cmd.CheckEmpty(args)
}
func (c *UpgradeJujuCommand) Init(args []string) error {
if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
return err
}
if c.vers != "" {
vers, err := version.Parse(c.vers)
if err != nil {
return err
}
if vers.Major != version.Current.Major {
return fmt.Errorf("cannot upgrade to version incompatible with CLI")
}
if c.UploadTools && vers.Build != 0 {
// TODO(fwereade): when we start taking versions from actual built
// code, we should disable --version when used with --upload-tools.
// For now, it's the only way to experiment with version upgrade
// behaviour live, so the only restriction is that Build cannot
// be used (because its value needs to be chosen internally so as
// not to collide with existing tools).
return fmt.Errorf("cannot specify build number when uploading tools")
}
c.Version = vers
}
if len(c.Series) > 0 && !c.UploadTools {
return fmt.Errorf("--series requires --upload-tools")
}
return cmd.CheckEmpty(args)
}
func (c *portCommand) Init(args []string) error {
if args == nil {
return errors.New("no port specified")
}
parts := strings.Split(args[0], "/")
if len(parts) > 2 {
return fmt.Errorf("expected %s; got %q", portFormat, args[0])
}
port, err := strconv.Atoi(parts[0])
if err != nil {
return badPort(parts[0])
}
if port < 1 || port > 65535 {
return badPort(port)
}
protocol := "tcp"
if len(parts) == 2 {
protocol = strings.ToLower(parts[1])
if protocol != "tcp" && protocol != "udp" {
return fmt.Errorf(`protocol must be "tcp" or "udp"; got %q`, protocol)
}
}
c.Port = port
c.Protocol = protocol
return cmd.CheckEmpty(args[1:])
}
func (c *SignMetadataCommand) Init(args []string) error {
if c.dir == "" {
return fmt.Errorf("directory must be specified")
}
if c.keyFile == "" {
return fmt.Errorf("keyfile must be specified")
}
return cmd.CheckEmpty(args)
}
func (c *EnsureAvailabilityCommand) Init(args []string) error {
if err := c.EnsureEnvName(); err != nil {
return err
}
if c.NumStateServers < 0 || (c.NumStateServers%2 != 1 && c.NumStateServers != 0) {
return fmt.Errorf("must specify a number of state servers odd and non-negative")
}
return cmd.CheckEmpty(args)
}
func (c *UnitGetCommand) Init(args []string) error {
if args == nil {
return errors.New("no setting specified")
}
if args[0] != "private-address" && args[0] != "public-address" {
return fmt.Errorf("unknown setting %q", args[0])
}
c.Key = args[0]
return cmd.CheckEmpty(args[1:])
}
func (c *OwnerGetCommand) Init(args []string) error {
if args == nil {
return errors.New("no setting specified")
}
if args[0] != "tag" {
return fmt.Errorf("unknown setting %q", args[0])
}
c.Key = args[0]
return cmd.CheckEmpty(args[1:])
}
func (c *UnexposeCommand) Init(args []string) error {
if err := c.EnsureEnvName(); err != nil {
return err
}
if len(args) == 0 {
return errors.New("no service name specified")
}
c.ServiceName = args[0]
return cmd.CheckEmpty(args[1:])
}
func (c *PublishCommand) Init(args []string) error {
if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
return err
}
if len(args) == 0 {
return nil
}
c.URL = args[0]
return cmd.CheckEmpty(args[1:])
}
func (c *RemoveUserCommand) Init(args []string) error {
if err := c.EnsureEnvName(); err != nil {
return err
}
if len(args) == 0 {
return errors.New("no username supplied")
}
c.User = args[0]
return cmd.CheckEmpty(args[1:])
}
func (c *GetCommand) Init(args []string) error {
if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
return err
}
// TODO(dfc) add --schema-only
if len(args) == 0 {
return errors.New("no service name specified")
}
c.ServiceName = args[0]
return cmd.CheckEmpty(args[1:])
}
func (c *ConfigGetCommand) Init(args []string) error {
if args == nil {
return nil
}
c.Key = args[0]
if c.Key != "" && c.All {
return fmt.Errorf("cannot use argument --all together with key %q", c.Key)
}
return cmd.CheckEmpty(args[1:])
}
func (c *GetConstraintsCommand) Init(args []string) error {
if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
return err
}
if len(args) > 0 {
if !names.IsService(args[0]) {
return fmt.Errorf("invalid service name %q", args[0])
}
c.ServiceName, args = args[0], args[1:]
}
return cmd.CheckEmpty(args)
}
func (c *RelationIdsCommand) Init(args []string) error {
if r, found := c.ctx.HookRelation(); found {
c.Name = r.Name()
}
if len(args) > 0 {
c.Name = args[0]
args = args[1:]
} else if c.Name == "" {
return fmt.Errorf("no relation name specified")
}
return cmd.CheckEmpty(args)
}
func (c *DestroyServiceCommand) Init(args []string) error {
if err := c.EnsureEnvName(); err != nil {
return err
}
if len(args) == 0 {
return fmt.Errorf("no service specified")
}
if !names.IsService(args[0]) {
return fmt.Errorf("invalid service name %q", args[0])
}
c.ServiceName, args = args[0], args[1:]
return cmd.CheckEmpty(args)
}
func (c *DebugLogCommand) Init(args []string) error {
if err := c.EnsureEnvName(); err != nil {
return err
}
if c.level != "" {
level, ok := loggo.ParseLevel(c.level)
if !ok || level < loggo.TRACE || level > loggo.ERROR {
return fmt.Errorf("level value %q is not one of %q, %q, %q, %q, %q",
c.level, loggo.TRACE, loggo.DEBUG, loggo.INFO, loggo.WARNING, loggo.ERROR)
}
c.params.Level = level
}
return cmd.CheckEmpty(args)
}
func (c *AddUnitCommand) Init(args []string) error {
if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
return err
}
switch len(args) {
case 1:
c.ServiceName = args[0]
case 0:
return errors.New("no service specified")
}
if err := cmd.CheckEmpty(args[1:]); err != nil {
return err
}
return c.UnitCommandBase.Init(args)
}
func (c *ResolvedCommand) Init(args []string) error {
if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
return err
}
if len(args) > 0 {
c.UnitName = args[0]
if !names.IsUnit(c.UnitName) {
return fmt.Errorf("invalid unit name %q", c.UnitName)
}
args = args[1:]
} else {
return fmt.Errorf("no unit specified")
}
return cmd.CheckEmpty(args)
}
func (c *RunCommand) Init(args []string) error {
if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
return err
}
if len(args) == 0 {
return errors.New("no commands specified")
}
c.commands, args = args[0], args[1:]
if c.all {
if len(c.machines) != 0 {
return fmt.Errorf("You cannot specify --all and individual machines")
}
if len(c.services) != 0 {
return fmt.Errorf("You cannot specify --all and individual services")
}
if len(c.units) != 0 {
return fmt.Errorf("You cannot specify --all and individual units")
}
} else {
if len(c.machines) == 0 && len(c.services) == 0 && len(c.units) == 0 {
return fmt.Errorf("You must specify a target, either through --all, --machine, --service or --unit")
}
}
var nameErrors []string
for _, machineId := range c.machines {
if !names.IsMachine(machineId) {
nameErrors = append(nameErrors, fmt.Sprintf(" %q is not a valid machine id", machineId))
}
}
for _, service := range c.services {
if !names.IsService(service) {
nameErrors = append(nameErrors, fmt.Sprintf(" %q is not a valid service name", service))
}
}
for _, unit := range c.units {
if !names.IsUnit(unit) {
nameErrors = append(nameErrors, fmt.Sprintf(" %q is not a valid unit name", unit))
}
}
if len(nameErrors) > 0 {
return fmt.Errorf("The following run targets are not valid:\n%s",
strings.Join(nameErrors, "\n"))
}
return cmd.CheckEmpty(args)
}
func (c *SyncToolsCommand) Init(args []string) error {
if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
return err
}
if c.destination != "" {
// Override localDir with destination as localDir now replaces destination
c.localDir = c.destination
logger.Warningf("Use of the --destination flag is deprecated in 1.18. Please use --local-dir instead.")
}
if c.versionStr != "" {
var err error
if c.majorVersion, c.minorVersion, err = version.ParseMajorMinor(c.versionStr); err != nil {
return err
}
}
return cmd.CheckEmpty(args)
}
func (c *ValidateImageMetadataCommand) Init(args []string) error {
if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
return err
}
if c.providerType != "" {
if c.series == "" {
return fmt.Errorf("series required if provider type is specified")
}
if c.region == "" {
return fmt.Errorf("region required if provider type is specified")
}
if c.metadataDir == "" {
return fmt.Errorf("metadata directory required if provider type is specified")
}
}
return cmd.CheckEmpty(args)
}
func (c *AddUserCommand) Init(args []string) error {
if err := c.EnsureEnvName(); err != nil {
return err
}
switch len(args) {
case 0:
return fmt.Errorf("no username supplied")
case 1:
c.GeneratePassword = true
case 2:
c.Password = args[1]
default:
return cmd.CheckEmpty(args[2:])
}
c.User = args[0]
return nil
}
func (c *UpgradeCharmCommand) Init(args []string) error {
if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
return err
}
switch len(args) {
case 1:
if !names.IsService(args[0]) {
return fmt.Errorf("invalid service name %q", args[0])
}
c.ServiceName = args[0]
case 0:
return errors.New("no service specified")
default:
return cmd.CheckEmpty(args[1:])
}
if c.SwitchURL != "" && c.Revision != -1 {
return fmt.Errorf("--switch and --revision are mutually exclusive")
}
return nil
}
func (c *RunCommand) Init(args []string) error {
// make sure we aren't in an existing hook context
if contextId, err := getenv("JUJU_CONTEXT_ID"); err == nil && contextId != "" {
return fmt.Errorf("juju-run cannot be called from within a hook, have context %q", contextId)
}
if !c.noContext {
if len(args) < 1 {
return fmt.Errorf("missing unit-name")
}
c.unit, args = args[0], args[1:]
// If the command line param is a unit id (like service/2) we need to
// change it to the unit tag as that is the format of the agent directory
// on disk (unit-service-2).
if names.IsUnit(c.unit) {
c.unit = names.UnitTag(c.unit)
}
}
if len(args) < 1 {
return fmt.Errorf("missing commands")
}
c.commands, args = args[0], args[1:]
return cmd.CheckEmpty(args)
}
func (c *RelationGetCommand) Init(args []string) error {
if c.RelationId == -1 {
return fmt.Errorf("no relation id specified")
}
c.Key = ""
if len(args) > 0 {
if c.Key = args[0]; c.Key == "-" {
c.Key = ""
}
args = args[1:]
}
if name, found := c.ctx.RemoteUnitName(); found {
c.UnitName = name
}
if len(args) > 0 {
c.UnitName = args[0]
args = args[1:]
}
if c.UnitName == "" {
return fmt.Errorf("no unit id specified")
}
return cmd.CheckEmpty(args)
}
func (c *ValidateToolsMetadataCommand) Init(args []string) error {
if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
return err
}
if c.providerType != "" {
if c.region == "" {
return fmt.Errorf("region required if provider type is specified")
}
if c.metadataDir == "" {
return fmt.Errorf("metadata directory required if provider type is specified")
}
}
if c.exactVersion == "current" {
c.exactVersion = version.Current.Number.String()
}
if c.partVersion != "" {
var err error
if c.major, c.minor, err = version.ParseMajorMinor(c.partVersion); err != nil {
return err
}
}
return cmd.CheckEmpty(args)
}
func (c *DeployCommand) Init(args []string) error {
if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
return err
}
switch len(args) {
case 2:
if !names.IsService(args[1]) {
return fmt.Errorf("invalid service name %q", args[1])
}
c.ServiceName = args[1]
fallthrough
case 1:
if _, err := charm.InferURL(args[0], "fake"); err != nil {
return fmt.Errorf("invalid charm name %q", args[0])
}
c.CharmName = args[0]
case 0:
return errors.New("no charm specified")
default:
return cmd.CheckEmpty(args[2:])
}
return c.UnitCommandBase.Init(args)
}
func (c *DestroyEnvironmentCommand) Init(args []string) error {
if c.envName != "" {
logger.Warningf("-e/--environment flag is deprecated in 1.18, " +
"please supply environment as a positional parameter")
// They supplied the -e flag
if len(args) == 0 {
// We're happy, we have enough information
return nil
}
// You can't supply -e ENV and ENV as a positional argument
return DoubleEnvironmentError
}
// No -e flag means they must supply the environment positionally
switch len(args) {
case 0:
return NoEnvironmentError
case 1:
c.envName = args[0]
return nil
default:
return cmd.CheckEmpty(args[1:])
}
}
func (c *EndpointCommand) Init(args []string) error {
if err := c.EnvCommandBase.EnsureEnvName(); err != nil {
return err
}
return cmd.CheckEmpty(args)
}