Get the admin information.
        Optional arguments:
        * server=None - Get admin information for -
            server instead of the current server.
5421
def admin(self, server=None):
        
        with self.lock:
            if not server:
                self.send('ADMIN')
            else:
                self.send('ADMIN %s' % server)
            rvalue = []
            while self.readable():
                admin_ncodes = '257', '258', '259'
                msg = self._recv(expected_replies=('256',) + admin_ncodes)
                if msg[0] == '256':
                    pass
                elif msg[0]  in admin_ncodes:
                    rvalue.append(' '.join(msg[2:])[1:])

            return rvalue
1139876
def get_admins(self):
        """"""
        # no nickserv support, assume people are who they say they are.
        if not self.config['feature'].getboolean('nickserv'):
            return
        with self.db.session_scope() as session:
            for a in session.query(orm.Permissions).all():
                if not a.registered:
                    self.update_authstatus(a.nick)
1337990
def find_info(name=None):
    """"""
    if not name:
        return list(servers.keys()) 
    name = name.lower()
    if name in servers:
        info = servers[name]
    else:
        raise CityNotFound("Could not find the specified city: %s" % name)
    return info
1201803
def user_info(authserver_host=None, authserver_port=None):
    
    authserver = get_auth_server_name(authserver_host, authserver_port)
    return DXHTTPRequest(authserver + "/system/getUserInfo", {}, prepend_srv=False)
885397
def info(self):
        
        if self._info_manager is None:
            self._info_manager = InfoManager(session=self._session)
        return self._info_manager
1205312
def get_server_info(self, format=None):
        
        parameters = {}
        if format is not None:
            parameters['format'] = format
        url = self.create_request_url(self.interface, 'GetServerInfo', 1,
            parameters)
        data = self.retrieve_request(url)
        return self.return_data(data, format=format)
790982
def info(self, server_id):
        
        result = self._storage[server_id].info()
        result['id'] = server_id
        return result
482373
def current_user(self):
        
        if not hasattr(self, '_serverInfo') or 'username' not in self._serverInfo:

            url = self._get_url('serverInfo')
            r = self._session.get(url, headers=self._options['headers'])

            r_json = json_loads(r)
            if 'x-ausername' in r.headers:
                r_json['username'] = r.headers['x-ausername']
            else:
                r_json['username'] = None
            self._serverInfo = r_json
            # del r_json['self']  # this isn't really an addressable resource
        return self._serverInfo['username']
753150
def server_info(self):
        
        retry = 0
        j = self._get_json('serverInfo')
        while not j and retry < 3:
            logging.warning("Bug https://jira.atlassian.com/browse/JRA-59676 trying again...")
            retry += 1
            j = self._get_json('serverInfo')
        return j
1028456
def get_root_resource(server_host, server_port=None,
                      username="admin", password="admin",
                      use_tls=False, version=API_CURRENT_VERSION):
  
  return ApiResource(server_host, server_port, username, password, use_tls,
      version)
371814
def database_admin_api(self):
        """"""
        if self._database_admin_api is None:
            self._database_admin_api = DatabaseAdminClient(
                credentials=self.credentials, client_info=_CLIENT_INFO
            )
        return self._database_admin_api
1286703
public static server[] get(nitro_service service, server_args args) throws Exception{
		server obj = new server();
		options option = new options();
		option.set_args(nitro_util.object_to_string_withoutquotes(args));
		server[] response = (server[])obj.get_resources(service, option);
		return response;
	}
1030696
def DbGetHostServersInfo(self, argin):
        
        self._log.debug("In DbGetHostServersInfo()")
        argin = replace_wildcard(argin)
        return self.db.get_host_servers_info(argin)
1106822
def url(self):
        
        if self.server_url is not None and \
                self.recid is not None:
            return '/'.join(
                [self.server_url, CFG_SITE_RECORD, str(self.recid)])
        else:
            return None
1286502
def get_server(self, name):
        
        mech = self.get(name)
        return mech if isinstance(mech, ServerMechanism) else None
635829
def administration(self):
        """"""
        from ..manageags._services import AGSService
        url = self._url
        res = search("/rest/", url).span()
        addText = "/admin/"
        part1 = url[:res[1]].lower().replace('/rest/', '')
        part2 = url[res[1]:].lower().replace('/featureserver', ".mapserver")
        adminURL = "%s%s%s" % (part1, addText, part2)
        return AGSService(url=adminURL,
                          securityHandler=self._securityHandler,
                          proxy_url=self._proxy_url,
                          proxy_port=self._proxy_port,
                          initialize=False)
225473
def get_server_home(self):
        
        home_dir = super(MongodServer, self).get_server_home()
        if not home_dir:
            home_dir = self.get_db_path()

        return home_dir