directory-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From kayyag...@apache.org
Subject svn commit: r1398835 - in /directory/apacheds/trunk/mmr-tests/src/test/java: com/ org/ org/apache/ org/apache/directory/ org/apache/directory/server/ org/apache/directory/server/ldap/ org/apache/directory/server/ldap/replication/
Date Tue, 16 Oct 2012 15:01:37 GMT
Author: kayyagari
Date: Tue Oct 16 15:01:37 2012
New Revision: 1398835

URL: http://svn.apache.org/viewvc?rev=1398835&view=rev
Log:
changed the package (accidentally left the keydap package while merging changes back to Directory
trunk)

Added:
    directory/apacheds/trunk/mmr-tests/src/test/java/org/
    directory/apacheds/trunk/mmr-tests/src/test/java/org/apache/
    directory/apacheds/trunk/mmr-tests/src/test/java/org/apache/directory/
    directory/apacheds/trunk/mmr-tests/src/test/java/org/apache/directory/server/
    directory/apacheds/trunk/mmr-tests/src/test/java/org/apache/directory/server/ldap/
    directory/apacheds/trunk/mmr-tests/src/test/java/org/apache/directory/server/ldap/replication/
    directory/apacheds/trunk/mmr-tests/src/test/java/org/apache/directory/server/ldap/replication/MmrTester.java
Removed:
    directory/apacheds/trunk/mmr-tests/src/test/java/com/

