Examples with ShadowType com.evolveum.midpoint.xml.ns._public.common.common_3.ShadowType used on opensource projects

Example 6 with ShadowType

use of com.evolveum.midpoint.xml.ns._public.common.common_3.ShadowType in project midpoint by Evolveum.

the class ReconciliationTaskHandler method scanForUnfinishedOperations.

/**
	 * Scans shadows for unfinished operations and tries to finish them.
     * Returns false if the reconciliation was interrupted.
	 */
private boolean scanForUnfinishedOperations(Task task, String resourceOid, ReconciliationTaskResult reconResult, OperationResult result) throws SchemaException, ObjectAlreadyExistsException, CommunicationException, ObjectNotFoundException, ConfigurationException, SecurityViolationException {
    LOGGER.trace("Scan for unfinished operations starting");
    OperationResult opResult = result.createSubresult(OperationConstants.RECONCILIATION + ".repoReconciliation");
    opResult.addParam("reconciled", true);
    ObjectQuery query = QueryBuilder.queryFor(ShadowType.class, prismContext).block().not().item(ShadowType.F_FAILED_OPERATION_TYPE).isNull().endBlock().and().item(ShadowType.F_RESOURCE_REF).ref(resourceOid).build();
    List<PrismObject<ShadowType>> shadows = repositoryService.searchObjects(ShadowType.class, query, null, opResult);
    // for this phase, obviously
    task.setExpectedTotal((long) shadows.size());
    LOGGER.trace("Found {} accounts that were not successfully processed.", shadows.size());
    reconResult.setUnOpsCount(shadows.size());
    long startedAll = System.currentTimeMillis();
    int processedSuccess = 0, processedFailure = 0;
    for (PrismObject<ShadowType> shadow : shadows) {
        long started = System.currentTimeMillis();
        task.recordIterativeOperationStart(shadow.asObjectable());
        OperationResult provisioningResult = new OperationResult(OperationConstants.RECONCILIATION + ".finishOperation");
        try {
            RepositoryCache.enter();
            ProvisioningOperationOptions options = ProvisioningOperationOptions.createCompletePostponed(false);
            Utils.clearRequestee(task);
            provisioningService.refreshShadow(shadow, options, task, provisioningResult);
            //				retryFailedOperation(shadow.asObjectable(), opResult);
            task.recordIterativeOperationEnd(shadow.asObjectable(), started, null);
            processedSuccess++;
        } catch (Throwable ex) {
            task.recordIterativeOperationEnd(shadow.asObjectable(), started, ex);
            processedFailure++;
            opResult.recordFatalError("Failed to finish operation with shadow: " + ObjectTypeUtil.toShortString(shadow.asObjectable()) + ". Reason: " + ex.getMessage(), ex);
            Collection<? extends ItemDelta> modifications = PropertyDelta.createModificationReplacePropertyCollection(ShadowType.F_ATTEMPT_NUMBER, shadow.getDefinition(), shadow.asObjectable().getAttemptNumber() + 1);
            try {
                repositoryService.modifyObject(ShadowType.class, shadow.getOid(), modifications, provisioningResult);
                task.recordObjectActionExecuted(shadow, null, null, ChangeType.MODIFY, SchemaConstants.CHANGE_CHANNEL_RECON_URI, null);
            } catch (Exception e) {
                task.recordObjectActionExecuted(shadow, null, null, ChangeType.MODIFY, SchemaConstants.CHANGE_CHANNEL_RECON_URI, e);
                LoggingUtils.logException(LOGGER, "Failed to record finish operation failure with shadow: " + ObjectTypeUtil.toShortString(shadow.asObjectable()), e);
            }
        } finally {
            task.markObjectActionExecutedBoundary();
            RepositoryCache.exit();
        }
        // TODO record statistics as well
        incrementAndRecordProgress(task, opResult);
        if (!task.canRun()) {
            break;
        }
    }
    // for next phases, it looks strangely to see progress e.g. 2/1
    task.setExpectedTotal(null);
    // for each try the operation again
    String message = "Processing unfinished operations done. Out of " + shadows.size() + " objects, " + processedSuccess + " were processed successfully and processing of " + processedFailure + " resulted in failure. " + "Total time spent: " + (System.currentTimeMillis() - startedAll) + " ms. " + (!task.canRun() ? "Was interrupted during processing." : "");
    opResult.computeStatus();
    result.createSubresult(opResult.getOperation() + ".statistics").recordStatus(opResult.getStatus(), message);
    LOGGER.debug("{}. Result: {}", message, opResult.getStatus());
    return task.canRun();
}

Example 7 with ShadowType

use of com.evolveum.midpoint.xml.ns._public.common.common_3.ShadowType in project midpoint by Evolveum.

the class SynchronizationServiceImpl method evaluateSynchronizationPolicyCondition.

