// constructImageConstraint returns model-specific criteria used to look for image metadata.
func (p *ProvisionerAPI) constructImageConstraint(m *state.Machine) (*imagemetadata.ImageConstraint, environs.Environ, error) {
// If we can determine current region,
// we want only metadata specific to this region.
cloud, env, err := p.obtainEnvCloudConfig()
if err != nil {
return nil, nil, errors.Trace(err)
}
lookup := simplestreams.LookupParams{
Series: []string{m.Series()},
Stream: env.Config().ImageStream(),
}
mcons, err := m.Constraints()
if err != nil {
return nil, nil, errors.Annotatef(err, "cannot get machine constraints for machine %v", m.MachineTag().Id())
}
if mcons.Arch != nil {
lookup.Arches = []string{*mcons.Arch}
}
if cloud != nil {
lookup.CloudSpec = *cloud
}
return imagemetadata.NewImageConstraint(lookup), env, nil
}
func getProvisioningInfo(m *state.Machine) (*params.ProvisioningInfo, error) {
cons, err := m.Constraints()
if err != nil {
return nil, err
}
// TODO(dimitern) For now, since network names and
// provider ids are the same, we return what we got
// from state. In the future, when networks can be
// added before provisioning, we should convert both
// slices from juju network names to provider-specific
// ids before returning them.
networks, err := m.RequestedNetworks()
if err != nil {
return nil, err
}
var jobs []params.MachineJob
for _, job := range m.Jobs() {
jobs = append(jobs, job.ToParams())
}
return ¶ms.ProvisioningInfo{
Constraints: cons,
Series: m.Series(),
Placement: m.Placement(),
Networks: networks,
Jobs: jobs,
}, nil
}
func makeMachineStatus(machine *state.Machine) (status params.MachineStatus) {
var err error
status.Id = machine.Id()
agentStatus := processMachine(machine)
status.AgentStatus = agentStatus
status.Series = machine.Series()
status.Jobs = paramsJobsFromJobs(machine.Jobs())
status.WantsVote = machine.WantsVote()
status.HasVote = machine.HasVote()
sInfo, err := machine.InstanceStatus()
populateStatusFromStatusInfoAndErr(&status.InstanceStatus, sInfo, err)
instid, err := machine.InstanceId()
if err == nil {
status.InstanceId = instid
addr, err := machine.PublicAddress()
if err != nil {
// Usually this indicates that no addresses have been set on the
// machine yet.
addr = network.Address{}
logger.Debugf("error fetching public address: %q", err)
}
status.DNSName = addr.Value
mAddrs := machine.Addresses()
if len(mAddrs) == 0 {
logger.Debugf("no IP addresses fetched for machine %q", instid)
// At least give it the newly created DNSName address, if it exists.
if addr.Value != "" {
mAddrs = append(mAddrs, addr)
}
}
for _, mAddr := range mAddrs {
switch mAddr.Scope {
case network.ScopeMachineLocal, network.ScopeLinkLocal:
continue
}
status.IPAddresses = append(status.IPAddresses, mAddr.Value)
}
} else {
if errors.IsNotProvisioned(err) {
status.InstanceId = "pending"
} else {
status.InstanceId = "error"
}
}
hc, err := machine.HardwareCharacteristics()
if err != nil {
if !errors.IsNotFound(err) {
status.Hardware = "error"
}
} else {
status.Hardware = hc.String()
}
status.Containers = make(map[string]params.MachineStatus)
return
}
func (p *ProvisionerAPI) getProvisioningInfo(m *state.Machine) (*params.ProvisioningInfo, error) {
cons, err := m.Constraints()
if err != nil {
return nil, err
}
volumes, err := p.machineVolumeParams(m)
if err != nil {
return nil, errors.Trace(err)
}
// TODO(dimitern) Drop this once we only use spaces for
// deployments.
networks, err := m.RequestedNetworks()
if err != nil {
return nil, err
}
var jobs []multiwatcher.MachineJob
for _, job := range m.Jobs() {
jobs = append(jobs, job.ToParams())
}
tags, err := p.machineTags(m, jobs)
if err != nil {
return nil, errors.Trace(err)
}
subnetsToZones, err := p.machineSubnetsAndZones(m)
if err != nil {
return nil, errors.Annotate(err, "cannot match subnets to zones")
}
endpointBindings, err := p.machineEndpointBindings(m)
if err != nil {
return nil, errors.Annotate(err, "cannot determine machine endpoint bindings")
}
imageMetadata, err := p.availableImageMetadata(m)
if err != nil {
return nil, errors.Annotate(err, "cannot get available image metadata")
}
return ¶ms.ProvisioningInfo{
Constraints: cons,
Series: m.Series(),
Placement: m.Placement(),
Networks: networks,
Jobs: jobs,
Volumes: volumes,
Tags: tags,
SubnetsToZones: subnetsToZones,
EndpointBindings: endpointBindings,
ImageMetadata: imageMetadata,
}, nil
}
func makeMachineStatus(machine *state.Machine) (status params.MachineStatus) {
status.Id = machine.Id()
agentStatus, compatStatus := processMachine(machine)
status.Agent = agentStatus
// These legacy status values will be deprecated for Juju 2.0.
status.AgentState = compatStatus.Status
status.AgentStateInfo = compatStatus.Info
status.AgentVersion = compatStatus.Version
status.Life = compatStatus.Life
status.Err = compatStatus.Err
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"
}
addr, err := machine.PublicAddress()
if err != nil {
// Usually this indicates that no addresses have been set on the
// machine yet.
addr = network.Address{}
logger.Warningf("error fetching public address: %q", err)
}
status.DNSName = addr.Value
} else {
if errors.IsNotProvisioned(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]params.MachineStatus)
return
}
func (p *ProvisionerAPI) getProvisioningInfo(m *state.Machine) (*params.ProvisioningInfo, error) {
cons, err := m.Constraints()
if err != nil {
return nil, errors.Trace(err)
}
volumes, err := p.machineVolumeParams(m)
if err != nil {
return nil, errors.Trace(err)
}
var jobs []multiwatcher.MachineJob
for _, job := range m.Jobs() {
jobs = append(jobs, job.ToParams())
}
tags, err := p.machineTags(m, jobs)
if err != nil {
return nil, errors.Trace(err)
}
subnetsToZones, err := p.machineSubnetsAndZones(m)
if err != nil {
return nil, errors.Annotate(err, "cannot match subnets to zones")
}
endpointBindings, err := p.machineEndpointBindings(m)
if err != nil {
return nil, errors.Annotate(err, "cannot determine machine endpoint bindings")
}
imageMetadata, err := p.availableImageMetadata(m)
if err != nil {
return nil, errors.Annotate(err, "cannot get available image metadata")
}
controllerCfg, err := p.st.ControllerConfig()
if err != nil {
return nil, errors.Annotate(err, "cannot get controller configuration")
}
return ¶ms.ProvisioningInfo{
Constraints: cons,
Series: m.Series(),
Placement: m.Placement(),
Jobs: jobs,
Volumes: volumes,
Tags: tags,
SubnetsToZones: subnetsToZones,
EndpointBindings: endpointBindings,
ImageMetadata: imageMetadata,
ControllerConfig: controllerCfg,
}, nil
}
func (s *MigrationImportSuite) AssertMachineEqual(c *gc.C, newMachine, oldMachine *state.Machine) {
c.Assert(newMachine.Id(), gc.Equals, oldMachine.Id())
c.Assert(newMachine.Principals(), jc.DeepEquals, oldMachine.Principals())
c.Assert(newMachine.Series(), gc.Equals, oldMachine.Series())
c.Assert(newMachine.ContainerType(), gc.Equals, oldMachine.ContainerType())
newHardware, err := newMachine.HardwareCharacteristics()
c.Assert(err, jc.ErrorIsNil)
oldHardware, err := oldMachine.HardwareCharacteristics()
c.Assert(err, jc.ErrorIsNil)
c.Assert(newHardware, jc.DeepEquals, oldHardware)
c.Assert(newMachine.Jobs(), jc.DeepEquals, oldMachine.Jobs())
c.Assert(newMachine.Life(), gc.Equals, oldMachine.Life())
newTools, err := newMachine.AgentTools()
c.Assert(err, jc.ErrorIsNil)
oldTools, err := oldMachine.AgentTools()
c.Assert(err, jc.ErrorIsNil)
c.Assert(newTools, jc.DeepEquals, oldTools)
}
func makeMachineStatus(machine *state.Machine) (status params.MachineStatus) {
status.Id = machine.Id()
agentStatus := processMachine(machine)
status.Agent = agentStatus
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"
}
addr, err := machine.PublicAddress()
if err != nil {
// Usually this indicates that no addresses have been set on the
// machine yet.
addr = network.Address{}
logger.Debugf("error fetching public address: %q", err)
}
status.DNSName = addr.Value
} else {
if errors.IsNotProvisioned(err) {
status.InstanceId = "pending"
} else {
status.InstanceId = "error"
}
}
hc, err := machine.HardwareCharacteristics()
if err != nil {
if !errors.IsNotFound(err) {
status.Hardware = "error"
}
} else {
status.Hardware = hc.String()
}
status.Containers = make(map[string]params.MachineStatus)
return
}
func (context *statusContext) makeMachineStatus(machine *state.Machine) (status api.MachineStatus) {
status.Id = machine.Id()
status.Agent, status.AgentState, status.AgentStateInfo = processAgent(machine)
status.AgentVersion = status.Agent.Version
status.Life = status.Agent.Life
status.Err = status.Agent.Err
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 = network.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
}
