PrEditor 0.0.0.dev1__py2.py3-none-any.whl → 0.1.0__py2.py3-none-any.whl

preditor/osystem.py

@@ -0,0 +1,401 @@
+"""
+This module provides additional methods that aren't easily found in existing
+python or Qt modules for cross-platform usage.
+
+The osystem module provides a number of functions to make dealing with
+paths and other platform-specific things in a more abstract platform-agnostic
+way.
+"""
+from __future__ import absolute_import, print_function
+
+import os
+import subprocess
+import sys
+from builtins import str as text
+
+import preditor
+
+from . import settings
+
+
+def getPointerSize():
+    import struct
+
+    try:
+        size = struct.calcsize('P')
+    except struct.error:
+        # Older installations can only query longs
+        size = struct.calcsize('l')
+    size *= 8
+    global getPointerSize
+
+    def getPointerSize():
+        return size
+
+    return size
+
+
+# Get the active version of python, not a hard coded value.
+def pythonPath(pyw=False, architecture=None):
+    if settings.OS_TYPE != 'Windows':
+        return 'python'
+    from distutils.sysconfig import get_python_inc
+
+    # Unable to pull the path from the registry just use the current python path
+    basepath = os.path.split(get_python_inc())[0]
+    # build the path to the python executable. If requested use pythonw instead of
+    # python
+    return os.path.join(basepath, 'python{w}.exe'.format(w=pyw and 'w' or ''))
+
+
+def defaultLogFile(filename='preditorProtocol.log'):
+    """Returns a default log file path often used for redirecting stdout/err to.
+    Uses the `BDEV_PATH_BLUR` environment variable as the basepath.
+
+    Args:
+        filename (str, optional): filename to log to.
+    """
+    basepath = expandvars(os.environ['BDEV_PATH_BLUR'])
+    return os.path.join(basepath, filename)
+
+
+def expandvars(text, cache=None):
+    """
+    Recursively expands the text variables, vs. the os.path.expandvars
+    method which only works at one level.
+
+    :param text: text string to expand
+    :type text: str
+    :param cache: used internally during recursion to prevent infinite loop
+    :type cache: dict
+    :rtype: str
+
+    """
+    # make sure we have data
+    if not text:
+        return ''
+
+    import re
+
+    # check for circular dependencies
+    if cache is None:
+        cache = {}
+
+    # return the cleaned variable
+    output = str(text)
+    keys = re.findall(r'\$(\w+)|\${(\w+)\}|\%(\w+)\%', text)
+
+    for first, second, third in keys:
+        repl = ''
+        key = ''
+        if first:
+            repl = '$%s' % first
+            key = first
+        elif second:
+            repl = '${%s}' % second
+            key = second
+        elif third:
+            repl = '%%%s%%' % third
+            key = third
+        else:
+            continue
+
+        value = os.environ.get(key)
+        if value:
+            if key not in cache:
+                cache[key] = value
+                value = expandvars(value, cache)
+            else:
+                print(
+                    'WARNING! %s environ variable contains a circular dependency' % key
+                )
+                value = cache[key]
+        else:
+            value = repl
+
+        output = output.replace(repl, value)
+
+    return output
+
+
+def explore(filename, dirFallback=False):
+    """Launches the provided filename in the prefered editor for the specific platform.
+
+    Args:
+        filename (str): The file path to explore to.
+        dirFallback (bool): If True, and the file path does not exist, explore to
+            the deepest folder that does exist.
+
+    Returns:
+        bool: If it was able to explore the filename.
+    """
+    # pull the file path from the inputed filename
+    fpath = os.path.normpath(filename)
+
+    if dirFallback:
+        # If the provided filename does not exist, recursively check each parent folder
+        # for existence.
+        while not os.path.exists(fpath) and not os.path.ismount(fpath):
+            fpath = os.path.split(fpath)[0]
+
+    # run the file in windows
+    if settings.OS_TYPE == 'Windows':
+        env = subprocessEnvironment()
+        if os.path.isfile(fpath):
+            subprocess.Popen(r'explorer.exe /select, "{}"'.format(fpath), env=env)
+            return True
+        subprocess.Popen(r'explorer.exe "{}"'.format(fpath), env=env)
+        return True
+
+    # run the file in linux
+    elif settings.OS_TYPE == 'Linux':
+        cmd = expandvars(os.environ.get('BDEV_CMD_BROWSE', ''))
+        if not cmd:
+            return False
+        subprocess.Popen(cmd % {'filepath': fpath}, shell=True)
+        return True
+    return False
+
+
+def subprocessEnvironment(env=None):
+    """Returns a copy of the environment that will restore a new python instance to
+    current state.
+
+    Provides a environment dict that can be passed to subprocess.Popen that will restore
+    the current treegrunt environment settings, and blurdev stylesheet. It also resets
+    any environment variables set by a dcc that may cause problems when running a
+    subprocess.
+
+    Args:
+
+        env (dict, Optional): The base dictionary that is modified with blurdev
+            variables. if None(default) it will be populated with a copy of os.environ.
+
+    Returns:
+        dict: A list of environment variables to be passed to subprocess's env argument.
+    """
+    if env is None:
+        env = os.environ.copy()
+
+    # By default libstone adds "C:\Windows\System32\blur64" or "C:\blur\common" to
+    # QApplication.libraryPaths(), setting this env var to a invalid path disables that.
+    # Leaving this set likely will cause the subprocess to not be configured correctly.
+    # The subprocess should be responsible for setting this variable
+    if 'LIBSTONE_QT_LIBRARY_PATH' in env:
+        del env['LIBSTONE_QT_LIBRARY_PATH']
+
+    # If PYTHONPATH is being used, attempt to reset it to the system value.
+    # Applications like maya add PYTHONPATH, and this breaks subprocesses.
+    if env.get('PYTHONPATH'):
+        if settings.OS_TYPE == 'Windows':
+            try:
+                # Store the 'PYTHONPATH' from the system registry if set
+                env['PYTHONPATH'] = getEnvironmentVariable('PYTHONPATH')
+            except WindowsError:
+                # If the registry is not set, then remove the variable
+                del env['PYTHONPATH']
+
+    # If PYTHONHOME is used, just remove it. This variable is supposed to point
+    # to a folder relative to the python stdlib
+    # Applications like Houdini add PYTHONHOME, and it breaks the subprocesses
+    if env.get('PYTHONHOME'):
+        if settings.OS_TYPE == 'Windows':
+            try:
+                # Store the 'PYTHONHOME' from the system registry if set
+                env['PYTHONHOME'] = getEnvironmentVariable('PYTHONHOME')
+            except WindowsError:
+                # If the registry is not set, then remove the variable
+                del env['PYTHONHOME']
+
+    # Some DCC's require inserting or appending path variables. When using subprocess
+    # these path variables may cause problems with the target application. This allows
+    # removing those path variables from the environment being passed to subprocess.
+    def normalize(i):
+        return os.path.normpath(os.path.normcase(i))
+
+    removePaths = set([normalize(x) for x in preditor.core._removeFromPATHEnv])
+
+    # blurpath records any paths it adds to the PATH variable and other env variable
+    # modifications it makes, revert these changes.
+    try:
+        import blurpath
+
+        # Restore the original environment variables stored by blurpath.
+        blurpath.resetEnvVars(env)  # blurpath v0.0.16 or newer
+    except ImportError:
+        pass
+    except AttributeError:
+        # TODO: Once blurpath v0.0.16 or newer is passed out, remove the
+        # outter AttributeError except block. Its just for backwards compatibility.
+        try:
+            removePaths.update([normalize(x) for x in blurpath.addedToPathEnv])
+        except AttributeError:
+            pass
+
+    path = env.get('PATH')
+    if path:
+        paths = [
+            x for x in path.split(os.path.pathsep) if normalize(x) not in removePaths
+        ]
+        path = os.path.pathsep.join(paths)
+        # subprocess does not accept unicode in python 2
+        if sys.version_info[0] == 2 and isinstance(path, text):
+            path = path.encode('utf8')
+        env['PATH'] = path
+
+    # settings.environStr does nothing in python3, so this code only needs
+    # to run in python2
+    if sys.version_info[0] < 3:
+        # subprocess explodes if it receives unicode in Python2 and in Python3,
+        # it explodes if it *doesn't* receive unicode.
+        temp = {}
+        for k, v in env.items():
+            # Attempt to remove any unicode objects. Ignore any conversion failures
+            try:
+                k = settings.environStr(k)
+            except Exception:
+                pass
+            try:
+                v = settings.environStr(v)
+            except AttributeError:
+                pass
+            temp[k] = v
+        env = temp
+
+    return env
+
+
+# --------------------------------------------------------------------------------
+#                               Read registy values
+# --------------------------------------------------------------------------------
+def getRegKey(registry, key, architecture=None, write=False):
+    """Returns a winreg hkey or none.
+
+    Args: registry (str): The registry to look in. 'HKEY_LOCAL_MACHINE' for example
+
+        key (str): The key to open. r'Software\\Autodesk\\Softimage\\InstallPaths' for
+            example
+
+        architecture (int | None): 32 or 64 bit. If None use system default.
+            Defaults to None
+
+    Returns:
+        A winreg handle object
+    """
+    # Do not want to import winreg unless it is neccissary
+    regKey = None
+    import winreg
+
+    aReg = winreg.ConnectRegistry(None, getattr(winreg, registry))
+    if architecture == 32:
+        sam = winreg.KEY_WOW64_32KEY
+    elif architecture == 64:
+        sam = winreg.KEY_WOW64_64KEY
+    else:
+        sam = 0
+    access = winreg.KEY_READ
+    if write:
+        access = winreg.KEY_WRITE
+    try:
+        regKey = winreg.OpenKey(aReg, key, 0, access | sam)
+    except WindowsError:
+        pass
+    return regKey
+
+
+def registryValue(registry, key, value_name, architecture=None):
+    """Returns the value and type of the provided registry key's value name.
+
+    Args:
+
+        registry (str): The registry to look in. 'HKEY_LOCAL_MACHINE' for example
+
+        key (str): The key to open. r'Software\\Autodesk\\Softimage\\InstallPaths' for
+            example
+
+        value_name (str): The name of the value to read. To read the '(Default)' key
+            pass a empty string.
+
+        architecture (int | None): 32 or 64 bit. If None use system default.
+            Defaults to None.
+
+    Returns:
+        object: Value stored in key
+        int: registry type for value. See winreg's Value Types
+    """
+    # Do not want to import winreg unless it is neccissary
+    regKey = getRegKey(registry, key, architecture=architecture)
+    if regKey:
+        import winreg
+
+        return winreg.QueryValueEx(regKey, value_name)
+    return '', 0
+
+
+def getEnvironmentRegKey(machine=False):
+    """Get the Registry Path and Key for the environment, either of the current
+    user or the system.
+
+    Args:
+        machine (bool, optional): If True, the system Environment location will
+            be returned.  Otherwise, the Environment location for the current
+            user will be returned.  Defaults to False.
+
+    Returns:
+        tuple: Returns a tuple of two strings (registry path, key).
+    """
+    registry = 'HKEY_CURRENT_USER'
+    key = r'Environment'
+    # Replace {PATH} with the existing path variable.
+    if machine:
+        registry = 'HKEY_LOCAL_MACHINE'
+        key = r'SYSTEM\CurrentControlSet\Control\Session Manager\Environment'
+    return registry, key
+
+
+def getEnvironmentVariable(value_name, system=None, default=None, architecture=None):
+    """Returns the environment variable stored in the windows registry.
+
+    Args:
+        value_name (str): The name of the environment variable to get the value of.
+        system (bool or None, optional): If True, then only look in the system
+            environment variables. If False, then only look at the user
+            environment variables. If None(default), then return the user value
+            if set, otherwise return the system value.
+        default: If the variable is not set, return this value.
+            If None(default) then a WindowsError is raised.
+        architecture (int or None): 32 or 64 bit. If None use system default.
+            Defaults to None.
+
+    Raises:
+        WindowsError: [Error 2] is returned if the environment variable is not
+            stored in the requested registry. If you pass a default value other
+            than None this will not be raised.
+    """
+    if system is None and value_name.lower() == 'path':
+        msg = "PATH is a special environment variable, set system to True or False."
+        raise ValueError(msg)
+
+    if not system:
+        # system is None or False, so check user variables.
+        registry, key = getEnvironmentRegKey(False)
+        try:
+            return registryValue(registry, key, value_name, architecture=architecture)[
+                0
+            ]
+        except WindowsError:
+            pass
+        if system is False:
+            # If system is False, then return the default.
+            # If None, then check the system.
+            if default is None:
+                raise
+            return default
+
+    registry, key = getEnvironmentRegKey(True)
+    try:
+        return registryValue(registry, key, value_name, architecture=architecture)[0]
+    except WindowsError:
+        if default is None:
+            raise
+        return default

