Ejemplo n.º 1
0
        public VerificationResult VerifyThat(Event actualEvent, int actualVersion)
        {
            var sb = new StringBuilder();

            if (ShouldBeVersion != Core.Data.ExpectedVersion.Any && actualVersion != ShouldBeVersion)
                sb.AppendFormat("- Actual version is wrong. Expected: {0}, actual: {1}.\n", ShouldBeVersion, actualVersion);

            if (actualEvent == null)
            {
                sb.AppendFormat("- Actual event is NULL!\n");
                return new VerificationResult(ComparisonStatus.Fail, sb.ToString());
            }

            if (actualEvent.EventId != Event.EventId)
                sb.AppendFormat("- Wrong EventId. Expected: {0}, actual: {1}.\n", Event.EventId, actualEvent.EventId);
            if (actualEvent.EventType != Event.EventType)
                sb.AppendFormat("- Wrong EventType. Expected: {0}, actual: {1}.\n", Event.EventType, actualEvent.EventType);
            
            if (actualEvent.Data.Length != Event.Data.Length)
                sb.AppendFormat("- Wrong length of data. Expected length: {0}, actual length: {1}.\n", Event.Data.Length, actualEvent.Data.Length);
            else if (actualEvent.Data.Zip(Event.Data, Tuple.Create).Any(x => x.Item1 != x.Item2))
                sb.AppendFormat("- Wrong data.\n");

            if (actualEvent.Metadata.Length != Event.Metadata.Length)
                sb.AppendFormat("- Wrong length of metadata. Expected length: {0}, actual length: {1}.\n", Event.Metadata.Length, actualEvent.Metadata.Length);
            else if (actualEvent.Metadata.Zip(Event.Metadata, Tuple.Create).Any(x => x.Item1 != x.Item2))
                sb.AppendFormat("- Wrong metadata.\n");

            return new VerificationResult(sb.Length == 0 ? ComparisonStatus.Success : ComparisonStatus.Fail, sb.ToString());
        }
        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);
        }
 private void PublishCheckpoint(int state)
 {
     Log.Debug("publishing checkpoint " + state);
     _outstandingWrite = true;
     var evnt = new Event(Guid.NewGuid(), "SubscriptionCheckpoint", true, state.ToJson(), null);            
     _ioDispatcher.WriteEvent(_subscriptionStateStream, _version, evnt, SystemAccount.Principal, WriteStateCompleted);
 }
 public void Initialize()
 {
     _checkpointEventToBePublished = null;
     _inCheckpointWriteAttempt = 0;
     _ioDispatcher.Writer.Cancel(_writeRequestId);
     _lastWrittenCheckpointEventNumber = ExpectedVersion.Invalid;
 }
        public Event Create(int version)
        {
            var accountObject = BankAccountEventFactory.CreateAccountObject(version);

            var serializedObject = Codec.Json.To(accountObject);
            var @event = new Event(Guid.NewGuid(), accountObject.GetType().FullName, false,  Encoding.UTF8.GetBytes(serializedObject), new byte[0]);

            return @event;
        }
        public Event Create(int version)
        {
            var accountObject = BankAccountEventFactory.CreateAccountObject(version);

            var serializedObject = Codec.Json.To(accountObject);
            var @event = new Event(Guid.NewGuid(), accountObject.GetType().Name, true, Helper.UTF8NoBom.GetBytes(serializedObject), new byte[0]);

            return @event;
        }
        public void BeginParkMessage(ResolvedEvent ev,string reason, Action<ResolvedEvent, OperationResult> completed)
        {
            var metadata = new ParkedMessageMetadata {Added = DateTime.Now, Reason = reason, SubscriptionEventNumber = ev.OriginalEventNumber};
            
            string data = GetLinkToFor(ev);

            var parkedEvent = new Event(Guid.NewGuid(), SystemEventTypes.LinkTo, false, data, metadata.ToJson());

            _ioDispatcher.WriteEvent(_parkedStreamId, ExpectedVersion.Any, parkedEvent, SystemAccount.Principal, x => WriteStateCompleted(completed, ev, x));
        }
Ejemplo n.º 8
0
        public VerificationEvent Next()
        {
            var expected = _expected == -1 ? _expected : _expected + 1;
            var shouldBe = _shouldBe;

            _expected++;
            _shouldBe++;

            var evnt = new Event(Guid.NewGuid(), "TEST", false,  Encoding.UTF8.GetBytes(string.Format("TEST-DATA exp: {0}. shd: {1}.", expected, shouldBe)), Encoding.UTF8.GetBytes(string.Format("TEST-METADATA exp: {0}. shd: {1}.", expected, shouldBe)));
            return new VerificationEvent(evnt, StreamId, expected, shouldBe);
        }
