func (resourceSuite) TestConcurrency(c *gc.C) {
// This test is designed to cause the race detector
// to fail if the locking is not done correctly.
var wg sync.WaitGroup
rs := common.NewResources()
start := func(f func()) {
wg.Add(1)
go func() {
f()
wg.Done()
}()
}
rs.Register(&fakeResource{})
start(func() {
rs.Register(&fakeResource{})
})
start(func() {
rs.Stop("1")
})
start(func() {
rs.Count()
})
start(func() {
rs.StopAll()
})
start(func() {
rs.Get("2")
})
wg.Wait()
}
func (*unitsWatcherSuite) TestWatchUnits(c *gc.C) {
st := &fakeState{
entities: map[string]entityWithError{
"x0": &fakeUnitsWatcher{fetchError: "x0 fails"},
"x1": &fakeUnitsWatcher{initial: []string{"foo", "bar"}},
"x2": &fakeUnitsWatcher{},
},
}
getCanWatch := func() (common.AuthFunc, error) {
return func(tag string) bool {
switch tag {
case "x0", "x1":
return true
}
return false
}, nil
}
resources := common.NewResources()
w := common.NewUnitsWatcher(st, resources, getCanWatch)
entities := params.Entities{[]params.Entity{
{"x0"}, {"x1"}, {"x2"}, {"x3"},
}}
result, err := w.WatchUnits(entities)
c.Assert(err, gc.IsNil)
c.Assert(result, jc.DeepEquals, params.StringsWatchResults{
Results: []params.StringsWatchResult{
{Error: ¶ms.Error{Message: "x0 fails"}},
{"1", []string{"foo", "bar"}, nil},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
},
})
}
func (s *deployerSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
// The two known machines now contain the following units:
// machine 0 (not authorized): mysql/1 (principal1)
// machine 1 (authorized): mysql/0 (principal0), logging/0 (subordinate0)
var err error
s.machine0, err = s.State.AddMachine("quantal", state.JobManageEnviron, state.JobHostUnits)
c.Assert(err, gc.IsNil)
s.machine1, err = s.State.AddMachine("quantal", state.JobHostUnits)
c.Assert(err, gc.IsNil)
s.service0 = s.AddTestingService(c, "mysql", s.AddTestingCharm(c, "mysql"))
s.service1 = s.AddTestingService(c, "logging", s.AddTestingCharm(c, "logging"))
eps, err := s.State.InferEndpoints([]string{"mysql", "logging"})
c.Assert(err, gc.IsNil)
rel, err := s.State.AddRelation(eps...)
c.Assert(err, gc.IsNil)
s.principal0, err = s.service0.AddUnit()
c.Assert(err, gc.IsNil)
err = s.principal0.AssignToMachine(s.machine1)
c.Assert(err, gc.IsNil)
s.principal1, err = s.service0.AddUnit()
c.Assert(err, gc.IsNil)
err = s.principal1.AssignToMachine(s.machine0)
c.Assert(err, gc.IsNil)
relUnit0, err := rel.Unit(s.principal0)
c.Assert(err, gc.IsNil)
err = relUnit0.EnterScope(nil)
c.Assert(err, gc.IsNil)
s.subordinate0, err = s.service1.Unit("logging/0")
c.Assert(err, gc.IsNil)
// Create a FakeAuthorizer so we can check permissions,
// set up assuming machine 1 has logged in.
s.authorizer = apiservertesting.FakeAuthorizer{
Tag: names.MachineTag(s.machine1.Id()),
LoggedIn: true,
MachineAgent: true,
}
// Create the resource registry separately to track invocations to
// Register.
s.resources = common.NewResources()
// Create a deployer API for machine 1.
deployer, err := deployer.NewDeployerAPI(
s.State,
s.resources,
s.authorizer,
)
c.Assert(err, gc.IsNil)
s.deployer = deployer
}
// newSrvRoot creates the client's connection representation
// and starts a ping timeout for the monitoring of this
// connection.
func newSrvRoot(root *initialRoot, entity taggedAuthenticator) *srvRoot {
r := &srvRoot{
srv: root.srv,
rpcConn: root.rpcConn,
resources: common.NewResources(),
entity: entity,
}
r.clientAPI.API = client.NewAPI(r.srv.state, r.resources, r, r.srv.dataDir)
return r
}
func (s *rsyslogSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
s.authorizer = apiservertesting.FakeAuthorizer{
LoggedIn: true,
EnvironManager: true,
}
s.resources = common.NewResources()
api, err := rsyslog.NewRsyslogAPI(s.State, s.resources, s.authorizer)
c.Assert(err, gc.IsNil)
s.EnvironWatcherTest = commontesting.NewEnvironWatcherTest(
api, s.State, s.resources, commontesting.NoSecrets)
}
func (resourceSuite) TestStop(c *gc.C) {
rs := common.NewResources()
r1 := &fakeResource{}
rs.Register(r1)
r2 := &fakeResource{}
rs.Register(r2)
rs.Stop("1")
c.Assert(r1.stopped, gc.Equals, true)
c.Assert(rs.Get("1"), gc.IsNil)
c.Assert(r2.stopped, gc.Equals, false)
c.Assert(rs.Get("2"), gc.Equals, r2)
c.Assert(rs.Count(), gc.Equals, 1)
}
func (*unitsWatcherSuite) TestWatchUnitsError(c *gc.C) {
getCanWatch := func() (common.AuthFunc, error) {
return nil, fmt.Errorf("pow")
}
resources := common.NewResources()
w := common.NewUnitsWatcher(
&fakeState{},
resources,
getCanWatch,
)
_, err := w.WatchUnits(params.Entities{[]params.Entity{{"x0"}}})
c.Assert(err, gc.ErrorMatches, "pow")
}
func (s *charmVersionSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
s.CharmSuite.SetUpTest(c)
s.resources = common.NewResources()
s.AddCleanup(func(_ *gc.C) { s.resources.StopAll() })
s.authoriser = apiservertesting.FakeAuthorizer{
LoggedIn: true,
EnvironManager: true,
}
var err error
s.charmrevisionupdater, err = charmrevisionupdater.NewCharmRevisionUpdaterAPI(s.State, s.resources, s.authoriser)
c.Assert(err, gc.IsNil)
}
func (s *keyManagerSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
s.resources = common.NewResources()
s.AddCleanup(func(_ *gc.C) { s.resources.StopAll() })
s.authoriser = apiservertesting.FakeAuthorizer{
Tag: "user-admin",
LoggedIn: true,
Client: true,
}
var err error
s.keymanager, err = keymanager.NewKeyManagerAPI(s.State, s.resources, s.authoriser)
c.Assert(err, gc.IsNil)
}
func (*unitsWatcherSuite) TestWatchNoArgsNoError(c *gc.C) {
getCanWatch := func() (common.AuthFunc, error) {
return nil, fmt.Errorf("pow")
}
resources := common.NewResources()
w := common.NewUnitsWatcher(
&fakeState{},
resources,
getCanWatch,
)
result, err := w.WatchUnits(params.Entities{})
c.Assert(err, gc.IsNil)
c.Assert(result.Results, gc.HasLen, 0)
}
func (resourceSuite) TestRegisterGetCount(c *gc.C) {
rs := common.NewResources()
r1 := &fakeResource{}
id := rs.Register(r1)
c.Assert(id, gc.Equals, "1")
c.Assert(rs.Get("1"), gc.Equals, r1)
c.Assert(rs.Count(), gc.Equals, 1)
r2 := &fakeResource{}
id = rs.Register(r2)
c.Assert(id, gc.Equals, "2")
c.Assert(rs.Get("2"), gc.Equals, r2)
c.Assert(rs.Count(), gc.Equals, 2)
}
func (*environMachinesWatcherSuite) TestWatchGetAuthError(c *gc.C) {
getCanWatch := func() (common.AuthFunc, error) {
return nil, fmt.Errorf("pow")
}
resources := common.NewResources()
e := common.NewEnvironMachinesWatcher(
&fakeEnvironMachinesWatcher{},
resources,
getCanWatch,
)
_, err := e.WatchEnvironMachines()
c.Assert(err, gc.ErrorMatches, "pow")
c.Assert(resources.Count(), gc.Equals, 0)
}
func (s *machinerSuite) SetUpTest(c *gc.C) {
s.commonSuite.SetUpTest(c)
// Create the resource registry separately to track invocations to
// Register.
s.resources = common.NewResources()
// Create a machiner API for machine 1.
machiner, err := machine.NewMachinerAPI(
s.State,
s.resources,
s.authorizer,
)
c.Assert(err, gc.IsNil)
s.machiner = machiner
}
func (*environMachinesWatcherSuite) TestWatchAuthError(c *gc.C) {
getCanWatch := func() (common.AuthFunc, error) {
return func(tag string) bool {
return false
}, nil
}
resources := common.NewResources()
e := common.NewEnvironMachinesWatcher(
&fakeEnvironMachinesWatcher{},
resources,
getCanWatch,
)
_, err := e.WatchEnvironMachines()
c.Assert(err, gc.ErrorMatches, "permission denied")
c.Assert(resources.Count(), gc.Equals, 0)
}
func (s *firewallerSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
// Reset previous machines and units (if any) and create 3
// machines for the tests.
s.machines = nil
s.units = nil
// Note that the specific machine ids allocated are assumed
// to be numerically consecutive from zero.
for i := 0; i <= 2; i++ {
machine, err := s.State.AddMachine("quantal", state.JobHostUnits)
c.Check(err, gc.IsNil)
s.machines = append(s.machines, machine)
}
// Create a service and three units for these machines.
s.charm = s.AddTestingCharm(c, "wordpress")
s.service = s.AddTestingService(c, "wordpress", s.charm)
// Add the rest of the units and assign them.
for i := 0; i <= 2; i++ {
unit, err := s.service.AddUnit()
c.Check(err, gc.IsNil)
err = unit.AssignToMachine(s.machines[i])
c.Check(err, gc.IsNil)
s.units = append(s.units, unit)
}
// Create a FakeAuthorizer so we can check permissions,
// set up assuming we logged in as the environment manager.
s.authorizer = apiservertesting.FakeAuthorizer{
LoggedIn: true,
EnvironManager: true,
}
// Create the resource registry separately to track invocations to
// Register.
s.resources = common.NewResources()
// Create a firewaller API for the machine.
firewallerAPI, err := firewaller.NewFirewallerAPI(
s.State,
s.resources,
s.authorizer,
)
c.Assert(err, gc.IsNil)
s.firewaller = firewallerAPI
s.EnvironWatcherTest = commontesting.NewEnvironWatcherTest(s.firewaller, s.State, s.resources, commontesting.HasSecrets)
}
func (*environMachinesWatcherSuite) TestWatchEnvironMachines(c *gc.C) {
getCanWatch := func() (common.AuthFunc, error) {
return func(tag string) bool {
return true
}, nil
}
resources := common.NewResources()
e := common.NewEnvironMachinesWatcher(
&fakeEnvironMachinesWatcher{initial: []string{"foo"}},
resources,
getCanWatch,
)
result, err := e.WatchEnvironMachines()
c.Assert(err, gc.IsNil)
c.Assert(result, jc.DeepEquals, params.StringsWatchResult{"1", []string{"foo"}, nil})
c.Assert(resources.Count(), gc.Equals, 1)
}
func (*environWatcherSuite) TestWatchSuccess(c *gc.C) {
getCanWatch := func() (common.AuthFunc, error) {
return func(tag string) bool {
return true
}, nil
}
resources := common.NewResources()
e := common.NewEnvironWatcher(
&fakeEnvironAccessor{},
resources,
getCanWatch,
nil,
)
result, err := e.WatchForEnvironConfigChanges()
c.Assert(err, gc.IsNil)
c.Assert(result, gc.DeepEquals, params.NotifyWatchResult{"1", nil})
c.Assert(resources.Count(), gc.Equals, 1)
}
func (*environWatcherSuite) TestWatchAuthError(c *gc.C) {
getCanWatch := func() (common.AuthFunc, error) {
return func(tag string) bool {
return false
}, nil
}
resources := common.NewResources()
e := common.NewEnvironWatcher(
&fakeEnvironAccessor{},
resources,
getCanWatch,
nil,
)
result, err := e.WatchForEnvironConfigChanges()
c.Assert(err, gc.ErrorMatches, "permission denied")
c.Assert(result, gc.DeepEquals, params.NotifyWatchResult{})
c.Assert(resources.Count(), gc.Equals, 0)
}
func (s *uniterSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
s.wpCharm = s.AddTestingCharm(c, "wordpress")
// Create two machines, two services and add a unit to each service.
var err error
s.machine0, err = s.State.AddMachine("quantal", state.JobHostUnits, state.JobManageEnviron)
c.Assert(err, gc.IsNil)
s.machine1, err = s.State.AddMachine("quantal", state.JobHostUnits)
c.Assert(err, gc.IsNil)
s.wordpress = s.AddTestingService(c, "wordpress", s.wpCharm)
s.mysql = s.AddTestingService(c, "mysql", s.AddTestingCharm(c, "mysql"))
s.wordpressUnit, err = s.wordpress.AddUnit()
c.Assert(err, gc.IsNil)
s.mysqlUnit, err = s.mysql.AddUnit()
c.Assert(err, gc.IsNil)
// Assign each unit to each machine.
err = s.wordpressUnit.AssignToMachine(s.machine0)
c.Assert(err, gc.IsNil)
err = s.mysqlUnit.AssignToMachine(s.machine1)
c.Assert(err, gc.IsNil)
// Create a FakeAuthorizer so we can check permissions,
// set up assuming unit 0 has logged in.
s.authorizer = apiservertesting.FakeAuthorizer{
Tag: s.wordpressUnit.Tag(),
LoggedIn: true,
UnitAgent: true,
Entity: s.wordpressUnit,
}
// Create the resource registry separately to track invocations to
// Register.
s.resources = common.NewResources()
// Create a uniter API for unit 0.
s.uniter, err = uniter.NewUniterAPI(
s.State,
s.resources,
s.authorizer,
)
c.Assert(err, gc.IsNil)
s.EnvironWatcherTest = commontesting.NewEnvironWatcherTest(s.uniter, s.State, s.resources, commontesting.NoSecrets)
}
func (s *loggerSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
s.resources = common.NewResources()
s.AddCleanup(func(_ *gc.C) { s.resources.StopAll() })
// Create a machine to work with
var err error
s.rawMachine, err = s.State.AddMachine("quantal", state.JobHostUnits)
c.Assert(err, gc.IsNil)
// The default auth is as the machine agent
s.authorizer = apiservertesting.FakeAuthorizer{
Tag: s.rawMachine.Tag(),
LoggedIn: true,
MachineAgent: true,
}
s.logger, err = logger.NewLoggerAPI(s.State, s.resources, s.authorizer)
c.Assert(err, gc.IsNil)
}
func (s *upgraderSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
s.resources = common.NewResources()
// Create a machine to work with
var err error
// The first machine created is the only one allowed to
// JobManageEnviron
s.apiMachine, err = s.State.AddMachine("quantal", state.JobHostUnits,
state.JobManageEnviron)
c.Assert(err, gc.IsNil)
s.rawMachine, err = s.State.AddMachine("quantal", state.JobHostUnits)
c.Assert(err, gc.IsNil)
// The default auth is as the machine agent
s.authorizer = apiservertesting.FakeAuthorizer{
Tag: s.rawMachine.Tag(),
LoggedIn: true,
MachineAgent: true,
}
s.upgrader, err = upgrader.NewUpgraderAPI(s.State, s.resources, s.authorizer)
c.Assert(err, gc.IsNil)
}
func (s *provisionerSuite) setUpTest(c *gc.C, withStateServer bool) {
s.JujuConnSuite.SetUpTest(c)
// Reset previous machines (if any) and create 3 machines
// for the tests, plus an optional state server machine.
s.machines = nil
// Note that the specific machine ids allocated are assumed
// to be numerically consecutive from zero.
if withStateServer {
s.machines = append(s.machines, testing.AddStateServerMachine(c, s.State))
}
for i := 0; i < 5; i++ {
machine, err := s.State.AddMachine("quantal", state.JobHostUnits)
c.Check(err, gc.IsNil)
s.machines = append(s.machines, machine)
}
// Create a FakeAuthorizer so we can check permissions,
// set up assuming we logged in as the environment manager.
s.authorizer = apiservertesting.FakeAuthorizer{
LoggedIn: true,
EnvironManager: true,
}
// Create the resource registry separately to track invocations to
// Register.
s.resources = common.NewResources()
// Create a provisioner API for the machine.
provisionerAPI, err := provisioner.NewProvisionerAPI(
s.State,
s.resources,
s.authorizer,
)
c.Assert(err, gc.IsNil)
s.provisioner = provisionerAPI
}
func (s *environmentSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
var err error
s.machine0, err = s.State.AddMachine("quantal", state.JobHostUnits, state.JobManageEnviron)
c.Assert(err, gc.IsNil)
s.authorizer = apiservertesting.FakeAuthorizer{
Tag: s.machine0.Tag(),
LoggedIn: true,
MachineAgent: true,
Entity: s.machine0,
}
s.resources = common.NewResources()
s.api, err = environment.NewEnvironmentAPI(
s.State,
s.resources,
s.authorizer,
)
c.Assert(err, gc.IsNil)
s.EnvironWatcherTest = commontesting.NewEnvironWatcherTest(
s.api, s.State, s.resources, commontesting.NoSecrets)
}
func (s *unitUpgraderSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
s.resources = common.NewResources()
// Create a machine and unit to work with
var err error
_, err = s.State.AddMachine("quantal", state.JobHostUnits)
c.Assert(err, gc.IsNil)
svc := s.AddTestingService(c, "wordpress", s.AddTestingCharm(c, "wordpress"))
s.rawUnit, err = svc.AddUnit()
c.Assert(err, gc.IsNil)
// Assign the unit to the machine.
s.rawMachine, err = s.rawUnit.AssignToCleanMachine()
c.Assert(err, gc.IsNil)
// The default auth is as the unit agent
s.authorizer = apiservertesting.FakeAuthorizer{
Tag: s.rawUnit.Tag(),
LoggedIn: true,
UnitAgent: true,
}
s.upgrader, err = upgrader.NewUnitUpgraderAPI(s.State, s.resources, s.authorizer, s.DataDir())
c.Assert(err, gc.IsNil)
}
func (s *apiAddresserSuite) SetUpTest(c *gc.C) {
s.addresser = common.NewAPIAddresser(fakeAddresses{}, common.NewResources())
}