// 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)
}
