Java 类net.sf.ehcache.search.Attribute 实例源码

/**
 * Use the Ehcache provided search API to perform criteria queries on defined search attributes.
 * NOTE: Requires search attributes to be previously defined in Ehcache config!
 * DEPRECATED because at observed large cache quantities the search noticeably slows down the system
 * @param params the search parameters as key/value pairs
 * @return the first found cache hit
 */
@Deprecated
@SuppressWarnings("unchecked")
public VALUE lookup(Map<String, String> params) {
    Query q = cache.createQuery();

    for (Map.Entry<String, String> param : params.entrySet()) {
        Attribute<String> theAttribute = ((Ehcache) cache).getSearchAttribute(param.getKey());
        q.addCriteria(theAttribute.eq(param.getValue()));
    }

    q.includeKeys().includeValues();
    Results results = q.execute();

    if (results == null || results.size() == 0) {
        return null;
    }

    if (results.size() > 1) {
        log.warn("There are multiple entries registered for params: {}", params.toString());
    }

    return (VALUE) results.all().get(0).getValue();
}

@Override
public List<Device> getByDeviceClassId(Long deviceClassId) {
  List<Device> deviceCacheObjects = new ArrayList<>();

  Results results = null;

  try {
    Query query = getCache().createQuery();
    Attribute<Long> id = getCache().getSearchAttribute("deviceClassId");
    results = query.includeKeys().includeValues().addCriteria(id.eq(deviceClassId)).execute();

    if (results.size() == 0) {
      throw new CacheElementNotFoundException("Failed to get device ids from cache");
    }

    results.all().forEach((result) -> deviceCacheObjects.add((DeviceCacheObject) result.getValue()));
  } finally {
    if (results != null) {
      results.discard();
    }
  }

  return deviceCacheObjects;
}

protected void init() {
    super.init();
    if(!initialized) {
        synchronized (this) {
            if(!initialized){
                if(delegatedCache == null)
                    throw new CacheException("Delegated cache does not exist...");

                final Attribute<Integer> partitionSearchAttribute = delegatedCache.getSearchAttribute(PROPNAME_PARTITIONID);
                if(null == partitionSearchAttribute)
                    throw new CacheException("Delegated cache should have a searchable attribute named " + PROPNAME_PARTITIONID);

                //schedule the timer pool to execute a cache search every 5 seconds...which in turn will execute the cache sync operations
                cacheTimerService.scheduleAtFixedRate(new TimedRefreshSyncOp(partitionSearchAttribute, this.partitionId), 0L, refreshInterval, refreshIntervalUnit);

                initialized = true;
            }
        }
    }
}

protected void init() {
    super.init();
    if(!initialized) {
        synchronized (this) {
            if(!initialized){
                if(delegatedCache == null)
                    throw new CacheException("Delegated cache does not exist...");

                final Attribute<Integer> partitionSearchAttribute = delegatedCache.getSearchAttribute(PROPNAME_PARTITIONID);
                if(null == partitionSearchAttribute)
                    throw new CacheException("Delegated cache should have a searchable attribute named " + PROPNAME_PARTITIONID);

                //schedule the timer pool to execute a cache search every 5 seconds...which in turn will execute the cache sync operations
                cacheTimerService.scheduleAtFixedRate(new TimedRefreshSyncOp(partitionSearchAttribute, this.partitionId), 0L, refreshInterval, refreshIntervalUnit);

                initialized = true;
            }
        }
    }
}

@Override
public DomainRoleEntry getDomainRole(String uid, Role role) {
    Cache cache = getCache(CacheId.DOMAIN_ROLES);
    Attribute<String> uidAttribute = cache.getSearchAttribute(UserRoleKey.USER_ID);
    Attribute<Role> roleAttribute = cache.getSearchAttribute(UserRoleKey.ROLE);
    // query is the fastest if you search for keys and if you need value then call Cache.get(key)
    Query queryRequestedUid = cache.createQuery()
                                   .addCriteria(uidAttribute.eq(uid))
                                   .addCriteria(roleAttribute.eq(role))
                                   .includeKeys()
                                   .end();
    Results results = queryRequestedUid.execute();
    DomainRoleEntry domainRole = null;
    if (!results.all().isEmpty()) {
        // Note: since (uid, role) is the primary key in domain role table
        // results is either empty or contains exactly one entry
        assert (results.all().size() == 1);
        domainRole = (DomainAccessControlStoreEhCache.<DomainRoleEntry> getElementValue(cache.get(results.all()
                                                                                                         .get(0)
                                                                                                         .getKey())));
    }

    return domainRole;
}

