public async Task <byte> Send(IMessage message, bool ignoreConnected = false)
{
if (!ignoreConnected && !IsConnected)
{
throw new Exception("Roflkopter 2");
}
Debug.WriteLine("Sende nun einen normalen Request");
Debug.WriteLine("------------------------------------------------------------------------------------");
TunnelRequest req = new TunnelRequest();
req.Type = TunnelTypes.Tunnel;
req.ConnId = _connId;
req.Data = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message, new JsonSerializerSettings()
{
TypeNameHandling = TypeNameHandling.All
}));
IRemoteMessage resp = await _conn.Send(req);
if (resp is TunnelResponse)
{
return((resp as TunnelResponse).Data[0]);
}
return(0);
}
private async void _conn_OnRequest(IRemoteMessage message)
{
if (message is TunnelRequest)
{
TunnelRequest req = message as TunnelRequest;
if (req.ConnId != 0 && req.ConnId != _connId)
{
return;
}
switch (req.Type)
{
case TunnelTypes.Tunnel:
IMessage msg = (IMessage)JsonConvert.DeserializeObject(Encoding.UTF8.GetString(req.Data), new JsonSerializerSettings()
{
TypeNameHandling = TypeNameHandling.Auto
});
Debug.WriteLine("Tunnel: " + msg);
byte seq = await _knxConn.Send(msg);
TunnelResponse req2 = new TunnelResponse(new byte[] { seq });
req2.Type = TunnelTypes.Response;
req2.ConnId = req.ConnId;
req2.SequenceNumber = req.SequenceNumber;
_ = _conn.Send(req2, false);
break;
}
}
}
public async Task Connect()
{
Debug.WriteLine(DateTime.Now);
TunnelRequest req = new TunnelRequest(Encoding.UTF8.GetBytes(Hash));
req.Type = TunnelTypes.Connect;
IRemoteMessage resp = await _conn.Send(req);
if (resp == null)
{
throw new Exception("Keine Antwort vom Remote Server");
}
TunnelResponse response = resp as TunnelResponse;
if (response == null)
{
throw new Exception("Unerwartete Antwort vom Remote Server: " + response.ToString());
}
IsConnected = true;
_connId = response.ConnId;
Debug.WriteLine(DateTime.Now);
Debug.WriteLine("Verbunden");
}
/// <summary>
/// Called by the remote manager to process messages received from the java bridge.
/// </summary>
/// <param name="message">A byte buffer containing a serialzied message.</param>
public void OnNext(IRemoteMessage <byte[]> message)
{
Logger.Log(Level.Verbose, "Message received: {0}", message.Identifier);
// Deserialize the message and invoke the appropriate handler.
_serializer.Read(message.Message, _fMessageObserver.Get());
}
/// <summary>
/// Receives and routes heartbeats from Evaluators.
/// </summary>
/// <param name="evaluatorHearBeatProto"></param>
private void Handle(IRemoteMessage <EvaluatorHeartbeatProto> evaluatorHearBeatProto)
{
EvaluatorHeartbeatProto heartbeat = evaluatorHearBeatProto.Message;
EvaluatorStatusProto status = heartbeat.evaluator_status;
string evaluatorId = status.evaluator_id;
LOGGER.Log(Level.Info, string.Format(CultureInfo.InvariantCulture, "Heartbeat from Evaluator {0} with state {1} timestamp {2}", evaluatorId, status.state, heartbeat.timestamp));
_sanityChecker.check(evaluatorId, heartbeat.timestamp);
lock (_evaluators)
{
if (_evaluators.ContainsKey(evaluatorId))
{
EvaluatorManager evaluatorManager = _evaluators[evaluatorId];
evaluatorManager.Handle(evaluatorHearBeatProto);
}
else
{
string msg = "Contact from unkonwn evaluator with id: " + evaluatorId;
if (heartbeat.evaluator_status != null)
{
msg += " with state" + status.state;
}
LOGGER.Log(Level.Error, msg);
Exceptions.Throw(new InvalidOperationException(msg), LOGGER);
}
}
}
public async Task Connect(string host, string auth, bool isSecure, string group = null, string code = null)
{
Hostname = host;
Authentification = auth;
State = "Verbinde...";
IsActive = true;
try
{
socket = new ClientWebSocket();
socket.Options.AddSubProtocol("chat");
await socket.ConnectAsync(new Uri((isSecure ? "wss://":"ws://") + host), source.Token);
int seq = SequenceNumber++;
AuthRequest msg = new AuthRequest(auth, seq, group, code);
ReceiveTokenSource = new CancellationTokenSource();
ProcessReceivingMessages();
await socket.SendAsync(msg.GetBytes(), WebSocketMessageType.Binary, true, source.Token);
IRemoteMessage resp = await WaitForResponse(seq);
if (resp is StateResponse)
{
StateResponse response = (StateResponse)resp;
switch (response.Code)
{
case StateCodes.WrongKey:
throw new Exception("Authentifizierung am Server fehlgeschlagen");
case StateCodes.GroupNotFound:
throw new Exception("Angegebene Gruppe ist nicht auf dem Server vorhanden");
case StateCodes.WrongGroupKey:
throw new Exception("Authentifizierung in der Gruppe fehlgeschlagen");
}
}
else if (resp is AuthResponse)
{
AuthResponse response = (AuthResponse)resp;
Group = response.Group;
State = "Verbunden (" + Group + ")";
}
else
{
throw new Exception("Ungültige Antwort erhalten: " + resp.GetType().ToString());
}
} catch (Exception ex)
{
State = ex.Message;
IsActive = false;
IsConnected = false;
}
}
public async Task <IRemoteMessage> Send(IRemoteMessage message, bool waitForResponse = true)
{
if (socket == null || socket.State != WebSocketState.Open)
{
return(null);
}
IRemoteMessage mesg = null;
try
{
if (message.SequenceNumber == -1)
{
message.SequenceNumber = SequenceNumber++;
}
if (message is TunnelRequest)
{
TunnelRequest req = message as TunnelRequest;
if (req.ChannelId == 0)
{
req.ChannelId = Remotes[req.ConnId].ChannelId;
}
if (req.Group == "")
{
req.Group = Remotes[req.ConnId].Group;
}
}
if (message is TunnelResponse)
{
TunnelResponse res = message as TunnelResponse;
if (res.ChannelId == 0)
{
res.ChannelId = Remotes[res.ConnId].ChannelId;
}
if (res.Group == "")
{
res.Group = Remotes[res.ConnId].Group;
}
}
await socket.SendAsync(message.GetBytes(), WebSocketMessageType.Binary, true, source.Token);
mesg = await WaitForResponse(message.SequenceNumber);
}catch (Exception ex)
{
}
return(mesg);
}
/// <summary>
/// On the first message, we map the <see cref="TaskMessageObserver"/> to the <see cref="IPEndPoint"/>
/// of the sending Task and register the observer with <see cref="IRemoteManager{T}"/>
/// by calling <see cref="TaskMessageObserver#OnNext"/>. On subsequent messages we simply ignore the message
/// and allow <see cref="ObserverContainer{T}"/> to send the message directly via the <see cref="IPEndPoint"/>.
/// </summary>
/// <param name="remoteMessage"></param>
public void OnNext(IRemoteMessage <NsMessage <GeneralGroupCommunicationMessage> > remoteMessage)
{
var nsMessage = remoteMessage.Message;
var gcm = nsMessage.Data.First();
var gcMessageTaskSource = gcm.Source;
TaskMessageObserver observer;
if (!_taskMessageObservers.TryGetValue(gcMessageTaskSource, out observer))
{
throw new KeyNotFoundException("Unable to find registered NodeMessageObserver for source Task " +
gcMessageTaskSource + ".");
}
_registeredNodes.GetOrAdd(gcMessageTaskSource,
id =>
{
observer.OnNext(remoteMessage);
return(new byte());
});
}
/// <summary>
/// This is called from the universal observer in ObserverContainer for the first message.
/// </summary>
public void OnNext(IRemoteMessage <NsMessage <GeneralGroupCommunicationMessage> > value)
{
// Lock to prevent duplication of messages.
lock (_registrationLock)
{
if (_hasRegistered)
{
return;
}
var socketRemoteId = value.Identifier as SocketRemoteIdentifier;
if (socketRemoteId == null)
{
throw new InvalidOperationException();
}
// Handle the message first, then register the observer.
Handle(value.Message, true);
_networkService.RemoteManager.RegisterObserver(socketRemoteId.Addr, this);
_hasRegistered = true;
}
}
public void Handle(IRemoteMessage <EvaluatorHeartbeatProto> evaluatorHearBeatProtoMessage)
{
lock (_evaluatorDescriptor)
{
EvaluatorHeartbeatProto heartbeatProto = evaluatorHearBeatProtoMessage.Message;
if (heartbeatProto.evaluator_status != null)
{
EvaluatorStatusProto status = heartbeatProto.evaluator_status;
if (status.error != null)
{
Handle(new EvaluatorException(Id, ByteUtilities.ByteArrarysToString(status.error)));
return;
}
else if (_state == STATE.SUBMITTED)
{
string evaluatorRId = evaluatorHearBeatProtoMessage.Identifier.ToString();
LOGGER.Log(Level.Info, "TODO: REPLACE THIS " + evaluatorRId);
// TODO
// _evaluatorControlHandler = _remoteManager.getHandler(evaluatorRID, EvaluatorRuntimeProtocol.EvaluatorControlProto.class);
_state = STATE.RUNNING;
LOGGER.Log(Level.Info, string.Format(CultureInfo.InvariantCulture, "Evaluator {0} is running", _evaluatorId));
}
}
LOGGER.Log(Level.Info, "Evaluator heartbeat: " + heartbeatProto);
EvaluatorStatusProto evaluatorStatusProto = heartbeatProto.evaluator_status;
foreach (ContextStatusProto contextStatusProto in heartbeatProto.context_status)
{
Handle(contextStatusProto, heartbeatProto.task_status != null);
}
if (heartbeatProto.task_status != null)
{
Handle(heartbeatProto.task_status);
}
if (evaluatorStatusProto.state == State.FAILED)
{
_state = STATE.FAILED;
EvaluatorException e = evaluatorStatusProto.error != null ?
new EvaluatorException(_evaluatorId, ByteUtilities.ByteArrarysToString(evaluatorStatusProto.error)) :
new EvaluatorException(_evaluatorId, "unknown cause");
LOGGER.Log(Level.Warning, "Failed evaluator: " + Id + e.Message);
Handle(e);
}
else if (evaluatorStatusProto.state == State.DONE)
{
LOGGER.Log(Level.Info, string.Format(CultureInfo.InvariantCulture, "Evaluator {0} done", Id));
_state = STATE.DONE;
// TODO
// dispatcher.onNext(CompletedEvaluator.class, new CompletedEvaluator() {
//@Override
//public String getId() {
// return EvaluatorManager.this.evaluatorId;
Dispose();
}
}
LOGGER.Log(Level.Info, "DONE with evaluator heartbeat");
}
private void ProcessReceivingMessages()
{
Task.Run(async() =>
{
while (socket.State == WebSocketState.Open)
{
ArraySegment <byte> buffer;
WebSocketReceiveResult result = null;
try
{
buffer = new ArraySegment <byte>(new byte[1024]);
result = await socket.ReceiveAsync(buffer, ReceiveTokenSource.Token);
}
catch (Exception ex)
{
socket = null;
IsActive = false;
IsConnected = false;
return;
}
if (result == null || result.Count == 0)
{
continue;
}
Kaenx.Konnect.Remote.MessageCodes code = (Konnect.Remote.MessageCodes)buffer.Array[0];
Debug.WriteLine("Got Remote Message: " + code);
//Check if assemby from this genügt
var q = from t in Assembly.LoadFrom("Kaenx.Konnect.dll").GetTypes()
where t.IsClass && t.IsNested == false && t.Namespace == "Kaenx.Konnect.Remote"
select t;
IRemoteMessage message = null;
foreach (Type t in q.ToList())
{
IRemoteMessage down = (IRemoteMessage)Activator.CreateInstance(t);
if (down != null && code == down.MessageCode)
{
message = down;
break;
}
}
if (message == null)
{
Debug.WriteLine("Unbekannte Nachricht: " + code);
}
try
{
message.Parse(buffer.Array.Take(result.Count).ToArray());
}
catch (Exception ex)
{
}
if (message is TunnelRequest && (message as TunnelRequest).Type == TunnelTypes.Connect)
{
TunnelRequest req = message as TunnelRequest;
KnxRemote rem = new KnxRemote(Encoding.UTF8.GetString(req.Data), this);
await rem.Init(getUsbHandler);
int connId = await rem.ConnectToInterface(req);
Remotes.Add(connId, rem);
continue;
}
if (message.ToString().EndsWith("Response"))
{
Responses[message.SequenceNumber] = message;
OnResponse?.Invoke(message);
}
else
{
OnRequest?.Invoke(message);
}
}
Debug.WriteLine("Verbindung abgebrochen");
});
}
public void OnNext(IRemoteMessage <REEFMessage> value)
{
REEFMessage remoteEvent = value.Message;
IRemoteIdentifier id = value.Identifier;
LOGGER.Log(Level.Info, string.Format(CultureInfo.InvariantCulture, "receive a ReefMessage from {0} Driver at {1}.", remoteEvent, id));
if (remoteEvent.evaluatorControl != null)
{
if (remoteEvent.evaluatorControl.context_control != null)
{
string context_message = null;
string task_message = null;
if (remoteEvent.evaluatorControl.context_control.context_message != null)
{
context_message = remoteEvent.evaluatorControl.context_control.context_message.ToString();
}
if (remoteEvent.evaluatorControl.context_control.task_message != null)
{
task_message = ByteUtilities.ByteArrarysToString(remoteEvent.evaluatorControl.context_control.task_message);
}
if (!(string.IsNullOrEmpty(context_message) && string.IsNullOrEmpty(task_message)))
{
LOGGER.Log(Level.Info,
string.Format(CultureInfo.InvariantCulture, "Control protobuf with context message [{0}] and task message [{1}]", context_message, task_message));
}
else if (remoteEvent.evaluatorControl.context_control.remove_context != null)
{
LOGGER.Log(Level.Info,
string.Format(CultureInfo.InvariantCulture, "Control protobuf to remove context {0}", remoteEvent.evaluatorControl.context_control.remove_context.context_id));
}
else if (remoteEvent.evaluatorControl.context_control.add_context != null)
{
LOGGER.Log(Level.Info,
string.Format(CultureInfo.InvariantCulture, "Control protobuf to add a context on top of {0}", remoteEvent.evaluatorControl.context_control.add_context.parent_context_id));
}
else if (remoteEvent.evaluatorControl.context_control.start_task != null)
{
LOGGER.Log(Level.Info,
string.Format(CultureInfo.InvariantCulture, "Control protobuf to start an task in {0}", remoteEvent.evaluatorControl.context_control.start_task.context_id));
}
else if (remoteEvent.evaluatorControl.context_control.stop_task != null)
{
LOGGER.Log(Level.Info, "Control protobuf to stop task");
}
else if (remoteEvent.evaluatorControl.context_control.suspend_task != null)
{
LOGGER.Log(Level.Info, "Control protobuf to suspend task");
}
}
}
if (_count == 0)
{
_begin = DateTime.Now;
_origBegin = _begin;
}
var count = Interlocked.Increment(ref _count);
int printBatchSize = 100000;
if (count % printBatchSize == 0)
{
DateTime end = DateTime.Now;
var diff = (end - _begin).TotalMilliseconds;
double seconds = diff / 1000.0;
long eventsPerSecond = (long)(printBatchSize / seconds);
_begin = DateTime.Now;
}
var observer = _observer;
if (observer != null)
{
observer.OnNext(value);
}
}
