internal async Task RunClientAsync()
{
var clientSock = new TcpClient();
_barrier.SignalAndWait();
await clientSock.ConnectAsync(IPAddress.Loopback, Program.lbPort);
var caller = new RpcCaller <IHelloService>(
new NetworkRpcClient(new TcpTransportLayer(clientSock)
));
//var result = await caller.CallByNameAsync<string>(nameof(IHelloServer.SayHello));
_barrier.SignalAndWait();
var client = caller.CreateClient();
var helloResult = client.SayHello();
Console.WriteLine($"Sent command from client. Server responded {helloResult}");
Console.WriteLine($"Is the sky blue?: {client.IsSkyBlue()}");
Console.WriteLine($"1 + 3 is: {client.Add(1, 3)}");
var c1 = new TastyCookie(TastyCookie.CookieFlavor.Chocolate, 6, 1);
var c2 = new TastyCookie(TastyCookie.CookieFlavor.Chocolate, 8, 1.2);
Console.WriteLine($"Volume of TastyCookie 1 is: {client.GetVolume(c1)}");
Console.WriteLine($"Cookie {(client.Compare(c1, c2) ? "1" : "2")} is larger.");
await Task.Delay(0);
}
public static TInterface CreateEmpty(RpcCaller <TInterface> caller)
{
var binder = new CallProxyBinder <TInterface>(caller);
var dynamicCallProxy = ProxyGenerator.BuildEmpty <TInterface>(binder);
return(dynamicCallProxy);
}
private async Task <T> MakeRPCCall <T>(Node node, string method = "getblockcount")
{
try
{
HttpResponseMessage response = null;
var rpcRequest = new RPCRequestBody(method);
if (!string.IsNullOrEmpty(node.SuccessUrl))
{
response = await RpcCaller.SendRPCCall(HttpMethod.Post, $"{node.SuccessUrl}", rpcRequest);
}
else
{
var ports = this.netSettings.GetPorts();
foreach (var portWithType in ports)
{
var triedUrl = default(string);
if (!string.IsNullOrEmpty(node.Url))
{
triedUrl = portWithType.GetFullUrl(node.Url);
response = await RpcCaller.SendRPCCall(HttpMethod.Post, triedUrl, rpcRequest);
}
else
{
triedUrl = portWithType.GetFullUrl(node.NodeAddresses.FirstOrDefault().Ip);
response = await RpcCaller.SendRPCCall(HttpMethod.Post, triedUrl, rpcRequest);
}
if (response != null && response.IsSuccessStatusCode)
{
node.SuccessUrl = triedUrl;
break;
}
}
}
if (response != null && response.IsSuccessStatusCode)
{
var result = await response.Content.ReadAsStringAsync();
var serializedResult = JsonConvert.DeserializeObject <T>(result);
return(serializedResult);
}
}
catch (Exception e)
{
}
return(default(T));
}
public TestClientFixture()
{
var sockets = SocketProvider.CreateSockets().Result;
var clientSock = sockets.Item1;
var serverSock = sockets.Item2;
Service = new RpcService <ITestService>(
new NetworkRpcService(new TcpTransportLayer(serverSock)
));
Caller = new RpcCaller <ITestService>(
new NetworkRpcClient(new TcpTransportLayer(clientSock)
));
Service.Export(new TestService());
Client = Caller.CreateClient();
}
static async Task Main(string[] args)
{
var factory = new ConnectionFactory
{
HostName = "localhost",
UserName = "******",
Password = "******"
};
var conn = factory.CreateConnection();
var channel = conn.CreateModel();
var svc1 = new MyService();
svc1.BindTo(channel);
var svc2 = new MyService();
svc2.BindTo(channel);
var caller = new RpcCaller(channel, svc1.DefaultQueueName);
await caller.Call("Test", 5);
Console.WriteLine("Done");
Thread.Sleep(Timeout.InfiniteTimeSpan);
}
public async Task <string> GetNodeVersion(string endpoint)
{
var result = await RpcCaller.MakeRPCCall <RPCResponseBody <RPCResponseVersion> >(endpoint, "getversion");
return(result == null ? string.Empty : result.Result.Useragent);
}
private void HandleNewAddress(RPCPeer address, StateOfNeoContext db)
{
var newNode = default(Node);
string successUrl = null;
var ports = this.netSettings.GetPorts();
foreach (var portWithType in ports)
{
var url = portWithType.GetFullUrl(address.Address.ToMatchedIp());
try
{
var rpcResult = RpcCaller.MakeRPCCall <RPCResponseBody <int> >(url, "getblockcount")
.GetAwaiter()
.GetResult();
if (rpcResult?.Result > 0)
{
successUrl = url;
newNode = this.CreateNodeOfAddress(address.Address,
portWithType.Type,
successUrl,
NodeAddressType.RPC);
break;
}
}
catch (Exception e)
{
Log.Error($"Get blockcount parse error {e.Message}", e);
break;
}
}
if (newNode == default(Node))
{
var httpTypes = new string[] { "https", "http" };
foreach (var httpType in httpTypes)
{
var url = $"{httpType}://{address.Address.ToMatchedIp()}";
var heightResponse = HttpRequester.MakeRestCall <HeightResponseObject>($@"{url}/api/main_net/v1/get_height", HttpMethod.Get)
.GetAwaiter()
.GetResult();
if (heightResponse != null)
{
successUrl = url;
newNode = this.CreateNodeOfAddress(address.Address,
httpType,
successUrl,
NodeAddressType.REST,
NodeCallsConstants.NeoScan);
break;
}
var versionResponse = HttpRequester.MakeRestCall <NeoNotificationVersionResponse>($@"{url}/v1/version", HttpMethod.Get)
.GetAwaiter()
.GetResult();
if (versionResponse != null)
{
successUrl = url;
newNode = this.CreateNodeOfAddress(address.Address,
httpType,
successUrl,
NodeAddressType.REST,
NodeCallsConstants.NeoNotification);
break;
}
}
}
if (newNode != null)
{
var newNodeAddress = new NodeAddress
{
Ip = address.Address.ToMatchedIp(),
Node = newNode
};
var peer = db.Peers.FirstOrDefault(x => x.Ip == address.Address.ToMatchedIp());
var result = LocationCaller.UpdateNode(newNode, newNodeAddress.Ip).GetAwaiter().GetResult();
newNode.NodeAddresses.Add(newNodeAddress);
db.NodeAddresses.Add(newNodeAddress);
db.Nodes.Add(newNode);
peer.Node = newNode;
db.SaveChanges();
}
}
public CallProxyBinder(RpcCaller <TInterface> caller)
{
_caller = caller;
}
public CallProxy(TInterface target, RpcCaller <TInterface> caller)
{
_remoteCaller = caller;
_proxiedObject = target;
}
