Merge pull request #1905 from pypeclub/feature/maya-multiple-deadline-servers

openpype/hosts/maya/plugins/create/create_render.py

@@ -4,6 +4,8 @@ import os
 import json
 import appdirs
 import requests
+import six
+import sys
 
 from maya import cmds
 import maya.app.renderSetup.model.renderSetup as renderSetup
@@ -12,7 +14,13 @@ from openpype.hosts.maya.api import (
     lib,
     plugin
 )
-from openpype.api import (get_system_settings, get_asset)
+from openpype.api import (
+    get_system_settings,
+    get_project_settings,
+    get_asset)
+from openpype.modules import ModulesManager
+
+from avalon.api import Session
 
 
 class CreateRender(plugin.Creator):
@@ -83,6 +91,32 @@ class CreateRender(plugin.Creator):
     def __init__(self, *args, **kwargs):
         """Constructor."""
         super(CreateRender, self).__init__(*args, **kwargs)
+        deadline_settings = get_system_settings()["modules"]["deadline"]
+        if not deadline_settings["enabled"]:
+            self.deadline_servers = {}
+            return
+        project_settings = get_project_settings(Session["AVALON_PROJECT"])
+        try:
+            default_servers = deadline_settings["deadline_urls"]
+            project_servers = (
+                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.
+            manager = ModulesManager()
+            deadline_module = manager.modules_by_name["deadline"]
+            # get default deadline webservice url from deadline module
+            self.deadline_servers = deadline_module.deadline_urls
 
     def process(self):
         """Entry point."""
@@ -94,10 +128,10 @@ class CreateRender(plugin.Creator):
         use_selection = self.options.get("useSelection")
         with lib.undo_chunk():
             self._create_render_settings()
-            instance = super(CreateRender, self).process()
+            self.instance = super(CreateRender, self).process()
             # create namespace with instance
             index = 1
-            namespace_name = "_{}".format(str(instance))
+            namespace_name = "_{}".format(str(self.instance))
             try:
                 cmds.namespace(rm=namespace_name)
             except RuntimeError:
@@ -105,12 +139,20 @@ class CreateRender(plugin.Creator):
                 pass
 
             while cmds.namespace(exists=namespace_name):
-                namespace_name = "_{}{}".format(str(instance), index)
+                namespace_name = "_{}{}".format(str(self.instance), index)
                 index += 1
 
             namespace = cmds.namespace(add=namespace_name)
 
-            cmds.setAttr("{}.machineList".format(instance), lock=True)
+            # add Deadline server selection list
+            if self.deadline_servers:
+                cmds.scriptJob(
+                    attributeChange=[
+                        "{}.deadlineServers".format(self.instance),
+                        self._deadline_webservice_changed
+                    ])
+
+            cmds.setAttr("{}.machineList".format(self.instance), lock=True)
             self._rs = renderSetup.instance()
             layers = self._rs.getRenderLayers()
             if use_selection:
@@ -122,7 +164,7 @@ class CreateRender(plugin.Creator):
                     render_set = cmds.sets(
                         n="{}:{}".format(namespace, layer.name()))
                     sets.append(render_set)
-                cmds.sets(sets, forceElement=instance)
+                cmds.sets(sets, forceElement=self.instance)
 
             # if no render layers are present, create default one with
             # asterisk selector
@@ -138,62 +180,61 @@ class CreateRender(plugin.Creator):
                 renderer = 'renderman'
 
             self._set_default_renderer_settings(renderer)
+        return self.instance
+
+    def _deadline_webservice_changed(self):
+        """Refresh Deadline server dependent options."""
+        # get selected server
+        from maya import cmds
+        webservice = self.deadline_servers[
+            self.server_aliases[
+                cmds.getAttr("{}.deadlineServers".format(self.instance))
+            ]
+        ]
+        pools = self._get_deadline_pools(webservice)
+        cmds.deleteAttr("{}.primaryPool".format(self.instance))
+        cmds.deleteAttr("{}.secondaryPool".format(self.instance))
+        cmds.addAttr(self.instance, longName="primaryPool",
+                     attributeType="enum",
+                     enumName=":".join(pools))
+        cmds.addAttr(self.instance, longName="secondaryPool",
+                     attributeType="enum",
+                     enumName=":".join(["-"] + pools))
+
+    def _get_deadline_pools(self, webservice):
+        # type: (str) -> list
+        """Get pools from Deadline.
+        Args:
+            webservice (str): Server url.
+        Returns:
+            list: Pools.
+        Throws:
+            RuntimeError: If deadline webservice is unreachable.
+
+        """
+        argument = "{}/api/pools?NamesOnly=true".format(webservice)
+        try:
+            response = self._requests_get(argument)
+        except requests.exceptions.ConnectionError as exc:
+            msg = 'Cannot connect to deadline web service'
+            self.log.error(msg)
+            six.reraise(
+                RuntimeError,
+                RuntimeError('{} - {}'.format(msg, exc)),
+                sys.exc_info()[2])
+        if not response.ok:
+            self.log.warning("No pools retrieved")
+            return []
+
+        return response.json()
 
     def _create_render_settings(self):
+        """Create instance settings."""
         # get pools
-        pools = []
-
-        system_settings = get_system_settings()["modules"]
-
-        deadline_enabled = system_settings["deadline"]["enabled"]
-        muster_enabled = system_settings["muster"]["enabled"]
-        deadline_url = system_settings["deadline"]["DEADLINE_REST_URL"]
-        muster_url = system_settings["muster"]["MUSTER_REST_URL"]
-
-        if deadline_enabled and muster_enabled:
-            self.log.error(
-                "Both Deadline and Muster are enabled. " "Cannot support both."
-            )
-            raise RuntimeError("Both Deadline and Muster are enabled")
-
-        if deadline_enabled:
-            argument = "{}/api/pools?NamesOnly=true".format(deadline_url)
-            try:
-                response = self._requests_get(argument)
-            except requests.exceptions.ConnectionError as e:
-                msg = 'Cannot connect to deadline web service'
-                self.log.error(msg)
-                raise RuntimeError('{} - {}'.format(msg, e))
-            if not response.ok:
-                self.log.warning("No pools retrieved")
-            else:
-                pools = response.json()
-                self.data["primaryPool"] = pools
-                # We add a string "-" to allow the user to not
-                # set any secondary pools
-                self.data["secondaryPool"] = ["-"] + pools
-
-        if muster_enabled:
-            self.log.info(">>> Loading Muster credentials ...")
-            self._load_credentials()
-            self.log.info(">>> Getting pools ...")
-            try:
-                pools = self._get_muster_pools()
-            except requests.exceptions.HTTPError as e:
-                if e.startswith("401"):
-                    self.log.warning("access token expired")
-                    self._show_login()
-                    raise RuntimeError("Access token expired")
-            except requests.exceptions.ConnectionError:
-                self.log.error("Cannot connect to Muster API endpoint.")
-                raise RuntimeError("Cannot connect to {}".format(muster_url))
-            pool_names = []
-            for pool in pools:
-                self.log.info("  - pool: {}".format(pool["name"]))
-                pool_names.append(pool["name"])
-
-            self.data["primaryPool"] = pool_names
+        pool_names = []
 
+        self.server_aliases = self.deadline_servers.keys()
+        self.data["deadlineServers"] = self.server_aliases
         self.data["suspendPublishJob"] = False
         self.data["review"] = True
         self.data["extendFrames"] = False
@@ -212,6 +253,54 @@ class CreateRender(plugin.Creator):
         # Disable for now as this feature is not working yet
         # self.data["assScene"] = False
 
+        system_settings = get_system_settings()["modules"]
+
+        deadline_enabled = system_settings["deadline"]["enabled"]
+        muster_enabled = system_settings["muster"]["enabled"]
+        muster_url = system_settings["muster"]["MUSTER_REST_URL"]
+
+        if deadline_enabled and muster_enabled:
+            self.log.error(
+                "Both Deadline and Muster are enabled. " "Cannot support both."
+            )
+            raise RuntimeError("Both Deadline and Muster are enabled")
+
+        if deadline_enabled:
+            # if default server is not between selected, use first one for
+            # initial list of pools.
+            try:
+                deadline_url = self.deadline_servers["default"]
+            except KeyError:
+                deadline_url = [
+                    self.deadline_servers[k]
+                    for k in self.deadline_servers.keys()
+                ][0]
+
+            pool_names = self._get_deadline_pools(deadline_url)
+
+        if muster_enabled:
+            self.log.info(">>> Loading Muster credentials ...")
+            self._load_credentials()
+            self.log.info(">>> Getting pools ...")
+            pools = []
+            try:
+                pools = self._get_muster_pools()
+            except requests.exceptions.HTTPError as e:
+                if e.startswith("401"):
+                    self.log.warning("access token expired")
+                    self._show_login()
+                    raise RuntimeError("Access token expired")
+            except requests.exceptions.ConnectionError:
+                self.log.error("Cannot connect to Muster API endpoint.")
+                raise RuntimeError("Cannot connect to {}".format(muster_url))
+            for pool in pools:
+                self.log.info("  - pool: {}".format(pool["name"]))
+                pool_names.append(pool["name"])
+
+        self.data["primaryPool"] = pool_names
+        # We add a string "-" to allow the user to not
+        # set any secondary pools
+        self.data["secondaryPool"] = ["-"] + pool_names
         self.options = {"useSelection": False}  # Force no content
 
     def _load_credentials(self):
@@ -293,9 +382,7 @@ class CreateRender(plugin.Creator):
 
         """
         if "verify" not in kwargs:
-            kwargs["verify"] = (
-                False if os.getenv("OPENPYPE_DONT_VERIFY_SSL", True) else True
-            )  # noqa
+            kwargs["verify"] = not os.getenv("OPENPYPE_DONT_VERIFY_SSL", True)
         return requests.post(*args, **kwargs)
 
     def _requests_get(self, *args, **kwargs):
@@ -312,9 +399,7 @@ class CreateRender(plugin.Creator):
 
         """
         if "verify" not in kwargs:
-            kwargs["verify"] = (
-                False if os.getenv("OPENPYPE_DONT_VERIFY_SSL", True) else True
-            )  # noqa
+            kwargs["verify"] = not os.getenv("OPENPYPE_DONT_VERIFY_SSL", True)
         return requests.get(*args, **kwargs)
 
     def _set_default_renderer_settings(self, renderer):
@@ -332,14 +417,10 @@ class CreateRender(plugin.Creator):
 
         if renderer == "arnold":
             # set format to exr
+
             cmds.setAttr(
                 "defaultArnoldDriver.ai_translator", "exr", type="string")
-            # enable animation
-            cmds.setAttr("defaultRenderGlobals.outFormatControl", 0)
-            cmds.setAttr("defaultRenderGlobals.animation", 1)
-            cmds.setAttr("defaultRenderGlobals.putFrameBeforeExt", 1)
-            cmds.setAttr("defaultRenderGlobals.extensionPadding", 4)
-
+            self._set_global_output_settings()
             # resolution
             cmds.setAttr(
                 "defaultResolution.width",
@@ -349,43 +430,12 @@ class CreateRender(plugin.Creator):
                 asset["data"].get("resolutionHeight"))
 
         if renderer == "vray":
-            vray_settings = cmds.ls(type="VRaySettingsNode")
-            if not vray_settings:
-                node = cmds.createNode("VRaySettingsNode")
-            else:
-                node = vray_settings[0]
-
-            # set underscore as element separator instead of default `.`
-            cmds.setAttr(
-                "{}.fileNameRenderElementSeparator".format(
-                    node),
-                "_"
-            )
-            # set format to exr
-            cmds.setAttr(
-                "{}.imageFormatStr".format(node), 5)
-
-            # animType
-            cmds.setAttr(
-                "{}.animType".format(node), 1)
-
-            # resolution
-            cmds.setAttr(
-                "{}.width".format(node),
-                asset["data"].get("resolutionWidth"))
-            cmds.setAttr(
-                "{}.height".format(node),
-                asset["data"].get("resolutionHeight"))
-
+            self._set_vray_settings(asset)
         if renderer == "redshift":
-            redshift_settings = cmds.ls(type="RedshiftOptions")
-            if not redshift_settings:
-                node = cmds.createNode("RedshiftOptions")
-            else:
-                node = redshift_settings[0]
+            _ = self._set_renderer_option(
+                "RedshiftOptions", "{}.imageFormat", 1
+            )
 
-            # set exr
-            cmds.setAttr("{}.imageFormat".format(node), 1)
             # resolution
             cmds.setAttr(
                 "defaultResolution.width",
@@ -394,8 +444,56 @@ class CreateRender(plugin.Creator):
                 "defaultResolution.height",
                 asset["data"].get("resolutionHeight"))
 
-            # enable animation
-            cmds.setAttr("defaultRenderGlobals.outFormatControl", 0)
-            cmds.setAttr("defaultRenderGlobals.animation", 1)
-            cmds.setAttr("defaultRenderGlobals.putFrameBeforeExt", 1)
-            cmds.setAttr("defaultRenderGlobals.extensionPadding", 4)
+            self._set_global_output_settings()
+
+    @staticmethod
+    def _set_renderer_option(renderer_node, arg=None, value=None):
+        # type: (str, str, str) -> str
+        """Set option on renderer node.
+
+        If renderer settings node doesn't exists, it is created first.
+
+        Args:
+             renderer_node (str): Renderer name.
+             arg (str, optional): Argument name.
+             value (str, optional): Argument value.
+
+        Returns:
+            str: Renderer settings node.
+
+        """
+        settings = cmds.ls(type=renderer_node)
+        result = settings[0] if settings else cmds.createNode(renderer_node)
+        cmds.setAttr(arg.format(result), value)
+        return result
+
+    def _set_vray_settings(self, asset):
+        # type: (dict) -> None
+        """Sets important settings for Vray."""
+        node = self._set_renderer_option(
+            "VRaySettingsNode", "{}.fileNameRenderElementSeparator", "_"
+        )
+
+        # set format to exr
+        cmds.setAttr(
+            "{}.imageFormatStr".format(node), 5)
+
+        # animType
+        cmds.setAttr(
+            "{}.animType".format(node), 1)
+
+        # resolution
+        cmds.setAttr(
+            "{}.width".format(node),
+            asset["data"].get("resolutionWidth"))
+        cmds.setAttr(
+            "{}.height".format(node),
+            asset["data"].get("resolutionHeight"))
+
+    @staticmethod
+    def _set_global_output_settings():
+        # enable animation
+        cmds.setAttr("defaultRenderGlobals.outFormatControl", 0)
+        cmds.setAttr("defaultRenderGlobals.animation", 1)
+        cmds.setAttr("defaultRenderGlobals.putFrameBeforeExt", 1)
+        cmds.setAttr("defaultRenderGlobals.extensionPadding", 4)

openpype/hosts/maya/plugins/publish/collect_render.py

@@ -64,6 +64,8 @@ class CollectMayaRender(pyblish.api.ContextPlugin):
     def process(self, context):
         """Entry point to collector."""
         render_instance = None
+        deadline_url = None
+
         for instance in context:
             if "rendering" in instance.data["families"]:
                 render_instance = instance
@@ -86,6 +88,15 @@ class CollectMayaRender(pyblish.api.ContextPlugin):
         asset = api.Session["AVALON_ASSET"]
         workspace = context.data["workspaceDir"]
 
+        deadline_settings = (
+            context.data
+            ["system_settings"]
+            ["modules"]
+            ["deadline"]
+        )
+
+        if deadline_settings["enabled"]:
+            deadline_url = render_instance.data.get("deadlineUrl")
         self._rs = renderSetup.instance()
         current_layer = self._rs.getVisibleRenderLayer()
         maya_render_layers = {
@@ -263,6 +274,9 @@ class CollectMayaRender(pyblish.api.ContextPlugin):
                         "vrayUseReferencedAovs") or False
             }
 
