public async Task <IActionResult> Start() { var payload = JsonConvert.SerializeObject(settings); await ioTHubModuleClient.InvokeMethodAsync(deviceId, moduleUpstreamFromStorages, new MethodRequest("StartUpstream", Encoding.UTF8.GetBytes(payload))); return(RedirectToAction("BlobTemperature")); }
public async Task <string[]> ListFiles(string path) { ListFilesModel model = new ListFilesModel(path); byte[] message = GetMessage(model); string jstring = JsonConvert.SerializeObject(model); MethodRequest request = new MethodRequest("listFiles", Encoding.UTF8.GetBytes(jstring)); MethodResponse response = await client.InvokeMethodAsync(deviceId, moduleId, request); if (response.Status != 200) { Console.WriteLine("DirectMethods Client listFiles failed"); throw new Exception("DirectMethods client failed on listFiles"); } else { string jsonResult = response.ResultAsJson; if (string.IsNullOrEmpty(jsonResult)) { return(null); } else { return(JsonConvert.DeserializeObject <string[]>(jsonResult)); } } }
private static async Task GetTimeMethod(ModuleClient moduleClient, CancellationTokenSource cts) { var cancellationToken = cts.Token; while (!cancellationToken.IsCancellationRequested) { try { var begin = DateTime.UtcNow; var response = await moduleClient.InvokeMethodAsync(DeviceId, "producer", new MethodRequest("GetTimeMethod"), cancellationToken); var end = DateTime.UtcNow; var payload = JObject.Parse(response.ResultAsJson); var produced = payload.Value <DateTime>("UtcTime"); LogTiming(begin, produced, end); } catch (IotHubCommunicationException cex) { LogException(cex); //This is fatal since we never recover once we see this message. //Just cancel and hopefully we restart if (cex.Message.Equals("Address already in use")) { cts.Cancel(); } } catch (Exception ex) { LogException(ex); } } }
/// <summary> /// Module behavior: /// Call HelloWorld Direct Method every 5 seconds. /// </summary> /// <param name="moduleClient"></param> /// <param name="dmDelay"></param> /// <param name="targetModuleId"></param> /// <param name="cts"></param> /// <param name="targetDeviceId"></param> /// <returns></returns> static async Task CallDirectMethod( ModuleClient moduleClient, TimeSpan dmDelay, string targetDeviceId, string targetModuleId, CancellationTokenSource cts) { while (!cts.Token.IsCancellationRequested) { Console.WriteLine($"\t{DateTime.Now.ToLocalTime()}> Calling Direct Method on module."); // Create the request var request = new MethodRequest("HelloWorldMethod", Encoding.UTF8.GetBytes("{ \"Message\": \"Hello\" }")); try { //Ignore Exception. Keep trying. MethodResponse response = await moduleClient.InvokeMethodAsync(targetDeviceId, targetModuleId, request); if (response.Status == (int)HttpStatusCode.OK) { await moduleClient.SendEventAsync("AnyOutput", new Message(Encoding.UTF8.GetBytes("Method Call succeeded."))); } } catch (Exception e) { Console.WriteLine(e); } await Task.Delay(dmDelay, cts.Token).ConfigureAwait(false); } }
static async Task CallDirectMethod( ModuleClient moduleClient, TimeSpan delay, string deviceId, string moduleId, CancellationTokenSource cts) { var request = new MethodRequest("HelloWorldMethod", Encoding.UTF8.GetBytes("{ \"Message\": \"Hello\" }")); while (!cts.Token.IsCancellationRequested) { Logger.LogInformation($"Calling Direct Method on device [{deviceId}] module [{moduleId}]."); try { MethodResponse response = await moduleClient.InvokeMethodAsync(deviceId, moduleId, request); if (response.Status == (int)HttpStatusCode.OK) { await moduleClient.SendEventAsync("AnyOutput", new Message(Encoding.UTF8.GetBytes("Direct Method Call succeeded."))); } } catch (Exception e) { Logger.LogError($"Exception caught: {e}"); } await Task.Delay(delay, cts.Token); } }
static async Task CallDirectMethodAsync() { try { var varEnvs = System.Environment.GetEnvironmentVariables(); foreach (System.Collections.DictionaryEntry varEnv in varEnvs) { Console.WriteLine($"Variable: key '{varEnv.Key}', value '{varEnv.Value}'"); } var deviceId = System.Environment.GetEnvironmentVariable("IOTEDGE_DEVICEID"); Console.WriteLine($"deviceId: {deviceId}"); // MethodRequest request = new MethodRequest("MethodA", Encoding.UTF8.GetBytes("{ \"Message\": \"Hello\" }")); string message = "{ \"TimeOut_mns\": " + timeOut_mns.ToString() + " }"; MethodRequest request = new MethodRequest("NotifyTimeOut", Encoding.UTF8.GetBytes(message)); MqttTransportSettings mqttSetting = new MqttTransportSettings(Microsoft.Azure.Devices.Client.TransportType.Mqtt_Tcp_Only); ITransportSettings[] settings = { mqttSetting }; ModuleClient ioTHubModuleClient = await ModuleClient.CreateFromEnvironmentAsync(settings); await ioTHubModuleClient.OpenAsync(); var response = await ioTHubModuleClient.InvokeMethodAsync(deviceId, "MQTTClientModule", request).ConfigureAwait(false); Console.WriteLine($"Received response with status {response.Status}"); } catch (Exception ex) { Console.WriteLine(); Console.WriteLine($"Error : {ex.Message}"); } }
/// <inheritdoc /> protected override async Task <(HttpStatusCode ResponseStatus, string ResponseString)> SendIotRequestAsync(string methodName, string requestString) { var directMethod = new MethodRequest(methodName, Encoding.UTF8.GetBytes(requestString), _responseTimeout, _connectionTimeout); var directMethodResponse = await _moduleClient.InvokeMethodAsync(_deviceId, _moduleId, directMethod); return((HttpStatusCode)directMethodResponse.Status, directMethodResponse.ResultAsJson); }
public async Task UploadFile(string path, string filename, string blobPath, string blobFilename, string contentType, bool append = false, CancellationToken token = default(CancellationToken)) { UploadFileModel model = new UploadFileModel(path, filename, blobPath, blobFilename, contentType, append); byte[] message = GetMessage(model); string jstring = JsonConvert.SerializeObject(model); MethodRequest request = new MethodRequest("uploadFile", Encoding.UTF8.GetBytes(jstring)); MethodResponse response = await client.InvokeMethodAsync(deviceId, moduleId, request); if (response.Status != 200) { Console.WriteLine("DirectMethods Client UploadFile failed"); } }
static async Task <string> CallModuleUsingModuleClient(string deviceId, string libraryModule, ModuleClient client) { Console.WriteLine($"Will call module method: {deviceId}, {libraryModule}"); var payloadData = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(new { payload = "ABCDEF0987654321", fport = 1 })); var methodName = random.Next(2) % 2 == 0 ? "test1" : "test2"; var methodRequest = new MethodRequest(methodName, payloadData); var stopwatch = Stopwatch.StartNew(); var response = await client.InvokeMethodAsync(deviceId, libraryModule, methodRequest); stopwatch.Stop(); var responseText = Encoding.UTF8.GetString(response.Result); Console.WriteLine($"Called module function: {responseText} in {stopwatch.ElapsedMilliseconds}ms"); return(responseText); }
static async Task CallDirectMethod( ModuleClient moduleClient, AnalyzerClient analyzerClient, TimeSpan delay, CancellationTokenSource cts) { var request = new MethodRequest("HelloWorldMethod", Encoding.UTF8.GetBytes("{ \"Message\": \"Hello\" }")); string deviceId = Settings.Current.DeviceId; string targetModuleId = Settings.Current.TargetModuleId; int directMethodCount = 1; while (!cts.Token.IsCancellationRequested) { Logger.LogInformation($"Calling Direct Method on device {deviceId} targeting module {targetModuleId}."); try { MethodResponse response = await moduleClient.InvokeMethodAsync(deviceId, targetModuleId, request); string statusMessage = $"Calling Direct Method with count {directMethodCount} returned with status code {response.Status}"; if (response.Status == (int)HttpStatusCode.OK) { Logger.LogDebug(statusMessage); } else { Logger.LogError(statusMessage); } await ReportStatus(targetModuleId, response, analyzerClient); directMethodCount++; } catch (Exception e) { Logger.LogError(e, "Exception caught"); } await Task.Delay(delay, cts.Token); } }
/// <summary> /// This method will send message to leaf device by invoking leaf device direct method. /// </summary> static async Task SendMessageToLeafDevice(string deviceId, ModuleClient moduleClient) { try { string message = $"{UtcDateTime} hello from edge!"; string jString = JsonConvert.SerializeObject(message); var methodRequest = new MethodRequest("LeafDeviceDirectMethod", Encoding.UTF8.GetBytes(jString)); var response = await moduleClient.InvokeMethodAsync(deviceId, methodRequest); if (response.Status == 200) { Console.WriteLine($"{UtcDateTime} message {message} sent"); } else { Console.WriteLine($"Error occurred invoking LeafDeviceDirectMethod. error status code {response.Status}"); } } catch (Exception ex) { Console.WriteLine($"SendMessageToLeafDevice got exception {ex.Message}"); } }
async Task <Tuple <DateTime, HttpStatusCode> > SendDirectMethodAsync( string deviceId, string targetModuleId, string directMethodName, DateTime runExpirationTime, CancellationToken cancellationToken) { ModuleClient moduleClient = await this.GetModuleClientAsync(); while ((!cancellationToken.IsCancellationRequested) && (DateTime.UtcNow < runExpirationTime)) { try { // Direct Method sequence number is always increasing regardless of sending result. this.directMethodCount++; MethodRequest request = new MethodRequest( directMethodName, Encoding.UTF8.GetBytes($"{{ \"Message\": \"Hello\", \"DirectMethodCount\": \"{this.directMethodCount}\" }}"), Settings.Current.SdkOperationTimeout, Settings.Current.SdkOperationTimeout); MethodResponse result = await moduleClient.InvokeMethodAsync(deviceId, targetModuleId, request); this.logger.LogInformation($"[DirectMethodEdgeHubConnector] Invoke DirectMethod with count {this.directMethodCount}"); if ((HttpStatusCode)result.Status == HttpStatusCode.OK) { this.logger.LogDebug(result.ResultAsJson); } else { this.logger.LogError(result.ResultAsJson); } return(new Tuple <DateTime, HttpStatusCode>(DateTime.UtcNow, (HttpStatusCode)result.Status)); } catch (Exception e) { // Only handle the exception that relevant to our test case; otherwise, re-throw it. if (this.IsEdgeHubDownDuringDirectMethodSend(e) || this.IsDirectMethodReceiverNotConnected(e)) { // swallow exeception and retry until success this.logger.LogDebug(e, $"[DirectMethodEdgeHubConnector] Exception caught with SequenceNumber {this.directMethodCount}"); } else { // something is wrong, Log and send report to TRC string errorMessage = $"[DirectMethodEdgeHubConnector] Exception caught with SequenceNumber {this.directMethodCount}"; this.logger.LogError(e, errorMessage); TestResultBase errorResult = new ErrorTestResult( Settings.Current.TrackingId, this.GetSource(), errorMessage, DateTime.UtcNow); await ModuleUtil.ReportTestResultAsync( this.GetReportClient(), this.logger, errorResult, cancellationToken); } } } return(new Tuple <DateTime, HttpStatusCode>(DateTime.UtcNow, HttpStatusCode.InternalServerError)); }