def _reply(cmd, socket, client_address=None): """Build a reply data and send it to client""" #ts = []; ts.append(timer()) try: r = _replyData(cmd) if len(r) == 0: return 0 except Exception as e: r = f'ERR.LS. Exception for cmd {cmd}: {e}' exc = traceback.format_exc() print('LS.Traceback: ' + repr(exc)) #print(croppedText(f'reply_object={r}',100000)) #ts.append(timer()); ts[-2] = round(ts[-1] - ts[-2],4) try: reply = ubjson.dumpb(r, no_float32=False) # 75% time is spent here except Exception as e: reply = ubjson.dumpb(f'ERR.LS. Exception in dumpb: {e}') #ts.append(timer()); ts[-2] = round(ts[-1] - ts[-2],4) #printd(f'reply {len(reply)} bytes, doubles={no_float32}') host, port = client_address # the port here is temporary #printd(croppedText(f'sending back {len(reply)} bytes to {client_address}')) #ts.append(timer()); ts[-2] = round(ts[-1] - ts[-2],4) if UDP: _send_UDP(reply, socket, client_address) # 25% time spent here # initiate the sending of EOD to that client else: #self.request.sendall(reply) printi('TCP not supported yet') #ts.append(timer()); ts[-2] = round(ts[-1] - ts[-2],4) #print(f'reply times: {ts[:-1]}') return len(reply)
def write_raw(self,data): """ """ ubdata = ubjson.dumpb(data) ubdata = ubdata + b'\n' print('Writing header') self.f.write(ubdata)
def send_request(self, request): """ Sends the request to the peer. :param request: The request as dictionary. :return: The response as dictionary """ request = { "action": "req", "payload": ESCSEQ_OBJ_START + \ ubjson.dumpb(request).replace(b'\x00', b'\x00\x00') + \ ESCSEQ_OBJ_END, "cv": threading.Condition() } with request['cv']: self._msgqueue.put(request) if not request['cv'].wait(timeout=CALL_TIMEOUT): raise TimeoutError("No response within %d seconds" % CALL_TIMEOUT) if 'error' in request: raise request['error'] try: return ubjson.loadb(request['response']) except ubjson.DecoderException: errmsg = "%s: Couldn't parse UBJSON from lora_controller. Got: %s" % \ (self._name, " ".join(hex(x) for x in request['response'])) logger.error(errmsg, exc_info=True) raise RuntimeError(errmsg)
def _call(self, method, args={}): msg = ubjson.dumpb({method: self._flatten_arrays(args)}) msglen = struct.pack("=i", len(msg)) try: self.callpipe.write(msglen + msg) if method.startswith("Set"): return None self.callpipe.flush() except OSError as exc: raise AMSWorkerError('Error while sending a message') from exc if method == "Exit": return None results = [] while True: try: msgbuf = self._read_exactly(self.replypipe, 4) msglen = struct.unpack("=i", msgbuf)[0] msgbuf = self._read_exactly(self.replypipe, msglen) except EOFError as exc: raise AMSWorkerError("Error while trying to read a reply") from exc try: msg = ubjson.loadb(msgbuf) except Exception as exc: raise AMSWorkerError("Error while decoding a reply") from exc if "return" in msg: ret = msg["return"] if ret["status"] == 0: return results else: raise AMSPipeError.from_message(ret) else: results.append(msg)
def export(self, g3dModel, filepath): baseModel = self.mountJsonOutput(g3dModel) output_file = open(filepath, 'wb') output_file.write(ubjson.dumpb(baseModel)) output_file.close()
def encrypt5(in_stream, out_stream, public_key, secret_key, verify_all, symmetric, force, block_size): version = 5 sym_key = nacl.utils.random(nacl.secret.SecretBox.KEY_SIZE) if None == secret_key: sign_key = nacl.public.PrivateKey.generate() else: sign_key = nacl.public.PrivateKey(secret_key) print(sym_key) secure_metadata = { "key": sym_key, "block_size": block_size, } secure_metadata_bytes = ubjson.dumpb(secure_metadata) public_key = nacl.public.PublicKey(public_key) smdbox = nacl.public.Box(sign_key, public_key) encrypted_metadata = bytes(smdbox.encrypt(secure_metadata_bytes)) metadata = { "sign_key": sign_key.public_key.encode(), "secure": encrypted_metadata, } encoded_metadata = ubjson.dumpb(metadata) metadata_length = len(encoded_metadata) first_bytes = struct.pack(FIRST_BYTES_FORMAT, version, metadata_length) out_stream.write(MAGIC_BYTES) out_stream.write(first_bytes) out_stream.write(encoded_metadata) # Using predictable nonces (but never twice for the same key) # there is a 3% size overhead due to the 16 byte signatures, # instead of a 7.8% size overhead due to a 40 byte signature+nonce counter = 0 encrypter_box = nacl.secret.SecretBox(sym_key) block = in_stream.read(block_size) while len(block) > 0: # Use network endianness counternonce = counter.to_bytes(nacl.secret.SecretBox.NONCE_SIZE, "big") out_block = encrypter_box.encrypt(block, nonce=counternonce)._ciphertext # We are counting on this for the decryption assert len(out_block) == SECRET_BOX_SIGN_SIZE + len(block) out_stream.write(out_block) block = in_stream.read(block_size) counter += 1 return
def serialize(self, obj): """ Implements :func:`autobahn.wamp.interfaces.IObjectSerializer.serialize` """ data = ubjson.dumpb(obj) if self._batched: return struct.pack("!L", len(data)) + data else: return data
def __calc_stashdump(self): with self.__stash_lock: stashdump = ubjson.dumpb(self.__stash) m = md5() m.update(stashdump) stashhash = m.hexdigest() if self.__stash_hash != stashhash: self.__stash_hash = stashhash return stashdump return None
def __new_handshake(self, cursor=0, token=NULL_TOKEN): """ Returns a new binary handshake message """ handshake = bytearray() handshake_contents = ubjson.dumpb({ 'type': CommType.HANDSHAKE.value, 'payload': { 'cursor': cursor, 'clientToken': token, 'isRealtime': self.realtime, } }) handshake += pack(">L", len(handshake_contents)) handshake += handshake_contents return handshake
def write(self,data): """ Writes data to file and to the loggerstreamdataobjects """ if(self.mode == 'wb'): ubdata = ubjson.dumpb(data) ubdata = ubdata + b'\n' print('Writing',data) self.f.write(ubdata) if(self.fill_loggerstreamdata): log_stream_number = data[0] loggerstream_ind = self._loggerstream_num2ind[log_stream_number] self.loggerstreams[loggerstream_ind].add_data(data[1])
def put_timestamp(hexhash: str, comment: str='', stream='timestamp') -> Optional[TxId]: client = get_active_rpc_client() if comment: data = dict(comment=comment) serialized = ubjson.dumpb(data) data_hex = hexlify(serialized).decode('utf-8') response = client.publish(stream, hexhash, data_hex) else: response = client.publish(stream, hexhash) if response['error'] is not None: raise RpcResponseError(response['error']['message']) return TxId(response['result'])
def put_timestamp(hexhash: str, comment: str = '', stream=app.STREAM_TIMESTAMP) -> Optional[TxId]: client = get_active_rpc_client() try: if comment: data = dict(comment=comment) serialized = ubjson.dumpb(data) data_hex = hexlify(serialized).decode('utf-8') response = client.publish(stream, hexhash, data_hex) else: response = client.publish(stream, hexhash, "") return TxId(response) except Exception as e: log.debug(e) raise RpcResponseError(str(e))
def _send_dictio(dictio, sock, hostPort: tuple): """low level send""" global LastDictio LastDictio = dictio.copy() # _printd('executing: '+str(dictio)) dictio['username'] = Username dictio['program'] = Program dictio['pid'] = PID # _printd(f'send_dictio to {hostPort}: {dictio}') encoded = ubjson.dumpb(dictio) if UDP: sock.sendto(encoded, hostPort) else: sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: sock.connect(hostPort) except Exception as e: _printe('in sock.connect:' + str(e)) sys.exit() sock.sendall(encoded)
import ubjson data = { "name": "python-ubjson", "versions": ["1", "2"], "group": { "is_a_package": True, "value": 42 } } serialized = ubjson.dumpb(data) print(serialized) with open("/tmp/data.json", "wb") as f: f.write(serialized)
import traceback lck = threading.Lock() def recv_fun(ser): while True: res = ser.read(32) lck.acquire() if (res != b''): print("".join(chr(x) for x in res), end='', flush=True) lck.release() with serial.Serial(sys.argv[1], 115200, timeout=0.1) as ser: recvthread = threading.Thread(target=recv_fun, args=[ser]) recvthread.start() print("Ready, press return to enter command.") while True: input() lck.acquire() jsoncmd = input("Enter JSON command: ") try: out_ubjson = ubjson.dumpb(json.loads(jsoncmd)) ser.write(b'\x00\x01') ser.write(out_ubjson) ser.write(b'\x00\x02') except: traceback.print_exc() lck.release()
# Sends a get_lora_channel command and tries to parse the response. import socket import time import ubjson import sys # The command that should be sent command = {"get_lora_channel":{ }} # Replace with IP and port shown in the RIOT console target_if = socket.getaddrinfo('fd00::1337:0001' if len(sys.argv)<2 else sys.argv[1], 9000, socket.AF_INET6, socket.SOCK_STREAM) (family, socktype, proto, canonname, sockaddr) = target_if[0] # Wrap the command in OBJ_BEGIN and OBJ_END sequences bincmd = b'\x00\x01' + ubjson.dumpb(command) + b'\x00\x02' # Open socket and send command s = socket.socket(family, socktype, proto) s.connect(sockaddr) s.send(bincmd) # Collect the response. Will loop until a OBJ_END sequence arrives data = b'' try: prefix = s.recv(2) if prefix == b'\x00\x01': while data[-2:] != b'\x00\x02': data += s.recv(1) # Unescape bianry zeroes if data[-2:]==b'\x00\x00':
def ask_retransmit(offsetSize): global retransmitInProgress retransmitInProgress = tuple(offsetSize) cmd = {'cmd': ('retransmit', offsetSize)} _printi(f'Asking to retransmit port {port}: {cmd}') sock.sendto(ubjson.dumpb(cmd), addr)
bson_files_sizes += [bson_file_size] with open(bin_file_name.format(i), 'rb') as bin_file: bs = bin_file.read() start = time.time() bson.loads(bs) end = time.time() bson_unpack_time += [end - start] bson_compression += [bson_file_size / json_file_size] # Testing ubjson library. bin_file_name = 'test-{}.ubjson.bin' with open(bin_file_name.format(i), 'wb') as bin_file: start = time.time() ubs = ubjson.dumpb(json_data) end = time.time() ubjson_pack_time += [end - start] bin_file.write(ubs) ubjson_file_size = os.stat(bin_file_name.format(i)).st_size ubjson_files_sizes += [ubjson_file_size] with open(bin_file_name.format(i), 'rb') as bin_file: ubs = bin_file.read() start = time.time() ubjson.loadb(ubs) end = time.time() ubjson_unpack_time += [end - start] ubjson_compression += [ubjson_file_size / json_file_size]