Ejemplo n.º 9
0
            public WritePrepares(Guid correlationId, IEnvelope envelope, string eventStreamId, int expectedVersion,
                                 Event[] events, DateTime liveUntil)
            {
                CorrelationId = correlationId;
                Envelope = envelope;
                EventStreamId = eventStreamId;
                ExpectedVersion = expectedVersion;
                Events = events;

                LiveUntil = liveUntil;
            }
 protected override void BeginWriteCheckpoint(
     CheckpointTag requestedCheckpointPosition, string requestedCheckpointState)
 {
     _requestedCheckpointPosition = requestedCheckpointPosition;
     _inCheckpointWriteAttempt = 1;
     //TODO: pass correct expected version
     _checkpointEventToBePublished = new Event(
         Guid.NewGuid(), "ProjectionCheckpoint", true,
         requestedCheckpointState == null ? null : Encoding.UTF8.GetBytes(requestedCheckpointState),
         requestedCheckpointPosition.ToJsonBytes());
     PublishWriteCheckpointEvent();
 }
 public void BeginWriteCheckpoint(IEnvelope envelope,
     CheckpointTag requestedCheckpointPosition, string requestedCheckpointState)
 {
     _envelope = envelope;
     _requestedCheckpointPosition = requestedCheckpointPosition;
     _inCheckpointWriteAttempt = 1;
     //TODO: pass correct expected version
     _checkpointEventToBePublished = new Event(
         Guid.NewGuid(), ProjectionNamesBuilder.EventType_ProjectionCheckpoint, true,
         requestedCheckpointState == null ? null : Helper.UTF8NoBom.GetBytes(requestedCheckpointState),
         requestedCheckpointPosition.ToJsonBytes(projectionVersion: _projectionVersion));
     PublishWriteStreamMetadataAndCheckpointEvent();
 }
Ejemplo n.º 12
0
        public VerificationEvent(Event @event, 
                                 string eventStreamId, 
                                 int expectedVersion, 
                                 int shouldBeVersion)
        {
            Ensure.NotNull(@event, "event");
            Ensure.NotNullOrEmpty(eventStreamId, "eventStreamId");

            Event = @event;
            EventStreamId = eventStreamId;

            ExpectedVersion = expectedVersion;
            ShouldBeVersion = shouldBeVersion;
        }
Ejemplo n.º 13
0
            public WritePrepares(Guid correlationId, IEnvelope envelope, string eventStreamId, int expectedVersion, Event[] events, DateTime liveUntil)
            {
                Ensure.NotEmptyGuid(correlationId, "correlationId");
                Ensure.NotNull(envelope, "envelope");
                Ensure.NotNull(eventStreamId, "eventStreamId");
                Ensure.NotNull(events, "events");
                
                CorrelationId = correlationId;
                Envelope = envelope;
                EventStreamId = eventStreamId;
                ExpectedVersion = expectedVersion;
                Events = events;

                LiveUntil = liveUntil;
            }
 private void OnWriteComplete(ClientMessage.WriteEventsCompleted completed, Event evnt, string streamId, int retryCount)
 {
     if (completed.Result != OperationResult.Success)
     {
         if (retryCount > 0)
         {
             Log.Error("PROJECTIONS: Failed to write a tracked stream id of {0} to the {1} stream. Retrying {2}/{3}. Reason: {4}", streamId, _projectionNamesBuilder.GetEmittedStreamsName(), (MaxRetryCount - retryCount) + 1, MaxRetryCount, completed.Result);
             WriteEvent(evnt, retryCount - 1);
         }
         else
         {
             Log.Error("PROJECTIONS: Failed to write a tracked stream id of {0} to the {1} stream. Retry limit of {2} reached. Reason: {3}", streamId, _projectionNamesBuilder.GetEmittedStreamsName(), MaxRetryCount, completed.Result);
         }
     }
 }
 //NOTE: committed event with null event _data means - end of the source reached.
 // Current last available TF commit position is in _position.CommitPosition
 // TODO: separate message?
 public CommittedEventDistributed(
     Guid correlationId, EventPosition position, string positionStreamId, int positionSequenceNumber,
     string eventStreamId, int eventSequenceNumber, bool resolvedLinkTo, Event data,
     long? safeTransactionFileReaderJoinPosition, float progress)
 {
     _correlationId = correlationId;
     _data = data;
     _safeTransactionFileReaderJoinPosition = safeTransactionFileReaderJoinPosition;
     _progress = progress;
     _position = position;
     _positionStreamId = positionStreamId;
     _positionSequenceNumber = positionSequenceNumber;
     _eventStreamId = eventStreamId;
     _eventSequenceNumber = eventSequenceNumber;
     _resolvedLinkTo = resolvedLinkTo;
 }
 public void TrackEmittedStream(EmittedEvent[] emittedEvents)
 {
     if (!_projectionConfig.TrackEmittedStreams) return;
     foreach (var emittedEvent in emittedEvents)
     {
         string streamId;
         if (!_streamIdCache.TryGetRecord(emittedEvent.StreamId, out streamId))
         {
             var trackEvent = new Event(Guid.NewGuid(), ProjectionEventTypes.StreamTracked, false, Helper.UTF8NoBom.GetBytes(emittedEvent.StreamId), null);
             lock (_locker)
             {
                 _streamIdCache.PutRecord(emittedEvent.StreamId, emittedEvent.StreamId, false);
             }
             WriteEvent(trackEvent, MaxRetryCount);
         }
     }
 }
