async def handle(request: web.Request) -> web.Response:
message = message_pb2.Message()
message.ParseFromString(request['body']) # type: ignore
response = message_pb2.Message(
id=str(uuid.uuid4()),
sender='server',
receiver=message.sender,
content=f'thanks {message.sender} for your message: {message.content}',
)
return {'code': 200, 'body': response.SerializeToString()}
def handleMessageAndGetResponse(serialized_message_string):
incrementNumberOfConnections()
switcher = {
message_pb2.Message.MessageType.CHANGE_SENSOR_STATUS_REQUEST: change_sensor_status, # Used by app and server to request sensor status
message_pb2.Message.MessageType.CHANGE_SENSOR_STATUS_RESPONSE: reply_sensor_status, # Used by sensor to send sensor status
message_pb2.Message.MessageType.READ_SENSOR_DATA_REQUEST: read_sensor_data, # Used by app and server to request sensor data
message_pb2.Message.MessageType.READ_SENSOR_DATA_RESPONSE: reply_sensor_data, # Used by sensor to send sensor data
message_pb2.Message.MessageType.MULTICAST_SENSOR_FINDER: find_sensor, # Used by server to find sensors on the internet
message_pb2.Message.MessageType.MULTICAST_SENSOR_FINDER_ACK: ack_sensor_up, # Used by sensor to show up it is alive
message_pb2.Message.MessageType.MULTICAST_SERVER_FINDER: find_server, # Used by sensor to find server on the internet
message_pb2.Message.MessageType.MULTICAST_SERVER_FINDER_ACK: ack_server_up, # Used by server to show up it is alive
message_pb2.Message.MessageType.UPTIME_REQUEST: get_server_uptime, # Used by app to get datetime since server's up
message_pb2.Message.MessageType.UPTIME_RESPONSE: reply_server_uptime, # Used by server to send datetime since it's up
message_pb2.Message.MessageType.REQNUM_REQUEST: get_server_reqnum, # Used by app to get the number of requests since server's up
message_pb2.Message.MessageType.REQNUM_RESPONSE: reply_server_reqnum, # Used by server to send the number of requests since it's up
message_pb2.Message.MessageType.CLOSE_CONNECTION_REQUEST: close_connection, # Used by app to attempt closing connection
message_pb2.Message.MessageType.CLOSE_CONNECTION_ACK: ack_close_connection # Used by server to acknowledge
}
message = message_pb2.Message()
message.ParseFromString(serialized_message_string)
response = switcher.get(message.type, getProtoMessage("Invalid message type."))
stayInTouch = message.type != message_pb2.Message.MessageType.CLOSE_CONNECTION_REQUEST
return stayInTouch, response
def getProtoMessage(description="teste"):
message = message_pb2.Message()
message.body.description = description
message.type = message_pb2.Message.MessageType.DEFAULT
message.sender.ip = "localhost"
message.sender.port = 5050
return message.SerializeToString()
def protobuff_test():
m = message_pb2.Message()
m.str_field = message['words']
for item in message['list']:
record = m.list_field.add()
record.value = item
for item in message['dict'].keys():
record = m.dict_field.add()
record.key = item
record.value = message['dict'][item]
m.int_field = message['int']
m.float_field = message['float']
src = m.SerializeToString()
setup = '''import message_pb2
d=%s
m = message_pb2.Message()
m.str_field = d['words']
for item in d['list']:
record = m.list_field.add()
record.value = item
for item in d['dict'].keys():
record = m.dict_field.add()
record.key = item
record.value = d['dict'][item]
m.int_field = d['int']
m.float_field = d['float']
src = m.SerializeToString()''' % message
result = timeit(setup=setup, stmt='m.SerializeToString()', number=loops)
enc_table.append(['ProtoBuff serialization', result, sys.getsizeof(src)])
result = timeit(setup=setup, stmt='new_mess = message_pb2.Message();new_mess.ParseFromString(src)', number=loops)
dec_table.append(['ProtoBuff deserialization', result])
print("ProtoBuff")
def post(self, mail):
'''
Adds a message
'''
if request.is_json:
try:
try:
table_service.get_entity('users', mail, '')
message = Entity()
details = message_pb2.Message()
details.title = request.json["title"]
details.content = request.json["content"]
details.magic_number = request.json["magic_number"]
message.PartitionKey = mail
message.RowKey = str(
len(list(table_service.query_entities('messages'))) +
1)
message.details = EntityProperty(EdmType.BINARY,
MessageToJson(details))
table_service.insert_entity('messages', message)
return None, 201
except (Azure404):
return None, 404
except (KeyError):
return 'Please provide a json object conforming to the \
following pattern: {\"title\": \"Message title\", \
\"content\":\"Message content\", \
\"magic_number\": a number}', 400
def parse_message(messageBytes: bytes):
message = pb.Message()
message.ParseFromString(messageBytes)
if message.name == "login":
content = pb.LoginMessage()
content.ParseFromString(message.content)
return LoginMessage(dict(content.files.items()), content.wallet, message.messageId)
if message.name == "purchase-req":
content = pb.PurchaseRequest()
content.ParseFromString(message.content)
return PurchaseRequest(content.fileName, content.cost, message.messageId)
if message.name == "purchase-confrm-seller":
content = pb.PurchaseConfirmedSeller()
content.ParseFromString(message.content)
return PurchaseConfirmedSeller(content.fileName, content.buyer, content.requestNumber, content.cost, message.messageId)
if message.name == "purchase-confrm-buyer":
content = pb.PurchaseConfirmedBuyer()
content.ParseFromString(message.content)
return PurchaseConfirmedBuyer(content.fileName, content.value, content.seller, content.requestNumber, message.messageId)
if message.name == "purchase-rej":
content = pb.PurchaseRejected()
content.ParseFromString(message.content)
return PurchaseRejected(content.requestNumber, message.messageId)
if message.name == "robbery":
content = pb.RobberyComplaint()
content.ParseFromString(message.content)
return RobberyComplaint(content.buyer, message.messageId)
raise NotImplementedError("Unknown message name: " + message.name)
def generateLampSensorDataMessage():
# TODO
message = message_pb2.Message()
message.body.description = "description"
message.type = message_pb2.Message.MessageType.DEFAULT
message.sender.ip = "localhost"
message.sender.port = 5050
return message.SerializeToString()
def DesempacotaMensagem(self, msg):
message = message_pb2.Message()
# Read length
(size, position) = decoder._DecodeVarint(msg, 0)
# Read the message
message.ParseFromString(msg[position:position + size])
return message.arguments
def generateSensorFinderMessage():
# TODO
message = message_pb2.Message()
message.body.description = "description"
message.type = message_pb2.Message.MessageType.MULTICAST_SENSOR_FINDER
message.sender.ip = "localhost"
message.sender.port = 5050
return message.SerializeToString()
async def handle_dummy(reader, writer):
print("Received client")
protobuf = message_pb2.Message()
protobuf.key = "light"
writer.write(protobuf.SerializeToString())
await writer.drain()
print("Wrote protobuf message")
writer.close()
def EmpacotaMensagem(self, referencia, metodo, objeto):
message = message_pb2.Message()
message.type = 0
message.id = randint(0, 1000)
message.objReference = referencia
message.methodId = metodo
message.arguments = objeto
out = message.SerializeToString()
out = encoder._VarintBytes(len(out)) + out
return out
def main(sender=None,
receiver=None,
content=None,
addr: 'server address' = None): # type: ignore
assert sender, '--sender is required'
assert receiver, '--receiver is required'
assert content, '--content is required'
assert addr, '--addr is required'
message = message_pb2.Message(
id=str(uuid.uuid4()),
sender=sender,
receiver=receiver,
content=content,
)
resp = requests.post(addr, data=message.SerializeToString())
assert resp.status_code == 200, [resp.status_code, resp.text]
resp_message = message_pb2.Message()
resp_message.ParseFromString(resp.content) # type: ignore
print(resp_message)
def quit_conn(sock, name):
socks.remove(sock)
sock.close()
msg = message_pb2.Message()
player = msg.player
player.id = 0
player.name = '管理员'
msg.content = u'%s 退出了聊天室' % (name,)
data = msg.SerializeToString()
packet_len = struct.pack(LENGTH_HEADER, len(data))
for item in socks:
item.sendall(packet_len + data)
def create_message(self, email=None, message=None):
""" Create message in protobuf"""
proto_message = message_pb2.Message()
proto_message.title = message['title']
proto_message.content = message['content']
proto_message.magic_number = message['magic_number']
details = ep(EdmType.BINARY, str(proto_message))
bmessage = {
'PartitionKey': email,
'RowKey': row_key,
'details': details,
}
if (self.ts.insert_or_replace_entity(MESSAGE_TABLE_NAME, bmessage)):
return {'success': True}
def handleMessageAndGetResponse(serialized_message_string):
message = message_pb2.Message()
message.ParseFromString(serialized_message_string)
stayInTouch = message.type != message_pb2.Message.MessageType.CLOSE_CONNECTION_REQUEST
if message.type == message_pb2.Message.MessageType.CHANGE_SENSOR_STATUS_REQUEST:
# Used by app and server to request sensor status
return stayInTouch, changeSensorStatus()
if message.type == message_pb2.Message.MessageType.READ_SENSOR_DATA_REQUEST:
# Used by app and server to request sensor data
return stayInTouch, readSensorData()
if message.type == message_pb2.Message.MessageType.MULTICAST_SENSOR_FINDER:
# Used by server to find sensors on the internet
return stayInTouch, findSensor()
return stayInTouch, getProtoMessage("Invalid message type.")
def read_one_record(input_stream, raw=False, verbose=False, strict=False, try_snappy=True):
# Read 1 byte record separator (and keep reading until we get one)
total_bytes = 0
skipped, eof = read_until_next(input_stream, 0x1e)
total_bytes += skipped
if eof:
return None, total_bytes
else:
# we've read one separator (plus anything we skipped)
total_bytes += 1
if skipped > 0:
if strict:
raise ValueError("Unexpected character(s) at the start of record")
if verbose:
print "Skipped", skipped, "bytes to find a valid separator"
raw_record = struct.pack("<B", 0x1e)
# Read the header length
header_length_raw = input_stream.read(1)
if header_length_raw == '':
return None, total_bytes
total_bytes += 1
raw_record += header_length_raw
# The "<" is to force it to read as Little-endian to match the way it's
# written. This is the "native" way in linux too, but might as well make
# sure we read it back the same way.
(header_length,) = struct.unpack('<B', header_length_raw)
header_raw = input_stream.read(header_length)
if header_raw == '':
return None, total_bytes
total_bytes += header_length
raw_record += header_raw
header = message_pb2.Header()
header.ParseFromString(header_raw)
unit_separator = input_stream.read(1)
total_bytes += 1
if ord(unit_separator[0]) != 0x1f:
error_msg = "Unexpected unit separator character in record #{} " \
"at offset {}: {}".format(record_count, total_bytes,
ord(unit_separator[0]))
if strict:
raise ValueError(error_msg)
return UnpackedRecord(raw_record, header, error=error_msg), total_bytes
raw_record += unit_separator
#print "message length:", header.message_length
message_raw = input_stream.read(header.message_length)
total_bytes += header.message_length
raw_record += message_raw
message = None
if not raw:
message = message_pb2.Message()
parsed_ok = False
if try_snappy:
try:
message.ParseFromString(snappy.decompress(message_raw))
parsed_ok = True
except:
# Wasn't snappy-compressed
pass
if not parsed_ok:
# Either we didn't want to attempt snappy, or the
# data was not snappy-encoded (or it was just bad).
message.ParseFromString(message_raw)
return UnpackedRecord(raw_record, header, message), total_bytes
value = [1, 1.2, 1.3, 1.4]
values = []
for x in range(10):
values.append(value)
msg = {'0': 'test', '1': 1, '2': values}
now = time.time()
for x in range(100000):
body = BSON.encode(msg)
print(len(body))
print(time.time() - now)
now = time.time()
for x in range(100000):
msg = BSON(body).decode()
print(time.time() - now)
m = message_pb2.Message()
m.cmd = 'test'
m.prepared = 1
value = message_pb2.Fields()
value.values.extend([message_pb2.Field(n=1), message_pb2.Field(d=1.2)])
value.values.extend([message_pb2.Field(d=1.3), message_pb2.Field(d=1.4)])
values = []
for x in range(10):
values.append(value)
m.values.extend(values)
now = time.time()
for x in range(100000):
body = m.SerializeToString()
print(len(body))
print(time.time() - now)
now = time.time()
def __init__(self, header, body):
self.__message = message_pb2.Message()
self.__message.header = header
self.__message.body = body
HOST = '127.0.0.1'
PORT = 8888
LENGTH_HEADER = '!I'
HEADER_LENGTH = struct.calcsize(LENGTH_HEADER)
def recv_fill(sock, packet_len):
buff = ''
while len(buff) < packet_len:
data = sock.recv(packet_len - len(buff))
if not data:
return
buff += data
return buff
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))
_len = recv_fill(s, HEADER_LENGTH)
(packet_len, ) = struct.unpack(LENGTH_HEADER, _len)
data = recv_fill(s, packet_len)
msg = message_pb2.Message()
msg.ParseFromString(data)
print msg.content
print msg.player.id
print msg.player.name
s.close()
def parseMessage(serialized_message_string):
message = message_pb2.Message()
message.ParseFromString(serialized_message_string)
return message
def parseSerializedStringIntoMessageObj(serialized_message_string):
message = message_pb2.Message()
message.ParseFromString(serialized_message_string)
return message
def saveSensorIPAndPort(serialized_message_string):
# TODO
message = message_pb2.Message()
message.ParseFromString(serialized_message_string)
return message
def serialize(self):
result = pb.Message()
result.name = self.name
result.messageId = self.messageId
result.content = self.serializeContent().SerializeToString()
return result.SerializeToString()
def _parse(message_string):
byte_string = base64.b64decode(message_string)
parsed_message = message_pb2.Message()
parsed_message.ParseFromString(byte_string)
return parsed_message
