// 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) }