internal void OnInit(Connection connection, WidgetContext context, Widget widget) { ID = widget.ID; Connection = connection; Context = context; object objConfig = widget.Config.ToObject(ConfigType) !; widget.Config = StdJson.ObjectToJObject(objConfig); SetConfig(objConfig); Type type = GetType(); string prefix = RequestMethodNamePrefix; int N = prefix.Length; MethodInfo[] methods = type.GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance) .Where(m => m.Name.StartsWith(prefix)) .ToArray(); foreach (MethodInfo m in methods) { ParameterInfo[] parameters = m.GetParameters(); UIReqDelegate theDelegate = (object?[] args) => { return((Task <ReqResult>)m.Invoke(this, args) !); }; UiReqPara[] uiReqParameters = parameters.Select(MakeParameter).ToArray(); string key = m.Name.Substring(N); mapUiReqMethods[key] = new UiReqMethod(theDelegate, uiReqParameters); } }
private void onEvent(Event evt) { switch (evt.Code) { case AdapterMsg.ID_Event_AlarmOrEvent: var alarm = StdJson.ObjectFromUtf8Stream <AdapterAlarmOrEvent>(evt.Payload); if (alarm != null) { callback?.Notify_AlarmOrEvent(alarm); } break; case AdapterMsg.ID_Event_DataItemsChanged: var items = StdJson.ObjectFromUtf8Stream <DataItemValue[]>(evt.Payload); if (items != null) { callback?.Notify_DataItemsChanged(items); } break; default: Console.Error.WriteLine("Unknown event code: " + evt.Code); break; } }
private static DataValue ConfigToIndentedDataValue(ViewConfig configuration) { string json = StdJson.ObjectToString(configuration, indented: true); string c = "\r\n" + Indent(json, 8) + "\r\n "; return(DataValue.FromJSON(c)); }
public async override void OnVariableHistoryChanged(HistoryChange[] changes) { var alarms = await GetActiveAlarms(); var events = await GetEvents(lastTimeRange, alarms); var newOrChangedAlarms = alarms.Where(a => { var oldVersion = lastAlarms.FirstOrDefault(x => x.T == a.T); if (oldVersion == null) { return(true); } return(!StdJson.ObjectsDeepEqual(a, oldVersion)); }).ToArray(); var newOrChangedEvents = events.Where(a => { var oldVersion = lastEvents.FirstOrDefault(x => x.T == a.T); if (oldVersion == null) { return(true); } return(!StdJson.ObjectsDeepEqual(a, oldVersion)); }).ToArray(); if (newOrChangedAlarms.Length > 0 || newOrChangedEvents.Length > 0) { lastAlarms = alarms; lastEvents = events; Context.SendEventToUI("Event", new { Alarms = newOrChangedAlarms, Events = newOrChangedEvents }); } }
public override async Task <string[]> BrowseDataItemAddress(string?idOrNull) { if (!await TryConnect() || connection == null) { return(new string[0]); } var allObjects = await connection.GetAllObjects(moduleID); var result = new List <string>(); foreach (ObjectInfo obj in allObjects) { foreach (Variable v in obj.Variables) { string objID = obj.ID.LocalObjectID; string varName = v.Name; if (varName == "Value") { result.Add(objID); } else { string[] objVar = new string[] { objID, varName }; result.Add(StdJson.ValueToString(objVar)); } } } return(result.ToArray()); }
private static Page PageFromTab(View_HistoryPlots.TabConfig tab, View_HistoryPlots.DataExport dataExport) { var hc = new Widgets.HistoryPlotConfig() { PlotConfig = MapPlotConfig(tab.PlotConfig), Items = tab.Items.Select(MapItemConfig).ToArray(), DataExport = MapDataExport(dataExport) }; JObject config = StdJson.ObjectToJObject(hc, indented: true); return(new Page() { ID = tab.Name, Name = tab.Name, Rows = new Row[] { new Row() { Columns = new Column[] { new Column() { Width = ColumnWidth.Fill, Widgets = new Widget[] { new Widget("w1", "HistoryPlot", width: "100%", height: "600px", config: config) } } } } } }); }
public static ReqResult Bad(string errMsg) { string js = "{ \"error\": " + StdJson.ValueToString(errMsg) + "}"; byte[] bytes = Encoding.UTF8.GetBytes(js); return(new ReqResult(400, new MemoryStream(bytes))); }
private void SendEvent <T>(IList <T> values, byte eventID) { if (values == null || values.Count == 0) { return; } connector.SendEvent(eventID, s => StdJson.ObjectToStream(values, s)); }
private static async Task OnReceivedConfigWriteRequest(IMqttClient clientMQTT, LargePayloadReader reader, string moduleID, string topicBase, Connection clientFAST, MqttApplicationMessageReceivedEventArgs arg) { var msg = arg.ApplicationMessage; await arg.AcknowledgeAsync(CancellationToken.None); if (msg.Topic.EndsWith("/info")) { reader.SetInfo(msg.Payload); string payload = Encoding.UTF8.GetString(msg.Payload); Console.WriteLine($"Got Info msg! ClientID: {arg.ClientId}; Topic: {msg.Topic}; QOS: {msg.QualityOfServiceLevel}; Payload: {payload}"); } else { int bucket = GetBucketNumberFromTopicName(msg.Topic); reader.SetBucket(bucket, msg.Payload); Console.WriteLine($"Got Data msg! ClientID: {arg.ClientId}; Topic: {msg.Topic}; Bucket: {bucket}; QOS: {msg.QualityOfServiceLevel}; Payload.Len: {msg.Payload.Length}"); } string?content = reader.Content(); if (content != null) { try { var nv = new NamedValue("config", content); DataValue value = await clientFAST.CallMethod(moduleID, "SetConfigString", nv); Console.WriteLine("Stored new config!"); } catch (Exception exp) { Exception e = exp.GetBaseException() ?? exp; Console.Error.WriteLine($"Failed to set new config: {e.Message}"); byte[] payload = StdJson.ObjectToBytes(new { Hash = reader.ContentHash, Error = e.Message, Time = Timestamp.Now.ToString() }, indented: true); var msgInfo = new MqttApplicationMessage() { QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce, Retain = true, Topic = $"{topicBase}/error", PayloadFormatIndicator = MqttPayloadFormatIndicator.CharacterData, Payload = payload, }; await clientMQTT.PublishAsync(msgInfo); } } }
private void SerializeArray <T>(T[] array, Stream output) { if (array == null || array.Length == 0) { output.WriteByte((byte)'['); output.WriteByte((byte)']'); } else { StdJson.ObjectToStream(array, output); } }
private static VariableRef MakeVarRefFromAddress(string address, string moduleID) { try { string[]? arr = StdJson.ObjectFromString <string[]>(address); if (arr != null && arr.Length == 2 && arr[0].Length > 0 && arr[1].Length > 0) { return(VariableRef.Make(moduleID, arr[0], arr[1])); } } catch (Exception) {} return(VariableRef.Make(moduleID, address, "Value")); }
private async Task SendWebSocket(WebSocket socket, string msgStart, object content) { int pendingCounter = 0; while (eventPending && !closed && pendingCounter < 100) { await Task.Delay(50); pendingCounter += 1; } if (closed) { return; } try { eventPending = true; var stream = streamSend; stream.Position = 0; stream.SetLength(0); // Console.WriteLine($"SendWebSocket: {stream.Capacity} Thread: {Thread.CurrentThread.ManagedThreadId}"); using (var writer = new StreamWriter(stream, UTF8_NoBOM, 1024, leaveOpen: true)) { writer.Write(msgStart); StdJson.ObjectToWriter(content, writer); writer.Write("}"); } ArraySegment <byte> segment; stream.TryGetBuffer(out segment); eventAcked = false; await socket.SendAsync(segment, WebSocketMessageType.Text, true, CancellationToken.None); int counter = 0; while (!eventAcked && !closed && counter < 100) { await Task.Delay(50); counter += 1; } } catch (Exception exp) { logInfo("SendWebSocket:", exp); } finally { eventPending = false; } }
private async Task <T> SendRequest <T>(AdapterMsg requestMsg) { using (Response res = await connection.SendRequest(requestMsg.GetMessageCode(), stream => StdJson.ObjectToStream(requestMsg, stream))) { if (res.Success) { return(StdJson.ObjectFromUtf8Stream <T>(res.SuccessPayload)); } else { throw new Exception(res.ErrorMsg); } } }
protected virtual string SerializeModelToString(T model) { switch (modelFormat) { case ModelFormat.XML: return(Xml.ToXml(model)); case ModelFormat.JSON: return(StdJson.ObjectToString(model, indented: true)); default: throw new Exception($"Model format {modelFormat} not implemented in SerializeModelToString"); } }
private async Task <VTQ> ReadDataItemFromDB(string itemID, string query, VTQ lastValue) { var rows = new List <JObject>(); using (DbCommand cmd = CreateCommand(dbConnection !, query)) { using (var reader = await cmd.ExecuteReaderAsync()) { while (reader.Read()) { int n = reader.FieldCount; JObject objRow = new JObject(); for (int i = 0; i < n; ++i) { string name = reader.GetName(i); object value = reader.GetValue(i); objRow[name] = JToken.FromObject(value); } rows.Add(objRow); } } } DataValue dataValue = DataValue.FromObject(rows, indented: true); if (lastValue.V == dataValue) { return(lastValue); } VTQ vtq = VTQ.Make(dataValue, Timestamp.Now.TruncateMilliseconds(), Quality.Good); int N = rows.Count; string firstRow = N == 0 ? "" : StdJson.ObjectToString(rows[0], indented: false); if (N == 0) { PrintLine($"Read 0 rows for {itemID}"); } else if (N == 1) { PrintLine($"Read 1 row for {itemID}: {firstRow}"); } else { PrintLine($"Read {N} rows for {itemID}. First row: {firstRow}"); } return(vtq); }
internal async Task SaveWidgetConfiguration(string pageID, Widget widget, object newWidgetConfig) { JObject objNewWidgetConfig = StdJson.ObjectToJObject(newWidgetConfig); widget.Config = objNewWidgetConfig; DataValue newViewConfig = DataValue.FromObject(configuration, indented: true); await Context.SaveViewConfiguration(newViewConfig); var msg = new { PageID = pageID, WidgetID = widget.ID, Config = widget.Config, }; await Context.SendEventToUI("WidgetConfigChanged", msg); }
private async Task <List <ObjectMember> > GetObjectMembers(string id, string type) { ObjectRef obj = ObjectRef.FromEncodedString(id); ClassInfo info = objTypes[type]; MemberRef[] members = info.SimpleMember.Select(m => MemberRef.Make(obj, m.Name)).ToArray(); MemberValue[] memValues = await Connection.GetMemberValues(members); var values = new List <ObjectMember>(); for (int i = 0; i < info.SimpleMember.Count; ++i) { SimpleMember m = info.SimpleMember[i]; MemberValue v = memValues[i]; string defaultValue = ""; if (m.DefaultValue.HasValue && m.Dimension != Dimension.Array) { defaultValue = m.DefaultValue.Value.JSON; } else if (m.Type == DataType.Struct) { defaultValue = StdJson.ObjectToString(GetStructDefaultValue(m), indented: true, ignoreNullValues: false); //Console.WriteLine("=> " + m.Name + ": " + defaultValue); } else { defaultValue = DataValue.FromDataType(m.Type, 1).JSON; } var member = new ObjectMember() { Key = obj.ToEncodedString() + "__" + m.Name, Name = m.Name, Type = m.Type.ToString(), IsScalar = m.Dimension == Dimension.Scalar, IsOption = m.Dimension == Dimension.Optional, IsArray = m.Dimension == Dimension.Array, Category = m.Category, Browseable = m.Browseable, Value = new JRaw(v.Value.JSON), ValueOriginal = new JRaw(v.Value.JSON), EnumValues = ResolveEnum(m), StructMembers = ResolveStruct(m), DefaultValue = defaultValue }; values.Add(member); } return(values); }
protected virtual T DeserializeModelFromString(string model) { string m = model.TrimStart(); if (m.StartsWith("<")) { modelFormat = ModelFormat.XML; return(Xml.FromXmlString <T>(model)); } else if (m.StartsWith("{")) { modelFormat = ModelFormat.JSON; return(StdJson.ObjectFromString <T>(model) ?? new T()); } else { throw new Exception($"Unknown file format for {modelFileName}: expected XML or JSON"); } }
public static ReqResult OK(object obj) { if (typeof(Task).IsAssignableFrom(obj.GetType())) { throw new Exception("ReqResult.OK: obj may not be a Task!"); } var res = MemoryManager.GetMemoryStream("ReqResult.OK"); try { StdJson.ObjectToStream(obj, res, indented: true, ignoreNullValues: false); res.Seek(0, SeekOrigin.Begin); } catch (Exception) { res.Dispose(); throw; } return(new ReqResult(200, res)); }
private async Task SendWebSocket(WebSocket socket, string msgStart, object content) { try { using (var stream = MemoryManager.GetMemoryStream("Session.SendWebSocket")) { using (var writer = new StreamWriter(stream, UTF8_NoBOM, 1024, leaveOpen: true)) { writer.Write(msgStart); StdJson.ObjectToWriter(content, writer); writer.Write("}"); } byte[] bytes = stream.GetBuffer(); int count = (int)stream.Length; var segment = new ArraySegment <byte>(bytes, 0, count); await socket.SendAsync(segment, WebSocketMessageType.Text, true, CancellationToken.None); } } catch (Exception exp) { logInfo("SendWebSocket:", exp); } }
public static ReqResult OK(object obj, bool ignoreShouldSerializeMembers = false, string?contentType = null) { if (typeof(Task).IsAssignableFrom(obj.GetType())) { throw new Exception("ReqResult.OK: obj may not be a Task!"); } var res = MemoryManager.GetMemoryStream("ReqResult.OK"); try { StdJson.ObjectToStream(obj, res, indented: true, ignoreShouldSerializeMembers: ignoreShouldSerializeMembers); res.Seek(0, SeekOrigin.Begin); } catch (Exception) { res.Dispose(); throw; } return(new ReqResult(200, res, contentType: contentType)); }
public override async Task <BrowseDataItemsResult> BrowseDataItems() { if (connection == null) { string endpoint = config?.Address ?? ""; string msg = $"No connection to server '{endpoint}': " + lastConnectErrMsg; return(new BrowseDataItemsResult( supportsBrowsing: true, browsingError: msg, items: new DataItemBrowseInfo[0], clientCertificate: "")); } var allObjects = await connection.GetAllObjects(moduleID); var result = new List <DataItemBrowseInfo>(); foreach (ObjectInfo obj in allObjects) { foreach (Variable v in obj.Variables) { string objID = obj.ID.LocalObjectID; string varName = v.Name; if (varName == "Value") { result.Add(new DataItemBrowseInfo(objID, new[] { objID })); } else { string[] objVar = new string[] { objID, varName }; string id = StdJson.ValueToString(objVar); result.Add(new DataItemBrowseInfo(id, objVar)); } } } return(new BrowseDataItemsResult( supportsBrowsing: true, browsingError: "", items: result.ToArray(), clientCertificate: "")); }
private static async Task Loop(TcpConnectorSlave connector, AdapterBase module) { Process?parentProcess = null; using (Request request = await connector.ReceiveRequest(5000)) { if (request.Code != AdapterMsg.ID_ParentInfo) { throw new Exception("Missing ParentInfo request"); } ParentInfoMsg?info = StdJson.ObjectFromUtf8Stream <ParentInfoMsg>(request.Payload); if (info == null) { throw new Exception("ParentInfoMsg is null"); } parentProcess = Process.GetProcessById(info.PID); connector.SendResponseSuccess(request.RequestID, s => { }); } Thread t = new Thread(() => { ParentAliveChecker(parentProcess); }); t.IsBackground = true; t.Start(); var helper = new AdapterHelper(module, connector); bool run = true; while (run) { using (Request request = await connector.ReceiveRequest()) { helper.ExecuteAdapterRequestAsync(request); bool shutdown = request.Code == AdapterMsg.ID_Shutdown; run = !shutdown; } } // Wait until parent process kills us (after Shutdown method completed) while (true) { await Task.Delay(1000); } }
public async Task <ReqResult> UiReq_ConfigPageDuplicate(string pageID, string newPageID, string title) { CheckActivePage(pageID); string pageCopy = StdJson.ObjectToString(activePage !.Page); var page = StdJson.ObjectFromString <Page>(pageCopy) !; page.ID = newPageID; page.Name = title; var pages = configuration.Pages.ToList(); pages.Add(page); configuration.Pages = pages.ToArray(); Pages[page.ID] = new PageState(page, Connection, widgetTypes, this); DataValue newViewConfig = DataValue.FromObject(configuration, indented: true); await Context.SaveViewConfiguration(newViewConfig); return(ReqResult.OK(configuration.Pages)); }
public async Task Register(IMqttClient clientMQTT, VariableValues allValues) { if (topic == "") { return; } var newVarVals = allValues.Where(v => !registeredVars.Contains(v.Variable)).ToList(); while (newVarVals.Count > 0) { int BatchSize = Math.Min(varPub.PayloadLimit, newVarVals.Count); var batch = newVarVals.Take(BatchSize).ToArray(); newVarVals.RemoveRange(0, BatchSize); JObject[] payload = batch.Select(vv => FromVariableValue(vv, varPub)).ToArray(); string msg = StdJson.ObjectToString(payload); try { await clientMQTT.PublishAsync(topic, msg); foreach (var vv in batch) { registeredVars.Add(vv.Variable); } if (varPub.PrintPayload) { Console.Out.WriteLine($"REG PUB: {topic}: {msg}"); } } catch (Exception exp) { Exception e = exp.GetBaseException() ?? exp; Console.Error.WriteLine($"Reg Publish failed for topic {topic}: {e.Message}"); break; } } }
public async override Task OnVariableHistoryChanged(List <HistoryChange> changes) { var alarms = await GetActiveAlarms(); var events = await GetEvents(lastTimeRange, alarms); var newOrChangedAlarms = alarms.Where(a => { var oldVersion = lastAlarms.FirstOrDefault(x => x.T == a.T); if (oldVersion == null) { return(true); } return(!StdJson.ObjectsDeepEqual(a, oldVersion)); }).ToArray(); long[] removedAlarms = lastAlarms.Where(la => alarms.All(a => a.T != la.T)).Select(x => x.T).ToArray(); var newOrChangedEvents = events.Where(a => { var oldVersion = lastEvents.FirstOrDefault(x => x.T == a.T); if (oldVersion == null) { return(true); } return(!StdJson.ObjectsDeepEqual(a, oldVersion)); }).ToArray(); if (newOrChangedAlarms.Length > 0 || newOrChangedEvents.Length > 0 || removedAlarms.Length > 0) { lastAlarms = alarms; lastEvents = events; await Context.SendEventToUI("Event", new { Alarms = newOrChangedAlarms, Events = newOrChangedEvents, RemovedAlarms = removedAlarms, }); } }
public virtual async Task <ReqResult> OnUiRequestAsync(string command, DataValue parameters) { if (mapUiReqMethods.ContainsKey(command)) { UiReqMethod method = mapUiReqMethods[command]; method.ResetValues(); JObject obj = StdJson.JObjectFromString(parameters.JSON); foreach (JProperty p in obj.Properties()) { if (method.ParameterMap.ContainsKey(p.Name)) { UiReqPara para = method.ParameterMap[p.Name]; para.Value = p.Value.ToObject(para.Type); } } object?[] paramValues = method.Parameters.Select(p => p.Value).ToArray(); return(await method.TheDelegate(paramValues)); } return(ReqResult.Bad("Unknown command: " + command)); }
private async Task SendVoidRequest(AdapterMsg requestMsg) { if (connection == null) { return; } using (Response res = await connection.SendRequest(requestMsg.GetMessageCode(), stream => StdJson.ObjectToStream(requestMsg, stream))) { if (res.Success) { return; } else { throw new Exception(res.ErrorMsg); } } }
private async Task <T> SendRequest <T>(AdapterMsg requestMsg) { if (connection == null) { throw new Exception("ExternalAdapter.SendRequest: connection is null"); } using (Response res = await connection.SendRequest(requestMsg.GetMessageCode(), stream => StdJson.ObjectToStream(requestMsg, stream))) { if (res.Success) { return(StdJson.ObjectFromUtf8Stream <T>(res.SuccessPayload !) ?? throw new Exception($"ExternalAdapter.SendRequest {requestMsg.GetType().Name}: returned result is null")); } else { throw new Exception(res.ErrorMsg); } } }
public void Notify_AlarmOrEvent(AdapterAlarmOrEvent eventInfo) { connector.SendEvent(AdapterMsg.ID_Event_AlarmOrEvent, s => StdJson.ObjectToStream(eventInfo, s)); }