def test_get_location_old_contact_file(monkeypatch, mpatch_get_fqdn_by_host): """It Fails because it's not a Cylc 8 workflow.""" contact_data = BASE_CONTACT_DATA.copy() contact_data['CYLC_SUITE_PUBLISH_PORT'] = '8042' contact_data['CYLC_VERSION'] = '5.1.2' monkeypatch.setattr( cylc.flow.network, 'load_contact_file', lambda _ : contact_data ) with pytest.raises(CylcVersionError, match=r'.*5.1.2.*') as exc: get_location('_')
def __init__(self, workflow: str, host: Optional[str] = None, port: Optional[int] = None, context: Optional[zmq.asyncio.Context] = None, timeout: Union[float, str, None] = None, srv_public_key_loc: Optional[str] = None): super().__init__(zmq.REQ, context=context) self.workflow = workflow if not host or not port: host, port, _ = get_location(workflow) else: port = int(port) self.host = host self.port = port if timeout is None: timeout = self.DEFAULT_TIMEOUT else: timeout = float(timeout) self.timeout = timeout * 1000 self.timeout_handler = partial(self._timeout_handler, workflow, host, port) self.poller: Any = None # Connect the ZMQ socket on instantiation self.start(self.host, self.port, srv_public_key_loc) # gather header info post start self.header = self.get_header()
def __init__(self, suite: str, host: str = None, port: int = None, context: object = None, timeout: Union[float, str] = None, srv_public_key_loc: str = None): super().__init__(zmq.REQ, context=context) self.suite = suite if not host or not port: host, port, _ = get_location(suite) else: port = int(port) self.host = host self.port = port if timeout is None: timeout = self.DEFAULT_TIMEOUT else: timeout = float(timeout) self.timeout = timeout * 1000 self.timeout_handler = partial(self._timeout_handler, suite, host, port) self.poller = None # Connect the ZMQ socket on instantiation self.start(self.host, self.port, srv_public_key_loc) # gather header info post start self.header = self.get_header()
def __init__(self, suite: str, host: str = None, timeout: Union[float, str] = None): self.suite = suite if not host: self.host, _, _ = get_location(suite)
def __init__( self, workflow: str, host: str = None, timeout: Union[float, str] = None ): self.workflow = workflow if not host: self.host, _, _ = get_location(workflow)
def __init__(self, workflow: str, host: str = None, timeout: Union[float, str] = None): self.workflow = workflow self.SLEEP_INTERVAL = 0.1 if not host: self.host, _, _ = get_location(workflow) # 5 min default timeout self.timeout = timeout if timeout is not None else 300
def test_get_location_ok(monkeypatch, mpatch_get_fqdn_by_host): """It passes when information is available.""" contact_data = BASE_CONTACT_DATA.copy() contact_data[ContactFileFields.PUBLISH_PORT] = '8042' monkeypatch.setattr( cylc.flow.network, 'load_contact_file', lambda _ : contact_data ) assert get_location('_') == ( 'myhost.x.y.z', 42, 8042 )
def main(_, options, *args): suite = args[0] if len(args) > 1: try: user_at_host, options.port = args[1].split(':') options.owner, options.host = user_at_host.split('@') except ValueError: print(('USER_AT_HOST must take the form ' '"user@host:port"'), file=sys.stderr) sys.exit(1) elif options.host is None or options.port is None: try: while True: try: options.host, _, options.port = get_location( suite, options.owner, options.host) except (ClientError, IOError, TypeError, ValueError): time.sleep(3) continue break except KeyboardInterrupt: exit() print(f'Connecting to tcp://{options.host}:{options.port}') topic_set = set() topic_set.add(b'shutdown') for topic in options.topics.split(','): topic_set.add(topic.encode('utf-8')) subscriber = WorkflowSubscriber(suite, host=options.host, port=options.port, topics=topic_set) subscriber.loop.create_task( subscriber.subscribe(process_delta_msg, func=print_message, subscriber=subscriber, once=options.once)) # run Python run try: subscriber.loop.run_forever() except (KeyboardInterrupt, SystemExit): print('\nDisconnecting') subscriber.stop() exit()
def __init__(self, suite: str, owner: str = None, host: str = None, port: Union[int, str] = None, context: object = None, srv_public_key_loc: str = None, topics: Iterable[bytes] = None): super().__init__(zmq.SUB, context=context) self.suite = suite if port: port = int(port) if not (host and port): host, _, port = get_location(suite, owner, host) if topics is None: self.topics = set(b'') self.topics = topics # Connect the ZMQ socket on instantiation self.start(host, port, srv_public_key_loc)
def main(_, options, *args): suite = args[0] try: while True: try: host, _, port = get_location(suite) except (ClientError, IOError, TypeError, ValueError) as exc: print(exc) time.sleep(3) continue break except KeyboardInterrupt: sys.exit() print(f'Connecting to tcp://{host}:{port}') topic_set = set() topic_set.add(b'shutdown') for topic in options.topics.split(','): topic_set.add(topic.encode('utf-8')) subscriber = WorkflowSubscriber(suite, host=host, port=port, topics=topic_set) subscriber.loop.create_task( subscriber.subscribe(process_delta_msg, func=print_message, subscriber=subscriber, once=options.once)) # run Python run try: subscriber.loop.run_forever() except (KeyboardInterrupt, SystemExit): print('\nDisconnecting') subscriber.stop() sys.exit()
async def async_request( self, command: str, args: Optional[Dict[str, Any]] = None, timeout: Optional[float] = None, req_meta: Optional[Dict[str, Any]] = None) -> object: """Send an asynchronous request using asyncio. Has the same arguments and return values as ``serial_request``. """ timeout = (float(timeout) * 1000 if timeout else None) or self.timeout if not args: args = {} # Note: we are using CurveZMQ to secure the messages (see # self.curve_auth, self.socket.curve_...key etc.). We have set up # public-key cryptography on the ZMQ messaging and sockets, so # there is no need to encrypt messages ourselves before sending. # send message msg: Dict[str, Any] = {'command': command, 'args': args} msg.update(self.header) # add the request metadata if req_meta: msg['meta'].update(req_meta) LOG.debug('zmq:send %s', msg) message = encode_(msg) self.socket.send_string(message) # receive response if self.poller.poll(timeout): res = await self.socket.recv() else: if callable(self.timeout_handler): self.timeout_handler() host, port, _ = get_location(self.workflow) if host != self.host or port != self.port: raise WorkflowStopped(self.workflow) raise ClientTimeout( 'Timeout waiting for server response.' ' This could be due to network or server issues.' ' Check the workflow log.') if msg['command'] in PB_METHOD_MAP: response = {'data': res} else: response = decode_(res.decode()) LOG.debug('zmq:recv %s', response) try: return response['data'] except KeyError: error = response.get( 'error', {'message': f'Received invalid response: {response}'}, ) raise ClientError( error.get('message'), error.get('traceback'), )