def setup_or_cleanup_iscsi(is_setup, is_login=True, emulated_image="emulated_iscsi", image_size="1G"): """ Set up(and login iscsi target) or clean up iscsi service on localhost. :param is_setup: Boolean value, true for setup, false for cleanup :param is_login: Boolean value, true for login, false for not login :param emulated_image: name of iscsi device :param image_size: emulated image's size :return: iscsi device name or iscsi target """ try: utils_misc.find_command("tgtadm") utils_misc.find_command("iscsiadm") except ValueError: raise error.TestNAError("Missing command 'tgtadm' and/or 'iscsiadm'.") tmpdir = os.path.join(data_dir.get_root_dir(), 'tmp') emulated_path = os.path.join(tmpdir, emulated_image) emulated_target = "iqn.2001-01.com.virttest:%s.target" % emulated_image iscsi_params = {"emulated_image": emulated_path, "target": emulated_target, "image_size": image_size, "iscsi_thread_id": "virt"} _iscsi = iscsi.Iscsi(iscsi_params) if is_setup: sv_status = None if utils_selinux.is_enforcing(): sv_status = utils_selinux.get_status() utils_selinux.set_status("permissive") _iscsi.export_target() if sv_status is not None: utils_selinux.set_status(sv_status) if is_login: _iscsi.login() # The device doesn't necessarily appear instantaneously, so give # about 5 seconds for it to appear before giving up iscsi_device = utils_misc.wait_for(_iscsi.get_device_name, 5, 0, 1, "Searching iscsi device name.") if iscsi_device: logging.debug("iscsi device: %s", iscsi_device) return iscsi_device if not iscsi_device: logging.error("Not find iscsi device.") # Cleanup and return "" - caller needs to handle that # _iscsi.export_target() will have set the emulated_id and # export_flag already on success... _iscsi.cleanup() utils.run("rm -f %s" % emulated_path) else: return emulated_target else: _iscsi.export_flag = True _iscsi.emulated_id = _iscsi.get_target_id() _iscsi.cleanup() utils.run("rm -f %s" % emulated_path) return ""
def __init__(self, test, params): self.vm_name = params.get("vm_name", "test-vm1") while virsh.domain_exists(self.vm_name): self.vm_name += ".test" params["main_vm"] = self.vm_name ios_file = os.path.join(data_dir.get_data_dir(), params.get('cdrom_cd1')) if not os.path.exists(ios_file): raise error.TestNAError("Please prepare ios file:%s" % ios_file) self.env = params.get('env') self.vm = self.env.create_vm("libvirt", None, self.vm_name, params, test.bindir) self.env.register_vm(self.vm_name, self.vm) self.twice_execute = "yes" == params.get("twice_execute", "no") self.kill_first = "yes" == params.get("kill_first", "no") self.read_only = "yes" == params.get("read_only", "no") self.selinux_enforcing = utils_selinux.is_enforcing() if self.selinux_enforcing: utils_selinux.set_status("permissive") self.image_path = os.path.join(test.virtdir, "test_image") if not os.path.exists(self.image_path): os.mkdir(self.image_path) if self.read_only: os.chmod(self.image_path, stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH) params["image_name"] = os.path.join(self.image_path, self.vm_name) params["image_format"] = "raw" params['force_create_image'] = "yes" params['remove_image'] = "yes" params['shutdown_cleanly'] = "yes" params['shutdown_cleanly_timeout'] = 120 params['guest_port_unattended_install'] = 12323 params['inactivity_watcher'] = "error" params['inactivity_treshold'] = 1800 params['image_verify_bootable'] = "no" params['unattended_delivery_method'] = "cdrom" params['drive_index_unattended'] = 1 params['drive_index_cd1'] = 2 params['boot_once'] = "d" params['medium'] = "cdrom" params['wait_no_ack'] = "yes" params['image_raw_device'] = "yes" params['backup_image_before_testing'] = "no" params['kernel_params'] = ("ks=cdrom nicdelay=60 " "console=ttyS0,115200 console=tty0") params['cdroms'] += " unattended" params['redirs'] += " unattended_install" self.params = params self.test = test
def __init__(self, test, params): self.vm_name = params.get("vm_name", "test-vm1") self.test = test while virsh.domain_exists(self.vm_name): self.vm_name += ".test" params["main_vm"] = self.vm_name ios_file = os.path.join(data_dir.get_data_dir(), params.get('cdrom_cd1')) if not os.path.exists(ios_file): self.test.cancel("Please prepare ios file:%s" % ios_file) self.env = params.get('env') self.vm = self.env.create_vm("libvirt", None, self.vm_name, params, test.bindir) self.env.register_vm(self.vm_name, self.vm) self.twice_execute = "yes" == params.get("twice_execute", "no") self.kill_first = "yes" == params.get("kill_first", "no") self.read_only = "yes" == params.get("read_only", "no") self.selinux_enforcing = utils_selinux.is_enforcing() if self.selinux_enforcing: utils_selinux.set_status("permissive") self.image_path = os.path.join(test.virtdir, "test_image") if not os.path.exists(self.image_path): os.mkdir(self.image_path) if self.read_only: os.chmod(self.image_path, stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH) params["image_name"] = os.path.join(self.image_path, self.vm_name) params["image_format"] = "raw" params['force_create_image'] = "yes" params['remove_image'] = "yes" params['shutdown_cleanly'] = "yes" params['shutdown_cleanly_timeout'] = 120 params['guest_port_unattended_install'] = 12323 params['inactivity_watcher'] = "error" params['inactivity_treshold'] = 1800 params['image_verify_bootable'] = "no" params['unattended_delivery_method'] = "cdrom" params['drive_index_unattended'] = 1 params['drive_index_cd1'] = 2 params['boot_once'] = "d" params['medium'] = "cdrom" params['wait_no_ack'] = "yes" params['image_raw_device'] = "yes" params['backup_image_before_testing'] = "no" params['kernel_params'] = ("ks=cdrom nicdelay=60 " "console=ttyS0,115200 console=tty0") params['cdroms'] += " unattended" params['redirs'] += " unattended_install" self.params = params
def __init__(self, test, params): self.td = None self.cpu_num = int(params.get("cpu_num", "1")) self.vm_name = params.get("main_vm") self.vm_new_name = params.get("vm_new_name") self.cgroup_name = params.get("cgroup_name") self.cgroup_dir = params.get("cgroup_dir") self.new_image_file = params.get("new_image_file") if self.new_image_file: self.new_image_file = os.path.join(test.virtdir, self.new_image_file) self.time_out = int(params.get("time_out", "600")) self.cpu_status = utils_misc.get_cpu_status(self.cpu_num) self.twice_execute = "yes" == params.get("twice_execute", "no") self.kill_first = "yes" == params.get("kill_first", "no") if params.get("abnormal_type") in ["disk_lack", ""]: self.selinux_enforcing = utils_selinux.is_enforcing() if self.selinux_enforcing: utils_selinux.set_status("permissive") self.fs_type = params.get("fs_type", "ext4") xml_file = vm_xml.VMXML.new_from_inactive_dumpxml(self.vm_name) disk_node = xml_file.get_disk_all()['vda'] source_file = disk_node.find('source').get('file') self.image_size = utils_misc.get_image_info(source_file)['dsize'] # Set the size to be image_size iscsi_size = "%sM" % (self.image_size / 1024 / 1024) params['image_size'] = iscsi_size self.iscsi_dev = qemu_storage.Iscsidev(params, test.virtdir, "iscsi") try: device_source = self.iscsi_dev.setup() except (exceptions.TestError, ValueError) as detail: self.iscsi_dev.cleanup() self.test.cancel("Cannot get iscsi device on this" " host:%s\n" % detail) libvirt.mk_label(device_source) libvirt.mk_part(device_source, iscsi_size) self.mount_dir = os.path.join(test.virtdir, params.get('mount_dir')) if not os.path.exists(self.mount_dir): os.mkdir(self.mount_dir) params['mount_dir'] = self.mount_dir self.partition = device_source + "1" libvirt.mkfs(self.partition, self.fs_type) utils_misc.mount(self.partition, self.mount_dir, self.fs_type) self.new_image_file = os.path.join(self.mount_dir, "new_file")
def setup_or_cleanup_nfs(is_setup, mount_dir="", is_mount=False, export_options="rw,no_root_squash", mount_src="nfs-export"): """ Set up or clean up nfs service on localhost. :param is_setup: Boolean value, true for setup, false for cleanup :param mount_dir: NFS mount point :param is_mount: Boolean value, true for mount, false for umount :param export_options: options for nfs dir :return: export nfs path or nothing """ tmpdir = os.path.join(data_dir.get_root_dir(), 'tmp') if not os.path.isabs(mount_src): mount_src = os.path.join(tmpdir, mount_src) if not mount_dir: mount_dir = os.path.join(tmpdir, 'nfs-mount') nfs_params = { "nfs_mount_dir": mount_dir, "nfs_mount_options": "rw", "nfs_mount_src": mount_src, "setup_local_nfs": "yes", "export_options": "rw,no_root_squash" } _nfs = nfs.Nfs(nfs_params) # Set selinux to permissive that the file in nfs # can be used freely if utils_selinux.is_enforcing(): sv_status = utils_selinux.get_status() utils_selinux.set_status("permissive") if is_setup: _nfs.setup() if not is_mount: _nfs.umount() return mount_src else: _nfs.unexportfs_in_clean = True _nfs.cleanup() return ""
def setup_or_cleanup_nfs(is_setup, mount_dir="", is_mount=False, export_options="rw,no_root_squash", mount_src="nfs-export"): """ Set up or clean up nfs service on localhost. :param is_setup: Boolean value, true for setup, false for cleanup :param mount_dir: NFS mount point :param is_mount: Boolean value, true for mount, false for umount :param export_options: options for nfs dir :return: export nfs path or nothing """ tmpdir = os.path.join(data_dir.get_root_dir(), 'tmp') if not os.path.isabs(mount_src): mount_src = os.path.join(tmpdir, mount_src) if not mount_dir: mount_dir = os.path.join(tmpdir, 'nfs-mount') nfs_params = {"nfs_mount_dir": mount_dir, "nfs_mount_options": "rw", "nfs_mount_src": mount_src, "setup_local_nfs": "yes", "export_options": "rw,no_root_squash"} _nfs = nfs.Nfs(nfs_params) # Set selinux to permissive that the file in nfs # can be used freely if utils_selinux.is_enforcing(): sv_status = utils_selinux.get_status() utils_selinux.set_status("permissive") if is_setup: _nfs.setup() if not is_mount: _nfs.umount() return mount_src else: _nfs.unexportfs_in_clean = True _nfs.cleanup() return ""
def export_target(self): """ Export target in localhost for emulated iscsi """ selinux_mode = None # create image disk if not os.path.isfile(self.emulated_image): process.system(self.create_cmd) else: emulated_image_size = os.path.getsize(self.emulated_image) // 1024 if emulated_image_size != self.emulated_expect_size: # No need to remvoe, rebuild is fine process.system(self.create_cmd) # confirm if the target exists and create iSCSI target cmd = "targetcli ls /iscsi 1" output = decode_to_text(process.system_output(cmd)) if not re.findall("%s$" % self.target, output, re.M): logging.debug("Need to export target in host") # Set selinux to permissive mode to make sure # iscsi target export successfully if utils_selinux.is_enforcing(): selinux_mode = utils_selinux.get_status() utils_selinux.set_status("permissive") # In fact, We've got two options here # # 1) Create a block backstore that usually provides the best # performance. We can use a block device like /dev/sdb or # a logical volume previously created, # (lvcreate -name lv_iscsi -size 1G vg) # 2) Create a fileio backstore, # which enables the local file system cache. # # This class Only works for emulated iscsi device, # So fileio backstore is enough and safe. # Create a fileio backstore device_cmd = ("targetcli /backstores/fileio/ create %s %s" % (self.device, self.emulated_image)) output = decode_to_text(process.system_output(device_cmd)) if "Created fileio" not in output: raise exceptions.TestFail("Failed to create fileio %s. (%s)" % (self.device, output)) # Create an IQN with a target named target_name target_cmd = "targetcli /iscsi/ create %s" % self.target output = decode_to_text(process.system_output(target_cmd)) if "Created target" not in output: raise exceptions.TestFail("Failed to create target %s. (%s)" % (self.target, output)) check_portal = "targetcli /iscsi/%s/tpg1/portals ls" % self.target portal_info = decode_to_text(process.system_output(check_portal)) if "0.0.0.0:3260" not in portal_info: # Create portal # 0.0.0.0 means binding to INADDR_ANY # and using default IP port 3260 portal_cmd = ("targetcli /iscsi/%s/tpg1/portals/ create %s" % (self.target, "0.0.0.0")) output = decode_to_text(process.system_output(portal_cmd)) if "Created network portal" not in output: raise exceptions.TestFail("Failed to create portal. (%s)" % output) if ("ipv6" == utils_net.IPAddress(self.portal_ip).version and self.portal_ip not in portal_info): # Ipv6 portal address can't be created by default, # create ipv6 portal if needed. portal_cmd = ("targetcli /iscsi/%s/tpg1/portals/ create %s" % (self.target, self.portal_ip)) output = decode_to_text(process.system_output(portal_cmd)) if "Created network portal" not in output: raise exceptions.TestFail("Failed to create portal. (%s)" % output) # Create lun lun_cmd = "targetcli /iscsi/%s/tpg1/luns/ " % self.target dev_cmd = "create /backstores/fileio/%s" % self.device output = decode_to_text(process.system_output(lun_cmd + dev_cmd)) luns = re.findall(r"Created LUN (\d+).", output) if not luns: raise exceptions.TestFail("Failed to create lun. (%s)" % output) self.luns = luns[0] # Set firewall if it's enabled output = decode_to_text( process.system_output("firewall-cmd --state", ignore_status=True)) if re.findall("^running", output, re.M): # firewall is running process.system("firewall-cmd --permanent --add-port=3260/tcp") process.system("firewall-cmd --reload") # Restore selinux if selinux_mode is not None: utils_selinux.set_status(selinux_mode) self.export_flag = True else: logging.info("Target %s has already existed!" % self.target) if self.chap_flag: # Set CHAP authentication on the exported target self.set_chap_auth_target() # Set CHAP authentication for initiator to login target if self.portal_visible(): self.set_chap_auth_initiator() else: # To enable that so-called "demo mode" TPG operation, # disable all authentication for the corresponding Endpoint. # which means grant access to all initiators, # so that they can access all LUNs in the TPG # without further authentication. auth_cmd = "targetcli /iscsi/%s/tpg1/ " % self.target attr_cmd = ("set attribute %s %s %s %s" % ("authentication=0", "demo_mode_write_protect=0", "generate_node_acls=1", "cache_dynamic_acls=1")) output = decode_to_text(process.system_output(auth_cmd + attr_cmd)) logging.info("Define access rights: %s" % output) # Discovery the target self.portal_visible() # Save configuration process.system("targetcli / saveconfig") # Restart iSCSI service restart_iscsid()
def export_target(self): """ Export target in localhost for emulated iscsi """ selinux_mode = None if not os.path.isfile(self.emulated_image): process.system(self.create_cmd) else: emulated_image_size = os.path.getsize(self.emulated_image) // 1024 if emulated_image_size != self.emulated_expect_size: # No need to remvoe, rebuild is fine process.system(self.create_cmd) cmd = "tgtadm --lld iscsi --mode target --op show" try: output = decode_to_text(process.system_output(cmd)) except process.CmdError: restart_tgtd() output = decode_to_text(process.system_output(cmd)) if not re.findall("%s$" % self.target, output, re.M): logging.debug("Need to export target in host") # Set selinux to permissive mode to make sure iscsi target # export successfully if utils_selinux.is_enforcing(): selinux_mode = utils_selinux.get_status() utils_selinux.set_status("permissive") output = decode_to_text(process.system_output(cmd)) used_id = re.findall("Target\s+(\d+)", output) emulated_id = 1 while str(emulated_id) in used_id: emulated_id += 1 self.emulated_id = str(emulated_id) cmd = "tgtadm --mode target --op new --tid %s" % self.emulated_id cmd += " --lld iscsi --targetname %s" % self.target process.system(cmd) cmd = "tgtadm --lld iscsi --op bind --mode target " cmd += "--tid %s -I ALL" % self.emulated_id process.system(cmd) else: target_strs = re.findall("Target\s+(\d+):\s+%s$" % self.target, output, re.M) self.emulated_id = target_strs[0].split(':')[0].split()[-1] cmd = "tgtadm --lld iscsi --mode target --op show" try: output = decode_to_text(process.system_output(cmd)) except process.CmdError: # In case service stopped restart_tgtd() output = decode_to_text(process.system_output(cmd)) # Create a LUN with emulated image if re.findall(self.emulated_image, output, re.M): # Exist already logging.debug("Exported image already exists.") self.export_flag = True else: tgt_str = re.search(r'.*(Target\s+\d+:\s+%s\s*.*)$' % self.target, output, re.DOTALL) if tgt_str: luns = len(re.findall("\s+LUN:\s(\d+)", tgt_str.group(1), re.M)) else: luns = len(re.findall("\s+LUN:\s(\d+)", output, re.M)) cmd = "tgtadm --mode logicalunit --op new " cmd += "--tid %s --lld iscsi " % self.emulated_id cmd += "--lun %s " % luns cmd += "--backing-store %s" % self.emulated_image process.system(cmd) self.export_flag = True self.luns = luns # Restore selinux if selinux_mode is not None: utils_selinux.set_status(selinux_mode) if self.chap_flag: # Set CHAP authentication on the exported target self.set_chap_auth_target() # Set CHAP authentication for initiator to login target if self.portal_visible(): self.set_chap_auth_initiator()
def export_target(self): """ Export target in localhost for emulated iscsi """ selinux_mode = None if not os.path.isfile(self.emulated_image): utils.system(self.create_cmd) else: emulated_image_size = os.path.getsize(self.emulated_image) / 1024 if emulated_image_size != self.emulated_expect_size: # No need to remvoe, rebuild is fine utils.system(self.create_cmd) cmd = "tgtadm --lld iscsi --mode target --op show" try: output = utils.system_output(cmd) except error.CmdError: utils.system("service tgtd restart") output = utils.system_output(cmd) if not re.findall("%s$" % self.target, output, re.M): logging.debug("Need to export target in host") # Set selinux to permissive mode to make sure iscsi target # export successfully if utils_selinux.is_enforcing(): selinux_mode = utils_selinux.get_status() utils_selinux.set_status("permissive") output = utils.system_output(cmd) used_id = re.findall("Target\s+(\d+)", output) emulated_id = 1 while str(emulated_id) in used_id: emulated_id += 1 self.emulated_id = str(emulated_id) cmd = "tgtadm --mode target --op new --tid %s" % self.emulated_id cmd += " --lld iscsi --targetname %s" % self.target utils.system(cmd) cmd = "tgtadm --lld iscsi --op bind --mode target " cmd += "--tid %s -I ALL" % self.emulated_id utils.system(cmd) else: target_strs = re.findall("Target\s+(\d+):\s+%s$" % self.target, output, re.M) self.emulated_id = target_strs[0].split(':')[0].split()[-1] cmd = "tgtadm --lld iscsi --mode target --op show" try: output = utils.system_output(cmd) except error.CmdError: # In case service stopped utils.system("service tgtd restart") output = utils.system_output(cmd) # Create a LUN with emulated image if re.findall(self.emulated_image, output, re.M): # Exist already logging.debug("Exported image already exists.") self.export_flag = True else: tgt_str = re.search(r'.*(Target\s+\d+:\s+%s\s*.*)$' % self.target, output, re.DOTALL) if tgt_str: luns = len(re.findall("\s+LUN:\s(\d+)", tgt_str.group(1), re.M)) else: luns = len(re.findall("\s+LUN:\s(\d+)", output, re.M)) cmd = "tgtadm --mode logicalunit --op new " cmd += "--tid %s --lld iscsi " % self.emulated_id cmd += "--lun %s " % luns cmd += "--backing-store %s" % self.emulated_image utils.system(cmd) self.export_flag = True # Restore selinux if selinux_mode is not None: utils_selinux.set_status(selinux_mode) if self.chap_flag: # Set CHAP authentication on the exported target self.set_chap_auth_target() # Set CHAP authentication for initiator to login target if self.portal_visible(): self.set_chap_auth_initiator()
def export_target(self): """ Export target in localhost for emulated iscsi """ selinux_mode = None # create image disk if not os.path.isfile(self.emulated_image): utils.system(self.create_cmd) else: emulated_image_size = os.path.getsize(self.emulated_image) / 1024 if emulated_image_size != self.emulated_expect_size: # No need to remvoe, rebuild is fine utils.system(self.create_cmd) # confirm if the target exists and create iSCSI target cmd = "targetcli ls /iscsi 1" output = utils.system_output(cmd) if not re.findall("%s$" % self.target, output, re.M): logging.debug("Need to export target in host") # Set selinux to permissive mode to make sure # iscsi target export successfully if utils_selinux.is_enforcing(): selinux_mode = utils_selinux.get_status() utils_selinux.set_status("permissive") # In fact, We've got two options here # # 1) Create a block backstore that usually provides the best # performance. We can use a block device like /dev/sdb or # a logical volume previously created, # (lvcreate -name lv_iscsi -size 1G vg) # 2) Create a fileio backstore, # which enables the local file system cache. # # This class Only works for emulated iscsi device, # So fileio backstore is enough and safe. # Create a fileio backstore device_cmd = ("targetcli /backstores/fileio/ create %s %s" % (self.device, self.emulated_image)) output = utils.system_output(device_cmd) if "Created fileio" not in output: raise error.TestFail("Failed to create fileio %s. (%s)", self.device, output) # Create an IQN with a target named target_name target_cmd = "targetcli /iscsi/ create %s" % self.target output = utils.system_output(target_cmd) if "Created target" not in output: raise error.TestFail("Failed to create target %s. (%s)", self.target, output) check_portal = "targetcli /iscsi/%s/tpg1/portals ls" % self.target if "0.0.0.0:3260" not in utils.system_output(check_portal): # Create portal # 0.0.0.0 means binding to INADDR_ANY # and using default IP port 3260 portal_cmd = ("targetcli /iscsi/%s/tpg1/portals/ create %s" % (self.target, "0.0.0.0")) output = utils.system_output(portal_cmd) if "Created network portal" not in output: raise error.TestFail("Failed to create portal. (%s)", output) # Create lun lun_cmd = "targetcli /iscsi/%s/tpg1/luns/ " % self.target dev_cmd = "create /backstores/fileio/%s" % self.device output = utils.system_output(lun_cmd + dev_cmd) if "Created LUN" not in output: raise error.TestFail("Failed to create lun. (%s)", output) # Set firewall if it's enabled output = utils.system_output("firewall-cmd --state", ignore_status=True) if re.findall("^running", output, re.M): # firewall is running utils.system("firewall-cmd --permanent --add-port=3260/tcp") utils.system("firewall-cmd --reload") # Restore selinux if selinux_mode is not None: utils_selinux.set_status(selinux_mode) self.export_flag = True else: logging.info("Target %s has already existed!" % self.target) if self.chap_flag: # Set CHAP authentication on the exported target self.set_chap_auth_target() # Set CHAP authentication for initiator to login target if self.portal_visible(): self.set_chap_auth_initiator() else: # To enable that so-called "demo mode" TPG operation, # disable all authentication for the corresponding Endpoint. # which means grant access to all initiators, # so that they can access all LUNs in the TPG # without further authentication. auth_cmd = "targetcli /iscsi/%s/tpg1/ " % self.target attr_cmd = ("set attribute %s %s %s %s" % ("authentication=0", "demo_mode_write_protect=0", "generate_node_acls=1", "cache_dynamic_acls=1")) output = utils.system_output(auth_cmd + attr_cmd) logging.info("Define access rights: %s" % output) # Save configuration utils.system("targetcli / saveconfig")
def setup_or_cleanup_iscsi(is_setup, is_login=True, emulated_image="emulated_iscsi", image_size="1G"): """ Set up(and login iscsi target) or clean up iscsi service on localhost. :param is_setup: Boolean value, true for setup, false for cleanup :param is_login: Boolean value, true for login, false for not login :param emulated_image: name of iscsi device :param image_size: emulated image's size :return: iscsi device name or iscsi target """ try: utils_misc.find_command("tgtadm") utils_misc.find_command("iscsiadm") except ValueError: raise error.TestNAError("Missing command 'tgtadm' and/or 'iscsiadm'.") tmpdir = os.path.join(data_dir.get_root_dir(), 'tmp') emulated_path = os.path.join(tmpdir, emulated_image) emulated_target = "iqn.2001-01.com.virttest:%s.target" % emulated_image iscsi_params = { "emulated_image": emulated_path, "target": emulated_target, "image_size": image_size, "iscsi_thread_id": "virt" } _iscsi = iscsi.Iscsi(iscsi_params) if is_setup: sv_status = None if utils_selinux.is_enforcing(): sv_status = utils_selinux.get_status() utils_selinux.set_status("permissive") _iscsi.export_target() if sv_status is not None: utils_selinux.set_status(sv_status) if is_login: _iscsi.login() # The device doesn't necessarily appear instantaneously, so give # about 5 seconds for it to appear before giving up iscsi_device = utils_misc.wait_for(_iscsi.get_device_name, 5, 0, 1, "Searching iscsi device name.") if iscsi_device: logging.debug("iscsi device: %s", iscsi_device) return iscsi_device if not iscsi_device: logging.error("Not find iscsi device.") # Cleanup and return "" - caller needs to handle that # _iscsi.export_target() will have set the emulated_id and # export_flag already on success... _iscsi.cleanup() utils.run("rm -f %s" % emulated_path) else: return emulated_target else: _iscsi.export_flag = True _iscsi.emulated_id = _iscsi.get_target_id() _iscsi.cleanup() utils.run("rm -f %s" % emulated_path) return ""