github.com/niedbalski/juju@v0.0.0-20190215020005-8ff100488e47/cmd/juju/user/disenable.go (about)

     1  // Copyright 2014 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package user
     5  
     6  import (
     7  	"github.com/juju/cmd"
     8  	"github.com/juju/errors"
     9  
    10  	jujucmd "github.com/juju/juju/cmd"
    11  	"github.com/juju/juju/cmd/juju/block"
    12  	"github.com/juju/juju/cmd/modelcmd"
    13  )
    14  
    15  var usageDisableUserSummary = `
    16  Disables a Juju user.`[1:]
    17  
    18  var usageDisableUserDetails = `
    19  A disabled Juju user is one that cannot log in to any controller.
    20  This command has no affect on models that the disabled user may have
    21  created and/or shared nor any applications associated with that user.
    22  
    23  Examples:
    24      juju disable-user bob
    25  
    26  See also: 
    27      users
    28      enable-user
    29      login`[1:]
    30  
    31  var usageEnableUserSummary = `
    32  Re-enables a previously disabled Juju user.`[1:]
    33  
    34  var usageEnableUserDetails = `
    35  An enabled Juju user is one that can log in to a controller.
    36  
    37  Examples:
    38      juju enable-user bob
    39  
    40  See also: 
    41      users
    42      disable-user
    43      login`[1:]
    44  
    45  // disenableUserBase common code for enable/disable user commands
    46  type disenableUserBase struct {
    47  	modelcmd.ControllerCommandBase
    48  	api  disenableUserAPI
    49  	User string
    50  }
    51  
    52  func NewDisableCommand() cmd.Command {
    53  	return modelcmd.WrapController(&disableCommand{})
    54  }
    55  
    56  // disableCommand disables users.
    57  type disableCommand struct {
    58  	disenableUserBase
    59  }
    60  
    61  func NewEnableCommand() cmd.Command {
    62  	return modelcmd.WrapController(&enableCommand{})
    63  }
    64  
    65  // enableCommand enables users.
    66  type enableCommand struct {
    67  	disenableUserBase
    68  }
    69  
    70  // Info implements Command.Info.
    71  func (c *disableCommand) Info() *cmd.Info {
    72  	return jujucmd.Info(&cmd.Info{
    73  		Name:    "disable-user",
    74  		Args:    "<user name>",
    75  		Purpose: usageDisableUserSummary,
    76  		Doc:     usageDisableUserDetails,
    77  	})
    78  }
    79  
    80  // Info implements Command.Info.
    81  func (c *enableCommand) Info() *cmd.Info {
    82  	return jujucmd.Info(&cmd.Info{
    83  		Name:    "enable-user",
    84  		Args:    "<user name>",
    85  		Purpose: usageEnableUserSummary,
    86  		Doc:     usageEnableUserDetails,
    87  	})
    88  }
    89  
    90  // Init implements Command.Init.
    91  func (c *disenableUserBase) Init(args []string) error {
    92  	if len(args) == 0 {
    93  		return errors.New("no username supplied")
    94  	}
    95  	// TODO(thumper): support multiple users in one command,
    96  	// and also verify that the values are valid user names.
    97  	c.User = args[0]
    98  	return cmd.CheckEmpty(args[1:])
    99  }
   100  
   101  // Username is here entirely for testing purposes to allow both the
   102  // disableCommand and enableCommand to support a common interface that is able
   103  // to ask for the command line supplied username.
   104  func (c *disenableUserBase) Username() string {
   105  	return c.User
   106  }
   107  
   108  // disenableUserAPI defines the API methods that the disable and enable
   109  // commands use.
   110  type disenableUserAPI interface {
   111  	EnableUser(username string) error
   112  	DisableUser(username string) error
   113  	Close() error
   114  }
   115  
   116  // Run implements Command.Run.
   117  func (c *disableCommand) Run(ctx *cmd.Context) error {
   118  	if c.api == nil {
   119  		api, err := c.NewUserManagerAPIClient()
   120  		if err != nil {
   121  			return errors.Trace(err)
   122  		}
   123  		c.api = api
   124  		defer c.api.Close()
   125  	}
   126  
   127  	if err := c.api.DisableUser(c.User); err != nil {
   128  		return block.ProcessBlockedError(err, block.BlockChange)
   129  	}
   130  	ctx.Infof("User %q disabled", c.User)
   131  	return nil
   132  }
   133  
   134  // Run implements Command.Run.
   135  func (c *enableCommand) Run(ctx *cmd.Context) error {
   136  	if c.api == nil {
   137  		api, err := c.NewUserManagerAPIClient()
   138  		if err != nil {
   139  			return errors.Trace(err)
   140  		}
   141  		c.api = api
   142  		defer c.api.Close()
   143  	}
   144  
   145  	if err := c.api.EnableUser(c.User); err != nil {
   146  		return block.ProcessBlockedError(err, block.BlockChange)
   147  	}
   148  	ctx.Infof("User %q enabled", c.User)
   149  	return nil
   150  }