/// <summary>
/// Processes a message that was received from a remote client
/// </summary>
/// <param name="message">the message that was received from the remote host</param>
/// <returns>a response message that was generated as result of the received message</returns>
public ServiceOperationResponseMessage ProcessMessage(ServerOperationMessage message)
{
var msg = new MessageArrivedEventArgs
{
TargetService = message.TargetService,
Message = message.OperationPayload
};
if (!string.IsNullOrEmpty(message.HubUser))
{
msg.HubUser = JsonHelper.FromJsonStringStrongTyped <TransferIdentity>(message.HubUser).ToIdentity(serverSecurity);
}
OnMessageArrived(msg);
ServiceOperationResponseMessage ret;
if (msg.Completed)
{
if (msg.Error == null)
{
ret = new ServiceOperationResponseMessage
{
OperationId = message.OperationId,
ResponsePayload = msg.Response,
TargetService = message.TargetService,
Ok = true
};
}
else
{
ret = new ServiceOperationResponseMessage
{
OperationId = message.OperationId,
ResponsePayload = JsonHelper.ToJsonStrongTyped(msg.Error, true),
TargetService = message.TargetService,
Ok = false
};
}
}
else
{
ret = new ServiceOperationResponseMessage
{
OperationId = message.OperationId,
TargetService = message.TargetService,
ResponsePayload = JsonHelper.ToJsonStrongTyped(new SerializedException("Message was not processed!", new SerializedException[0]), true),
Ok = false
};
}
if (!string.IsNullOrEmpty(consumedService))
{
ret.ResponderFor = consumedService;
}
return(ret);
}
public override Task <Empty> CommitServiceOperation(ServiceOperationResponseMessage request, ServerCallContext context)
{
serviceBackend.Broker.CommitServerOperation(new MessagingShared.Hub.Protocol.ServiceOperationResponseMessage
{
Ok = request.Ok,
OperationId = request.OperationId,
ResponderFor = request.ResponderFor,
ResponsePayload = request.ResponsePayload,
TargetService = request.TargetService
});
return(Task.FromResult(new Empty()));
}
public void CommitServerOperation(ServiceOperationResponseMessage response)
{
if (GrabService(response.TargetService, null, true, out var service, out var operations, out var waitingMessages))
{
if (service != null && service.ServiceKind == ServiceStatus.ServiceType.Local)
{
throw new CommunicationException("Not used for local clients!");
}
if (waitingMessages.TryRemove(response.OperationId, out var waitHandle))
{
waitHandle.ServerResponse.SetResult(response);
}
else
{
throw new CommunicationException("The given operation is not open.");
}
}
}
public override Task CommitServiceOperation(ServiceOperationResponseMessage request, DataTransferContext context)
{
try
{
if (string.IsNullOrEmpty(request.ResponderFor))
{
CheckAuth(context, "ActAsService");
}
else
{
CheckAuth(context, "ConnectAnyService", request.ResponderFor);
}
return(base.CommitServiceOperation(request, context));
}
catch (Exception ex)
{
return(Task.FromException(ex));
}
}
/// <summary>
/// Initializes the hubconnection with the remote hub
/// </summary>
private void InitHubConnection()
{
rnd = new Random();
client = factory.CreateClient(serviceAddr, channel);
client.Broken += ClientBroken;
ServiceName = myServiceName;
if (!string.IsNullOrEmpty(ServiceName))
{
mySvc = new RegisterServiceMessage {
ServiceName = ServiceName, Ttl = 15
};
if (!string.IsNullOrEmpty(consumedService))
{
mySvc.ResponderFor = consumedService;
}
var reg = client.RegisterService(mySvc);
if (reg.Ok)
{
session = new ServiceSessionOperationMessage {
ServiceName = mySvc.ServiceName, SessionTicket = reg.SessionTicket, Ttl = mySvc.Ttl
};
if (!string.IsNullOrEmpty(consumedService))
{
session.ResponderFor = consumedService;
}
tickTimer.Change(0, TickPeriod);
serverCallbackCancel = new CancellationTokenSource();
var token = serverCallbackCancel.Token;
Task.Run(async() =>
{
var cancelR = token;
try
{
client.ServiceReady(session);
LogEnvironment.LogDebugEvent("Service is ready!", LogSeverity.Report);
while (await channel.MoveNext().ConfigureAwait(false))
{
var c = channel.Current;
LogEnvironment.LogDebugEvent(
$"TargetService: {c.TargetService}, TickBack: {c.TickBack}, Id: {c.OperationId}",
LogSeverity.Report);
if (!c.TickBack)
{
var msg = new MessageArrivedEventArgs
{
Message = c.OperationPayload,
TargetService = c.TargetService
};
if (!string.IsNullOrEmpty(c.HubUser))
{
msg.HubUser = JsonHelper.FromJsonStringStrongTyped <TransferIdentity>(c.HubUser)
.ToIdentity(customServerSecurity);
}
OnMessageArrived(msg);
ServiceOperationResponseMessage ret;
if (msg.Completed)
{
if (msg.Error == null)
{
ret = new ServiceOperationResponseMessage
{
OperationId = c.OperationId,
ResponsePayload = msg.Response,
TargetService = c.TargetService,
Ok = true
};
}
else
{
ret = new ServiceOperationResponseMessage
{
OperationId = c.OperationId,
ResponsePayload = JsonHelper.ToJsonStrongTyped(msg.Error, true),
TargetService = c.TargetService,
Ok = false
};
}
}
else
{
ret = new ServiceOperationResponseMessage
{
OperationId = c.OperationId,
TargetService = c.TargetService,
ResponsePayload = JsonHelper.ToJsonStrongTyped(
new SerializedException("Message was not processed!",
new SerializedException[0]), true),
Ok = false
};
}
if (!string.IsNullOrEmpty(consumedService))
{
ret.ResponderFor = consumedService;
}
client.CommitServiceOperation(ret);
}
else
{
LogEnvironment.LogDebugEvent("TickBack from Hub!", LogSeverity.Report);
}
}
}
catch (IOException ex)
{
LogEnvironment.LogDebugEvent(
$"Connection has gone... {ex.Message}, {ex.GetType().FullName}", LogSeverity.Warning);
}
catch (CommunicationException ex)
{
LogEnvironment.LogDebugEvent($"Connection has gone... {ex.Message}", LogSeverity.Warning);
}
catch (Exception ex)
{
LogEnvironment.LogEvent($"Unexpected Error: {ex.OutlineException()}", LogSeverity.Error);
}
finally
{
if (!disposing)
{
LostConnection();
}
}
}, token);
}
else
{
ServiceName = null;
throw new Exception($"Unable to register Service: {reg.Reason}");
}
}
}
public virtual Task CommitServiceOperation(ServiceOperationResponseMessage request, DataTransferContext context)
{
serviceBackend.Broker.CommitServerOperation(request);
return(Task.CompletedTask);
}
public void CommitServiceOperation(ServiceOperationResponseMessage ret)
{
channel.Write(ret);
}
/// <summary>
/// Initializes the hubconnection with the remote hub
/// </summary>
private void InitHubConnection()
{
AppContext.SetSwitch(
"System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);
rnd = new Random();
GrpcChannelOptions options = new GrpcChannelOptions();
configurator.ConfigureChannel(options);
channel = GrpcChannel.ForAddress(serviceAddr, options);
client = new ServiceHub.ServiceHubClient(channel);
ServiceName = myServiceName;
if (!string.IsNullOrEmpty(ServiceName))
{
mySvc = new RegisterServiceMessage {
ServiceName = ServiceName, Ttl = 15
};
if (!string.IsNullOrEmpty(consumedService))
{
mySvc.ResponderFor = consumedService;
}
var reg = client.RegisterService(mySvc);
if (reg.Ok)
{
session = new ServiceSessionOperationMessage {
ServiceName = mySvc.ServiceName, SessionTicket = reg.SessionTicket, Ttl = mySvc.Ttl
};
if (!string.IsNullOrEmpty(consumedService))
{
session.ResponderFor = consumedService;
}
tickTimer.Change(0, TickPeriod);
serverCallbackCancel = new CancellationTokenSource();
var token = serverCallbackCancel.Token;
Task.Run(async() =>
{
var cancelR = token;
var en = client.ServiceReady(session, new CallOptions(cancellationToken: cancelR));
try
{
while (await en.ResponseStream.MoveNext())
{
var c = en.ResponseStream.Current;
if (!c.TickBack)
{
var msg = new MessageArrivedEventArgs
{
Message = c.OperationPayload,
TargetService = c.TargetService
};
if (!string.IsNullOrEmpty(c.HubUser))
{
msg.HubUser = JsonHelper.FromJsonStringStrongTyped <TransferIdentity>(c.HubUser).ToIdentity(customServerSecurity);
}
OnMessageArrived(msg);
ServiceOperationResponseMessage ret;
if (msg.Completed)
{
if (msg.Error == null)
{
ret = new ServiceOperationResponseMessage
{
OperationId = c.OperationId,
ResponsePayload = msg.Response,
TargetService = c.TargetService,
Ok = true
};
}
else
{
ret = new ServiceOperationResponseMessage
{
OperationId = c.OperationId,
ResponsePayload = JsonHelper.ToJsonStrongTyped(msg.Error, true),
TargetService = c.TargetService,
Ok = false
};
}
}
else
{
ret = new ServiceOperationResponseMessage
{
OperationId = c.OperationId,
TargetService = c.TargetService,
ResponsePayload = JsonHelper.ToJsonStrongTyped(new SerializedException("Message was not processed!", new SerializedException[0]), true),
Ok = false
};
}
if (!string.IsNullOrEmpty(consumedService))
{
ret.ResponderFor = consumedService;
}
client.CommitServiceOperation(ret);
}
else
{
LogEnvironment.LogDebugEvent("TickBack from Hub!", LogSeverity.Report);
}
}
}
catch (IOException ex)
{
LogEnvironment.LogDebugEvent($"Connection has gone... {ex.Message}, {ex.GetType().FullName}", LogSeverity.Warning);
if (!disposing)
{
LostConnection();
}
}
catch (RpcException ex)
{
LogEnvironment.LogDebugEvent($"Connection has gone... {ex.Message}", LogSeverity.Warning);
if (!disposing)
{
LostConnection();
}
}
}, token);
}
else
{
ServiceName = null;
throw new Exception($"Unable to register Service: {reg.Reason}");
}
}
}
