@NotNull public static Collection<Class<? extends CapabilityType>> getNativeCapabilityClasses(ResourceType resource) { Set<Class<? extends CapabilityType>> rv = new HashSet<>(); if (resource.getCapabilities() == null || resource.getCapabilities().getNative() == null) { return rv; } for (Object o : resource.getCapabilities().getNative().getAny()) { rv.add(CapabilityUtil.asCapabilityType(o).getClass()); } return rv; }
/** * Returns collection of capabilities. Note: there is difference between empty set and null. * Empty set means that we know the resource has no capabilities. Null means that the * capabilities were not yet determined. */ public static Collection<Object> getNativeCapabilitiesCollection(ResourceType resource) { if (resource.getCapabilities() == null) { // No capabilities, not initialized return null; } CapabilityCollectionType nativeCap = resource.getCapabilities().getNative(); if (nativeCap == null) { return null; } return nativeCap.getAny(); }
public static boolean hasResourceConfiguredActivationCapability(ResourceType resource) { if (resource.getCapabilities() == null) { return false; } if (resource.getCapabilities().getConfigured() != null) { ActivationCapabilityType configuredCapability = CapabilityUtil.getCapability(resource.getCapabilities().getConfigured().getAny(), ActivationCapabilityType.class); if (configuredCapability != null) { return true; } // No configured capability entry, fallback to native capability } return false; }
public static boolean hasResourceNativeActivationCapability(ResourceType resource) { ActivationCapabilityType activationCapability = null; // check resource native capabilities. if resource cannot do // activation, it sholud be null.. if (resource.getCapabilities() != null && resource.getCapabilities().getNative() != null) { activationCapability = CapabilityUtil.getCapability(resource.getCapabilities().getNative().getAny(), ActivationCapabilityType.class); } if (activationCapability == null) { return false; } return true; }
public static boolean hasResourceNativeActivationLockoutCapability(ResourceType resource) { ActivationCapabilityType activationCapability = null; // check resource native capabilities. if resource cannot do // activation, it sholud be null.. if (resource.getCapabilities() != null && resource.getCapabilities().getNative() != null) { activationCapability = CapabilityUtil.getCapability(resource.getCapabilities().getNative().getAny(), ActivationCapabilityType.class); } return CapabilityUtil.getEffectiveActivationLockoutStatus(activationCapability) != null; }
public static boolean hasResourceNativeActivationStatusCapability(ResourceType resource) { ActivationCapabilityType activationCapability = null; if (resource.getCapabilities() != null && resource.getCapabilities().getNative() != null) { activationCapability = CapabilityUtil.getCapability(resource.getCapabilities().getNative().getAny(), ActivationCapabilityType.class); } return CapabilityUtil.getEffectiveActivationStatus(activationCapability) != null; }
private static List<Object> getEffectiveCapabilities(ResourceType resource, boolean includeDisabled) throws SchemaException { List<Object> rv = new ArrayList<>(); if (resource.getCapabilities() == null) { return rv; } List<Object> configuredCaps = resource.getCapabilities().getConfigured() != null ? resource.getCapabilities().getConfigured().getAny() : Collections.emptyList(); List<Object> nativeCaps = resource.getCapabilities().getNative() != null ? resource.getCapabilities().getNative().getAny() : Collections.emptyList(); for (Object configuredCapability : configuredCaps) { if (includeDisabled || CapabilityUtil.isCapabilityEnabled(configuredCapability)) { rv.add(configuredCapability); } } for (Object nativeCapability: nativeCaps) { if (!CapabilityUtil.containsCapabilityWithSameElementName(configuredCaps, nativeCapability)) { if (includeDisabled || CapabilityUtil.isCapabilityEnabled(nativeCapability)) { rv.add(nativeCapability); } } } return rv; }
/** * Explicitly check the capability of the resource (primary connector), not capabilities of additional connectors */ public static boolean isPrimaryCachingOnly(ResourceType resource) { ReadCapabilityType readCapabilityType = CapabilityUtil.getEffectiveCapability(resource.getCapabilities(), ReadCapabilityType.class); if (readCapabilityType == null) { return false; } if (!CapabilityUtil.isCapabilityEnabled(readCapabilityType)) { return false; } return Boolean.TRUE.equals(readCapabilityType.isCachingOnly()); }
private boolean isComplete(PrismObject<ResourceType> resource) { ResourceType resourceType = resource.asObjectable(); Element xsdSchema = ResourceTypeUtil.getResourceXsdSchema(resource); if (xsdSchema == null) { return false; } CapabilitiesType capabilitiesType = resourceType.getCapabilities(); if (capabilitiesType == null) { return false; } CachingMetadataType capCachingMetadata = capabilitiesType.getCachingMetadata(); if (capCachingMetadata == null) { return false; } return true; }
public <T extends CapabilityType> CapabilitiesType getConnectorCapabilities(PrismObject<ResourceType> resource, Class<T> operationCapabilityClass) { for (ConnectorInstanceSpecificationType additionalConnectorType: resource.asObjectable().getAdditionalConnector()) { if (supportsCapability(additionalConnectorType, operationCapabilityClass)) { return additionalConnectorType.getCapabilities(); } } return resource.asObjectable().getCapabilities(); }
private void assertCapabilities(ResourceType resourceType) throws SchemaException { if (resourceType.getCapabilities() != null) { if (resourceType.getCapabilities().getNative() != null) { for (Object capability : resourceType.getCapabilities().getNative().getAny()) { System.out.println("Native Capability: "+CapabilityUtil.getCapabilityDisplayName(capability)+" : "+capability); if (resourceType.getCapabilities().getConfigured() != null) { for (Object capability : resourceType.getCapabilities().getConfigured().getAny()) { System.out.println("Configured Capability: "+CapabilityUtil.getCapabilityDisplayName(capability)+" : "+capability); assertNotNull("null native capabilities", resourceType.getCapabilities().getNative()); assertFalse("empty native capabilities", resourceType.getCapabilities().getNative().getAny().isEmpty()); assertEquals("Unexepected number of native capabilities", 3, resourceType.getCapabilities().getNative().getAny().size()); assertNotNull("null configured capabilities", resourceType.getCapabilities().getConfigured()); assertFalse("empty configured capabilities", resourceType.getCapabilities().getConfigured().getAny().isEmpty()); assertEquals("Unexepected number of configured capabilities", 2, resourceType.getCapabilities().getConfigured().getAny().size());
private static <T extends CapabilityType> T getEffectiveCapabilityInternal(ResourceType resource, ResourceObjectTypeDefinitionType resourceObjectTypeDefinitionType, Class<T> capabilityClass) { if (resourceObjectTypeDefinitionType != null && resourceObjectTypeDefinitionType.getConfiguredCapabilities() != null) { T configuredCapability = CapabilityUtil.getCapability(resourceObjectTypeDefinitionType.getConfiguredCapabilities().getAny(), capabilityClass); if (configuredCapability != null) { return configuredCapability; } // No capability at the level of resource object type, continuing at the resource level } for (ConnectorInstanceSpecificationType additionalConnector: resource.getAdditionalConnector()) { T connectorCapability = CapabilityUtil.getEffectiveCapability(additionalConnector.getCapabilities(), capabilityClass); if (CapabilityUtil.isCapabilityEnabled(connectorCapability)) { return connectorCapability; } } return CapabilityUtil.getEffectiveCapability(resource.getCapabilities(), capabilityClass); }
private void completeCapabilities(PrismObject<ResourceType> resource, boolean forceRefresh, Map<String,Collection<Object>> capabilityMap, Collection<ItemDelta<?, ?>> modifications, OperationResult result) throws SchemaException, ObjectNotFoundException, CommunicationException, ConfigurationException { ResourceType resourceType = resource.asObjectable(); ConnectorSpec defaultConnectorSpec = getDefaultConnectorSpec(resource); CapabilitiesType resourceCapType = resourceType.getCapabilities(); if (resourceCapType == null) { resourceCapType = new CapabilitiesType(); resourceType.setCapabilities(resourceCapType); } completeConnectorCapabilities(defaultConnectorSpec, resourceCapType, ResourceType.F_CAPABILITIES, forceRefresh, capabilityMap==null?null:capabilityMap.get(null), modifications, result); for (ConnectorInstanceSpecificationType additionalConnectorType: resource.asObjectable().getAdditionalConnector()) { ConnectorSpec connectorSpec = getConnectorSpec(resource, additionalConnectorType); CapabilitiesType connectorCapType = additionalConnectorType.getCapabilities(); if (connectorCapType == null) { connectorCapType = new CapabilitiesType(); additionalConnectorType.setCapabilities(connectorCapType); } ItemPath itemPath = additionalConnectorType.asPrismContainerValue().getPath().append(ConnectorInstanceSpecificationType.F_CAPABILITIES); completeConnectorCapabilities(connectorSpec, connectorCapType, itemPath, forceRefresh, capabilityMap==null?null:capabilityMap.get(additionalConnectorType.getName()), modifications, result); } }
/** * Checks if the resource is internally consistent, if it has everything it should have. * * @throws SchemaException */ private void checkOpenDjResource(ResourceType resource, String source) throws SchemaException { assertNotNull("Resource from " + source + " is null", resource); ObjectReferenceType connectorRefType = resource.getConnectorRef(); assertNotNull("Resource from " + source + " has null connectorRef", connectorRefType); assertFalse("Resource from " + source + " has no OID in connectorRef", StringUtils.isBlank(connectorRefType.getOid())); assertNotNull("Resource from " + source + " has null description in connectorRef", connectorRefType.getDescription()); assertNotNull("Resource from " + source + " has null filter in connectorRef", connectorRefType.getFilter()); assertNotNull("Resource from " + source + " has null filter element in connectorRef", connectorRefType.getFilter().getFilterClauseXNode()); assertNotNull("Resource from " + source + " has null configuration", resource.getConnectorConfiguration()); assertNotNull("Resource from " + source + " has null schema", resource.getSchema()); checkOpenDjSchema(resource, source); assertNotNull("Resource from " + source + " has null schemahandling", resource.getSchemaHandling()); checkOpenDjSchemaHandling(resource, source); if (!source.equals("repository")) { // This is generated on the fly in provisioning assertNotNull("Resource from " + source + " has null nativeCapabilities", resource.getCapabilities().getNative()); assertFalse("Resource from " + source + " has empty nativeCapabilities", resource.getCapabilities().getNative().getAny().isEmpty()); } assertNotNull("Resource from " + source + " has null configured capabilities", resource.getCapabilities().getConfigured()); assertFalse("Resource from " + source + " has empty capabilities", resource.getCapabilities().getConfigured().getAny().isEmpty()); assertNotNull("Resource from " + source + " has null synchronization", resource.getSynchronization()); checkOpenDjConfiguration(resource.asPrismObject(), source); }
@Test public void test006Capabilities() throws Exception { final String TEST_NAME = "test006Capabilities"; TestUtil.displayTestTitle(TEST_NAME); // GIVEN OperationResult result = new OperationResult(TestOpenDj.class.getName()+"."+TEST_NAME); // WHEN ResourceType resource = provisioningService.getObject(ResourceType.class, getResourceOid(), null, null, result).asObjectable(); // THEN display("Resource from provisioninig", resource); display("Resource from provisioninig (XML)", PrismTestUtil.serializeObjectToString(resource.asPrismObject(), PrismContext.LANG_XML)); CapabilityCollectionType nativeCapabilities = resource.getCapabilities().getNative(); List<Object> nativeCapabilitiesList = nativeCapabilities.getAny(); assertFalse("Empty capabilities returned",nativeCapabilitiesList.isEmpty()); // Connector cannot do activation, this should be null ActivationCapabilityType capAct = CapabilityUtil.getCapability(nativeCapabilitiesList, ActivationCapabilityType.class); assertNull("Found activation capability while not expecting it" ,capAct); ScriptCapabilityType capScript = CapabilityUtil.getCapability(nativeCapabilitiesList, ScriptCapabilityType.class); assertNotNull("No script capability", capScript); List<Host> scriptHosts = capScript.getHost(); assertEquals("Wrong number of script hosts", 2, scriptHosts.size()); assertScriptHost(capScript, ProvisioningScriptHostType.CONNECTOR); assertScriptHost(capScript, ProvisioningScriptHostType.RESOURCE); List<Object> effectiveCapabilities = ResourceTypeUtil.getEffectiveCapabilities(resource); for (Object capability : effectiveCapabilities) { System.out.println("Capability: "+CapabilityUtil.getCapabilityDisplayName(capability)+" : "+capability); } }
@Test public void test006Capabilities() throws Exception { final String TEST_NAME = "test006Capabilities"; TestUtil.displayTestTitle(TEST_NAME); // GIVEN OperationResult result = new OperationResult(TestOpenDj.class.getName()+"."+TEST_NAME); // WHEN ResourceType resource = provisioningService.getObject(ResourceType.class, getResourceOid(), null, null, result).asObjectable(); // THEN display("Resource from provisioninig", resource); display("Resource from provisioninig (XML)", PrismTestUtil.serializeObjectToString(resource.asPrismObject(), PrismContext.LANG_XML)); CapabilityCollectionType nativeCapabilities = resource.getCapabilities().getNative(); List<Object> nativeCapabilitiesList = nativeCapabilities.getAny(); assertFalse("Empty capabilities returned",nativeCapabilitiesList.isEmpty()); CreateCapabilityType capCreate = CapabilityUtil.getCapability(nativeCapabilitiesList, CreateCapabilityType.class); assertNotNull("Missing create capability", capCreate); assertManual(capCreate); ActivationCapabilityType capAct = CapabilityUtil.getCapability(nativeCapabilitiesList, ActivationCapabilityType.class); assertNotNull("Missing activation capability", capAct); ReadCapabilityType capRead = CapabilityUtil.getCapability(nativeCapabilitiesList, ReadCapabilityType.class); assertNotNull("Missing read capability" ,capRead); assertEquals("Wrong caching-only setting in read capability", Boolean.TRUE, capRead.isCachingOnly()); List<Object> effectiveCapabilities = ResourceTypeUtil.getEffectiveCapabilities(resource); for (Object capability : effectiveCapabilities) { System.out.println("Capability: "+CapabilityUtil.getCapabilityDisplayName(capability)+" : "+capability); } }
@Test public void test010Sanity() throws Exception { final String TEST_NAME = "test010Sanity"; TestUtil.displayTestTitle(TEST_NAME); final OperationResult result = new OperationResult(TestSynchronization.class.getName() + "." + TEST_NAME); // WHEN PrismObject<ResourceType> resource = provisioningService.getObject(ResourceType.class, resourceType.getOid(), null, taskManager.createTaskInstance(), result); // THEN assertNotNull("Resource is null", resource); display("getObject(resource)", resource); result.computeStatus(); display("getObject(resource) result", result); TestUtil.assertSuccess(result); // Make sure these were generated assertNotNull("No resource schema", resource.asObjectable().getSchema()); assertNotNull("No native capabilities", resource.asObjectable().getCapabilities().getNative()); Task syncTask = taskManager.getTask(SYNC_TASK_OID, result); AssertJUnit.assertNotNull(syncTask); assertSyncToken(syncTask, 0, result); }
CapabilitiesType capabilities = resource.getCapabilities(); assertNotNull("Missing capability caching metadata", capabilities.getCachingMetadata());
@Test public void test001Connection() throws Exception { final String TEST_NAME = "test001Connection"; TestUtil.displayTestTitle(TEST_NAME); Task task = createTask(TEST_NAME); OperationResult result = task.getResult(); // WHEN OperationResult testResult = provisioningService.testResource(RESOURCE_DERBY_OID, task); display("Test result",testResult); TestUtil.assertSuccess("Test resource failed (result)", testResult); ResourceType resource = repositoryService.getObject(ResourceType.class, RESOURCE_DERBY_OID, null, result).asObjectable(); display("Resource after test",resource); display("Resource after test (XML)", PrismTestUtil.serializeObjectToString(resource.asPrismObject(), PrismContext.LANG_XML)); List<Object> nativeCapabilities = resource.getCapabilities().getNative().getAny(); CredentialsCapabilityType credentialsCapabilityType = CapabilityUtil.getCapability(nativeCapabilities, CredentialsCapabilityType.class); assertNotNull("No credentials capability", credentialsCapabilityType); PasswordCapabilityType passwordCapabilityType = credentialsCapabilityType.getPassword(); assertNotNull("No password in credentials capability", passwordCapabilityType); assertEquals("Wrong password capability ReturnedByDefault", Boolean.FALSE, passwordCapabilityType.isReturnedByDefault()); }
assertNotNull("no capabilities", resourceAfterAdd.asObjectable().getCapabilities()); assertNull("capabilities not gone", resourceAfterOverwrite.asObjectable().getCapabilities());