Merge branch 'feat--Reduce-ingest-visual-noise' into bbc-main-autonext

Author: PeterC89

meteor/server/publications/partInstancesUI/publication.ts

@@ -136,6 +136,9 @@ export async function manipulateUIPartInstancesPublicationData(
 	updateProps: Partial<ReadonlyDeep<UIPartInstancesUpdateProps>> | undefined
 ): Promise<void> {
 	// Prepare data for publication:
+	// - With quickLoop invalidation: refresh all cached PartInstances.
+	// - Without quickLoop invalidation: refresh only explicitly invalidated PartInstances and
+	//   those in explicitly invalidated segments.
 
 	if (updateProps?.newCache !== undefined) {
 		state.contentCache = updateProps.newCache ?? undefined
@@ -186,25 +189,60 @@ export async function manipulateUIPartInstancesPublicationData(
 		collection.remove(partId) // if it still exists, it will be replaced in the next step
 	})
 
+	const invalidateQuickLoop = !!updateProps?.invalidateQuickLoop
+	const invalidatedSegmentIds = updateProps?.invalidateSegmentIds ?? []
+	const invalidatedPartInstanceIds = updateProps?.invalidatePartInstanceIds ?? []
+
+	if (!invalidateQuickLoop && invalidatedSegmentIds.length === 0 && invalidatedPartInstanceIds.length === 0) {
+		return
+	}
+
 	const invalidatedSegmentsSet = new Set(updateProps?.invalidateSegmentIds ?? [])
 	const invalidatedPartInstancesSet = new Set(updateProps?.invalidatePartInstanceIds ?? [])
+	const processedPartInstanceIds = new Set<PartInstanceId>()
+
+	const replacePartInstance = (partInstance: DBPartInstance): void => {
+		processedPartInstanceIds.add(partInstance._id)
+		modifyPartInstanceForQuickLoop(
+			partInstance,
+			segmentRanks,
+			rundownRanks,
+			playlist,
+			studioSettings.settings,
+			quickLoopStartPosition,
+			quickLoopEndPosition
+		)
+		collection.replace(partInstance)
+	}
+
+	if (!invalidateQuickLoop) {
+		for (const partInstanceId of invalidatedPartInstanceIds) {
+			const partInstance = state.contentCache.PartInstances.findOne(partInstanceId)
+			if (partInstance) replacePartInstance(partInstance)
+		}
+
+		if (invalidatedSegmentIds.length > 0) {
+			state.contentCache.PartInstances.find({
+				segmentId: {
+					$in: invalidatedSegmentIds,
+				},
+			}).forEach((partInstance) => {
+				if (!processedPartInstanceIds.has(partInstance._id)) {
+					replacePartInstance(partInstance)
+				}
+			})
+		}
+
+		return
+	}
 
 	state.contentCache.PartInstances.find({}).forEach((partInstance) => {
 		if (
 			updateProps?.invalidateQuickLoop ||
 			invalidatedSegmentsSet.has(partInstance.segmentId) ||
 			invalidatedPartInstancesSet.has(partInstance._id)
 		) {
-			modifyPartInstanceForQuickLoop(
-				partInstance,
-				segmentRanks,
-				rundownRanks,
-				playlist,
-				studioSettings.settings,
-				quickLoopStartPosition,
-				quickLoopEndPosition
-			)
-			collection.replace(partInstance)
+			replacePartInstance(partInstance)
 		}
 	})
 }

packages/blueprints-integration/src/context/processIngestDataContext.ts

