static async Task Main(string[] args)
{
Console.WriteLine("---- MQ test ----");
var mqOptions = Helper.GetMQOptions();
_c1 = NManager.CreateClientProxy <IService>(mqOptions);
_c2 = NManager.CreateClientProxy <IService2>(mqOptions);
await TestAsync();
Console.WriteLine("---- Http test ----");
var httpOptions = new HttpClientOptions {
ApiUrl = "http://localhost:5000", SignalRHubUrl = "http://localhost:5000/callback"
};
_c1 = NetRpc.Http.Client.NManager.CreateClientProxy <IService>(httpOptions);
_c2 = NetRpc.Http.Client.NManager.CreateClientProxy <IService2>(httpOptions);
await TestAsync();
Console.WriteLine("---- Grpc test ----");
GrpcClientOptions grpcOpt = new GrpcClientOptions {
Host = "localhost", Port = 50000
};
_c1 = NetRpc.Grpc.NManager.CreateClientProxy <IService>(grpcOpt);
_c2 = NetRpc.Grpc.NManager.CreateClientProxy <IService2>(grpcOpt);
await TestAsync();
Console.WriteLine("---- end ----");
Console.Read();
}
/// <summary>
/// Channel统一管理
/// </summary>
/// <param name="serviceDiscovery"></param>
/// <param name="loadBalancer"></param>
/// <param name="memoryCache"></param>
/// <param name="grpcClientOptions"></param>
public ChannelPool(IServiceDiscovery serviceDiscovery, ILoadBalancer loadBalancer, IMemoryCache memoryCache, IOptions <GrpcClientOptions> grpcClientOptions)
{
this._serviceDiscovery = serviceDiscovery;
this._loadBalancer = loadBalancer;
this._memoryCache = memoryCache;
this._grpcClientOptions = grpcClientOptions.Value;
}
static async Task Main(string[] args)
{
ThreadPool.SetMinThreads(500, 500);
//await Task.Delay(35000);
var services = new ServiceCollection();
var grpcOptions = new GrpcClientOptions()
{
Host = "172.25.189.157",
Port = 90
};
services.AddProxyClient(Options.Create(grpcOptions));
var scope = services.BuildServiceProvider().CreateScope();
var client = scope.ServiceProvider.GetRequiredService <ProxyGrpcClient>();
var task = new List <Task>();
for (var i = 0; i < 1000; i++)
{
var result = client.SetKey($"{Guid.NewGuid()}", new { hola = "holasdfadsfa" }, (int)TimeSpan.Parse("00:01:00").TotalMilliseconds);
var result2 = client.SetKey($"{Guid.NewGuid()}", new { hola = "hoasdfasdla" }, (int)TimeSpan.Parse("00:01:00").TotalMilliseconds);
var result3 = client.SetKey($"{Guid.NewGuid()}", new { hola = "asdfasdf" }, (int)TimeSpan.Parse("00:01:00").TotalMilliseconds);
var result4 = client.SetKey($"{Guid.NewGuid()}", new { hola = "asfdasdfasdf" }, (int)TimeSpan.Parse("00:01:00").TotalMilliseconds);
task.Add(result);
task.Add(result2);
task.Add(result3);
task.Add(result4);
}
await Task.WhenAll(task);
var getResult = await client.GetKey <object>("mykey0");
var getResult1 = await client.GetKey <object>("mykey1");
var getResult2 = await client.GetKey <object>("mykey2");
var getResult3 = await client.GetKey <object>("mykey3");
var getResult4 = await client.GetKey <object>("mykey4");
Console.WriteLine("Value of Get keys {0}", getResult);
var delete = await client.DeleteKey("mykey0");
Console.WriteLine("Deleted keys {0}", delete.Status);
getResult = await client.GetKey <object>("mykey");
Console.WriteLine("Second validation after delete Get keys {0}", getResult);
var deleteNonExists = await client.DeleteKey("mykey-notexists");
Console.WriteLine("Deleted keys {0}", deleteNonExists?.Status ?? false);
}
static void Main(string[] args)
{
var options = new GrpcClientOptions()
{
Host = "svc-kadder-server",
Port = 80,
NamespaceName = "Atlantis.Simple",
ServiceName = "AtlantisService",
ScanAssemblies = new string[]
{
typeof(IPersonMessageServicer).Assembly.FullName
}
};
IServiceCollection services = new ServiceCollection();
services.AddLogging(b => b.AddConsole());
services.AddTransient(typeof(ILogger <>), typeof(NullLogger <>));
services.AddKadderGrpcClient(builder =>
{
builder.RegClient(options);
//builder.RegShareInterceptor<Kadder.Simple.Client.LoggerInterceptor>();
});
var provider = services.BuildServiceProvider();
provider.ApplyKadderGrpcClient();
var log = provider.GetService <ILogger <GrpcClient> >();
log.LogInformation("dd");
// TestInterceptor(provider);
TestNumber(provider);
Console.ReadLine();
// var channel = new Channel("127.0.0.1", 3002, ChannelCredentials.Insecure);
// channel.ConnectAsync().Wait();
// AtlantisServiceClient client=new AtlantisServiceClient(channel);
//
// var result= client.Hello(message);
// // var serailizer=new ProtobufBinarySerializer();
// // var s=serailizer.Serialize(message);
// // foreach(var b in s)
// // {
// // Console.Write($" {b}");
// }
}
/// <summary>
/// Create provider
/// </summary>
/// <param name="setups"></param>
/// <returns></returns>
public static IServiceProvider CreateProvider(Action <string, ClientConfigurator> customSetup, params ClientSetup[] setups)
{
// init collection
var collection = new ServiceCollection();
// add logging
var logSink = new TestLogSink();
collection.AddSingleton(logSink);
collection.AddLogging(cfg => cfg.AddProvider(new TestLoggerProvider(logSink)));
// setup clients
setups.ToList().ForEach(setup => {
// add grpc client one
collection.AddGrpcClient(cfg => {
// set name
if (!string.IsNullOrWhiteSpace(setup.Name))
{
cfg.SetName(setup.Name);
}
// add services
cfg.AddService <ITestService>();
cfg.AddService <Greeter.GreeterClient>();
// add channels
setup.Ports.ToList().ForEach(port => {
cfg.AddHost(new GrpcChannelConnectionData
{
Port = port,
Url = "127.0.0.1"
});
});
// client options
var opts = new GrpcClientOptions
{
TimeoutMs = setup.TimeoutMs,
StatusServiceEnabled = setup.EnableStatus
};
cfg.SetClientOptions(opts);
// custom setup
customSetup?.Invoke(setup.Name, cfg);
});
});
// build provider for services
return(collection.BuildServiceProvider());
}
protected HammeredSampleServiceClient(GrpcClientOptions options) : base(options, new ProtoBufSerializer())
{
}
/// <summary>
/// Set the centralized Lucene engine as the search engine and
/// sets the <see cref="GrpcServiceClient"/> as the client for
/// search service communication.
/// </summary>
/// <param name="repositoryBuilder">The <see cref="IRepositoryBuilder"/> instance.</param>
/// <param name="options">Grpc client options</param>
public static IRepositoryBuilder UseLucene29CentralizedSearchEngineWithGrpc(this IRepositoryBuilder repositoryBuilder, GrpcClientOptions options)
{
//TODO: refactor the Grpc client to be able to work as a hosted service and use dependency injection correctly
// shortcut for bypassing certificate validation using a single configurable flag
if (!options.ValidateServerCertificate)
{
options.ChannelOptions.HttpClient = new HttpClient(new HttpClientHandler
{
ServerCertificateCustomValidationCallback = (message, certificate2, arg3, arg4) => true
});
options.ChannelOptions.DisposeHttpClient = true;
}
repositoryBuilder
.UseLucene29CentralizedSearchEngine()
.UseLucene29CentralizedServiceClient(CreateGrpcServiceClient(options.ServiceAddress, options.ChannelOptions));
SnLog.WriteInformation("GrpcServiceClient set as Lucene29 Centralized Service Client.");
return(repositoryBuilder);
}
protected GrpcClientBase(GrpcClientOptions options, ISerializer serializer)
{
_channel = new G.Channel(options.Url, options.Port, G.ChannelCredentials.Insecure);
_invoker = new G.DefaultCallInvoker(_channel);
_serializer = serializer;
}
