Frame13/ayon-core
1
0
Fork 1
mirror of https://github.com/ynput/ayon-core.git synced 2025-12-24 21:04:40 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

🚧 redoing publishing flow for multiple rr roots

Browse source
This commit is contained in:
Ondrej Samohel 2023-01-11 19:13:28 +01:00
parent 77315d301c
commit ca552a7018
No known key found for this signature in database
GPG key ID: 02376E18990A97C6
9 changed files with 138 additions and 89 deletions
Download patch file Download diff file Expand all files Collapse all files

89
openpype/hosts/maya/plugins/create/create_render.py
View file

@ -80,31 +80,58 @@ class CreateRender(plugin.Creator):
if self._project_settings["maya"]["RenderSettings"]["apply_render_settings"]: # noqa
lib_rendersettings.RenderSettings().set_default_renderer_settings()
# Deadline-only
# Handling farms
manager = ModulesManager()
deadline_settings = get_system_settings()["modules"]["deadline"]
if not deadline_settings["enabled"]:
self.deadline_servers = {}
rr_settings = get_system_settings()["modules"]["royalrender"]
self.deadline_servers = {}
self.rr_paths = {}
if deadline_settings["enabled"]:
self.deadline_module = manager.modules_by_name["deadline"]
try:
default_servers = deadline_settings["deadline_urls"]
project_servers = (
self._project_settings["deadline"]["deadline_servers"]
)
self.deadline_servers = {
k: default_servers[k]
for k in project_servers
if k in default_servers
}
if not self.deadline_servers:
self.deadline_servers = default_servers
except AttributeError:
# Handle situation were we had only one url for deadline.
# get default deadline webservice url from deadline module
self.deadline_servers = self.deadline_module.deadline_urls
# RoyalRender only
if not rr_settings["enabled"]:
return
self.deadline_module = manager.modules_by_name["deadline"]
self.rr_module = manager.modules_by_name["royalrender"]
try:
default_servers = deadline_settings["deadline_urls"]
project_servers = (
self._project_settings["deadline"]["deadline_servers"]
default_paths = rr_settings["rr_paths"]
project_paths = (
self._project_settings["royalrender"]["rr_paths"]
)
self.deadline_servers = {
k: default_servers[k]
for k in project_servers
if k in default_servers
self.rr_paths = {
k: default_paths[k]
for k in project_paths
if k in default_paths
}
if not self.deadline_servers:
self.deadline_servers = default_servers
if not self.rr_paths:
self.rr_paths = default_paths
except AttributeError:
# Handle situation were we had only one url for deadline.
# get default deadline webservice url from deadline module
self.deadline_servers = self.deadline_module.deadline_urls
# Handle situation were we had only one path for royalrender.
# Get default royalrender root path from the rr module.
self.rr_paths = self.rr_module.rr_paths
def process(self):
"""Entry point."""
@ -140,6 +167,14 @@ class CreateRender(plugin.Creator):
self._deadline_webservice_changed
])
# add RoyalRender root path selection list
if self.rr_paths:
cmds.scriptJob(
attributeChange=[
"{}.rrPaths".format(self.instance),
self._rr_path_changed
])
cmds.setAttr("{}.machineList".format(self.instance), lock=True)
rs = renderSetup.instance()
layers = rs.getRenderLayers()
@ -192,6 +227,18 @@ class CreateRender(plugin.Creator):
attributeType="enum",
enumName=":".join(sorted_pools))
@staticmethod
def _rr_path_changed():
"""Unused callback to pull information from RR."""
"""
_ = self.rr_paths[
self.server_aliases[
cmds.getAttr("{}.rrPaths".format(self.instance))
]
]
"""
pass
def _create_render_settings(self):
"""Create instance settings."""
# get pools (slave machines of the render farm)
@ -226,15 +273,21 @@ class CreateRender(plugin.Creator):
system_settings = get_system_settings()["modules"]
deadline_enabled = system_settings["deadline"]["enabled"]
royalrender_enabled = system_settings["royalrender"]["enabled"]
muster_enabled = system_settings["muster"]["enabled"]
muster_url = system_settings["muster"]["MUSTER_REST_URL"]
if deadline_enabled and muster_enabled:
if deadline_enabled and muster_enabled and royalrender_enabled:
self.log.error(
"Both Deadline and Muster are enabled. " "Cannot support both."
("Multiple render farm support (Deadline/RoyalRender/Muster) "
"is enabled. We support only one at time.")
)
raise RuntimeError("Both Deadline and Muster are enabled")
if royalrender_enabled:
self.server_aliases = list(self.rr_paths.keys())
self.data["rrPaths"] = self.server_aliases
if deadline_enabled:
self.server_aliases = list(self.deadline_servers.keys())
self.data["deadlineServers"] = self.server_aliases

