def connect(server: str = "localhost", port: int = 5555, timeout: int = 0, access_token: str = None, connect_url=None) -> None: """ Connect to a running arkouda server. Parameters ---------- server : str, optional The hostname of the server (must be visible to the current machine). Defaults to `localhost`. port : int, optional The port of the server. Defaults to 5555. timeout : int, optional The timeout in seconds for client send and receive operations. Defaults to 0 seconds, whicn is interpreted as no timeout. access_token : str, optional The token used to connect to an existing socket to enable access to an Arkouda server where authentication is enabled. Defaults to None. connect_url : str, optional The complete url in the format of tcp://server:port?token=<token_value> where the token is optional Returns ------- None Raises ------ ConnectionError Raised if there's an error in connecting to the Arkouda server ValueError Raised if there's an error in parsing the connect_url parameter RuntimeError Raised if there is a server-side error Notes ----- On success, prints the connected address, as seen by the server. If called with an existing connection, the socket will be re-initialized. """ global context, socket, pspStr, connected, verbose, username, token logger.debug("ZMQ version: {}".format(zmq.zmq_version())) if connect_url: url_values = _parse_url(connect_url) server = url_values[0] port = url_values[1] if len(url_values) == 3: access_token = url_values[2] # "protocol://server:port" pspStr = "tcp://{}:{}".format(server, port) # check to see if tunnelled connection is desired. If so, start tunnel tunnel_server = os.getenv('ARKOUDA_TUNNEL_SERVER') if tunnel_server: (pspStr, _) = _start_tunnel(addr=pspStr, tunnel_server=tunnel_server) logger.debug("psp = {}".format(pspStr)) # create and configure socket for connections to arkouda server socket = context.socket(zmq.REQ) # request end of the zmq connection # if timeout is specified, set send and receive timeout params if timeout > 0: socket.setsockopt(zmq.SNDTIMEO, timeout * 1000) socket.setsockopt(zmq.RCVTIMEO, timeout * 1000) # set token and username global variables username = security.get_username() token = cast( str, _set_access_token(access_token=access_token, connect_string=pspStr)) # connect to arkouda server try: socket.connect(pspStr) except Exception as e: raise ConnectionError(e) # send the connect message message = "connect" logger.debug("[Python] Sending request: {}".format(message)) # send connect request to server and get the response confirming if # the connect request succeeded and, if not not, the error message return_message = _send_string_message(message) logger.debug("[Python] Received response: {}".format(str(return_message))) connected = True conf = get_config() if conf['arkoudaVersion'] != __version__: warnings.warn(('Version mismatch between client ({}) and server ({}); ' + 'this may cause some commands to fail or behave ' + 'incorrectly! Updating arkouda is strongly recommended.').\ format(__version__, conf['arkoudaVersion']), RuntimeWarning)
def testGetUsername(self): self.assertTrue(security.get_username() in security.username_tokenizer \ [platform.system()](security.get_home_directory()))