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()