private <T extends ControlEntry> List<T> getAces(String uid, CacheId cacheId) {
    Cache cache = getCache(cacheId);
    List<T> aces = new ArrayList<T>();
    // here search on uid take place
    Attribute<String> uidAttribute = cache.getSearchAttribute(UserDomainInterfaceOperationKey.USER_ID);
    // query is the fastest if you search for keys and if you need value then call Cache.get(key)
    Query queryRequestedUid = cache.createQuery().addCriteria(uidAttribute.eq(uid).or(uidAttribute.eq(WILDCARD)))
    // have specific user ids appear before wildcards
                                   .addOrderBy(uidAttribute, Direction.DESCENDING)
                                   .includeKeys()
                                   .end();
    Results results = queryRequestedUid.execute();
    for (Result result : results.all()) {
        aces.add(DomainAccessControlStoreEhCache.<T> getElementValue(cache.get(result.getKey())));
    }

    return aces;
}

private <T extends ControlEntry> List<T> getAces(String domain, String interfaceName, CacheId cacheId) {
    Cache cache = getCache(cacheId);
    List<T> aces = new ArrayList<T>();
    // here search on domain and interface take place
    Attribute<String> domainAttribute = cache.getSearchAttribute(UserDomainInterfaceOperationKey.DOMAIN);
    Attribute<String> interfaceAttribute = cache.getSearchAttribute(UserDomainInterfaceOperationKey.INTERFACE);
    // query is the fastest if you search for keys and if you need value then call Cache.get(key)
    Query queryDomainInterface = cache.createQuery()
                                      .addCriteria(domainAttribute.eq(domain)
                                                                  .and(interfaceAttribute.eq(interfaceName)))
                                      .includeKeys()
                                      .end();
    Results results = queryDomainInterface.execute();
    for (Result result : results.all()) {
        T ace = DomainAccessControlStoreEhCache.<T> getElementValue(cache.get(result.getKey()));
        aces.add(ace);
    }

    return aces;
}

@Override
public Long getDeviceClassIdByName(String deviceClassName) {
  Long deviceClassId;

  if (deviceClassName == null || deviceClassName.equalsIgnoreCase("")) {
    throw new IllegalArgumentException("Attempting to retrieve a DeviceClass from the cache with a NULL or empty name parameter.");
  }

  Results results = null;
  try {
    Attribute<String> className = getCache().getSearchAttribute("deviceClassName");
    Query query = getCache().createQuery();
    results = query.includeKeys().addCriteria(className.eq(deviceClassName)).maxResults(1).execute();

    if (results.size() == 0) {
      throw new CacheElementNotFoundException("Failed to find a device class with name " + deviceClassName + " in the cache.");
    }

    deviceClassId = (long) results.all().get(0).getKey();
  } finally {
    if (results != null) {
      results.discard();
    }
  }

  return deviceClassId;
}

@Override
public boolean hasTagWithName(String name) {
  if (name == null || name.equalsIgnoreCase("")) {
    throw new IllegalArgumentException("Attempting to retrieve a Tag from the cache with a NULL or empty name parameter.");
  }

  // This will prevent wildcard searches
  if (name.contains("*")) {
    name = name.replace("*", "\\*");
  }
  if (name.contains("?")) {
    name = name.replace("?", "\\?");
  }

  Results results = null;

  try {
    Ehcache ehcache = getCache();
    Attribute<String> tagName = ehcache.getSearchAttribute("tagName");

    Query query = ehcache.createQuery();
    results = query.includeKeys().addCriteria(tagName.ilike(name)).maxResults(1).execute();

    return results.hasKeys();
  }
  finally {
    if (results != null) {
      // Discard the results when done to free up cache resources.
      results.discard();
    }
  }

}

