public TcpDefaultAuthRequest(TcpConnectionManager manager, Guid correlationId, UserCredentials userCredentials) : base(userCredentials.Login, userCredentials.Password) { _manager = manager; _correlationId = correlationId; _userCredentials = userCredentials; }
public Message UnwrapPackage(TcpPackage package, IEnvelope envelope, IPrincipal user, string login, string pass, TcpConnectionManager connection, byte version) { if (envelope == null) { throw new ArgumentNullException("envelope"); } var unwrapper = _unwrappers[version][(byte)package.Command]; if (unwrapper == null) { unwrapper = _unwrappers[_unwrappers.Length - 1][(byte)package.Command]; } if (unwrapper != null) { try { return(unwrapper(package, envelope, user, login, pass, connection)); } catch (Exception exc) { Log.ErrorException(exc, "Error while unwrapping TcpPackage with command {command}.", package.Command); } } return(null); }
public SendOverTcpEnvelope(TcpConnectionManager manager, IPublisher networkSendQueue) { Ensure.NotNull(manager, "manager"); Ensure.NotNull(networkSendQueue, "networkSendQueue"); _networkSendQueue = networkSendQueue; _manager = manager; }
private void OnConnectionAccepted(IPEndPoint endPoint, Socket socket) { var conn = _securityType == TcpSecurityType.Secure ? TcpConnectionSsl.CreateServerFromSocket(Guid.NewGuid(), endPoint, socket, _certificate, verbose: true) : TcpConnection.CreateAcceptedTcpConnection(Guid.NewGuid(), endPoint, socket, verbose: true); Log.Information( "{serviceType} TCP connection accepted: [{securityType}, {remoteEndPoint}, L{localEndPoint}, {connectionId:B}].", _serviceType, _securityType, conn.RemoteEndPoint, conn.LocalEndPoint, conn.ConnectionId); var dispatcher = _dispatcherFactory(conn.ConnectionId, _serverEndPoint); var manager = new TcpConnectionManager( string.Format("{0}-{1}", _serviceType.ToString().ToLower(), _securityType.ToString().ToLower()), _serviceType, dispatcher, _publisher, conn, _networkSendQueue, _authProvider, _heartbeatInterval, _heartbeatTimeout, (m, e) => _publisher.Publish(new TcpMessage.ConnectionClosed(m, e)), _connectionPendingSendBytesThreshold, _connectionQueueSizeThreshold); // TODO AN: race condition _publisher.Publish(new TcpMessage.ConnectionEstablished(manager)); manager.StartReceiving(); }
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)); }
public SendOverTcpEnvelope(TcpConnectionManager manager, IPublisher networkSendQueue) { _networkSendQueue = networkSendQueue; Ensure.NotNull(manager, "manager"); Ensure.NotNull(networkSendQueue, "networkSendQueue"); _manager = new WeakReference(manager); }
public SendOverTcpEnvelope(TcpConnectionManager manager) { if (manager == null) { throw new ArgumentNullException("manager"); } _manager = new WeakReference(manager); }
public TcpDefaultAuthRequest(TcpConnectionManager manager, Guid correlationId, UserCredentials userCredentials) : base($"(TCP) {manager.RemoteEndPoint}", userCredentials.Tokens) { _manager = manager; _correlationId = correlationId; _userCredentials = userCredentials; }
public Message UnwrapPackage(TcpPackage package, IEnvelope envelope, TcpConnectionManager connection) { if (envelope == null) throw new ArgumentNullException("envelope"); Func<TcpPackage, IEnvelope, TcpConnectionManager, Message> unwrapper = _unwrappers[(byte)package.Command]; return unwrapper == null ? null : unwrapper(package, envelope, connection); }
private void OnConnectionAccepted(TcpConnection connection) { Log.Info("Client TCP connection accepted: [{0}]", connection.EffectiveEndPoint); var manager = new TcpConnectionManager("REPLICA", _tcpDispatcher, _publisher, connection); manager.ConnectionClosed += OnConnectionClosed; _publisher.Publish(new TcpMessage.ConnectionEstablished(manager)); manager.StartReceiving(); }
private ReplicationMessage.ReplicaSubscribed UnwrapReplicaSubscribed(TcpPackage package, IEnvelope envelope, TcpConnectionManager connection) { var dto = package.Data.Deserialize <ReplicationMessageDto.ReplicaSubscribed>(); return(new ReplicationMessage.ReplicaSubscribed(new Guid(dto.LeaderId), new Guid(dto.SubscriptionId), dto.SubscriptionPosition, connection.RemoteEndPoint)); }
private ClientMessage.DeletePersistentSubscription UnwrapDeletePersistentSubscription( TcpPackage package, IEnvelope envelope, ClaimsPrincipal user, 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)); }
//private static TcpPackage WrapReadEventsFromBeginning(ClientMessage.ReadEventsForward msg) //{ // var dto = new ClientMessageDto.ReadEventsForward(msg.CorrelationId, // msg.EventStreamId, // msg.EventNumber, // msg.MaxCount); // return new TcpPackage(TcpCommand.ReadEventsForward, dto.Serialize()); //} private static ClientMessage.ReadEventsForward UnwrapReadEventsForward(TcpPackage package, IEnvelope envelope, TcpConnectionManager connection) { var dto = package.Data.Deserialize <ClientMessageDto.ReadEventsForward>(); return(new ClientMessage.ReadEventsForward(new Guid(dto.CorrelationId), envelope, dto.EventStreamId, dto.StartIndex, dto.MaxCount, dto.ResolveLinktos)); }
private ClientMessage.PersistentSubscriptionAckEvents UnwrapPersistentSubscriptionAckEvents( TcpPackage package, IEnvelope envelope, ClaimsPrincipal user, TcpConnectionManager connection) { var dto = package.Data.Deserialize <TcpClientMessageDto.PersistentSubscriptionAckEvents>(); if (dto == null) { return(null); } return(new ClientMessage.PersistentSubscriptionAckEvents( Guid.NewGuid(), package.CorrelationId, envelope, dto.SubscriptionId, dto.ProcessedEventIds.Select(x => new Guid(x)).ToArray(), user)); }
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)); }
private ClientMessage.SubscribeToStream UnwrapSubscribeToStream(TcpPackage package, IEnvelope envelope, ClaimsPrincipal user, 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)); }
public Message UnwrapPackage(TcpPackage package, IEnvelope envelope, ClaimsPrincipal user, IReadOnlyDictionary <string, string> tokens, TcpConnectionManager connection, byte version) { if (envelope == null) { throw new ArgumentNullException(nameof(envelope)); } var unwrapper = _unwrappers[version][(byte)package.Command] ?? _unwrappers[^ 1][(byte)package.Command]; try { return(unwrapper?.Invoke(package, envelope, user, tokens, connection)); } catch (Exception exc) { Log.Error(exc, "Error while unwrapping TcpPackage with command {command}.", package.Command); } return(null); }
public Message UnwrapPackage(TcpPackage package, IEnvelope envelope, TcpConnectionManager connection) { if (envelope == null) { throw new ArgumentNullException("envelope"); } Func <TcpPackage, IEnvelope, TcpConnectionManager, Message> unwrapper = _unwrappers[(byte)package.Command]; if (unwrapper != null) { try { return(unwrapper(package, envelope, connection)); } catch (Exception exc) { Log.ErrorException(exc, "Error while unwrapping TcpPackage with command {0}.", package.Command); } } return(null); }
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 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 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.LeaderId), new Guid(dto.SubscriptionId), dto.IsPromotable)); }
private ClientMessage.SubscribeToAllStreams UnwrapSubscribeToAllStreams(TcpPackage package, IEnvelope envelope, TcpConnectionManager connection) { //var dto = package.Data.Deserialize<HttpClientMessageDto.SubscribeToAllStreams>(); return(new ClientMessage.SubscribeToAllStreams(connection, package.CorrelationId)); }
public TcpAuthRequest(TcpConnectionManager manager, TcpPackage package, string login, string password) : base(login, password) { _manager = manager; _package = package; }
//private static ClientMessage.ReadEventsForwardCompleted UnwrapReadEventsFromBeginningCompleted( // TcpPackage package, // IEnvelope envelope, // TcpConnectionManager connection) //{ // var dto = package.Data.Deserialize<ClientMessageDto.ReadEventsForwardCompleted>(); // return new ClientMessage.ReadEventsForwardCompleted(new Guid(dto.CorrelationId), // dto.EventStreamId, // dto.Events, // dto.LinkToEvents, // (RangeReadResult)dto.Result, // dto.LastCommitPosition); //} private ClientMessage.SubscribeToStream UnwrapSubscribeToStream(TcpPackage package, IEnvelope envelope, TcpConnectionManager connection) { var dto = package.Data.Deserialize <ClientMessageDto.SubscribeToStream>(); return(new ClientMessage.SubscribeToStream(connection, new Guid(dto.CorrelationId), dto.EventStreamId)); }
private void OnConnectionClosed(TcpConnectionManager manager, SocketError socketError) { manager.ConnectionClosed -= OnConnectionClosed; _publisher.Publish(new TcpMessage.ConnectionClosed(manager, socketError)); }
public TcpAuthRequest(TcpConnectionManager manager, TcpPackage package, string login, string password) : base($"(TCP) {manager.RemoteEndPoint}", login, password) { _manager = manager; _package = package; }
private ClientMessage.FilteredSubscribeToStream UnwrapFilteredSubscribeToStream(TcpPackage package, IEnvelope envelope, ClaimsPrincipal user, TcpConnectionManager connection) { var dto = package.Data.Deserialize <TcpClientMessageDto.FilteredSubscribeToStream>(); if (dto == null) { return(null); } IEventFilter eventFilter = EventFilter.Get(dto.Filter); return(new ClientMessage.FilteredSubscribeToStream(Guid.NewGuid(), package.CorrelationId, envelope, connection.ConnectionId, dto.EventStreamId, dto.ResolveLinkTos, user, eventFilter, dto.CheckpointInterval)); }
private static ClientMessage.ReadAllEventsBackward UnwrapReadAllEventsBackward(TcpPackage package, IEnvelope envelope, TcpConnectionManager connection) { var dto = package.Data.Deserialize <TcpClientMessageDto.ReadAllEventsBackward>(); if (dto == null) { return(null); } return(new ClientMessage.ReadAllEventsBackward(package.CorrelationId, envelope, dto.CommitPosition, dto.PreparePosition, dto.MaxCount, dto.ResolveLinkTos)); }
private ClientMessage.UnsubscribeFromAllStreams UnwrapUnsubscribeFromAllStreams(TcpPackage package, IEnvelope envelope, TcpConnectionManager connection) { var dto = package.Data.Deserialize <ClientMessageDto.UnsubscribeFromAllStreams>(); return(new ClientMessage.UnsubscribeFromAllStreams(connection, new Guid(dto.CorrelationId))); }
public TcpAuthRequest(TcpConnectionManager manager, TcpPackage package) : base($"(TCP) {manager.RemoteEndPoint}", package.Tokens) { _manager = manager; _package = package; }