public void Init()
{
var serverCredentials = new SslServerCredentials(new[] { new KeyCertificatePair(File.ReadAllText(TestCredentials.ServerCertChainPath), File.ReadAllText(TestCredentials.ServerPrivateKeyPath)) });
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)
};
var asyncAuthInterceptor = new AsyncAuthInterceptor(async (authUri, metadata) =>
{
await Task.Delay(100); // make sure the operation is asynchronous.
metadata.Add("authorization", "SECRET_TOKEN");
});
var clientCredentials = ChannelCredentials.Create(
new SslCredentials(File.ReadAllText(TestCredentials.ClientCertAuthorityPath)),
new MetadataCredentials(asyncAuthInterceptor));
channel = new Channel(Host, server.Ports.Single().BoundPort, clientCredentials, options);
client = TestService.NewClient(channel);
}
public async Task <string[]> GenerateSeed(string aezeedPassphrase = default(string))
{
var genSeedResponse = new GenSeedResponse();
try
{
walletRpcChannel = new Grpc.Core.Channel(HostName, new SslCredentials(Cert));
walletUnlocker = new WalletUnlocker.WalletUnlockerClient(walletRpcChannel);
await walletRpcChannel.ConnectAsync();
var genSeedRequest = new GenSeedRequest();
if (!string.IsNullOrEmpty(aezeedPassphrase))
{
genSeedRequest.AezeedPassphrase = ByteString.CopyFromUtf8(aezeedPassphrase);
}
genSeedResponse = await walletUnlocker.GenSeedAsync(genSeedRequest);
walletRpcChannel.ShutdownAsync().Wait();
} catch (RpcException e)
{
walletRpcChannel.ShutdownAsync().Wait();
return(new string[] { e.Status.Detail });
}
return(genSeedResponse.CipherSeedMnemonic.ToArray());;
}
public void Connect()
{
this.channel = new grpc.Channel(host, port, grpc.ChannelCredentials.Insecure);
this.client = new EdgifyService.EdgifyServiceClient(channel);
this.analytics_client = new AnalyticsService.AnalyticsServiceClient(channel);
this.samples_client = new SamplesService.SamplesServiceClient(channel);
}
private const string ProjectName = "apiarydotnetclienttesting"; // this is actually gRPC, but I had that project handy
#endregion Fields
#region Methods
static void Main(string[] args)
{
// Prerequisites
// 1. create a new cloud project with your google account
// 2. enable cloud datastore API on that project
// 3. 'gcloud auth login' to store your google credential in a well known location (from where GoogleCredential.GetApplicationDefaultAsync() can pick it up).
var credentials = Task.Run(() => GoogleCredential.GetApplicationDefaultAsync()).Result;
Channel channel = new Channel("datastore.googleapis.com", credentials.ToChannelCredentials());
var datastoreClient = new Google.Datastore.V1Beta3.Datastore.DatastoreClient(channel);
var result = datastoreClient.RunQuery(new RunQueryRequest
{
ProjectId = ProjectName,
GqlQuery = new GqlQuery {
QueryString = "SELECT * FROM Foo"
}
});
Console.WriteLine(result);
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
channel.ShutdownAsync();
}
public async Task <IActionResult> OnPost()
{
using var ms1 = new MemoryStream();
await PhotoFile.CopyToAsync(ms1);
ms1.Position = 0;
var model = new Application.Posts.Models.PostAddModel
{
Body = this.Body,
UserId = ""
};
var postId = await _postService.Create(model);
var userId = User.GetUserId();
#region Upload to Vega
var channel = new Grpc.Core.Channel("localhost:5005", SslCredentials.Insecure);
var client = new Servers.Vega.FileService.FileServiceClient(channel);
var result2 = client.UploadFile(new UploadRequest
{
Content = ByteString.CopyFrom(ms1.ToArray()),
ContentType = PhotoFile.ContentType,
Name = PhotoFile.FileName,
PostId = postId,
UserId = User.GetUserId()
});
#endregion
return(RedirectToPage("/index"));
}
public LndGrpcService(IConfiguration config)
{
/*
* var certLoc = config.GetValue<string>("cert");
* var macLoc = config.GetValue<string>("mac");
* ;
*
* var directory = Path.GetFullPath(certLoc);
* Console.WriteLine(rpc + " stuff " + directory);*/
var directory = Environment.CurrentDirectory;
var tls = File.ReadAllText(directory + "./../lnd-test-cluster/docker/temp/lnd-alice/tls.cert");
var hexMac = Util.ToHex(File.ReadAllBytes(directory + "./../lnd-test-cluster/docker/temp/lnd-alice/data/chain/bitcoin/regtest/admin.macaroon"));
var rpc = config.GetValue <string>("rpc");
feePercentage = config.GetValue <uint>("fee");
maxSatPerPayment = config.GetValue <uint>("max_sat");
maxVouchers = config.GetValue <uint>("max_voucher");
var macaroonCallCredentials = new MacaroonCallCredentials(hexMac);
var channelCreds = ChannelCredentials.Create(new SslCredentials(tls), macaroonCallCredentials.credentials);
var lndChannel = new Grpc.Core.Channel(rpc, channelCreds);
client = new Lightning.LightningClient(lndChannel);
getInfo = client.GetInfo(new GetInfoRequest());
Console.WriteLine(getInfo.ToString());
}
// Creates a client to Juzusvr with SSL credentials
// from a string containing PEM encoded root certificates,
// that can validate the certificate presented by the server.
public Client(string url, string rootCert)
{
this.serverURL = url;
this.creds = new Grpc.Core.SslCredentials(rootCert);
this.channel = new Grpc.Core.Channel(url, this.creds, this.defaultChannelOptions());
this.client = client = new CobaltSpeech.Juzu.Juzu.JuzuClient(channel);
}
public void State_IdleAfterCreation()
{
using (var channel = new Channel("localhost", Credentials.Insecure))
{
Assert.AreEqual(ChannelState.Idle, channel.State);
}
}
public async Task ManyStreamingServerCallsSingleClientTest()
{
GrpcCore.Server server = this.StartSimpleServiceServer();
GrpcCore.Channel channel = new GrpcCore.Channel($"127.0.0.1:{GrpcTestPort}", GrpcCore.ChannelCredentials.Insecure);
var client = new SimpleCoreService.SimpleCoreServiceClient(channel);
List <Task> activeCalls = new List <Task>();
const int TotalClientCalls = 100;
const int ClientId = 0;
TaskCompletionSource <bool> tasksQueuedCompletionSource = new TaskCompletionSource <bool>();
var callsCounter = new CallsCounter {
nTotalCalls = TotalClientCalls, tasksQueueTask = tasksQueuedCompletionSource.Task
};
this.activeCallCountersDictionary.Add(ClientId, callsCounter);
for (int i = 0; i < 100; i++)
{
activeCalls.Add(MakeStreamingServerCalls(client, ClientId, 10, 10));
lock (callsCounter)
{
callsCounter.nActiveCalls++;
}
}
Assert.AreEqual(TotalClientCalls, callsCounter.nActiveCalls);
tasksQueuedCompletionSource.SetResult(true);
await Task.WhenAll(activeCalls);
Assert.AreEqual(0, callsCounter.nActiveCalls);
await server.ShutdownAsync();
}
public void Init()
{
helper = new MockServiceHelper(Host);
server = helper.GetServer();
server.Start();
channel = helper.GetChannel();
}
public void Init()
{
var marshaller = new Marshaller<string>(
(str) =>
{
if (str == "UNSERIALIZABLE_VALUE")
{
// Google.Protobuf throws exception inherited from IOException
throw new IOException("Error serializing the message.");
}
return System.Text.Encoding.UTF8.GetBytes(str);
},
(payload) =>
{
var s = System.Text.Encoding.UTF8.GetString(payload);
if (s == "UNPARSEABLE_VALUE")
{
// Google.Protobuf throws exception inherited from IOException
throw new IOException("Error parsing the message.");
}
return s;
});
helper = new MockServiceHelper(Host, marshaller);
server = helper.GetServer();
server.Start();
channel = helper.GetChannel();
}
static void Main(string[] args)
{
var rpcChannel = new Channel("localhost:1337", ChannelCredentials.Insecure);
var rpcClient = new BenchmarkServiceClient(BenchmarkService.NewClient(rpcChannel));
rpcChannel.ConnectAsync().Wait();
_timer.Elapsed += (s, e) =>
{
var lastMinuteCallCount = Interlocked.Exchange(ref _lastMinuteCallCount, 0);
Console.WriteLine($"{DateTime.Now} -- {lastMinuteCallCount} ops/sec");
};
_timer.Start();
for (int i = 0; i < CALL_COUNT; i++)
{
rpcClient.Operation(new ServiceRequest { Id = 10 });
Interlocked.Increment(ref _lastMinuteCallCount);
}
//for (int i = 0; i < CALL_COUNT; i++)
//{
// rpcClient.OperationAsync(new ServiceRequest { Id = 10 }).ContinueWith(t => Interlocked.Increment(ref _lastMinuteCallCount));
//}
//rpcClient.OperationStreamAsync(() => Interlocked.Increment(ref _lastMinuteCallCount)).Wait();
}
public List <VoiceItem> ListVoices(Grpc.Core.Channel channel)
{
TextToSpeechClient client = TextToSpeechClient.Create(channel);
// Performs the list voices request
var response = client.ListVoices(new ListVoicesRequest
{
});
List <VoiceItem> voices = new List <VoiceItem>();
foreach (Voice voice in response.Voices)
{
foreach (var languageCode in voice.LanguageCodes)
{
VoiceItem voiceItem = new VoiceItem
{
Name = voice.Name,
Gender = voice.SsmlGender.ToString(),
Language = languageCode,
};
voices.Add(voiceItem);
}
}
return(voices);
}
static void Main(string[] args)
{
// initialization, better done elsewhere
var channel = new Grpc.Core.Channel("localhost", 5000, ChannelCredentials.Insecure);
//// create client
//var customerClient = new Customer.CustomerClient(channel);
//var customerRequested = new IsProductAddressUpdateAllowedRequest
//{
// StateFrom = "ON",
// StateTo = "OW",
// Userrelationid = 1234
//};
//var response = customerClient.IsProductAddressUpdateAllowed(customerRequested);
//Console.WriteLine(response.IsAddressUpdatable.ToString());
//Console.WriteLine(response.ReturnMessage);
var client = new ShoppingCart.ShoppingCartClient(channel); // Customer.CustomerClient(channel);
var request = new InsuranceTrialLinkGetRequest
{
State = "SC",
Server = 1
};
var reply = client.InsuranceTrialLinkGet(request);
Console.WriteLine(reply.TrialURL.ToString());
Console.ReadLine();
Console.ReadKey();
}
public void Target()
{
using (var channel = new Channel("127.0.0.1", Credentials.Insecure))
{
Assert.IsTrue(channel.Target.Contains("127.0.0.1"));
}
}
public void test()
{
LanguageServiceSettings settings = new LanguageServiceSettings();
if (TimeOut > 0)
{
int hour = TimeOut / 3600;
int min = TimeOut / 60;
if (TimeOut >= 60)
{
TimeOut = TimeOut % 60;
}
TimeSpan ts0 = new TimeSpan(hour, min, TimeOut);
settings.AnalyzeSentimentSettings = CallSettings.FromCallTiming(CallTiming.FromTimeout(ts0));
}
string json = "{\"type\": \"service_account\",\"project_id\": \"" + Config["project_id"] + "\",\"private_key_id\": \"" + Config["private_key_id"] + "\",\"private_key\": \"" + Config["private_key"] + "\",\"client_email\": \"" + Config["client_email"] + "\",\"client_id\": \"" + Config["client_id"] + "\",\"auth_uri\": \"" + Config["auth_uri"] + "\",\"token_uri\": \"" + Config["token_uri"] + "\",\"auth_provider_x509_cert_url\": \"" + Config["auth_provider_x509_cert_url"] + "\",\"client_x509_cert_url\": \"" + Config["client_x509_cert_url"] + "\"}";
var credential = GoogleCredential.FromJson(json).CreateScoped(LanguageServiceClient.DefaultScopes);
var channel = new Grpc.Core.Channel(
LanguageServiceClient.DefaultEndpoint.ToString(),
credential.ToChannelCredentials());
LanguageServiceClient test = LanguageServiceClient.Create(channel, settings);
var Sentimentresponse = test.AnalyzeSentiment(new Document()
{
Content = "hello",
Type = Document.Types.Type.PlainText
});
}
private async static void TestStream(string server)
{
while (true)
{
var channel = new Grpc.Core.Channel(server, ChannelCredentials.Insecure);
var client = new RouteGuideClient(channel);
using (var call = client.ListFeatures(new Rectangle()))
{
try
{
while (await call.ResponseStream.MoveNext())
{
Feature feature = call.ResponseStream.Current;
Console.WriteLine($"Received {feature}");
}
break;
}
catch (Exception ex)
{
Console.WriteLine($"{ex.Message}");
System.Threading.Thread.Sleep(1000);
; // loop
}
}
channel.ShutdownAsync().Wait();
}
Console.WriteLine("Finished TestStream");
}
public void WaitForStateChangedAsync_InvalidArgument()
{
using (var channel = new Channel("localhost", Credentials.Insecure))
{
Assert.Throws(typeof(ArgumentException), () => channel.WaitForStateChangedAsync(ChannelState.FatalFailure));
}
}
public static async Task<WalletClient> ConnectAsync(string networkAddress, string rootCertificate)
{
if (networkAddress == null)
throw new ArgumentNullException(nameof(networkAddress));
if (rootCertificate == null)
throw new ArgumentNullException(nameof(rootCertificate));
var channel = new Channel(networkAddress, new SslCredentials(rootCertificate));
var deadline = DateTime.UtcNow.AddSeconds(3);
try
{
await channel.ConnectAsync(deadline);
}
catch (TaskCanceledException)
{
await channel.ShutdownAsync();
throw new ConnectTimeoutException();
}
// Ensure the server is running a compatible version.
var versionClient = new VersionService.VersionServiceClient(channel);
var response = await versionClient.VersionAsync(new VersionRequest(), deadline: deadline);
var serverVersion = new SemanticVersion(response.Major, response.Minor, response.Patch);
SemanticVersion.AssertCompatible(RequiredRpcServerVersion, serverVersion);
return new WalletClient(channel);
}
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 = TestService.NewClient(channel);
}
public static void Main(string[] args)
{
// This code doesn't do much but makes sure the native extension is loaded
// which is what we are testing here.
Channel c = new Channel("127.0.0.1:1000", ChannelCredentials.Insecure);
c.ShutdownAsync().Wait();
Console.WriteLine("Success!");
}
public void Init()
{
server = new Server();
server.AddServiceDefinition(ServiceDefinition);
int port = server.AddPort(Host, Server.PickUnusedPort, ServerCredentials.Insecure);
server.Start();
channel = new Channel(Host, port, Credentials.Insecure);
}
public void Init()
{
server = new Server();
server.AddServiceDefinition(ServiceDefinition);
int port = server.AddListeningPort(Host, Server.PickUnusedPort);
server.Start();
channel = new Channel(Host, port);
}
public async UniTask DisposeAsync()
{
await _client.DisposeAsync();
await _channel.ShutdownAsync();
_channel = null;
}
public NLClient(string jsonPath)
{
var credential = GoogleCredential.FromFile(jsonPath).CreateScoped(LanguageServiceClient.DefaultScopes);
var channel = new Grpc.Core.Channel(
LanguageServiceClient.DefaultEndpoint.ToString(),
credential.ToChannelCredentials());
client = LanguageServiceClient.Create(channel);
}
static void Main(string[] args)
{
var channel = new Channel("127.0.0.1:9007", ChannelCredentials.Insecure);
var client = new gRPC.gRPCClient(channel);
var replay = client.SayHello(new HelloRequest { Name = "shoy" });
Console.WriteLine(replay.Message);
channel.ShutdownAsync().Wait();
Console.ReadKey();
}
// Creates a client to Juzusvr with mutually authenticated TLS.
// The PEM encoded root certificates, PEM encoded client certificate
// and the client's PEM private key must be provided as strings.
public Client(string url, string rootCert, string clientCert, string clientKey)
{
this.serverURL = url;
var keyCertPair = new Grpc.Core.KeyCertificatePair(clientCert, clientKey);
this.creds = new Grpc.Core.SslCredentials(rootCert, keyCertPair);
this.channel = new Grpc.Core.Channel(url, this.creds, this.defaultChannelOptions());
this.client = client = new CobaltSpeech.Juzu.Juzu.JuzuClient(channel);
}
static void Main(string[] args)
{
var channel = new Grpc.Core.Channel("127.0.0.1", 8890, ChannelCredentials.Insecure);
var client = new Greeter.GreeterClient(channel);
var res = client.SayHello(new HelloRequest {
Name = "123123"
});
Console.WriteLine("Hello World!");
}
public void Init()
{
server = new Server();
server.AddServiceDefinition(ServiceDefinition);
int port = server.AddPort(Host, Server.PickUnusedPort, ServerCredentials.Insecure);
server.Start();
channel = new Channel(Host, port, Credentials.Insecure);
stringFromServerHandlerTcs = new TaskCompletionSource<string>();
}
public DefaultRpcChannel(IRpcServiceDiscovery rpcServiceDiscovery, ISerializer serializer, IOptions <RpcClientOptions> options)
{
var(host, port) = rpcServiceDiscovery == null
? (options.Value.Host, options.Value.Port)
: rpcServiceDiscovery.ResolveAsync().ConfigureAwait(false).GetAwaiter().GetResult();
var channel = new GrpcCore.Channel(host, port, GrpcCore.ChannelCredentials.Insecure);
this._invoker = new GrpcCore.DefaultCallInvoker(channel);
this._serializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
}
/// <summary>
/// コンストラクタ
/// </summary>
public HubConnector(TClient receiver, string ipAddr, int port)
{
ClientImpl = receiver;
channel = new Grpc.Core.Channel(ipAddr, port, ChannelCredentials.Insecure);
channel.ShutdownToken.Register(() =>
{
Debug.Log("Call ShutdownToken From Register");
});
}
public void Init()
{
helper = new MockServiceHelper();
server = helper.GetServer();
server.Start();
channel = helper.GetChannel();
headers = new Metadata { { "ascii-header", "abcdefg" } };
}
/// <summary>同步集群中MasterLeader
/// </summary>
private async void GrpcSyncMasterLeader()
{
if (_masterLeaderChannel == null)
{
_logger.LogError("同步MasterLeader出错,当前MasterLeaderChannel为空.");
return;
}
try
{
var client = GetMasterClient();
var request = new MasterPb.KeepConnectedRequest()
{
Name = Guid.NewGuid().ToString("N")
};
using (var call = client.KeepConnected())
{
var responseReaderTask = Task.Run(() =>
{
while (call.ResponseStream.MoveNext(CancellationToken.None).WaitResult(5000))
{
var volumeLocation = call.ResponseStream.Current;
//接收到VolumeLocation信息后处理...
if (!volumeLocation.Leader.IsNullOrWhiteSpace() && !volumeLocation.Leader.Equals(_masterLeaderChannel.Target, StringComparison.OrdinalIgnoreCase))
{
//不相等,创建新的连接
lock (SyncObject)
{
var connectionAddress = new ConnectionAddress(volumeLocation.Leader);
_masterLeaderChannel = CreateChannel(connectionAddress);
}
}
}
});
await call.RequestStream.WriteAsync(request);
await call.RequestStream.CompleteAsync();
await responseReaderTask;
}
}
catch (AggregateException ex)
{
foreach (var e in ex.InnerExceptions)
{
_logger.LogError(e.InnerException, "同步MasterLeader出现线程异常,{0}", ex.Message);
}
}
catch (Exception ex)
{
_logger.LogError(ex, "同步MasterLeader出错,{0}", ex.Message);
}
}
public void Init()
{
server = new Server
{
Services = { TestService.BindService(new UnimplementedTestServiceImpl()) },
Ports = { { Host, ServerPort.PickUnused, SslServerCredentials.Insecure } }
};
server.Start();
channel = new Channel(Host, server.Ports.Single().BoundPort, ChannelCredentials.Insecure);
client = new TestService.TestServiceClient(channel);
}
public void Init()
{
server = new Server
{
Services = { Math.BindService(new MathServiceImpl()) },
Ports = { { Host, ServerPort.PickUnused, ServerCredentials.Insecure } }
};
server.Start();
channel = new Channel(Host, server.Ports.Single().BoundPort, Credentials.Insecure);
client = Math.NewClient(channel);
}
public void Run()
{
if (channel == null || client == null)
{
// 서버 연결
string liveHost = "183.99.10.187:20051";
string inhouseHost = "127.0.0.1:20051";
channel = new Grpc.Core.Channel(inhouseHost, Grpc.Core.ChannelCredentials.Insecure);
client = new RpcService.RpcServiceClient(channel);
}
}
public void Init()
{
serviceImpl = new HealthServiceImpl();
server = new Server();
server.AddServiceDefinition(Grpc.Health.V1Alpha.Health.BindService(serviceImpl));
int port = server.AddListeningPort(Host, Server.PickUnusedPort);
server.Start();
channel = new Channel(Host, port);
client = Grpc.Health.V1Alpha.Health.NewClient(channel);
}
public ServerHost()
{
_server = new Server
{
Ports =
{
new ServerPort("localhost", Port, ServerCredentials.Insecure)
}
};
Channel = new GrpcChannel("localhost", Port, ChannelCredentials.Insecure);
}
public void Init()
{
server = new Server
{
Services = { ServiceDefinition },
Ports = { { Host, ServerPort.PickUnused, ServerCredentials.Insecure } }
};
server.Start();
channel = new Channel(Host, server.Ports.Single().BoundPort, Credentials.Insecure);
stringFromServerHandlerTcs = new TaskCompletionSource<string>();
}
static async Task RunAsync(string endpoint, string prefix, ChannelOption[] options)
{
var channel = new Grpc.Core.Channel(endpoint, ChannelCredentials.Insecure, options);
var client = new Greeter.GreeterClient(channel);
var user = "******";
var reply = client.SayHello(new HelloRequest {
Name = user
});
Console.WriteLine("Greeting: " + reply.Message);
// duplex
var requestHeaders = new Metadata
{
{ "x-host-port", "10-0-0-10" },
};
using var streaming = client.StreamingBothWays(requestHeaders);
var readTask = Task.Run(async() =>
{
while (await streaming.ResponseStream.MoveNext())
{
var response = streaming.ResponseStream.Current;
Console.WriteLine($"{prefix} {response.Message}");
}
});
var i = 0;
while (i++ < 100)
{
try
{
await streaming.RequestStream.WriteAsync(new HelloRequest
{
Name = $"{prefix} {i}",
});
}
catch (Exception ex)
{
Console.WriteLine($"{prefix} error {channel.State} {ex.Message} {ex.StackTrace}");
}
await Task.Delay(TimeSpan.FromSeconds(1));
}
await streaming.RequestStream.CompleteAsync();
await readTask;
channel.ShutdownAsync().Wait();
}
/// <summary>运行
/// </summary>
public void Start()
{
if (_isRunning)
{
return;
}
_masterLeaderChannel = CreateMasterChannel();
//开启同步
StartGrpcSyncMasterLeaderTask();
//var channel=new GoogleGrpc.Channel("127.0.0.1")
_isRunning = true;
}
public void Init()
{
serviceImpl = new HealthServiceImpl();
server = new Server
{
Services = { Grpc.Health.V1Alpha.Health.BindService(serviceImpl) },
Ports = { { Host, ServerPort.PickUnused, ServerCredentials.Insecure } }
};
server.Start();
channel = new Channel(Host, server.Ports.Single().BoundPort, ChannelCredentials.Insecure);
client = Grpc.Health.V1Alpha.Health.NewClient(channel);
}
public async Task <string> ConnectToLnd(string host, string cert)
{
Debug.Log("connecting to lnd");
HostName = host;
Cert = cert;
var channelCreds = new SslCredentials(cert);
rpcChannel = new Grpc.Core.Channel(host, channelCreds);
lndClient = new Lightning.LightningClient(rpcChannel);
InvokeRepeating("TryConnecting", 3, 5);
return("connected");
}
public void Init()
{
server = new Server();
server.AddServiceDefinition(TestService.BindService(new TestServiceImpl()));
int port = server.AddPort(host, Server.PickUnusedPort, TestCredentials.CreateTestServerCredentials());
server.Start();
var options = new List<ChannelOption>
{
new ChannelOption(ChannelOptions.SslTargetNameOverride, TestCredentials.DefaultHostOverride)
};
channel = new Channel(host, port, TestCredentials.CreateTestClientCredentials(true), options);
client = TestService.NewClient(channel);
}
public static void Main(string[] args)
{
Channel channel = new Channel("127.0.0.1:50051", Credentials.Insecure);
var client = Greeter.NewClient(channel);
String user = "******";
var reply = client.SayHello(new HelloRequest { Name = user });
Console.WriteLine("Greeting: " + reply.Message);
channel.ShutdownAsync().Wait();
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
}
public void Init()
{
serviceImpl = new ReflectionServiceImpl(ServerReflection.Descriptor);
server = new Server
{
Services = { ServerReflection.BindService(serviceImpl) },
Ports = { { Host, ServerPort.PickUnused, ServerCredentials.Insecure } }
};
server.Start();
channel = new Channel(Host, server.Ports.Single().BoundPort, ChannelCredentials.Insecure);
client = new ServerReflection.ServerReflectionClient(channel);
}
// Connect instantiates a new server connexion and instatiantes the main
// character.
public bool Connect(string endpoint)
{
if (endpoint == "")
{
endpoint = "[::1]:50051";
}
Debug.Log(endpoint);
_grpc_channel = new Grpc.Core.Channel(
endpoint, Grpc.Core.ChannelCredentials.Insecure);
_client = new Game.GameClient(_grpc_channel);
is_connected = true;
return(true);
}
public static async Task MainAsync()
{
var channel = new Channel("127.0.0.1:50051", ChannelCredentials.Insecure);
var client = new Greeter.GreeterClient(channel);
var user = Environment.UserName;
var reply = client.SayHello(new HelloRequest { Name = user });
Console.WriteLine("Greeting: {0}", reply.Message);
await channel.ShutdownAsync().ConfigureAwait(false);
Console.ReadLine();
}
public static void Main(string[] args)
{
GrpcEnvironment.Initialize();
using (Channel channel = new Channel("127.0.0.1:50051"))
{
var client = Greeter.NewStub(channel);
String user = "******";
var reply = client.SayHello(new HelloRequest.Builder { Name = user }.Build());
Console.WriteLine("Greeting: " + reply.Message);
}
GrpcEnvironment.Shutdown();
}
static async Task <string> Reverse()
{
Channel channel = new Channel("localhost", 11111, ChannelCredentials.Insecure);
RevService.Generated.RevService.RevServiceClient client = new RevService.Generated.RevService.RevServiceClient(channel);
var data = new RevService.Generated.Data()
{
UserId = "aaa", Permissions = "a,b,c"
};
var res = await client.ReverseAsync(data);
return(res.Permissions);
}
public async Task <string> ConnectToLndWithMacaroon(string host, string cert, string macaroon)
{
Debug.Log("connecting to lnd");
HostName = host;
Cert = cert;
var macaroonCallCredentials = new MacaroonCallCredentials(macaroon);
var sslCreds = new SslCredentials(cert);
var channelCreds = ChannelCredentials.Create(sslCreds, macaroonCallCredentials.credentials);
rpcChannel = new Grpc.Core.Channel(host, channelCreds);
lndClient = new Lightning.LightningClient(rpcChannel);
InvokeRepeating("TryConnecting", 3, 5);
return("connected");
}
// proto: https://github.com/googleapis/googleapis/tree/master/google
// c# code: https://github.com/googleapis/google-api-dotnet-client/tree/master/Src
public static Grpc.Core.CallInvoker create(string url)
{
if (!initialized)
{
initialized = true;
var path = System.Configuration.ConfigurationManager.AppSettings["google-cloud-service-account"];
Environment.SetEnvironmentVariable("GOOGLE_APPLICATION_CREDENTIALS", path);
}
var ev = Environment.GetEnvironmentVariable("GOOGLE_APPLICATION_CREDENTIALS");
var token = Google.Apis.Auth.OAuth2.GoogleCredential.GetApplicationDefault();
var channelCredential = Grpc.Auth.GoogleGrpcCredentials.ToChannelCredentials(token);
var channel = new Grpc.Core.Channel(url, channelCredential);
return(new Grpc.Core.DefaultCallInvoker(channel));
}
public void Init()
{
server = new Server();
server.AddServiceDefinition(Math.BindService(new MathServiceImpl()));
int port = server.AddPort(host, Server.PickUnusedPort, ServerCredentials.Insecure);
server.Start();
channel = new Channel(host, port, Credentials.Insecure);
client = Math.NewClient(channel);
// TODO(jtattermusch): get rid of the custom header here once we have dedicated tests
// for header support.
client.HeaderInterceptor = (metadata) =>
{
metadata.Add(new Metadata.Entry("customHeader", "abcdef"));
};
}
public async Task <IActionResult> OnGetImageAsync(int postId)
{
//var channel = GrpcChannel.ForAddress("http://localhost:5005");
//var client = new Servers.Vega.FileService.FileServiceClient(channel);
var channel = new Grpc.Core.Channel("localhost:5005", SslCredentials.Insecure);
var client = new Servers.Vega.FileService.FileServiceClient(channel);
var result = await client.DownloadFileAsync(new Servers.Vega.DownloadRequest
{
PostId = postId
});
return(File(result.Content.ToArray(), result.ContentType));
}
public async Task <IActionResult> OnPostAsync(int postId)
{
var likeChannel = new Grpc.Core.Channel("localhost:5007", SslCredentials.Insecure);
var likeClient = new Liker.LikerClient(likeChannel);
var reply = await likeClient.AddImageLikeAsync(new PostIdRequest()
{
PostId = postId,
UserId = User.GetUserId(),
//Status = PostIdRequest.Types.Status.Like
});
IsLiked = true;
return(new RedirectToPageResult("", new{ postId = postId }));
}
private void Form1_Load(object sender, EventArgs e)
{
try
{
//Create a connection
var channel = new Channel("127.0.0.1:50051", ChannelCredentials.Insecure);
var rClient = new RobotService.RobotServiceClient(channel);
var client = new RobotServiceClient(rClient);
Console.WriteLine("Loaded");
client.StreamReport();
}
catch (Exception err)
{
MessageBox.Show("Failed to load:", err.Message);
}
}
public async Task <KestrelHost> StartAsync()
{
GrpcChannelExtensions.Http2UnencryptedSupport = true;
_host = Host
.CreateDefaultBuilder()
.ConfigureServices(services =>
{
services.AddGrpc();
services.AddServiceModelGrpc();
_configureServices?.Invoke(services);
})
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.Configure(app =>
{
app.UseRouting();
_configureApp?.Invoke(app);
if (_configureEndpoints != null)
{
app.UseEndpoints(_configureEndpoints);
}
});
webBuilder.UseKestrel(o => o.ListenLocalhost(_port, l => l.Protocols = HttpProtocols.Http2));
})
.Build();
try
{
await _host.StartAsync();
}
catch
{
await DisposeAsync();
throw;
}
ClientFactory = new ClientFactory(_clientFactoryDefaultOptions);
Channel = new GrpcChannel("localhost", DefaultPort, ChannelCredentials.Insecure);
return(this);
}
public void Init()
{
server = new Server
{
Services = { TestService.BindService(new TestServiceImpl()) },
Ports = { { Host, ServerPort.PickUnused, TestCredentials.CreateSslServerCredentials() } }
};
server.Start();
var options = new List<ChannelOption>
{
new ChannelOption(ChannelOptions.SslTargetNameOverride, TestCredentials.DefaultHostOverride)
};
int port = server.Ports.Single().BoundPort;
channel = new Channel(Host, port, TestCredentials.CreateSslCredentials(), options);
client = TestService.NewClient(channel);
}
public static void Main(string[] args)
{
var channel = new Channel("127.0.0.1", 23456, ChannelCredentials.Insecure);
Math.IMathClient client = new Math.MathClient(channel);
MathExamples.DivExample(client);
MathExamples.DivAsyncExample(client).Wait();
MathExamples.FibExample(client).Wait();
MathExamples.SumExample(client).Wait();
MathExamples.DivManyExample(client).Wait();
MathExamples.DependendRequestsExample(client).Wait();
channel.ShutdownAsync().Wait();
}
/**
* Get the last block received by this peer.
*
* @return The last block received by this peer. May return null if no block has been received since first reactivated.
*/
private Task ConnectEnvelopeAsync(Envelope envelope, CancellationToken token)
{
if (shutdown)
{
logger.Warn($"{ToString()} not connecting is shutdown.");
return(Task.FromResult(0));
}
Channel lmanagedChannel = managedChannel;
if (lmanagedChannel == null || lmanagedChannel.State == ChannelState.Shutdown || lmanagedChannel.State == ChannelState.TransientFailure)
{
lmanagedChannel = channelBuilder.BuildChannel();
managedChannel = lmanagedChannel;
}
return(DeliverAsync(lmanagedChannel, envelope, token));
}
