コード例 #1
0
  private IndexOperationMessage handleEdgeDelete(final QueueMessage message) {

    Preconditions.checkNotNull(message, "Queue Message cannot be null for handleEdgeDelete");

    final AsyncEvent event = (AsyncEvent) message.getBody();

    Preconditions.checkNotNull(message, "QueueMessage Body cannot be null for handleEdgeDelete");
    Preconditions.checkArgument(
        event instanceof EdgeDeleteEvent,
        String.format(
            "Event Type for handleEdgeDelete must be EDGE_DELETE, got %s", event.getClass()));

    final EdgeDeleteEvent edgeDeleteEvent = (EdgeDeleteEvent) event;

    final ApplicationScope applicationScope = edgeDeleteEvent.getApplicationScope();
    final Edge edge = edgeDeleteEvent.getEdge();

    if (logger.isDebugEnabled()) {
      logger.debug("Deleting in app scope {} with edge {}", applicationScope, edge);
    }

    // default this observable's return to empty index operation message if nothing is emitted
    return eventBuilder
        .buildDeleteEdge(applicationScope, edge)
        .toBlocking()
        .lastOrDefault(new IndexOperationMessage());
  }
コード例 #2
0
  private IndexOperationMessage handleEdgeIndex(final QueueMessage message) {

    Preconditions.checkNotNull(message, "Queue Message cannot be null for handleEdgeIndex");

    final AsyncEvent event = (AsyncEvent) message.getBody();

    Preconditions.checkNotNull(message, "QueueMessage Body cannot be null for handleEdgeIndex");
    Preconditions.checkArgument(
        event instanceof EdgeIndexEvent,
        String.format(
            "Event Type for handleEdgeIndex must be EDGE_INDEX, got %s", event.getClass()));

    final EdgeIndexEvent edgeIndexEvent = (EdgeIndexEvent) event;

    final EntityCollectionManager ecm =
        entityCollectionManagerFactory.createCollectionManager(
            edgeIndexEvent.getApplicationScope());

    // default this observable's return to empty index operation message if nothing is emitted
    return ecm.load(edgeIndexEvent.getEntityId())
        .flatMap(
            loadedEntity ->
                eventBuilder.buildNewEdge(
                    edgeIndexEvent.getApplicationScope(), loadedEntity, edgeIndexEvent.getEdge()))
        .toBlocking()
        .lastOrDefault(new IndexOperationMessage());
  }
コード例 #3
0
  private IndexOperationMessage handleEntityIndexUpdate(final QueueMessage message) {

    Preconditions.checkNotNull(message, "Queue Message cannot be null for handleEntityIndexUpdate");

    final AsyncEvent event = (AsyncEvent) message.getBody();

    Preconditions.checkNotNull(
        message, "QueueMessage Body cannot be null for handleEntityIndexUpdate");
    Preconditions.checkArgument(
        event instanceof EntityIndexEvent,
        String.format(
            "Event Type for handleEntityIndexUpdate must be ENTITY_INDEX, got %s",
            event.getClass()));

    final EntityIndexEvent entityIndexEvent = (EntityIndexEvent) event;

    // process the entity immediately
    // only process the same version, otherwise ignore
    final EntityIdScope entityIdScope = entityIndexEvent.getEntityIdScope();
    final ApplicationScope applicationScope = entityIdScope.getApplicationScope();
    final Id entityId = entityIdScope.getId();
    final long updatedAfter = entityIndexEvent.getUpdatedAfter();

    final EntityIndexOperation entityIndexOperation =
        new EntityIndexOperation(applicationScope, entityId, updatedAfter);

    // default this observable's return to empty index operation message if nothing is emitted
    return eventBuilder
        .buildEntityIndex(entityIndexOperation)
        .toBlocking()
        .lastOrDefault(new IndexOperationMessage());
  }
コード例 #4
0
  private IndexOperationMessage handleEntityDelete(final QueueMessage message) {

    Preconditions.checkNotNull(message, "Queue Message cannot be null for handleEntityDelete");

    final AsyncEvent event = (AsyncEvent) message.getBody();
    Preconditions.checkNotNull(message, "QueueMessage Body cannot be null for handleEntityDelete");
    Preconditions.checkArgument(
        event instanceof EntityDeleteEvent,
        String.format(
            "Event Type for handleEntityDelete must be ENTITY_DELETE, got %s", event.getClass()));

    final EntityDeleteEvent entityDeleteEvent = (EntityDeleteEvent) event;
    final ApplicationScope applicationScope =
        entityDeleteEvent.getEntityIdScope().getApplicationScope();
    final Id entityId = entityDeleteEvent.getEntityIdScope().getId();

    if (logger.isDebugEnabled())
      logger.debug(
          "Deleting entity id from index in app scope {} with entityId {}",
          applicationScope,
          entityId);

    final EventBuilderImpl.EntityDeleteResults entityDeleteResults =
        eventBuilder.buildEntityDelete(applicationScope, entityId);

    // Delete the entities and remove from graph separately
    entityDeleteResults.getEntitiesDeleted().toBlocking().lastOrDefault(null);

    entityDeleteResults.getCompactedNode().toBlocking().lastOrDefault(null);

    // default this observable's return to empty index operation message if nothing is emitted
    return entityDeleteResults
        .getIndexObservable()
        .toBlocking()
        .lastOrDefault(new IndexOperationMessage());
  }
