Get list of the inactive domains.
764635
public static List<Domain> getDefinedDomains(Connect libvirt) {
        try {
            List<Domain> domains = new ArrayList<>();
            String[] domainNames = libvirt.listDefinedDomains();
            for (String name : domainNames) {
                domains.add(libvirt.domainLookupByName(name));
            }
            return domains;
        } catch (LibvirtException e) {
            throw new LibvirtRuntimeException("Unable to list defined domains", e);
        }
    }
1188340
def get_domain_events(self, originator_id, gt=None, gte=None, lt=None, lte=None, limit=None, is_ascending=True,
                          page_size=None):
        
1223391
def list_records(self, domain, limit=None, offset=None):
        
        uri = "/domains/%s/records%s" % (utils.get_id(domain),
                self._get_pagination_qs(limit, offset))
        return self._list_records(uri)
1084717
def get_activations(self):
        """"""
        res = (self.added, self.removed)

        self.added = set()
        self.removed = set()

        return res
511290
def list_domains(custom_headers:nil)
      response = list_domains_async(custom_headers:custom_headers).value!
      response.body unless response.nil?
    end
967848
def list_domain_cache():
    '''
    
    '''
    cache = salt.cache.Cache(__opts__, syspaths.CACHE_DIR)
    return cache.list('venafi/domains')
1065971
public function getDomains()
    {
        if (0 === count($this->domains)) {
            return null;
        }

        return $this->domains->map(function(Domain $domain) {
            return $domain->getUrl();
        });
    }
857447
def list_records(self, domain, limit=None, offset=None):
        
        return domain.list_records(limit=limit, offset=offset)
128826
protected function getDomainListOfAllSites()
    {
        $sites = $this->getAvailableSites();
        $domains = [];
        foreach ($sites as $site) {
            $domains[] = $site->getDomain();
        }

        $allowedSites = implode(',', $domains);
        return $allowedSites;
    }
1145070
def get_active_nodes(self):
        
        # the -1 4 -1 args are the filters <proxy_id> <type> <server_id>,
        # -1 for all proxies, 4 for servers only, -1 for all servers
        stats_response = self.send_command("show stat -1 4 -1")
        if not stats_response:
            return []

        lines = stats_response.split("\n")
        fields = lines.pop(0).split(",")
        # the first field is the service name, which we key off of so
        # it's not included in individual node records
        fields.pop(0)

        active_nodes = collections.defaultdict(list)

        for line in lines:
            values = line.split(",")
            service_name = values.pop(0)
            active_nodes[service_name].append(
                dict(
                    (fields[i], values[i])
                    for i in range(len(fields))
                )
            )

        return active_nodes
1151706
def domains(self):
        
        json = self.request('/domains', method='GET')
        status = json.get('status')
        if status == 'OK':
            domains_json = json.get('domains', [])
            domains = [Domain.from_json(domain) for domain in domains_json]
            return domains
        else:
            message = json.get('message')
            raise DOPException('[%s]: %s' % (status, message))
632725
def domains(self):
        
        if self._domains is None:
            self._domains = DomainList(self._version, account_sid=self._solution['account_sid'], )
        return self._domains
77051
@Nullable
    @ThriftField(value = 1, requiredness = OPTIONAL)
    public Map<String, PrestoThriftDomain> getDomains()
    {
        return domains;
    }
179726
def available_domains(self):
        
        if not hasattr(self, '_available_domains'):
            url = 'http://{0}/request/domains/format/json/'.format(
                self.api_domain)
            req = requests.get(url)
            domains = req.json()
            setattr(self, '_available_domains', domains)
        return self._available_domains
1259696
function iface(end) {
    if (end) {
      return db.quit(next);
    } else {
      // Get all the domains whose records expired some time before now
      db.eval(scoreRange,2,'expiring_domains','querying_domains',
        '-inf', Date.now(), function (err, res) {
          if (err) return cb(err);
          // Query each of these domains
          for (var i = 0; i < res.length; i += 2) {
            queryDomain(res[i], finishQuerying.bind(null, res[i]));
          }
        });
      return iface;
    }
  }
105176
def get_all_subdomains(self, offset=None, count=None, min_sequence=None, cur=None):
        
        get_cmd = 'SELECT DISTINCT fully_qualified_subdomain FROM {}'.format(self.subdomain_table)
        args = ()

        if min_sequence is not None:
            get_cmd += ' WHERE sequence >= ?'
            args += (min_sequence,)

        if count is not None:
            get_cmd += ' LIMIT ?'
            args += (count,)

        if offset is not None:
            get_cmd += ' OFFSET ?'
            args += (offset,)

        get_cmd += ';'

        cursor = None
        if cur is None:
            cursor = self.conn.cursor()
        else:
            cursor = cur

        rows = db_query_execute(cursor, get_cmd, args)
        subdomains = []
        for row in rows:
            subdomains.append(row['fully_qualified_subdomain'])

        return subdomains
294715
def filter(self, table, domains, filter_string):
        """"""
        q = filter_string.lower()

        def comp(domain):
            if q in domain.name.lower():
                return True
            return False

        return filter(comp, domains)