Examples with SearchResultMetadata com.evolveum.midpoint.schema.SearchResultMetadata used on opensource projects

Example 36 with SearchResultMetadata

use of com.evolveum.midpoint.schema.SearchResultMetadata in project midpoint by Evolveum.

the class AbstractLdapConnTest method test174SeachFirst222AccountsOffset20.

/**
	 * Blocksize is 100, so this gets more than two blocks.
	 * There is offset, so VLV should be used.
	 * No explicit sorting.
	 */
@Test
public void test174SeachFirst222AccountsOffset20() throws Exception {
    final String TEST_NAME = "test174SeachFirst222AccountsOffset20";
    TestUtil.displayTestTile(this, TEST_NAME);
    // GIVEN
    Task task = taskManager.createTaskInstance(this.getClass().getName() + "." + TEST_NAME);
    OperationResult result = task.getResult();
    ObjectQuery query = ObjectQueryUtil.createResourceAndObjectClassQuery(getResourceOid(), getAccountObjectClass(), prismContext);
    ObjectPaging paging = ObjectPaging.createPaging(20, 222);
    query.setPaging(paging);
    SearchResultList<PrismObject<ShadowType>> searchResultList = doSearch(TEST_NAME, query, 222, task, result);
    assertConnectorOperationIncrement(1, 223);
    assertConnectorSimulatedPagingSearchIncrement(0);
    SearchResultMetadata metadata = searchResultList.getMetadata();
    if (metadata != null) {
        assertFalse(metadata.isPartialResults());
    }
    assertLdapConnectorInstances(1, 2);
}

Example 37 with SearchResultMetadata

use of com.evolveum.midpoint.schema.SearchResultMetadata in project midpoint by Evolveum.

the class ResourceObjectConverter method searchResourceObjects.

public SearchResultMetadata searchResourceObjects(final ProvisioningContext ctx, final ResultHandler<ShadowType> resultHandler, ObjectQuery query, final boolean fetchAssociations, final OperationResult parentResult) throws SchemaException, CommunicationException, ObjectNotFoundException, ConfigurationException, SecurityViolationException, ExpressionEvaluationException {
    LOGGER.trace("Searching resource objects, query: {}", query);
    RefinedObjectClassDefinition objectClassDef = ctx.getObjectClassDefinition();
    AttributesToReturn attributesToReturn = ProvisioningUtil.createAttributesToReturn(ctx);
    SearchHierarchyConstraints searchHierarchyConstraints = null;
    ResourceObjectReferenceType baseContextRef = objectClassDef.getBaseContext();
    if (baseContextRef != null) {
        PrismObject<ShadowType> baseContextShadow = resourceObjectReferenceResolver.resolve(ctx, baseContextRef, null, "base context specification in " + objectClassDef, parentResult);
        if (baseContextShadow == null) {
            throw new ObjectNotFoundException("No base context defined by " + baseContextRef + " in base context specification in " + objectClassDef);
        }
        RefinedObjectClassDefinition baseContextObjectClassDefinition = ctx.getRefinedSchema().determineCompositeObjectClassDefinition(baseContextShadow);
        ResourceObjectIdentification baseContextIdentification = ShadowUtil.getResourceObjectIdentification(baseContextShadow, baseContextObjectClassDefinition);
        searchHierarchyConstraints = new SearchHierarchyConstraints(baseContextIdentification, null);
    }
    if (InternalsConfig.consistencyChecks && query != null && query.getFilter() != null) {
        query.getFilter().checkConsistence(true);
    }
    ConnectorInstance connector = ctx.getConnector(ReadCapabilityType.class, parentResult);
    SearchResultMetadata metadata = null;
    try {
        metadata = connector.search(objectClassDef, query, (shadow) -> {
            // in order to utilize the cache right from the beginning...
            RepositoryCache.enter();
            try {
                try {
                    shadow = postProcessResourceObjectRead(ctx, shadow, fetchAssociations, parentResult);
                } catch (SchemaException | CommunicationException | ConfigurationException | SecurityViolationException | ObjectNotFoundException | ExpressionEvaluationException e) {
                    throw new TunnelException(e);
                }
                return resultHandler.handle(shadow);
            } finally {
                RepositoryCache.exit();
            }
        }, attributesToReturn, objectClassDef.getPagedSearches(), searchHierarchyConstraints, ctx, parentResult);
    } catch (GenericFrameworkException e) {
        parentResult.recordFatalError("Generic error in the connector: " + e.getMessage(), e);
        throw new SystemException("Generic error in the connector: " + e.getMessage(), e);
    } catch (CommunicationException ex) {
        parentResult.recordFatalError("Error communicating with the connector " + connector + ": " + ex.getMessage(), ex);
        throw new CommunicationException("Error communicating with the connector " + connector + ": " + ex.getMessage(), ex);
    } catch (SecurityViolationException ex) {
        parentResult.recordFatalError("Security violation communicating with the connector " + connector + ": " + ex.getMessage(), ex);
        throw new SecurityViolationException("Security violation communicating with the connector " + connector + ": " + ex.getMessage(), ex);
    } catch (TunnelException e) {
        Throwable cause = e.getCause();
        if (cause instanceof SchemaException) {
            throw (SchemaException) cause;
        } else if (cause instanceof CommunicationException) {
            throw (CommunicationException) cause;
        } else if (cause instanceof ObjectNotFoundException) {
            throw (ObjectNotFoundException) cause;
        } else if (cause instanceof ConfigurationException) {
            throw (ConfigurationException) cause;
        } else if (cause instanceof SecurityViolationException) {
            throw (SecurityViolationException) cause;
        } else if (cause instanceof ExpressionEvaluationException) {
            throw (ExpressionEvaluationException) cause;
        } else if (cause instanceof GenericFrameworkException) {
            throw new GenericConnectorException(cause.getMessage(), cause);
        } else {
            throw new SystemException(cause.getMessage(), cause);
        }
    }
    computeResultStatus(parentResult);
    LOGGER.trace("Searching resource objects done: {}", parentResult.getStatus());
    return metadata;
}

