warlock-manager 2.2.4__tar.gz → 2.2.6__tar.gz

{warlock_manager-2.2.4 → warlock_manager-2.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: warlock-manager
-Version: 2.2.4
+Version: 2.2.6
 Summary: Dependency library for game-server management applications.
 Author-email: Charlie Powell <cdp1337@bitsnbytes.dev>
 Maintainer-email: Charlie Powell <cdp1337@bitsnbytes.dev>

{warlock_manager-2.2.4 → warlock_manager-2.2.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "warlock-manager"
-version = "2.2.4"
+version = "2.2.6"
 description = "Dependency library for game-server management applications."
 readme = "README.md"
 requires-python = ">=3.10"

{warlock_manager-2.2.4 → warlock_manager-2.2.6}/tests/test_base_service.py

@@ -61,4 +61,4 @@ class TestBaseService(unittest.TestCase):
 			self.assertIn('Type=simple', data_new)
 			self.assertIn('ExecStart=%s' % svc.get_executable(), data_new)
 			self.assertIn('WorkingDirectory=%s' % svc.get_app_directory(), data_new)
-			self.assertIn('EnvironmentFile=%s/Environments/%s.env' % (utils.get_app_directory(), svc.service), data_new)
+			self.assertIn('EnvironmentFile=%s/Environments/%s.env' % (utils.get_base_directory(), svc.service), data_new)

{warlock_manager-2.2.4 → warlock_manager-2.2.6}/tests/test_cmd.py

@@ -3,16 +3,34 @@ from warlock_manager.libs.cmd import Cmd
 
 
 class TestCmd(unittest.TestCase):
-	def test_exists_true(self):
+	def test_exists(self):
+		"""
+		Test if commands exist and do not exist
+		:return:
+		"""
 		cmd = Cmd(["echo"])
 		self.assertTrue(cmd.exists)
 
-	def test_exists_false(self):
 		cmd = Cmd(["nonexistentbinary12345"])
 		self.assertFalse(cmd.exists)
 		self.assertFalse(cmd.success)
 
+	def test_exists_sudo(self):
+		"""
+		Test exists functionality when used with sudo
+		:return:
+		"""
+		cmd = Cmd(["true"]).sudo('nobody')
+		self.assertTrue(cmd.exists)
+
+		cmd = Cmd(["nonexistentbinary12345"]).sudo('nobody')
+		self.assertFalse(cmd.exists)
+
 	def test_text(self):
+		"""
+		Test that .text returns the output of the command
+		:return:
+		"""
 		cmd = Cmd(["echo", "hello world"])
 		self.assertEqual(cmd.text, "hello world")
 
@@ -42,6 +60,15 @@ class TestCmd(unittest.TestCase):
 		with self.assertRaises(Exception):
 			_ = cmd.json
 
+	def test_cwd(self):
+		"""
+		Test that the cwd is set and used correctly
+
+		:return:
+		"""
+		cmd = Cmd(["pwd"]).cwd("/tmp")
+		self.assertEqual(cmd.text, "/tmp")
+
 
 if __name__ == "__main__":
 	unittest.main()

{warlock_manager-2.2.4 → warlock_manager-2.2.6}/tests/test_unreal_config.py

@@ -23,32 +23,32 @@ class TestUnrealConfig(unittest.TestCase):
         cfg = UnrealConfig('test', os.path.join(here, 'data', 'unreal_simple.ini'))
         # Configs are grouped by named parameters, so let's add some options
         cfg.add_option({
-            'name': 'Key1',
+            'name': 'Key 1',
             'section': 'SomeSection',
             'key': 'Key1',
         })
         cfg.add_option({
-            'name': 'Key2',
+            'name': 'Key 2',
             'section': 'SomeSection',
             'key': 'Key2',
             'type': 'int'
         })
         cfg.add_option({
-            'name': 'Key3',
+            'name': 'Key 3',
             'section': 'SomeSection',
             'key': 'Key3',
             'type': 'bool'
         })
         cfg.load()
 
-        self.assertEqual(cfg.get_value('Key1'), 'Value1')
-        self.assertEqual(cfg.get_value('Key2'), 42)
-        self.assertEqual(cfg.get_value('Key3'), True)
+        self.assertEqual(cfg.get_value('Key 1'), 'Value1')
+        self.assertEqual(cfg.get_value('Key 2'), 42)
+        self.assertEqual(cfg.get_value('Key 3'), True)
 
         # These values should exist
-        self.assertTrue(cfg.has_value('Key1'))
-        self.assertTrue(cfg.has_value('Key2'))
-        self.assertTrue(cfg.has_value('Key3'))
+        self.assertTrue(cfg.has_value('Key 1'))
+        self.assertTrue(cfg.has_value('Key 2'))
+        self.assertTrue(cfg.has_value('Key 3'))
 
         # This value should not
         self.assertFalse(cfg.has_value('NonExistentKey'))
@@ -58,14 +58,14 @@ class TestUnrealConfig(unittest.TestCase):
             expected = f.read()
         self.assertEqual(expected, cfg.fetch())
 
-        cfg.set_value('Key1', 'NewValue')
-        self.assertEqual(cfg.get_value('Key1'), 'NewValue')
+        cfg.set_value('Key 1', 'NewValue')
+        self.assertEqual(cfg.get_value('Key 1'), 'NewValue')
 
-        cfg.set_value('Key2', 100)
-        self.assertEqual(cfg.get_value('Key2'), 100)
+        cfg.set_value('Key 2', 100)
+        self.assertEqual(cfg.get_value('Key 2'), 100)
 
-        cfg.set_value('Key3', False)
-        self.assertEqual(cfg.get_value('Key3'), False)
+        cfg.set_value('Key 3', False)
+        self.assertEqual(cfg.get_value('Key 3'), False)
 
         # Ensure the generated data matches expectations
         expected = '''; This is a simple config file for testing purposes.
@@ -80,6 +80,61 @@ Key3=False
 '''
         self.assertEqual(expected, cfg.fetch())
 
+    def test_always_escape_strings(self):
+        cfg = UnrealConfig('test', os.path.join(here, 'data', 'unreal_simple.ini'))
+        cfg.always_escape_strings = True
+        # Configs are grouped by named parameters, so let's add some options
+        cfg.add_option({
+            'name': 'Key 1',
+            'section': 'SomeSection',
+            'key': 'Group/Key1',
+        })
+        cfg.add_option({
+            'name': 'Key 2',
+            'section': 'SomeSection',
+            'key': 'Group/Key2',
+            'type': 'int'
+        })
+        cfg.add_option({
+            'name': 'Key 3',
+            'section': 'SomeSection',
+            'key': 'Group/Key3',
+            'type': 'bool'
+        })
+
+        cfg.set_value('Key 1', 'Value1')
+        cfg.set_value('Key 2', 42)
+        cfg.set_value('Key 3', True)
+
+        self.assertEqual(cfg.get_value('Key 1'), 'Value1')
+        self.assertEqual(cfg.get_value('Key 2'), 42)
+        self.assertEqual(cfg.get_value('Key 3'), True)
+
+        # These values should exist
+        self.assertTrue(cfg.has_value('Key 1'))
+        self.assertTrue(cfg.has_value('Key 2'))
+        self.assertTrue(cfg.has_value('Key 3'))
+
+        # This value should not
+        self.assertFalse(cfg.has_value('NonExistentKey'))
+
+        # Ensure the generated data matches expectations
+        expected = '[SomeSection]\nGroup=(Key1="Value1",Key2=42,Key3=True)\n'
+        self.assertEqual(expected, cfg.fetch())
+
+        cfg.set_value('Key 1', 'NewValue')
+        self.assertEqual(cfg.get_value('Key 1'), 'NewValue')
+
+        cfg.set_value('Key 2', 100)
+        self.assertEqual(cfg.get_value('Key 2'), 100)
+
+        cfg.set_value('Key 3', False)
+        self.assertEqual(cfg.get_value('Key 3'), False)
+
+        # Ensure the generated data matches expectations
+        expected = '[SomeSection]\nGroup=(Key1="NewValue",Key2=100,Key3=False)\n'
+        self.assertEqual(expected, cfg.fetch())
+
     def test_simple_create(self):
         cfg = UnrealConfig('test', os.path.join(here, 'data', 'unreal_simple.ini'))
         # Configs are grouped by named parameters, so let's add some options
@@ -247,6 +302,9 @@ PlayedMaps=NewMap2_WP
         })
         cfg.load()
 
