func unitMatchExposure(u *state.Unit, patterns []string) (bool, bool, error) {
s, err := u.Service()
if err != nil {
return false, false, err
}
return matchExposure(patterns, s)
}
// HasSubordinates returns the whether each given unit has any subordinates.
func (u *UniterAPIV3) HasSubordinates(args params.Entities) (params.BoolResults, error) {
result := params.BoolResults{
Results: make([]params.BoolResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.BoolResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var unit *state.Unit
unit, err = u.getUnit(tag)
if err == nil {
subordinates := unit.SubordinateNames()
result.Results[i].Result = len(subordinates) > 0
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
}
// Resolved returns the current resolved setting for each given unit.
func (u *UniterAPIV3) Resolved(args params.Entities) (params.ResolvedModeResults, error) {
result := params.ResolvedModeResults{
Results: make([]params.ResolvedModeResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.ResolvedModeResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var unit *state.Unit
unit, err = u.getUnit(tag)
if err == nil {
result.Results[i].Mode = params.ResolvedMode(unit.Resolved())
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
}
func (s *SSHCommonSuite) getMachineForUnit(c *gc.C, u *state.Unit) *state.Machine {
machineId, err := u.AssignedMachineId()
c.Assert(err, jc.ErrorIsNil)
m, err := s.State.Machine(machineId)
c.Assert(err, jc.ErrorIsNil)
return m
}
// PrivateAddress returns the private address for each given unit, if set.
func (u *UniterAPIV3) PrivateAddress(args params.Entities) (params.StringResults, error) {
result := params.StringResults{
Results: make([]params.StringResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.StringResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var unit *state.Unit
unit, err = u.getUnit(tag)
if err == nil {
var address network.Address
address, err = unit.PrivateAddress()
if err == nil {
result.Results[i].Result = address.Value
} else if network.IsNoAddressError(err) {
err = common.NoAddressSetError(tag, "private")
}
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
}
// ConfigSettings returns the complete set of service charm config
// settings available to each given unit.
func (u *UniterAPIV3) ConfigSettings(args params.Entities) (params.ConfigSettingsResults, error) {
result := params.ConfigSettingsResults{
Results: make([]params.ConfigSettingsResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.ConfigSettingsResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var unit *state.Unit
unit, err = u.getUnit(tag)
if err == nil {
var settings charm.Settings
settings, err = unit.ConfigSettings()
if err == nil {
result.Results[i].Settings = params.ConfigSettings(settings)
}
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
}
// ClosePorts sets the policy of the port range with protocol to be
// closed, for all given units.
func (u *UniterAPIV3) ClosePorts(args params.EntitiesPortRanges) (params.ErrorResults, error) {
result := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.ErrorResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var unit *state.Unit
unit, err = u.getUnit(tag)
if err == nil {
err = unit.ClosePorts(entity.Protocol, entity.FromPort, entity.ToPort)
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
}
func waitForUnitStarted(stateConn *state.State, unit *state.Unit, c *gc.C) {
timeout := time.After(5 * time.Second)
for {
select {
case <-timeout:
c.Fatalf("no activity detected")
case <-time.After(coretesting.ShortWait):
err := unit.Refresh()
c.Assert(err, gc.IsNil)
st, info, data, err := unit.Status()
c.Assert(err, gc.IsNil)
switch st {
case params.StatusPending, params.StatusInstalled:
c.Logf("waiting...")
continue
case params.StatusStarted:
c.Logf("started!")
return
case params.StatusDown:
stateConn.StartSync()
c.Logf("unit is still down")
default:
c.Fatalf("unexpected status %s %s %v", st, info, data)
}
}
}
}
func (s *MachineSuite) waitProvisioned(c *gc.C, unit *state.Unit) (*state.Machine, instance.Id) {
c.Logf("waiting for unit %q to be provisioned", unit)
machineId, err := unit.AssignedMachineId()
c.Assert(err, gc.IsNil)
m, err := s.State.Machine(machineId)
c.Assert(err, gc.IsNil)
w := m.Watch()
defer w.Stop()
timeout := time.After(coretesting.LongWait)
for {
select {
case <-timeout:
c.Fatalf("timed out waiting for provisioning")
case _, ok := <-w.Changes():
c.Assert(ok, jc.IsTrue)
err := m.Refresh()
c.Assert(err, gc.IsNil)
if instId, err := m.InstanceId(); err == nil {
c.Logf("unit provisioned with instance %s", instId)
return m, instId
} else {
c.Check(err, jc.Satisfies, state.IsNotProvisionedError)
}
}
}
}
func unitMatchPort(u *state.Unit, patterns []string) (bool, bool, error) {
portRanges, err := u.OpenedPorts()
if err != nil {
return false, false, err
}
return matchPortRanges(patterns, portRanges...)
}
// SetCharmURL sets the charm URL for each given unit. An error will
// be returned if a unit is dead, or the charm URL is not know.
func (u *UniterAPIV3) SetCharmURL(args params.EntitiesCharmURL) (params.ErrorResults, error) {
result := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.ErrorResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var unit *state.Unit
unit, err = u.getUnit(tag)
if err == nil {
var curl *charm.URL
curl, err = charm.ParseURL(entity.CharmURL)
if err == nil {
err = unit.SetCharmURL(curl)
}
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
}
func unitStatus(u *state.Unit, statusInfo status.StatusInfo) func(*gc.C) bool {
return func(c *gc.C) bool {
sInfo, err := u.Status()
c.Assert(err, jc.ErrorIsNil)
return sInfo.Status == statusInfo.Status && sInfo.Message == statusInfo.Message
}
}
// PublicAddress returns the public address for each given unit, if set.
func (u *uniterBaseAPI) PublicAddress(args params.Entities) (params.StringResults, error) {
result := params.StringResults{
Results: make([]params.StringResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.StringResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var unit *state.Unit
unit, err = u.getUnit(tag)
if err == nil {
address, ok := unit.PublicAddress()
if ok {
result.Results[i].Result = address
} else {
err = common.NoAddressSetError(tag, "public")
}
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
}
func (s *UnitSuite) newAgent(c *gc.C, unit *state.Unit) *UnitAgent {
a := NewUnitAgent(nil, nil)
s.InitAgent(c, a, "--unit-name", unit.Name(), "--log-to-stderr=true")
err := a.ReadConfig(unit.Tag().String())
c.Assert(err, jc.ErrorIsNil)
return a
}
// PrivateAddress returns the private address for each given unit, if set.
func (u *UniterAPI) PrivateAddress(args params.Entities) (params.StringResults, error) {
result := params.StringResults{
Results: make([]params.StringResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.StringResults{}, err
}
for i, entity := range args.Entities {
err := common.ErrPerm
if canAccess(entity.Tag) {
var unit *state.Unit
unit, err = u.getUnit(entity.Tag)
if err == nil {
address, ok := unit.PrivateAddress()
if ok {
result.Results[i].Result = address
} else {
err = common.NoAddressSetError(entity.Tag, "private")
}
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
}
func (s *UnitSuite) newAgent(c *gc.C, unit *state.Unit) *UnitAgent {
a := &UnitAgent{}
s.initAgent(c, a, "--unit-name", unit.Name())
err := a.ReadConfig(unit.Tag().String())
c.Assert(err, gc.IsNil)
return a
}
// GetPrincipal returns the result of calling PrincipalName() and
// converting it to a tag, on each given unit.
func (u *UniterAPIV3) GetPrincipal(args params.Entities) (params.StringBoolResults, error) {
result := params.StringBoolResults{
Results: make([]params.StringBoolResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.StringBoolResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var unit *state.Unit
unit, err = u.getUnit(tag)
if err == nil {
principal, ok := unit.PrincipalName()
if principal != "" {
result.Results[i].Result = names.NewUnitTag(principal).String()
}
result.Results[i].Ok = ok
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
}
func unitMatchAgentStatus(u *state.Unit, patterns []string) (bool, bool, error) {
statusInfo, err := u.AgentStatus()
if err != nil {
return false, false, err
}
return matchAgentStatus(patterns, statusInfo.Status)
}
// TestWatchMeterStatus tests the meter status watcher functionality.
func TestWatchMeterStatus(c *gc.C, status meterstatus.MeterStatus, unit *jujustate.Unit, state *jujustate.State, resources *common.Resources) {
c.Assert(resources.Count(), gc.Equals, 0)
args := params.Entities{Entities: []params.Entity{
{Tag: unit.UnitTag().String()},
{Tag: "unit-foo-42"},
}}
result, err := status.WatchMeterStatus(args)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, gc.DeepEquals, params.NotifyWatchResults{
Results: []params.NotifyWatchResult{
{NotifyWatcherId: "1"},
{Error: apiservertesting.ErrUnauthorized},
},
})
// Verify the resource was registered and stop when done
c.Assert(resources.Count(), gc.Equals, 1)
resource := resources.Get("1")
defer statetesting.AssertStop(c, resource)
// Check that the Watch has consumed the initial event ("returned" in
// the Watch call)
wc := statetesting.NewNotifyWatcherC(c, state, resource.(jujustate.NotifyWatcher))
wc.AssertNoChange()
err = unit.SetMeterStatus("GREEN", "No additional information.")
c.Assert(err, jc.ErrorIsNil)
wc.AssertOneChange()
}
func unitMatchSubnet(u *state.Unit, patterns []string) (bool, bool, error) {
pub, pubOK := u.PublicAddress()
priv, privOK := u.PrivateAddress()
if !pubOK && !privOK {
return true, false, nil
}
return matchSubnet(patterns, pub, priv)
}
func (s *baseSuite) setAgentPresence(c *gc.C, u *state.Unit) {
_, err := u.SetAgentPresence()
c.Assert(err, jc.ErrorIsNil)
s.State.StartSync()
s.BackingState.StartSync()
err = u.WaitAgentPresence(coretesting.LongWait)
c.Assert(err, jc.ErrorIsNil)
}
func (s *DeployLocalSuite) assertAssignedUnit(c *gc.C, u *state.Unit, mId string, cons constraints.Value) {
id, err := u.AssignedMachineId()
c.Assert(err, jc.ErrorIsNil)
machine, err := s.State.Machine(id)
c.Assert(err, jc.ErrorIsNil)
machineCons, err := machine.Constraints()
c.Assert(err, jc.ErrorIsNil)
c.Assert(machineCons, gc.DeepEquals, cons)
}
func (s *FilterSuite) APILogin(c *gc.C, unit *state.Unit) {
password, err := utils.RandomPassword()
c.Assert(err, gc.IsNil)
err = unit.SetPassword(password)
c.Assert(err, gc.IsNil)
s.st = s.OpenAPIAs(c, unit.Tag(), password)
s.uniter = s.st.Uniter()
c.Assert(s.uniter, gc.NotNil)
}
func relationsInScopeTags(unit *state.Unit) ([]string, error) {
relations, err := unit.RelationsInScope()
if err != nil {
return nil, err
}
tags := make([]string, len(relations))
for i, relation := range relations {
tags[i] = relation.Tag().String()
}
return tags, nil
}
func (s *clientSuite) assertResolved(c *gc.C, u *state.Unit) {
err := s.APIState.Client().Resolved("wordpress/0", false)
c.Assert(err, jc.ErrorIsNil)
// Freshen the unit's state.
err = u.Refresh()
c.Assert(err, jc.ErrorIsNil)
// And now the actual test assertions: we set the unit as resolved via
// the API so it should have a resolved mode set.
mode := u.Resolved()
c.Assert(mode, gc.Equals, state.ResolvedRetryHooks)
}
// processUnit retrieves version and status information for the given unit.
func processUnit(unit *state.Unit) (agentStatus, workloadStatus params.DetailedStatus) {
agent, workload := common.UnitStatus(unit)
populateStatusFromStatusInfoAndErr(&agentStatus, agent.Status, agent.Err)
populateStatusFromStatusInfoAndErr(&workloadStatus, workload.Status, workload.Err)
agentStatus.Life = processLife(unit)
if t, err := unit.AgentTools(); err == nil {
agentStatus.Version = t.Version.Number.String()
}
return
}
func (s *ConnSuite) assertAssignedMachineRequestedNetworks(c *gc.C, unit *state.Unit, includeNets, excludeNets []string) {
machineId, err := unit.AssignedMachineId()
c.Assert(err, gc.IsNil)
machine, err := s.conn.State.Machine(machineId)
c.Assert(err, gc.IsNil)
networks, err := machine.RequestedNetworks()
c.Assert(err, gc.IsNil)
c.Assert(networks, jc.DeepEquals, includeNets)
cons, err := machine.Constraints()
c.Assert(err, gc.IsNil)
c.Assert(cons.ExcludeNetworks(), jc.DeepEquals, excludeNets)
}
// processUnit retrieves version and status information for the given unit.
func processUnitStatus(unit *state.Unit) (agentStatus, workloadStatus api.AgentStatus) {
// First determine the agent status information.
unitAgent := unit.Agent().(*state.UnitAgent)
makeStatusForEntity(&agentStatus, unitAgent)
agentStatus.Life = processLife(unit)
if t, err := unit.AgentTools(); err == nil {
agentStatus.Version = t.Version.Number.String()
}
// Second, determine the workload (unit) status.
makeStatusForEntity(&workloadStatus, unit)
return
}
// processUnit retrieves version and status information for the given unit.
func processUnitStatus(unit *state.Unit) (agentStatus, workloadStatus params.AgentStatus) {
// First determine the agent status information.
unitAgent := unit.Agent()
populateStatusFromGetter(&agentStatus, unitAgent)
agentStatus.Life = processLife(unit)
if t, err := unit.AgentTools(); err == nil {
agentStatus.Version = t.Version.Number.String()
}
// Second, determine the workload (unit) status.
populateStatusFromGetter(&workloadStatus, unit)
return
}
func (u *UniterAPIV3) destroySubordinates(principal *state.Unit) error {
subordinates := principal.SubordinateNames()
for _, subName := range subordinates {
unit, err := u.getUnit(names.NewUnitTag(subName))
if err != nil {
return err
}
if err = unit.Destroy(); err != nil {
return err
}
}
return nil
}
