Determine the current domain and zone IDs for the domain.
172043
def authenticate(self):
        """"""
        try:
            payload = self._api.domain.info(self._api_key, self._domain)
            self._zone_id = payload['zone_id']
            return payload['id']
        except xmlrpclib.Fault as err:
            raise Exception("Failed to authenticate: '{0}'".format(err))
861219
def list_domains(self):
        
        self.connect()
        results = self.server.list_domains(self.session_id)
        return {i['domain']: i['subdomains'] for i in results}
913824
def domain_informations(domain, options={})
      response = connection.get do |req|
        req.url "insight/domains/#{domain}", options
      end
      return_error_or_body(response)
    end
632725
def domains(self):
        
        if self._domains is None:
            self._domains = DomainList(self._version, account_sid=self._solution['account_sid'], )
        return self._domains
1089894
def query_domain(self, domain, typenames, domainquerytype='list', count=False):
        

        objects = self._get_repo_filter(Layer.objects)

        if domainquerytype == 'range':
            return [tuple(objects.aggregate(Min(domain), Max(domain)).values())]
        else:
            if count:
                return [(d[domain], d['%s__count' % domain])
                        for d in objects.values(domain).annotate(Count(domain))]
            else:
                return objects.values_list(domain).distinct()
293464
def determine_locally
      domain = @libvirt_capabilities.get_plugin(@previous_plugin_info).domain_rank.last
      generate_xml(OpenStruct.new({
        :domain_type => domain.name,
        :os_type => domain.virt_rank.last,
        :bus => domain.bus
      }))
    end
1039389
public java.util.List<String> getDomainControllerIds() {
        if (domainControllerIds == null) {
            domainControllerIds = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return domainControllerIds;
    }
385990
def protection_domains(self):
        
        self.connection._check_login()
        response = self.connection._do_get("{}/{}".format(self.connection._api_url, "types/ProtectionDomain/instances")).json()
        all_pds = []
        for pd in response:
            all_pds.append(
                SIO_Protection_Domain.from_dict(pd)
            )
        return all_pds
930055
def get_domainalias(self, domainid, aliasid):
        """"""
        return self.api_call(
            ENDPOINTS['domainaliases']['get'],
            dict(domainid=domainid, aliasid=aliasid))
979678
def domain_list(gandi):
    """"""
    domains = gandi.dns.list()
    for domain in domains:
        gandi.echo(domain['fqdn'])

    return domains
1322664
function get_domain_id($domain)
    {
        $xml = $this->domain_info($domain);
        $id  = intval($xml->site->get->result->id);
        $id  = (is_int($id)) ? $id : false;

        return $id;
    }
228523
def domains(self):
        """"""
        return self._h._get_resources(
            resource=('apps', self.name, 'domains'),
            obj=Domain, app=self
        )
1179046
def check_many(self, domains):
        
        return dict((item.domain, item.status) for item in self.check_domain_request(domains))
327762
def get_domains(custom_headers:nil)
      response = get_domains_async(custom_headers:custom_headers).value!
      response.body unless response.nil?
    end
39285
def get_ldapsettings(self, domainid, serverid, settingsid):
        """"""
        return self.api_call(
            ENDPOINTS['ldapsettings']['get'],
            dict(domainid=domainid, serverid=serverid, settingsid=settingsid))
96679
def get_domain_id_for_operation(request):
    

    domain_context = request.session.get('domain_context')
    if domain_context:
        return domain_context
    return api.keystone.get_effective_domain_id(request)
252259
private static SiteDomainInfo getDomainInfo(Collection<String> uris) {

        Set<String> rootDomains = Sets.newHashSet();
        Set<String> domains = Sets.newHashSet();
        boolean invalidPort = false;

        for (String uriStr : uris) {

            try {
                URI uri = new URI(uriStr);
                int port = uri.getPort();
                if (!((port == 80) || (port == 443) || (port == -1))) {
                    invalidPort = true;
                }
                String rootDomain = getDomainRoot(uri);
                if (rootDomain == null) {
                    LOG.warn("Host is not under public suffix, skipping it: " + uri);
                    continue;
                }
                domains.add(uri.getHost());
                rootDomains.add(rootDomain);
            } catch (URISyntaxException e) {
                LOG.warn("getDomainInfo: invalid URI " + uriStr, e);
                continue;
            }
        }
        String rootDomain = (rootDomains.size() == 1 ? rootDomains.iterator().next() : null);
        return new SiteDomainInfo(domains, rootDomain, invalidPort);
    }