Class AttributeResolverImpl

All Implemented Interfaces:
AttributeResolver, Component, DestructableComponent, IdentifiableComponent, IdentifiedComponent, InitializableComponent, ServiceableComponent<AttributeResolver>, Aware, ApplicationContextAware

@ThreadSafe
public class AttributeResolverImpl
extends AbstractServiceableComponent<AttributeResolver>
implements AttributeResolver
A component that resolves the attributes for a particular subject. Note WellThis class is about attribute resolution, that is to say the summoning up of attributes in response to the exigies of the provided context. It does not implement Resolver which in about summoning up bits of generic data from the configuration (usually the metadata) in response to specific Criterions.
  • Field Details

  • Constructor Details

    • AttributeResolverImpl

      public AttributeResolverImpl()
      Constructor.
  • Method Details

    • setAttributeDefinitions

      public void setAttributeDefinitions​(@Nonnull @NonnullElements Collection<AttributeDefinition> definitions)
      Sets the attribute definitions for this resolver.
      Parameters:
      definitions - attribute definitions loaded in to this resolver
    • getAttributeDefinitions

      @Nonnull @NonnullElements @Unmodifiable public Map<String,​AttributeDefinition> getAttributeDefinitions()
      Gets the collection of attribute definitions for this resolver.
      Returns:
      attribute definitions loaded in to this resolver
    • setDataConnectors

      public void setDataConnectors​(@Nonnull @NonnullElements Collection<DataConnector> connectors)
      Sets the data connectors for this resolver.
      Parameters:
      connectors - data connectors loaded in to this resolver
    • getDataConnectors

      @Nonnull @NonnullElements @Unmodifiable public Map<String,​DataConnector> getDataConnectors()
      Gets the unmodifiable collection of data connectors for this resolver.
      Returns:
      data connectors loaded in to this resolver
    • isStripNulls

      public boolean isStripNulls()
      Do we strip nulls from attribute values.
      Returns:
      Returns whether to strip nulls from attribute values
    • setStripNulls

      public void setStripNulls​(Boolean doStripNulls)
      Sets whether to strip nulls from attribute values.
      Parameters:
      doStripNulls - what to set
    • setProfileContextLookupStrategy

      public void setProfileContextLookupStrategy​(@Nonnull Function<AttributeResolutionContext,​ProfileRequestContext> strategy)
      Set the mechanism to obtain the ProfileRequestContext.
      Parameters:
      strategy - lookup strategy
    • resolveAttributes

      public void resolveAttributes​(@Nonnull AttributeResolutionContext resolutionContext) throws ResolutionException
      Resolves the attribute for the given request. Note, if attributes are requested, AttributeResolutionContext.getRequestedIdPAttributeNames(), the resolver will not fail if they can not be resolved. This information serves only as a hint to the resolver to, potentially, optimize the resolution of attributes.
      Specified by:
      resolveAttributes in interface AttributeResolver
      Parameters:
      resolutionContext - the attribute resolution context that identifies the request subject and accumulates the resolved attributes
      Throws:
      ResolutionException - thrown if there is a problem resolving the attributes for the subject
    • getToBeResolvedAttributeIds

      @Nonnull @NonnullElements protected Collection<String> getToBeResolvedAttributeIds​(@Nonnull AttributeResolutionContext resolutionContext)
      Gets the list of attributes, identified by IDs, that should be resolved. If the AttributeResolutionContext.getRequestedIdPAttributeNames() is not empty then those attributes are the ones to be resolved, otherwise all registered attribute definitions are to be resolved.
      Parameters:
      resolutionContext - current resolution context
      Returns:
      list of attributes, identified by IDs, that should be resolved
    • resolveAttributeDefinition

      protected void resolveAttributeDefinition​(@Nonnull String attributeId, @Nonnull AttributeResolutionContext resolutionContext) throws ResolutionException
      Resolve the AttributeDefinition which has the specified ID. The results of the resolution are stored in the given AttributeResolutionContext.
      Parameters:
      attributeId - id of the attribute definition to resolve
      resolutionContext - resolution context that we are working in
      Throws:
      ResolutionException - if unable to resolve the requested attribute definition
    • resolveDataConnector

      protected void resolveDataConnector​(@Nonnull String connectorId, @Nonnull AttributeResolutionContext resolutionContext) throws ResolutionException
      Resolve the DataConnector which has the specified ID. The results of the resolution are stored in the given AttributeResolutionContext.
      Parameters:
      connectorId - id of the data connector to resolve
      resolutionContext - resolution context that we are working in
      Throws:
      ResolutionException - if unable to resolve the requested connector
    • resolveDependencies

      protected void resolveDependencies​(@Nonnull ResolverPlugin<?> plugin, @Nonnull AttributeResolutionContext resolutionContext) throws ResolutionException
      Resolves all the dependencies for a given plugin.
      Parameters:
      plugin - plugin whose dependencies should be resolved
      resolutionContext - current resolution context
      Throws:
      ResolutionException - thrown if there is a problem resolving a dependency
    • filterAttributeValues

      @Nullable @NonnullElements private List<IdPAttributeValue> filterAttributeValues​(String attributeId, List<IdPAttributeValue> input)
      Helper method for exporting attributes.
      Parameters:
      attributeId - the if (for logging)
      input - the inout list
      Returns:
      a null stripped, or null list of values
    • collectResolvedAttributes

      private void collectResolvedAttributes​(Map<String,​IdPAttribute> resolvedAttributes, AttributeResolverWorkContext workContext, boolean includeDependencyOnly)
      Helper function to collect suitably resolved attributes.
      Parameters:
      resolvedAttributes - bucket to collect attributes into
      workContext - context to extract attributes from
      includeDependencyOnly - whether we include dependencyOnly attributes
    • collectExportingDataConnectors

      private void collectExportingDataConnectors​(Map<String,​IdPAttribute> resolvedAttributes, AttributeResolutionContext resolutionContext, AttributeResolverWorkContext workContext)
      Helper function to collect attributes and their data & metadata from suitable data connectors.
      Parameters:
      resolvedAttributes - bucket to collect attributes into
      resolutionContext - the context we are working in
      workContext - context to extract attributes from
    • finalizeResolvedAttributes

      protected void finalizeResolvedAttributes​(@Nonnull AttributeResolutionContext resolutionContext)
      Finalizes the set of resolved attributes and places them in the AttributeResolutionContext. The result of each AttributeDefinition resolution is inspected. If the result is not null, a dependency-only attribute, or an attribute that contains no values then it becomes part of the final set of resolved attributes.

      Then we handle attribute exports from DataConnectors.

      Values are also de-duplicated here, so that all the intermediate operations maintain the coherency of multi-valued result sets produced by data connectors.

      Parameters:
      resolutionContext - current resolution context
    • finalizePreResolvedAttributes

      protected void finalizePreResolvedAttributes​(@Nonnull AttributeResolutionContext resolutionContext)
      Collects the set of pre resolved attributes and places them in an AttributeContext which inserted as a child of the AttributeResolutionContext and also returned.

      Values are also de-duplicated here.

      Parameters:
      resolutionContext - current resolution context
    • doInitialize

      protected void doInitialize() throws ComponentInitializationException
      Overrides:
      doInitialize in class AbstractServiceableComponent<AttributeResolver>
      Throws:
      ComponentInitializationException
    • checkPlugInDependencies

      protected void checkPlugInDependencies​(String circularCheckPluginId, ResolverPlugin<?> plugin, Set<String> checkedPlugins) throws ComponentInitializationException
      Checks to ensure that there are no circular dependencies or dependencies on non-existent plugins.
      Parameters:
      circularCheckPluginId - the ID of the plugin currently being checked for circular dependencies
      plugin - current plugin, in the dependency tree of the plugin being checked, that we're currently looking at
      checkedPlugins - IDs of plugins that have already been checked and known to be good
      Throws:
      ComponentInitializationException - thrown if there is a dependency loop
    • getComponent

      @Nonnull public AttributeResolver getComponent()
      Specified by:
      getComponent in interface ServiceableComponent<AttributeResolver>
      Specified by:
      getComponent in class AbstractServiceableComponent<AttributeResolver>
    • startTimer

      private boolean startTimer​(@Nonnull AttributeResolutionContext resolutionContext)
      Conditionally start a timer at the beginning of the resolution process.
      Parameters:
      resolutionContext - attribute resolution context
      Returns:
      true iff the stopTimer(AttributeResolutionContext) method needs to be called
    • stopTimer

      private void stopTimer​(@Nonnull AttributeResolutionContext resolutionContext)
      Conditionally stop a timer at the end of the resolution process.
      Parameters:
      resolutionContext - attribute resolution context