Provide access to VM in Standalone context

Add possibility to access VM with SampleVNF image, which is spawned on
baremetal server using password or key pairs (provided or generated).
Changes provided for OVS-DPDK and SRIOV cases.

JIRA: YARDSTICK-1260

Change-Id: I89cf17dc83f02abe23d206b24b9d0ec1298d3231
Signed-off-by: Stepan Andrushko <stepanx.andrushko@intel.com>

6 files changed, 261 insertions, 52 deletions

diff --git a/yardstick/benchmark/contexts/standalone/model.py b/yardstick/benchmark/contexts/standalone/model.py
index ecddcbbe0..962cb48e2 100644
--- a/yardstick/benchmark/contexts/standalone/model.py
+++ b/yardstick/benchmark/contexts/standalone/model.py
@@ -89,6 +89,17 @@ VM_TEMPLATE = """
   </devices>
 </domain>
 """
+
+USER_DATA_TEMPLATE = """
+cat > {user_file} <<EOF
+#cloud-config
+preserve_hostname: false
+hostname: {host}
+users:
+{user_config}
+EOF
+"""
+
 WAIT_FOR_BOOT = 30
 
 
@@ -268,7 +279,7 @@ class Libvirt(object):
         return vm_image
 
     @classmethod
-    def build_vm_xml(cls, connection, flavor, vm_name, index):
+    def build_vm_xml(cls, connection, flavor, vm_name, index, cdrom_img):
         """Build the XML from the configuration parameters"""
         memory = flavor.get('ram', '4096')
         extra_spec = flavor.get('extra_specs', {})
@@ -293,6 +304,9 @@ class Libvirt(object):
             socket=socket, threads=threads,
             vm_image=image, cpuset=cpuset, cputune=cputune)
 
+        # Add CD-ROM device
+        vm_xml = Libvirt.add_cdrom(cdrom_img, vm_xml)
+
         return vm_xml, mac
 
     @staticmethod
@@ -320,6 +334,71 @@ class Libvirt(object):
         et = ET.ElementTree(element=root)
         et.write(file_name, encoding='utf-8', method='xml')
 