@Override
public Collection<Long> findAlarm(AlarmQuery query) {

  Ehcache ehcache = getCache();
  ArrayList<Long> result = new ArrayList<Long>();

  Query cacheQuery = ehcache.createQuery();

  if (query.getFaultCode() != 0) {
      Attribute<Integer> fc = ehcache.getSearchAttribute("faultCode");
      cacheQuery.addCriteria(fc.eq(query.getFaultCode()));
  }
  if (query.getFaultFamily() != null && !"".equals(query.getFaultFamily())) {
      Attribute<String> ff = ehcache.getSearchAttribute("faultFamily");
      cacheQuery.addCriteria(ff.ilike(query.getFaultFamily()));
  }
  if (query.getFaultMember() != null && !"".equals(query.getFaultMember())) {
      Attribute<String> fm = ehcache.getSearchAttribute("faultMember");
      cacheQuery.addCriteria(fm.ilike(query.getFaultMember()));
  }
  if (query.getPriority() != 0) {
      Attribute<Integer> prio = ehcache.getSearchAttribute("priority");
      cacheQuery.addCriteria(prio.eq(query.getPriority()));
  }
  if (query.getActive() != null) {
    Attribute<Boolean> active = ehcache.getSearchAttribute("isActive");
    cacheQuery.addCriteria(active.eq(query.getActive()));
  }

  for (Result res: cacheQuery.maxResults(query.getMaxResultSize()).includeKeys().execute().all()) {
      result.add((Long) res.getKey());
  }

  return result;
}

/**
 * Receives a list of all DataTag ids which are attached to the given equipment or sub-equipment.
 * @param id The id of the (sub-)equipment
 * @param searchAttribute The ehcache search attribute, which is specified in the wrapper method
 * @return A list of all DataTag ids belonging to the given (sub-)equipment
 */
private List<Long> getDataTagIds(Long id, String searchAttribute) {
  List<Long> tagIds = new LinkedList<>();
  Results results = null;

  if (id == null) {
    throw new IllegalArgumentException("Attempting to retrieve a List of DataTag ids from the cache with a NULL " +
        "parameter.");
  }

  try {
    Attribute<Long> cacheEquipmentId = getCache().getSearchAttribute(searchAttribute);
    results = getCache().createQuery().includeKeys().addCriteria(cacheEquipmentId.eq(id)).execute();

    if (results == null) {
      throw new CacheElementNotFoundException("Failed to execute query with (sub)EquipmentId " + id + " : " +
          "Result is null.");
    }

    results.all().forEach(r -> tagIds.add((Long) r.getKey()));

  } finally {
    if (results != null) {
      // Discard the results when done to free up cache resources.
      results.discard();
    }
  }
  return tagIds;
}

@Override
public Long getProcessId(final String name) {
  Long processKey = null;
  Results results = null;

  if (name == null || name.equalsIgnoreCase("")) {
    throw new IllegalArgumentException("Attempting to retrieve a Process from the cache with a NULL or empty name parameter.");
  }

  try {
    Attribute<String> processName = getCache().getSearchAttribute("processName");
    // By limiting the query result list to 1 it is up to the administrator to
    // make
    // sure that the process name is unique. Otherwise this will result in an
    // unpredictable behaviour.
    Query query = getCache().createQuery();
    results = query.includeKeys().addCriteria(processName.eq(name)).maxResults(1).execute();

    // Find the number of results -- the number of hits.
    int size = results.size();
    if (size == 0) {
      throw new CacheElementNotFoundException("Failed to find a process with name " + name + " in the cache.");
    }

    processKey = (Long) results.all().get(0).getKey();
  }
  finally {
    if (results != null) {
      // Discard the results when done to free up cache resources.
      results.discard();
    }
  }

  return processKey;
}

@Override
public Long getCommandTagId(final String name) {
  Long commandTagKey = null;
  Results results = null;

  if (name == null || name.equalsIgnoreCase("")) {
    throw new IllegalArgumentException("Attempting to retrieve a CommandTag from the cache with a NULL or empty name parameter.");
  }

  try {
    Attribute<String> commandTagName = getCache().getSearchAttribute("commandTagName");
    Query query = getCache().createQuery();
    results = query.includeKeys().addCriteria(commandTagName.eq(name)).maxResults(1).execute();

    // Find the number of results -- the number of hits.
    int size = results.size();
    if (size == 0) {
      log.info("Failed to find a command tag with name " + name + " in the cache.");
    }

    commandTagKey = results.all().size() > 0 ? (Long) results.all().get(0).getKey() : null;
  }
  finally {
    if (results != null) {
      // Discard the results when done to free up cache resources.
      results.discard();
    }
  }

  return commandTagKey;
}

public TimedRefreshSyncOp(Attribute<Integer> partitionSearchAttribute, Integer partitionId) {
    this.query = delegatedCache.createQuery();
    Criteria searchCriteria = partitionSearchAttribute.eq(partitionId);
    query.addCriteria(searchCriteria);
    query.includeKeys();
    query.end();
}

