@VisibleForTesting public static MailboxEventDispatcher ofListener(MailboxListener mailboxListener) { return new MailboxEventDispatcher(mailboxListener, new EventFactory()); }
private void setRights(MailboxACL mailboxACL, MailboxMapper mapper, Mailbox mailbox, MailboxSession session) throws MailboxException { ACLDiff aclDiff = mapper.setACL(mailbox, mailboxACL); dispatcher.aclUpdated(session, mailbox.generateAssociatedPath(), aclDiff); }
public void added(MailboxSession session, MessageMetaData messageMetaData, Mailbox mailbox) { SortedMap<MessageUid, MessageMetaData> metaDataMap = ImmutableSortedMap.<MessageUid, MessageMetaData>naturalOrder() .put(messageMetaData.getUid(), messageMetaData) .build(); added(session, metaDataMap, mailbox, ImmutableMap.<MessageUid, MailboxMessage>of()); }
private SortedMap<MessageUid, MessageMetaData> move(MessageRange set, StoreMessageManager to, MailboxSession session) throws MailboxException { IteratorWrapper<MailboxMessage> originalRows = new IteratorWrapper<>(retrieveOriginalRows(set, session)); MoveResult moveResult = to.move(originalRows, session); SortedMap<MessageUid, MessageMetaData> moveUids = collectMetadata(moveResult.getMovedMessages()); ImmutableMap.Builder<MessageUid, MailboxMessage> messagesMap = ImmutableMap.builder(); for (MailboxMessage message : originalRows.getEntriesSeen()) { messagesMap.put(message.getUid(), immutableMailboxMessageFactory.from(to.getMailboxEntity().getMailboxId(), message)); } dispatcher.added(session, moveUids, to.getMailboxEntity(), messagesMap.build()); dispatcher.expunged(session, collectMetadata(moveResult.getOriginalMessages()), getMailboxEntity()); dispatcher.moved(session, MessageMoves.builder() .previousMailboxIds(getMailboxEntity().getMailboxId()) .targetMailboxIds(to.getMailboxEntity().getMailboxId()) .build(), messagesMap.build()); return moveUids; }
private SortedMap<MessageUid, MessageMetaData> copy(MessageRange set, StoreMessageManager to, MailboxSession session) throws MailboxException { IteratorWrapper<MailboxMessage> originalRows = new IteratorWrapper<>(retrieveOriginalRows(set, session)); SortedMap<MessageUid, MessageMetaData> copiedUids = collectMetadata(to.copy(originalRows, session)); ImmutableMap.Builder<MessageUid, MailboxMessage> messagesMap = ImmutableMap.builder(); for (MailboxMessage message : originalRows.getEntriesSeen()) { messagesMap.put(message.getUid(), immutableMailboxMessageFactory.from(to.getMailboxEntity().getMailboxId(), message)); } dispatcher.added(session, copiedUids, to.getMailboxEntity(), messagesMap.build()); dispatcher.moved(session, MessageMoves.builder() .previousMailboxIds(getMailboxEntity().getMailboxId()) .targetMailboxIds(to.getMailboxEntity().getMailboxId(), getMailboxEntity().getMailboxId()) .build(), messagesMap.build()); return copiedUids; }
public void expunged(MailboxSession session, MessageMetaData messageMetaData, Mailbox mailbox) { Map<MessageUid, MessageMetaData> metaDataMap = ImmutableMap.<MessageUid, MessageMetaData>builder() .put(messageMetaData.getUid(), messageMetaData) .build(); expunged(session, metaDataMap, mailbox); }
public void flagsUpdated(MailboxSession session, MessageUid uid, Mailbox mailbox, UpdatedFlags uflags) { flagsUpdated(session, ImmutableList.of(uid), mailbox, ImmutableList.of(uflags)); }
mapper.execute(Mapper.toTransaction(() -> mailboxIds.add(mapper.save(m)))); dispatcher.mailboxAdded(mailboxSession, m); } catch (MailboxExistsException e) { LOGGER.info("{} mailbox was created concurrently", m.generateAssociatedPath());
private void delete(MessageIdMapper messageIdMapper, List<MailboxMessage> messageList, MailboxSession mailboxSession) throws MailboxException { ImmutableList<MetadataWithMailboxId> metadataWithMailbox = messageList.stream() .map(StoreMessageIdManager::toMetadataWithMailboxId) .collect(Guavate.toImmutableList()); messageIdMapper.delete( messageList.stream() .collect(Guavate.toImmutableListMultimap( Message::getMessageId, MailboxMessage::getMailboxId))); MailboxMapper mailboxMapper = mailboxSessionMapperFactory.getMailboxMapper(mailboxSession); for (MetadataWithMailboxId metadataWithMailboxId : metadataWithMailbox) { dispatcher.expunged(mailboxSession, metadataWithMailboxId.messageMetaData, mailboxMapper.findMailboxById(metadataWithMailboxId.mailboxId)); } }
private void dispatchFlagsChange(MailboxSession mailboxSession, MailboxId mailboxId, UpdatedFlags updatedFlags) throws MailboxException { if (updatedFlags.flagsChanged()) { Mailbox mailbox = mailboxSessionMapperFactory.getMailboxMapper(mailboxSession).findMailboxById(mailboxId); dispatcher.flagsUpdated(mailboxSession, updatedFlags.getUid(), mailbox, updatedFlags); } }
public static CassandraMailboxManager createMailboxManager(CassandraMailboxSessionMapperFactory mapperFactory) throws Exception { DefaultDelegatingMailboxListener delegatingMailboxListener = new DefaultDelegatingMailboxListener(); MailboxEventDispatcher mailboxEventDispatcher = new MailboxEventDispatcher(delegatingMailboxListener); StoreRightManager storeRightManager = new StoreRightManager(mapperFactory, new UnionMailboxACLResolver(), new SimpleGroupMembershipResolver(), mailboxEventDispatcher); StoreMailboxAnnotationManager annotationManager = new StoreMailboxAnnotationManager(mapperFactory, storeRightManager); CassandraMailboxManager cassandraMailboxManager = new CassandraMailboxManager(mapperFactory, mock(Authenticator.class), mock(Authorizator.class), new NoMailboxPathLocker(), new MessageParser(), new CassandraMessageId.Factory(), mailboxEventDispatcher, delegatingMailboxListener, annotationManager, storeRightManager); cassandraMailboxManager.init(); return cassandraMailboxManager; }
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(); }
@Override public Iterator<MessageUid> expunge(MessageRange set, MailboxSession mailboxSession) throws MailboxException { if (!isWriteable(mailboxSession)) { throw new ReadOnlyException(getMailboxPath(), mailboxSession.getPathDelimiter()); } Map<MessageUid, MessageMetaData> uids = deleteMarkedInMailbox(set, mailboxSession); dispatcher.expunged(mailboxSession, uids, getMailboxEntity()); return uids.keySet().iterator(); }
@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; }
@Override public void applyRightsCommand(MailboxPath mailboxPath, ACLCommand mailboxACLCommand, MailboxSession session) throws MailboxException { assertSharesBelongsToUserDomain(mailboxPath.getUser(), mailboxACLCommand); MailboxMapper mapper = mailboxSessionMapperFactory.getMailboxMapper(session); Mailbox mailbox = mapper.findMailboxByPath(mailboxPath); ACLDiff aclDiff = mapper.updateACL(mailbox, mailboxACLCommand); dispatcher.aclUpdated(session, mailboxPath, aclDiff); }
@Override @Before public void setUp() throws Exception { mailboxSessionMapperFactory = new InMemoryMailboxSessionMapperFactory(); Authenticator noAuthenticator = null; Authorizator noAuthorizator = null; DefaultDelegatingMailboxListener delegatingListener = new DefaultDelegatingMailboxListener(); MailboxEventDispatcher mailboxEventDispatcher = new MailboxEventDispatcher(delegatingListener); MessageId.Factory messageIdFactory = new InMemoryMessageId.Factory(); GroupMembershipResolver groupMembershipResolver = null; UnionMailboxACLResolver aclResolver = new UnionMailboxACLResolver(); StoreRightManager storeRightManager = new StoreRightManager(mailboxSessionMapperFactory, aclResolver, groupMembershipResolver, mailboxEventDispatcher); StoreMailboxAnnotationManager annotationManager = new StoreMailboxAnnotationManager(mailboxSessionMapperFactory, storeRightManager); mailboxManager = new InMemoryMailboxManager(mailboxSessionMapperFactory, noAuthenticator, noAuthorizator, new NoMailboxPathLocker(), new MessageParser(), messageIdFactory, mailboxEventDispatcher, delegatingListener, annotationManager, storeRightManager); mailboxManager.init(); MessageParser failingMessageParser = mock(MessageParser.class); when(failingMessageParser.retrieveAttachments(any(InputStream.class))) .thenThrow(new RuntimeException("Message parser set to fail")); parseFailingMailboxManager = new InMemoryMailboxManager(mailboxSessionMapperFactory, noAuthenticator, noAuthorizator, new NoMailboxPathLocker(), failingMessageParser, messageIdFactory, mailboxEventDispatcher, delegatingListener, annotationManager, storeRightManager); parseFailingMailboxManager.init(); super.setUp(); }
public void added(MailboxSession session, Mailbox mailbox, MailboxMessage mailboxMessage) { SimpleMessageMetaData messageMetaData = new SimpleMessageMetaData(mailboxMessage); SortedMap<MessageUid, MessageMetaData> metaDataMap = ImmutableSortedMap.<MessageUid, MessageMetaData>naturalOrder() .put(messageMetaData.getUid(), messageMetaData) .build(); added(session, metaDataMap, mailbox, ImmutableMap.of(mailboxMessage.getUid(), mailboxMessage)); }
private void removeMessageFromMailboxes(MailboxMessage message, Set<MailboxId> mailboxesToRemove, MailboxSession mailboxSession) throws MailboxException { MessageIdMapper messageIdMapper = mailboxSessionMapperFactory.getMessageIdMapper(mailboxSession); MailboxMapper mailboxMapper = mailboxSessionMapperFactory.getMailboxMapper(mailboxSession); SimpleMessageMetaData eventPayload = new SimpleMessageMetaData(message); for (MailboxId mailboxId: mailboxesToRemove) { messageIdMapper.delete(message.getMessageId(), mailboxesToRemove); dispatcher.expunged(mailboxSession, eventPayload, mailboxMapper.findMailboxById(mailboxId)); } }
private void initSystemUnderTest() throws Exception { CassandraMessageId.Factory messageIdFactory = new CassandraMessageId.Factory(); mailboxSessionMapperFactory = TestCassandraMailboxSessionMapperFactory.forTests( cassandra.getConf(), cassandra.getTypesProvider(), messageIdFactory); Authenticator noAuthenticator = null; Authorizator noAuthorizator = null; DefaultDelegatingMailboxListener delegatingMailboxListener = new DefaultDelegatingMailboxListener(); MailboxEventDispatcher mailboxEventDispatcher = new MailboxEventDispatcher(delegatingMailboxListener); StoreRightManager storeRightManager = new StoreRightManager(mailboxSessionMapperFactory, new UnionMailboxACLResolver(), new SimpleGroupMembershipResolver(), mailboxEventDispatcher); StoreMailboxAnnotationManager annotationManager = new StoreMailboxAnnotationManager(mailboxSessionMapperFactory, storeRightManager); mailboxManager = new CassandraMailboxManager(mailboxSessionMapperFactory, noAuthenticator, noAuthorizator, new NoMailboxPathLocker(), new MessageParser(), messageIdFactory, mailboxEventDispatcher, delegatingMailboxListener, annotationManager, storeRightManager); mailboxManager.init(); MessageParser failingMessageParser = mock(MessageParser.class); when(failingMessageParser.retrieveAttachments(any())) .thenThrow(new RuntimeException("Message parser set to fail")); parseFailingMailboxManager = new CassandraMailboxManager(mailboxSessionMapperFactory, noAuthenticator, noAuthorizator, new NoMailboxPathLocker(), failingMessageParser, messageIdFactory, mailboxEventDispatcher, delegatingMailboxListener, annotationManager, storeRightManager); parseFailingMailboxManager.init(); }
private void addMessageToMailboxes(MailboxMessage mailboxMessage, Set<MailboxId> mailboxIds, MailboxSession mailboxSession) throws MailboxException { MessageIdMapper messageIdMapper = mailboxSessionMapperFactory.getMessageIdMapper(mailboxSession); MailboxMapper mailboxMapper = mailboxSessionMapperFactory.getMailboxMapper(mailboxSession); for (MailboxId mailboxId : mailboxIds) { boolean shouldPreserveFlags = mailboxManager.myRights(mailboxId, mailboxSession).contains(Right.Write); SimpleMailboxMessage copy = SimpleMailboxMessage.from(mailboxMessage) .mailboxId(mailboxId) .flags( FlagsFactory .builder() .flags(mailboxMessage.createFlags()) .filteringFlags( FlagsFilter.builder() .systemFlagFilter(f -> shouldPreserveFlags) .userFlagFilter(f -> shouldPreserveFlags) .build()) .build()) .build(); save(mailboxSession, messageIdMapper, copy); dispatcher.added(mailboxSession, mailboxMapper.findMailboxById(mailboxId), copy); } }