private Boolean evaluateSynchronizationPolicyCondition(ObjectSynchronizationType synchronizationPolicy, PrismObject<? extends ShadowType> currentShadow, PrismObject<ResourceType> resource, PrismObject<SystemConfigurationType> configuration, Task task, OperationResult result) throws SchemaException, ExpressionEvaluationException, ObjectNotFoundException {
    if (synchronizationPolicy.getCondition() == null) {
        return null;
    }
    ExpressionType conditionExpressionType = synchronizationPolicy.getCondition();
    String desc = "condition in object synchronization " + synchronizationPolicy.getName();
    ExpressionVariables variables = Utils.getDefaultExpressionVariables(null, currentShadow, null, resource, configuration, null);
    try {
        ModelExpressionThreadLocalHolder.pushExpressionEnvironment(new ExpressionEnvironment<>(task, result));
        PrismPropertyValue<Boolean> evaluateCondition = ExpressionUtil.evaluateCondition(variables, conditionExpressionType, expressionFactory, desc, task, result);
        return evaluateCondition.getValue();
    } finally {
        ModelExpressionThreadLocalHolder.popExpressionEnvironment();
    }
}

Example 8 with ShadowType

use of com.evolveum.midpoint.xml.ns._public.common.common_3.ShadowType in project midpoint by Evolveum.

the class ResourceContentPanel method getResultLabel.

private String getResultLabel(IModel<SelectableBean<ShadowType>> model) {
    OperationResultType result = getResult(model);
    if (result == null) {
        return "";
    }
    StringBuilder b = new StringBuilder(createStringResource("FailedOperationTypeType." + getShadow(model).getFailedOperationType()).getObject());
    b.append(":");
    b.append(createStringResource("OperationResultStatusType." + result.getStatus()).getObject());
    return b.toString();
}

Example 9 with ShadowType

use of com.evolveum.midpoint.xml.ns._public.common.common_3.ShadowType in project midpoint by Evolveum.

the class XsdTypeConverterTest method testAccountMarshall.

// ... as it uses JAXB that is no more supported
@Deprecated
@Test(enabled = false)
public void testAccountMarshall() throws JAXBException, SchemaException, IOException {
    System.out.println("===[ testAccountMarshall ]===");
    ShadowType shadow = PrismTestUtil.parseObjectable(new File("src/test/resources/converter/account-jack.xml"), ShadowType.class);
    System.out.println("Object: " + shadow);
    ProtectedStringType ps = new ProtectedStringType();
    ps.setClearValue("foo");
    JAXBElement<ProtectedStringType> pse = new JAXBElement<ProtectedStringType>(FOO_QNAME, ProtectedStringType.class, ps);
    shadow.getAttributes().getAny().add(pse);
    shadow.getAttributes().getAny().add(XmlTypeConverter.toXsdElement(42, BAR_QNAME, null, true));
    Document doc = DOMUtil.getDocument();
    JAXBElement<ShadowType> accountElement = new JAXBElement<ShadowType>(ObjectTypes.SHADOW.getQName(), ShadowType.class, shadow);
    JaxbTestUtil.getInstance().marshalElementToDom(accountElement, doc);
    System.out.println("marshalled shadow: " + DOMUtil.serializeDOMToString(doc));
    Element rootElement = DOMUtil.getFirstChildElement(doc);
    System.out.println("root element: " + rootElement);
    Element attrElement = (Element) rootElement.getElementsByTagNameNS(SchemaConstants.NS_C, "attributes").item(0);
    System.out.println("attrElement element: " + attrElement);
    Element fooElement = (Element) attrElement.getElementsByTagNameNS(FOO_QNAME.getNamespaceURI(), FOO_QNAME.getLocalPart()).item(0);
    System.out.println("fooElement element: " + fooElement);
    Element clearValue = DOMUtil.getFirstChildElement(fooElement);
    assertEquals("foo", clearValue.getTextContent());
    Element barElement = (Element) attrElement.getElementsByTagNameNS(BAR_QNAME.getNamespaceURI(), BAR_QNAME.getLocalPart()).item(0);
    System.out.println("barElement element: " + barElement);
    assertEquals(DOMUtil.XSD_INT, DOMUtil.resolveXsiType(barElement));
    assertEquals("42", barElement.getTextContent());
}

Example 10 with ShadowType

use of com.evolveum.midpoint.xml.ns._public.common.common_3.ShadowType in project midpoint by Evolveum.

the class ProjectionCredentialsProcessor method processProjectionPasswordMapping.