@@ -3,6 +3,12 @@ import type { IStudioContext } from './studioContext.js'
 import type { IngestDefaultChangesOptions, MutableIngestRundown, NrcsIngestChangeDetails } from '../ingest.js'
 
 export interface IProcessIngestDataContext extends IStudioContext {
+	/**
+	 * Request that `syncIngestUpdateToPartInstance` is executed for current/next part instances
+	 * during commit, even when ingest changes would normally not select any part instances.
+	 */
+	requestSyncIngestUpdateToPartInstances(): void
+
 	/**
 	 * Perform the default syncing of changes from the ingest data to the rundown.
 	 *

packages/job-worker/src/blueprints/__tests__/context.test.ts

@@ -3,6 +3,7 @@ import { unprotectString } from '@sofie-automation/corelib/dist/protectedString'
 import { MockJobContext, setupDefaultJobEnvironment } from '../../__mocks__/context.js'
 import { getShowStyleConfigRef, getStudioConfigRef } from '../configRefs.js'
 import { CommonContext } from '../context/CommonContext.js'
+import { ProcessIngestDataContext } from '../context/ProcessIngestDataContext.js'
 import { StudioContext } from '../context/StudioContext.js'
 import { ShowStyleContext } from '../context/ShowStyleContext.js'
 
@@ -134,4 +135,21 @@ describe('Test blueprint api context', () => {
 	describe('SegmentUserContext', () => {
 		// TODO?
 	})
+
+	describe('ProcessIngestDataContext', () => {
+		test('requestSyncIngestUpdateToPartInstances', () => {
+			const context = new ProcessIngestDataContext(
+				{ name: 'processIngestData', identifier: unprotectString(jobContext.studioId) },
+				jobContext.studio,
+				jobContext.getStudioBlueprintConfig()
+			)
+
+			expect(context.consumeSyncIngestUpdateToPartInstancesRequest()).toBe(false)
+
+			context.requestSyncIngestUpdateToPartInstances()
+
+			expect(context.consumeSyncIngestUpdateToPartInstancesRequest()).toBe(true)
+			expect(context.consumeSyncIngestUpdateToPartInstancesRequest()).toBe(false)
+		})
+	})
 })

packages/job-worker/src/blueprints/context/ProcessIngestDataContext.ts

@@ -20,6 +20,18 @@ import {
  * Custom updates of the IngestRundown are done by calling methods on the mutableIngestRundown itself.
  */
 export class ProcessIngestDataContext extends StudioContext implements IProcessIngestDataContext {
+	#syncIngestUpdateToPartInstancesRequested = false
+
+	requestSyncIngestUpdateToPartInstances(): void {
+		this.#syncIngestUpdateToPartInstancesRequested = true
+	}
+
+	consumeSyncIngestUpdateToPartInstancesRequest(): boolean {
+		const requested = this.#syncIngestUpdateToPartInstancesRequested
+		this.#syncIngestUpdateToPartInstancesRequested = false
+		return requested
+	}
+
 	defaultApplyIngestChanges<TRundownPayload, TSegmentPayload, TPartPayload>(
 		mutableIngestRundown: MutableIngestRundown<TRundownPayload, TSegmentPayload, TPartPayload>,
 		nrcsIngestRundown: IngestRundown,

packages/job-worker/src/blueprints/ingest/MutableIngestRundownImpl.ts

@@ -386,6 +386,7 @@ export class MutableIngestRundownImpl<
 				segmentsUpdatedRanks,
 				segmentsToRegenerate,
 				regenerateRundown,
+				forceSyncIngestUpdateToPartInstances: false,
 				segmentExternalIdChanges: segmentExternalIdChanges,
 			},
 

packages/job-worker/src/blueprints/ingest/__tests__/MutableIngestRundownImpl.spec.ts

@@ -109,6 +109,7 @@ describe('MutableIngestRundownImpl', () => {
 				segmentsUpdatedRanks: {},
 				segmentsToRegenerate: [],
 				regenerateRundown: false,
+				forceSyncIngestUpdateToPartInstances: false,
 
 				segmentExternalIdChanges: {},
 			},

packages/job-worker/src/ingest/__tests__/ingest.test.ts

@@ -1,6 +1,7 @@
 import '../../__mocks__/_extendJest.js'
 import {
 	IBlueprintPiece,
+	IngestChangeType,
 	IngestPart,
 	IngestRundown,
 	IngestSegment,
@@ -51,6 +52,7 @@ import { PlayoutPartInstanceModel } from '../../playout/model/PlayoutPartInstanc
 import { NrcsIngestCacheType } from '@sofie-automation/corelib/dist/dataModel/NrcsIngestDataCache'
 import { wrapGenericIngestJob, wrapGenericIngestJobWithPrecheck } from '../jobWrappers.js'
 import { wrapDefaultObject } from '@sofie-automation/corelib/dist/settings/objectWithOverrides'
+import { ProcessIngestDataContext } from '../../blueprints/context/ProcessIngestDataContext.js'
 
 const handleRemovedRundownWrapped = wrapGenericIngestJob(handleRemovedRundown)
 const handleUpdatedRundownWrapped = wrapGenericIngestJob(handleUpdatedRundown)
@@ -1608,6 +1610,77 @@ describe('Test ingest actions for rundowns and segments', () => {
 		}
 	})
 
+	test('processIngestData can force syncIngestUpdateToPartInstance for active rundown', async () => {
+		const rundownData = clone(rundownData1)
+		const syncIngestUpdateToPartInstance = jest.fn()
+
+		context.updateStudioBlueprint({
+			processIngestData: async (
+				blueprintContext,
+				mutableIngestRundown,
+				nrcsIngestRundown,
+				_previous,
+				ingestChanges
+			) => {
+				if (ingestChanges.source !== IngestChangeType.Ingest) {
+					throw new Error(`Expected ingest changes for this test`)
+				}
+
+				blueprintContext.defaultApplyIngestChanges(mutableIngestRundown, nrcsIngestRundown, ingestChanges)
+				;(blueprintContext as ProcessIngestDataContext).requestSyncIngestUpdateToPartInstances()
+			},
+		})
+		context.updateShowStyleBlueprint({
+			syncIngestUpdateToPartInstance,
+		})
+
+		try {
+			await handleUpdatedRundownWrapped(context, {
+				rundownExternalId: rundownData.externalId,
+				ingestRundown: rundownData,
+				isCreateAction: true,
+				rundownSource: createRundownSource(device),
+			})
+
+			const rundown = (await context.mockCollections.Rundowns.findOne({ externalId: externalId })) as DBRundown
+			expect(rundown).toBeTruthy()
+
+			await handleActivateRundownPlaylist(context, {
+				playlistId: rundown.playlistId,
+				rehearsal: true,
+			})
+			await handleTakeNextPart(context, { playlistId: rundown.playlistId, fromPartInstanceId: null })
+
+			const selectedInstances = await getSelectedPartInstances(
+				context,
+				(await context.mockCollections.RundownPlaylists.findOne(rundown.playlistId)) as DBRundownPlaylist
+			)
+			expect(selectedInstances.currentPartInstance?.part.externalId).toBe('part0')
+			expect(selectedInstances.nextPartInstance?.part.externalId).toBe('part1')
+
+			syncIngestUpdateToPartInstance.mockClear()
+
+			await handleUpdatedPartWrapped(context, {
+				rundownExternalId: rundownData.externalId,
+				ingestPart: {
+					externalId: 'part2',
+					name: 'Part 2 updated',
+					rank: 0,
+					payload: undefined,
+				},
+				segmentExternalId: 'segment1',
+				isCreateAction: false,
+			})
+
+			expect(syncIngestUpdateToPartInstance).toHaveBeenCalled()
+			const playStatuses = syncIngestUpdateToPartInstance.mock.calls.map((call) => call[3])
+			expect(playStatuses.some((status) => status === 'current' || status === 'next')).toBe(true)
+		} finally {
+			context.updateStudioBlueprint({ processIngestData: undefined as any })
+			context.updateShowStyleBlueprint({ syncIngestUpdateToPartInstance: undefined as any })
+		}
+	})
+
 	test('previous partinstance getting removed if an adlib part', async () => {
 		const rundownData: IngestRundown = {
 			externalId: externalId,

packages/job-worker/src/ingest/__tests__/syncChangesToPartInstance.test.ts

@@ -16,7 +16,7 @@ import type { DBPart } from '@sofie-automation/corelib/dist/dataModel/Part'
 import { protectString } from '@sofie-automation/corelib/dist/protectedString'
 import { PlayoutModelImpl } from '../../playout/model/implementation/PlayoutModelImpl.js'
 import { PlaylistTimingType, ShowStyleBlueprintManifest } from '@sofie-automation/blueprints-integration'
-import { RundownPlaylistId } from '@sofie-automation/corelib/dist/dataModel/Ids'
+import { RundownPlaylistId, SegmentId } from '@sofie-automation/corelib/dist/dataModel/Ids'
 import {
 	DBRundownPlaylist,
 	SelectedPartInstance,
@@ -82,6 +82,55 @@ describe('SyncChangesToPartInstancesWorker', () => {
 			expect(instancesToSync).toHaveLength(0)
 		})
 
+		test('Current partInstance is skipped when changedSegmentIds does not include its segment', async () => {
+			const context = setupDefaultJobEnvironment()
+
+			const affectedSegmentId = protectString<SegmentId>('affectedSegmentId')
+			const unchangedSegmentId = protectString<SegmentId>('unchangedSegmentId')
+
+			const currentPartInstance = mock<PlayoutPartInstanceModel>(
+				{
+					partInstance: {
+						_id: protectString('currentPartInstanceId'),
+						segmentId: unchangedSegmentId,
+						rundownId: protectString('mockRundownId'),
+						takeCount: 0,
+						rehearsal: false,
+						playlistActivationId: protectString('mockPlaylistActivationId'),
+						segmentPlayoutId: protectString('mockSegmentPlayoutId'),
+						part: createMockPart('currentPartId'),
+					} satisfies PlayoutPartInstanceModel['partInstance'],
+				},
+				mockOptions
+			)
+
+			const playoutModel = mock<PlayoutModel>(
+				{
+					currentPartInstance,
+					nextPartInstance: null,
+					previousPartInstance: null,
+					findPart: jest.fn(() => createMockPart('currentPartId')),
+				},
+				mockOptions
+			)
+
+			const ingestModel = createMockIngestModelReadonly()
+			const rundownModel = mock<PlayoutRundownModel>(
+				{
+					rundown: {
+						_id: protectString('mockRundownId'),
+					} as any,
+				},
+				mockOptions
+			)
+
+			const instancesToSync = findInstancesToSync(context, playoutModel, ingestModel, rundownModel, [
+				affectedSegmentId,
+			])
+
+			expect(instancesToSync).toHaveLength(0)
+		})
+
 		// TODO - this needs a lot more fleshing out
 	})
 

packages/job-worker/src/ingest/commit.ts

@@ -229,8 +229,17 @@ export async function CommitIngestOperation(
 			await validateAdlibTestingSegment(context, playoutModel)
 
 			try {
+				const syncChangedSegmentIds = data.forceSyncIngestUpdateToPartInstances
+					? undefined
+					: data.changedSegmentIds
+				if (data.forceSyncIngestUpdateToPartInstances) {
+					logger.debug(
+						`Forcing syncChangesToPartInstances for rundown "${ingestModel.rundownId}" without segment filtering`
+					)
+				}
+
 				// sync changes to the 'selected' partInstances
-				await syncChangesToPartInstances(context, playoutModel, ingestModel)
+				await syncChangesToPartInstances(context, playoutModel, ingestModel, syncChangedSegmentIds)
 
 				// update the quickloop in case we did any changes to things involving marker
 				playoutModel.updateQuickLoopState()

packages/job-worker/src/ingest/generationRundown.ts

@@ -93,6 +93,7 @@ export async function updateRundownFromIngestData(
 	span?.end()
 	return literal<CommitIngestDataExt>({
 		changedSegmentIds: regenerateSegmentsChanges?.changedSegmentIds ?? [],
+		forceSyncIngestUpdateToPartInstances: false,
 		removedSegmentIds: regenerateSegmentsChanges?.removedSegmentIds ?? [],
 		renamedSegments: new Map(),