/// <summary>
/// Adds a Service-Tag to an existing service
/// </summary>
/// <param name="serviceSession">the service-session for which to add a tag</param>
/// <param name="tagName">the tag-key of the given value</param>
/// <param name="value">the tag-value</param>
public void AddServiceTag(ServiceSessionOperationMessage serviceSession, string tagName, string value)
{
if (GrabService(serviceSession.ServiceName, serviceSession.SessionTicket, true, out var service, out var operations, out var waitingMessages))
{
service.SetTag(tagName, value);
}
}
public override async Task ServiceReady(ServiceSessionOperationMessage request, IMemoryChannel channel, DataTransferContext context)
{
try
{
if (string.IsNullOrEmpty(request.ResponderFor))
{
CheckAuth(context, "ActAsService");
}
else
{
CheckAuth(context, "ConnectAnyService", request.ResponderFor);
}
await base.ServiceReady(request, channel, context);
}
catch (Exception ex)
{
LogEnvironment.LogEvent(ex.OutlineException(), LogSeverity.Error);
throw;
}
finally
{
TemporaryGrants.UnRegisterService(request.ServiceName);
if (!string.IsNullOrEmpty(request.ResponderFor))
{
TemporaryGrants.RevokeTemporaryPermission(request.ResponderFor, request.ServiceName);
}
}
}
public virtual Task <ServiceTickResponseMessage> ServiceTick(ServiceSessionOperationMessage request, DataTransferContext context)
{
var retRaw = serviceBackend.Broker.Tick(request);
return(Task.FromResult(new ServiceTickResponseMessage
{
Ok = retRaw.Ok,
PendingOperationsCount = retRaw.PendingOperationsCount,
Reason = retRaw.Reason
}));
}
public void ServiceTick(ServiceSessionOperationMessage session)
{
try
{
channel.Request(session).GetAwaiter().GetResult();
}
catch (Exception ex)
{
LogEnvironment.LogDebugEvent($"Error sending Tick: {ex.Message}", LogSeverity.Error);
}
}
public override Task <ServiceTickResponseMessage> ServiceTick(ServiceSessionOperationMessage request, ServerCallContext context)
{
var retRaw = serviceBackend.Broker.Tick(new MessagingShared.Hub.Protocol.ServiceSessionOperationMessage
{
ResponderFor = request.ResponderFor,
ServiceName = request.ServiceName,
SessionTicket = request.SessionTicket,
Ttl = request.Ttl,
Tick = true
});
return(Task.FromResult(new ServiceTickResponseMessage
{
Ok = retRaw.Ok,
PendingOperationsCount = retRaw.PendingOperationsCount,
Reason = retRaw.Reason ?? ""
}));
}
public override Task <ServiceTickResponseMessage> ServiceTick(ServiceSessionOperationMessage request, DataTransferContext context)
{
try
{
if (string.IsNullOrEmpty(request.ResponderFor))
{
CheckAuth(context, "ActAsService");
}
else
{
CheckAuth(context, "ConnectAnyService", request.ResponderFor);
}
return(base.ServiceTick(request, context));
}
catch (Exception ex)
{
return(Task.FromException <ServiceTickResponseMessage>(ex));
}
}
public void FailOperation(ServiceSessionOperationMessage serviceSession, string req, Exception ex)
{
if (req != null)
{
try
{
if (GrabService(serviceSession.ServiceName, serviceSession.SessionTicket, true, out var service, out var operations, out var waitingMessages))
{
if (waitingMessages.TryGetValue(req, out var rq))
{
rq.ServerResponse.SetException(ex);
}
}
}
catch (Exception x)
{
LogEnvironment.LogEvent($"Failed to set ServerResponse: {x.Message}", LogSeverity.Error);
}
}
}
public Task <ServerOperationMessage> NextRequest(ServiceSessionOperationMessage serviceSession)
{
if (GrabService(serviceSession.ServiceName, serviceSession.SessionTicket, true, out var service, out var operations, out var waitingMessages))
{
if (service.ServiceKind == ServiceStatus.ServiceType.Local)
{
throw new CommunicationException("Not used for local clients!");
}
Task <OperationWaitHandle> retTask = null;
lock (service)
{
if (operations.IsEmpty && service.OpenTaskWait == null)
{
retTask = (service.OpenTaskWait = new TaskCompletionSource <OperationWaitHandle>(TaskCreationOptions.RunContinuationsAsynchronously)).Task;
}
else if (!operations.IsEmpty && operations.TryDequeue(out var retVal))
{
retTask = Task.FromResult(retVal);
}
}
if (retTask != null)
{
return(retTask.ContinueWith((t, s) =>
{
if (t.Result != null && !t.Result.ClientRequest.TickBack)
{
waitingMessages.TryAdd(t.Result.ClientRequest.OperationId, t.Result);
}
return t.Result?.ClientRequest;
}, null, TaskContinuationOptions.None));
}
//return retTask;
}
throw new CommunicationException("Unknown Service-grab - Error");
}
public override async Task ServiceReady(ServiceSessionOperationMessage request, IServerStreamWriter <ServerOperationMessage> responseStream, ServerCallContext context)
{
CancellationToken cancellationToken = context.CancellationToken;
var req = new MessagingShared.Hub.Protocol.ServiceSessionOperationMessage
{
ResponderFor = request.ResponderFor ?? "",
SessionTicket = request.SessionTicket ?? "",
Ttl = request.Ttl,
ServiceName = request.ServiceName ?? "",
Tick = false
};
try
{
do
{
try
{
var nextMessage = await serviceBackend.Broker.NextRequest(req);
if (nextMessage != null)
{
await responseStream.WriteAsync(new ServerOperationMessage
{
HubUser = nextMessage.HubUser ?? "",
OperationId = nextMessage.OperationId ?? "",
OperationPayload = nextMessage.OperationPayload ?? "",
TargetService = nextMessage.TargetService ?? "",
TickBack = nextMessage.TickBack
}).ConfigureAwait(false);
}
else
{
await Task.Delay(500, cancellationToken).ConfigureAwait(false);
}
}
catch (ServiceBrokenException sbe)
{
LogEnvironment.LogEvent($"Error occurred: {sbe.Message}", LogSeverity.Error);
break;
}
catch (ServiceTimeoutException ste)
{
LogEnvironment.LogEvent($"Error occurred: {ste.Message}", LogSeverity.Error);
break;
}
catch (ServiceUnknownException sue)
{
LogEnvironment.LogEvent($"Error occurred: {sue.Message}", LogSeverity.Error);
break;
}
catch (Exception ex)
{
LogEnvironment.LogEvent($"Error occurred: {ex.OutlineException()}", LogSeverity.Error);
}
} while (cancellationToken.IsCancellationRequested == false);
}
finally
{
serviceBackend.Broker.TryUnRegisterService(req);
}
}
/// <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 async Task ServiceReady(ServiceSessionOperationMessage request, IMemoryChannel channel, DataTransferContext context)
{
CancellationToken cancellationToken = channel.CancellationToken;
try
{
serviceBackend.Broker.AddServiceTag(request, "ChannelName", channel.Name);
do
{
string req = null;
try
{
var nextMessage = await serviceBackend.Broker.NextRequest(request);
req = nextMessage.OperationId;
if (nextMessage != null)
{
await channel.WriteAsync(new ServerOperationMessage
{
HubUser = nextMessage.HubUser,
OperationId = nextMessage.OperationId,
OperationPayload = nextMessage.OperationPayload,
TargetService = nextMessage.TargetService,
TickBack = nextMessage.TickBack
}).ConfigureAwait(false);
}
else
{
await Task.Delay(500, cancellationToken).ConfigureAwait(false);
}
}
catch (ServiceBrokenException sbe)
{
serviceBackend.Broker.FailOperation(request, req, sbe);
LogEnvironment.LogEvent($"Error occurred: {sbe.Message}", LogSeverity.Error);
break;
}
catch (ServiceTimeoutException ste)
{
serviceBackend.Broker.FailOperation(request, req, ste);
LogEnvironment.LogEvent($"Error occurred: {ste.Message}", LogSeverity.Error);
break;
}
catch (ServiceUnknownException sue)
{
serviceBackend.Broker.FailOperation(request, req, sue);
LogEnvironment.LogEvent($"Error occurred: {sue.Message}", LogSeverity.Error);
break;
}
catch (Exception ex)
{
serviceBackend.Broker.FailOperation(request, req, ex);
LogEnvironment.LogEvent($"Error occurred: {ex.OutlineException()}", LogSeverity.Error);
}
} while (cancellationToken.IsCancellationRequested == false);
}
finally
{
serviceBackend.Broker.TryUnRegisterService(request);
}
}
public void ServiceReady(ServiceSessionOperationMessage session)
{
channel.Write(session);
}
/// <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}");
}
}
}