+        self.assertTrue(cfg.has_value('Difficulty'))
+        self.assertFalse(cfg.has_value('I do not exist'))
+
         self.assertEqual(cfg.get_value('Difficulty'), 'None')
         self.assertEqual(cfg.get_value('Randomizer Seed'), '')
         self.assertEqual(cfg.get_value('Randomizer Pal Level Random'), False)
@@ -256,6 +314,14 @@ PlayedMaps=NewMap2_WP
             expected = f.read()
         self.assertEqual(expected, cfg.fetch())
 
+        cfg.set_value('Difficulty', 'Super Duper Hard')
+        cfg.set_value('Randomizer Seed', 'Random Seed')
+        cfg.set_value('Randomizer Pal Level Random', True)
+
+        self.assertEqual(cfg.get_value('Difficulty'), 'Super Duper Hard')
+        self.assertEqual(cfg.get_value('Randomizer Seed'), 'Random Seed')
+        self.assertEqual(cfg.get_value('Randomizer Pal Level Random'), True)
+
     def test_palworld_empty(self):
         """
         Test that the Palworld format works even when the ini is empty.

{warlock_manager-2.2.4 → warlock_manager-2.2.6}/warlock_manager/apps/base_app.py

@@ -88,7 +88,6 @@ class BaseApp(ABC):
 			'api',  # Game supports baseline API features
 			'cmd',  # Game supports commands sent via the API
 			'create_service',  # Game supports creating new services
-			'mods',  # Game supports mods
 		}
 		"""
 		List of features available in this game
