def testtwo(): p = AnimatedProgressBar(end=100, width=80) while True: p + 5 p.show_progress() time.sleep(0.1) if p.progress == 100: break
def hashing(disk_path, meta_path, chunk_size=4096, window_size=512): # TODO: need more efficient implementation, e.g. bisect # generate hash of base disk # disk_path : raw disk path # chunk_size : hash chunk size # window_size : slicing window size prog_bar = AnimatedProgressBar(end=100, width=80, stdout=sys.stdout) total_iteration = os.path.getsize(disk_path) / window_size iter_count = 0 prog_interval = 100 disk_file = open(disk_path, "rb") out_file = open(meta_path, "w+b") data = disk_file.read(chunk_size) if (not data) or len(data) < chunk_size: raise DiskError("invalid raw disk size") entire_hashing = sha256() entire_hashing.update(data) s_offset = 0 data_len = len(data) hash_dic = dict() while True: if (iter_count) % prog_interval == 0: prog_bar.process(100.0 * prog_interval / total_iteration) prog_bar.show_progress() iter_count += 1 hashed_data = sha256(data).digest() if hash_dic.get(hashed_data) == None: hash_dic[hashed_data] = (hashed_data, s_offset, data_len) added_data = disk_file.read(window_size) if (not added_data) or len(added_data) != window_size: break s_offset += window_size data = data[window_size:] + added_data entire_hashing.update(added_data) for hashed_data, s_offset, data_len in list(hash_dic.values()): out_file.write( struct.pack("!QI%ds" % len(hashed_data), s_offset, data_len, hashed_data)) disk_file.close() out_file.close() return entire_hashing.hexdigest()
def testone(): progress = AnimatedProgressBar(end=FILESIZE, width=50) for i in range(0, FILESIZE, CHUNK): progress + CHUNK progress.show_progress()
def dispatch_command(self, command): """ Apply user command @param command : user command """ if len(command) == 1: if command[0] == "help": self.print_help() elif command[0] == "version": print self.VERSION_NUMBER elif command[0] == "quit": self.stop() sys.exit(0) elif len(command) < 2: print "Incorrect command. Run \"help\" to get more information" # Print SWAP traffic elif command[0] == "traffic": if command[1].lower() == "on": self.verbose = True self.server.verbose = True self.server.modem.verbose = True self.server.modem._serport._verbose = True elif command[1].lower() == "off": self.verbose = False self.server.verbose = False self.server.modem.verbose = False self.server.modem._serport._verbose = False else: print command[1] + " is not a correct value" # Set HEX file elif command[0] == "hexfile": # HEX file object self.hexfile = HexFile(command[1]) # Print list of nodes elif command[0] == "list": if command[1] == "nodes": if len(self.network.motes) == 0: print "No nodes detected" else: for mote in self.network.motes: print "Addr: " + hex( mote.address) + " - " + mote.definition.product # Clear list list of nodes elif command[0] == "clear": if command[1] == "nodes": self.server.network.clear() self.server.network.save() # Change device device property elif command[0] == "node": if len(command) < 3: print "Insufficient arguments" print "Correct format is: node <address> <options...>" else: addr = self.str_to_int(command[1]) if addr is None: print "Incorrect address format" else: # Get mote object mote = self.server.network.get_mote(address=addr) if mote is None: print "Node not found in data base" print "Clear your list of nodes and restart them again" else: # Program node if command[2] == "program": if (self.hexfile == None): print "Please set a hexfile before running \"program\"" else: # Create progress bar self.progress = AnimatedProgressBar( end=self.hexfile.nbof_data_lines, width=50) # Save address of node being programmed self.prog_address = addr # Transmit product code self.transmit_product_code() # Put node in upgrade mode val = SwapValue(SwapState.UPGRADE, 1) if mote.cmdRegisterWack( SwapRegId.ID_SYSTEM_STATE, val): print "Node now in programming mode" elif self.hexfile_line == 0: print "Unable to put node in progamming mode" self.prog_address = None # Restart node (if not sleeping) elif command[2] == "restart": if mote.restart(): print "Node restarting" else: print "Got no response from node. It's probably sleeping" # Show details of device elif command[2] == "details": print "SWAP address : " + hex(mote.address) print "Developer : " + mote.definition.manufacturer print "Product name : " + mote.definition.product if mote.config_registers is not None: print "Config registers :" for reg in mote.config_registers: print "Register ID : " + hex(reg.id) print "Register name : " + reg.name print "Register value : 0x" + reg.value.toAsciiHex( ) for param in reg.parameters: print " Parameter name : " + param.name print " Parameter value : 0x" + param.value.toAsciiHex( ) if mote.regular_registers is not None: print "Regular registers :" for reg in mote.regular_registers: print "Register ID : " + hex(reg.id) print "Register name : " + reg.name print "Register value : 0x" + reg.value.toAsciiHex( ) for endp in reg.parameters: print " Endpoint name : " + endp.name print " Endpoint value : 0x" + endp.value.toAsciiHex( ) # Change device address elif command[2] == "address": if len(command) == 3: self.print_response( mote.qryRegisterWack( SwapRegId.ID_DEVICE_ADDR), command[2]) elif len(command) > 4: self.print_format_error(command[2]) else: new_addr = self.str_to_int(command[3]) if new_addr is not None: self.print_confirmation( mote.setAddress(new_addr), command[2], command[3]) # Change Tx interval elif command[2] == "txinterval": if len(command) == 3: self.print_response( mote.qryRegisterWack( SwapRegId.ID_TX_INTERVAL), command[2]) elif len(command) > 4: self.print_format_error(command[2]) else: new_interval = self.str_to_int(command[3]) if new_interval is not None: self.print_confirmation( mote.setTxInterval(new_interval), command[2], command[3]) # Change network id elif command[2] == "netid": if len(command) == 3: self.print_response( mote.qryRegisterWack( SwapRegId.ID_NETWORK_ID), "network ID") elif len(command) > 4: self.print_format_error(command[2]) else: new_netid = self.str_to_int(command[3]) if new_netid is not None: self.print_confirmation( mote.setNetworkId(new_netid), command[2], command[3]) # Change frequency channel elif command[2] == "channel": if len(command) == 3: self.print_response( mote.qryRegisterWack( SwapRegId.ID_FREQ_CHANNEL), command[2]) elif len(command) > 4: self.print_format_error(command[2]) else: new_channel = self.str_to_int(command[3]) if new_channel is not None: self.print_confirmation( mote.setFreqChannel(new_channel), command[2], command[3]) # Read/write register elif command[2] == "reg": if len(command) > 3: reg_id = self.str_to_int(command[3]) if reg_id is not None: if len(command) == 4: self.print_response( mote.qryRegisterWack(reg_id), "register value") elif len(command) == 5: reg = mote.getRegister(reg_id) val = SwapValue( command[4], reg.value.getLength()) self.print_confirmation( mote.cmdRegisterWack(reg_id, val), "register value", command[4]) else: print "Too many arguments" print "Correct format is: node <address> reg <reg_id> [<reg_val>]" else: print "Insufficient arguments" print "Correct format is: node <address> reg <reg_id> [<reg_val>]" else: print "Command not supported" else: print "Command not supported"
def _get_mem_hash(self, fin, end_offset, hash_list, **kwargs): # kwargs # diff: compare hash_list with self object # free_pfn_dict: free memory physical frame number as a dictionary {'#':1, ... } diff = kwargs.get("diff", None) apply_free_memory = kwargs.get("apply_free_memory", True) free_pfn_dict = kwargs.get("free_pfn_dict", None) LOG.info("Get hash list of memory page") prog_bar = AnimatedProgressBar(end=100, width=80, stdout=sys.stdout) total_size = end_offset ram_offset = 0 freed_page_counter = 0 base_hashlist_length = len(self.hash_list) while total_size != ram_offset: data = fin.read(Memory.RAM_PAGE_SIZE) if not diff: hash_list.append((ram_offset, len(data), sha256(data).digest())) else: # compare input with hash or corresponding base memory, save only when it is different hash_list_index = ram_offset/Memory.RAM_PAGE_SIZE if hash_list_index < base_hashlist_length: self_hash_value = self.hash_list[hash_list_index][2] else: self_hash_value = None if self_hash_value != sha256(data).digest(): is_free_memory = False if (free_pfn_dict != None) and \ (free_pfn_dict.get(long(ram_offset/Memory.RAM_PAGE_SIZE), None) == 1): is_free_memory = True if is_free_memory and apply_free_memory: # Do not compare. It is free memory freed_page_counter += 1 else: #get xdelta comparing self.raw source_data = self.get_raw_data(ram_offset, len(data)) #save xdelta as DeltaItem only when it gives smaller try: if source_data == None: raise IOError("launch memory snapshot is bigger than base vm") patch = tool.diff_data(source_data, data, 2*len(source_data)) if len(patch) < len(data): delta_item = DeltaItem(DeltaItem.DELTA_MEMORY, ram_offset, len(data), hash_value=sha256(data).digest(), ref_id=DeltaItem.REF_XDELTA, data_len=len(patch), data=patch) else: raise IOError("xdelta3 patch is bigger than origianl") except IOError as e: #LOG.info("xdelta failed, so save it as raw (%s)" % str(e)) delta_item = DeltaItem(DeltaItem.DELTA_MEMORY, ram_offset, len(data), hash_value=sha256(data).digest(), ref_id=DeltaItem.REF_RAW, data_len=len(data), data=data) hash_list.append(delta_item) # memory over-usage protection if len(hash_list) > Memory.RAM_PAGE_SIZE*1000000: # 400MB for hashlist raise MemoryError("possibly comparing with wrong base VM") ram_offset += len(data) # print progress bar for every 100 page if (ram_offset % (Memory.RAM_PAGE_SIZE*100)) == 0: prog_bar.set_percent(100.0*ram_offset/total_size) prog_bar.show_progress() prog_bar.finish() return freed_page_counter