def client_protocol(socket):
connect_write_to_server = socket.makefile('w')
protocol = 'I32CFP_HELLO\n'
connect_write_to_server.write(protocol)
connect_write_to_server.flush()
receive_ready = socket.makefile('r')
protocol = receive_ready.readline()
if protocol == 'READY\n':
print('The server is ready to start the game')
pass
else:
socket.close()
print('server not speaking the same protocols,close connection.\n')
return
def handle_request(socket, client_address, server):
s = ServerInfo(software=server_version, multiconnection=True, multithread=False, multiprocess=False)
c = ConnectionInfo(server=s)
c.server.addr = LazyAddress(socket.family, lambda: socket.getsockname())
c.remote.addr = Address(socket.family, client_address)
c.socket = socket
with socket.makefile('r') as input:
with socket.makefile('w') as output:
app(input, output, sys.stderr, c)
def client_protocol(socket):
connect_write_to_server = socket.makefile('w')
protocol = 'I32CFP_HELLO\n'
connect_write_to_server.write(protocol)
connect_write_to_server.flush()
receive_ready = socket.makefile('r')
protocol = receive_ready.readline()
if protocol == 'READY\n':
print('The server is ready to start the game')
pass
else:
socket.close()
print('server not speaking the same protocols,close connection.\n')
return
def receive_protocols(socket):
file_in = socket.makefile('r')
protocols = file_in.readline()
file_in.close()
if protocols == 'I32CFP_HELLO\n':
file_out = socket.makefile('w')
file_out.write('READY\n')
file_out.flush()
file_out.close()
pass
else:
socket.close()
print('Client is not speaking the same protocols.Closing connection.\n')
return
def receive_protocols(socket):
file_in = socket.makefile('r')
protocols = file_in.readline()
file_in.close()
if protocols == 'I32CFP_HELLO\n':
file_out = socket.makefile('w')
file_out.write('READY\n')
file_out.flush()
file_out.close()
pass
else:
socket.close()
print(
'Client is not speaking the same protocols.Closing connection.\n')
return
def run(self):
from robocorp_ls_core.debug_adapter_core.debug_adapter_threads import (
writer_thread_no_auto_seq, )
from robocorp_ls_core.debug_adapter_core.debug_adapter_threads import (
reader_thread, )
try:
assert (
self._server_socket
is not None), "start_listening must be called before start()"
# while True:
# Only handle a single connection...
socket, _addr = self._server_socket.accept()
read_from = socket.makefile("rb")
write_to = socket.makefile("wb")
debug_adapter_comm = self._weak_debug_adapter_comm()
writer = self._writer_thread = threading.Thread(
target=writer_thread_no_auto_seq,
args=(write_to, self._write_to_robot_queue,
"write to robot process"),
name=
"Write to robot (LaunchProcessDebugAdapterRobotTargetComm)",
)
writer.daemon = True
reader = self._reader_thread = threading.Thread(
target=reader_thread,
args=(
read_from,
self._from_robot,
debug_adapter_comm.
write_to_client_queue, # Used for errors
b"read from robot process",
),
name=
"Read from robot (LaunchProcessDebugAdapterRobotTargetComm)",
)
reader.daemon = True
reader.start()
writer.start()
self._connected_event.set()
except:
log.exception()
def wait_server_move(mode,column,socket):
output = socket.makefile('w')
output.write(mode+ ' ' + str(column)+'\n')
output.flush()
output.close()
print('Waiting for server to move or update.')
pass
def mangodb(socket, address):
socket.sendall('HELLO\r\n')
client = socket.makefile()
output = open(os.devnull, 'w')
lock = threading.Lock()
wait = threading.Condition(lock)
while 1:
line = client.readline()
if not line:
break
cmd_bits = line.split(' ', 1)
cmd = cmd_bits[0]
if cmd == 'BYE':
break
if cmd == 'WAIT':
wait.wait()
continue
if len(cmd_bits) > 1:
lock.acquire(True)
output.write(cmd_bits[1])
if MANGODB_DURABLE:
output.flush()
os.fsync(output.fileno())
data = '42' if MANGODB_EVENTUAL else \
os.urandom(1024).encode('string-escape')
lock.release()
client.write('OK' + data + '\r\n')
client.flush()
def wait_player_move(mode, col, socket):
output = socket.makefile('w')
output.write(mode + ' ' + str(col) + '\n')
output.flush()
output.close()
print('waiting for player to move')
pass
def handle(self, socket, address):
"""
If not a leader, a node will simply return a single item list pointing
to the leader. Otherwise, it will add the host of the connected client
to the cluster roster, broadcast to all nodes the new roster, and wait
for keepalives. If no keepalive within timeout or the client drops, it
drops it from the roster and broadcasts to all remaining nodes.
"""
self.logger.debug('New connection from %s:%s' % address)
if not self.manager.is_leader:
socket.send(json.dumps({'leader': self.manager.client.leader_address[0],
'port': self.manager.client.leader_address[1]}))
socket.close()
self.logger.debug("Redirected to %s:%s" % self.manager.client.leader_address)
else:
socket.send(self._cluster_message())
sockfile = socket.makefile()
name = sockfile.readline()
if not name:
return
if name == '\n':
name = address[0]
else:
name = name.strip()
self._update(add={'host': name, 'socket': socket})
# TODO: Use TCP keepalives
timeout = self._client_timeout(socket)
for line in util.line_protocol(sockfile, strip=False):
timeout.kill()
timeout = self._client_timeout(socket)
socket.send('\n')
self.logger.debug("Keepalive from %s:%s" % address)
self.logger.debug("Client disconnected from %s:%s" % address)
self._update(remove=name)
def send_video():
connection = None
try:
camera = picamera.PiCamera()
camera.resolution = (VIDEO_WIDTH, VIDEO_HEIGHT)
# let the camera warm up for 2 seconds
time.sleep(2)
# Make a file-like object out of the connection
connection = socket.makefile('wb')
stream = io.BytesIO()
for foo in camera.capture_continuous(stream,
'jpeg',
use_video_port=True):
# Write the length of the capture to the stream and flush to
# ensure it actually gets sent
connection.write(struct.pack('<L', stream.tell()))
connection.flush()
# Rewind the stream and send the image data over the wire
stream.seek(0)
connection.write(stream.read())
# Reset the stream for the next capture
stream.seek(0)
stream.truncate()
# Write a length of zero to the stream to signal we're done
connection.write(struct.pack('<L', 0))
except socket.error as ex:
print(ex)
finally:
connection.close()
socket.close()
def wait_server_move(mode, column, socket):
output = socket.makefile('w')
output.write(mode + ' ' + str(column) + '\n')
output.flush()
output.close()
print('Waiting for server to move or update.')
pass
def handleRequest(tcpSocket):
# 1. Receive request message from the client on connection (tcp?) socket
tcpSocket = serverSocket.accept() # acceptrequest
bufferSize = tcpSocket.CMSG_SPACE(
4
) # IPv4 address is 4 bytes in length - calculates the size of the buffer that should be allocated for receiving the ancillary data.
#recieve message in buffer size allocated
requestMessage = tcpSocket.recvmsg(bufferSize[0, [0]])
# 2. Extract the path of the requested object from the message (second part of the HTTP header)
file = requestMessage.unpack_from(bufferSize) # returns a tuple
# 3. Read the corresponding file from disk
socket.sendfile(file)
# 4. Store in temporary buffer
tempBuffer = socket.makefile(mode='r',
buffering=None,
encoding=None,
errors=None,
newline=None)
tempFile = struct.pack_into(format, self.tempBuffer, 0, file)
# 5. Send the correct HTTP response error
httpResponseError = ("HTTP/1.1 404 Not Found\r\n")
tcpSocket.sendmsg(httpResponseError)
# 6. Send the content of the file to the socket
tcpSocket.recvmsg(bufferSize[0, 0])
# 7. Close the connection socket
tcpSocket.close()
pass
def connection(socket, address):
print('New connection from %s:%s' % (address[0], address[1]))
stream = socket.makefile('rw')
for line in stream:
stream.write(handle(root, line) + '\n')
stream.flush()
def handleRequest(tcpSocket):
# 1. Receive request message from the client on connection socket
bufferSize = tcpSocket.CMSG_SPACE(4) #IPv4 address is 4 bytes in length
requestMessage = tcpSocket.recvmsg(bufferSize[0,[0]])
# 2. Extract the path of the requested object from the message (second part of the HTTP header)
file = requestMessage.unpack_from(format, buffer, offset=1) #returns a tuple
# 3. Read the corresponding file from disk
socket.sendfile(file, offset=0, count=None)
# 4. Store in temporary buffer
buffer = socket.makefile(mode='r', buffering=None, encoding=None,errors=None, newline=None)
struct.pack_into(format, self.buffer, 0, file)
# 5. Send the correct HTTP response error
# 6. Send the content of the file to the socket
tcpSocket.recvmsg(bufferSize[0, 0])
# 7. Close the connection socket
tcpSocket.close()
pass
def wait_player_move(mode, col,socket):
output = socket.makefile('w')
output.write(mode+ ' ' + str(col)+'\n')
output.flush()
output.close()
print('waiting for player to move')
pass
def run(self):
"""Starts listening and accepting connection requests.
This method is called when invoking `CallbackServer.start()`. A
CallbackServer instance is created and started automatically when
a :class:`JavaGateway <py4j.java_gateway.JavaGateway>` instance is
created.
"""
try:
with self.lock:
self.is_shutdown = False
logger.info('Callback Server Starting')
self.server_socket.listen(5)
logger.info('Socket listening on {0}'.
format(smart_decode(self.server_socket.getsockname())))
while not self.is_shutdown:
socket, _ = self.server_socket.accept()
input = socket.makefile('rb', 0)
connection = CallbackConnection(self.pool, input, socket,
self.gateway_client)
with self.lock:
if not self.is_shutdown:
self.connections.append(connection)
connection.start()
else:
connection.socket.shutdown(socket.SHUT_RDWR)
connection.socket.close()
except Exception:
if self.is_shutdown:
logger.info('Error while waiting for a connection.')
else:
logger.exception('Error while waiting for a connection.')
def listen_on_socket(socket, *args):
if socket is None:
return
command = ""
file = socket.makefile('rwb')
while True:
try:
data = file.read(1)
if data == b'':
sleep(0.001)
continue
else:
data = data.decode('ascii')
if data == AtHomeProtocol['end_of_communication']:
print('Communication ended', file=sys.stderr)
return
if data != AtHomeProtocol['end_of_command']:
command += data
else:
command = ""
continue
if command.endswith(AtHomeProtocol['end_of_line']):
command = command[0:-2]
if command in AtHomeCommands:
AtHomeCommands[command](file)
else:
command = ""
raise NameError('[Unknown Command] %s' % command)
command = ""
except EOFError:
file.close()
socket.close()
return
except Exception as e:
print('[Exception] %s' % e, file=sys.stderr)
def __init__(self, socket):
"""Keeps track of the socket and the file posing as the socket"""
self.socket = socket
self.stream = socket.makefile()
self.active = True
self.editor = 'Emacs'
self.name = 'Richard Stallman'
def __init__(self, server, socket):
self.server = server
self.socket = socket
self.socket_file = socket.makefile('rb', 0)
self.compression_enabled = False
self.user_uuid = None
self.user_name = None
def run(self):
"""Starts listening and accepting connection requests.
This method is called when invoking `CallbackServer.start()`. A
CallbackServer instance is created and started automatically when
a :class:`JavaGateway <py4j.java_gateway.JavaGateway>` instance is
created.
"""
try:
with self.lock:
self.is_shutdown = False
logger.info('Callback Server Starting')
self.server_socket.listen(5)
logger.info('Socket listening on {0}'.format(
smart_decode(self.server_socket.getsockname())))
while not self.is_shutdown:
socket, _ = self.server_socket.accept()
input = socket.makefile('rb', 0)
connection = CallbackConnection(self.pool, input, socket,
self.gateway_client)
with self.lock:
if not self.is_shutdown:
self.connections.append(connection)
connection.start()
else:
connection.socket.shutdown(socket.SHUT_RDWR)
connection.socket.close()
except:
logger.exception('Error while waiting for a connection.')
def __init__(self, server, socket):
self.server = server
self.socket = socket
self.socket_file = socket.makefile('rb', 0)
self.compression_enabled = False
self.user_uuid = None
self.user_name = None
def WrapAndSendPayload(cls, socket, payload):
'''
Send payload, true if success, false if failed
'''
try:
# From SocketServer.py
# wbufsize = 0, flush immediately
wbufsize = -1
# Convert
socket_message = SocketMessage(payload)
wfile = socket.makefile('wb', wbufsize)
# Write the message
wfile.write(struct.pack(fmt, socket_message.magic))
# Need to send the packed version
# print 'Sent ', socket_message.magic
wfile.write(struct.pack(fmt, socket_message.payload_size))
# print 'Sent ', socket_message.payload_size
wfile.write(payload)
# print 'Sent ', payload
wfile.flush()
wfile.close() # Close file object, not close the socket
return True
except Exception as e:
_L.error('Fail to send message %s', e)
return False
def WrapAndSendPayload(cls, socket, payload):
"""
Send payload, true if success, false if failed
"""
try:
# From SocketServer.py
# wbufsize = 0, flush immediately
wbufsize = -1
# Convert
socket_message = SocketMessage(payload)
wfile = socket.makefile('wb', wbufsize)
# Write the message
wfile.write(struct.pack(fmt, socket_message.magic))
# Need to send the packed version
# print 'Sent ', socket_message.magic
wfile.write(struct.pack(fmt, socket_message.payload_size))
# print 'Sent ', socket_message.payload_size
wfile.write(payload)
# print 'Sent ', payload
wfile.flush()
wfile.close() # Close file object, not close the socket
return True
except Exception as e:
_L.error('Fail to send message %s', e)
return False
def _wait(self, sock):
onStart = True
with socket.makefile('rb') as f:
while 1:
data = f.readline()
if not data:
self.disconnected.emit()
break
response = json.loads(data.decode())
if onStart:
self.started.emit(response)
onStart = False
else:
self.readyCPULoad.emit(response.get('cpu_percent'))
self.readyCPUFreq.emit(response.get('cpu_freq'))
memory = response.get('memory')
self.readyMemory.emit(memory.get('used'),
memory.get('percent'),
memory.get('availble'))
swap = response.get('swap')
self.readySwap.emit(swap.get('used'), swap.get('percent'),
swap.get('free'))
sleep(1)
def mangodb(socket, address):
socket.sendall('HELLO\r\n')
client = socket.makefile()
output = open(os.devnull, 'w')
lock = threading.Lock()
wait = threading.Condition(lock)
while 1:
line = client.readline()
if not line:
break
cmd_bits = line.split(' ', 1)
cmd = cmd_bits[0]
if cmd == 'BYE':
break
if cmd == 'WAIT':
wait.wait()
continue
if len(cmd_bits) > 1:
lock.acquire(True)
output.write(cmd_bits[1])
if MANGODB_DURABLE:
output.flush()
os.fsync(output.fileno())
data = '42' if MANGODB_EVENTUAL else \
os.urandom(1024).encode('string-escape')
lock.release()
client.write('OK' + data + '\r\n')
client.flush()
def receive(socket, char=None):
f = socket.makefile()
while len(select.select([f], [], [], 0.1)[0]) == 0:
pass
try:
return bdecode(f)
finally:
f.close()
def __init__(self, server, socket):
"""
Override BaseHTTPRequestHandler.__init__(): we need to be able
to have (potentially) multiple handler objects at a given time.
Inputs:
server -- server object to handle requests for
socket -- socket connection
"""
## Settings required by BaseHTTPRequestHandler
self.rfile = socket.makefile("rb", -1)
self.wfile = socket.makefile("wb", 0)
self.connection = socket
self.client_address = (server.host, server.port)
self._server = server
def wait_server_move(mode, drop, socket):
print('runing wait server move')
output = socket.makefile('w')
output.write(mode + ' ' + str(drop) + '\n')
output.flush()
output.close()
print('waiting for server to move')
pass
def wait_server_move(mode,drop,socket):
print('runing wait server move')
output = socket.makefile('w')
output.write(mode+ ' ' + str(drop)+'\n')
output.flush()
output.close()
print('waiting for server to move')
pass
def __init__(self, server, socket):
"""
Override BaseHTTPRequestHandler.__init__(): we need to be able
to have (potentially) multiple handler objects at a given time.
Inputs:
server -- server object to handle requests for
socket -- socket connection
"""
## Settings required by BaseHTTPRequestHandler
self.rfile = socket.makefile('rb', -1)
self.wfile = socket.makefile('wb', 0)
self.connection = socket
self.client_address = (server.host, server.port)
self._server = server
def create_socket_file(socket):
try:
sock_file = socket.makefile()
except Exception as e:
logging.add_log(2, "Problem creating socket file -> %s" % e)
return -1
return sock_file
def get_room(self, room, password):
socket = self.connect_to_service()
socket_fd = socket.makefile()
skip_hello(socket_fd)
send("get_room", socket)
send(password, socket)
send(room, socket)
line = readline(socket_fd)
return line
def recv_json(socket):
if not hasattr(recv_json, 'files'):
recv_json.files = {} # static variable
if not socket in recv_json.files:
recv_json.files[socket] = socket.makefile()
data = recv_json.files[socket].readline()
return json.loads(data.strip())
def recv_lines(socket):
lines = []
file = socket.makefile()
while True:
line = file.readline().strip()
if line == "":
break
lines.append(line)
return lines
def get_room(self, room, password):
socket = self.connect_to_service()
socket_fd = socket.makefile()
skip_hello(socket_fd)
send("get_room", socket)
send(password, socket)
send(room, socket)
line = readline(socket_fd)
return line
def check(self):
socket = self.connect_to_checker()
socket_fd = socket.makefile('r')
send("list", socket)
line = readline(socket_fd)
if not self.hostname in line:
service_down(message="Node not found in cluster")
else:
service_ok()
def get(self, flag_id, flag):
socket = self.connect_to_checker()
socket_fd = socket.makefile()
send("get " + self.hostname + ":" + str(PORT) + " " + flag_id, socket)
result = readline(socket_fd)
if result == flag:
service_ok()
else:
service_corrupt(message="Unexpected GET response: " + result)
def __init__(self, threadID, name, counter,state,socket,finishEvent):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.counter = counter
self.state=state
self.socket=socket
self.socket_file=socket.makefile()
self.finished=finishEvent
def get(self, flag_id, flag):
socket = self.connect_to_checker()
socket_fd = socket.makefile()
send("get " + self.hostname + ":" + str(PORT) + " " + flag_id, socket)
result = readline(socket_fd)
if result == flag:
service_ok()
else:
service_corrupt(message="Unexpected GET response: " + result)
def __init__(self, socket, parent):
self.is_ai = False
self.is_human = False
self.sock = socket
self.fsock = socket.makefile()
self.parent = parent
t = threading.Thread(target=self.receive)
t.daemon = True
t.start()
def recv_lines(socket):
lines = []
file = socket.makefile()
while True:
line = file.readline().strip()
if line == "":
break
lines.append(line)
return lines
def __init__(self, socket, address, server, rfile=None):
if rfile is None and hasattr(socket, "_makefile_refs"):
rfile = socket.makefile()
# restore gEvent's work-around of not letting wsgi.environ['input']
# keep the socket alive in CLOSE_WAIT state after client is gone
# to work with async.SSLSocket
socket._makefile_refs -= 1
self.state = context.get_context().markov_stats['wsgi_handler'].make_transitor('new')
super(MakeFileCloseWSGIHandler, self).__init__(socket, address, server, rfile)
def run(self, room, program, password):
socket = self.connect_to_service()
socket_fd = socket.makefile()
skip_hello(socket_fd)
send("run", socket)
send(password, socket)
send(room, socket)
send(program, socket)
return readline(socket_fd)
def check(self):
socket = self.connect_to_checker()
socket_fd = socket.makefile('r')
send("list", socket)
line = readline(socket_fd)
if not self.hostname in line:
service_down(message="Node not found in cluster")
else:
service_ok()
def run(self, room, program, password):
socket = self.connect_to_service()
socket_fd = socket.makefile()
skip_hello(socket_fd)
send("run", socket)
send(password, socket)
send(room, socket)
send(program, socket)
return readline(socket_fd)
def ReceivePayload(cls, socket):
'''
Return only payload, not the raw message, None if failed.
socket: a blocking socket for read data.
'''
# rbufsize = -1 # From SocketServer.py
rbufsize = 0
rfile = socket.makefile('rb', rbufsize)
_L.debug('read raw_magic %s', threading.current_thread().name)
try:
raw_magic = rfile.read(4) # socket is disconnected or invalid
except Exception as e:
_L.debug('Fail to read raw_magic, %s', e)
raw_magic = None
_L.debug('read raw_magic %s done: %s',
threading.current_thread().name, repr(raw_magic))
if not raw_magic: # nothing to read
# _L.debug('socket disconnect')
return None
# print 'Receive raw magic: %d, %s' % (len(raw_magic), raw_magic)
magic = struct.unpack(fmt, raw_magic)[0] # 'I' means unsigned int
# print 'Receive magic:', magic
if magic != cls.magic:
_L.error(
'Error: receive a malformat message, the message should start from a four bytes uint32 magic number'
)
return None
# The next time it will read four bytes again
_L.debug('read payload')
raw_payload_size = rfile.read(4)
# print 'Receive raw payload size: %d, %s' % (len(raw_payload_size), raw_payload_size)
payload_size = struct.unpack('I', raw_payload_size)[0]
_L.debug('Receive payload size %d', payload_size)
# if the message is incomplete, should wait until all the data received
payload = b""
remain_size = payload_size
while remain_size > 0:
data = rfile.read(remain_size)
if not data:
return None
payload += data
bytes_read = len(
data
) # len(data) is its string length, but we want length of bytes
# print 'bytes_read %d, remain_size %d, read_str %s' % (bytes_read, remain_size, data)
assert (bytes_read <= remain_size)
remain_size -= bytes_read
rfile.close()
return payload
def getHamlibCurrentPosition(socket, socket_fh=None):
if socket_fh == None:
socket_fh = socket.makefile()
socket.sendall("p\n")
retval = {'cmd': 'p'}
retval['az'] = socket_fh.readline()
retval['el'] = socket_fh.readline()
return retval
def __getline(socket):
file = socket.makefile('rb')
data = file.readline()
if data is None:
logging.error('failure in recv, aborting')
sys.exit(1)
if len(data) == 0:
logging.info('EOF')
sys.exit(0)
return data
def authenticate(self, socket):
size = 5
read_write = 'rb'
connection = socket.makefile(read_write)
request = connection.read(size)
print(request)
if request == self.stream_id:
self.handle_stream(connection)
else:
self.handle_request(request, socket)
def recieveMessage(socket):
try:
f = socket.makefile()
data = str(f.readline())
f.close()
except:
data = "0"
print "Caught exception socket.error"
return data
def __init__(self, socket, address, server, rfile=None):
if rfile is None and hasattr(socket, "_makefile_refs"):
rfile = socket.makefile()
# restore gEvent's work-around of not letting wsgi.environ['input']
# keep the socket alive in CLOSE_WAIT state after client is gone
# to work with async.SSLSocket
socket._makefile_refs -= 1
self.state = context.get_context(
).markov_stats['wsgi_handler'].make_transitor('new')
super(MakeFileCloseWSGIHandler, self).__init__(socket, address, server,
rfile)
def put(self, flag_id, flag):
socket = self.connect_to_checker()
socket_fd = socket.makefile()
send("put " + self.hostname + ":" + str(PORT) + " " + flag_id + " " + flag, socket)
result = readline(socket_fd)
time.sleep(2)
if result == "done":
service_ok(message=flag_id)
else:
service_mumble(message="Unexpected PUT response: " + result)
def handle(self, socket, address):
fd = socket.makefile()
while True:
line = fd.readline()
if not line:
break
name, value, timestamp = line.split()
ds = self.context.get_data_source(name)
ds.submit(int(timestamp), float(value))
socket.shutdown(gevent.socket.SHUT_RDWR)
socket.close()
def ReceivePayload(cls, socket):
'''
Return only payload, not the raw message, None if failed.
socket: a blocking socket for read data.
'''
# rbufsize = -1 # From SocketServer.py
rbufsize = 0
rfile = socket.makefile('rb', rbufsize)
_L.debug('read raw_magic %s', threading.current_thread().name)
try:
raw_magic = rfile.read(4) # socket is disconnected or invalid
except Exception as e:
_L.debug('Fail to read raw_magic, %s', e)
raw_magic = None
_L.debug('read raw_magic %s done: %s', threading.current_thread().name, repr(raw_magic))
if not raw_magic: # nothing to read
# _L.debug('socket disconnect')
return None
# print 'Receive raw magic: %d, %s' % (len(raw_magic), raw_magic)
magic = struct.unpack(fmt, raw_magic)[0] # 'I' means unsigned int
# print 'Receive magic:', magic
if magic != cls.magic:
_L.error('Error: receive a malformat message, the message should start from a four bytes uint32 magic number')
return None
# The next time it will read four bytes again
_L.debug('read payload')
raw_payload_size = rfile.read(4)
# print 'Receive raw payload size: %d, %s' % (len(raw_payload_size), raw_payload_size)
payload_size = struct.unpack('I', raw_payload_size)[0]
_L.debug('Receive payload size %d', payload_size)
# if the message is incomplete, should wait until all the data received
payload = b""
remain_size = payload_size
while remain_size > 0:
data = rfile.read(remain_size)
if not data:
return None
payload += data
bytes_read = len(data) # len(data) is its string length, but we want length of bytes
# print 'bytes_read %d, remain_size %d, read_str %s' % (bytes_read, remain_size, data)
assert(bytes_read <= remain_size)
remain_size -= bytes_read
rfile.close()
return payload
def do_list(self, entity):
socket = self.connect_to_service()
socket_fd = socket.makefile('r')
skip_hello(socket_fd)
send("list", socket)
send(entity, socket)
line = readline(socket_fd)
if line != DELIM:
return service_mumble(message="Bad response", error=make_err_message("Bad status", "list\n{}".format(entity), line))
line = readline(socket_fd)
result = []
while line != DELIM:
result.append(line)
line = readline(socket_fd)
return result
def __init__(self, socket):
'''
Create a session.
:param socket: The stream socket instance.
:type socket: gevent.socket.socket.
'''
super(Session, self).__init__()
self.peerName = socket.getpeername()
self.name = ':'.join([str(s) for s in self.peerName[:2]])
self._disp = self
self._sck = socket
self._fp = socket.makefile('r')
self._lock = gevent.coros.Semaphore()
self._requests = {} # request queue
self._requestId = 1 # manage request id
self.requestTimeout = None # default request timeout
def __init__(self, socket):
"""
Keeps track of the socket and the file posing as the socket, and
defines a commands-function dictionary to parse user input.
"""
self.socket = socket
self.stream = socket.makefile()
self.active = True
self.commands = {
'load' : self.send_challenge,
'send' : self.send_challenge, # deprecated
'submit' : self.send_challenge,
'init' : self.init_challenge,
'ls' : self.list_challenges,
'exit' : self.quit,
'quit' : self.quit
}
self.challenge_loaded = False
