private void timer1_Tick(object sender, EventArgs e) { var connections = TcpConnectionManager.GetCurrentTcpConnections(); //this.dataGridView1.DataSource = null; this.dataGridView1.DataSource = connections; }
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); }
static void ConnectAsClient() { int count = 0; var server = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 3666); var connection = new TcpConnectionManager("ClientConnection", Guid.NewGuid(), server, new TcpClientConnector(), false, null, false, new EchoFramer(), (c, d) => { var message = UTF8NoBom.GetString(d); Console.WriteLine("Client: message from server: {0}", message); var messageCount = Interlocked.Increment(ref count); c.Send(UTF8NoBom.GetBytes(string.Format("client says: {0} message received.", messageCount))); if (messageCount == 50) { c.Close(); } }, (c) => { Console.WriteLine("Client: connected."); c.Send(UTF8NoBom.GetBytes("Hello server.")); }, (c, e) => { Console.WriteLine("Client: connection lost."); }); connection.StartReceiving(); }
public void TestCallbacks() { log4net.Config.XmlConfigurator.Configure(LogManager.GetRepository(Assembly.GetCallingAssembly())); TcpConnectionManager connectionManager = new TcpConnectionManager(); connectionManager.OnConnectionFound += HandleConnectionManagerOnConnectionFound; incomingGenerators = new List <TcpStreamGenerator>(); // outgoingGenerators = new List<TcpStreamGenerator>(); // open the offline file var dev = new CaptureFileReaderDevice(captureFilename); dev.Open(); Assert.True(dev != null, "failed to open " + captureFilename); RawCapture rawCapture; while ((rawCapture = dev.GetNextPacket()) != null) { var p = Packet.ParsePacket(rawCapture.LinkLayerType, rawCapture.Data); var tcpPacket = p.Extract <TcpPacket>(); Console.WriteLine("tcpPacket.PayloadData.Length {0}", tcpPacket.PayloadData.Length); connectionManager.ProcessPacket(rawCapture.Timeval, tcpPacket); } dev.Close(); int expectedCallbackCount = 5; Assert.Equal(expectedCallbackCount, callbackCount); }
private void ConnectToMaster(VNodeInfo master) { Debug.Assert(_state == VNodeState.PreReplica); var masterEndPoint = GetMasterEndPoint(master, _useSsl); if (_connection != null) { _connection.Stop(string.Format("Reconnecting from old master [{0}] to new master: [{1}].", _connection.RemoteEndPoint, masterEndPoint)); } _connection = new TcpConnectionManager(_useSsl ? "master-secure" : "master-normal", Guid.NewGuid(), _tcpDispatcher, _publisher, masterEndPoint, _connector, _useSsl, _sslTargetHost, _sslValidateServer, _networkSendQueue, _authProvider, _heartbeatInterval, _heartbeatTimeout, OnConnectionEstablished, OnConnectionClosed); _connection.StartReceiving(); }
when_send_queue_size_is_larger_than_threshold_should_close_connection() { var mre = new ManualResetEventSlim(); var messageSize = _connectionPendingSendBytesThreshold; var evnt = new EventRecord(0, 0, Guid.NewGuid(), Guid.NewGuid(), 0, 0, "testStream", 0, DateTime.Now, PrepareFlags.None, "eventType", new byte[messageSize], new byte[0]); var record = ResolvedEvent.ForUnresolvedEvent(evnt, null); var message = new ClientMessage.ReadEventCompleted(Guid.NewGuid(), "testStream", ReadEventResult.Success, record, StreamMetadata.Empty, false, ""); var dummyConnection = new DummyTcpConnection(); dummyConnection.SendQueueSize = ESConsts.MaxConnectionQueueSize + 1; var tcpConnectionManager = new TcpConnectionManager( Guid.NewGuid().ToString(), TcpServiceType.External, new ClientTcpDispatcher(2000), InMemoryBus.CreateTest(), dummyConnection, InMemoryBus.CreateTest(), new InternalAuthenticationProvider(InMemoryBus.CreateTest(), new Core.Helpers.IODispatcher(InMemoryBus.CreateTest(), new NoopEnvelope()), null, 1, false), new AuthorizationGateway(new TestAuthorizationProvider()), TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(10), (man, err) => { mre.Set(); }, ESConsts.UnrestrictedPendingSendBytes, ESConsts.MaxConnectionQueueSize); tcpConnectionManager.SendMessage(message); if (!mre.Wait(2000)) { Assert.Fail("Timed out waiting for connection to close"); } }
private void ProcessPackets(ICaptureDevice dev, TcpConnectionManager tcpConnectionManager) { // reset the expected message index at the start of the test run expectedMessageIndex = 0; GetPacketStatus status; PacketCapture e; while ((status = dev.GetNextPacket(out e)) == GetPacketStatus.PacketRead) { var rawCapture = e.GetPacket(); var p = Packet.ParsePacket(rawCapture.LinkLayerType, rawCapture.Data); var tcpPacket = p.Extract <TcpPacket>(); // skip non-tcp packets, http is a tcp based protocol if (p == null) { continue; } log.Debug("passing packet to TcpConnectionManager"); tcpConnectionManager.ProcessPacket(rawCapture.Timeval, tcpPacket); } // did we get all of the messages? Assert.Equal(expectedMessages.Count, expectedMessageIndex); }
public void when_handling_trusted_write_on_internal_service() { ManualResetEvent waiter = new ManualResetEvent(false); ClientMessage.WriteEvents publishedWrite = null; var evnt = new Event(Guid.NewGuid(), "TestEventType", true, new byte[] { }, new byte[] { }); var write = new TcpClientMessageDto.WriteEvents( Guid.NewGuid().ToString(), ExpectedVersion.Any, new[] { new TcpClientMessageDto.NewEvent(evnt.EventId.ToByteArray(), evnt.EventType, evnt.IsJson ? 1 : 0, 0, evnt.Data, evnt.Metadata) }, false); var package = new TcpPackage(TcpCommand.WriteEvents, Guid.NewGuid(), write.Serialize()); var dummyConnection = new DummyTcpConnection(); var publisher = InMemoryBus.CreateTest(); publisher.Subscribe(new AdHocHandler<ClientMessage.WriteEvents>(x => { publishedWrite = x; waiter.Set(); })); var tcpConnectionManager = new TcpConnectionManager( Guid.NewGuid().ToString(), TcpServiceType.Internal, new ClientTcpDispatcher(), publisher, dummyConnection, publisher, new InternalAuthenticationProvider(new Core.Helpers.IODispatcher(publisher, new NoopEnvelope()), new StubPasswordHashAlgorithm(), 1), TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(10), (man, err) => { }); tcpConnectionManager.ProcessPackage(package); if (!waiter.WaitOne(TimeSpan.FromSeconds(5))) { throw new Exception("Timed out waiting for events."); } Assert.AreEqual(evnt.EventId, publishedWrite.Events.First().EventId, "Expected the published write to be the event that was sent through the tcp connection manager to be the event {0} but got {1}", evnt.EventId, publishedWrite.Events.First().EventId); }
public ReplicaSubscriptionRequest(Guid correlationId, IEnvelope envelope, TcpConnectionManager connection, long logPosition, Guid chunkId, Epoch[] lastEpochs, IPEndPoint replicaEndPoint, Guid masterId, Guid subscriptionId, bool isPromotable) { Ensure.NotEmptyGuid(correlationId, "correlationId"); Ensure.NotNull(envelope, "envelope"); Ensure.NotNull(connection, "connection"); Ensure.Nonnegative(logPosition, "logPosition"); Ensure.NotNull(lastEpochs, "lastEpochs"); Ensure.NotNull(replicaEndPoint, "ReplicaEndPoint"); Ensure.NotEmptyGuid(masterId, "masterId"); Ensure.NotEmptyGuid(subscriptionId, "subscriptionId"); CorrelationId = correlationId; Envelope = envelope; Connection = connection; LogPosition = logPosition; ChunkId = chunkId; LastEpochs = lastEpochs; ReplicaEndPoint = replicaEndPoint; MasterId = masterId; SubscriptionId = subscriptionId; IsPromotable = isPromotable; }
public static void Destroy() { Logging.WriteLine("Destroying PhoenixEmu environment..."); if (GetGame() != null) { GetGame().Destroy(); Game = null; } if (GetConnectionManager() != null) { Logging.WriteLine("Destroying connection manager."); GetConnectionManager().GetListener().Destroy(); GetConnectionManager().DestroyManager(); ConnectionManager = null; } if (GetDatabase() != null) { try { Logging.WriteLine("Destroying database manager."); MySqlConnection.ClearAllPools(); DatabaseManager = null; } catch { } } Logging.WriteLine("Uninitialized successfully. Closing."); }
public void when_handling_trusted_write_on_internal_service() { ManualResetEvent waiter = new ManualResetEvent(false); ClientMessage.WriteEvents publishedWrite = null; var evnt = new Event(Guid.NewGuid(), "TestEventType", true, new byte[] { }, new byte[] { }); var write = new TcpClientMessageDto.WriteEvents( Guid.NewGuid().ToString(), ExpectedVersion.Any, new[] { new TcpClientMessageDto.NewEvent(evnt.EventId.ToByteArray(), evnt.EventType, evnt.IsJson ? 1 : 0, 0, evnt.Data, evnt.Metadata) }, false); var package = new TcpPackage(TcpCommand.WriteEvents, Guid.NewGuid(), write.Serialize()); var dummyConnection = new DummyTcpConnection(); var publisher = InMemoryBus.CreateTest(); publisher.Subscribe(new AdHocHandler <ClientMessage.WriteEvents>(x => { publishedWrite = x; waiter.Set(); })); var tcpConnectionManager = new TcpConnectionManager( Guid.NewGuid().ToString(), TcpServiceType.Internal, new ClientTcpDispatcher(), publisher, dummyConnection, publisher, new InternalAuthenticationProvider(new Core.Helpers.IODispatcher(publisher, new NoopEnvelope()), new StubPasswordHashAlgorithm(), 1), TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(10), (man, err) => { }); tcpConnectionManager.ProcessPackage(package); if (!waiter.WaitOne(TimeSpan.FromSeconds(5))) { throw new Exception("Timed out waiting for events."); } Assert.AreEqual(evnt.EventId, publishedWrite.Events.First().EventId, "Expected the published write to be the event that was sent through the tcp connection manager to be the event {0} but got {1}", evnt.EventId, publishedWrite.Events.First().EventId); }
public void when_handling_trusted_write_on_external_service() { var package = new TcpPackage(TcpCommand.WriteEvents, TcpFlags.TrustedWrite, Guid.NewGuid(), null, null, new byte[] { }); var dummyConnection = new DummyTcpConnection(); var tcpConnectionManager = new TcpConnectionManager( Guid.NewGuid().ToString(), TcpServiceType.External, new ClientTcpDispatcher(2000), InMemoryBus.CreateTest(), dummyConnection, InMemoryBus.CreateTest(), new InternalAuthenticationProvider( InMemoryBus.CreateTest(), 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); tcpConnectionManager.ProcessPackage(package); var data = dummyConnection.ReceivedData.Last(); var receivedPackage = TcpPackage.FromArraySegment(data); Assert.AreEqual(receivedPackage.Command, TcpCommand.BadRequest, "Expected Bad Request but got {0}", receivedPackage.Command); }
public void Test() { connectionStatistics.OnMeasurementFound += HandleConnectionStatisticsOnMeasurementFound; connectionStatistics.OnMeasurementEvent += HandleConnectionStatisticsOnMeasurementEvent; captureFilename = capturePre + captureFN; // open the offline file var dev = new CaptureFileReaderDevice(captureFilename); dev.Open(); Assert.True(dev != null, "failed to open " + captureFilename); var tcpConnectionManager = new TcpConnectionManager(); tcpConnectionManager.OnConnectionFound += HandleTcpConnectionManagerOnConnectionFound; RawCapture rawCapture; while ((rawCapture = dev.GetNextPacket()) != null) { var p = Packet.ParsePacket(rawCapture.LinkLayerType, rawCapture.Data); var tcpPacket = p.Extract <TcpPacket>(); if (tcpPacket != null) { // Console.WriteLine("{0}", tcpPacket.ToString()); tcpConnectionManager.ProcessPacket(rawCapture.Timeval, tcpPacket); } } }
when_send_queue_size_is_smaller_than_threshold_should_not_close_connection() { var mre = new ManualResetEventSlim(); var messageSize = _connectionPendingSendBytesThreshold; var evnt = new EventRecord(0, 0, Guid.NewGuid(), Guid.NewGuid(), 0, 0, "testStream", 0, DateTime.Now, PrepareFlags.None, "eventType", new byte[messageSize], new byte[0]); var record = ResolvedEvent.ForUnresolvedEvent(evnt, null); var message = new ClientMessage.ReadEventCompleted(Guid.NewGuid(), "testStream", ReadEventResult.Success, record, StreamMetadata.Empty, false, ""); var dummyConnection = new DummyTcpConnection(); dummyConnection.SendQueueSize = ESConsts.MaxConnectionQueueSize - 1; var tcpConnectionManager = new TcpConnectionManager( Guid.NewGuid().ToString(), TcpServiceType.External, new ClientTcpDispatcher(2000), InMemoryBus.CreateTest(), dummyConnection, InMemoryBus.CreateTest(), new InternalAuthenticationProvider(InMemoryBus.CreateTest(), new Core.Helpers.IODispatcher(InMemoryBus.CreateTest(), new NoopEnvelope()), null, 1, false), new AuthorizationGateway(new TestAuthorizationProvider()), TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(10), (man, err) => { mre.Set(); }, ESConsts.UnrestrictedPendingSendBytes, ESConsts.MaxConnectionQueueSize); tcpConnectionManager.SendMessage(message); var data = dummyConnection.ReceivedData.Last(); var receivedPackage = TcpPackage.FromArraySegment(data); Assert.AreEqual(receivedPackage.Command, TcpCommand.ReadEventCompleted, "Expected ReadEventCompleted but got {0}", receivedPackage.Command); }
public TestNode(RoutingManager routingManager, TcpConnectionManager connectionManager, DataManager dataManager, EncryptionManager encryptionManager) { this.routingManager = routingManager; this.connectionManager = connectionManager; this.dataManager = dataManager; this.encryptionManager = encryptionManager; }
when_limit_pending_and_sending_message_larger_than_pending_bytes_threshold_but_no_bytes_pending_should_not_close_connection() { var messageSize = _connectionPendingSendBytesThreshold + 1000; var evnt = new EventRecord(0, 0, Guid.NewGuid(), Guid.NewGuid(), 0, 0, "testStream", 0, DateTime.Now, PrepareFlags.None, "eventType", new byte[messageSize], new byte[0]); var record = ResolvedEvent.ForUnresolvedEvent(evnt, null); var message = new ClientMessage.ReadEventCompleted(Guid.NewGuid(), "testStream", ReadEventResult.Success, record, StreamMetadata.Empty, false, ""); var dummyConnection = new DummyTcpConnection(); dummyConnection.PendingSendBytes = 0; var tcpConnectionManager = new TcpConnectionManager( Guid.NewGuid().ToString(), TcpServiceType.External, new ClientTcpDispatcher(), InMemoryBus.CreateTest(), dummyConnection, InMemoryBus.CreateTest(), new InternalAuthenticationProvider( new Core.Helpers.IODispatcher(InMemoryBus.CreateTest(), new NoopEnvelope()), null, 1, false), TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(10), (man, err) => { }, _connectionPendingSendBytesThreshold, _connectionQueueSizeThreshold); tcpConnectionManager.SendMessage(message); var data = dummyConnection.ReceivedData.Last(); var receivedPackage = TcpPackage.FromArraySegment(data); Assert.AreEqual(receivedPackage.Command, TcpCommand.ReadEventCompleted, "Expected ReadEventCompleted but got {0}", receivedPackage.Command); }
public static void Main() { // Usage - first, instantiate an IDevice. // Then, instantiate an IConnection, and pass both the device and connection into // an instantiated IConnectionManager. Then pass the IConnectionManager to an instantiated // IController. Finally, initialize the device, passing in your controller. // Any components should be added in your particular Device class // Any commands added should be placed in the CommandHandler class - instructions included. var device = new Device(); var serverConnection = new SingleDataConnection(IPAddress.Parse("192.168.168.101"), 420); var connectionManager = new TcpConnectionManager(device, serverConnection) { KeepAliveActive = true, KeepAliveTime = 30000 }; var netduino = new NetDuinoPlus2(connectionManager); device.Init(netduino); while (true) { Debug.Print("Available RAM: " + Debug.GC(true)); Thread.Sleep(30000); } }
private void Disconnect() { if (_connection != null) { _connection.Stop(string.Format("Node state changed to {0}. Closing replication connection.", _state)); _connection = null; } }
public ReplicaSubscription(IPublisher tcpSendPublisher, TcpConnectionManager connection, Guid subscriptionId, EndPoint replicaEndPoint, bool isPromotable) { _tcpSendPublisher = tcpSendPublisher; _connection = connection; SubscriptionId = subscriptionId; ReplicaEndPoint = replicaEndPoint; IsPromotable = isPromotable; }
public BluemeshNode(RoutingManager routingManager, TcpConnectionManager connectionManager, DataManager dataManager, EncryptionManager encryptionManager, bool doLogMap) { this.RoutingManager = routingManager; this.ConnectionManager = connectionManager; this.DataManager = dataManager; this.EncryptionManager = encryptionManager; this.DoLogMap = doLogMap; }
private void UnsubscribeFromStream(string eventStreamId, Guid correlationId, TcpConnectionManager connection) { List <Tuple <Guid, TcpConnectionManager> > subscribers; if (_subscriptions.TryGetValue(eventStreamId, out subscribers)) { subscribers.Remove(Tuple.Create(correlationId, connection)); } }
private void OnConnectionClosed(TcpConnectionManager connectionManager, SocketError error) { if (_running) { _bus.Publish(new ProjectionMessage.CoreService.Stop()); //TODO: duplicate stop sent here Thread.Sleep(1000); //TODO: use scheduler service Connect(); } }
private static HackerNode CreateNode(IConnectionConfig connectionConfig, IRoutingConfig routingConfig, string storagePath) { var encryptionManager = new EncryptionManager(((TcpAddress)connectionConfig.LocalAddress).Endpoint, connectionConfig.KeySendCooldown); var connectionManager = new TcpConnectionManager(connectionConfig, routingConfig, encryptionManager); var routingManager = new RoutingManager(connectionManager, routingConfig); var dataManager = new DataManager(LoadStorage(storagePath) ?? new DataStorage(), storagePath, routingManager, encryptionManager); return(new HackerNode(routingManager, connectionManager, dataManager, encryptionManager, routingConfig.DoLogMap)); }
/// <summary> /// Initializes a new instance of the <see cref="ServerModeViewModel"/> class. /// </summary> /// <param name="viewShell">The view shell.</param> public ServerModeViewModel(ViewShellBaseViewModel viewShell) : base(viewShell) { ViewShellViewModel shell = (ViewShellViewModel)this.ViewShell; TcpConnectionManager tcpConnectionManager = new TcpConnectionManager(shell.TcpListener, 1600); this.server = new Server(tcpConnectionManager); shell.Server = this.server; this.server.Start(); }
public ServerNode(int tcpPort, List <IPEndPoint> knownEndPoints, DataManager dataManager) { _knownEndPoints = knownEndPoints; _dataManager = dataManager; _tcpConnectionManager = new TcpConnectionManager(tcpPort, new DefaultWireProtocol()); _tcpConnectionManager.ConnectorConnected += OnTcpClientConnected; _tcpConnectors = new List <IConnector>(); _knowedServerNodesConnectors = new List <IConnector>(); _totalDataQunatity = BytesHelper.GetDataSizeInBytes(_dataManager.GetEmployees().ToList()); }
public TcpNETServer(IParamsTcpServer parameters, TcpHandler handler = null) { _parameters = parameters; _connectionManager = new TcpConnectionManager(); _handler = handler ?? new TcpHandler(_parameters); _handler.ConnectionEvent += OnConnectionEvent; _handler.MessageEvent += OnMessageEventAsync; _handler.ErrorEvent += OnErrorEvent; _handler.ServerEvent += OnServerEvent; }
public void Setup() { _dispatcher = new ClientTcpDispatcher(); var dummyConnection = new DummyTcpConnection(); _connection = new TcpConnectionManager( Guid.NewGuid().ToString(), TcpServiceType.External, new ClientTcpDispatcher(), InMemoryBus.CreateTest(), dummyConnection, InMemoryBus.CreateTest(), new InternalAuthenticationProvider( new Core.Helpers.IODispatcher(InMemoryBus.CreateTest(), new NoopEnvelope()), new StubPasswordHashAlgorithm(), 1), TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(10), (man, err) => { }, Opts.ConnectionPendingSendBytesThresholdDefault); }
/// <summary> /// Constructs an instance of the SyncSocketReadingStream class. /// </summary> /// <param name="tcpConnectionManager">TCP Connection Manager.</param> /// <param name="tcpSocketInfo">The connection.</param> /// <param name="receiveTimeout">The moment at which the message must be received entirely.</param> /// <param name="automaticallyContinueReading">Indicates whether this instance will automatically initiate reading of the next message from the specified connection.</param> public SyncSocketReadingStream(TcpConnectionManager tcpConnectionManager, TcpSocketInfo tcpSocketInfo, int receiveTimeout, bool automaticallyContinueReading) { this._readBuffer = BufferPool.ObtainBuffer(); this._tcpConnectionManager = tcpConnectionManager; this._tcpSocketInfo = tcpSocketInfo; this._receiveTimeout = receiveTimeout; this._automaticallyContinueReading = automaticallyContinueReading; // first, complete receiving of the first header // it may read up the entire message and release the underlying connection ReadNextPortion(true); }
public TcpNETServer(IParamsTcpServer parameters, byte[] certificate, string certificatePassword, TcpHandler handler = null) { _parameters = parameters; _connectionManager = new TcpConnectionManager(); _handler = handler ?? new TcpHandler(_parameters, certificate, certificatePassword); _handler.ConnectionEvent += OnConnectionEvent; _handler.MessageEvent += OnMessageEventAsync; _handler.ErrorEvent += OnErrorEvent; _handler.ServerEvent += OnServerEvent; }
public TcpMessage.TcpSend[] GetTcpSendsFor(TcpConnectionManager connection) { var sentMessages = new List <TcpMessage.TcpSend>(); while (TcpSends.TryDequeue(out var msg)) { if (msg.ConnectionManager == connection) { sentMessages.Add(msg); } } return(sentMessages.ToArray()); }
public void ConnectionCreation() { // store the logging value var oldThreshold = LoggingConfiguration.GlobalLoggingLevel; // disable logging to improve performance LoggingConfiguration.GlobalLoggingLevel = log4net.Core.Level.Off; string captureFN = "tcp_test.pcap"; string captureFilename = capturePre + captureFN; // open the offline file var dev = new CaptureFileReaderDevice(captureFilename); dev.Open(); Assert.True(dev != null, "failed to open " + captureFilename); var tcpConnectionManager = new TcpConnectionManager(); tcpConnectionManager.OnConnectionFound += HandleTcpConnectionManagerOnConnectionFound; connectionsFound = 0; var startTime = DateTime.Now; PacketCapture e; GetPacketStatus status; while ((status = dev.GetNextPacket(out e)) == GetPacketStatus.PacketRead) { var rawCapture = e.GetPacket(); var p = Packet.ParsePacket(rawCapture.LinkLayerType, rawCapture.Data); var tcpPacket = p.Extract <TcpPacket>(); if (tcpPacket != null) { // Console.WriteLine("{0}", tcpPacket.ToString()); tcpConnectionManager.ProcessPacket(rawCapture.Timeval, tcpPacket); } } var endTime = DateTime.Now; // restore logging LoggingConfiguration.GlobalLoggingLevel = oldThreshold; var rate = new Utils.Rate(startTime, endTime, connectionsFound, "Connections found"); Console.WriteLine(rate.ToString()); }
private ReplicationMessage.ReplicaSubscriptionRequest UnwrapReplicaSubscriptionRequest(TcpPackage package, IEnvelope envelope, TcpConnectionManager connection) { var dto = package.Data.Deserialize<ReplicationMessageDto.SubscribeReplica>(); var vnodeTcpEndPoint = new IPEndPoint(new IPAddress(dto.Ip), dto.Port); var lastEpochs = dto.LastEpochs.Safe().Select(x => new Epoch(x.EpochPosition, x.EpochNumber, new Guid(x.EpochId))).ToArray(); return new ReplicationMessage.ReplicaSubscriptionRequest(package.CorrelationId, envelope, connection, dto.LogPosition, new Guid(dto.ChunkId), lastEpochs, vnodeTcpEndPoint, new Guid(dto.MasterId), new Guid(dto.SubscriptionId), dto.IsPromotable); }
public void when_handling_trusted_write_on_external_service() { var package = new TcpPackage(TcpCommand.WriteEvents, TcpFlags.TrustedWrite, Guid.NewGuid(), null, null, new byte[] { }); var dummyConnection = new DummyTcpConnection(); var tcpConnectionManager = new TcpConnectionManager( Guid.NewGuid().ToString(), TcpServiceType.External, new ClientTcpDispatcher(), InMemoryBus.CreateTest(), dummyConnection, InMemoryBus.CreateTest(), new InternalAuthenticationProvider(new Core.Helpers.IODispatcher(InMemoryBus.CreateTest(), new NoopEnvelope()), new StubPasswordHashAlgorithm(), 1), TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(10), (man, err) => { }); tcpConnectionManager.ProcessPackage(package); var data = dummyConnection.ReceivedData.Last(); var receivedPackage = TcpPackage.FromArraySegment(data); Assert.AreEqual(receivedPackage.Command, TcpCommand.BadRequest, "Expected Bad Request but got {0}", receivedPackage.Command); }
public ConnectionEstablished(TcpConnectionManager connection) { Connection = connection; }
private ClientMessage.PersistentSubscriptionNackEvents UnwrapPersistentSubscriptionNackEvents( TcpPackage package, IEnvelope envelope, IPrincipal user, string login, string pass, TcpConnectionManager connection) { var dto = package.Data.Deserialize<TcpClientMessageDto.PersistentSubscriptionNakEvents>(); if (dto == null) return null; return new ClientMessage.PersistentSubscriptionNackEvents( Guid.NewGuid(), package.CorrelationId, envelope, dto.SubscriptionId, dto.Message, (ClientMessage.PersistentSubscriptionNackEvents.NakAction)dto.Action, dto.ProcessedEventIds.Select(x => new Guid(x)).ToArray(), user); }
private ClientMessage.UnsubscribeFromStream UnwrapUnsubscribeFromStream(TcpPackage package, IEnvelope envelope, TcpConnectionManager connection) { var dto = package.Data.Deserialize<TcpClientMessageDto.UnsubscribeFromStream>(); if (dto == null) return null; return new ClientMessage.UnsubscribeFromStream(connection, package.CorrelationId, dto.EventStreamId); }
private static ClientMessage.ReadStreamEventsForward UnwrapReadStreamEventsForward(TcpPackage package, IEnvelope envelope, TcpConnectionManager connection) { var dto = package.Data.Deserialize<TcpClientMessageDto.ReadStreamEventsForward>(); if (dto == null) return null; return new ClientMessage.ReadStreamEventsForward(package.CorrelationId, envelope, dto.EventStreamId, dto.StartIndex, dto.MaxCount, dto.ResolveLinkTos); }
private ClientMessage.SubscribeToAllStreams UnwrapSubscribeToAllStreams(TcpPackage package, IEnvelope envelope, TcpConnectionManager connection) { var dto = package.Data.Deserialize<ClientMessageDto.SubscribeToAllStreams>(); return new ClientMessage.SubscribeToAllStreams(connection, new Guid(dto.CorrelationId)); }
private ClientMessage.UpdatePersistentSubscription UnwrapUpdatePersistentSubscription( TcpPackage package, IEnvelope envelope, IPrincipal user, string username, string password, TcpConnectionManager connection) { var dto = package.Data.Deserialize<TcpClientMessageDto.UpdatePersistentSubscription>(); if (dto == null) return null; var namedConsumerStrategy = dto.NamedConsumerStrategy; if (string.IsNullOrEmpty(namedConsumerStrategy)) { namedConsumerStrategy = dto.PreferRoundRobin ? SystemConsumerStrategies.RoundRobin : SystemConsumerStrategies.DispatchToSingle; } return new ClientMessage.UpdatePersistentSubscription(Guid.NewGuid(), package.CorrelationId, envelope, dto.EventStreamId, dto.SubscriptionGroupName, dto.ResolveLinkTos, dto.StartFrom, dto.MessageTimeoutMilliseconds, dto.RecordStatistics, dto.MaxRetryCount, dto.BufferSize, dto.LiveBufferSize, dto.ReadBatchSize, dto.CheckpointAfterTime, dto.CheckpointMinCount, dto.CheckpointMaxCount, dto.SubscriberMaxCount, namedConsumerStrategy, user, username, password); }
private ClientMessage.SubscribeToStream UnwrapSubscribeToStream(TcpPackage package, IEnvelope envelope, IPrincipal user, string login, string pass, TcpConnectionManager connection) { var dto = package.Data.Deserialize<TcpClientMessageDto.SubscribeToStream>(); if (dto == null) return null; return new ClientMessage.SubscribeToStream(Guid.NewGuid(), package.CorrelationId, envelope, connection.ConnectionId, dto.EventStreamId, dto.ResolveLinkTos, user); }
private ReplicationMessage.ReplicaSubscribed UnwrapReplicaSubscribed(TcpPackage package, IEnvelope envelope, TcpConnectionManager connection) { var dto = package.Data.Deserialize<ReplicationMessageDto.ReplicaSubscribed>(); return new ReplicationMessage.ReplicaSubscribed(new Guid(dto.MasterId), new Guid(dto.SubscriptionId), dto.SubscriptionPosition, connection.RemoteEndPoint); }
private ReplicationMessage.ReplicaLogPositionAck UnwrapReplicaLogPositionAck(TcpPackage package, IEnvelope envelope, TcpConnectionManager connection) { var dto = package.Data.Deserialize<ReplicationMessageDto.ReplicaLogPositionAck>(); return new ReplicationMessage.ReplicaLogPositionAck(new Guid(dto.SubscriptionId), dto.ReplicationLogPosition); }
private ClientMessage.DeletePersistentSubscription UnwrapDeletePersistentSubscription( TcpPackage package, IEnvelope envelope, IPrincipal user, string username, string password, TcpConnectionManager connection) { var dto = package.Data.Deserialize<TcpClientMessageDto.CreatePersistentSubscription>(); if (dto == null) return null; return new ClientMessage.DeletePersistentSubscription(Guid.NewGuid(), package.CorrelationId, envelope, dto.EventStreamId, dto.SubscriptionGroupName, user); }
public ConnectionClosed(TcpConnectionManager connection, SocketError socketError) { Connection = connection; SocketError = socketError; }
public TcpSend(TcpConnectionManager connectionManager, Message message) { ConnectionManager = connectionManager; Message = message; }
public Connected(TcpConnectionManager connection) { _connection = connection; }
private static ClientMessage.ReadAllEventsForward UnwrapReadAllEventsForward(TcpPackage package, IEnvelope envelope, TcpConnectionManager connection) { var dto = package.Data.Deserialize<TcpClientMessageDto.ReadAllEventsForward>(); if (dto == null) return null; return new ClientMessage.ReadAllEventsForward(package.CorrelationId, envelope, dto.CommitPosition, dto.PreparePosition, dto.MaxCount, dto.ResolveLinkTos); }
public UnsubscribeFromAllStreams(TcpConnectionManager connection, Guid correlationId) { Connection = connection; CorrelationId = correlationId; }
private ClientMessage.UnsubscribeFromAllStreams UnwrapUnsubscribeFromAllStreams(TcpPackage package, IEnvelope envelope, TcpConnectionManager connection) { //var dto = package.Data.Deserialize<HttpClientMessageDto.UnsubscribeFromAllStreams>(); return new ClientMessage.UnsubscribeFromAllStreams(connection, package.CorrelationId); }
public SubscribeToStream(TcpConnectionManager connection, Guid correlationId, string eventStreamId, bool resolveLinkTos) { Connection = connection; CorrelationId = correlationId; EventStreamId = eventStreamId; ResolveLinkTos = resolveLinkTos; }
public UnsubscribeFromStream(TcpConnectionManager connection, Guid correlationId, string eventStreamId) { Connection = connection; CorrelationId = correlationId; EventStreamId = eventStreamId; }
private ClientMessage.ConnectToPersistentSubscription UnwrapConnectToPersistentSubscription( TcpPackage package, IEnvelope envelope, IPrincipal user, string login, string pass, TcpConnectionManager connection) { var dto = package.Data.Deserialize<TcpClientMessageDto.ConnectToPersistentSubscription>(); if (dto == null) return null; return new ClientMessage.ConnectToPersistentSubscription(Guid.NewGuid(), package.CorrelationId, envelope, connection.ConnectionId, dto.SubscriptionId, dto.EventStreamId, dto.AllowedInFlightMessages, connection.RemoteEndPoint.ToString(), user); }