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 override Task <ServiceDiscoverResponseMessage> DiscoverService(ServiceDiscoverMessage request, DataTransferContext context)
{
try
{
CheckAuth(context, "ConnectAnyService", request.TargetService);
return(base.DiscoverService(request, context));
}
catch (Exception ex)
{
return(Task.FromResult(new ServiceDiscoverResponseMessage {
Ok = false, Reason = ex.Message, TargetService = request.TargetService
}));
}
}
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 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));
}
}
public override Task <ServiceOperationResponseMessage> ConsumeService(ServerOperationMessage request, DataTransferContext context)
{
try
{
CheckAuth(context, "ConnectAnyService", request.TargetService);
request.HubUser = JsonHelper.ToJsonStrongTyped(((ClaimsIdentity)context.Identity).ForTransfer());
return(base.ConsumeService(request, context));
}
catch (Exception ex)
{
return(Task.FromException <ServiceOperationResponseMessage>(ex));
}
}
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);
}
}
/// <summary>
///
/// </summary>
/// <param name="context"></param>
public DataTransferContextException(DataTransferContext context)
{
this.Context = context;
this.Text = this.Context.GetText();
}
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 virtual Task <ServiceDiscoverResponseMessage> DiscoverService(ServiceDiscoverMessage request, DataTransferContext context)
{
var retRaw = serviceBackend.Broker.DiscoverService(request);
return(Task.FromResult(retRaw));
}
public virtual async Task <ServiceOperationResponseMessage> ConsumeService(ServerOperationMessage request, DataTransferContext context)
{
//context.GetHttpContext().RequestServices.VerifyUserPermissions()
var retRaw = await serviceBackend.Broker.SendMessageToServer(request);
return(retRaw);
}
public virtual Task CommitServiceOperation(ServiceOperationResponseMessage request, DataTransferContext context)
{
serviceBackend.Broker.CommitServerOperation(request);
return(Task.CompletedTask);
}
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
}));
}