Ejemplo n.º 17
0
        private Task NextForStream(string stream)
        {
            var expected = _currentExpected == -1 ? _currentExpected : _currentExpected + 1;
            var shouldBe = _currentShouldBe;

            _currentExpected++;
            _currentShouldBe++;

            var evnt = new Event(
                Guid.NewGuid(), 
                "TEST", 
                false,
                Encoding.UTF8.GetBytes(string.Format("TEST-DATA exp: {0}. shd: {1}.", expected, shouldBe)),
                Encoding.UTF8.GetBytes(string.Format("TEST-METADATA exp: {0}. shd: {1}.", expected, shouldBe)));

            return new WriteTask(new VerificationEvent(evnt, stream, expected, shouldBe));
        }
Ejemplo n.º 18
0
        public Task Next()
        {
            var expected = _expected == -1 ? _expected : _expected + 1;
            var shouldBe = _shouldBe;

            _expected++;
            _shouldBe++;

            var accountObject = BankAccountEventFactory.CreateAccountObject(shouldBe);
            var metadata = new Dictionary<string, string> {{"Source", "National Bank"}};

            var serializedObject = Codec.Json.To(accountObject);
            var serializedMetadata = Codec.Json.To(metadata);

            var @event = new Event(Guid.NewGuid(), accountObject.GetType().FullName, false,  Encoding.UTF8.GetBytes(serializedObject), Encoding.UTF8.GetBytes(serializedMetadata));

            var verificationEvent = new VerificationEvent(@event, "AdvBankAccount", expected, shouldBe);
            return new WriteTask(verificationEvent);
        }
Ejemplo n.º 19
0
            public TransactionWriteRequestCreated(Guid correlationId, IEnvelope envelope, long transactionId, string eventStreamId, Event[] events)
            {
                Ensure.NotEmptyGuid(correlationId, "correlationId");
                Ensure.NotNull(envelope, "envelope");
                Ensure.Nonnegative(transactionId, "transactionId");
                Ensure.NotNull(eventStreamId, "eventStreamId");
                Ensure.NotNull(events, "events");

                CorrelationId = correlationId;
                Envelope = envelope;
                TransactionId = transactionId;
                EventStreamId = eventStreamId;
                Events = events;
            }
Ejemplo n.º 20
0
 public WriteTransactionData(Guid correlationId, IEnvelope envelope, long transactionId, Event[] events)
 {
     CorrelationId = correlationId;
     Envelope = envelope;
     TransactionId = transactionId;
     Events = events;
 }
        private static Event[] Parse(HttpClientMessageDto.ClientEventDynamic[] dynamicEvents)
        {
            var events = new Event[dynamicEvents.Length];
            for (int i = 0, n = dynamicEvents.Length; i < n; ++i)
            {
                var textEvent = dynamicEvents[i];
                bool dataIsJson;
                bool metadataIsJson;
                var data = AsBytes(textEvent.Data, out dataIsJson);
                var metadata = AsBytes(textEvent.Metadata, out metadataIsJson);

                events[i] = new Event(textEvent.EventId, textEvent.EventType, dataIsJson || metadataIsJson, data, metadata);
            }
            return events.ToArray();
        }
Ejemplo n.º 22
0
            public TransactionWrite(Guid internalCorrId, Guid correlationId, IEnvelope envelope, bool requireMaster,
                                    long transactionId, Event[] events,
                                    IPrincipal user, string login = null, string password = null)
                : base(internalCorrId, correlationId, envelope, requireMaster, user, login, password)
            {
                Ensure.Nonnegative(transactionId, "transactionId");
                Ensure.NotNull(events, "events");

                TransactionId = transactionId;
                Events = events;
            }