+            if deadline_url:
+                data["deadlineUrl"] = deadline_url
+
             if self.sync_workfile_version:
                 data["version"] = context.data["version"]
 
@@ -392,11 +406,13 @@ class CollectMayaRender(pyblish.api.ContextPlugin):
         rset = self.maya_layers[layer].renderSettingsCollectionInstance()
         return rset.getOverrides()
 
-    def get_render_attribute(self, attr, layer):
+    @staticmethod
+    def get_render_attribute(attr, layer):
         """Get attribute from render options.
 
         Args:
-            attr (str): name of attribute to be looked up.
+            attr (str): name of attribute to be looked up
+            layer (str): name of render layer
 
         Returns:
             Attribute value

openpype/lib/abstract_submit_deadline.py

@@ -415,13 +415,11 @@ class AbstractSubmitDeadline(pyblish.api.InstancePlugin):
         """Plugin entry point."""
         self._instance = instance
         context = instance.context
-        self._deadline_url = (
-            context.data["system_settings"]
-            ["modules"]
-            ["deadline"]
-            ["DEADLINE_REST_URL"]
-        )
-        assert self._deadline_url, "Requires DEADLINE_REST_URL"
+        self._deadline_url = context.data.get("defaultDeadline")
+        self._deadline_url = instance.data.get(
+            "deadlineUrl", self._deadline_url)
+
+        assert self._deadline_url, "Requires Deadline Webservice URL"
 
         file_path = None
         if self.use_published:

openpype/modules/deadline/deadline_module.py

@@ -6,17 +6,25 @@ from openpype.modules import (
 class DeadlineModule(PypeModule, IPluginPaths):
     name = "deadline"
 
+    def __init__(self, manager, settings):
+        self.deadline_urls = {}
+        super(DeadlineModule, self).__init__(manager, settings)
+
     def initialize(self, modules_settings):
         # This module is always enabled
         deadline_settings = modules_settings[self.name]
         self.enabled = deadline_settings["enabled"]
-        self.deadline_url = deadline_settings["DEADLINE_REST_URL"]
+        deadline_url = deadline_settings.get("DEADLINE_REST_URL")
+        if deadline_url:
+            self.deadline_urls = {"default": deadline_url}
+        else:
+            self.deadline_urls = deadline_settings.get("deadline_urls")  # noqa: E501
 
-    def get_global_environments(self):
-        """Deadline global environments for OpenPype implementation."""
-        return {
-            "DEADLINE_REST_URL": self.deadline_url
-        }
+        if not self.deadline_urls:
+            self.enabled = False
+            self.log.warning(("default Deadline Webservice URL "
+                              "not specified. Disabling module."))
+            return
 
     def connect_with_modules(self, *_a, **_kw):
         return

openpype/modules/deadline/plugins/publish/collect_deadline_server_from_instance.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+"""Collect Deadline servers from instance.
+
+This is resolving index of server lists stored in `deadlineServers` instance
+attribute or using default server if that attribute doesn't exists.
+
+"""
+import pyblish.api
+
+
+class CollectDeadlineServerFromInstance(pyblish.api.InstancePlugin):
+    """Collect Deadline Webservice URL from instance."""
+
+    order = pyblish.api.CollectorOrder
+    label = "Deadline Webservice from the Instance"
+    families = ["rendering"]
+
+    def process(self, instance):
+        instance.data["deadlineUrl"] = self._collect_deadline_url(instance)
+        self.log.info(
+            "Using {} for submission.".format(instance.data["deadlineUrl"]))
+
+    @staticmethod
+    def _collect_deadline_url(render_instance):
+        # type: (pyblish.api.Instance) -> str
+        """Get Deadline Webservice URL from render instance.
+
+        This will get all configured Deadline Webservice URLs and create
+        subset of them based upon project configuration. It will then take
+        `deadlineServers` from render instance that is now basically `int`
+        index of that list.
+
+        Args:
+            render_instance (pyblish.api.Instance): Render instance created
+                by Creator in Maya.
+
+        Returns:
+            str: Selected Deadline Webservice URL.
+
+        """
+
+        deadline_settings = (
+            render_instance.context.data
+            ["system_settings"]
+            ["modules"]
+            ["deadline"]
+        )
+
+        try:
+            default_servers = deadline_settings["deadline_urls"]
+            project_servers = (
+                render_instance.context.data
+                ["project_settings"]
+                ["deadline"]
+                ["deadline_servers"]
+            )
+            deadline_servers = {
+                k: default_servers[k]
+                for k in project_servers
+                if k in default_servers
+            }
+
+        except AttributeError:
+            # Handle situation were we had only one url for deadline.
+            return render_instance.context.data["defaultDeadline"]
+
+        return deadline_servers[
+            list(deadline_servers.keys())[
+                int(render_instance.data.get("deadlineServers"))
+            ]
+        ]

openpype/modules/deadline/plugins/publish/collect_default_deadline_server.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+"""Collect default Deadline server."""
+import pyblish.api
+
+
+class CollectDefaultDeadlineServer(pyblish.api.ContextPlugin):
+    """Collect default Deadline Webservice URL."""
+
+    order = pyblish.api.CollectorOrder + 0.01
+    label = "Default Deadline Webservice"
+
+    def process(self, context):
+        try:
+            deadline_module = context.data.get("openPypeModules")["deadline"]
+        except AttributeError:
+            self.log.error("Cannot get OpenPype Deadline module.")
+            raise AssertionError("OpenPype Deadline module not found.")
+
+        # get default deadline webservice url from deadline module
+        self.log.debug(deadline_module.deadline_urls)
+        context.data["defaultDeadline"] = deadline_module.deadline_urls["default"]  # noqa: E501

openpype/modules/deadline/plugins/publish/submit_maya_deadline.py

@@ -264,12 +264,13 @@ class MayaSubmitDeadline(pyblish.api.InstancePlugin):
 
         self._instance = instance
         self.payload_skeleton = copy.deepcopy(payload_skeleton_template)
-        self._deadline_url = (
-            context.data["system_settings"]
-            ["modules"]
-            ["deadline"]
-            ["DEADLINE_REST_URL"]
-        )
+
+        # get default deadline webservice url from deadline module
+        self.deadline_url = instance.context.data.get("defaultDeadline")
+        # if custom one is set in instance, use that
+        if instance.data.get("deadlineUrl"):
+            self.deadline_url = instance.data.get("deadlineUrl")
+        assert self.deadline_url, "Requires Deadline Webservice URL"
 
         self._job_info = (
             context.data["project_settings"].get(
@@ -287,8 +288,6 @@ class MayaSubmitDeadline(pyblish.api.InstancePlugin):
                 "pluginInfo", {})
         )
 
-        assert self._deadline_url, "Requires DEADLINE_REST_URL"
-
         context = instance.context
         workspace = context.data["workspaceDir"]
         anatomy = context.data['anatomy']
@@ -683,7 +682,7 @@ class MayaSubmitDeadline(pyblish.api.InstancePlugin):
             self.log.info(
                 "Submitting tile job(s) [{}] ...".format(len(frame_payloads)))
 
-            url = "{}/api/jobs".format(self._deadline_url)
+            url = "{}/api/jobs".format(self.deadline_url)
             tiles_count = instance.data.get("tilesX") * instance.data.get("tilesY")  # noqa: E501
 
             for tile_job in frame_payloads:
@@ -767,7 +766,7 @@ class MayaSubmitDeadline(pyblish.api.InstancePlugin):
             self.log.debug(json.dumps(payload, indent=4, sort_keys=True))
 
             # E.g. http://192.168.0.1:8082/api/jobs
-            url = "{}/api/jobs".format(self._deadline_url)
+            url = "{}/api/jobs".format(self.deadline_url)
             response = self._requests_post(url, json=payload)
             if not response.ok:
                 raise Exception(response.text)
@@ -975,7 +974,7 @@ class MayaSubmitDeadline(pyblish.api.InstancePlugin):
             payload = self._get_arnold_export_payload(data)
             self.log.info("Submitting ass export job.")
 
-        url = "{}/api/jobs".format(self._deadline_url)
+        url = "{}/api/jobs".format(self.deadline_url)
         response = self._requests_post(url, json=payload)
         if not response.ok:
             self.log.error("Submition failed!")

openpype/modules/deadline/plugins/publish/submit_nuke_deadline.py

@@ -42,13 +42,12 @@ class NukeSubmitDeadline(pyblish.api.InstancePlugin):
         node = instance[0]
         context = instance.context
 
-        deadline_url = (
-            context.data["system_settings"]
-            ["modules"]
-            ["deadline"]
-            ["DEADLINE_REST_URL"]
-        )
-        assert deadline_url, "Requires DEADLINE_REST_URL"
+        # get default deadline webservice url from deadline module
+        deadline_url = instance.context.data["defaultDeadline"]
+        # if custom one is set in instance, use that
+        if instance.data.get("deadlineUrl"):
+            deadline_url = instance.data.get("deadlineUrl")
+        assert deadline_url, "Requires Deadline Webservice URL"
 
         self.deadline_url = "{}/api/jobs".format(deadline_url)
         self._comment = context.data.get("comment", "")

openpype/modules/deadline/plugins/publish/submit_publish_job.py

@@ -5,7 +5,6 @@ import os
 import json
 import re
 from copy import copy, deepcopy
-import sys
 import openpype.api
 
 from avalon import api, io
@@ -615,14 +614,16 @@ class ProcessSubmittedJobOnFarm(pyblish.api.InstancePlugin):
             instance["families"] = families
 
     def process(self, instance):
+        # type: (pyblish.api.Instance) -> None
         """Process plugin.
 
         Detect type of renderfarm submission and create and post dependend job
         in case of Deadline. It creates json file with metadata needed for
         publishing in directory of render.
 
