Merge remote-tracking branch 'public/master' into optimize

# Conflicts:
#	rust/crates/scheduler/src/accounting/redis_client.rs
#	rust/crates/scheduler/src/dao/layer_dao.rs
#	rust/crates/scheduler/src/host_cache/actor.rs
#	rust/crates/scheduler/src/host_cache/cache.rs
#	rust/crates/scheduler/src/pipeline/entrypoint.rs
#	rust/crates/scheduler/src/pipeline/matcher.rs

Author: DiegoTavares

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

@@ -448,6 +448,7 @@ public void setCommentEmail(ShowSetCommentEmailRequest request,
         adminManager.updateShowCommentEmail(getShowEntity(request.getShow()),
                 request.getEmail().split(","));
         responseObserver.onNext(ShowSetCommentEmailResponse.newBuilder().build());
+        responseObserver.onCompleted();
     }
 
     public AdminManager getAdminManager() {

cuebot/src/test/java/com/imageworks/spcue/test/servant/ManageShowTests.java

@@ -28,10 +28,15 @@
 import com.imageworks.spcue.config.TestAppConfig;
 import com.imageworks.spcue.dao.ShowDao;
 import com.imageworks.spcue.grpc.show.Show;
+import com.imageworks.spcue.grpc.show.ShowSetCommentEmailRequest;
+import com.imageworks.spcue.grpc.show.ShowSetCommentEmailResponse;
 import com.imageworks.spcue.grpc.show.ShowSetSchedulerManagedRequest;
 import com.imageworks.spcue.grpc.show.ShowSetSchedulerManagedResponse;
 import com.imageworks.spcue.servant.ManageShow;
 
+import io.grpc.stub.StreamObserver;
+
+import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
@@ -47,6 +52,55 @@ public class ManageShowTests extends AbstractTransactionalJUnit4SpringContextTes
 
     private static final String SHOW_NAME = "pipe";
 
+    /**
+     * StreamObserver that records whether onNext / onCompleted were called, so a servant method
+     * that forgets to close the stream (onCompleted) is caught.
+     */
+    private static class RecordingStreamObserver<T> implements StreamObserver<T> {
+        boolean nextCalled = false;
+        boolean completed = false;
+        Throwable error = null;
+
+        @Override
+        public void onNext(T value) {
+            nextCalled = true;
+        }
+
+        @Override
+        public void onError(Throwable t) {
+            error = t;
+        }
+
+        @Override
+        public void onCompleted() {
+            completed = true;
+        }
+    }
+
+    @Test
+    @Transactional
+    @Rollback(true)
+    public void testSetCommentEmail() {
+        ShowEntity show = showDao.findShowDetail(SHOW_NAME);
+        Show showProto = Show.newBuilder().setId(show.id).setName(show.name).build();
+
+        ShowSetCommentEmailRequest request = ShowSetCommentEmailRequest.newBuilder()
+                .setShow(showProto).setEmail("first@example.com,second@example.com").build();
+        RecordingStreamObserver<ShowSetCommentEmailResponse> observer =
+                new RecordingStreamObserver<ShowSetCommentEmailResponse>();
+
+        manageShow.setCommentEmail(request, observer);
+
+        // The RPC must both emit a response and CLOSE the stream; a missing
+        // onCompleted() leaves callers hanging until they time out.
+        assertTrue(observer.nextCalled);
+        assertTrue(observer.completed);
+
+        // And the email is persisted (split on comma, matching the servant).
+        assertArrayEquals(new String[] {"first@example.com", "second@example.com"},
+                showDao.findShowDetail(SHOW_NAME).commentMail);
+    }
+
     @Test
     @Transactional
     @Rollback(true)

cueweb/app/__tests__/allocations/allocation_utils.test.ts

@@ -0,0 +1,82 @@
+/*
+ * Copyright Contributors to the OpenCue Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  computeAllocationHostStats,
+  buildAllocationRows,
+} from '@/app/allocations/allocation-utils';
+import type { Allocation, Host } from '@/app/utils/get_utils';
+
+const host = (over: Partial<Host>): Host => ({
+  id: 'h', name: 'h', state: 'UP', lockState: 'OPEN', nimbyEnabled: false,
+  cores: 0, idleCores: 0, memory: '0', idleMemory: '0', totalMemory: '0',
+  freeMcp: '0', bootTime: 0, pingTime: 0, ...over,
+});
+
+describe('computeAllocationHostStats', () => {
+  it('sums DOWN/REPAIR cores and counts REPAIR hosts per allocation', () => {
+    const hosts: Host[] = [
+      host({ allocName: 'local.general', state: 'DOWN', cores: 8 }),
+      host({ allocName: 'local.general', state: 'REPAIR', cores: 4 }),
+      host({ allocName: 'local.general', state: 'REPAIR', cores: 2 }),
+      host({ allocName: 'local.general', state: 'UP', cores: 16 }),
+      host({ allocName: 'cloud.general', state: 'DOWN', cores: 32 }),
+    ];
+
+    const stats = computeAllocationHostStats(hosts);
+
+    expect(stats['local.general']).toEqual({ downCores: 8, repairCores: 6, repairHosts: 2 });
+    expect(stats['cloud.general']).toEqual({ downCores: 32, repairCores: 0, repairHosts: 0 });
+  });
+
+  it('ignores hosts with no allocName', () => {
+    const stats = computeAllocationHostStats([host({ state: 'DOWN', cores: 5 })]);
+    expect(stats).toEqual({});
+  });
+
+  it('returns {} for no hosts', () => {
+    expect(computeAllocationHostStats([])).toEqual({});
+  });
+});
+
+describe('buildAllocationRows', () => {
+  const alloc = (name: string): Allocation => ({
+    id: name, name, tag: 'general', facility: 'local',
+    stats: {
+      cores: 20, availableCores: 10, idleCores: 10, runningCores: 0,
+      lockedCores: 0, hosts: 2, lockedHosts: 0, downHosts: 0,
+    },
+  });
+
+  it('merges derived host stats onto each allocation', () => {
+    const rows = buildAllocationRows(
+      [alloc('local.general')],
+      { 'local.general': { downCores: 8, repairCores: 6, repairHosts: 2 } },
+    );
+    expect(rows[0].name).toBe('local.general');
+    expect(rows[0].stats?.cores).toBe(20);
+    expect(rows[0].downCores).toBe(8);
+    expect(rows[0].repairCores).toBe(6);
+    expect(rows[0].repairHosts).toBe(2);
+  });
+
+  it('defaults derived stats to 0 when an allocation has no matching hosts', () => {
+    const rows = buildAllocationRows([alloc('cloud.unassigned')], {});
+    expect(rows[0].downCores).toBe(0);
+    expect(rows[0].repairCores).toBe(0);
+    expect(rows[0].repairHosts).toBe(0);
+  });
+});

cueweb/app/__tests__/api/utils/action_utils.test.ts

@@ -18,6 +18,8 @@
 import {
     eatJobsDeadFrames,
     killJobs,
+    reparentGroups,
+    reparentJobs,
     unpauseJobs
 } from '@/app/utils/action_utils';
 import { accessActionApi } from '@/app/utils/api_utils';
@@ -138,6 +140,94 @@ describe('action_utils', () => {
         });
     });
 
+    // Reparent groups under a new parent group
+    describe('reparentGroups', () => {
+        it('posts a single ReparentGroups request with the new parent and group ids', async () => {
+            (accessActionApi as jest.Mock).mockResolvedValue({ success: true });
+
+            await reparentGroups('parent-1', ['g1', 'g2']);
+
+            expect(accessActionApi).toHaveBeenCalledWith(
+                '/api/group/action/reparentgroups',
+                [JSON.stringify({
+                    group: { id: 'parent-1' },
+                    groups: { groups: [{ id: 'g1' }, { id: 'g2' }] },
+                })]
+            );
+        });
+
+        it('returns true on success (the group tree relies on this to refetch)', async () => {
+            (accessActionApi as jest.Mock).mockResolvedValue({ success: true });
+
+            const result = await reparentGroups('parent-1', ['g1']);
+
+            expect(result).toBe(true);
+        });
+
+        it('handles API errors gracefully', async () => {
+            (accessActionApi as jest.Mock).mockRejectedValue(new Error('API Error'));
+
+            await reparentGroups('parent-1', ['g1']);
+
+            expect(handleError).toHaveBeenCalledWith(
+                new Error('API Error'),
+                `Error performing action for: /api/group/action/reparentgroups`
+            );
+        });
+
+        it('returns false on failure (the group tree relies on this to roll back)', async () => {
+            (accessActionApi as jest.Mock).mockRejectedValue(new Error('API Error'));
+
+            const result = await reparentGroups('parent-1', ['g1']);
+
+            expect(result).toBe(false);
+        });
+    });
+
+    // Reparent jobs under a new parent group
+    describe('reparentJobs', () => {
+        it('posts a single ReparentJobs request with the new parent and job ids', async () => {
+            (accessActionApi as jest.Mock).mockResolvedValue({ success: true });
+
+            await reparentJobs('parent-1', ['j1', 'j2']);
+
+            expect(accessActionApi).toHaveBeenCalledWith(
+                '/api/group/action/reparentjobs',
+                [JSON.stringify({
+                    group: { id: 'parent-1' },
+                    jobs: { jobs: [{ id: 'j1' }, { id: 'j2' }] },
+                })]
+            );
+        });
+
+        it('returns true on success (the group tree relies on this to refetch)', async () => {
+            (accessActionApi as jest.Mock).mockResolvedValue({ success: true });
+
+            const result = await reparentJobs('parent-1', ['j1']);
+
+            expect(result).toBe(true);
+        });
+
+        it('handles API errors gracefully', async () => {
+            (accessActionApi as jest.Mock).mockRejectedValue(new Error('API Error'));
+
+            await reparentJobs('parent-1', ['j1']);
+
+            expect(handleError).toHaveBeenCalledWith(
+                new Error('API Error'),
+                `Error performing action for: /api/group/action/reparentjobs`
+            );
+        });
+
+        it('returns false on failure (the group tree relies on this to roll back)', async () => {
+            (accessActionApi as jest.Mock).mockRejectedValue(new Error('API Error'));
+
+            const result = await reparentJobs('parent-1', ['j1']);
+
+            expect(result).toBe(false);
+        });
+    });
+
     // Testing unpauseJobs with error handling
     describe('unpauseJobs', () => {
         it('should handle API errors and trigger handleError', async () => {

cueweb/app/__tests__/api/utils/get_utils.test.ts

@@ -0,0 +1,86 @@
+/*
+ * Copyright Contributors to the OpenCue Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+    getShowGroups,
+    getGroupJobs,
+} from '@/app/utils/get_utils';
+import { accessGetApi } from '@/app/utils/api_utils';
+
+jest.mock('@/app/utils/api_utils', () => ({
+    accessGetApi: jest.fn(),
+}));
+
+jest.mock('@/app/utils/notify_utils', () => ({
+    handleError: jest.fn(),
+}));
+
+describe('get_utils group helpers', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    const mockGroups = [
+        { id: 'g1', name: 'root', parentId: '' },
+        { id: 'g2', name: 'sub', parentId: 'g1' },
+    ];
+
+    describe('getShowGroups', () => {
+        it('posts to /api/show/getgroups with the show id and returns the groups array', async () => {
+            (accessGetApi as jest.Mock).mockResolvedValue(mockGroups);
+
+            const result = await getShowGroups('show-123');
+
+            expect(accessGetApi).toHaveBeenCalledWith(
+                '/api/show/getgroups',
+                JSON.stringify({ show: { id: 'show-123' } })
+            );
+            expect(result).toEqual(mockGroups);
+        });
+
+        it('returns [] when the API responds with null', async () => {
+            (accessGetApi as jest.Mock).mockResolvedValue(null);
+
+            const result = await getShowGroups('show-123');
+
+            expect(result).toEqual([]);
+        });
+    });
+
+    describe('getGroupJobs', () => {
+        const mockJobs = [{ id: 'j1', name: 'job-1' }];
+
+        it('posts to /api/group/getjobs with the group id and returns the jobs array', async () => {
+            (accessGetApi as jest.Mock).mockResolvedValue(mockJobs);
+
+            const result = await getGroupJobs('group-abc');
+
+            expect(accessGetApi).toHaveBeenCalledWith(
+                '/api/group/getjobs',
+                JSON.stringify({ group: { id: 'group-abc' } })
+            );
+            expect(result).toEqual(mockJobs);
+        });
+
+        it('returns [] when the API responds with null', async () => {
+            (accessGetApi as jest.Mock).mockResolvedValue(null);
+
+            const result = await getGroupJobs('group-abc');
+
+            expect(result).toEqual([]);
+        });
+    });
+});