github.com/cloudbase/juju-core@v0.0.0-20140504232958-a7271ac7912f/state/api/provisioner/provisioner.go (about)

     1  // Copyright 2013 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package provisioner
     5  
     6  import (
     7  	"fmt"
     8  
     9  	"launchpad.net/juju-core/state/api/base"
    10  	"launchpad.net/juju-core/state/api/common"
    11  	"launchpad.net/juju-core/state/api/params"
    12  	"launchpad.net/juju-core/state/api/watcher"
    13  	"launchpad.net/juju-core/tools"
    14  )
    15  
    16  const provisioner = "Provisioner"
    17  
    18  // State provides access to the Machiner API facade.
    19  type State struct {
    20  	*common.EnvironWatcher
    21  
    22  	caller base.Caller
    23  }
    24  
    25  // NewState creates a new client-side Machiner facade.
    26  func NewState(caller base.Caller) *State {
    27  	return &State{
    28  		EnvironWatcher: common.NewEnvironWatcher(provisioner, caller),
    29  
    30  		caller: caller}
    31  }
    32  
    33  // machineLife requests the lifecycle of the given machine from the server.
    34  func (st *State) machineLife(tag string) (params.Life, error) {
    35  	return common.Life(st.caller, provisioner, tag)
    36  }
    37  
    38  // Machine provides access to methods of a state.Machine through the facade.
    39  func (st *State) Machine(tag string) (*Machine, error) {
    40  	life, err := st.machineLife(tag)
    41  	if err != nil {
    42  		return nil, err
    43  	}
    44  	return &Machine{
    45  		tag:  tag,
    46  		life: life,
    47  		st:   st,
    48  	}, nil
    49  }
    50  
    51  // WatchEnvironMachines returns a StringsWatcher that notifies of
    52  // changes to the lifecycles of the machines (but not containers) in
    53  // the current environment.
    54  func (st *State) WatchEnvironMachines() (watcher.StringsWatcher, error) {
    55  	var result params.StringsWatchResult
    56  	err := st.caller.Call(provisioner, "", "WatchEnvironMachines", nil, &result)
    57  	if err != nil {
    58  		return nil, err
    59  	}
    60  	if err := result.Error; err != nil {
    61  		return nil, result.Error
    62  	}
    63  	w := watcher.NewStringsWatcher(st.caller, result)
    64  	return w, nil
    65  }
    66  
    67  // StateAddresses returns the list of addresses used to connect to the state.
    68  func (st *State) StateAddresses() ([]string, error) {
    69  	var result params.StringsResult
    70  	err := st.caller.Call(provisioner, "", "StateAddresses", nil, &result)
    71  	if err != nil {
    72  		return nil, err
    73  	}
    74  	return result.Result, nil
    75  }
    76  
    77  // APIAddresses returns the list of addresses used to connect to the API.
    78  func (st *State) APIAddresses() ([]string, error) {
    79  	var result params.StringsResult
    80  	err := st.caller.Call(provisioner, "", "APIAddresses", nil, &result)
    81  	if err != nil {
    82  		return nil, err
    83  	}
    84  	return result.Result, nil
    85  }
    86  
    87  // CACert returns the certificate used to validate the state connection.
    88  func (st *State) CACert() ([]byte, error) {
    89  	var result params.BytesResult
    90  	err := st.caller.Call(provisioner, "", "CACert", nil, &result)
    91  	if err != nil {
    92  		return nil, err
    93  	}
    94  	return result.Result, nil
    95  }
    96  
    97  // Tools returns the agent tools for the given entity.
    98  func (st *State) Tools(tag string) (*tools.Tools, error) {
    99  	var results params.ToolsResults
   100  	args := params.Entities{
   101  		Entities: []params.Entity{{Tag: tag}},
   102  	}
   103  	err := st.caller.Call(provisioner, "", "Tools", args, &results)
   104  	if err != nil {
   105  		// TODO: Not directly tested
   106  		return nil, err
   107  	}
   108  	if len(results.Results) != 1 {
   109  		// TODO: Not directly tested
   110  		return nil, fmt.Errorf("expected one result, got %d", len(results.Results))
   111  	}
   112  	result := results.Results[0]
   113  	if err := result.Error; err != nil {
   114  		return nil, err
   115  	}
   116  	return result.Tools, nil
   117  }
   118  
   119  // ContainerConfig returns information from the environment config that are
   120  // needed for container cloud-init.
   121  func (st *State) ContainerConfig() (result params.ContainerConfig, err error) {
   122  	err = st.caller.Call(provisioner, "", "ContainerConfig", nil, &result)
   123  	return result, err
   124  }