feat(MOS): support OpenMedia's hot standby

packages/mos-gateway/src/$schemas/devices.json

@@ -105,6 +105,12 @@
 					"ui:description": "How often to ping NRCS to determine connection status",
 					"default": 30000
 				},
+				"hotStandby": {
+					"type": "boolean",
+					"ui:title": "Secondary: Hot Standby",
+					"ui:description": "Is the secondary connection a hot standby for the primary",
+					"default": false
+				},
 				"ports": {
 					"type": "object",
 					"ui:title": "Ports",

packages/mos-gateway/src/CoreMosDeviceHandler.ts

@@ -75,13 +75,15 @@ export class CoreMosDeviceHandler {
 	private _pendingStoryItemChanges: Array<IStoryItemChange> = []
 	private _pendingChangeTimeout: number = 60 * 1000
 	private mosTypes: MosTypes
+	private _hotStandby: boolean
 
 	private _messageQueue: Queue
 
-	constructor(parent: CoreHandler, mosDevice: IMOSDevice, mosHandler: MosHandler) {
+	constructor(parent: CoreHandler, mosDevice: IMOSDevice, mosHandler: MosHandler, hotStandby: boolean) {
 		this._coreParentHandler = parent
 		this._mosDevice = mosDevice
 		this._mosHandler = mosHandler
+		this._hotStandby = hotStandby
 
 		this._messageQueue = new Queue()
 
@@ -138,25 +140,47 @@ export class CoreMosDeviceHandler {
 		let statusCode: StatusCode
 		const messages: Array<string> = []
 
-		if (connectionStatus.PrimaryConnected) {
-			if (connectionStatus.SecondaryConnected || !this._mosDevice.idSecondary) {
+		if (this._hotStandby) {
+			// OpenMedia treats secondary server as hot-standby
+			// And thus is not considered as a warning if it's not connected
+			if (connectionStatus.PrimaryConnected) {
 				statusCode = StatusCode.GOOD
 			} else {
-				statusCode = StatusCode.WARNING_MINOR
+				// Primary not connected is only bad if there is no secondary:
+				if (connectionStatus.SecondaryConnected) {
+					statusCode = StatusCode.GOOD
+					messages.push(connectionStatus.SecondaryStatus || 'Running NRCS on hot standby')
+				} else {
+					statusCode = StatusCode.BAD
+					// Send messages for both connections
+					messages.push(connectionStatus.PrimaryStatus || 'Primary and hot standby are not connected')
+					messages.push(connectionStatus.SecondaryStatus || 'Primary and hot standby are not connected')
+				}
 			}
 		} else {
-			if (connectionStatus.SecondaryConnected) {
-				statusCode = StatusCode.WARNING_MAJOR
+			if (connectionStatus.PrimaryConnected) {
+				// ENPS expect both Primary and Secondary to be connected if both of them are configured
+				if (connectionStatus.SecondaryConnected || !this._mosDevice.idSecondary) {
+					statusCode = StatusCode.GOOD
+				} else {
+					statusCode = StatusCode.WARNING_MINOR
+				}
 			} else {
-				statusCode = StatusCode.BAD
+				if (connectionStatus.SecondaryConnected) {
+					// Primary not connected should give a warning if Secondary is used.
+					statusCode = StatusCode.WARNING_MAJOR
+				} else {
+					// If neither Primary nor Secondary is connected, it's a bad state.
+					statusCode = StatusCode.BAD
+				}
 			}
-		}
 
-		if (!connectionStatus.PrimaryConnected) {
-			messages.push(connectionStatus.PrimaryStatus || 'Primary not connected')
-		}
-		if (this._mosDevice.idSecondary && !connectionStatus.SecondaryConnected) {
-			messages.push(connectionStatus.SecondaryStatus || 'Fallback not connected')
+			if (!connectionStatus.PrimaryConnected) {
+				messages.push(connectionStatus.PrimaryStatus || 'Primary not connected')
+			}
+			if (this._mosDevice.idSecondary && !connectionStatus.SecondaryConnected) {
+				messages.push(connectionStatus.SecondaryStatus || 'Fallback not connected')
+			}
 		}
 
 		this.core

packages/mos-gateway/src/coreHandler.ts

@@ -142,9 +142,13 @@ export class CoreHandler {
 
 		return options
 	}
-	async registerMosDevice(mosDevice: IMOSDevice, mosHandler: MosHandler): Promise<CoreMosDeviceHandler> {
+	async registerMosDevice(
+		mosDevice: IMOSDevice,
+		mosHandler: MosHandler,
+		hotStandby: boolean
+	): Promise<CoreMosDeviceHandler> {
 		this.logger.info('registerMosDevice -------------')
-		const coreMos = new CoreMosDeviceHandler(this, mosDevice, mosHandler)
+		const coreMos = new CoreMosDeviceHandler(this, mosDevice, mosHandler, hotStandby)
 
 		this._coreMosHandlers.push(coreMos)
 		return coreMos.init().then(() => {

packages/mos-gateway/src/generated/devices.ts

@@ -24,6 +24,7 @@ export interface MosDeviceConfig {
 		dontUseQueryPort?: boolean
 		timeout?: number
 		heartbeatInterval?: number
+		hotStandby?: boolean
 		ports?: {
 			lower: number
 			upper: number

packages/mos-gateway/src/mosHandler.ts

@@ -59,13 +59,15 @@ export class MosHandler {
 	private _logger: Winston.Logger
 	private _disposed = false
 	private _settings?: MosGatewayConfig
+	private _hotStandby: boolean
 	private _coreHandler: CoreHandler | undefined
 	private _observers: Array<Observer<any>> = []
 	private _triggerupdateDevicesTimeout: any = null
 	private mosTypes: MosTypes
 
 	constructor(logger: Winston.Logger) {
 		this._logger = logger
+		this._hotStandby = false
 		this.mosTypes = getMosTypes(this.strict) // temporary, another will be set upon init()
 	}
 	async init(config: MosConfig, coreHandler: CoreHandler): Promise<void> {
@@ -101,7 +103,7 @@ export class MosHandler {
 
 		this.mosTypes = getMosTypes(this.strict)
 
-		await this._initMosConnection()
+		await this._updateDevices()
 
 		if (!this._coreHandler) throw Error('_coreHandler is undefined!')
 		this._coreHandler.onConnected(() => {
@@ -110,8 +112,6 @@ export class MosHandler {
 			this.sendStatusOfAllMosDevices()
 		})
 		this.setupObservers()
-
-		return this._updateDevices()
 	}
 	async dispose(): Promise<void> {
 		this._disposed = true
@@ -243,7 +243,7 @@ export class MosHandler {
 
 				if (!this._coreHandler) throw Error('_coreHandler is undefined!')
 
-				const coreMosHandler = await this._coreHandler.registerMosDevice(mosDevice, this)
+				const coreMosHandler = await this._coreHandler.registerMosDevice(mosDevice, this, this._hotStandby)
 				// this._logger.info('mosDevice registered -------------')
 				// Setup message flow between the devices:
 
@@ -420,6 +420,7 @@ export class MosHandler {
 			for (const [deviceId, device] of Object.entries<{ options: MosDeviceConfig }>(devices)) {
 				if (device) {
 					if (device.options.secondary) {
+						this._hotStandby = device.options.secondary?.hotStandby || false
 						// If the host isn't set, don't use secondary:
 						if (!device.options.secondary.host || !device.options.secondary.id)
 							delete device.options.secondary