This section is empty.


This section is empty.


This section is empty.


type Action

type Action struct {
	ID         string
	Receiver   string
	Name       string
	Parameters map[string]interface{}

    Action is a named task to execute on a unit or machine.

    type ActionMessage

    type ActionMessage struct {
    	Timestamp time.Time
    	Message   string

      ActionMessage represents a logged message on an action.

      type ActionReference

      type ActionReference struct {
      	ID       string
      	Receiver string
      	Error    error

        ActionReference is a reference to an action on a receiver.

        type ActionResult

        type ActionResult struct {
        	Action    *Action
        	Enqueued  time.Time
        	Started   time.Time
        	Completed time.Time
        	Status    string
        	Message   string
        	Log       []ActionMessage
        	Output    map[string]interface{}
        	Error     error

          ActionResult is the result of running an action.

          type ActionSpec

          type ActionSpec struct {
          	Description string
          	Params      map[string]interface{}

            ActionSpec is a definition of the parameters and traits of an Action. The Params map is expected to conform to JSON-Schema Draft 4 as defined at (see

            type Client

            type Client struct {
            	// contains filtered or unexported fields

              Client provides access to the action facade.

              func NewClient

              func NewClient(st base.APICallCloser) *Client

                NewClient returns a new actions client.

                func (*Client) Actions

                func (c *Client) Actions(actionIDs []string) ([]ActionResult, error)

                  Actions takes a list of ActionTags, and returns the full Action for each ID.

                  func (*Client) ApplicationCharmActions

                  func (c *Client) ApplicationCharmActions(appName string) (map[string]ActionSpec, error)

                    ApplicationCharmActions is a single query which uses ApplicationsCharmsActions to get the charm.Actions for a single Application by tag.

                    func (*Client) Cancel

                    func (c *Client) Cancel(actionIDs []string) ([]ActionResult, error)

                      Cancel attempts to cancel a queued up Action from running.

                      func (*Client) Enqueue

                      func (c *Client) Enqueue(actions []Action) ([]ActionResult, error)

                        Enqueue takes a list of Actions and queues them up to be executed by the designated ActionReceiver, returning the params.Action for each queued Action, or an error if there was a problem queueing up the Action.

                        func (*Client) EnqueueOperation

                        func (c *Client) EnqueueOperation(actions []Action) (EnqueuedActions, error)

                          EnqueueOperation takes a list of Actions and queues them up to be executed as an operation, each action running as a task on the the designated ActionReceiver. We return the ID of the overall operation and each individual task.

                          func (*Client) FindActionTagsByPrefix

                          func (c *Client) FindActionTagsByPrefix(arg params.FindTags) (params.FindTagsResults, error)

                            FindActionTagsByPrefix takes a list of string prefixes and finds corresponding ActionTags that match that prefix.

                            func (*Client) FindActionsByNames

                            func (c *Client) FindActionsByNames(arg params.FindActionsByNames) (map[string][]ActionResult, error)

                              FindActionsByNames takes a list of action names and returns actions for every name.

                              func (*Client) ListOperations

                              func (c *Client) ListOperations(arg OperationQueryArgs) (Operations, error)

                                ListOperations fetches the operation summaries for specified apps/units.

                                func (*Client) Operation

                                func (c *Client) Operation(id string) (Operation, error)

                                  Operation fetches the operation with the specified id.

                                  func (*Client) Run

                                  func (c *Client) Run(run RunParams) (EnqueuedActions, error)

                                    Run the Commands specified on the machines identified through the ids provided in the machines, applications and units slices.

                                    func (*Client) RunOnAllMachines

                                    func (c *Client) RunOnAllMachines(commands string, timeout time.Duration) (EnqueuedActions, error)

                                      RunOnAllMachines runs the command on all the machines with the specified timeout.

                                      func (*Client) WatchActionProgress

                                      func (c *Client) WatchActionProgress(actionId string) (watcher.StringsWatcher, error)

                                        WatchActionProgress returns a watcher that reports on action log messages. The result strings are json formatted core.actions.ActionMessage objects.

                                        type EnqueuedActions

                                        type EnqueuedActions struct {
                                        	OperationID string
                                        	Actions     []ActionReference

                                          EnqueuedActions represents the result of enqueuing actions to run.

                                          type Facade

                                          type Facade struct {
                                          	// contains filtered or unexported fields

                                            Facade allows calls to "ActionPruner" endpoints

                                            func NewFacade

                                            func NewFacade(caller base.APICaller) *Facade

                                              NewFacade builds a facade for the action pruner endpoints

                                              func (*Facade) Prune

                                              func (s *Facade) Prune(maxHistoryTime time.Duration, maxHistoryMB int) error

                                                Prunes action entries by specified age and size

                                                type Operation

                                                type Operation struct {
                                                	ID        string
                                                	Summary   string
                                                	Fail      string
                                                	Enqueued  time.Time
                                                	Started   time.Time
                                                	Completed time.Time
                                                	Status    string
                                                	Actions   []ActionResult
                                                	Error     error

                                                  Operation holds a list of actions run as part of the operation

                                                  type OperationQueryArgs

                                                  type OperationQueryArgs struct {
                                                  	Applications []string
                                                  	Units        []string
                                                  	Machines     []string
                                                  	ActionNames  []string
                                                  	Status       []string
                                                  	// These attributes are used to support client side
                                                  	// batching of results.
                                                  	Offset *int
                                                  	Limit  *int

                                                    OperationQueryArgs holds args for listing operations.

                                                    type Operations

                                                    type Operations struct {
                                                    	Operations []Operation
                                                    	Truncated  bool

                                                      Operations holds a list of operations and whether the list has been truncated (used for batch queries).

                                                      type RunParams

                                                      type RunParams struct {
                                                      	Commands       string
                                                      	Timeout        time.Duration
                                                      	Machines       []string
                                                      	Applications   []string
                                                      	Units          []string
                                                      	Parallel       *bool
                                                      	ExecutionGroup *string
                                                      	// WorkloadContext for CAAS is true when the Commands should be run on
                                                      	// the workload not the operator.
                                                      	WorkloadContext bool

                                                        RunParams is used to provide the parameters to the Run method.