7
openpype/hosts/maya/plugins/publish/collect_render.py
View file

@ -338,6 +338,13 @@ class CollectMayaRender(pyblish.api.ContextPlugin):
if deadline_settings["enabled"]:
data["deadlineUrl"] = render_instance.data.get("deadlineUrl")
rr_settings = (
context.data["system_settings"]["modules"]["royalrender"]
)
if rr_settings["enabled"]:
data["rrPathName"] = render_instance.data.get("rrPathName")
self.log.info(data["rrPathName"])
if self.sync_workfile_version:
data["version"] = context.data["version"]

30
openpype/modules/royalrender/api.py
View file

@ -15,36 +15,10 @@ class Api:
RR_SUBMIT_CONSOLE = 1
RR_SUBMIT_API = 2
def __init__(self, project=None):
def __init__(self, rr_path=None):
self.log = Logger.get_logger("RoyalRender")
self._initialize_rr(project)
def _initialize_rr(self, project=None):
# type: (str) -> None
"""Initialize RR Path.
Args:
project (str, Optional): Project name to set RR api in
context.
"""
if project:
project_settings = get_project_settings(project)
rr_path = (
project_settings
["royalrender"]
["rr_paths"]
)
else:
rr_path = (
self._settings
["modules"]
["royalrender"]
["rr_path"]
["default"]
)
os.environ["RR_ROOT"] = rr_path
self._rr_path = rr_path
os.environ["RR_ROOT"] = rr_path
def _get_rr_bin_path(self, rr_root=None):
# type: (str) -> str

23
openpype/modules/royalrender/plugins/publish/collect_default_rr_path.py
View file

@ -1,23 +0,0 @@
# -*- coding: utf-8 -*-
"""Collect default Deadline server."""
import pyblish.api
class CollectDefaultRRPath(pyblish.api.ContextPlugin):
"""Collect default Royal Render path."""
order = pyblish.api.CollectorOrder
label = "Default Royal Render Path"
def process(self, context):
try:
rr_module = context.data.get(
"openPypeModules")["royalrender"]
except AttributeError:
msg = "Cannot get OpenPype Royal Render module."
self.log.error(msg)
raise AssertionError(msg)
# get default deadline webservice url from deadline module
self.log.debug(rr_module.rr_paths)
context.data["defaultRRPath"] = rr_module.rr_paths["default"] # noqa: E501

16
openpype/modules/royalrender/plugins/publish/collect_rr_path_from_instance.py
View file

