def handle_read(self):
try:
received = self.recv(32768)
self.received_strings.append(received)
if is_python3():
s = b''.join(self.received_strings)
sbuffer = memoryview(s)
else:
s = ''.join(self.received_strings)
sbuffer = buffer(s)
consumedBytes = 0
offset = 0
received_messages = []
while offset < len(sbuffer):
if self.message is None:
try:
self.message = SpecMessage.message(
version=self.client_version,
order=self.client_order)
except:
import traceback
log.log(2, traceback.format_exc())
consumedBytes = self.message.readFromStream(sbuffer[offset:])
if consumedBytes == 0:
break
offset += consumedBytes
if self.message.isComplete():
# dispatch incoming message
if self.message.cmd == SpecMessage.HELLO:
self.client_order = self.message.packedHeaderDataFormat[
0]
self.client_version = self.message.vers
self.clientName = self.message.name
self.send_hello_reply(self.message.sn,
str(self.server.name))
else:
received_messages.append(self.message)
self.message = None
self.received_strings = [s[offset:]]
for message in received_messages:
if not self.dispatch_message(message):
self.send_error(
message.sn, '',
'unsupported command type : %d' % message.cmd)
except:
import traceback
log.log(3, "SpecServer read error. %s" % traceback.format_exc())
return
def handle_read(self):
"""Handle 'read' events on socket
Messages are built from the read calls on the socket.
"""
self.receivedStrings.append(self.recv(32768)) #read at most all the input buffer
s = ''.join(self.receivedStrings)
sbuffer = buffer(s)
consumedBytes = 0
offset = 0
while offset < len(sbuffer):
if self.message is None:
self.message = SpecMessage.message(version = self.serverVersion)
consumedBytes = self.message.readFromStream(sbuffer[offset:])
if consumedBytes == 0:
break
offset += consumedBytes
if self.message.isComplete():
# dispatch incoming message
if self.message.cmd == SpecMessage.REPLY:
replyID = self.message.sn
if replyID > 0:
try:
reply = self.registeredReplies[replyID]
except:
logging.getLogger("SpecClient").exception("Unexpected error while receiving a message from server")
else:
del self.registeredReplies[replyID]
reply.update(self.message.data, self.message.type == SpecMessage.ERROR, self.message.err)
#SpecEventsDispatcher.emit(self, 'replyFromSpec', (replyID, reply, ))
elif self.message.cmd == SpecMessage.EVENT:
for name in SpecChannel.SpecChannel.channel_aliases[self.message.name]:
self.registeredChannels[name].update(self.message.data, deleted=self.message.flags == SpecMessage.DELETED)
elif self.message.cmd == SpecMessage.HELLO_REPLY:
if self.checkourversion(self.message.name):
self.serverVersion = self.message.vers #header version
#self.state = CONNECTED
self.specConnected()
else:
self.serverVersion = None
self.connected = False
self.close()
self.state = DISCONNECTED
self.message = None
self.receivedStrings = [ s[offset:] ]
def handle_read(self):
"""Handle 'read' events on socket
Messages are built from the read calls on the socket.
"""
_received = self.recv(32768)
self.received_strings.append(_received)
if is_python3():
s = b''.join(self.received_strings)
sbuffer = memoryview(s)
else:
s = ''.join(self.received_strings)
sbuffer = buffer(s)
consumedBytes = 0
offset = 0
while offset < len(sbuffer):
if self.message is None:
self.message = SpecMessage.message(version=self.server_version)
consumedBytes = self.message.readFromStream(sbuffer[offset:])
if consumedBytes == 0:
break
offset += consumedBytes
if self.message.isComplete():
try:
# dispatch incoming message
if self.message.cmd == SpecMessage.REPLY:
self.dispatch_reply_msg(self.message)
elif self.message.cmd == SpecMessage.EVENT:
self.dispatch_event_msg(self.message)
elif self.message.cmd == SpecMessage.HELLO_REPLY:
self.dispatch_hello_reply_msg(self.message)
except Exception as e:
self.message = None
self.received_strings = [s[offset:]]
raise SpecClientProtocolError(str(e))
else:
self.message = None
self.received_strings = [s[offset:]]
def handle_read(self):
self.receivedStrings.append(self.recv(32768))
s = ''.join(self.receivedStrings)
sbuffer = buffer(s)
consumedBytes = 0
offset = 0
received_messages = []
while offset < len(sbuffer):
if self.message is None:
self.message = SpecMessage.message(version=self.clientVersion,
order=self.clientOrder)
consumedBytes = self.message.readFromStream(sbuffer[offset:])
if consumedBytes == 0:
break
offset += consumedBytes
if self.message.isComplete():
# dispatch incoming message
if self.message.cmd == SpecMessage.HELLO:
self.clientOrder = self.message.packedHeaderDataFormat[0]
print "client byte order: ", self.clientOrder
self.clientVersion = self.message.vers
self.clientName = self.message.name
self.send_hello_reply(self.message.sn,
str(self.server.name))
else:
received_messages.append(self.message)
self.message = None
self.receivedStrings = [s[offset:]]
for message in received_messages:
if not self.dispatchIncomingMessage(message):
self.send_error(message.sn, '',
'unsupported command type : %d' % message.cmd)
def handle_read(self):
self.receivedStrings.append(self.recv(32768))
s = ''.join(self.receivedStrings)
sbuffer = buffer(s)
consumedBytes = 0
offset = 0
received_messages = []
while offset < len(sbuffer):
if self.message is None:
self.message = SpecMessage.message(version = self.clientVersion, order=self.clientOrder)
consumedBytes = self.message.readFromStream(sbuffer[offset:])
if consumedBytes == 0:
break
offset += consumedBytes
if self.message.isComplete():
# dispatch incoming message
if self.message.cmd == SpecMessage.HELLO:
self.clientOrder = self.message.packedHeaderDataFormat[0]
print "client byte order: ", self.clientOrder
self.clientVersion = self.message.vers
self.clientName = self.message.name
self.send_hello_reply(self.message.sn, str(self.server.name))
else:
received_messages.append(self.message)
self.message = None
self.receivedStrings = [ s[offset:] ]
for message in received_messages:
if not self.dispatchIncomingMessage(message):
self.send_error(message.sn, '', 'unsupported command type : %d' % message.cmd)
def connectionHandler(connection_ref, socket_to_spec):
receivedStrings = []
message = None
serverVersion = None
socket_to_spec.settimeout(None)
conn = connection_ref()
if conn is not None:
conn.connected = True
conn.state = WAITINGFORHELLO
conn.socket = socket_to_spec
conn.send_msg_hello()
del conn
while True:
try:
receivedStrings.append(socket_to_spec.recv(4096))
except:
receivedStrings.append("")
if receivedStrings[-1] == "":
conn = connection_ref()
if conn is None:
break
conn.handle_close()
del conn
break
s = "".join(receivedStrings)
consumedBytes = 0
offset = 0
while offset < len(s):
if message is None:
message = SpecMessage.message(version=serverVersion)
consumedBytes = message.readFromStream(s[offset:])
if consumedBytes == 0:
break
offset += consumedBytes
if message.isComplete():
conn = connection_ref()
if conn is None:
break
try:
try:
# dispatch incoming message
if message.cmd == SpecMessage.REPLY:
replyID = message.sn
if replyID > 0:
try:
reply = conn.registeredReplies[replyID]
except:
logging.getLogger("SpecClient").exception(
"Unexpected error while receiving a message from server"
)
else:
del conn.registeredReplies[replyID]
# replies_queue.put((reply, message.data, message.type==SpecMessage.ERROR, message.err))
gevent.spawn(
reply.update, message.data, message.type == SpecMessage.ERROR, message.err
)
time.sleep(1e-6)
elif message.cmd == SpecMessage.EVENT:
try:
channel = conn.registeredChannels[message.name]
except KeyError:
pass
else:
# channels_queue.put((channel, message.data, message.flags == SpecMessage.DELETED))
gevent.spawn(channel.update, message.data, message.flags == SpecMessage.DELETED)
time.sleep(1e-6)
elif message.cmd == SpecMessage.HELLO_REPLY:
if conn.checkourversion(message.name):
serverVersion = message.vers # header version
conn.serverVersion = serverVersion
gevent.spawn(conn.specConnected)
time.sleep(1e-6)
else:
serverVersion = None
conn.serverVersion = None
conn.connected = False
conn.disconnect()
conn.state = DISCONNECTED
if conn.scanport:
conn.port += 1
except:
receivedStrings = [s[offset:]]
raise
finally:
del conn
message = None
receivedStrings = [s[offset:]]
def handle_read(self):
"""Handle 'read' events on socket
Messages are built from the read calls on the socket.
"""
_received = self.recv(32768)
#if is_python3():
#_received = _received.decode('utf-8')
self.receivedStrings.append(_received)
log.log(DEBUG, "received new data from spec")
if is_python3():
s = b''.join(self.receivedStrings)
sbuffer = memoryview(s)
#sbuffer = bytes(sbuffer).decode('utf-8')
else:
s = ''.join(self.receivedStrings)
sbuffer = buffer(s)
consumedBytes = 0
offset = 0
while offset < len(sbuffer):
if self.message is None:
log.log(DEBUG, "creating a new message")
self.message = SpecMessage.message(version=self.serverVersion)
else:
log.log(DEBUG, "adding data to existing message")
consumedBytes = self.message.readFromStream(sbuffer[offset:])
log.log(DEBUG, " bytes consumed %s" % consumedBytes)
log.log(DEBUG, " message complete? %s" % self.message.isComplete())
if consumedBytes == 0:
log.log(DEBUG, " no bytes consumed")
break
offset += consumedBytes
if self.message.isComplete():
log.log(
DEBUG, "new message from spec %s / name %s" %
(self.message.cmd, self.message.name))
try:
# dispatch incoming message
if self.message.cmd == SpecMessage.REPLY:
replyID = self.message.sn
if replyID > 0:
try:
reply = self.registeredReplies[replyID]
except:
log.exception(
"Unexpected error while receiving a message from server"
)
else:
del self.registeredReplies[replyID]
reply.update(
self.message.data,
self.message.type == SpecMessage.ERROR,
self.message.err)
#SpecEventsDispatcher.emit(self, 'replyFromSpec', (replyID, reply, ))
elif self.message.cmd == SpecMessage.EVENT:
log.log(
2, "got a new event from spec name=%s, data=%s" %
(self.message.name, self.message.data))
try:
self.registeredChannels[self.message.name].update(
self.message.data,
self.message.flags == SpecMessage.DELETED)
except KeyError:
import traceback
log.log(2, traceback.format_exc())
except:
import traceback
log.log(2, traceback.format_exc())
log.log(
DEBUG,
"AFTER event: %s" % str(self.registeredChannels))
elif self.message.cmd == SpecMessage.HELLO_REPLY:
if self.checkourversion(self.message.name):
self.serverVersion = self.message.vers #header version
#self.state = CONNECTED
log.log(DEBUG, "Hello reply. all right. connected")
self.specConnected()
else:
self.serverVersion = None
self.connected = False
self.close()
self.state = DISCONNECTED
except:
self.message = None
self.receivedStrings = [s[offset:]]
raise
else:
self.message = None
self.receivedStrings = [s[offset:]]
def connectionHandler(connection_ref, socket_to_spec):
receivedStrings = []
message = None
serverVersion = None
socket_to_spec.settimeout(None)
conn = connection_ref()
if conn is not None:
conn.connected = True
conn.state = WAITINGFORHELLO
conn.socket = socket_to_spec
conn.send_msg_hello()
del conn
while True:
try:
receivedStrings.append(socket_to_spec.recv(4096))
except:
receivedStrings.append("")
if receivedStrings[-1] == "":
conn = connection_ref()
if conn is None:
break
conn.handle_close()
del conn
break
s = ''.join(receivedStrings)
consumedBytes = 0
offset = 0
while offset < len(s):
if message is None:
message = SpecMessage.message(version=serverVersion)
consumedBytes = message.readFromStream(s[offset:])
if consumedBytes == 0:
break
offset += consumedBytes
if message.isComplete():
conn = connection_ref()
if conn is None:
break
try:
try:
# dispatch incoming message
if message.cmd == SpecMessage.REPLY:
replyID = message.sn
if replyID > 0:
try:
reply = conn.registeredReplies[replyID]
except:
logging.getLogger("SpecClient").exception(
"Unexpected error while receiving a message from server"
)
else:
del conn.registeredReplies[replyID]
#replies_queue.put((reply, message.data, message.type==SpecMessage.ERROR, message.err))
gevent.spawn(
reply.update, message.data,
message.type == SpecMessage.ERROR,
message.err)
time.sleep(1E-6)
elif message.cmd == SpecMessage.EVENT:
try:
channel = conn.registeredChannels[message.name]
except KeyError:
pass
else:
#channels_queue.put((channel, message.data, message.flags == SpecMessage.DELETED))
gevent.spawn(
channel.update, message.data,
message.flags == SpecMessage.DELETED)
time.sleep(1E-6)
elif message.cmd == SpecMessage.HELLO_REPLY:
if conn.checkourversion(message.name):
serverVersion = message.vers #header version
conn.serverVersion = serverVersion
gevent.spawn(conn.specConnected)
time.sleep(1E-6)
else:
serverVersion = None
conn.serverVersion = None
conn.connected = False
conn.disconnect()
conn.state = DISCONNECTED
if conn.scanport:
conn.port += 1
except:
receivedStrings = [s[offset:]]
raise
finally:
del conn
message = None
receivedStrings = [s[offset:]]
def handle_read(self):
"""Handle 'read' events on socket
Messages are built from the read calls on the socket.
"""
self.receivedStrings.append(
self.recv(32768)) #read at most all the input buffer
s = ''.join(self.receivedStrings)
sbuffer = buffer(s)
consumedBytes = 0
offset = 0
while offset < len(sbuffer):
if self.message is None:
self.message = SpecMessage.message(version=self.serverVersion)
consumedBytes = self.message.readFromStream(sbuffer[offset:])
if consumedBytes == 0:
break
offset += consumedBytes
if self.message.isComplete():
try:
# dispatch incoming message
if self.message.cmd == SpecMessage.REPLY:
replyID = self.message.sn
if replyID > 0:
try:
reply = self.registeredReplies[replyID]
except:
logging.getLogger("SpecClient").exception(
"Unexpected error while receiving a message from server"
)
else:
del self.registeredReplies[replyID]
reply.update(
self.message.data,
self.message.type == SpecMessage.ERROR,
self.message.err)
#SpecEventsDispatcher.emit(self, 'replyFromSpec', (replyID, reply, ))
elif self.message.cmd == SpecMessage.EVENT:
try:
self.registeredChannels[self.message.name].update(
self.message.data,
self.message.flags == SpecMessage.DELETED)
except KeyError:
pass
elif self.message.cmd == SpecMessage.HELLO_REPLY:
if self.checkourversion(self.message.name):
self.serverVersion = self.message.vers #header version
#self.state = CONNECTED
self.specConnected()
else:
self.serverVersion = None
self.connected = False
self.close()
self.state = DISCONNECTED
except:
self.message = None
self.receivedStrings = [s[offset:]]
raise
else:
self.message = None
self.receivedStrings = [s[offset:]]
