PersistedEventLog.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Security;
 
namespace Waher.Events.Persistence
{
    public class PersistedEventLog : EventSink
    {
        private Timer timer;
        private int eventLifetimeDays;
        private string defaultFacility;
        private string defaultFacilityDigest = null;
 
        public PersistedEventLog(int EventLifetimeDays)
            : this(EventLifetimeDays, null, string.Empty, string.Empty)
        {
        }
 
        public PersistedEventLog(int EventLifetimeDays, TimeSpan? CleanupTime)
            : this(EventLifetimeDays, CleanupTime, string.Empty, string.Empty)
        {
        }
 
        public PersistedEventLog(int EventLifetimeDays, TimeSpan? CleanupTime, string DefaultFacility, string DefaultFacilityKey)
            : base("Persisted Event Log")
        {
            if (EventLifetimeDays <= 0)
                throw new ArgumentOutOfRangeException("The lifetime must be a positive number of days.", nameof(EventLifetimeDays));
 
            this.eventLifetimeDays = EventLifetimeDays;
            this.defaultFacility = DefaultFacility;
            this.defaultFacilityDigest = this.ComputeDigest(DefaultFacilityKey);
 
            if (CleanupTime.HasValue)
                this.TurnOnDailyPurge(EventLifetimeDays, CleanupTime.Value);
            else
                this.timer = null;
        }
 
        public void TurnOnDailyPurge(int EventLifetimeDays, TimeSpan CleanupTime)
        {
            this.TurnOffDailyPurge();
 
            if (CleanupTime < TimeSpan.Zero || CleanupTime.TotalDays >= 1.0)
                throw new ArgumentOutOfRangeException("Invalid time.", nameof(CleanupTime));
 
            int MillisecondsPerDay = 1000 * 60 * 60 * 24;
            int MsUntilNext = (int)((DateTime.Today.AddDays(1).Add(CleanupTime) - DateTime.Now).TotalMilliseconds + 0.5);
 
            this.eventLifetimeDays = EventLifetimeDays;
            this.timer = new Timer(this.DoCleanup, null, MsUntilNext, MillisecondsPerDay);
        }
 
        public bool TurnOffDailyPurge()
        {
            if (!(this.timer is null))
            {
                this.timer.Dispose();
                this.timer = null;
 
                return true;
            }
            else
                return false;
        }
 
        public override void Dispose()
        {
            this.TurnOffDailyPurge();
            base.Dispose();
        }
 
