public static async Task <ClientWebSocket> ConnectToDevice(this ServiceClient serviceClient, string deviceId, CancellationToken ct, string streamName = "EdgeStream")
        {
            DeviceStreamRequest deviceStreamRequest = new DeviceStreamRequest(streamName);

            Console.WriteLine($"Connecting to {deviceId}");
            DeviceStreamResponse streamInfo = await serviceClient.CreateStreamAsync(deviceId, deviceStreamRequest, ct).ConfigureAwait(false);

            Console.WriteLine($"Stream response received: Name={deviceStreamRequest.StreamName} IsAccepted={streamInfo.IsAccepted}");

            return(await DeviceStreamWebsocket.MakeWebSocket(streamInfo.Url, streamInfo.AuthorizationToken, ct));
        }
        public async Task RunSampleAsync()
        {
            try
            {
                DeviceStreamRequest deviceStreamRequest = new DeviceStreamRequest(
                    streamName: "TestStream"
                    );

                DeviceStreamResponse result = await _serviceClient.CreateStreamAsync(_deviceId, deviceStreamRequest).ConfigureAwait(false);

                System.Diagnostics.Debug.WriteLine("Stream response received: Name={0} IsAccepted={1}", deviceStreamRequest.StreamName, result.IsAccepted);
                Console.WriteLine("Stream response received: Name={0} IsAccepted={1}", deviceStreamRequest.StreamName, result.IsAccepted);

                if (result.IsAccepted)
                {
                    using (var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromMinutes(1)))
                        using (var stream = await DeviceStreamingCommon.GetStreamingDeviceAsync(result.Url, result.AuthorizationToken, cancellationTokenSource.Token).ConfigureAwait(false))
                        {
                            byte[] sendBuffer    = Encoding.UTF8.GetBytes("Streaming data over a stream...");
                            byte[] receiveBuffer = new byte[1024];

                            await stream.SendAsync(sendBuffer, WebSocketMessageType.Binary, true, cancellationTokenSource.Token).ConfigureAwait(false);

                            System.Diagnostics.Debug.WriteLine(string.Format("Sent stream data: {0}", Encoding.UTF8.GetString(sendBuffer, 0, sendBuffer.Length)));
                            Console.WriteLine("Sent stream data: {0}", Encoding.UTF8.GetString(sendBuffer, 0, sendBuffer.Length));

                            var receiveResult = await stream.ReceiveAsync(receiveBuffer, cancellationTokenSource.Token).ConfigureAwait(false);

                            System.Diagnostics.Debug.WriteLine(string.Format("Received stream data: {0}", Encoding.UTF8.GetString(receiveBuffer, 0, receiveResult.Count)));
                            Console.WriteLine("Received stream data: {0}", Encoding.UTF8.GetString(receiveBuffer, 0, receiveResult.Count));

                            await stream.CloseAsync(WebSocketCloseStatus.NormalClosure, String.Empty, cancellationTokenSource.Token).ConfigureAwait(false);
                        }
                }
                else
                {
                    System.Diagnostics.Debug.WriteLine("Stream request was rejected by the device");
                    Console.WriteLine("Stream request was rejected by the device");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Got an exception: {0}", ex);
                throw;
            }
        }
