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