@Override public MessageResultIterator getMessages(MessageRange set, FetchGroup fetchGroup, MailboxSession mailboxSession) throws MailboxException { final MessageMapper messageMapper = mapperFactory.getMessageMapper(mailboxSession); return new StoreMessageResultIterator(messageMapper, mailbox, set, batchSizes, fetchGroup); }
@Override public Flags getApplicableFlags(MailboxSession session) throws MailboxException { return mapperFactory.getMessageMapper(session) .getApplicableFlag(mailbox); }
private Iterator<MailboxMessage> retrieveOriginalRows(MessageRange set, MailboxSession session) throws MailboxException { MessageMapper messageMapper = mapperFactory.getMessageMapper(session); return messageMapper.findInMailbox(mailbox, set, FetchType.Full, -1); }
/** * Return the uid of the first unseen message or null of none is found */ protected MessageUid findFirstUnseenMessageUid(MailboxSession session) throws MailboxException { MessageMapper messageMapper = mapperFactory.getMessageMapper(session); return messageMapper.findFirstUnseenMessageUid(getMailboxEntity()); }
private MoveResult move(Iterator<MailboxMessage> originalRows, MailboxSession session) throws MailboxException { final List<MessageMetaData> movedRows = new ArrayList<>(); final List<MessageMetaData> originalRowsCopy = new ArrayList<>(); final MessageMapper messageMapper = mapperFactory.getMessageMapper(session); while (originalRows.hasNext()) { final MailboxMessage originalMessage = originalRows.next(); originalRowsCopy.add(new SimpleMessageMetaData(originalMessage)); MessageMetaData data = messageMapper.execute( () -> messageMapper.move(getMailboxEntity(), originalMessage)); movedRows.add(data); } return new MoveResult(movedRows.iterator(), originalRowsCopy.iterator()); }
protected MessageMetaData appendMessageToStore(final MailboxMessage message, final List<MessageAttachment> messageAttachments, MailboxSession session) throws MailboxException { final MessageMapper messageMapper = mapperFactory.getMessageMapper(session); return mapperFactory.getMessageMapper(session).execute(() -> { storeAttachment(message, messageAttachments, session); return messageMapper.add(getMailboxEntity(), message); }); }
private Iterator<MessageUid> listAllMessageUids(MailboxSession session) throws MailboxException { final MessageMapper messageMapper = mapperFactory.getMessageMapper(session); return messageMapper.execute( () -> messageMapper.listAllMessageUids(mailbox)); }
@Override public long getMessageCount(MailboxSession mailboxSession) throws MailboxException { return mapperFactory.getMessageMapper(mailboxSession).countMessagesInMailbox(getMailboxEntity()); }
protected long countUnseenMessagesInMailbox(MailboxSession session) throws MailboxException { MessageMapper messageMapper = mapperFactory.getMessageMapper(session); return messageMapper.countUnseenMessagesInMailbox(getMailboxEntity()); }
private Optional<MailboxMessage> fullyReadMessage(MailboxSession mailboxSession, Mailbox mailbox, MessageUid mUid) throws MailboxException { return Iterators.toStream(mailboxSessionMapperFactory.getMessageMapper(mailboxSession) .findInMailbox(mailbox, MessageRange.one(mUid), MessageMapper.FetchType.Full, SINGLE_MESSAGE)) .findFirst(); }
protected Map<MessageUid, MessageMetaData> deleteMarkedInMailbox(final MessageRange range, MailboxSession session) throws MailboxException { final MessageMapper messageMapper = mapperFactory.getMessageMapper(session); return messageMapper.execute( () -> messageMapper.expungeMarkedForDeletionInMailbox(getMailboxEntity(), range)); }
private Task.Result reIndex(MailboxPath path, MailboxSession mailboxSession, ReprocessingContext reprocessingContext) throws MailboxException { LOGGER.info("Intend to reindex {}", path.asString()); Mailbox mailbox = mailboxSessionMapperFactory.getMailboxMapper(mailboxSession).findMailboxByPath(path); messageSearchIndex.deleteAll(mailboxSession, mailbox); try { return Iterators.toStream( mailboxSessionMapperFactory.getMessageMapper(mailboxSession) .findInMailbox(mailbox, MessageRange.all(), MessageMapper.FetchType.Metadata, NO_LIMIT)) .map(MailboxMessage::getUid) .map(uid -> handleMessageReIndexing(mailboxSession, mailbox, uid)) .peek(reprocessingContext::updateAccordingToReprocessingResult) .reduce(Task::combine) .orElse(Task.Result.COMPLETED); } finally { LOGGER.info("Finish to reindex {}", path.asString()); } }
public CurrentQuotas recalculateCurrentQuotas(QuotaRoot quotaRoot, MailboxSession session) throws MailboxException { List<Mailbox> mailboxes = retrieveMailboxes(quotaRoot, session); MessageMapper mapper = factory.getMessageMapper(session); long messagesSizes = 0; long messageCount = 0; for (Mailbox mailbox : mailboxes) { Iterator<MailboxMessage> messages = mapper.findInMailbox(mailbox, MessageRange.all(), MessageMapper.FetchType.Metadata, -1); messageCount += mapper.countMessagesInMailbox(mailbox); while (messages.hasNext()) { messagesSizes += messages.next().getFullContentOctets(); } } return new CurrentQuotas(messageCount, messagesSizes); }
@Override public Map<MessageUid, Flags> setFlags(final Flags flags, final FlagsUpdateMode flagsUpdateMode, final MessageRange set, MailboxSession mailboxSession) throws MailboxException { if (!isWriteable(mailboxSession)) { throw new ReadOnlyException(getMailboxPath(), mailboxSession.getPathDelimiter()); } final SortedMap<MessageUid, Flags> newFlagsByUid = new TreeMap<>(); trimFlags(flags, mailboxSession); final MessageMapper messageMapper = mapperFactory.getMessageMapper(mailboxSession); Iterator<UpdatedFlags> it = messageMapper.execute(() -> messageMapper.updateFlags(getMailboxEntity(), new FlagsUpdateCalculator(flags, flagsUpdateMode), set)); final SortedMap<MessageUid, UpdatedFlags> uFlags = new TreeMap<>(); while (it.hasNext()) { UpdatedFlags flag = it.next(); newFlagsByUid.put(flag.getUid(), flag.getNewFlags()); uFlags.put(flag.getUid(), flag); } dispatcher.flagsUpdated(mailboxSession, new ArrayList<>(uFlags.keySet()), getMailboxEntity(), new ArrayList<>(uFlags.values())); return newFlagsByUid; }
private Iterator<MessageMetaData> copy(Iterator<MailboxMessage> originalRows, MailboxSession session) throws MailboxException { final List<MessageMetaData> copiedRows = new ArrayList<>(); final MessageMapper messageMapper = mapperFactory.getMessageMapper(session); while (originalRows.hasNext()) { final MailboxMessage originalMessage = originalRows.next(); new QuotaChecker(quotaManager, quotaRootResolver, mailbox) .tryAddition(1, originalMessage.getFullContentOctets()); MessageMetaData data = messageMapper.execute( () -> messageMapper.copy(getMailboxEntity(), originalMessage)); dispatcher.added(session, this.getMailboxEntity(), immutableMailboxMessageFactory.from(getMailboxEntity().getMailboxId(), originalMessage)); copiedRows.add(data); } return copiedRows.iterator(); }
@Test public void importEmlFileToMailboxShouldNotImportEmlFileWithWrongPathToGivenMailbox() throws Exception { Mailbox mailbox = new SimpleMailbox(MailboxPath.forUser(USER, "name"), UID_VALIDITY); mapperFactory.createMailboxMapper(session).save(mailbox); String emlpath = ClassLoader.getSystemResource("eml/frnog.eml").getFile(); mailboxManagerManagement.importEmlFileToMailbox(MailboxConstants.USER_NAMESPACE, USER, "name", "wrong_path" + emlpath); assertThat(mapperFactory.getMessageMapper(session).countMessagesInMailbox(mailbox)).isEqualTo(0); Iterator<MailboxMessage> iterator = mapperFactory.getMessageMapper(session).findInMailbox(mailbox, MessageRange.all(), MessageMapper.FetchType.Full, LIMIT); assertThat(iterator.hasNext()).isFalse(); }
@Test public void importEmlFileToMailboxShouldImportEmlFileToGivenMailbox() throws Exception { Mailbox mailbox = new SimpleMailbox(MailboxPath.forUser(USER, "name"), UID_VALIDITY); mapperFactory.createMailboxMapper(session).save(mailbox); String emlpath = ClassLoader.getSystemResource("eml/frnog.eml").getFile(); mailboxManagerManagement.importEmlFileToMailbox(MailboxConstants.USER_NAMESPACE, USER, "name", emlpath); assertThat(mapperFactory.getMessageMapper(session).countMessagesInMailbox(mailbox)).isEqualTo(1); Iterator<MailboxMessage> iterator = mapperFactory.getMessageMapper(session).findInMailbox(mailbox, MessageRange.all(), MessageMapper.FetchType.Full, LIMIT); MailboxMessage mailboxMessage = iterator.next(); assertThat(IOUtils.toString(new FileInputStream(new File(emlpath)), StandardCharsets.UTF_8)) .isEqualTo(IOUtils.toString(mailboxMessage.getFullContent(), StandardCharsets.UTF_8)); }
@Test public void test() throws Exception { final MockMailboxSession mockMailboxSession = new MockMailboxSession("re-indexing"); when(mailboxManager.createSystemSession(any(String.class))) .thenReturn(mockMailboxSession); final MessageMapper messageMapper = mock(MessageMapper.class); final MailboxMapper mailboxMapper = mock(MailboxMapper.class); when(mailboxSessionMapperFactory.getMessageMapper(any(MailboxSession.class))) .thenReturn(messageMapper); when(mailboxSessionMapperFactory.getMailboxMapper(any(MailboxSession.class))) .thenReturn(mailboxMapper); final MailboxMessage message = new MessageBuilder().build(); final SimpleMailbox mailbox = new SimpleMailbox(INBOX, 42); mailbox.setMailboxId(message.getMailboxId()); when(mailboxMapper.findMailboxByPath(INBOX)).thenReturn(mailbox); when(messageMapper.findInMailbox(mailbox, MessageRange.all(), MessageMapper.FetchType.Full, LIMIT)) .thenReturn(Lists.newArrayList(message).iterator()); reIndexer.reIndex(INBOX); verify(mailboxManager).createSystemSession(any(String.class)); verify(mailboxSessionMapperFactory).getMailboxMapper(mockMailboxSession); verify(mailboxSessionMapperFactory).getMessageMapper(mockMailboxSession); verify(mailboxMapper).findMailboxByPath(INBOX); verify(messageMapper).findInMailbox(mailbox, MessageRange.all(), MessageMapper.FetchType.Full, LIMIT); verify(mailboxManager).addListener(eq(INBOX), any(MailboxListener.class), any(MailboxSession.class)); verify(mailboxManager).removeListener(eq(INBOX), any(MailboxListener.class), any(MailboxSession.class)); verify(messageSearchIndex).add(any(MailboxSession.class), eq(mailbox), eq(message)); verify(messageSearchIndex).deleteAll(any(MailboxSession.class), eq(mailbox)); verifyNoMoreInteractions(mailboxMapper, mailboxSessionMapperFactory, messageSearchIndex, messageMapper, mailboxMapper); }
@Override public void deleteMailbox(final MailboxPath mailboxPath, final MailboxSession session) throws MailboxException { LOGGER.info("deleteMailbox {}", mailboxPath); assertIsOwner(session, mailboxPath); MailboxMapper mailboxMapper = mailboxSessionMapperFactory.getMailboxMapper(session); MessageMapper messageMapper = mailboxSessionMapperFactory.getMessageMapper(session); mailboxMapper.execute((Mapper.Transaction<Mailbox>) () -> { Mailbox mailbox = mailboxMapper.findMailboxByPath(mailboxPath); if (mailbox == null) { throw new MailboxNotFoundException(mailboxPath); } QuotaRoot quotaRoot = quotaRootResolver.getQuotaRoot(mailboxPath); long messageCount = messageMapper.countMessagesInMailbox(mailbox); long totalSize = Iterators.toStream(messageMapper.findInMailbox(mailbox, MessageRange.all(), MessageMapper.FetchType.Metadata, -1)) .mapToLong(Message::getFullContentOctets) .sum(); // We need to create a copy of the mailbox as maybe we can not refer to the real // mailbox once we remove it SimpleMailbox m = new SimpleMailbox(mailbox); mailboxMapper.delete(mailbox); dispatcher.mailboxDeleted(session, mailbox, quotaRoot, QuotaCount.count(messageCount), QuotaSize.size(totalSize)); return m; }); }
/** * Return a List which holds all uids of recent messages and optional reset * the recent flag on the messages for the uids */ protected List<MessageUid> recent(final boolean reset, MailboxSession mailboxSession) throws MailboxException { if (reset) { if (!isWriteable(mailboxSession)) { throw new ReadOnlyException(getMailboxPath(), mailboxSession.getPathDelimiter()); } } final MessageMapper messageMapper = mapperFactory.getMessageMapper(mailboxSession); return messageMapper.execute(() -> { final List<MessageUid> members = messageMapper.findRecentMessageUidsInMailbox(getMailboxEntity()); // Convert to MessageRanges so we may be able to optimize the // flag update List<MessageRange> ranges = MessageRange.toRanges(members); for (MessageRange range : ranges) { if (reset) { // only call save if we need to messageMapper.updateFlags(getMailboxEntity(), new FlagsUpdateCalculator(new Flags(Flag.RECENT), FlagsUpdateMode.REMOVE), range); } } return members; }); }