func (s *HookContextSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
var err error
sch := s.AddTestingCharm(c, "wordpress")
s.service = s.AddTestingService(c, "u", sch)
s.unit = s.AddUnit(c, s.service)
password, err := utils.RandomPassword()
err = s.unit.SetPassword(password)
c.Assert(err, gc.IsNil)
s.st = s.OpenAPIAs(c, s.unit.Tag(), password)
s.uniter = s.st.Uniter()
c.Assert(s.uniter, gc.NotNil)
// Note: The unit must always have a charm URL set, because this
// happens as part of the installation process (that happens
// before the initial install hook).
err = s.unit.SetCharmURL(sch.URL())
c.Assert(err, gc.IsNil)
s.relch = s.AddTestingCharm(c, "mysql")
s.relunits = map[int]*state.RelationUnit{}
s.relctxs = map[int]*uniter.ContextRelation{}
s.AddContextRelation(c, "db0")
s.AddContextRelation(c, "db1")
}
func (s *RelationerSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
var err error
s.svc = s.AddTestingService(c, "u", s.AddTestingCharm(c, "riak"))
c.Assert(err, gc.IsNil)
rels, err := s.svc.Relations()
c.Assert(err, gc.IsNil)
c.Assert(rels, gc.HasLen, 1)
s.rel = rels[0]
_, unit := s.AddRelationUnit(c, "u/0")
s.dirPath = c.MkDir()
s.dir, err = relation.ReadStateDir(s.dirPath, s.rel.Id())
c.Assert(err, gc.IsNil)
s.hooks = make(chan hook.Info)
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)
apiUnit, err := s.uniter.Unit(unit.Tag())
c.Assert(err, gc.IsNil)
apiRel, err := s.uniter.Relation(s.rel.Tag())
c.Assert(err, gc.IsNil)
s.apiRelUnit, err = apiRel.Unit(apiUnit)
c.Assert(err, gc.IsNil)
}
func (s *ContextRelationSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
ch := s.AddTestingCharm(c, "riak")
var err error
s.svc = s.AddTestingService(c, "u", ch)
rels, err := s.svc.Relations()
c.Assert(err, gc.IsNil)
c.Assert(rels, gc.HasLen, 1)
s.rel = rels[0]
unit, err := s.svc.AddUnit()
c.Assert(err, gc.IsNil)
s.ru, err = s.rel.Unit(unit)
c.Assert(err, gc.IsNil)
err = s.ru.EnterScope(nil)
c.Assert(err, gc.IsNil)
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)
apiRel, err := s.uniter.Relation(s.rel.Tag())
c.Assert(err, gc.IsNil)
apiUnit, err := s.uniter.Unit(unit.Tag())
c.Assert(err, gc.IsNil)
s.apiRelUnit, err = apiRel.Unit(apiUnit)
c.Assert(err, gc.IsNil)
}
func (c *UserAddCommand) Run(ctx *cmd.Context) error {
client, err := juju.NewUserManagerClient(c.EnvName)
if err != nil {
return err
}
defer client.Close()
if c.Password == "" {
c.Password, err = utils.RandomPassword()
if err != nil {
return fmt.Errorf("Failed to generate password: %v", err)
}
}
err = client.AddUser(c.User, c.Password)
if err != nil {
return err
}
fmt.Fprintf(ctx.Stdout, "user \"%s\" added with password \"%s\"\n", c.User, c.Password)
if c.outPath != "" {
outPath := NormaliseJenvPath(ctx, c.outPath)
err := GenerateUserJenv(c.EnvName, c.User, c.Password, outPath)
if err == nil {
fmt.Fprintf(ctx.Stdout, "environment file written to %s\n", outPath)
}
}
return err
}
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 (s *unitUpgraderSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
s.rawMachine, _, _, s.rawUnit = s.addMachineServiceCharmAndUnit(c, "wordpress")
password, err := utils.RandomPassword()
c.Assert(err, gc.IsNil)
err = s.rawUnit.SetPassword(password)
c.Assert(err, gc.IsNil)
s.stateAPI = s.OpenAPIAs(c, s.rawUnit.Tag(), password)
// Create the upgrader facade.
s.st = s.stateAPI.Upgrader()
c.Assert(s.st, gc.NotNil)
}
func (s *CommonProvisionerSuite) APILogin(c *gc.C, machine *state.Machine) {
if s.st != nil {
c.Assert(s.st.Close(), gc.IsNil)
}
password, err := utils.RandomPassword()
c.Assert(err, gc.IsNil)
err = machine.SetPassword(password)
c.Assert(err, gc.IsNil)
err = machine.SetProvisioned("i-fake", "fake_nonce", nil)
c.Assert(err, gc.IsNil)
s.st = s.OpenAPIAsMachine(c, machine.Tag(), password, "fake_nonce")
c.Assert(s.st, gc.NotNil)
c.Logf("API: login as %q successful", machine.Tag())
s.provisioner = s.st.Provisioner()
c.Assert(s.provisioner, gc.NotNil)
}
// initBootstrapMachine initializes the initial bootstrap machine in state.
func initBootstrapMachine(c ConfigSetter, st *state.State, cfg BootstrapMachineConfig) (*state.Machine, error) {
logger.Infof("initialising bootstrap machine with config: %+v", cfg)
jobs := make([]state.MachineJob, len(cfg.Jobs))
for i, job := range cfg.Jobs {
machineJob, err := state.MachineJobFromParams(job)
if err != nil {
return nil, fmt.Errorf("invalid bootstrap machine job %q: %v", job, err)
}
jobs[i] = machineJob
}
m, err := st.AddOneMachine(state.MachineTemplate{
Addresses: cfg.Addresses,
Series: version.Current.Series,
Nonce: state.BootstrapNonce,
Constraints: cfg.Constraints,
InstanceId: cfg.InstanceId,
HardwareCharacteristics: cfg.Characteristics,
Jobs: jobs,
})
if err != nil {
return nil, fmt.Errorf("cannot create bootstrap machine in state: %v", err)
}
if m.Id() != BootstrapMachineId {
return nil, fmt.Errorf("bootstrap machine expected id 0, got %q", m.Id())
}
// Read the machine agent's password and change it to
// a new password (other agents will change their password
// via the API connection).
logger.Debugf("create new random password for machine %v", m.Id())
newPassword, err := utils.RandomPassword()
if err != nil {
return nil, err
}
if err := m.SetPassword(newPassword); err != nil {
return nil, err
}
if err := m.SetMongoPassword(newPassword); err != nil {
return nil, err
}
c.SetPassword(newPassword)
return m, nil
}
// deploy will deploy the supplied unit with the deployer's manager. It will
// panic if it observes inconsistent internal state.
func (d *Deployer) deploy(unit *apideployer.Unit) error {
unitName := unit.Name()
if d.deployed.Contains(unit.Name()) {
panic("must not re-deploy a deployed unit")
}
logger.Infof("deploying unit %q", unitName)
initialPassword, err := utils.RandomPassword()
if err != nil {
return err
}
if err := unit.SetPassword(initialPassword); err != nil {
return fmt.Errorf("cannot set password for unit %q: %v", unitName, err)
}
if err := d.ctx.DeployUnit(unitName, initialPassword); err != nil {
return err
}
d.deployed.Add(unitName)
return nil
}
func (s *FirewallerSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
s.charm = s.AddTestingCharm(c, "dummy")
// Create a manager machine and login to the API.
machine, err := s.State.AddMachine("quantal", state.JobManageEnviron)
c.Assert(err, gc.IsNil)
password, err := utils.RandomPassword()
c.Assert(err, gc.IsNil)
err = machine.SetPassword(password)
c.Assert(err, gc.IsNil)
err = machine.SetProvisioned("i-manager", "fake_nonce", nil)
c.Assert(err, gc.IsNil)
s.st = s.OpenAPIAsMachine(c, machine.Tag(), password, "fake_nonce")
c.Assert(s.st, gc.NotNil)
// Create the firewaller API facade.
s.firewaller = s.st.Firewaller()
c.Assert(s.firewaller, gc.NotNil)
}
func (s *toolsSuite) TestAuthRequiresUser(c *gc.C) {
// Add a machine and try to login.
machine, err := s.State.AddMachine("quantal", state.JobHostUnits)
c.Assert(err, gc.IsNil)
err = machine.SetProvisioned("foo", "fake_nonce", nil)
c.Assert(err, gc.IsNil)
password, err := utils.RandomPassword()
c.Assert(err, gc.IsNil)
err = machine.SetPassword(password)
c.Assert(err, gc.IsNil)
resp, err := s.sendRequest(c, machine.Tag(), password, "POST", s.toolsURI(c, ""), "", nil)
c.Assert(err, gc.IsNil)
s.assertErrorResponse(c, resp, http.StatusUnauthorized, "unauthorized")
// Now try a user login.
resp, err = s.authRequest(c, "POST", s.toolsURI(c, ""), "", nil)
c.Assert(err, gc.IsNil)
s.assertErrorResponse(c, resp, http.StatusBadRequest, "expected binaryVersion argument")
}
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. The first one is a manager node.
s.machines = make([]*state.Machine, 3)
s.units = make([]*state.Unit, 3)
var err error
s.machines[0], err = s.State.AddMachine("quantal", state.JobManageEnviron, state.JobHostUnits)
c.Assert(err, gc.IsNil)
password, err := utils.RandomPassword()
c.Assert(err, gc.IsNil)
err = s.machines[0].SetPassword(password)
c.Assert(err, gc.IsNil)
err = s.machines[0].SetProvisioned("i-manager", "fake_nonce", nil)
c.Assert(err, gc.IsNil)
s.st = s.OpenAPIAsMachine(c, s.machines[0].Tag(), password, "fake_nonce")
c.Assert(s.st, gc.NotNil)
// Note that the specific machine ids allocated are assumed
// to be numerically consecutive from zero.
for i := 1; i <= 2; i++ {
s.machines[i], err = s.State.AddMachine("quantal", state.JobHostUnits)
c.Check(err, gc.IsNil)
}
// 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++ {
s.units[i], err = s.service.AddUnit()
c.Check(err, gc.IsNil)
err = s.units[i].AssignToMachine(s.machines[i])
c.Check(err, gc.IsNil)
}
// Create the firewaller API facade.
s.firewaller = s.st.Firewaller()
c.Assert(s.firewaller, gc.NotNil)
}
func (s *RelationerImplicitSuite) TestImplicitRelationer(c *gc.C) {
// Create a relationer for an implicit endpoint (mysql:juju-info).
mysql := s.AddTestingService(c, "mysql", s.AddTestingCharm(c, "mysql"))
u, err := mysql.AddUnit()
c.Assert(err, gc.IsNil)
machine, err := s.State.AddMachine("quantal", state.JobHostUnits)
c.Assert(err, gc.IsNil)
err = u.AssignToMachine(machine)
c.Assert(err, gc.IsNil)
err = machine.SetAddresses(instance.NewAddress("blah", instance.NetworkCloudLocal))
c.Assert(err, gc.IsNil)
logging := s.AddTestingService(c, "logging", s.AddTestingCharm(c, "logging"))
eps, err := s.State.InferEndpoints([]string{"logging", "mysql"})
c.Assert(err, gc.IsNil)
rel, err := s.State.AddRelation(eps...)
c.Assert(err, gc.IsNil)
relsDir := c.MkDir()
dir, err := relation.ReadStateDir(relsDir, rel.Id())
c.Assert(err, gc.IsNil)
hooks := make(chan hook.Info)
password, err := utils.RandomPassword()
c.Assert(err, gc.IsNil)
err = u.SetPassword(password)
c.Assert(err, gc.IsNil)
st := s.OpenAPIAs(c, u.Tag(), password)
uniterState := st.Uniter()
c.Assert(uniterState, gc.NotNil)
apiUnit, err := uniterState.Unit(u.Tag())
c.Assert(err, gc.IsNil)
apiRel, err := uniterState.Relation(rel.Tag())
c.Assert(err, gc.IsNil)
apiRelUnit, err := apiRel.Unit(apiUnit)
c.Assert(err, gc.IsNil)
r := uniter.NewRelationer(apiRelUnit, dir, hooks)
c.Assert(r, jc.Satisfies, (*uniter.Relationer).IsImplicit)
// Join the relation.
err = r.Join()
c.Assert(err, gc.IsNil)
sub, err := logging.Unit("logging/0")
c.Assert(err, gc.IsNil)
// Join the other side; check no hooks are sent.
r.StartHooks()
defer func() { c.Assert(r.StopHooks(), gc.IsNil) }()
subru, err := rel.Unit(sub)
c.Assert(err, gc.IsNil)
err = subru.EnterScope(map[string]interface{}{"some": "data"})
c.Assert(err, gc.IsNil)
s.State.StartSync()
select {
case <-time.After(coretesting.ShortWait):
case <-hooks:
c.Fatalf("unexpected hook generated")
}
// Set it to Dying; check that the dir is removed immediately.
err = r.SetDying()
c.Assert(err, gc.IsNil)
path := strconv.Itoa(rel.Id())
ft.Removed{path}.Check(c, relsDir)
// Check that it left scope, by leaving scope on the other side and destroying
// the relation.
err = subru.LeaveScope()
c.Assert(err, gc.IsNil)
err = rel.Destroy()
c.Assert(err, gc.IsNil)
err = rel.Refresh()
c.Assert(err, jc.Satisfies, errors.IsNotFound)
// Verify that no other hooks were sent at any stage.
select {
case <-hooks:
c.Fatalf("unexpected hook generated")
default:
}
}
