~juju-qa/ubuntu/xenial/juju/2.0-rc2

func (suite *maas2EnvironSuite) injectControllerWithSpacesAndCheck(c *gc.C, spaces []gomaasapi.Space, expected gomaasapi.AllocateMachineArgs) *maasEnviron {

func (suite *maas2EnvironSuite) injectControllerWithSpacesAndCheck(c *gc.C, spaces []gomaasapi.Space, expected gomaasapi.AllocateMachineArgs) (*maasEnviron, *fakeController) {

var env *maasEnviron

check := func(args gomaasapi.AllocateMachineArgs) {

expected.AgentName = env.Config().UUID()

suite.injectController(controller)

suite.setupFakeTools(c)

env = suite.makeEnviron(c, nil)

return env

return env, controller

}

func (suite *maas2EnvironSuite) makeEnvironWithMachines(c *gc.C, expectedSystemIDs []string, returnSystemIDs []string) *maasEnviron {

309

308

}

310

309

311

310

func (suite *maas2EnvironSuite) TestStartInstance(c *gc.C) {

312

env := suite.injectControllerWithSpacesAndCheck(c, nil, gomaasapi.AllocateMachineArgs{})

311

env, _ := suite.injectControllerWithSpacesAndCheck(c, nil, gomaasapi.AllocateMachineArgs{})

313

312

314

313

params := environs.StartInstanceParams{ControllerUUID: suite.controllerUUID}

315

314

result, err := jujutesting.StartInstanceWithParams(env, "1", params)

317

316

c.Assert(result.Instance.Id(), gc.Equals, instance.Id("Bruce Sterling"))

318

317

}

319

318

319

func (suite *maas2EnvironSuite) TestStartInstanceAppliesResourceTags(c *gc.C) {

320

env, controller := suite.injectControllerWithSpacesAndCheck(c, nil, gomaasapi.AllocateMachineArgs{})

321

config := env.Config()

322

_, ok := config.ResourceTags()

323

c.Assert(ok, jc.IsTrue)

324

params := environs.StartInstanceParams{ControllerUUID: suite.controllerUUID}

325

_, err := jujutesting.StartInstanceWithParams(env, "1", params)

326

c.Assert(err, jc.ErrorIsNil)

327

328

machine := controller.allocateMachine.(*fakeMachine)

329

machine.CheckCallNames(c, "Start", "SetOwnerData")

330

c.Assert(machine.Calls()[1].Args[0], gc.DeepEquals, map[string]string{

331

"claude": "rains",

332

tags.JujuController: suite.controllerUUID,

333

tags.JujuModel: config.UUID(),

334

})

335

}

336

320

337

func (suite *maas2EnvironSuite) TestStartInstanceParams(c *gc.C) {

321

338

var env *maasEnviron

322

339

suite.injectController(&fakeController{

371

388

Tags: []string{"tag1", "tag3"},

372

389

NotTags: []string{"tag2", "tag4"},

373

390

}

374

env = suite.injectControllerWithSpacesAndCheck(c, nil, expected)

391

env, _ = suite.injectControllerWithSpacesAndCheck(c, nil, expected)

375

392

_, err := env.acquireNode2(

376

393

"", "",

377

394

constraints.Value{Tags: stringslicep("tag1", "^tag2", "tag3", "^tag4")},

403

420

id: 8,

404

421

405

422

}

406

407

423

}

408

424

409

425

func (suite *maas2EnvironSuite) TestAcquireNodePassesPositiveAndNegativeSpaces(c *gc.C) {

414

430

{Label: "1", Space: "7"},

415

431

416

432

}

417

env := suite.injectControllerWithSpacesAndCheck(c, getFourSpaces(), expected)

433

env, _ := suite.injectControllerWithSpacesAndCheck(c, getFourSpaces(), expected)

418

434

419

435

_, err := env.acquireNode2(

420

436

"", "",

425

441

}

426

442

427

443

func (suite *maas2EnvironSuite) TestAcquireNodeDisambiguatesNamedLabelsFromIndexedUpToALimit(c *gc.C) {

428

env := suite.injectControllerWithSpacesAndCheck(c, getFourSpaces(), gomaasapi.AllocateMachineArgs{})

444

env, _ := suite.injectControllerWithSpacesAndCheck(c, getFourSpaces(), gomaasapi.AllocateMachineArgs{})

429

445

var shortLimit uint = 0

430

446

suite.PatchValue(&numericLabelLimit, shortLimit)

431

447

624

640

NotSpace: []string{"3"},

625

641

Interfaces: []gomaasapi.InterfaceSpec{{Label: "0", Space: "2"}},

626

642

}

627

env := suite.injectControllerWithSpacesAndCheck(c, getTwoSpaces(), expected)

643

env, _ := suite.injectControllerWithSpacesAndCheck(c, getTwoSpaces(), expected)

628

644

cons := constraints.Value{

629

645

Spaces: stringslicep("foo", "^bar"),

630

646

}

637

653

NotSpace: []string{"3"},

638

654

Interfaces: []gomaasapi.InterfaceSpec{{Label: "0", Space: "2"}},

639

655

}

640

env := suite.injectControllerWithSpacesAndCheck(c, getTwoSpaces(), expected)

656

env, _ := suite.injectControllerWithSpacesAndCheck(c, getTwoSpaces(), expected)

641

657

cons := constraints.Value{

642

658

Spaces: stringslicep("foo-1", "^bar-3"),

643

659

}

1253

1269

suite.assertAllocateContainerAddressesFails(c, controller, nil, "cannot find primary interface for container")

1254

1270

}

1255

1271

1256

func (suite *maas2EnvironSuite) TestAllocateContainerAddressesPrimaryInterfaceSubnetMissing(c *gc.C) {

1257

controller := &fakeController{}

1258

prepared := []network.InterfaceInfo{{InterfaceName: "eth0"}}

1259

errorMatches := "primary NIC subnet not found"

1260

suite.assertAllocateContainerAddressesFails(c, controller, prepared, errorMatches)

1261

}

1262

1263

1272

func makeFakeSubnet(id int) fakeSubnet {

1264

1273

return fakeSubnet{

1265

1274

id: id,

1344

1353

c.Assert(maasArgs, jc.DeepEquals, expected)

1345

1354

}

1346

1355

1347

func (suite *maas2EnvironSuite) TestAllocateContainerAddressesSecondNICSubnetMissing(c *gc.C) {

1356

func (suite *maas2EnvironSuite) TestAllocateContainerAddressesSubnetMissing(c *gc.C) {

1348

1357

subnet := makeFakeSubnet(3)

1349

1358

var env *maasEnviron

1350

1359

device := &fakeDevice{

1351

interfaceSet: []gomaasapi.Interface{&fakeInterface{}},

1352

systemID: "foo",

1360

Stub: &testing.Stub{},

1361

interfaceSet: []gomaasapi.Interface{

1362

&fakeInterface{

1363

id: 93,

1364

1365

type_: "physical",

1366

enabled: true,

1367

macAddress: "53:54:00:70:9b:ff",

1368

vlan: &fakeVLAN{vid: 0},

1369

links: []gomaasapi.Link{

1370

&fakeLink{

1371

id: 480,

1372

mode: "link_up",

1373

1374

1375

parents: []string{},

1376

children: []string{},

1377

Stub: &testing.Stub{},

1378

1379

1380

interface_: &fakeInterface{

1381

id: 94,

1382

1383

type_: "physical",

1384

enabled: true,

1385

macAddress: "53:54:00:70:9b:f1",

1386

vlan: &fakeVLAN{vid: 0},

1387

links: []gomaasapi.Link{

1388

&fakeLink{

1389

id: 481,

1390

mode: "link_up",

1391

1392

1393

parents: []string{},

1394

children: []string{},

1395

Stub: &testing.Stub{},

1396

1397

systemID: "foo",

1353

1398

}

1354

1399

machine := &fakeMachine{

1355

1400

Stub: &testing.Stub{},

1357

1402

createDevice: device,

1358

1403

}

1359

1404

controller := &fakeController{

1405

Stub: &testing.Stub{},

1360

1406

machines: []gomaasapi.Machine{machine},

1361

1407

spaces: []gomaasapi.Space{

1362

1408

fakeSpace{

1365

1411

subnets: []gomaasapi.Subnet{subnet},

1366

1412

1367

1413

1414

devices: []gomaasapi.Device{device},

1368

1415

}

1369

1416

suite.injectController(controller)

1370

1417

env = suite.makeEnviron(c, nil)

1371

1418

prepared := []network.InterfaceInfo{

1372

{InterfaceName: "eth0", CIDR: "10.20.19.0/24", MACAddress: "DEADBEEF"},

1373

{InterfaceName: "eth1", CIDR: "10.20.20.0/24", MACAddress: "DEADBEEE"},

1419

{InterfaceName: "eth0", CIDR: "", MACAddress: "DEADBEEF"},

1420

{InterfaceName: "eth1", CIDR: "", MACAddress: "DEADBEEE"},

1374

1421

}

1375

1422

ignored := names.NewMachineTag("1/lxd/0")

1376

_, err := env.AllocateContainerAddresses(instance.Id("1"), ignored, prepared)

1377

c.Assert(err, gc.ErrorMatches, "NIC eth1 subnet 10.20.20.0/24 not found")

1423

allocated, err := env.AllocateContainerAddresses(instance.Id("1"), ignored, prepared)

1424

c.Assert(err, jc.ErrorIsNil)

1425

c.Assert(allocated, jc.DeepEquals, []network.InterfaceInfo{{

1426

MACAddress: "53:54:00:70:9b:ff",

1427

ProviderId: "93",

1428

ProviderVLANId: "0",

1429

VLANTag: 0,

1430

InterfaceName: "eth0",

1431

InterfaceType: "ethernet",

1432

Disabled: false,

1433

NoAutoStart: false,

1434

ConfigType: "manual",

1435

MTU: 1500,

1436

}, {

1437

MACAddress: "53:54:00:70:9b:f1",

1438

ProviderId: "94",

1439

ProviderVLANId: "0",

1440

VLANTag: 0,

1441

InterfaceName: "eth1",

1442

InterfaceType: "ethernet",

1443

Disabled: false,

1444

NoAutoStart: false,

1445

ConfigType: "manual",

1446

MTU: 1500,

1447

}})

1378

1448

}

1379

1449

1380

1450

func (suite *maas2EnvironSuite) TestAllocateContainerAddressesCreateInterfaceError(c *gc.C) {

1442

1512

createDevice: device,

1443

1513

}

1444

1514

controller := &fakeController{

1515

Stub: &testing.Stub{},

1445

1516

machines: []gomaasapi.Machine{machine},

1446

1517

spaces: []gomaasapi.Space{

1447

1518

fakeSpace{

1450

1521

subnets: []gomaasapi.Subnet{subnet, subnet2},

1451

1522

1452

1523

1524

devices: []gomaasapi.Device{device},

1453

1525

}

1454

1526

suite.injectController(controller)

1455

1527

env = suite.makeEnviron(c, nil)

1458

1530

{InterfaceName: "eth1", CIDR: "10.20.20.0/24", MACAddress: "DEADBEEE"},

1459

1531

}

1460

1532

ignored := names.NewMachineTag("1/lxd/0")

1461

_, err := env.AllocateContainerAddresses(instance.Id("1"), ignored, prepared)

1462

c.Assert(err, gc.ErrorMatches, "cannot link device interface to subnet: boom")

1533

allocated, err := env.AllocateContainerAddresses(instance.Id("1"), ignored, prepared)

1534

c.Assert(err, jc.ErrorIsNil)

1535

c.Assert(allocated, jc.DeepEquals, []network.InterfaceInfo{{

1536

CIDR: "",

1537

ProviderId: "0",

1538

ProviderSubnetId: "",

1539

ProviderVLANId: "0",

1540

VLANTag: 0,

1541

InterfaceName: "",

1542

InterfaceType: "ethernet",

1543

ConfigType: "",

1544

MTU: 1500,

1545

Disabled: true,

1546

NoAutoStart: true,

1547

}, {

1548

CIDR: "",

1549

ProviderId: "0",

1550

ProviderSubnetId: "",

1551

ProviderVLANId: "0",

1552

VLANTag: 0,

1553

InterfaceName: "",

1554

InterfaceType: "ethernet",

1555

ConfigType: "",

1556

MTU: 1500,

1557

Disabled: true,

1558

NoAutoStart: true,

1559

}})

1560

1463

1561

args := getArgs(c, interface_.Calls())

1464

1562

maasArgs, ok := args.(gomaasapi.LinkSubnetArgs)

1465

1563

c.Assert(ok, jc.IsTrue)

1502

1600

})

1503

1601

c.Assert(err, jc.ErrorIsNil)

1504

1602

1505

machine.Stub.CheckCallNames(c, "Start")

1506

controller.Stub.CheckCallNames(c, "GetFile", "AddFile")

1507

addFileArgs, ok := controller.Stub.Calls()[1].Args[0].(gomaasapi.AddFileArgs)

1603

machine.Stub.CheckCallNames(c, "Start", "SetOwnerData")

1604

ownerData, ok := machine.Stub.Calls()[1].Args[0].(map[string]string)

1508

1605

c.Assert(ok, jc.IsTrue)

1509

1510

// Make it look like the right state was written to the file.

1511

buffer := new(bytes.Buffer)

1512

buffer.ReadFrom(addFileArgs.Reader)

1513

file.contents = buffer.Bytes()

1514

c.Check(string(buffer.Bytes()), gc.Equals, "state-instances:\n- gus\n")

1606

c.Assert(ownerData, gc.DeepEquals, map[string]string{

1607

"claude": "rains",

1608

tags.JujuController: suite.controllerUUID,

1609

tags.JujuIsController: "true",

1610

tags.JujuModel: env.Config().UUID(),

1611

})

1515

1612

1516

1613

// Test the instance id is correctly recorded for the bootstrap node.

1517

1614

// Check that ControllerInstances returns the id of the bootstrap machine.

1533

1630

instance, hc := jujutesting.AssertStartInstance(c, env, suite.controllerUUID, "1")

1534

1631

c.Check(instance, gc.NotNil)

1535

1632

c.Assert(hc, gc.NotNil)

1536

c.Check(hc.String(), gc.Equals, fmt.Sprintf("arch=%s cpu-cores=1 mem=1024M availability-zone=test_zone", arch.HostArch()))

1633

c.Check(hc.String(), gc.Equals, fmt.Sprintf("arch=%s cores=1 mem=1024M availability-zone=test_zone", arch.HostArch()))

1537

1634

1538

node1.Stub.CheckCallNames(c, "Start")

1635

node1.Stub.CheckCallNames(c, "Start", "SetOwnerData")

1539

1636

startArgs, ok := node1.Stub.Calls()[0].Args[0].(gomaasapi.StartArgs)

1540

1637

c.Assert(ok, jc.IsTrue)

1541

1638

1563

1660

_, err := env.ControllerInstances(suite.controllerUUID)

1564

1661

c.Assert(err, gc.Equals, environs.ErrNotBootstrapped)

1565

1662

1566

tests := [][]instance.Id{{}, {"inst-0"}, {"inst-0", "inst-1"}}

1663

controller.machinesArgsCheck = func(args gomaasapi.MachinesArgs) {

1664

c.Assert(args, gc.DeepEquals, gomaasapi.MachinesArgs{

1665

OwnerData: map[string]string{

1666

tags.JujuIsController: "true",

1667

tags.JujuController: suite.controllerUUID,

1668

1669

})

1670

}

1671

1672

tests := [][]instance.Id{{"inst-0"}, {"inst-0", "inst-1"}}

1567

1673

for _, expected := range tests {

1568

state, err := goyaml.Marshal(&common.BootstrapState{StateInstances: expected})

1569

c.Assert(err, jc.ErrorIsNil)

1570

1571

controller.files = []gomaasapi.File{&fakeFile{

1572

1573

contents: state,

1574

}}

1674

controller.machines = make([]gomaasapi.Machine, len(expected))

1675

for i := range expected {

1676

controller.machines[i] = newFakeMachine(string(expected[i]), "", "")

1677

}

1575

1678

controllerInstances, err := env.ControllerInstances(suite.controllerUUID)

1576

1679

c.Assert(err, jc.ErrorIsNil)

1577

1680

c.Assert(controllerInstances, jc.SameContents, expected)

1578

1681

}

1579

1682

}

1580

1683

1581

func (suite *maas2EnvironSuite) TestControllerInstancesFailsIfNoStateInstances(c *gc.C) {

1582

env := suite.makeEnviron(c,

1583

newFakeControllerWithErrors(gomaasapi.NewNoMatchError("state")))

1584

_, err := env.ControllerInstances(suite.controllerUUID)

1585

c.Check(err, gc.Equals, environs.ErrNotBootstrapped)

1586

}

1587

1588

1684

func (suite *maas2EnvironSuite) TestDestroy(c *gc.C) {

1589

1685

file1 := &fakeFile{name: coretesting.ModelTag.Id() + "-provider-state"}

1590

1686

file2 := &fakeFile{name: coretesting.ModelTag.Id() + "-horace"}

Older »