[cuebot/cuegui] Feature add layer dispatchorder control

VERSION.in

@@ -1 +1 @@
-1.18
+1.19

cuebot/src/main/java/com/imageworks/spcue/dao/LayerDao.java

@@ -127,6 +127,15 @@ public interface LayerDao {
      */
     void updateLayerMinCores(LayerInterface layer, int val);
 
+
+    /**
+     * update the dispatch order of the layer
+     *
+     * @param layer
+     * @param val
+     */
+    void updateLayerDispatchOrder(LayerInterface layer, int val);
+
     /**
      * update the number of gpus the layer requires
      *

cuebot/src/main/java/com/imageworks/spcue/dao/postgres/LayerDaoJdbc.java

@@ -314,6 +314,15 @@ public void increaseLayerMinGpuMemory(LayerInterface layer, long kb) {
                 layer.getLayerId(), kb);
     }
 
+    @Override
+    public void updateLayerDispatchOrder(LayerInterface layer, int val) {
+        if (val < 0) {
+            throw new IllegalArgumentException("Layer dispatch order must be positive.");
+        }
+        getJdbcTemplate().update("UPDATE layer SET int_dispatch_order=? WHERE pk_layer=?", val,
+                layer.getLayerId());
+    }
+
     @Override
     public void updateLayerMinCores(LayerInterface layer, int val) {
         if (val < Dispatcher.CORE_POINTS_RESERVED_MIN) {

cuebot/src/main/java/com/imageworks/spcue/servant/ManageLayer.java

@@ -90,6 +90,8 @@
 import com.imageworks.spcue.grpc.job.LayerReorderFramesResponse;
 import com.imageworks.spcue.grpc.job.LayerRetryFramesRequest;
 import com.imageworks.spcue.grpc.job.LayerRetryFramesResponse;
+import com.imageworks.spcue.grpc.job.LayerSetDispatchOrderRequest;
+import com.imageworks.spcue.grpc.job.LayerSetDispatchOrderResponse;
 import com.imageworks.spcue.grpc.job.LayerSetMaxCoresRequest;
 import com.imageworks.spcue.grpc.job.LayerSetMaxCoresResponse;
 import com.imageworks.spcue.grpc.job.LayerSetMinCoresRequest;
@@ -235,6 +237,17 @@ public void setTags(LayerSetTagsRequest request,
         }
     }
 
+    @Override
+    public void setDispatchOrder(LayerSetDispatchOrderRequest request,
+            StreamObserver<LayerSetDispatchOrderResponse> responseObserver) {
+        updateLayer(request.getLayer());
+        if (attemptChange(env, property, jobManager, layer, responseObserver)) {
+            jobManager.setLayerDispatchOrder(layer, request.getOrder());
+            responseObserver.onNext(LayerSetDispatchOrderResponse.newBuilder().build());
+            responseObserver.onCompleted();
+        }
+    }
+
     @Override
     public void setMinCores(LayerSetMinCoresRequest request,
             StreamObserver<LayerSetMinCoresResponse> responseObserver) {

cuebot/src/main/java/com/imageworks/spcue/service/JobManager.java

@@ -423,6 +423,14 @@ public interface JobManager {
      */
     List<ThreadStats> getThreadStats(LayerInterface layer);
 
+    /**
+     * Update the dispatch order for the given layer.
+     *
+     * @param layer
+     * @param order
+     */
+    void setLayerDispatchOrder(LayerInterface layer, int order);
+
     /**
      * Update the max core value for the given layer.
      *

cuebot/src/main/java/com/imageworks/spcue/service/JobManagerService.java

@@ -441,6 +441,11 @@ public void setLayerTag(LayerInterface layer, String tag) {
         layerDao.updateLayerTags(layer, Sets.newHashSet(tag));
     }
 
+    @Override
+    public void setLayerDispatchOrder(LayerInterface layer, int order) {
+        layerDao.updateLayerDispatchOrder(layer, order);
+    }
+
     @Override
     public void setLayerMinCores(LayerInterface layer, int coreUnits) {
         layerDao.updateLayerMinCores(layer, coreUnits);

cuegui/cuegui/LayerMonitorTree.py

@@ -298,8 +298,9 @@ def contextMenuEvent(self, e):
         self.__menuActions.layers().addAction(depend_menu, "markdone")
         menu.addMenu(depend_menu)
 
+        menu.addSeparator()
+        reorder_dispatch_action = self.__menuActions.layers().addAction(menu, "reorder_dispatch")
         if len(__selectedObjects) == 1:
-            menu.addSeparator()
             try:
                 if int(self.app.settings.value("DisableDeeding", 0)) == 0:
                     if len({layer.data.range for layer in __selectedObjects}) == 1:

cuegui/cuegui/MenuActions.py

@@ -1076,6 +1076,31 @@ def dependWizard(self, rpcObjects=None):
         if layers:
             cuegui.DependWizard.DependWizard(self._caller, [self._getSource()], layers=layers)
 
+
+    reorder_dispatch_info = ["Reorder Dispatch...", None, "configure"]
+
+    def reorder_dispatch(self, rpcObjects=None):
+        layers = self._getOnlyLayerObjects(rpcObjects)
+        if not layers:
+            return
+
+        body = "Which dispatch order to set?"
+        if len(layers) > 1:
+            title = "Reorder layers"
+            for layer in layers:
+                body += '\n%s' % layer.data.name
+        else:
+            title = "Reorder layer %s" % layer.data.name
+
+        (order, choice) = QtWidgets.QInputDialog.getInt(self._caller, title, body, 1, 1, 100000, 1)
+        if not choice:
+            return
+
+        for layer in layers:
+            self.cuebotCall(layer.setDispatchOrder, "Reorder Dispatch Failed", order)
+
+        self._update()
+
     reorder_info = ["Reorder Frames...", None, "configure"]
 
     def reorder(self, rpcObjects=None):

proto/src/job.proto

@@ -358,6 +358,9 @@ service LayerInterface {
     // Retry the Frames of this Layer
     rpc RetryFrames(LayerRetryFramesRequest) returns (LayerRetryFramesResponse);
 
+    // Set the Dispatch Order of this Layer
+    rpc SetDispatchOrder(LayerSetDispatchOrderRequest) returns (LayerSetDispatchOrderResponse);
+
     // The maximum number of cores to run on a given frame within this layer.  Fractional core values are not allowed
     // with this setting.
     rpc SetMaxCores(LayerSetMaxCoresRequest) returns (LayerSetMaxCoresResponse);
@@ -1693,6 +1696,13 @@ message LayerRetryFramesRequest {
 
 message LayerRetryFramesResponse {} // Empty
 
+message LayerSetDispatchOrderRequest {
+    Layer layer = 1;
+    int32 order = 2;
+}
+
+message LayerSetDispatchOrderResponse {} // Empty
+
 // RegisterOutputPath
 message LayerRegisterOutputPathRequest {
     Layer layer = 1;

pycue/opencue/wrappers/layer.py

@@ -127,6 +127,17 @@ def setTags(self, tags):
         return self.stub.SetTags(job_pb2.LayerSetTagsRequest(layer=self.data, tags=tags),
                                  timeout=Cuebot.Timeout)
 
+    def setDispatchOrder(self, order):
+        """Sets the dispatch order for this layer.
+
+        :type  order: int
+        :param order: layer dipsatch order
+        """
+        return self.stub.SetDispatchOrder(
+            job_pb2.LayerSetDispatchOrderRequest(layer=self.data, order=order),
+            timeout=Cuebot.Timeout)
+
+
     def setMaxCores(self, cores):
         """Sets the maximum number of cores that this layer requires.