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: } }