+    @classmethod
+    def add_cdrom(cls, file_path, xml_str):
+        """Add a CD-ROM disk XML node in 'devices' node
+
+        <devices>
+            <disk type='file' device='cdrom'>
+              <driver name='qemu' type='raw'/>
+              <source file='/var/lib/libvirt/images/data.img'/>
+              <target dev='hdb'/>
+              <readonly/>
+            </disk>
+            ...
+        </devices>
+        """
+
+        root = ET.fromstring(xml_str)
+        device = root.find('devices')
+
+        disk = ET.SubElement(device, 'disk')
+        disk.set('type', 'file')
+        disk.set('device', 'cdrom')
+
+        driver = ET.SubElement(disk, 'driver')
+        driver.set('name', 'qemu')
+        driver.set('type', 'raw')
+
+        source = ET.SubElement(disk, 'source')
+        source.set('file', file_path)
+
+        target = ET.SubElement(disk, 'target')
+        target.set('dev', 'hdb')
+
+        ET.SubElement(disk, 'readonly')
+        return ET.tostring(root)
+
+    @staticmethod
+    def gen_cdrom_image(connection, file_path, vm_name, vm_user, key_filename):
+        """Generate ISO image for CD-ROM """
+
+        user_config = ["    - name: {user_name}",
+                       "      ssh_authorized_keys:",
+                       "        - {pub_key_str}"]
+        if vm_user != "root":
+            user_config.append("      sudo: ALL=(ALL) NOPASSWD:ALL")
+
+        meta_data = "/tmp/meta-data"
+        user_data = "/tmp/user-data"
+        with open(".".join([key_filename, "pub"]), "r") as pub_key_file:
+            pub_key_str = pub_key_file.read().rstrip()
+        user_conf = os.linesep.join(user_config).format(pub_key_str=pub_key_str, user_name=vm_user)
+
+        cmd_lst = [
+            "touch %s" % meta_data,
+            USER_DATA_TEMPLATE.format(user_file=user_data, host=vm_name, user_config=user_conf),
+            "genisoimage -output {0} -volid cidata -joliet -r {1} {2}".format(file_path,
+                                                                              meta_data,
+                                                                              user_data),
+            "rm {0} {1}".format(meta_data, user_data),
+        ]
+        for cmd in cmd_lst:
+            LOG.info(cmd)
+            status, _, error = connection.execute(cmd)
+            if status:
+                raise exceptions.LibvirtQemuImageCreateError(error=error)
+
 
 class StandaloneContextHelper(object):
     """ This class handles all the common code for standalone
@@ -331,7 +410,7 @@ class StandaloneContextHelper(object):
     @staticmethod
     def install_req_libs(connection, extra_pkgs=None):
         extra_pkgs = extra_pkgs or []
-        pkgs = ["qemu-kvm", "libvirt-bin", "bridge-utils", "numactl", "fping"]
+        pkgs = ["qemu-kvm", "libvirt-bin", "bridge-utils", "numactl", "fping", "genisoimage"]
         pkgs.extend(extra_pkgs)
         cmd_template = "dpkg-query -W --showformat='${Status}\\n' \"%s\"|grep 'ok installed'"
         for pkg in pkgs:
@@ -457,6 +536,25 @@ class StandaloneContextHelper(object):
                 node["ip"] = ip
         return nodes
 
+    @classmethod
+    def check_update_key(cls, connection, node, vm_name, id_name, cdrom_img):
+        # Generate public/private keys if private key file is not provided
+        user_name = node.get('user')
+        if not user_name:
+            node['user'] = 'root'
+            user_name = node.get('user')
+        if not node.get('key_filename'):
+            key_filename = ''.join(
+                [constants.YARDSTICK_ROOT_PATH,
+                 'yardstick/resources/files/yardstick_key-',
+                 id_name])
+            ssh.SSH.gen_keys(key_filename)
+            node['key_filename'] = key_filename
+        # Update image with public key
+        key_filename = node.get('key_filename')
+        Libvirt.gen_cdrom_image(connection, cdrom_img, vm_name, user_name, key_filename)
+        return node
+
 
 class Server(object):
     """ This class handles geting vnf nodes
diff --git a/yardstick/benchmark/contexts/standalone/ovs_dpdk.py b/yardstick/benchmark/contexts/standalone/ovs_dpdk.py
index 88ad598c3..5891f798e 100644
--- a/yardstick/benchmark/contexts/standalone/ovs_dpdk.py
+++ b/yardstick/benchmark/contexts/standalone/ovs_dpdk.py
@@ -394,13 +394,14 @@ class OvsDpdkContext(base.Context):
         for index, (key, vnf) in enumerate(collections.OrderedDict(
                 self.servers).items()):
             cfg = '/tmp/vm_ovs_%d.xml' % index
