public void Connect(IPEndPoint tcpEndPoint, IPEndPoint httpEndPoint = null)
        {
            Ensure.NotNull(tcpEndPoint, "tcpEndPoint");
            var task = ConnectAsync(tcpEndPoint, httpEndPoint);

            task.Wait();
        }
        public Task SubscribeToAllStreamsAsync(Action <RecordedEvent, Position> eventAppeared, Action subscriptionDropped)
        {
            Ensure.NotNull(eventAppeared, "eventAppeared");
            Ensure.NotNull(subscriptionDropped, "subscriptionDropped");
            EnsureActive();

            lock (_connectionLock)
                _subscriptionsChannel.EnsureConnected(_tcpEndPoint);
            return(_subscriptionsChannel.SubscribeToAllStreams(eventAppeared, subscriptionDropped));
        }
        public void TransactionalWrite(long transactionId, string stream, IEnumerable <IEvent> events)
        {
            Ensure.NotNullOrEmpty(stream, "stream");
            Ensure.NotNull(events, "events");
            EnsureActive();

            var task = TransactionalWriteAsync(transactionId, stream, events);

            task.Wait();
        }
        public void AppendToStream(string stream, int expectedVersion, IEnumerable <IEvent> events)
        {
            Ensure.NotNullOrEmpty(stream, "stream");
            Ensure.NotNull(events, "events");
            EnsureActive();

            var task = AppendToStreamAsync(stream, expectedVersion, events);

            task.Wait();
        }
        public AllEventsSlice ReadAllEventsBackward(Position position, int maxCount)
        {
            Ensure.NotNull(position, "position");
            Ensure.Positive(maxCount, "maxCount");
            EnsureActive();

            var task = ReadAllEventsBackwardAsync(position, maxCount);

            task.Wait();
            return(task.Result);
        }
        public Task <AllEventsSlice> ReadAllEventsBackwardAsync(Position position, int maxCount)
        {
            Ensure.NotNull(position, "position");
            Ensure.Positive(maxCount, "maxCount");
            EnsureActive();

            var source    = new TaskCompletionSource <AllEventsSlice>();
            var operation = new ReadAllEventsBackwardOperation(source, Guid.NewGuid(), position, maxCount, true);

            EnqueueOperation(operation);
            return(source.Task);
        }
        public Task TransactionalWriteAsync(long transactionId, string stream, IEnumerable <IEvent> events)
        {
            Ensure.NotNullOrEmpty(stream, "stream");
            Ensure.NotNull(events, "events");
            EnsureActive();

            var source    = new TaskCompletionSource <object>();
            var operation = new TransactionalWriteOperation(source, Guid.NewGuid(), _allowForwarding, transactionId, stream, events);

            EnqueueOperation(operation);
            return(source.Task);
        }
        public Task AppendToStreamAsync(string stream, int expectedVersion, IEnumerable <IEvent> events)
        {
            Ensure.NotNullOrEmpty(stream, "stream");
            Ensure.NotNull(events, "events");
            EnsureActive();

            var source    = new TaskCompletionSource <object>();
            var operation = new AppendToStreamOperation(source, Guid.NewGuid(), _allowForwarding, stream, expectedVersion, events);

            EnqueueOperation(operation);
            return(source.Task);
        }
 public Task ConnectAsync(IPEndPoint tcpEndPoint, IPEndPoint httpEndPoint = null)
 {
     Ensure.NotNull(tcpEndPoint, "tcpEndPoint");
     return(EstablishConnectionAsync(tcpEndPoint, httpEndPoint ?? new IPEndPoint(tcpEndPoint.Address, tcpEndPoint.Port + 1000)));
 }