public async ValueTask <IMessageContentPage> TryGetPageAsync(string topicId, MessagePageId pageId, string reason)
        {
            var page = _messagesContentCache.TryGetPage(topicId, pageId);

            if (page != null)
            {
                return(page);
            }


            IMessageContentPage result = null;


            await _taskSchedulerByTopic.ExecuteTaskAsync(topicId, pageId, "Getting page: " + reason, async() =>
            {
                result = await TryGetPageTopicThreadSynchronizedAsync(topicId, pageId);
            });

            return(result);
        }
Example #2
0
 public static async ValueTask WriteCompressedPageAsync(this ICompressedMessagesStorage storage,
                                                        string topicId, IMessageContentPage page, IAppLogger appLogger)
 {
     var compressedPage = page.GetCompressedPage();
     await storage.WriteCompressedPageAsync(topicId, page.PageId, compressedPage, appLogger);
 }
Example #3
0
        public async Task ExecuteOperationThreadTopicSynchronizedAsync(string topicId, MessagePageId pageId, IMessageContentPage messageContentPage)
        {
            var logContext = "Page: " + pageId.Value;

            if (await _compressedMessagesStorage.HasCompressedPageAsync(topicId, pageId))
            {
                _appLogger.AddLog(LogProcess.PagesCompressor, topicId, logContext, "Has compressed page. Skipping compressing procedure");
                return;
            }


            if (messageContentPage.Count == 0)
            {
                _appLogger.AddLog(LogProcess.PagesCompressor, topicId, logContext, "No messages to compress. Skipping compressing procedure");
                return;
            }

            var compressedPage = messageContentPage.GetCompressedPage();

            if (_appGlobalFlags.DebugTopic == topicId)
            {
                _appLogger.AddLog(LogProcess.PagesCompressor, topicId, logContext, $"Writing Compressed data for page {pageId}.");
            }

            await _compressedMessagesStorage.WriteCompressedPageAsync(topicId, pageId, compressedPage, _appLogger);

            if (_appGlobalFlags.DebugTopic == topicId)
            {
                _appLogger.AddLog(LogProcess.PagesCompressor, topicId, logContext, $"Verifying compressed data for page {pageId}");
            }

            var compressedPageToVerify = await _compressedMessagesStorage.GetCompressedPageAsync(topicId, pageId);

            var messages = compressedPageToVerify.Messages;

            if (_appGlobalFlags.DebugTopic == topicId)
            {
                _appLogger.AddLog(LogProcess.PagesCompressor, topicId, logContext, $"Verified compressed data for page {pageId}. Messages: " + messages.Count);
            }

            if (_appGlobalFlags.DebugTopic == topicId)
            {
                _appLogger.AddLog(LogProcess.PagesCompressor, topicId, logContext, $"Deleting Uncompressed page {pageId}");
            }

            await _persistentStorage.DeleteNonCompressedPageAsync(topicId, pageId);

            if (_appGlobalFlags.DebugTopic == topicId)
            {
                _appLogger.AddLog(LogProcess.PagesCompressor, topicId, logContext, "Written Compressed Page: " + pageId + ". Messages in the page:" + messageContentPage.Count);
            }
        }
 public static bool HasSkipped(this IMessageContentPage page)
 {
     return(page.ShouldHaveAmount() != page.Count);
 }
        public static int ShouldHaveAmount(this IMessageContentPage page)
        {
            var firstMessageId = page.PageId.Value * 100000;

            return((int)(page.MaxMessageId - firstMessageId + 1));
        }
 public static int Percent(this IMessageContentPage page)
 {
     return(page.Count / 1000);
 }
 public static CompressedPage GetCompressedPage(this IMessageContentPage page)
 {
     return(new(page.PageId, page.GetMessages()));
 }