Example 38 with SearchResultMetadata

use of com.evolveum.midpoint.schema.SearchResultMetadata in project midpoint by Evolveum.

the class ProvisioningServiceImpl method searchObjectsIterative.

@SuppressWarnings({ "rawtypes", "unchecked" })
@Override
public <T extends ObjectType> SearchResultMetadata searchObjectsIterative(final Class<T> type, ObjectQuery query, final Collection<SelectorOptions<GetOperationOptions>> options, final ResultHandler<T> handler, Task task, final OperationResult parentResult) throws SchemaException, ObjectNotFoundException, CommunicationException, ConfigurationException, SecurityViolationException, ExpressionEvaluationException {
    Validate.notNull(parentResult, "Operation result must not be null.");
    Validate.notNull(handler, "Handler must not be null.");
    if (LOGGER.isTraceEnabled()) {
        LOGGER.trace("Start to search object. Query {}", query != null ? query.debugDump() : "(null)");
    }
    final OperationResult result = parentResult.createSubresult(ProvisioningService.class.getName() + ".searchObjectsIterative");
    result.setSummarizeSuccesses(true);
    result.setSummarizeErrors(true);
    result.setSummarizePartialErrors(true);
    result.addParam("query", query);
    result.addContext(OperationResult.CONTEXT_IMPLEMENTATION_CLASS, ProvisioningServiceImpl.class);
    ObjectFilter filter = null;
    if (query != null) {
        filter = ObjectQueryUtil.simplify(query.getFilter());
        query = query.cloneEmpty();
        query.setFilter(filter);
    }
    if (InternalsConfig.consistencyChecks && filter != null) {
        // We may not have all the definitions here. We will apply the definitions later
        filter.checkConsistence(false);
    }
    if (filter != null && filter instanceof NoneFilter) {
        result.recordSuccessIfUnknown();
        result.cleanupResult();
        LOGGER.trace("Finished searching. Nothing to do. Filter is NONE");
        SearchResultMetadata metadata = new SearchResultMetadata();
        metadata.setApproxNumberOfAllResults(0);
        return metadata;
    }
    final GetOperationOptions rootOptions = SelectorOptions.findRootOptions(options);
    if (!ShadowType.class.isAssignableFrom(type)) {
        ResultHandler<T> internalHandler = (object, objResult) -> handleRepoObject(type, object, options, handler, task, objResult);
        Collection<SelectorOptions<GetOperationOptions>> repoOptions = null;
        if (GetOperationOptions.isReadOnly(rootOptions)) {
            repoOptions = SelectorOptions.createCollection(GetOperationOptions.createReadOnly());
        }
        SearchResultMetadata metadata = null;
        try {
            // TODO think about strictSequential flag
            metadata = getCacheRepositoryService().searchObjectsIterative(type, query, internalHandler, repoOptions, false, result);
            result.computeStatus();
            result.recordSuccessIfUnknown();
        } catch (SchemaException | RuntimeException | Error e) {
            ProvisioningUtil.recordFatalError(LOGGER, result, null, e);
        }
        result.cleanupResult();
        return metadata;
    }
    final boolean shouldDoRepoSearch = ProvisioningUtil.shouldDoRepoSearch(rootOptions);
    final ShadowHandler shadowHandler = new ShadowHandler() {

        @Override
        public boolean handle(ShadowType shadowType) {
            OperationResult handleResult = result.createSubresult(ProvisioningService.class.getName() + ".searchObjectsIterative.handle");
            if (shouldDoRepoSearch) {
                return handleRepoObject(type, (PrismObject<T>) shadowType.asPrismObject(), options, handler, task, handleResult);
            }
            if (shadowType == null) {
                throw new IllegalArgumentException("Null shadow in call to handler");
            }
            if (LOGGER.isTraceEnabled()) {
                LOGGER.trace("searchObjectsIterative: processing shadow: {}", SchemaDebugUtil.prettyPrint(shadowType));
            }
            boolean doContinue;
            try {
                PrismObject shadow = shadowType.asPrismObject();
                validateObject(shadow);
                doContinue = handler.handle(shadow, handleResult);
                handleResult.computeStatus();
                handleResult.recordSuccessIfUnknown();
                if (!handleResult.isSuccess() && !handleResult.isHandledError()) {
                    Collection<? extends ItemDelta> shadowModificationType = PropertyDelta.createModificationReplacePropertyCollection(ShadowType.F_RESULT, getResourceObjectShadowDefinition(), handleResult.createOperationResultType());
                    try {
                        ConstraintsChecker.onShadowModifyOperation(shadowModificationType);
                        cacheRepositoryService.modifyObject(ShadowType.class, shadowType.getOid(), shadowModificationType, result);
                    } catch (ObjectNotFoundException ex) {
                        result.recordFatalError("Saving of result to " + shadow + " shadow failed: Not found: " + ex.getMessage(), ex);
                    } catch (ObjectAlreadyExistsException ex) {
                        result.recordFatalError("Saving of result to " + shadow + " shadow failed: Already exists: " + ex.getMessage(), ex);
                    } catch (SchemaException ex) {
                        result.recordFatalError("Saving of result to " + shadow + " shadow failed: Schema error: " + ex.getMessage(), ex);
                    } catch (RuntimeException e) {
                        result.recordFatalError("Saving of result to " + shadow + " shadow failed: " + e.getMessage(), e);
                        throw e;
                    }
                }
            } catch (RuntimeException e) {
                result.recordFatalError(e);
                throw e;
            } finally {
                handleResult.computeStatus();
                handleResult.recordSuccessIfUnknown();
                // AbstractSummarizingResultHandler [lazyman]
                if (result.isSuccess()) {
                    result.getSubresults().clear();
                }
                result.summarize();
            }
            return doContinue;
        }
    };
    SearchResultMetadata metadata;
    try {
        metadata = getShadowCache(Mode.STANDARD).searchObjectsIterative(query, options, shadowHandler, true, task, result);
        result.computeStatus();
    } catch (ConfigurationException | CommunicationException | ObjectNotFoundException | SchemaException | ExpressionEvaluationException | RuntimeException | Error e) {
        ProvisioningUtil.recordFatalError(LOGGER, result, null, e);
        throw e;
    } finally {
        result.cleanupResult();
    }
    return metadata;
}

