public async Task <bool> TryConnectMain(string ip_address, int port)
{
try {
var crt = new SslCredentials(file);
this.main_room_chan = new Channel(
ip_address, port, crt
);
if (ConfigForm.Connector == "")
{
ConfigForm.Connector = "grpc";
}
if (ConfigForm.Host == "")
{
ConfigForm.Host = ip_address;
}
if (ConfigForm.Port == 0)
{
ConfigForm.Port = port;
}
return(true);
} catch (RpcException e) {
Debug.LogError(e);
return(false);
throw e;
}
}
public static void Main(string[] args)
{
var option = int.Parse(args[0]);
var cacert = File.ReadAllText(@"ca.crt");
var cert = File.ReadAllText(@"client.crt");
var key = File.ReadAllText(@"client.key");
var keypair = new KeyCertificatePair(cert, key);
SslCredentials creds = new SslCredentials(cacert, keypair);
var channel = new Channel("DESKTOP-1UHNCG6", Port, creds);
var client = new EmployeeServiceClient(channel);
switch (option)
{
case 1:
SendMetadataAsync(client).Wait();
break;
case 2:
GetByBadgeNumber(client).Wait();
break;
case 3:
GetAll(client).Wait();
break;
case 4:
AddPhoto(client).Wait();
break;
case 5:
SaveAll(client).Wait();
break;
}
}
public void Init()
{
var rootCert = File.ReadAllText(TestCredentials.ClientCertAuthorityPath);
var keyCertPair = new KeyCertificatePair(
File.ReadAllText(TestCredentials.ServerCertChainPath),
File.ReadAllText(TestCredentials.ServerPrivateKeyPath));
var serverCredentials = new SslServerCredentials(new[] { keyCertPair }, rootCert, true);
var clientCredentials = new SslCredentials(rootCert, keyCertPair);
server = new Server
{
Services = { TestService.BindService(new TestServiceImpl()) },
Ports = { { Host, ServerPort.PickUnused, serverCredentials } }
};
server.Start();
var options = new List <ChannelOption>
{
new ChannelOption(ChannelOptions.SslTargetNameOverride, TestCredentials.DefaultHostOverride)
};
channel = new Channel(Host, server.Ports.Single().BoundPort, clientCredentials, options);
client = new TestService.TestServiceClient(channel);
}
public void InitClientAndServer(bool clientAddKeyCertPair,
SslClientCertificateRequestType clientCertRequestType,
VerifyPeerCallback verifyPeerCallback = null)
{
rootCert = File.ReadAllText(TestCredentials.ClientCertAuthorityPath);
keyCertPair = new KeyCertificatePair(
File.ReadAllText(TestCredentials.ServerCertChainPath),
File.ReadAllText(TestCredentials.ServerPrivateKeyPath));
var serverCredentials = new SslServerCredentials(new[] { keyCertPair }, rootCert, clientCertRequestType);
var clientCredentials = new SslCredentials(rootCert, clientAddKeyCertPair ? keyCertPair : null, verifyPeerCallback);
// Disable SO_REUSEPORT to prevent https://github.com/grpc/grpc/issues/10755
server = new Server(new[] { new ChannelOption(ChannelOptions.SoReuseport, 0) })
{
Services = { TestService.BindService(new SslCredentialsTestServiceImpl()) },
Ports = { { Host, ServerPort.PickUnused, serverCredentials } }
};
server.Start();
var options = new List <ChannelOption>
{
new ChannelOption(ChannelOptions.SslTargetNameOverride, TestCredentials.DefaultHostOverride)
};
channel = new Channel(Host, server.Ports.Single().BoundPort, clientCredentials, options);
client = new TestService.TestServiceClient(channel);
}
/// <summary>
/// Creates the specific communication client based on grpc technoligy
/// </summary>
/// <param name="address">The address.</param>
/// <param name="chunkSender">The chunkSender<see cref="IChunkSender{Command, FetchRequest, GrpcResponse}"/></param>
/// <param name="chunkReceiver">The chunkReceiver<see cref="IChunkReceiver{Command}"/></param>
/// <returns>The <see cref="IClient{Command, FetchRequest, GrpcResponse}"/></returns>
public static IClient <Command, FetchRequest, GrpcResponse> Create(string address, IChunkSender <Command, FetchRequest, GrpcResponse> chunkSender, IChunkReceiver <Command> chunkReceiver)
{
try
{
var endPoint = address.ToIpEndpoint();
Channel channel = null;
ChannelOption optionReceive = new ChannelOption(ChannelOptions.MaxReceiveMessageLength, GrpcStream.MaxPackageSize);
ChannelOption optionSend = new ChannelOption(ChannelOptions.MaxSendMessageLength, GrpcStream.MaxPackageSize);
if (System.IO.File.Exists("ca.crt"))
{
var cacert = System.IO.File.ReadAllText(@"ca.crt");
var clientcert = System.IO.File.ReadAllText(@"client.crt");
var clientkey = System.IO.File.ReadAllText(@"client.key");
var ssl = new SslCredentials(cacert, new KeyCertificatePair(clientcert, clientkey));
channel = new Channel(string.Format("{0}:{1}", endPoint.Address.ToString(), endPoint.Port), ssl);
}
else
{
channel = new Channel(string.Format("{0}:{1}", endPoint.Address.ToString(), endPoint.Port), ChannelCredentials.Insecure, new List <ChannelOption>()
{
optionReceive, optionSend
});
}
return(new GrpcClient(channel, endPoint, chunkSender, chunkReceiver));
}
catch (Exception ex)
{
throw new Exception("Grpc initialization error", ex);
}
}
static void Main(string[] args)
{
// Read exported (PEM formatted) server TLS certificate from disk
var serverCert = File.ReadAllText("<< ADD PATH TO EXPORTED SERVER CERTIFICATE >>");
var tlsCertCredentials = new SslCredentials(serverCert);
// Apply the api key to every request that is made with the client
var apiKeyCredentials = CallCredentials.FromInterceptor((context, metadata) =>
{
metadata.Add("ibahdapi-apikey", "<< ADD API KEY >>");
return(Task.CompletedTask);
});
var combinedCredentials = ChannelCredentials.Create(tlsCertCredentials, apiKeyCredentials);
// gRPC channel setup to connect to ibaHD-API endpoint in ibaHD-Server
// Increasing the default message size (~4MB) is recommended
var channel = new Channel("127.0.0.1:9003", combinedCredentials,
new List <ChannelOption> {
new ChannelOption(ChannelOptions.MaxReceiveMessageLength, Int32.MaxValue)
});
// Instantiate ibaHD-API client on the gRPC channel
var client = new HdApiService.HdApiServiceClient(channel);
// Simple request to retrieve stores
var response = client.GetHdStores(new GetHdStoresRequest());
// Clean channel shutdown (Check ShutdownAsync() documentation for details)
channel.ShutdownAsync().Wait();
Console.WriteLine(response);
Console.ReadLine();
}
/// <summary>
/// Create a new channel.
/// </summary>
/// <param name="uriStr"></param>
/// <param name="crt">Certificate</param>
/// <returns></returns>
private Channel CreateChannel(string uriStr, string crt)
{
var channelCredentials = new SslCredentials(crt);
var channel = new Channel(uriStr, channelCredentials);
return(channel);
}
private static async Task <HelloChatty.HelloChattyClient> ConnectProtoClient(string serverAddress)
{
var key = System.IO.File.ReadAllText(client_private_key_file);
var cert = System.IO.File.ReadAllText(client_certificate_file);
var serverCert = System.IO.File.ReadAllText(server_certificate_file);
var creds = new SslCredentials(
serverCert, new KeyCertificatePair(key, cert)
);
var rpcChannel = new Channel(serverAddress, creds,
new List <ChannelOption> {
// docs about keeping grpc connection alive: https://github.com/grpc/grpc/blob/master/doc/keepalive.md
// the mappings of the fields are in file grpc/include/grpc/impl/codegen/grpc_types.h in the official grpc core repo https://github.com/grpc/grpc
new ChannelOption("grpc.keepalive_time_ms", 1000), // keepalive ping every X ms
new ChannelOption("grpc.keepalive_timeout_ms", 10 * 1000), // peer must reply to our ping within this
new ChannelOption("grpc.keepalive_permit_without_calls", 1), // allow keepalive without calls at all
// new ChannelOption ( "grpc.http2.max_pings_without_data", 0 ), // server-only setting
// new ChannelOption ( "grpc.http2.min_ping_interval_without_data_ms", 1000), // server-only setting
new ChannelOption("grpc.http2.max_ping_strikes", 1),
}
);
var rpcClient = new HelloChatty.HelloChattyClient(rpcChannel);
await rpcChannel.ConnectAsync();
if (rpcChannel.State == ChannelState.Ready)
{
return(rpcClient);
}
throw new Exception($@"For unknown reason, the channel state is still {rpcChannel.State}");
}
static ChannelCredentials CreateCredentials(bool mutualTls, bool useJwt)
{
var certsPath = Environment.GetEnvironmentVariable("CERTS_PATH");
var caRoots = File.ReadAllText(Path.Combine(certsPath, "ca.pem"));
ChannelCredentials channelCredentials;
if (!mutualTls)
{
channelCredentials = new SslCredentials(caRoots);
}
else
{
var keyCertPair = new KeyCertificatePair(
File.ReadAllText(Path.Combine(certsPath, "client.pem")),
File.ReadAllText(Path.Combine(certsPath, "client.key")));
channelCredentials = new SslCredentials(caRoots, keyCertPair);
}
if (useJwt)
{
var authInterceptor = new AsyncAuthInterceptor(async(context, metadata) =>
{
metadata.Add(
new Metadata.Entry("authorization", "Bearer " + GenerateJwt()));
});
var metadataCredentials = CallCredentials.FromInterceptor(authInterceptor);
channelCredentials = ChannelCredentials.Create(channelCredentials, metadataCredentials);
}
return(channelCredentials);
}
const string target = "127.0.0.1:50051";//connection IP on which the client want to connect
static async Task Main(string[] args)
{
//WITHOUT SSL
//Channel channel = new Channel(target, ChannelCredentials.Insecure);
//WITH SSL
var clientCert = File.ReadAllText("ssl/client.crt");
var clientKey = File.ReadAllText("ssl/client.key");
var caCrt = File.ReadAllText("ssl/ca.crt");
var channelCredentials = new SslCredentials(caCrt, new KeyCertificatePair(clientCert, clientKey));
Channel channel = new Channel("localhost", 50051, channelCredentials);
//-------------------------------------------------------------
await channel.ConnectAsync().ContinueWith((task) =>
{
if (task.Status == TaskStatus.RanToCompletion)
{
Console.WriteLine("The Client Connected Successfully");
}
});
//var client = new DummyService.DummyServiceClient(channel);
var client = new GreetingService.GreetingServiceClient(channel);
DoSimpleGreet(client);//UNARY
//await DoManyGreetings(client);//SERVER STREAMING
//await DoLongGreet(client);//CLIENT STREAMING
//await DoGreetEveryone(client);//BI-DIRECTINAL STREAMING
channel.ShutdownAsync().Wait();
Console.ReadKey();
}
static async Task Main(string[] args)
{
if (args.Length < 6)
{
throw new Exception("Arguments are missing. Expecting: <private key> <public key> <server CA> <external IP> <namepace> <enable multi-cluster>");
}
string clientKey = File.ReadAllText(args[0]);
string clientCert = File.ReadAllText(args[1]);
string serverCa = File.ReadAllText(args[2]);
string externalIp = args[3];
string namespaceArg = args[4];
bool multicluster = bool.Parse(args[5]);
var creds = new SslCredentials(serverCa, new KeyCertificatePair(clientCert, clientKey));
var channel = new Channel(externalIp + ":443", creds);
var client = new AllocationService.AllocationServiceClient(channel);
try {
var response = await client.AllocateAsync(new AllocationRequest {
Namespace = namespaceArg,
MultiClusterSetting = new V1Alpha1.MultiClusterSetting {
Enabled = multicluster,
}
});
Console.WriteLine(response);
}
catch (RpcException e)
{
Console.WriteLine($"gRPC error: {e}");
}
}
static async Task <int> Main(string[] args)
{
Console.WriteLine("GrpcClient started.");
var channelCredentials = new SslCredentials(File.ReadAllText(@"Certs\certificate.crt"));
var channel = new Channel($"localhost:{PORT}", channelCredentials);
var nl = Environment.NewLine;
var orgTextColor = Console.ForegroundColor;
var client = new Client();
await client.Do(
channel,
() =>
{
Console.Write($"Connected to server.{nl}ClientId = ");
Console.ForegroundColor = ConsoleColor.Cyan;
Console.Write($"{client.ClientId}");
Console.ForegroundColor = orgTextColor;
Console.WriteLine($".{nl}Enter string message to server.{nl}" +
$"You will get response if your message will contain question mark '?'.{nl}" +
$"Enter empty message to quit.{nl}");
},
() => Console.WriteLine("Shutting down...")
);
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
return(0);
}
private kubemqClient CreateNewClient()
{
Channel channel;
string kubemqAddress = GetKubeMQAddress();
string clientCertFile = ConfigurationLoader.GetCertificateFile();
List <ChannelOption> options = new List <ChannelOption>();
options.Add(new ChannelOption("grpc.max_receive_message_length", 1024 * 1024 * 1024));
if (!string.IsNullOrWhiteSpace(clientCertFile))
{
// Open SSL/TLS connection
var channelCredentials = new SslCredentials(File.ReadAllText(clientCertFile));
channel = new Channel(kubemqAddress, channelCredentials, options);
}
else
{
// Open Insecure connection
channel = new Channel(kubemqAddress, ChannelCredentials.Insecure, options);
}
_client = new kubemqClient(channel);
//logger.LogTrace("Opened connection to KubeMQ server (ip:port) {0}", kubemqAddress);
return(_client);
}
public async Task <ChannelCredentials> Generate(string type, string configuration)
{
var sslConfiguration = JsonSerializerHelper.Deserialize <SSLConfiguration>(configuration);
var cacert = File.ReadAllText(sslConfiguration.CAFile);
SslClientCertificateRequestType clientStrategy;
switch (sslConfiguration.ClientStrategy)
{
case 1:
clientStrategy = SslClientCertificateRequestType.DontRequest;
break;
default:
clientStrategy = SslClientCertificateRequestType.RequestAndRequireAndVerify;
break;
}
SslCredentials sslCredentials;
if (clientStrategy == SslClientCertificateRequestType.RequestAndRequireAndVerify)
{
var servercert = File.ReadAllText(sslConfiguration.ChannelFile);
var serverkey = File.ReadAllText(sslConfiguration.KeyFile);
var keypair = new KeyCertificatePair(servercert, serverkey);
sslCredentials = new SslCredentials(cacert, keypair);
}
else
{
sslCredentials = new SslCredentials(cacert);
}
return(await Task.FromResult(sslCredentials));
}
public static void Main(string[] args)
{
var callCre = CallCredentials.FromInterceptor(MyAsyncAuthInterceptor);
var cacert = File.ReadAllText(@"C:\Sertifika\ca.crt");
var clientcert = File.ReadAllText(@"C:\Sertifika\client.crt");
var clientkey = File.ReadAllText(@"C:\Sertifika\client.key");
var sslCrd = new SslCredentials(cacert, new KeyCertificatePair(clientcert, clientkey));
var crd = ChannelCredentials.Create(sslCrd, callCre);
channel = new Channel("localhost:50051", crd);
var channel2 = new Channel("localhost:50052", crd);
var inv = new MyInvoker(new Channel[] { channel, channel2 });
var client = new Greeter.GreeterClient(inv);
while (true)
{
var user = Console.ReadLine();
if (user == "q")
{
break;
}
var reply = client.SayHello(new HelloRequest {
Name = user
});
Console.WriteLine("Greeting: " + reply.Message);
}
channel.ShutdownAsync().Wait();
channel2.ShutdownAsync().Wait();
}
static async Task Main(string[] args)
{
string serverCa = File.ReadAllText("../creds/service.pem");
string clientKey = File.ReadAllText("../creds/client.key");
string clientCert = File.ReadAllText("../creds/client.pem");
var creds = new SslCredentials(serverCa, new KeyCertificatePair(clientCert, clientKey));
var channel = new Channel("localhost:12343", creds);
var client = new HelloWorldService.HelloWorldServiceClient(channel);
try {
var response = await client.TestAsync(new TestRequest { Query = "mTLS random" });
Console.WriteLine(response.Message);
}
catch (RpcException e)
{
Console.WriteLine($"gRPC error: {e.Status.Detail}");
Console.WriteLine($"{e}");
}
catch
{
Console.WriteLine($"Unexpected error calling HelloWorldService");
throw;
}
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
}
private static void Register()
{
Serilog.ILogger serilog = new LoggerConfiguration()
.Enrich.FromLogProxy()
.Destructure.UsingAttributes()
.WriteTo.Seq(EnvVars.SeqAddress())
.CreateLogger();
Log.Logger = serilog;
var builder = new ContainerBuilder();
// SSL gRPC
var caCrt = File.ReadAllText(EnvVars.CaCrtPath());
var sslCredentials = new SslCredentials(caCrt);
var registrationEngineGrpcChannel = new Channel(
EnvVars.Target(@"RegistrationEngineHost", @"RegistrationEnginePort"),
sslCredentials);
// Create MagicOnion dynamic client proxy
var registrationEngineGrpcClient = TrackingProxy.Create <IRegistrationEngineGrpc>(registrationEngineGrpcChannel);
var registrationEngine = LogProxy.Create <IRegistrationEngine>(new RegistrationEngineClient(registrationEngineGrpcClient), serilog, LogType.All);
builder.RegisterInstance <Serilog.ILogger>(serilog);
builder.RegisterInstance <IRegistrationEngine>(registrationEngine);
builder.RegisterType <MembershipManager>().As <IMembershipManager>();
IContainer container = builder.Build();
// Set up the service locator
ServiceLocator.SetLocatorProvider(() => new AutofacServiceLocator(container));
GrpcEnvironment.SetLogger(new ConsoleLogger());
}
public ISender GetSender(ILoggerFactory loggerFactory, Configuration.SenderConfiguration senderConfiguration)
{
var logger = loggerFactory.CreateLogger <GrpcSenderFactory>();
ChannelCredentials credentials;
if (!string.IsNullOrEmpty(senderConfiguration.GrpcRootCertificate))
{
logger.LogDebug("Using TLS gRPC channel with data from the configuration.");
KeyCertificatePair keypair = null;
if (!string.IsNullOrEmpty(senderConfiguration.GrpcClientChain) &&
!string.IsNullOrEmpty(senderConfiguration.GrpcClientKey))
{
var clientcert = File.ReadAllText(senderConfiguration.GrpcClientChain);
var clientkey = File.ReadAllText(senderConfiguration.GrpcClientKey);
keypair = new KeyCertificatePair(clientcert, clientkey);
}
var rootcert = File.ReadAllText(senderConfiguration.GrpcRootCertificate);
credentials = new SslCredentials(rootcert, keypair);
}
else
{
logger.LogDebug("Using insecure gRPC channel without credentials.");
credentials = ChannelCredentials.Insecure;
}
logger.LogDebug("Using the gRPC Sender to send spans directly to the endpoint.");
return(new GrpcSender(
StringOrDefault(senderConfiguration.GrpcTarget, GrpcSender.DefaultCollectorGrpcTarget),
credentials,
0 /* max packet size */));
}
private static ChannelCredentials GetRootCertificateCredentials()
{
var rootCert = "";
var assetPath = UnityEngine.Application.streamingAssetsPath;
var path = Path.Combine(assetPath, "ca.crt");
#if UNITY_IOS
using (var streamReader = new StreamReader(path))
{
rootCert = streamReader.ReadToEnd();
}
#elif UNITY_ANDROID
var www = new WWW(path);
while (!www.isDone)
{
}
using (var txtReader = new StringReader(www.text))
{
rootCert = txtReader.ReadToEnd();
}
#else
rootCert = File.ReadAllText(path);
#endif
var credentials = new SslCredentials(rootCert);
return(credentials);
}
static void Main(string[] args)
{
// setup the channel
var caCert = File.ReadAllText(@"certs/ca-chain.pem");
var clientCert = File.ReadAllText(@"certs/certificate.pem");
var clientKey = File.ReadAllText(@"certs/key.pem");
var ssl = new SslCredentials(caCert, new KeyCertificatePair(clientCert, clientKey));
Channel channel = new Channel("grpc.pub1.passkit.io", 443, ssl);
// run member sample code
MembersDemo md = new MembersDemo(channel);
md.RunSamples();
// run coupon sample code
CouponsDemo cd = new CouponsDemo(channel);
cd.RunSamples();
// run flights sample code
FlightsDemo fd = new FlightsDemo(channel);
fd.RunSamples();
channel.ShutdownAsync().Wait();
}
public BTrDB(string endpoint, string apikey)
{
SslCredentials systemCAs = new SslCredentials();
this.channel = new Channel(endpoint, systemCAs);
this.client = new V5Api.BTrDB.BTrDBClient(this.channel);
}
public static void Main(string[] args)
{
const int port = 9000;
var cacert = File.ReadAllText("Keys/ca.crt");
var cert = File.ReadAllText("Keys/client.crt");
var key = File.ReadAllText("Keys/client.key");
var keypair = new KeyCertificatePair(cert, key);
var sslCreds = new SslCredentials(cacert, keypair);
var channel = new Channel("Alexiss-MacBook-Pro.local", port, sslCreds);
var client = new UserServiceClient(channel);
Console.WriteLine("--- UNARY CALL ---------------------");
GetByUserIdAsync(client).Wait();
Console.WriteLine("------------------------------------");
Console.WriteLine("--- SERVER STREAMING CALL ----------");
GetAllAsync(client).Wait();
Console.WriteLine("------------------------------------");
Console.WriteLine("--- CLIENT STREAMING CALL ----------");
AddImageAsync(client).Wait();
Console.WriteLine("------------------------------------");
Console.WriteLine("--- BIDIRECTIONAL STREAMING CALL ---");
SaveAllAsync(client).Wait();
Console.WriteLine("------------------------------------");
}
private async Task <ChannelCredentials> CreateCredentialsAsync(bool?useTestCaOverride = null)
{
var credentials = ChannelCredentials.Insecure;
if (options.UseTls.GetValueOrDefault())
{
credentials = new SslCredentials();
}
if (options.TestCase == "jwt_token_creds")
{
var googleCredential = await GoogleCredential.GetApplicationDefaultAsync();
Assert.IsTrue(googleCredential.IsCreateScopedRequired);
credentials = ChannelCredentials.Create(credentials, googleCredential.ToCallCredentials());
}
if (options.TestCase == "compute_engine_creds")
{
var googleCredential = await GoogleCredential.GetApplicationDefaultAsync();
Assert.IsFalse(googleCredential.IsCreateScopedRequired);
credentials = ChannelCredentials.Create(credentials, googleCredential.ToCallCredentials());
}
return(credentials);
}
public async Task ConnectAsync(RobotConnectionInfo connectionInfo)
{
if (Client == null)
{
//create channel
var ssl = new SslCredentials(connectionInfo.Certificate);
var interceptor = new AsyncAuthInterceptor((context, metadata) =>
{
metadata.Add("authorization", $"Bearer {connectionInfo.Token}");
return(Task.CompletedTask);
});
var cred = ChannelCredentials.Create(ssl, CallCredentials.FromInterceptor(interceptor));
_channel = new Channel(connectionInfo.IpAddress, 443, cred, new ChannelOption[] { new ChannelOption("grpc.ssl_target_name_override", connectionInfo.RobotName) });
//connect to client
try
{
await _channel.ConnectAsync(DateTime.UtcNow.AddSeconds(10));
}
catch (TaskCanceledException ex)
{
throw new VectorConnectionException("could not connect to Vector. insure IP address is correct and that Vector is turned on", ex);
}
//create client
Client = new ExternalInterfaceClient(_channel);
IsConnected = true;
}
}
private void Reset(GrpcClientOptions opt)
{
#if NETCOREAPP3_1
var host = new Uri(opt.Url !).Host;
var port = new Uri(opt.Url !).Port;
_client = new Client(GrpcChannel.ForAddress(opt.Url !, opt.ChannelOptions !), host, port, opt.ToString());
#else
if (string.IsNullOrEmpty(opt.PublicKey))
{
_client = new Client(new Channel(opt.Host, opt.Port, ChannelCredentials.Insecure), opt.Host !, opt.Port, opt.ToString());
}
else
{
Channel channel;
var ssl = new SslCredentials(opt.PublicKey);
if (string.IsNullOrEmpty(opt.SslTargetName))
{
channel = new Channel(opt.Host, opt.Port, ssl);
}
else
{
var options = new List <ChannelOption>();
options.Add(new ChannelOption(ChannelOptions.SslTargetNameOverride, opt.SslTargetName));
channel = new Channel(opt.Host, opt.Port, ssl, options);
}
_client = new Client(channel, opt.Host !, opt.Port, opt.ToString());
}
#endif
_client.Connect();
}
/// <summary>
/// Creates a channel/client pair with the appropriate options and interceptors.
/// </summary>
/// <returns>A tuple of the channel and client</returns>
private async Task <GrpcClient> CreateClientAsync(DnsEndPoint remoteEndpoint)
{
var certificate = await RetrieveServerCertificateAsync(remoteEndpoint);
if (certificate == null)
{
return(null);
}
Logger.LogDebug($"Upgrading connection to TLS: {certificate}.");
ChannelCredentials credentials = new SslCredentials(TlsHelper.ObjectToPem(certificate), _clientKeyCertificatePair);
var channel = new Channel(remoteEndpoint.ToString(), credentials, new List <ChannelOption>
{
new ChannelOption(ChannelOptions.MaxSendMessageLength, GrpcConstants.DefaultMaxSendMessageLength),
new ChannelOption(ChannelOptions.MaxReceiveMessageLength, GrpcConstants.DefaultMaxReceiveMessageLength),
new ChannelOption(ChannelOptions.SslTargetNameOverride, GrpcConstants.DefaultTlsCommonName)
});
var nodePubkey = AsyncHelper.RunSync(() => _accountService.GetPublicKeyAsync()).ToHex();
var interceptedChannel = channel.Intercept(metadata =>
{
metadata.Add(GrpcConstants.PubkeyMetadataKey, nodePubkey);
return(metadata);
}).Intercept(new RetryInterceptor());
var client = new PeerService.PeerServiceClient(interceptedChannel);
return(new GrpcClient(channel, client, certificate));
}
public static async Task <GreetingResponse> Execute(string host, int port, GreetingRequest greetingRequest)
{
var clientCert = File.ReadAllText("ssl/client.crt");
var clientKey = File.ReadAllText("ssl/client.key");
var caCrt = File.ReadAllText("ssl/ca.crt");
var channelCredentials = new SslCredentials(caCrt, new KeyCertificatePair(clientCert, clientKey));
Channel channel = null;
GreetingResponse response;
try
{
channel = new Channel(host, port, channelCredentials);
await channel.ConnectAsync();
var client = new GreetingService.GreetingServiceClient(channel);
response = await client.GreetAsync(greetingRequest, deadline : DateTime.UtcNow.AddMilliseconds(5000));
}
catch (Exception)
{
// log
throw;
}
finally
{
if (channel != null)
{
await channel.ShutdownAsync();
}
}
return(response);
}
static void Main(string[] args)
{
Console.WriteLine("Press any key to start...");
Console.ReadKey();
var cacert = File.ReadAllText(CertPath + @"ca.crt");
var cert = File.ReadAllText(CertPath + @"client.crt");
var key = File.ReadAllText(CertPath + @"client.key");
var keypair = new KeyCertificatePair(cert, key);
var creds = new SslCredentials(cacert, keypair);
// The host value should be same with COMPUTERNAME in generate_crt_key.bat
var channel = new Channel("localhost", Port, creds);
var client = new PingClient(new PingApi.PingApiClient(channel));
// Test echo
client.Ping("sender1", 10L);
client.Ping("sender2", 100L);
client.Ping("sender3", 1000L);
client.Ping("sender4", 10000L);
client.Ping("sender5", 100000L);
client.Ping("sender6", 1000000L);
channel.ShutdownAsync().Wait();
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
}
private async Task <StreamingRecognizeStream> GetGoogleStream(int SampleRate)
{
var sslCredentials = new SslCredentials();
var speechBuilder = new SpeechClientBuilder();
speechBuilder.ChannelCredentials = sslCredentials;
//speechBuilder.Endpoint = "google.com/speech-api/";
var speech = speechBuilder.Build();
var streamingCall = speech.StreamingRecognize(CallSettings.FromHeader("x-goog-api-key", ApiKey));
// Write the initial request with the config.
await streamingCall.WriteAsync(
new StreamingRecognizeRequest()
{
StreamingConfig = new StreamingRecognitionConfig()
{
Config = new RecognitionConfig()
{
Encoding = RecognitionConfig.Types.AudioEncoding.Linear16,
SampleRateHertz = SampleRate,
LanguageCode = CultureLanguage.ToString(),
EnableAutomaticPunctuation = false,
AudioChannelCount = 1,
UseEnhanced = true
},
InterimResults = false,
}
});
return(streamingCall);
}
public ChatServiceClient()
{
// Locate required files and set true to enable SSL
var secure = false;
if (secure)
{
// create secure channel
var serverCACert = File.ReadAllText(@"C:\localhost_server.crt");
var clientCert = File.ReadAllText(@"C:\localhost_client.crt");
var clientKey = File.ReadAllText(@"C:\localhost_clientkey.pem");
var keyPair = new KeyCertificatePair(clientCert, clientKey);
var credentials = new SslCredentials(serverCACert, keyPair);
// Client authentication is an option. You can remove it as follows if you only need SSL.
//var credentials = new SslCredentials(serverCACert);
m_client = new Chat.ChatClient(
new Channel("localhost", 50052, credentials));
}
else
{
// create insecure channel
m_client = new Chat.ChatClient(
new Channel("localhost", 50052, ChannelCredentials.Insecure));
}
}