@@ -576,7 +575,7 @@ class BaseApp(ABC):
 		except urllib_error.HTTPError as e:
 			print('Could not notify Discord: %s' % e)
 
-	@deprecated("Please use get_app_directory() from utils instead.")
+	@deprecated("Please use get_base_directory() from utils instead.")
 	def get_app_directory(self) -> str:
 		"""
 		Get the base directory for this game installation.
@@ -585,7 +584,7 @@ class BaseApp(ABC):
 
 		:return:
 		"""
-		return utils.get_app_directory()
+		return utils.get_base_directory()
 
 	@deprecated("Please use get_home_directory() from utils instead")
 	def get_home_directory(self) -> str:
@@ -663,8 +662,8 @@ class BaseApp(ABC):
 				logging.info('Removed config file for %s at %s' % (self.name, config.path))
 
 		# Cleanup directory structure
-		shutil.rmtree(os.path.join(utils.get_app_directory(), 'AppFiles'))
-		shutil.rmtree(os.path.join(utils.get_app_directory(), 'Environments'))
+		shutil.rmtree(os.path.join(utils.get_base_directory(), 'AppFiles'))
+		shutil.rmtree(os.path.join(utils.get_base_directory(), 'Environments'))
 
 	def remove_service(self, service_name: str):
 		"""
@@ -689,7 +688,7 @@ class BaseApp(ABC):
 		Try to detect available services for this game.
 		:return:
 		"""
-		envs = os.path.join(utils.get_app_directory(), 'Environments')
+		envs = os.path.join(utils.get_base_directory(), 'Environments')
 		if os.path.exists(envs):
 			# Each service should have a file here, named as {service}.env
 			services = []
@@ -724,9 +723,9 @@ class BaseApp(ABC):
 		"""
 
 		# Ensure some baseline directories exist with the correct ownership and permissions
-		utils.makedirs(os.path.join(utils.get_app_directory(), 'Backups'))
-		utils.makedirs(os.path.join(utils.get_app_directory(), 'AppFiles'))
-		utils.makedirs(os.path.join(utils.get_app_directory(), 'Environments'))
+		utils.makedirs(os.path.join(utils.get_base_directory(), 'Backups'))
+		utils.makedirs(os.path.join(utils.get_base_directory(), 'AppFiles'))
+		utils.makedirs(os.path.join(utils.get_base_directory(), 'Environments'))
 
 		return True
 

{warlock_manager-2.2.4 → warlock_manager-2.2.6}/warlock_manager/apps/steam_app.py

@@ -317,7 +317,7 @@ class SteamApp(BaseApp, ABC):
 
 		:return:
 		"""
-		app_manifest = os.path.join(utils.get_app_directory(), 'AppFiles', 'steamapps', 'appmanifest_%s.acf' % self.steam_id)
+		app_manifest = os.path.join(utils.get_base_directory(), 'AppFiles', 'steamapps', 'appmanifest_%s.acf' % self.steam_id)
 
 		if not os.path.exists(app_manifest):
 			print(f"App manifest file {app_manifest} does not exist.", file=sys.stderr)
