public async Task <bool> ConnectAsync(PeerId peerIdentifier)
{
_recipientPeerId = peerIdentifier;
var peerRpcConfig = new RpcClientSettings
{
HostAddress = _recipientPeerId.IpAddress,
Port = (int)_recipientPeerId.Port,
PublicKey = _recipientPeerId.PublicKey.KeyToString()
};
_logger.Information($"Connecting to {peerRpcConfig.HostAddress}:{peerRpcConfig.Port}");
try
{
_rpcClient =
await _rpcClientFactory.GetClient(_certificate, peerRpcConfig).ConfigureAwait(false);
return(_rpcClient.Channel.Open);
}
catch (ConnectException connectionException)
{
_logger.Error(connectionException, "Could not connect to node");
}
catch (Exception exception)
{
_logger.Error(exception, "Error attempting to connect to node");
}
return(false);
}
public async Task GetClient_Should_Return_RpcClient()
{
var nodeRpcConfig = Substitute.For <IRpcClientConfig>();
nodeRpcConfig.HostAddress = IPAddress.Any;
nodeRpcConfig.NodeId = "0";
nodeRpcConfig.PfxFileName = "pfx";
nodeRpcConfig.Port = 9000;
var rpcClient = await _rpcClientFactory.GetClient(null, nodeRpcConfig);
rpcClient.Should().BeAssignableTo <IRpcClient>();
}
/// <summary>
/// 开启远程调用
/// </summary>
/// <param name="arrMethodArgs">方法参数</param>
/// <param name="methodInfo">方法名字</param>
/// <returns></returns>
private object DoMethodCall(object[] arrMethodArgs, Type[] argmentTypes, MethodInfo methodInfo)
{
var methodCallInfo = new MethodCallInfo()
{
ClassName = _proxyType.FullName,
MethodName = methodInfo.Name,
Parameters = arrMethodArgs,
TypeHandle = _proxyType.TypeHandle,
ArgumentTypes = argmentTypes
};
var client = RpcClientFactory.GetClient(_proxyType.Name);
var requestMessage = new RequestMessage()
{
MethodCallInfo = methodCallInfo
};
var responseMessage = client.Send(requestMessage);
return(responseMessage);
}
public async Task SubscribeToResponse_Should_Not_Return_Invalid_Response()
{
var nodeRpcClientFactory = new RpcClientFactory(_channelFactory, _clientEventLoopGroupFactory,
new List <IRpcResponseObserver> {
new GetVersionResponseObserver(_logger)
});
var nodeRpcClient = await nodeRpcClientFactory.GetClient(null, _rpcClientConfig);
var receivedResponse = false;
var targetVersionResponse = new VersionResponse {
Version = "1.2.3.4"
};
var protocolMessage =
targetVersionResponse.ToProtocolMessage(_peerIdentifier, CorrelationId.GenerateCorrelationId());
var observerDto = new ObserverDto(_channelHandlerContext, protocolMessage);
_mockSocketReplySubject.OnNext(observerDto);
nodeRpcClient.SubscribeToResponse <GetDeltaResponse>(response => receivedResponse = true);
_testScheduler.Start();
receivedResponse.Should().BeFalse();
}
public async Task SubscribeToResponse_Without_Response_Handler_Should_Throw_Exception()
{
var nodeRpcClientFactory = new RpcClientFactory(_channelFactory, _clientEventLoopGroupFactory,
new List <IRpcResponseObserver>());
var nodeRpcClient = await nodeRpcClientFactory.GetClient(null, _rpcClientConfig);
var targetVersionResponse = new VersionResponse {
Version = "1.2.3.4"
};
var protocolMessage =
targetVersionResponse.ToProtocolMessage(_peerIdentifier, CorrelationId.GenerateCorrelationId());
var observerDto = new ObserverDto(_channelHandlerContext, protocolMessage);
var exception = Record.Exception(() =>
{
_mockSocketReplySubject.OnNext(observerDto);
nodeRpcClient.SubscribeToResponse <VersionResponse>(response => { });
_testScheduler.Start();
});
exception.Should().BeOfType <ResponseHandlerDoesNotExistException>();
}
