public ArraySegment <byte> SerializeCompressEncrypt <TIn>(TIn input)
{
return(_encryptionProvider
.Encrypt(_compressionProvider
.Compress(_serializationProvider
.Serialize(input))));
}
public void Compress()
{
var compressedData = _provider.Compress(_data).ToArray();
Assert.NotNull(compressedData);
Assert.NotEqual(compressedData.Length, _data.Length);
Assert.True(compressedData.Length < _data.Length);
}
public void Deflate_Compress()
{
var compressed = _deflateProvider.Compress(_compressableData);
Assert.NotNull(compressed);
Assert.NotEqual(compressed.Length, _compressableData.Length);
Assert.True(compressed.Length < _compressableData.Length);
}
public void Gzip_Compress()
{
var compressed = _gzipProvider.Compress(_compressableData);
Assert.NotNull(compressed);
Assert.NotEqual(compressed.Length, _compressableData.Length);
Assert.True(compressed.Length < _compressableData.Length);
}
public void LZ4Pickle_Compress()
{
var compressed = _lz4PickleProvider.Compress(_compressableData);
Assert.NotNull(compressed);
Assert.NotEqual(compressed.Length, _compressableData.Length);
Assert.True(compressed.Length < _compressableData.Length);
}
public bool Create(Guid id, string filename, byte[] data)
{
ICompressionProvider compressionProvider = Factory.GetCompressionProvider(configurationProvider.CompressionProviderType, configurationProvider);
IEncryptionProvider encryptionProvider = Factory.GetEncryptionProvider(configurationProvider.EncryptionProviderType, configurationProvider);
int originalSize = data.Length;
Dictionary <string, string> metaData = new Dictionary <string, string>();
byte[] compressedData = compressionProvider.Compress(data);
if ((double)compressedData.Length / data.Length <= CompressionThreshold)
{
metaData.Add(CompressionKey, configurationProvider.CompressionProviderType.ToString());
data = compressedData;
}
data = encryptionProvider.Encrypt(data);
if (!(encryptionProvider is PassThroughEncryptionProvider))
{
metaData.Add(EncryptionKey, configurationProvider.EncryptionProviderType.ToString());
}
if (originalSize != data.Length)
{
metaData.Add(OriginalFileSizeKey, originalSize.ToString());
}
return(storageProvider.Create(id, filename, data, metaData));
}
public void RecyclableGzipProvider_10KBytes(int x)
{
for (var i = 0; i < x; i++)
{
var compressedData = RecyclableProvider.Compress(Payload1);
var decompressedData = RecyclableProvider.Decompress(compressedData);
}
}
public void GzipProvider_5KBytes(int x)
{
for (var i = 0; i < x; i++)
{
var compressedData = CompressionProvider.Compress(Payload1);
var decompressedData = CompressionProvider.Decompress(compressedData);
}
}
public static async Task GzipCompressAsync()
{
var compressedData = _gzipProvider.Compress(_serializedData);
var length = GetLength(compressedData);
if (_serializedData.Count == length)
{
await Console.Out.WriteLineAsync("LastFourLength is good.");
}
}
public void Setup()
{
Enumerable.Repeat <byte>(0xFF, 1000).ToArray().CopyTo(Payload1, 0);
Enumerable.Repeat <byte>(0xAA, 1000).ToArray().CopyTo(Payload1, 1000);
Enumerable.Repeat <byte>(0x1A, 1000).ToArray().CopyTo(Payload1, 2000);
Enumerable.Repeat <byte>(0xAF, 1000).ToArray().CopyTo(Payload1, 3000);
Enumerable.Repeat <byte>(0x01, 1000).ToArray().CopyTo(Payload1, 4000);
CompressionProvider = new RecyclableDeflateProvider();
CompressedPayload1 = CompressionProvider.Compress(Payload1).ToArray();
}
public static async Task DeflateCompressAsync()
{
var compressedData = _deflateProvider.Compress(_serializedData.ToArray());
var span = compressedData.Slice(compressedData.Count - 8, 8);
var length = BitConverter.ToInt32(span);
if (compressedData.Count == length)
{
await Console.Out.WriteLineAsync("Length is good.");
}
}
public LZ4PickleTests(ITestOutputHelper output)
{
_output = output;
Enumerable.Repeat <byte>(0xFF, 1000).ToArray().CopyTo(_data, 0);
Enumerable.Repeat <byte>(0xAA, 1000).ToArray().CopyTo(_data, 1000);
Enumerable.Repeat <byte>(0x1A, 1000).ToArray().CopyTo(_data, 2000);
Enumerable.Repeat <byte>(0xAF, 1000).ToArray().CopyTo(_data, 3000);
Enumerable.Repeat <byte>(0x01, 1000).ToArray().CopyTo(_data, 4000);
_provider = new LZ4PickleProvider();
_compressedData = _provider.Compress(_data).ToArray();
}
public void Setup()
{
Enumerable.Repeat <byte>(0xFF, 1000).ToArray().CopyTo(Payload1, 0);
Enumerable.Repeat <byte>(0xAA, 1000).ToArray().CopyTo(Payload1, 1000);
Enumerable.Repeat <byte>(0x1A, 1000).ToArray().CopyTo(Payload1, 2000);
Enumerable.Repeat <byte>(0xAF, 1000).ToArray().CopyTo(Payload1, 3000);
Enumerable.Repeat <byte>(0x01, 1000).ToArray().CopyTo(Payload1, 4000);
RecyclableManager.ConfigureNewStaticManagerWithDefaults();
RecyclableProvider = new RecyclableGzipProvider();
CompressedPayload1 = RecyclableProvider.Compress(Payload1).ToArray();
}
private async Task ProcessMessagesAsync(ChannelReader <IMessage> channelReader)
{
await Task.Yield();
while (await channelReader.WaitToReadAsync().ConfigureAwait(false))
{
while (channelReader.TryRead(out var message))
{
if (message == null)
{
continue;
}
var metadata = message.GetMetadata();
if (_compress)
{
message.Body = _compressionProvider.Compress(message.Body).ToArray();
metadata.Compressed = _compress;
metadata.CustomFields[Constants.HeaderForCompressed] = _compress;
metadata.CustomFields[Constants.HeaderForCompression] = _compressionProvider.Type;
}
if (_encrypt)
{
message.Body = _encryptionProvider.Encrypt(message.Body).ToArray();
metadata.Encrypted = _encrypt;
metadata.CustomFields[Constants.HeaderForEncrypted] = _encrypt;
metadata.CustomFields[Constants.HeaderForEncryption] = _encryptionProvider.Type;
metadata.CustomFields[Constants.HeaderForEncryptDate] = Time.GetDateTimeNow(Time.Formats.CatRFC3339);
}
_logger.LogDebug(LogMessages.AutoPublishers.MessagePublished, message.MessageId, metadata?.Id);
await PublishAsync(message, _createPublishReceipts, _withHeaders)
.ConfigureAwait(false);
}
}
}
private async Task ProcessLettersAsync(ChannelReader <Letter> channelReader)
{
await Task.Yield();
while (await channelReader.WaitToReadAsync().ConfigureAwait(false))
{
while (channelReader.TryRead(out var letter))
{
if (letter == null)
{
continue;
}
if (_compress)
{
letter.Body = _compressionProvider.Compress(letter.Body);
letter.LetterMetadata.Compressed = _compress;
letter.LetterMetadata.CustomFields[Constants.HeaderForCompressed] = _compress;
letter.LetterMetadata.CustomFields[Constants.HeaderForCompression] = _compressionProvider.Type;
}
if (_encrypt)
{
letter.Body = _encryptionProvider.Encrypt(letter.Body);
letter.LetterMetadata.Encrypted = _encrypt;
letter.LetterMetadata.CustomFields[Constants.HeaderForEncrypted] = _encrypt;
letter.LetterMetadata.CustomFields[Constants.HeaderForEncryption] = _encryptionProvider.Type;
letter.LetterMetadata.CustomFields[Constants.HeaderForEncryptDate] = Time.GetDateTimeNow(Time.Formats.CatRFC3339);
}
_logger.LogDebug(LogMessages.AutoPublishers.LetterPublished, letter.LetterId, letter.LetterMetadata?.Id);
await PublishAsync(letter, _createPublishReceipts, _withHeaders)
.ConfigureAwait(false);
}
}
}
public void Compress5KBytes()
{
CompressionProvider.Compress(Payload1);
}