private <F extends FocusType> void processProjectionPasswordMapping(LensContext<F> context, final LensProjectionContext projCtx, final ValuePolicyType passwordPolicy, XMLGregorianCalendar now, Task task, OperationResult result) throws ExpressionEvaluationException, ObjectNotFoundException, SchemaException, CommunicationException, ConfigurationException, SecurityViolationException {
    LensFocusContext<F> focusContext = context.getFocusContext();
    PrismObject<F> userNew = focusContext.getObjectNew();
    if (userNew == null) {
        // This must be a user delete or something similar. No point in proceeding
        LOGGER.trace("userNew is null, skipping credentials processing");
        return;
    }
    PrismObjectDefinition<ShadowType> accountDefinition = prismContext.getSchemaRegistry().findObjectDefinitionByCompileTimeClass(ShadowType.class);
    PrismPropertyDefinition<ProtectedStringType> projPasswordPropertyDefinition = accountDefinition.findPropertyDefinition(SchemaConstants.PATH_PASSWORD_VALUE);
    ResourceShadowDiscriminator rsd = projCtx.getResourceShadowDiscriminator();
    RefinedObjectClassDefinition refinedProjDef = projCtx.getStructuralObjectClassDefinition();
    if (refinedProjDef == null) {
        LOGGER.trace("No RefinedObjectClassDefinition, therefore also no password outbound definition, skipping credentials processing for projection {}", rsd);
        return;
    }
    List<MappingType> outboundMappingTypes = refinedProjDef.getPasswordOutbound();
    if (outboundMappingTypes == null || outboundMappingTypes.isEmpty()) {
        LOGGER.trace("No outbound password mapping for {}, skipping credentials processing", rsd);
        return;
    }
    // HACK
    if (!projCtx.isDoReconciliation() && !projCtx.isAdd() && !isActivated(outboundMappingTypes, focusContext.getDelta())) {
        LOGGER.trace("Outbound password mappings not activated for type {}, skipping credentials processing", rsd);
        return;
    }
    final ObjectDelta<ShadowType> projDelta = projCtx.getDelta();
    final PropertyDelta<ProtectedStringType> projPasswordDelta;
    if (projDelta != null && projDelta.getChangeType() == MODIFY) {
        projPasswordDelta = projDelta.findPropertyDelta(SchemaConstants.PATH_PASSWORD_VALUE);
    } else {
        projPasswordDelta = null;
    }
    checkExistingDeltaSanity(projCtx, projPasswordDelta);
    boolean evaluateWeak = getEvaluateWeak(projCtx);
    final ItemDeltaItem<PrismPropertyValue<PasswordType>, PrismPropertyDefinition<ProtectedStringType>> userPasswordIdi = focusContext.getObjectDeltaObject().findIdi(SchemaConstants.PATH_PASSWORD_VALUE);
    StringPolicyResolver stringPolicyResolver = new StringPolicyResolver() {

        @Override
        public void setOutputPath(ItemPath outputPath) {
        }

        @Override
        public void setOutputDefinition(ItemDefinition outputDefinition) {
        }

        @Override
        public StringPolicyType resolve() {
            if (passwordPolicy == null) {
                return null;
            }
            return passwordPolicy.getStringPolicy();
        }
    };
    MappingInitializer<PrismPropertyValue<ProtectedStringType>, PrismPropertyDefinition<ProtectedStringType>> initializer = (builder) -> {
        builder.defaultTargetDefinition(projPasswordPropertyDefinition);
        builder.defaultSource(new Source<>(userPasswordIdi, ExpressionConstants.VAR_INPUT));
        builder.stringPolicyResolver(stringPolicyResolver);
        return builder;
    };
    MappingOutputProcessor<PrismPropertyValue<ProtectedStringType>> processor = (mappingOutputPath, outputStruct) -> {
        PrismValueDeltaSetTriple<PrismPropertyValue<ProtectedStringType>> outputTriple = outputStruct.getOutputTriple();
        if (outputTriple == null) {
            LOGGER.trace("Credentials 'password' expression resulted in null output triple, skipping credentials processing for {}", rsd);
            return false;
        }
        boolean projectionIsNew = projDelta != null && (projDelta.getChangeType() == ChangeType.ADD || projCtx.getSynchronizationPolicyDecision() == SynchronizationPolicyDecision.ADD);
        Collection<PrismPropertyValue<ProtectedStringType>> newValues = outputTriple.getPlusSet();
        if (projectionIsNew) {
            newValues = outputTriple.getNonNegativeValues();
        } else {
            newValues = outputTriple.getPlusSet();
        }
        if (!canGetCleartext(newValues)) {
            ObjectDelta<ShadowType> projectionPrimaryDelta = projCtx.getPrimaryDelta();
            if (projectionPrimaryDelta != null) {
                PropertyDelta<ProtectedStringType> passwordPrimaryDelta = projectionPrimaryDelta.findPropertyDelta(SchemaConstants.PATH_PASSWORD_VALUE);
                if (passwordPrimaryDelta != null) {
                    // We have only hashed value coming from the mapping. There are not very useful
                    // for provisioning. But we have primary projection delta - and that is very likely
                    // to be better.
                    // Skip all password mappings in this case. Primary delta trumps everything. 
                    // No weak, normal or even strong mapping can change that.
                    // We need to disregard even strong mapping in this case. If we would heed the strong
                    // mapping then account initialization won't be possible.
                    LOGGER.trace("We have primary password delta in projection, skipping credentials processing");
                    return false;
                }
            }
        }
        return true;
    };
    mappingEvaluator.evaluateOutboundMapping(context, projCtx, outboundMappingTypes, SchemaConstants.PATH_PASSWORD_VALUE, SchemaConstants.PATH_PASSWORD_VALUE, initializer, processor, now, true, evaluateWeak, "password mapping", task, result);
}