        private async void DoCleanup(object P)
        {
            try
            {
                await this.DeleteOld(DateTime.Now.AddDays(-this.eventLifetimeDays));
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        public Task<int> DeleteOld(DateTime Limit)
        {
            return DeleteOld(this.ObjectID, Limit);
        }
 
        public static async Task<int> DeleteOld(string ObjectId, DateTime Limit)
        {
            int NrEvents = 0;
            bool Deleted;
 
            do
            {
                Deleted = false;
 
                foreach (PersistedEvent Event in await Database.FindDelete<PersistedEvent>(0, 100, new FilterFieldLesserOrEqualTo("Timestamp", Limit)))
                {
                    NrEvents++;
                    Deleted = true;
                }
            }
            while (Deleted);
 
            if (NrEvents > 0)
            {
                KeyValuePair<string, object>[] Tags = new KeyValuePair<string, object>[]
                {
                    new KeyValuePair<string, object>("Limit", Limit),
                    new KeyValuePair<string, object>("NrEvents", NrEvents)
                };
 
                if (NrEvents == 1)
                    Log.Informational("Deleting 1 event from the database.", ObjectId, Tags);
                else
                    Log.Informational("Deleting " + NrEvents.ToString() + " events from the database.", ObjectId, Tags);
            }
 
            return NrEvents;
        }
 
        public Task<IEnumerable<PersistedEvent>> GetEvents(int Offset, int MaxCount, DateTime From, DateTime To)
        {
            return Database.Find<PersistedEvent>(Offset, MaxCount, new FilterAnd(
                new FilterFieldGreaterOrEqualTo("Timestamp", From),
                new FilterFieldLesserOrEqualTo("Timestamp", To)), "-Timestamp");
        }
 
        public Task<IEnumerable<PersistedEvent>> GetEventsOfType(int Offset, int MaxCount, EventType Type, DateTime From, DateTime To)
        {
            return Database.Find<PersistedEvent>(Offset, MaxCount, new FilterAnd(
                new FilterFieldGreaterOrEqualTo("Type", Type),
                new FilterFieldGreaterOrEqualTo("Timestamp", From),
                new FilterFieldLesserOrEqualTo("Timestamp", To)), "-Timestamp");
        }
 
        public Task<IEnumerable<PersistedEvent>> GetEventsOfObject(int Offset, int MaxCount, string Object, DateTime From, DateTime To)
        {
            return Database.Find<PersistedEvent>(Offset, MaxCount, new FilterAnd(
                new FilterFieldGreaterOrEqualTo("Object", Object),
                new FilterFieldGreaterOrEqualTo("Timestamp", From),
                new FilterFieldLesserOrEqualTo("Timestamp", To)), "-Timestamp");
        }
 
        public Task<IEnumerable<PersistedEvent>> GetEventsOfActor(int Offset, int MaxCount, string Actor, DateTime From, DateTime To)
        {
            return Database.Find<PersistedEvent>(Offset, MaxCount, new FilterAnd(
                new FilterFieldGreaterOrEqualTo("Actor", Actor),
                new FilterFieldGreaterOrEqualTo("Timestamp", From),
                new FilterFieldLesserOrEqualTo("Timestamp", To)), "-Timestamp");
        }
 
        public Task<IEnumerable<PersistedEvent>> GetEventsOfEventId(int Offset, int MaxCount, string EventId, DateTime From, DateTime To)
        {
            return Database.Find<PersistedEvent>(Offset, MaxCount, new FilterAnd(
                new FilterFieldGreaterOrEqualTo("EventId", EventId),
                new FilterFieldGreaterOrEqualTo("Timestamp", From),
                new FilterFieldLesserOrEqualTo("Timestamp", To)), "-Timestamp");
        }
 
        public Task<IEnumerable<PersistedEvent>> GetEventsOfFacility(int Offset, int MaxCount, string Facility, DateTime From, DateTime To)
        {
            return Database.Find<PersistedEvent>(Offset, MaxCount, new FilterAnd(
                new FilterFieldGreaterOrEqualTo("Facility", Facility),
                new FilterFieldGreaterOrEqualTo("Timestamp", From),
                new FilterFieldLesserOrEqualTo("Timestamp", To)), "-Timestamp");
        }
 
        public int EventLifetimeDays => this.eventLifetimeDays;
 
        public override async Task Queue(Event Event)
        {
            PersistedEvent PersistedEvent = new PersistedEvent(Event);
 
            if (string.IsNullOrEmpty(PersistedEvent.Facility))
                PersistedEvent.Facility = this.defaultFacility;
 
            await Database.InsertLazy(PersistedEvent);
        }
 
        public void SetDefaultFacility(string DefaultFacility, string DefaultFacilityKey)
        {
            if (this.defaultFacility != DefaultFacility)
            {
                if (!string.IsNullOrEmpty(this.defaultFacility))
                {
                    if (this.ComputeDigest(DefaultFacilityKey) != this.defaultFacilityDigest)
                        throw new UnauthorizedAccessException("Unauthorized to change the default facility.");
                }
 
                this.defaultFacility = DefaultFacility;
                this.defaultFacilityDigest = this.ComputeDigest(DefaultFacilityKey);
            }
        }
 
        private string ComputeDigest(string Key)
        {
            return Hashes.ComputeSHA256HashString(Encoding.UTF8.GetBytes(Key + ":" + this.defaultFacility));
        }
 
        internal static int ArchiveDays
        {
            get
            {
                if (registeredLog is null)
                {
                    foreach (IEventSink Sink in Log.Sinks)
                    {
                        if (Sink is PersistedEventLog PersistedEventLog)
                        {
                            registeredLog = PersistedEventLog;
                            break;
                        }
                    }
 
                    if (registeredLog is null)
                        return 90;
                }
 
                return registeredLog.eventLifetimeDays;
            }
        }
 
        private static PersistedEventLog registeredLog = null;
    }
}