def cb_tcp_accept_recv(self, cs_tcp_accept_recv):
engine = cs_tcp_accept_recv.engine
accept_sid = cs_tcp_accept_recv.accept_sid
bb = cs_tcp_accept_recv.bb
#
msg = bb.decode('utf8')
log('cb_tcp_accept_recv [%s]' % (msg))
def cb_pub_stop(self, cs_pub_stop):
engine = cs_pub_stop.engine
pub_sid = cs_pub_stop.pub_sid
message = cs_pub_stop.message
#
log('pub stop %s'%(self.pub_sid))
self.pub_sid = None
def __init__(self, orb, nearcast_schema, filename):
self.orb = orb
self.nearcast_schema = nearcast_schema
self.filename = filename
#
self.f_ptr = open(filename, 'w+')
log('Logging to %s' % filename)
def cb_tcp_server_stop(self, cs_tcp_server_stop):
engine = cs_tcp_server_stop.engine
server_sid = cs_tcp_server_stop.server_sid
msg = cs_tcp_server_stop.message
#
self.server_sid = None
log('cb_tcp_server_stop, sid %s, %s' % (server_sid, msg))
def cb_linetalk_command(self, cs_linetalk_command):
accept_sid = cs_linetalk_command.accept_sid
tokens = cs_linetalk_command.tokens
session = self.d_session[accept_sid]
log('linetalk command |%s|' % (tokens))
def cb_linetalk_command(self, cs_linetalk_command):
accept_sid = cs_linetalk_command.accept_sid
tokens = cs_linetalk_command.tokens
#
def complain(msg):
self.rail_linetalk.send(
accept_sid=accept_sid,
msg=' %s\n'%msg)
#
log('tokens |%s|'%(str(tokens)))
if 0 == len(tokens):
pass
elif tokens[0] == 'add':
if 3 != len(tokens):
complain('Usage: add a b')
return
(_, a, b) = tokens
self.nearcast.cmd_add(
accept_sid=accept_sid,
a=a,
b=b)
elif tokens[0] == 'echo':
if 2 != len(tokens):
complain('Usage: echo s')
return
(_, s) = tokens
self.nearcast.cmd_echo(
accept_sid=accept_sid,
s=s)
elif tokens[0] == 'quit':
self.nearcast.cmd_quit(
accept_sid=accept_sid)
else:
complain('??')
return
def cb_tcp_accept_recv(self, cs_tcp_accept_recv):
engine = cs_tcp_accept_recv.engine
accept_sid = cs_tcp_accept_recv.accept_sid
bb = cs_tcp_accept_recv.bb
#
try:
s = bb.decode('utf8')
except UnicodeDecodeError as e:
hexdump(bb)
log('ERROR: unicode decode error. |%s|'%(accept_sid))
engine.close_tcp_accept(
accept_sid=accept_sid)
return
#
for c in s:
if c == '\n':
line = ''.join(self.c_buffer)
self.c_buffer = []
tokens = tokenise_line(
line=line)
self.call_line_console_command(
rail_h=self.rail_h,
tokens=tokens)
elif c == '\r':
continue
else:
self.c_buffer.append(c)
def should_write_string():
sip = Sip(100)
#
# In UTF8, the delta symbol takes two bytes (\xce\x94').
delta_symbol = u'\N{GREEK CAPITAL LETTER DELTA}'
assert 1 == len(delta_symbol)
delta_len = len(delta_symbol.encode('utf8'))
assert 2 == delta_len
#
# Length of the source string, in characters.
source = u'abcdefghi%s' % (delta_symbol)
source_string_len = len(source)
assert 10 == source_string_len
#
# Length of the source string, in bytes
utf8_bytes = bytes(source.encode('utf8'))
assert 11 == len(utf8_bytes)
#
# Store in the arr
sip.store_vs(o=10, arr=utf8_bytes)
assert 11 == sip.get_vslen(o=10)
#
# String from the arr
log('!! %s' % (sip.get_vs(10)))
assert source == sip.get_vs(o=10)
#
# Fetch from the arr. Currently we're not testing that this is correct.
second = bytearray(sip.get_vslen(o=10))
sip.fetch_vs(o=10, arr=second)
assert second == utf8_bytes
#
return True
def metasock_create_sub(engine, mempool, sid, addr, port, cb_sub_start, cb_sub_stop, cb_sub_recv):
log('metasock_create_sub %s (%s:%s)'%(sid, addr, port))
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock_nodelay_condition(
engine=engine,
sock=sock)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind((addr, port))
sock.setblocking(0)
#
ms = Metasock(
engine=engine,
mempool=mempool,
sid=sid,
ms_type=MS_TYPE_SUB,
addr=addr,
port=port)
ms.sock = sock
ms.can_it_recv = True
ms.can_it_send = False
ms.cb_sub_start = cb_sub_start
ms.cb_sub_stop = cb_sub_stop
ms.cb_sub_recv = cb_sub_recv
#
engine._map_sid_to_metasock(
sid=sid,
ms=ms)
ms.after_init()
#
return ms
def cb_tcp_accept_condrop(self, cs_tcp_accept_condrop):
engine = cs_tcp_accept_condrop.engine
server_sid = cs_tcp_accept_condrop.server_sid
accept_sid = cs_tcp_accept_condrop.accept_sid
message = cs_tcp_accept_condrop.message
#
log('xxx')
def metasock_create_tcp_accept(engine, mempool, sid, accept_sock, addr, port, parent_sid, cb_tcp_accept_connect, cb_tcp_accept_condrop, cb_tcp_accept_recv):
"""This is in the chain of functions that get called after a tcp server
accepts a connection. In BSD sockets language, this is considered to be a
'client' socket. But in our language, we call this an 'accept' socket.
That is, we distinguish between server, client and accept."""
log('metasock_create_tcp_accept %s (%s:%s)'%(sid, addr, port))
sock_nodelay_condition(
engine=engine,
sock=accept_sock)
#
ms = Metasock(
engine=engine,
mempool=mempool,
sid=sid,
ms_type=MS_TYPE_TCP_ACCEPT,
addr=addr,
port=port)
ms.sock = accept_sock
ms.can_it_recv = True
ms.can_it_send = True
ms.parent_sid = parent_sid
ms.cb_tcp_accept_connect = cb_tcp_accept_connect
ms.cb_tcp_accept_condrop = cb_tcp_accept_condrop
ms.cb_tcp_accept_recv = cb_tcp_accept_recv
#
engine._map_sid_to_metasock(
sid=sid,
ms=ms)
ms.after_init()
#
return ms
def cb_tcp_server_start(self, cs_tcp_server_start):
engine = cs_tcp_server_start.engine
server_sid = cs_tcp_server_start.server_sid
addr = cs_tcp_server_start.addr
port = cs_tcp_server_start.port
#
log('xxx')
def metasock_create_tcp_client(engine, mempool, sid, addr, port, cb_tcp_client_connect, cb_tcp_client_condrop, cb_tcp_client_recv):
log('metasock_create_tcp_client %s (%s:%s)'%(sid, addr, port))
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock_nodelay_condition(
engine=engine,
sock=sock)
sock.setblocking(0)
sock.connect_ex( (addr, port) )
#
ms = Metasock(
engine=engine,
mempool=mempool,
sid=sid,
ms_type=MS_TYPE_TCP_CLIENT,
addr=addr,
port=port)
ms.sock = sock
ms.can_it_recv = True
ms.can_it_send = True
ms.b_tcp_client_connecting = True
ms.cb_tcp_client_connect = cb_tcp_client_connect
ms.cb_tcp_client_condrop = cb_tcp_client_condrop
ms.cb_tcp_client_recv = cb_tcp_client_recv
#
engine._map_sid_to_metasock(
sid=sid,
ms=ms)
ms.after_init()
#
return ms
def metasock_create_tcp_server(engine, mempool, sid, addr, port, cb_tcp_server_start, cb_tcp_server_stop, cb_tcp_accept_connect, cb_tcp_accept_condrop, cb_tcp_accept_recv):
log('metasock_create_tcp_server %s (%s:%s)'%(sid, addr, port))
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock_nodelay_condition(
engine=engine,
sock=sock)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind((addr, port))
sock.setblocking(0)
sock.listen(0)
#
ms = Metasock(
engine=engine,
mempool=mempool,
sid=sid,
ms_type=MS_TYPE_TCP_SERVER,
addr=addr,
port=port)
ms.sock = sock
ms.can_it_recv = True
ms.can_it_send = True
ms.cb_tcp_accept_condrop = cb_tcp_accept_condrop
ms.cb_tcp_accept_connect = cb_tcp_accept_connect
ms.cb_tcp_accept_recv = cb_tcp_accept_recv
ms.cb_tcp_server_start = cb_tcp_server_start
ms.cb_tcp_server_stop = cb_tcp_server_stop
#
engine._map_sid_to_metasock(
sid=sid,
ms=ms)
ms.after_init()
#
return ms
def cb_recv_bulk_protocol_head(self, cs_recv_bulk_protocol_head):
zero_h = cs_recv_bulk_protocol_head.zero_h
doc_len = cs_recv_bulk_protocol_head.doc_len
self.doc_len = doc_len
self.doc_so_far = 0
log('bulk head: %s, doc length: %s' % (zero_h, doc_len))
def cb_tcp_accept_connect(self, cs_tcp_accept_connect):
engine = cs_tcp_accept_connect.engine
server_sid = cs_tcp_accept_connect.server_sid
accept_sid = cs_tcp_accept_connect.accept_sid
accept_addr = cs_tcp_accept_connect.accept_addr
accept_port = cs_tcp_accept_connect.accept_port
self.__stop_server()
self.accept_sid = accept_sid
fingerprint = 'accept%s_%s_%s' % (accept_sid, accept_addr, accept_port)
log('[tcp accept connect, %s]' % (fingerprint))
kilobyte = 1024
megabyte = kilobyte * 1024
block_size = megabyte
zero_h = fingerprint
self.rail_recv_bulk_protocol.zero(
zero_h=zero_h,
cb_recv_bulk_protocol_head=self.cb_recv_bulk_protocol_head,
cb_recv_bulk_protocol_data=self.cb_recv_bulk_protocol_data,
cb_recv_bulk_protocol_done=self.cb_recv_bulk_protocol_done,
block_size=block_size)
self.path = os.path.join(self.track_prime.dir_save,
'%s.bin' % (fingerprint))
self.f_ptr = open(self.path, 'wb+')
def cb_sub_start(self, cs_sub_start):
engine = cs_sub_start.engine
sub_sid = cs_sub_start.sub_sid
addr = cs_sub_start.addr
port = cs_sub_start.port
#
log('sub %s started %s:%s' % (sub_sid, addr, port))
def orb_turn(self, activity):
self.turn_counter += 1
if self.turn_counter == 3:
activity.mark(
l=self,
s="reached the important turn")
#
# The next line uses a convenience object that is injected
# into the cog when the orb initialises it. Internally, this
# is what it is doing:
#
# self.orb.nearcast(
# cog=self,
# message_h='nearcast_note',
# field_a='text in a',
# field_b='text in b')
#
# So why this unusual code injection rather than asking the user
# to write the code above? Writing to the nearcast is a frequent
# operation. The usage below is faster and less distracting once
# you are fluent.
#
self.nearcast.nearcast_note(
field_a='text in a',
field_b='text in b')
log('%s sent nearcast note'%(self.cog_h))
def manage_writable(self):
'''
When select marks a socket as writable, it implies one of these
scenarios:
* Client sockets in the process of connecting
* Sockets which can be written to
* Sudden client disconnect
'''
if not self.can_it_send:
raise Exception("%s is not a send sock."%self.sid)
if self.b_tcp_client_connecting:
ec = self.sock.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR)
log('b_tcp_client_connecting %s'%ec)
if 0 == ec:
# :ms_successful_connection_as_tcp_client
self.b_tcp_client_connecting = False
self.cs_tcp_client_connect.engine = self.engine
self.cs_tcp_client_connect.client_sid = self.sid
self.cs_tcp_client_connect.addr = self.addr
self.cs_tcp_client_connect.port = self.port
self.cb_tcp_client_connect(
cs_tcp_client_connect=self.cs_tcp_client_connect)
elif 'EINPROGRESS' == errno.errorcode[ec]:
pass
else:
e_message = errno.errorcode[ec]
r = ' '.join( [ 'Unable to connect to'
, '%s:%s'%(self.addr, self.port)
, '[%s:%s]'%(ec, e_message)
] )
raise MetasockCloseCondition(r)
return
try:
while self.send_buf:
sip = self.send_buf.popleft()
bb = sip.get()
send_size = self.sock.send(bb)
if send_size == len(bb):
# Ideal situation: our send was successful
self.mempool.free(
sip=sip)
continue
elif 0 == send_size:
# Network conjestion or slow throughput by the reader
# is causing things to back up. This will happen from
# time to time in normal operation.
self.send_buf.appendleft(sip)
break
else:
# This is weird. Since our bb must be smaller than
# the MTU size, this should never happen.
raise Algorithm("Weird: partial payload send. %s of %s"%(
send_size, len(bb)))
except:
# When you try to do a send to a BSD socket that is in the
# process of going down, you can get an exception. This caterss
# for that scenario.
raise MetasockCloseCondition('send_fail')
return
def cb_recv_bulk_protocol_done(self, cs_recv_bulk_protocol_done):
zero_h = cs_recv_bulk_protocol_done.zero_h
log('bulk data: %s, doc done' % (zero_h))
self.f_ptr.close()
self.engine.close_tcp_accept(accept_sid=self.accept_sid)
def cb_sub_stop(self, cs_sub_stop):
engine = cs_sub_stop.engine
sub_sid = cs_sub_stop.sub_sid
message = cs_sub_stop.message
#
log('sub stopped %s' % (sub_sid))
#
self.sub_sid = None
def cb_tcp_accept_connect(self, cs_tcp_accept_connect):
engine = cs_tcp_accept_connect.engine
server_sid = cs_tcp_accept_connect.server_sid
accept_sid = cs_tcp_accept_connect.accept_sid
accept_addr = cs_tcp_accept_connect.accept_addr
accept_port = cs_tcp_accept_connect.accept_port
#
log('xxx')
def cb_pub_start(self, cs_pub_start):
engine = cs_pub_start.engine
pub_sid = cs_pub_start.pub_sid
addr = cs_pub_start.addr
port = cs_pub_start.port
#
self.pub_sid = pub_sid
log('pub start %s'%(self.pub_sid))
def cb_selui_lselect(self, cs_selui_lselect):
drop = cs_selui_lselect.drop
rest = cs_selui_lselect.rest
c = cs_selui_lselect.c
cpair = cs_selui_lselect.cpair
#
pass
log('xxx cb_selui_lselect drop %s rest %s c %s cpair %s'%(drop, rest, c, cpair))
def cb_sub_recv(self, cs_sub_recv):
engine = cs_sub_recv.engine
sub_sid = cs_sub_recv.sub_sid
bb = cs_sub_recv.bb
#
log('sub recv (len %s)' % (len(bb)))
#
self.rail_line_finder.accept_bytes(bb=bb)
def cb_sub_stop(self, cs_sub_stop):
engine = cs_sub_stop.engine
sub_sid = cs_sub_stop.sub_sid
message = cs_sub_stop.message
#
log('sub stopped %s' % sub_sid)
#
self.rail_line_finder.clear()
def cb_tcp_server_start(self, cs_tcp_server_start):
engine = cs_tcp_server_start.engine
server_sid = cs_tcp_server_start.server_sid
addr = cs_tcp_server_start.addr
port = cs_tcp_server_start.port
#
self.server_sid = server_sid
log('cb_tcp_server_start, sid %s, at %s:%s' % (server_sid, addr, port))
def cb_selui_lselect(self, cs_selui_lselect):
drop = cs_selui_lselect.drop
rest = cs_selui_lselect.rest
c = cs_selui_lselect.c
cpair = cs_selui_lselect.cpair
#
# user makes a selection
log('xxx cb_selui_lselect drop %s rest %s'%(drop, rest))
def orb_turn(self, activity):
self.turn_counter += 1
if self.turn_counter == 8:
activity.mark(
l=self,
s='last turn, quitting')
log('quitting')
raise SolentQuitException()
def cb_tcp_accept_condrop(self, cs_tcp_accept_condrop):
engine = cs_tcp_accept_condrop.engine
server_sid = cs_tcp_accept_condrop.server_sid
accept_sid = cs_tcp_accept_condrop.accept_sid
#
log('cb_tcp_accept_condrop from %s' % (accept_sid))
self.accept_sid = None
if self.b_active:
self._start_server()
