public async Task CanCreateBinaryDataFromFileStream()
{
byte[] buffer = Encoding.UTF8.GetBytes("some data");
using FileStream stream = new FileStream(Path.GetTempFileName(), FileMode.Open);
stream.Write(buffer, 0, buffer.Length);
stream.Position = 0;
BinaryData data = BinaryData.FromStream(stream);
Assert.Equal(buffer, data.ToArray());
byte[] output = new byte[buffer.Length];
var outputStream = data.ToStream();
outputStream.Read(output, 0, (int)outputStream.Length);
Assert.Equal(buffer, output);
stream.Position = 0;
data = await BinaryData.FromStreamAsync(stream);
Assert.Equal(buffer, data.ToArray());
outputStream = data.ToStream();
outputStream.Read(output, 0, (int)outputStream.Length);
Assert.Equal(buffer, output);
}
private async Task <ResourceAccessRuleSet> DownloadBlobAsync(string id, string eTag)
{
BlockBlobClient blob = this.Container.GetBlockBlobClient(id);
// Can't use DownloadContentAsync because of https://github.com/Azure/azure-sdk-for-net/issues/22598
try
{
Response <BlobDownloadStreamingResult> response = await blob.DownloadStreamingAsync(
conditions : string.IsNullOrEmpty(eTag)?null : new BlobRequestConditions {
IfNoneMatch = new ETag(eTag !)
})
.ConfigureAwait(false);
int status = response.GetRawResponse().Status;
if (status == 304)
{
// NOP - we are quite happy to ignore that, as the blob hasn't changed.
return(null);
}
// Note: it is technically possible to use System.Text.Json to work directly from
// the UTF-8 data, which is more efficient than decoding to a .NET UTF-16 string
// first. However, we have to do this for the time being because we are in the world of
// IJsonSerializerSettingsProvider, where all serialization options are managed in
// terms of JSON.NET.
using BlobDownloadStreamingResult blobDownloadStreamingResult = response.Value;
BinaryData data = await BinaryData.FromStreamAsync(blobDownloadStreamingResult.Content).ConfigureAwait(false);
string ruleSetJson = data.ToString();
ResourceAccessRuleSet ruleSet = JsonConvert.DeserializeObject <ResourceAccessRuleSet>(ruleSetJson, this.serializerSettings);
ruleSet.ETag = response.Value.Details.ETag.ToString("G");
return(ruleSet);
}
private async Task <BinaryData> ClientSideDecryptInternal(BinaryData downloadedMessage, bool async, CancellationToken cancellationToken)
{
if (!EncryptedMessageSerializer.TryDeserialize(downloadedMessage, out var encryptedMessage))
{
return(downloadedMessage); // not recognized as client-side encrypted message
}
var encryptedMessageStream = new MemoryStream(Convert.FromBase64String(encryptedMessage.EncryptedMessageText));
var decryptedMessageStream = await _decryptor.DecryptReadInternal(
encryptedMessageStream,
encryptedMessage.EncryptionData,
ivInStream : false,
noPadding : false,
async : async,
cancellationToken).ConfigureAwait(false);
// if we got back the stream we put in, then we couldn't decrypt and are supposed to return the original
// message to the user
if (encryptedMessageStream == decryptedMessageStream)
{
return(downloadedMessage);
}
return(async ?
await BinaryData.FromStreamAsync(decryptedMessageStream, cancellationToken).ConfigureAwait(false) :
BinaryData.FromStream(decryptedMessageStream));
}
public async Task CanCreateBinaryDataFromStreamUsingBackingBuffer()
{
byte[] buffer = Encoding.UTF8.GetBytes("some data");
using MemoryStream stream = new MemoryStream();
stream.Write(buffer, 0, buffer.Length);
stream.Position = 0;
BinaryData data = BinaryData.FromStream(stream);
Assert.Equal(buffer, data.ToMemory().ToArray());
byte[] output = new byte[buffer.Length];
var outputStream = data.ToStream();
outputStream.Read(output, 0, (int)outputStream.Length);
Assert.Equal(buffer, output);
stream.Position = 0;
data = await BinaryData.FromStreamAsync(stream);
Assert.Equal(buffer, data.ToMemory().ToArray());
outputStream = data.ToStream();
outputStream.Read(output, 0, (int)outputStream.Length);
Assert.Equal(buffer, output);
}
public async Task CanCreateBinaryDataFromStream()
{
byte[] buffer = Encoding.UTF8.GetBytes("some data");
using MemoryStream stream = new MemoryStream(buffer, 0, buffer.Length, true, true);
BinaryData data = BinaryData.FromStream(stream);
Assert.Equal(buffer, data.ToArray());
byte[] output = new byte[buffer.Length];
var outputStream = data.ToStream();
outputStream.Read(output, 0, (int)outputStream.Length);
Assert.Equal(buffer, output);
stream.Position = 0;
data = await BinaryData.FromStreamAsync(stream);
Assert.Equal(buffer, data.ToArray());
outputStream = data.ToStream();
outputStream.Read(output, 0, (int)outputStream.Length);
Assert.Equal(buffer, output);
//changing the backing buffer should not affect the BD instance
buffer[3] = (byte)'z';
Assert.NotEqual(buffer, data.ToMemory().ToArray());
}
public async Task CreateThrowsOnNullStream()
{
var ex = Assert.Throws <ArgumentNullException>(() => BinaryData.FromStream(null));
Assert.Contains("stream", ex.Message);
ex = await Assert.ThrowsAsync <ArgumentNullException>(() => BinaryData.FromStreamAsync(null));
Assert.Contains("stream", ex.Message);
}
public void CreateThrowsOnNullStream()
{
Assert.That(
() => BinaryData.FromStream(null),
Throws.InstanceOf <ArgumentNullException>());
Assert.That(
async() => await BinaryData.FromStreamAsync(null),
Throws.InstanceOf <ArgumentNullException>());
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
ILogger log)
{
log.LogInformation("IoT Hub Device connection status.");
BinaryData events = await BinaryData.FromStreamAsync(req.Body);
EventGridEvent[] eventGridEvents = EventGridEvent.ParseMany(events);
foreach (EventGridEvent eventGridEvent in eventGridEvents)
{
// Handle system events
if (eventGridEvent.TryGetSystemEventData(out object eventData))
{
// Handle the subscription validation event
if (eventData is SubscriptionValidationEventData subscriptionValidationEventData)
{
log.LogInformation($"Got SubscriptionValidation event data, validation code: {subscriptionValidationEventData.ValidationCode}, topic: {eventGridEvent.Topic}");
// Do any additional validation (as required) and then return back the below response
var responseData = new SubscriptionValidationResponse()
{
ValidationResponse = subscriptionValidationEventData.ValidationCode
};
return(new OkObjectResult(responseData));
}
}
var data = eventGridEvent.Data.ToString();
// "data": {
// "deviceConnectionStateEventInfo": {
// "sequenceNumber": "000000000000000001D4132452F67CE200000002000000000000000000000001"
// },
// "hubName": "townbroadcast-hub",
// "deviceId": "LogicAppTestDevice"
// }
log.LogInformation($"eventGridEvent.Data: {eventGridEvent.Data.ToString()}");
var eventdata = JsonConvert.DeserializeObject <EventGridData>(data);
log.LogInformation($"{eventdata.deviceId} is {(eventGridEvent.EventType == "Microsoft.Devices.DeviceConnected" ? "Connected" : "Disconnected")}");
switch (eventGridEvent.EventType)
{
case "Microsoft.Devices.DeviceDisconnected":
break;
case "Microsoft.Devices.DeviceConnected":
break;
}
}
return(new OkObjectResult(""));
}
private async Task UploadEntityAsync <TEntity>(TEntity entity, CancellationToken cancellationToken = new CancellationToken()) where TEntity : class
{
var blob = await GetBlobClientAsync(entity).ConfigureAwait(false);
await TryGeneratePrimaryKeyAsync(entity).ConfigureAwait(false);
using (var stream = Serialize <TEntity>(entity))
{
var binaryData = await BinaryData.FromStreamAsync(stream, cancellationToken).ConfigureAwait(false);
await blob.UploadAsync(binaryData, overwrite : true, cancellationToken).ConfigureAwait(false);
}
}
public async Task CanCreateBinaryDataFromStream()
{
var buffer = Encoding.UTF8.GetBytes("some data");
var payload = new MemoryStream(buffer);
var data = BinaryData.FromStream(payload);
Assert.AreEqual(buffer, data.Bytes.ToArray());
Assert.AreEqual(payload, data.ToStream());
payload.Position = 0;
data = await BinaryData.FromStreamAsync(payload);
Assert.AreEqual(buffer, data.Bytes.ToArray());
Assert.AreEqual(payload, data.ToStream());
}
public async Task StartPositionOfStreamRespected(int bufferOffset, long streamStart)
{
var input = "some data";
ArraySegment <byte> buffer = new ArraySegment <byte>(Encoding.UTF8.GetBytes("some data"), bufferOffset, input.Length - bufferOffset);
MemoryStream stream = new MemoryStream(buffer.Array, buffer.Offset, buffer.Count);
var payload = new ReadOnlyMemory <byte>(buffer.Array, buffer.Offset, buffer.Count).Slice((int)streamStart);
stream.Position = streamStart;
BinaryData data = BinaryData.FromStream(stream);
Assert.Equal(payload.ToArray(), data.ToMemory().ToArray());
Assert.Equal(buffer.Count - streamStart, data.ToStream().Length);
stream.Position = streamStart;
data = await BinaryData.FromStreamAsync(stream);
Assert.Equal(payload.ToArray(), data.ToMemory().ToArray());
Assert.Equal(buffer.Count - streamStart, data.ToStream().Length);
}
/// <summary>
/// Validates Azure event subscription and calls the appropriate event handler. Responds HttpOk.
/// </summary>
/// <param name="request">HttpRequest received from Azure</param>
/// <param name="eventTypeHandlers">Dictionary of eventType strings and their associated handlers.</param>
/// <returns>OkObjectResult</returns>
/// <remarks>Reference https://docs.microsoft.com/en-us/azure/event-grid/receive-events</remarks>
public async static Task <ObjectResult> HandleAzureEvents(HttpRequest request,
Dictionary <string, Func <EventGridEvent, Task> > eventTypeHandlers)
{
var queryKey = request.Query["key"];
if (!CoreHelpers.FixedTimeEquals(queryKey, EventGridKey))
{
return(new UnauthorizedObjectResult("Authentication failed. Please use a valid key."));
}
var response = string.Empty;
var requestData = await BinaryData.FromStreamAsync(request.Body);
var eventGridEvents = EventGridEvent.ParseMany(requestData);
foreach (var eventGridEvent in eventGridEvents)
{
if (eventGridEvent.TryGetSystemEventData(out object systemEvent))
{
if (systemEvent is SubscriptionValidationEventData eventData)
{
// Might want to enable additional validation: subject, topic etc.
var responseData = new SubscriptionValidationResponse()
{
ValidationResponse = eventData.ValidationCode
};
return(new OkObjectResult(responseData));
}
}
if (eventTypeHandlers.ContainsKey(eventGridEvent.EventType))
{
await eventTypeHandlers[eventGridEvent.EventType](eventGridEvent);
}
}
return(new OkObjectResult(response));
}
public async Task CanCreateBinaryDataFromEmptyStream()
{
//completely empty stream
using MemoryStream stream = new MemoryStream();
BinaryData data = BinaryData.FromStream(stream);
Assert.Empty(data.ToArray());
data = await BinaryData.FromStreamAsync(stream);
Assert.Empty(data.ToArray());
// stream at end
byte[] buffer = Encoding.UTF8.GetBytes("some data");
stream.Write(buffer, 0, buffer.Length);
data = BinaryData.FromStream(stream);
Assert.Empty(data.ToArray());
data = await BinaryData.FromStreamAsync(stream);
Assert.Empty(data.ToArray());
}
public async Task CanCreateBinaryDataFromLongStream()
{
byte[] buffer = Encoding.UTF8.GetBytes("some data");
using MemoryStream stream = new OverFlowStream(offset: int.MaxValue - 10000, buffer);
BinaryData data = BinaryData.FromStream(stream);
Assert.Equal(buffer, data.ToArray());
byte[] output = new byte[buffer.Length];
var outputStream = data.ToStream();
outputStream.Read(output, 0, (int)outputStream.Length);
Assert.Equal(buffer, output);
stream.Position = 0;
data = await BinaryData.FromStreamAsync(stream);
Assert.Equal(buffer, data.ToArray());
outputStream = data.ToStream();
outputStream.Read(output, 0, (int)outputStream.Length);
Assert.Equal(buffer, output);
}
public async Task CanCreateBinaryDataFromNonSeekableStream()
{
byte[] buffer = "some data" u8.ToArray();
using MemoryStream stream = new NonSeekableStream(buffer);
BinaryData data = BinaryData.FromStream(stream);
Assert.Equal(buffer, data.ToArray());
byte[] output = new byte[buffer.Length];
var outputStream = data.ToStream();
outputStream.Read(output, 0, (int)outputStream.Length);
Assert.Equal(buffer, output);
stream.Position = 0;
data = await BinaryData.FromStreamAsync(stream);
Assert.Equal(buffer, data.ToArray());
outputStream = data.ToStream();
outputStream.Read(output, 0, (int)outputStream.Length);
Assert.Equal(buffer, output);
}
protected override async Task <BinaryData> DownloadAsync(DataLakeFileClient client) => await BinaryData.FromStreamAsync((await client.ReadAsync()).Value.Content);
