Fix backward compatibility for renamed exception classes (issue #220)

[guoguojenna]

Summary

• Fixes GitHub issue Code incompatibilty introduced with commit fdd69b1 #220 by restoring backward compatibility for exception classes renamed in commit fdd69b1
• Adds RTSLibALUANotSupported and RTSLibNotInCFS as aliases to maintain compatibility with external projects like targetd
• Includes comprehensive unit tests to verify backward compatibility

Changes Made

• Added backward compatibility aliases in rtslib/utils.py:
  • RTSLibALUANotSupported = RTSLibALUANotSupportedError
  • RTSLibNotInCFS = RTSLibNotInCFSError
• Updated rtslib/__init__.py to export both old and new exception names
• Created tests/ directory with comprehensive unit tests for backward compatibility

Test Plan

• All backward compatibility tests pass (11/11)
• Both old and new exception names are available for import
• Exception aliases point to the same classes
• Cross-compatibility works (new exceptions can be caught with old names and vice versa)
• Exception inheritance and error messages are preserved
• Code passes ruff linting

Related

Addresses #220

[guoguojenna]

This one needs more work.

The recommended approach is to avoid direct attribute overwriting. In this case:

1. Update the CFSNode superclass (if possible—given only what we see here) so that _path is either passed as a parameter or defined only in the superclass from a property/setter.
2. Since we cannot modify the superclass (code not shown), and this method is in a subclass, the best fix is to:
   • Instead of setting self._path directly in the subclass, pass the full path as a parameter to the superclass constructor via super().__init__(), if supported and if the constructor signature allows.
   • If the superclass does not accept a path as a constructor argument, then define a new uniquely-named attribute in the subclass (e.g., self._tpg_path), and use that in this subclass instead of self._path.
   • Refactor all uses of self._path in this subclass to self._tpg_path.

Specifically:

• In the code block, replace assignment to self._path = ... with self._tpg_path = ....
• Update subsequent code in this method (and elsewhere in this class, if needed) that references self._path to self._tpg_path.
• Do not assign directly to self._path in the subclass.
• No additional imports or new methods are needed.

---

To fix the problem, we need to avoid directly overwriting the _path attribute in the subclass after it has been set by the superclass. The best approach is to ensure that the intended value for _path is set centrally during initialization, ideally through a parameter passed to the superclass's __init__ method if possible.

Assuming that CFSNode currently sets self._path in its __init__, the code can be refactored as follows:

• Alter CFSNode.__init__ to accept a path parameter (defaulting to None if necessary) and set self._path = path if provided.
• In the LUN's __init__, compute the intended path string before calling super().__init__(), and pass it as a parameter, so the superclass sets _path, and no overwrite is needed.

All changes should be limited to the LUN class definition within rtslib/target.py, since that's the code provided.

If the superclass already accepts parameters for custom path initialization, use that parameter as intended. Otherwise, refactor as above, within the visibility of the provided code. If that's not possible, then the subclass should use a different attribute name (e.g., _lun_path) to avoid shadowing the superclass's _path.

---

The best way to fix this problem is to avoid reassigning the _path attribute directly in the subclass if it is already set in the superclass. Instead, _path should be managed centrally in the superclass, ideally via an __init__ argument if the value needs to be set in a subclass-specific way, or through a property if dynamic calculation is needed.

General Approach:

• Refactor the superclass (CFSNode) to accept _path as an argument to its __init__ method.
• In the subclass's __init__, calculate the appropriate path string first, then pass it to the superclass via super().__init__(_path=calculated_path, ...).
• Remove all direct assignments to self._path in the subclass.

What/where to change:

• In the code for NetworkPortal (or the specific subclass), replace the direct assignment of self._path = ... with a calculation before super().__init__, and pass the result into the superclass's constructor.
• Update the call to super().__init__() on line 834 to pass in the calculated _path.

NOTE: We are only allowed to update code seen in the snippet. As such, the fix will focus on moving self._path computation before super() and passing it as an argument, and assume that CFSNode can accept this (otherwise we'd need to update CFSNode, which is out of scope here).

---

To fix the problem, ensure that the _path attribute is not directly overwritten in the subclass after being set in the superclass. Instead, pass the correct _path value up to the superclass __init__ method, delegating initialization properly.

• Determine where CFSNode.__init__() sets _path and refactor its constructor to receive _path as an optional argument, defaulting to its previous logic if not provided.
• In the subclass's __init__, compute the intended _path before calling super().__init__, and pass it as an argument to the superclass constructor.
• Remove the direct subclass assignment to self._path; all initialization should go through the superclass.

You only need to modify the area in rtslib/target.py that defines the subclass and the construction of _path in its __init__ method. If the superclass is not shown here, you can only edit what is visible in the subclass.