public TimedRefreshSyncOp(Attribute<Integer> partitionSearchAttribute, Integer partitionId) {
    this.query = delegatedCache.createQuery();
    Criteria searchCriteria = partitionSearchAttribute.eq(partitionId);
    query.addCriteria(searchCriteria);
    query.includeKeys();
    query.end();
}

/**
 * Retrieve the Cache attribute
 *
 * @param attributeName the name of search attribute
 * @param <T> the type of search attribute
 * @return the search attribute
 * @throws CacheException in the event ehcache throws an exception it will be wrapped.
 */
@Override
public <T> Attribute<T> getSearchAttribute( String attributeName ) throws CacheException
{
    if ( cache == null )
    {
        String error = "getSearchAttribute detected null cache name [" + name + "]";
        throw new CacheException( GlobalErrIds.FT_NULL_CACHE, error );
    }
    return this.cache.getSearchAttribute( attributeName );
}

/**
 * Given DSD entry name, clear its corresponding object values from the cache.
 *
 * @param name contains the name of object to be cleared.
 * @param contextId maps to sub-tree in DIT, e.g. ou=contextId, dc=example, dc=com.     *
 * @throws SecurityException in the event of system or rule violation.
 */
void clearDsdCacheEntry(String name, String contextId)
{
    Attribute<String> context = m_dsdCache.getSearchAttribute(CONTEXT_ID);
    Attribute<String> dsdName = m_dsdCache.getSearchAttribute(DSD_NAME);
    Query query = m_dsdCache.createQuery();
    query.includeKeys();
    query.includeValues();
    query.addCriteria(dsdName.eq(name).and(context.eq(contextId)));
    Results results = query.execute();
    for (Result result : results.all())
    {
        m_dsdCache.clear(result.getKey());
    }
}

/**
 * Given a role name, return the set of DSD's that have a matching member.
 *
 * @param name contains name of authorized Role used to search the cache.
 * @param contextId maps to sub-tree in DIT, e.g. ou=contextId, dc=example, dc=com.
 * @return un-ordered set of matching DSD's.
 * @throws SecurityException in the event of system or rule violation.
 */
private Set<SDSet> getDsdCache(String name, String contextId)
    throws SecurityException
{
    contextId = getContextId(contextId);
    Set<SDSet> finalSet = new HashSet<>();
    Attribute<String> context = m_dsdCache.getSearchAttribute(CONTEXT_ID);
    Attribute<String> member = m_dsdCache.getSearchAttribute(SchemaConstants.MEMBER_AT);
    Query query = m_dsdCache.createQuery();
    query.includeKeys();
    query.includeValues();
    query.addCriteria(member.eq(name).and(context.eq(contextId)));
    Results results = query.execute();
    boolean empty = false;
    for (Result result : results.all())
    {
        DsdCacheEntry entry = (DsdCacheEntry) result.getValue();
        if (!entry.isEmpty())
        {
            finalSet.add(entry.getSdSet());
            finalSet = putDsdCache(name, contextId);
        }
        else
        {
            empty = true;
        }
        finalSet.add(entry.getSdSet());
    }
    // If nothing was found in the cache, determine if it needs to be seeded:
    if (finalSet.size() == 0 && !empty)
    {
        finalSet = putDsdCache(name, contextId);
    }
    return finalSet;
}

void runTests()
{
    loadCache();
    Attribute<String> member = cache.getSearchAttribute( "member" );
    Query query = cache.createQuery();
    query.includeKeys();
    query.includeValues();
    Set<String> roles = new HashSet<>();
    roles.add( "oamt17dsd1" );
    roles.add( "oamt17dsd4" );
    roles.add( "oamT13DSD6" );
    roles.add( "oamT16SDR7" );
    query.addCriteria( member.in( roles ) );
    Results results = query.execute();
    System.out.println( " Size: " + results.size() );
    System.out.println( "----Results-----\n" );
    Set<SDSet> resultSet = new HashSet<>();

    for ( Result result : results.all() )
    {
        DsdCacheEntry entry = ( DsdCacheEntry ) result.getValue();
        resultSet.add( entry.getSdSet() );
    }

    for ( SDSet sdSet : resultSet )
    {
        LOG.info( "Found SDSet: " + sdSet.getName() );
    }
}