preditor/plugins.py

@@ -0,0 +1,65 @@
+from __future__ import absolute_import
+
+import logging
+
+import six
+
+if six.PY3:
+    from importlib_metadata import entry_points
+else:
+    import pkg_resources
+
+logger = logging.getLogger(__name__)
+
+
+class Plugins(object):
+    def about_module(self):
+        plugs = {}
+        for ep in self.iterator("preditor.plug.about_module"):
+            name = ep.name
+            if name in plugs:
+                logger.warning(
+                    'Duplicate "preditor.plug.about_module" plugin found with '
+                    'name "{}"'.format(name)
+                )
+            else:
+                plugs[name] = ep
+
+        # Sort the plugins alphabetically
+        for name in sorted(plugs.keys(), key=lambda i: i.lower()):
+            ep = plugs[name]
+            try:
+                result = ep.load()
+            except Exception as error:
+                result = "Error processing: {}".format(error)
+
+            yield name, result
+
+    def editor(self, name):
+        for plug_name, ep in self.editors(name):
+            return plug_name, ep.load()
+        return None, None
+
+    def editors(self, name=None):
+        for ep in self.iterator(group="preditor.plug.editors"):
+            if name and ep.name != name:
+                continue
+            yield ep.name, ep
+
+    def initialize(self, name=None):
+        for ep in self.iterator(group="preditor.plug.initialize"):
+            yield ep.load()
+
+    def logging_handlers(self, name=None):
+        for ep in self.iterator(group="preditor.plug.logging_handlers"):
+            yield ep.name, ep.load()
+
+    @classmethod
+    def iterator(cls, group=None, name=None):
+        """Iterates over the requested entry point yielding results."""
+        if six.PY3:
+            for ep in entry_points().select(group=group):
+                yield ep
+        else:
+            for ep in pkg_resources.iter_entry_points(group, name=name):
+                yield ep