-        :param instance: Instance data
-        :type instance: dict
+        Args:
+            instance (pyblish.api.Instance): Instance data.
+
         """
         data = instance.data.copy()
         context = instance.context
@@ -908,13 +909,12 @@ class ProcessSubmittedJobOnFarm(pyblish.api.InstancePlugin):
             }
 
         if submission_type == "deadline":
-            self.deadline_url = (
-                context.data["system_settings"]
-                ["modules"]
-                ["deadline"]
-                ["DEADLINE_REST_URL"]
-            )
-            assert self.deadline_url, "Requires DEADLINE_REST_URL"
+            # get default deadline webservice url from deadline module
+            self.deadline_url = instance.context.data["defaultDeadline"]
+            # if custom one is set in instance, use that
+            if instance.data.get("deadlineUrl"):
+                self.deadline_url = instance.data.get("deadlineUrl")
+            assert self.deadline_url, "Requires Deadline Webservice URL"
 
             self._submit_deadline_post_job(instance, render_job, instances)
 

openpype/modules/deadline/plugins/publish/validate_deadline_connection.py

@@ -1,11 +1,10 @@
 import pyblish.api
 
 from avalon.vendor import requests
-from openpype.plugin import contextplugin_should_run
 import os
 
 
-class ValidateDeadlineConnection(pyblish.api.ContextPlugin):
+class ValidateDeadlineConnection(pyblish.api.InstancePlugin):
     """Validate Deadline Web Service is running"""
 
     label = "Validate Deadline Web Service"
@@ -13,18 +12,16 @@ class ValidateDeadlineConnection(pyblish.api.ContextPlugin):
     hosts = ["maya", "nuke"]
     families = ["renderlayer"]
 
-    def process(self, context):
-
-        # Workaround bug pyblish-base#250
-        if not contextplugin_should_run(self, context):
-            return
-
-        deadline_url = (
-            context.data["system_settings"]
-            ["modules"]
-            ["deadline"]
-            ["DEADLINE_REST_URL"]
-        )
+    def process(self, instance):
+        # get default deadline webservice url from deadline module
+        deadline_url = instance.context.data["defaultDeadline"]
+        # if custom one is set in instance, use that
+        if instance.data.get("deadlineUrl"):
+            deadline_url = instance.data.get("deadlineUrl")
+            self.log.info(
+                "We have deadline URL on instance {}".format(
+                    deadline_url))
+        assert deadline_url, "Requires Deadline Webservice URL"
 
         # Check response
         response = self._requests_get(deadline_url)

openpype/modules/deadline/plugins/publish/validate_expected_and_rendered_files.py

@@ -4,7 +4,6 @@ import pyblish.api
 
 from avalon.vendor import requests
 
-from openpype.api import get_system_settings
 from openpype.lib.abstract_submit_deadline import requests_get
 from openpype.lib.delivery import collect_frames
 
@@ -22,6 +21,7 @@ class ValidateExpectedFiles(pyblish.api.InstancePlugin):
     allow_user_override = True
 
     def process(self, instance):
+        self.instance = instance
         frame_list = self._get_frame_list(instance.data["render_job_id"])
 
         for repre in instance.data["representations"]:
@@ -129,13 +129,12 @@ class ValidateExpectedFiles(pyblish.api.InstancePlugin):
             Might be different than job info saved in metadata.json if user
             manually changes job pre/during rendering.
         """
