This is almost the same with `add_nodes`. The difference is that
        it will add slaves in two slower way.
        This is mainly used to avoid huge overhead caused by full sync
        when large amount of slaves are added to cluster.
        If fast_mode is False, there is only one master node doing
        replication at the same time.
        If fast_mode is True, only after the current slave has finshed
        its sync, will the next slave on the same host start replication.

def add_slaves(self, new_slaves, fast_mode=False):
        '''This is almost the same with `add_nodes`. The difference is that
        it will add slaves in two slower way.
        This is mainly used to avoid huge overhead caused by full sync
        when large amount of slaves are added to cluster.
        If fast_mode is False, there is only one master node doing
        replication at the same time.
        If fast_mode is True, only after the current slave has finshed
        its sync, will the next slave on the same host start replication.
        '''
        new_nodes, master_map = self._prepare_for_adding(new_slaves)

        slaves = defaultdict(list)
        for s in new_nodes:
            slaves[s.host].append(s)

        waiting = set()
        while len(slaves) > 0:
            for host in slaves.keys():
                if self.check_action_stopped():
                    logger.warning('Slaves adding was stopped, ' \
                        'waiting for the last slave to be finished')
                slave_list = slaves[host]
                s = slave_list[0]

                if not fast_mode and len(waiting) > 0 and s not in waiting:
                    continue

                if s not in waiting:
                    if self.check_action_stopped():
                        raise ActionStopped(
                            'Slaves adding was successfully stopped')
                    master_name = master_map[s.name]
                    target = self.get_node(master_name)
                    if not target:
                        raise NodeNotFound(master_name)
                    self._add_as_master(s, self.nodes[0])
                    s.replicate(target.name)
                    waiting.add(s)
                    continue

                role = s.execute_command('ROLE')
                # role[3] being changed to 'connected' means sync is finished
                if role[0] == 'master' or role[3] != 'connected':
                    continue

                waiting.remove(s)
                slave_list.pop(0)
                if len(slave_list) == 0:
                    slaves.pop(host)

            if len(waiting) > 0:
                waiting_list = ['{}:{}'.format(n.host, n.port) for n in waiting]
                logger.info('sync waiting list: {}'.format(waiting_list))
            time.sleep(1)