def _set_nexus(self, nexus_wwn=None):
        '''
        Sets the nexus initiator WWN. Raises an exception if the nexus is
        already set or if the TPG does not use a nexus.
        '''
        self._check_self()

        if not self.has_feature('nexus'):
            raise RTSLibError("The TPG does not use a nexus.")
        if self._get_nexus():
            raise RTSLibError("The TPG's nexus initiator WWN is already set.")

        # Nexus wwn type should match parent target
        wwn_type = self.parent_target.wwn_type
        if nexus_wwn:
            # Not using fabric-specific version of normalize_wwn, since we
            # want to make sure wwn conforms to regexp, but don't check
            # against target wwn_list, since we're setting the "initiator" here.
            nexus_wwn = normalize_wwn((wwn_type,), nexus_wwn)[0]
        else:
            nexus_wwn = generate_wwn(wwn_type)

        fm = self.parent_target.fabric_module

        fwrite("%s/nexus" % self.path, fm.to_fabric_wwn(nexus_wwn))

 def _set_discovery_password(self, password):
     self._check_self()
     self._assert_feature('discovery_auth')
     path = "%s/discovery_auth/password" % self.path
     if password.strip() == '':
         password = "NULL"
     fwrite(path, "%s" % password)

 def _set_write_protect(self, write_protect):
     self._check_self()
     path = "%s/write_protect" % self.path
     if write_protect:
         fwrite(path, "1")
     else:
         fwrite(path, "0")

 def _set_discovery_userid(self, userid):
     self._check_self()
     self._assert_feature('discovery_auth')
     path = "%s/discovery_auth/userid" % self.path
     if userid.strip() == '':
         userid = "NULL"
     fwrite(path, "%s" % userid)

    def _config_pr_aptpl(self):
        """
        LIO actually *writes* pr aptpl info to the filesystem, so we
        need to read it in and squirt it back into configfs when we configure
        the storage object. BLEH.
        """
        aptpl_dir = "/var/target/pr"

        try:
            lines = fread("%s/aptpl_%s" % (aptpl_dir, self.wwn)).split()
        except:
            return

        if not lines[0].startswith("PR_REG_START:"):
            return

        reservations = []
        for line in lines:
            if line.startswith("PR_REG_START:"):
                res_list = []
            elif line.startswith("PR_REG_END:"):
                reservations.append(res_list)
            else:
                res_list.append(line.strip())

        for res in reservations:
            fwrite(self.path + "/pr/res_aptpl_metadata", ",".join(res))

    def restore_pr_aptpl(self, src_path=None):
        '''
        Restores StorageObject persistent reservations read from src_path.
        If src_path is omitted, uses the default LIO PR APTPL system
        path if it exists. This only works if the StorageObject is not
        in use currently, else an IO error will occur.

        @param src_path: The PR metadata file path.
        @type src_path: string or None
        '''
        dst_path = "%s/pr/res_aptpl_metadata" % self.path
        if src_path is None:
            src_path = "%s/aptpl_%s" % (self.pr_aptpl_metadata_dir, self.wwn)

        if not os.path.isfile(src_path):
            return

        lines = fread(src_path).split()
        if not lines[0].startswith("PR_REG_START:"):
            return

        for line in lines:
            if line.startswith("PR_REG_START:"):
                pr_lines = []
            elif line.startswith("PR_REG_END:"):
                fwrite(dst_path, ",".join(pr_lines))
            else:
                pr_lines.append(line.strip())

 def _set_iser(self, boolean):
     path = "%s/iser" % self.path
     try:
         fwrite(path, str(int(boolean)))
     except IOError:
         # b/w compat: don't complain if iser entry is missing
         if os.path.isfile(path):
             raise RTSLibError("Cannot change iser")

 def _set_wwn(self, wwn):
     self._check_self()
     if self.is_configured():
         path = "%s/wwn/vpd_unit_serial" % self.path
         fwrite(path, "%s\n" % wwn)
     else:
         raise RTSLibError("Cannot write a T10 WWN Unit Serial to "
                           + "an unconfigured StorageObject")

 def _set_tcq_depth(self, depth):
     self._check_self()
     path = "%s/cmdsn_depth" % self.path
     try:
         fwrite(path, "%s" % depth)
     except IOError, msg:
         msg = msg[1]
         raise RTSLibError("Cannot set tcq_depth: %s" % str(msg))

 def _set_discovery_enable_auth(self, enable):
     self._check_self()
     self._assert_feature('discovery_auth')
     path = "%s/discovery_auth/enforce_discovery_auth" % self.path
     if int(enable):
         enable = 1
     else:
         enable = 0
     fwrite(path, "%s" % enable)

 def _set_iser_attr(self, iser_attr):
     path = "%s/iser" % self.path
     if os.path.isfile(path):
         if iser_attr:
             fwrite(path, "1")
         else:
             fwrite(path, "0")
     else:
         raise RTSLibError("iser network portal attribute does not exist.")

 def delete(self):
     '''
     Delete the NetworkPortal.
     '''
     path = "%s/iser" % self.path
     if os.path.isfile(path):
         iser_attr = fread(path).strip()
         if iser_attr == "1":
             fwrite(path, "0")
     super(NetworkPortal, self).delete()

 def _set_enable(self, boolean):
     '''
     Enables or disables the TPG. Raises an error if trying to disable a TPG
     without an enable attribute (but enabling works in that case).
     '''
     self._check_self()
     path = "%s/enable" % self.path
     if os.path.isfile(path) and (boolean != self._get_enable()):
         try:
             fwrite(path, str(int(boolean)))
         except IOError, e:
             raise RTSLibError("Cannot change enable state: %s" % e)

 def _set_enable(self, boolean):
     """
     Enables or disables the TPG. If the TPG doesn't support the enable
     attribute, do nothing.
     """
     self._check_self()
     path = "%s/enable" % self.path
     if os.path.isfile(path) and (boolean != self._get_enable()):
         try:
             fwrite(path, str(int(boolean)))
         except IOError as e:
             raise RTSLibError("Cannot change enable state: %s" % e)

 def _set_enable(self, boolean):
     '''
     Enables or disables the TPG. Raises an error if trying to disable a TPG
     without en enable attribute (but enabling works in that case).
     '''
     self._check_self()
     path = "%s/enable" % self.path
     if os.path.isfile(path):
         if boolean and not self._get_enable():
             fwrite(path, "1")
         elif not boolean and self._get_enable():
             fwrite(path, "0")
     elif not boolean:
         raise RTSLibError("TPG cannot be disabled.")

 def _set_nexus(self, nexus_wwn=None):
     '''
     Sets the nexus initiator WWN. Raises an exception if the nexus is
     already set or if the TPG does not use a nexus.
     '''
     self._check_self()
     if not self.has_feature('nexus'):
         raise RTSLibError("The TPG does not use a nexus.")
     elif self._get_nexus():
         raise RTSLibError("The TPG's nexus initiator WWN is already set.")
     else:
         if nexus_wwn is None:
             nexus_wwn = generate_wwn(self.parent_target.wwn_type)
         elif not is_valid_wwn(self.parent_target.wwn_type, nexus_wwn):
             raise RTSLibError("WWN '%s' is not of type '%s'."
                               % (nexus_wwn, self.parent_target.wwn_type))
     fwrite("%s/nexus" % self.path, nexus_wwn)

 def set_parameter(self, parameter, value):
     '''
     Sets the value of a named RFC-3720 parameter.
     The parameter must exist in configFS.
     @param parameter: The RFC-3720 parameter's name. It is case-sensitive.
     @type parameter: string
     @param value: The parameter's value.
     @type value: string
     '''
     self._check_self()
     path = "%s/param/%s" % (self.path, str(parameter))
     if not os.path.isfile(path):
         raise RTSLibError("Cannot find parameter: %s" % parameter)
     else:
         try:
             fwrite(path, "%s\n" % str(value))
         except Exception as e:
             raise RTSLibError("Cannot set parameter %s: %s" % (parameter, e))

 def set_attribute(self, attribute, value):
     '''
     Sets the value of a named attribute.
     The attribute must exist in configFS.
     @param attribute: The attribute's name. It is case-sensitive.
     @type attribute: string
     @param value: The attribute's value.
     @type value: string
     '''
     self._check_self()
     path = "%s/attrib/%s" % (self.path, str(attribute))
     if not os.path.isfile(path):
         raise RTSLibError("Cannot find attribute: %s."
                           % str(attribute))
     else:
         try:
             fwrite(path, "%s" % str(value))
         except Exception as e:
             raise RTSLibError("Cannot set attribute %s: %s" % (attribute, e))

 def set_auth_attr(self, auth_attr, value):
     '''
     Sets the value of a named auth_attr.
     The auth_attr must exist in configFS.
     @param auth_attr: The auth_attr's name. It is case-sensitive.
     @type auth_attr: string
     @param value: The auth_attr's value.
     @type value: string
     '''
     self._check_self()
     path = "%s/auth/%s" % (self.path, str(auth_attr))
     if not os.path.isfile(path):
         raise RTSLibError("Cannot find auth attribute: %s."
                           % str(auth_attr))
     else:
         try:
             fwrite(path, "%s" % str(value))
         except IOError, msg:
             msg = msg[1]
             raise RTSLibError("Cannot set auth attribute %s: %s"
                               % (str(auth_attr), str(msg)))

    def delete(self):
        '''
        Recursively deletes a Nexus object.
        This will delete all attached LUN, and then the Nexus itself.
        '''
        self._check_self()
        for lun in self.luns:
            lun.delete()

        # TODO: check that ALUA MD removal works while removing Nexus
        if os.path.isdir(self.alua_metadata_path):
            shutil.rmtree(self.alua_metadata_path)

        nexus_path = self._path + "/nexus"
        if os.path.isfile(nexus_path):
            try:
                fwrite(nexus_path, "NULL")
            except IOError, msg:
                raise RTSLibError("Cannot delete Nexus initiator "
                                  + "(>=4.0 style, %s): %s."
                                  % (nexus_path, msg))