Added: directory/apacheds/trunk/mmr-tests/src/test/java/org/apache/directory/server/ldap/replication/MmrTester.java
URL: http://svn.apache.org/viewvc/directory/apacheds/trunk/mmr-tests/src/test/java/org/apache/directory/server/ldap/replication/MmrTester.java?rev=1398835&view=auto
==============================================================================
--- directory/apacheds/trunk/mmr-tests/src/test/java/org/apache/directory/server/ldap/replication/MmrTester.java
(added)
+++ directory/apacheds/trunk/mmr-tests/src/test/java/org/apache/directory/server/ldap/replication/MmrTester.java
Tue Oct 16 15:01:37 2012
@@ -0,0 +1,798 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ *
+ */
+package org.apache.directory.server.ldap.replication;
+
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.apache.directory.ldap.client.api.LdapNetworkConnection;
+import org.apache.directory.server.annotations.CreateConsumer;
+import org.apache.directory.server.annotations.CreateLdapServer;
+import org.apache.directory.server.annotations.CreateTransport;
+import org.apache.directory.server.constants.ServerDNConstants;
+import org.apache.directory.server.core.annotations.CreateDS;
+import org.apache.directory.server.core.annotations.CreateIndex;
+import org.apache.directory.server.core.annotations.CreatePartition;
+import org.apache.directory.server.core.api.CoreSession;
+import org.apache.directory.server.core.api.DirectoryService;
+import org.apache.directory.server.core.factory.DSAnnotationProcessor;
+import org.apache.directory.server.core.integ.FrameworkRunner;
+import org.apache.directory.server.factory.ServerAnnotationProcessor;
+import org.apache.directory.server.ldap.LdapServer;
+import org.apache.directory.server.ldap.replication.consumer.ReplicationConsumer;
+import org.apache.directory.server.ldap.replication.consumer.ReplicationConsumerImpl;
+import org.apache.directory.server.ldap.replication.provider.SyncReplRequestHandler;
+import org.apache.directory.shared.ldap.model.constants.SchemaConstants;
+import org.apache.directory.shared.ldap.model.cursor.EntryCursor;
+import org.apache.directory.shared.ldap.model.entry.DefaultEntry;
+import org.apache.directory.shared.ldap.model.entry.Entry;
+import org.apache.directory.shared.ldap.model.message.DeleteRequest;
+import org.apache.directory.shared.ldap.model.message.DeleteRequestImpl;
+import org.apache.directory.shared.ldap.model.message.DeleteResponse;
+import org.apache.directory.shared.ldap.model.message.ModifyDnRequest;
+import org.apache.directory.shared.ldap.model.message.ModifyDnRequestImpl;
+import org.apache.directory.shared.ldap.model.message.ModifyDnResponse;
+import org.apache.directory.shared.ldap.model.message.ModifyRequest;
+import org.apache.directory.shared.ldap.model.message.ModifyRequestImpl;
+import org.apache.directory.shared.ldap.model.message.ModifyResponse;
+import org.apache.directory.shared.ldap.model.message.ResultCodeEnum;
+import org.apache.directory.shared.ldap.model.message.SearchScope;
+import org.apache.directory.shared.ldap.model.name.Dn;
+import org.apache.directory.shared.ldap.model.name.Rdn;
+import org.apache.directory.shared.ldap.model.url.LdapUrl;
+
+/**
+ * Holds the configuration and instances of connections
+ * 
+ * WARN: this class is not yet ready to run as a junit test cause it requires 
+ *       some manual setup of servers and test is invoked by main()
+ *       The existing annotation based server instances are not used yet.
+ *       
+ * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
+ */
+public class MmrTester
+{
+    private static final String PARTITION_SUFFIX = "dc=example,dc=com";
+
+    private static final String RDN_PREFIX = "p";
+
+    private Set<String> urls = new LinkedHashSet<String>();
+    
+    private List<LdapNetworkConnection> connections;
+    
+    private static final int TOTAL_ENTRY_COUNT = 10;
+    
+    private AtomicInteger count = new AtomicInteger(-1);
+    
+    private Random rand = new Random();
+
+    private boolean verbose = false;
+    
+    private static LdapServer peer1Server;
+
+    private static LdapServer peer2Server;
+
+    static
+    {
+        try
+        {
+            Class.forName( FrameworkRunner.class.getName() );
+        }
+        catch(Exception e)
+        {
+            throw new RuntimeException( e );
+        }
+    }
+    
+    public MmrTester( String... ldapUrls )
+    {
+        if( ( ldapUrls == null ) || ( ldapUrls.length < 2 ) )
+        {
+            throw new IllegalArgumentException( "Atleast two servers are required to run
MMR tests" );
+        }
+        
+        for( String u : ldapUrls )
+        {
+            urls.add( u.toLowerCase() );
+        }
+    }
+    
+    
+    public void prepareConnections() throws Exception
+    {
+        connections = new ArrayList<LdapNetworkConnection>();
+        
+        for( String u : urls )
+        {
+            LdapUrl url = new LdapUrl( u );
+            boolean useSsl = false;
+            if( url.getScheme().equals( "ldaps" ) )
+            {
+                useSsl = true;
+            }
+            
+            LdapNetworkConnection c = new LdapNetworkConnection( url.getHost(), url.getPort(),
useSsl );
+            c.connect();
+            c.bind( ServerDNConstants.ADMIN_SYSTEM_DN, "secret" );
+            System.out.println( "connected to the server " + url );
+            connections.add( c );
+        }
+    }
+    
+    
+    public void addAndCompare()
+    {
+        List<Dn> injected = new ArrayList<Dn>();
+        int batch = 20;
+        
+        if( batch > TOTAL_ENTRY_COUNT )
+        {
+            batch = TOTAL_ENTRY_COUNT;
+        }
+        else
+        {
+            batch = TOTAL_ENTRY_COUNT;
+        }
+        
+        for( int i=0; i < batch; i++ )
+        {
+            int index = rand.nextInt( connections.size() );
+
+            LdapNetworkConnection nc = connections.get( index );
+            
+            if( verbose )
+            {
+                System.out.println( "inserting into the server " + nc.getConfig().getLdapHost()
+ ":" + nc.getConfig().getLdapPort() );
+            }
+            
+            Entry e = createEntry( count.incrementAndGet() );
+            if ( inject( nc, e ) )
+            {
+                injected.add( e.getDn() );
+            }
+        }
+        
+        compareEntries( injected );
+    }
+    
+    
+    public List<Dn> modify() throws Exception
+    {
+        List<Dn> modified = new ArrayList<Dn>();
+        int batch = 20;
+        
+        if( batch > TOTAL_ENTRY_COUNT )
+        {
+            batch = TOTAL_ENTRY_COUNT;
+        }
+        else
+        {
+            batch = (int) ( TOTAL_ENTRY_COUNT * 0.10 ); // modify 10% of total entries
+        }
+
+        for( int i=0; i < batch; i++ )
+        {
+            int connectionIndex = rand.nextInt( connections.size() );
+            
+            int entryIndex = rand.nextInt( batch );
+            
+            LdapNetworkConnection nc = connections.get( connectionIndex );
+            
+            String cn = RDN_PREFIX + entryIndex;
+            Dn personDn = new Dn( "cn=" + cn + "," + PARTITION_SUFFIX );
+
+            if ( verbose )
+            {
+                System.out.println( "modifying " + personDn + " on the server " + nc.getConfig().getLdapHost()
+ ":" + nc.getConfig().getLdapPort() );
+            }
+            
+            ModifyRequest modReq = new ModifyRequestImpl();
+            modReq.setName( personDn );
+            modReq.replace( SchemaConstants.SN_AT, "sn_" + i );
+            
+            ModifyResponse resp = nc.modify( modReq );
+            ResultCodeEnum rc = resp.getLdapResult().getResultCode();
+            if( rc != ResultCodeEnum.SUCCESS )
+            {
+                System.out.println( "Error modifying " + personDn + " on the server " + nc.getConfig().getLdapHost()
+ ":" + nc.getConfig().getLdapPort() + " with result code " + rc );
+            }
+
+            modified.add( personDn );
+        }
+        
+        return modified;
+    }
+    
+    
+    public void moveAndCompare( Dn superiorDn ) throws Exception
+    {
+        List<Dn> moved = new ArrayList<Dn>();
+        int batch = 5;
+        
+        if( batch > TOTAL_ENTRY_COUNT )
+        {
+            batch = TOTAL_ENTRY_COUNT;
+        }
+        else
+        {
+            batch = (int) ( TOTAL_ENTRY_COUNT * 0.20 ); // move 20% of total entries
+        }
+        
+        for( int i=0; i < batch; i++ )
+        {
+            int connectionIndex = rand.nextInt( connections.size() );
+            
+            LdapNetworkConnection nc = connections.get( connectionIndex );
+            
+            String cn = RDN_PREFIX + i;
+            Dn personDn = new Dn( "cn=" + cn + "," + PARTITION_SUFFIX );
+            
+            if( verbose )
+            {
+                System.out.println( "moving " + personDn + " on the server " + nc.getConfig().getLdapHost()
+ ":" + nc.getConfig().getLdapPort() + ":" + nc.getConfig().getLdapPort() );
+            }
+            
+            ModifyDnRequest modReq = new ModifyDnRequestImpl();
+            modReq.setName( personDn );
+            modReq.setNewRdn( personDn.getRdn() );
+            modReq.setNewSuperior( superiorDn );
+            
+            ModifyDnResponse resp = nc.modifyDn( modReq );
+            ResultCodeEnum rc = resp.getLdapResult().getResultCode();
+            if( rc != ResultCodeEnum.SUCCESS )
+            {
+                System.out.println( "Error moving " + personDn + " on the server " + nc.getConfig().getLdapHost()
+ ":" + nc.getConfig().getLdapPort() + ":" + nc.getConfig().getLdapPort() + " with result
code " + rc );
+            }
+            
+            moved.add( superiorDn.add( personDn.getRdn() ) );
+        }
+        
+        compareEntries( moved );
+    }
+
+    
+    public List<Dn> renameAndCompare( Dn containerDn ) throws Exception
+    {
+        List<Dn> renamed = new ArrayList<Dn>();
+        List<Dn> present = new ArrayList<Dn>();
+        
+        int connectionIndex = rand.nextInt( connections.size() );
+
+        LdapNetworkConnection nc = connections.get( connectionIndex );
+        EntryCursor cursor = nc.search( containerDn, "(cn=" + RDN_PREFIX + "*)", SearchScope.ONELEVEL,
SchemaConstants.NO_ATTRIBUTE_ARRAY );
+        
+        while( cursor.next() )
+        {
+            present.add( cursor.get().getDn() );
+        }
+        
+        cursor.close();
+        
+        for( int i=0; i < present.size(); i++ )
+        {
+            connectionIndex = rand.nextInt( connections.size() );
+            nc = connections.get( connectionIndex );
+            
+            Dn personDn = present.get( i );
+            
+            ModifyDnRequest modReq = new ModifyDnRequestImpl();
+            Rdn newRdn = new Rdn( "cn=p_rename" + i );
+            modReq.setName( personDn );
+            modReq.setNewRdn( newRdn );
+            
+            if( verbose )
+            {
+                System.out.println( "renaming " + personDn + " on the server " + nc.getConfig().getLdapHost()
+ ":" + nc.getConfig().getLdapPort() );    
+            }
+            
+            ModifyDnResponse resp = nc.modifyDn( modReq );
+            ResultCodeEnum rc = resp.getLdapResult().getResultCode();
+            if( rc != ResultCodeEnum.SUCCESS )
+            {
+                System.out.println( "Error renaming " + personDn + " on the server " + nc.getConfig().getLdapHost()
+ ":" + nc.getConfig().getLdapPort() + " with result code " + rc );
+            }
+            
+            renamed.add( personDn.getParent().add( newRdn ) );
+        }
+        
+        compareEntries( renamed );
+        
+        return renamed;
+    }
+
+    
+    public void deleteAndVerify( List<Dn> present ) throws Exception
+    {
+        List<Dn> deleted = new ArrayList<Dn>();
+        
+        int count = present.size();//( present.size() - 2 );
+        for( int i=0; i < count; i++ )
+        {
+            int connectionIndex = rand.nextInt( connections.size() );
+            
+            LdapNetworkConnection nc = connections.get( connectionIndex );
+            
+            Dn personDn = present.get( i );
+            
+            DeleteRequest delReq = new DeleteRequestImpl();
+            delReq.setName( personDn );
+            
+            if( verbose )
+            {
+                System.out.println( "deleting " + personDn + " on the server " + nc.getConfig().getLdapHost()
+ ":" + nc.getConfig().getLdapPort() );
+            }
+            
+            DeleteResponse resp = nc.delete( delReq );
+            ResultCodeEnum rc = resp.getLdapResult().getResultCode();
+
+            if( rc != ResultCodeEnum.SUCCESS )
+            {
+                System.out.println( "Error deleting " + personDn + " on the server " + nc.getConfig().getLdapHost()
+ ":" + nc.getConfig().getLdapPort() + " with result code " + rc );
+            }
+            
+            deleted.add( personDn );
+        }
+        
+        verifyDeleted( deleted );
+    }
+
+    
+    public void compareEntries( List<Dn> injected )
+    {
+        for( Dn dn : injected )
+        {
+            Entry baseEntry = null;
+            Iterator<LdapNetworkConnection> itr = connections.iterator();
+            LdapNetworkConnection c = itr.next();
+            baseEntry = lookupWithWait( c, dn );
+            
+            while( itr.hasNext() )
+            {
+                c = itr.next();
+                Entry replicaEntry = lookupWithWait( c, dn );
+                boolean equal = baseEntry.equals( replicaEntry );
+                if( !equal )
+                {
+                    System.out.println( "base entry: " + baseEntry );
+                    System.out.println( "replica entry: " + replicaEntry );
+                }
+                
+                assertTrue( equal );
+            }
+        }
+    }
+    
+
+    public void verifyDeleted( List<Dn> injected )
+    {
+        for( Dn dn : injected )
+        {
+            Iterator<LdapNetworkConnection> itr = connections.iterator();
+            outer: while( itr.hasNext() )
+            {
+                LdapNetworkConnection c = itr.next();
+                try
+                {
+                    for( int i = 1; i <= 10; )
+                    {
+                        if( !c.exists( dn ) )
+                        {
+                            continue outer;
+                        }
+                        
+                        Thread.sleep( 1000 * i );
+                    }
+                    
+                    throw new RuntimeException( "deleted Entry " + dn + " found on server
" + c.getConfig().getLdapHost() + ":" + c.getConfig().getLdapPort() );
+                }
+                catch( Exception e )
+                {
+                    throw new RuntimeException( e );
+                }
+            }
+        }
+    }
+    
+    
+    public Entry lookupWithWait( LdapNetworkConnection c, Dn dn )
+    {
+        try
+        {
+            for( int i = 1; i <= 10; )
+            {
+                if( !c.exists( dn ) )
+                {
+                    Thread.sleep( 1000 * i );
+                    continue;
+                }
+                
+                return c.lookup( dn, SchemaConstants.ALL_USER_ATTRIBUTES, SchemaConstants.ENTRY_UUID_AT
);
+            }
+        }
+        catch( Exception e )
+        {
+            throw new RuntimeException( e );
+        }
+        
+        throw new RuntimeException( "Entry " + dn + " not found on server " + c.getConfig().getLdapHost()
+ ":" + c.getConfig().getLdapPort() );
+    }
+    
+    
+    public boolean inject( LdapNetworkConnection nc, Entry e )
+    {
+        try
+        {
+            nc.add( e );
+            return true;
+        }
+        catch( Exception ex )
+        {
+            count.decrementAndGet();
+            ex.printStackTrace();
+            return false;
+        }
+    }
+
+    
+    public boolean isCountReached()
+    {
+        return ( count.get() >= TOTAL_ENTRY_COUNT );
+    }
+    
+    
+    public void injectAndWaitTillReplicates( Entry ctxEntry ) throws Exception
+    {
+        LdapNetworkConnection c = connections.get( 0 );
+        
+        if( !c.exists( ctxEntry.getDn() ) )
+        {
+            c.add( ctxEntry );
+        }
+        
+        compareEntries( Collections.singletonList( ctxEntry.getDn() ) );
+    }
+    
+    
+    private Entry createEntry( int num )
+    {
+        try
+        {
+            String cn = RDN_PREFIX + num;
+            Dn personDn = new Dn( "cn=" + cn + "," + PARTITION_SUFFIX );
+            Entry person = new DefaultEntry(
+                personDn.toString(),
+                "ObjectClass: top",
+                "ObjectClass: person",
+                "cn: " + cn,
+                "sn: sn_" + cn,
+                "userPassword: 12345" );
+            return person;
+        }
+        catch( Exception e )
+        {
+            throw new RuntimeException( e );
+        }
+    }
+    
+    
+    public void closeConnections()
+    {
+        for( LdapNetworkConnection nc : connections )
+        {
+            try
+            {
+                nc.close();
+            }
+            catch( Exception e )
+            {
+                //ignore
+                e.printStackTrace();
+            }
+        }
+    }
+    
+    public static void main( String[] args )
+    {
+        MmrTester cc = new MmrTester( "ldap://localhost:16389", "ldap://localhost:17389"
);
+        
+        if( TOTAL_ENTRY_COUNT < 150 )
+        {
+            cc.verbose = true;
+        }
+        
+        try
+        {
+            Thread t1 = new Thread( new Runnable()
+            {
+                
+                @Override
+                public void run()
+                {
+                    try
+                    {
+                        startPeer1();
+                    }
+                    catch(Exception e )
+                    {
+                        e.printStackTrace();
+                    }
+                }
+            } );
+
+            t1.setDaemon( true );
+            
+            Thread t2 = new Thread( new Runnable()
+            {
+                
+                @Override
+                public void run()
+                {
+                    try
+                    {
+                        startPeer2();
+                    }
+                    catch(Exception e )
+                    {
+                        e.printStackTrace();
+                    }
+                }
+            } );
+
+            t2.setDaemon( true );
+            
+//            t1.start();
+//            t2.start();
+//            
+//            t1.join();
+//            t2.join();
+            
+            cc.prepareConnections();
+
+            Entry ctxEntry = new DefaultEntry( "dc=example,dc=com",
+                "objectClass: domain",
+                "objectClass: top",
+                "dc: example" );
+
+            cc.injectAndWaitTillReplicates( ctxEntry );
+            cc.addAndCompare();
+            
+            List<Dn> modified = cc.modify();
+            Thread.sleep( 15000 );
+            
+            cc.compareEntries( modified );
+            
+            Entry groupEntry = new DefaultEntry( "ou=groups,dc=example,dc=com",
+                "objectClass: organizationalUnit",
+                "objectClass: top",
+                "ou: groups" );
+            
+            cc.injectAndWaitTillReplicates( groupEntry );
+            
+            cc.moveAndCompare( groupEntry.getDn() );
+            
+            List<Dn> renamed = cc.renameAndCompare( groupEntry.getDn() );
+            
+            cc.deleteAndVerify( renamed );
+        }
+        catch( Exception e )
+        {
+            e.printStackTrace();
+        }
+        finally
+        {
+            cc.closeConnections();
+//            shutdown();
+        }
+    }
+
+    @CreateDS(
+        allowAnonAccess = true,
+        enableChangeLog = false,
+        name = "peer1",
+        partitions =
+            {
+                @CreatePartition(
+                    name = "example",
+                    suffix = "dc=example,dc=com",
+                    indexes =
+                        {
+                            @CreateIndex(attribute = "objectClass"),
+                            @CreateIndex(attribute = "dc"),
+                            @CreateIndex(attribute = "ou")
+                    })
+        })
+    @CreateLdapServer(transports =
+        { @CreateTransport(port = 16000, protocol = "LDAP") })
+    @CreateConsumer
+    (
+        remoteHost = "localhost",
+        remotePort = 16001,
+        replUserDn = "uid=admin,ou=system",
+        replUserPassword = "secret",
+        useTls = false,
+        baseDn = "dc=example,dc=com",
+        replicaId = 1,
+        refreshNPersist = true
+    )
+    public static void startPeer1() throws Exception
+    {
+        DirectoryService provDirService = DSAnnotationProcessor.getDirectoryService();
+
+        peer1Server = ServerAnnotationProcessor.getLdapServer( provDirService );
+        peer1Server.setReplicationReqHandler( new SyncReplRequestHandler() );
+        peer1Server.startReplicationProducer();
+        
+        final ReplicationConsumerImpl consumer = ( ReplicationConsumerImpl ) ServerAnnotationProcessor.createConsumer();
+        List<ReplicationConsumer> replConsumers = new ArrayList<ReplicationConsumer>();
+        replConsumers.add( consumer );
+        
+        peer1Server.setReplConsumers( replConsumers );
+        peer1Server.startReplicationConsumers();
+
+        Runnable r = new Runnable()
+        {
+            public void run()
+            {
+                try
+                {
+                    DirectoryService ds = peer1Server.getDirectoryService();
+
+                    Dn configDn = new Dn( ds.getSchemaManager(), "ads-replConsumerId=localhost,ou=system"
);
+                    consumer.getConfig().setConfigEntryDn( configDn );
+
+                    Entry provConfigEntry = new DefaultEntry( ds.getSchemaManager(), configDn,
+                        "objectClass: ads-replConsumer",
+                        "ads-replConsumerId: localhost",
+                        "ads-searchBaseDN", consumer.getConfig().getBaseDn(),
+                        "ads-replProvHostName", consumer.getConfig().getRemoteHost(),
+                        "ads-replProvPort", String.valueOf( consumer.getConfig().getRemotePort()
),
+                        "ads-replRefreshInterval", String.valueOf( consumer.getConfig().getRefreshInterval()
),
+                        "ads-replRefreshNPersist", String.valueOf( consumer.getConfig().isRefreshNPersist()
),
+                        "ads-replSearchScope", consumer.getConfig().getSearchScope().getLdapUrlValue(),
+                        "ads-replSearchFilter", consumer.getConfig().getFilter(),
+                        "ads-replSearchSizeLimit", String.valueOf( consumer.getConfig().getSearchSizeLimit()
),
+                        "ads-replSearchTimeOut", String.valueOf( consumer.getConfig().getSearchTimeout()
),
+                        "ads-replUserDn", consumer.getConfig().getReplUserDn(),
+                        "ads-replUserPassword", consumer.getConfig().getReplUserPassword()
);
+
+                    provConfigEntry.put( "ads-replAliasDerefMode", consumer.getConfig().getAliasDerefMode()
+                        .getJndiValue() );
+                    provConfigEntry.put( "ads-replAttributes", consumer.getConfig().getAttributes()
);
+
+                    CoreSession consumerSession = peer1Server.getDirectoryService().getAdminSession();
+                    consumerSession.add( provConfigEntry );
+                }
+                catch ( Exception e )
+                {
+                    throw new RuntimeException( e );
+                }
+            }
+        };
+
+        Thread t = new Thread( r );
+        t.setDaemon( true );
+        t.start();
+        t.join();
+    }
+
+    @CreateDS(
+        allowAnonAccess = true,
+        enableChangeLog = false,
+        name = "peer2",
+        partitions =
+            {
+                @CreatePartition(
+                    name = "example",
+                    suffix = "dc=example,dc=com",
+                    indexes =
+                        {
+                            @CreateIndex(attribute = "objectClass"),
+                            @CreateIndex(attribute = "dc"),
+                            @CreateIndex(attribute = "ou")
+                    })
+        })
+    @CreateLdapServer(transports =
+        { @CreateTransport(port = 16001, protocol = "LDAP") })
+    @CreateConsumer
+    (
+        remoteHost = "localhost",
+        remotePort = 16000,
+        replUserDn = "uid=admin,ou=system",
+        replUserPassword = "secret",
+        useTls = false,
+        baseDn = "dc=example,dc=com",
+        refreshNPersist = true,
+        replicaId = 1
+    )
+    public static void startPeer2() throws Exception
+    {
+        DirectoryService provDirService = DSAnnotationProcessor.getDirectoryService();
+
+        peer2Server = ServerAnnotationProcessor.getLdapServer( provDirService );
+        peer2Server.setReplicationReqHandler( new SyncReplRequestHandler() );
+        peer2Server.startReplicationProducer();
+        
+        final ReplicationConsumerImpl consumer = ( ReplicationConsumerImpl ) ServerAnnotationProcessor.createConsumer();
+        List<ReplicationConsumer> replConsumers = new ArrayList<ReplicationConsumer>();
+        replConsumers.add( consumer );
+        
+        peer2Server.setReplConsumers( replConsumers );
+        peer2Server.startReplicationConsumers();
+
+        Runnable r = new Runnable()
+        {
+            public void run()
+            {
+                try
+                {
+                    DirectoryService ds = peer2Server.getDirectoryService();
+
+                    Dn configDn = new Dn( ds.getSchemaManager(), "ads-replConsumerId=localhost,ou=system"
);
+                    consumer.getConfig().setConfigEntryDn( configDn );
+
+                    Entry provConfigEntry = new DefaultEntry( ds.getSchemaManager(), configDn,
+                        "objectClass: ads-replConsumer",
+                        "ads-replConsumerId: localhost",
+                        "ads-searchBaseDN", consumer.getConfig().getBaseDn(),
+                        "ads-replProvHostName", consumer.getConfig().getRemoteHost(),
+                        "ads-replProvPort", String.valueOf( consumer.getConfig().getRemotePort()
),
+                        "ads-replRefreshInterval", String.valueOf( consumer.getConfig().getRefreshInterval()
),
+                        "ads-replRefreshNPersist", String.valueOf( consumer.getConfig().isRefreshNPersist()
),
+                        "ads-replSearchScope", consumer.getConfig().getSearchScope().getLdapUrlValue(),
+                        "ads-replSearchFilter", consumer.getConfig().getFilter(),
+                        "ads-replSearchSizeLimit", String.valueOf( consumer.getConfig().getSearchSizeLimit()
),
+                        "ads-replSearchTimeOut", String.valueOf( consumer.getConfig().getSearchTimeout()
),
+                        "ads-replUserDn", consumer.getConfig().getReplUserDn(),
+                        "ads-replUserPassword", consumer.getConfig().getReplUserPassword()
);
+
+                    provConfigEntry.put( "ads-replAliasDerefMode", consumer.getConfig().getAliasDerefMode()
+                        .getJndiValue() );
+                    provConfigEntry.put( "ads-replAttributes", consumer.getConfig().getAttributes()
);
+
+                    CoreSession consumerSession = peer2Server.getDirectoryService().getAdminSession();
+                    consumerSession.add( provConfigEntry );
+                }
+                catch ( Exception e )
+                {
+                    throw new RuntimeException( e );
+                }
+            }
+        };
+
+        Thread t = new Thread( r );
+        t.setDaemon( true );
+        t.start();
+        t.join();
+    }
+    
+    public static void shutdown()
+    {
+        peer1Server.stop();
+        peer2Server.stop();
+    }
+}



Mime
View raw message