preditor/prefs.py

@@ -0,0 +1,74 @@
+"""
+Module for handling user interface preferences
+
+"""
+from __future__ import absolute_import
+
+import os
+import sys
+
+# cache of all the preferences
+_cache = {}
+
+
+def backup():
+    """Saves a copy of the current preferences to a zip archive."""
+    import glob
+    import shutil
+
+    archive_base = "preditor_backup_"
+    # Save all prefs not just the current core_name.
+    prefs = prefs_path()
+    # Note: Using parent dir of prefs so we can use shutil.make_archive without
+    # backing up the previous backups.
+    parent_dir = os.path.join(os.path.dirname(prefs), "_backups")
+
+    # Get the next backup version number to use.
+    filenames = glob.glob(os.path.join(parent_dir, "{}*.zip".format(archive_base)))
+    version = 1
+    if filenames:
+        # Add one to the largest version that exists on disk.
+        version = int(os.path.splitext(max(filenames))[0].split(archive_base)[-1])
+        version += 1
+
+    # Build the file path to save the archive to.
+    archive_base = os.path.join(parent_dir, archive_base + "{:04}".format(version))
+
+    # Save the preferences to the given archive name.
+    zip_path = shutil.make_archive(archive_base, "zip", prefs)
+
+    return zip_path
+
+
+def browse(core_name):
+    from . import osystem
+
+    path = prefs_path(core_name)
+    osystem.explore(path)
+
+
+def existing():
+    """Returns a list of PrEditor preference path names that exist on disk."""
+    root = prefs_path()
+    return sorted(next(os.walk(root))[1], key=lambda i: i.lower())
+
+
+def prefs_path(filename=None, core_name=None):
+    """The path PrEditor's preferences are saved as a json file.
+
+    The enviroment variable `PREDITOR_PREF_PATH` is used if set, otherwise
+    it is saved in one of the user folders.
+    """
+    if "PREDITOR_PREF_PATH" in os.environ:
+        ret = os.environ["PREDITOR_PREF_PATH"]
+    else:
+        if sys.platform == "win32":
+            ret = "%appdata%/blur/preditor"
+        else:
+            ret = "$HOME/.blur/preditor"
+    ret = os.path.normpath(os.path.expandvars(os.path.expanduser(ret)))
+    if core_name:
+        ret = os.path.join(ret, core_name)
+    if filename:
+        ret = os.path.join(ret, filename)
+    return ret