@Override
public List<DomainRoleEntry> getDomainRoles(String uid) {
    Cache cache = getCache(CacheId.DOMAIN_ROLES);
    List<DomainRoleEntry> domainRoles = new ArrayList<DomainRoleEntry>();
    Attribute<String> uidAttribute = cache.getSearchAttribute(UserRoleKey.USER_ID);
    // query is the fastest if you search for keys and if you need value then call Cache.get(key)
    Query queryRequestedUid = cache.createQuery().addCriteria(uidAttribute.eq(uid)).includeKeys().end();
    Results results = queryRequestedUid.execute();
    for (Result result : results.all()) {
        domainRoles.add(DomainAccessControlStoreEhCache.<DomainRoleEntry> getElementValue(cache.get(result.getKey())));
    }

    return domainRoles;
}

private <T extends ControlEntry> T getAce(CacheId cacheId,
                                          String uid,
                                          String domain,
                                          String interfaceName,
                                          String operation) {
    Cache cache = getCache(cacheId);
    Attribute<String> uidAttribute = cache.getSearchAttribute(UserDomainInterfaceOperationKey.USER_ID);
    Attribute<String> domainAttribute = cache.getSearchAttribute(UserDomainInterfaceOperationKey.DOMAIN);
    Attribute<String> interfaceAttribute = cache.getSearchAttribute(UserDomainInterfaceOperationKey.INTERFACE);
    Attribute<String> operationAttribute = cache.getSearchAttribute(UserDomainInterfaceOperationKey.OPERATION);
    Query queryAllOperations = cache.createQuery()
                                    .addCriteria(uidAttribute.eq(uid).or(uidAttribute.eq(WILDCARD)))
                                    .addCriteria(domainAttribute.eq(domain))
                                    .addCriteria(interfaceAttribute.eq(interfaceName))
                                    .addCriteria(operationAttribute.eq(operation))
                                    // have specific user ids appear before wildcards
                                    .addOrderBy(uidAttribute, Direction.DESCENDING)
                                    .includeKeys()
                                    .end();
    Results results = queryAllOperations.execute();
    T ace = null;
    if (!results.all().isEmpty()) {
        ace = DomainAccessControlStoreEhCache.<T> getElementValue(cache.get(results.all().get(0).getKey()));
    }

    return ace;
}

private <T extends ControlEntry> List<T> getAces(CacheId cacheId, String uid, String domain, String interfaceName) {
    Cache cache = getCache(cacheId);
    Attribute<String> uidAttribute = cache.getSearchAttribute(UserDomainInterfaceOperationKey.USER_ID);
    Attribute<String> domainAttribute = cache.getSearchAttribute(UserDomainInterfaceOperationKey.DOMAIN);
    Attribute<String> interfaceAttribute = cache.getSearchAttribute(UserDomainInterfaceOperationKey.INTERFACE);
    Query queryAllOperations = cache.createQuery()
                                    .addCriteria(uidAttribute.eq(uid).or(uidAttribute.eq(WILDCARD)))
                                    .addCriteria(domainAttribute.eq(domain))
                                    .addCriteria(interfaceAttribute.eq(interfaceName))
                                    // have specific user ids appear before wildcards
                                    .addOrderBy(uidAttribute, Direction.DESCENDING)
                                    .includeKeys()
                                    .end();
    Results results = queryAllOperations.execute();
    List<T> aces = new ArrayList<T>();
    String currentUid = null;
    for (Result result : results.all()) {
        T ace = DomainAccessControlStoreEhCache.<T> getElementValue(cache.get(result.getKey()));

        // Don't add uid wildcards if a specific uid has been added to the results
        if (currentUid == null) {
            currentUid = ace.getUid();
        } else if (!currentUid.equals(ace.getUid())) {
            break;
        }

        aces.add(ace);
    }

    return aces;
}

