Esempio n. 1
0
        public virtual IEnumerable <StreamHead> GetStreamsToSnapshot(int maxThreshold)
        {
            Logger.Debug(Messages.GettingStreamsToSnapshot);

            return(TryMongo(() =>
            {
                IMongoQuery query = Query.GTE("Unsnapshotted", maxThreshold);

                return PersistedStreamHeads.Find(query).SetSortOrder(SortBy.Descending("Unsnapshotted")).Select(x => x.ToStreamHead());
            }));
        }
Esempio n. 2
0
        public virtual bool AddSnapshot(ISnapshot snapshot)
        {
            CheckIfSnapshotEnabled();

            if (snapshot == null)
            {
                return(false);
            }

            if (Logger.IsDebugEnabled)
            {
                Logger.Debug(Messages.AddingSnapshot, snapshot.StreamId, snapshot.BucketId, snapshot.StreamRevision);
            }

            try
            {
                BsonDocument mongoSnapshot = snapshot.ToMongoSnapshot(_serializer);
                var          query         = Builders <BsonDocument> .Filter.Eq(MongoShapshotFields.Id, mongoSnapshot[MongoShapshotFields.Id]);

                var update = Builders <BsonDocument> .Update.Set(MongoShapshotFields.Payload, mongoSnapshot[MongoShapshotFields.Payload]);

                // Doing an upsert instead of an insert allows us to overwrite an existing snapshot and not get stuck with a
                // stream that needs to be snapshotted because the insert fails and the SnapshotRevision isn't being updated.
                PersistedSnapshots.UpdateOne(query, update, new UpdateOptions()
                {
                    IsUpsert = true
                });

                // More commits could have been made between us deciding that a snapshot is required and writing it so just
                // resetting the Unsnapshotted count may be a little off. Adding snapshots should be a separate process so
                // this is a good chance to make sure the numbers are still in-sync - it only adds a 'read' after all ...
                BsonDocument streamHeadId = GetStreamHeadId(snapshot.BucketId, snapshot.StreamId);
                StreamHead   streamHead   = PersistedStreamHeads.Find(Builders <BsonDocument> .Filter.Eq(MongoStreamHeadFields.Id, streamHeadId))
                                            .First()
                                            .ToStreamHead();

                int unsnapshotted = streamHead.HeadRevision - snapshot.StreamRevision;

                PersistedStreamHeads.UpdateOne(
                    Builders <BsonDocument> .Filter
                    .Eq(MongoStreamHeadFields.Id, streamHeadId),
                    Builders <BsonDocument> .Update
                    .Set(MongoStreamHeadFields.SnapshotRevision, snapshot.StreamRevision)
                    .Set(MongoStreamHeadFields.Unsnapshotted, unsnapshotted)
                    );

                return(true);
            }
            catch (Exception)
            {
                return(false);
            }
        }
        /// <inheritdoc/>
        public virtual IEnumerable <IStreamHead> GetStreamsToSnapshot(string bucketId, int maxThreshold)
        {
            CheckIfSnapshotEnabled();

            Logger.LogDebug(Messages.GettingStreamsToSnapshot);

            return(TryMongo(() =>
            {
                var query = Builders <BsonDocument> .Filter.Gte(MongoStreamHeadFields.Unsnapshotted, maxThreshold);
                return PersistedStreamHeads
                .Find(query)
                .Sort(Builders <BsonDocument> .Sort.Descending(MongoStreamHeadFields.Unsnapshotted))
                .ToEnumerable()
                .Select(x => x.ToStreamHead());
            }));
        }