// PrivateAddress implements the server side of Client.PrivateAddress.
func (c *Client) PrivateAddress(p params.PrivateAddress) (results params.PrivateAddressResults, err error) {
switch {
case names.IsMachine(p.Target):
machine, err := c.api.state.Machine(p.Target)
if err != nil {
return results, err
}
addr := instance.SelectInternalAddress(machine.Addresses(), false)
if addr == "" {
return results, fmt.Errorf("machine %q has no internal address", machine)
}
return params.PrivateAddressResults{PrivateAddress: addr}, nil
case names.IsUnit(p.Target):
unit, err := c.api.state.Unit(p.Target)
if err != nil {
return results, err
}
addr, ok := unit.PrivateAddress()
if !ok {
return results, fmt.Errorf("unit %q has no internal address", unit)
}
return params.PrivateAddressResults{PrivateAddress: addr}, nil
}
return results, fmt.Errorf("unknown unit or machine %q", p.Target)
}
// stateServerAddresses returns the list of internal addresses of the state
// server machines.
func (st *State) stateServerAddresses() ([]string, error) {
type addressMachine struct {
Addresses []address
}
var allAddresses []addressMachine
// TODO(rog) 2013/10/14 index machines on jobs.
err := st.machines.Find(bson.D{{"jobs", JobManageEnviron}}).All(&allAddresses)
if err != nil {
return nil, err
}
if len(allAddresses) == 0 {
return nil, fmt.Errorf("no state server machines found")
}
apiAddrs := make([]string, 0, len(allAddresses))
for _, addrs := range allAddresses {
instAddrs := addressesToInstanceAddresses(addrs.Addresses)
addr := instance.SelectInternalAddress(instAddrs, false)
if addr != "" {
apiAddrs = append(apiAddrs, addr)
}
}
if len(apiAddrs) == 0 {
return nil, fmt.Errorf("no state server machines with addresses found")
}
return apiAddrs, nil
}
// PrivateAddress returns the private address of the unit and whether it is valid.
func (u *Unit) PrivateAddress() (string, bool) {
var privateAddress string
addresses := u.addressesOfMachine()
if len(addresses) > 0 {
privateAddress = instance.SelectInternalAddress(addresses, false)
}
return privateAddress, privateAddress != ""
}
// remoteParamsForMachine returns a filled in RemoteExec instance
// based on the machine, command and timeout params. If the machine
// does not have an internal address, the Host is empty. This is caught
// by the function that actually tries to execute the command.
func remoteParamsForMachine(machine *state.Machine, command string, timeout time.Duration) *RemoteExec {
// magic boolean parameters are bad :-(
address := instance.SelectInternalAddress(machine.Addresses(), false)
execParams := &RemoteExec{
ExecParams: ssh.ExecParams{
Command: command,
Timeout: timeout,
},
MachineId: machine.Id(),
}
if address != "" {
execParams.Host = fmt.Sprintf("ubuntu@%s", address)
}
return execParams
}
// SelectPeerAddress returns the address to use as the
// mongo replica set peer address by selecting it from the given addresses.
func SelectPeerAddress(addrs []instance.Address) string {
return instance.SelectInternalAddress(addrs, false)
}