/// <summary> /// Sets and optionally compresses the data for the <see cref="IDataObject"/>. /// </summary> /// <param name="dataObject">The data object.</param> /// <param name="data">The data.</param> /// <param name="compressionMethod">The compression method to use if any.</param> /// <returns>The data object with the data set.</returns> public static IDataObject SetData(this IDataObject dataObject, byte[] data, string compressionMethod = EtpCompression.None) { var encoding = string.Empty; if (EtpCompression.RequiresCompression(compressionMethod) && data?.Length > 0) { if (!EtpCompression.CanCompress(compressionMethod)) { throw new NotSupportedException($"Compression method not supported: {compressionMethod}"); } using (var compressed = new MemoryStream()) { using (var uncompressed = new MemoryStream(data)) using (var compressionStream = EtpCompression.TryGetCompresionStream(compressionMethod, compressed)) { uncompressed.CopyTo(compressionStream); } data = compressed.ToArray(); encoding = compressionMethod; } } dataObject.ContentEncoding = encoding; dataObject.Data = data ?? new byte[0]; return(dataObject); }
/// <summary> /// Encodes the specified message. /// </summary> /// <typeparam name="T">The type of the message body.</typeparam> /// <param name="message">The message.</param> /// <param name="asBinary">Whether or not to encode as binary.</param> /// <param name="includeExtension">Whether or not to include a message header extension.</param> /// <param name="compression">The compression type.</param> /// <returns>The encoded byte array containing the message data.</returns> public static byte[] Encode <T>(this EtpMessage <T> message, bool asBinary = true, bool includeExtension = false, string compression = EtpCompression.None) where T : IEtpMessageBody { using (var stream = new MemoryStream()) using (var compressionStream = message.Header.CanBeCompressed() ? EtpCompression.TryGetCompresionStream(compression, stream) : null) { // create avro binary encoder to write to memory stream var headerEncoder = asBinary ? (IAvroEncoder) new BinaryAvroEncoder(stream) : new JsonAvroEncoder(stream); var bodyEncoder = headerEncoder; if (compressionStream != null) { // add Compressed flag to message flags before writing header message.Header.SetCompressed(); bodyEncoder = asBinary ? (IAvroEncoder) new BinaryAvroEncoder(compressionStream) : new JsonAvroEncoder(compressionStream); } // serialize header message.Header.Encode(headerEncoder); // serialize header extension if (message.Extension != null && includeExtension) { message.Extension.Encode(bodyEncoder); // Use body encoder to handle compression } message.Body.Encode(bodyEncoder); if (compressionStream != null) { compressionStream.Close(); } return(stream.ToArray()); } }
/// <summary> /// Gets the data contained by the <see cref="IDataObject"/> and decompresses the byte array, if necessary. /// </summary> /// <param name="dataObject">The data object.</param> /// <returns>The decompressed data as a byte array.</returns> public static byte[] GetData(this IDataObject dataObject) { if (!EtpCompression.RequiresDecompression(dataObject.ContentEncoding) || dataObject.Data?.Length == 0) { return(dataObject.Data); } if (!EtpCompression.CanDecompress(dataObject.ContentEncoding)) { throw new NotSupportedException($"Content encoding not supported: {dataObject.ContentEncoding}"); } using (var uncompressed = new MemoryStream()) { using (var compressed = new MemoryStream(dataObject.Data)) using (var decompressionStream = EtpCompression.TryGetDecompresionStream(dataObject.ContentEncoding, compressed)) { decompressionStream.CopyTo(uncompressed); } return(uncompressed.ToArray()); } }