public static <T extends CapabilityType> T getEffectiveCapability(CapabilitiesType capabilitiesType, Class<T> capabilityClass) { if (capabilitiesType == null) { return null; } if (capabilitiesType.getConfigured() != null) { T configuredCapability = CapabilityUtil.getCapability(capabilitiesType.getConfigured().getAny(), capabilityClass); if (configuredCapability != null) { return configuredCapability; } // No configured capability entry, fallback to native capability } if (capabilitiesType.getNative() != null) { T nativeCapability = CapabilityUtil.getCapability(capabilitiesType.getNative().getAny(), capabilityClass); if (nativeCapability != null) { return nativeCapability; } } return null; }
/** * Create an instance of {@link CapabilitiesType } * */ public CapabilitiesType createCapabilitiesType() { return new CapabilitiesType(); }
public CapabilitiesType clone() { CapabilitiesType object = new CapabilitiesType(); PrismContainerValue value = asPrismContainerValue().clone(); object.setupContainerValue(value); return object; }
@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; }
assertNotNull("Missing capability caching metadata", capabilities.getCachingMetadata()); CapabilityCollectionType nativeCapabilities = capabilities.getNative(); List<Object> nativeCapabilitiesList = nativeCapabilities.getAny(); assertFalse("Empty capabilities returned",nativeCapabilitiesList.isEmpty());
throws ObjectNotFoundException, SchemaException, CommunicationException, ConfigurationException { if (capType.getNative() != null && !capType.getNative().getAny().isEmpty()) { if (!forceRefresh) { CachingMetadataType cachingMetadata = capType.getCachingMetadata(); if (cachingMetadata == null) { cachingMetadata = MiscSchemaUtil.generateCachingMetadata(); capType.setNative(nativeCapType); nativeCapType.getAny().addAll(retrievedCapabilities); capType.setCachingMetadata(cachingMetadata); itemPath, capType.asPrismContainerValue().clone());
CapabilityCollectionType nativeCapabilities = resourceType.getCapabilities().getNative(); display("Native capabilities", PrismTestUtil.serializeAnyDataWrapped(nativeCapabilities)); display("Resource", resourceType); assertRunAsCapability(capRunAs); capabilitiesCachingMetadataType = resourceType.getCapabilities().getCachingMetadata(); assertNotNull("No capabilities caching metadata", capabilitiesCachingMetadataType); assertNotNull("No capabilities caching metadata timestamp", capabilitiesCachingMetadataType.getRetrievalTimestamp()); CapabilityCollectionType configuredCapabilities = resourceType.getCapabilities().getConfigured(); if (configuredCapabilities == null) { assertCountConfiguredCapability(null);
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; }
@Override public boolean equals(Object object) { if (!(object instanceof CapabilitiesType)) { return false; } CapabilitiesType other = ((CapabilitiesType) object); return asPrismContainerValue().equivalent(other.asPrismContainerValue()); }
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 CapabilitiesType cachingMetadata(CachingMetadataType value) { setCachingMetadata(value); return this; }
public CapabilitiesType _native(CapabilityCollectionType value) { setNative(value); return this; }
public static <T extends CapabilityType> boolean hasNativeCapability(CapabilitiesType capabilities, Class<T> capabilityClass) { if (capabilities == null) { return false; } CapabilityCollectionType nativeCaps = capabilities.getNative(); if (nativeCaps == null) { return false; } return getCapability(nativeCaps.getAny(), capabilityClass) != null; } }
if (initialized || nativeCapabilitiesEntered()) { AssertJUnit.assertNotNull("Native capabilities missing before test connection. Bad test setup?", capabilitiesBefore); AssertJUnit.assertNotNull("Native capabilities missing before test connection. Bad test setup?", capabilitiesBefore.getNative()); } else { if (capabilitiesBefore != null) { AssertJUnit.assertNull("Native capabilities present before test connection. Bad test setup?", capabilitiesBefore.getNative()); AssertJUnit.assertNotNull("Native capabilities missing after test connection.", capabilitiesRepoAfter.getNative()); AssertJUnit.assertNotNull("Capabilities caching metadata missing after test connection.", capabilitiesRepoAfter.getCachingMetadata()); AssertJUnit.assertNotNull("Native capabilities missing after test connection (model)", capabilitiesModelAfter.getNative()); AssertJUnit.assertNotNull("Capabilities caching metadata missing after test connection (model)", capabilitiesModelAfter.getCachingMetadata());
private <T extends CapabilityType> boolean supportsCapability(ConnectorInstanceSpecificationType additionalConnectorType, Collection<Object> nativeCapabilities, Class<T> capabilityClass) { CapabilitiesType specifiedCapabilitiesType = additionalConnectorType.getCapabilities(); if (specifiedCapabilitiesType != null) { CapabilityCollectionType configuredCapCollectionType = specifiedCapabilitiesType.getConfigured(); if (configuredCapCollectionType != null) { T configuredCap = CapabilityUtil.getCapability(configuredCapCollectionType.getAny(), capabilityClass); if (configuredCap != null && !CapabilityUtil.isCapabilityEnabled(configuredCap)) { return false; } } } T cap = CapabilityUtil.getCapability(nativeCapabilities, capabilityClass); if (cap == null) { return false; } return CapabilityUtil.isCapabilityEnabled(cap); }
@Override public int hashCode() { return asPrismContainerValue().hashCode(); }
CachingMetadataType capCachingMetadataType = capabilitiesType.getCachingMetadata(); assertNotNull("No capabilities caching metadata fetched from provisioning", capCachingMetadataType); CachingMetadataType capCachingMetadataTypeAgain = resourceTypeAgain.getCapabilities().getCachingMetadata(); assertEquals("Capabilities caching metadata serial number has changed", capCachingMetadataType.getSerialNumber(), capCachingMetadataTypeAgain.getSerialNumber());
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; }
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; }
CapabilitiesType capabilitiesRepoAfter = resourceTypeRepoAfter.getCapabilities(); AssertJUnit.assertNotNull("Capabilities missing after test connection.", capabilitiesRepoAfter); AssertJUnit.assertNotNull("Native capabilities missing after test connection.", capabilitiesRepoAfter.getNative()); AssertJUnit.assertNotNull("Capabilities caching metadata missing after test connection.", capabilitiesRepoAfter.getCachingMetadata()); AssertJUnit.assertNotNull("Native capabilities missing after test connection (model)", capabilitiesModelAfter.getNative()); AssertJUnit.assertNotNull("Capabilities caching metadata missing after test connection (model)", capabilitiesModelAfter.getCachingMetadata());