Merge pull request #99 from cbcrc:feat/support_no_messageId

feat: support for no messageId in non-strict mode

packages/connector/src/MosConnection.ts

@@ -82,7 +82,8 @@ export class MosConnection extends EventEmitter implements IMosConnection {
 			this._conf.mosID,
 			connectionOptions.primary.timeout,
 			connectionOptions.primary.heartbeatInterval,
-			this._debug
+			this._debug,
+			this.mosTypes.strict
 		)
 		let secondary = null
 		this._ncsConnections[connectionOptions.primary.host] = primary
@@ -128,7 +129,8 @@ export class MosConnection extends EventEmitter implements IMosConnection {
 				this._conf.mosID,
 				connectionOptions.secondary.timeout,
 				connectionOptions.secondary.heartbeatInterval,
-				this._debug
+				this._debug,
+				this.mosTypes.strict
 			)
 			this._ncsConnections[connectionOptions.secondary.host] = secondary
 			secondary.on('rawMessage', (type: string, message: string) => {
@@ -459,7 +461,8 @@ export class MosConnection extends EventEmitter implements IMosConnection {
 						this._conf.mosID,
 						undefined,
 						undefined,
-						this._debug
+						this._debug,
+						this.mosTypes.strict
 					)
 					this._ncsConnections[remoteAddress] = primary
 

packages/connector/src/__tests__/Profile0-non-strict.spec.ts

@@ -2,6 +2,8 @@ import {
 	checkMessageSnapshot,
 	clearMocks,
 	decode,
+	DEFAULT_TIMEOUT,
+	delay,
 	doBeforeAll,
 	encode,
 	getMessageId,
@@ -104,6 +106,41 @@ describe('Profile 0 - non strict', () => {
 		expect(socketMockUpper).toBeTruthy()
 		expect(serverSocketMockLower).toBeTruthy()
 	})
+	test('send heartbeats - no messageId', async () => {
+		socketMockLower.setAutoReplyToHeartBeat(false) // Handle heartbeat manually
+		socketMockUpper.setAutoReplyToHeartBeat(false) // Handle heartbeat manually
+
+		const heartbeatCount = {
+			upper: 0,
+			lower: 0,
+		}
+
+		const mockReply = (portType: 'upper' | 'lower') => {
+			return (data: any) => {
+				const str = decode(data)
+
+				if (str.match(/<heartbeat/)) {
+					const repl = getXMLReply('', xmlData.heartbeat)
+					heartbeatCount[portType]++
+					return encode(repl)
+				} else throw new Error('Mock: Unhandled message: ' + str)
+			}
+		}
+
+		for (let i = 0; i < 100; i++) {
+			socketMockUpper.mockAddReply(mockReply('upper'))
+			socketMockLower.mockAddReply(mockReply('lower'))
+		}
+
+		// During this time, there should have been sent a few heartbeats to the server:
+		await delay(DEFAULT_TIMEOUT * 4.5)
+		expect(heartbeatCount.upper).toBeGreaterThanOrEqual(4)
+		expect(heartbeatCount.lower).toBeGreaterThanOrEqual(4)
+		expect(mosDevice.getConnectionStatus()).toMatchObject({ PrimaryConnected: true })
+
+		socketMockLower.setAutoReplyToHeartBeat(true) // reset
+		socketMockUpper.setAutoReplyToHeartBeat(true) // reset
+	})
 	test('requestMachineInfo - missing <time>', async () => {
 		// Prepare mock server response:
 		const mockReply = jest.fn((data) => {
@@ -152,6 +189,28 @@ describe('Profile 0 - non strict', () => {
 		expect(returnedMachineInfo).toMatchObject(replyMessage)
 		// expect(returnedMachineInfo.opTime).toBeUndefined()
 	})
+	test('requestMachineInfo - empty <time>, no messageId', async () => {
+		// Prepare mock server response:
+		const mockReply = jest.fn((_data) => {
+			const replyMessage = xmlData.machineInfo.replace(/<time>.*<\/time>/, '<time></time>')
+			const repl = getXMLReply('', replyMessage)
+			return encode(repl)
+		})
+		socketMockLower.mockAddReply(mockReply)
+		if (!xmlApiData.mosObj.ID) throw new Error('xmlApiData.mosObj.ID not set')
+
+		const returnedMachineInfo: IMOSListMachInfo = await mosDevice.requestMachineInfo()
+		expect(mockReply).toHaveBeenCalledTimes(1)
+		const msg = decode(mockReply.mock.calls[0][0])
+		expect(msg).toMatch(/<reqMachInfo\/>/)
+		checkMessageSnapshot(msg)
+
+		const replyMessage = { ...xmlApiData.machineInfoReply }
+		replyMessage.time = mosTypes.mosTime.fallback()
+
+		expect(returnedMachineInfo).toMatchObject(replyMessage)
+		// expect(returnedMachineInfo.opTime).toBeUndefined()
+	})
 	test('requestMachineInfo - bad formatted <time>', async () => {
 		// Prepare mock server response:
 		const mockReply = jest.fn((data) => {

packages/connector/src/__tests__/__snapshots__/Profile0-non-strict.spec.ts.snap

@@ -18,6 +18,15 @@ exports[`Profile 0 - non strict requestMachineInfo - empty <time> 1`] = `
 </mos>"
 `;
 
+exports[`Profile 0 - non strict requestMachineInfo - empty <time>, no messageId 1`] = `
+"<mos>
+  <ncsID>their.mos.id</ncsID>
+  <mosID>our.mos.id</mosID>
+  <messageID>xx</messageID>
+  <reqMachInfo/>
+</mos>"
+`;
+
 exports[`Profile 0 - non strict requestMachineInfo - missing <opTime> 1`] = `
 "<mos>
   <ncsID>their.mos.id</ncsID>

packages/connector/src/__tests__/lib.ts

@@ -120,6 +120,8 @@ export function getXMLReply(
 	ourMosId?: string,
 	theirMosId?: string
 ): string {
+	//add field only if messageId exist
+	if(messageId) messageId = '<messageID>' + messageId + '</messageID>'
 	return (
 		'<mos>' +
 		'<mosID>' +
@@ -128,9 +130,7 @@ export function getXMLReply(
 		'<ncsID>' +
 		(theirMosId || 'their.mos.id') +
 		'</ncsID>' +
-		'<messageID>' +
 		messageId +
-		'</messageID>' +
 		content +
 		'</mos>\r\n'
 	)

packages/connector/src/connection/NCSServerConnection.ts

@@ -30,6 +30,7 @@ export class NCSServerConnection extends EventEmitter implements INCSServerConne
 	private _timeout: number
 	private _mosID: string
 	private _debug: boolean
+	private _strict = false
 	private _disposed = false
 
 	private _clients: { [clientID: string]: ClientDescription } = {}
@@ -45,7 +46,8 @@ export class NCSServerConnection extends EventEmitter implements INCSServerConne
 		mosID: string,
 		timeout: number | undefined,
 		heartbeatsInterval: number | undefined,
-		debug: boolean
+		debug: boolean,
+		strict: boolean
 	) {
 		super()
 		this._id = id
@@ -55,13 +57,21 @@ export class NCSServerConnection extends EventEmitter implements INCSServerConne
 		this._mosID = mosID
 		this._connected = false
 		this._debug = debug ?? false
+		this._strict = strict ?? false
 	}
 	get timeout(): number {
 		return this._timeout
 	}
 	/** Create a MOS client, which talks to  */
 	createClient(clientID: string, port: number, clientDescription: ConnectionType, useHeartbeats: boolean): void {
-		const client = new MosSocketClient(this._host, port, clientDescription, this._timeout, this._debug)
+		const client = new MosSocketClient(
+			this._host,
+			port,
+			clientDescription,
+			this._timeout,
+			this._debug,
+			this._strict
+		)
 		this.debugTrace('registerOutgoingConnection', clientID)
 
 		this._clients[clientID] = {

packages/connector/src/connection/mosSocketClient.ts

@@ -20,6 +20,7 @@ export class MosSocketClient extends EventEmitter {
 	private _reconnectDelay = 3000
 	private _reconnectAttempts = 0
 	private _debug: boolean
+	private _strict: boolean
 
 	private _description: string
 	private _client: Socket | undefined
@@ -48,13 +49,14 @@ export class MosSocketClient extends EventEmitter {
 	private messageParser: MosMessageParser
 
 	/** */
-	constructor(host: string, port: number, description: string, timeout: number, debug: boolean) {
+	constructor(host: string, port: number, description: string, timeout: number, debug: boolean, strict: boolean) {
 		super()
 		this._host = host
 		this._port = port
 		this._description = description
 		this._commandTimeout = timeout || DEFAULT_COMMAND_TIMEOUT
 		this._debug = debug ?? false
+		this._strict = strict ?? false
 
 		this.messageParser = new MosMessageParser(description)
 		this.messageParser.debug = this._debug
@@ -390,7 +392,7 @@ export class MosSocketClient extends EventEmitter {
 	}
 
 	private _handleMessage(parsedData: any, messageString: string) {
-		const messageId = parsedData.mos.messageID
+		const messageId = this._getMessageId(parsedData, messageString)
 		if (messageId) {
 			const sentMessage = this._sentMessage || this._lingeringMessage
 			if (sentMessage) {
@@ -441,6 +443,42 @@ export class MosSocketClient extends EventEmitter {
 		this.processQueue()
 	}
 
+	private _getMessageId(parsedData: any, messageString: string): string | undefined {
+		// If there is a messageID, just return it:
+		if (typeof parsedData.mos.messageID === 'string' && parsedData.mos.messageID !== '')
+			return parsedData.mos.messageID
+
+		if (this._strict) {
+			this.debugTrace(`Reply with no messageId: ${messageString}. Try non-strict mode.`)
+			return undefined
+		} else {
+			// In non-strict mode: handle special cases:
+
+			// <heartbeat> response doesn't contain messageId (compliant with MOS version 2.8)
+			// we can assume it's the same as our sent message:
+			if (
+				this._sentMessage &&
+				this._sentMessage.msg.toString().search('<heartbeat>') >= 0 &&
+				parsedData.mos.heartbeat
+			) {
+				return `${this._sentMessage.msg.messageID}`
+			}
+
+			// <reqMachInfo> response doesn't contain messageId (compliant with MOS version 2.8)
+			// we can assume it's the same as our sent message:
+			if (
+				this._sentMessage &&
+				this._sentMessage.msg.toString().search('<reqMachInfo/>') >= 0 &&
+				parsedData.mos.listMachInfo
+			) {
+				return `${this._sentMessage.msg.messageID}`
+			} else {
+				this.debugTrace(`Invalid reply with no messageId in non-strict mode: ${messageString}`)
+				return undefined
+			}
+		}
+	}
+
 	/** */
 	private _onError(error: Error) {
 		// dispatch error!!!!!