Ejemplo n.º 23
0
 public WriteEvents(Guid internalCorrId, Guid correlationId, IEnvelope envelope, bool requireMaster,
                    string eventStreamId, int expectedVersion, Event @event,
                    IPrincipal user, string login = null, string password = null)
     : this(internalCorrId, correlationId, envelope, requireMaster, eventStreamId, expectedVersion,
            @event == null ? null : new[] { @event }, user, login, password)
 {
 }
Ejemplo n.º 24
0
            public WriteEvents(Guid internalCorrId, Guid correlationId, IEnvelope envelope, bool requireMaster, 
                               string eventStreamId, int expectedVersion, Event[] events,
                               IPrincipal user, string login = null, string password = null)
                : base(internalCorrId, correlationId, envelope, requireMaster, user, login, password)
            {
                Ensure.NotNullOrEmpty(eventStreamId, "eventStreamId");
                if (expectedVersion < Data.ExpectedVersion.Any) throw new ArgumentOutOfRangeException("expectedVersion");
                Ensure.NotNull(events, "events");

                EventStreamId = eventStreamId;
                ExpectedVersion = expectedVersion;
                Events = events;
            }
 public override void Initialize()
 {
     base.Initialize();
     _writeDispatcher.Cancel(_writeRequestId);
     _readDispatcher.Cancel(_readRequestId);
     foreach (var requestId in _loadStateRequests)
         _readDispatcher.Cancel(requestId);
     _loadStateRequests.Clear();
     _inCheckpointWriteAttempt = 0;
     _lastWrittenCheckpointEventNumber = 0;
     _nextStateIndexToRequest = 0;
     _checkpointEventToBePublished = null;
     _requestedCheckpointPosition = null;
     _readRequestsInProgress = 0;
 }
 public void BeginParkMessage(ResolvedEvent @event,string reason, Action<ResolvedEvent, OperationResult> completed)
 {
     var metadata = new ParkedMessageMetadata() {Added = DateTime.Now, Reason = reason};
     var evnt = new Event(Guid.NewGuid(), SystemEventTypes.LinkTo, false, GetLinkToFor(@event), metadata.ToJson());
     _ioDispatcher.WriteEvent(_parkedStreamId, ExpectedVersion.Any, evnt, SystemAccount.Principal, x => WriteStateCompleted(completed, @event, x));
 }
Ejemplo n.º 27
0
            public WriteRequestCreated(Guid correlationId, 
                                       IEnvelope envelope,
                                       string eventStreamId,
                                       int expectedVersion,
                                       Event[] events)
            {
                Ensure.NotEmptyGuid(correlationId, "correlationId");
                Ensure.NotNull(envelope, "envelope");
                Ensure.NotNullOrEmpty(eventStreamId, "eventStreamId");
                Ensure.NotNull(events, "events");

                CorrelationId = correlationId;
                Envelope = envelope;

                EventStreamId = eventStreamId;
                ExpectedVersion = expectedVersion;

                Events = events;
            }
Ejemplo n.º 28
0
 private static Event[] LoadRaw(string data, bool isJson, Guid includedId, string includedType) {
     var ret = new Event[1];
     ret[0] = new Event(includedId, includedType, isJson, data, null);
     return ret;
 }
Ejemplo n.º 29
0
 private static Event[] LoadRaw(byte[] data, Guid includedId, string includedType)
 {
     var ret = new Event[1];
     ret[0] = new Event(includedId, includedType, false, data, null);
     return ret;
 }
Ejemplo n.º 30
0
        private static ClientMessage.WriteEvents UnwrapWriteEvents(TcpPackage package, IEnvelope envelope,
                                                                   IPrincipal user, string login, string password)
        {
            var dto = package.Data.Deserialize<TcpClientMessageDto.WriteEvents>();
            if (dto == null) return null;
            
            var events = new Event[dto.Events == null ? 0 : dto.Events.Length];
            for (int i = 0; i < events.Length; ++i)
            {
// ReSharper disable PossibleNullReferenceException
                var e = dto.Events[i];
// ReSharper restore PossibleNullReferenceException
                events[i] = new Event(new Guid(e.EventId), e.EventType, e.DataContentType == 1, e.Data, e.Metadata);
            }
            return new ClientMessage.WriteEvents(Guid.NewGuid(), package.CorrelationId, envelope, dto.RequireMaster,
                                                 dto.EventStreamId, dto.ExpectedVersion, events, user, login, password);
        }