/// <summary> /// Processes the message. /// </summary> /// <param name="data">The data.</param> /// <returns> /// The Task /// </returns> /// <exception cref="System.NotImplementedException"></exception> public async Task ProcessMessage(EventData data) { if (!data.Properties.ContainsKey(Constants.DeviceIdKey)) { throw new Exception("Device Id is missing"); } var deviceId = data.Properties[Constants.DeviceIdKey].ToString(); var actor = this.GetActor(deviceId); var telemetryMessage = new TelemetryMessage() { Body = data.GetBytes(), Properties = data.Properties, DeviceId = deviceId }; if (data.Properties.ContainsKey(Constants.MessageIdKey)) { telemetryMessage.MessageId = data.Properties[Constants.MessageIdKey].ToString(); } await actor.ProcessMessage(telemetryMessage); }
/// <summary> /// The main method to invoke TLC, with some high level configuration options set. /// </summary> /// <param name="env">The environment used in this run of TLC, for the purpose of returning outputs.</param> /// <param name="args">The command line arguments.</param> /// <param name="alwaysPrintStacktrace">"Marked" exceptions are assumed to be sufficiently descriptive, so we /// do not print stack traces for them to the console, and instead print these only to a log file. /// However, throwing unmarked exceptions is considered a bug in TLC (even if due to bad user input), /// so we always write . If set to true though, this executable will also print stack traces from the /// marked exceptions as well.</param> /// <returns></returns> internal static int MainCore(TlcEnvironment env, string args, bool alwaysPrintStacktrace) { // REVIEW: How should extra dlls, tracking, etc be handled? Should the args objects for // all commands derive from a common base? var mainHost = env.Register("Main"); using (var telemetryPipe = mainHost.StartPipe <TelemetryMessage>("TelemetryPipe")) using (var ch = mainHost.Start("Main")) { int result; try { if (!CmdParser.TryGetFirstToken(args, out string kind, out string settings)) { telemetryPipe.Send(TelemetryMessage.CreateCommand("ArgumentParsingFailure", args)); Usage(); return(-1); } var cmdDef = new SubComponent <ICommand, SignatureCommand>(kind, settings); if (!ComponentCatalog.TryCreateInstance(mainHost, out ICommand cmd, cmdDef)) { // Telemetry: Log telemetryPipe.Send(TelemetryMessage.CreateCommand("UnknownCommand", settings)); ch.Error("Unknown command: '{0}'", kind); Usage(); return(-1); } // Telemetry: Log the command and settings. telemetryPipe.Send(TelemetryMessage.CreateCommand(kind.ToUpperInvariant(), settings)); cmd.Run(); result = 0; } catch (Exception ex) { var dumpFileDir = Path.Combine( Path.GetTempPath(), "TLC"); var dumpFilePath = Path.Combine(dumpFileDir, string.Format(CultureInfo.InvariantCulture, "Error_{0:yyyyMMdd_HHmmss}_{1}.log", DateTime.UtcNow, Guid.NewGuid())); bool isDumpSaved = false; try { Directory.CreateDirectory(dumpFileDir); // REVIEW: Should specify the encoding. using (var sw = new StreamWriter(new FileStream(dumpFilePath, FileMode.Create, FileAccess.Write))) { sw.WriteLine("--- Command line args ---"); sw.WriteLine(args); sw.WriteLine("--- Exception message ---"); PrintFullExceptionDetails(sw, ex); } isDumpSaved = true; } catch (Exception) { // Don't throw an exception if we failed to write to the dump file. } // Process exceptions that we understand. int count = 0; for (var e = ex; e != null; e = e.InnerException) { // Telemetry: Log the exception telemetryPipe.Send(TelemetryMessage.CreateException(e)); if (e.IsMarked()) { ch.Error(e.Sensitivity(), e.Message); PrintExceptionData(ch, e, false); count++; } } if (count == 0) { // Didn't recognize any of the exceptions. ch.Error(MessageSensitivity.None, "***** Unexpected failure. Please go to https://aka.ms/MLNetIssue and register the error details *****"); if (isDumpSaved) { ch.Error(MessageSensitivity.None, "***** Error log has been saved to '{0}', please register the error at https://aka.ms/MLNetIssue *****", dumpFilePath); } } else if (isDumpSaved) { ch.Error(MessageSensitivity.None, "Error log has been saved to '{0}'. please register the error at https://aka.ms/MLNetIssue", dumpFilePath); } if (count == 0 || alwaysPrintStacktrace) { ch.Error(MessageSensitivity.None, "===== Begin detailed dump ====="); PrintFullExceptionDetails(ch, ex); ch.Error(MessageSensitivity.None, "====== End detailed dump ====="); } // Return a negative result code so AEther recognizes this as a failure. result = count > 0 ? -1 : -2; } finally { } telemetryPipe.Done(); return(result); } }
private static async Task SimulateData(CancellationToken ct) { bool atLeastOneSensorMatchFound = false; var serializer = new DataContractJsonSerializer(typeof(TelemetryMessage)); foreach (Sensor sensor in DeviceInfo.Sensors) { if (SensorInfosByDataType.ContainsKey(sensor.DataType)) { atLeastOneSensorMatchFound = true; break; } } if (!atLeastOneSensorMatchFound) { throw new Exception( $"No preconfigured Sensor found for any of the following datatypes: {string.Join( ", ", SensorInfosByDataType.Keys )}"); } Console.WriteLine(); Console.WriteLine("Beginning to simulate data..."); Console.WriteLine(); while (true) { if (ct.IsCancellationRequested) { break; } foreach (Sensor sensor in DeviceInfo.Sensors) { if (!SensorInfosByDataType.TryGetValue(sensor.DataType, out SensorInfo sensorInfo)) { continue; } if (sensorInfo.IsCurrentValueDifferent()) { sensorInfo.UpdateLastValueSentWithCurrentValue(); var currentValue = sensorInfo.GetCurrentValue(); var telemetryMessage = new TelemetryMessage() { SensorId = sensor.Id, SensorReading = currentValue.ToString(), EventTimestamp = DateTime.UtcNow.ToString("o"), SensorType = sensor.Type, SensorDataType = sensor.DataType, SpaceId = sensor.SpaceId, IoTHubDeviceId = IoTHubDeviceId }; try { List <Task> tasks = new List <Task>(); using (var stream = new MemoryStream()) { serializer.WriteObject(stream, telemetryMessage); var binaryMessage = stream.ToArray(); Message eventMessage = new Message(binaryMessage); eventMessage.Properties.Add("Sensor", ""); eventMessage.Properties.Add("MessageVersion", "1.0"); eventMessage.Properties.Add("x-ms-flighting-udf-execution-manually-enabled", "true"); Console.WriteLine( $"\t{DateTime.UtcNow.ToLocalTime()}> Sending message: {Encoding.ASCII.GetString( binaryMessage )}"); tasks.Add(TopologyDeviceClient.SendEventAsync(eventMessage)); } await Task.WhenAll(tasks); } catch (Exception ex) { Console.WriteLine($"Error occurred in {nameof( SimulateData )}: {ex}"); } } } await Task.Delay(int.Parse(Configuration[MessageIntervalInMilliSecondsSetting]), ct); } }
public void Telemetry() { TelemetryMessage tm = new TelemetryMessage(); Console.WriteLine(TelemetryMessage.DefaultMachineID); }
private static async Task SimulateData(CancellationToken ct) { var serializer = new DataContractJsonSerializer(typeof(TelemetryMessage)); var sensor = DeviceInfo.Sensors.FirstOrDefault(x => (x.DataType == Configuration[SensorDataTypeSetting])); if (sensor == null) { throw new Exception($"No preconfigured Sensor for DataType '{Configuration[SensorDataTypeSetting]}' found."); } while (true) { if (ct.IsCancellationRequested) { break; } int newTemperature = _currentTemperature + _offsetModifier; if (newTemperature != _lastCurrentTemperatureSent) { _lastCurrentTemperatureSent = newTemperature; var telemetryMessage = new TelemetryMessage() { SensorId = sensor.Id, SensorReading = newTemperature.ToString(CultureInfo.InvariantCulture), EventTimestamp = DateTime.UtcNow.ToString("o"), SensorType = sensor.Type, SensorDataType = sensor.DataType, SpaceId = sensor.SpaceId }; try { List <Task> tasks = new List <Task>(); using (var stream = new MemoryStream()) { serializer.WriteObject(stream, telemetryMessage); var binaryMessage = stream.ToArray(); Message eventMessage = new Message(binaryMessage); eventMessage.Properties.Add("Sensor", ""); eventMessage.Properties.Add("MessageVersion", "1.0"); eventMessage.Properties.Add("x-ms-flighting-udf-execution-manually-enabled", "true"); Console.WriteLine( $"\t{DateTime.UtcNow.ToLocalTime()}> Sending message: {Encoding.ASCII.GetString( binaryMessage )}"); tasks.Add(TopologyDeviceClient.SendEventAsync(eventMessage)); } await Task.WhenAll(tasks); } catch (Exception ex) { Console.WriteLine($"Error occurred in {nameof( SimulateData )}: {ex}"); } } await Task.Delay(int.Parse(Configuration[MessageIntervalInMilliSecondsSetting]), ct); } }
public void Publish(TelemetryMessage message) { _deviceDataController.PublishData(message); }
public bool SendTelemetry(TelemetryMessage telemetryMessage) { throw new NotImplementedException(); }
private async Task ListenAsync() { uint headerSize = (uint)Marshal.SizeOf(typeof(MessageHeader)); byte[] headerBuffer = new byte[headerSize]; DataReader reader = new DataReader(_stream.InputStream); while (true) { await reader.LoadAsync(headerSize); reader.ReadBytes(headerBuffer); MessageHeader header = StructSerializer.DeserializeStruct <MessageHeader>(headerBuffer); if (header.Type == MessageType.Telemetry) { uint telemetrySize = (uint)Marshal.SizeOf(typeof(TelemetryMessage)); byte[] telemetryBuffer = new byte[telemetrySize - headerSize]; await reader.LoadAsync(telemetrySize - headerSize); reader.ReadBytes(telemetryBuffer); var z = new byte[headerBuffer.Length + telemetryBuffer.Length]; headerBuffer.CopyTo(z, 0); telemetryBuffer.CopyTo(z, headerBuffer.Length); TelemetryMessage telemetry = StructSerializer.DeserializeStruct <TelemetryMessage>(z); CurrentValues.Update(telemetry); Debug.WriteLine("Telemetry"); for (int i = 0; i < TelemetryMessage.EntryLength; i++) { Debug.WriteLine(" {0} = {1},{2}", telemetry.Devices[i].Hash, telemetry.Devices[i].IValue, telemetry.Devices[i].DValue); } Debug.WriteLine(""); for (int i = 0; i < TelemetryMessage.EntryLength; i++) { if (telemetry.Devices[i].Hash == 0) { continue; } //If we are not watching this hash, ignore it if (!_telemetry.ContainsKey(telemetry.Devices[i].Hash)) { continue; } ObservableCollection <Data> collection = _telemetry[telemetry.Devices[i].Hash]; object value; TypeCode type = _telemetryHashToType[telemetry.Devices[i].Hash]; switch (type) { case TypeCode.Int32: value = telemetry.Devices[i].IValue; break; case TypeCode.Single: value = telemetry.Devices[i].DValue; break; default: throw new NotImplementedException(); } Data data = new Data { DateTime = DateTime.Now, Value = value }; CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { collection.Add(data); }); } } } }