-        deadline_url = (
-            get_system_settings()
-            ["modules"]
-            ["deadline"]
-            ["DEADLINE_REST_URL"]
-        )
-        assert deadline_url, "Requires DEADLINE_REST_URL"
+        # get default deadline webservice url from deadline module
+        deadline_url = self.instance.context.data["defaultDeadline"]
+        # if custom one is set in instance, use that
+        if self.instance.data.get("deadlineUrl"):
+            deadline_url = self.instance.data.get("deadlineUrl")
+        assert deadline_url, "Requires Deadline Webservice URL"
 
         url = "{}/api/jobs?JobID={}".format(deadline_url, job_id)
         try:

openpype/plugins/publish/collect_modules.py

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+"""Collect OpenPype modules."""
+from openpype.modules import ModulesManager
+import pyblish.api
+
+
+class CollectModules(pyblish.api.ContextPlugin):
+    """Collect OpenPype modules."""
+
+    order = pyblish.api.CollectorOrder
+    label = "OpenPype Modules"
+
+    def process(self, context):
+        manager = ModulesManager()
+        context.data["openPypeModules"] = manager.modules_by_name

openpype/settings/defaults/project_settings/deadline.json

@@ -1,4 +1,5 @@
 {
+    "deadline_servers": [],
     "publish": {
         "ValidateExpectedFiles": {
             "enabled": true,

openpype/settings/defaults/project_settings/maya.json

@@ -44,6 +44,12 @@
                 "Main"
             ]
         },
+        "CreateRender": {
+            "enabled": true,
+            "defaults": [
+                "Main"
+            ]
+        },
         "CreateAnimation": {
             "enabled": true,
             "defaults": [
@@ -94,12 +100,6 @@
                 "Main"
             ]
         },
-        "CreateRender": {
-            "enabled": true,
-            "defaults": [
-                "Main"
-            ]
-        },
         "CreateRenderSetup": {
             "enabled": true,
             "defaults": [

openpype/settings/defaults/system_settings/modules.json

@@ -140,7 +140,9 @@
     },
     "deadline": {
         "enabled": true,
-        "DEADLINE_REST_URL": "http://localhost:8082"
+        "deadline_urls": {
+            "default": "http://127.0.0.1:8082"
+        }
     },
     "muster": {
         "enabled": false,

openpype/settings/entities/__init__.py

@@ -105,7 +105,8 @@ from .enum_entity import (
     AppsEnumEntity,
     ToolsEnumEntity,
     TaskTypeEnumEntity,
-    ProvidersEnum
+    ProvidersEnum,
+    DeadlineUrlEnumEntity
 )
 
 from .list_entity import ListEntity
@@ -160,6 +161,7 @@ __all__ = (
     "ToolsEnumEntity",
     "TaskTypeEnumEntity",
     "ProvidersEnum",
+    "DeadlineUrlEnumEntity",
 
     "ListEntity",
 

openpype/settings/entities/enum_entity.py

@@ -443,3 +443,54 @@ class ProvidersEnum(BaseEnumEntity):
             self._current_value = value_on_not_set
 
         self.value_on_not_set = value_on_not_set
+
+
+class DeadlineUrlEnumEntity(BaseEnumEntity):
+    schema_types = ["deadline_url-enum"]
+
+    def _item_initalization(self):
+        self.multiselection = self.schema_data.get("multiselection", True)
+
+        self.enum_items = []
+        self.valid_keys = set()
+
+        if self.multiselection:
+            self.valid_value_types = (list,)
+            self.value_on_not_set = []
+        else:
+            for key in self.valid_keys:
+                if self.value_on_not_set is NOT_SET:
+                    self.value_on_not_set = key
+                    break
+
+            self.valid_value_types = (STRING_TYPE,)
+
+        # GUI attribute
+        self.placeholder = self.schema_data.get("placeholder")
+
+    def _get_enum_values(self):
+        system_settings_entity = self.get_entity_from_path("system_settings")
+
+        valid_keys = set()
+        enum_items_list = []
+        deadline_urls_entity = (
+            system_settings_entity
+            ["modules"]
+            ["deadline"]
+            ["deadline_urls"]
+        )
+        for server_name, url_entity in deadline_urls_entity.items():
+            enum_items_list.append(
+                {server_name: "{}: {}".format(server_name, url_entity.value)})
+            valid_keys.add(server_name)
+        return enum_items_list, valid_keys
+
+    def set_override_state(self, *args, **kwargs):
+        super(DeadlineUrlEnumEntity, self).set_override_state(*args, **kwargs)
+
+        self.enum_items, self.valid_keys = self._get_enum_values()
+        new_value = []
+        for key in self._current_value:
+            if key in self.valid_keys:
+                new_value.append(key)
+        self._current_value = new_value

openpype/settings/entities/schemas/projects_schema/schema_project_deadline.json

@@ -5,6 +5,12 @@
     "collapsible": true,
     "is_file": true,
     "children": [
+        {
+            "type": "deadline_url-enum",
+            "key": "deadline_servers",
+            "label": "Deadline Webservice URLs",
+            "multiselect": true
+        },
         {
             "type": "dict",
             "collapsible": true,

openpype/settings/entities/schemas/projects_schema/schemas/schema_maya_create.json

@@ -29,6 +29,26 @@
                 }
             ]
         },
+        {
+            "type": "dict",
+            "collapsible": true,
+            "key": "CreateRender",
+            "label": "Create Render",
+            "checkbox_key": "enabled",
+            "children": [
+                {
+                    "type": "boolean",
+                    "key": "enabled",
+                    "label": "Enabled"
+                },
+                {
+                    "type": "list",
+                    "key": "defaults",
+                    "label": "Default Subsets",
+                    "object_type": "text"
+                }
+            ]
+        },
         {
             "type": "schema_template",
             "name": "template_create_plugin",
@@ -65,10 +85,6 @@
                     "key": "CreatePointCache",
                     "label": "Create Cache"
                 },
-                {
-                    "key": "CreateRender",
-                    "label": "Create Render"
-                },
                 {
                     "key": "CreateRenderSetup",
                     "label": "Create Render Setup"

openpype/settings/entities/schemas/system_schema/schema_modules.json

@@ -130,9 +130,11 @@
                     "label": "Enabled"
                 },
                 {
-                    "type": "text",
-                    "key": "DEADLINE_REST_URL",
-                    "label": "Deadline Resl URL"
+                    "type": "dict-modifiable",
+                    "object_type": "text",
+                    "key": "deadline_urls",
+                    "required_keys": ["default"],
+                    "label": "Deadline Webservice URLs"
                 }
             ]
         },