func (s *firewallerSuite) TestLife(c *gc.C) {
// Unassign unit 1 from its machine, so we can change its life cycle.
err := s.units[1].UnassignFromMachine()
c.Assert(err, gc.IsNil)
err = s.machines[1].EnsureDead()
c.Assert(err, gc.IsNil)
s.assertLife(c, 0, state.Alive)
s.assertLife(c, 1, state.Dead)
s.assertLife(c, 2, state.Alive)
args := addFakeEntities(params.Entities{Entities: []params.Entity{
{Tag: s.machines[0].Tag()},
{Tag: s.machines[1].Tag()},
{Tag: s.machines[2].Tag()},
}})
result, err := s.firewaller.Life(args)
c.Assert(err, gc.IsNil)
c.Assert(result, jc.DeepEquals, params.LifeResults{
Results: []params.LifeResult{
{Life: "alive"},
{Life: "dead"},
{Life: "alive"},
{Error: apiservertesting.NotFoundError("machine 42")},
{Error: apiservertesting.NotFoundError(`unit "foo/0"`)},
{Error: apiservertesting.NotFoundError(`service "bar"`)},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
},
})
// Remove a machine and make sure it's detected.
err = s.machines[1].Remove()
c.Assert(err, gc.IsNil)
err = s.machines[1].Refresh()
c.Assert(err, jc.Satisfies, errors.IsNotFound)
args = params.Entities{
Entities: []params.Entity{
{Tag: s.machines[1].Tag()},
},
}
result, err = s.firewaller.Life(args)
c.Assert(err, gc.IsNil)
c.Assert(result, jc.DeepEquals, params.LifeResults{
Results: []params.LifeResult{
{Error: apiservertesting.NotFoundError("machine 1")},
},
})
}
func (s *withoutStateServerSuite) TestLifeAsEnvironManager(c *gc.C) {
err := s.machines[1].EnsureDead()
c.Assert(err, gc.IsNil)
err = s.machines[1].Refresh()
c.Assert(err, gc.IsNil)
c.Assert(s.machines[0].Life(), gc.Equals, state.Alive)
c.Assert(s.machines[1].Life(), gc.Equals, state.Dead)
c.Assert(s.machines[2].Life(), gc.Equals, state.Alive)
args := params.Entities{Entities: []params.Entity{
{Tag: s.machines[0].Tag()},
{Tag: s.machines[1].Tag()},
{Tag: s.machines[2].Tag()},
{Tag: "machine-42"},
{Tag: "unit-foo-0"},
{Tag: "service-bar"},
}}
result, err := s.provisioner.Life(args)
c.Assert(err, gc.IsNil)
c.Assert(result, gc.DeepEquals, params.LifeResults{
Results: []params.LifeResult{
{Life: "alive"},
{Life: "dead"},
{Life: "alive"},
{Error: apiservertesting.NotFoundError("machine 42")},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
},
})
// Remove the subordinate and make sure it's detected.
err = s.machines[1].Remove()
c.Assert(err, gc.IsNil)
err = s.machines[1].Refresh()
c.Assert(err, jc.Satisfies, errors.IsNotFound)
result, err = s.provisioner.Life(params.Entities{
Entities: []params.Entity{
{Tag: s.machines[1].Tag()},
},
})
c.Assert(err, gc.IsNil)
c.Assert(result, gc.DeepEquals, params.LifeResults{
Results: []params.LifeResult{
{Error: apiservertesting.NotFoundError("machine 1")},
},
})
}
func (s *firewallerSuite) TestInstanceId(c *gc.C) {
// Provision 2 machines first.
err := s.machines[0].SetProvisioned("i-am", "fake_nonce", nil)
c.Assert(err, gc.IsNil)
hwChars := instance.MustParseHardware("arch=i386", "mem=4G")
err = s.machines[1].SetProvisioned("i-am-not", "fake_nonce", &hwChars)
c.Assert(err, gc.IsNil)
args := addFakeEntities(params.Entities{Entities: []params.Entity{
{Tag: s.machines[0].Tag()},
{Tag: s.machines[1].Tag()},
{Tag: s.machines[2].Tag()},
{Tag: s.service.Tag()},
{Tag: s.units[2].Tag()},
}})
result, err := s.firewaller.InstanceId(args)
c.Assert(err, gc.IsNil)
c.Assert(result, jc.DeepEquals, params.StringResults{
Results: []params.StringResult{
{Result: "i-am"},
{Result: "i-am-not"},
{Error: apiservertesting.NotProvisionedError("2")},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.NotFoundError("machine 42")},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
},
})
}
func (s *withoutStateServerSuite) TestProvisioningInfoPermissions(c *gc.C) {
// Login as a machine agent for machine 0.
anAuthorizer := s.authorizer
anAuthorizer.MachineAgent = true
anAuthorizer.EnvironManager = false
anAuthorizer.Tag = s.machines[0].Tag()
aProvisioner, err := provisioner.NewProvisionerAPI(s.State, s.resources, anAuthorizer)
c.Assert(err, gc.IsNil)
c.Assert(aProvisioner, gc.NotNil)
args := params.Entities{Entities: []params.Entity{
{Tag: s.machines[0].Tag()},
{Tag: s.machines[0].Tag() + "-lxc-0"},
{Tag: "machine-42"},
{Tag: s.machines[1].Tag()},
{Tag: "service-bar"},
}}
// Only machine 0 and containers therein can be accessed.
results, err := aProvisioner.ProvisioningInfo(args)
c.Assert(results, gc.DeepEquals, params.ProvisioningInfoResults{
Results: []params.ProvisioningInfoResult{
{Result: ¶ms.ProvisioningInfo{
Series: "quantal",
IncludeNetworks: []string{},
ExcludeNetworks: []string{},
}},
{Error: apiservertesting.NotFoundError("machine 0/lxc/0")},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
},
})
}
func (s *withoutStateServerSuite) TestDistributionGroupMachineAgentAuth(c *gc.C) {
anAuthorizer := s.authorizer
anAuthorizer.Tag = "machine-1"
anAuthorizer.EnvironManager = false
anAuthorizer.MachineAgent = true
provisioner, err := provisioner.NewProvisionerAPI(s.State, s.resources, anAuthorizer)
c.Check(err, gc.IsNil)
args := params.Entities{Entities: []params.Entity{
{Tag: "machine-0"},
{Tag: "machine-1"},
{Tag: "machine-42"},
{Tag: "machine-0-lxc-99"},
{Tag: "machine-1-lxc-99"},
{Tag: "machine-1-lxc-99-lxc-100"},
}}
result, err := provisioner.DistributionGroup(args)
c.Assert(err, gc.IsNil)
c.Assert(result, gc.DeepEquals, params.DistributionGroupResults{
Results: []params.DistributionGroupResult{
{Error: apiservertesting.ErrUnauthorized},
{Result: []instance.Id{}},
{Error: apiservertesting.ErrUnauthorized},
// only a machine agent for the container or its
// parent may access it.
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.NotFoundError("machine 1/lxc/99")},
{Error: apiservertesting.ErrUnauthorized},
},
})
}
func (s *withoutStateServerSuite) TestSeries(c *gc.C) {
// Add a machine with different series.
foobarMachine, err := s.State.AddMachine("foobar", state.JobHostUnits)
c.Assert(err, gc.IsNil)
args := params.Entities{Entities: []params.Entity{
{Tag: s.machines[0].Tag()},
{Tag: foobarMachine.Tag()},
{Tag: s.machines[2].Tag()},
{Tag: "machine-42"},
{Tag: "unit-foo-0"},
{Tag: "service-bar"},
}}
result, err := s.provisioner.Series(args)
c.Assert(err, gc.IsNil)
c.Assert(result, gc.DeepEquals, params.StringResults{
Results: []params.StringResult{
{Result: s.machines[0].Series()},
{Result: foobarMachine.Series()},
{Result: s.machines[2].Series()},
{Error: apiservertesting.NotFoundError("machine 42")},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
},
})
}
func (s *firewallerSuite) TestWatchUnits(c *gc.C) {
c.Assert(s.resources.Count(), gc.Equals, 0)
args := addFakeEntities(params.Entities{Entities: []params.Entity{
{Tag: s.machines[0].Tag()},
{Tag: s.service.Tag()},
{Tag: s.units[0].Tag()},
}})
result, err := s.firewaller.WatchUnits(args)
c.Assert(err, gc.IsNil)
c.Assert(result, jc.DeepEquals, params.StringsWatchResults{
Results: []params.StringsWatchResult{
{Changes: []string{"wordpress/0"}, StringsWatcherId: "1"},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.NotFoundError("machine 42")},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
},
})
// Verify the resource was registered and stop when done
c.Assert(s.resources.Count(), gc.Equals, 1)
c.Assert(result.Results[0].StringsWatcherId, gc.Equals, "1")
resource := s.resources.Get("1")
defer statetesting.AssertStop(c, resource)
// Check that the Watch has consumed the initial event ("returned" in
// the Watch call)
wc := statetesting.NewStringsWatcherC(c, s.State, resource.(state.StringsWatcher))
wc.AssertNoChange()
}
func (s *withoutStateServerSuite) TestStatus(c *gc.C) {
err := s.machines[0].SetStatus(params.StatusStarted, "blah", nil)
c.Assert(err, gc.IsNil)
err = s.machines[1].SetStatus(params.StatusStopped, "foo", nil)
c.Assert(err, gc.IsNil)
err = s.machines[2].SetStatus(params.StatusError, "not really", params.StatusData{"foo": "bar"})
c.Assert(err, gc.IsNil)
args := params.Entities{Entities: []params.Entity{
{Tag: s.machines[0].Tag()},
{Tag: s.machines[1].Tag()},
{Tag: s.machines[2].Tag()},
{Tag: "machine-42"},
{Tag: "unit-foo-0"},
{Tag: "service-bar"},
}}
result, err := s.provisioner.Status(args)
c.Assert(err, gc.IsNil)
c.Assert(result, gc.DeepEquals, params.StatusResults{
Results: []params.StatusResult{
{Status: params.StatusStarted, Info: "blah", Data: params.StatusData{}},
{Status: params.StatusStopped, Info: "foo", Data: params.StatusData{}},
{Status: params.StatusError, Info: "not really", Data: params.StatusData{"foo": "bar"}},
{Error: apiservertesting.NotFoundError("machine 42")},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
},
})
}
func (s *withoutStateServerSuite) TestEnsureDead(c *gc.C) {
err := s.machines[1].EnsureDead()
c.Assert(err, gc.IsNil)
s.assertLife(c, 0, state.Alive)
s.assertLife(c, 1, state.Dead)
s.assertLife(c, 2, state.Alive)
args := params.Entities{Entities: []params.Entity{
{Tag: s.machines[0].Tag()},
{Tag: s.machines[1].Tag()},
{Tag: s.machines[2].Tag()},
{Tag: "machine-42"},
{Tag: "unit-foo-0"},
{Tag: "service-bar"},
}}
result, err := s.provisioner.EnsureDead(args)
c.Assert(err, gc.IsNil)
c.Assert(result, gc.DeepEquals, params.ErrorResults{
Results: []params.ErrorResult{
{nil},
{nil},
{nil},
{apiservertesting.NotFoundError("machine 42")},
{apiservertesting.ErrUnauthorized},
{apiservertesting.ErrUnauthorized},
},
})
// Verify the changes.
s.assertLife(c, 0, state.Dead)
s.assertLife(c, 1, state.Dead)
s.assertLife(c, 2, state.Dead)
}
func (s *withoutStateServerSuite) TestRemove(c *gc.C) {
err := s.machines[1].EnsureDead()
c.Assert(err, gc.IsNil)
s.assertLife(c, 0, state.Alive)
s.assertLife(c, 1, state.Dead)
s.assertLife(c, 2, state.Alive)
args := params.Entities{Entities: []params.Entity{
{Tag: s.machines[0].Tag()},
{Tag: s.machines[1].Tag()},
{Tag: s.machines[2].Tag()},
{Tag: "machine-42"},
{Tag: "unit-foo-0"},
{Tag: "service-bar"},
}}
result, err := s.provisioner.Remove(args)
c.Assert(err, gc.IsNil)
c.Assert(result, gc.DeepEquals, params.ErrorResults{
Results: []params.ErrorResult{
{¶ms.Error{Message: `cannot remove entity "machine-0": still alive`}},
{nil},
{¶ms.Error{Message: `cannot remove entity "machine-2": still alive`}},
{apiservertesting.NotFoundError("machine 42")},
{apiservertesting.ErrUnauthorized},
{apiservertesting.ErrUnauthorized},
},
})
// Verify the changes.
s.assertLife(c, 0, state.Alive)
err = s.machines[1].Refresh()
c.Assert(err, jc.Satisfies, errors.IsNotFound)
s.assertLife(c, 2, state.Alive)
}
func (s *toolsSuite) TestTools(c *gc.C) {
getCanRead := func() (common.AuthFunc, error) {
return func(tag string) bool {
return tag == "machine-0" || tag == "machine-42"
}, nil
}
tg := common.NewToolsGetter(s.State, getCanRead)
c.Assert(tg, gc.NotNil)
err := s.machine0.SetAgentVersion(version.Current)
c.Assert(err, gc.IsNil)
args := params.Entities{
Entities: []params.Entity{
{Tag: "machine-0"},
{Tag: "machine-1"},
{Tag: "machine-42"},
}}
result, err := tg.Tools(args)
c.Assert(err, gc.IsNil)
c.Assert(result.Results, gc.HasLen, 3)
c.Assert(result.Results[0].Tools, gc.NotNil)
c.Assert(result.Results[0].Tools.Version, gc.DeepEquals, version.Current)
c.Assert(result.Results[0].DisableSSLHostnameVerification, jc.IsFalse)
c.Assert(result.Results[1].Error, gc.DeepEquals, apiservertesting.ErrUnauthorized)
c.Assert(result.Results[2].Error, gc.DeepEquals, apiservertesting.NotFoundError("machine 42"))
}
func (s *withoutStateServerSuite) TestConstraints(c *gc.C) {
// Add a machine with some constraints.
template := state.MachineTemplate{
Series: "quantal",
Jobs: []state.MachineJob{state.JobHostUnits},
Constraints: constraints.MustParse("cpu-cores=123", "mem=8G"),
}
consMachine, err := s.State.AddOneMachine(template)
c.Assert(err, gc.IsNil)
machine0Constraints, err := s.machines[0].Constraints()
c.Assert(err, gc.IsNil)
args := params.Entities{Entities: []params.Entity{
{Tag: s.machines[0].Tag()},
{Tag: consMachine.Tag()},
{Tag: "machine-42"},
{Tag: "unit-foo-0"},
{Tag: "service-bar"},
}}
result, err := s.provisioner.Constraints(args)
c.Assert(err, gc.IsNil)
c.Assert(result, gc.DeepEquals, params.ConstraintsResults{
Results: []params.ConstraintsResult{
{Constraints: machine0Constraints},
{Constraints: template.Constraints},
{Error: apiservertesting.NotFoundError("machine 42")},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
},
})
}
func (s *firewallerSuite) TestWatch(c *gc.C) {
c.Assert(s.resources.Count(), gc.Equals, 0)
args := addFakeEntities(params.Entities{Entities: []params.Entity{
{Tag: s.machines[0].Tag()},
{Tag: s.service.Tag()},
{Tag: s.units[0].Tag()},
}})
result, err := s.firewaller.Watch(args)
c.Assert(err, gc.IsNil)
c.Assert(result, jc.DeepEquals, params.NotifyWatchResults{
Results: []params.NotifyWatchResult{
{Error: apiservertesting.ErrUnauthorized},
{NotifyWatcherId: "1"},
{NotifyWatcherId: "2"},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.NotFoundError(`unit "foo/0"`)},
{Error: apiservertesting.NotFoundError(`service "bar"`)},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
},
})
// Verify the resources were registered and stop when done.
c.Assert(s.resources.Count(), gc.Equals, 2)
c.Assert(result.Results[1].NotifyWatcherId, gc.Equals, "1")
watcher1 := s.resources.Get("1")
defer statetesting.AssertStop(c, watcher1)
c.Assert(result.Results[2].NotifyWatcherId, gc.Equals, "2")
watcher2 := s.resources.Get("2")
defer statetesting.AssertStop(c, watcher2)
// Check that the Watch has consumed the initial event ("returned" in
// the Watch call)
wc1 := statetesting.NewNotifyWatcherC(c, s.State, watcher1.(state.NotifyWatcher))
wc1.AssertNoChange()
wc2 := statetesting.NewNotifyWatcherC(c, s.State, watcher2.(state.NotifyWatcher))
wc2.AssertNoChange()
}
func (s *withoutStateServerSuite) TestSetProvisioned(c *gc.C) {
// Provision machine 0 first.
hwChars := instance.MustParseHardware("arch=i386", "mem=4G")
err := s.machines[0].SetProvisioned("i-am", "fake_nonce", &hwChars)
c.Assert(err, gc.IsNil)
args := params.SetProvisioned{Machines: []params.MachineSetProvisioned{
{Tag: s.machines[0].Tag(), InstanceId: "i-was", Nonce: "fake_nonce", Characteristics: nil},
{Tag: s.machines[1].Tag(), InstanceId: "i-will", Nonce: "fake_nonce", Characteristics: &hwChars},
{Tag: s.machines[2].Tag(), InstanceId: "i-am-too", Nonce: "fake", Characteristics: nil},
{Tag: "machine-42", InstanceId: "", Nonce: "", Characteristics: nil},
{Tag: "unit-foo-0", InstanceId: "", Nonce: "", Characteristics: nil},
{Tag: "service-bar", InstanceId: "", Nonce: "", Characteristics: nil},
}}
result, err := s.provisioner.SetProvisioned(args)
c.Assert(err, gc.IsNil)
c.Assert(result, gc.DeepEquals, params.ErrorResults{
Results: []params.ErrorResult{
{¶ms.Error{
Message: `cannot set instance data for machine "0": already set`,
}},
{nil},
{nil},
{apiservertesting.NotFoundError("machine 42")},
{apiservertesting.ErrUnauthorized},
{apiservertesting.ErrUnauthorized},
},
})
// Verify machine 1 and 2 were provisioned.
c.Assert(s.machines[1].Refresh(), gc.IsNil)
c.Assert(s.machines[2].Refresh(), gc.IsNil)
instanceId, err := s.machines[1].InstanceId()
c.Assert(err, gc.IsNil)
c.Check(instanceId, gc.Equals, instance.Id("i-will"))
instanceId, err = s.machines[2].InstanceId()
c.Assert(err, gc.IsNil)
c.Check(instanceId, gc.Equals, instance.Id("i-am-too"))
c.Check(s.machines[1].CheckProvisioned("fake_nonce"), jc.IsTrue)
c.Check(s.machines[2].CheckProvisioned("fake"), jc.IsTrue)
gotHardware, err := s.machines[1].HardwareCharacteristics()
c.Assert(err, gc.IsNil)
c.Check(gotHardware, gc.DeepEquals, &hwChars)
}
func (s *withoutStateServerSuite) TestProvisioningInfo(c *gc.C) {
template := state.MachineTemplate{
Series: "quantal",
Jobs: []state.MachineJob{state.JobHostUnits},
Constraints: constraints.MustParse("cpu-cores=123", "mem=8G"),
Placement: "valid",
IncludeNetworks: []string{"net1", "net2"},
ExcludeNetworks: []string{"net3", "net4"},
}
placementMachine, err := s.State.AddOneMachine(template)
c.Assert(err, gc.IsNil)
args := params.Entities{Entities: []params.Entity{
{Tag: s.machines[0].Tag()},
{Tag: placementMachine.Tag()},
{Tag: "machine-42"},
{Tag: "unit-foo-0"},
{Tag: "service-bar"},
}}
result, err := s.provisioner.ProvisioningInfo(args)
c.Assert(err, gc.IsNil)
c.Assert(result, gc.DeepEquals, params.ProvisioningInfoResults{
Results: []params.ProvisioningInfoResult{
{
Result: ¶ms.ProvisioningInfo{
Series: "quantal",
IncludeNetworks: []string{},
ExcludeNetworks: []string{},
},
},
{
Result: ¶ms.ProvisioningInfo{
Series: "quantal",
Constraints: template.Constraints,
Placement: template.Placement,
IncludeNetworks: template.IncludeNetworks,
ExcludeNetworks: template.ExcludeNetworks,
},
},
{Error: apiservertesting.NotFoundError("machine 42")},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
},
})
}
func (s *firewallerSuite) TestOpenedPorts(c *gc.C) {
// Open some ports on two of the units.
err := s.units[0].OpenPort("foo", 1234)
c.Assert(err, gc.IsNil)
err = s.units[0].OpenPort("bar", 4321)
c.Assert(err, gc.IsNil)
err = s.units[2].OpenPort("baz", 1111)
c.Assert(err, gc.IsNil)
args := addFakeEntities(params.Entities{Entities: []params.Entity{
{Tag: s.units[0].Tag()},
{Tag: s.units[1].Tag()},
{Tag: s.units[2].Tag()},
}})
result, err := s.firewaller.OpenedPorts(args)
c.Assert(err, gc.IsNil)
c.Assert(result, jc.DeepEquals, params.PortsResults{
Results: []params.PortsResult{
{Ports: []instance.Port{{"bar", 4321}, {"foo", 1234}}},
{Ports: []instance.Port{}},
{Ports: []instance.Port{{"baz", 1111}}},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.NotFoundError(`unit "foo/0"`)},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
},
})
// Now close unit 2's port and check again.
err = s.units[2].ClosePort("baz", 1111)
c.Assert(err, gc.IsNil)
args = params.Entities{Entities: []params.Entity{
{Tag: s.units[2].Tag()},
}}
result, err = s.firewaller.OpenedPorts(args)
c.Assert(err, gc.IsNil)
c.Assert(result, jc.DeepEquals, params.PortsResults{
Results: []params.PortsResult{
{Ports: []instance.Port{}},
},
})
}
func (s *firewallerSuite) TestGetAssignedMachine(c *gc.C) {
// Unassign a unit first.
err := s.units[2].UnassignFromMachine()
c.Assert(err, gc.IsNil)
args := addFakeEntities(params.Entities{Entities: []params.Entity{
{Tag: s.units[0].Tag()},
{Tag: s.units[1].Tag()},
{Tag: s.units[2].Tag()},
}})
result, err := s.firewaller.GetAssignedMachine(args)
c.Assert(err, gc.IsNil)
c.Assert(result, jc.DeepEquals, params.StringResults{
Results: []params.StringResult{
{Result: s.machines[0].Tag()},
{Result: s.machines[1].Tag()},
{Error: apiservertesting.NotAssignedError("wordpress/2")},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.NotFoundError(`unit "foo/0"`)},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
},
})
// Now reset assign unit 2 again and check.
err = s.units[2].AssignToMachine(s.machines[0])
c.Assert(err, gc.IsNil)
args = params.Entities{Entities: []params.Entity{
{Tag: s.units[2].Tag()},
}}
result, err = s.firewaller.GetAssignedMachine(args)
c.Assert(err, gc.IsNil)
c.Assert(result, jc.DeepEquals, params.StringResults{
Results: []params.StringResult{
{Result: s.machines[0].Tag()},
},
})
}
func (s *toolsSuite) TestSetTools(c *gc.C) {
getCanWrite := func() (common.AuthFunc, error) {
return func(tag string) bool {
return tag == "machine-0" || tag == "machine-42"
}, nil
}
ts := common.NewToolsSetter(s.State, getCanWrite)
c.Assert(ts, gc.NotNil)
err := s.machine0.SetAgentVersion(version.Current)
c.Assert(err, gc.IsNil)
args := params.EntitiesVersion{
AgentTools: []params.EntityVersion{{
Tag: "machine-0",
Tools: ¶ms.Version{
Version: version.Current,
},
}, {
Tag: "machine-1",
Tools: ¶ms.Version{
Version: version.Current,
},
}, {
Tag: "machine-42",
Tools: ¶ms.Version{
Version: version.Current,
},
}},
}
result, err := ts.SetTools(args)
c.Assert(err, gc.IsNil)
c.Assert(result.Results, gc.HasLen, 3)
c.Assert(result.Results[0].Error, gc.IsNil)
agentTools, err := s.machine0.AgentTools()
c.Assert(err, gc.IsNil)
c.Assert(agentTools.Version, gc.DeepEquals, version.Current)
c.Assert(result.Results[1].Error, gc.DeepEquals, apiservertesting.ErrUnauthorized)
c.Assert(result.Results[2].Error, gc.DeepEquals, apiservertesting.NotFoundError("machine 42"))
}
func (s *withoutStateServerSuite) TestRequestedNetworks(c *gc.C) {
// Add a machine with some requested networks.
template := state.MachineTemplate{
Series: "quantal",
Jobs: []state.MachineJob{state.JobHostUnits},
IncludeNetworks: []string{"net1", "net2"},
ExcludeNetworks: []string{"net3", "net4"},
}
netsMachine, err := s.State.AddOneMachine(template)
c.Assert(err, gc.IsNil)
includeNetsMachine0, excludeNetsMachine0, err := s.machines[0].RequestedNetworks()
c.Assert(err, gc.IsNil)
args := params.Entities{Entities: []params.Entity{
{Tag: s.machines[0].Tag()},
{Tag: netsMachine.Tag()},
{Tag: "machine-42"},
{Tag: "unit-foo-0"},
{Tag: "service-bar"},
}}
result, err := s.provisioner.RequestedNetworks(args)
c.Assert(err, gc.IsNil)
c.Assert(result, gc.DeepEquals, params.RequestedNetworksResults{
Results: []params.RequestedNetworkResult{
{
IncludeNetworks: includeNetsMachine0,
ExcludeNetworks: excludeNetsMachine0,
},
{
IncludeNetworks: template.IncludeNetworks,
ExcludeNetworks: template.ExcludeNetworks,
},
{Error: apiservertesting.NotFoundError("machine 42")},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
},
})
}
func (s *withoutStateServerSuite) TestSetPasswords(c *gc.C) {
args := params.EntityPasswords{
Changes: []params.EntityPassword{
{Tag: s.machines[0].Tag(), Password: "******"},
{Tag: s.machines[1].Tag(), Password: "******"},
{Tag: s.machines[2].Tag(), Password: "******"},
{Tag: s.machines[3].Tag(), Password: "******"},
{Tag: s.machines[4].Tag(), Password: "******"},
{Tag: "machine-42", Password: "******"},
{Tag: "unit-foo-0", Password: "******"},
{Tag: "service-bar", Password: "******"},
},
}
results, err := s.provisioner.SetPasswords(args)
c.Assert(err, gc.IsNil)
c.Assert(results, gc.DeepEquals, params.ErrorResults{
Results: []params.ErrorResult{
{nil},
{nil},
{nil},
{nil},
{nil},
{apiservertesting.NotFoundError("machine 42")},
{apiservertesting.ErrUnauthorized},
{apiservertesting.ErrUnauthorized},
},
})
// Verify the changes to both machines succeeded.
for i, machine := range s.machines {
c.Logf("trying %q password", machine.Tag())
err = machine.Refresh()
c.Assert(err, gc.IsNil)
changed := machine.PasswordValid(fmt.Sprintf("xxx%d-1234567890123457890", i))
c.Assert(changed, jc.IsTrue)
}
}
func (s *firewallerSuite) TestGetExposed(c *gc.C) {
// Set the service to exposed first.
err := s.service.SetExposed()
c.Assert(err, gc.IsNil)
args := addFakeEntities(params.Entities{Entities: []params.Entity{
{Tag: s.service.Tag()},
}})
result, err := s.firewaller.GetExposed(args)
c.Assert(err, gc.IsNil)
c.Assert(result, jc.DeepEquals, params.BoolResults{
Results: []params.BoolResult{
{Result: true},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.NotFoundError(`service "bar"`)},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
},
})
// Now reset the exposed flag for the service and check again.
err = s.service.ClearExposed()
c.Assert(err, gc.IsNil)
args = params.Entities{Entities: []params.Entity{
{Tag: s.service.Tag()},
}}
result, err = s.firewaller.GetExposed(args)
c.Assert(err, gc.IsNil)
c.Assert(result, jc.DeepEquals, params.BoolResults{
Results: []params.BoolResult{
{Result: false},
},
})
}
func (s *withoutStateServerSuite) TestSetStatus(c *gc.C) {
err := s.machines[0].SetStatus(params.StatusStarted, "blah", nil)
c.Assert(err, gc.IsNil)
err = s.machines[1].SetStatus(params.StatusStopped, "foo", nil)
c.Assert(err, gc.IsNil)
err = s.machines[2].SetStatus(params.StatusError, "not really", nil)
c.Assert(err, gc.IsNil)
args := params.SetStatus{
Entities: []params.EntityStatus{
{Tag: s.machines[0].Tag(), Status: params.StatusError, Info: "not really",
Data: params.StatusData{"foo": "bar"}},
{Tag: s.machines[1].Tag(), Status: params.StatusStopped, Info: "foobar"},
{Tag: s.machines[2].Tag(), Status: params.StatusStarted, Info: "again"},
{Tag: "machine-42", Status: params.StatusStarted, Info: "blah"},
{Tag: "unit-foo-0", Status: params.StatusStopped, Info: "foobar"},
{Tag: "service-bar", Status: params.StatusStopped, Info: "foobar"},
}}
result, err := s.provisioner.SetStatus(args)
c.Assert(err, gc.IsNil)
c.Assert(result, gc.DeepEquals, params.ErrorResults{
Results: []params.ErrorResult{
{nil},
{nil},
{nil},
{apiservertesting.NotFoundError("machine 42")},
{apiservertesting.ErrUnauthorized},
{apiservertesting.ErrUnauthorized},
},
})
// Verify the changes.
s.assertStatus(c, 0, params.StatusError, "not really", params.StatusData{"foo": "bar"})
s.assertStatus(c, 1, params.StatusStopped, "foobar", params.StatusData{})
s.assertStatus(c, 2, params.StatusStarted, "again", params.StatusData{})
}
func (s *withoutStateServerSuite) TestWatchAllContainers(c *gc.C) {
c.Assert(s.resources.Count(), gc.Equals, 0)
args := params.WatchContainers{Params: []params.WatchContainer{
{MachineTag: s.machines[0].Tag()},
{MachineTag: s.machines[1].Tag()},
{MachineTag: "machine-42"},
{MachineTag: "unit-foo-0"},
{MachineTag: "service-bar"},
}}
result, err := s.provisioner.WatchAllContainers(args)
c.Assert(err, gc.IsNil)
c.Assert(result, gc.DeepEquals, params.StringsWatchResults{
Results: []params.StringsWatchResult{
{StringsWatcherId: "1", Changes: []string{}},
{StringsWatcherId: "2", Changes: []string{}},
{Error: apiservertesting.NotFoundError("machine 42")},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
},
})
// Verify the resources were registered and stop them when done.
c.Assert(s.resources.Count(), gc.Equals, 2)
m0Watcher := s.resources.Get("1")
defer statetesting.AssertStop(c, m0Watcher)
m1Watcher := s.resources.Get("2")
defer statetesting.AssertStop(c, m1Watcher)
// Check that the Watch has consumed the initial event ("returned"
// in the Watch call)
wc0 := statetesting.NewStringsWatcherC(c, s.State, m0Watcher.(state.StringsWatcher))
wc0.AssertNoChange()
wc1 := statetesting.NewStringsWatcherC(c, s.State, m1Watcher.(state.StringsWatcher))
wc1.AssertNoChange()
}
func (s *withoutStateServerSuite) TestDistributionGroupEnvironManagerAuth(c *gc.C) {
args := params.Entities{Entities: []params.Entity{
{Tag: "machine-0"},
{Tag: "machine-42"},
{Tag: "machine-0-lxc-99"},
{Tag: "unit-foo-0"},
{Tag: "service-bar"},
}}
result, err := s.provisioner.DistributionGroup(args)
c.Assert(err, gc.IsNil)
c.Assert(result, gc.DeepEquals, params.DistributionGroupResults{
Results: []params.DistributionGroupResult{
// environ manager may access any top-level machines.
{Result: []instance.Id{}},
{Error: apiservertesting.NotFoundError("machine 42")},
// only a machine agent for the container or its
// parent may access it.
{Error: apiservertesting.ErrUnauthorized},
// non-machines always unauthorized
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
},
})
}
func (s *withoutStateServerSuite) TestSetInstanceInfo(c *gc.C) {
// Provision machine 0 first.
hwChars := instance.MustParseHardware("arch=i386", "mem=4G")
err := s.machines[0].SetInstanceInfo("i-am", "fake_nonce", &hwChars, nil, nil)
c.Assert(err, gc.IsNil)
networks := []params.Network{{
Tag: "network-net1",
ProviderId: "net1",
CIDR: "0.1.2.0/24",
VLANTag: 0,
}, {
Tag: "network-vlan42",
ProviderId: "vlan42",
CIDR: "0.2.2.0/24",
VLANTag: 42,
}, {
Tag: "network-vlan69",
ProviderId: "vlan69",
CIDR: "0.3.2.0/24",
VLANTag: 69,
}, {
Tag: "network-vlan42", // duplicated; ignored
ProviderId: "vlan42",
CIDR: "0.2.2.0/24",
VLANTag: 42,
}}
ifaces := []params.NetworkInterface{{
MACAddress: "aa:bb:cc:dd:ee:f0",
NetworkTag: "network-net1",
InterfaceName: "eth0",
IsVirtual: false,
}, {
MACAddress: "aa:bb:cc:dd:ee:f1",
NetworkTag: "network-net1",
InterfaceName: "eth1",
IsVirtual: false,
}, {
MACAddress: "aa:bb:cc:dd:ee:f1",
NetworkTag: "network-vlan42",
InterfaceName: "eth1.42",
IsVirtual: true,
}, {
MACAddress: "aa:bb:cc:dd:ee:f0",
NetworkTag: "network-vlan69",
InterfaceName: "eth0.69",
IsVirtual: true,
}, {
MACAddress: "aa:bb:cc:dd:ee:f1", // duplicated mac+net; ignored
NetworkTag: "network-vlan42",
InterfaceName: "eth2",
IsVirtual: true,
}, {
MACAddress: "aa:bb:cc:dd:ee:f2",
NetworkTag: "network-net1",
InterfaceName: "eth1", // duplicated name+machine id; ignored for machine 1.
IsVirtual: false,
}}
args := params.InstancesInfo{Machines: []params.InstanceInfo{{
Tag: s.machines[0].Tag(),
InstanceId: "i-was",
Nonce: "fake_nonce",
}, {
Tag: s.machines[1].Tag(),
InstanceId: "i-will",
Nonce: "fake_nonce",
Characteristics: &hwChars,
Networks: networks,
Interfaces: ifaces,
}, {
Tag: s.machines[2].Tag(),
InstanceId: "i-am-too",
Nonce: "fake",
Characteristics: nil,
Networks: networks,
Interfaces: ifaces,
},
{Tag: "machine-42"},
{Tag: "unit-foo-0"},
{Tag: "service-bar"},
}}
result, err := s.provisioner.SetInstanceInfo(args)
c.Assert(err, gc.IsNil)
c.Assert(result, jc.DeepEquals, params.ErrorResults{
Results: []params.ErrorResult{
{¶ms.Error{
Message: `aborted instance "i-was": cannot set instance data for machine "0": already set`,
}},
{nil},
{nil},
{apiservertesting.NotFoundError("machine 42")},
{apiservertesting.ErrUnauthorized},
{apiservertesting.ErrUnauthorized},
},
})
// Verify machine 1 and 2 were provisioned.
c.Assert(s.machines[1].Refresh(), gc.IsNil)
c.Assert(s.machines[2].Refresh(), gc.IsNil)
instanceId, err := s.machines[1].InstanceId()
c.Assert(err, gc.IsNil)
c.Check(instanceId, gc.Equals, instance.Id("i-will"))
instanceId, err = s.machines[2].InstanceId()
c.Assert(err, gc.IsNil)
c.Check(instanceId, gc.Equals, instance.Id("i-am-too"))
c.Check(s.machines[1].CheckProvisioned("fake_nonce"), jc.IsTrue)
c.Check(s.machines[2].CheckProvisioned("fake"), jc.IsTrue)
gotHardware, err := s.machines[1].HardwareCharacteristics()
c.Assert(err, gc.IsNil)
c.Check(gotHardware, gc.DeepEquals, &hwChars)
ifacesMachine1, err := s.machines[1].NetworkInterfaces()
c.Assert(err, gc.IsNil)
c.Assert(ifacesMachine1, gc.HasLen, 4)
actual := make([]params.NetworkInterface, len(ifacesMachine1))
for i, iface := range ifacesMachine1 {
actual[i].InterfaceName = iface.InterfaceName()
actual[i].NetworkTag = iface.NetworkTag()
actual[i].MACAddress = iface.MACAddress()
actual[i].IsVirtual = iface.IsVirtual()
c.Check(iface.MachineId(), gc.Equals, s.machines[1].Id())
c.Check(iface.MachineTag(), gc.Equals, s.machines[1].Tag())
}
c.Assert(actual, jc.SameContents, ifaces[:4])
ifacesMachine2, err := s.machines[2].NetworkInterfaces()
c.Assert(err, gc.IsNil)
c.Assert(ifacesMachine2, gc.HasLen, 1)
c.Assert(ifacesMachine2[0].InterfaceName(), gc.Equals, ifaces[5].InterfaceName)
c.Assert(ifacesMachine2[0].MACAddress(), gc.Equals, ifaces[5].MACAddress)
c.Assert(ifacesMachine2[0].NetworkTag(), gc.Equals, ifaces[5].NetworkTag)
c.Assert(ifacesMachine2[0].MachineId(), gc.Equals, s.machines[2].Id())
for i, _ := range networks {
if i == 3 {
// Last one was ignored, so don't check.
break
}
_, networkName, err := names.ParseTag(networks[i].Tag, names.NetworkTagKind)
c.Assert(err, gc.IsNil)
network, err := s.State.Network(networkName)
c.Assert(err, gc.IsNil)
c.Check(network.Name(), gc.Equals, networkName)
c.Check(network.ProviderId(), gc.Equals, networks[i].ProviderId)
c.Check(network.Tag(), gc.Equals, networks[i].Tag)
c.Check(network.VLANTag(), gc.Equals, networks[i].VLANTag)
c.Check(network.CIDR(), gc.Equals, networks[i].CIDR)
}
}