Exemplo n.º 1
0
        public void CompareColumnNames_DifferentTimestamps()
        {
            var ts      = Timestamp.Now;
            var eventId = Guid.NewGuid();

            EventPointerFormatter.CompareColumnNames(ColumnName(ts, eventId), ColumnName(ts.AddTicks(1), eventId)).Should().BeNegative();
        }
Exemplo n.º 2
0
 public void GetEventId()
 {
     EventPointerFormatter.GetEventId("00636207551966343582_7c314f94-26ea-4725-9cf8-ad5a91d01457").Should().Be(Guid.Parse("7c314f94-26ea-4725-9cf8-ad5a91d01457"));
     EventPointerFormatter.GetEventId("00636207551966343582_7C314F94-26EA-4725-9CF8-AD5A91D01457").Should().Be(Guid.Parse("7c314f94-26ea-4725-9cf8-ad5a91d01457"));
     EventPointerFormatter.GetEventId("00636207551966343582_ffffffff-ffff-ffff-ffff-ffffffffffff").Should().Be(maxGuid);
     EventPointerFormatter.GetEventId("00636207551966343582_00000000-0000-0000-0000-000000000000").Should().Be(minGuid);
 }
Exemplo n.º 3
0
        public void CompareColumnNames_EqualColumnNames()
        {
            var ts      = Timestamp.Now;
            var eventId = Guid.NewGuid();

            EventPointerFormatter.CompareColumnNames(ColumnName(ts, eventId), ColumnName(ts, eventId)).Should().Be(0);
        }
        public EventsQueryResult <TaskMetaUpdatedEvent, string> GetEvents([CanBeNull] string fromOffsetExclusive, [NotNull] string toOffsetInclusive, int estimatedCount)
        {
            if (estimatedCount <= 0)
            {
                throw new InvalidOperationException("estimatedCount <= 0");
            }
            if (string.IsNullOrEmpty(toOffsetInclusive))
            {
                throw new InvalidOperationException("toOffsetInclusive is not set");
            }

            var firstEventTicks = eventLogRepository.GetFirstEventTicks();

            if (firstEventTicks == 0)
            {
                return(new EventsQueryResult <TaskMetaUpdatedEvent, string>(new List <EventWithOffset <TaskMetaUpdatedEvent, string> >(), lastOffset: null, noMoreEventsInSource: true));
            }

            var exclusiveStartColumnName = GetExclusiveStartColumnName(fromOffsetExclusive, firstEventTicks);

            if (EventPointerFormatter.CompareColumnNames(exclusiveStartColumnName, toOffsetInclusive) >= 0)
            {
                return(new EventsQueryResult <TaskMetaUpdatedEvent, string>(new List <EventWithOffset <TaskMetaUpdatedEvent, string> >(), lastOffset: null, noMoreEventsInSource: true));
            }

            if (estimatedCount == int.MaxValue)
            {
                estimatedCount--;
            }

            var eventsToFetch = estimatedCount;
            var events        = new List <EventWithOffset <TaskMetaUpdatedEvent, string> >();
            var partitionKey  = EventPointerFormatter.GetPartitionKey(EventPointerFormatter.GetTimestamp(exclusiveStartColumnName).Ticks);

            while (true)
            {
                var eventsBatch = eventLogRepository.GetEvents(partitionKey, exclusiveStartColumnName, toOffsetInclusive, eventsToFetch, out var currentPartitionIsExhausted);
                events.AddRange(eventsBatch.Select(x => new EventWithOffset <TaskMetaUpdatedEvent, string>(x.Event, x.Offset)));

                if (!currentPartitionIsExhausted)
                {
                    return(new EventsQueryResult <TaskMetaUpdatedEvent, string>(events, lastOffset: events.Last().Offset, noMoreEventsInSource: false));
                }

                var nextPartitionStartTicks = (EventPointerFormatter.ParsePartitionKey(partitionKey) + 1) * EventPointerFormatter.PartitionDurationTicks;
                if (nextPartitionStartTicks > EventPointerFormatter.GetTimestamp(toOffsetInclusive).Ticks)
                {
                    return(new EventsQueryResult <TaskMetaUpdatedEvent, string>(events, lastOffset: toOffsetInclusive, noMoreEventsInSource: true));
                }

                eventsToFetch            = estimatedCount - events.Count;
                partitionKey             = EventPointerFormatter.GetPartitionKey(nextPartitionStartTicks);
                exclusiveStartColumnName = EventPointerFormatter.GetMaxColumnNameForTicks(nextPartitionStartTicks - 1);
            }
        }
 private static string GetExclusiveStartColumnName([CanBeNull] string fromOffsetExclusive, long firstEventTicks)
 {
     if (!string.IsNullOrEmpty(fromOffsetExclusive))
     {
         var fromTimestampExclusive = EventPointerFormatter.GetTimestamp(fromOffsetExclusive);
         if (fromTimestampExclusive.Ticks >= firstEventTicks)
         {
             return(fromOffsetExclusive);
         }
     }
     return(EventPointerFormatter.GetMaxColumnNameForTicks(firstEventTicks - 1));
 }
