예제 #1
0
  @Override
  public <T extends ObjectType> SearchResultList<PrismObject<T>> searchObjects(
      Class<T> type,
      ObjectQuery query,
      Collection<SelectorOptions<GetOperationOptions>> options,
      OperationResult parentResult)
      throws SchemaException {
    if (!isCacheable(type) || !nullOrHarmlessOptions(options)) {
      log("Cache: PASS ({})", type.getSimpleName());
      return repository.searchObjects(type, query, options, parentResult);
    }
    Cache cache = getCache();
    if (cache == null) {
      log("Cache: NULL ({})", type.getSimpleName());
    } else {
      SearchResultList queryResult = cache.getQueryResult(type, query, prismContext);
      if (queryResult != null) {
        log("Cache: HIT {} ({})", query, type.getSimpleName());
        return queryResult.clone();
      }
      log("Cache: MISS {} ({})", query, type.getSimpleName());
    }

    // Cannot satisfy from cache, pass down to repository
    SearchResultList<PrismObject<T>> objects =
        repository.searchObjects(type, query, options, parentResult);
    if (cache != null && options == null) {
      for (PrismObject<T> object : objects) {
        cacheObject(cache, object);
      }
      cache.putQueryResult(type, query, objects, prismContext);
    }
    return objects;
  }
예제 #2
0
 @Override
 public <T extends ObjectType> PrismObject<T> getObject(
     Class<T> type,
     String oid,
     Collection<SelectorOptions<GetOperationOptions>> options,
     OperationResult parentResult)
     throws ObjectNotFoundException, SchemaException {
   if (!isCacheable(type) || !nullOrHarmlessOptions(options)) {
     log("Cache: PASS {} ({})", oid, type.getSimpleName());
     return repository.getObject(type, oid, options, parentResult);
   }
   Cache cache = getCache();
   if (cache == null) {
     log("Cache: NULL {} ({})", oid, type.getSimpleName());
   } else {
     PrismObject<T> object = (PrismObject) cache.getObject(oid);
     if (object != null) {
       // TODO: result?
       log("Cache: HIT {} ({})", oid, type.getSimpleName());
       return object.clone();
     }
     log("Cache: MISS {} ({})", oid, type.getSimpleName());
   }
   PrismObject<T> object = repository.getObject(type, oid, null, parentResult);
   cacheObject(cache, object);
   return object;
 }
예제 #3
0
 @Override
 public <T extends ObjectType> int countObjects(
     Class<T> type, ObjectQuery query, OperationResult parentResult) throws SchemaException {
   // TODO use cached query result if applicable
   log("Cache: PASS countObjects ({})", type.getSimpleName());
   return repository.countObjects(type, query, parentResult);
 }
예제 #4
0
  @Test(enabled = true)
  public void test010SetGetWfApprovedBy() throws Exception {

    Task task = taskManager.createTaskInstance();
    OperationResult result = new OperationResult("test010SetGetWfApprovedBy");

    task.setOwner(
        repositoryService.getObject(
            UserType.class, SystemObjectsType.USER_ADMINISTRATOR.value(), null, result));
    taskManager.switchToBackground(task, result);

    wfTaskUtil.addApprovedBy(task, SystemObjectsType.USER_ADMINISTRATOR.value());
    wfTaskUtil.addApprovedBy(task, SystemObjectsType.USER_ADMINISTRATOR.value());
    wfTaskUtil.addApprovedBy(task, AbstractWfTestLegacy.R1BOSS_OID);
    wfTaskUtil.addApprovedBy(task, AbstractWfTestLegacy.R2BOSS_OID);
    task.savePendingModifications(result);

    Task task2 = taskManager.getTask(task.getOid(), result);
    PrismReference approvers = wfTaskUtil.getApprovedBy(task2);

    assertEquals("Incorrect number of approvers", 3, approvers.getValues().size());
    assertEquals(
        "Incorrect approvers",
        new HashSet(
            Arrays.asList(
                SystemObjectsType.USER_ADMINISTRATOR.value(),
                AbstractWfTestLegacy.R1BOSS_OID,
                AbstractWfTestLegacy.R2BOSS_OID)),
        new HashSet(
            Arrays.asList(
                approvers.getValue(0).getOid(),
                approvers.getValue(1).getOid(),
                approvers.getValue(2).getOid())));
  }
예제 #5
0
 @Override
 public <T extends ShadowType> List<PrismObject<T>> listResourceObjectShadows(
     String resourceOid, Class<T> resourceObjectShadowType, OperationResult parentResult)
     throws ObjectNotFoundException, SchemaException {
   return repository.listResourceObjectShadows(
       resourceOid, resourceObjectShadowType, parentResult);
 }