Example 39 with SearchResultMetadata

use of com.evolveum.midpoint.schema.SearchResultMetadata in project midpoint by Evolveum.

the class ProvisioningServiceImpl method searchObjects.

@Override
public <T extends ObjectType> SearchResultList<PrismObject<T>> searchObjects(Class<T> type, ObjectQuery query, Collection<SelectorOptions<GetOperationOptions>> options, Task task, OperationResult parentResult) throws SchemaException, ObjectNotFoundException, CommunicationException, ConfigurationException, SecurityViolationException, ExpressionEvaluationException {
    OperationResult result = parentResult.createSubresult(ProvisioningService.class.getName() + ".searchObjects");
    result.addParam("objectType", type);
    result.addParam("query", query);
    result.addContext(OperationResult.CONTEXT_IMPLEMENTATION_CLASS, ProvisioningServiceImpl.class);
    final SearchResultList<PrismObject<T>> objListType = new SearchResultList<>(new ArrayList<PrismObject<T>>());
    SearchResultMetadata metadata;
    try {
        if (!ShadowType.class.isAssignableFrom(type)) {
            SearchResultList<PrismObject<T>> objects = searchRepoObjects(type, query, options, task, result);
            result.computeStatus();
            result.recordSuccessIfUnknown();
            result.cleanupResult();
            //				validateObjects(objects);
            return objects;
        }
        final ResultHandler<T> handler = (object, parentResult1) -> objListType.add(object);
        metadata = searchObjectsIterative(type, query, options, handler, task, result);
    } catch (ConfigurationException | SecurityViolationException | CommunicationException | ObjectNotFoundException | SchemaException | ExpressionEvaluationException | RuntimeException | Error e) {
        ProvisioningUtil.recordFatalError(LOGGER, result, "Could not search objects: " + e.getMessage(), e);
        throw e;
    }
    result.computeStatus();
    result.cleanupResult();
    //		validateObjects(objListType);
    objListType.setMetadata(metadata);
    return objListType;
}