private <T extends ControlEntry> List<T> getEditableAces(String uid, CacheId cacheId, Role role) {
    List<T> aces = new ArrayList<T>();
    // find out first on which domains uid has specified role
    Cache drtCache = getCache(CacheId.DOMAIN_ROLES);
    UserRoleKey dreKey = new UserRoleKey(uid, role);
    String[] uidDomains = null;
    // read domains from DRE
    if (drtCache.isKeyInCache(dreKey)) {
        DomainRoleEntry dre = DomainAccessControlStoreEhCache.<DomainRoleEntry> getElementValue(drtCache.get(dreKey));
        uidDomains = dre.getDomains();
    }
    // if uid has no domains with specified role return empty list
    if (uidDomains == null || uidDomains.length == 0) {
        return aces;
    }

    Cache cache = getCache(cacheId);
    // here should search on uid and domain take place
    Attribute<String> uidAttribute = cache.getSearchAttribute(UserDomainInterfaceOperationKey.USER_ID);
    Attribute<String> domainAttribute = cache.getSearchAttribute(UserDomainInterfaceOperationKey.DOMAIN);
    for (String domain : uidDomains) {
        Query query = cache.createQuery()
                           .addCriteria(uidAttribute.eq(uid).and(domainAttribute.eq(domain)))
                           .includeKeys()
                           .end();
        Results results = query.execute();
        for (Result result : results.all()) {
            aces.add(DomainAccessControlStoreEhCache.<T> getElementValue(cache.get(result.getKey())));
        }

    }

    return aces;
}

@Override
public <T> Attribute<T> getSearchAttribute(String attributeName)
        throws CacheException {
    init();
    return super.getSearchAttribute(attributeName);
}

@Override
public <T> Attribute<T> getSearchAttribute(String attributeName)
        throws CacheException {
    init();
    return super.getSearchAttribute(attributeName);
}

/**
 * Given a Set of authorized Roles, return the set of DSD's that have matching members.
 *
 * @param authorizedRoleSet contains an un-order Set of authorized Roles.
 * @param contextId maps to sub-tree in DIT, e.g. ou=contextId, dc=example, dc=com.
 * @return un-ordered set of matching DSD's.
 * @throws SecurityException in the event of system or rule violation.
 */
Set<SDSet> getDsdCache(Set<String> authorizedRoleSet, String contextId)
    throws SecurityException
{
    contextId = getContextId(contextId);
    Set<SDSet> dsdRetSets = new HashSet<>();
    // Need to proceed?
    if (!CollectionUtils.isNotEmpty( authorizedRoleSet ))
    {
        return dsdRetSets;
    }
    // Was the DSD Cache switched off?
    boolean isCacheDisabled = Config.getInstance().getBoolean(IS_DSD_CACHE_DISABLED_PARM, false);
    // If so, get DSD's from LDAP:
    if (isCacheDisabled)
    {
        SDSet sdSet = new SDSet();
        sdSet.setType(SDSet.SDType.DYNAMIC);
        sdSet.setContextId(contextId);
        dsdRetSets = sp.search(authorizedRoleSet, sdSet);
    }
    // Search the DSD cache for matching Role members:
    else
    {
        // Search on roleName attribute which maps to 'member' attr on the cache record:
        Attribute<String> member = m_dsdCache.getSearchAttribute(SchemaConstants.MEMBER_AT);
        Attribute<String> context = m_dsdCache.getSearchAttribute(CONTEXT_ID);
        Query query = m_dsdCache.createQuery();
        query.includeKeys();
        query.includeValues();
        // Add the passed in authorized Role names to this cache query:
        Set<String> roles = new HashSet<>(authorizedRoleSet);
        query.addCriteria(member.in(roles).and(context.eq(contextId)));
        // Return all DSD cache entries that match roleName to the 'member' attribute in cache entry:
        Results results = query.execute();
        for (Result result : results.all())
        {
            DsdCacheEntry entry = (DsdCacheEntry) result.getValue();
            // Do not add dummy DSD sets to the final list:
            if (!entry.isEmpty())
            {
                dsdRetSets.add(entry.getSdSet());
            }
            // Remove role member from authorizedRoleSet to preclude from upcoming DSD search:
            //authorizedRoleSet.remove(entry.getMember());
        }
        // Authorized roles remaining in this set correspond to missed cache hits from above:
        if (authorizedRoleSet.size() > 0)
        {
            dsdRetSets = putDsdCache(authorizedRoleSet, contextId);
        }
    }
    return dsdRetSets;
}

public Attribute<Object> getSearchAttribute( String attributeName ) {
    return new Attribute<Object>( attributeName );// this.cache.getSearchAttribute( attributeName );
}

/**
 * Retrieve the Cache attribute
 *
 * @param attributeName the name of search attribute
 * @param <T> the type of search attribute
 * @return the search attribute
 * @throws CacheException will wraps the implementation's exception.
 */
<T> Attribute<T> getSearchAttribute( String attributeName ) throws CacheException;