Return a list of the BareMetal servers that are on the provider.
162996
def list_nodes_full(call=None):
    ''' 
    '''
    if call == 'action':
        raise SaltCloudSystemExit(
            'list_nodes_full must be called with -f or --function'
        )

    items = query(method='servers')

    # For each server, iterate on its parameters.
    ret = {}
    for node in items['servers']:
        ret[node['name']] = {}
        for item in node:
            value = node[item]
            ret[node['name']][item] = value
    return ret
538235
def _get_index_servers(self):
        """"""
        idx_srvs = []
        if 'index-servers' in self.conf.options('distutils'):
            idx = self.conf.get('distutils', 'index-servers')
            idx_srvs = [srv.strip() for srv in idx.split('\n') if srv.strip()]
        return idx_srvs
837567
def list_websites(self):
        
        self.connect()
        results = self.server.list_websites(self.session_id)

        return results
844046
def list_hosts(kwargs=None, call=None):
    '''
    
    '''
    if call != 'function':
        raise SaltCloudSystemExit(
            'The list_hosts function must be called with '
            '-f or --function.'
        )

    return {'Hosts': salt.utils.vmware.list_hosts(_get_si())}
1346580
def proxy_servers(self):
        
        proxy_servers = {}
        if self._load_rc_func is None:
            return proxy_servers
        else:
            HTTP_PROXY = os.environ.get('HTTP_PROXY')
            HTTPS_PROXY = os.environ.get('HTTPS_PROXY')

            if HTTP_PROXY:
                proxy_servers['http'] = HTTP_PROXY

            if HTTPS_PROXY:
                proxy_servers['https'] = HTTPS_PROXY

            proxy_servers_conf = self._load_rc_func().get('proxy_servers', {})
            proxy_servers.update(proxy_servers_conf)

            return proxy_servers
902935
def get_matrix_servers(url: str) -> List[str]:
    
    try:
        response = requests.get(url)
        if response.status_code != 200:
            raise requests.RequestException('Response: {response!r}')
    except requests.RequestException as ex:
        raise RuntimeError(f'Could not fetch matrix servers list: {url!r} => {ex!r}') from ex

    available_servers = []
    for line in response.text.splitlines():
        line = line.strip(string.whitespace + '-')
        if line.startswith('#') or not line:
            continue
        if not line.startswith('http'):
            line = 'https://' + line  # default schema
        available_servers.append(line)
    return available_servers
45659
def server_group_list(request):
    """"""
    try:
        return api.nova.server_group_list(request)
    except Exception:
        exceptions.handle(request,
                          _('Unable to retrieve Nova server groups.'))
        return []
324348
def list_images(self, provider=None):
        '''
        
        '''
        mapper = salt.cloud.Map(self._opts_defaults())
        return salt.utils.data.simple_types_filter(
            mapper.image_list(provider)
        )
1208242
def get_servers():
    '''
    
    '''
    ret = list()

    with salt.utils.winapi.Com():
        try:
            connection = wmi.WMI(namespace=_WMI_NAMESPACE)
            objs = connection.IIsSmtpServerSetting()

            for obj in objs:
                ret.append(six.text_type(obj.Name))
        except wmi.x_wmi as error:
            _LOG.error('Encountered WMI error: %s', error.com_error)
        except (AttributeError, IndexError) as error:
            _LOG.error('Error getting IIsSmtpServerSetting: %s', error)

    _LOG.debug('Found SMTP servers: %s', ret)
    return ret
127515
def servers(self):
        """"""
        self.__init()
        items = []
        for k,v in self._json_dict.items():
            if k == "servers":
                for s in v:
                    if 'id' in s:
                        url = "%s/%s" % (self.root, s['id'])
                        items.append(
                            self.Server(url=url,
                                        securityHandler=self._securityHandler,
                                        proxy_url=self._proxy_url,
                                        proxy_port=self._proxy_port))
            del k,v
        return items
87205
def get_queues(self):
        """"""
        res = self.celery.control.inspect().active_queues() or dict()
        return [result.get('name') for host in res.values() for result in host]
604588
def get_servers(self, topic):
        

        return (nsq.node.ServerNode(sh) for sh in self.__server_hosts)
815673
static function getServersList()
    {
        $target_list = array();
        $i = 0;
        $wsINI = eZINI::instance( 'wsproviders.ini' );
        // calculate list of target ws servers as it is hard to do that in tpl code
        foreach ( $wsINI->groups() as $groupname => $groupdef )
        {
            if ( $groupname != 'GeneralSettings' && $groupname != 'ExtensionSettings' )
            {
                if ( $wsINI->hasVariable( $groupname, 'providerType' ) )
                {
                    $target_list[] = array( 'name' => $groupname, 'id' => md5( $groupname ) );
                }
                else
                {
                    /// @todo log warning ???
                }
            }
        }
        return $target_list;
    }
954085
def get_name_servers(self, id_or_uri):
        

        uri = self._client.build_uri(id_or_uri) + "/nameServers"
        return self._client.get(uri)
189655
def find_servers(self, *args, **kwargs):
        
        servers = super(HPNova, self).find_servers(*args, **kwargs)
        return map(fix_hp_addrs, servers)
743964
def get_deliveryservers(self, domainid, page=None):
        """"""
        opts = {}
        if page:
            opts['page'] = page
        return self.api_call(
            ENDPOINTS['deliveryservers']['list'],
            dict(domainid=domainid), **opts)
1249209
def servers(self, server='api.telldus.com', port=http.HTTPS_PORT):
        
        logging.debug("Fetching server list from %s:%d", server, port)

        conn = http.HTTPSConnection(server, port, context=self.ssl_context())
        conn.request('GET', "/server/assign?protocolVersion=2")

        response = conn.getresponse()
        if response.status != http.OK:
            raise RuntimeError("Could not connect to {}:{}: {} {}".format(
                server, port, response.status, response.reason))

        servers = []

        def extract_servers(name, attributes):
            if name == "server":
                servers.append((attributes['address'],
                                int(attributes['port'])))

        parser = expat.ParserCreate()
        parser.StartElementHandler = extract_servers
        parser.ParseFile(response)

        logging.debug("Found %d available servers", len(servers))
        return servers