public void SetUp()
{
System.Net.ServicePointManager.DefaultConnectionLimit = 1000;
Console.WriteLine("Initializing tests (setting console loggers)...");
SetUpDebugListeners();
var originalFormatter = NLog.Config.ConfigurationItemFactory.Default.ValueFormatter;
ConfigurationItemFactory.Default.ValueFormatter = new NLogValueFormatter(originalFormatter, false);
ConsoleTarget consoleTarget = new ConsoleTarget("testconsole");
var config = new NLog.Config.LoggingConfiguration();
config.AddRule(LogLevel.Trace, LogLevel.Fatal, consoleTarget);
consoleTarget.Layout = "[${processid:padCharacter=0:padding=5},${threadid:padCharacter=0:padding=2},${date:universalTime=true:format=HH\\:mm\\:ss\\.fff},${level:padding=-5:uppercase=true}] ${message}${onexception:${newline}${literal:text=EXCEPTION OCCURRED}${newline}${exception:format=message}}";
NLog.LogManager.Configuration = config;
EventStore.Common.Log.LogManager.SetLogFactory(x => new NLogger(x));
Application.AddDefines(new[] { Application.AdditionalCommitChecks });
LogEnvironmentInfo();
if (!Debugger.IsAttached)
{
PortsHelper.InitPorts(IPAddress.Loopback);
}
}
private int GetFreePort(IPAddress ip)
{
var port = PortsHelper.GetAvailablePort(ip);
_portsUsed.Add(port);
return(port);
}
public async Task should_throw_exception_when_trying_to_reopen_closed_connection()
{
ClientApiLoggerBridge.Default.Info("Starting '{0}' test...",
"should_throw_exception_when_trying_to_reopen_closed_connection");
var closed = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously);
var settings = ConnectionSettings.Create()
.EnableVerboseLogging()
.UseCustomLogger(ClientApiLoggerBridge.Default)
.LimitReconnectionsTo(0)
.WithConnectionTimeoutOf(TimeSpan.FromSeconds(10))
.SetReconnectionDelayTo(TimeSpan.FromMilliseconds(0))
.FailOnNoServerResponse();
if (_tcpType == TcpType.Ssl)
{
settings.UseSslConnection("ES", false);
}
var ip = IPAddress.Loopback;
int port = PortsHelper.GetAvailablePort(ip);
using var connection = EventStoreConnection.Create(settings, new IPEndPoint(ip, port).ToESTcpUri());
connection.Closed += (s, e) => closed.TrySetResult(true);
await connection.ConnectAsync();
await closed.Task.WithTimeout(
TimeSpan.FromSeconds(120)); // TCP connection timeout might be even 60 seconds
await AssertEx.ThrowsAsync <ObjectDisposedException>(() => connection.ConnectAsync().WithTimeout());
}
private Guid AddSubscription(Guid replicaId, bool isPromotable, out TcpConnectionManager manager)
{
var tcpConn = new DummyTcpConnection()
{
ConnectionId = replicaId
};
manager = new TcpConnectionManager(
"Test Subscription Connection manager", TcpServiceType.External, new ClientTcpDispatcher(),
InMemoryBus.CreateTest(), tcpConn, InMemoryBus.CreateTest(),
new InternalAuthenticationProvider(
new Core.Helpers.IODispatcher(InMemoryBus.CreateTest(), new NoopEnvelope()),
new StubPasswordHashAlgorithm(), 1, false),
new AuthorizationGateway(new TestAuthorizationProvider()),
TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(10), (man, err) => { },
_connectionPendingSendBytesThreshold, _connectionQueueSizeThreshold);
var subRequest = new ReplicationMessage.ReplicaSubscriptionRequest(
Guid.NewGuid(),
new NoopEnvelope(),
manager,
0,
Guid.NewGuid(),
new Epoch[0],
PortsHelper.GetLoopback(),
LeaderId,
replicaId,
isPromotable);
Service.Handle(subRequest);
return(tcpConn.ConnectionId);
}
public ping_controller_should()
{
var port = PortsHelper.GetAvailablePort(IPAddress.Loopback);
_serverEndPoint = new IPEndPoint(IPAddress.Loopback, port);
_portableServer = new PortableServer(_serverEndPoint);
}
public when_http_service_has_no_controllers()
{
var port = PortsHelper.GetAvailablePort(IPAddress.Loopback);
_serverEndPoint = new IPEndPoint(IPAddress.Loopback, port);
_portableServer = new PortableServer(_serverEndPoint);
}
public override void TestFixtureTearDown()
{
PortsHelper.ReturnPort(_serverPort);
_portableServer.TearDown();
_connection.Dispose();
base.TestFixtureTearDown();
}
public http_service_should()
{
var port = PortsHelper.GetAvailablePort(IPAddress.Loopback);
_serverEndPoint = new IPEndPoint(IPAddress.Loopback, port);
_portableServer = new PortableServer(_serverEndPoint);
}
public when_http_request_times_out()
{
_timeout = 2000;
var port = PortsHelper.GetAvailablePort(IPAddress.Loopback);
_serverEndPoint = new IPEndPoint(IPAddress.Loopback, port);
_portableServer = new PortableServer(_serverEndPoint, _timeout);
}
public async Task should_not_throw_exception_when_server_is_down()
{
var ip = IPAddress.Loopback;
int port = PortsHelper.GetAvailablePort(ip);
using var connection = TestConnection.Create(new IPEndPoint(ip, port), _tcpType);
await connection.ConnectAsync();
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
#if DEBUG
QueueStatsCollector.InitializeIdleDetection();
#else
throw new NotSupportedException("These tests require DEBUG conditional");
#endif
_nodeEndpoints[0] = new Endpoints(
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback),
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback),
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback));
_nodeEndpoints[1] = new Endpoints(
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback),
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback),
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback));
_nodeEndpoints[2] = new Endpoints(
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback),
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback),
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback));
PortsHelper.GetAvailablePort(IPAddress.Loopback);
_nodes[0] = CreateNode(0,
_nodeEndpoints[0], new IPEndPoint[] { _nodeEndpoints[1].InternalHttp, _nodeEndpoints[2].InternalHttp });
_nodes[1] = CreateNode(1,
_nodeEndpoints[1], new IPEndPoint[] { _nodeEndpoints[0].InternalHttp, _nodeEndpoints[2].InternalHttp });
_nodes[2] = CreateNode(2,
_nodeEndpoints[2], new IPEndPoint[] { _nodeEndpoints[0].InternalHttp, _nodeEndpoints[1].InternalHttp });
_nodes[0].Start();
_nodes[1].Start();
_nodes[2].Start();
WaitHandle.WaitAll(new[] { _nodes[0].StartedEvent, _nodes[1].StartedEvent, _nodes[2].StartedEvent });
QueueStatsCollector.WaitIdle(waitForNonEmptyTf: true);
_conn = EventStoreConnection.Create(_nodes[0].ExternalTcpEndPoint);
_conn.ConnectAsync().Wait();
_manager = new ProjectionsManager(
new ConsoleLogger(),
_nodes[0].ExternalHttpEndPoint,
TimeSpan.FromMilliseconds(10000));
if (GivenStandardProjectionsRunning())
{
EnableStandardProjections();
}
QueueStatsCollector.WaitIdle();
Given();
When();
}
public void SetUp()
{
Console.WriteLine("Initializing tests (setting console loggers)...");
LogManager.SetLogFactory(x => new ConsoleLogger());
Application.AddDefines(new[] { Application.AdditionalCommitChecks });
LogEnvironmentInfo();
if (!Debugger.IsAttached)
{
PortsHelper.InitPorts(IPAddress.Loopback);
}
}
public void should_close_connection_after_configured_amount_of_failed_reconnections()
{
var closed = new ManualResetEventSlim();
var settings =
ConnectionSettings.Create()
.EnableVerboseLogging()
.UseCustomLogger(ClientApiLoggerBridge.Default)
.LimitReconnectionsTo(1)
.WithConnectionTimeoutOf(TimeSpan.FromSeconds(10))
.SetReconnectionDelayTo(TimeSpan.FromMilliseconds(0))
.FailOnNoServerResponse();
if (_tcpType == TcpType.Ssl)
{
settings.UseSslConnection("ES", false);
}
var ip = IPAddress.Loopback;
int port = PortsHelper.GetAvailablePort(ip);
try {
using (var connection = EventStoreConnection.Create(settings, new IPEndPoint(ip, port).ToESTcpUri())) {
connection.Closed += (s, e) => closed.Set();
connection.Connected += (s, e) =>
Console.WriteLine("EventStoreConnection '{0}': connected to [{1}]...",
e.Connection.ConnectionName, e.RemoteEndPoint);
connection.Reconnecting += (s, e) =>
Console.WriteLine("EventStoreConnection '{0}': reconnecting...", e.Connection.ConnectionName);
connection.Disconnected += (s, e) =>
Console.WriteLine("EventStoreConnection '{0}': disconnected from [{1}]...",
e.Connection.ConnectionName, e.RemoteEndPoint);
connection.ErrorOccurred += (s, e) => Console.WriteLine("EventStoreConnection '{0}': error = {1}",
e.Connection.ConnectionName, e.Exception);
connection.ConnectAsync().Wait();
if (!closed.Wait(TimeSpan.FromSeconds(120))) // TCP connection timeout might be even 60 seconds
{
Assert.Fail("Connection timeout took too long.");
}
Assert.That(
() => connection
.AppendToStreamAsync("stream", ExpectedVersion.EmptyStream, TestEvent.NewTestEvent())
.Wait(),
Throws.Exception.InstanceOf <AggregateException>()
.With.InnerException.InstanceOf <InvalidOperationException>());
}
} finally {
PortsHelper.ReturnPort(port);
}
}
public override void TestFixtureTearDown()
{
for (var i = 0; i < _portsUsed.Count; i++)
{
PortsHelper.ReturnPort(_portsUsed[i]);
}
_conn.Close();
_nodes[0].Shutdown();
_nodes[1].Shutdown();
_nodes[2].Shutdown();
base.TestFixtureTearDown();
}
public void should_not_throw_exception_when_server_is_down()
{
var ip = IPAddress.Loopback;
int port = PortsHelper.GetAvailablePort(ip);
try {
using (var connection = TestConnection.Create(new IPEndPoint(ip, port), _tcpType)) {
Assert.DoesNotThrow(() => connection.ConnectAsync().Wait());
}
} finally {
PortsHelper.ReturnPort(port);
}
}
public override void When()
{
BecomeMaster();
WriterCheckpoint.Write(_logPosition);
WriterCheckpoint.Flush();
Service.Handle(new ReplicationTrackingMessage.WriterCheckpointFlushed());
Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_replicaId1, _logPosition));
Service.Handle(new SystemMessage.VNodeConnectionLost(
PortsHelper.GetLoopback(),
Guid.NewGuid(),
_replicaId1));
Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_replicaId2, _logPosition));
AssertEx.IsOrBecomesTrue(() => Service.IsCurrent());
}
public void Start()
{
var rpcNodeStartup = new RPCNodeStartup(_walletRepository, _network, _blockChainStore,
_smartContractStore, _transactionHelper, _transactionValidator, _blockValidator, _solidityExecutor);
_host = new WebHostBuilder().UseKestrel()
.UseUrls($"http://localhost:{PortsHelper.GetRPCPort(_network)}")
.Configure((app) =>
{
rpcNodeStartup.Configure(app);
})
.Build();
_host.Start();
}
public void SetUp()
{
System.Net.ServicePointManager.DefaultConnectionLimit = 1000;
Console.WriteLine("Initializing tests (setting console loggers)...");
SetUpDebugListeners();
LogManager.SetLogFactory(x => new ConsoleLogger());
Application.AddDefines(new[] { Application.AdditionalCommitChecks });
LogEnvironmentInfo();
if (!Debugger.IsAttached)
{
PortsHelper.InitPorts(IPAddress.Loopback);
}
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
#if DEBUG
QueueStatsCollector.InitializeIdleDetection();
#endif
_nodeEndpoints[0] = new Endpoints(
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback),
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback),
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback));
_nodeEndpoints[1] = new Endpoints(
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback),
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback),
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback));
_nodeEndpoints[2] = new Endpoints(
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback),
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback),
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback));
PortsHelper.GetAvailablePort(IPAddress.Loopback);
_nodeCreationFactory.Add(0, (wait) => CreateNode(0,
_nodeEndpoints[0], new IPEndPoint[] { _nodeEndpoints[1].InternalHttp, _nodeEndpoints[2].InternalHttp }, wait));
_nodeCreationFactory.Add(1, (wait) => CreateNode(1,
_nodeEndpoints[1], new IPEndPoint[] { _nodeEndpoints[0].InternalHttp, _nodeEndpoints[2].InternalHttp }, wait));
_nodeCreationFactory.Add(2, (wait) => CreateNode(2,
_nodeEndpoints[2], new IPEndPoint[] { _nodeEndpoints[0].InternalHttp, _nodeEndpoints[1].InternalHttp }, wait));
_nodes[0] = _nodeCreationFactory[0](true);
_nodes[1] = _nodeCreationFactory[1](true);
_nodes[2] = _nodeCreationFactory[2](true);
BeforeNodesStart();
_nodes[0].Start();
_nodes[1].Start();
_nodes[2].Start();
WaitHandle.WaitAll(new[] { _nodes[0].StartedEvent, _nodes[1].StartedEvent, _nodes[2].StartedEvent });
QueueStatsCollector.WaitIdle(waitForNonEmptyTf: true);
_conn = EventStoreConnection.Create(_nodes[0].ExternalTcpEndPoint);
_conn.ConnectAsync().Wait();
QueueStatsCollector.WaitIdle();
Given();
}
private void KillStartedNode(int processId)
{
Log.Information("Killing {processId}...", processId);
Process process;
if (TryGetProcessById(processId, out process))
{
process.Kill();
var waitCount = 200;
while (!process.HasExited && waitCount > 0)
{
Thread.Sleep(250);
waitCount -= 1;
}
if (process.HasExited)
{
_startedNodesProcIds.Remove(processId);
PortsHelper.ReturnPort(_nodeConnection.TcpPort);
PortsHelper.ReturnPort(_nodeConnection.HttpPort);
Log.Information("Killed process {processId}, wait a bit.", processId);
Thread.Sleep(1000); // wait for system to release port used by HttpListener.
}
else
{
Process temp;
if (TryGetProcessById(processId, out temp))
{
Log.Error(
"Process {processId} did not report about exit in time and is still present in processes list.",
processId);
}
else
{
Log.Information("Process {processId} did not report about exit in time but is not found again.",
processId);
}
}
}
else
{
Log.Error("Process {processId} was not found to be killed.", processId);
}
}
public void Connect(string host, ServiceFlags serviceFlag)
{
if (string.IsNullOrWhiteSpace(host))
{
throw new ArgumentNullException(nameof(host));
}
var iid = Interop.Constants.InterfaceId;
var port = PortsHelper.GetPort(_network);
IPAddress ipAdr = null;
if (!IPAddress.TryParse(host, out ipAdr))
{
// TODO : Throw an exception.
}
var adrBytes = ipAdr.MapToIPv6().GetAddressBytes();
_serviceFlag = serviceFlag;
_currentIpAddress = new IpAddress(serviceFlag, adrBytes, ushort.Parse(port));
// _client = new RpcClientApi(iid, RpcProtseq.ncacn_ip_tcp, host, port);
_client = new RpcClientApi(iid, RpcProtseq.ncalrpc, null, host);
// Connection to peers : https://bitcoin.org/en/developer-guide#connecting-to-peers
var instance = PeersStore.Instance();
var transmittingNode = instance.GetMyIpAddress();
var nonce = NonceHelper.GetNonceUInt64();
var versionMessage = new VersionMessage(transmittingNode, _currentIpAddress, nonce, string.Empty, 0, false, _network);
try
{
_peerConnection = new PeerConnection(adrBytes);
var result = _messageCoordinator.Launch(this, versionMessage);
if (result != null && result is VerackMessage)
{
_peerConnection.Connect();
if (ConnectEvent != null)
{
ConnectEvent(this, new IpAddressEventArgs(_currentIpAddress));
}
_timer = new Timer(TimerElapsed, _autoEvent, CHECK_INTERVAL, CHECK_INTERVAL); // CHECK PEERS AVAILABILITY EVERY 60 SECONDS.
}
}
catch (Interop.RpcException)
{
throw new PeerConnectorException(ErrorCodes.PeerRpcError);
}
}
public override void TestFixtureTearDown()
{
for (var i = 0; i < _portsUsed.Count; i++)
{
PortsHelper.ReturnPort(_portsUsed[i]);
}
_conn.Close();
_nodes[0].Shutdown();
_nodes[1].Shutdown();
_nodes[2].Shutdown();
#if DEBUG
QueueStatsCollector.DisableIdleDetection();
#endif
base.TestFixtureTearDown();
}
protected ScenarioBase(Action <IPEndPoint, byte[]> directSendOverTcp,
int maxConcurrentRequests,
int connections,
int streams,
int eventsPerStream,
int streamDeleteStep,
string dbParentPath,
NodeConnectionInfo customNodeConnection)
{
DirectSendOverTcp = directSendOverTcp;
MaxConcurrentRequests = maxConcurrentRequests;
Connections = connections;
Streams = streams;
EventsPerStream = eventsPerStream;
StreamDeleteStep = streamDeleteStep;
_customNodeConnection = customNodeConnection;
_startedNodesProcIds = new HashSet <int>();
var ipAddress = IPAddress.Loopback;
if (_customNodeConnection != null)
{
_nodeConnection = _customNodeConnection;
_dbPath = null;
}
else
{
_dbPath = CreateNewDbPath(dbParentPath);
_nodeConnection = new NodeConnectionInfo(ipAddress,
PortsHelper.GetAvailablePort(ipAddress),
PortsHelper.GetAvailablePort(ipAddress));
}
_connections = new IEventStoreConnection[connections];
Log.Information("Projection manager points to {nodeConnection}.", _nodeConnection);
_projectionsManager = new ProjectionsManager(new ConsoleLogger(),
new IPEndPoint(_nodeConnection.IpAddress, _nodeConnection.HttpPort), TimeSpan.FromMilliseconds(5000));
_writeHandlers = new Dictionary <WriteMode, Func <string, int, Func <int, EventData>, Task> > {
{ WriteMode.SingleEventAtTime, WriteSingleEventAtTime },
{ WriteMode.Bucket, WriteBucketOfEventsAtTime },
{ WriteMode.Transactional, WriteEventsInTransactionalWay }
};
}
public async Task should_close_connection_after_configured_amount_of_failed_reconnections()
{
var closed = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously);
var settings =
ConnectionSettings.Create()
.EnableVerboseLogging()
.UseCustomLogger(ClientApiLoggerBridge.Default)
.LimitReconnectionsTo(1)
.WithConnectionTimeoutOf(TimeSpan.FromSeconds(10))
.SetReconnectionDelayTo(TimeSpan.FromMilliseconds(0))
.FailOnNoServerResponse();
if (_tcpType == TcpType.Ssl)
{
settings.DisableServerCertificateValidation();
}
else
{
settings.DisableTls();
}
var ip = IPAddress.Loopback;
int port = PortsHelper.GetAvailablePort(ip);
using var connection = EventStoreConnection.Create(settings, new IPEndPoint(ip, port).ToESTcpUri());
connection.Closed += (s, e) => closed.TrySetResult(true);
connection.Connected += (s, e) =>
Console.WriteLine("EventStoreConnection '{0}': connected to [{1}]...",
e.Connection.ConnectionName, e.RemoteEndPoint);
connection.Reconnecting += (s, e) =>
Console.WriteLine("EventStoreConnection '{0}': reconnecting...", e.Connection.ConnectionName);
connection.Disconnected += (s, e) =>
Console.WriteLine("EventStoreConnection '{0}': disconnected from [{1}]...",
e.Connection.ConnectionName, e.RemoteEndPoint);
connection.ErrorOccurred += (s, e) => Console.WriteLine("EventStoreConnection '{0}': error = {1}",
e.Connection.ConnectionName, e.Exception);
await connection.ConnectAsync();
await closed.Task.WithTimeout(
TimeSpan.FromSeconds(120)); // TCP connection timeout might be even 60 seconds
await AssertEx.ThrowsAsync <ObjectDisposedException>(() => connection
.AppendToStreamAsync("stream", ExpectedVersion.NoStream, TestEvent.NewTestEvent())
.WithTimeout());
}
protected override void Given()
{
_serverEndPoint = new IPEndPoint(IPAddress.Loopback, PortsHelper.GetAvailablePort(IPAddress.Loopback));
_url = _HttpEndPoint.ToHttpUrl("/stats/tcp");
var settings = ConnectionSettings.Create();
_connection = EventStoreConnection.Create(settings, _node.TcpEndPoint, _clientConnectionName);
_connection.ConnectAsync().Wait();
var testEvent = new EventData(Guid.NewGuid(), "TestEvent", true, Encoding.ASCII.GetBytes("{'Test' : 'OneTwoThree'}"), null);
_connection.AppendToStreamAsync("tests", ExpectedVersion.Any, testEvent).Wait();
_portableServer = new PortableServer(_serverEndPoint);
_portableServer.SetUp();
}
public void should_throw_exception_when_trying_to_reopen_closed_connection()
{
ClientApiLoggerBridge.Default.Info("Starting '{0}' test...", "should_throw_exception_when_trying_to_reopen_closed_connection");
var closed = new ManualResetEventSlim();
var settings = ConnectionSettings.Create()
.EnableVerboseLogging()
.UseCustomLogger(ClientApiLoggerBridge.Default)
.LimitReconnectionsTo(0)
.WithConnectionTimeoutOf(TimeSpan.FromSeconds(10))
.SetReconnectionDelayTo(TimeSpan.FromMilliseconds(0))
.FailOnNoServerResponse();
if (_tcpType == TcpType.Ssl)
{
settings.UseSslConnection("ES", false);
}
var ip = IPAddress.Loopback;
int port = PortsHelper.GetAvailablePort(ip);
try
{
using (var connection = EventStoreConnection.Create(settings, new IPEndPoint(ip, port).ToESTcpUri()))
{
connection.Closed += (s, e) => closed.Set();
connection.ConnectAsync().Wait();
if (!closed.Wait(TimeSpan.FromSeconds(120))) // TCP connection timeout might be even 60 seconds
{
Assert.Fail("Connection timeout took too long.");
}
Assert.That(() => connection.ConnectAsync().Wait(),
Throws.Exception.InstanceOf <AggregateException>()
.With.InnerException.InstanceOf <InvalidOperationException>());
}
}
finally
{
PortsHelper.ReturnPort(port);
}
}
public void Start(IEnumerable <byte> ipAddress = null)
{
if (ipAddress == null)
{
ipAddress = _ipAdrHelper.GetIpv4Address();
}
_ipAddress = new IpAddress(DateTime.UtcNow, _serviceFlag, ipAddress.ToArray(), ushort.Parse(PortsHelper.GetPort(_network)));
PeersStore.Instance().SetMyIpAddress(_ipAddress);
var iid = Interop.Constants.InterfaceId;
var instance = PeersStore.Instance();
var port = PortsHelper.GetPort(_network);
// _server = new RpcServerApi(iid, 1234, -1, true);
// _server.AddProtocol(RpcProtseq.ncacn_ip_tcp, port, 5);
var name = (new IPAddress(_ipAddress.Ipv6)).MapToIPv4().ToString(); // USE QUEUE.
_server = new RpcServerApi(iid, 1234, -1, true);
_server.AddProtocol(RpcProtseq.ncalrpc, name, 5);
_server.StartListening();
_server.OnExecute += delegate(IRpcClientInfo client, byte[] arg)
{
var message = _messageParser.Parse(arg);
var connectedPeer = _p2pNetworkConnector.GetPeer(message.MessageHeader.Ipv6);
if (NewMessageEvent != null)
{
NewMessageEvent(this, new StringEventArgs(message.GetCommandName()));
}
var response = _messageCoordinator.Receive(message, connectedPeer, _p2pNetworkConnector);
if (response == null)
{
return(new byte[0]);
}
return(response.Serialize());
};
if (StartNodeEvent != null)
{
StartNodeEvent(this, EventArgs.Empty);
}
}
public override void When()
{
BecomeMaster();
WriterCheckpoint.Write(_logPosition);
WriterCheckpoint.Flush();
Service.Handle(new ReplicationTrackingMessage.WriterCheckpointFlushed());
Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_replicaId1, _logPosition));
Service.Handle(new SystemMessage.VNodeConnectionLost(
PortsHelper.GetLoopback(),
Guid.NewGuid(),
_replicaId1));
AssertEx.IsOrBecomesTrue(() => Service.IsCurrent()); //n.b. we still don't have quorum here
//moving directly to log position 2 after rejoin
WriterCheckpoint.Write(_logPosition2);
WriterCheckpoint.Flush();
Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_replicaId1, _logPosition2));
Service.Handle(new ReplicationTrackingMessage.ReplicaWriteAck(_replicaId2, _logPosition2));
AssertEx.IsOrBecomesTrue(() => Service.IsCurrent());
}
public override async Task TestFixtureSetUp()
{
await base.TestFixtureSetUp();
#if (!DEBUG)
Assert.Ignore("These tests require DEBUG conditional");
#else
_nodeEndpoints[0] = new Endpoints(
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback),
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback),
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback));
_nodeEndpoints[1] = new Endpoints(
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback),
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback),
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback));
_nodeEndpoints[2] = new Endpoints(
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback),
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback),
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback));
_nodes[0] = CreateNode(0,
_nodeEndpoints[0], new[] { _nodeEndpoints[1].InternalHttp, _nodeEndpoints[2].InternalHttp });
_nodes[1] = CreateNode(1,
_nodeEndpoints[1], new[] { _nodeEndpoints[0].InternalHttp, _nodeEndpoints[2].InternalHttp });
_nodes[2] = CreateNode(2,
_nodeEndpoints[2], new[] { _nodeEndpoints[0].InternalHttp, _nodeEndpoints[1].InternalHttp });
WaitIdle();
var projectionsStarted = _projections.Select(p => SystemProjections.Created(p.LeaderMainBus)).ToArray();
foreach (var node in _nodes)
{
node.Start();
node.WaitIdle();
}
await Task.WhenAll(_nodes.Select(x => x.Started)).WithTimeout(TimeSpan.FromSeconds(30));
_conn = EventStoreConnection.Create(_nodes[0].ExternalTcpEndPoint);
await _conn.ConnectAsync().WithTimeout();
_manager = new ProjectionsManager(
new ConsoleLogger(),
_nodes.Single(x => x.NodeState == VNodeState.Leader).ExternalHttpEndPoint,
TimeSpan.FromMilliseconds(10000));
if (GivenStandardProjectionsRunning())
{
await Task.WhenAny(projectionsStarted).WithTimeout(TimeSpan.FromSeconds(10));
await EnableStandardProjections().WithTimeout(TimeSpan.FromMinutes(2));
}
WaitIdle();
try {
await Given().WithTimeout();
} catch (Exception ex) {
throw new Exception("Given Failed", ex);
}
try {
await When().WithTimeout();
} catch (Exception ex) {
throw new Exception("When Failed", ex);
}
#endif
}
public void TestFixtureTearDown()
{
PortsHelper.ReturnPort(_serverEndPoint.Port);
}