@@ -395,7 +395,7 @@ class SteamApp(BaseApp, ABC):
 		cmd = Cmd([
 			guess_steamcmd_path(),
 			'+force_install_dir',
-			os.path.join(utils.get_app_directory(), 'AppFiles'),
+			os.path.join(utils.get_base_directory(), 'AppFiles'),
 			'+login',
 			'anonymous',
 			'+app_update',

{warlock_manager-2.2.4 → warlock_manager-2.2.6}/warlock_manager/config/unreal_config.py

@@ -12,9 +12,64 @@ class UnrealConfig(BaseConfig):
 		super().__init__(group_name)
 		self.path = path
 		self._data = []
-		self._values = {}
 		self._use_array_operators = False
 		self._is_changed = False
+		self.always_escape_strings = False
+		"""
+		Set to True to always escape strings in Configuration files.  Some games require this.
+		"""
+
+	def _get_raw_value(self, name: str):
+		"""
+		Get the raw value, possibly in a nested dictionary.
+
+		useful for get_value and has_value.
+
+		:param name: Name of the option
+		:return:
+		"""
+		if name not in self.options:
+			return None
+		opt = self.options[name]
+
+		# Check if this section exists, also serves to find the section.
+		section = None
+		for sec in self._data:
+			if sec[0]['type'] == 'section' and sec[0]['value'] == opt.section:
+				section = sec[1:]
+				break
+		if section is None:
+			return None
+
+		if '/' in opt.key:
+			# Look for a key inside structured data (aka a dict)
+			group = opt.key.split('/')[0]
+			for sec in section:
+				if sec['key'] == group:
+					current = sec['value']
+					for part in opt.key.split('/')[1:]:
+						if part in current:
+							current = current[part]
+						else:
+							# Subkey does not exist in the value of this section config; doesn't exist.
+							return None
+					return current
+		else:
+			# Simple key.
+			ret = None
+			for sec in section:
+				if sec['type'] == 'keyvalue' and sec['key'] == opt.key:
+					# Unreal supports duplicate keys; these should be exposed as a list.
+					if ret is None:
+						ret = sec['value']
+					elif isinstance(ret, list):
+						ret.append(sec['value'])
+					else:
+						ret = [ret]
+						ret.append(sec['value'])
+			return ret
+
+		return None
 
 	def get_value(self, name: str) -> Union[str, int, bool, list]:
 		"""
@@ -28,27 +83,11 @@ class UnrealConfig(BaseConfig):
 			return ''
 
 		opt = self.options[name]
-
-		if opt.section not in self._values:
-			val = opt.default
+		raw_value = self._get_raw_value(name)
+		if raw_value is None:
+			return opt.default
 		else:
-			if '/' in opt.key:
-				# Struct key
-				parts = opt.key.split('/')
-				current = self._values[opt.section]
-				for part in parts:
-					if part in current:
-						current = current[part]
-					else:
-						current = opt.default
-						break
-				val = current
-			elif opt.key not in self._values[opt.section]:
-				val = opt.default
-			else:
-				val = self._values[opt.section][opt.key]
-
-		return opt.to_system_type(val)
+			return opt.to_system_type(raw_value)
 
 	def _find_or_create_value(self, section: list, key: str, str_value: Union[str, list]) -> list:
 		"""
@@ -136,9 +175,14 @@ class UnrealConfig(BaseConfig):
 		opt = self.options[name]
 		str_value = self.from_system_type(name, value)
 
-		if opt.section not in self._values:
+		# Create the section if necessary
+		exists = False
+		for sec in self._data:
+			if sec[0]['type'] == 'section' and sec[0]['value'] == opt.section:
+				exists = True
+				break
+		if not exists:
 			# Create the section
-			self._values[opt.section] = {}
 			self._data.append([{'type': 'section', 'value': opt.section}])
 
 		# Ensure the updated value is in the data structure
@@ -157,7 +201,6 @@ class UnrealConfig(BaseConfig):
 				new_data.append(sec)
 
 		self._data = new_data
-		self._values[opt.section][opt.key] = str_value
 		self._is_changed = True
 
 	def has_value(self, name: str) -> bool:
@@ -167,17 +210,8 @@ class UnrealConfig(BaseConfig):
 		:param name: Name of the option
 		:return:
 		"""
-		if name not in self.options:
-			return False
-		opt = self.options[name]
-
-		if opt.section not in self._values:
-			return False
-		else:
-			if opt.key not in self._values[opt.section]:
-				return False
-			else:
-				return self._values[opt.section][opt.key] != ''
+		raw_value = self._get_raw_value(name)
+		return raw_value is not None
 
 	def exists(self) -> bool:
 		"""
@@ -194,7 +228,6 @@ class UnrealConfig(BaseConfig):
 		if os.path.exists(self.path):
 			with open(self.path, 'r', encoding='utf-8') as f:
 				section = []
-				last_section = ''
 				for line in f.readlines():
 					data = None
 					stripped = line.strip()
@@ -232,27 +265,6 @@ class UnrealConfig(BaseConfig):
 								self._data.append(section)
 							section = []
 							section.append(data)
-							last_section = data['value']
-						elif data['type'] == 'keystruct':
-							section.append(data)
-							if last_section not in self._values:
-								self._values[last_section] = {}
-							self._values[last_section][data['key']] = data['value']
-						elif data['type'] == 'keyvalue':
-							section.append(data)
-							if last_section not in self._values:
-								self._values[last_section] = {}
-							# Auto-handle duplicate keys by converting them to a list.
-							# UE is weird.
-							if data['key'] in self._values[last_section]:
-								# Existing key, convert to list
-								existing_value = self._values[last_section][data['key']]
-								if not isinstance(existing_value, list):
-									existing_value = [existing_value]
-								existing_value.append(data['value'])
-								self._values[last_section][data['key']] = existing_value
-							else:
-								self._values[last_section][data['key']] = data['value']
 						else:
 							section.append(data)
 				if len(section) > 0:
@@ -289,6 +301,10 @@ class UnrealConfig(BaseConfig):
 			# Boolean strings do not require quoting
 			return False
 
+		if self.always_escape_strings:
+			# Game requested to always escape strings
+			return True
+
 		if re.match(r'^[A-Za-z0-9]+$', s) is not None:
 			# Simple strings do not require quoting
 			return False

{warlock_manager-2.2.4 → warlock_manager-2.2.6}/warlock_manager/formatters/cli_formatter.py

@@ -10,6 +10,48 @@ def cli_formatter(
     true_value: str | bool = 'True',
     false_value: str | bool = 'False',
 ) -> str:
+    """
+    Format a given Configuration object as CLI arguments.
+
+    ## True/False Formatting
+
+    The most complicated part of this is handling true/false boolean values.
+
+    The default is to render bool TRUE values as -key_name=True and bool FALSE values as -key_name=False
+
+    Render bool TRUE values as -key_name and bool FALSE values are omitted completely
+
+    ```python
+    cli_formatter(..., prefix='-', true_value=True, false_value=False)
+    ```
+
+    The inverse is possible too, to omit TRUE values and only render FALSE values.
+
+    ```python
+    cli_formatter(..., prefix='-', true_value=False, false_value=True)
+    ```
+
+    Render bool TRUE values as -key_name=true and bool FALSE values as -key_name=false
+
+    ```python
+    cli_formatter(..., prefix='-', true_value='true', false_value='false')
+    ```
+
+    Render bool TRUE values as ?key_name:YUP and bool FALSE values as ?key_name:LULZNOPE
+
+    ```python
+    cli_formatter(..., prefix='?', sep=':', true_value='YUP', false_value='LULZNOPE')
+    ```
+
+    :param data:
+    :param section:
+    :param prefix:
+    :param sep:
+    :param joiner:
+    :param true_value:
+    :param false_value:
+    :return:
+    """
     values = []
     for opt in data.options.values():
         if opt.section != section:

{warlock_manager-2.2.4 → warlock_manager-2.2.6}/warlock_manager/libs/cache.py

@@ -8,7 +8,7 @@ from warlock_manager.libs import utils
 def get_cache(some_string: str, expires: int = 3600) -> str | None:
 	# Check cache prior to running the command.
 	cmd_hash = hashlib.sha256(some_string.encode()).hexdigest()
-	cache_path = os.path.join(utils.get_app_directory(), '.cache', cmd_hash)
+	cache_path = os.path.join(utils.get_base_directory(), '.cache', cmd_hash)
 	if os.path.exists(cache_path) and os.path.getmtime(cache_path) > time.time() - expires:
 		with open(cache_path, "r") as f:
 			return f.read()
@@ -17,13 +17,13 @@ def get_cache(some_string: str, expires: int = 3600) -> str | None:
 
 
 def save_cache(some_string: str, content: str):
-	cache_path = os.path.join(utils.get_app_directory(), '.cache')
+	cache_path = os.path.join(utils.get_base_directory(), '.cache')
 	if not os.path.exists(cache_path):
 		os.makedirs(cache_path)
 		utils.ensure_file_ownership(cache_path)
 
 	cmd_hash = hashlib.sha256(some_string.encode()).hexdigest()
-	cache_path = os.path.join(utils.get_app_directory(), '.cache', cmd_hash)
+	cache_path = os.path.join(utils.get_base_directory(), '.cache', cmd_hash)
 	with open(cache_path, "w") as f:
 		f.write(content)
 	utils.ensure_file_ownership(cache_path)

{warlock_manager-2.2.4 → warlock_manager-2.2.6}/warlock_manager/libs/cmd.py

@@ -3,6 +3,7 @@ import subprocess
 import json
 import logging
 import time
+import pwd
 
 from warlock_manager.libs import cache
 
@@ -39,7 +40,7 @@ class Cmd:
 		CompletedProcess: The result of the command execution
 		"""
 
-		self.executable: str | None = cmd[0] if len(cmd) > 0 else None
+		self.executable: str | None = self.cmd[0] if len(self.cmd) > 0 else None
 		"""
 		str: The executable name of the command
 		"""
@@ -65,7 +66,12 @@ class Cmd:
 		These commands are NOT persistent across calls!
 		"""
 
-	def sudo(self, runas: str | int):
+		self._cwd: str | None = None
+		"""
+		The current working directory for this command
+		"""
+
+	def sudo(self, runas: str | int) -> 'Cmd':
 		"""
 		Run this command as another user using sudo.
 
@@ -78,55 +84,73 @@ class Cmd:
 		:return:
 		"""
 		if isinstance(runas, str):
-			if os.getlogin() == runas:
+			# Get the name of the user owning the current process
+			# use pwd instead of os.getlogin to address CI tests on 3.13
+			current_user = pwd.getpwuid(os.geteuid()).pw_name
+			if current_user == runas:
 				# If we're already running as this user, no need to prefix with sudo
-				return
+				return self
 			prefix = ['sudo', '-u', runas]
 		else:
 			if os.geteuid() == runas:
 				# If we're already running as this user, no need to prefix with sudo
-				return
+				return self
 			prefix = ['sudo', '-u', '#%s' % runas]
 
 		self.cmd = prefix + self.cmd
 		self.result = None
+		return self
 
-	def use_stdout(self):
+	def use_stdout(self) -> 'Cmd':
 		"""
 		Set this command to use stdout for output instead of stderr.
 		:return:
 		"""
 		self.uses = 'stdout'
+		return self
 
-	def use_stderr(self):
+	def use_stderr(self) -> 'Cmd':
 		"""
 		Set this command to use stderr for output instead of stdout.
 		:return:
 		"""
 		self.uses = 'stderr'
+		return self
 
-	def stream_output(self):
+	def stream_output(self) -> 'Cmd':
 		"""
 		Set this command to stream to stdout/stderr directly.  Useful for long-running commands.
 		:return:
 		"""
 		self.uses = None
+		return self
 
-	def is_cacheable(self, expires: int = 3600):
+	def is_cacheable(self, expires: int = 3600) -> 'Cmd':
 		"""
 		Set this command as cacheable for N seconds.
 		:param expires:
 		:return:
 		"""
 		self.cacheable = expires
+		return self
 
-	def is_memory_cacheable(self, expires: int = 2):
+	def is_memory_cacheable(self, expires: int = 2) -> 'Cmd':
 		"""
 		Set this command as cacheable in memory for N seconds.
 		:param expires:
 		:return:
 		"""
 		self.memory_cacheable = expires
+		return self
+
+	def cwd(self, path: str | None) -> 'Cmd':
+		"""
+		Set the current working directory for this command.
+		:param path:
+		:return:
+		"""
+		self._cwd = path
+		return self
 
 	@property
 	def exists(self) -> bool:
@@ -230,6 +254,7 @@ class Cmd:
 					self.cmd,
 					capture_output=capture_output,
 					check=False,
+					cwd=self._cwd,
 					encoding='utf-8'
 				)
 			except FileNotFoundError as e:
@@ -265,21 +290,54 @@ class Cmd:
 
 		return self.result
 
-	def extend(self, args: list):
+	def extend(self, args: list) -> 'Cmd':
 		"""
 		Extend the command with additional arguments.
 		:param args:
 		"""
 		self.cmd = self.cmd + args
 		self.result = None
+		return self
 
-	def append(self, arg: str):
+	def append(self, arg: str) -> 'Cmd':
 		"""
 		Append a single argument to the command.
 		:param arg:
 		"""
 		self.cmd.append(arg)
 		self.result = None
+		return self
+
+
+class PipeCmd(Cmd):
+	"""
+	Convenience wrapper for piping command output to a parent process
+	"""
+
+	def run(self):
+		"""
+		Run the command in the background using nohup. Caches the result so subsequent calls don't re-run the command.
+
+		:return:
+		"""
+		if self.result is None:
+
+			if self.cacheable is not False:
+				logging.warning('Piped commands cannot be cached!')
+
+			try:
+				logging.debug('Running piped command: %s' % ' '.join(self.cmd))
+				self.result = subprocess.Popen(
+					self.cmd,
+					stdout=subprocess.PIPE,
+					stderr=subprocess.PIPE
+				)
+			except FileNotFoundError as e:
+				self.result = CmdFakeResponse('', str(e), 127)
+			except OSError as e:
+				self.result = CmdFakeResponse('', str(e), 1)
+
+		return self.result
 
 
 class BackgroundCmd(Cmd):
@@ -299,11 +357,11 @@ class BackgroundCmd(Cmd):
 				logging.warning('Background commands cannot be cached!')
 
 			try:
+				logging.debug('Running background command: %s' % ' '.join(self.cmd))
 				self.result = subprocess.Popen(
 					self.cmd,
 					stdout=subprocess.DEVNULL,
-					stderr=subprocess.DEVNULL,
-					preexec_fn=lambda: logging.debug('Running background command: %s' % ' '.join(self.cmd))
+					stderr=subprocess.DEVNULL
 				)
 			except FileNotFoundError as e:
 				self.result = CmdFakeResponse('', str(e), 127)

{warlock_manager-2.2.4 → warlock_manager-2.2.6}/warlock_manager/libs/firewall.py

@@ -1,4 +1,5 @@
 from warlock_manager.libs.cmd import Cmd
+import logging
 
 
 class Firewall:
@@ -79,7 +80,7 @@ class Firewall:
 		return None
 
 	@classmethod
-	def allow(cls, port: int, protocol: str = 'tcp', comment: str = None) -> None:
+	def allow(cls, port: int, protocol: str = 'tcp', comment: str = None) -> bool:
 		"""
 		Allows a specific port through the system's firewall.
 		Supports UFW, Firewalld, and iptables.
@@ -90,30 +91,47 @@ class Firewall:
 			comment (str, optional): An optional comment for the rule. Defaults to None.
 		"""
 
+		if port <= 0 or port >= 65536:
+			logging.error(f"Invalid port number: {port}")
+			return False
+
+		if protocol.lower() not in ['tcp', 'udp']:
+			logging.error(f"Invalid protocol: {protocol}")
+			return False
+
 		firewall = cls.get_available()
 
 		if firewall == 'ufw':
+			# UFW requires the protocol to be all lowercase.
+			protocol = protocol.lower()
+			logging.info(f"Allowing {port}/{protocol} via UFW")
 			cmd = Cmd(['ufw', 'allow', f'{port}/{protocol}'])
 			if comment:
 				cmd.extend(['comment', comment])
-			cmd.run()
+			return cmd.success
 
 		elif firewall == 'firewalld':
-			Cmd(['firewall-cmd', '--permanent', '--add-port', f'{port}/{protocol}']).run()
-			Cmd(['firewall-cmd', '--reload']).run()
+			logging.info(f"Allowing {port}/{protocol} via Firewalld")
+			if Cmd(['firewall-cmd', '--permanent', '--add-port', f'{port}/{protocol}']).success:
+				Cmd(['firewall-cmd', '--reload']).run()
+				return True
 
 		elif firewall == 'iptables':
+			logging.info(f"Allowing {port}/{protocol} via iptables")
 			cmd = Cmd(['iptables', '-A', 'INPUT', '-p', protocol, '--dport', str(port), '-j', 'ACCEPT'])
 			if comment:
 				cmd.extend(['-m', 'comment', '--comment', comment])
-			cmd.run()
-			Cmd(['service', 'iptables', 'save']).run()
+			if cmd.success:
+				Cmd(['service', 'iptables', 'save']).run()
+				return True
 
 		else:
-			raise OSError("No supported firewall found on the system.")
+			logging.error('No supported firewall found on the system.')
+
+		return False
 
 	@classmethod
-	def remove(cls, port: int, protocol: str = 'tcp') -> None:
+	def remove(cls, port: int, protocol: str = 'tcp') -> bool:
 		"""
 		Removes a specific port from the system's firewall.
 		Supports UFW, Firewalld, and iptables.
@@ -123,21 +141,33 @@ class Firewall:
 			protocol (str, optional): The protocol to use ('tcp' or 'udp'). Defaults to 'tcp'.
 		"""
 
+		if port <= 0 or port >= 65536:
+			logging.error(f"Invalid port number: {port}")
+			return False
+
+		if protocol.lower() not in ['tcp', 'udp']:
+			logging.error(f"Invalid protocol: {protocol}")
+			return False
+
 		firewall = cls.get_available()
 
 		if firewall == 'ufw':
-			Cmd(['ufw', 'delete', 'allow', f'{port}/{protocol}']).run()
+			return Cmd(['ufw', 'delete', 'allow', f'{port}/{protocol}']).success
 
 		elif firewall == 'firewalld':
-			Cmd(['firewall-cmd', '--permanent', '--remove-port', f'{port}/{protocol}']).run()
-			Cmd(['firewall-cmd', '--reload']).run()
+			if Cmd(['firewall-cmd', '--permanent', '--remove-port', f'{port}/{protocol}']).success:
+				Cmd(['firewall-cmd', '--reload']).run()
+				return True
 
 		elif firewall == 'iptables':
-			Cmd(['iptables', '-D', 'INPUT', '-p', protocol, '--dport', str(port), '-j', 'ACCEPT']).run()
-			Cmd(['service', 'iptables', 'save']).run()
+			if Cmd(['iptables', '-D', 'INPUT', '-p', protocol, '--dport', str(port), '-j', 'ACCEPT']).success:
+				Cmd(['service', 'iptables', 'save']).run()
+				return True
 
 		else:
-			raise OSError("No supported firewall found on the system.")
+			logging.error('No supported firewall found on the system.')
+
+		return False
 
 	@classmethod
 	def is_global_open(cls, port: int, protocol: str = 'tcp') -> bool:
@@ -163,7 +193,8 @@ class Firewall:
 			ufw_check = Cmd(['ufw', 'status'])
 			ufw_check.is_memory_cacheable(3)
 			result = ufw_check.text
-			port_proto = f"{port}/{protocol}"
+			# UFW requires the protocol to be all lowercase.
+			port_proto = f"{port}/{protocol}".lower()
 			for line in result.splitlines():
 				if port_proto in line and "ALLOW" in line and ("Anywhere" in line or "Anywhere (v6)" in line):
 					return True
@@ -188,4 +219,5 @@ class Firewall:
 			return False
 
 		else:
-			raise OSError("No supported firewall found on the system.")
+			logging.error('No supported firewall found on the system.')
+			return True  # No firewall means it's probably enabled by default, so we return true.

{warlock_manager-2.2.4 → warlock_manager-2.2.6}/warlock_manager/libs/utils.py

@@ -2,8 +2,10 @@ import logging
 import os
 import pwd
 import sys
+from typing_extensions import deprecated
 
 
+@deprecated('Please use utils.get_base_directory instead to avoid confusion')
 def get_app_directory() -> str:
 	"""
 	Get the base directory for this game installation.
@@ -15,6 +17,17 @@ def get_app_directory() -> str:
 	return os.path.dirname(os.path.realpath(sys.argv[0]))
 
 
+def get_base_directory() -> str:
+	"""
+	Get the base directory for this game installation.
+
+	This directory usually will contain manage.py, AppFiles, Backups, and other related files.
+
+	:return:
+	"""
+	return os.path.dirname(os.path.realpath(sys.argv[0]))
+
+
 def get_home_directory() -> str:
 	"""
 	Get the home directory of the user running this application

{warlock_manager-2.2.4 → warlock_manager-2.2.6}/warlock_manager/mods/base_mod.py

@@ -195,7 +195,7 @@ class BaseMod:
 			logging.error('Mod install package not found!')
 			return False
 
-		target_archive = os.path.join(utils.get_app_directory(), 'Packages', self.package)
+		target_archive = os.path.join(utils.get_base_directory(), 'Packages', self.package)
 		if not os.path.exists(target_archive):
 			download_file(self.source, target_archive)
 		else:
@@ -242,7 +242,7 @@ class BaseMod:
 		Get all registered mods, eg all mods which are present in the registration file
 		:return:
 		"""
-		mods_path = os.path.join(utils.get_app_directory(), 'Packages', 'mods.json')
+		mods_path = os.path.join(utils.get_base_directory(), 'Packages', 'mods.json')
 		if not os.path.exists(mods_path):
 			# No mods installed; mods cache is empty.
 			return []
@@ -264,7 +264,11 @@ class BaseMod:
 		:param mods:
 		:return:
 		"""
-		mods_path = os.path.join(utils.get_app_directory(), 'Packages', 'mods.json')
+		mods_directory = os.path.join(utils.get_base_directory(), 'Packages')
+		if not os.path.exists(mods_directory):
+			utils.makedirs(mods_directory)
+
+		mods_path = os.path.join(utils.get_base_directory(), 'Packages', 'mods.json')
 
 		flat_mods = []
 		for mod in mods:

{warlock_manager-2.2.4 → warlock_manager-2.2.6}/warlock_manager/nexus/nexus.py

@@ -275,6 +275,12 @@ class Nexus:
 			'X-Host-Token': self.host_auth,
 		}
 
