// MakeMachine will add a machine with values defined in params. For some // values in params, if they are missing, some meaningful empty values will be // set. // If params is not specified, defaults are used. If more than one // params struct is passed to the function, it panics. func (factory *Factory) MakeMachine(c *gc.C, params *MachineParams) *state.Machine { if params == nil { params = &MachineParams{} } if params.Series == "" { params.Series = "quantal" } if params.Nonce == "" { params.Nonce = "nonce" } if len(params.Jobs) == 0 { params.Jobs = []state.MachineJob{state.JobHostUnits} } if params.InstanceId == "" { params.InstanceId = instance.Id(factory.UniqueString("id")) } if params.Password == "" { var err error params.Password, err = utils.RandomPassword() c.Assert(err, gc.IsNil) } machine, err := factory.st.AddMachine(params.Series, params.Jobs...) c.Assert(err, gc.IsNil) err = machine.SetProvisioned(params.InstanceId, params.Nonce, params.Characteristics) c.Assert(err, gc.IsNil) err = machine.SetPassword(params.Password) c.Assert(err, gc.IsNil) return machine }
// MakeUnit creates a service unit with specified params, filling in sane // defaults for missing values. If params is not specified, defaults are used. // The unit and its password are returned. func (factory *Factory) MakeUnitReturningPassword(c *gc.C, params *UnitParams) (*state.Unit, string) { if params == nil { params = &UnitParams{} } if params.Machine == nil { params.Machine = factory.MakeMachine(c, nil) } if params.Service == nil { params.Service = factory.MakeService(c, nil) } if params.Password == "" { var err error params.Password, err = utils.RandomPassword() c.Assert(err, jc.ErrorIsNil) } unit, err := params.Service.AddUnit() c.Assert(err, jc.ErrorIsNil) err = unit.AssignToMachine(params.Machine) c.Assert(err, jc.ErrorIsNil) if params.SetCharmURL { serviceCharmURL, _ := params.Service.CharmURL() err = unit.SetCharmURL(serviceCharmURL) c.Assert(err, jc.ErrorIsNil) } err = unit.SetPassword(params.Password) c.Assert(err, jc.ErrorIsNil) if params.Status != nil { err = unit.SetStatus(params.Status.Status, params.Status.Message, params.Status.Data) c.Assert(err, jc.ErrorIsNil) } return unit, params.Password }
func (s *undertakerSuite) hostedAPI(c *gc.C) (*undertaker.Client, *state.State) { otherState := s.Factory.MakeModel(c, &factory.ModelParams{Name: "hosted_env"}) password, err := utils.RandomPassword() c.Assert(err, jc.ErrorIsNil) machine := s.Factory.MakeMachine(c, &factory.MachineParams{ Jobs: []state.MachineJob{state.JobManageModel}, Password: password, Nonce: "fake_nonce", }) // Connect to hosted environ from controller. info := s.APIInfo(c) info.Tag = machine.Tag() info.Password = password info.Nonce = "fake_nonce" info.ModelTag = otherState.ModelTag() otherAPIState, err := api.Open(info, api.DefaultDialOpts()) c.Assert(err, jc.ErrorIsNil) undertakerClient := undertaker.NewClient(otherAPIState) c.Assert(undertakerClient, gc.NotNil) return undertakerClient, otherState }
func (*changePasswordCommand) generateOrReadPassword(ctx *cmd.Context, generate bool) (string, error) { if generate { password, err := utils.RandomPassword() if err != nil { return "", errors.Annotate(err, "failed to generate random password") } randomPasswordNotify(password) return password, nil } // Don't add the carriage returns before readPassword, but add // them directly after the readPassword so any errors are output // on their own lines. fmt.Fprint(ctx.Stdout, "password: "******"\n") if err != nil { return "", errors.Trace(err) } fmt.Fprint(ctx.Stdout, "type password again: ") verify, err := readPassword() fmt.Fprint(ctx.Stdout, "\n") if err != nil { return "", errors.Trace(err) } if password != verify { return "", errors.New("Passwords do not match") } return password, nil }
func (s *unitMetricBatchesSuite) SetUpTest(c *gc.C) { s.JujuConnSuite.SetUpTest(c) s.charm = s.Factory.MakeCharm(c, &jujufactory.CharmParams{ Name: "metered", URL: "cs:quantal/metered", }) service := s.Factory.MakeService(c, &jujufactory.ServiceParams{ Charm: s.charm, }) unit := s.Factory.MakeUnit(c, &jujufactory.UnitParams{ Service: service, SetCharmURL: true, }) password, err := utils.RandomPassword() c.Assert(err, jc.ErrorIsNil) err = unit.SetPassword(password) c.Assert(err, jc.ErrorIsNil) s.st = s.OpenAPIAs(c, unit.Tag(), password) // Create the uniter API facade. s.uniter, err = s.st.Uniter() c.Assert(err, jc.ErrorIsNil) c.Assert(s.uniter, gc.NotNil) s.apiUnit, err = s.uniter.Unit(unit.Tag().(names.UnitTag)) c.Assert(err, jc.ErrorIsNil) }
func (c *environClient) generateSigmaComponents(baseName string, constraints *sigmaConstraints, args environs.StartInstanceParams, drv gosigma.Drive, userData []byte) (cc gosigma.Components, err error) { cc.SetName(baseName) cc.SetDescription(baseName) cc.SetSMP(constraints.cores) cc.SetCPU(constraints.power) cc.SetMem(constraints.mem) vncpass, err := utils.RandomPassword() if err != nil { err = errors.Errorf("error generating password: %v", err) return } cc.SetVNCPassword(vncpass) logger.Debugf("Setting ssh key: %s end", c.config.AuthorizedKeys()) cc.SetSSHPublicKey(c.config.AuthorizedKeys()) cc.AttachDrive(1, "0:0", "virtio", drv.UUID()) cc.NetworkDHCP4(gosigma.ModelVirtio) if multiwatcher.AnyJobNeedsState(args.InstanceConfig.Jobs...) { cc.SetMeta(jujuMetaInstance, jujuMetaInstanceStateServer) } else { cc.SetMeta(jujuMetaInstance, jujuMetaInstanceServer) } cc.SetMeta(jujuMetaEnvironment, c.uuid) cc.SetMeta(jujuMetaCoudInit, string(userData)) cc.SetMeta(jujuMetaBase64, jujuMetaCoudInit) return cc, nil }
func (s *serverSuite) TestUnitLoginStartsPinger(c *gc.C) { // Create a new service and unit to verify "agent alive" behavior. service := s.AddTestingService(c, "wordpress", s.AddTestingCharm(c, "wordpress")) unit, err := service.AddUnit() c.Assert(err, gc.IsNil) password, err := utils.RandomPassword() c.Assert(err, gc.IsNil) err = unit.SetPassword(password) c.Assert(err, gc.IsNil) // Not alive yet. s.assertAlive(c, unit, false) // Login as the unit agent of the created unit. st := s.OpenAPIAs(c, unit.Tag(), password) // Make sure the pinger has started. s.assertAlive(c, unit, true) // Now make sure it stops when connection is closed. c.Assert(st.Close(), gc.IsNil) // Sync, then wait for a bit to make sure the state is updated. s.State.StartSync() <-time.After(coretesting.ShortWait) s.State.StartSync() s.assertAlive(c, unit, false) }
func (s *uniterSuite) setUpTest(c *gc.C, addController bool) { s.JujuConnSuite.SetUpTest(c) if addController { s.controllerMachine = testing.AddControllerMachine(c, s.State) } // Bind "db" relation of wordpress to space "internal", // and the "admin-api" extra-binding to space "public". bindings := map[string]string{ "db": "internal", "admin-api": "public", } _, err := s.State.AddSpace("internal", "", nil, false) c.Assert(err, jc.ErrorIsNil) _, err = s.State.AddSpace("public", "", nil, true) c.Assert(err, jc.ErrorIsNil) // Create a machine, a service and add a unit so we can log in as // its agent. s.wordpressMachine, s.wordpressService, s.wordpressCharm, s.wordpressUnit = s.addMachineBoundServiceCharmAndUnit(c, "wordpress", bindings) password, err := utils.RandomPassword() c.Assert(err, jc.ErrorIsNil) err = s.wordpressUnit.SetPassword(password) c.Assert(err, jc.ErrorIsNil) s.st = s.OpenAPIAs(c, s.wordpressUnit.Tag(), password) // Create the uniter API facade. s.uniter, err = s.st.Uniter() c.Assert(err, jc.ErrorIsNil) c.Assert(s.uniter, gc.NotNil) }
// Run implements Command.Run. func (c *addCommand) Run(ctx *cmd.Context) error { if c.api == nil { api, err := c.NewUserManagerAPIClient() if err != nil { return errors.Trace(err) } c.api = api defer c.api.Close() } password, err := utils.RandomPassword() if err != nil { return errors.Annotate(err, "failed to generate random password") } randomPasswordNotify(password) if _, err := c.api.AddUser(c.User, c.DisplayName, password); err != nil { return block.ProcessBlockedError(err, block.BlockChange) } displayName := c.User if c.DisplayName != "" { displayName = fmt.Sprintf("%s (%s)", c.DisplayName, c.User) } ctx.Infof("user %q added", displayName) return writeServerFile(c, ctx, c.User, password, c.OutPath) }
func (s *serverSuite) TestMachineLoginStartsPinger(c *gc.C) { // This is the same steps as OpenAPIAsNewMachine but we need to assert // the agent is not alive before we actually open the API. // Create a new machine to verify "agent alive" behavior. 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) // Not alive yet. s.assertAlive(c, machine, false) // Login as the machine agent of the created machine. st := s.OpenAPIAsMachine(c, machine.Tag(), password, "fake_nonce") // Make sure the pinger has started. s.assertAlive(c, machine, true) // Now make sure it stops when connection is closed. c.Assert(st.Close(), gc.IsNil) // Sync, then wait for a bit to make sure the state is updated. s.State.StartSync() <-time.After(coretesting.ShortWait) s.State.StartSync() s.assertAlive(c, machine, false) }
func (s *rebootSuite) SetUpTest(c *gc.C) { var err error template := state.MachineTemplate{ Series: coretesting.FakeDefaultSeries, Jobs: []state.MachineJob{state.JobHostUnits}, } s.JujuConnSuite.SetUpTest(c) s.stateAPI, s.machine = s.OpenAPIAsNewMachine(c) s.rebootState, err = s.stateAPI.Reboot() c.Assert(err, jc.ErrorIsNil) c.Assert(s.rebootState, gc.NotNil) //Add container s.ct, err = s.State.AddMachineInsideMachine(template, s.machine.Id(), instance.KVM) c.Assert(err, jc.ErrorIsNil) password, err := utils.RandomPassword() c.Assert(err, jc.ErrorIsNil) err = s.ct.SetPassword(password) c.Assert(err, jc.ErrorIsNil) err = s.ct.SetProvisioned("foo", "fake_nonce", nil) c.Assert(err, jc.ErrorIsNil) // Open api as container ctState := s.OpenAPIAsMachine(c, s.ct.Tag(), password, "fake_nonce") s.ctRebootState, err = ctState.Reboot() c.Assert(err, jc.ErrorIsNil) c.Assert(s.ctRebootState, gc.NotNil) lock, err := fslock.NewLock(c.MkDir(), "fake", fslock.Defaults()) c.Assert(err, jc.ErrorIsNil) s.lock = lock }
func (factory *Factory) paramsFillDefaults(c *gc.C, params *MachineParams) *MachineParams { if params == nil { params = &MachineParams{} } if params.Series == "" { params.Series = "quantal" } if params.Nonce == "" { params.Nonce = "nonce" } if len(params.Jobs) == 0 { params.Jobs = []state.MachineJob{state.JobHostUnits} } if params.InstanceId == "" { params.InstanceId = instance.Id(uniqueString("id")) } if params.Password == "" { var err error params.Password, err = utils.RandomPassword() c.Assert(err, jc.ErrorIsNil) } if params.Characteristics == nil { arch := "amd64" mem := uint64(64 * 1024 * 1024 * 1024) hardware := instance.HardwareCharacteristics{ Arch: &arch, Mem: &mem, } params.Characteristics = &hardware } return params }
func (s *rebootSuite) SetUpTest(c *gc.C) { var err error template := state.MachineTemplate{ Series: series.LatestLts(), Jobs: []state.MachineJob{state.JobHostUnits}, } s.JujuConnSuite.SetUpTest(c) s.stateAPI, s.machine = s.OpenAPIAsNewMachine(c) s.rebootState, err = s.stateAPI.Reboot() c.Assert(err, jc.ErrorIsNil) c.Assert(s.rebootState, gc.NotNil) //Add container s.ct, err = s.State.AddMachineInsideMachine(template, s.machine.Id(), instance.KVM) c.Assert(err, jc.ErrorIsNil) password, err := utils.RandomPassword() c.Assert(err, jc.ErrorIsNil) err = s.ct.SetPassword(password) c.Assert(err, jc.ErrorIsNil) err = s.ct.SetProvisioned("foo", "fake_nonce", nil) c.Assert(err, jc.ErrorIsNil) // Open api as container ctState := s.OpenAPIAsMachine(c, s.ct.Tag(), password, "fake_nonce") s.ctRebootState, err = ctState.Reboot() c.Assert(err, jc.ErrorIsNil) c.Assert(s.ctRebootState, gc.NotNil) s.clock = &fakeClock{delay: time.Millisecond} }
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 *provisionerSuite) SetUpTest(c *gc.C) { s.JujuConnSuite.SetUpTest(c) // We're testing with address allocation on by default. There are // separate tests to check the behavior when the flag is not // enabled. s.SetFeatureFlags(feature.AddressAllocation) var err error s.machine, err = s.State.AddMachine("quantal", state.JobManageModel) c.Assert(err, jc.ErrorIsNil) password, err := utils.RandomPassword() c.Assert(err, jc.ErrorIsNil) err = s.machine.SetPassword(password) c.Assert(err, jc.ErrorIsNil) err = s.machine.SetInstanceInfo("i-manager", "fake_nonce", nil, nil, nil, nil, nil) c.Assert(err, jc.ErrorIsNil) s.st = s.OpenAPIAsMachine(c, s.machine.Tag(), password, "fake_nonce") c.Assert(s.st, gc.NotNil) err = s.machine.SetProviderAddresses(network.NewAddress("0.1.2.3")) c.Assert(err, jc.ErrorIsNil) // Create the provisioner API facade. s.provisioner = s.st.Provisioner() c.Assert(s.provisioner, gc.NotNil) s.ModelWatcherTests = apitesting.NewModelWatcherTests(s.provisioner, s.BackingState, apitesting.HasSecrets) s.APIAddresserTests = apitesting.NewAPIAddresserTests(s.provisioner, s.BackingState) }
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().String(), 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 *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().String(), password) s.uniter = s.st.Uniter() c.Assert(s.uniter, gc.NotNil) apiRel, err := s.uniter.Relation(s.rel.Tag().String()) c.Assert(err, gc.IsNil) apiUnit, err := s.uniter.Unit(unit.Tag().(names.UnitTag)) 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 := getAddUserAPI(c) if err != nil { return err } defer client.Close() if c.Password == "" { c.Password, err = utils.RandomPassword() if err != nil { return errors.Annotate(err, "failed to generate password") } } err = client.AddUser(c.User, c.DisplayName, c.Password) if err != nil { return err } user := c.User if c.DisplayName != "" { user = fmt.Sprintf("%s (%s)", c.DisplayName, user) } fmt.Fprintf(ctx.Stdout, "user %q added with password %q\n", user, c.Password) if c.OutPath != "" { outPath := NormaliseJenvPath(ctx, c.OutPath) err = GenerateUserJenv(c.ConnectionName(), c.User, c.Password, outPath) if err == nil { fmt.Fprintf(ctx.Stdout, "environment file written to %s\n", outPath) } } return err }
func (s *HookContextSuite) SetUpTest(c *gc.C) { var err error s.JujuConnSuite.SetUpTest(c) s.BlockHelper = NewBlockHelper(s.APIState) c.Assert(s.BlockHelper, gc.NotNil) s.AddCleanup(func(*gc.C) { s.BlockHelper.Close() }) // reset s.machine = nil sch := s.AddTestingCharm(c, "wordpress") s.service = s.AddTestingService(c, "u", sch) s.unit = s.AddUnit(c, s.service) s.meteredCharm = s.AddTestingCharm(c, "metered") meteredService := s.AddTestingService(c, "m", s.meteredCharm) meteredUnit := s.addUnit(c, meteredService) err = meteredUnit.SetCharmURL(s.meteredCharm.URL()) c.Assert(err, jc.ErrorIsNil) password, err := utils.RandomPassword() err = s.unit.SetPassword(password) c.Assert(err, jc.ErrorIsNil) s.st = s.OpenAPIAs(c, s.unit.Tag(), password) s.uniter, err = s.st.Uniter() c.Assert(err, jc.ErrorIsNil) c.Assert(s.uniter, gc.NotNil) s.apiUnit, err = s.uniter.Unit(s.unit.Tag().(names.UnitTag)) c.Assert(err, jc.ErrorIsNil) err = meteredUnit.SetPassword(password) c.Assert(err, jc.ErrorIsNil) meteredState := s.OpenAPIAs(c, meteredUnit.Tag(), password) meteredUniter, err := meteredState.Uniter() s.meteredApiUnit, err = meteredUniter.Unit(meteredUnit.Tag().(names.UnitTag)) c.Assert(err, jc.ErrorIsNil) // 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, jc.ErrorIsNil) s.relch = s.AddTestingCharm(c, "mysql") s.relunits = map[int]*state.RelationUnit{} s.apiRelunits = map[int]*uniter.RelationUnit{} s.AddContextRelation(c, "db0") s.AddContextRelation(c, "db1") storageData0 := names.NewStorageTag("data/0") s.storage = &runnertesting.StorageContextAccessor{ map[names.StorageTag]*runnertesting.ContextStorage{ storageData0: &runnertesting.ContextStorage{ storageData0, storage.StorageKindBlock, "/dev/sdb", }, }, } }
func (*passwordSuite) TestRandomPassword(c *gc.C) { p, err := utils.RandomPassword() c.Assert(err, gc.IsNil) if len(p) < 18 { c.Errorf("password too short: %q", p) } c.Assert(p, gc.Matches, base64Chars) }
func (s *agentAuthenticatorSuite) SetUpTest(c *gc.C) { s.JujuConnSuite.SetUpTest(c) s.user = s.Factory.MakeUser(c, &factory.UserParams{ Name: "bobbrown", DisplayName: "Bob Brown", Password: "******", }) // add machine for testing machine agent authentication machine, err := s.State.AddMachine("quantal", state.JobHostUnits) c.Assert(err, gc.IsNil) nonce, err := utils.RandomPassword() c.Assert(err, gc.IsNil) err = machine.SetProvisioned("foo", 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) s.machine = machine s.machinePassword = password s.machineNonce = nonce // add a unit for testing unit agent authentication wordpress := s.AddTestingService(c, "wordpress", s.AddTestingCharm(c, "wordpress")) c.Assert(err, gc.IsNil) unit, err := wordpress.AddUnit() c.Assert(err, gc.IsNil) s.unit = unit password, err = utils.RandomPassword() c.Assert(err, gc.IsNil) err = unit.SetPassword(password) c.Assert(err, gc.IsNil) s.unitPassword = password // add relation wordpressEP, err := wordpress.Endpoint("db") c.Assert(err, gc.IsNil) mysql := s.AddTestingService(c, "mysql", s.AddTestingCharm(c, "mysql")) mysqlEP, err := mysql.Endpoint("server") c.Assert(err, gc.IsNil) s.relation, err = s.State.AddRelation(wordpressEP, mysqlEP) c.Assert(err, gc.IsNil) }
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 *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, jc.ErrorIsNil) machine, err := s.State.AddMachine("quantal", state.JobHostUnits) c.Assert(err, jc.ErrorIsNil) err = u.AssignToMachine(machine) c.Assert(err, jc.ErrorIsNil) err = machine.SetProviderAddresses(network.NewScopedAddress("blah", network.ScopeCloudLocal)) c.Assert(err, jc.ErrorIsNil) s.AddTestingService(c, "logging", s.AddTestingCharm(c, "logging")) eps, err := s.State.InferEndpoints("logging", "mysql") c.Assert(err, jc.ErrorIsNil) rel, err := s.State.AddRelation(eps...) c.Assert(err, jc.ErrorIsNil) relsDir := c.MkDir() dir, err := relation.ReadStateDir(relsDir, rel.Id()) c.Assert(err, jc.ErrorIsNil) password, err := utils.RandomPassword() c.Assert(err, jc.ErrorIsNil) err = u.SetPassword(password) c.Assert(err, jc.ErrorIsNil) st := s.OpenAPIAs(c, u.Tag(), password) uniterState, err := st.Uniter() c.Assert(err, jc.ErrorIsNil) c.Assert(uniterState, gc.NotNil) apiUnit, err := uniterState.Unit(u.Tag().(names.UnitTag)) c.Assert(err, jc.ErrorIsNil) apiRel, err := uniterState.Relation(rel.Tag().(names.RelationTag)) c.Assert(err, jc.ErrorIsNil) apiRelUnit, err := apiRel.Unit(apiUnit) c.Assert(err, jc.ErrorIsNil) r := relation.NewRelationer(apiRelUnit, dir) c.Assert(r, jc.Satisfies, (*relation.Relationer).IsImplicit) // Hooks are not allowed. f := func() { r.PrepareHook(hook.Info{}) } c.Assert(f, gc.PanicMatches, "implicit relations must not run hooks") f = func() { r.CommitHook(hook.Info{}) } c.Assert(f, gc.PanicMatches, "implicit relations must not run hooks") // Set it to Dying; check that the dir is removed immediately. err = r.SetDying() c.Assert(err, jc.ErrorIsNil) path := strconv.Itoa(rel.Id()) ft.Removed{path}.Check(c, relsDir) err = rel.Destroy() c.Assert(err, jc.ErrorIsNil) err = rel.Refresh() c.Assert(err, jc.Satisfies, errors.IsNotFound) }
func (s *networkerSuite) TestNoModprobeWhenRunningInLXC(c *gc.C) { c.Skip("enable once the networker is enabled again") // Create a new container. template := state.MachineTemplate{ Series: coretesting.FakeDefaultSeries, Jobs: []state.MachineJob{state.JobHostUnits}, } lxcMachine, err := s.State.AddMachineInsideMachine(template, s.stateMachine.Id(), instance.LXC) c.Assert(err, jc.ErrorIsNil) password, err := utils.RandomPassword() c.Assert(err, jc.ErrorIsNil) err = lxcMachine.SetPassword(password) c.Assert(err, jc.ErrorIsNil) lxcInterfaces := []state.NetworkInterfaceInfo{{ MACAddress: "aa:bb:cc:dd:02:f0", InterfaceName: "eth0.123", NetworkName: "vlan123", IsVirtual: true, Disabled: false, }} s.machineInterfaces = []net.Interface{ {Index: 1, MTU: 65535, Name: "lo", Flags: net.FlagUp | net.FlagLoopback}, {Index: 2, MTU: 1500, Name: "eth0", Flags: net.FlagUp}, } err = lxcMachine.SetInstanceInfo("i-am-lxc", "fake_nonce", nil, s.stateNetworks, lxcInterfaces, nil, nil) c.Assert(err, jc.ErrorIsNil) // Login to the API as the machine agent of lxcMachine. lxcState := s.OpenAPIAsMachine(c, lxcMachine.Tag(), password, "fake_nonce") c.Assert(lxcState, gc.NotNil) lxcFacade := lxcState.Networker() c.Assert(lxcFacade, gc.NotNil) // Create and setup networker for the LXC machine. nw, _ := s.newCustomNetworker(c, lxcFacade, lxcMachine.Id(), true, true) defer worker.Stop(nw) timeout := time.After(coretesting.LongWait) for { select { case cmds := <-s.lastCommands: if !s.upInterfaces.Contains("eth0.123") { c.Fatalf("expected command ifup eth0.123, got %v", cmds) } c.Assert(s.vlanModuleLoaded, jc.IsFalse) c.Assert(nw.IsVLANModuleLoaded(), jc.IsFalse) s.assertHaveConfig(c, nw, "", "eth0.123") s.assertNoConfig(c, nw, "lo", "eth0") return case <-timeout: c.Fatalf("no commands executed!") } } }
func (s *userAuthenticatorSuite) TestMachineLoginFails(c *gc.C) { // add machine for testing machine agent authentication machine, err := s.State.AddMachine("quantal", state.JobHostUnits) c.Assert(err, jc.ErrorIsNil) nonce, err := utils.RandomPassword() c.Assert(err, jc.ErrorIsNil) err = machine.SetProvisioned("foo", nonce, nil) c.Assert(err, jc.ErrorIsNil) password, err := utils.RandomPassword() c.Assert(err, jc.ErrorIsNil) err = machine.SetPassword(password) c.Assert(err, jc.ErrorIsNil) machinePassword := password // attempt machine login authenticator := &authentication.UserAuthenticator{} err = authenticator.Authenticate(machine, machinePassword, nonce) c.Assert(err, gc.ErrorMatches, "invalid request") }
// OpenAPIState opens the API using the given information. The agent's // password is changed if the fallback password was used to connect to // the API. func OpenAPIState(agentConfig agent.Config, a Agent) (_ *api.State, _ *apiagent.Entity, outErr error) { info := agentConfig.APIInfo() st, usedOldPassword, err := openAPIStateUsingInfo(info, a, agentConfig.OldPassword()) if err != nil { return nil, nil, err } defer func() { if outErr != nil && st != nil { st.Close() } }() entity, err := st.Agent().Entity(a.Tag()) if err == nil && entity.Life() == params.Dead { logger.Errorf("agent terminating - entity %q is dead", a.Tag()) return nil, nil, worker.ErrTerminateAgent } if params.IsCodeUnauthorized(err) { logger.Errorf("agent terminating due to error returned during entity lookup: %v", err) return nil, nil, worker.ErrTerminateAgent } if err != nil { return nil, nil, err } if !usedOldPassword { // Call set password with the current password. If we've recently // become a state server, this will fix up our credentials in mongo. if err := entity.SetPassword(info.Password); err != nil { return nil, nil, errors.Annotate(err, "can't reset agent password") } } else { // We succeeded in connecting with the fallback // password, so we need to create a new password // for the future. newPassword, err := utils.RandomPassword() if err != nil { return nil, nil, err } err = setAgentPassword(newPassword, info.Password, a, entity) if err != nil { return nil, nil, err } // Reconnect to the API with the new password. st.Close() info.Password = newPassword st, err = apiOpen(info, api.DialOpts{}) if err != nil { return nil, nil, err } } return st, entity, err }
func generateOrReadPassword(ctx *cmd.Context, generate bool) (string, error) { if generate { password, err := utils.RandomPassword() if err != nil { return "", errors.Annotate(err, "failed to generate random password") } randomPasswordNotify(password) return password, nil } return readAndConfirmPassword(ctx) }
func (s *CommonProvisionerSuite) SetUpTest(c *gc.C) { // Disable the default state policy, because the // provisioner needs to be able to test pathological // scenarios where a machine exists in state with // invalid environment config. dummy.SetStatePolicy(nil) s.JujuConnSuite.SetUpTest(c) // Create the operations channel with more than enough space // for those tests that don't listen on it. op := make(chan dummy.Operation, 500) dummy.Listen(op) s.op = op cfg, err := s.State.EnvironConfig() c.Assert(err, jc.ErrorIsNil) s.cfg = cfg // Create a machine for the dummy bootstrap instance, // so the provisioner doesn't destroy it. insts, err := s.Environ.Instances([]instance.Id{dummy.BootstrapInstanceId}) c.Assert(err, jc.ErrorIsNil) addrs, err := insts[0].Addresses() c.Assert(err, jc.ErrorIsNil) machine, err := s.State.AddOneMachine(state.MachineTemplate{ Addresses: addrs, Series: "quantal", Nonce: agent.BootstrapNonce, InstanceId: dummy.BootstrapInstanceId, Jobs: []state.MachineJob{state.JobManageEnviron}, }) c.Assert(err, jc.ErrorIsNil) c.Assert(machine.Id(), gc.Equals, "0") current := version.Binary{ Number: version.Current, Arch: arch.HostArch(), Series: series.HostSeries(), } err = machine.SetAgentVersion(current) c.Assert(err, jc.ErrorIsNil) password, err := utils.RandomPassword() c.Assert(err, jc.ErrorIsNil) err = machine.SetPassword(password) c.Assert(err, jc.ErrorIsNil) s.st = s.OpenAPIAsMachine(c, machine.Tag(), password, agent.BootstrapNonce) 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) }
func (s *ContextRelationSuite) SetUpTest(c *gc.C) { s.JujuConnSuite.SetUpTest(c) machine, err := s.State.AddMachine("quantal", state.JobHostUnits) c.Assert(err, jc.ErrorIsNil) password, err := utils.RandomPassword() c.Assert(err, jc.ErrorIsNil) err = machine.SetPassword(password) c.Assert(err, jc.ErrorIsNil) err = machine.SetProvisioned("foo", "fake_nonce", nil) c.Assert(err, jc.ErrorIsNil) ch := s.AddTestingCharm(c, "riak") s.svc = s.AddTestingService(c, "u", ch) rels, err := s.svc.Relations() c.Assert(err, jc.ErrorIsNil) c.Assert(rels, gc.HasLen, 1) s.rel = rels[0] unit, err := s.svc.AddUnit() c.Assert(err, jc.ErrorIsNil) err = unit.AssignToMachine(machine) s.ru, err = s.rel.Unit(unit) c.Assert(err, jc.ErrorIsNil) err = s.ru.EnterScope(nil) c.Assert(err, jc.ErrorIsNil) password, err = utils.RandomPassword() c.Assert(err, jc.ErrorIsNil) err = unit.SetPassword(password) c.Assert(err, jc.ErrorIsNil) s.st = s.OpenAPIAs(c, unit.Tag(), password) s.uniter, err = s.st.Uniter() c.Assert(err, jc.ErrorIsNil) c.Assert(s.uniter, gc.NotNil) apiRel, err := s.uniter.Relation(s.rel.Tag().(names.RelationTag)) c.Assert(err, jc.ErrorIsNil) apiUnit, err := s.uniter.Unit(unit.Tag().(names.UnitTag)) c.Assert(err, jc.ErrorIsNil) s.apiRelUnit, err = apiRel.Unit(apiUnit) c.Assert(err, jc.ErrorIsNil) }
func (s *unitSuite) SetUpTest(c *gc.C) { var err error s.JujuConnSuite.SetUpTest(c) svc := s.AddTestingService(c, "wordpress", s.AddTestingCharm(c, "wordpress")) s.unit, err = svc.AddUnit() c.Assert(err, gc.IsNil) password, err := utils.RandomPassword() c.Assert(err, gc.IsNil) err = s.unit.SetPassword(password) s.st = s.OpenAPIAs(c, s.unit.Tag(), password) }