private void racerAdd_Click(object sender, EventArgs e) { try { Networking.gRPC.Racer racer = new Networking.gRPC.Racer { Name = Nume.Text, Team = (Networking.gRPC.Team)Enum.Parse(typeof(Networking.gRPC.Team), ((Domain.Team)team.SelectedItem).ToString(), true), Engine = (Networking.gRPC.Engine)Enum.Parse(typeof(Networking.gRPC.Engine), ((Domain.Engine)racerEngine.SelectedItem).ToString(), true) }; Domain.Race race = (Domain.Race)racesSelector.SelectedItem; Networking.gRPC.Race race1 = new Networking.gRPC.Race { Id = race.id, NoRacers = (uint)race.NoRacers, Date = race.Date.ToString("yyyy-MM-dd").Split()[0], Engine = (Networking.gRPC.Engine)Enum.Parse(typeof(Networking.gRPC.Engine), race.Engine.ToString(), true) }; streamWriter.WriteAsync(new Request { Type = Request.Types.Type.Add, Race = race1, Racer = racer }); } catch (NullReferenceException ex1) { Console.WriteLine(ex1.Message); MessageBox.Show("All input fields must be selected and completed", "Ups", MessageBoxButtons.OK, MessageBoxIcon.Exclamation); } catch (Exception ex) { MessageBox.Show(ex.Message, "Ups", MessageBoxButtons.OK, MessageBoxIcon.Exclamation); } Nume.Text = "Name"; team.Text = "Team"; racerEngine.Text = "Engine"; racesSelector.Text = "Races"; }
private static bool SatisfyDataRequest( [NotNull] DataVerificationResponse arg, [NotNull] IVerificationDataProvider verificationDataProvider, [NotNull] IClientStreamWriter <DataVerificationRequest> callRequestStream) { DataVerificationRequest result = new DataVerificationRequest(); try { if (arg.SchemaRequest != null) { result.Schema = verificationDataProvider.GetGdbSchema(arg.SchemaRequest); } else if (arg.DataRequest != null) { result.Data = verificationDataProvider .GetData(arg.DataRequest).FirstOrDefault(); } callRequestStream.WriteAsync(result); return(true); } catch (Exception e) { _msg.Debug("Error handling data request", e); // Send an empty message to make sure the server does not wait forever: callRequestStream.WriteAsync(result); throw; } }
public bool TrySendData(IClientStreamWriter <TRequest> requestStream, TRequest item, int sendTimeoutMs, CancellationToken cancellationToken) { try { //If there is no channel, return if (cancellationToken.IsCancellationRequested) { return(false); } return(requestStream.WriteAsync(item).Wait(sendTimeoutMs, cancellationToken)); } catch (Exception ex) { const string errorMessage = "Unable to create gRPC Request/Response Streams"; var invalidOperEx = ex as InvalidOperationException; if (invalidOperEx != null && invalidOperEx.Message == "Request stream has already been completed.") { throw new GrpcWrapperStreamNotAvailableException(errorMessage, invalidOperEx); } var grpcEx = ex as RpcException ?? ex.InnerException as RpcException; if (grpcEx != null) { throw new GrpcWrapperException(grpcEx.StatusCode, errorMessage, grpcEx); } throw new GrpcWrapperException(errorMessage, ex); } }
/// <inheritdoc/> public async Task Write(IEnumerable <TagDataPoint> dataPoints) { var streamTagDataPoints = new PushTagDataPoints(); streamTagDataPoints.DataPoints.Add(dataPoints.Select(_ => _.ToRuntime())); await _serverStreamWriter.WriteAsync(streamTagDataPoints).ConfigureAwait(false); }
/// <summary> /// Writes the specified requests. /// </summary> /// <typeparam name="TRequest">The type of the request.</typeparam> /// <param name="streamWriter"></param> /// <param name="requests">The requests.</param> /// <returns></returns> public static async Task WriteRequestsAsync <TRequest>(this IClientStreamWriter <TRequest> streamWriter, IEnumerable <Task <TRequest> > requests) { foreach (Task <TRequest> request in requests) { await streamWriter.WriteAsync(await request.ConfigureAwait(false)).ConfigureAwait(false); } }
public async Task <long> Publish(ReadOnlyMemory <byte> message) { Task writeTask; long seqNum; lock (sync) { if (disposed) { throw new PublisherException($"Cannot write to disposed {nameof(Publisher)}"); } writeTask = requestStream.WriteAsync(new WriteRequest { SequenceNumber = sequenceNumber, Message = Google.Protobuf.ByteString.CopyFrom(message.Span) }); seqNum = sequenceNumber++; } await writeTask; return(seqNum); }
public async Task <long> Publish(IEnumerable <ReadOnlyMemory <byte> > messages) { Task writeTask; long seqNum; lock (sync) { if (disposed) { throw new PublisherException($"Cannot write to disposed {nameof(Publisher)}"); } var request = new PublishManyRequest { SequenceNumber = sequenceNumber }; request.Messages.AddRange(messages.Select(x => Google.Protobuf.ByteString.CopyFrom(x.Span))); writeTask = requestStream.WriteAsync(request); seqNum = sequenceNumber++; } await writeTask; return(seqNum); }
public async Task StartWriterAsync(IClientStreamWriter <StreamingMessage> requestStream) { await foreach (StreamingMessage rpcWriteMsg in _outputChannel.Channel.Reader.ReadAllAsync()) { await requestStream.WriteAsync(rpcWriteMsg); } }
public Task SendPoint(int x, int y, string colorHex) { System.Drawing.Color col = ColorTranslator.FromHtml(colorHex); var drawReq = new DrawPointRequest() { Id = id, DrawPoint = new DrawPoint() { Color = new gRPCClient.Color() { R = (int)col.R, B = (int)col.B, G = (int)col.G }, Point = new gRPCClient.Point() { X = x, Y = y } } }; _requestStream.WriteAsync(drawReq); return(Task.CompletedTask); }
private async Task StreamContentAsync(Stream input, byte[] buffer, IClientStreamWriter <PushFileRequest> requestStream, CancellationToken ct) { Contract.Requires(!(input is null)); Contract.Requires(!(requestStream is null)); int chunkSize = 0; // Pre-fill buffer with the file's first chunk await readNextChunk(); while (true) { ct.ThrowIfCancellationRequested(); if (chunkSize == 0) { break; } ByteString content = ByteString.CopyFrom(buffer, 0, chunkSize); var request = new PushFileRequest() { Content = content }; // Read the next chunk while waiting for the response await Task.WhenAll(readNextChunk(), requestStream.WriteAsync(request)); } async Task <int> readNextChunk() { chunkSize = await input.ReadAsync(buffer, 0, buffer.Length, ct); return(chunkSize); } }
public Task WriteAsync(T message) { if (onMessage != null) { message = onMessage(message); } return(writer.WriteAsync(message)); }
private async Task SendEnvelopesAsync(IEnumerable <MessageEnvelope> envelopes) { var batch = new MessageBatch(); batch.Envelopes.AddRange(envelopes); await _streamWriter.WriteAsync(batch); }
/// <summary> /// Writes the specified requests and send a completion. /// </summary> /// <typeparam name="TRequest">The type of the request.</typeparam> /// <param name="streamWriter"></param> /// <param name="requests">The requests.</param> /// <returns></returns> public static async Task WriteRequestsAndCompleteAsync <TRequest>(this IClientStreamWriter <TRequest> streamWriter, IEnumerable <TRequest> requests) { foreach (TRequest request in requests) { await streamWriter.WriteAsync(request).ConfigureAwait(false); } await streamWriter.CompleteAsync().ConfigureAwait(false); }
private async Task WriteAudioIn(byte[] buffer) { OnDebug?.Invoke("Write Audio " + buffer.Length, true); var request = new ConverseRequest() { AudioIn = ByteString.CopyFrom(buffer) }; await _requestStream.WriteAsync(request); }
public Task WriteAsync(T message) { Task result = _writer.WriteAsync(message); result.ContinueWith(task => { _onMessage.Invoke(); }); return(result); }
internal void WriteTo(IClientStreamWriter <T> writer) { writer.WriteOptions = WriteOptions; Task task = Message == null?writer.CompleteAsync() : writer.WriteAsync(Message); task.ContinueWith(t => { _continuation?.Invoke(t); PropagateTaskResult(t, CompletionSource); }); }
private async Task Start(CancellationToken token) { await foreach (var i in _request.WithCancellation(token).ConfigureAwait(false)) { await _stream.WriteAsync(new Message <TRequest>(i)).ConfigureAwait(false); } if (!token.IsCancellationRequested) { await _stream.CompleteAsync().ConfigureAwait(false); } }
private static async Task SendRandomMessage(IClientStreamWriter <Message> requestStrm) { var randomMessage = new Message { Id = Guid.NewGuid().GetHashCode().ToString(), Contents = Utilities.RandomSentence() }; await requestStrm.WriteAsync(randomMessage); await Task.Delay(1000); }
public async Task Complete(long messageId) { if (disposed) { throw new SubscriberException($"Cannot write to disposed {nameof(Subscriber)}"); } await requestStream.WriteAsync(new FastQueueService.CompleteRequest { Id = messageId }); }
/// <summary> /// Writes all elements from given enumerable to the stream. /// Completes the stream afterwards unless close = false. /// </summary> public static async Task WriteAllAsync <T>(this IClientStreamWriter <T> streamWriter, IEnumerable <T> elements, bool complete = true) where T : class { foreach (var element in elements) { await streamWriter.WriteAsync(element).ConfigureAwait(false); } if (complete) { await streamWriter.CompleteAsync().ConfigureAwait(false); } }
private static async Task MyPlay(IClientStreamWriter <GameRequest> request) { // // client play // var myDice = await client.RollDiceAsync(new EmptyRequest()); var clientResult = $"Client Result: {myDice.Result}"; Console.WriteLine(clientResult); await request.WriteAsync(new GameRequest { ClientResult = clientResult }); }
private async Task SendEnvelopesAsync(MessageBatch batch, IContext context) { try { await _streamWriter.WriteAsync(batch); } catch (Exception x) { context.Stash(); Console.WriteLine($"[REMOTING] gRPC Failed to send to address {_address}, reason {x.Message}"); throw; } }
private async Task ListServices(IClientStreamWriter <ServerReflectionRequest> req, ListServiceResponse resp) { var services = resp.Service.Where(p => !p.Name.StartsWith("grpc.")); foreach (var service in services) { await req.WriteAsync(new ServerReflectionRequest() { FileContainingSymbol = service.Name }); } await req.CompleteAsync(); }
private async Task SendEnvelopesAsync(MessageBatch batch, IContext context) { try { await _streamWriter.WriteAsync(batch); } catch (Exception x) { context.Stash(); _logger.LogError($"gRPC Failed to send to address {_address}, reason {x.Message}"); throw; } }
public async Task SendStartStreamMessageAsync(IClientStreamWriter <StreamingMessage> requestStream) { StartStream str = new StartStream() { WorkerId = _options.WorkerId }; StreamingMessage startStream = new StreamingMessage() { StartStream = str }; await requestStream.WriteAsync(startStream); }
private static async Task WriteStream(IClientStreamWriter <PostForecastRequest> requestStream) { await foreach (var f in ForecastFactory.CreateMultipleAsync(10)) { await requestStream.WriteAsync(new PostForecastRequest { Date = f.date, TemperatureC = f.temperatureC, Summary = f.summary, CanYouPlayGolf = f.canYouPlayGolf }); } await requestStream.CompleteAsync(); }
/// <summary> /// Sends a single ping to designate that the Game Server is alive and healthy. /// </summary> /// <returns>gRPC Status of the request</returns> internal async Task <Status> HealthAsync() { try { await healthStream.WriteAsync(new Empty()); return(new Status(StatusCode.OK, "Health ping successful.")); } catch (RpcException ex) { Console.Error.WriteLine(ex.Message); return(ex.Status); } }
/// <summary> /// Sends a single ping to designate that the Game Server is alive and healthy. /// </summary> /// <returns>gRPC Status of the request</returns> public async Task <Status> HealthAsync() { try { await healthStream.WriteAsync(new Empty()); return(new Status(StatusCode.OK, "Health ping successful.")); } catch (RpcException ex) { LogError(ex, "Unable to invoke the GameServer health check."); return(ex.Status); } }
async Task WritePong(CancellationToken cancellationToken) { await _writeResponseSemaphore.WaitAsync(cancellationToken).ConfigureAwait(false); try { if (cancellationToken.IsCancellationRequested) { _logger.Debug("Reverse Call Client was cancelled before it could respond with pong"); return; } var message = new TClientMessage(); _setPong(message, new Pong()); _logger.Trace("Writing pong"); await _clientToServer.WriteAsync(message).ConfigureAwait(false); } finally { _writeResponseSemaphore.Release(); } }
private async Task SatisfyDataQueryAsync( [NotNull] DataRequest dataRequest, [NotNull] IClientStreamWriter <DataVerificationRequest> targetStream) { // Once the result messages are split up, this could be used for higher throughput foreach (GdbData data in Assert.NotNull(VerificationDataProvider).GetData(dataRequest)) { DataVerificationRequest r = new DataVerificationRequest { Data = data }; await targetStream.WriteAsync(r); } }