Exemplo n.º 6
0
 public int Compare([CanBeNull] string x, [CanBeNull] string y)
 {
     if (x == null && y == null)
     {
         return(0);
     }
     if (x == null)
     {
         return(-1);
     }
     if (y == null)
     {
         return(1);
     }
     return(EventPointerFormatter.CompareColumnNames(x, y));
 }
Exemplo n.º 7
0
        public string[] GetRecentTaskIds([CanBeNull] Timestamp fromTimestampExclusive, [NotNull] Timestamp toTimestampInclusive)
        {
            if (fromTimestampExclusive >= toTimestampInclusive)
            {
                return(new string[0]);
            }

            var firstEventTicks = EventLogRepository.GetFirstEventTicks();

            if (firstEventTicks == 0)
            {
                return(new string[0]);
            }

            var recentTaskIds            = new HashSet <string>();
            var exclusiveStartColumnName = fromTimestampExclusive == null || fromTimestampExclusive.Ticks < firstEventTicks
                                               ? EventPointerFormatter.GetMaxColumnNameForTicks(firstEventTicks - 1)
                                               : EventPointerFormatter.GetMaxColumnNameForTimestamp(fromTimestampExclusive);

            var       inclusiveEndColumnName = EventPointerFormatter.GetMaxColumnNameForTimestamp(toTimestampInclusive);
            var       partitionKey           = EventPointerFormatter.GetPartitionKey(EventPointerFormatter.GetTimestamp(exclusiveStartColumnName).Ticks);
            const int eventsToFetch          = int.MaxValue - 1;

            while (true)
            {
                var eventsBatch = EventLogRepository.GetEvents(partitionKey, exclusiveStartColumnName, inclusiveEndColumnName, eventsToFetch, out var currentPartitionIsExhausted);
                foreach (var(@event, _) in eventsBatch)
                {
                    recentTaskIds.Add(@event.TaskId);
                }

                if (!currentPartitionIsExhausted)
                {
                    throw new InvalidOperationException("currentPartitionIsExhausted == false");
                }

                var nextPartitionStartTicks = (EventPointerFormatter.ParsePartitionKey(partitionKey) + 1) * EventPointerFormatter.PartitionDurationTicks;
                if (nextPartitionStartTicks > toTimestampInclusive.Ticks)
                {
                    return(recentTaskIds.ToArray());
                }

                partitionKey             = EventPointerFormatter.GetPartitionKey(nextPartitionStartTicks);
                exclusiveStartColumnName = EventPointerFormatter.GetMaxColumnNameForTicks(nextPartitionStartTicks - 1);
            }
        }
