public List<ObjectId> toRefs(JsonNode refsNode) { if (refsNode != null) { try { return mapper.convertValue(refsNode, new TypeReference<List<ObjectId>>() { }); } catch (Exception ex) { LOG.debug("Failed to get objectIds: " + refsNode, ex); } } return null; }
public ObjectId toRef(JsonNode refNode) { if (refNode != null) { try { return mapper.convertValue(refNode, ObjectId.class); } catch (Exception ex) { LOG.debug("Failed to get objectId: " + refNode, ex); } } return null; }
public Id toId(JsonNode jsonNode) { if (jsonNode != null) { try { return mapper.convertValue(jsonNode, Id.class); } catch (Exception ex) { LOG.debug("Failed to get id: " + jsonNode, ex); } } return null; }
private EventVerb getActivityVerb(ObjectNode objectNode, String fieldName) { JsonNode got = objectNode.get(fieldName); if (got == null || got.isNull()) { return null; } try { return mapper.convertValue(got, EventVerb.class); } catch (Exception ex) { LOG.debug("Failed to get activity verb for field " + fieldName + ": " + objectNode, ex); return null; } }
public long getEventId(ObjectNode eventNode) { JsonNode got = eventNode.get(ReservedFields.EVENT_ID); if (got == null || got.isNull()) { return 0L; } try { return got.longValue(); } catch (Exception ex) { LOG.debug("Failed to get eventId: " + eventNode, ex); return 0L; } }
private Id getId(ObjectNode objectNode, String fieldName) { JsonNode got = objectNode.get(fieldName); if (got == null || got.isNull()) { return null; } try { return new Id(got.textValue()); } catch (Exception ex) { LOG.debug("Failed to get objectId for field " + fieldName + ": " + objectNode, ex); return null; } }
public TenantId getTenantId(ObjectNode eventNode) { try { JsonNode got = eventNode.get(ReservedFields.TENANT_ID); if (got == null || got.isNull()) { return null; } return new TenantId(got.textValue()); } catch (Exception ex) { LOG.debug("Failed to get tenantId: " + eventNode, ex); return null; } }
public Id getInstanceId(ObjectNode eventNode, String className) { JsonNode got = eventNode.get(className); if (got == null || got.isNull() || !got.isObject()) { return null; } ObjectNode instanceNode = (ObjectNode) got; got = instanceNode.get(ReservedFields.INSTANCE_ID); if (got == null || got.isNull()) { return null; } try { return new Id(got.textValue()); } catch (Exception ex) { LOG.debug("Failed to get instanceId for className '" + className + "': " + eventNode, ex); return null; } }
@Override public void run() { try { if (requests.size() > 1) { LOG.debug("Request aggregation size: {}", requests.size()); } referenceStore.multiStreamRefs(requests); } catch (Exception ex) { LOG.warn("Failed to process request:" + requests, ex); for (RefStreamRequestContext request : requests) { request.failure(ex); } } } });
@Override public EventWriterResponse write(List<ObjectNode> events, EventWriterOptions options) throws JsonEventWriteException { Preconditions.checkNotNull(events); ObjectWriter writer = mapper.writer().withDefaultPrettyPrinter(); List<Long> eventIds = new ArrayList<>(events.size()); List<ObjectId> objectIds = new ArrayList<>(events.size()); List<ObjectNode> responseList = this.events.get(); for (ObjectNode event : events) { if (LOG.isDebugEnabled()) { try { LOG.debug("Mock received event: " + writer.writeValueAsString(event)); } catch (IOException e) { throw new JsonEventWriteException("Failed to serialize event", e); } } eventIds.add(orderIdProvider.nextId()); objectIds.add(jsonEventConventions.getInstanceObjectId(event, jsonEventConventions.getInstanceClassName(event))); if (responseList != null) { responseList.add(event); } } return new EventWriterResponse(eventIds, objectIds); }
@Override public ViewResponse getView(TenantIdAndCentricId tenantIdAndCentricId, ObjectId viewId, ViewResponse viewResponse) { if (viewResponse.getStatusCode() == ViewResponse.StatusCode.OK) { ObjectNode view = viewResponse.getViewBody(); if (view.size() == 0) { LOG.debug("Retrieved empty view object for view object id {}. Returning null view object", viewId); viewResponse = ViewResponse.notFound(); } else if (view.has(ReservedFields.DELETED) && view.get(ReservedFields.DELETED).booleanValue()) { LOG.debug("Encountered deleted view object with id {}. Returning null view object", viewId); viewResponse = ViewResponse.notFound(); } else { view.put(ReservedFields.VIEW_CLASS, viewId.getClassName()); view.put(ReservedFields.TENANT_ID, tenantIdAndCentricId.getTenantId().toStringForm()); //view.put(ReservedFields.USER_ID, tenantIdAndCentricId.getUserId().toStringForm()); } } return viewResponse; }
public void loadModel(TenantId tenantId) { ChainedVersion currentVersion = viewsProvider.getCurrentViewsVersion(tenantId); if (currentVersion == ChainedVersion.NULL) { versionedViewModel.put(tenantId, new VersionedViewsModel(currentVersion)); } else { VersionedViewsModel currentVersionedViewsModel = versionedViewModel.get(tenantId); if (currentVersionedViewsModel == null || !currentVersionedViewsModel.getVersion().equals(currentVersion)) { Map<String, Map<Long, PathAndDictionary>> newViewValueBindings = Maps.newHashMap(); Views views = this.viewsProvider.getViews(new ViewsProcessorId(tenantId, "NotBeingUsedYet")); for (ViewBinding viewBinding : views.getViewBindings()) { Map<Long, PathAndDictionary> got = newViewValueBindings.get(viewBinding.getViewClassName()); if (got == null) { got = Maps.newHashMap(); newViewValueBindings.put(viewBinding.getViewClassName(), got); } for (ModelPath modelPath : viewBinding.getModelPaths()) { PathAndDictionary pathAndDictionary = new PathAndDictionary(modelPath, new ViewPathDictionary(modelPath, viewPathKeyProvider)); got.put(viewPathKeyProvider.modelPathHashcode(modelPath.getId()), pathAndDictionary); } } versionedViewModel.put(tenantId, new VersionedViewsModel(views.getVersion(), newViewValueBindings)); } else { LOG.debug("Didn't reload because view model versions are equal."); } } }
public void loadModel(TenantId tenantId) { ChainedVersion currentVersion = eventsProvider.getCurrentEventsVersion(tenantId); if (currentVersion == ChainedVersion.NULL) { versionedEventsModels.put(tenantId, new VersionedEventsModel(currentVersion, null)); } else { VersionedEventsModel currentVersionedEventModel = versionedEventsModels.get(tenantId); if (currentVersionedEventModel == null || !currentVersionedEventModel.getVersion().equals(currentVersion)) { final MutableInt errors = new MutableInt(); final EventsModel newEventsModel = new EventsModel(); List<ObjectNode> events = eventsProvider.getEvents(new EventsProcessorId(tenantId, "NotBeingUsedYet")); for (ObjectNode event : events) { try { newEventsModel.addEvent(event); } catch (Exception x) { LOG.error("Failed to load event for " + event, x); throw new RuntimeException("Failed to load (" + errors.longValue() + ") event/s. "); } } versionedEventsModels.put(tenantId, new VersionedEventsModel(currentVersion, newEventsModel)); } else { LOG.debug("Didn't reload because event model versions are equal."); } } }
LOG.debug("Didn't reload because view model versions are equal.");
LOG.debug("Failed to load model path and view path dictionary from column key. Older column key format is likely the case."); try { staleViewFieldStream.stream(viewDescriptor, fieldValue);
public void remove(TenantIdAndCentricId tenantIdAndCentricId, List<ViewWriteFieldChange> removes) throws IOException { MultiRemove<ImmutableByteArray, ImmutableByteArray> rawRemoves = new MultiRemove<>(); for (ViewWriteFieldChange change : removes) { rawRemoves.add(rowKey(change.getViewObjectId()), columnKey(change.getModelPathIdHashcode(), change.getModelPathInstanceIds()), new ConstantTimestamper(change.getTimestamp())); LOG.debug("VVS:REMOVED {}", change); } List<RowColumnTimestampRemove<ImmutableByteArray, ImmutableByteArray>> took = rawRemoves.take(); viewValueStore.multiRowsMultiRemove(tenantIdAndCentricId, took); }
public void add(TenantIdAndCentricId tenantIdAndCentricId, List<ViewWriteFieldChange> adds) throws IOException { MultiAdd<ImmutableByteArray, ImmutableByteArray, ViewValue> rawAdds = new MultiAdd<>(); for (ViewWriteFieldChange change : adds) { rawAdds.add(rowKey(change.getViewObjectId()), columnKey(change.getModelPathIdHashcode(), change.getModelPathInstanceIds()), change.getValue(), new ConstantTimestamper(change.getTimestamp())); LOG.debug("VVS:ADD {}", change); } List<RowColumValueTimestampAdd<ImmutableByteArray, ImmutableByteArray, ViewValue>> took = rawAdds.take(); viewValueStore.multiRowsMultiAdd(tenantIdAndCentricId, took); }
public boolean add(ViewDescriptor viewDescriptor, ModelPath modelPath, Id[] modelPathIds, String[] viewPathClasses, ViewValue viewValue, Long timestamp) throws IOException { byte[] value = (viewValue == null) ? null : viewValue.getValue(); viewSizeInBytes += (value == null) ? 0 : value.length; if (viewSizeInBytes > viewMaxSizeInBytes) { LOG.error("ViewDescriptor:" + viewDescriptor + " is larger than viewMaxReadableBytes:" + viewMaxSizeInBytes); return false; } if (viewValue == null || viewValue.getValue() == null || viewValue.getValue().length == 0) { return false; } ObjectNode valueObject = merger.toObjectNode(viewValue.getValue()); if (valueObject == null || valueObject.isNull() || valueObject.size() == 0) { return false; } ObjectId[] modelPathInstanceIds = modelPathInstanceIds(modelPathIds, viewPathClasses, modelPath.getPathMembers()); LOG.debug("Read view path -> with id={} instance ids={} value={} timestamp={}", new Object[]{modelPath.getId(), modelPathIds, viewValue, timestamp}); if (treeRoot == null) { treeRoot = new MapTreeNode(modelPathInstanceIds[0]); } treeRoot.add(modelPath.getPathMembers().toArray(new ModelPathStep[modelPath.getPathMemberSize()]), modelPathInstanceIds, viewValue, timestamp); return true; }