public async Task CreateClient_Test()
{
var remoteChainId = ChainOptions.ChainId;
var localChainId = ChainHelper.GetChainId(1);
var host = "127.0.0.1";
var port = 5100;
await Server.StartAsync(port);
var fakeCrossChainClient = new CrossChainClientCreationContext
{
LocalChainId = localChainId,
RemoteChainId = remoteChainId,
IsClientToParentChain = false,
RemoteServerHost = host,
RemoteServerPort = port
};
await _crossChainClientService.CreateClientAsync(fakeCrossChainClient);
var res = _grpcCrossChainClientProvider.TryGetClient(remoteChainId, out var client);
Assert.True(res);
await client.ConnectAsync();
Assert.True(client.IsConnected);
await client.CloseAsync();
Assert.False(client.IsConnected);
}
public async Task RequestCrossChainDataTest()
{
var crossChainClientCreationContext = new CrossChainClientCreationContext
{
LocalChainId = 0,
RemoteChainId = 1,
IsClientToParentChain = false,
RemoteServerHost = "localhost",
RemoteServerPort = 5000
};
var communicationHelper = GetRequiredService <CrossChainCommunicationTestHelper>();
communicationHelper.SetClientConnected(crossChainClientCreationContext.RemoteChainId, true);
await _crossChainClientService.CreateClientAsync(crossChainClientCreationContext);
_crossChainCacheEntityService.RegisterNewChain(crossChainClientCreationContext.RemoteChainId, 10);
communicationHelper.CheckClientConnected(-1).ShouldBeFalse();
await _crossChainRequestService.RequestCrossChainDataFromOtherChainsAsync();
communicationHelper.CheckClientConnected(-1).ShouldBeTrue();
var chainInitializationData = await _crossChainRequestService.RequestChainInitializationDataAsync(crossChainClientCreationContext.RemoteChainId);
chainInitializationData.CreationHeightOnParentChain.ShouldBe(1);
}
public void CreateCrossChainClient_Test()
{
var remoteChainId = ChainOptions.ChainId;
var localChainId = ChainHelper.GetChainId(1);
var host = "127.0.0.1";
var port = 5000;
var crossChainClientDto = new CrossChainClientCreationContext
{
LocalChainId = localChainId,
RemoteChainId = remoteChainId,
IsClientToParentChain = false,
RemoteServerHost = host,
RemoteServerPort = port
};
var client = _grpcCrossChainClientProvider.CreateChainInitializationDataClient(crossChainClientDto);
var isClientCached = _grpcCrossChainClientProvider.TryGetClient(remoteChainId, out _);
Assert.False(isClientCached);
Assert.True(client.RemoteChainId == remoteChainId);
Assert.False(client.IsConnected);
Assert.Equal(remoteChainId, client.RemoteChainId);
var expectedUriStr = string.Concat(host, ":", "5000");
Assert.Equal(expectedUriStr, client.TargetUriString);
}
public Task <ICrossChainClient> CreateChainInitializationClientAsync(int chainId)
{
var crossChainClientDto = new CrossChainClientCreationContext
{
IsClientToParentChain = true,
LocalChainId = chainId
};
var client = _crossChainClientProvider.CreateChainInitializationDataClient(crossChainClientDto);
return(Task.FromResult(client));
}
public void CreateAndCacheClient(int chainId, bool toParenChain, int port, int remoteChainId = 0)
{
var fakeCrossChainClient = new CrossChainClientCreationContext
{
LocalChainId = chainId,
RemoteChainId = remoteChainId,
IsClientToParentChain = toParenChain,
RemoteServerHost = "localhost",
RemoteServerPort = port
};
_grpcCrossChainClientProvider.AddOrUpdateClient(fakeCrossChainClient);
}
private ICrossChainClient CreateAndAddClient(CrossChainCommunicationTestHelper crossChainCommunicationTestHelper,
CrossChainClientCreationContext crossChainClientCreationContext)
{
crossChainCommunicationTestHelper.AddNewCrossChainClient(crossChainClientCreationContext);
bool isConnected =
crossChainCommunicationTestHelper.CheckClientConnected(crossChainClientCreationContext
.RemoteChainId);
return(MockCrossChainClient(crossChainClientCreationContext.RemoteChainId, isConnected,
entity =>
{
crossChainCommunicationTestHelper.SetClientConnected(-1, true);
return true;
}));
}
public async Task GetClientTest()
{
int remoteChainId1 = ChainHelper.GetChainId(1);
int remoteChainId2 = ChainHelper.GetChainId(2);
int remoteChainId3 = ChainHelper.GetChainId(3);
var localChainId = ChainHelper.ConvertBase58ToChainId("AELF");
{
var crossChainClientCreationContext1 = new CrossChainClientCreationContext
{
LocalChainId = localChainId,
RemoteChainId = remoteChainId1,
IsClientToParentChain = false,
RemoteServerHost = "localhost",
RemoteServerPort = 5000
};
_crossChainCommunicationTestHelper.SetClientConnected(remoteChainId1, true);
await _crossChainClientService.CreateClientAsync(crossChainClientCreationContext1);
var client1 = await _crossChainClientService.GetConnectedCrossChainClientAsync(remoteChainId1);
client1.IsConnected.ShouldBeTrue();
client1.RemoteChainId.ShouldBe(remoteChainId1);
}
{
var crossChainClientCreationContext2 = new CrossChainClientCreationContext
{
LocalChainId = localChainId,
RemoteChainId = remoteChainId2,
IsClientToParentChain = false,
RemoteServerHost = "localhost",
RemoteServerPort = 5000
};
_crossChainCommunicationTestHelper.SetClientConnected(remoteChainId2, false);
await _crossChainClientService.CreateClientAsync(crossChainClientCreationContext2);
var client2 = await _crossChainClientService.GetConnectedCrossChainClientAsync(remoteChainId2);
client2.ShouldBeNull();
}
{
var client3 = await _crossChainClientService.GetConnectedCrossChainClientAsync(remoteChainId3);
client3.ShouldBeNull();
}
}
public ICrossChainClient AddOrUpdateClient(CrossChainClientCreationContext crossChainClientCreationContext)
{
var chainId = crossChainClientCreationContext.RemoteChainId;
var uriStr = crossChainClientCreationContext.IsClientToParentChain
? GetUriStr(_grpcCrossChainConfigOption.ParentChainServerIp,
_grpcCrossChainConfigOption.ParentChainServerPort)
: GetUriStr(crossChainClientCreationContext.RemoteServerHost, crossChainClientCreationContext.RemoteServerPort);
if (TryGetClient(chainId, out var client) && client.TargetUriString.Equals(uriStr))
{
return(client); // client already cached
}
client = CreateClient(crossChainClientCreationContext);
_grpcCrossChainClients.TryAdd(chainId, client);
Logger.LogTrace("Create client finished.");
return(client);
}
public async Task AddClientTest()
{
int remoteChainId = ChainHelper.GetChainId(1);
var localChainId = ChainHelper.ConvertBase58ToChainId("AELF");
var crossChainClientCreationContext = new CrossChainClientCreationContext
{
LocalChainId = localChainId,
RemoteChainId = remoteChainId,
IsClientToParentChain = false,
RemoteServerHost = "localhost",
RemoteServerPort = 5000
};
_crossChainCommunicationTestHelper.SetClientConnected(remoteChainId, true);
var client = await _crossChainClientService.CreateClientAsync(crossChainClientCreationContext);
client.IsConnected.ShouldBeTrue();
client.RemoteChainId.ShouldBe(remoteChainId);
}
private ICrossChainClient CreateClient(CrossChainClientCreationContext crossChainClientCreationContext)
{
var clientInitializationContext = new GrpcClientInitializationContext
{
DialTimeout = _grpcCrossChainConfigOption.ConnectionTimeout,
LocalChainId = crossChainClientCreationContext.LocalChainId,
ListeningPort = _grpcCrossChainConfigOption.ListeningPort,
RemoteChainId = crossChainClientCreationContext.RemoteChainId
};
if (crossChainClientCreationContext.IsClientToParentChain)
{
clientInitializationContext.UriStr = GetUriStr(_grpcCrossChainConfigOption.ParentChainServerIp,
_grpcCrossChainConfigOption.ParentChainServerPort);
return(new ClientForParentChain(clientInitializationContext));
}
clientInitializationContext.UriStr = GetUriStr(crossChainClientCreationContext.RemoteServerHost,
crossChainClientCreationContext.RemoteServerPort);
return(new ClientForSideChain(clientInitializationContext));
}
public void TryGetClient_Test()
{
var remoteChainId = ChainOptions.ChainId;
var localChainId = ChainHelper.GetChainId(1);
var host = "127.0.0.1";
var port = 5000;
var crossChainClientDto = new CrossChainClientCreationContext
{
LocalChainId = localChainId,
RemoteChainId = remoteChainId,
IsClientToParentChain = false,
RemoteServerHost = host,
RemoteServerPort = port
};
var client = _grpcCrossChainClientProvider.AddOrUpdateClient(crossChainClientDto);
var isClientCached = _grpcCrossChainClientProvider.TryGetClient(remoteChainId, out var clientInCache);
Assert.True(isClientCached);
Assert.Equal(client, clientInCache);
}
public void GetAllClients_Test()
{
var remoteChainId = ChainOptions.ChainId;
var localChainId = ChainHelper.GetChainId(1);
var host = "127.0.0.1";
var port = 5000;
var crossChainClientDto = new CrossChainClientCreationContext
{
LocalChainId = localChainId,
RemoteChainId = remoteChainId,
IsClientToParentChain = false,
RemoteServerHost = host,
RemoteServerPort = port
};
var client = _grpcCrossChainClientProvider.AddOrUpdateClient(crossChainClientDto);
var clients = _grpcCrossChainClientProvider.GetAllClients();
Assert.Single(clients);
Assert.Equal(client, clients[0]);
}
public Task <ICrossChainClient> CreateClientAsync(CrossChainClientCreationContext crossChainClientCreationContext)
{
var client = _crossChainClientProvider.AddOrUpdateClient(crossChainClientCreationContext);
return(Task.FromResult(client));
}
/// <summary>
/// Create a new client to another chain.
/// </summary>
/// <returns>
/// </returns>
public ICrossChainClient CreateChainInitializationDataClient(CrossChainClientCreationContext crossChainClientCreationContext)
{
return(CreateClient(crossChainClientCreationContext));
}
public bool TryGetCrossChainClientCreationContext(int chainId,
out CrossChainClientCreationContext crossChainClientCreationContext)
{
return(_crossChainClientCreationContexts.TryGetValue(chainId, out crossChainClientCreationContext));
}
public void AddNewCrossChainClient(CrossChainClientCreationContext crossChainClientCreationContext)
{
_crossChainClientCreationContexts[crossChainClientCreationContext.RemoteChainId] =
crossChainClientCreationContext;
}
