def replyACK(ackToSend, sock): replyToWorld = wa.ACommands() replyToWorld.acks.append(ackToSend) reply = replyToWorld.SerializeToString() _EncodeVarint(sock.send, len(reply), None) sock.send(reply) return
def send_to_world(msg): print('msg you send is') print('-----') print(msg) print('-----') _EncodeVarint(world_fd.send, len(msg.SerializeToString()), None) world_fd.sendall(msg.SerializeToString())
def Send(sock, msg): print('sending out the following: ') print(msg) req = msg.SerializeToString() _EncodeVarint(sock.send, len(req), None) sock.send(req) print('send finish')
def waitACK(seqnum, message, sock): global WAIT_ACK_QUEUE while True: # receive from world wait = select.select([sock], [], [], 10) if wait[0]: world_response = responseFromWorld(sock) if not world_response.acks: print("no acks") print(world_response) break else: for ack in world_response.acks: print(f"receive ack: {ack}") WAIT_ACK_QUEUE.remove(ack) if ack == seqnum: # return return world_response # check WAIT_ACK_QUEUE every 10 seconds if seqnum in WAIT_ACK_QUEUE: # send again print("resend") _EncodeVarint(sock.send, len(message), None) sock.send(message)
def write_output(self, message): serialized = message.SerializeToString() self.__lock.acquire() encoder._EncodeVarint(self.__file.write, len(serialized)) self.__file.write(serialized) self.__file.flush() self.__lock.release()
def send_to_amazon(msg): print('msg you send is') print('-----') print(msg) print('-----') _EncodeVarint(amazon_fd.send, len(msg.SerializeToString()), None) amazon_fd.sendall(msg.SerializeToString())
def WriteArticle(article, fileobj): """ Writes the given Article protocol buffer to the given file-like object. """ msg = article.SerializeToString() _EncodeVarint(fileobj.write, len(msg)) fileobj.write(msg)
def sendMsg(s, protoType): if protoType is not None: msg = protoType.SerializeToString() _EncodeVarint(s.sendall, len(msg), None) try: s.sendall(msg) except: raise SocketDisconnectedException
def sendMsg(socket, msg): print("============") print("send:", msg) print("============") msgstr = msg.SerializeToString() _EncodeVarint(socket.send, len(msgstr), None) socket.send(msgstr)
def send(sock, msg, des): print("send : ") print(msg) print(des) req = msg.SerializeToString() _EncodeVarint(sock.send, len(req), None) sock.send(req) print('send finish')
def encode_uvarint(value): """Encode a long or int into a bytearray.""" if not isinstance(value, int): raise TypeError("UVarInt encode requires a int type") output = bytearray() encoder._EncodeVarint(output.extend, value) return output
def my_send(s, message): print("------------------ Send Message ---------------") print(message) hdr = [] _EncodeVarint(hdr.append, len(message.SerializeToString()), None) s.sendall(b"".join(hdr)) s.sendall(message.SerializeToString()) print("-----------------------------------------------")
def send_request(sock, request): """Send protocol buffer over connected socket Args: request -- a protocol buffer """ message = request.SerializeToString() _EncodeVarint(sock.send, len(message), None) sock.sendall(message)
def stop_recording(self): """ Stop recording. Always call this function or the :py:func:`blickfeld_scanner.stream.point_cloud.point_cloud.close` function before deleting a point_cloud object. """ if self._ofile: self._stream_data.footer.CopyFrom(self._metadata.footer) _EncodeVarint(self._ofile.write, self._stream_data.ByteSize()) self._ofile.write(self._stream_data.SerializeToString()) self._ofile.close() self._ofile = None
def numpy_u32_encoder(write, value): value_bytes = value.tobytes() value_len = len(value_bytes) tag1 = (3 << 3) | 2 tag2 = (1 << 3) | 2 write(bytes([tag1])) _EncodeVarint(write, 1 + _VarintSize(value_len) + value_len) write(bytes([tag2])) _EncodeVarint(write, value_len) return write(value_bytes)
def send_request(self): message = self.acommunicate.SerializeToString() _EncodeVarint(self.sock.send, len(message), None) while True: try: self.sock.sendall(message) except socket.error as e: # broken connection self.sock.connect(self.addr) continue else: break
def encode_uvarint(value): """Encode a long or int into a bytearray.""" output = bytearray() if value < 0: raise EncoderException( "Error encoding %d as uvarint. Value must be positive" % value) try: encoder._EncodeVarint(_gen_append_bytearray(output), value) except (struct.error, ValueError) as exc: six.raise_from( EncoderException("Error encoding %d as uvarint." % value), exc) return output
def writeToDelimitedString(obj, stream=None): """ Stanford CoreNLP uses the Java "writeDelimitedTo" function, which writes the size (and offset) of the buffer before writing the object. This function handles parsing this message starting from offset 0. @returns how many bytes of @buf were consumed. """ if stream is None: stream = BytesIO() _EncodeVarint(stream.write, obj.ByteSize(), True) stream.write(obj.SerializeToString()) return stream
def connect_world_simulator(): # UConnect message to world simulator uconnect = world_ups_pb2.UConnect() uconnect.trucks.extend([truck1, truck2]) uconnect.isAmazon = False conn_world_req = uconnect.SerializeToString() _EncodeVarint(conn_world.sendall, len(conn_world_req)) conn_world.sendall(conn_world_req) # UConnected from world simulator uconnected = world_ups_pb2.UConnected() data = recv_world_id() uconnected.ParseFromString(data) print("world simulator status: ", uconnected.result) return uconnected.worldid
def build_cmd(self, cmd_type, cmd): msg = cmd.SerializeToString() cmd = CommandMsg() cmd.type = cmd_type cmd.content = msg msg = cmd.SerializeToString() class PrefixWriter(object): def __init__(self): self.msg = '' def write(self, onechr): self.msg = onechr + self.msg writer = PrefixWriter() encoder._EncodeVarint(writer.write, len(msg)) return writer.msg + msg
def send_unack_msg_to_amazon(amazon_fd): db_conn = psycopg2.connect( "dbname='postgres' user='******' password = '******'" "host='" + db_host + "' port='" + db_port + "'") db_cur = db_conn.cursor() while True: """ get all message that haven't receive ack """ db_cur.execute("""select message from amazon_ack""") """send them all again""" msgs_json = db_cur.fetchall() for msg_json in msgs_json: """restore it back to Message and send again""" msg = ups_amazon_pb2.UCommunicate() msg = json2pb(msg, msg_json, useFieldNumber=False) _EncodeVarint(amazon_fd.send, len(msg.SerializeToString()), None) amazon_fd.sendall(msg.SerializeToString()) sleep(60)
def _save_frame_to_file(self, frame): """ Save a pointcloud frame to a file. Write Metadata into the footer """ self._stream_data.frame.CopyFrom(frame) # Add events for changed scan pattern to footer scan_pattern_str = self._stream_data.frame.scan_pattern.SerializeToString( ) if self._prev_scan_pattern_str != scan_pattern_str: event = self._metadata.footer.events.add() event.from_frame_id = self._stream_data.frame.id event.scan_pattern.CopyFrom(self._stream_data.frame.scan_pattern) self._prev_scan_pattern_str = scan_pattern_str # Update stats in footer counter = self._metadata.footer.stats.counter counter.frames = counter.frames + 1 counter.points = counter.points + self._stream_data.frame.total_number_of_points counter.returns = counter.returns + self._stream_data.frame.total_number_of_returns _EncodeVarint(self._ofile.write, self._stream_data.ByteSize()) self._ofile.write(self._stream_data.SerializeToString())
def record_to_file(self, file_name, compresslevel=1): """ Record point cloud stream to file :param file_name: Path to the file where it should be dumped :param compresslevel: The compresslevel argument is an integer from 0 to 9 controlling the level of compression; 1 is fastest and produces the least compression, and 9 is slowest and produces the most compression. 0 is no compression. The default is 1. If frames are lost during the recording decrease the compression level. .. deprecated:: 2.13.0 Since BSL v2.13.0 this function is deprecated, because of performance issues. Please use :py:func:`blickfeld_scanner.scanner.scanner.record_point_cloud_stream` for a performance improved recording. """ warnings.warn( "This function is deprecated, because of performance issues. Please use scanner.record_point_cloud_stream for a performance improved recording.", DeprecationWarning, stacklevel=2) if self._ofile: raise Exception( "The output file has already been opened. To open another file, please call 'stop_recording' first to close the current output file." ) self._prev_scan_pattern_str = b"" self._metadata.ClearField("footer") self._ofile = gzip.open(file_name, 'wb', compresslevel=compresslevel) _EncodeVarint(self._ofile.write, self._metadata.header.ByteSize()) self._ofile.write(self._metadata.header.SerializeToString())
def write_long_no_tag(self, val): _EncodeVarint(self._write, wire_format.ZigZagEncode(val))
def encode(i): buf = [] # Note: The signed variant is named "_EncodeSignedVarint". _EncodeVarint(buf.append, i) return "".join(buf)
def _encode_varint(i): """Encode integer as varint """ buff = bytearray() _EncodeVarint(buff.append, i) return buff
def send_msg(socket,msg): to_send = msg.SerializeToString() _EncodeVarint(socket.sendall,len(to_send)) socket.sendall(to_send)
def Send(sock, msg): req = msg.SerializeToString() _EncodeVarint(sock.send, len(req), None) sock.send(req) print('send finish')
def write_delimited(f, message): msg_string = message.SerializeToString() msg_size = len(msg_string) _EncodeVarint(f.write, msg_size) f.write(msg_string)
def send_message(response, msg, s): response.messageId = msg.messageId s_response = response.SerializeToString() _EncodeVarint(s.sendall, len(s_response), False) s.sendall(s_response)
def encode_varint(self, value): """ Encode an int as a protobuf varint """ data = [] _EncodeVarint()(data.append, value, None) return b''.join(data)
def send_data_amazon(self, message): data = message.SerializeToString() _EncodeVarint(self.amazon_sock.send, len(data), None) self.amazon_sock.send(data)
def send_message(response, msg, s): response.messageId = msg.messageId s_response = response.SerializeToString() _EncodeVarint(s.sendall, len(s_response)) s.sendall(s_response)
def sendString(self, string): #print "sending %d bytes" % len(string) out = StringIO() encoder._EncodeVarint(out.write, len(string)) out.write(string) self.transport.write(out.getvalue())
def encode_varint(v): out = StringIO() _EncodeVarint(out.write, v) return out.getvalue()
def encode_and_send(self, socket): _EncodeVarint(socket.send, len(self._message), None) socket.send(self._message)
def encode_varint(value): bio = BytesIO() encoder._EncodeVarint(bio.write, value) bio.seek(0) return bio.read()
def send_msg(s, msg): hdr = [] _EncodeVarint(hdr.append, len(msg.SerializeToString()), None) s.send(b"".join(hdr)) s.send(msg.SerializeToString())
def sendString(self, addr, string): out = StringIO() encoder._EncodeVarint(out.write, len(string)) out.write(string) self.transport.write(out.getvalue(), addr)