/** * Creates a top level Evaluator where leaves are delegated to a leaf node * evaluator which will be created. * * @param schemaManager The server schemaManager */ public ExpressionEvaluator( SchemaManager schemaManager ) { SubstringEvaluator substringEvaluator = null; substringEvaluator = new SubstringEvaluator(); // leafEvaluator = new LeafEvaluator( schemaManager, substringEvaluator ); leafEvaluator = new LeafEvaluator( substringEvaluator ); }
/** * Creates a new instance of RegistrationEntry associated with a listener * @param listener The associated listener */ RegistrationEntry( SchemaManager schemaManager, DirectoryListener listener ) { this( listener, new NotificationCriteria( schemaManager ) ); }
/** * @param eventTypes the eventTypes to set */ public void setEventMask( EventType... eventTypes ) { this.eventMask = EventType.getMask( eventTypes ); }
NotificationCriteria criteria = new NotificationCriteria( session.getCoreSession().getDirectoryService().getSchemaManager() ); criteria.setAliasDerefMode( req.getDerefAliases() ); criteria.setBase( req.getBase() ); criteria.setFilter( req.getFilter() ); criteria.setScope( req.getScope() ); criteria.setEventMask( EventType.getEventTypes( psearch.getChangeTypes() ) ); getLdapServer().getDirectoryService().getEventService().addListener( persistentSearchListener, criteria ); req.addAbandonListener( new SearchAbandonListener( ldapServer, persistentSearchListener ) );
public void addNamingListener( Name name, int scope, NamingListener namingListener ) throws NamingException { ExprNode filter = new PresenceNode( objectClassAT ); try { DirectoryListener listener = new EventListenerAdapter( ( ServerLdapContext ) this, namingListener ); NotificationCriteria criteria = new NotificationCriteria( schemaManager ); criteria.setFilter( filter ); criteria.setScope( SearchScope.getSearchScope( scope ) ); criteria.setAliasDerefMode( AliasDerefMode.getEnum( env ) ); criteria.setBase( buildTarget( JndiUtils.fromName( name ) ) ); service.getEventService().addListener( listener, criteria ); listeners.put( namingListener, listener ); } catch ( Exception e ) { JndiUtils.wrap( e ); } }
return scopeEvaluator.evaluate( node, dn, entry ); return evalPresence( ( ( PresenceNode ) node ).getAttributeType(), entry ); return evalEquality( ( EqualityNode<?> ) node, entry ); return evalGreaterOrLesser( ( GreaterEqNode<?> ) node, entry, COMPARE_GREATER ); return evalGreaterOrLesser( ( LessEqNode<?> ) node, entry, COMPARE_LESSER ); return substringEvaluator.evaluate( node, dn, entry );
public void requestAbandoned( AbandonableRequest req ) { if ( listener != null ) { ldapServer.getDirectoryService().getEventService().removeListener( listener ); } } }
/** * Gets the comparator for equality matching. * * @param attributeType the attributeType * @return the comparator for equality matching * @throws LdapException if there is a failure */ private LdapComparator<? super Object> getComparator( AttributeType attributeType ) throws LdapException { MatchingRule mrule = getMatchingRule( attributeType, EQUALITY_MATCH ); return mrule.getLdapComparator(); }
/** * Creates a leaf expression node evaluator. * * @param substringEvaluator The evaluator to use */ public LeafEvaluator( SubstringEvaluator substringEvaluator ) { this.scopeEvaluator = new ScopeEvaluator(); this.substringEvaluator = substringEvaluator; }
/** * Creates a subtreeSpecification evaluatior which can be used to determine * if an entry is included within the collection of a subtree. * * @param schemaManager The server schemaManager */ public SubtreeEvaluator( SchemaManager schemaManager ) { evaluator = new ExpressionEvaluator( schemaManager ); }
/** * {@inheritDoc} */ public String toString() { StringBuilder sb = new StringBuilder(); sb.append( listener ).append( '/' ); if ( criteria != null ) { sb.append( criteria.toString() ); } return sb.toString(); } }
/** * {@inheritDoc} */ public String toString() { StringBuilder sb = new StringBuilder(); sb.append( "Notification criteria : " ); sb.append( '\'' ).append( base ).append( "', " ); sb.append( '\'' ).append( filter ).append( "', " ); sb.append( '\'' ).append( scope ).append( "', " ); sb.append( '\'' ).append( aliasDerefMode ).append( "', " ); sb.append( '\'' ).append( EventType.toString( eventMask ) ).append( '\'' ); return sb.toString(); } }
public void removeNamingListener( NamingListener namingListener ) throws NamingException { try { DirectoryListener listener = listeners.remove( namingListener ); if ( listener != null ) { service.getEventService().removeListener( listener ); } } catch ( Exception e ) { JndiUtils.wrap( e ); } }
/** * Compute the mask associated with the given eventTypes * * @param eventTypes The eventTypes * @return The associated mask */ public static int getMask( EventType... eventTypes ) { int mask = 0; for ( EventType type : eventTypes ) { mask |= type.getMask(); } return mask; }
/** * Gets the normalizer for equality matching. * * @param attributeType the attributeType * @return the normalizer for equality matching * @throws LdapException if there is a failure */ private Normalizer getNormalizer( AttributeType attributeType ) throws LdapException { MatchingRule mrule = getMatchingRule( attributeType, EQUALITY_MATCH ); return mrule.getNormalizer(); }
/** * @see javax.naming.Context#close() */ public void close() throws NamingException { for ( DirectoryListener listener : listeners.values() ) { try { service.getEventService().removeListener( listener ); } catch ( Exception e ) { JndiUtils.wrap( e ); } } listeners.clear(); }
public void abandon() throws LdapException { // must abandon the operation session.getCoreSession().getDirectoryService().getEventService().removeListener( this ); /* * From RFC 2251 Section 4.11: * * In the event that a server receives an Abandon Request on a Search * operation in the midst of transmitting responses to the Search, that * server MUST cease transmitting entry responses to the abandoned * request immediately, and MUST NOT send the SearchResultDone. Of * course, the server MUST ensure that only properly encoded LDAPMessage * PDUs are transmitted. * * SO DON'T SEND BACK ANYTHING!!!!! */ }
public synchronized void removeEventLog( ReplicaEventLog replicaEventLog ) { directoryService.getEventService().removeListener( replicaEventLog.getPersistentListener() ); String name = replicaEventLog.getName(); LOG.debug( "removed the persistent listener for replication event log {}", name ); replicaLogMap.remove( replicaEventLog.getId() ); try { replicaEventLog.stop(); new File( directoryService.getInstanceLayout().getReplDirectory(), name + ".db" ).delete(); new File( directoryService.getInstanceLayout().getReplDirectory(), name + ".lg" ).delete(); LOG.info( "successfully removed replication event log {}", name ); } catch ( Exception e ) { LOG.warn( "Closing the replication event log of the entry {} was not successful, will be removed anyway", name, e ); } }