Explode realms with each realm_members and higher_realms to get all the
        realms sub realms.

        :return: None
177106
def explode(self):
        
        # Manage higher realms where defined
        for realm in [tmp_realm for tmp_realm in self if tmp_realm.higher_realms]:
            for parent in realm.higher_realms:
                higher_realm = self.find_by_name(parent)
                if higher_realm:
                    # Add the realm to its parent realm members
                    higher_realm.realm_members.append(realm.get_name())

        for realm in self:
            # Set a recursion tag to protect against loop
            for tmp_realm in self:
                tmp_realm.rec_tag = False
            realm.get_realms_by_explosion(self)

        # Clean the recursion tag
        for tmp_realm in self:
            del tmp_realm.rec_tag
236977
def group_members(self, group, limit=99999):
        
        url = 'rest/api/1.0/admin/groups/more-members'
        params = {}
        if limit:
            params['limit'] = limit
        if group:
            params['context'] = group
        return (self.get(url, params=params) or {}).get('values')
174797
def memberships(self, group, include=None):
        
        return self._get(self._build_url(self.endpoint.memberships(id=group, include=include)))
928208
def splitRangeByTablets(self, login, tableName, range, maxSplits):
    
    self.send_splitRangeByTablets(login, tableName, range, maxSplits)
    return self.recv_splitRangeByTablets()
193892
def members(self):
        ''''''
        with self._mutex:
            if not self._members:
                self._members = {}
                for o in self.organisations:
                    # TODO: Search for these in the tree
                    self._members[o.org_id] = o.obj.get_members()
        return self._members
716094
def linkify_h_by_realms(self, realms):
        
        default_realm = realms.get_default()
        for host in self:
            if not getattr(host, 'realm', None):
                # Applying default realm to an host
                host.realm = default_realm.uuid if default_realm else ''
                host.realm_name = default_realm.get_name() if default_realm else ''
                host.got_default_realm = True

            if host.realm not in realms:
                realm = realms.find_by_name(host.realm)
                if not realm:
                    continue
                host.realm = realm.uuid
            else:
                realm = realms[host.realm]
316041
def _slice(self, level):
        ''''''
        if level >= len(self.taxonomy):
            raise IndexError('Level greater than size of taxonomy')
        res = []
        for ident in sorted(list(self.keys())):
            res.append((self[ident]['taxref'], self[ident]['lineage'][level]))
        return res
315912
def linkify(self, hosts=None, realms=None, forced_realms_hostgroups=True):
        
        self.linkify_hostgroups_hosts(hosts)
        self.linkify_hostgroups_realms_hosts(realms, hosts, forced_realms_hostgroups)
1004916
def extractall(self, path=None, members=None, pwd=None):
        
        if members is None:
            members = self.namelist()

        for zipinfo in members:
            self.extract(zipinfo, path, pwd)
583296
def GET_subdomains( self, path_info ):
        
        qs_values = path_info['qs_values']
        page = qs_values.get('page', None)
        if page is None:
            log.error("Page required")
            return self._reply_json({'error': 'page= argument required'}, status_code=400)

        try:
            page = int(page)
            assert page >= 0
        except Exception:
            log.error("Invalid page")
            return self._reply_json({'error': 'Invalid page= value'}, status_code=400)

        offset = page * 100
        count = 100

        blockstackd_url = get_blockstackd_url()
        res = blockstackd_client.get_all_subdomains(offset, count, hostport=blockstackd_url)

        if json_is_error(res):
            log.error("Failed to list all subdomains (offset={}, count={}): {}".format(offset, count, res['error']))
            return self._reply_json({'error': 'Failed to list all names'}, status_code=res.get('http_status', 406))

        return self._reply_json(res)
57738
def clear_cached_realms(self, realms, params=None):
        
        if realms in SKIP_IN_PATH:
            raise ValueError("Empty value passed for a required argument 'realms'.")
        return self.transport.perform_request(
            "POST",
            _make_path("_security", "realm", realms, "_clear_cache"),
            params=params,
        )
34616
def explode(self):
        
        # first elements, after groups
        self.contacts.explode(self.contactgroups, self.notificationways)
        self.contactgroups.explode()

        self.hosts.explode(self.hostgroups, self.contactgroups)

        self.hostgroups.explode()

        self.services.explode(self.hosts, self.hostgroups, self.contactgroups,
                              self.servicegroups, self.servicedependencies)
        self.servicegroups.explode()

        self.timeperiods.explode()

        self.hostdependencies.explode(self.hostgroups)

        self.servicedependencies.explode(self.hostgroups)

        # Serviceescalations hostescalations will create new escalations
        self.serviceescalations.explode(self.escalations)
        self.hostescalations.explode(self.escalations)
        self.escalations.explode(self.hosts, self.hostgroups, self.contactgroups)

        # Now the architecture part
        self.realms.explode()
159462
def apply_realms(self):
        
        self.authenticator.init_realms(self.realms)
        self.authorizer.init_realms(self.realms)
26274
def getmembers(self):
        '''
        
        '''
        if self._members is None:
            self._members = _members = []
            g = self.data_file
            magic = g.read(2)
            while magic:
                if magic == b'07':
                    magic += g.read(4)
                    member = RPMInfo._read(magic, g)

                    if member.name == 'TRAILER!!!':
                        break

                    if not member.isdir:
                        _members.append(member)

                magic = g.read(2)
            return _members
        return self._members
24813
def _find_set_members(set):
    '''
    
    '''

    cmd = '{0} list {1}'.format(_ipset_cmd(), set)
    out = __salt__['cmd.run_all'](cmd, python_shell=False)

    if out['retcode'] > 0:
        # Set doesn't exist return false
        return False

    _tmp = out['stdout'].split('\n')
    members = []
    startMembers = False
    for i in _tmp:
        if startMembers:
            members.append(i)
        if 'Members:' in i:
            startMembers = True
    return members
975367
def get_members(self, sort='id_asc'):
        
        return self._session.fetch_items("groups.getMembers", User.from_json, 1000, group_id=self.id, sort=sort, fields=User.__slots__ + User.USER_FIELDS)
603446
def members(self):
        
        res = [self]
        for c in list(self.children.values()):
            res.extend(c.members)
        return res