예제 #6
0
 @Override
 public <T extends ObjectType> void deleteObject(
     Class<T> type, String oid, OperationResult parentResult) throws ObjectNotFoundException {
   repository.deleteObject(type, oid, parentResult);
   Cache cache = getCache();
   if (cache != null) {
     cache.removeObject(oid);
     cache.clearQueryResults(type);
   }
 }
  /* (non-Javadoc)
   * @see com.evolveum.midpoint.model.api.ModelDiagnosticService#repositorySelfTest(com.evolveum.midpoint.task.api.Task)
   */
  @Override
  public OperationResult repositorySelfTest(Task task) {
    OperationResult testResult = new OperationResult(REPOSITORY_SELF_TEST);
    // Give repository chance to run its own self-test if available
    repositoryService.repositorySelfTest(testResult);

    repositorySelfTestUser(task, testResult);

    testResult.computeStatus();
    return testResult;
  }
예제 #8
0
  // Called from the ObjectResolver.resolve
  public ObjectType resolveRef(
      ObjectReferenceType ref, String contextDescription, OperationResult result)
      throws ObjectNotFoundException, SchemaException {

    Class<? extends ObjectType> type = ObjectType.class;
    if (ref.getType() != null) {
      ObjectTypes objectTypeType = ObjectTypes.getObjectTypeFromTypeQName(ref.getType());
      type = objectTypeType.getClassDefinition();
    }

    return repositoryService.getObject(type, ref.getOid(), null, result).asObjectable();
  }
예제 #9
0
 @Override
 public <F extends FocusType> PrismObject<F> searchShadowOwner(
     String shadowOid,
     Collection<SelectorOptions<GetOperationOptions>> options,
     OperationResult parentResult)
     throws ObjectNotFoundException {
   // TODO cache the search operation?
   PrismObject<F> ownerObject = repository.searchShadowOwner(shadowOid, options, parentResult);
   if (ownerObject != null && nullOrHarmlessOptions(options)) {
     cacheObject(getCache(), ownerObject);
   }
   return ownerObject;
 }
예제 #10
0
 /* (non-Javadoc)
  * @see com.evolveum.midpoint.repo.api.RepositoryService#getVersion(java.lang.Class, java.lang.String, com.evolveum.midpoint.schema.result.OperationResult)
  */
 @Override
 public <T extends ObjectType> String getVersion(
     Class<T> type, String oid, OperationResult parentResult)
     throws ObjectNotFoundException, SchemaException {
   if (!isCacheable(type)) {
     log("Cache: PASS {} ({})", oid, type.getSimpleName());
     return repository.getVersion(type, oid, parentResult);
   }
   Cache cache = getCache();
   if (cache == null) {
     log("Cache: NULL {} ({})", oid, type.getSimpleName());
   } else {
     String version = cache.getObjectVersion(oid);
     if (version != null) {
       log("Cache: HIT {} ({})", oid, type.getSimpleName());
       return version;
     }
     log("Cache: MISS {} ({})", oid, type.getSimpleName());
   }
   String version = repository.getVersion(type, oid, parentResult);
   cacheObjectVersion(cache, oid, version);
   return version;
 }
예제 #11
0
 @Override
 public <T extends ObjectType> void modifyObject(
     Class<T> type,
     String oid,
     Collection<? extends ItemDelta> modifications,
     OperationResult parentResult)
     throws ObjectNotFoundException, SchemaException, ObjectAlreadyExistsException {
   repository.modifyObject(type, oid, modifications, parentResult);
   // this changes the object. We are too lazy to apply changes ourselves, so just invalidate
   // the object in cache
   Cache cache = getCache();
   if (cache != null) {
     cache.removeObject(oid);
     cache.clearQueryResults(type);
   }
 }
예제 #12
0
 @Override
 public <T extends ObjectType> String addObject(
     PrismObject<T> object, RepoAddOptions options, OperationResult parentResult)
     throws ObjectAlreadyExistsException, SchemaException {
   String oid = repository.addObject(object, options, parentResult);
   Cache cache = getCache();
   // DON't cache the object here. The object may not have proper "JAXB" form, e.g. some pieces may
   // be
   // DOM element instead of JAXB elements. Not to cache it is safer and the performance loss
   // is acceptable.
   if (cache != null) {
     // Invalidate the cache entry if it happens to be there
     cache.removeObject(oid);
     cache.clearQueryResults(object.getCompileTimeClass());
   }
   return oid;
 }
