def test_register_all_nodes_kernel_ramdisk(self):
node_list = [self._get_node()]
node_properties = {
"cpus": "1",
"memory_mb": "2048",
"local_gb": "30",
"cpu_arch": "amd64",
"capabilities": "num_nics:6"
}
ironic = mock.MagicMock()
glance = mock.MagicMock()
image = collections.namedtuple('image', ['id'])
glance.images.find.side_effect = (image('kernel-123'),
image('ramdisk-999'))
nodes.register_all_nodes(node_list,
client=ironic,
glance_client=glance,
kernel_name='bm-kernel',
ramdisk_name='bm-ramdisk')
pxe_node_driver_info = {
"ssh_address": "foo.bar",
"ssh_username": "******",
"ssh_key_contents": "random",
"ssh_virt_type": "virsh",
"deploy_kernel": "kernel-123",
"deploy_ramdisk": "ramdisk-999"
}
pxe_node = mock.call(driver="pxe_ssh",
name='node1',
driver_info=pxe_node_driver_info,
properties=node_properties)
port_call = mock.call(node_uuid=ironic.node.create.return_value.uuid,
address='aaa')
ironic.node.create.assert_has_calls([pxe_node, mock.ANY])
ironic.port.create.assert_has_calls([port_call])
def test_register_all_nodes_kernel_ramdisk(self):
node_list = [self._get_node()]
node_properties = {"cpus": "1",
"memory_mb": "2048",
"local_gb": "30",
"cpu_arch": "amd64",
"capabilities": "num_nics:6"}
ironic = mock.MagicMock()
glance = mock.MagicMock()
image = collections.namedtuple('image', ['id'])
glance.images.find.side_effect = (image('kernel-123'),
image('ramdisk-999'))
nodes.register_all_nodes(node_list, client=ironic,
glance_client=glance, kernel_name='bm-kernel',
ramdisk_name='bm-ramdisk')
pxe_node_driver_info = {"ipmi_address": "foo.bar",
"ipmi_username": "******",
"ipmi_password": "******",
"deploy_kernel": "kernel-123",
"deploy_ramdisk": "ramdisk-999"}
pxe_node = mock.call(driver="ipmi",
name='node1',
driver_info=pxe_node_driver_info,
properties=node_properties)
port_call = mock.call(node_uuid=ironic.node.create.return_value.uuid,
address='aaa')
ironic.node.create.assert_has_calls([pxe_node, mock.ANY])
ironic.port.create.assert_has_calls([port_call])
def test_register_all_nodes_caps_dict(self):
node_list = [self._get_node()]
node_list[0]['capabilities'] = {'num_nics': 7}
node_properties = {
"cpus": "1",
"memory_mb": "2048",
"local_gb": "30",
"cpu_arch": "amd64",
"capabilities": "num_nics:7"
}
ironic = mock.MagicMock()
nodes.register_all_nodes('servicehost', node_list, client=ironic)
pxe_node_driver_info = {
"ssh_address": "foo.bar",
"ssh_username": "******",
"ssh_key_contents": "random",
"ssh_virt_type": "virsh"
}
pxe_node = mock.call(driver="pxe_ssh",
name='node1',
driver_info=pxe_node_driver_info,
properties=node_properties)
port_call = mock.call(node_uuid=ironic.node.create.return_value.uuid,
address='aaa')
power_off_call = mock.call(ironic.node.create.return_value.uuid, 'off')
ironic.node.create.assert_has_calls([pxe_node, mock.ANY])
ironic.port.create.assert_has_calls([port_call])
ironic.node.set_power_state.assert_has_calls([power_off_call])
def test_register_all_nodes_caps_dict(self):
node_list = [self._get_node()]
node_list[0]['capabilities'] = {'num_nics': 7}
node_properties = {
"cpus": "1",
"memory_mb": "2048",
"local_gb": "30",
"cpu_arch": "amd64",
"capabilities": "num_nics:7"
}
ironic = mock.MagicMock()
nodes.register_all_nodes(node_list, client=ironic)
pxe_node_driver_info = {
"ipmi_address": "foo.bar",
"ipmi_username": "******",
"ipmi_password": "******"
}
pxe_node = mock.call(driver="ipmi",
name='node1',
driver_info=pxe_node_driver_info,
resource_class='baremetal',
properties=node_properties)
port_call = mock.call(node_uuid=ironic.node.create.return_value.uuid,
address='aaa')
ironic.node.create.assert_has_calls([pxe_node, mock.ANY])
ironic.port.create.assert_has_calls([port_call])
def test_register_all_nodes_with_interfaces(self):
interfaces = {'boot_interface': 'pxe',
'console_interface': 'ipmitool-socat',
'deploy_interface': 'direct',
'inspect_interface': 'inspector',
'management_interface': 'ipmitool',
'network_interface': 'neutron',
'power_interface': 'ipmitool',
'raid_interface': 'agent',
'storage_interface': 'cinder',
'vendor_interface': 'ipmitool'}
node_list = [self._get_node()]
node_list[0].update(interfaces)
node_properties = {"cpus": "1",
"memory_mb": "2048",
"local_gb": "30",
"cpu_arch": "amd64",
"capabilities": "num_nics:6"}
ironic = mock.MagicMock()
nodes.register_all_nodes(node_list, client=ironic)
pxe_node_driver_info = {"ipmi_address": "foo.bar",
"ipmi_username": "******",
"ipmi_password": "******"}
pxe_node = mock.call(driver="ipmi",
name='node1',
driver_info=pxe_node_driver_info,
properties=node_properties,
resource_class='baremetal',
**interfaces)
port_call = mock.call(node_uuid=ironic.node.create.return_value.uuid,
address='aaa', physical_network='ctlplane')
ironic.node.create.assert_has_calls([pxe_node, mock.ANY])
ironic.port.create.assert_has_calls([port_call])
def test_register_all_nodes_uuid(self):
node_list = [self._get_node()]
node_list[0]['uuid'] = 'abcdef'
node_properties = {"cpus": "1",
"memory_mb": "2048",
"local_gb": "30",
"cpu_arch": "amd64",
"capabilities": "num_nics:6"}
ironic = mock.MagicMock()
nodes.register_all_nodes('servicehost', node_list, client=ironic)
pxe_node_driver_info = {"ssh_address": "foo.bar",
"ssh_username": "******",
"ssh_key_contents": "random",
"ssh_virt_type": "virsh"}
pxe_node = mock.call(driver="pxe_ssh",
name='node1',
driver_info=pxe_node_driver_info,
properties=node_properties,
uuid="abcdef")
port_call = mock.call(node_uuid=ironic.node.create.return_value.uuid,
address='aaa')
power_off_call = mock.call(ironic.node.create.return_value.uuid, 'off')
ironic.node.create.assert_has_calls([pxe_node, mock.ANY])
ironic.port.create.assert_has_calls([port_call])
ironic.node.set_power_state.assert_has_calls([power_off_call])
def test_register_all_nodes_ironic_no_hw_stats(self):
node_list = [self._get_node()]
# Remove the hardware stats from the node dictionary
node_list[0].pop("cpu")
node_list[0].pop("memory")
node_list[0].pop("disk")
node_list[0].pop("arch")
# Node properties should be created with empty string values for the
# hardware statistics
node_properties = {"capabilities": "num_nics:6"}
ironic = mock.MagicMock()
new_nodes = nodes.register_all_nodes(node_list, client=ironic)
self.assertEqual([ironic.node.create.return_value], new_nodes)
pxe_node_driver_info = {"ipmi_address": "foo.bar",
"ipmi_username": "******",
"ipmi_password": "******"}
pxe_node = mock.call(driver="ipmi",
name='node1',
driver_info=pxe_node_driver_info,
properties=node_properties)
port_call = mock.call(node_uuid=ironic.node.create.return_value.uuid,
address='aaa')
ironic.node.create.assert_has_calls([pxe_node, mock.ANY])
ironic.port.create.assert_has_calls([port_call])
def test_register_all_nodes_ironic_no_hw_stats(self):
node_list = [self._get_node()]
# Remove the hardware stats from the node dictionary
node_list[0].pop("cpu")
node_list[0].pop("memory")
node_list[0].pop("disk")
node_list[0].pop("arch")
# Node properties should be created with empty string values for the
# hardware statistics
node_properties = {"capabilities": "num_nics:6"}
ironic = mock.MagicMock()
new_nodes = nodes.register_all_nodes('servicehost',
node_list,
client=ironic)
self.assertEqual([ironic.node.create.return_value], new_nodes)
pxe_node_driver_info = {
"ssh_address": "foo.bar",
"ssh_username": "******",
"ssh_key_contents": "random",
"ssh_virt_type": "virsh"
}
pxe_node = mock.call(driver="pxe_ssh",
name='node1',
driver_info=pxe_node_driver_info,
properties=node_properties)
port_call = mock.call(node_uuid=ironic.node.create.return_value.uuid,
address='aaa')
power_off_call = mock.call(ironic.node.create.return_value.uuid, 'off')
ironic.node.create.assert_has_calls([pxe_node, mock.ANY])
ironic.port.create.assert_has_calls([port_call])
ironic.node.set_power_state.assert_has_calls([power_off_call])
def test_register_all_nodes_ironic_no_hw_stats(self):
node_list = [self._get_node()]
# Remove the hardware stats from the node dictionary
node_list[0].pop("cpu")
node_list[0].pop("memory")
node_list[0].pop("disk")
node_list[0].pop("arch")
# Node properties should be created with empty string values for the
# hardware statistics
node_properties = {"capabilities": "num_nics:6"}
ironic = mock.MagicMock()
new_nodes = nodes.register_all_nodes(node_list, client=ironic)
self.assertEqual([ironic.node.create.return_value], new_nodes)
pxe_node_driver_info = {
"ipmi_address": "foo.bar",
"ipmi_username": "******",
"ipmi_password": "******"
}
pxe_node = mock.call(driver="ipmi",
name='node1',
driver_info=pxe_node_driver_info,
resource_class='baremetal',
properties=node_properties)
port_call = mock.call(node_uuid=ironic.node.create.return_value.uuid,
address='aaa')
ironic.node.create.assert_has_calls([pxe_node, mock.ANY])
ironic.port.create.assert_has_calls([port_call])
def take_action(self, parsed_args):
self.log.debug("take_action(%s)" % parsed_args)
if parsed_args.json or parsed_args.file_in.name.endswith('.json'):
nodes_config = json.load(parsed_args.file_in)
elif parsed_args.csv or parsed_args.file_in.name.endswith('.csv'):
nodes_config = _csv_to_nodes_dict(parsed_args.file_in)
elif parsed_args.file_in.name.endswith('.yaml'):
nodes_config = yaml.safe_load(parsed_args.file_in)
else:
raise exceptions.InvalidConfiguration(
_("Invalid file extension for %s, must be json, yaml or csv") %
parsed_args.file_in.name)
if 'nodes' in nodes_config:
nodes_config = nodes_config['nodes']
client = self.app.client_manager.baremetal
if parsed_args.initial_state == "enroll":
api_version = client.http_client.os_ironic_api_version
if [int(part) for part in api_version.split('.')] < [1, 11]:
raise exceptions.InvalidConfiguration(
_("OS_BAREMETAL_API_VERSION must be >=1.11 for use of "
"'enroll' provision state; currently %s") % api_version)
for node in nodes_config:
caps = utils.capabilities_to_dict(node.get('capabilities', {}))
caps.setdefault('boot_option', parsed_args.instance_boot_option)
node['capabilities'] = utils.dict_to_capabilities(caps)
new_nodes = nodes.register_all_nodes(
parsed_args.service_host,
nodes_config,
client=client,
keystone_client=self.app.client_manager.identity,
glance_client=self.app.client_manager.image,
kernel_name=(parsed_args.deploy_kernel
if not parsed_args.no_deploy_image else None),
ramdisk_name=(parsed_args.deploy_ramdisk
if not parsed_args.no_deploy_image else None))
if parsed_args.initial_state == "available":
manageable_node_uuids = list(
utils.set_nodes_state(
client,
new_nodes,
"manage",
"manageable",
skipped_states={'manageable', 'available'}))
manageable_nodes = [
n for n in new_nodes if n.uuid in manageable_node_uuids
]
list(
utils.set_nodes_state(client,
manageable_nodes,
"provide",
"available",
skipped_states={'available'}))
def test_register_all_nodes(self):
node_list = [self._get_node()]
node_properties = {"cpus": "1",
"memory_mb": "2048",
"local_gb": "30",
"cpu_arch": "amd64",
"capabilities": "num_nics:6"}
ironic = mock.MagicMock()
nodes.register_all_nodes(node_list, client=ironic)
pxe_node_driver_info = {"ipmi_address": "foo.bar",
"ipmi_username": "******",
"ipmi_password": "******"}
pxe_node = mock.call(driver="ipmi",
name='node1',
driver_info=pxe_node_driver_info,
properties=node_properties)
port_call = mock.call(node_uuid=ironic.node.create.return_value.uuid,
address='aaa')
ironic.node.create.assert_has_calls([pxe_node, mock.ANY])
ironic.port.create.assert_has_calls([port_call])
def take_action(self, parsed_args):
self.log.debug("take_action(%s)" % parsed_args)
if parsed_args.json or parsed_args.file_in.name.endswith('.json'):
nodes_config = json.load(parsed_args.file_in)
elif parsed_args.csv or parsed_args.file_in.name.endswith('.csv'):
nodes_config = _csv_to_nodes_dict(parsed_args.file_in)
elif parsed_args.file_in.name.endswith('.yaml'):
nodes_config = yaml.safe_load(parsed_args.file_in)
else:
raise exceptions.InvalidConfiguration(
_("Invalid file extension for %s, must be json, yaml or csv") %
parsed_args.file_in.name)
if 'nodes' in nodes_config:
nodes_config = nodes_config['nodes']
client = self.app.client_manager.baremetal
if parsed_args.initial_state == "enroll":
api_version = client.http_client.os_ironic_api_version
if [int(part) for part in api_version.split('.')] < [1, 11]:
raise exceptions.InvalidConfiguration(
_("OS_BAREMETAL_API_VERSION must be >=1.11 for use of "
"'enroll' provision state; currently %s") % api_version)
for node in nodes_config:
caps = utils.capabilities_to_dict(node.get('capabilities', {}))
caps.setdefault('boot_option', parsed_args.instance_boot_option)
node['capabilities'] = utils.dict_to_capabilities(caps)
new_nodes = nodes.register_all_nodes(
parsed_args.service_host,
nodes_config,
client=client,
keystone_client=self.app.client_manager.identity,
glance_client=self.app.client_manager.image,
kernel_name=(parsed_args.deploy_kernel if not
parsed_args.no_deploy_image else None),
ramdisk_name=(parsed_args.deploy_ramdisk if not
parsed_args.no_deploy_image else None))
if parsed_args.initial_state == "available":
manageable_node_uuids = list(utils.set_nodes_state(
client, new_nodes, "manage", "manageable",
skipped_states={'manageable', 'available'}
))
manageable_nodes = [
n for n in new_nodes if n.uuid in manageable_node_uuids
]
list(utils.set_nodes_state(
client, manageable_nodes, "provide", "available",
skipped_states={'available'}
))
def run_module():
result = dict(success=False, error="", nodes=[])
argument_spec = openstack_full_argument_spec(
**yaml.safe_load(DOCUMENTATION)['options'])
module = AnsibleModule(argument_spec,
supports_check_mode=True,
**openstack_module_kwargs())
_, conn = openstack_cloud_from_module(module)
tripleo = tc.TripleOCommon(session=conn.session)
# if the user is working with this module in only check mode we do not
# want to make any changes to the environment, just return the current
# state with no modifications
if module.check_mode:
module.exit_json(**result)
nodes_json = nodes.convert_nodes_json_mac_to_ports(
module.params['nodes_json'])
for node in nodes_json:
caps = node.get('capabilities', {})
caps = nodes.capabilities_to_dict(caps)
if module.params['instance_boot_option'] is not None:
caps.setdefault('boot_option',
module.params['instance_boot_option'])
node['capabilities'] = nodes.dict_to_capabilities(caps)
baremetal_client = tripleo.get_baremetal_client()
image_client = tripleo.get_image_client()
try:
registered_nodes = nodes.register_all_nodes(
nodes_json,
client=baremetal_client,
remove=module.params['remove'],
glance_client=image_client,
kernel_name=module.params['kernel_name'],
ramdisk_name=module.params['ramdisk_name'])
result['success'] = True
result['nodes'] = [
dict(uuid=node.uuid, provision_state=node.provision_state)
for node in registered_nodes
]
except Exception as exc:
# LOG.exception("Error registering nodes with ironic.")
result['error'] = str(exc)
module.fail_json(msg='Validation Failed', **result)
# in the event of a successful module execution, you will want to
# simple AnsibleModule.exit_json(), passing the key/value results
module.exit_json(**result)
def run(self, context):
for node in self.nodes_json:
caps = node.get('capabilities', {})
caps = nodes.capabilities_to_dict(caps)
caps.setdefault('boot_option', self.instance_boot_option)
node['capabilities'] = nodes.dict_to_capabilities(caps)
baremetal_client = self.get_baremetal_client(context)
image_client = self.get_image_client(context)
try:
return nodes.register_all_nodes(self.nodes_json,
client=baremetal_client,
remove=self.remove,
glance_client=image_client,
kernel_name=self.kernel_name,
ramdisk_name=self.ramdisk_name)
except Exception as err:
LOG.exception("Error registering nodes with ironic.")
return actions.Result(error=six.text_type(err))
def run(self, context):
for node in self.nodes_json:
caps = node.get('capabilities', {})
caps = nodes.capabilities_to_dict(caps)
caps.setdefault('boot_option', self.instance_boot_option)
node['capabilities'] = nodes.dict_to_capabilities(caps)
baremetal_client = self.get_baremetal_client(context)
image_client = self.get_image_client(context)
try:
return nodes.register_all_nodes(
self.nodes_json,
client=baremetal_client,
remove=self.remove,
glance_client=image_client,
kernel_name=self.kernel_name,
ramdisk_name=self.ramdisk_name)
except Exception as err:
LOG.exception("Error registering nodes with ironic.")
return actions.Result(error=six.text_type(err))
def run(self):
for node in self.nodes_json:
caps = node.get('capabilities', {})
caps = nodes.capabilities_to_dict(caps)
caps.setdefault('boot_option', self.instance_boot_option)
node['capabilities'] = nodes.dict_to_capabilities(caps)
baremetal_client = self._get_baremetal_client()
image_client = self._get_image_client()
try:
return nodes.register_all_nodes(
'service_host', # unused
self.nodes_json,
client=baremetal_client,
remove=self.remove,
glance_client=image_client,
kernel_name=self.kernel_name,
ramdisk_name=self.ramdisk_name)
except Exception as err:
LOG.exception("Error registering nodes with ironic.")
return mistral_workflow_utils.Result("", err.message)
