def create_channel(self, name, priority=0, *, wait=True): """ Create a new channel. """ address = self.broadcaster.search(name) circuit = self.get_circuit(address, priority) cid = circuit.circuit.new_channel_id() cachan = ca.ClientChannel(name, circuit.circuit, cid=cid) chan = circuit.channels[cid] = Channel(circuit, cachan) with circuit.new_command_cond: if circuit.circuit.states[ca.SERVER] is ca.IDLE: circuit.create_connection() circuit.send(cachan.version(), cachan.host_name(), cachan.client_name()) # NOTE: starting the response command evaluation thread here, # after having sent the VersionRequest, fixes a race condition # with handling of rsrv sending VersionResponse upon connection circuit.command_thread.start() _condition_with_timeout(lambda: circuit.connected, circuit.new_command_cond, 2) # do not need to lock here, take care of in send method circuit.send(cachan.create()) if wait: chan.wait_for_connection() return chan
def test_create_channel_failure(circuit_pair): cli_circuit, srv_circuit = circuit_pair cid = cli_circuit.new_channel_id() sid = srv_circuit.new_channel_id() cli_channel = ca.ClientChannel('doomed', cli_circuit, cid) srv_channel = ca.ServerChannel('doomed', srv_circuit, sid) # Send and receive CreateChanRequest req = cli_channel.create() cli_circuit.send(req) commands, _ = srv_circuit.recv(bytes(req)) for command in commands: srv_circuit.process_command(command) # Send and receive CreateChFailResponse. res = ca.CreateChFailResponse(req.cid) buffers_to_send = srv_circuit.send(res) assert srv_channel.states[ca.CLIENT] is ca.FAILED assert srv_channel.states[ca.SERVER] is ca.FAILED assert cli_channel.states[ca.CLIENT] is ca.AWAIT_CREATE_CHAN_RESPONSE assert cli_channel.states[ca.SERVER] is ca.SEND_CREATE_CHAN_RESPONSE commands, _ = cli_circuit.recv(*buffers_to_send) for command in commands: cli_circuit.process_command(command) assert cli_channel.states[ca.CLIENT] is ca.FAILED assert cli_channel.states[ca.SERVER] is ca.FAILED
def make_channel(pv_name, udp_sock, priority, timeout): log = logging.LoggerAdapter(logging.getLogger('caproto.ch'), {'pv': pv_name}) address = search(pv_name, udp_sock, timeout) try: circuit = global_circuits[(address, priority)] except KeyError: circuit = global_circuits[(address, priority)] = ca.VirtualCircuit( our_role=ca.CLIENT, address=address, priority=priority) chan = ca.ClientChannel(pv_name, circuit) new = False if chan.circuit not in sockets: new = True sockets[chan.circuit] = socket.create_connection( chan.circuit.address, timeout) circuit.our_address = sockets[chan.circuit].getsockname() try: if new: # Initialize our new TCP-based CA connection with a VersionRequest. send( chan.circuit, ca.VersionRequest(priority=priority, version=ca.DEFAULT_PROTOCOL_VERSION), pv_name) send(chan.circuit, chan.host_name(socket.gethostname())) send(chan.circuit, chan.client_name(getpass.getuser())) send(chan.circuit, chan.create(), pv_name) t = time.monotonic() while True: try: commands = recv(chan.circuit) if time.monotonic() - t > timeout: raise socket.timeout except socket.timeout: raise CaprotoTimeoutError("Timeout while awaiting channel " "creation.") tags = { 'direction': '<<<---', 'our_address': chan.circuit.our_address, 'their_address': chan.circuit.address } for command in commands: if isinstance(command, ca.Message): tags['bytesize'] = len(command) logger.debug("%r", command, extra=tags) elif command is ca.DISCONNECTED: raise CaprotoError('Disconnected during initialization') if chan.states[ca.CLIENT] is ca.CONNECTED: log.info("Channel connected.") break except BaseException: sockets[chan.circuit].close() del sockets[chan.circuit] del global_circuits[(chan.circuit.address, chan.circuit.priority)] raise return chan
def make_channel(pv_name, udp_sock, priority, timeout): log = logging.getLogger(f'caproto.ch.{pv_name}.{priority}') address = search(pv_name, udp_sock, timeout) try: circuit = global_circuits[(address, priority)] except KeyError: circuit = global_circuits[(address, priority)] = ca.VirtualCircuit( our_role=ca.CLIENT, address=address, priority=priority) chan = ca.ClientChannel(pv_name, circuit) new = False if chan.circuit not in sockets: new = True sockets[chan.circuit] = socket.create_connection( chan.circuit.address, timeout) try: if new: # Initialize our new TCP-based CA connection with a VersionRequest. send( chan.circuit, ca.VersionRequest(priority=priority, version=ca.DEFAULT_PROTOCOL_VERSION)) send(chan.circuit, chan.host_name(socket.gethostname())) send(chan.circuit, chan.client_name(getpass.getuser())) send(chan.circuit, chan.create()) t = time.monotonic() while True: try: commands = recv(chan.circuit) if time.monotonic() - t > timeout: raise socket.timeout except socket.timeout: raise CaprotoTimeoutError("Timeout while awaiting channel " "creation.") if chan.states[ca.CLIENT] is ca.CONNECTED: log.info('%s connected' % pv_name) break for command in commands: if command is ca.DISCONNECTED: raise CaprotoError('Disconnected during initialization') except BaseException: sockets[chan.circuit].close() del sockets[chan.circuit] del global_circuits[(chan.circuit.address, chan.circuit.priority)] raise return chan
async def create_channel(self, name, priority=0): """ Create a new channel. """ address = self.broadcaster.search_results[name] circuit = await self.get_circuit(address, priority) chan = ca.ClientChannel(name, circuit.circuit) # Wait for the SERVER to agree that we have an initialized circuit. while True: async with circuit.new_command_condition: state = circuit.circuit.states[ca.SERVER] if state is ca.CONNECTED: break await circuit.new_command_condition.wait() # Send command that creates the Channel. await circuit.send(chan.create()) return Channel(circuit, chan)
def make_channels(cli_circuit, srv_circuit, data_type, data_count, name='a'): cid = cli_circuit.new_channel_id() sid = srv_circuit.new_channel_id() cli_channel = ca.ClientChannel(name, cli_circuit, cid) srv_channel = ca.ServerChannel(name, srv_circuit, cid) req = cli_channel.create() cli_circuit.send(req) commands, num_bytes_needed = srv_circuit.recv(bytes(req)) for command in commands: srv_circuit.process_command(command) res = srv_channel.create(data_type, data_count, sid) srv_circuit.send(res) commands, num_bytes_needed = cli_circuit.recv(bytes(res)) for command in commands: cli_circuit.process_command(command) return cli_channel, srv_channel
async def create_channel(self, name, priority=0): """ Create a new channel. """ address = self.broadcaster.search_results[name] circuit = self.get_circuit(address, priority) chan = ca.ClientChannel(name, circuit.circuit) if chan.circuit.states[ca.SERVER] is ca.IDLE: await circuit._socket_lock.acquire() # wrong primitive await curio.spawn(circuit.create_connection(), daemon=True) await curio.spawn(circuit._command_queue_loop(), daemon=True) await circuit.send(chan.version()) await circuit.send(chan.host_name()) await circuit.send(chan.client_name()) await circuit.send(chan.create()) return Channel(circuit, chan)
def test_nonet(): # Register with the repeater. assert not cli_b._registered bytes_to_send = cli_b.send(ca.RepeaterRegisterRequest('0.0.0.0')) assert not cli_b._registered # Receive response data = bytes(ca.RepeaterConfirmResponse('127.0.0.1')) commands = cli_b.recv(data, cli_addr) cli_b.process_commands(commands) assert cli_b._registered # Search for pv1. # CA requires us to send a VersionRequest and a SearchRequest bundled into # one datagram. bytes_to_send = cli_b.send(ca.VersionRequest(0, ca.DEFAULT_PROTOCOL_VERSION), ca.SearchRequest(pv1, 0, ca.DEFAULT_PROTOCOL_VERSION)) commands = srv_b.recv(bytes_to_send, cli_addr) srv_b.process_commands(commands) ver_req, search_req = commands bytes_to_send = srv_b.send( ca.VersionResponse(ca.DEFAULT_PROTOCOL_VERSION), ca.SearchResponse(5064, None, search_req.cid, ca.DEFAULT_PROTOCOL_VERSION)) # Receive a VersionResponse and SearchResponse. commands = iter(cli_b.recv(bytes_to_send, cli_addr)) command = next(commands) assert type(command) is ca.VersionResponse command = next(commands) assert type(command) is ca.SearchResponse address = ca.extract_address(command) circuit = ca.VirtualCircuit(our_role=ca.CLIENT, address=address, priority=0) circuit.log.setLevel('DEBUG') chan1 = ca.ClientChannel(pv1, circuit) assert chan1.states[ca.CLIENT] is ca.SEND_CREATE_CHAN_REQUEST assert chan1.states[ca.SERVER] is ca.IDLE srv_circuit = ca.VirtualCircuit(our_role=ca.SERVER, address=address, priority=None) cli_send(chan1.circuit, ca.VersionRequest(priority=0, version=ca.DEFAULT_PROTOCOL_VERSION)) srv_recv(srv_circuit) srv_send(srv_circuit, ca.VersionResponse(version=ca.DEFAULT_PROTOCOL_VERSION)) cli_recv(chan1.circuit) cli_send(chan1.circuit, ca.HostNameRequest('localhost')) cli_send(chan1.circuit, ca.ClientNameRequest('username')) cli_send(chan1.circuit, ca.CreateChanRequest(name=pv1, cid=chan1.cid, version=ca.DEFAULT_PROTOCOL_VERSION)) assert chan1.states[ca.CLIENT] is ca.AWAIT_CREATE_CHAN_RESPONSE assert chan1.states[ca.SERVER] is ca.SEND_CREATE_CHAN_RESPONSE srv_recv(srv_circuit) assert chan1.states[ca.CLIENT] is ca.AWAIT_CREATE_CHAN_RESPONSE assert chan1.states[ca.SERVER] is ca.SEND_CREATE_CHAN_RESPONSE srv_chan1, = srv_circuit.channels.values() assert srv_chan1.states[ca.CLIENT] is ca.AWAIT_CREATE_CHAN_RESPONSE assert srv_chan1.states[ca.SERVER] is ca.SEND_CREATE_CHAN_RESPONSE srv_send(srv_circuit, ca.CreateChanResponse(cid=chan1.cid, sid=1, data_type=5, data_count=1)) assert srv_chan1.states[ca.CLIENT] is ca.CONNECTED assert srv_chan1.states[ca.SERVER] is ca.CONNECTED # At this point the CLIENT is not aware that we are CONNECTED because it # has not yet received the CreateChanResponse. It should not be allowed to # read or write. assert chan1.states[ca.CLIENT] is ca.AWAIT_CREATE_CHAN_RESPONSE assert chan1.states[ca.SERVER] is ca.SEND_CREATE_CHAN_RESPONSE # Try sending a premature read request. read_req = ca.ReadNotifyRequest(sid=srv_chan1.sid, data_type=srv_chan1.native_data_type, data_count=srv_chan1.native_data_count, ioid=0) with pytest.raises(ca.LocalProtocolError): cli_send(chan1.circuit, read_req) # The above failed because the sid is not recognized. Remove that failure # by editing the sid cache, and check that it *still* fails, this time # because of the state machine prohibiting this command before the channel # is in a CONNECTED state. chan1.circuit.channels_sid[1] = chan1 with pytest.raises(ca.LocalProtocolError): cli_send(chan1.circuit, read_req) cli_recv(chan1.circuit) assert chan1.states[ca.CLIENT] is ca.CONNECTED assert chan1.states[ca.SERVER] is ca.CONNECTED # Test subscriptions. assert chan1.native_data_type and chan1.native_data_count add_req = ca.EventAddRequest(data_type=chan1.native_data_type, data_count=chan1.native_data_count, sid=chan1.sid, subscriptionid=0, low=0, high=0, to=0, mask=1) cli_send(chan1.circuit, add_req) srv_recv(srv_circuit) add_res = ca.EventAddResponse(data=(3,), data_type=chan1.native_data_type, data_count=chan1.native_data_count, subscriptionid=0, status=1) srv_send(srv_circuit, add_res) cli_recv(chan1.circuit) cancel_req = ca.EventCancelRequest(data_type=add_req.data_type, sid=add_req.sid, subscriptionid=add_req.subscriptionid) cli_send(chan1.circuit, cancel_req) srv_recv(srv_circuit) # Test reading. cli_send(chan1.circuit, ca.ReadNotifyRequest(data_type=5, data_count=1, sid=chan1.sid, ioid=12)) srv_recv(srv_circuit) srv_send(srv_circuit, ca.ReadNotifyResponse(data=(3,), data_type=5, data_count=1, ioid=12, status=1)) cli_recv(chan1.circuit) # Test writing. request = ca.WriteNotifyRequest(data_type=2, data_count=1, sid=chan1.sid, ioid=13, data=(4,)) cli_send(chan1.circuit, request) srv_recv(srv_circuit) srv_send(srv_circuit, ca.WriteNotifyResponse(data_type=5, data_count=1, ioid=13, status=1)) cli_recv(chan1.circuit) # Test "clearing" (closing) the channel. cli_send(chan1.circuit, ca.ClearChannelRequest(sid=chan1.sid, cid=chan1.cid)) assert chan1.states[ca.CLIENT] is ca.MUST_CLOSE assert chan1.states[ca.SERVER] is ca.MUST_CLOSE srv_recv(srv_circuit) assert srv_chan1.states[ca.CLIENT] is ca.MUST_CLOSE assert srv_chan1.states[ca.SERVER] is ca.MUST_CLOSE srv_send(srv_circuit, ca.ClearChannelResponse(sid=chan1.sid, cid=chan1.cid)) assert srv_chan1.states[ca.CLIENT] is ca.CLOSED assert srv_chan1.states[ca.SERVER] is ca.CLOSED
def main(*, skip_monitor_section=False): # A broadcast socket udp_sock = ca.bcast_socket() # Register with the repeater. bytes_to_send = b.send(ca.RepeaterRegisterRequest('0.0.0.0')) # TODO: for test environment with specific hosts listed in # EPICS_CA_ADDR_LIST if False: fake_reg = (('127.0.0.1', ca.EPICS_CA1_PORT), [ca.RepeaterConfirmResponse(repeater_address='127.0.0.1')]) b.command_queue.put(fake_reg) else: udp_sock.sendto(bytes_to_send, ('', CA_REPEATER_PORT)) # Receive response data, address = udp_sock.recvfrom(1024) commands = b.recv(data, address) b.process_commands(commands) # Search for pv1. # CA requires us to send a VersionRequest and a SearchRequest bundled into # one datagram. bytes_to_send = b.send(ca.VersionRequest(0, 13), ca.SearchRequest(pv1, 0, 13)) for host in ca.get_address_list(): if ':' in host: host, _, specified_port = host.partition(':') udp_sock.sendto(bytes_to_send, (host, int(specified_port))) else: udp_sock.sendto(bytes_to_send, (host, CA_SERVER_PORT)) print('searching for %s' % pv1) # Receive a VersionResponse and SearchResponse. bytes_received, address = udp_sock.recvfrom(1024) commands = b.recv(bytes_received, address) b.process_commands(commands) c1, c2 = commands assert type(c1) is ca.VersionResponse assert type(c2) is ca.SearchResponse address = ca.extract_address(c2) circuit = ca.VirtualCircuit(our_role=ca.CLIENT, address=address, priority=0) circuit.log.setLevel('DEBUG') chan1 = ca.ClientChannel(pv1, circuit) sockets[chan1.circuit] = socket.create_connection(chan1.circuit.address) # Initialize our new TCP-based CA connection with a VersionRequest. send(chan1.circuit, ca.VersionRequest(priority=0, version=13)) recv(chan1.circuit) # Send info about us. send(chan1.circuit, ca.HostNameRequest('localhost')) send(chan1.circuit, ca.ClientNameRequest('username')) send(chan1.circuit, ca.CreateChanRequest(name=pv1, cid=chan1.cid, version=13)) commands = recv(chan1.circuit) # Test subscriptions. assert chan1.native_data_type and chan1.native_data_count add_req = ca.EventAddRequest(data_type=chan1.native_data_type, data_count=chan1.native_data_count, sid=chan1.sid, subscriptionid=0, low=0, high=0, to=0, mask=1) send(chan1.circuit, add_req) commands = recv(chan1.circuit) if not skip_monitor_section: try: print('Monitoring until Ctrl-C is hit. Meanwhile, use caput to ' 'change the value and watch for commands to arrive here.') while True: commands = recv(chan1.circuit) if commands: print(commands) except KeyboardInterrupt: pass cancel_req = ca.EventCancelRequest(data_type=add_req.data_type, sid=add_req.sid, subscriptionid=add_req.subscriptionid) send(chan1.circuit, cancel_req) commands, = recv(chan1.circuit) # Test reading. send( chan1.circuit, ca.ReadNotifyRequest(data_type=2, data_count=1, sid=chan1.sid, ioid=12)) commands, = recv(chan1.circuit) # Test writing. request = ca.WriteNotifyRequest(data_type=2, data_count=1, sid=chan1.sid, ioid=13, data=(4, )) send(chan1.circuit, request) recv(chan1.circuit) time.sleep(2) send( chan1.circuit, ca.ReadNotifyRequest(data_type=2, data_count=1, sid=chan1.sid, ioid=14)) recv(chan1.circuit) # Test "clearing" (closing) the channel. send(chan1.circuit, ca.ClearChannelRequest(chan1.sid, chan1.cid)) recv(chan1.circuit) sockets.pop(chan1.circuit).close() udp_sock.close()