public ModelElementContext<?> getFocusContext() { return modelContext.getFocusContext(); }
@Override public <F extends ObjectType> void projectorFinish(ModelContext<F> context) { recordStateTime(projectorTimes, context.getState(), null, System.currentTimeMillis()); String desc = null; if (context.getFocusContext() != null) { PrismObject<F> focusObject = context.getFocusContext().getObjectNew(); if (focusObject == null) { context.getFocusContext().getObjectOld(); for (ModelProjectionContext projectionContext: context.getProjectionContexts()) { PrismObject<ShadowType> projObj = projectionContext.getObjectNew(); if (projObj == null) { Collection<ObjectDelta<? extends ObjectType>> allDeltas = null; try { allDeltas = context.getAllChanges(); } catch (SchemaException e) { changes = -1; changes = allDeltas.size(); long projectorEtime = projectorTimes.get(context.getState()).etime(); LOGGER.trace("Projector {} finished ({}), {} changes, etime: {} ms ({} mapping evaluated, {} ms total)", context.getState(), desc, changes, projectorEtime, projectorMappingTotalCount, projectorMappingTotalMillis);
@Override public HookOperationMode invoke(@NotNull ModelContext context, @NotNull Task task, @NotNull OperationResult result) { // todo in the future we should perhaps act in POSTEXECUTION state, but currently the clockwork skips this state if (context.getState() != ModelState.FINAL) { return HookOperationMode.FOREGROUND; } if (notificationManager.isDisabled()) { LOGGER.trace("Notifications are temporarily disabled, exiting the hook."); return HookOperationMode.FOREGROUND; } if (LOGGER.isTraceEnabled()) { LOGGER.trace("Notification change hook called with model context: " + context.debugDump()); } if (context.getFocusContext() == null) { if (LOGGER.isTraceEnabled()) { LOGGER.trace("Focus context is null, exiting the hook."); } return HookOperationMode.FOREGROUND; } emitModelEvent(context, task, result); emitPolicyRulesEvents(context, task, result); return HookOperationMode.FOREGROUND; }
public Class<? extends ObjectType> getFocusClass(ModelContext<? extends ObjectType> context) { if (context.getFocusClass() != null) { return context.getFocusClass(); } // if for some reason context.focusClass is not set... here is a fallback if (context.getFocusContext() == null) { return null; } ObjectDelta<? extends ObjectType> change = context.getFocusContext().getPrimaryDelta(); if (change == null) { return null; } return change.getObjectTypeClass(); }
public <O extends ObjectType> ObjectTreeDeltas<O> extractTreeDeltasFromModelContext(ModelContext<O> modelContext) { ObjectTreeDeltas<O> objectTreeDeltas = new ObjectTreeDeltas<>(modelContext.getPrismContext()); if (modelContext.getFocusContext() != null && modelContext.getFocusContext().getPrimaryDelta() != null) { objectTreeDeltas.setFocusChange(modelContext.getFocusContext().getPrimaryDelta().clone()); } for (ModelProjectionContext projectionContext : modelContext.getProjectionContexts()) { if (projectionContext.getPrimaryDelta() != null) { objectTreeDeltas.addProjectionChange(projectionContext.getResourceShadowDiscriminator(), projectionContext.getPrimaryDelta()); } } return objectTreeDeltas; }
protected void fillDeltas(ModelContext<UserType> modelContext, List<ObjectDelta<? extends ObjectType>> primaryDeltas, List<ObjectDelta<? extends ObjectType>> secondaryDeltas) throws SchemaException { if (modelContext != null) { if (modelContext.getFocusContext() != null) { addIgnoreNull(primaryDeltas, modelContext.getFocusContext().getPrimaryDelta()); addIgnoreNull(secondaryDeltas, modelContext.getFocusContext().getSecondaryDelta()); } for (ModelProjectionContext projCtx : modelContext.getProjectionContexts()) { addIgnoreNull(primaryDeltas, projCtx.getPrimaryDelta()); addIgnoreNull(secondaryDeltas, projCtx.getExecutableDelta()); } } display("primary deltas", primaryDeltas); display("secondary deltas", secondaryDeltas); }
TestUtil.assertSuccess(result); ModelElementContext<UserType> focusContext = modelContext.getFocusContext(); assertNotNull("Null model focus context", focusContext); assertNull("Unexpected focus primary delta: "+focusContext.getPrimaryDelta(), focusContext.getPrimaryDelta()); assertSideEffectiveDeltasOnly("focus secondary delta", userSecondaryDelta); Collection<? extends ModelProjectionContext> projectionContexts = modelContext.getProjectionContexts(); assertNotNull("Null model projection context list", projectionContexts); assertEquals("Unexpected number of projection contexts", 3, projectionContexts.size()); ModelProjectionContext accContext = modelContext.findProjectionContext( new ResourceShadowDiscriminator(RESOURCE_DUMMY_BLUE_OID, ShadowKindType.ACCOUNT, null)); assertNotNull("Null model projection context", accContext);
assertNotNull("Null focus context", context.getFocusContext()); assertEquals("Wrong number of projection contexts", 1, context.getProjectionContexts().size()); DeltaSetTriple<? extends EvaluatedAssignment<?>> evaluatedAssignmentTriple = context.getEvaluatedAssignmentTriple(); assertNotNull("null evaluatedAssignmentTriple", evaluatedAssignmentTriple); assertTrue("Unexpected plus set in evaluatedAssignmentTriple", evaluatedAssignmentTriple.getPlusSet().isEmpty());
@Override public <O extends ObjectType> HookOperationMode invoke(@NotNull ModelContext<O> context, @NotNull Task task, @NotNull OperationResult result) { if (context.getState() != ModelState.FINAL) { return HookOperationMode.FOREGROUND; } LensElementContext<O> focusContext = (LensElementContext<O>) context.getFocusContext(); if (focusContext == null || !FocusType.class.isAssignableFrom(focusContext.getObjectTypeClass())) { return HookOperationMode.FOREGROUND; } List<CertificationPolicyActionType> actions = new ArrayList<>(); actions.addAll(getFocusCertificationActions(context)); actions.addAll(getAssignmentCertificationActions(context)); try { certificationManager.startAdHocCertifications(focusContext.getObjectAny(), actions, task, result); } catch (CommonException e) { throw new SystemException("Couldn't start ad-hoc campaign(s): " + e.getMessage(), e); } return HookOperationMode.FOREGROUND; }
@Override public HookOperationMode processModelInvocation(@NotNull ModelContext<?> context, WfConfigurationType wfConfigurationType, @NotNull Task taskFromModel, @NotNull OperationResult result) throws SchemaException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException { if (context.getState() != PRIMARY) { return null; } return previewOrProcessModelInvocation(context, wfConfigurationType, false, null, taskFromModel, result); }
public Collection<? extends ModelProjectionContext> getProjectionContexts() { return modelContext.getProjectionContexts(); }
TestUtil.assertSuccess(result); ModelElementContext<UserType> focusContext = modelContext.getFocusContext(); assertNotNull("Model focus context missing", focusContext); DeltaSetTriple<? extends EvaluatedAssignment<?>> evaluatedAssignmentTriple = modelContext.getEvaluatedAssignmentTriple(); display("evaluatedAssignmentTriple", evaluatedAssignmentTriple);
ModelState state = context.getState(); if (state != ModelState.FINAL) { if (LOGGER.isTraceEnabled()) { boolean isDeletion = false; PrismObject<?> object = null; for (Object o : context.getProjectionContexts()) { boolean deletion = false; object = ((ModelElementContext<?>) o).getObjectNew();
LOGGER.trace("There's no primary delta in focus context; we'll delete model operation context. Task = {}, model context:\n{}", task, modelContext.debugDump()); modelContext.getFocusContext().setPrimaryDelta(focusChange); Set<Map.Entry<ResourceShadowDiscriminator, ObjectDelta<ShadowType>>> entries = deltasOut.getProjectionChangeMapEntries(); for (Map.Entry<ResourceShadowDiscriminator, ObjectDelta<ShadowType>> entry : entries) { modelContext.findProjectionContext(entry.getKey()).setPrimaryDelta(entry.getValue()); LOGGER.trace("Resulting model context to be stored into task {}:\n{}", task, modelContext.debugDump(0));
ModelElementContext<FocusType> focusContext = modelContext.getFocusContext(); PrismObject<FocusType> focus = focusContext.getObjectNew() != null ? focusContext.getObjectNew() : focusContext.getObjectOld(); FocusType userType = focus.asObjectable(); body.append("----------------------------------------\n"); body.append("Technical information:\n\n"); body.append(modelContext.debugDump(2));
@SuppressWarnings("unchecked") private ObjectDelta<? extends FocusType> assignmentToDelta(ModelContext<?> modelContext, AssignmentType assignmentType, String objectOid) { PrismObject<FocusType> focus = (PrismObject<FocusType>) modelContext.getFocusContext().getObjectNew(); PrismContainerDefinition<AssignmentType> prismContainerDefinition = focus.getDefinition().findContainerDefinition(FocusType.F_ASSIGNMENT); ItemDelta<PrismContainerValue<AssignmentType>,PrismContainerDefinition<AssignmentType>> addRoleDelta = prismContext.deltaFactory().container().create( ItemPath.EMPTY_PATH, FocusType.F_ASSIGNMENT, prismContainerDefinition); PrismContainerValue<AssignmentType> assignmentValue = assignmentType.asPrismContainerValue().clone(); addRoleDelta.addValueToAdd(assignmentValue); Class focusClass = primaryChangeAspectHelper.getFocusClass(modelContext); return modelContext.getPrismContext().deltaFactory().object().createModifyDelta(objectOid, addRoleDelta, focusClass ); }
result.addArbitraryObjectAsContext("model state", context.getState()); try { WfConfigurationType wfConfigurationType = baseConfigurationHelper.getWorkflowConfiguration(context, result); if (context.getPartialProcessingOptions().getApprovals() == PartialProcessingTypeType.SKIP) { LOGGER.debug("Skipping workflow processing because of the partial processing option set to SKIP"); result.recordSuccess(); if (SchemaConstants.CHANNEL_GUI_INIT_URI.equals(context.getChannel())) { LOGGER.debug("Skipping workflow processing because the channel is '" + SchemaConstants.CHANNEL_GUI_INIT_URI + "'."); result.recordSuccess();
private Collection<CertificationPolicyActionType> getAssignmentCertificationActions(ModelContext<?> context) { DeltaSetTriple<? extends EvaluatedAssignment<?>> evaluatedAssignmentTriple = context.getEvaluatedAssignmentTriple(); if (evaluatedAssignmentTriple == null) { return Collections.emptyList(); } else { return evaluatedAssignmentTriple.stream() .flatMap(ea -> getCertificationActions(ea.getAllTargetsPolicyRules()).stream()) .collect(Collectors.toList()); } }
public void logJobsBeforeStart(WfTask rootWfTask, OperationResult result) throws SchemaException, ConfigurationException, ObjectNotFoundException, CommunicationException, ExpressionEvaluationException { if (!LOGGER.isTraceEnabled()) { return; } StringBuilder sb = new StringBuilder(); sb.append("===[ Situation just before root task starts waiting for subtasks ]===\n"); sb.append("Root job = ").append(rootWfTask).append("; task = ").append(rootWfTask.getTask().debugDump()).append("\n"); if (rootWfTask.hasModelContext()) { sb.append("Context in root task: \n").append(rootWfTask.retrieveModelContext(result).debugDump(1)).append("\n"); } List<WfTask> children = rootWfTask.listChildren(result); for (int i = 0; i < children.size(); i++) { WfTask child = children.get(i); sb.append("Child job #").append(i).append(" = ").append(child).append(", its task:\n").append(child.getTask().debugDump(1)); if (child.hasModelContext()) { sb.append("Context in child task:\n").append(child.retrieveModelContext(result).debugDump(2)); } } LOGGER.trace("\n{}", sb.toString()); LOGGER.trace("Now the root task starts waiting for child tasks"); }
private List<ApprovalRequest<AssociationAdditionType>> getApprovalRequests(ModelContext<?> modelContext, PrimaryChangeProcessorConfigurationType wfConfigurationType, ObjectTreeDeltas changes, Task taskFromModel, OperationResult result) { List<ApprovalRequest<AssociationAdditionType>> requests = new ArrayList<>(); PcpAspectConfigurationType config = primaryChangeAspectHelper.getPcpAspectConfigurationType(wfConfigurationType, this); Set<Map.Entry<ResourceShadowDiscriminator, ObjectDelta<ShadowType>>> entries = changes.getProjectionChangeMapEntries(); for (Map.Entry<ResourceShadowDiscriminator, ObjectDelta<ShadowType>> entry : entries) { ObjectDelta<ShadowType> delta = entry.getValue(); if (delta.isAdd()) { requests.addAll(getApprovalRequestsFromShadowAdd(config, entry.getValue(), entry.getKey(), modelContext, taskFromModel, result)); } else if (delta.isModify()) { ModelProjectionContext projectionContext = modelContext.findProjectionContext(entry.getKey()); requests.addAll(getApprovalRequestsFromShadowModify( config, projectionContext.getObjectOld(), entry.getValue(), entry.getKey(), modelContext, taskFromModel, result)); } else { // no-op } } return requests; }