{blurdev → preditor}/resource/environment_variables.html

@@ -1,38 +1,26 @@
-<html>
-<head/>
-<body>
-	<h1>blurdev</h1>
-	<hr>
-	<h2>blurdev Site variables:</h2>
-	<p><span style=" font-style:italic;">These variables should be defined at a user or system level to configure blurdev.</span></p>
-	<p><span style=" font-weight:bold;">BDEV_INCLUDE_*:</span> Contains a path that is inserted at index zero of sys.path. This is done in reverse alphabetical order.</p>
-	<p><span style=" font-weight:bold;">BDEV_DESIGNERPLUG_*:</span> Used to add a collection of designer plugins to QDesigner. Should be set to "XMLPATH,MODULE_DIR". XMLPATH is the full path to a xml file listing plugins to load. MODULE_DIR is a path that needs added to sys.path so the modules in XMLPATH are importable. You can use environment variables in these strings, they will be expanded. This is used by QDesigner, nothing else.</p>
-	<p><span style=" font-weight:bold;">BLURLIBSPATH:</span> Adds blurdev widgets to QtDesigner. It should contain the path to the folder containing the blurdev module. This is used by QDesigner, nothing else. This is used to populate BDEV_DESIGNERPLUG_BLUR with the correct values in settings.ini.</p>
-	<p><span style=" font-weight:bold;">BDEV_OFFLINE:</span> If set to 1, this indicates that blurdev is not running on the "Blur" network. This causes the [* Offline] section of blurdev/resource/settings.ini to override the [Default] and [*] sections. When blurdev is imported it adds all env vars defined in settings.ini for the current operating system  and Default if they are not already defined in os.environ.</p>
-	<p><span style=" font-weight:bold;">BDEV_PATH_PREFS:</span> This environment variable points to where per-computer user prefs are stored.</p>
-	<p><span style=" font-weight:bold;">BDEV_PATH_PREFS_SHARED:</span> This environment variable points to where shared user prefs are stored. This is often on the network and includes the os's logged in username in the path. If BDEV_OFFLINE is set to 1 this may point to the BDEV_PATH_PREFS location.</p>
-	<p><span style=" font-weight:bold;">BDEV_RESOURCES_CACHE:</span> This environment variable points to where blurdev's ResourceFinder should cache located resources in order to speed up code execution. By default this is set to a cache directory in the system's blur directory.</p>
-	<p><span style=" font-weight:bold;">BDEV_CACHE_RESOURCES:</span> This environment variable sets whether to enable or disable blurdev's ResourceFinder's caching capability. This should be set to "true" or "false". Caching is considered enabled by default if the environment variable is not found.</p>
-	<p></p>
-	<h2>blurdev Temp variables:</h2>
-	<p><span style=" font-style:italic;">These variables should not be defined all the time.</span></p>
-	<p><span style=" font-weight:bold;">BDEV_DISABLE_AUTORUN:</span> Set to "true" to disable the autorun.bat script used at blur. If this is not set when Maya shuts down, maya takes minutes to close. Maya uses several subprocess calls when closing and for some reason the doskey calls in the script take much longer than normal.</p>
-	<p><span style=" font-weight:bold;">BDEV_STYLESHEET:</span> Used to override the stylesheet when initalizing blurdev.</p>
-	<p><span style=" font-weight:bold;">BDEV_TOOL_ENVIRONMENT:</span> Forces blurdev to initialize with this treegrunt environment name. When saving prefs, this environment name change will not be saved. This is mostly used to ensure that launching a subprocess or farm job happens on the same treegrunt environment.</p>
-	<p></p>
-	<h2>Sentry variables:</h2>
-	<p><span style=" font-style:italic;">These variables control the behavior of Sentry's integration in blurdev.</span></p>
-	<p><span style=" font-weight:bold;">SENTRY_DSN:</span> Required for Sentry to initialize, defines the endpoint for Sentry to submit error events.</p>
-	<p><span style=" font-weight:bold;">SENTRY_DEBUG:</span> If set to 1 (or any value), Sentry will be initialized in debug mode providing granular output related to the underlying Sentry API (such as startup process progress and output for event transmission).</p>
-	<p><span style=" font-weight:bold;">BDEV_SENTRY_AT_STARTUP:</span> Sets up Sentry earlier in blurdev startup process. By default, Sentry is configured upon core initialization.</p>
-	<p></p>
-	<h1>trax</h1>
-	<hr>
-	<p><span style=" font-weight:bold;">BDEV_INCLUDE_TRAX:</span> A special BDEV_INCLUDE_* environment variable that specifies where trax can be imported from. It should contain the path to the <b>folder containing the trax folder</b>(for instance: C:\blur\it\python\apps). It is used by the blurpath system to ensure the correct build is imported. It can also be used to make testing development easier by pointing to your local checkout.</p>
-	<p><span style=" font-weight:bold;">TRAX_SPOOL_DIRECTORY_OVERRIDE:</span> If defined, all messages will be stored the directory of this variable. Each message filename will have a "[mapping.mount()]_" prefix added giving you a hint to which server it would have ended up on. Defining this variable effectively disables all spool messages, and gives you a way to see what each spool message would look like. If your code depends on trax.api.spool.waitForCompletion, it will never complete.</p>
-	<p><span style=" font-weight:bold;">TRAXDEVPATH:</span> Adds trax widgets to QtDesigner. It should contain the path to the folder containing the trax module. This is used by QDesigner, nothing else. This is used to populate BDEV_DESIGNERPLUG_TRAX with the correct values in settings.ini.</p>
-	<h1>Notes</h1>
-	<hr>
-	<p>Any variable names containing a * are wildcards. This allows you to add as many instances of that environment variable type as needed.</p>
-</body>
-</html>
+<html>
+<head/>
+<body>
+	<h1>blurdev</h1>
+	<hr>
+	<h2>blurdev Site variables:</h2>
+	<p><span style=" font-style:italic;">These variables should be defined at a user or system level to configure blurdev.</span></p>
+	<p><span style=" font-weight:bold;">BDEV_DESIGNERPLUG_*:</span> Used to add a collection of designer plugins to QDesigner. Should be set to "XMLPATH,MODULE_DIR". XMLPATH is the full path to a xml file listing plugins to load. MODULE_DIR is a path that needs added to sys.path so the modules in XMLPATH are importable. You can use environment variables in these strings, they will be expanded. This is used by QDesigner, nothing else.</p>
+	<p><span style=" font-weight:bold;">BDEV_OFFLINE:</span> If set to 1, this indicates that blurdev is not running on the "Blur" network. This causes the [* Offline] section of blurdev/resource/settings.ini to override the [Default] and [*] sections. When blurdev is imported it adds all env vars defined in settings.ini for the current operating system  and Default if they are not already defined in os.environ.</p>
+	<p><span style=" font-weight:bold;">BDEV_PATH_PREFS:</span> This environment variable points to where per-computer user prefs are stored.</p>
+	<p><span style=" font-weight:bold;">BDEV_PATH_PREFS_SHARED:</span> This environment variable points to where shared user prefs are stored. This is often on the network and includes the os's logged in username in the path. If BDEV_OFFLINE is set to 1 this may point to the BDEV_PATH_PREFS location.</p>
+	<p></p>
+	<h2>blurdev Temp variables:</h2>
+	<p><span style=" font-style:italic;">These variables should not be defined all the time.</span></p>
+	<p><span style=" font-weight:bold;">BDEV_DISABLE_AUTORUN:</span> Set to "true" to disable the autorun.bat script used at blur. If this is not set when Maya shuts down, maya takes minutes to close. Maya uses several subprocess calls when closing and for some reason the doskey calls in the script take much longer than normal.</p>
+	<p><span style=" font-weight:bold;">BDEV_STYLESHEET:</span> Used to override the stylesheet when initalizing blurdev.</p>
+	<p><span style=" font-weight:bold;">BDEV_TOOL_ENVIRONMENT:</span> Forces blurdev to initialize with this treegrunt environment name. When saving prefs, this environment name change will not be saved. This is mostly used to ensure that launching a subprocess or farm job happens on the same treegrunt environment.</p>
+	<p></p>
+	<h1>trax</h1>
+	<hr>
+	<p><span style=" font-weight:bold;">TRAX_SPOOL_DIRECTORY_OVERRIDE:</span> If defined, all messages will be stored the directory of this variable. Each message filename will have a "[mapping.mount()]_" prefix added giving you a hint to which server it would have ended up on. Defining this variable effectively disables all spool messages, and gives you a way to see what each spool message would look like. If your code depends on trax.api.spool.waitForCompletion, it will never complete.</p>
+	<h1>Notes</h1>
+	<hr>
+	<p>Any variable names containing a * are wildcards. This allows you to add as many instances of that environment variable type as needed.</p>
+</body>
+</html>