fix: Don't attach missing or substituted fonts on submit

README.md

@@ -76,11 +76,11 @@ The submitter includes a folder `DeadlineCloudSubmitter_Assets` and a file `Dead
 
 #### Font attachment system:
 
-The submitter detects fonts used in the submitted composition and automatically adds them as job attachments on submission. These get installed on the worker before the render starts and get removed again when the job ends.
+Fonts used in the submitted composition are detected by the submitter and are automatically added as job attachments on submission. These get installed on the worker before the render starts and get removed when the job ends.
 Supported font types include: OpenType (`.otf`), TrueType (`.ttf`), and [Adobe Fonts](https://fonts.adobe.com/).
 Windows bitmap fonts (`.fon`) are only supported on Windows machines.
 
-If fonts are missing at render time, first check that they're installed (on the system or your user), and then check they're being included in the job attachments tab in the submitter.
+The submitter detects if fonts are missing or substituted in a project and warns you before proceeding with submission. If you choose to submit a composition with missing or substituted fonts, its render tasks will use the substituted fonts as submitted. To ensure correct render output, you must add any required fonts to your system or your user profile before opening a project that needs them. First check that the missing fonts are installed (on the system or your user), and then check they're being included in the job attachments tab in the submitter.
 
 Fonts distributed through Adobe Creative Cloud can be made available for all non-Adobe apps on your workstation, or only made available in Adobe apps. Cloud fonts need to be installed for all non-Adobe apps for use with Deadline Cloud.
 To install fonts for non-Adobe apps in Creative Cloud:

dist/DeadlineCloudSubmitter_Assets/JobTemplate/scripts/call_aerender.py

@@ -10,6 +10,10 @@
 import os
 
 
+FATAL_WARNINGS = [
+    # "Project has missing fonts"
+]
+
 def main():
     parser = argparse.ArgumentParser(description="After Effects Render Script")
     parser.add_argument("project", type=str, help="Project file path")
@@ -91,6 +95,11 @@ def main():
             if "WARNING:After Effects warning" in line:
                 print(f"After Effects Warning: {line.strip()}", file=sys.stderr)
 
+                # Some warnings should be treated as errors, i.e. a fatal warning
+                if any([w in line for w in FATAL_WARNINGS]):
+                    print(f"After Effects Fatal Warning: {line.strip()}", file=sys.stderr)
+                    sys.exit(1)
+
         # Also handle stderr (errors)
         for line in process.stderr:
             print(line, end="", flush=True)  # Print stderr line by line

dist/DeadlineCloudSubmitter_Assets/JobTemplate/scripts/font_manager.py

@@ -133,12 +133,19 @@ def install_font(src_path, scope=INSTALL_SCOPE_USER):
             registry_scope = winreg.HKEY_CURRENT_USER
         dst_path = os.path.join(dst_dir, os.path.basename(src_path))
 
-        # Copy the font to the Windows Fonts folder
-        shutil.copy(src_path, dst_path)
+        # Check if the font is already present
+        if os.path.exists(dst_path) and (os.stat(src_path).st_size == os.stat(dst_path).st_size):
+            logger.info(f"Font already present: {dst_path}")
+        else:
+            # Copy the font to the destination Fonts folder
+            shutil.copy(src_path, dst_path)
 
         # Load the font in the current session, remove font when loading fails
         if not gdi32.AddFontResourceW(dst_path):
-            os.remove(dst_path)
+            try:
+                os.remove(dst_path)
+            except Exception as e:
+                logger.error(f"Couldn't remove: {dst_path}  {e.message}")
             raise WindowsError(f'AddFontResource failed to load "{src_path}"')
 
         # Notify running programs
@@ -151,7 +158,7 @@ def install_font(src_path, scope=INSTALL_SCOPE_USER):
         fontname = get_font_name(dst_path)
 
         # Creates registry if it doesn't exist, opens when it does exist
-        with winreg.CreateKeyEx(registry_scope, FONTS_REG_PATH, 0, access= winreg.KEY_SET_VALUE) as key:
+        with winreg.CreateKeyEx(registry_scope, FONTS_REG_PATH, 0, access=winreg.KEY_SET_VALUE) as key:
             winreg.SetValueEx(key, fontname, 0, winreg.REG_SZ, filename)
     except Exception:
         return False, traceback.format_exc()
@@ -177,13 +184,24 @@ def uninstall_font(src_path, scope=INSTALL_SCOPE_USER):
 
         # Remove the fontname/filename from the registry
         fontname = get_font_name(dst_path)
-
-        with winreg.OpenKey(registry_scope, FONTS_REG_PATH, 0, access= winreg.KEY_SET_VALUE) as key:
-            winreg.DeleteValue(key, fontname)
+
+        try:
+            with winreg.OpenKey(registry_scope, FONTS_REG_PATH, 0, access=winreg.KEY_SET_VALUE) as key:
+                winreg.DeleteValue(key, fontname)
+        except FileNotFoundError as e:
+            # The entry was already deleted
+            logger.warning(f"Couldn't remove {dst_path}: {getattr(e, 'message', getattr(e, 'args', 'unknown FileNotFoundError'))}")
+        except:
+            raise
 
         # Unload the font in the current session
         if not gdi32.RemoveFontResourceW(dst_path):
-            os.remove(dst_path)
+            try:
+                os.remove(dst_path)
+            except PermissionError as e:
+                logger.warning(f"Couldn't remove {dst_path}: {getattr(e, 'message', getattr(e, 'args', 'unknown FileNotFoundError'))}")
+            except Exception:
+                raise
             raise WindowsError(f'RemoveFontResourceW failed to load "{src_path}"')
 
         if os.path.exists(dst_path):

dist/DeadlineCloudSubmitter_Assets/JobTemplate/scripts/get_user_fonts.py

@@ -14,16 +14,9 @@
 except ModuleNotFoundError:
     error_msg = "Error: The fonttools module was not found.\n"
     error_msg += "Please install fonttools by running:\n\npip install fonttools"
-    print(json.dumps({
-        "error": error_msg
-    }))
-    sys.exit(1)
+    error_exit(error_msg)
 except Exception as e:
-    print(json.dumps({
-        "error": traceback.format_exc()
-    }))
-    sys.exit(1)
-
+    error_exit(traceback.format_exc())
 
 # Font locations to search on Windows
 SEARCH_PATHS = [
@@ -52,6 +45,13 @@
 TTF_POSTSCRIPT_NAME = 6
 
 
+def error_exit(message, errorlevel=1):
+    print(json.dumps({
+        "error": message
+    }))
+    sys.exit(errorlevel)
+
+
 def get_font(font_path):
     """
     Collect font metadata from the given font file.
@@ -62,19 +62,29 @@ def get_font(font_path):
 
     try:
         t = ttLib.TTFont(font_path)
+    except ttLib.TTLibError as e:
+        # Not a TrueType or OpenType font (bad sfntVersion)
+        result["error_verbose"] = traceback.format_exc()
+        if "bad sfntVersion" in str(e):
+            # These errors are very common.
+            # Don't show a UI warning but report the error in "error_verbose"
+            result["error_verbose"] = traceback.format_exc()
+        else:
+            result["error"] = f"{e}: {font_path}"
+        return result
     except Exception as e:
-        if verbose:
-            print(traceback.format_exc())
+        result["error_verbose"] = traceback.format_exc()
+        result["error"] = f"{getattr(e, 'message', str(e))}: {font_path}"
         return result
 
     # Collect name metadata from the name table
     names_table = t["name"].names
     raw_table = {}
     try:
         raw_table = {i:str(names_table[i]) for i in range(0, len(names_table))}
-    except Exception:
-        if verbose:
-            print(traceback.format_exc())
+    except Exception as e:
+        result["error_verbose"] = traceback.format_exc()
+        result["error"] = f"{getattr(e, 'message', str(e))}: {font_path}"
         return result
 
     try:
@@ -85,95 +95,93 @@ def get_font(font_path):
             "postscript_name": str(names_table[TTF_POSTSCRIPT_NAME]),
             "raw": raw_table
         }
-    except Exception:
-        if verbose:
-            print(traceback.format_exc())
+    except Exception as e:
+        result["error"] = f"{getattr(e, 'message', str(e))}: {font_path}"
         return result
 
     return result
 
 
-def get_fonts(root_path, verbose=None):
+def get_fonts(root_path):
     """
     Collect font metadata from all font files under the specified root_path.
-    Returns a dictionary with file paths as the keys.
+    Returns a dictionary with file paths as the keys and a list of errors encountered.
     """
 
     result = {}
+    errors = []
+    errors_verbose = []
 
-    try:
-        if not os.path.exists(root_path):
-            return result
-    except Exception:
-        if verbose:
-            print(traceback.format_exc())
-        return result
+    for path, dirs, files in os.walk(root_path):
+        for file in files:
+            _, ext = os.path.splitext(file)
+            if ext.lower() not in FONT_EXTENSIONS:
+                continue
 
-    try:
-        for path, dirs, files in os.walk(root_path):
-            for file in files:
-                _, ext = os.path.splitext(file)
-                if ext.lower() not in FONT_EXTENSIONS:
-                    continue
-
-                font_path = path + "/" + file
-                if sys.platform == "win32":
-                    font_path = font_path.replace("\\", "/")
-                else:
-                    pass
-
-                if verbose:
-                    print(f"font_path: {font_path}")
-
-                font_data = {}
-                try:
-                    font_data = get_font(font_path)
-                    result.update(font_data)
-                except Exception:
-                    if verbose:
-                        print(traceback.format_exc())
-                    continue
-    except Exception:
-        if verbose:
-            print(traceback.format_exc())
-    return result
+            font_path = path + "/" + file
+            if sys.platform == "win32":
+                font_path = font_path.replace("\\", "/")
+
+            font_data = {}
+            try:
+                font_data = get_font(font_path)
+                result.update(font_data)
+            except Exception as e:
+                errors.append(f"{getattr(e, 'message', str(e))}: {font_path}")
+                continue
+            if "error" in font_data:
+                errors.append(font_data["error"])
+            if "error_verbose" in font_data:
+                errors_verbose.append(font_data["error_verbose"])
+    return result, errors, errors_verbose
 
 
-def search_for_fonts(search_paths, verbose=None):
+def search_for_fonts(search_paths):
     """
     Searches the given paths recursively for font files and collects
     their metadata.
     Returns a dictionary with file paths as the keys.
     """
 
     fonts = {}
-
+    errors = []
+    errors_verbose = []
+
     for search_path in search_paths:
         search_root = os.path.normpath(os.path.expandvars(os.path.expanduser(search_path)))
         try:
             if not os.path.exists(search_root):
                 continue
-        except Exception:
-            if verbose:
-                print(traceback.format_exc())
+        except Exception as e:
+            errors.extend(f"{getattr(e, 'message', str(e))}: {search_root}")
             continue
 
-        if verbose:
-            print(f"search_root: {search_root}")
-
-        font_results = get_fonts(search_root, verbose=verbose)
+        font_results, font_errors, font_errors_verbose = get_fonts(search_root)
         fonts.update(font_results)
+        errors.extend(font_errors)
+        errors_verbose.extend(font_errors_verbose)
+
+    if errors:
+        s = "s" if len(errors) > 1 else ""
+        fonts["error"] = f"Error{s} encountered during font scan:\n"
+        for e in errors:
+            fonts["error"] += e + "\n"
+
+    if errors_verbose:
+        fonts["error_verbose"] = errors_verbose
 
     return fonts
 
 
 if __name__ == "__main__":
-    verbose = False
     result = []
     try:
-        result = search_for_fonts(SEARCH_PATHS, verbose=verbose)
+        result = search_for_fonts(SEARCH_PATHS)
+        print(json.dumps(result))
+    except Exception as e:
+        result = {
+            "error": f"{getattr(e, 'message', str(e))}",
+            "error_verbose": traceback.format_exc()
+        }
         print(json.dumps(result))
-    except Exception:
-        if verbose:
-            print(traceback.format_exc())
 

requirements.txt

@@ -0,0 +1 @@
+fonttools ~= 4.55.6