def topology(request): """This fixture is used to standalone topology for the 'module'.""" standalone = DirSrv(verbose=False) # Args for the standalone instance args_instance[SER_HOST] = HOST_STANDALONE args_instance[SER_PORT] = PORT_STANDALONE args_instance[SER_SERVERID_PROP] = SERVERID_STANDALONE args_standalone = args_instance.copy() standalone.allocate(args_standalone) # Get the status of the instance and restart it if it exists instance_standalone = standalone.exists() # Remove the instance if instance_standalone: standalone.delete() # Create the instance standalone.create() # Used to retrieve configuration information (dbdir, confdir...) standalone.open() # Delete each instance in the end def fin(): standalone.delete() request.addfinalizer(fin) # Here we have standalone instance up and running return TopologyStandalone(standalone)
def topology(request): """Create DS Deployment""" # Creating standalone instance ... if DEBUGGING: standalone = DirSrv(verbose=True) else: standalone = DirSrv(verbose=False) args_instance[SER_HOST] = HOST_STANDALONE args_instance[SER_PORT] = PORT_STANDALONE args_instance[SER_SERVERID_PROP] = SERVERID_STANDALONE args_instance[SER_CREATION_SUFFIX] = DEFAULT_SUFFIX args_standalone = args_instance.copy() standalone.allocate(args_standalone) instance_standalone = standalone.exists() if instance_standalone: standalone.delete() standalone.create() standalone.open() def fin(): """If we are debugging just stop the instances, otherwise remove them """ if DEBUGGING: standalone.stop(60) else: standalone.delete() request.addfinalizer(fin) # Clear out the tmp dir standalone.clearTmpDir(__file__) return TopologyStandalone(standalone)
def topology(request): global installation1_prefix if installation1_prefix: args_instance[SER_DEPLOYED_DIR] = installation1_prefix # Creating standalone instance ... standalone = DirSrv(verbose=False) args_instance[SER_HOST] = HOST_STANDALONE args_instance[SER_PORT] = PORT_STANDALONE args_instance[SER_SERVERID_PROP] = SERVERID_STANDALONE args_instance[SER_CREATION_SUFFIX] = DEFAULT_SUFFIX args_standalone = args_instance.copy() standalone.allocate(args_standalone) instance_standalone = standalone.exists() if instance_standalone: standalone.delete() standalone.create() standalone.open() # Clear out the tmp dir standalone.clearTmpDir(__file__) def fin(): standalone.delete() sbin_dir = standalone.get_sbin_dir() if not standalone.has_asan(): valgrind_disable(sbin_dir) request.addfinalizer(fin) return TopologyStandalone(standalone)
def topology(request): # Creating standalone instance ... standalone = DirSrv(verbose=False) args_instance[SER_HOST] = HOST_STANDALONE args_instance[SER_PORT] = PORT_STANDALONE args_instance[SER_SERVERID_PROP] = SERVERID_STANDALONE args_instance[SER_CREATION_SUFFIX] = DEFAULT_SUFFIX args_standalone = args_instance.copy() standalone.allocate(args_standalone) instance_standalone = standalone.exists() if instance_standalone: standalone.delete() standalone.create() standalone.open() # Delete each instance in the end def fin(): standalone.delete() request.addfinalizer(fin) # Clear out the tmp dir standalone.clearTmpDir(__file__) return TopologyStandalone(standalone)
def setUp(self): # Create the master instance master = DirSrv(verbose=False) master.log.debug("Master allocated") args = {SER_HOST: HOST_MASTER, SER_PORT: PORT_MASTER, SER_DEPLOYED_DIR: INSTANCE_PREFIX, SER_SERVERID_PROP: SERVERID_MASTER } master.allocate(args) if master.exists(): master.delete() master.create() master.open() self.master = master # Create the consumer instance consumer = DirSrv(verbose=False) consumer.log.debug("Consumer allocated") args = {SER_HOST: HOST_CONSUMER, SER_PORT: PORT_CONSUMER, SER_DEPLOYED_DIR: INSTANCE_PREFIX, SER_SERVERID_PROP: SERVERID_CONSUMER } consumer.allocate(args) if consumer.exists(): consumer.delete() consumer.create() consumer.open() self.consumer = consumer
def topology(request): """Create DS Deployment""" # Creating standalone instance ... standalone = DirSrv(verbose=DEBUGGING) args_instance[SER_HOST] = HOST_STANDALONE args_instance[SER_PORT] = PORT_STANDALONE args_instance[SER_SECURE_PORT] = SECUREPORT_STANDALONE args_instance[SER_SERVERID_PROP] = SERVERID_STANDALONE args_instance[SER_CREATION_SUFFIX] = DEFAULT_SUFFIX args_standalone = args_instance.copy() standalone.allocate(args_standalone) instance_standalone = standalone.exists() if instance_standalone: standalone.delete() standalone.create() standalone.open() def fin(): """If we are debugging just stop the instances, otherwise remove them """ if DEBUGGING: standalone.stop() else: standalone.delete() request.addfinalizer(fin) return TopologyStandalone(standalone)
def topology(request): # Creating standalone instance ... standalone = DirSrv(verbose=False) args_instance[SER_HOST] = HOST_STANDALONE args_instance[SER_PORT] = PORT_STANDALONE args_instance[SER_SERVERID_PROP] = SERVERID_STANDALONE args_instance[SER_CREATION_SUFFIX] = DEFAULT_SUFFIX args_standalone = args_instance.copy() standalone.allocate(args_standalone) instance_standalone = standalone.exists() if instance_standalone: standalone.delete() standalone.create() standalone.open() # Delete each instance in the end def fin(): # This is useful for analysing the test env. standalone.db2ldif(bename=DEFAULT_BENAME, suffixes=[DEFAULT_SUFFIX], excludeSuffixes=[], encrypt=False, \ repl_data=True, outputfile='%s/ldif/%s.ldif' % (standalone.dbdir,SERVERID_STANDALONE )) standalone.clearBackupFS() standalone.backupFS() standalone.delete() request.addfinalizer(fin) # Clear out the tmp dir standalone.clearTmpDir(__file__) return TopologyStandalone(standalone)
def topology(request): """ This fixture is used to create a DirSrv instance for the 'module'. """ schemainst = DirSrv(verbose=False) # Args for the master instance args_instance[SER_HOST] = HOST_STANDALONE args_instance[SER_PORT] = PORT_STANDALONE args_instance[SER_SERVERID_PROP] = SERVERID_STANDALONE schemainst.allocate(args_instance) # Remove all the instance if schemainst.exists(): schemainst.delete() # Create the instance schemainst.create() schemainst.open() def fin(): schemainst.delete() request.addfinalizer(fin) return TopologyStandalone(schemainst)
def topology(request): # Create the master instance master = DirSrv(verbose=False) master.log.debug("Master allocated") args = {SER_HOST: HOST_MASTER, SER_PORT: PORT_MASTER, SER_SERVERID_PROP: SERVERID_MASTER} master.allocate(args) if master.exists(): master.delete() master.create() master.open() # Create the consumer instance consumer = DirSrv(verbose=False) consumer.log.debug("Consumer allocated") args = {SER_HOST: HOST_CONSUMER, SER_PORT: PORT_CONSUMER, SER_SERVERID_PROP: SERVERID_CONSUMER} consumer.allocate(args) if consumer.exists(): consumer.delete() consumer.create() consumer.open() # Delete each instance in the end def fin(): master.delete() consumer.delete() request.addfinalizer(fin) return TopologyReplication(master, consumer)
def topology(request): ''' This fixture is used to standalone topology for the 'module'. At the beginning, It may exists a standalone instance. It may also exists a backup for the standalone instance. ''' standalone = DirSrv(verbose=False) # Args for the standalone instance args_instance[SER_HOST] = HOST_STANDALONE args_instance[SER_PORT] = PORT_STANDALONE args_instance[SER_SERVERID_PROP] = SERVERID_STANDALONE args_standalone = args_instance.copy() standalone.allocate(args_standalone) # Get the status of the instance and restart it if it exists instance_standalone = standalone.exists() if instance_standalone: standalone.delete() # Create the instance standalone.create() # Used to retrieve configuration information (dbdir, confdir...) standalone.open() def fin(): standalone.delete() request.addfinalizer(fin) return TopologyStandalone(standalone)
def topology(request): ''' This fixture is used to standalone topology for the 'module'. ''' standalone = DirSrv(verbose=True) # Args for the standalone instance args_instance[SER_HOST] = HOST_STANDALONE args_instance[SER_PORT] = PORT_STANDALONE args_instance[SER_SERVERID_PROP] = SERVERID_STANDALONE args_standalone = args_instance.copy() standalone.allocate(args_standalone) # Get the status of the instance and restart it if it exists instance_standalone = standalone.exists() # Remove the instance if instance_standalone: standalone.delete() # Create the instance standalone.create() # Used to retrieve configuration information (dbdir, confdir...) standalone.open() # clear the tmp directory standalone.clearTmpDir(__file__) # Here we have standalone instance up and running return TopologyStandalone(standalone)
def topology(request): global installation1_prefix if installation1_prefix: args_instance[SER_DEPLOYED_DIR] = installation1_prefix # Creating standalone instance ... standalone = DirSrv(verbose=False) args_instance[SER_HOST] = HOST_STANDALONE args_instance[SER_PORT] = PORT_STANDALONE args_instance[SER_SERVERID_PROP] = SERVERID_STANDALONE args_instance[SER_CREATION_SUFFIX] = DEFAULT_SUFFIX args_standalone = args_instance.copy() standalone.allocate(args_standalone) instance_standalone = standalone.exists() if instance_standalone: standalone.delete() standalone.create() standalone.open() def fin(): standalone.delete() request.addfinalizer(fin) return TopologyStandalone(standalone)
def topology(request): return # Create the realm first krb = MitKrb5(realm=REALM) if krb.check_realm(): krb.destroy_realm() krb.create_realm() DEBUG = False # Creating master 1... master1 = DirSrv(verbose=DEBUG) args_instance[SER_HOST] = HOST_MASTER_1 args_instance[SER_PORT] = PORT_MASTER_1 args_instance[SER_SERVERID_PROP] = SERVERID_MASTER_1 args_instance[SER_CREATION_SUFFIX] = DEFAULT_SUFFIX args_instance[SER_REALM] = REALM args_instance[SER_STRICT_HOSTNAME_CHECKING] = False args_master = args_instance.copy() master1.allocate(args_master) instance_master1 = master1.exists() if instance_master1: master1.delete() master1.create() # There is some magic in .create that finds the realm, and adds the keytab for us. master1.open() master1.replica.enableReplication(suffix=SUFFIX, role=REPLICAROLE_MASTER, replicaId=REPLICAID_MASTER_1) # Creating master 2... master2 = DirSrv(verbose=DEBUG) args_instance[SER_HOST] = HOST_MASTER_2 args_instance[SER_PORT] = PORT_MASTER_2 args_instance[SER_SERVERID_PROP] = SERVERID_MASTER_2 args_instance[SER_CREATION_SUFFIX] = DEFAULT_SUFFIX args_instance[SER_REALM] = REALM args_instance[SER_STRICT_HOSTNAME_CHECKING] = False args_master = args_instance.copy() master2.allocate(args_master) instance_master2 = master2.exists() if instance_master2: master2.delete() master2.create() master2.open() master2.replica.enableReplication(suffix=SUFFIX, role=REPLICAROLE_MASTER, replicaId=REPLICAID_MASTER_2) # Delete each instance in the end def fin(): master1.delete() master2.delete() if krb.check_realm(): krb.destroy_realm() request.addfinalizer(fin) # Clear out the tmp dir master1.clearTmpDir(__file__) return TopologyReplication(master1, master2)
def topology(request): # Master # # Create the master instance master = DirSrv(verbose=False) master.log.debug("Master allocated") args = { SER_HOST: HOST_MASTER, SER_PORT: PORT_MASTER, SER_SERVERID_PROP: SERVERID_MASTER } master.allocate(args) if master.exists(): master.delete() master.create() master.open() # Enable replication master.replica.enableReplication(suffix=SUFFIX, role=ReplicaRole.MASTER, replicaId=REPLICAID_MASTER) # Consumer # # Create the consumer instance consumer = DirSrv(verbose=False) consumer.log.debug("Consumer allocated") args = { SER_HOST: HOST_CONSUMER, SER_PORT: PORT_CONSUMER, SER_SERVERID_PROP: SERVERID_CONSUMER } consumer.allocate(args) if consumer.exists(): consumer.delete() consumer.create() consumer.open() # Enable replication consumer.replica.enableReplication(suffix=SUFFIX, role=ReplicaRole.CONSUMER) # Delete each instance in the end def fin(): master.delete() consumer.delete() request.addfinalizer(fin) return TopologyReplication(master, consumer)
def setUp(self): instance = DirSrv(verbose=False) instance.log.debug("Instance allocated") args = {SER_HOST: LOCALHOST, SER_PORT: INSTANCE_PORT, SER_DEPLOYED_DIR: INSTANCE_PREFIX, SER_SERVERID_PROP: INSTANCE_SERVERID } instance.allocate(args) if instance.exists(): instance.delete() instance.create() instance.open() self.instance = instance
def setUp(self): # # Master # # Create the master instance master = DirSrv(verbose=False) master.log.debug("Master allocated") args = { SER_HOST: HOST_MASTER, SER_PORT: PORT_MASTER, SER_DEPLOYED_DIR: INSTANCE_PREFIX, SER_SERVERID_PROP: SERVERID_MASTER } master.allocate(args) if master.exists(): master.delete() master.create() master.open() # enable replication master.replica.enableReplication(suffix=SUFFIX, role=REPLICAROLE_MASTER, replicaId=REPLICAID_MASTER) self.master = master # # Consumer # # Create the consumer instance consumer = DirSrv(verbose=False) consumer.log.debug("Consumer allocated") args = { SER_HOST: HOST_CONSUMER, SER_PORT: PORT_CONSUMER, SER_DEPLOYED_DIR: INSTANCE_PREFIX, SER_SERVERID_PROP: SERVERID_CONSUMER } consumer.allocate(args) if consumer.exists(): consumer.delete() consumer.create() consumer.open() # enable replication consumer.replica.enableReplication(suffix=SUFFIX, role=REPLICAROLE_CONSUMER) self.consumer = consumer
def topology(request): instance = DirSrv(verbose=False) instance.log.debug("Instance allocated") args = {SER_HOST: LOCALHOST, SER_PORT: INSTANCE_PORT, SER_SERVERID_PROP: INSTANCE_SERVERID} instance.allocate(args) if instance.exists(): instance.delete() instance.create() instance.open() def fin(): instance.delete() request.addfinalizer(fin) return TopologyInstance(instance)
def topology(request): standalone = DirSrv(verbose=False) standalone.log.debug('Instance allocated') args = {SER_HOST: LOCALHOST, SER_PORT: INSTANCE_PORT, SER_SERVERID_PROP: INSTANCE_SERVERID} standalone.allocate(args) if standalone.exists(): standalone.delete() standalone.create() standalone.open() def fin(): standalone.delete() request.addfinalizer(fin) return TopologyStandalone(standalone)
def topology(request): # Master # # Create the master instance master = DirSrv(verbose=False) master.log.debug("Master allocated") args = {SER_HOST: HOST_MASTER, SER_PORT: PORT_MASTER, SER_SERVERID_PROP: SERVERID_MASTER} master.allocate(args) if master.exists(): master.delete() master.create() master.open() # Enable replication master.replica.enableReplication(suffix=SUFFIX, role=REPLICAROLE_MASTER, replicaId=REPLICAID_MASTER) # Consumer # # Create the consumer instance consumer = DirSrv(verbose=False) consumer.log.debug("Consumer allocated") args = {SER_HOST: HOST_CONSUMER, SER_PORT: PORT_CONSUMER, SER_SERVERID_PROP: SERVERID_CONSUMER} consumer.allocate(args) if consumer.exists(): consumer.delete() consumer.create() consumer.open() # Enable replication consumer.replica.enableReplication(suffix=SUFFIX, role=REPLICAROLE_CONSUMER) # Delete each instance in the end def fin(): master.delete() consumer.delete() request.addfinalizer(fin) return TopologyReplication(master, consumer)
def topology(request): standalone = DirSrv(verbose=False) standalone.log.debug("Instance allocated") args = {SER_HOST: LOCALHOST, SER_PORT: INSTANCE_PORT, # SER_DEPLOYED_DIR: INSTANCE_PREFIX, SER_SERVERID_PROP: INSTANCE_SERVERID} standalone.allocate(args) if standalone.exists(): standalone.delete() standalone.create() standalone.open() def fin(): standalone.delete() request.addfinalizer(fin) return TopologyStandalone(standalone)
def topology(request): # Create the realm instance = DirSrv(verbose=False) instance.log.debug("Instance allocated") args = {SER_PORT: INSTANCE_PORT, SER_SERVERID_PROP: INSTANCE_SERVERID} instance.allocate(args) if instance.exists(): instance.delete() instance.create() instance.open() def fin(): if instance.exists(): instance.delete() request.addfinalizer(fin) return TopologyInstance(instance)
def setUp(self): # # Master # # Create the master instance master = DirSrv(verbose=False) master.log.debug("Master allocated") args = {SER_HOST: HOST_MASTER, SER_PORT: PORT_MASTER, SER_DEPLOYED_DIR: INSTANCE_PREFIX, SER_SERVERID_PROP: SERVERID_MASTER } master.allocate(args) if master.exists(): master.delete() master.create() master.open() # enable replication master.replica.enableReplication(suffix=SUFFIX, role=REPLICAROLE_MASTER, replicaId=REPLICAID_MASTER) self.master = master # # Consumer # # Create the consumer instance consumer = DirSrv(verbose=False) consumer.log.debug("Consumer allocated") args = {SER_HOST: HOST_CONSUMER, SER_PORT: PORT_CONSUMER, SER_DEPLOYED_DIR: INSTANCE_PREFIX, SER_SERVERID_PROP: SERVERID_CONSUMER } consumer.allocate(args) if consumer.exists(): consumer.delete() consumer.create() consumer.open() # enable replication consumer.replica.enableReplication(suffix=SUFFIX, role=REPLICAROLE_CONSUMER) self.consumer = consumer
def create_instance(config_attr): log.info('create_instance - Installs the instance and Sets the value of InstScriptsEnabled to true OR false.') log.info("Set up the instance and set the config_attr") instance_data = generate_ds_params(1, ReplicaRole.STANDALONE) # Create instance standalone = DirSrv(verbose=False) # Args for the instance args_instance[SER_HOST] = instance_data[SER_HOST] args_instance[SER_PORT] = instance_data[SER_PORT] args_instance[SER_SERVERID_PROP] = instance_data[SER_SERVERID_PROP] args_instance[SER_CREATION_SUFFIX] = DEFAULT_SUFFIX args_instance[SER_INST_SCRIPTS_ENABLED] = config_attr args_standalone = args_instance.copy() standalone.allocate(args_standalone) if standalone.exists(): standalone.delete() standalone.create() standalone.open() return standalone
def topology(request): # Creating standalone instance ... standalone = DirSrv(verbose=False) args_instance[SER_HOST] = HOST_STANDALONE args_instance[SER_PORT] = PORT_STANDALONE args_instance[SER_SERVERID_PROP] = SERVERID_STANDALONE args_instance[SER_CREATION_SUFFIX] = DEFAULT_SUFFIX args_standalone = args_instance.copy() standalone.allocate(args_standalone) instance_standalone = standalone.exists() if instance_standalone: standalone.delete() standalone.create() standalone.open() # Delete each instance in the end def fin(): #standalone.delete() pass request.addfinalizer(fin) return TopologyStandalone(standalone)
def topology(request): standalone = DirSrv(verbose=False) standalone.log.debug("Instance allocated") args = { SER_PORT: INSTANCE_PORT, # SER_DEPLOYED_DIR: INSTANCE_PREFIX, SER_SERVERID_PROP: INSTANCE_SERVERID } standalone.allocate(args) if standalone.exists(): standalone.delete() standalone.create() standalone.open() standalone.config.set('nsslapd-accesslog-logbuffering', 'off') def fin(): standalone.delete() request.addfinalizer(fin) # We have to wait for time to elapse for the access log to be flushed. return TopologyStandalone(standalone)
def topology(request): # Create the master instance master = DirSrv(verbose=False) master.log.debug("Master allocated") args = { SER_HOST: HOST_MASTER, SER_PORT: PORT_MASTER, SER_SERVERID_PROP: SERVERID_MASTER } master.allocate(args) if master.exists(): master.delete() master.create() master.open() # Create the consumer instance consumer = DirSrv(verbose=False) consumer.log.debug("Consumer allocated") args = { SER_HOST: HOST_CONSUMER, SER_PORT: PORT_CONSUMER, SER_SERVERID_PROP: SERVERID_CONSUMER } consumer.allocate(args) if consumer.exists(): consumer.delete() consumer.create() consumer.open() # Delete each instance in the end def fin(): master.delete() consumer.delete() request.addfinalizer(fin) return TopologyReplication(master, consumer)
def topology(request): # Create the realm krb = MitKrb5(realm=REALM) instance = DirSrv(verbose=False) instance.log.debug("Instance allocated") # WARNING: If this test fails it's like a hostname issue!!! args = {SER_HOST: socket.gethostname(), SER_PORT: INSTANCE_PORT, SER_REALM: REALM, SER_SERVERID_PROP: INSTANCE_SERVERID} instance.allocate(args) if instance.exists(): instance.delete() # Its likely our realm exists too # Remove the old keytab if os.path.exists(KEYTAB): os.remove(KEYTAB) if krb.check_realm(): krb.destroy_realm() # This will automatically create the krb entries krb.create_realm() instance.create() instance.open() def fin(): if instance.exists(): instance.delete() if krb.check_realm(): krb.destroy_realm() if os.path.exists(KEYTAB): os.remove(KEYTAB) if os.path.exists(CCACHE): os.remove(CCACHE) request.addfinalizer(fin) return TopologyInstance(instance)
def topology(request): global installation1_prefix if installation1_prefix: args_instance[SER_DEPLOYED_DIR] = installation1_prefix # Creating master 1... master1 = DirSrv(verbose=False) args_instance[SER_HOST] = HOST_MASTER_1 args_instance[SER_PORT] = PORT_MASTER_1 args_instance[SER_SERVERID_PROP] = SERVERID_MASTER_1 args_instance[SER_CREATION_SUFFIX] = DEFAULT_SUFFIX args_master = args_instance.copy() master1.allocate(args_master) instance_master1 = master1.exists() if instance_master1: master1.delete() master1.create() master1.open() master1.replica.enableReplication(suffix=SUFFIX, role=REPLICAROLE_MASTER, replicaId=REPLICAID_MASTER_1) # Creating master 2... master2 = DirSrv(verbose=False) args_instance[SER_HOST] = HOST_MASTER_2 args_instance[SER_PORT] = PORT_MASTER_2 args_instance[SER_SERVERID_PROP] = SERVERID_MASTER_2 args_instance[SER_CREATION_SUFFIX] = DEFAULT_SUFFIX args_master = args_instance.copy() master2.allocate(args_master) instance_master2 = master2.exists() if instance_master2: master2.delete() master2.create() master2.open() master2.replica.enableReplication(suffix=SUFFIX, role=REPLICAROLE_MASTER, replicaId=REPLICAID_MASTER_2) # # Create all the agreements # # Creating agreement from master 1 to master 2 properties = {RA_NAME: 'meTo_%s:%s' %(master2.host, master2.port), RA_BINDDN: defaultProperties[REPLICATION_BIND_DN], RA_BINDPW: defaultProperties[REPLICATION_BIND_PW], RA_METHOD: defaultProperties[REPLICATION_BIND_METHOD], RA_TRANSPORT_PROT: defaultProperties[REPLICATION_TRANSPORT]} m1_m2_agmt = master1.agreement.create(suffix=SUFFIX, host=master2.host, port=master2.port, properties=properties) if not m1_m2_agmt: log.fatal("Fail to create a master -> master replica agreement") sys.exit(1) log.debug("%s created" % m1_m2_agmt) # Creating agreement from master 2 to master 1 properties = {RA_NAME: 'meTo_%s:%s' %(master1.host, master1.port), RA_BINDDN: defaultProperties[REPLICATION_BIND_DN], RA_BINDPW: defaultProperties[REPLICATION_BIND_PW], RA_METHOD: defaultProperties[REPLICATION_BIND_METHOD], RA_TRANSPORT_PROT: defaultProperties[REPLICATION_TRANSPORT]} m2_m1_agmt = master2.agreement.create(suffix=SUFFIX, host=master1.host, port=master1.port, properties=properties) if not m2_m1_agmt: log.fatal("Fail to create a master -> master replica agreement") sys.exit(1) log.debug("%s created" % m2_m1_agmt) # Allow the replicas to get situated with the new agreements... time.sleep(5) # # Initialize all the agreements # master1.agreement.init(SUFFIX, HOST_MASTER_2, PORT_MASTER_2) master1.waitForReplInit(m1_m2_agmt) master2.agreement.init(SUFFIX, HOST_MASTER_1, PORT_MASTER_1) master2.waitForReplInit(m2_m1_agmt) # Check replication is working... if master1.testReplication(DEFAULT_SUFFIX, master2): log.info('Replication is working.') else: log.fatal('Replication is not working.') assert False log.info("Set Replication Debugging loglevel for the errorlog") master1.setLogLevel(LOG_REPLICA) master2.setLogLevel(LOG_REPLICA) logging_attr = 'nsslapd-logging-hr-timestamps-enabled' master1.modify_s("cn=config", [(ldap.MOD_REPLACE, logging_attr, "off")]) master2.modify_s("cn=config", [(ldap.MOD_REPLACE, logging_attr, "off")]) # Delete each instance in the end def fin(): master1.delete() master2.delete() request.addfinalizer(fin) # Clear out the tmp dir master1.clearTmpDir(__file__) return TopologyReplication(master1, master2, m1_m2_agmt, m2_m1_agmt)
class Test_dirsrv(): def _add_user(self, success=True): try: self.instance.add_s(Entry((TEST_REPL_DN, {'objectclass': "top person organizationalPerson inetOrgPerson".split(), 'uid': 'test', 'sn': 'test', 'cn': 'test'}))) except Exception as e: if success: raise else: self.instance.log.info('Fail to add (expected): %s' % e.args) return self.instance.log.info('%s added' % TEST_REPL_DN) def _mod_user(self, success=True): try: replace = [(ldap.MOD_REPLACE, 'description', str(randint(1, 100)))] self.instance.modify_s(TEST_REPL_DN, replace) except Exception as e: if success: raise else: self.instance.log.info('Fail to modify (expected): %s' % e.args) return self.instance.log.info('%s modified' % TEST_REPL_DN) def setUp(self): pass def tearDown(self): pass def test_allocate(self, verbose=False): instance = DirSrv(verbose=verbose) instance.log.debug("Instance allocated") assert instance.state == DIRSRV_STATE_INIT # Allocate the instance args = {SER_HOST: LOCALHOST, SER_PORT: INSTANCE_PORT, SER_DEPLOYED_DIR: INSTANCE_PREFIX, SER_SERVERID_PROP: INSTANCE_SERVERID } instance.allocate(args) userid = pwd.getpwuid( os.getuid() )[ 0 ] # Now verify the settings assert instance.state == DIRSRV_STATE_ALLOCATED assert instance.host == LOCALHOST assert instance.port == INSTANCE_PORT assert instance.sslport == None assert instance.binddn == DN_DM assert instance.bindpw == PW_DM assert instance.creation_suffix == DEFAULT_SUFFIX assert instance.userid == userid assert instance.serverid == INSTANCE_SERVERID assert instance.groupid == instance.userid assert instance.prefix == INSTANCE_PREFIX assert instance.backupdir == INSTANCE_BACKUP # Now check we can change the settings of an allocated DirSrv args = {SER_SERVERID_PROP:INSTANCE_SERVERID, SER_HOST: LOCALHOST, SER_PORT: INSTANCE_PORT, SER_DEPLOYED_DIR: INSTANCE_PREFIX, SER_ROOT_DN: "uid=foo"} instance.allocate(args) assert instance.state == DIRSRV_STATE_ALLOCATED assert instance.host == LOCALHOST assert instance.port == INSTANCE_PORT assert instance.sslport == None assert instance.binddn == "uid=foo" assert instance.bindpw == PW_DM assert instance.creation_suffix == DEFAULT_SUFFIX assert instance.userid == userid assert instance.serverid == INSTANCE_SERVERID assert instance.groupid == instance.userid assert instance.prefix == INSTANCE_PREFIX assert instance.backupdir == INSTANCE_BACKUP # OK restore back the valid parameters args = {SER_SERVERID_PROP:INSTANCE_SERVERID, SER_HOST: LOCALHOST, SER_PORT: INSTANCE_PORT, SER_DEPLOYED_DIR: INSTANCE_PREFIX} instance.allocate(args) assert instance.state == DIRSRV_STATE_ALLOCATED assert instance.host == LOCALHOST assert instance.port == INSTANCE_PORT assert instance.sslport == None assert instance.binddn == DN_DM assert instance.bindpw == PW_DM assert instance.creation_suffix == DEFAULT_SUFFIX assert instance.userid == userid assert instance.serverid == INSTANCE_SERVERID assert instance.groupid == instance.userid assert instance.prefix == INSTANCE_PREFIX assert instance.backupdir == INSTANCE_BACKUP self.instance = instance def test_list_init(self): ''' Lists the instances on the file system ''' for properties in self.instance.list(): self.instance.log.info("properties: %r" % properties) for properties in self.instance.list(all=True): self.instance.log.info("properties (all): %r" % properties) def test_allocated_to_offline(self): self.instance.create() def test_offline_to_online(self): self.instance.open() def test_online_to_offline(self): self.instance.close() def test_offline_to_allocated(self): self.instance.delete() def test_allocated_to_online(self, verbose): # Here the instance was already create, check we can connect to it # without creating it (especially without serverid value) # Allocate the instance args = {SER_HOST: LOCALHOST, SER_PORT: INSTANCE_PORT, SER_DEPLOYED_DIR: INSTANCE_PREFIX, SER_SERVERID_PROP: INSTANCE_SERVERID } self.instance.log.info("test_allocated_to_online: Create an instance") self.instance = DirSrv(verbose=verbose) assert not hasattr(self, 'serverid') self.instance.allocate(args) self.instance.create() self.instance.open() assert self.instance.serverid != None # The instance is create, allocate a new DirSrv self.instance.log.info("test_allocated_to_online: instance New") self.instance = DirSrv(verbose=verbose) assert not hasattr(self, 'serverid') assert self.instance.state == DIRSRV_STATE_INIT args = {SER_HOST: LOCALHOST, SER_PORT: INSTANCE_PORT, SER_DEPLOYED_DIR: INSTANCE_PREFIX, } self.instance.allocate(args) self.instance.log.info("test_allocated_to_online: instance Allocated") assert self.instance.serverid == None assert self.instance.state == DIRSRV_STATE_ALLOCATED self.instance.open() self.instance.log.info("test_allocated_to_online: instance online") assert self.instance.serverid != None assert self.instance.serverid == self.instance.inst assert self.instance.state == DIRSRV_STATE_ONLINE
def test_dynamic_plugins(topology): """ Test Dynamic Plugins - exercise each plugin and its main features, while changing the configuration without restarting the server. Need to test: functionality, stability, and stress. These tests need to run with replication disabled, and with replication setup with a second instance. Then test if replication is working, and we have same entries on each side. Functionality - Make sure that as configuration changes are made they take effect immediately. Cross plugin interaction (e.g. automember/memberOf) needs to tested, as well as plugin tasks. Need to test plugin config validation(dependencies, etc). Memory Corruption - Restart the plugins many times, and in different orders and test functionality, and stability. This will excerise the internal plugin linked lists, dse callbacks, and task handlers. Stress - Put the server under load that will trigger multiple plugins(MO, RI, DNA, etc) Restart various plugins while these operations are going on. Perform this test 5 times(stress_max_run). """ REPLICA_PORT = 33334 RUV_FILTER = '(&(nsuniqueid=ffffffff-ffffffff-ffffffff-ffffffff)(objectclass=nstombstone))' master_maxcsn = 0 replica_maxcsn = 0 msg = ' (no replication)' replication_run = False stress_max_runs = 5 # First enable dynamic plugins try: topology.standalone.modify_s(DN_CONFIG, [(ldap.MOD_REPLACE, 'nsslapd-dynamic-plugins', 'on')]) except ldap.LDAPError as e: ldap.fatal('Failed to enable dynamic plugin!' + e.message['desc']) assert False # Test that critical plugins can be updated even though the change might not be applied try: topology.standalone.modify_s(DN_LDBM, [(ldap.MOD_REPLACE, 'description', 'test')]) except ldap.LDAPError as e: ldap.fatal('Failed to apply change to critical plugin' + e.message['desc']) assert False while 1: # # First run the tests with replication disabled, then rerun them with replication set up # ############################################################################ # Test plugin functionality ############################################################################ log.info('####################################################################') log.info('Testing Dynamic Plugins Functionality' + msg + '...') log.info('####################################################################\n') plugin_tests.test_all_plugins(topology.standalone) log.info('####################################################################') log.info('Successfully Tested Dynamic Plugins Functionality' + msg + '.') log.info('####################################################################\n') ############################################################################ # Test the stability by exercising the internal lists, callabcks, and task handlers ############################################################################ log.info('####################################################################') log.info('Testing Dynamic Plugins for Memory Corruption' + msg + '...') log.info('####################################################################\n') prev_plugin_test = None prev_prev_plugin_test = None for plugin_test in plugin_tests.func_tests: # # Restart the plugin several times (and prev plugins) - work that linked list # plugin_test(topology.standalone, "restart") if prev_prev_plugin_test: prev_prev_plugin_test(topology.standalone, "restart") plugin_test(topology.standalone, "restart") if prev_plugin_test: prev_plugin_test(topology.standalone, "restart") plugin_test(topology.standalone, "restart") # Now run the functional test plugin_test(topology.standalone) # Set the previous tests if prev_plugin_test: prev_prev_plugin_test = prev_plugin_test prev_plugin_test = plugin_test log.info('####################################################################') log.info('Successfully Tested Dynamic Plugins for Memory Corruption' + msg + '.') log.info('####################################################################\n') ############################################################################ # Stress two plugins while restarting it, and while restarting other plugins. # The goal is to not crash, and have the plugins work after stressing them. ############################################################################ log.info('####################################################################') log.info('Stressing Dynamic Plugins' + msg + '...') log.info('####################################################################\n') stress_tests.configureMO(topology.standalone) stress_tests.configureRI(topology.standalone) stress_count = 0 while stress_count < stress_max_runs: log.info('####################################################################') log.info('Running stress test' + msg + '. Run (%d/%d)...' % (stress_count + 1, stress_max_runs)) log.info('####################################################################\n') try: # Launch three new threads to add a bunch of users add_users = stress_tests.AddUsers(topology.standalone, 'employee', True) add_users.start() add_users2 = stress_tests.AddUsers(topology.standalone, 'entry', True) add_users2.start() add_users3 = stress_tests.AddUsers(topology.standalone, 'person', True) add_users3.start() time.sleep(1) # While we are adding users restart the MO plugin and an idle plugin topology.standalone.plugins.disable(name=PLUGIN_MEMBER_OF) topology.standalone.plugins.enable(name=PLUGIN_MEMBER_OF) time.sleep(1) topology.standalone.plugins.disable(name=PLUGIN_MEMBER_OF) time.sleep(1) topology.standalone.plugins.enable(name=PLUGIN_MEMBER_OF) topology.standalone.plugins.disable(name=PLUGIN_LINKED_ATTRS) topology.standalone.plugins.enable(name=PLUGIN_LINKED_ATTRS) time.sleep(1) topology.standalone.plugins.disable(name=PLUGIN_MEMBER_OF) topology.standalone.plugins.enable(name=PLUGIN_MEMBER_OF) time.sleep(2) topology.standalone.plugins.disable(name=PLUGIN_MEMBER_OF) time.sleep(1) topology.standalone.plugins.enable(name=PLUGIN_MEMBER_OF) topology.standalone.plugins.disable(name=PLUGIN_LINKED_ATTRS) topology.standalone.plugins.enable(name=PLUGIN_LINKED_ATTRS) topology.standalone.plugins.disable(name=PLUGIN_MEMBER_OF) time.sleep(1) topology.standalone.plugins.enable(name=PLUGIN_MEMBER_OF) topology.standalone.plugins.disable(name=PLUGIN_MEMBER_OF) topology.standalone.plugins.enable(name=PLUGIN_MEMBER_OF) # Wait for the 'adding' threads to complete add_users.join() add_users2.join() add_users3.join() # Now launch three threads to delete the users del_users = stress_tests.DelUsers(topology.standalone, 'employee') del_users.start() del_users2 = stress_tests.DelUsers(topology.standalone, 'entry') del_users2.start() del_users3 = stress_tests.DelUsers(topology.standalone, 'person') del_users3.start() time.sleep(1) # Restart both the MO, RI plugins during these deletes, and an idle plugin topology.standalone.plugins.disable(name=PLUGIN_REFER_INTEGRITY) topology.standalone.plugins.disable(name=PLUGIN_MEMBER_OF) topology.standalone.plugins.enable(name=PLUGIN_MEMBER_OF) topology.standalone.plugins.enable(name=PLUGIN_REFER_INTEGRITY) time.sleep(1) topology.standalone.plugins.disable(name=PLUGIN_REFER_INTEGRITY) time.sleep(1) topology.standalone.plugins.disable(name=PLUGIN_MEMBER_OF) time.sleep(1) topology.standalone.plugins.enable(name=PLUGIN_MEMBER_OF) time.sleep(1) topology.standalone.plugins.enable(name=PLUGIN_REFER_INTEGRITY) topology.standalone.plugins.disable(name=PLUGIN_LINKED_ATTRS) topology.standalone.plugins.enable(name=PLUGIN_LINKED_ATTRS) topology.standalone.plugins.disable(name=PLUGIN_REFER_INTEGRITY) topology.standalone.plugins.disable(name=PLUGIN_MEMBER_OF) topology.standalone.plugins.enable(name=PLUGIN_MEMBER_OF) topology.standalone.plugins.enable(name=PLUGIN_REFER_INTEGRITY) time.sleep(2) topology.standalone.plugins.disable(name=PLUGIN_REFER_INTEGRITY) time.sleep(1) topology.standalone.plugins.disable(name=PLUGIN_MEMBER_OF) time.sleep(1) topology.standalone.plugins.enable(name=PLUGIN_MEMBER_OF) time.sleep(1) topology.standalone.plugins.enable(name=PLUGIN_REFER_INTEGRITY) topology.standalone.plugins.disable(name=PLUGIN_LINKED_ATTRS) topology.standalone.plugins.enable(name=PLUGIN_LINKED_ATTRS) # Wait for the 'deleting' threads to complete del_users.join() del_users2.join() del_users3.join() # Now make sure both the MO and RI plugins still work correctly plugin_tests.func_tests[8](topology.standalone) # RI plugin plugin_tests.func_tests[5](topology.standalone) # MO plugin # Cleanup the stress tests stress_tests.cleanup(topology.standalone) except: log.info('Stress test failed!') repl_fail(replica_inst) stress_count += 1 log.info('####################################################################') log.info('Successfully Stressed Dynamic Plugins' + msg + '. Completed (%d/%d)' % (stress_count, stress_max_runs)) log.info('####################################################################\n') if replication_run: # We're done. break else: # # Enable replication and run everything one more time # log.info('Setting up replication, and rerunning the tests...\n') # Create replica instance replica_inst = DirSrv(verbose=False) args_instance[SER_HOST] = LOCALHOST args_instance[SER_PORT] = REPLICA_PORT args_instance[SER_SERVERID_PROP] = 'replica' args_instance[SER_CREATION_SUFFIX] = DEFAULT_SUFFIX args_replica_inst = args_instance.copy() replica_inst.allocate(args_replica_inst) replica_inst.create() replica_inst.open() try: topology.standalone.replica.enableReplication(suffix=DEFAULT_SUFFIX, role=REPLICAROLE_MASTER, replicaId=1) replica_inst.replica.enableReplication(suffix=DEFAULT_SUFFIX, role=REPLICAROLE_CONSUMER, replicaId=65535) properties = {RA_NAME: r'to_replica', RA_BINDDN: defaultProperties[REPLICATION_BIND_DN], RA_BINDPW: defaultProperties[REPLICATION_BIND_PW], RA_METHOD: defaultProperties[REPLICATION_BIND_METHOD], RA_TRANSPORT_PROT: defaultProperties[REPLICATION_TRANSPORT]} repl_agreement = topology.standalone.agreement.create(suffix=DEFAULT_SUFFIX, host=LOCALHOST, port=REPLICA_PORT, properties=properties) if not repl_agreement: log.fatal("Fail to create a replica agreement") repl_fail(replica_inst) topology.standalone.agreement.init(DEFAULT_SUFFIX, LOCALHOST, REPLICA_PORT) topology.standalone.waitForReplInit(repl_agreement) except: log.info('Failed to setup replication!') repl_fail(replica_inst) replication_run = True msg = ' (replication enabled)' time.sleep(1) ############################################################################ # Check replication, and data are in sync, and remove the instance ############################################################################ log.info('Checking if replication is in sync...') try: # Grab master's max CSN entry = topology.standalone.search_s(DEFAULT_SUFFIX, ldap.SCOPE_SUBTREE, RUV_FILTER) if not entry: log.error('Failed to find db tombstone entry from master') repl_fail(replica_inst) elements = entry[0].getValues('nsds50ruv') for ruv in elements: if 'replica 1' in ruv: parts = ruv.split() if len(parts) == 5: master_maxcsn = parts[4] break else: log.error('RUV is incomplete') repl_fail(replica_inst) if master_maxcsn == 0: log.error('Failed to find maxcsn on master') repl_fail(replica_inst) except ldap.LDAPError as e: log.fatal('Unable to search masterfor db tombstone: ' + e.message['desc']) repl_fail(replica_inst) # Loop on the consumer - waiting for it to catch up count = 0 insync = False while count < 60: try: # Grab master's max CSN entry = replica_inst.search_s(DEFAULT_SUFFIX, ldap.SCOPE_SUBTREE, RUV_FILTER) if not entry: log.error('Failed to find db tombstone entry on consumer') repl_fail(replica_inst) elements = entry[0].getValues('nsds50ruv') for ruv in elements: if 'replica 1' in ruv: parts = ruv.split() if len(parts) == 5: replica_maxcsn = parts[4] break if replica_maxcsn == 0: log.error('Failed to find maxcsn on consumer') repl_fail(replica_inst) except ldap.LDAPError as e: log.fatal('Unable to search for db tombstone on consumer: ' + e.message['desc']) repl_fail(replica_inst) if master_maxcsn == replica_maxcsn: insync = True log.info('Replication is in sync.\n') break count += 1 time.sleep(1) # Report on replication status if not insync: log.error('Consumer not in sync with master!') repl_fail(replica_inst) # # Verify the databases are identical. There should not be any "user, entry, employee" entries # log.info('Checking if the data is the same between the replicas...') # Check the master try: entries = topology.standalone.search_s(DEFAULT_SUFFIX, ldap.SCOPE_SUBTREE, "(|(uid=person*)(uid=entry*)(uid=employee*))") if len(entries) > 0: log.error('Master database has incorrect data set!\n') repl_fail(replica_inst) except ldap.LDAPError as e: log.fatal('Unable to search db on master: ' + e.message['desc']) repl_fail(replica_inst) # Check the consumer try: entries = replica_inst.search_s(DEFAULT_SUFFIX, ldap.SCOPE_SUBTREE, "(|(uid=person*)(uid=entry*)(uid=employee*))") if len(entries) > 0: log.error('Consumer database in not consistent with master database') repl_fail(replica_inst) except ldap.LDAPError as e: log.fatal('Unable to search db on consumer: ' + e.message['desc']) repl_fail(replica_inst) log.info('Data is consistent across the replicas.\n') log.info('####################################################################') log.info('Replication consistency test passed') log.info('####################################################################\n') # Remove the replica instance replica_inst.delete() ############################################################################ # We made it to the end! ############################################################################ log.info('#####################################################') log.info('#####################################################') log.info("Dynamic Plugins Testsuite: Completed Successfully!") log.info('#####################################################') log.info('#####################################################\n')
def topology(request): """Create Replication Deployment""" # Creating master 1... if DEBUGGING: master1 = DirSrv(verbose=True) else: master1 = DirSrv(verbose=False) args_instance[SER_HOST] = HOST_MASTER_1 args_instance[SER_PORT] = PORT_MASTER_1 args_instance[SER_SERVERID_PROP] = SERVERID_MASTER_1 args_instance[SER_CREATION_SUFFIX] = DEFAULT_SUFFIX args_master = args_instance.copy() master1.allocate(args_master) instance_master1 = master1.exists() if instance_master1: master1.delete() master1.create() master1.open() master1.replica.enableReplication(suffix=SUFFIX, role=REPLICAROLE_MASTER, replicaId=REPLICAID_MASTER_1) # Creating master 2... if DEBUGGING: master2 = DirSrv(verbose=True) else: master2 = DirSrv(verbose=False) args_instance[SER_HOST] = HOST_MASTER_2 args_instance[SER_PORT] = PORT_MASTER_2 args_instance[SER_SERVERID_PROP] = SERVERID_MASTER_2 args_instance[SER_CREATION_SUFFIX] = DEFAULT_SUFFIX args_master = args_instance.copy() master2.allocate(args_master) instance_master2 = master2.exists() if instance_master2: master2.delete() master2.create() master2.open() master2.replica.enableReplication(suffix=SUFFIX, role=REPLICAROLE_MASTER, replicaId=REPLICAID_MASTER_2) # # Create all the agreements # # Creating agreement from master 1 to master 2 properties = {RA_NAME: 'meTo_' + master2.host + ':' + str(master2.port), RA_BINDDN: defaultProperties[REPLICATION_BIND_DN], RA_BINDPW: defaultProperties[REPLICATION_BIND_PW], RA_METHOD: defaultProperties[REPLICATION_BIND_METHOD], RA_TRANSPORT_PROT: defaultProperties[REPLICATION_TRANSPORT]} m1_m2_agmt = master1.agreement.create(suffix=SUFFIX, host=master2.host, port=master2.port, properties=properties) if not m1_m2_agmt: log.fatal("Fail to create a master -> master replica agreement") sys.exit(1) log.debug("%s created" % m1_m2_agmt) # Creating agreement from master 2 to master 1 properties = {RA_NAME: 'meTo_' + master1.host + ':' + str(master1.port), RA_BINDDN: defaultProperties[REPLICATION_BIND_DN], RA_BINDPW: defaultProperties[REPLICATION_BIND_PW], RA_METHOD: defaultProperties[REPLICATION_BIND_METHOD], RA_TRANSPORT_PROT: defaultProperties[REPLICATION_TRANSPORT]} m2_m1_agmt = master2.agreement.create(suffix=SUFFIX, host=master1.host, port=master1.port, properties=properties) if not m2_m1_agmt: log.fatal("Fail to create a master -> master replica agreement") sys.exit(1) log.debug("%s created" % m2_m1_agmt) # Allow the replicas to get situated with the new agreements... time.sleep(5) # # Initialize all the agreements # master1.agreement.init(SUFFIX, HOST_MASTER_2, PORT_MASTER_2) master1.waitForReplInit(m1_m2_agmt) # Check replication is working... if master1.testReplication(DEFAULT_SUFFIX, master2): log.info('Replication is working.') else: log.fatal('Replication is not working.') assert False def fin(): """If we are debugging just stop the instances, otherwise remove them """ if DEBUGGING: master1.stop() master2.stop() else: master1.delete() master2.delete() request.addfinalizer(fin) # Clear out the tmp dir master1.clearTmpDir(__file__) return TopologyReplication(master1, master2)
def _create_instances(topo_dict, suffix): """Create requested instances without replication or any other modifications :param topo_dict: a dictionary {ReplicaRole.STANDALONE: num, ReplicaRole.MASTER: num, ReplicaRole.HUB: num, ReplicaRole.CONSUMER: num} :type topo_dict: dict :param suffix: a suffix :type suffix: str :return - TopologyMain object """ instances = {} ms = {} cs = {} hs = {} ins = {} # Create instances for role in topo_dict.keys(): for inst_num in range(1, topo_dict[role]+1): instance_data = generate_ds_params(inst_num, role) if DEBUGGING: instance = DirSrv(verbose=True) else: instance = DirSrv(verbose=False) # TODO: Put 'args_instance' to generate_ds_params. # Also, we need to keep in mind that the function returns # SER_SECURE_PORT and REPLICA_ID that are not used in # the instance creation here. # args_instance[SER_HOST] = instance_data[SER_HOST] args_instance = {} args_instance[SER_PORT] = instance_data[SER_PORT] args_instance[SER_SECURE_PORT] = instance_data[SER_SECURE_PORT] args_instance[SER_SERVERID_PROP] = instance_data[SER_SERVERID_PROP] # It's required to be able to make a suffix-less install for # some cli tests. It's invalid to require replication with # no suffix however .... if suffix is not None: args_instance[SER_CREATION_SUFFIX] = suffix elif role != ReplicaRole.STANDALONE: raise AssertionError("Invalid request to make suffix-less replicated environment") instance.allocate(args_instance) instance_exists = instance.exists() if instance_exists: instance.delete(pyinstall=PYINSTALL) instance.create(pyinstall=PYINSTALL) # We set a URL here to force ldap:// only. Once we turn on TLS # we'll flick this to ldaps. instance.use_ldap_uri() instance.open() if role == ReplicaRole.STANDALONE: ins[instance.serverid] = instance instances.update(ins) if role == ReplicaRole.MASTER: ms[instance.serverid] = instance instances.update(ms) if role == ReplicaRole.CONSUMER: cs[instance.serverid] = instance instances.update(cs) if role == ReplicaRole.HUB: hs[instance.serverid] = instance instances.update(hs) if DEBUGGING: instance.config.set('nsslapd-accesslog-logbuffering','off') instance.config.set('nsslapd-errorlog-level','8192') instance.config.set('nsslapd-auditlog-logging-enabled','on') log.info("Instance with parameters {} was created.".format(args_instance)) if "standalone1" in instances and len(instances) == 1: return TopologyMain(standalones=instances["standalone1"]) else: return TopologyMain(standalones=ins, masters=ms, consumers=cs, hubs=hs)
def topology(request): ''' This fixture is used to create a replicated topology for the 'module'. The replicated topology is MASTER1 <-> Master2. ''' global installation1_prefix global installation2_prefix # allocate master1 on a given deployement master1 = DirSrv(verbose=False) if installation1_prefix: args_instance[SER_DEPLOYED_DIR] = installation1_prefix # Args for the master1 instance args_instance[SER_HOST] = HOST_MASTER_1 args_instance[SER_PORT] = PORT_MASTER_1 args_instance[SER_SERVERID_PROP] = SERVERID_MASTER_1 args_master = args_instance.copy() master1.allocate(args_master) # allocate master1 on a given deployement master2 = DirSrv(verbose=False) if installation2_prefix: args_instance[SER_DEPLOYED_DIR] = installation2_prefix # Args for the consumer instance args_instance[SER_HOST] = HOST_MASTER_2 args_instance[SER_PORT] = PORT_MASTER_2 args_instance[SER_SERVERID_PROP] = SERVERID_MASTER_2 args_master = args_instance.copy() master2.allocate(args_master) # Get the status of the instance and restart it if it exists instance_master1 = master1.exists() instance_master2 = master2.exists() # Remove all the instances if instance_master1: master1.delete() if instance_master2: master2.delete() # Create the instances master1.create() master1.open() master2.create() master2.open() # # Now prepare the Master-Consumer topology # # First Enable replication master1.replica.enableReplication(suffix=SUFFIX, role=REPLICAROLE_MASTER, replicaId=REPLICAID_MASTER_1) master2.replica.enableReplication(suffix=SUFFIX, role=REPLICAROLE_MASTER, replicaId=REPLICAID_MASTER_2) # Initialize the supplier->consumer properties = {RA_NAME: r'meTo_$host:$port', RA_BINDDN: defaultProperties[REPLICATION_BIND_DN], RA_BINDPW: defaultProperties[REPLICATION_BIND_PW], RA_METHOD: defaultProperties[REPLICATION_BIND_METHOD], RA_TRANSPORT_PROT: defaultProperties[REPLICATION_TRANSPORT]} repl_agreement = master1.agreement.create(suffix=SUFFIX, host=master2.host, port=master2.port, properties=properties) if not repl_agreement: log.fatal("Fail to create a replica agreement") sys.exit(1) log.debug("%s created" % repl_agreement) properties = {RA_NAME: r'meTo_$host:$port', RA_BINDDN: defaultProperties[REPLICATION_BIND_DN], RA_BINDPW: defaultProperties[REPLICATION_BIND_PW], RA_METHOD: defaultProperties[REPLICATION_BIND_METHOD], RA_TRANSPORT_PROT: defaultProperties[REPLICATION_TRANSPORT]} master2.agreement.create(suffix=SUFFIX, host=master1.host, port=master1.port, properties=properties) master1.agreement.init(SUFFIX, HOST_MASTER_2, PORT_MASTER_2) master1.waitForReplInit(repl_agreement) # Check replication is working fine if master1.testReplication(DEFAULT_SUFFIX, master2): log.info('Replication is working.') else: log.fatal('Replication is not working.') assert False def fin(): master1.delete() master2.delete() request.addfinalizer(fin) # Here we have two instances master and consumer # with replication working. return TopologyMaster1Master2(master1, master2)
def topology(request): global installation1_prefix if installation1_prefix: args_instance[SER_DEPLOYED_DIR] = installation1_prefix # Creating master 1... master1 = DirSrv(verbose=False) if installation1_prefix: args_instance[SER_DEPLOYED_DIR] = installation1_prefix args_instance[SER_HOST] = HOST_MASTER_1 args_instance[SER_PORT] = PORT_MASTER_1 args_instance[SER_SERVERID_PROP] = SERVERID_MASTER_1 args_instance[SER_CREATION_SUFFIX] = DEFAULT_SUFFIX args_master = args_instance.copy() master1.allocate(args_master) instance_master1 = master1.exists() if instance_master1: master1.delete() master1.create() master1.open() master1.replica.enableReplication(suffix=SUFFIX, role=REPLICAROLE_MASTER, replicaId=REPLICAID_MASTER_1) # Creating master 2... master2 = DirSrv(verbose=False) if installation1_prefix: args_instance[SER_DEPLOYED_DIR] = installation1_prefix args_instance[SER_HOST] = HOST_MASTER_2 args_instance[SER_PORT] = PORT_MASTER_2 args_instance[SER_SERVERID_PROP] = SERVERID_MASTER_2 args_instance[SER_CREATION_SUFFIX] = DEFAULT_SUFFIX args_master = args_instance.copy() master2.allocate(args_master) instance_master2 = master2.exists() if instance_master2: master2.delete() master2.create() master2.open() master2.replica.enableReplication(suffix=SUFFIX, role=REPLICAROLE_MASTER, replicaId=REPLICAID_MASTER_2) # # Create all the agreements # # Creating agreement from master 1 to master 2 properties = {RA_NAME: r'meTo_%s:%s' % (master2.host, master2.port), RA_BINDDN: defaultProperties[REPLICATION_BIND_DN], RA_BINDPW: defaultProperties[REPLICATION_BIND_PW], RA_METHOD: defaultProperties[REPLICATION_BIND_METHOD], RA_TRANSPORT_PROT: defaultProperties[REPLICATION_TRANSPORT]} global m1_m2_agmt m1_m2_agmt = master1.agreement.create(suffix=SUFFIX, host=master2.host, port=master2.port, properties=properties) if not m1_m2_agmt: log.fatal("Fail to create a master -> master replica agreement") sys.exit(1) log.debug("%s created" % m1_m2_agmt) # Creating agreement from master 2 to master 1 properties = {RA_NAME: r'meTo_%s:%s' % (master1.host, master1.port), RA_BINDDN: defaultProperties[REPLICATION_BIND_DN], RA_BINDPW: defaultProperties[REPLICATION_BIND_PW], RA_METHOD: defaultProperties[REPLICATION_BIND_METHOD], RA_TRANSPORT_PROT: defaultProperties[REPLICATION_TRANSPORT]} m2_m1_agmt = master2.agreement.create(suffix=SUFFIX, host=master1.host, port=master1.port, properties=properties) if not m2_m1_agmt: log.fatal("Fail to create a master -> master replica agreement") sys.exit(1) log.debug("%s created" % m2_m1_agmt) # Allow the replicas to get situated with the new agreements... time.sleep(5) # # Initialize all the agreements # master1.agreement.init(SUFFIX, HOST_MASTER_2, PORT_MASTER_2) master1.waitForReplInit(m1_m2_agmt) # Check replication is working... if master1.testReplication(DEFAULT_SUFFIX, master2): log.info('Replication is working.') else: log.fatal('Replication is not working.') assert False # Delete each instance in the end def fin(): master1.delete() master2.delete() request.addfinalizer(fin) return TopologyReplication(master1, master2)
def topology(request): """ This fixture is used to create a replicated topology for the 'module'. The replicated topology is MASTER -> Consumer. """ master = DirSrv(verbose=False) consumer = DirSrv(verbose=False) # Args for the master instance args_instance[SER_HOST] = HOST_MASTER_1 args_instance[SER_PORT] = PORT_MASTER_1 args_instance[SER_SERVERID_PROP] = SERVERID_MASTER_1 args_master = args_instance.copy() master.allocate(args_master) # Args for the consumer instance args_instance[SER_HOST] = HOST_CONSUMER_1 args_instance[SER_PORT] = PORT_CONSUMER_1 args_instance[SER_SERVERID_PROP] = SERVERID_CONSUMER_1 args_consumer = args_instance.copy() consumer.allocate(args_consumer) # Get the status of the instance and restart it if it exists instance_master = master.exists() instance_consumer = consumer.exists() # Remove all the instances if instance_master: master.delete() if instance_consumer: consumer.delete() # Create the instances master.create() master.open() consumer.create() consumer.open() # # Now prepare the Master-Consumer topology # # First Enable replication master.replica.enableReplication(suffix=SUFFIX, role=REPLICAROLE_MASTER, replicaId=REPLICAID_MASTER_1) consumer.replica.enableReplication(suffix=SUFFIX, role=REPLICAROLE_CONSUMER) # Initialize the supplier->consumer properties = { RA_NAME: r"meTo_$host:$port", RA_BINDDN: defaultProperties[REPLICATION_BIND_DN], RA_BINDPW: defaultProperties[REPLICATION_BIND_PW], RA_METHOD: defaultProperties[REPLICATION_BIND_METHOD], RA_TRANSPORT_PROT: defaultProperties[REPLICATION_TRANSPORT], } repl_agreement = master.agreement.create( suffix=SUFFIX, host=consumer.host, port=consumer.port, properties=properties ) if not repl_agreement: log.fatal("Fail to create a replica agreement") sys.exit(1) log.debug("%s created" % repl_agreement) master.agreement.init(SUFFIX, HOST_CONSUMER_1, PORT_CONSUMER_1) master.waitForReplInit(repl_agreement) # Check replication is working fine if master.testReplication(DEFAULT_SUFFIX, consumer): log.info("Replication is working.") else: log.fatal("Replication is not working.") assert False def fin(): master.delete() consumer.delete() request.addfinalizer(fin) # # Here we have two instances master and consumer # with replication working. Either coming from a backup recovery # or from a fresh (re)init # Time to return the topology return TopologyMasterConsumer(master, consumer)
def topology(request): global installation1_prefix if installation1_prefix: args_instance[SER_DEPLOYED_DIR] = installation1_prefix # Creating supplier 1... supplier1 = DirSrv(verbose=DEBUGGING) args_instance[SER_HOST] = HOST_SUPPLIER_1 args_instance[SER_PORT] = PORT_SUPPLIER_1 args_instance[SER_SECURE_PORT] = SECUREPORT_SUPPLIER_1 args_instance[SER_SERVERID_PROP] = SERVERID_SUPPLIER_1 args_instance[SER_CREATION_SUFFIX] = DEFAULT_SUFFIX args_supplier = args_instance.copy() supplier1.allocate(args_supplier) instance_supplier1 = supplier1.exists() if instance_supplier1: supplier1.delete() supplier1.create() supplier1.open() supplier1.replica.enableReplication(suffix=SUFFIX, role=ReplicaRole.SUPPLIER, replicaId=REPLICAID_SUPPLIER_1) # Creating supplier 2... supplier2 = DirSrv(verbose=DEBUGGING) args_instance[SER_HOST] = HOST_SUPPLIER_2 args_instance[SER_PORT] = PORT_SUPPLIER_2 args_instance[SER_SECURE_PORT] = SECUREPORT_SUPPLIER_2 args_instance[SER_SERVERID_PROP] = SERVERID_SUPPLIER_2 args_instance[SER_CREATION_SUFFIX] = DEFAULT_SUFFIX args_supplier = args_instance.copy() supplier2.allocate(args_supplier) instance_supplier2 = supplier2.exists() if instance_supplier2: supplier2.delete() supplier2.create() supplier2.open() supplier2.replica.enableReplication(suffix=SUFFIX, role=ReplicaRole.SUPPLIER, replicaId=REPLICAID_SUPPLIER_2) # # Create all the agreements # # Creating agreement from supplier 1 to supplier 2 properties = { RA_NAME: r'meTo_$host:$port', RA_BINDDN: defaultProperties[REPLICATION_BIND_DN], RA_BINDPW: defaultProperties[REPLICATION_BIND_PW], RA_METHOD: defaultProperties[REPLICATION_BIND_METHOD], RA_TRANSPORT_PROT: defaultProperties[REPLICATION_TRANSPORT] } m1_m2_agmt = supplier1.agreement.create(suffix=SUFFIX, host=supplier2.host, port=supplier2.port, properties=properties) if not m1_m2_agmt: log.fatal("Fail to create a supplier -> supplier replica agreement") sys.exit(1) log.debug("%s created" % m1_m2_agmt) # Creating agreement from supplier 2 to supplier 1 properties = { RA_NAME: r'meTo_$host:$port', RA_BINDDN: defaultProperties[REPLICATION_BIND_DN], RA_BINDPW: defaultProperties[REPLICATION_BIND_PW], RA_METHOD: defaultProperties[REPLICATION_BIND_METHOD], RA_TRANSPORT_PROT: defaultProperties[REPLICATION_TRANSPORT] } m2_m1_agmt = supplier2.agreement.create(suffix=SUFFIX, host=supplier1.host, port=supplier1.port, properties=properties) if not m2_m1_agmt: log.fatal("Fail to create a supplier -> supplier replica agreement") sys.exit(1) log.debug("%s created" % m2_m1_agmt) # Allow the replicas to get situated with the new agreements... time.sleep(5) # # Import tests entries into supplier1 before we initialize supplier2 # ldif_dir = supplier1.get_ldif_dir() import_ldif = ldif_dir + '/rel7.5-entries.ldif' # First generate an ldif try: ldif = open(import_ldif, 'w') except IOError as e: log.fatal('Failed to create test ldif, error: %s - %s' % (e.errno, e.strerror)) assert False # Create the root node ldif.write('dn: ' + DEFAULT_SUFFIX + '\n') ldif.write('objectclass: top\n') ldif.write('objectclass: domain\n') ldif.write('dc: example\n') ldif.write('\n') # Create the entries idx = 0 while idx < NUM_USERS: count = str(idx) ldif.write('dn: uid=supplier1_entry' + count + ',' + DEFAULT_SUFFIX + '\n') ldif.write('objectclass: top\n') ldif.write('objectclass: person\n') ldif.write('objectclass: inetorgperson\n') ldif.write('objectclass: organizationalperson\n') ldif.write('uid: supplier1_entry' + count + '\n') ldif.write('cn: supplier1 entry' + count + '\n') ldif.write('givenname: supplier1 ' + count + '\n') ldif.write('sn: entry ' + count + '\n') ldif.write('userpassword: supplier1_entry' + count + '\n') ldif.write('description: ' + 'a' * random.randint(1, 1000) + '\n') ldif.write('\n') ldif.write('dn: uid=supplier2_entry' + count + ',' + DEFAULT_SUFFIX + '\n') ldif.write('objectclass: top\n') ldif.write('objectclass: person\n') ldif.write('objectclass: inetorgperson\n') ldif.write('objectclass: organizationalperson\n') ldif.write('uid: supplier2_entry' + count + '\n') ldif.write('cn: supplier2 entry' + count + '\n') ldif.write('givenname: supplier2 ' + count + '\n') ldif.write('sn: entry ' + count + '\n') ldif.write('userpassword: supplier2_entry' + count + '\n') ldif.write('description: ' + 'a' * random.randint(1, 1000) + '\n') ldif.write('\n') idx += 1 ldif.close() # Now import it try: supplier1.tasks.importLDIF(suffix=DEFAULT_SUFFIX, input_file=import_ldif, args={TASK_WAIT: True}) except ValueError: log.fatal('test_reliab_7.5: Online import failed') assert False # # Initialize all the agreements # supplier1.agreement.init(SUFFIX, HOST_SUPPLIER_2, PORT_SUPPLIER_2) supplier1.waitForReplInit(m1_m2_agmt) # Check replication is working... if supplier1.testReplication(DEFAULT_SUFFIX, supplier2): log.info('Replication is working.') else: log.fatal('Replication is not working.') assert False # Clear out the tmp dir supplier1.clearTmpDir(__file__) # Delete each instance in the end def fin(): supplier1.delete() supplier2.delete() if ENABLE_VALGRIND: sbin_dir = get_sbin_dir(prefix=supplier1.prefix) valgrind_disable(sbin_dir) request.addfinalizer(fin) return TopologyReplication(supplier1, supplier2)
def topology(request): global installation1_prefix if installation1_prefix: args_instance[SER_DEPLOYED_DIR] = installation1_prefix # Creating master 1... master1 = DirSrv(verbose=False) args_instance[SER_HOST] = HOST_MASTER_1 args_instance[SER_PORT] = PORT_MASTER_1 args_instance[SER_SERVERID_PROP] = SERVERID_MASTER_1 args_instance[SER_CREATION_SUFFIX] = DEFAULT_SUFFIX args_master = args_instance.copy() master1.allocate(args_master) instance_master1 = master1.exists() if instance_master1: master1.delete() master1.create() master1.open() master1.replica.enableReplication(suffix=SUFFIX, role=REPLICAROLE_MASTER, replicaId=REPLICAID_MASTER_1) # Creating hub 1... hub1 = DirSrv(verbose=False) args_instance[SER_HOST] = HOST_HUB_1 args_instance[SER_PORT] = PORT_HUB_1 args_instance[SER_SERVERID_PROP] = SERVERID_HUB_1 args_instance[SER_CREATION_SUFFIX] = DEFAULT_SUFFIX args_hub = args_instance.copy() hub1.allocate(args_hub) instance_hub1 = hub1.exists() if instance_hub1: hub1.delete() hub1.create() hub1.open() hub1.replica.enableReplication(suffix=SUFFIX, role=REPLICAROLE_HUB, replicaId=REPLICAID_HUB_1) # Creating consumer 1... consumer1 = DirSrv(verbose=False) args_instance[SER_HOST] = HOST_CONSUMER_1 args_instance[SER_PORT] = PORT_CONSUMER_1 args_instance[SER_SERVERID_PROP] = SERVERID_CONSUMER_1 args_instance[SER_CREATION_SUFFIX] = DEFAULT_SUFFIX args_consumer = args_instance.copy() consumer1.allocate(args_consumer) instance_consumer1 = consumer1.exists() if instance_consumer1: consumer1.delete() consumer1.create() consumer1.open() consumer1.changelog.create() consumer1.replica.enableReplication(suffix=SUFFIX, role=REPLICAROLE_CONSUMER, replicaId=CONSUMER_REPLICAID) # # Create all the agreements # # Creating agreement from master 1 to hub 1 properties = {RA_NAME: r'meTo_$host:$port', RA_BINDDN: defaultProperties[REPLICATION_BIND_DN], RA_BINDPW: defaultProperties[REPLICATION_BIND_PW], RA_METHOD: defaultProperties[REPLICATION_BIND_METHOD], RA_TRANSPORT_PROT: defaultProperties[REPLICATION_TRANSPORT]} m1_h1_agmt = master1.agreement.create(suffix=SUFFIX, host=hub1.host, port=hub1.port, properties=properties) if not m1_h1_agmt: log.fatal("Fail to create a master -> hub replica agreement") sys.exit(1) log.debug("%s created" % m1_h1_agmt) # Creating agreement from hub 1 to consumer 1 properties = {RA_NAME: r'meTo_$host:$port', RA_BINDDN: defaultProperties[REPLICATION_BIND_DN], RA_BINDPW: defaultProperties[REPLICATION_BIND_PW], RA_METHOD: defaultProperties[REPLICATION_BIND_METHOD], RA_TRANSPORT_PROT: defaultProperties[REPLICATION_TRANSPORT]} h1_c1_agmt = hub1.agreement.create(suffix=SUFFIX, host=consumer1.host, port=consumer1.port, properties=properties) if not h1_c1_agmt: log.fatal("Fail to create a hub -> consumer replica agreement") sys.exit(1) log.debug("%s created" % h1_c1_agmt) # Allow the replicas to get situated with the new agreements... time.sleep(5) # # Initialize all the agreements # master1.agreement.init(SUFFIX, HOST_HUB_1, PORT_HUB_1) master1.waitForReplInit(m1_h1_agmt) hub1.agreement.init(SUFFIX, HOST_CONSUMER_1, PORT_CONSUMER_1) hub1.waitForReplInit(h1_c1_agmt) # Check replication is working... if master1.testReplication(DEFAULT_SUFFIX, consumer1): log.info('Replication is working.') else: log.fatal('Replication is not working.') assert False # Delete each instance in the end def fin(): master1.delete() hub1.delete() consumer1.delete() pass request.addfinalizer(fin) # Clear out the tmp dir master1.clearTmpDir(__file__) return TopologyReplication(master1, hub1, consumer1)
class Test_dirsrv(): def _add_user(self, success=True): try: self.instance.add_s( Entry((TEST_REPL_DN, { 'objectclass': "top person organizationalPerson inetOrgPerson".split(), 'uid': 'test', 'sn': 'test', 'cn': 'test' }))) except Exception as e: if success: raise else: self.instance.log.info('Fail to add (expected): %s' % e.args) return self.instance.log.info('%s added' % TEST_REPL_DN) def _mod_user(self, success=True): try: replace = [(ldap.MOD_REPLACE, 'description', str(randint(1, 100)))] self.instance.modify_s(TEST_REPL_DN, replace) except Exception as e: if success: raise else: self.instance.log.info('Fail to modify (expected): %s' % e.args) return self.instance.log.info('%s modified' % TEST_REPL_DN) def setUp(self): pass def tearDown(self): pass def test_allocate(self, verbose=False): instance = DirSrv(verbose=verbose) instance.log.debug("Instance allocated") assert instance.state == DIRSRV_STATE_INIT # Allocate the instance args = { SER_HOST: LOCALHOST, SER_PORT: INSTANCE_PORT, SER_DEPLOYED_DIR: INSTANCE_PREFIX, SER_SERVERID_PROP: INSTANCE_SERVERID } instance.allocate(args) userid = pwd.getpwuid(os.getuid())[0] # Now verify the settings assert instance.state == DIRSRV_STATE_ALLOCATED assert instance.host == LOCALHOST assert instance.port == INSTANCE_PORT assert instance.sslport == None assert instance.binddn == DN_DM assert instance.bindpw == PW_DM assert instance.creation_suffix == DEFAULT_SUFFIX assert instance.userid == userid assert instance.serverid == INSTANCE_SERVERID assert instance.groupid == instance.userid assert instance.prefix == INSTANCE_PREFIX assert instance.backupdir == INSTANCE_BACKUP # Now check we can change the settings of an allocated DirSrv args = { SER_SERVERID_PROP: INSTANCE_SERVERID, SER_HOST: LOCALHOST, SER_PORT: INSTANCE_PORT, SER_DEPLOYED_DIR: INSTANCE_PREFIX, SER_ROOT_DN: "uid=foo" } instance.allocate(args) assert instance.state == DIRSRV_STATE_ALLOCATED assert instance.host == LOCALHOST assert instance.port == INSTANCE_PORT assert instance.sslport == None assert instance.binddn == "uid=foo" assert instance.bindpw == PW_DM assert instance.creation_suffix == DEFAULT_SUFFIX assert instance.userid == userid assert instance.serverid == INSTANCE_SERVERID assert instance.groupid == instance.userid assert instance.prefix == INSTANCE_PREFIX assert instance.backupdir == INSTANCE_BACKUP # OK restore back the valid parameters args = { SER_SERVERID_PROP: INSTANCE_SERVERID, SER_HOST: LOCALHOST, SER_PORT: INSTANCE_PORT, SER_DEPLOYED_DIR: INSTANCE_PREFIX } instance.allocate(args) assert instance.state == DIRSRV_STATE_ALLOCATED assert instance.host == LOCALHOST assert instance.port == INSTANCE_PORT assert instance.sslport == None assert instance.binddn == DN_DM assert instance.bindpw == PW_DM assert instance.creation_suffix == DEFAULT_SUFFIX assert instance.userid == userid assert instance.serverid == INSTANCE_SERVERID assert instance.groupid == instance.userid assert instance.prefix == INSTANCE_PREFIX assert instance.backupdir == INSTANCE_BACKUP self.instance = instance def test_list_init(self): ''' Lists the instances on the file system ''' for properties in self.instance.list(): self.instance.log.info("properties: %r" % properties) for properties in self.instance.list(all=True): self.instance.log.info("properties (all): %r" % properties) def test_allocated_to_offline(self): self.instance.create() def test_offline_to_online(self): self.instance.open() def test_online_to_offline(self): self.instance.close() def test_offline_to_allocated(self): self.instance.delete() def test_allocated_to_online(self, verbose): # Here the instance was already create, check we can connect to it # without creating it (especially without serverid value) # Allocate the instance args = { SER_HOST: LOCALHOST, SER_PORT: INSTANCE_PORT, SER_DEPLOYED_DIR: INSTANCE_PREFIX, SER_SERVERID_PROP: INSTANCE_SERVERID } self.instance.log.info("test_allocated_to_online: Create an instance") self.instance = DirSrv(verbose=verbose) assert not hasattr(self, 'serverid') self.instance.allocate(args) self.instance.create() self.instance.open() assert self.instance.serverid != None # The instance is create, allocate a new DirSrv self.instance.log.info("test_allocated_to_online: instance New") self.instance = DirSrv(verbose=verbose) assert not hasattr(self, 'serverid') assert self.instance.state == DIRSRV_STATE_INIT args = { SER_HOST: LOCALHOST, SER_PORT: INSTANCE_PORT, SER_DEPLOYED_DIR: INSTANCE_PREFIX, } self.instance.allocate(args) self.instance.log.info("test_allocated_to_online: instance Allocated") assert self.instance.serverid == None assert self.instance.state == DIRSRV_STATE_ALLOCATED self.instance.open() self.instance.log.info("test_allocated_to_online: instance online") assert self.instance.serverid != None assert self.instance.serverid == self.instance.inst assert self.instance.state == DIRSRV_STATE_ONLINE
def topology(request): global installation1_prefix if installation1_prefix: args_instance[SER_DEPLOYED_DIR] = installation1_prefix # Creating master 1... master1 = DirSrv(verbose=False) args_instance[SER_HOST] = HOST_MASTER_1 args_instance[SER_PORT] = PORT_MASTER_1 args_instance[SER_SERVERID_PROP] = SERVERID_MASTER_1 args_instance[SER_CREATION_SUFFIX] = DEFAULT_SUFFIX args_master = args_instance.copy() master1.allocate(args_master) instance_master1 = master1.exists() if instance_master1: master1.delete() master1.create() master1.open() master1.replica.enableReplication(suffix=SUFFIX, role=REPLICAROLE_MASTER, replicaId=REPLICAID_MASTER_1) # Creating master 2... master2 = DirSrv(verbose=False) args_instance[SER_HOST] = HOST_MASTER_2 args_instance[SER_PORT] = PORT_MASTER_2 args_instance[SER_SERVERID_PROP] = SERVERID_MASTER_2 args_instance[SER_CREATION_SUFFIX] = DEFAULT_SUFFIX args_master = args_instance.copy() master2.allocate(args_master) instance_master2 = master2.exists() if instance_master2: master2.delete() master2.create() master2.open() master2.replica.enableReplication(suffix=SUFFIX, role=REPLICAROLE_MASTER, replicaId=REPLICAID_MASTER_2) # # Create all the agreements # # Creating agreement from master 1 to master 2 properties = {RA_NAME: r'meTo_$host:$port', RA_BINDDN: defaultProperties[REPLICATION_BIND_DN], RA_BINDPW: defaultProperties[REPLICATION_BIND_PW], RA_METHOD: defaultProperties[REPLICATION_BIND_METHOD], RA_TRANSPORT_PROT: defaultProperties[REPLICATION_TRANSPORT]} m1_m2_agmt = master1.agreement.create(suffix=SUFFIX, host=master2.host, port=master2.port, properties=properties) if not m1_m2_agmt: log.fatal("Fail to create a master -> master replica agreement") sys.exit(1) log.debug("%s created" % m1_m2_agmt) # Creating agreement from master 2 to master 1 properties = {RA_NAME: r'meTo_$host:$port', RA_BINDDN: defaultProperties[REPLICATION_BIND_DN], RA_BINDPW: defaultProperties[REPLICATION_BIND_PW], RA_METHOD: defaultProperties[REPLICATION_BIND_METHOD], RA_TRANSPORT_PROT: defaultProperties[REPLICATION_TRANSPORT]} m2_m1_agmt = master2.agreement.create(suffix=SUFFIX, host=master1.host, port=master1.port, properties=properties) if not m2_m1_agmt: log.fatal("Fail to create a master -> master replica agreement") sys.exit(1) log.debug("%s created" % m2_m1_agmt) # Allow the replicas to get situated with the new agreements... time.sleep(5) # # Import tests entries into master1 before we initialize master2 # ldif_dir = master1.get_ldif_dir() import_ldif = ldif_dir + '/rel7.5-entries.ldif' # First generate an ldif try: ldif = open(import_ldif, 'w') except IOError as e: log.fatal('Failed to create test ldif, error: %s - %s' % (e.errno, e.strerror)) assert False # Create the root node ldif.write('dn: ' + DEFAULT_SUFFIX + '\n') ldif.write('objectclass: top\n') ldif.write('objectclass: domain\n') ldif.write('dc: example\n') ldif.write('\n') # Create the entries idx = 0 while idx < NUM_USERS: count = str(idx) ldif.write('dn: uid=master1_entry' + count + ',' + DEFAULT_SUFFIX + '\n') ldif.write('objectclass: top\n') ldif.write('objectclass: person\n') ldif.write('objectclass: inetorgperson\n') ldif.write('objectclass: organizationalperson\n') ldif.write('uid: master1_entry' + count + '\n') ldif.write('cn: master1 entry' + count + '\n') ldif.write('givenname: master1 ' + count + '\n') ldif.write('sn: entry ' + count + '\n') ldif.write('userpassword: master1_entry' + count + '\n') ldif.write('description: ' + 'a' * random.randint(1, 1000) + '\n') ldif.write('\n') ldif.write('dn: uid=master2_entry' + count + ',' + DEFAULT_SUFFIX + '\n') ldif.write('objectclass: top\n') ldif.write('objectclass: person\n') ldif.write('objectclass: inetorgperson\n') ldif.write('objectclass: organizationalperson\n') ldif.write('uid: master2_entry' + count + '\n') ldif.write('cn: master2 entry' + count + '\n') ldif.write('givenname: master2 ' + count + '\n') ldif.write('sn: entry ' + count + '\n') ldif.write('userpassword: master2_entry' + count + '\n') ldif.write('description: ' + 'a' * random.randint(1, 1000) + '\n') ldif.write('\n') idx += 1 ldif.close() # Now import it try: master1.tasks.importLDIF(suffix=DEFAULT_SUFFIX, input_file=import_ldif, args={TASK_WAIT: True}) except ValueError: log.fatal('test_reliab_7.5: Online import failed') assert False # # Initialize all the agreements # master1.agreement.init(SUFFIX, HOST_MASTER_2, PORT_MASTER_2) master1.waitForReplInit(m1_m2_agmt) # Check replication is working... if master1.testReplication(DEFAULT_SUFFIX, master2): log.info('Replication is working.') else: log.fatal('Replication is not working.') assert False # Clear out the tmp dir master1.clearTmpDir(__file__) # Delete each instance in the end def fin(): master1.delete() master2.delete() if ENABLE_VALGRIND: sbin_dir = get_sbin_dir(prefix=master1.prefix) valgrind_disable(sbin_dir) request.addfinalizer(fin) return TopologyReplication(master1, master2)