// PublicAddress implements the server side of Client.PublicAddress.
func (c *Client) PublicAddress(p params.PublicAddress) (results params.PublicAddressResults, err error) {
switch {
case names.IsMachine(p.Target):
machine, err := c.api.state.Machine(p.Target)
if err != nil {
return results, err
}
addr := instance.SelectPublicAddress(machine.Addresses())
if addr == "" {
return results, fmt.Errorf("machine %q has no public address", machine)
}
return params.PublicAddressResults{PublicAddress: addr}, nil
case names.IsUnit(p.Target):
unit, err := c.api.state.Unit(p.Target)
if err != nil {
return results, err
}
addr, ok := unit.PublicAddress()
if !ok {
return results, fmt.Errorf("unit %q has no public address", unit)
}
return params.PublicAddressResults{PublicAddress: addr}, nil
}
return results, fmt.Errorf("unknown unit or machine %q", p.Target)
}
// runMachineUpdate connects via ssh to the machine and runs the update script
func runMachineUpdate(m *state.Machine, sshArg string) error {
progress("updating machine: %v\n", m)
addr := instance.SelectPublicAddress(m.Addresses())
if addr == "" {
return fmt.Errorf("no appropriate public address found")
}
return runViaSsh(addr, sshArg)
}
// PublicAddress returns the public address of the unit and whether it is valid.
func (u *Unit) PublicAddress() (string, bool) {
var publicAddress string
addresses := u.addressesOfMachine()
if len(addresses) > 0 {
publicAddress = instance.SelectPublicAddress(addresses)
}
return publicAddress, publicAddress != ""
}
func (context *statusContext) makeMachineStatus(machine *state.Machine) (status api.MachineStatus) {
status.Id = machine.Id()
status.Life,
status.AgentVersion,
status.AgentState,
status.AgentStateInfo,
status.Err = processAgent(machine)
status.Series = machine.Series()
status.Jobs = paramsJobsFromJobs(machine.Jobs())
status.WantsVote = machine.WantsVote()
status.HasVote = machine.HasVote()
instid, err := machine.InstanceId()
if err == nil {
status.InstanceId = instid
status.InstanceState, err = machine.InstanceStatus()
if err != nil {
status.InstanceState = "error"
}
status.DNSName = instance.SelectPublicAddress(machine.Addresses())
} else {
if state.IsNotProvisionedError(err) {
status.InstanceId = "pending"
} else {
status.InstanceId = "error"
}
// There's no point in reporting a pending agent state
// if the machine hasn't been provisioned. This
// also makes unprovisioned machines visually distinct
// in the output.
status.AgentState = ""
}
hc, err := machine.HardwareCharacteristics()
if err != nil {
if !errors.IsNotFound(err) {
status.Hardware = "error"
}
} else {
status.Hardware = hc.String()
}
status.Containers = make(map[string]api.MachineStatus)
return
}
func InstanceAddress(addresses map[string][]nova.IPAddress) string {
return instance.SelectPublicAddress(convertNovaAddresses(addresses))
}