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);