+		if self.game is None:
+			return {
+				'success': False,
+				'message': 'Game not set',
+			}
+
 		try:
 			url = self.base_url + '/mod/search/' + self.game
 			params = {
@@ -306,6 +312,12 @@ class Nexus:
 			'X-Host-Token': self.host_auth,
 		}
 
+		if self.game is None:
+			return {
+				'success': False,
+				'message': 'Game not set',
+			}
+
 		try:
 			url = self.base_url + '/mod/get/' + self.game + '/' + str(provider) + '/' + str(mod_id)
 			params = {}

{warlock_manager-2.2.4 → warlock_manager-2.2.6}/warlock_manager/services/base_service.py

@@ -49,7 +49,7 @@ class BaseService(ABC):
 		used for checking existence and loading configuration options from the file
 		"""
 
-		self._env_file = os.path.join(utils.get_app_directory(), 'Environments', '%s.env' % service)
+		self._env_file = os.path.join(utils.get_base_directory(), 'Environments', '%s.env' % service)
 		"""
 		:type str:
 		Fully resolved path on the filesystem for the environmental variable for this service
@@ -1274,13 +1274,23 @@ class BaseService(ABC):
 				continue
 
 			port = self.get_option_value(port_config[0])
+			port_default = self.get_option_default(port_config[0])
 			if port == 0:
 				# This port does not have a default value, probably not enabled by default.
 				continue
 			new_port = self.game.get_next_available_port(self, port, port_config[1])
 
