private void ProcessServerResponse(byte[] buffer, int length)
{
// Currently this work is done on the async socket completion thread, make sure work to be done is timely and if the response processing
// is coming in via the command channel and needs to send a command back to the server, it should be done on a separate thread...
if (buffer != null && length > 0)
{
try
{
ServerResponse responseCode = (ServerResponse)buffer[0];
ServerCommand commandCode = (ServerCommand)buffer[1];
int responseLength = EndianOrder.BigEndian.ToInt32(buffer, 2);
int responseIndex = DataPublisher.ClientResponseHeaderSize;
bool solicited = false;
byte[][][] keyIVs;
// See if this was a solicited response to a requested server command
if (responseCode.IsSolicited())
{
lock (m_requests)
{
int index = m_requests.BinarySearch(commandCode);
if (index >= 0)
{
solicited = true;
m_requests.RemoveAt(index);
}
}
// Disconnect any established UDP data channel upon successful unsubscribe
if (solicited && commandCode == ServerCommand.Unsubscribe && responseCode == ServerResponse.Succeeded)
DataChannel = null;
}
switch (responseCode)
{
case ServerResponse.Succeeded:
if (solicited)
{
switch (commandCode)
{
case ServerCommand.Authenticate:
OnStatusMessage("Success code received in response to server command \"{0}\": {1}", commandCode, InterpretResponseMessage(buffer, responseIndex, responseLength));
m_authenticated = true;
OnConnectionAuthenticated();
break;
case ServerCommand.Subscribe:
OnStatusMessage("Success code received in response to server command \"{0}\": {1}", commandCode, InterpretResponseMessage(buffer, responseIndex, responseLength));
m_subscribed = true;
if ((object)m_dataStreamMonitor != null)
m_dataStreamMonitor.Enabled = true;
break;
case ServerCommand.Unsubscribe:
OnStatusMessage("Success code received in response to server command \"{0}\": {1}", commandCode, InterpretResponseMessage(buffer, responseIndex, responseLength));
m_subscribed = false;
if ((object)m_dataStreamMonitor != null)
m_dataStreamMonitor.Enabled = false;
break;
case ServerCommand.RotateCipherKeys:
OnStatusMessage("Success code received in response to server command \"{0}\": {1}", commandCode, InterpretResponseMessage(buffer, responseIndex, responseLength));
break;
case ServerCommand.MetaDataRefresh:
OnStatusMessage("Success code received in response to server command \"{0}\": latest meta-data received.", commandCode);
OnMetaDataReceived(DeserializeMetadata(buffer.BlockCopy(responseIndex, responseLength)));
break;
}
}
else
{
switch (commandCode)
{
case ServerCommand.MetaDataRefresh:
// Meta-data refresh may be unsolicited
OnStatusMessage("Received server confirmation for unsolicited request to \"{0}\" command: latest meta-data received.", commandCode);
OnMetaDataReceived(DeserializeMetadata(buffer.BlockCopy(responseIndex, responseLength)));
break;
case ServerCommand.RotateCipherKeys:
// Key rotation may be unsolicited
OnStatusMessage("Received server confirmation for unsolicited request to \"{0}\" command: {1}", commandCode, InterpretResponseMessage(buffer, responseIndex, responseLength));
break;
case ServerCommand.Subscribe:
OnStatusMessage("Received unsolicited response to \"{0}\" command: {1}", commandCode, InterpretResponseMessage(buffer, responseIndex, responseLength));
break;
default:
OnProcessException(new InvalidOperationException("Publisher sent a success code for an unsolicited server command: " + commandCode));
break;
}
}
break;
case ServerResponse.Failed:
if (solicited)
OnStatusMessage("Failure code received in response to server command \"{0}\": {1}", commandCode, InterpretResponseMessage(buffer, responseIndex, responseLength));
else
OnProcessException(new InvalidOperationException("Publisher sent a failed code for an unsolicited server command: " + commandCode));
break;
case ServerResponse.DataPacket:
long now = DateTime.UtcNow.Ticks;
// Deserialize data packet
List<IMeasurement> measurements = new List<IMeasurement>();
DataPacketFlags flags;
Ticks timestamp = 0;
int count;
// Track total data packet bytes received from any channel
m_totalBytesReceived += m_lastBytesReceived;
m_monitoredBytesReceived += m_lastBytesReceived;
// Get data packet flags
flags = (DataPacketFlags)buffer[responseIndex];
responseIndex++;
bool synchronizedMeasurements = ((byte)(flags & DataPacketFlags.Synchronized) > 0);
bool compactMeasurementFormat = ((byte)(flags & DataPacketFlags.Compact) > 0);
bool compressedPayload = ((byte)(flags & DataPacketFlags.Compressed) > 0);
int cipherIndex = (flags & DataPacketFlags.CipherIndex) > 0 ? 1 : 0;
// Decrypt data packet payload if keys are available
if (m_keyIVs != null)
{
// Get a local copy of volatile keyIVs reference since this can change at any time
keyIVs = m_keyIVs;
// Decrypt payload portion of data packet
buffer = Common.SymmetricAlgorithm.Decrypt(buffer, responseIndex, responseLength - 1, keyIVs[cipherIndex][0], keyIVs[cipherIndex][1]);
responseIndex = 0;
responseLength = buffer.Length;
}
// Synchronized packets contain a frame level timestamp
if (synchronizedMeasurements)
{
timestamp = EndianOrder.BigEndian.ToInt64(buffer, responseIndex);
responseIndex += 8;
}
// Deserialize number of measurements that follow
count = EndianOrder.BigEndian.ToInt32(buffer, responseIndex);
responseIndex += 4;
if (compressedPayload)
{
if ((object)m_signalIndexCache == null && m_lastMissingCacheWarning + MissingCacheWarningInterval < now)
{
if (m_lastMissingCacheWarning != 0L)
{
// Warning message for missing signal index cache
OnStatusMessage("WARNING: Signal index cache has not arrived. No compact measurements can be parsed.");
}
m_lastMissingCacheWarning = now;
}
else
{
try
{
// Decompress compact measurements from payload
measurements.AddRange(buffer.DecompressPayload(m_signalIndexCache, responseIndex, responseLength - responseIndex + DataPublisher.ClientResponseHeaderSize, count, m_includeTime, flags));
}
catch (Exception ex)
{
OnProcessException(new InvalidOperationException("WARNING: Decompression failure: " + ex.Message, ex));
}
}
}
else
{
// Deserialize measurements
for (int i = 0; i < count; i++)
{
if (!compactMeasurementFormat)
{
// Deserialize full measurement format
SerializableMeasurement measurement = new SerializableMeasurement(m_encoding);
responseIndex += measurement.ParseBinaryImage(buffer, responseIndex, responseLength - responseIndex);
measurements.Add(measurement);
}
else if ((object)m_signalIndexCache != null)
{
// Deserialize compact measurement format
CompactMeasurement measurement = new CompactMeasurement(m_signalIndexCache, m_includeTime, m_baseTimeOffsets, m_timeIndex, m_useMillisecondResolution);
responseIndex += measurement.ParseBinaryImage(buffer, responseIndex, responseLength - responseIndex);
// Apply timestamp from frame if not included in transmission
if (!measurement.IncludeTime)
measurement.Timestamp = timestamp;
measurements.Add(measurement);
}
else if (m_lastMissingCacheWarning + MissingCacheWarningInterval < now)
{
if (m_lastMissingCacheWarning != 0L)
{
// Warning message for missing signal index cache
OnStatusMessage("WARNING: Signal index cache has not arrived. No compact measurements can be parsed.");
}
m_lastMissingCacheWarning = now;
}
}
}
// Provide new measurements to local concentrator, if defined, otherwise directly expose them to the consumer
if ((object)m_localConcentrator != null)
m_localConcentrator.SortMeasurements(measurements);
else
OnNewMeasurements(measurements);
break;
case ServerResponse.DataStartTime:
// Raise data start time event
OnDataStartTime(EndianOrder.BigEndian.ToInt64(buffer, responseIndex));
break;
case ServerResponse.ProcessingComplete:
// Raise input processing completed event
OnProcessingComplete(InterpretResponseMessage(buffer, responseIndex, responseLength));
break;
case ServerResponse.UpdateSignalIndexCache:
// Deserialize new signal index cache
m_remoteSignalIndexCache = DeserializeSignalIndexCache(buffer.BlockCopy(responseIndex, responseLength));
m_signalIndexCache = new SignalIndexCache(DataSource, m_remoteSignalIndexCache);
break;
case ServerResponse.UpdateBaseTimes:
// Get active time index
m_timeIndex = EndianOrder.BigEndian.ToInt32(buffer, responseIndex);
responseIndex += 4;
// Deserialize new base time offsets
m_baseTimeOffsets = new long[] { EndianOrder.BigEndian.ToInt64(buffer, responseIndex), EndianOrder.BigEndian.ToInt64(buffer, responseIndex + 8) };
break;
case ServerResponse.UpdateCipherKeys:
// Get active cipher index
m_cipherIndex = buffer[responseIndex++];
// Extract remaining response
byte[] bytes = buffer.BlockCopy(responseIndex, responseLength - 1);
// Decrypt response payload if subscription is authenticated
if (m_authenticated)
bytes = bytes.Decrypt(m_sharedSecret, CipherStrength.Aes256);
// Deserialize new cipher keys
keyIVs = new byte[2][][];
keyIVs[EvenKey] = new byte[2][];
keyIVs[OddKey] = new byte[2][];
int index = 0;
int bufferLen;
// Read even key size
bufferLen = EndianOrder.BigEndian.ToInt32(bytes, index);
index += 4;
// Read even key
keyIVs[EvenKey][KeyIndex] = new byte[bufferLen];
Buffer.BlockCopy(bytes, index, keyIVs[EvenKey][KeyIndex], 0, bufferLen);
index += bufferLen;
// Read even initialization vector size
bufferLen = EndianOrder.BigEndian.ToInt32(bytes, index);
index += 4;
// Read even initialization vector
keyIVs[EvenKey][IVIndex] = new byte[bufferLen];
Buffer.BlockCopy(bytes, index, keyIVs[EvenKey][IVIndex], 0, bufferLen);
index += bufferLen;
// Read odd key size
bufferLen = EndianOrder.BigEndian.ToInt32(bytes, index);
index += 4;
// Read odd key
keyIVs[OddKey][KeyIndex] = new byte[bufferLen];
Buffer.BlockCopy(bytes, index, keyIVs[OddKey][KeyIndex], 0, bufferLen);
index += bufferLen;
// Read odd initialization vector size
bufferLen = EndianOrder.BigEndian.ToInt32(bytes, index);
index += 4;
// Read odd initialization vector
keyIVs[OddKey][IVIndex] = new byte[bufferLen];
Buffer.BlockCopy(bytes, index, keyIVs[OddKey][IVIndex], 0, bufferLen);
index += bufferLen;
// Exchange keys
m_keyIVs = keyIVs;
OnStatusMessage("Successfully established new cipher keys for data packet transmissions.");
break;
}
}
catch (Exception ex)
{
OnProcessException(new InvalidOperationException("Failed to process publisher response packet due to exception: " + ex.Message, ex));
}
}
}
/// <summary>
/// Publish <see cref="IFrame"/> of time-aligned collection of <see cref="IMeasurement"/> values that arrived within the
/// concentrator's defined <see cref="ConcentratorBase.LagTime"/>.
/// </summary>
/// <param name="frame"><see cref="IFrame"/> of measurements with the same timestamp that arrived within <see cref="ConcentratorBase.LagTime"/> that are ready for processing.</param>
/// <param name="index">Index of <see cref="IFrame"/> within a second ranging from zero to <c><see cref="ConcentratorBase.FramesPerSecond"/> - 1</c>.</param>
protected override void PublishFrame(IFrame frame, int index)
{
if ((object)m_parent == null || m_disposed)
return;
// Includes data packet flags, frame level timestamp and measurement count
const int PacketHeaderSize = DataPublisher.ClientResponseHeaderSize + 13;
List<IBinaryMeasurement> packet = new List<IBinaryMeasurement>();
bool usePayloadCompression = m_usePayloadCompression;
bool useCompactMeasurementFormat = m_useCompactMeasurementFormat || usePayloadCompression;
long frameLevelTimestamp = frame.Timestamp;
IBinaryMeasurement binaryMeasurement;
int packetSize = PacketHeaderSize;
int binaryLength;
foreach (IMeasurement measurement in frame.Measurements.Values)
{
// Serialize the current measurement.
if (useCompactMeasurementFormat)
binaryMeasurement = new CompactMeasurement(measurement, m_signalIndexCache, false);
else
binaryMeasurement = new SerializableMeasurement(measurement, m_parent.GetClientEncoding(ClientID));
// Determine the size of the measurement in bytes.
binaryLength = binaryMeasurement.BinaryLength;
// If the current measurement will not fit in the packet based on
// the max packet size, process the packet and start a new one.
if (packetSize + binaryLength > DataPublisher.MaxPacketSize)
{
ProcessBinaryMeasurements(packet, frameLevelTimestamp, useCompactMeasurementFormat, usePayloadCompression);
packet.Clear();
packetSize = PacketHeaderSize;
}
// Add the measurement to the packet.
packet.Add(binaryMeasurement);
packetSize += binaryLength;
}
// Process the remaining measurements.
ProcessBinaryMeasurements(packet, frameLevelTimestamp, useCompactMeasurementFormat, usePayloadCompression);
}
