def test_returns_nothing_if_no_user(self):
node = factory.make_Node(status=NODE_STATUS.DEPLOYING, osystem='esxi')
for i in ['server', 'username', 'password', 'datacenter']:
key = 'vcenter_%s' % i
Config.objects.set_config(key, factory.make_name(key))
config = get_vendor_data(node, None)
self.assertDictEqual({}, config)
def test_removes_lock_when_ephemeral(self):
node = factory.make_Node(
status=random.choice(COMMISSIONING_LIKE_STATUSES)
)
configuration = get_vendor_data(node, None)
config = dict(configuration)
self.assertThat(config["runcmd"], Contains("rm -rf /run/netplan"))
def test_includes_smt_off_for_install_kvm_on_ppc64(self):
node = factory.make_Node(
status=NODE_STATUS.DEPLOYING,
osystem="ubuntu",
netboot=False,
architecture="ppc64el/generic",
)
node.install_kvm = True
configuration = get_vendor_data(node, None)
config = dict(configuration)
self.assertThat(
config["runcmd"],
Contains([
"sh",
"-c",
'printf "'
"#!/bin/sh\\n"
"ppc64_cpu --smt=off\\n"
"exit 0\\n"
'" >> /etc/rc.local',
]),
)
self.assertThat(config["runcmd"],
Contains(["chmod", "+x", "/etc/rc.local"]))
self.assertThat(config["runcmd"], Contains(["/etc/rc.local"]))
def test_does_nothing_if_not_vmware(self):
mock_get_configs = self.patch(Config.objects, "get_configs")
node = factory.make_Node(status=NODE_STATUS.DEPLOYING,
owner=factory.make_admin())
config = get_vendor_data(node, None)
self.assertThat(mock_get_configs, MockNotCalled())
self.assertDictEqual({}, config)
def test_returns_vcenter_yaml_if_rbac_admin(self):
rbac = self.useFixture(RBACEnabled())
node = factory.make_Node(
status=NODE_STATUS.DEPLOYING,
osystem="esxi",
owner=factory.make_User(),
)
node.nodemetadata_set.create(key="vcenter_registration", value="True")
rbac.store.add_pool(node.pool)
rbac.store.allow(node.owner.username, node.pool, "admin-machines")
vcenter = {
"vcenter_server": factory.make_name("vcenter_server"),
"vcenter_username": factory.make_name("vcenter_username"),
"vcenter_password": factory.make_name("vcenter_password"),
"vcenter_datacenter": factory.make_name("vcenter_datacenter"),
}
for key, value in vcenter.items():
Config.objects.set_config(key, value)
config = get_vendor_data(node, None)
self.assertDictEqual(
{
"write_files": [{
"content": yaml.safe_dump(vcenter),
"path": "/altbootbank/maas/vcenter.yaml",
}]
},
config,
)
def test_returns_vcenter_yaml(self):
node = factory.make_Node(
status=NODE_STATUS.DEPLOYING,
osystem="esxi",
owner=factory.make_admin(),
)
node.nodemetadata_set.create(key="vcenter_registration", value="True")
vcenter = {
"vcenter_server": factory.make_name("vcenter_server"),
"vcenter_username": factory.make_name("vcenter_username"),
"vcenter_password": factory.make_name("vcenter_password"),
"vcenter_datacenter": factory.make_name("vcenter_datacenter"),
}
for key, value in vcenter.items():
Config.objects.set_config(key, value)
config = get_vendor_data(node, None)
self.assertDictEqual(
{
"write_files": [{
"content": yaml.safe_dump(vcenter),
"path": "/altbootbank/maas/vcenter.yaml",
}]
},
config,
)
def test_returns_nothing_if_no_user(self):
node = factory.make_Node(status=NODE_STATUS.DEPLOYING, osystem="esxi")
for i in ["server", "username", "password", "datacenter"]:
key = "vcenter_%s" % i
Config.objects.set_config(key, factory.make_name(key))
config = get_vendor_data(node, None)
self.assertDictEqual({}, config)
def test_returns_nothing_if_no_values_set(self):
node = factory.make_Node(
status=NODE_STATUS.DEPLOYING, osystem='esxi',
owner=factory.make_admin())
node.nodemetadata_set.create(key='vcenter_registration', value='True')
config = get_vendor_data(node, None)
self.assertDictEqual({}, config)
def test_includes_qemu_efi_for_install_kvm_on_arm64(self):
node = factory.make_Node(
osystem='ubuntu', netboot=False, architecture='arm64/generic')
node.install_kvm = True
configuration = get_vendor_data(node, None)
config = dict(configuration)
self.assertThat(config['packages'], Contains("qemu-efi"))
def test__does_nothing_if_deploying(self):
# MAAS transitions a machine from DEPLOYING to DEPLOYED after
# user_data has been requested. Make sure deploying nodes don't
# get this config.
node = factory.make_Node(status=NODE_STATUS.DEPLOYING)
configuration = get_vendor_data(node, None)
config = dict(configuration)
self.assertNotIn("runcmd", config)
def vendor_data(self, node, version, item):
vendor_data = {"cloud-init": "#cloud-config\n%s" % yaml.safe_dump(
get_vendor_data(node)
)}
vendor_data_dump = yaml.safe_dump(
vendor_data, encoding="utf-8", default_flow_style=False)
# Use the same Content-Type as Piston 3 for YAML content.
return HttpResponse(
vendor_data_dump, content_type="application/x-yaml; charset=utf-8")
def test_returns_nothing_if_no_values_set(self):
node = factory.make_Node(
status=NODE_STATUS.DEPLOYING,
osystem="esxi",
owner=factory.make_admin(),
)
node.nodemetadata_set.create(key="vcenter_registration", value="True")
config = get_vendor_data(node, None)
self.assertNotIn(config, "write_files")
def test_includes_system_information_if_default_user(self):
owner = factory.make_User()
node = factory.make_Node(owner=owner, default_user=owner)
vendor_data = get_vendor_data(node)
self.assertThat(vendor_data, ContainsDict({
"system_info": MatchesDict({
"default_user": KeysEqual("name", "gecos"),
}),
}))
def test_yields_configuration_when_node_is_ephemeral_deployment(self):
node = factory.make_Node(with_boot_disk=False)
configuration = get_vendor_data(node, None)
config = dict(configuration)
self.assertThat(
config['write_files'][0]['path'],
Contains("/etc/netplan/50-maas.yaml"))
# Make sure netplan's lock is removed before applying the config
self.assertEquals(config['runcmd'][0], 'rm -rf /run/netplan')
self.assertEquals(config['runcmd'][1], 'netplan apply --debug')
def test_returns_nothing_if_vcenter_registration_not_set(self):
node = factory.make_Node(
status=NODE_STATUS.DEPLOYING,
osystem="esxi",
owner=factory.make_admin(),
)
for i in ["server", "username", "password", "datacenter"]:
key = "vcenter_%s" % i
Config.objects.set_config(key, factory.make_name(key))
config = get_vendor_data(node, None)
self.assertNotIn(config, "write_files")
def test_includes_ntp_server_information(self):
Config.objects.set_config("ntp_external_only", True)
Config.objects.set_config("ntp_servers", "foo bar")
node = factory.make_Node()
vendor_data = get_vendor_data(node, None)
self.assertThat(
vendor_data,
ContainsDict(
{"ntp": Equals({"servers": [], "pools": ["bar", "foo"]})}
),
)
def test_yields_configuration_when_node_is_ephemeral_deployment(self):
node = factory.make_Node(
with_boot_disk=False,
ephemeral_deploy=True,
status=NODE_STATUS.DEPLOYING,
)
configuration = get_vendor_data(node, None)
config = dict(configuration)
self.assertThat(
config["write_files"][0]["path"],
Contains("/etc/netplan/50-maas.yaml"),
)
# Make sure netplan's lock is removed before applying the config
self.assertEquals(config["runcmd"][0], "rm -rf /run/netplan")
self.assertEquals(config["runcmd"][1], "netplan apply --debug")
def test_yields_configuration_when_machine_install_kvm_true(self):
node = factory.make_Node(osystem='ubuntu', netboot=False)
node.install_kvm = True
configuration = get_vendor_data(node)
config = str(dict(configuration))
self.assertThat(config, Contains("virsh"))
self.assertThat(config, Contains("ssh_pwauth"))
self.assertThat(config, Contains("rbash"))
self.assertThat(config, Contains("libvirt-qemu"))
self.assertThat(config, Contains("ForceCommand"))
self.assertThat(config, Contains("qemu-kvm"))
self.assertThat(config, Contains("libvirt-bin"))
# Check that a password was saved for the pod-to-be.
virsh_password_meta = NodeMetadata.objects.filter(
node=node, key="virsh_password").first()
self.assertThat(virsh_password_meta.value, HasLength(32))
def test_yields_configuration_when_machine_install_kvm_true(self):
node = factory.make_Node(status=NODE_STATUS.DEPLOYING,
osystem="ubuntu",
netboot=False)
node.install_kvm = True
configuration = get_vendor_data(node, None)
config = str(dict(configuration))
self.assertThat(config, Contains("virsh"))
self.assertThat(config, Contains("ssh_pwauth"))
self.assertThat(config, Contains("rbash"))
self.assertThat(config, Contains("libvirt-daemon-system"))
self.assertThat(config, Contains("ForceCommand"))
self.assertThat(config, Contains("libvirt-clients"))
# Check that a password was saved for the pod-to-be.
virsh_password_meta = NodeMetadata.objects.filter(
node=node, key="virsh_password").first()
self.assertThat(virsh_password_meta.value, HasLength(32))
def test_combines_key_values(self):
controller = factory.make_RackController()
ControllerInfo.objects.set_version(controller, "3.0.0-123-g.abc")
secret = factory.make_string()
Config.objects.set_config("rpc_shared_secret", secret)
node = factory.make_Node(
netboot=False, install_rackd=True, osystem="ubuntu"
)
config = get_vendor_data(node, None)
self.assertEqual(
config["runcmd"],
[
"snap install maas --channel=3.0/stable",
f"/snap/bin/maas init rack --maas-url http://localhost:5240/MAAS --secret {secret}",
"rm -rf /run/netplan",
],
)
def test_returns_nothing_if_rbac_user(self):
rbac = self.useFixture(RBACEnabled())
node = factory.make_Node(
status=NODE_STATUS.DEPLOYING, osystem='esxi',
owner=factory.make_User())
node.nodemetadata_set.create(key='vcenter_registration', value='True')
rbac.store.add_pool(node.pool)
rbac.store.allow(node.owner.username, node.pool, 'deploy-machines')
vcenter = {
'vcenter_server': factory.make_name('vcenter_server'),
'vcenter_username': factory.make_name('vcenter_username'),
'vcenter_password': factory.make_name('vcenter_password'),
'vcenter_datacenter': factory.make_name('vcenter_datacenter'),
}
for key, value in vcenter.items():
Config.objects.set_config(key, value)
config = get_vendor_data(node, None)
self.assertDictEqual({}, config)
def test_includes_smt_off_for_install_kvm_on_ppc64(self):
node = factory.make_Node(
status=NODE_STATUS.DEPLOYING, osystem='ubuntu', netboot=False,
architecture='ppc64el/generic')
node.install_kvm = True
configuration = get_vendor_data(node, None)
config = dict(configuration)
self.assertThat(
config['runcmd'], Contains([
'sh', '-c', 'printf "'
'#!/bin/sh\\n'
'ppc64_cpu --smt=off\\n'
'exit 0\\n'
'" >> /etc/rc.local'
]))
self.assertThat(
config['runcmd'], Contains(['chmod', '+x', '/etc/rc.local']))
self.assertThat(config['runcmd'], Contains(['/etc/rc.local']))
def test_returns_vcenter_yaml(self):
node = factory.make_Node(
status=NODE_STATUS.DEPLOYING, osystem='esxi',
owner=factory.make_admin())
node.nodemetadata_set.create(key='vcenter_registration', value='True')
vcenter = {
'vcenter_server': factory.make_name('vcenter_server'),
'vcenter_username': factory.make_name('vcenter_username'),
'vcenter_password': factory.make_name('vcenter_password'),
'vcenter_datacenter': factory.make_name('vcenter_datacenter'),
}
for key, value in vcenter.items():
Config.objects.set_config(key, value)
config = get_vendor_data(node, None)
self.assertDictEqual(
{'write_files': [{
'content': yaml.safe_dump(vcenter),
'path': '/altbootbank/maas/vcenter.yaml',
}]}, config)
def test_returns_nothing_if_rbac_user(self):
rbac = self.useFixture(RBACEnabled())
node = factory.make_Node(
status=NODE_STATUS.DEPLOYING,
osystem="esxi",
owner=factory.make_User(),
)
node.nodemetadata_set.create(key="vcenter_registration", value="True")
rbac.store.add_pool(node.pool)
rbac.store.allow(node.owner.username, node.pool, "deploy-machines")
vcenter = {
"vcenter_datacenter": factory.make_name("vcenter_datacenter"),
"vcenter_password": factory.make_name("vcenter_password"),
"vcenter_server": factory.make_name("vcenter_server"),
"vcenter_username": factory.make_name("vcenter_username"),
}
for key, value in vcenter.items():
Config.objects.set_config(key, value)
config = get_vendor_data(node, None)
self.assertNotIn(config, "write_files")
def test_returns_vcenter_yaml_if_rbac_admin(self):
rbac = self.useFixture(RBACEnabled())
node = factory.make_Node(
status=NODE_STATUS.DEPLOYING, osystem='esxi',
owner=factory.make_User())
node.nodemetadata_set.create(key='vcenter_registration', value='True')
rbac.store.add_pool(node.pool)
rbac.store.allow(node.owner.username, node.pool, 'admin-machines')
vcenter = {
'vcenter_server': factory.make_name('vcenter_server'),
'vcenter_username': factory.make_name('vcenter_username'),
'vcenter_password': factory.make_name('vcenter_password'),
'vcenter_datacenter': factory.make_name('vcenter_datacenter'),
}
for key, value in vcenter.items():
Config.objects.set_config(key, value)
config = get_vendor_data(node, None)
self.assertDictEqual(
{'write_files': [{
'content': yaml.safe_dump(vcenter),
'path': '/altbootbank/maas/vcenter.yaml',
}]}, config)
def test_includes_no_system_information_if_no_default_user(self):
node = factory.make_Node(owner=factory.make_User())
vendor_data = get_vendor_data(node)
self.assertThat(vendor_data, Not(Contains('system_info')))
def test_returns_dict(self):
node = factory.make_Node()
self.assertThat(get_vendor_data(node), IsInstance(dict))