예제 #13
0
 /* (non-Javadoc)
  * @see com.evolveum.midpoint.repo.api.RepositoryService#searchObjectsIterative(java.lang.Class, com.evolveum.midpoint.prism.query.ObjectQuery, com.evolveum.midpoint.schema.ResultHandler, com.evolveum.midpoint.schema.result.OperationResult)
  */
 @Override
 public <T extends ObjectType> SearchResultMetadata searchObjectsIterative(
     Class<T> type,
     ObjectQuery query,
     final ResultHandler<T> handler,
     Collection<SelectorOptions<GetOperationOptions>> options,
     OperationResult parentResult)
     throws SchemaException {
   // TODO use cached query result if applicable
   log("Cache: PASS searchObjectsIterative ({})", type.getSimpleName());
   final Cache cache = getCache();
   ResultHandler<T> myHandler =
       new ResultHandler<T>() {
         @Override
         public boolean handle(PrismObject<T> object, OperationResult parentResult) {
           cacheObject(cache, object);
           return handler.handle(object, parentResult);
         }
       };
   return repository.searchObjectsIterative(type, query, myHandler, options, parentResult);
 }
예제 #14
0
 @Override
 public boolean isAnySubordinate(String upperOrgOid, Collection<String> lowerObjectOids)
     throws SchemaException {
   return repository.isAnySubordinate(upperOrgOid, lowerObjectOids);
 }
예제 #15
0
 @Override
 public void testOrgClosureConsistency(boolean repairIfNecessary, OperationResult testResult) {
   repository.testOrgClosureConsistency(repairIfNecessary, testResult);
 }
예제 #16
0
 /* (non-Javadoc)
  * @see com.evolveum.midpoint.repo.api.RepositoryService#repositorySelfTest(com.evolveum.midpoint.schema.result.OperationResult)
  */
 @Override
 public void repositorySelfTest(OperationResult parentResult) {
   repository.repositorySelfTest(parentResult);
 }
