public Stream EchoStream(Stream data)
{
Console.WriteLine($"[EchoStream]...Received length:{data.Length}, {Helper.ReadStr(data)}...Send TestFile.txt");
var stream = File.Open(Helper.GetTestFilePath(), FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
return(stream);
}
private static async Task RunRabbitMQAsync()
{
var host = new HostBuilder()
.ConfigureServices((context, services) =>
{
//set single target by DI.
services.AddNetRpcRabbitMQService(i => i.CopyFrom(Helper.GetMQOptions()));
services.AddNetRpcGrpcGateway <IService>(o =>
{
o.Host = "localhost";
o.Port = 50001;
});
services.AddNetRpcGrpcGateway <IService2>();
//set different target point.
//var p1 = NetRpcManager.CreateClientProxy<IService>(new Channel("localhost", 50001, ChannelCredentials.Insecure)).Proxy;
//var p2 = NetRpcManager.CreateClientProxy<IService2>(new Channel("localhost2", 50001, ChannelCredentials.Insecure)).Proxy;
//services.AddNetRpcContractSingleton(typeof(IService), p1);
//services.AddNetRpcContractSingleton(typeof(IService2), p2);
})
.Build();
await host.RunAsync();
}
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();
}
public Stream GetStream()
{
Console.WriteLine("[GetStream]...Send TestFile.txt");
var stream = File.Open(Helper.GetTestFilePath(), FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
return(stream);
}
private static async Task RabbitMQ()
{
//RabbitMQ
Console.WriteLine("\r\n--------------- Client RabbitMQ ---------------");
var services = new ServiceCollection();
services.AddNClientContract <IServiceAsync>();
services.AddNClientContract <IService>();
services.AddNRabbitMQClient(o => o.CopyFrom(Helper.GetMQOptions()));
var sp = services.BuildServiceProvider();
_clientProxy = sp.GetService <IClientProxy <IService> >();
_clientProxy.Connected += (_, _) => Console.WriteLine("[event] Connected");
_clientProxy.DisConnected += (_, _) => Console.WriteLine("[event] DisConnected");
_clientProxy.ExceptionInvoked += (_, _) => Console.WriteLine("[event] ExceptionInvoked");
//Heartbeat
_clientProxy.HeartbeatAsync += (s, e) =>
{
Console.WriteLine("[event] Heartbeat");
((IService)((IClientProxy)s).Proxy).Hearbeat();
return(Task.CompletedTask);
};
//clientProxy.StartHeartbeat(true);
_proxy = _clientProxy.Proxy;
_proxyAsync = sp.GetService <IClientProxy <IServiceAsync> >() !.Proxy;
RunTest();
await RunTestAsync();
}
public async Task <ComplexStream> ComplexCallAsync(CustomObj obj, string p1, Stream stream, Func <CustomCallbackObj, Task> cb, CancellationToken token)
{
Console.WriteLine($"[ComplexCallAsync]...receive:{obj}, p1:{p1}, streamLength:{stream.Length}");
for (var i = 1; i <= 3; i++)
{
Console.Write($"{i}, ");
await cb(new CustomCallbackObj { Progress = i });
await Task.Delay(1000, token);
}
var ret = new ComplexStream
{
Stream = File.Open(Helper.GetTestFilePath(), FileMode.Open, FileAccess.Read, FileShare.ReadWrite),
StreamName = "TestFile.txt",
InnerObj = new InnerObj
{
CustomObj = new CustomObj
{
Name = NameEnum.John
},
P1 = "中文p1!@#$%^&*()_+\"\":?~!@#$"
}
};
return(ret);
}
private static async Task Main(string[] args)
{
ServiceProvider sp;
var services = new ServiceCollection();
services.AddNClientContract <IServiceAsync>();
services.AddNRabbitMQClient(o => o.CopyFrom(Helper.GetMQOptions()));
sp = services.BuildServiceProvider();
var proxy = sp.GetService <IServiceAsync>();
for (var i = 0; i < 10; i++)
{
var i1 = i;
Task.Run(async() =>
{
Console.WriteLine($"Send {i1}");
await proxy.CallAsync(async p => Console.WriteLine(p), i1.ToString());
});
}
//for (int i = 0; i < 10; i++)
//{
// using (var stream = File.Open(Helper.GetTestFilePath(), FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
// await proxy.PostAsync(i.ToString(), stream);
// Console.WriteLine($"post {i}");
//}
Console.WriteLine("Send end");
Console.Read();
}
static async Task Main(string[] args)
{
var host = new HostBuilder()
.ConfigureServices((context, services) =>
{
services.Configure <GrpcClientOptions>("grpc", i =>
{
i.Host = "localhost";
i.Port = 50001;
});
services.AddNGrpcClient();
services.AddNClientContract <IService>("grpc");
services.Configure <RabbitMQClientOptions>("mq", i => { i.CopyFrom(Helper.GetMQOptions()); });
services.AddNRabbitMQClient();
services.AddHostedService <H>();
})
.Build();
await host.RunAsync();
Console.WriteLine("end");
Console.Read();
}
private static async Task Test_GetComplexStreamAsync()
{
Console.Write("[GetComplexStreamAsync]...");
var complexStream = await _proxyAsync.GetComplexStreamAsync();
using (var stream = complexStream.Stream)
Console.WriteLine($"length:{stream.Length}, {Helper.ReadStr(stream)}");
Console.WriteLine($", otherInfo:{complexStream.OtherInfo}");
}
private static void Test_GetComplexStream()
{
Console.Write("[GetComplexStream]...");
var complexStream = _proxy.GetComplexStream();
using (var stream = complexStream.Stream)
Console.WriteLine($"length:{stream.Length}, {Helper.ReadStr(stream)}");
Console.WriteLine($", otherInfo:{complexStream.OtherInfo}");
}
private static void Test_EchoStream()
{
using (var stream = File.Open(Helper.GetTestFilePath(), FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
Console.Write("[EchoStream]...Send TestFile.txt...");
var data = _proxy.EchoStream(stream);
Console.WriteLine($"Received length:{data.Length}, {Helper.ReadStr(data)}");
}
}
public ComplexStream GetComplexStream()
{
Console.WriteLine("[GetComplexStream]...Send TestFile.txt...this is other info");
return(new ComplexStream
{
Stream = File.Open(Helper.GetTestFilePath(), FileMode.Open, FileAccess.Read, FileShare.ReadWrite),
OtherInfo = "this is other info"
});
}
private static async Task Main(string[] args)
{
var h = Host.CreateDefaultBuilder(null)
.ConfigureWebHostDefaults(builder =>
{
builder.ConfigureKestrel((context, options) =>
{
options.ListenAnyIP(5101);
options.ListenAnyIP(50001, listenOptions => listenOptions.Protocols = HttpProtocols.Http2);
})
.ConfigureServices(services =>
{
services.AddCors();
services.AddSignalR();
services.AddNSwagger();
services.AddNHttpService();
services.AddNGrpcService();
services.AddNRabbitMQService(i => i.CopyFrom(Helper.GetMQOptions()));
services.AddNServiceContract <IService, Service>(ServiceLifetime.Scoped);
services.Configure <GrpcClientOptions>("grpc1", i => { i.Url = "http://localhost:50002"; });
services.Configure <GrpcClientOptions>("grpc2", i => { i.Url = "http://localhost:50003"; });
services.AddNGrpcClient(null, null, ServiceLifetime.Scoped);
services.Configure <ServiceSwaggerOptions>(i => i.HostPath = "http://localhost:5101/swagger");
services.Configure <ClientSwaggerOptions>("grpc1", i => i.HostPath = "http://localhost:5102/swagger");
services.Configure <ClientSwaggerOptions>("grpc2", i => i.HostPath = "http://localhost:5103/swagger");
services.AddNJaeger(i =>
{
i.Host = "m.k8s.yx.com";
i.Port = 36831;
i.ServiceName = "Service";
}, i => { i.LogActionInfoMaxLength = 1000; });
})
.Configure(app =>
{
app.UseCors(set =>
{
set.SetIsOriginAllowed(origin => true)
.AllowAnyHeader()
.AllowAnyMethod()
.AllowCredentials();
});
app.UseRouting();
app.UseEndpoints(endpoints => { endpoints.MapHub <CallbackHub>("/callback"); });
app.UseNSwagger();
app.UseNHttp();
app.UseNGrpc();
})
.ConfigureLogging(logging => { logging.AddConsole(); });
}).Build();
await h.RunAsync();
}
private static async Task Test_EchoStreamAsync()
{
using (var stream = File.Open(Helper.GetTestFilePath(), FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
Console.Write("[EchoStreamAsync]...Send TestFile.txt...");
var data = await _proxyAsync.EchoStreamAsync(stream);
Console.WriteLine($"Received length:{stream.Length}, {Helper.ReadStr(data)}");
}
}
static async Task Main(string[] args)
{
var host = NManager.CreateHost(Helper.GetMQOptions(),
null,
new ContractParam <IServiceAsync, ServiceAsync>());
Console.WriteLine("Service Opened.");
await host.RunAsync();
Console.Read();
}
public async Task PostAsync(string s1, Stream data)
{
Console.Write($"Receive: {s1}, stream:{Helper.ReadStr(data)}, start...");
for (var i = 0; i < 3; i++)
{
await Task.Delay(1000);
Console.Write($"{i}, ");
}
Console.WriteLine("end");
}
static async Task RunAsync()
{
var h = new HostBuilder()
.ConfigureServices((context, services) =>
{
services.AddNRabbitMQService(i => { i.CopyFrom(Helper.GetMQOptions()); });
services.AddNGrpcService(i => i.AddPort("0.0.0.0", 50001));
services.AddNServiceContract <IService, Service>();
})
.Build();
await h.RunAsync();
}
static void Main(string[] args)
{
//RabbitMQ
var serviceProxy = Helper.OpenRabbitMQService(new Service(), new ServiceAsync());
//add a Middleware
serviceProxy.UseMiddleware <TestGlobalExceptionMiddleware>("testArg1");
//Grpc wrap Exception to FaultException
Helper.OpenGrpcService(true, new Service(), new ServiceAsync());
Console.WriteLine("Service Opened.");
Console.Read();
}
private static async Task Main(string[] args)
{
var mpHost = new HostBuilder()
.ConfigureServices((_, services) =>
{
services.AddNRabbitMQService(i => i.CopyFrom(Helper.GetMQOptions()));
services.AddNServiceContract <IServiceAsync, ServiceAsync>();
})
.Build();
Console.WriteLine("Service Opened.");
await mpHost.RunAsync();
}
static void Main(string[] args)
{
var proxy = NetRpcManager.CreateClientProxy <IService>(Helper.GetMQParam()).Proxy;
var fileStream = File.Open(@"d:\4\1212.pdf", FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
for (int i = 0; i < 10; i++)
{
proxy.CallAsync(fileStream, j => Console.WriteLine(j), i.ToString());
Console.WriteLine($"Send {i}");
}
Console.WriteLine($"Send end");
Console.Read();
}
private static async Task RabbitMQ()
{
//RabbitMQ
Console.WriteLine("\r\n--------------- Client RabbitMQ ---------------");
var services = new ServiceCollection();
services.AddNClientContract <IServiceAsync>();
services.AddNClientContract <IService2Async>();
services.AddNRabbitMQClient(o => o.CopyFrom(Helper.GetMQOptions()));
var sp = services.BuildServiceProvider();
_c1 = sp.GetService <IClientProxy <IServiceAsync> >();
_c2 = sp.GetService <IClientProxy <IService2Async> >();
await TestAsync();
}
private static async Task Test_ComplexCallAsync()
{
using (var stream = File.Open(Helper.GetTestFilePath(), FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
Console.Write("[ComplexCallAsync]...Send TestFile.txt...");
var complexStream = await _c1.Proxy.ComplexCallAsync(
new CustomObj { Date = DateTime.Now, Name = "ComplexCall" },
stream,
async i => Console.Write(", " + i.Progress),
default);
using (var stream2 = complexStream.Stream)
Console.Write($", receive length:{stream.Length}, {Helper.ReadStr(stream2)}");
Console.WriteLine($", otherInfo:{complexStream.OtherInfo}");
}
}
private static async Task Main(string[] args)
{
var h = new HostBuilder()
.ConfigureServices((context, services) =>
{
services.AddOptions();
services.AddHostedService <MyHost>();
services.Configure <RabbitMQClientOptions>("mq", i => i.CopyFrom(Helper.GetMQOptions()));
services.Configure <GrpcClientOptions>("grpc", i => { i.Url = "http://localhost:50001"; });
services.AddNRabbitMQClient();
services.AddNGrpcClient();
})
.ConfigureLogging((context, builder) => { builder.AddConsole(); })
.Build();
await h.RunAsync();
}
public async Task <Ret> Call(InParam p, int i, Stream stream, Func <int, Task> progs, CancellationToken token)
{
Console.WriteLine($"{p}, {i}, {Helper.ReadStr(stream)}");
for (var i1 = 0; i1 < 3; i1++)
{
await progs(i1);
await Task.Delay(100, token);
}
return(new Ret
{
Stream = File.OpenRead(Helper.GetTestFilePath()),
P1 = "return p1"
});
}
public async Task <ComplexStream> ComplexCallAsync(CustomObj obj, Stream data, Func <CustomCallbackObj, Task> cb, CancellationToken token)
{
Console.Write($"[ComplexCallAsync]...Received length:{data.Length}, {Helper.ReadStr(data)}, ");
for (var i = 1; i <= 3; i++)
{
Console.Write($"{i}, ");
await cb(new CustomCallbackObj { Progress = i });
await Task.Delay(100, token);
}
Console.WriteLine("...Send TestFile.txt");
return(new ComplexStream
{
Stream = File.Open(Helper.GetTestFilePath(), FileMode.Open, FileAccess.Read, FileShare.ReadWrite),
OtherInfo = "this is other info"
});
}
static async Task Main(string[] args)
{
//rabbitMq
var mOpt = new MiddlewareOptions();
mOpt.UseMiddleware <TestGlobalExceptionMiddleware>();
var mqHost = NetRpcManager.CreateHost(Helper.GetMQOptions(),
mOpt, new Contract <IService, Service>(), new Contract <IServiceAsync, ServiceAsync>());
mqHost.RunAsync();
//grpc
var grpcHost = NetRpc.Grpc.NetRpcManager.CreateHost(Helper.GetGrpcServiceOptions(),
null, new Contract <IService, Service>(), new Contract <IServiceAsync, ServiceAsync>());
grpcHost.RunAsync();
Console.Read();
}
public ComplexStream ComplexCall(CustomObj obj, Stream data, Func <CustomCallbackObj, Task> cb)
{
Console.Write($"[ComplexCall]...Received length:{data.Length}, {Helper.ReadStr(data)}, ");
for (var i = 1; i <= 3; i++)
{
Console.Write($"{i}, ");
cb(new CustomCallbackObj {
Progress = i
});
Task.Delay(100).Wait();
}
Console.WriteLine("...Send TestFile.txt");
return(new ComplexStream
{
Stream = File.Open(Helper.GetTestFilePath(), FileMode.Open, FileAccess.Read, FileShare.ReadWrite),
OtherInfo = "this is other info"
});
}
static async Task Main(string[] args)
{
//RabbitMQ
Console.WriteLine("--- Client RabbitMQ ---");
var mqF = new RabbitMQClientConnectionFactoryOptions(Helper.GetMQOptions(), NullLoggerFactory.Instance);
_clientProxy = NManager.CreateClientProxy <IService>(mqF);
_clientProxy.Connected += (s, e) => Console.WriteLine("[event] Connected");
_clientProxy.DisConnected += (s, e) => Console.WriteLine("[event] DisConnected");
_clientProxy.ExceptionInvoked += (s, e) => Console.WriteLine("[event] ExceptionInvoked");
//Heartbeat
_clientProxy.HeartbeatAsync += (s, e) =>
{
Console.WriteLine("[event] Heartbeat");
((IService)((IClientProxy)s).Proxy).Hearbeat();
return(Task.CompletedTask);
};
//clientProxy.StartHeartbeat(true);
_proxy = _clientProxy.Proxy;
_proxyAsync = NManager.CreateClientProxy <IServiceAsync>(mqF).Proxy;
RunTest();
await RunTestAsync();
//Grpc
Console.WriteLine("\r\n--- Client Grpc ---");
var grpcF = new GrpcClientConnectionFactoryOptions(
new GrpcClientOptions {
Host = "localhost", Port = 50001
});
_clientProxy = NetRpc.Grpc.NManager.CreateClientProxy <IService>(grpcF);
_proxy = _clientProxy.Proxy;
_proxyAsync = NetRpc.Grpc.NManager.CreateClientProxy <IServiceAsync>(grpcF).Proxy;
RunTest();
await RunTestAsync();
Console.WriteLine("Test end.");
Console.Read();
}
public async Task StartAsync(CancellationToken cancellationToken)
{
try
{
var ret = await _s1.Call(new InParam { P1 = "123" }, 100, File.OpenRead(Helper.GetTestFilePath()),
async i => Console.WriteLine(i), CancellationToken.None);
Console.WriteLine($"ret:{ret.P1}, {Helper.ReadStr(ret.Stream)}");
using (var fs = File.OpenWrite(@"d:\1.rar"))
{
ret.Stream.CopyTo(fs);
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
static async Task Main(string[] args)
{
var proxy = NManager.CreateClientProxy <IServiceAsync>(Helper.GetMQOptions()).Proxy;
for (var i = 0; i < 10; i++)
{
var i1 = i;
Task.Run(async() =>
{
Console.WriteLine($"Send {i1}");
await proxy.CallAsync(async p => Console.WriteLine(p), i1.ToString());
});
}
//for (int i = 0; i < 10; i++)
//{
// using (var stream = File.Open(Helper.GetTestFilePath(), FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
// await proxy.PostAsync(i.ToString(), stream);
// Console.WriteLine($"post {i}");
//}
Console.WriteLine("Send end");
Console.Read();
}