-            vm_name = "vm_%d" % index
+            vm_name = "vm-%d" % index
+            cdrom_img = "/var/lib/libvirt/images/cdrom-%d.img" % index
 
             # 1. Check and delete VM if already exists
             model.Libvirt.check_if_vm_exists_and_delete(vm_name,
                                                         self.connection)
             xml_str, mac = model.Libvirt.build_vm_xml(
-                self.connection, self.vm_flavor, vm_name, index)
+                self.connection, self.vm_flavor, vm_name, index, cdrom_img)
 
             # 2: Cleanup already available VMs
             for vfs in [vfs for vfs_name, vfs in vnf["network_ports"].items()
@@ -411,16 +412,24 @@ class OvsDpdkContext(base.Context):
             model.Libvirt.write_file(cfg, xml_str)
             self.connection.put(cfg, cfg)
 
+            node = self.vnf_node.generate_vnf_instance(self.vm_flavor,
+                                                       self.networks,
+                                                       self.host_mgmt.get('ip'),
+                                                       key, vnf, mac)
+            # Generate public/private keys if password or private key file is not provided
+            node = model.StandaloneContextHelper.check_update_key(self.connection,
+                                                                  node,
+                                                                  vm_name,
+                                                                  self.name,
+                                                                  cdrom_img)
+
+            # store vnf node details
+            nodes.append(node)
+
             # NOTE: launch through libvirt
             LOG.info("virsh create ...")
             model.Libvirt.virsh_create_vm(self.connection, cfg)
 
             self.vm_names.append(vm_name)
 
-            # build vnf node details
-            nodes.append(self.vnf_node.generate_vnf_instance(self.vm_flavor,
-                                                             self.networks,
-                                                             self.host_mgmt.get('ip'),
-                                                             key, vnf, mac))
-
         return nodes
diff --git a/yardstick/benchmark/contexts/standalone/sriov.py b/yardstick/benchmark/contexts/standalone/sriov.py
index 3da12a9a8..8d410b2f3 100644
--- a/yardstick/benchmark/contexts/standalone/sriov.py
+++ b/yardstick/benchmark/contexts/standalone/sriov.py
@@ -225,13 +225,14 @@ class SriovContext(base.Context):
         for index, (key, vnf) in enumerate(collections.OrderedDict(
                 self.servers).items()):
             cfg = '/tmp/vm_sriov_%s.xml' % str(index)
-            vm_name = "vm_%s" % str(index)
+            vm_name = "vm-%s" % str(index)
+            cdrom_img = "/var/lib/libvirt/images/cdrom-%d.img" % index
 
             # 1. Check and delete VM if already exists
             model.Libvirt.check_if_vm_exists_and_delete(vm_name,
                                                         self.connection)
             xml_str, mac = model.Libvirt.build_vm_xml(
-                self.connection, self.vm_flavor, vm_name, index)
+                self.connection, self.vm_flavor, vm_name, index, cdrom_img)
 
             # 2: Cleanup already available VMs
             network_ports = collections.OrderedDict(
@@ -243,17 +244,26 @@ class SriovContext(base.Context):
             model.Libvirt.write_file(cfg, xml_str)
             self.connection.put(cfg, cfg)
 
+            node = self.vnf_node.generate_vnf_instance(self.vm_flavor,
+                                                       self.networks,
+                                                       self.host_mgmt.get('ip'),
+                                                       key, vnf, mac)
+            # Generate public/private keys if password or private key file is not provided
+            node = model.StandaloneContextHelper.check_update_key(self.connection,
+                                                                  node,
+                                                                  vm_name,
+                                                                  self.name,
+                                                                  cdrom_img)
+
+            # store vnf node details
+            nodes.append(node)
+
             # NOTE: launch through libvirt
             LOG.info("virsh create ...")
             model.Libvirt.virsh_create_vm(self.connection, cfg)
 
             self.vm_names.append(vm_name)
 
-            # build vnf node details
-            nodes.append(self.vnf_node.generate_vnf_instance(
-                self.vm_flavor, self.networks, self.host_mgmt.get('ip'),
-                key, vnf, mac))
-
         return nodes
 
     def _get_vf_data(self, value, vfmac, pfif):
diff --git a/yardstick/tests/unit/benchmark/contexts/standalone/test_model.py b/yardstick/tests/unit/benchmark/contexts/standalone/test_model.py
index 8ad581918..371e4ef36 100644
--- a/yardstick/tests/unit/benchmark/contexts/standalone/test_model.py
+++ b/yardstick/tests/unit/benchmark/contexts/standalone/test_model.py
@@ -46,6 +46,16 @@ XML_SAMPLE_INTERFACE = """<?xml version="1.0"?>
 
 class ModelLibvirtTestCase(unittest.TestCase):
 
+    XML_STR = model.VM_TEMPLATE.format(
+        vm_name="vm_name",
+        random_uuid=uuid.uuid4(),
+        mac_addr="00:01:02:03:04:05",
+        memory=2048, vcpu=2, cpu=2,
+        numa_cpus=0 - 10,
+        socket=1, threads=1,
+        vm_image="/var/lib/libvirt/images/yardstick-nsb-image.img",
+        cpuset=2 - 10, cputune='')
+
     def setUp(self):
         self.pci_address_str = '0001:04:03.2'
         self.pci_address = utils.PciAddress(self.pci_address_str)
@@ -66,34 +76,34 @@ class ModelLibvirtTestCase(unittest.TestCase):
             ssh_mock.execute = mock.Mock(return_value=(0, "a", ""))
             ssh.return_value = ssh_mock
         # NOTE(ralonsoh): this test doesn't cover function execution.
-        model.Libvirt.check_if_vm_exists_and_delete("vm_0", ssh_mock)
+        model.Libvirt.check_if_vm_exists_and_delete('vm-0', ssh_mock)
 
     def test_virsh_create_vm(self):
         self.mock_ssh.execute = mock.Mock(return_value=(0, 0, 0))
-        model.Libvirt.virsh_create_vm(self.mock_ssh, 'vm_0')
-        self.mock_ssh.execute.assert_called_once_with('virsh create vm_0')
+        model.Libvirt.virsh_create_vm(self.mock_ssh, 'vm-0')
+        self.mock_ssh.execute.assert_called_once_with('virsh create vm-0')
 
     def test_virsh_create_vm_error(self):
         self.mock_ssh.execute = mock.Mock(return_value=(1, 0, 'error_create'))
         with self.assertRaises(exceptions.LibvirtCreateError) as exc:
-            model.Libvirt.virsh_create_vm(self.mock_ssh, 'vm_0')
+            model.Libvirt.virsh_create_vm(self.mock_ssh, 'vm-0')
         self.assertEqual('Error creating the virtual machine. Error: '
                          'error_create.', str(exc.exception))
-        self.mock_ssh.execute.assert_called_once_with('virsh create vm_0')
+        self.mock_ssh.execute.assert_called_once_with('virsh create vm-0')
 
     def test_virsh_destroy_vm(self):
         self.mock_ssh.execute = mock.Mock(return_value=(0, 0, 0))
-        model.Libvirt.virsh_destroy_vm('vm_0', self.mock_ssh)
-        self.mock_ssh.execute.assert_called_once_with('virsh destroy vm_0')
+        model.Libvirt.virsh_destroy_vm('vm-0', self.mock_ssh)
+        self.mock_ssh.execute.assert_called_once_with('virsh destroy vm-0')
 
     @mock.patch.object(model, 'LOG')
     def test_virsh_destroy_vm_error(self, mock_logger):
         self.mock_ssh.execute = mock.Mock(return_value=(1, 0, 'error_destroy'))
         mock_logger.warning = mock.Mock()
-        model.Libvirt.virsh_destroy_vm('vm_0', self.mock_ssh)
+        model.Libvirt.virsh_destroy_vm('vm-0', self.mock_ssh)
         mock_logger.warning.assert_called_once_with(
-            'Error destroying VM %s. Error: %s', 'vm_0', 'error_destroy')
-        self.mock_ssh.execute.assert_called_once_with('virsh destroy vm_0')
+            'Error destroying VM %s. Error: %s', 'vm-0', 'error_destroy')
+        self.mock_ssh.execute.assert_called_once_with('virsh destroy vm-0')
 
     def test_add_interface_address(self):
         xml = ElementTree.ElementTree(
@@ -171,6 +181,56 @@ class ModelLibvirtTestCase(unittest.TestCase):
         self.assertEqual('0x' + vm_pci.split(':')[2].split('.')[1],
                          interface_address.get('function'))
 
+    def test_add_cdrom(self):
+        xml_input = copy.deepcopy(XML_SAMPLE)
+        xml_output = model.Libvirt.add_cdrom('/var/lib/libvirt/images/data.img', xml_input)
+
+        root = ElementTree.fromstring(xml_output)
+        et_out = ElementTree.ElementTree(element=root)
+        disk = et_out.find('devices').find('disk')
+        self.assertEqual('file', disk.get('type'))
+        self.assertEqual('cdrom', disk.get('device'))
+        driver = disk.find('driver')
+        self.assertEqual('qemu', driver.get('name'))
+        self.assertEqual('raw', driver.get('type'))
+        source = disk.find('source')
+        self.assertEqual('/var/lib/libvirt/images/data.img', source.get('file'))
+        target = disk.find('target')
+        self.assertEqual('hdb', target.get('dev'))
+        self.assertIsNotNone(disk.find('readonly'))
+
+    def test_gen_cdrom_image(self):
+        self.mock_ssh.execute = mock.Mock(return_value=(0, 0, 0))
+        root = ElementTree.fromstring(self.XML_STR)
+        hostname = root.find('name').text
+        meta_data = "/tmp/meta-data"
+        user_data = "/tmp/user-data"
+        file_path = "/tmp/cdrom-0.img"
+        key_filename = "id_rsa"
+        pub_key_str = "KEY"
+        user = 'root'
+        user_config = ["    - name: {user_name}",
+                       "      ssh_authorized_keys:",
+                       "        - {pub_key_str}"]
+
+        user_conf = os.linesep.join(user_config).format(pub_key_str=pub_key_str, user_name=user)
+        with mock.patch('six.moves.builtins.open', mock.mock_open(read_data=pub_key_str),
+                        create=True) as mock_file:
+            with open(key_filename, "r") as h:
+                result = h.read()
+            model.Libvirt.gen_cdrom_image(self.mock_ssh, file_path, hostname, user, key_filename)
+            mock_file.assert_called_with(".".join([key_filename, "pub"]), "r")
+        self.assertEqual(result, pub_key_str)
+
+        self.mock_ssh.execute.assert_has_calls([
+            mock.call("touch %s" % meta_data),
+            mock.call(model.USER_DATA_TEMPLATE.format(user_file=user_data, host=hostname,
+                                                      user_config=user_conf)),
+            mock.call("genisoimage -output {0} -volid cidata"
+                      " -joliet -r {1} {2}".format(file_path, meta_data, user_data)),
+            mock.call("rm {0} {1}".format(meta_data, user_data))
+        ])
+
     def test_create_snapshot_qemu(self):
         self.mock_ssh.execute = mock.Mock(return_value=(0, 0, 0))
         index = 1
@@ -211,6 +271,19 @@ class ModelLibvirtTestCase(unittest.TestCase):
         self.mock_ssh.put_file.assert_called_once_with(base_image,
                                                        '/tmp/base_image')
 
+    @mock.patch.object(model.Libvirt, 'gen_cdrom_image')
+    def test_check_update_key(self, mock_gen_cdrom_image):
+        node = {'user': 'defuser', 'key_filename': '/home/ubuntu/id_rsa'}
+        cdrom_img = "/var/lib/libvirt/images/data.img"
+        id_name = 'fake_name'
+        key_filename = node.get('key_filename')
+        root = ElementTree.fromstring(self.XML_STR)
+        hostname = root.find('name').text
+        model.StandaloneContextHelper.check_update_key(self.mock_ssh, node, hostname, id_name,
+                                                       cdrom_img)
+        mock_gen_cdrom_image.assert_called_once_with(self.mock_ssh, cdrom_img, hostname,
+                                                     node.get('user'), key_filename)
+
     @mock.patch.object(os, 'access', return_value=False)
     def test_create_snapshot_qemu_no_image_local(self, mock_os_access):
         self.mock_ssh.execute = mock.Mock(side_effect=[(0, 0, 0), (1, 0, 0)])
@@ -253,18 +326,20 @@ class ModelLibvirtTestCase(unittest.TestCase):
         mac = model.StandaloneContextHelper.get_mac_address(0x00)
         _uuid = uuid.uuid4()
         connection = mock.Mock()
+        cdrom_img = '/tmp/cdrom-0.img'
         with mock.patch.object(model.StandaloneContextHelper,
                                'get_mac_address', return_value=mac) as \
                 mock_get_mac_address, \
                 mock.patch.object(uuid, 'uuid4', return_value=_uuid):
             xml_out, mac = model.Libvirt.build_vm_xml(
-                connection, flavor, 'vm_name', 100)
+                connection, flavor, 'vm_name', 100, cdrom_img)
 
         xml_ref = model.VM_TEMPLATE.format(vm_name='vm_name',
             random_uuid=_uuid, mac_addr=mac, memory='1024', vcpu='8', cpu='4',
             numa_cpus='0-7', socket='3', threads='2',
             vm_image='qemu_image', cpuset='4,5', cputune='cool')
-        self.assertEqual(xml_ref, xml_out)
+        xml_ref = model.Libvirt.add_cdrom(cdrom_img, xml_ref)
+        self.assertEqual(xml_out, xml_ref)
         mock_get_mac_address.assert_called_once_with(0x00)
         mock_create_snapshot_qemu.assert_called_once_with(
             connection, 100, 'images')
@@ -296,6 +371,7 @@ class ModelLibvirtTestCase(unittest.TestCase):
         status = model.Libvirt.pin_vcpu_for_perf(ssh_mock, 4)
         self.assertIsNotNone(status)
 
+
 class StandaloneContextHelperTestCase(unittest.TestCase):
 
     NODE_SAMPLE = "nodes_sample.yaml"
@@ -463,7 +539,7 @@ class ServerTestCase(unittest.TestCase):
             }
         }
         status = self.server.generate_vnf_instance(
-            {}, self.NETWORKS, '1.1.1.1/24', 'vm_0', vnf, '00:00:00:00:00:01')
+            {}, self.NETWORKS, '1.1.1.1/24', 'vm-0', vnf, '00:00:00:00:00:01')
         self.assertIsNotNone(status)
 
 
diff --git a/yardstick/tests/unit/benchmark/contexts/standalone/test_ovs_dpdk.py b/yardstick/tests/unit/benchmark/contexts/standalone/test_ovs_dpdk.py
index 69779d3e0..1a2407575 100644
--- a/yardstick/tests/unit/benchmark/contexts/standalone/test_ovs_dpdk.py
+++ b/yardstick/tests/unit/benchmark/contexts/standalone/test_ovs_dpdk.py
@@ -231,8 +231,8 @@ class OvsDpdkContextTestCase(unittest.TestCase):
     def test_undeploy(self, mock_libvirt):
         self.ovs_dpdk.vm_deploy = True
         self.ovs_dpdk.connection = mock.Mock()
-        self.ovs_dpdk.vm_names = ['vm_0', 'vm_1']
-        self.ovs_dpdk.drivers = ['vm_0', 'vm_1']
+        self.ovs_dpdk.vm_names = ['vm-0', 'vm-1']
+        self.ovs_dpdk.drivers = ['vm-0', 'vm-1']
         self.ovs_dpdk.cleanup_ovs_dpdk_env = mock.Mock()
         self.ovs_dpdk.networks = self.NETWORKS
         self.ovs_dpdk.undeploy()
@@ -370,7 +370,7 @@ class OvsDpdkContextTestCase(unittest.TestCase):
             ssh.return_value = ssh_mock
         self.ovs_dpdk.vm_deploy = True
         self.ovs_dpdk.connection = ssh_mock
-        self.ovs_dpdk.vm_names = ['vm_0', 'vm_1']
+        self.ovs_dpdk.vm_names = ['vm-0', 'vm-1']
         self.ovs_dpdk.drivers = []
         self.ovs_dpdk.networks = self.NETWORKS
         self.ovs_dpdk.helper.get_mac_address = mock.Mock(return_value="")
@@ -381,7 +381,7 @@ class OvsDpdkContextTestCase(unittest.TestCase):
     def test__enable_interfaces(self, mock_add_ovs_interface):
         self.ovs_dpdk.vm_deploy = True
         self.ovs_dpdk.connection = mock.Mock()
-        self.ovs_dpdk.vm_names = ['vm_0', 'vm_1']
+        self.ovs_dpdk.vm_names = ['vm-0', 'vm-1']
         self.ovs_dpdk.drivers = []
         self.ovs_dpdk.networks = self.NETWORKS
         self.ovs_dpdk.ovs_properties = {'vpath': 'fake_path'}
@@ -391,15 +391,16 @@ class OvsDpdkContextTestCase(unittest.TestCase):
             'fake_path', 0, self.NETWORKS['private_0']['vpci'],
             self.NETWORKS['private_0']['mac'], 'test')
 
+    @mock.patch.object(model.StandaloneContextHelper, 'check_update_key')
     @mock.patch.object(model.Libvirt, 'write_file')
     @mock.patch.object(model.Libvirt, 'build_vm_xml')
     @mock.patch.object(model.Libvirt, 'check_if_vm_exists_and_delete')
     @mock.patch.object(model.Libvirt, 'virsh_create_vm')
-    def test_setup_ovs_dpdk_context(self, mock_create_vm, mock_check_if_exists,
-                                    mock_build_xml, mock_write_file):
+    def test_setup_ovs_dpdk_context(self, mock_create_vm, mock_check_if_exists, mock_build_xml,
+                                    mock_write_file, mock_check_update_key):
         self.ovs_dpdk.vm_deploy = True
         self.ovs_dpdk.connection = mock.Mock()
-        self.ovs_dpdk.vm_names = ['vm_0', 'vm_1']
+        self.ovs_dpdk.vm_names = ['vm-0', 'vm-1']
         self.ovs_dpdk.drivers = []
         self.ovs_dpdk.servers = {
             'vnf_0': {
@@ -413,23 +414,32 @@ class OvsDpdkContextTestCase(unittest.TestCase):
         self.ovs_dpdk.networks = self.NETWORKS
         self.ovs_dpdk.host_mgmt = {}
         self.ovs_dpdk.flavor = {}
+        self.ovs_dpdk.file_path = '/var/lib/libvirt/images/cdrom-0.img'
         self.ovs_dpdk.configure_nics_for_ovs_dpdk = mock.Mock(return_value="")
-        xml_str = mock.Mock()
+        self.ovs_dpdk._name_task_id = 'fake_name'
+        xml_str = 'vm-0'
         mock_build_xml.return_value = (xml_str, '00:00:00:00:00:01')
         self.ovs_dpdk._enable_interfaces = mock.Mock(return_value=xml_str)
         vnf_instance = mock.Mock()
+        vnf_instance_2 = mock.Mock()
+        mock_check_update_key.return_value = vnf_instance_2
         self.ovs_dpdk.vnf_node.generate_vnf_instance = mock.Mock(
             return_value=vnf_instance)
 
-        self.assertEqual([vnf_instance],
+        self.assertEqual([vnf_instance_2],
                          self.ovs_dpdk.setup_ovs_dpdk_context())
         mock_create_vm.assert_called_once_with(
             self.ovs_dpdk.connection, '/tmp/vm_ovs_0.xml')
         mock_check_if_exists.assert_called_once_with(
-            'vm_0', self.ovs_dpdk.connection)
+            'vm-0', self.ovs_dpdk.connection)
         mock_build_xml.assert_called_once_with(
-            self.ovs_dpdk.connection, self.ovs_dpdk.vm_flavor, 'vm_0', 0)
+            self.ovs_dpdk.connection, self.ovs_dpdk.vm_flavor, 'vm-0', 0, self.ovs_dpdk.file_path)
         mock_write_file.assert_called_once_with('/tmp/vm_ovs_0.xml', xml_str)
+        mock_check_update_key.assert_called_once_with(self.ovs_dpdk.connection,
+                                                      vnf_instance,
+                                                      xml_str,
+                                                      self.ovs_dpdk._name_task_id,
+                                                      self.ovs_dpdk.file_path)
 
     @mock.patch.object(io, 'BytesIO')
     def test__check_hugepages(self, mock_bytesio):
diff --git a/yardstick/tests/unit/benchmark/contexts/standalone/test_sriov.py b/yardstick/tests/unit/benchmark/contexts/standalone/test_sriov.py
index 74c31569c..ae8e95f9a 100644
--- a/yardstick/tests/unit/benchmark/contexts/standalone/test_sriov.py
+++ b/yardstick/tests/unit/benchmark/contexts/standalone/test_sriov.py
@@ -113,8 +113,8 @@ class SriovContextTestCase(unittest.TestCase):
 
         self.sriov.vm_deploy = True
         self.sriov.connection = mock_ssh
-        self.sriov.vm_names = ['vm_0', 'vm_1']
-        self.sriov.drivers = ['vm_0', 'vm_1']
+        self.sriov.vm_names = ['vm-0', 'vm-1']
+        self.sriov.drivers = ['vm-0', 'vm-1']
         self.assertIsNone(self.sriov.undeploy())
 
     def _get_file_abspath(self, filename):
@@ -254,7 +254,7 @@ class SriovContextTestCase(unittest.TestCase):
             ssh.return_value = ssh_mock
         self.sriov.vm_deploy = True
         self.sriov.connection = ssh_mock
-        self.sriov.vm_names = ['vm_0', 'vm_1']
+        self.sriov.vm_names = ['vm-0', 'vm-1']
         self.sriov.drivers = []
         self.sriov.networks = self.NETWORKS
         self.sriov.helper.get_mac_address = mock.Mock(return_value="")
@@ -267,7 +267,7 @@ class SriovContextTestCase(unittest.TestCase):
     def test__enable_interfaces(self, mock_add_sriov, mock_ssh):
         self.sriov.vm_deploy = True
         self.sriov.connection = mock_ssh
-        self.sriov.vm_names = ['vm_0', 'vm_1']
+        self.sriov.vm_names = ['vm-0', 'vm-1']
         self.sriov.drivers = []
         self.sriov.networks = self.NETWORKS
         self.assertEqual(
@@ -276,12 +276,13 @@ class SriovContextTestCase(unittest.TestCase):
         mock_add_sriov.assert_called_once_with(
             '0000:00:0a.0', 0, self.NETWORKS['private_0']['mac'], 'test')
 
+    @mock.patch.object(model.StandaloneContextHelper, 'check_update_key')
     @mock.patch.object(model.Libvirt, 'build_vm_xml')
     @mock.patch.object(model.Libvirt, 'check_if_vm_exists_and_delete')
     @mock.patch.object(model.Libvirt, 'write_file')
     @mock.patch.object(model.Libvirt, 'virsh_create_vm')
-    def test_setup_sriov_context(self, mock_create_vm, mock_write_file,
-                                 mock_check, mock_build_vm_xml):
+    def test_setup_sriov_context(self, mock_create_vm, mock_write_file, mock_check,
+                                 mock_build_vm_xml, mock_check_update_key):
         self.sriov.servers = {
             'vnf_0': {
                 'network_ports': {
@@ -297,24 +298,29 @@ class SriovContextTestCase(unittest.TestCase):
         self.sriov.vm_flavor = 'flavor'
         self.sriov.networks = 'networks'
         self.sriov.configure_nics_for_sriov = mock.Mock()
+        self.sriov._name_task_id = 'fake_name'
         cfg = '/tmp/vm_sriov_0.xml'
-        vm_name = 'vm_0'
+        vm_name = 'vm-0'
         xml_out = mock.Mock()
         mock_build_vm_xml.return_value = (xml_out, '00:00:00:00:00:01')
+        mock_check_update_key.return_value = 'node_2'
+        cdrom_img = '/var/lib/libvirt/images/cdrom-0.img'
 
         with mock.patch.object(self.sriov, 'vnf_node') as mock_vnf_node, \
                 mock.patch.object(self.sriov, '_enable_interfaces') as \
                 mock_enable_interfaces:
             mock_enable_interfaces.return_value = 'out_xml'
             mock_vnf_node.generate_vnf_instance = mock.Mock(
-                return_value='node')
+                return_value='node_1')
             nodes_out = self.sriov.setup_sriov_context()
-        self.assertEqual(['node'], nodes_out)
+        mock_check_update_key.assert_called_once_with(connection, 'node_1', vm_name,
+                                                      self.sriov._name_task_id, cdrom_img)
+        self.assertEqual(['node_2'], nodes_out)
         mock_vnf_node.generate_vnf_instance.assert_called_once_with(
             'flavor', 'networks', '1.2.3.4', 'vnf_0',
             self.sriov.servers['vnf_0'], '00:00:00:00:00:01')
         mock_build_vm_xml.assert_called_once_with(
-            connection, 'flavor', vm_name, 0)
+            connection, 'flavor', vm_name, 0, cdrom_img)
         mock_create_vm.assert_called_once_with(connection, cfg)
         mock_check.assert_called_once_with(vm_name, connection)
         mock_write_file.assert_called_once_with(cfg, 'out_xml')
@@ -332,7 +338,7 @@ class SriovContextTestCase(unittest.TestCase):
             ssh.return_value = ssh_mock
         self.sriov.vm_deploy = True
         self.sriov.connection = ssh_mock
-        self.sriov.vm_names = ['vm_0', 'vm_1']
+        self.sriov.vm_names = ['vm-0', 'vm-1']
         self.sriov.drivers = []
         self.sriov.servers = {
             'vnf_0': {