public override async Task EnableVariableHistoryChangedEvents(params ObjectRef[] idsOfEnabledTreeRoots) { JObject request = MakeSessionRequest(); request["idsOfEnabledTreeRoots"] = new JRaw(StdJson.ValueToString(idsOfEnabledTreeRoots)); await PostJObject("EnableVariableHistoryChangedEvents", request); }
public override async Task EnableVariableHistoryChangedEvents(params VariableRef[] variables) { JObject request = MakeSessionRequest(); request["variables"] = new JRaw(StdJson.ObjectToString(variables)); await PostJObject("EnableVariableHistoryChangedEvents", request); }
public override async Task <ObjectValue[]> GetObjectValuesByID(params ObjectRef[] objectIDs) { JObject request = MakeSessionRequest(); request["objectIDs"] = new JRaw(StdJson.ValueToString(objectIDs)); return(await Post <ObjectValue[]>("GetObjectValuesByID", request)); }
public override async Task <VTQ[]> ReadVariablesSync(VariableRef[] variables, Duration?timeout = null) { if (variables == null) { throw new ArgumentNullException(nameof(variables)); } JObject request = MakeSessionRequest(); request["variables"] = new JRaw(StdJson.ObjectToString(variables)); if (timeout.HasValue) { request["timeout"] = new JRaw(StdJson.ValueToString(timeout.Value)); } Task <VTQ[]> task = Post <VTQ[]>("ReadVariablesSync", request); if (timeout.HasValue) { if (task == await Task.WhenAny(task, Task.Delay(timeout.Value.ToTimeSpan()))) { return(await task); } else { throw new Exception("Timeout"); } } else { return(await task); } }
public override async Task EnableConfigChangedEvents(params ObjectRef[] objects) { JObject request = MakeSessionRequest(); request["objects"] = new JRaw(StdJson.ValueToString(objects)); await PostJObject("EnableConfigChangedEvents", request); }
public override async Task EnableAlarmsAndEvents(Severity minSeverity = Severity.Info) { JObject request = MakeSessionRequest(); request["minSeverity"] = new JRaw(StdJson.ValueToString(minSeverity)); await PostJObject("EnableAlarmsAndEvents", request); }
public override async Task <WriteResult> WriteVariablesSync(VariableValue[] values, Duration?timeout = null) { JObject request = MakeSessionRequest(); request["values"] = new JRaw(StdJson.ObjectToString(values)); if (timeout.HasValue) { request["timeout"] = new JRaw(StdJson.ValueToString(timeout.Value)); } Task <WriteResult> task = Post <WriteResult>("WriteVariablesSync", request); if (timeout.HasValue) { if (task == await Task.WhenAny(task, Task.Delay(timeout.Value.ToTimeSpan()))) { return(await task); } else { throw new Exception("Timeout"); } } else { return(await task); } }
public override async Task WriteVariables(VariableValue[] values) { JObject request = MakeSessionRequest(); request["values"] = new JRaw(StdJson.ObjectToString(values)); await PostJObject("WriteVariables", request); }
public override async Task HistorianDeleteAllVariablesOfObjectTree(ObjectRef objectID) { JObject request = MakeSessionRequest(); request["objectID"] = new JRaw(StdJson.ValueToString(objectID)); await PostJObject("HistorianDeleteAllVariablesOfObjectTree", request); }
public override async Task HistorianDeleteVariables(params VariableRef[] variables) { JObject request = MakeSessionRequest(); request["variables"] = new JRaw(StdJson.ObjectToString(variables)); await PostJObject("HistorianDeleteVariables", request); }
public override async Task <ObjectValue> GetParentOfObject(ObjectRef objectID) { JObject request = MakeSessionRequest(); request["objectID"] = new JRaw(StdJson.ValueToString(objectID)); return(await Post <ObjectValue>("GetParentOfObject", request)); }
public override async Task <ObjectInfo> GetRootObject(string moduleID) { JObject request = MakeSessionRequest(); request["moduleID"] = new JRaw(StdJson.ValueToString(moduleID)); return(await Post <ObjectInfo>("GetRootObject", request)); }
public override async Task <VariableValue[]> ReadAllVariablesOfObjectTree(ObjectRef objectID) { JObject request = MakeSessionRequest(); request["objectID"] = new JRaw(StdJson.ValueToString(objectID)); return(await Post <VariableValue[]>("ReadAllVariablesOfObjectTree", request)); }
private async Task <RequestBase> GetRequestObject(HttpRequest request, ReqDef def) { const string mediaBinary = "application/octet-stream"; using (var memoryStream = MemoryManager.GetMemoryStream("HandleClientRequest")) { using (var body = request.Body) { await body.CopyToAsync(memoryStream).ConfigureAwait(false); } memoryStream.Seek(0, SeekOrigin.Begin); RequestBase ret; bool binaryRequest = request.ContentType == mediaBinary; if (binaryRequest) { ret = def.MakeRequestObject(); using (var reader = new BinaryReader(memoryStream, Encoding.UTF8, leaveOpen: false)) { BinSerializable x = (BinSerializable)ret; x.BinDeserialize(reader); } } else { ret = (RequestBase)(StdJson.ObjectFromUtf8Stream(memoryStream, def.ReqType) ?? throw new Exception("Request via JSON is null")); } var accept = request.Headers["Accept"]; bool binaryResponse = accept.Any(a => a.Contains(mediaBinary)); ret.ReturnBinaryResponse = binaryResponse; return(ret); } }
private void onEvent(Event evt) { switch (evt.Code) { case ExternalModuleHost.ModuleHelper.ID_Event_VariableValuesChanged: var values = BinSeri.VariableValue_Serializer.Deserialize(evt.Payload); notifier?.Notify_VariableValuesChanged(values); break; case ExternalModuleHost.ModuleHelper.ID_Event_ConfigChanged: var objects = StdJson.ObjectFromUtf8Stream <List <ObjectRef> >(evt.Payload); if (objects != null) { notifier?.Notify_ConfigChanged(objects); } break; case ExternalModuleHost.ModuleHelper.ID_Event_AlarmOrEvent: var ae = StdJson.ObjectFromUtf8Stream <AlarmOrEventInfo>(evt.Payload); if (ae != null) { notifier?.Notify_AlarmOrEvent(ae); } break; default: logger.Error("Unknown event code: " + evt.Code); break; } }
public override async Task <ObjectInfo[]> GetAllObjectsWithVariablesOfType(string moduleID, params DataType[] types) { JObject request = MakeSessionRequest(); request["moduleID"] = new JRaw(StdJson.ValueToString(moduleID)); request["types"] = new JRaw(StdJson.ValueToString(types.Cast <Enum>().ToArray())); return(await Post <ObjectInfo[]>("GetAllObjectsWithVariablesOfType", request)); }
public override async Task <ObjectInfo[]> GetAllObjectsOfType(string moduleID, string className) { JObject request = MakeSessionRequest(); request["moduleID"] = new JRaw(StdJson.ValueToString(moduleID)); request["className"] = new JRaw(StdJson.ValueToString(className)); return(await Post <ObjectInfo[]>("GetAllObjectsOfType", request)); }
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 async Task HandleClientRequest(HttpContext context) { HttpRequest request = context.Request; HttpResponse response = context.Response; if (shutdown) { response.StatusCode = 400; // BAD Request return; } try { if (request.Path == "/Mediator/" && context.WebSockets.IsWebSocketRequest) { WebSocket webSocket = await context.WebSockets.AcceptWebSocketAsync(); await HandleClientWebSocket(webSocket); return; } if (request.Method != "POST" || !HandleClientRequests.IsValid(request.Path)) { logger.Warn("Invalid request " + request.Path.ToUriComponent()); response.StatusCode = 400; // BAD Request return; } //logger.Info("Client request: " + request.Path); JObject obj = null; using (var body = request.Body) { using (var reader = new StreamReader(body, Encoding.UTF8)) { obj = await StdJson.JObjectFromReaderAsync(reader); //logger.Info("ReqStr: " + StdJson.ObjectToString(obj, true)); } } using (ReqResult result = await reqHandler.Handle(request.Path, obj)) { //logger.Info(result.AsString()); response.StatusCode = result.StatusCode; response.ContentLength = result.Bytes.Length; response.ContentType = "application/json"; try { await result.Bytes.CopyToAsync(response.Body); } catch (Exception) { response.StatusCode = 500; } } } catch (Exception exp) { response.StatusCode = 500; logger.Warn(exp.GetBaseException(), "Error handling client request"); } }
public override async Task HistorianModify(VariableRef variable, ModifyMode mode, params VTQ[] data) { JObject request = MakeSessionRequest(); request["variable"] = new JRaw(StdJson.ObjectToString(variable)); request["data"] = new JRaw(StdJson.ObjectToString(data)); request["mode"] = new JRaw(StdJson.ValueToString(mode)); await PostJObject("HistorianModify", request); }
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); } }
public override Task <DataValue> CallMethod(string moduleID, string methodName, params NamedValue[] parameters) { JObject request = MakeSessionRequest(); request["moduleID"] = moduleID; request["methodName"] = methodName; request["parameters"] = new JRaw(StdJson.ObjectToString(parameters)); return(Post <DataValue>("CallMethod", request)); }
public override async Task <long> HistorianDeleteInterval(VariableRef variable, Timestamp startInclusive, Timestamp endInclusive) { JObject request = MakeSessionRequest(); request["variable"] = new JRaw(StdJson.ObjectToString(variable)); request["startInclusive"] = new JRaw(StdJson.ValueToString(startInclusive)); request["endInclusive"] = new JRaw(StdJson.ValueToString(endInclusive)); return(await Post <long>("HistorianDeleteInterval", request)); }
public override async Task <VTTQ?> HistorianGetLatestTimestampDB(VariableRef variable, Timestamp startInclusive, Timestamp endInclusive) { JObject request = MakeSessionRequest(); request["variable"] = new JRaw(StdJson.ObjectToString(variable)); request["startInclusive"] = new JRaw(StdJson.ValueToString(startInclusive)); request["endInclusive"] = new JRaw(StdJson.ValueToString(endInclusive)); return(await Post <VTTQ?>("HistorianGetLatestTimestampDB", request)); }
protected async Task ReadWebSocketForEvents(CancellationToken cancelToken, Action notifyConnectionBroken) { var buffer = new ArraySegment <byte>(new byte[8192]); var stream = new MemoryStream(8192); while (!cancelToken.IsCancellationRequested) { stream.Seek(0, SeekOrigin.Begin); WebSocketReceiveResult result = null; do { try { result = await webSocket.ReceiveAsync(buffer, cancelToken); } catch (Exception) { var t = CloseSocket(); // no need to wait for completion if (!cancelToken.IsCancellationRequested) { notifyConnectionBroken(); } listener.OnConnectionClosed(); return; } stream.Write(buffer.Array, buffer.Offset, result.Count); }while (!result.EndOfMessage); stream.Seek(0, SeekOrigin.Begin); if (result.MessageType == WebSocketMessageType.Text) { using (var reader = new StreamReader(stream, Encoding.UTF8, false, 1024, leaveOpen: true)) { JObject eventObj = StdJson.JObjectFromReader(reader); try { DispatchEvent(eventObj); } catch (Exception exp) { Exception exception = exp.GetBaseException() ?? exp; Console.Error.WriteLine("Exception in event dispatch: " + exception.Message); } } } else if (result.MessageType == WebSocketMessageType.Close) { await CloseSocket(); if (!cancelToken.IsCancellationRequested) { notifyConnectionBroken(); } listener.OnConnectionClosed(); return; } } }
public override async Task <MemberValue[]> GetMemberValues(MemberRef[] member) { if (member == null) { throw new ArgumentNullException(nameof(member)); } JObject request = MakeSessionRequest(); request["member"] = new JRaw(StdJson.ObjectToString(member)); return(await Post <MemberValue[]>("GetMemberValues", request)); }
public override async Task <MetaInfos> GetMetaInfos(string moduleID) { if (moduleID == null) { throw new ArgumentNullException(nameof(moduleID)); } JObject request = MakeSessionRequest(); request["moduleID"] = new JRaw(StdJson.ValueToString(moduleID)); return(await Post <MetaInfos>("GetMetaInfos", request)); }
public override Task <BrowseResult> BrowseObjectMemberValues(MemberRef member, int?continueID = null) { JObject request = MakeSessionRequest(); request["member"] = new JRaw(StdJson.ObjectToString(member)); if (continueID.HasValue) { request["continueID"] = new JRaw(StdJson.ValueToString(continueID.Value)); } return(Post <BrowseResult>("BrowseObjectMemberValues", request)); }
public override async Task <VTTQ[]> HistorianReadRaw(VariableRef variable, Timestamp startInclusive, Timestamp endInclusive, int maxValues, BoundingMethod bounding) { JObject request = MakeSessionRequest(); request["variable"] = new JRaw(StdJson.ObjectToString(variable)); request["startInclusive"] = new JRaw(StdJson.ValueToString(startInclusive)); request["endInclusive"] = new JRaw(StdJson.ValueToString(endInclusive)); request["maxValues"] = new JRaw(StdJson.ValueToString(maxValues)); request["bounding"] = new JRaw(StdJson.ValueToString(bounding)); return(await Post <VTTQ[]>("HistorianReadRaw", request)); }
public override async Task <VTQ[]> ReadVariables(VariableRef[] variables) { if (variables == null) { throw new ArgumentNullException(nameof(variables)); } JObject request = MakeSessionRequest(); request["variables"] = new JRaw(StdJson.ObjectToString(variables)); return(await Post <VTQ[]>("ReadVariables", request)); }