public void Configure(IApplicationBuilder app)
{
//Make sure that the grpc-server is run
app.Run(async context =>
{
AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);
var httpClient = new HttpClient();
httpClient.BaseAddress = new Uri("http://localhost:5500"); //check the values at /server project
var client = GrpcClient.Create <Billboard.Board.BoardClient>(httpClient);
var result = client.ShowMessage(new Billboard.MessageRequest
{
Name = "Johny"
});
context.Response.Headers["Content-Type"] = "text/event-stream";
using var tokenSource = new CancellationTokenSource();
CancellationToken token = tokenSource.Token;
var streamReader = result.ResponseStream;
while (await streamReader.MoveNext(token))
{
var reply = streamReader.Current;
var displayDate = new DateTime(reply.DisplayTime);
await context.Response.WriteAsync($"Received \"{reply.Message}\" on {displayDate.ToLongTimeString()} \n");
await context.Response.Body.FlushAsync();
}
});
}
private async Task <BoolResult> CheckGrpcPortIsOpen(Context context, uint grpcPort)
{
var client = new GrpcClient(new ServiceClientContentSessionTracer(nameof(CheckGrpcPortIsOpen)), FileSystem, grpcPort, nameof(CheckGrpcPortIsOpen));
var sw = Stopwatch.StartNew();
while (sw.ElapsedMilliseconds < ReadyWaitMs * 5)
{
try
{
var startupResult = await client.StartupAsync(context);
if (startupResult.Succeeded)
{
return(BoolResult.Success);
}
}
catch (ClientCanRetryException)
{ }
// Wait a short time so we don't churn
await Task.Delay(100);
}
return(new BoolResult($"Failed to detect active grpc client for {grpcPort}"));
}
static async Task Main(string[] args)
{
AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);
var httpClient = new HttpClient();
httpClient.BaseAddress = new Uri("http://localhost:50051");
var client = GrpcClient.Create <Greeter.GreeterClient>(httpClient);
var reply = await client.SayHelloAsync(
new HelloRequest { Name = "GreeterClient" });
Console.WriteLine("Greeting: " + reply.Message);
using (var call = client.lotsOfReplies(new HelloRequest {
Name = "GreeterClient"
}))
{
while (await call.ResponseStream.MoveNext())
{
var replystreammsg = call.ResponseStream.Current;
Console.WriteLine("Received " + replystreammsg.ToString());
}
}
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
}
/// <inheritdoc/>
protected override Task InitializeAsync(CancellationToken cancellationToken)
{
var proto = ""; //todo
var fileDescriptorSet = new FileDescriptorSet();
fileDescriptorSet.Add("" /* todo */, true, new StringReader(proto));
fileDescriptorSet.Process();
var errors = fileDescriptorSet.GetErrors();
foreach (var file in fileDescriptorSet.Files)
{
foreach (var service in file.Services)
{
foreach (var method in service.Methods)
{
//todo: if method.Deprecated => display warning
}
}
}
var channel = GrpcChannel.ForAddress($"{EnvironmentVariables.Api.HostName.Value}:8080");
var serviceName = "";
var client = new GrpcClient(channel, serviceName);
return(Task.CompletedTask);
}
public static RpcClient CreateClient(string clientName, RemoteConnectionType connectionType, Dictionary <string, string> labels)
{
string clientNameInner = clientName;
if (!ClientMap.TryGetValue(clientNameInner, out var client))
{
RpcClient moduleClient = null;
if (connectionType.Equals(RemoteConnectionType.GRPC))
{
moduleClient = new GrpcClient(clientNameInner);
}
if (moduleClient == null)
{
throw new ArgumentException("unsupported connection type :" + connectionType.ToString());
}
moduleClient.InitLabels(labels);
ClientMap.AddOrUpdate(clientNameInner, moduleClient, (x, y) => moduleClient);
ClientMap[clientNameInner] = moduleClient;
return(moduleClient);
}
return(client);
}
static StreamClient GetClient()
{
var httpClient = new HttpClient();
httpClient.BaseAddress = new Uri("https://localhost:5001");
return(GrpcClient.Create <StreamClient>(httpClient));
}
public async Task <string> GetAsync(CancellationToken cancellationToken)
{
// fixed https error
var httpclientHandler = new HttpClientHandler
{
ServerCertificateCustomValidationCallback = (message, cert, chain, error) => true
};
var httpClient = new HttpClient(httpclientHandler)
{
// The port number(5001) must match the port of the gRPC server.
BaseAddress = new Uri("https://localhost:5001")
};
try
{
var client = GrpcClient.Create <UserInfoRpcService.UserInfoRpcServiceClient>(httpClient);
var callOptions = new Grpc.Core.CallOptions()
// StatusCode=Cancelled
.WithCancellationToken(cancellationToken)
// StatusCode=DeadlineExceeded
.WithDeadline(DateTime.UtcNow.AddMilliseconds(200));
var reply = await client.GetByIdAsync(new GetUserByIdRequest { Id = 1 }, callOptions);
return(reply.Name);
}
catch (Exception ex)
{
_logger.LogError(ex, "some exception occure");
return("error");
}
}
private static async Task MainAsync()
{
var index = 1;
var callOptions = GrpcClient.GetCallOptions(cancellationToken: ContainerLifecycle.CancellationToken);
using var channel = GrpcClient.GetChannel(new Uri("https://localhost:10010"), GrpcClient.GetChannelOptions(100, true, true));
var client = new PraxiCloudPipelineService.PraxiCloudPipelineServiceClient(channel);
while (_continue)
{
await Task.Delay(10).ConfigureAwait(false);
var request = new TestRequest {
Message = $"Test message {index++}"
};
var response = await client.TestAsync(request, callOptions);
if (index % 100 == 0)
{
Console.WriteLine($"Response was {response.Message}");
}
}
}
private void CameraTextureWorker()
{
while (!IsClosing)
{
Task.Delay(Delay).Wait();
if (string.IsNullOrEmpty(_currentCamera))
{
continue;
}
var cameraData = GrpcClient.GetCameraDataAsync(_currentCamera).Result;
if (cameraData.Texture == null)
{
_statusUnstable = true;
continue;
}
if (ByteArrayCompare(cameraData.Texture, _previousTexture))
{
continue;
}
if (_desiredHeight == 0)
{
_desiredHeight = 800;
}
using MemoryStream ms = new(cameraData.Texture);
_texture = Bitmap.DecodeToHeight(ms, (int)_desiredHeight,
BitmapInterpolationMode.LowQuality);
_statusUnstable = false;
_previousTexture = cameraData.Texture;
StringBuilder sb = new();
sb.AppendLine(cameraData.Altitude);
sb.AppendLine(cameraData.Speed);
Dispatcher.UIThread.InvokeAsync(() =>
{
_desiredHeight = this.FindControl <Image>("ImgCameraTexture").DesiredSize.Height;
this.FindControl <Image>("ImgCameraTexture").Source = _texture;
if (_statusUnstable)
{
return;
}
var textInfo = this.FindControl <TextBlock>("TextInfo");
textInfo.Text = sb.ToString();
var window = this.FindControl <Window>("MainWindow");
window.Title = cameraData.CameraName;
});
}
}
static async Task Main(string[] args)
{
// 设置当前上下文为http2.0请求
AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);
var httpClient = new HttpClient {
BaseAddress = new Uri("http://localhost:50051")
};
// The port number(50051) must match the port of the gRPC server.
var client = GrpcClient.Create <Greeter.GreeterClient>(httpClient);
var st = new Stopwatch();
while (Console.ReadKey().Key != ConsoleKey.Q)
{
st.Restart();
for (int i = 0; i < 1; i++)
{
var reply = await client.SayHelloAsync(
new HelloRequest { Name = "GreeterClient", UpTime = new Google.Protobuf.WellKnownTypes.Timestamp {
Seconds = DateTime.Now.Ticks
} });
Console.WriteLine("Greeting: " + reply.Message);
}
st.Stop();
Console.WriteLine($"time:{st.ElapsedMilliseconds}");
}
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
}
static async Task Main(string[] args)
{
Console.WriteLine("Starting GRPC Client...");
Console.WriteLine();
var httpClient = new HttpClient();
string grpcServerUrl = "https://localhost:5001";
httpClient.BaseAddress = new Uri(grpcServerUrl);
var client = GrpcClient.Create <GrpcUser.GrpcUserClient>(httpClient);
try
{
var response = await client.GetUserAsync(new GetUserRequest { Id = "123" });
Console.WriteLine("Response from server : ");
Console.WriteLine("Id: " + response.Id);
Console.WriteLine("Name: " + response.Name);
}
catch (RpcException ex)
{
if (ex.StatusCode == StatusCode.NotFound)
{
Console.WriteLine(ex.Status.Detail);
}
}
Console.WriteLine();
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
}
public void Configure(IApplicationBuilder app)
{
//Make sure that the grpc-server is run
app.Run(async context =>
{
AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);
var httpClient = new HttpClient();
httpClient.BaseAddress = new Uri("http://localhost:5500"); //check the values at /server project
var client = GrpcClient.Create <Billboard.Board.BoardClient>(httpClient);
var request = new Billboard.MessageRequest();
request.Capabilities.Add(new Billboard.MessageRequest.Types.SuperPower {
Name = "Flying", Level = 1
});
request.Capabilities.Add(new Billboard.MessageRequest.Types.SuperPower {
Name = "Invisibility", Level = 10
});
request.Capabilities.Add(new Billboard.MessageRequest.Types.SuperPower {
Name = "Speed", Level = 5
});
var reply = await client.ShowMessageAsync(request);
var displayDate = new DateTime(reply.ReceivedTime);
await context.Response.WriteAsync($"We sent a message to a gRPC server and received the following reply \n'\n{reply.Message}' \non {displayDate} ");
});
}
private async Task ConnectToServerAsync()
{
AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);
var deviceId = Preferences.Get("deviceId", string.Empty);
if (string.IsNullOrWhiteSpace(deviceId))
{
deviceId = Guid.NewGuid().ToString();
Preferences.Set("deviceId", deviceId);
}
var channel = new Channel(_connectionString, ChannelCredentials.Insecure);
_client = new GrpcClient(channel, _nodeName, deviceId);
var response = await _client.RegisterNodeAsync(false);
DestinationNodeList.Clear();
foreach (var item in response)
{
DestinationNodeList.Add(item);
}
IsConnected = true;
}
public async Task SendCompressedMessage_ServiceCompressionConfigured_ResponseGzipEncoding()
{
// Arrange
var compressionMetadata = CreateClientCompressionMetadata("gzip");
string?requestMessageEncoding = null;
string?responseMessageEncoding = null;
using var httpClient = Fixture.CreateClient(new TestDelegateHandler(
r =>
{
requestMessageEncoding = r.Headers.GetValues(GrpcProtocolConstants.MessageEncodingHeader).Single();
},
r =>
{
responseMessageEncoding = r.Headers.GetValues(GrpcProtocolConstants.MessageEncodingHeader).Single();
}
));
var client = GrpcClient.Create <CompressionService.CompressionServiceClient>(httpClient, LoggerFactory);
// Act
var call = client.SayHelloAsync(new HelloRequest {
Name = "World"
}, headers: compressionMetadata);
var response = await call.ResponseAsync.DefaultTimeout();
// Assert
Assert.AreEqual("Hello World", response.Message);
Assert.AreEqual("gzip", requestMessageEncoding);
Assert.AreEqual("gzip", responseMessageEncoding);
}
/// <summary>
/// Get gRPC client object used by data portal.
/// </summary>
/// <returns></returns>
protected virtual GrpcService.GrpcServiceClient GetGrpcClient()
{
if (_grpcClient == null)
{
_grpcClient = GrpcClient.Create <GrpcService.GrpcServiceClient>(GetHttpClient());
}
return(_grpcClient);
}
private IActionResult SendProcurementGRPC(int pro, string phar)
{
Pharmacy p = _pharmacyService.Get(phar);
UrgentMedicationProcurement pr = _service.Get(pro);
GrpcClient grpc = new GrpcClient();
return(Ok(grpc.Urgent(p, pr.MedicationName).Result));
}
public void Create_WithLiteClientBaseClient_ReturnInstance()
{
// Arrange & Act
var client = GrpcClient.Create <CoreGreet.Greeter.GreeterClient>(_httpClient);
// Assert
Assert.IsNotNull(client);
}
public Task ConnectAsync()
{
_client = GrpcClient.Create <Greeter.GreeterClient>(new HttpClient
{
BaseAddress = new Uri(BaseUri, UriKind.RelativeOrAbsolute)
});
return(Task.CompletedTask);
}
/// <summary>
/// Creates a GRPC client.
/// </summary>
/// <param name="address">The address.</param>
/// <param name="clientId">The client identifier.</param>
/// <returns>
/// the nanomite client
/// </returns>
public static NanomiteClient CreateGrpcClient(string address, string clientId)
{
string version = FileVersionInfo.GetVersionInfo(Assembly.GetAssembly(typeof(GrpcClient)).Location).ProductVersion;
var client = GrpcClient.Create(address, new ChunkSender(), new ChunkReceiver());
CommunicationClient comClient = new CommunicationClient(client, clientId);
return(new NanomiteClient(comClient, version));
}
public static EmulatorClient Create()
{
var httpClient = new HttpClient();
// The port number(50051) must match the port of the gRPC server.
httpClient.BaseAddress = new Uri($"https://localhost:{Defaults.Port}");
return(GrpcClient.Create <EmulatorClient>(httpClient));
}
static async Task ShowAll(GrpcClient client)
{
var reply = await client.GetAllPostsAsync(new Empty());
foreach (var post in reply.Posts)
{
DisplayPostResponse(post);
}
}
public MainViewModel()
{
client = new GrpcClient("https://localhost:5001");
prisonersVM = new PrisonersViewModel(this);
locationsVM = new LocationsViewModel(this);
jobsVM = new JobsViewModel(this);
workersVM = new WorkersViewModel(this);
LoadViewModels();
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
app.UseStaticFiles();
//Make sure that the grpc-server is run
app.Run(async context =>
{
AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);
var httpClient = new HttpClient();
httpClient.BaseAddress = new Uri("http://localhost:5500"); //check the values at /server project
var client = GrpcClient.Create <Billboard.Board.BoardClient>(httpClient);
var result = client.ShowMessage(new Billboard.MessageRequest());
context.Response.Headers["Content-Type"] = "text/html";
await context.Response.WriteAsync("<html><body><h1>Kitty Streaming</h1>");
using var tokenSource = new CancellationTokenSource();
CancellationToken token = tokenSource.Token;
var streamReader = result.ResponseStream;
//get metdata
string path = null;
await streamReader.MoveNext(token);
var initial = streamReader.Current;
if (initial.ImageCase == Billboard.MessageReply.ImageOneofCase.MetaData)
{
path = Path.Combine(env.WebRootPath, initial.MetaData.FileName);
}
if (path == null)
{
throw new ApplicationException("Metadata is missing from the server");
}
using FileStream file = new FileStream(path, FileMode.Create);
int position = 0;
while (await streamReader.MoveNext(token))
{
var chunk = streamReader.Current.Chunk;
await file.WriteAsync(chunk.Data.ToByteArray(), 0, chunk.Length);
position += chunk.Length;
await context.Response.WriteAsync(position + " ");
}
file.Close();
await context.Response.WriteAsync($"<img src=\"{initial.MetaData.FileName}\"/>");
await context.Response.WriteAsync("</body></html>");
});
}
static async Task Main(string[] args)
{
var mailboxName = GetMailboxName(args);
Console.WriteLine($"Creating client to mailbox '{mailboxName}'");
Console.WriteLine();
var httpClient = ClientResources.CreateHttpClient("localhost:50051");
var client = GrpcClient.Create <Mailer.MailerClient>(httpClient);
Console.WriteLine("Client created");
Console.WriteLine("Press escape to disconnect. Press any other key to forward mail.");
using (var mailbox = client.Mailbox(headers: new Metadata {
new Metadata.Entry("mailbox-name", mailboxName)
}))
{
_ = Task.Run(async() =>
{
try
{
while (await mailbox.ResponseStream.MoveNext(CancellationToken.None))
{
var response = mailbox.ResponseStream.Current;
Console.ForegroundColor = response.Reason == MailboxMessage.Types.Reason.Received ? ConsoleColor.White : ConsoleColor.Green;
Console.WriteLine();
Console.WriteLine(response.Reason == MailboxMessage.Types.Reason.Received ? "Mail received" : "Mail forwarded");
Console.WriteLine($"New mail: {response.New}, Forwarded mail: {response.Forwarded}");
Console.ResetColor();
}
}
catch (Exception ex)
{
Console.WriteLine("Error reading reaponse: " + ex);
}
});
while (true)
{
var result = Console.ReadKey(intercept: true);
if (result.Key == ConsoleKey.Escape)
{
break;
}
await mailbox.RequestStream.WriteAsync(new ForwardMailMessage());
}
Console.WriteLine("Disconnecting");
await mailbox.RequestStream.CompleteAsync();
}
Console.WriteLine("Disconnected. Press any key to exit.");
Console.ReadKey();
}
/// <summary>
/// Constructor to create the menu system for the console application.
/// </summary>
/// <param name="contractManagerClient">The contract manager gRPC client to use when interacting with contracts.</param>
public RootMenu(GrpcClient <IContractManager> contractManagerClient)
: base("Test Client", breadcrumbHeader: true)
{
AddPage(new MainMenu(this));
AddPage(new ContractManagement(this));
AddPage(new CreateContract(this, contractManagerClient));
AddPage(new GetContract(this, contractManagerClient));
SetPage <MainMenu>();
}
static void Run(int i)
{
HelloRequest request = new HelloRequest();
request.Name = i.ToString();
HelloReply reply = new HelloReply();
reply = GrpcClient.SayHello(request);
Console.WriteLine(reply.Message);
}
public void Create_WithBaseAddress_ReturnInstance()
{
// Arrange & Act
var httpClient = new HttpClient
{
BaseAddress = new Uri("http://localhost")
};
var client = GrpcClient.Create <GreeterClient>(httpClient);
// Assert
Assert.IsNotNull(client);
}
private static async Task Main(string[] args)
{
Console.Title = "gRPC Client";
GrpcClient.Start();
Console.WriteLine("gRPC client started. Press spacebar to switch mode or any other key to stop it.");
GrpcClient.ItemChanges.RestartMonitorOnEndOfStream = false;
while (Console.ReadKey().Key == ConsoleKey.Spacebar)
{
GrpcClient.ItemChanges.RestartMonitorOnEndOfStream = !GrpcClient.ItemChanges.RestartMonitorOnEndOfStream;
}
await GrpcClient.Stop();
}
static async Task Main(string[] args)
{
var httpClient = ClientResources.CreateHttpClient(Address);
var client = GrpcClient.Create <Aggregator.AggregatorClient>(httpClient);
await ServerStreamingCallExample(client);
await ClientStreamingCallExample(client);
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
_logger.LogInformation("Pizza worker running at: {time}", DateTimeOffset.Now);
while (!stoppingToken.IsCancellationRequested)
{
try
{
var msg = await PizzaOrdersQueue.GetMessageAsync();
if (msg != null)
{
var order = JsonConvert.DeserializeObject <Order>(msg.AsString);
using (IServiceScope scope = _serviceProvider.CreateScope())
{
// Save the order to the DB
var context = scope.ServiceProvider.GetRequiredService <PizzaStoreContext>();
order.Status = "Preparing";
context.Orders.Attach(order);
await context.SaveChangesAsync();
await PizzaOrdersQueue.DeleteMessageAsync(msg);
_logger.LogInformation($"Preparing order {order.OrderId}");
// Send Preparing status
var httpClient = new HttpClient {
BaseAddress = new Uri("https://localhost:5001")
};
var client = GrpcClient.Create <PizzaOrderStatusClient>(httpClient);
var ack = await client.SendStatusAsync(order.ToStatusUpdate());
_logger.LogInformation($"Status update ack: {ack.Message}");
await Task.Delay(10000, stoppingToken); // Prepare the pizza
// Put the pizza order on the delivery queue
await PizzaDeliveryQueue.AddMessageAsync(new CloudQueueMessage(JsonConvert.SerializeObject(order)));
_logger.LogInformation($"Order {order.OrderId} sent for delivery");
}
}
}
catch (Exception ex)
{
_logger.LogError(ex, $"Error preparing pizza order: {ex.Message}");
}
// Mandatory Pizza Worker break
await Task.Delay(1000, stoppingToken);
}
}