예제 #17
0
 /* (non-Javadoc)
  * @see com.evolveum.midpoint.repo.api.RepositoryService#getRepositoryDiag()
  */
 @Override
 public RepositoryDiag getRepositoryDiag() {
   return repository.getRepositoryDiag();
 }
  private void repositorySelfTestUser(Task task, OperationResult testResult) {
    OperationResult result = testResult.createSubresult(REPOSITORY_SELF_TEST_USER);

    PrismObject<UserType> user = getObjectDefinition(UserType.class).instantiate();
    UserType userType = user.asObjectable();

    String name = generateRandomName();
    PolyStringType namePolyStringType = toPolyStringType(name);
    userType.setName(namePolyStringType);
    result.addContext("name", name);
    userType.setDescription(SelfTestData.POLICIJA);
    userType.setFullName(toPolyStringType(USER_FULL_NAME));
    userType.setGivenName(toPolyStringType(USER_GIVEN_NAME));
    userType.setFamilyName(toPolyStringType(USER_FAMILY_NAME));
    userType.setTitle(toPolyStringType(INSANE_NATIONAL_STRING));
    userType.getEmployeeType().add(USER_EMPLOYEE_TYPE[0]);
    userType.getEmployeeType().add(USER_EMPLOYEE_TYPE[1]);
    userType.getOrganization().add(toPolyStringType(USER_ORGANIZATION[0]));
    userType.getOrganization().add(toPolyStringType(USER_ORGANIZATION[1]));

    String oid;
    try {
      oid = repositoryService.addObject(user, null, result);
    } catch (ObjectAlreadyExistsException e) {
      result.recordFatalError(e);
      return;
    } catch (SchemaException e) {
      result.recordFatalError(e);
      return;
    } catch (RuntimeException e) {
      result.recordFatalError(e);
      return;
    }

    try {

      {
        OperationResult subresult = result.createSubresult(result.getOperation() + ".getObject");

        PrismObject<UserType> userRetrieved;
        try {
          userRetrieved = repositoryService.getObject(UserType.class, oid, null, subresult);
        } catch (ObjectNotFoundException e) {
          result.recordFatalError(e);
          return;
        } catch (SchemaException e) {
          result.recordFatalError(e);
          return;
        } catch (RuntimeException e) {
          result.recordFatalError(e);
          return;
        }

        if (LOGGER.isTraceEnabled()) {
          LOGGER.trace("Self-test:user getObject:\n{}", userRetrieved.debugDump());
        }

        checkUser(userRetrieved, name, subresult);

        subresult.recordSuccessIfUnknown();
      }

      {
        OperationResult subresult =
            result.createSubresult(result.getOperation() + ".searchObjects.fullName");
        try {

          ObjectQuery query = new ObjectQuery();
          ObjectFilter filter =
              EqualFilter.createEqual(
                  UserType.F_FULL_NAME,
                  UserType.class,
                  prismContext,
                  null,
                  toPolyString(USER_FULL_NAME));
          query.setFilter(filter);
          subresult.addParam("query", query);
          List<PrismObject<UserType>> foundObjects =
              repositoryService.searchObjects(UserType.class, query, null, subresult);
          if (LOGGER.isTraceEnabled()) {
            LOGGER.trace("Self-test:user searchObjects:\n{}", DebugUtil.debugDump(foundObjects));
          }
          assertSingleSearchResult("user", foundObjects, subresult);

          PrismObject<UserType> userRetrieved = foundObjects.iterator().next();
          checkUser(userRetrieved, name, subresult);

          subresult.recordSuccessIfUnknown();
        } catch (SchemaException e) {
          subresult.recordFatalError(e);
          return;
        } catch (RuntimeException e) {
          subresult.recordFatalError(e);
          return;
        }
      }

      // MID-1116
      {
        OperationResult subresult =
            result.createSubresult(result.getOperation() + ".searchObjects.employeeType");
        try {

          ObjectQuery query = new ObjectQuery();
          ObjectFilter filter =
              EqualFilter.createEqual(
                  UserType.F_EMPLOYEE_TYPE,
                  UserType.class,
                  prismContext,
                  null,
                  USER_EMPLOYEE_TYPE[0]);
          query.setFilter(filter);
          subresult.addParam("query", query);
          List<PrismObject<UserType>> foundObjects =
              repositoryService.searchObjects(UserType.class, query, null, subresult);
          if (LOGGER.isTraceEnabled()) {
            LOGGER.trace("Self-test:user searchObjects:\n{}", DebugUtil.debugDump(foundObjects));
          }
          assertSingleSearchResult("user", foundObjects, subresult);

          PrismObject<UserType> userRetrieved = foundObjects.iterator().next();
          checkUser(userRetrieved, name, subresult);

          subresult.recordSuccessIfUnknown();
        } catch (SchemaException e) {
          subresult.recordFatalError(e);
          return;
        } catch (RuntimeException e) {
          subresult.recordFatalError(e);
          return;
        }
      }

      // MID-1116
      {
        OperationResult subresult =
            result.createSubresult(result.getOperation() + ".searchObjects.organization");
        try {

          ObjectQuery query = new ObjectQuery();
          ObjectFilter filter =
              EqualFilter.createEqual(
                  UserType.F_ORGANIZATION,
                  UserType.class,
                  prismContext,
                  null,
                  toPolyString(USER_ORGANIZATION[1]));
          query.setFilter(filter);
          subresult.addParam("query", query);
          List<PrismObject<UserType>> foundObjects =
              repositoryService.searchObjects(UserType.class, query, null, subresult);
          if (LOGGER.isTraceEnabled()) {
            LOGGER.trace("Self-test:user searchObjects:\n{}", DebugUtil.debugDump(foundObjects));
          }
          assertSingleSearchResult("user", foundObjects, subresult);

          PrismObject<UserType> userRetrieved = foundObjects.iterator().next();
          checkUser(userRetrieved, name, subresult);

          subresult.recordSuccessIfUnknown();
        } catch (SchemaException e) {
          subresult.recordFatalError(e);
          return;
        } catch (RuntimeException e) {
          subresult.recordFatalError(e);
          return;
        }
      }

    } finally {

      try {
        repositoryService.deleteObject(UserType.class, oid, testResult);
      } catch (ObjectNotFoundException e) {
        result.recordFatalError(e);
        return;
      } catch (RuntimeException e) {
        result.recordFatalError(e);
        return;
      }

      result.computeStatus();
    }
  }
 /* (non-Javadoc)
  * @see com.evolveum.midpoint.model.api.ModelDiagnosticService#getRepositoryDiag(com.evolveum.midpoint.task.api.Task, com.evolveum.midpoint.schema.result.OperationResult)
  */
 @Override
 public RepositoryDiag getRepositoryDiag(Task task, OperationResult parentResult) {
   return repositoryService.getRepositoryDiag();
 }
예제 #20
0
 @Override
 @Deprecated
 public PrismObject<UserType> listAccountShadowOwner(
     String accountOid, OperationResult parentResult) throws ObjectNotFoundException {
   return repository.listAccountShadowOwner(accountOid, parentResult);
 }