@ -5,19 +5,19 @@ import pyblish.api
class CollectRRPathFromInstance(pyblish.api.InstancePlugin):
"""Collect RR Path from instance."""
order = pyblish.api.CollectorOrder + 0.01
label = "Royal Render Path from the Instance"
order = pyblish.api.CollectorOrder
label = "Collect Royal Render path name from the Instance"
families = ["rendering"]
def process(self, instance):
instance.data["rrPath"] = self._collect_rr_path(instance)
instance.data["rrPathName"] = self._collect_rr_path_name(instance)
self.log.info(
"Using {} for submission.".format(instance.data["rrPath"]))
"Using '{}' for submission.".format(instance.data["rrPathName"]))
@staticmethod
def _collect_rr_path(render_instance):
def _collect_rr_path_name(render_instance):
# type: (pyblish.api.Instance) -> str
"""Get Royal Render path from render instance."""
"""Get Royal Render pat name from render instance."""
rr_settings = (
render_instance.context.data
["system_settings"]
@ -42,8 +42,6 @@ class CollectRRPathFromInstance(pyblish.api.InstancePlugin):
# Handle situation were we had only one url for royal render.
return render_instance.context.data["defaultRRPath"]
return rr_servers[
list(rr_servers.keys())[
return list(rr_servers.keys())[
int(render_instance.data.get("rrPaths"))
]
]

2
openpype/modules/royalrender/plugins/publish/collect_sequences_from_job.py
View file

@ -71,7 +71,7 @@ class CollectSequencesFromJob(pyblish.api.ContextPlugin):
"""Gather file sequences from job directory.
When "OPENPYPE_PUBLISH_DATA" environment variable is set these paths
(folders or .json files) are parsed for image sequences. Otherwise the
(folders or .json files) are parsed for image sequences. Otherwise, the
current working directory is searched for file sequences.
"""

51
openpype/modules/royalrender/plugins/publish/submit_maya_royalrender.py
View file

@ -3,9 +3,10 @@
import os
import sys
import tempfile
import platform
from maya.OpenMaya import MGlobal # noqa
from pyblish.api import InstancePlugin, IntegratorOrder
from pyblish.api import InstancePlugin, IntegratorOrder, Context
from openpype.hosts.maya.api.lib import get_attr_in_layer
from openpype.pipeline.farm.tools import get_published_workfile_instance
from openpype.pipeline.publish import KnownPublishError
@ -16,6 +17,8 @@ from openpype.modules.royalrender.rr_job import RRJob, SubmitterParameter
class MayaSubmitRoyalRender(InstancePlugin):
label = "Submit to RoyalRender"
order = IntegratorOrder + 0.1
families = ["renderlayer"]
targets = ["local"]
use_published = True
def __init__(self, *args, **kwargs):
@ -102,7 +105,16 @@ class MayaSubmitRoyalRender(InstancePlugin):
"""Plugin entry point."""
self._instance = instance
context = instance.context
self.rr_api = rr_api(context.data["project"])
from pprint import pformat
self._rr_root = self._resolve_rr_path(context, instance.data.get("rrPathName")) # noqa
self.log.debug(self._rr_root)
if not self._rr_root:
raise KnownPublishError(
("Missing RoyalRender root. "
"You need to configure RoyalRender module."))
self.rr_api = rr_api(self._rr_root)
# get royalrender module
"""
@ -114,11 +126,7 @@ class MayaSubmitRoyalRender(InstancePlugin):
raise AssertionError("OpenPype RoyalRender module not found.")
"""
self._rrRoot = instance.data["rrPath"] or context.data["defaultRRPath"] # noqa
if not self._rrRoot:
raise KnownPublishError(
("Missing RoyalRender root. "
"You need to configure RoyalRender module."))
file_path = None
if self.use_published:
file_path = get_published_workfile_instance()
@ -147,4 +155,33 @@ class MayaSubmitRoyalRender(InstancePlugin):
self.rr_api.submit_file(file=xml)
@staticmethod
def _resolve_rr_path(context, rr_path_name):
# type: (Context, str) -> str
rr_settings = (
context.data
["system_settings"]
["modules"]
["royalrender"]
)
try:
default_servers = rr_settings["rr_paths"]
project_servers = (
context.data
["project_settings"]
["royalrender"]
["rr_paths"]
)
rr_servers = {
k: default_servers[k]
for k in project_servers
if k in default_servers
}
except (AttributeError, KeyError):
# Handle situation were we had only one url for royal render.
return context.data["defaultRRPath"][platform.system().lower()]
return rr_servers[rr_path_name][platform.system().lower()]

3
openpype/settings/defaults/project_settings/royalrender.json
View file

@ -1,4 +1,7 @@
{
"rr_paths": [
"default"
],
"publish": {
"CollectSequencesFromJob": {
"review": true

6
openpype/settings/defaults/system_settings/modules.json
View file

@ -185,9 +185,9 @@
"enabled": false,
"rr_paths": {
"default": {
"windows": "",
"darwin": "",
"linux": ""
"windows": "C:\\RR8",
"darwin": "/Volumes/share/RR8",
"linux": "/mnt/studio/RR8"
}
}
},