def do_loop_turn(self):
        # pylint: disable=too-many-branches, too-many-statements, too-many-locals
        """Loop turn for Arbiter

        If not a master daemon, wait for my master death...
        Else, run:
        * Check satellites are alive
        * Check and dispatch (if needed) the configuration
        * Get broks and external commands from the satellites
        * Push broks and external commands to the satellites

        :return: None
        """
        # If I am a spare, I only wait for the master arbiter to die...
        if not self.is_master:
            logger.debug("Waiting for my master death...")
            self.wait_for_master_death()
            return

        if self.loop_count % self.alignak_monitor_period == 1:
            self.get_alignak_status(details=True)

        # Maybe an external process requested Alignak stop...
        if self.kill_request:
            logger.info("daemon stop mode ...")
            if not self.dispatcher.stop_request_sent:
                logger.info("entering daemon stop mode, time before exiting: %s",
                            self.conf.daemons_stop_timeout)
                self.dispatcher.stop_request()
            if time.time() > self.kill_timestamp + self.conf.daemons_stop_timeout:
                logger.info("daemon stop mode delay reached, immediate stop")
                self.dispatcher.stop_request(stop_now=True)
                time.sleep(1)
                self.interrupted = True
                logger.info("exiting...")

        if not self.kill_request:
            # Main loop treatment
            # Try to see if one of my module is dead, and restart previously dead modules
            self.check_and_del_zombie_modules()

            # Call modules that manage a starting tick pass
            _t0 = time.time()
            self.hook_point('tick')
            statsmgr.timer('hook.tick', time.time() - _t0)

            # Look for logging timeperiods activation change (active/inactive)
            self.check_and_log_tp_activation_change()

            # Check that my daemons are alive
            if not self.daemons_check():
                if self.conf.daemons_failure_kill:
                    self.request_stop(message="Some Alignak daemons cannot be checked.",
                                      exit_code=4)
                else:
                    logger.warning("Should have killed my children if "
                                   "'daemons_failure_kill' were set!")

            # Now the dispatcher job - check if all daemons are reachable and have a configuration
            if not self.daemons_reachability_check():
                logger.warning("A new configuration dispatch is required!")

                # Prepare and dispatch the monitored configuration
                self.configuration_dispatch(self.dispatcher.not_configured)

            # Now get things from our module instances
            _t0 = time.time()
            self.get_objects_from_from_queues()
            statsmgr.timer('get-objects-from-queues', time.time() - _t0)

            # Maybe our satellites raised new broks. Reap them...
            _t0 = time.time()
            self.get_broks_from_satellites()
            statsmgr.timer('broks.got.time', time.time() - _t0)

            # One broker is responsible for our broks, we give him our broks
            _t0 = time.time()
            self.push_broks_to_broker()
            statsmgr.timer('broks.pushed.time', time.time() - _t0)

            # # We push our external commands to our schedulers...
            # _t0 = time.time()
            # self.push_external_commands_to_schedulers()
            # statsmgr.timer('external-commands.pushed.time', time.time() - _t0)

        if self.system_health and (self.loop_count % self.system_health_period == 1):
            perfdatas = []
            cpu_count = psutil.cpu_count()
            perfdatas.append("'cpu_count'=%d" % cpu_count)
            logger.debug("  . cpu count: %d", cpu_count)

            cpu_percents = psutil.cpu_percent(percpu=True)
            cpu = 1
            for percent in cpu_percents:
                perfdatas.append("'cpu_%d_percent'=%.2f%%" % (cpu, percent))
                cpu += 1

            cpu_times_percent = psutil.cpu_times_percent(percpu=True)
            cpu = 1
            for cpu_times_percent in cpu_times_percent:
                logger.debug("  . cpu time percent: %s", cpu_times_percent)
                for key in cpu_times_percent._fields:
                    perfdatas.append(
                        "'cpu_%d_%s_percent'=%.2f%%" % (cpu, key,
                                                        getattr(cpu_times_percent, key)))
                cpu += 1

            logger.info("%s cpu|%s", self.name, " ".join(perfdatas))

            perfdatas = []
            disk_partitions = psutil.disk_partitions(all=False)
            for disk_partition in disk_partitions:
                logger.debug("  . disk partition: %s", disk_partition)

                disk = getattr(disk_partition, 'mountpoint')
                disk_usage = psutil.disk_usage(disk)
                logger.debug("  . disk usage: %s", disk_usage)
                for key in disk_usage._fields:
                    if 'percent' in key:
                        perfdatas.append("'disk_%s_percent_used'=%.2f%%"
                                         % (disk, getattr(disk_usage, key)))
                    else:
                        perfdatas.append("'disk_%s_%s'=%dB"
                                         % (disk, key, getattr(disk_usage, key)))

            logger.info("%s disks|%s", self.name, " ".join(perfdatas))

            perfdatas = []
            virtual_memory = psutil.virtual_memory()
            logger.debug("  . memory: %s", virtual_memory)
            for key in virtual_memory._fields:
                if 'percent' in key:
                    perfdatas.append("'mem_percent_used_%s'=%.2f%%"
                                     % (key, getattr(virtual_memory, key)))
                else:
                    perfdatas.append("'mem_%s'=%dB"
                                     % (key, getattr(virtual_memory, key)))

            swap_memory = psutil.swap_memory()
            logger.debug("  . memory: %s", swap_memory)
            for key in swap_memory._fields:
                if 'percent' in key:
                    perfdatas.append("'swap_used_%s'=%.2f%%"
                                     % (key, getattr(swap_memory, key)))
                else:
                    perfdatas.append("'swap_%s'=%dB"
                                     % (key, getattr(swap_memory, key)))

            logger.info("%s memory|%s", self.name, " ".join(perfdatas))
Loop turn for Arbiter

        If not a master daemon, wait for my master death...
        Else, run:
        * Check satellites are alive
        * Check and dispatch (if needed) the configuration
        * Get broks and external commands from the satellites
        * Push broks and external commands to the satellites

        :return: None