public override Task <IpAddressResponse> GetClientIpAddress(Empty request, ServerCallContext context) { return(Task.FromResult(new IpAddressResponse { IpAddress = context?.GetHttpContext()?.Connection?.RemoteIpAddress?.ToString() ?? "" })); }
public override async Task <UpdateReply> Update(UpdateRequest request, ServerCallContext context) { try { Comment c = await commentsService.UpdateAsync(new Comment { Id = request.Id, Subject = request.Subject, Body = request.Body }); return(new UpdateReply() { Id = c.Id, PhotoId = c.PhotoId, Subject = c.Subject, UserName = c.UserName, Body = c.Body, SubmittedOn = Google.Protobuf.WellKnownTypes.Timestamp.FromDateTime(c.SubmittedOn.ToUniversalTime()) }); } catch (UnauthorizedEditAttemptException <Comment> ) { //found on https://docs.microsoft.com/en-us/dotnet/architecture/grpc-for-wcf-developers/error-handling var user = context.GetHttpContext().User; var metadata = new Metadata { { "User", user.Identity.Name } }; throw new RpcException(new Status(StatusCode.PermissionDenied, "Permission denied"), metadata); } }
private async Task <TResponse> ResolvedInterceptorInvoker(TRequest resolvedRequest, ServerCallContext resolvedContext) { GrpcActivatorHandle <TService> serviceHandle = default; try { serviceHandle = ServiceActivator.Create(resolvedContext.GetHttpContext().RequestServices); return(await _invoker(serviceHandle.Instance, resolvedRequest, resolvedContext)); } finally { if (serviceHandle.Instance != null) { await ServiceActivator.ReleaseAsync(serviceHandle); } } }
public override async Task <Empty> Accept(AcceptRequest request, ServerCallContext context) { var user = context.GetHttpContext().User; if (!await _authorizationProvider.CheckAccessAsync(user, AcceptOperation, context.CancellationToken).ConfigureAwait(false)) { throw RpcExceptions.AccessDenied(); } _bus.Publish(new ElectionMessage.Accept( Uuid.FromDto(request.ServerId).ToGuid(), new DnsEndPoint(request.ServerHttp.Address, (int)request.ServerHttp.Port), Uuid.FromDto(request.LeaderId).ToGuid(), new DnsEndPoint(request.LeaderHttp.Address, (int)request.LeaderHttp.Port), request.View)); return(EmptyResult); }
public override async Task <TResponse> UnaryServerHandler <TRequest, TResponse>(TRequest request, ServerCallContext context, UnaryServerMethod <TRequest, TResponse> continuation) { TResponse response = null; try { response = await continuation(request, context); } finally { var httpContext = context.GetHttpContext(); httpContext.Items.Add(BasicConfig.HttpReportsGrpcRequest, request); httpContext.Items.Add(BasicConfig.HttpReportsGrpcResponse, response); } return(response); }
public override async Task <RemoveAuthenticatorReply> RemoveAuthenticator(RemoveAuthenticatorRequest request, ServerCallContext context) { Guid id = new Guid(request.Id); AppUser user = await _userManager.GetUserAsync(context.GetHttpContext().User); UserTotpDevice device = await _authDbContext.UserTotpDevices .Where(d => d.User == user) .Where(d => d.Id == id) .SingleAsync(); _authDbContext.Remove(device); await _authDbContext.SaveChangesAsync(); return(new RemoveAuthenticatorReply { Success = true, }); }
public override async Task <StateResp> State(StateReq request, ServerCallContext context) { var user = context.GetHttpContext().User; if (!await _authorizationProvider.CheckAccessAsync(user, StateOperation, context.CancellationToken) .ConfigureAwait(false)) { throw AccessDenied(); } var resultSource = new TaskCompletionSource <Value>(); var options = request.Options; var name = options.Name; var partition = options.Partition ?? string.Empty; var envelope = new CallbackEnvelope(OnMessage); _queue.Publish(new ProjectionManagementMessage.Command.GetState(envelope, name, partition)); return(new StateResp { State = await resultSource.Task.ConfigureAwait(false) }); void OnMessage(Message message) { if (!(message is ProjectionManagementMessage.ProjectionState result)) { resultSource.TrySetException(UnknownMessage <ProjectionManagementMessage.ProjectionState>(message)); return; } if (string.IsNullOrEmpty(result.State)) { resultSource.TrySetResult(new Value { StructValue = new Struct() }); return; } var document = JsonDocument.Parse(result.State); resultSource.TrySetResult(GetProtoValue(document.RootElement)); } }
public async Task CreateDuplexStreaming( IAsyncStreamReader <TRequest> requestStream, IServerStreamWriter <TResponse> responseStream, ServerCallContext context) { var httpContext = context.GetHttpContext(); Logger.LogInformation($"Connection id: {httpContext.Connection.Id}"); if (!await requestStream.MoveNext()) { return; } var clientId = _messageProcessor.GetClientId(requestStream.Current); Logger.LogInformation($"{clientId} connected"); var subscriber = new SubscribersModel <TResponse> { Subscriber = responseStream, Id = $"{clientId}" }; _serverGrpcSubscribers.AddSubscriber(subscriber); do { if (requestStream.Current == null) { continue; } var resultMessage = _messageProcessor.Process(requestStream.Current); if (resultMessage == null) { continue; } await _serverGrpcSubscribers.BroadcastMessageAsync(resultMessage); } while (await requestStream.MoveNext()); _serverGrpcSubscribers.RemoveSubscriber(subscriber); Logger.LogInformation($"{clientId} disconnected"); }
public override async Task <Empty> RestartSubsystem(Empty request, ServerCallContext context) { var restartSubsystemSource = new TaskCompletionSource <Empty>(); var user = context.GetHttpContext().User; if (!await _authorizationProvider.CheckAccessAsync(user, RestartOperation, context.CancellationToken).ConfigureAwait(false)) { throw RpcExceptions.AccessDenied(); } _publisher.Publish(new SubscriptionMessage.PersistentSubscriptionsRestart( new CallbackEnvelope(HandleRestartSubsystemCompleted))); return(await restartSubsystemSource.Task.ConfigureAwait(false)); void HandleRestartSubsystemCompleted(Message message) { if (message is ClientMessage.NotHandled notHandled && RpcExceptions.TryHandleNotHandled(notHandled, out var ex)) { restartSubsystemSource.TrySetException(ex); return; } switch (message) { case SubscriptionMessage.PersistentSubscriptionsRestarting _: restartSubsystemSource.TrySetResult(new Empty()); return; case SubscriptionMessage.InvalidPersistentSubscriptionsRestart fail: restartSubsystemSource.TrySetException( RpcExceptions.PersistentSubscriptionFailed("", "", $"Persistent Subscriptions cannot be restarted as it is in the wrong state.")); return; default: restartSubsystemSource.TrySetException( RpcExceptions.UnknownMessage <SubscriptionMessage.PersistentSubscriptionsRestarting>(message)); return; } } }
private async Task <Reply> UpdateFields(Tags.Tag request, ServerCallContext context, Func <Tag, Task <Error> > updateField) { var reply = new Reply(); var user = await _userService.GetUser(context.GetHttpContext()); if (user == null) { reply.Error = Error.NeedLogin; return(reply); } if (!user.HasWritePermission()) { reply.Error = Error.NoPermission; return(reply); } if (Guid.TryParse(request.Id, out var id)) { var item = await _service.All().Where(i => i.Id == id).FirstOrDefaultAsync(); if (item != null) { reply.Error = await updateField(item); if (reply.Error == Error.None) { await _service.Update(item); } } else { reply.Error = Error.NoSuchEntity; } } else { reply.Error = Error.InvalidArguments; } return(reply); }
public override async Task SayHellos(HelloRequest request, IServerStreamWriter <HelloReply> responseStream, ServerCallContext context) { var httpContext = context.GetHttpContext(); _logger.LogInformation($"Connection id: {httpContext.Connection.Id}"); var i = 0; while (!context.CancellationToken.IsCancellationRequested) { var message = $"How are you {request.Name}? {++i}"; _logger.LogInformation($"Sending greeting {message}."); await responseStream.WriteAsync(new HelloReply { Message = message }); // Gotta look busy await Task.Delay(1000); } }
public override async Task <UpdateResp> Update(UpdateReq request, ServerCallContext context) { var updatedSource = new TaskCompletionSource <bool>(); var options = request.Options; var user = context.GetHttpContext().User; if (!await _authorizationProvider.CheckAccessAsync(user, UpdateOperation, context.CancellationToken) .ConfigureAwait(false)) { throw AccessDenied(); } const string handlerType = "JS"; var name = options.Name; var query = options.Query; bool? emitEnabled = (options.EmitOptionCase, options.EmitEnabled) switch { (EmitOptionOneofCase.EmitEnabled, true) => true, (EmitOptionOneofCase.EmitEnabled, false) => false, (EmitOptionOneofCase.NoEmitOptions, _) => default,
public override async Task <KeyValueReply> AddOrUpdate(KeyValue request, ServerCallContext context) { var reply = new KeyValueReply(); var user = await _userService.GetUser(context.GetHttpContext()); if (user == null) { reply.Error = Error.NeedLogin; return(reply); } if (!user.HasWritePermission()) { reply.Error = Error.NoPermission; return(reply); } if (string.IsNullOrWhiteSpace(request.Id)) { reply.Error = Error.InvalidArguments; return(reply); } var item = await _service.All().Where(k => k.Id == request.Id).FirstOrDefaultAsync(); Domain.Models.KeyValue newItem; if (item != null) { item.Value = request.Value; newItem = await _service.Update(item); } else { newItem = await _service.Add(new Domain.Models.KeyValue { Id = request.Id, Value = request.Value }); } reply.KeyValue = new KeyValue { Id = newItem.Id, Value = newItem.Value }; return(reply); }
private async Task <Reply> UpdateFields(string id, ServerCallContext context, Func <User, Task <Error> > updateField) { var reply = new Reply(); var user = await _userService.GetUser(context.GetHttpContext()); if (user == null) { reply.Error = Error.NeedLogin; return(reply); } if (!user.HasWritePermission()) { reply.Error = Error.NoPermission; return(reply); } if (string.IsNullOrWhiteSpace(id)) { reply.Error = Error.InvalidArguments; } else { var item = await _service.All().Where(i => i.Id == id).FirstOrDefaultAsync(); if (item != null) { reply.Error = await updateField(item); if (reply.Error == Error.None) { await _service.Update(item); } } else { reply.Error = Error.NoSuchEntity; } } return(reply); }
public override async Task SayHellos(HelloRequest request, IServerStreamWriter <HelloReply> responseStream, ServerCallContext context) { var httpContext = context.GetHttpContext(); _logger.LogInformation($"Connection id: {httpContext.Connection.Id}"); for (int i = 0; i < 3; i++) { var message = $"How are you {request.Name}? {i}"; _logger.LogInformation($"Sending greeting {message}"); await responseStream.WriteAsync(new HelloReply { Message = message }); // Gotta look busy await Task.Delay(1000); } _logger.LogInformation("Sending goodbye"); await responseStream.WriteAsync(new HelloReply { Message = $"Goodbye {request.Name}!" }); }
public override async Task <TradesResponse> GetTrades(TradesRequest request, ServerCallContext context) { var result = await _validationService.ValidateTradesRequestAsync(request.AssetPairId, request.Offset, request.Take); if (result != null) { return(new TradesResponse { Error = new Error { Code = (int)result.Code, Message = result.Message } }); } DateTime?from = null; DateTime?to = null; if (DateTime.TryParse(request.From, out var fromDate)) { from = fromDate; } if (DateTime.TryParse(request.To, out var toDate)) { to = toDate; } var orderAction = request.OptionalSideCase == TradesRequest.OptionalSideOneofCase.None ? (OrderAction?)null : request.Side == Side.Buy ? OrderAction.Buy : OrderAction.Sell; var trades = await _historyClient.GetTradersAsync(context.GetHttpContext().User.GetWalletId(), request.AssetPairId, request.Offset, request.Take, orderAction, from, to); var res = new TradesResponse(); var data = _mapper.Map <List <Trade> >(trades); res.Payload.AddRange(data); return(res); }
public override async Task <TombstoneResp> Tombstone(TombstoneReq request, ServerCallContext context) { var options = request.Options; var streamName = options.StreamName; var expectedVersion = options.ExpectedStreamRevisionCase switch { TombstoneReq.Types.Options.ExpectedStreamRevisionOneofCase.Revision => new StreamRevision(options.Revision).ToInt64(), TombstoneReq.Types.Options.ExpectedStreamRevisionOneofCase.Any => AnyStreamRevision.Any.ToInt64(), TombstoneReq.Types.Options.ExpectedStreamRevisionOneofCase.NoStream => AnyStreamRevision.NoStream.ToInt64(), TombstoneReq.Types.Options.ExpectedStreamRevisionOneofCase.StreamExists => AnyStreamRevision.StreamExists.ToInt64(), _ => throw new InvalidOperationException() }; var requiresLeader = GetRequiresLeader(context.RequestHeaders); var user = context.GetHttpContext().User; var op = DeleteOperation.WithParameter(Plugins.Authorization.Operations.Streams.Parameters.StreamId(streamName)); if (!await _provider.CheckAccessAsync(user, op, context.CancellationToken).ConfigureAwait(false)) { throw AccessDenied(); } var position = await DeleteInternal(streamName, expectedVersion, user, true, requiresLeader, context.CancellationToken).ConfigureAwait(false); return(position.HasValue ? new TombstoneResp { Position = new TombstoneResp.Types.Position { CommitPosition = position.Value.CommitPosition, PreparePosition = position.Value.PreparePosition } } : new TombstoneResp { NoPosition = new Empty() }); }
public override async Task <Empty> PrepareOk(PrepareOkRequest request, ServerCallContext context) { var user = context.GetHttpContext().User; if (!await _authorizationProvider.CheckAccessAsync(user, PrepareOkOperation, context.CancellationToken).ConfigureAwait(false)) { throw AccessDenied(); } _bus.Publish(new ElectionMessage.PrepareOk( request.View, Uuid.FromDto(request.ServerId).ToGuid(), new IPEndPoint(IPAddress.Parse(request.ServerInternalHttp.Address), (int)request.ServerInternalHttp.Port), request.EpochNumber, request.EpochPosition, Uuid.FromDto(request.EpochId).ToGuid(), request.LastCommitPosition, request.WriterCheckpoint, request.ChaserCheckpoint, request.NodePriority)); return(EmptyResult); }
public override async Task <TResponse> UnaryServerHandler <TRequest, TResponse>( TRequest request, ServerCallContext context, UnaryServerMethod <TRequest, TResponse> continuation) { if (_locator.TryGetValidator <TRequest>(out var validator)) { var results = await validator.ValidateAsync(request); if (!results.IsValid) { var message = await _handler.HandleAsync(results.Errors); context.Status = new Status(StatusCode.InvalidArgument, message); context.GetHttpContext().Response.Headers[GrpcProtocolConstants.StatusTrailerName] = GrpcProtocolConstants.StatusTrailerInvalidArgument; return(ObjectCreator <TResponse> .Empty); } } return(await continuation(request, context)); }
private async Task <IQueryable <File> > FilterPrivate(IQueryable <File> items, ServerCallContext context) { //todo: permission via filetype: File->Adm, Resource->Login var readPrivate = (await _userService.GetUser(context.GetHttpContext())).HasReadPrivatePermission(); if (!readPrivate) { var defStr = await _keyValueService.GetValue(ServerKeys.DefaultPrivate.Key); var defPrivate = defStr == "true"; if (defPrivate) { items = items.Where(i => i.Private == (ulong)PrivateType.Public); } else { items = items.Where(i => i.Private != (ulong)PrivateType.Private); } } return(items); }
public override async Task SendMessage( IAsyncStreamReader <ChatMessage> requestStream, IServerStreamWriter <ChatMessage> responseStream, ServerCallContext context) { string connectionId = context.GetHttpContext().Connection.Id; rooms[responseStream] = connectionId; await foreach (var request in requestStream.ReadAllAsync(context.CancellationToken)) { foreach (var room in rooms) { await room.Key.WriteAsync(new ChatMessage { Content = request.Content }); } } //while (await requestStream.MoveNext(context.CancellationToken)) //{ //} }
private async Task ResolvedInterceptorInvoker(IAsyncStreamReader <TRequest> requestStream, IServerStreamWriter <TResponse> responseStream, ServerCallContext resolvedContext) { GrpcActivatorHandle <TService> serviceHandle = default; try { serviceHandle = ServiceActivator.Create(resolvedContext.GetHttpContext().RequestServices); await _invoker( serviceHandle.Instance, requestStream, responseStream, resolvedContext); } finally { if (serviceHandle.Instance != null) { await ServiceActivator.ReleaseAsync(serviceHandle); } } }
public override async Task <Empty> ResetCache(Empty _, ServerCallContext context) { try { var user = context.GetHttpContext().User; _logger.LogInformation($"User {user.ToBlameString()} is resetting the cache."); await _configManager.ResetCacheAsync(user); return(new Empty()); } catch (SecurityException ex) { _logger.LogError(ex, "Failed to reset cache."); throw new RpcException(new Status(StatusCode.PermissionDenied, ex.Message)); } catch (Exception ex) when(!(ex is RpcException)) { _logger.LogError(ex, "Failed to reset cache."); throw new RpcException(new Status(StatusCode.Internal, ex.Message)); } }
public override async Task <UserReply> GetUser(Empty request, ServerCallContext context) { string userId = _userManager.GetUserId(context.GetHttpContext().User); AppUser user = await _dbContext.Users .Include(u => u.Groups) .SingleAsync(u => u.Id == new Guid(userId)); UserReply reply = new UserReply { Username = user.UserName, Email = user.Email, }; foreach (UserGroup group in user.Groups) { reply.GroupNames.Add(group.Name); } return(reply); }
public override async Task <Reply> DeleteAll(Empty request, ServerCallContext context) { var reply = new Reply(); var user = await _userService.GetUser(context.GetHttpContext()); if (user == null) { reply.Error = Error.NeedLogin; return(reply); } if (!user.HasWritePermission()) { reply.Error = Error.NoPermission; return(reply); } await _service.DeleteAll(); return(reply); }
public override async Task <ChangePasswordResp> ChangePassword(ChangePasswordReq request, ServerCallContext context) { var options = request.Options; var user = context.GetHttpContext().User; var changePasswordOperation = ChangePasswordOperation; if (user?.Identity?.Name != null) { changePasswordOperation = changePasswordOperation.WithParameter( Plugins.Authorization.Operations.Users.Parameters.User(user.Identity.Name)); } if (!await _authorizationProvider.CheckAccessAsync(user, changePasswordOperation, context.CancellationToken).ConfigureAwait(false)) { throw RpcExceptions.AccessDenied(); } var changePasswordSource = new TaskCompletionSource <bool>(); var envelope = new CallbackEnvelope(OnMessage); _publisher.Publish(new UserManagementMessage.ChangePassword(envelope, user, options.LoginName, options.CurrentPassword, options.NewPassword)); await changePasswordSource.Task.ConfigureAwait(false); return(new ChangePasswordResp()); void OnMessage(Message message) { if (HandleErrors(options.LoginName, message, changePasswordSource)) { return; } changePasswordSource.TrySetResult(true); } }
public override async Task <Empty> RestartPersistentSubscriptions(Empty request, ServerCallContext context) { var restart = new TaskCompletionSource <bool>(); var envelope = new CallbackEnvelope(OnMessage); var user = context.GetHttpContext().User; if (!await _authorizationProvider.CheckAccessAsync(user, RestartPersistentSubscriptionsOperation, context.CancellationToken) .ConfigureAwait(false)) { throw RpcExceptions.AccessDenied(); } _publisher.Publish(new SubscriptionMessage.PersistentSubscriptionsRestart(envelope)); await restart.Task.ConfigureAwait(false); return(new Empty()); void OnMessage(Message message) { switch (message) { case SubscriptionMessage.PersistentSubscriptionsRestarting _: restart.TrySetResult(true); break; case SubscriptionMessage.InvalidPersistentSubscriptionsRestart _: restart.TrySetResult(true); break; default: restart.TrySetException( RpcExceptions .UnknownMessage <SubscriptionMessage.PersistentSubscriptionsRestarting>(message)); break; } } }
public override async Task <TResponse> UnaryServerHandler <TRequest, TResponse>(TRequest request, ServerCallContext context, UnaryServerMethod <TRequest, TResponse> continuation) { TResponse response = null; try { response = await continuation(request, context); } catch (Exception ex) { _logger.LogError("UnaryServerHandler Error:" + ex.ToString()); } finally { var httpContext = context.GetHttpContext(); httpContext.Items.Add(BasicConfig.HttpReportsGrpcRequest, request); httpContext.Items.Add(BasicConfig.HttpReportsGrpcResponse, response); } return(response); }
public override async Task <RemoveReply> Remove(RemoveRequest request, ServerCallContext context) { Photo ph = await photosService.FindAsync(request.Id); var user = context.GetHttpContext().User; var authorizationResult = await authorizationService.AuthorizeAsync(user, ph, Policies.EditDeletePhoto); if (authorizationResult.Succeeded) { ph = await photosService.RemoveAsync(request.Id); return(ph.ToRemoveReply()); } else { //found on https://docs.microsoft.com/en-us/dotnet/architecture/grpc-for-wcf-developers/error-handling var metadata = new Metadata { { "User", user.Identity.Name } }; throw new RpcException(new Status(StatusCode.PermissionDenied, "Permission denied"), metadata); } }
public override async Task <Shared.Apps.AppListReply> ListApps(Empty request, ServerCallContext context) { Guid userId = new Guid(_userManager.GetUserId(context.GetHttpContext().User)); IEnumerable <AuthApp> authApps = await _authDbContext.AuthApp .AsNoTracking() .Where(a => a.UserGroups.Any(u => u.Members.Any(m => m.Id == userId))) .ToListAsync(); AppListReply reply = new AppListReply(); foreach (AuthApp app in authApps) { reply.Apps.Add(new AppListEntry { Id = app.Id.ToString(), Name = app.Name, }); } return(reply); }