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));
}
