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