else:

              self._log = logging.getLogger(__name__)

          self._alloc_rids = []

      def _ensure_changelog(self, instance):

          """Internally guarantee a changelog exists for

          """From an instance, determine the agreement name that we

          would use for it. Internal only.

          """

      def create_first_master(self, instance):

          """In a topology, this creates the "first" master that has the

      def _create_service_group(self, from_instance):

          """Internally create the service group that contains replication managers.

          This may become part of the default objects in the future. Internal only.

          """

          groups = Groups(from_instance, basedn=self._suffix, rdn=None)

      def _create_service_account(self, from_instance, to_instance):

          """Create the server replication service account, and

          port = to_instance.sslport

          services = ServiceAccounts(from_instance, self._suffix)

          repl_service = services.ensure_state(properties={

          })

          repl_group.ensure_member(repl_service.dn)

          to_replicas = Replicas(to_instance)

          try:

              to_r = to_replicas.get(self._suffix)

              return

          except ldap.NO_SUCH_OBJECT:

              pass

          # Make sure we replicate this suffix too ...

          # Ensure we have a cl

          self._ensure_changelog(to_instance)

          repl_dn = self._create_service_account(from_instance, to_instance)

          # Find the ruv on from_instance

          # Get a free rid

          rid = ruv.alloc_rid()

          # WARNING: You need to create passwords and agmts BEFORE you tot_init!

          # Now put in an agreement from to -> from

          # both ends.

          self.ensure_agreement(from_instance, to_instance)

          self.ensure_agreement(to_instance, from_instance, init=True)

          # Now fix our replica credentials from -> to

          to_r.set('nsDS5ReplicaBindDNGroup', repl_dn)

          :param to_instance: An instance to join to the topology.

          :type to_instance: lib389.DirSrv

          """

          self._ensure_changelog(to_instance)

      def join_consumer(self, from_instance, to_instance):

          """Join a new consumer to this instance. This will complete

          to_replicas = Replicas(to_instance)

          try:

              to_r = to_replicas.get(self._suffix)

              return

          except ldap.NO_SUCH_OBJECT:

              pass

          # Make sure we replicate this suffix too ...

          # Create replica on to_instance, with bootstrap details.

          to_r = to_replicas.create(properties={

          })

          # WARNING: You need to create passwords and agmts BEFORE you tot_init!

          repl_group = self._create_service_group(from_instance)

          # Now put in an agreement from to -> from

          # both ends.

          self.ensure_agreement(from_instance, to_instance)

          # Now fix our replica credentials from -> to

          to_r.set('nsDS5ReplicaBindDNGroup', repl_group.dn)

          # Now finally test it ...

          # Done!

          self._log.info("SUCCESS: joined consumer from %s to %s" % (from_instance.ldapuri, to_instance.ldapuri))

          Internal Only.

          """

      def ensure_agreement(self, from_instance, to_instance, init=False):

          """Guarantee that a replication agreement exists 'from_instance' send

          consumer.

          Both instances must have been added to the topology with

          :param from_instance: An instance already in the topology.

          :type from_instance: lib389.DirSrv

          # init = False (default) means creds *might* exist, and we create them

          # on the "from" master.

          agmt_name = self._inst_to_agreement_name(to_instance)

          try:

              agmt = from_agmts.get(agmt_name)

              self._log.info("SUCCESS: Agreement from %s to %s already exists" % (from_instance.ldapuri, to_instance.ldapuri))

          except ldap.NO_SUCH_OBJECT:

              # Okay, it doesn't exist, lets go ahead!

              pass

                  # No agreement, that's good!

                  pass

          # This should delete the agreements ....

      def disable_to_master(self, to_instance, from_instances=[]):

          """For all masters "from" disable all agreements "to" instance.

          :type to_instance: lib389.DirSrv

          """

          to_replicas = Replicas(to_instance)

          to_r = to_replicas.get(self._suffix)

          for i in range(0, timeout):

              to_ruv = to_r.get_ruv()

              time.sleep(1)

          raise Exception("Replication did not sync in time!")

      def test_replication(self, from_instance, to_instance, timeout=20):

          """Wait for a replication event to occur from instance to instance. This

  #

  import os

  import logging

  # For hostname detection for GSSAPI tests

  import socket

  import pytest

  from lib389 import DirSrv

  from lib389.utils import generate_ds_params

  from lib389.mit_krb5 import MitKrb5

  from lib389.saslmap import SaslMappings

  from lib389.replica import ReplicationManager, Replicas

  DEBUGGING = os.getenv('DEBUGGING', default=False)

  if DEBUGGING:

  log = logging.getLogger(__name__)

      :param topo_dict: a dictionary {ReplicaRole.STANDALONE: num, ReplicaRole.MASTER: num,

      :type topo_dict: dict

      :type suffix: str

      :return - TopologyMain object

      """

      instances = {}

      ms = {}

      cs = {}

      ins = {}

      # Create instances

      for role in topo_dict.keys():

              if role == ReplicaRole.CONSUMER:

                  cs[instance.serverid] = instance

                  instances.update(cs)

              log.info("Instance with parameters {} was created.".format(args_instance))

      # Start with a single master, and create it "first".

      first_master = None

      try:

          log.info("Creating replication topology.")

          # Now get the first master ready.

          repl = ReplicationManager(DEFAULT_SUFFIX)

      # Now init the other masters from this.

      # This will reinit m, and put a bi-directional agreement

      # in place.

          # Skip firstmaster.

          if m is first_master:

              continue

          repl.join_master(first_master, m)

      # Mesh the master agreements.

              if mo is mi:

                  continue

              log.info("Ensuring master %s to %s ..." % (mo.serverid, mi.serverid))

              repl.ensure_agreement(mo, mi)

      # Add master -> consumer agreements.

          repl.join_consumer(first_master, c)

              log.info("Ensuring consumer %s from %s ..." % (c.serverid, m.serverid))

              repl.ensure_agreement(m, c)

      # Clear out the tmp dir

          instance.clearTmpDir(__file__)

  class TopologyMain(object):

      def __init__(self, standalones=None, masters=None, consumers=None, hubs=None):

          self.all_insts = {}

          if standalones:

          if DEBUGGING:

              topology.standalone.stop()

          else:

      request.addfinalizer(fin)

      return topology

      topology.standalone.restart()

      def fin():

          if DEBUGGING:

              topology.standalone.stop()

          else:

              krb.destroy_realm()

      request.addfinalizer(fin)

          if DEBUGGING:

              [inst.stop() for inst in topology]

          else:

      request.addfinalizer(fin)

      return topology

          if DEBUGGING:

              [inst.stop() for inst in topology]

          else:

      request.addfinalizer(fin)

      return topology

          if DEBUGGING:

              [inst.stop() for inst in topology]

          else:

      request.addfinalizer(fin)

      return topology

          if DEBUGGING:

              [inst.stop() for inst in topology]

          else:

      request.addfinalizer(fin)

      return topology

          if DEBUGGING:

              [inst.stop() for inst in topology]

          else:

      request.addfinalizer(fin)

      return topology

          if DEBUGGING:

              [inst.stop() for inst in topology]

          else:

      request.addfinalizer(fin)

      return topology

          if DEBUGGING:

              [inst.stop() for inst in topology]

          else:

      request.addfinalizer(fin)

      return topology

          if DEBUGGING:

              [inst.stop() for inst in topology]

          else:

      request.addfinalizer(fin)

      return topology

  def topology_m1h1c1(request):

      """Create Replication Deployment with one master, one consumer and one hub"""

      # Clear out the tmp dir

      def fin():

          if DEBUGGING:

          else:

      request.addfinalizer(fin)