public virtual Task <RegisterServiceResponseMessage> RegisterService(RegisterServiceMessage request, DataTransferContext context)
{
LogEnvironment.LogDebugEvent("Registering Service...", LogSeverity.Report);
var retRaw = serviceBackend.Broker.RegisterService(request);
return(Task.FromResult(retRaw));
}
public override Task <RegisterServiceResponseMessage> RegisterService(RegisterServiceMessage request, DataTransferContext context)
{
try
{
if (string.IsNullOrEmpty(request.ResponderFor))
{
CheckAuth(context, "ActAsService");
TemporaryGrants.RegisterService(request.ServiceName, context.Identity.Name);
}
else
{
CheckAuth(context, "ConnectAnyService", request.ResponderFor);
TemporaryGrants.GrantTemporaryPermission(request.ResponderFor, request.ServiceName);
}
return(base.RegisterService(request, context));
}
catch (Exception ex)
{
LogEnvironment.LogEvent(ex.OutlineException(), LogSeverity.Error);
return(Task.FromResult(new RegisterServiceResponseMessage {
Ok = false, Reason = ex.Message
}));
}
}
public override Task <RegisterServiceResponseMessage> RegisterService(RegisterServiceMessage request, ServerCallContext context)
{
var retRaw = serviceBackend.Broker.RegisterService(new MessagingShared.Hub.Protocol.RegisterServiceMessage
{
ResponderFor = request.ResponderFor,
ServiceName = request.ServiceName,
Ttl = request.Ttl
});
var ret = new RegisterServiceResponseMessage
{
Ok = retRaw.Ok,
Reason = retRaw.Reason ?? "",
SessionTicket = retRaw.SessionTicket ?? ""
};
return(Task.FromResult(ret));
}
/// <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 RegisterServiceResponseMessage RegisterService(RegisterServiceMessage registration)
{
lock (registrationLock)
{
try
{
if (GrabService(registration.ServiceName, null, false, out var service, out var operations, out var waitingMessages))
{
return(new RegisterServiceResponseMessage
{
Reason = "Service is already registered!",
Ok = false
});
}
var newSvc = new ServiceStatus
{
LastPing = DateTime.Now,
Ttl = registration.Ttl,
ServiceName = registration.ServiceName,
RegistrationTicket = $"{registration.ServiceName}_{DateTime.Now.Ticks}_{rnd.Next(10000000)}",
ServiceKind = ServiceStatus.ServiceType.InterProcess
};
StringBuilder fmsg = new StringBuilder();
bool ok = services.TryAdd(registration.ServiceName, newSvc);
if (!ok)
{
fmsg.Append(@"Service-Entry could not be added.
");
}
ok = ok && openWaitHandles.TryAdd(registration.ServiceName, new ConcurrentDictionary <string, OperationWaitHandle>());
if (!ok)
{
fmsg.Append(@"OpenWait-Entry could not be added.
");
}
ok = ok && messages.TryAdd(registration.ServiceName, new ConcurrentQueue <OperationWaitHandle>());
if (!ok)
{
fmsg.Append(@"OpenMsg-Entry could not be added.
");
}
var retVal = new RegisterServiceResponseMessage
{
SessionTicket = newSvc.RegistrationTicket,
Ok = ok,
Reason = ok ? "" : fmsg.ToString()
};
if (!ok)
{
UnsafeServerDrop(registration.ServiceName);
}
return(retVal);
}
catch (Exception ex)
{
return(new RegisterServiceResponseMessage
{
Ok = false,
Reason = ex.Message
});
}
}
}
public RegisterServiceResponseMessage RegisterService(RegisterServiceMessage mySvc)
{
var ret = channel.Request(mySvc).ConfigureAwait(false).GetAwaiter().GetResult();
return((RegisterServiceResponseMessage)(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}");
}
}
}