+			if port_default == new_port:
+				# New installations where the default port may not trigger the 'change' logic
+				# as the port _technically_ didn't change, therefore the firewall rules won't be added.
+				logging.info('Setting %s to 0 to force firewall change' % port_config[0])
+				self.set_option(port_config[0], 0)
+
 			self.set_option(port_config[0], new_port)
-			logging.info('Set %s to %s to try to avoid conflicts' % (port_config[0], new_port))
+			if new_port != port:
+				logging.info('Set %s to %s to try to avoid conflicts' % (port_config[0], new_port))
+			else:
+				logging.info('Set %s to %s' % (port_config[0], new_port))
 
 		# Reload systemd to pick up the new service
 		self.reload()
@@ -1715,14 +1725,14 @@ class BaseService(ABC):
 				utils.makedirs(target_file)
 			elif source == '@':
 				# Source is the package itself; this just copies the entire mod into the destination.
-				source_file = os.path.join(utils.get_app_directory(), 'Packages', mod.package)
+				source_file = os.path.join(utils.get_base_directory(), 'Packages', mod.package)
 				logging.info('Copying %s -> %s' % (source_file, target_file))
 				shutil.copy(source_file, target_file)
 				utils.ensure_file_ownership(target_file)
 			elif source.startswith('@:'):
 				# Source is a file within the package, (usually a ZIP archive)
 				source_file = source[2:]
-				source_archive = os.path.join(utils.get_app_directory(), 'Packages', mod.package)
+				source_archive = os.path.join(utils.get_base_directory(), 'Packages', mod.package)
 				if source_archive.endswith('.zip'):
 					logging.info('Extracting %s -> %s' % (source_file, target_file))
 					with ZipFile(source_archive, 'r') as zip_ref:

{warlock_manager-2.2.4 → warlock_manager-2.2.6}/warlock_manager.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: warlock-manager
-Version: 2.2.4
+Version: 2.2.6
 Summary: Dependency library for game-server management applications.
 Author-email: Charlie Powell <cdp1337@bitsnbytes.dev>
 Maintainer-email: Charlie Powell <cdp1337@bitsnbytes.dev>