示例#3
0
        private static async void HandleIncomingConnectionsAndCreateStreams(string deviceId, ServiceClient serviceClient, TcpClient tcpClient)
        {
            DeviceStreamRequest deviceStreamRequest = new DeviceStreamRequest(
                streamName: "ProxyStreamFromSvc"
                );

            using (var localStream = tcpClient.GetStream())
            {
                Update("Awaiting connection");
                using (cancellationTokenSourceOuter = new CancellationTokenSource())
                {
                    DeviceStreamResponse result = await serviceClient.CreateStreamAsync(deviceId, deviceStreamRequest, cancellationTokenSourceOuter.Token).ConfigureAwait(false);

                    Update($"Stream response received: Name={deviceStreamRequest.StreamName} IsAccepted={result.IsAccepted}");

                    if (result.IsAccepted)
                    {
                        try
                        {
                            using (cancellationTokenSource = new CancellationTokenSource())
                                using (ClientWebSocket remoteStream = await DeviceStreamingCommon.GetStreamingClientAsync(result.Url, result.AuthorizationToken, cancellationTokenSource.Token).ConfigureAwait(false))
                                {
                                    Update("Starting streaming");
                                    counter = 0;
                                    await Task.WhenAny(
                                        HandleIncomingDataAsync(localStream, remoteStream, cancellationTokenSource.Token),
                                        HandleOutgoingDataAsync(localStream, remoteStream, cancellationTokenSource.Token)).ConfigureAwait(false);
                                }

                            Update("Done streaming");
                        }
                        catch (Exception ex)
                        {
                            ErrorMsg("Service got an exception: {0}", ex);
                        }
                    }
                }
            }
            tcpClient.Close();
        }
        public async Task RunSampleAsync()
        {
            try
            {
                var deviceStreamRequest = new DeviceStreamRequest("TestStream");

                DeviceStreamResponse result = await _serviceClient.CreateStreamAsync(_deviceId, deviceStreamRequest);

                Console.WriteLine($"Stream response received: Name={deviceStreamRequest.StreamName} IsAccepted={result.IsAccepted}");

                if (result.IsAccepted)
                {
                    using var cts = new CancellationTokenSource(TimeSpan.FromMinutes(1));
                    using ClientWebSocket stream = await DeviceStreamingCommon.GetStreamingClientAsync(result.Uri, result.AuthorizationToken, cts.Token);

                    byte[] sendBuffer    = Encoding.UTF8.GetBytes("Streaming data over a stream...");
                    byte[] receiveBuffer = new byte[1024];

                    await stream.SendAsync(sendBuffer, WebSocketMessageType.Binary, true, cts.Token);

                    Console.WriteLine($"Sent stream data: {Encoding.UTF8.GetString(sendBuffer, 0, sendBuffer.Length)}");

                    var receiveResult = await stream.ReceiveAsync(receiveBuffer, cts.Token);

                    Console.WriteLine($"Received stream data: {Encoding.UTF8.GetString(receiveBuffer, 0, receiveResult.Count)}");

                    await stream.CloseAsync(WebSocketCloseStatus.NormalClosure, "Streaming completed", new CancellationToken());
                }
                else
                {
                    Console.WriteLine("Stream request was rejected by the device");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Got an exception: {ex}");
                throw;
            }
        }
        /// <summary>
        /// Handle incoming connections and create streams
        /// </summary>
        /// <param name="deviceId">device Id</param>
        /// <param name="serviceClient">service Client</param>
        /// <param name="tcpClient">TCP Client</param>
        private static async Task HandleIncomingConnectionsAndCreateStreams(string deviceId, ServiceClient serviceClient, TcpClient tcpClient)
        {
            DeviceStreamRequest deviceStreamRequest = new DeviceStreamRequest(streamName: "TestStream");

            using (var localStream = tcpClient.GetStream())
            {
                DeviceStreamResponse result = await serviceClient.CreateStreamAsync(deviceId, deviceStreamRequest, CancellationToken.None).ConfigureAwait(false);

                if (result.IsAccepted)
                {
                    using (var cancellationTokenSource = new CancellationTokenSource())
                        using (var remoteStream = await DeviceStreamingHelper.GetStreamingClientAsync(result.Url, result.AuthorizationToken, cancellationTokenSource.Token).ConfigureAwait(false))
                        {
                            await Task.WhenAny(
                                HandleIncomingDataAsync(localStream, remoteStream, cancellationTokenSource.Token),
                                HandleOutgoingDataAsync(localStream, remoteStream, cancellationTokenSource.Token)).ConfigureAwait(false);
                        }
                }
            }

            tcpClient.Close();
        }
        private static async void HandleIncomingConnectionsAndCreateStreams(string deviceId, ServiceClient serviceClient, TcpClient tcpClient)
        {
            DeviceStreamRequest deviceStreamRequest = new DeviceStreamRequest(
                streamName: "TestStream"
                );

            using (var localStream = tcpClient.GetStream())
            {
                DeviceStreamResponse result = await serviceClient.CreateStreamAsync(deviceId, deviceStreamRequest, CancellationToken.None).ConfigureAwait(false);

                Console.WriteLine($"Stream response received: Name={deviceStreamRequest.StreamName} IsAccepted={result.IsAccepted}");

                if (result.IsAccepted)
                {
                    try
                    {
                        using (var cancellationTokenSource = new CancellationTokenSource(new TimeSpan(0, 1, 0)))
                            using (var remoteStream = await DeviceStreamingCommon.GetStreamingClientAsync(result.Url, result.AuthorizationToken, cancellationTokenSource.Token).ConfigureAwait(false))
                            {
                                Console.WriteLine("Starting streaming");

                                await Task.WhenAny(
                                    HandleIncomingDataAsync(localStream, remoteStream, cancellationTokenSource.Token),
                                    HandleOutgoingDataAsync(localStream, remoteStream, cancellationTokenSource.Token)).ConfigureAwait(false);
                            }

                        Console.WriteLine("Done streaming");
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine("Got an exception: {0}", ex);
                    }
                }
            }
            tcpClient.Close();
        }
        private async Task RunSvcAsync()
        {
            string errorMsg  = "";
            string updateMsg = "";

            using (cancellationTokenSourceManual = new CancellationTokenSource())
            {
                ClientWebSocket stream = null;
                try
                {
                    DeviceStreamRequest deviceStreamRequest = new DeviceStreamRequest(
                        streamName: "TestStream"
                        );
                    updateMsg = "Starting Svc TestStream";
                    UpdateStatus(updateMsg);

                    cancellationTokenSourceManual.Token.Register(() =>
                    {
                        _serviceClient?.CloseAsync();
                        _serviceClient?.Dispose();
                    });

                    DeviceStreamResponse result = await _serviceClient.CreateStreamAsync(_deviceId, deviceStreamRequest).ConfigureAwait(false);

                    updateMsg = string.Format("Svc Stream response received: Name={0} IsAccepted={1}", deviceStreamRequest.StreamName, result.IsAccepted);
                    UpdateStatus(updateMsg);

                    if (result.IsAccepted)
                    {
                        using (cancellationTokenSourceTimeout = new CancellationTokenSource(DeviceStreamingCommon.DeviceTimeout))
                        {
                            try
                            {
                                using (stream = await DeviceStreamingCommon.GetStreamingDeviceAsync(result.Url, result.AuthorizationToken, cancellationTokenSourceTimeout.Token).ConfigureAwait(false))
                                {
                                    updateMsg = "Stream is open.";
                                    UpdateStatus(updateMsg);
                                    bool keepAlive = false;
                                    MsgOutWaitHandle = new AutoResetEvent(true);
                                    do
                                    {
                                        //Nb: Not waited on first entry as waiting for msgOut, which we already have.
                                        updateMsg = "Stream is open. Waiting for msg to send.";
                                        UpdateStatus(updateMsg);

                                        MsgOutWaitHandle.WaitOne();
                                        updateMsg = "Sending msg.";
                                        UpdateStatus(updateMsg);
                                        bool caught = false;
                                        try
                                        {
                                            MsgOut = SvcCurrentSettings.ProcessMsgOut(MsgOut, SvcCurrentSettings.KeepAlive, SvcCurrentSettings.ResponseExpected, DevKeepListening, DevAutoStart);
                                        } catch (NotImplementedException)
                                        {
                                            errorMsg += "DeviceCurrentSettings not properly implemented";
                                            keepAlive = false;
                                            caught    = true;
                                        }
                                        if (!caught)
                                        {
                                            await SendMsg(stream, MsgOut, cancellationTokenSourceTimeout);

                                            updateMsg = "Sent msg.";
                                            UpdateStatus(updateMsg);

                                            if (this.SvcCurrentSettings.ResponseExpected)
                                            {
                                                byte[] receiveBuffer = new byte[1024];
                                                System.ArraySegment <byte> ReceiveBuffer = new ArraySegment <byte>(receiveBuffer);

                                                var receiveResult = await stream.ReceiveAsync(ReceiveBuffer, cancellationTokenSourceTimeout.Token).ConfigureAwait(false);

                                                MsgIn = Encoding.UTF8.GetString(receiveBuffer, 0, receiveResult.Count);
                                                string subStrn    = AzIoTHubDeviceStreams.DeviceStreamingCommon.DeiceInSimuatedDeviceModeStrn;
                                                int    subStrnLen = subStrn.Length;
                                                if (MsgIn.Length >= subStrnLen)
                                                {
                                                    if (MsgIn.Substring(0, subStrnLen) == subStrn)
                                                    {
                                                        MsgIn = MsgIn.Substring(subStrnLen);
                                                        AzIoTHubModules.SyntheticIoTMessage    iotHubMessage = AzIoTHubModules.SyntheticIoTMessage.Deserialize(MsgIn);
                                                        Microsoft.Azure.Devices.Client.Message message       = iotHubMessage.ToMessage();
                                                        Microsoft.Azure.EventHubs.EventData    eventData     = AzIoTHubModules.SyntheticIoTMessage.ToEventData(message);
                                                        MsgIn = AzIoTHubModules.SyntheticIoTMessage.EventData_ToString(eventData);
                                                    }
                                                }
                                                keepAlive = false;
                                                if (SvcCurrentSettings != null)
                                                {
                                                    keepAlive = this.SvcCurrentSettings.KeepAlive;
                                                }
                                                try
                                                {
                                                    if (OnRecvdTextD != null)
                                                    {
                                                        OnRecvdTextD(MsgIn);
                                                    }
                                                }
                                                catch (Exception exx)
                                                {
                                                    errorMsg += "OnRecvdTextD not properly implemented: " + exx.Message;
                                                    keepAlive = false;
                                                }

                                                updateMsg = string.Format("Svc Received stream data: {0}", MsgIn);
                                                UpdateStatus(updateMsg);
                                            }
                                            MsgOutWaitHandle.Reset();
                                        }
                                    } while (keepAlive);
                                    MsgOutWaitHandle = null;
                                    updateMsg        = "Closing Svc Socket";
                                    UpdateStatus(updateMsg);
                                    await stream.CloseAsync(WebSocketCloseStatus.NormalClosure, String.Empty, cancellationTokenSourceTimeout.Token).ConfigureAwait(false);

                                    stream = null;
                                }
                            }
                            catch (Microsoft.Azure.Devices.Client.Exceptions.IotHubCommunicationException)
                            {
                                System.Diagnostics.Debug.WriteLine("1 Error RunSvcAsync(): Hub connection failure");
                                errorMsg = "Hub connection failure";
                            }
                            catch (Microsoft.Azure.Devices.Common.Exceptions.DeviceNotFoundException)
                            {
                                System.Diagnostics.Debug.WriteLine("1 Error RunSvcAsync(): Device not found");
                                errorMsg = "Device not found";
                            }
                            catch (TaskCanceledException)
                            {
                                System.Diagnostics.Debug.WriteLine("1 Error RunSvcAsync(): Task cancelled");
                                errorMsg = "Task cancelled";
                            }
                            catch (OperationCanceledException)
                            {
                                System.Diagnostics.Debug.WriteLine("1 Error RunSvcAsync(): Operation cancelled");
                                errorMsg = "Operation cancelled";
                            }
                            catch (Exception ex)
                            {
                                if ((bool)cancellationTokenSourceManual?.IsCancellationRequested)
                                {
                                    System.Diagnostics.Debug.WriteLine("1 Error RunSvcAsync(): Cancelled.");
                                    errorMsg = "Cancelled";
                                }
                                else if ((bool)cancellationTokenSourceTimeout?.IsCancellationRequested)
                                {
                                    System.Diagnostics.Debug.WriteLine("1 Error RunSvcAsync(): Timed Out.");
                                    errorMsg = "Timed Out";
                                }
                                else if (!ex.Message.Contains("Timed out"))
                                {
                                    System.Diagnostics.Debug.WriteLine("1 Error RunSvcAsync(): " + ex.Message);
                                    errorMsg = ex.Message;
                                }
                                else
                                {
                                    System.Diagnostics.Debug.WriteLine("2 Error RunSvcAsync(): Timed out");
                                    errorMsg = "Timed Out";
                                }
                            }
                        }
                    }
                }
                catch (Microsoft.Azure.Devices.Client.Exceptions.IotHubCommunicationException)
                {
                    System.Diagnostics.Debug.WriteLine("2 Error RunSvcAsync(): Hub connection failure");
                    errorMsg += " Hub connection failure";
                }
                catch (Microsoft.Azure.Devices.Common.Exceptions.DeviceNotFoundException)
                {
                    System.Diagnostics.Debug.WriteLine("2 Error RunSvcAsync(): Device not found");
                    errorMsg += " Device not found";
                }
                catch (TaskCanceledException)
                {
                    System.Diagnostics.Debug.WriteLine("2 Error RunSvcAsync(): Task cancelled");
                    errorMsg += " Task cancelled";
                }
                catch (OperationCanceledException)
                {
                    System.Diagnostics.Debug.WriteLine("2 Error RunSvcAsync(): Operation cancelled");
                    errorMsg += " Operation cancelled";
                }
                catch (Exception ex)
                { if ((bool)cancellationTokenSourceManual?.IsCancellationRequested)
                  {
                      System.Diagnostics.Debug.WriteLine("2 Error RunSvcAsync(): Cancelled.");
                      errorMsg += " Cancelled";
                  }
                  else if ((bool)cancellationTokenSourceTimeout?.IsCancellationRequested)
                  {
                      System.Diagnostics.Debug.WriteLine("2 Error RunSvcAsync(): Timed Out.");
                      errorMsg += " Timed Out";
                  }
                  else if (!ex.Message.Contains("Timed out"))
                  {
                      System.Diagnostics.Debug.WriteLine("2 Error RunSvcAsync(): " + ex.Message);
                      errorMsg += " " + ex.Message;
                  }
                  else
                  {
                      System.Diagnostics.Debug.WriteLine("2 Error RunSvcAsync(): Timed out");
                      errorMsg += " Timed Out";
                  } };

                if (stream != null)
                {
                    if (stream.CloseStatus != WebSocketCloseStatus.NormalClosure)
                    {
                        updateMsg = "Aborting Svc Socket as is errant or cancelled: " + errorMsg;
                        UpdateStatus(updateMsg);
                        stream.Abort();
                        updateMsg = "Aborted Svc Socket as was errant or cancelled:" + errorMsg;
                        UpdateStatus(updateMsg);
                    }
                    else
                    {
                        updateMsg = "Socket closed normally: " + errorMsg;
                        UpdateStatus(updateMsg);
                    }
                    stream = null;
                }
                else
                {
                    updateMsg = "Socket closed Normally: " + errorMsg;
                    UpdateStatus(updateMsg);
                }

                deviceStream_Svc = null;
                MsgOutWaitHandle = null;
                cancellationTokenSourceTimeout = null;
            }
        }