Exemplo n.º 8
0
        public void CompareColumnNames_EqualTimestamps()
        {
            var ts = Timestamp.Now;

            EventPointerFormatter.CompareColumnNames(ColumnName(ts, minGuid), ColumnName(ts, maxGuid)).Should().BeNegative();
            EventPointerFormatter.CompareColumnNames(ColumnName(ts, minGuid), ColumnName(ts, Guid.NewGuid())).Should().BeNegative();
            EventPointerFormatter.CompareColumnNames(ColumnName(ts, minGuid), ColumnName(ts, Guid.Parse("a0000000-0000-0000-0000-000000000000"))).Should().BeNegative();
            EventPointerFormatter.CompareColumnNames(ColumnName(ts, minGuid), ColumnName(ts, Guid.Parse("000000a0-0000-0000-0000-000000000000"))).Should().BeNegative();
            EventPointerFormatter.CompareColumnNames(ColumnName(ts, minGuid), ColumnName(ts, Guid.Parse("0000000a-0000-0000-0000-000000000000"))).Should().BeNegative();
            EventPointerFormatter.CompareColumnNames(ColumnName(ts, minGuid), ColumnName(ts, Guid.Parse("00000000-0000-0000-0000-00000000000a"))).Should().BeNegative();
            EventPointerFormatter.CompareColumnNames(ColumnName(ts, minGuid), ColumnName(ts, Guid.Parse("f0000000-0000-0000-0000-000000000000"))).Should().BeNegative();
            EventPointerFormatter.CompareColumnNames(ColumnName(ts, minGuid), ColumnName(ts, Guid.Parse("00000000-0000-0000-0000-00000000000f"))).Should().BeNegative();
            EventPointerFormatter.CompareColumnNames(ColumnName(ts, Guid.NewGuid()), ColumnName(ts, maxGuid)).Should().BeNegative();
            EventPointerFormatter.CompareColumnNames(ColumnName(ts, Guid.Parse("a0000000-0000-0000-0000-000000000000")), ColumnName(ts, maxGuid)).Should().BeNegative();
            EventPointerFormatter.CompareColumnNames(ColumnName(ts, Guid.Parse("000000a0-0000-0000-0000-000000000000")), ColumnName(ts, maxGuid)).Should().BeNegative();
            EventPointerFormatter.CompareColumnNames(ColumnName(ts, Guid.Parse("0000000a-0000-0000-0000-000000000000")), ColumnName(ts, maxGuid)).Should().BeNegative();
            EventPointerFormatter.CompareColumnNames(ColumnName(ts, Guid.Parse("00000000-0000-0000-0000-00000000000a")), ColumnName(ts, maxGuid)).Should().BeNegative();
            EventPointerFormatter.CompareColumnNames(ColumnName(ts, Guid.Parse("f0000000-0000-0000-0000-000000000000")), ColumnName(ts, maxGuid)).Should().BeNegative();
            EventPointerFormatter.CompareColumnNames(ColumnName(ts, Guid.Parse("00000000-0000-0000-0000-00000000000f")), ColumnName(ts, maxGuid)).Should().BeNegative();
        }
Exemplo n.º 9
0
 private static string ColumnName(Timestamp ts, Guid eventId)
 {
     return(EventPointerFormatter.GetColumnName(ts.Ticks, eventId));
 }
Exemplo n.º 10
0
 public string GetMaxOffsetForTimestamp([NotNull] Timestamp timestamp)
 {
     return(EventPointerFormatter.GetMaxColumnNameForTimestamp(timestamp));
 }
Exemplo n.º 11
0
 public void ParsePartitionKey()
 {
     EventPointerFormatter.ParsePartitionKey("176724319").Should().Be(176724319);
 }
Exemplo n.º 12
0
 public void GetPartitionKey()
 {
     EventPointerFormatter.GetPartitionKey(636207551966343582).Should().Be("176724319");
     EventPointerFormatter.GetPartitionKey(636207548400000000).Should().Be("176724319");
     EventPointerFormatter.GetPartitionKey(new Timestamp(636207551966343582).Floor(TimeSpan.FromMinutes(6)).Ticks).Should().Be("176724319");
 }
 private static Guid GetEventId(EventWithOffset <TaskMetaUpdatedEvent, string> eventWithOffset)
 {
     return(EventPointerFormatter.GetEventId(eventWithOffset.Offset));
 }
 private static Timestamp GetTimestamp(EventWithOffset <TaskMetaUpdatedEvent, string> eventWithOffset)
 {
     return(EventPointerFormatter.GetTimestamp(eventWithOffset.Offset));
 }
 private static string Offset(Timestamp eventTimestamp, Guid eventId)
 {
     return(EventPointerFormatter.GetColumnName(eventTimestamp.Ticks, eventId));
 }
Exemplo n.º 16
0
 public void GetTimestamp()
 {
     EventPointerFormatter.GetTimestamp("00636207551966343582_7c314f94-26ea-4725-9cf8-ad5a91d01457").Should().Be(new Timestamp(636207551966343582));
     EventPointerFormatter.GetTimestamp("00636207551966343582_ffffffff-ffff-ffff-ffff-ffffffffffff").Should().Be(new Timestamp(636207551966343582));
     EventPointerFormatter.GetTimestamp("00636207551966343582_00000000-0000-0000-0000-000000000000").Should().Be(new Timestamp(636207551966343582));
 }
Exemplo n.º 17
0
 public Timestamp GetTimestampFromOffset([CanBeNull] string offset)
 {
     return(string.IsNullOrEmpty(offset) ? null : EventPointerFormatter.GetTimestamp(offset));
 }