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());
}
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());
}
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());
}
public void index(final ApplicationScope applicationScope, final Id id, final long updatedSince) {
EntityIndexOperation entityIndexOperation =
new EntityIndexOperation(applicationScope, id, updatedSince);
queueIndexOperationMessage(
eventBuilder.buildEntityIndex(entityIndexOperation).toBlocking().lastOrDefault(null));
}
private void generateCode(Writer modelCodeWriter) throws IOException, TemplateException {
Map<String, Object> modelProperties = Maps.newHashMap();
List<Map<String, Object>> eventList = Lists.newLinkedList();
modelProperties.put("modelName", modelName);
modelProperties.put("events", eventList);
modelProperties.put("variables", variableList);
for (Event event : events) {
EventBuilder eventBuilder = new EventBuilder();
Event.EventState eventState = event.getEventState();
Event.Function eventFunctionMatcher = new Event.Function(eventState.getFunctionBody());
eventFunctionMatcher.process();
eventBuilder.setName(eventState.getName());
eventBuilder.setParameters(eventFunctionMatcher.getParameters());
eventBuilder.setBody(eventFunctionMatcher.getBody());
for (Map.Entry<Event, List<Edge>> targetEntry : adjacencyList.row(event).entrySet()) {
List<Edge> edges = targetEntry.getValue();
for (Edge edge : edges) {
eventBuilder.addEdge(edge);
}
}
eventList.add(eventBuilder.asMap());
}
Templates templatesInstance = Templates.getTemplatesInstance();
Configuration templateConfiguration = templatesInstance.getConfiguration();
Template modelTemplate = templateConfiguration.getTemplate("Simulation.java.ftl");
modelTemplate.process(modelProperties, modelCodeWriter);
}
public IndexOperationMessage handleDeIndexOldVersionEvent(
final DeIndexOldVersionsEvent deIndexOldVersionsEvent) {
final ApplicationScope applicationScope =
deIndexOldVersionsEvent.getEntityIdScope().getApplicationScope();
final Id entityId = deIndexOldVersionsEvent.getEntityIdScope().getId();
final UUID markedVersion = deIndexOldVersionsEvent.getMarkedVersion();
// default this observable's return to empty index operation message if nothing is emitted
return eventBuilder
.deIndexOldVersions(applicationScope, entityId, markedVersion)
.toBlocking()
.lastOrDefault(new IndexOperationMessage());
}
@Override
public void queueEntityIndexUpdate(
final ApplicationScope applicationScope, final Entity entity, long updatedAfter) {
offer(
new EntityIndexEvent(
queueFig.getPrimaryRegion(), new EntityIdScope(applicationScope, entity.getId()), 0));
final EntityIndexOperation entityIndexOperation =
new EntityIndexOperation(applicationScope, entity.getId(), updatedAfter);
final IndexOperationMessage indexMessage =
eventBuilder.buildEntityIndex(entityIndexOperation).toBlocking().lastOrDefault(null);
queueIndexOperationMessage(indexMessage);
}
public void indexBatch(final List<EdgeScope> edges, final long updatedSince) {
IndexOperationMessage batch = new IndexOperationMessage();
for (EdgeScope e : edges) {
EntityIndexOperation entityIndexOperation =
new EntityIndexOperation(
e.getApplicationScope(), e.getEdge().getTargetNode(), updatedSince);
IndexOperationMessage indexOperationMessage =
eventBuilder.buildEntityIndex(entityIndexOperation).toBlocking().lastOrDefault(null);
if (indexOperationMessage != null) {
batch.ingest(indexOperationMessage);
}
}
queueIndexOperationMessage(batch);
}
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());
}