コード例 #5
0
  private void handleInitializeApplicationIndex(
      final AsyncEvent event, final QueueMessage message) {
    Preconditions.checkNotNull(
        message, "Queue Message cannot be null for handleInitializeApplicationIndex");
    Preconditions.checkArgument(
        event instanceof InitializeApplicationIndexEvent,
        String.format(
            "Event Type for handleInitializeApplicationIndex must be APPLICATION_INDEX, got %s",
            event.getClass()));

    final InitializeApplicationIndexEvent initializeApplicationIndexEvent =
        (InitializeApplicationIndexEvent) event;

    final IndexLocationStrategy indexLocationStrategy =
        initializeApplicationIndexEvent.getIndexLocationStrategy();
    final EntityIndex index = entityIndexFactory.createEntityIndex(indexLocationStrategy);
    index.initialize();
  }
コード例 #6
0
  /**
   * calls the event handlers and returns a result with information on whether it needs to be ack'd
   * and whether it needs to be indexed
   *
   * @param messages
   * @return
   */
  private List<IndexEventResult> callEventHandlers(final List<QueueMessage> messages) {

    if (logger.isDebugEnabled()) {
      logger.debug("callEventHandlers with {} message(s)", messages.size());
    }

    Stream<IndexEventResult> indexEventResults =
        messages
            .stream()
            .map(
                message -> {
                  if (logger.isDebugEnabled()) {
                    logger.debug(
                        "Queue message with ID {} has been received {} time(s)",
                        message.getMessageId(),
                        message.getReceiveCount());
                  }

                  AsyncEvent event = null;
                  try {
                    event = (AsyncEvent) message.getBody();

                  } catch (ClassCastException cce) {
                    logger.error("Failed to deserialize message body", cce);
                    return new IndexEventResult(
                        Optional.absent(), Optional.absent(), System.currentTimeMillis());
                  }

                  if (event == null) {
                    logger.error("AsyncEvent type or event is null!");
                    return new IndexEventResult(
                        Optional.absent(), Optional.absent(), System.currentTimeMillis());
                  }

                  final AsyncEvent thisEvent = event;

                  if (logger.isDebugEnabled()) {
                    logger.debug("Processing event with type {}", event.getClass().getSimpleName());
                  }

                  try {

                    IndexOperationMessage single = new IndexOperationMessage();

                    // normal indexing event for an entity
                    if (event instanceof EntityIndexEvent) {

                      single = handleEntityIndexUpdate(message);

                    }
                    // normal indexing event for an edge
                    else if (event instanceof EdgeIndexEvent) {

                      single = handleEdgeIndex(message);

                    }
                    // deletes are 2-part, actual IO to delete data, then queue up a de-index
                    else if (event instanceof EdgeDeleteEvent) {

                      single = handleEdgeDelete(message);
                    }
                    // deletes are 2-part, actual IO to delete data, then queue up a de-index
                    else if (event instanceof EntityDeleteEvent) {

                      single = handleEntityDelete(message);
                    }
                    // initialization has special logic, therefore a special event type and no index
                    // operation message
                    else if (event instanceof InitializeApplicationIndexEvent) {

                      handleInitializeApplicationIndex(event, message);
                    }
                    // this is the main event that pulls the index doc from map persistence and
                    // hands to the index producer
                    else if (event instanceof ElasticsearchIndexEvent) {

                      handleIndexOperation((ElasticsearchIndexEvent) event);

                    } else if (event instanceof DeIndexOldVersionsEvent) {

                      single = handleDeIndexOldVersionEvent((DeIndexOldVersionsEvent) event);

                    } else {

                      throw new Exception(
                          "Unknown EventType for message: " + message.getStringBody().trim());
                    }

                    if (!(event instanceof ElasticsearchIndexEvent)
                        && !(event instanceof InitializeApplicationIndexEvent)
                        && single.isEmpty()) {
                      logger.warn(
                          "No index operation messages came back from event processing for msg: {} ",
                          message.getStringBody().trim());
                    }

                    // if no exception happens and the QueueMessage is returned in these results, it
                    // will get ack'd
                    return new IndexEventResult(
                        Optional.of(single), Optional.of(message), thisEvent.getCreationTime());

                  } catch (IndexDocNotFoundException e) {

                    // this exception is throw when we wait before trying quorum read on map
                    // persistence.
                    // return empty event result so the event's message doesn't get ack'd
                    if (logger.isDebugEnabled()) {
                      logger.debug(e.getMessage());
                    }
                    return new IndexEventResult(
                        Optional.absent(), Optional.absent(), thisEvent.getCreationTime());

                  } catch (Exception e) {

                    // NPEs don't have a detail message, so add something for our log statement to
                    // identify better
                    final String errorMessage;
                    if (e instanceof NullPointerException) {
                      errorMessage = "NullPointerException";
                    } else {
                      errorMessage = e.getMessage();
                    }

                    // if the event fails to process, log and return empty message result so it
                    // doesn't get ack'd
                    logger.error(
                        "{}. Failed to process message: {}",
                        errorMessage,
                        message.getStringBody().trim());
                    return new IndexEventResult(
                        Optional.absent(), Optional.absent(), thisEvent.getCreationTime());
                  }
                });

    return indexEventResults.collect(Collectors.toList());
  }