idx int64 0 63k | question stringlengths 61 4.03k | target stringlengths 6 1.23k |
|---|---|---|
9,600 | def mnemonic ( self , value ) : if value not in REIL_MNEMONICS : raise Exception ( "Invalid instruction mnemonic : %s" % str ( value ) ) self . _mnemonic = value | Set instruction mnemonic . |
9,601 | def operands ( self , value ) : if len ( value ) != 3 : raise Exception ( "Invalid instruction operands : %s" % str ( value ) ) self . _operands = value | Set instruction operands . |
9,602 | def __taint_load ( self , instr ) : op0_val = self . __emu . read_operand ( instr . operands [ 0 ] ) op0_taint = self . get_memory_taint ( op0_val , instr . operands [ 2 ] . size // 8 ) self . set_operand_taint ( instr . operands [ 2 ] , op0_taint ) | Taint LDM instruction . |
9,603 | def __taint_store ( self , instr ) : op2_val = self . __emu . read_operand ( instr . operands [ 2 ] ) op0_size = instr . operands [ 0 ] . size op0_taint = self . get_operand_taint ( instr . operands [ 0 ] ) self . set_memory_taint ( op2_val , op0_size // 8 , op0_taint ) | Taint STM instruction . |
9,604 | def __taint_move ( self , instr ) : op0_taint = self . get_operand_taint ( instr . operands [ 0 ] ) self . set_operand_taint ( instr . operands [ 2 ] , op0_taint ) | Taint registers move instruction . |
9,605 | def execute ( self , asm_instr ) : self . ir_emulator . registers [ self . ip ] = asm_instr . address + asm_instr . size if self . arch_info . instr_is_syscall ( asm_instr ) : raise Syscall ( ) return self . __execute ( asm_instr ) | Execute an assembler instruction . |
9,606 | def ir_instrs ( self ) : ir_instrs = [ ] for asm_instr in self . _instrs : ir_instrs += asm_instr . ir_instrs return ir_instrs | Get gadgets IR instructions . |
9,607 | def load_symbols_elf ( filename ) : f = open ( filename , 'rb' ) elffile = ELFFile ( f ) symbols = [ ] for section in elffile . iter_sections ( ) : if not isinstance ( section , SymbolTableSection ) : continue if section [ 'sh_entsize' ] == 0 : logger . warn ( "Symbol table {} has a sh_entsize of zero." . format ( sect... | Load the symbol tables contained in the file |
9,608 | def _classify_no_operation ( self , regs_init , regs_fini , mem_fini , written_regs , read_regs ) : matches = [ ] regs_changed = any ( regs_init [ r ] != regs_fini [ r ] for r in regs_init ) flags_changed = False mem_changed = mem_fini . get_write_count ( ) != 0 if not regs_changed and not flags_changed and not mem_cha... | Classify no - operation gadgets . |
9,609 | def _classify_move_register ( self , regs_init , regs_fini , mem_fini , written_regs , read_regs ) : matches = [ ] regs_init_inv = self . _invert_dictionary ( regs_init ) for dst_reg , dst_val in regs_fini . items ( ) : if dst_reg not in written_regs : continue for src_reg in regs_init_inv . get ( dst_val , [ ] ) : if ... | Classify move - register gadgets . |
9,610 | def _classify_load_constant ( self , regs_init , regs_fini , mem_fini , written_regs , read_regs ) : matches = [ ] for dst_reg , dst_val in regs_fini . items ( ) : if dst_reg not in written_regs : continue if dst_val == regs_init [ dst_reg ] : continue dst_val_ir = ReilImmediateOperand ( dst_val , self . _arch_regs_siz... | Classify load - constant gadgets . |
9,611 | def _classify_arithmetic ( self , regs_init , regs_fini , mem_fini , written_regs , read_regs ) : matches = [ ] op_restrictions = { "+" : lambda x , y : False , "-" : lambda x , y : x == y , "|" : lambda x , y : x == y , "&" : lambda x , y : x == y , "^" : lambda x , y : x == y , } for op_name , op_fn in self . _binary... | Classify binary - operation gadgets . |
9,612 | def _classify_load_memory ( self , regs_init , regs_fini , mem_fini , written_regs , read_regs ) : matches = [ ] regs_init_inv = self . _invert_dictionary ( regs_init ) for dst_reg , dst_val in regs_fini . items ( ) : if dst_reg not in written_regs : continue dst_size = self . _arch_regs_size [ dst_reg ] for src_addr i... | Classify load - memory gadgets . |
9,613 | def _classify_store_memory ( self , regs_init , regs_fini , mem_fini , written_regs , read_regs ) : matches = [ ] regs_init_inv = self . _invert_dictionary ( regs_init ) for src_reg , src_val in regs_init . items ( ) : if src_reg not in read_regs : continue src_size = self . _arch_regs_size [ src_reg ] for addr in mem_... | Classify store - memory gadgets . |
9,614 | def _classify_arithmetic_load ( self , regs_init , regs_fini , mem_fini , written_regs , read_regs ) : matches = [ ] for op_name , op_fn in self . _binary_ops . items ( ) : for dst_reg , dst_val in regs_fini . items ( ) : if dst_reg not in written_regs or dst_reg not in read_regs : continue dst_size = self . _arch_regs... | Classify arithmetic - load gadgets . |
9,615 | def _classify_arithmetic_store ( self , regs_init , regs_fini , mem_fini , written_regs , read_regs ) : matches = [ ] for op_name , op_fn in self . _binary_ops . items ( ) : for size in [ 8 , 16 , 32 , 64 ] : for addr in mem_fini . get_addresses ( ) : success_read_curr , val_curr = mem_fini . try_read ( addr , size // ... | Classify arithmetic - store gadgets . |
9,616 | def _init_regs_random ( self ) : values = set ( ) while len ( values ) != len ( self . _arch_regs_parent ) : values . add ( random . randint ( 0 , 2 ** self . _arch_info . operand_size - 1 ) ) values = list ( values ) regs = { } for idx , reg in enumerate ( self . _arch_regs_parent ) : regs [ reg ] = values [ idx ] & (... | Initialize register with random values . |
9,617 | def _compute_mod_regs ( self , regs_init , regs_fini ) : assert regs_init . keys ( ) == regs_fini . keys ( ) modified_regs = [ ] for reg in regs_init : if regs_init [ reg ] != regs_fini [ reg ] : modified_regs . append ( reg ) return modified_regs | Compute modified registers . |
9,618 | def _invert_dictionary ( self , d ) : inv_dict = { } for k , v in d . items ( ) : inv_dict [ v ] = inv_dict . get ( v , [ ] ) inv_dict [ v ] += [ k ] return inv_dict | Invert a dictionary . |
9,619 | def _print_memory ( self , memory ) : for addr , value in memory . items ( ) : print ( " 0x%08x : 0x%08x (%d)" % ( addr , value , value ) ) | Print memory . |
9,620 | def _print_registers ( self , registers ) : for reg , value in registers . items ( ) : print ( " %s : 0x%08x (%d)" % ( reg , value , value ) ) | Print registers . |
9,621 | def bb_get_instr_max_width ( basic_block ) : asm_mnemonic_max_width = 0 for instr in basic_block : if len ( instr . mnemonic ) > asm_mnemonic_max_width : asm_mnemonic_max_width = len ( instr . mnemonic ) return asm_mnemonic_max_width | Get maximum instruction mnemonic width |
9,622 | def end_address ( self ) : if self . _instrs is [ ] : return None return self . _instrs [ - 1 ] . address + self . _instrs [ - 1 ] . size - 1 | Get basic block end address . |
9,623 | def size ( self ) : if self . _instrs is [ ] : return None return sum ( [ instr . size for instr in self . _instrs ] ) | Get basic block size . |
9,624 | def branches ( self ) : branches = [ ] if self . _taken_branch : branches += [ ( self . _taken_branch , 'taken' ) ] if self . _not_taken_branch : branches += [ ( self . _not_taken_branch , 'not-taken' ) ] if self . _direct_branch : branches += [ ( self . _direct_branch , 'direct' ) ] return branches | Get basic block branches . |
9,625 | def _compute_register_list ( self , operand ) : ret = [ ] for reg_range in operand . reg_list : if len ( reg_range ) == 1 : ret . append ( ReilRegisterOperand ( reg_range [ 0 ] . name , reg_range [ 0 ] . size ) ) else : reg_num = int ( reg_range [ 0 ] . name [ 1 : ] ) reg_end = int ( reg_range [ 1 ] . name [ 1 : ] ) if... | Return operand register list . |
9,626 | def translate ( self , instruction ) : try : trans_instrs = self . __translate ( instruction ) except NotImplementedError : unkn_instr = self . _builder . gen_unkn ( ) unkn_instr . address = instruction . address << 8 | ( 0x0 & 0xff ) trans_instrs = [ unkn_instr ] self . _log_not_supported_instruction ( instruction ) e... | Return IR representation of an instruction . |
9,627 | def read ( self , address , size ) : value = 0x0 for i in range ( 0 , size ) : value |= self . _read_byte ( address + i ) << ( i * 8 ) return value | Read arbitrary size content from memory . |
9,628 | def _read_byte ( self , address ) : if address not in self . _memory : self . _memory [ address ] = random . randint ( 0x00 , 0xff ) return self . _memory [ address ] | Read a byte from memory . |
9,629 | def write ( self , address , size , value ) : for i in range ( 0 , size ) : self . __write_byte ( address + i , ( value >> ( i * 8 ) ) & 0xff ) | Write arbitrary size content to memory . |
9,630 | def read_inverse ( self , value , size ) : addr_candidates = [ addr for addr , val in self . _memory . items ( ) if val == ( value & 0xff ) ] addr_matches = [ ] for addr in addr_candidates : match = True for i in range ( 0 , size ) : byte_curr = ( value >> ( i * 8 ) ) & 0xff try : match = self . _memory [ addr + i ] ==... | Return a list of memory addresses that contain the specified value . |
9,631 | def try_read ( self , address , size ) : value = 0x0 for i in range ( 0 , size ) : addr = address + i if addr in self . _memory : value |= self . _read_byte ( addr ) << ( i * 8 ) else : return False , None return True , value | Try to read memory content at specified address . |
9,632 | def try_read_prev ( self , address , size ) : value = 0x0 for i in range ( 0 , size ) : addr = address + i if addr in self . __memory_prev : _ , val_byte = self . __try_read_byte_prev ( addr ) value |= val_byte << ( i * 8 ) else : return False , None return True , value | Try to read previous memory content at specified address . |
9,633 | def __try_read_byte_prev ( self , address ) : if address not in self . __memory_prev : return False , None return True , self . __memory_prev [ address ] | Read previous value for memory location . |
9,634 | def __write_byte ( self , address , value ) : if address in self . _memory : self . __memory_prev [ address ] = self . _memory [ address ] self . _memory [ address ] = value & 0xff | Write byte in memory . |
9,635 | def gen_add ( src1 , src2 , dst ) : assert src1 . size == src2 . size return ReilBuilder . build ( ReilMnemonic . ADD , src1 , src2 , dst ) | Return an ADD instruction . |
9,636 | def gen_sub ( src1 , src2 , dst ) : assert src1 . size == src2 . size return ReilBuilder . build ( ReilMnemonic . SUB , src1 , src2 , dst ) | Return a SUB instruction . |
9,637 | def gen_mul ( src1 , src2 , dst ) : assert src1 . size == src2 . size return ReilBuilder . build ( ReilMnemonic . MUL , src1 , src2 , dst ) | Return a MUL instruction . |
9,638 | def gen_div ( src1 , src2 , dst ) : assert src1 . size == src2 . size return ReilBuilder . build ( ReilMnemonic . DIV , src1 , src2 , dst ) | Return a DIV instruction . |
9,639 | def gen_mod ( src1 , src2 , dst ) : assert src1 . size == src2 . size return ReilBuilder . build ( ReilMnemonic . MOD , src1 , src2 , dst ) | Return a MOD instruction . |
9,640 | def gen_bsh ( src1 , src2 , dst ) : assert src1 . size == src2 . size return ReilBuilder . build ( ReilMnemonic . BSH , src1 , src2 , dst ) | Return a BSH instruction . |
9,641 | def gen_and ( src1 , src2 , dst ) : assert src1 . size == src2 . size return ReilBuilder . build ( ReilMnemonic . AND , src1 , src2 , dst ) | Return an AND instruction . |
9,642 | def gen_or ( src1 , src2 , dst ) : assert src1 . size == src2 . size return ReilBuilder . build ( ReilMnemonic . OR , src1 , src2 , dst ) | Return an OR instruction . |
9,643 | def gen_xor ( src1 , src2 , dst ) : assert src1 . size == src2 . size return ReilBuilder . build ( ReilMnemonic . XOR , src1 , src2 , dst ) | Return a XOR instruction . |
9,644 | def gen_ldm ( src , dst ) : return ReilBuilder . build ( ReilMnemonic . LDM , src , ReilEmptyOperand ( ) , dst ) | Return a LDM instruction . |
9,645 | def gen_stm ( src , dst ) : return ReilBuilder . build ( ReilMnemonic . STM , src , ReilEmptyOperand ( ) , dst ) | Return a STM instruction . |
9,646 | def gen_str ( src , dst ) : return ReilBuilder . build ( ReilMnemonic . STR , src , ReilEmptyOperand ( ) , dst ) | Return a STR instruction . |
9,647 | def gen_bisz ( src , dst ) : return ReilBuilder . build ( ReilMnemonic . BISZ , src , ReilEmptyOperand ( ) , dst ) | Return a BISZ instruction . |
9,648 | def gen_jcc ( src , dst ) : return ReilBuilder . build ( ReilMnemonic . JCC , src , ReilEmptyOperand ( ) , dst ) | Return a JCC instruction . |
9,649 | def gen_unkn ( ) : empty_reg = ReilEmptyOperand ( ) return ReilBuilder . build ( ReilMnemonic . UNKN , empty_reg , empty_reg , empty_reg ) | Return an UNKN instruction . |
9,650 | def gen_undef ( ) : empty_reg = ReilEmptyOperand ( ) return ReilBuilder . build ( ReilMnemonic . UNDEF , empty_reg , empty_reg , empty_reg ) | Return an UNDEF instruction . |
9,651 | def gen_nop ( ) : empty_reg = ReilEmptyOperand ( ) return ReilBuilder . build ( ReilMnemonic . NOP , empty_reg , empty_reg , empty_reg ) | Return a NOP instruction . |
9,652 | def gen_sext ( src , dst ) : assert src . size <= dst . size empty_reg = ReilEmptyOperand ( ) return ReilBuilder . build ( ReilMnemonic . SEXT , src , empty_reg , dst ) | Return a SEXT instruction . |
9,653 | def gen_sdiv ( src1 , src2 , dst ) : assert src1 . size == src2 . size return ReilBuilder . build ( ReilMnemonic . SDIV , src1 , src2 , dst ) | Return a SDIV instruction . |
9,654 | def gen_smod ( src1 , src2 , dst ) : assert src1 . size == src2 . size return ReilBuilder . build ( ReilMnemonic . SMOD , src1 , src2 , dst ) | Return a SMOD instruction . |
9,655 | def gen_smul ( src1 , src2 , dst ) : assert src1 . size == src2 . size return ReilBuilder . build ( ReilMnemonic . SMUL , src1 , src2 , dst ) | Return a SMUL instruction . |
9,656 | def build ( mnemonic , oprnd1 , oprnd2 , oprnd3 ) : ins = ReilInstruction ( ) ins . mnemonic = mnemonic ins . operands = [ oprnd1 , oprnd2 , oprnd3 ] return ins | Return the specified instruction . |
9,657 | def _setup_arch ( self , arch_mode = None ) : self . arch_info = None if self . binary . architecture == ARCH_X86 : self . _setup_x86_arch ( arch_mode ) else : self . _setup_arm_arch ( arch_mode ) | Set up architecture . |
9,658 | def _setup_arm_arch ( self , arch_mode = None ) : if arch_mode is None : arch_mode = ARCH_ARM_MODE_THUMB self . name = "ARM" self . arch_info = ArmArchitectureInformation ( arch_mode ) self . disassembler = ArmDisassembler ( architecture_mode = arch_mode ) self . ir_translator = ArmTranslator ( architecture_mode = arch... | Set up ARM architecture . |
9,659 | def _setup_x86_arch ( self , arch_mode = None ) : if arch_mode is None : arch_mode = self . binary . architecture_mode self . name = "x86" self . arch_info = X86ArchitectureInformation ( arch_mode ) self . disassembler = X86Disassembler ( arch_mode ) self . ir_translator = X86Translator ( arch_mode ) | Set up x86 architecture . |
9,660 | def _setup_core_modules ( self ) : self . ir_emulator = None self . smt_solver = None self . smt_translator = None if self . arch_info : self . ir_emulator = ReilEmulator ( self . arch_info ) self . smt_solver = None if SMT_SOLVER not in ( "Z3" , "CVC4" ) : raise Exception ( "{} SMT solver not supported." . format ( SM... | Set up core modules . |
9,661 | def _setup_analysis_modules ( self ) : self . bb_builder = CFGRecoverer ( RecursiveDescent ( self . disassembler , self . text_section , self . ir_translator , self . arch_info ) ) self . code_analyzer = None if self . smt_translator : self . code_analyzer = CodeAnalyzer ( self . smt_solver , self . smt_translator , se... | Set up analysis modules . |
9,662 | def open ( self , filename ) : if filename : self . binary = BinaryFile ( filename ) self . text_section = self . binary . text_section self . _load ( arch_mode = self . binary . architecture_mode ) | Open a file for analysis . |
9,663 | def disassemble ( self , start = None , end = None , arch_mode = None ) : if arch_mode is None : arch_mode = self . binary . architecture_mode curr_addr = start if start else self . binary . ea_start end_addr = end if end else self . binary . ea_end while curr_addr < end_addr : encoding = self . __fetch_instr ( curr_ad... | Disassemble native instructions . |
9,664 | def recover_cfg ( self , start = None , end = None , symbols = None , callback = None , arch_mode = None ) : if arch_mode is None : arch_mode = self . binary . architecture_mode self . _load ( arch_mode = arch_mode ) start = start if start else self . binary . entry_point cfg , _ = self . _recover_cfg ( start = start ,... | Recover CFG . |
9,665 | def emulate ( self , context = None , start = None , end = None , arch_mode = None , hooks = None , max_instrs = None , print_asm = False ) : if arch_mode is not None : self . _load ( arch_mode = arch_mode ) context = context if context else { } start_addr = start if start else self . binary . ea_start end_addr = end i... | Emulate native code . |
9,666 | def find ( self , start_address , end_address , byte_depth = 20 , instrs_depth = 2 ) : self . _max_bytes = byte_depth self . _instrs_depth = instrs_depth if self . _architecture == ARCH_X86 : candidates = self . _find_x86_candidates ( start_address , end_address ) elif self . _architecture == ARCH_ARM : candidates = se... | Find gadgets . |
9,667 | def _build_from ( self , address , root , base_address , depth = 2 ) : if depth == 0 : return end_addr = address for step in range ( 1 , self . _max_bytes + 1 ) : start_addr = address - step if start_addr < 0 or start_addr < base_address : break raw_bytes = self . _mem [ start_addr : end_addr ] if self . _architecture ... | Build gadgets recursively . |
9,668 | def _build_gadgets ( self , gadget_tree_root ) : node_list = self . _build_gadgets_rec ( gadget_tree_root ) return [ RawGadget ( n ) for n in node_list ] | Return a gadgets list . |
9,669 | def _build_gadgets_rec ( self , gadget_tree_root ) : root = gadget_tree_root . get_root ( ) children = gadget_tree_root . get_children ( ) node_list = [ ] root_gadget_ins = root if not children : node_list += [ [ root_gadget_ins ] ] else : for child in children : node_list_rec = self . _build_gadgets_rec ( child ) node... | Build a gadgets from a gadgets tree . |
9,670 | def _is_valid_ins ( self , ins_ir ) : invalid_instrs = [ ReilMnemonic . JCC , ReilMnemonic . UNDEF , ReilMnemonic . UNKN , ] return not any ( [ i . mnemonic in invalid_instrs for i in ins_ir ] ) | Check for instruction validity as a gadgets . |
9,671 | def translate ( self , instruction ) : try : trans_instrs = self . _translate ( instruction ) except Exception : self . _log_translation_exception ( instruction ) raise TranslationError ( "Unknown error" ) return trans_instrs | Return REIL representation of an instruction . |
9,672 | def add_instruction ( self , reil_instruction ) : for expr in self . _translator . translate ( reil_instruction ) : self . _solver . add ( expr ) | Add an instruction for analysis . |
9,673 | def _get_var_name ( self , register_name , mode ) : var_name = { "pre" : self . _translator . get_name_init ( register_name ) , "post" : self . _translator . get_name_curr ( register_name ) , } return var_name [ mode ] | Get variable name for a register considering pre and post mode . |
9,674 | def __process_instr ( self , instr , avoid , next_addr , initial_state , execution_state , trace_current ) : if instr . mnemonic == ReilMnemonic . JCC : not_taken_addr = next_addr address , index = split_address ( instr . address ) logger . debug ( "[+] Processing branch: {:#08x}:{:02x} : {}" . format ( address , index... | Process a REIL instruction . |
9,675 | def __fa_process_sequence ( self , sequence , avoid , initial_state , execution_state , trace_current , next_addr ) : ip = sequence . address next_ip = None while ip : try : instr = sequence . fetch ( ip ) except ReilSequenceInvalidAddressError : assert split_address ( ip ) [ 1 ] == 0x0 next_ip = ip break try : target_... | Process a REIL sequence . |
9,676 | def __fa_process_container ( self , container , find , start , end , avoid , initial_state , execution_state , trace_current , trace_final ) : ip = start while ip : try : instr = container . fetch ( ip ) except ReilContainerInvalidAddressError : logger . debug ( "Exception @ {:#08x}" . format ( ip ) ) raise ReilContain... | Process a REIL container . |
9,677 | def find_function_by_name ( self , name ) : cfg_rv = None for cfg in self . _cfgs : if cfg . name == name : cfg_rv = cfg break return cfg_rv | Return the cfg of the requested function by name . |
9,678 | def find_function_by_address ( self , address ) : cfg_rv = None for cfg in self . _cfgs : if cfg . start_address == address : cfg_rv = cfg break return cfg_rv | Return the cfg of the requested function by address . |
9,679 | def all_simple_bb_paths ( self , start_address , end_address ) : bb_start = self . _find_basic_block ( start_address ) bb_end = self . _find_basic_block ( end_address ) paths = networkx . all_simple_paths ( self . _graph , source = bb_start . address , target = bb_end . address ) return ( [ self . _bb_by_addr [ addr ] ... | Return a list of path between start and end address . |
9,680 | def build ( self , start , end , symbols = None ) : symbols = { } if not symbols else symbols bbs = self . _recover_bbs ( start , end , symbols ) bbs = self . _split_bbs ( bbs , symbols ) call_targets = self . _extract_call_targets ( bbs ) return bbs , call_targets | Return the list of basic blocks . |
9,681 | def parse_operand ( string , location , tokens ) : sizes = { "dqword" : 128 , "pointer" : 72 , "qword" : 64 , "pointer" : 40 , "dword" : 32 , "word" : 16 , "byte" : 8 , "bit" : 1 , } if "immediate" in tokens : imm_str = "" . join ( tokens [ "immediate" ] ) base = 16 if imm_str . startswith ( "0x" ) or imm_str . startsw... | Parse instruction operand . |
9,682 | def parse_instruction ( string , location , tokens ) : mnemonic_str = ReilMnemonic . from_string ( tokens [ "mnemonic" ] ) oprnd1 = tokens [ "fst_operand" ] [ 0 ] oprnd2 = tokens [ "snd_operand" ] [ 0 ] oprnd3 = tokens [ "trd_operand" ] [ 0 ] ins_builder = ReilBuilder ( ) return ins_builder . build ( mnemonic_str , opr... | Parse instruction . |
9,683 | def parse ( self , instrs ) : instrs_reil = [ ] try : for instr in instrs : instr_lower = instr . lower ( ) if instr_lower not in self . _cache : self . _cache [ instr_lower ] = instruction . parseString ( instr_lower ) [ 0 ] instrs_reil += [ copy . deepcopy ( self . _cache [ instr_lower ] ) ] except : error_msg = "Fai... | Parse an IR instruction . |
9,684 | def parse_operand ( string , location , tokens ) : if "immediate_operand" in tokens : size = arch_info . operand_size oprnd = ArmImmediateOperand ( "" . join ( tokens [ "immediate_operand" ] ) , size ) if "register_operand" in tokens : oprnd = process_register ( tokens [ "register_operand" ] ) if "wb" in tokens [ "regi... | Parse an ARM instruction operand . |
9,685 | def parse_instruction ( string , location , tokens ) : mnemonic_str = tokens . get ( "mnemonic" ) operands = [ op for op in tokens . get ( "operands" , [ ] ) ] instr = ArmInstruction ( string , mnemonic_str [ "ins" ] , operands , arch_info . architecture_mode ) if "cc" in mnemonic_str : instr . condition_code = cc_mapp... | Parse an ARM instruction . |
9,686 | def get_next_scheduled_time ( cron_string ) : itr = croniter . croniter ( cron_string , datetime . utcnow ( ) ) return itr . get_next ( datetime ) | Calculate the next scheduled time by creating a crontab object with a cron string |
9,687 | def rationalize_until ( until = None ) : if until is None : until = "+inf" elif isinstance ( until , datetime ) : until = to_unix ( until ) elif isinstance ( until , timedelta ) : until = to_unix ( ( datetime . utcnow ( ) + until ) ) return until | Rationalizes the until argument used by other functions . This function accepts datetime and timedelta instances as well as integers representing epoch values . |
9,688 | def register_death ( self ) : self . log . info ( 'Registering death' ) with self . connection . pipeline ( ) as p : p . hset ( self . scheduler_key , 'death' , time . time ( ) ) p . expire ( self . scheduler_key , 60 ) p . execute ( ) | Registers its own death . |
9,689 | def acquire_lock ( self ) : key = '%s_lock' % self . scheduler_key now = time . time ( ) expires = int ( self . _interval ) + 10 self . _lock_acquired = self . connection . set ( key , now , ex = expires , nx = True ) return self . _lock_acquired | Acquire lock before scheduling jobs to prevent another scheduler from scheduling jobs at the same time . |
9,690 | def remove_lock ( self ) : key = '%s_lock' % self . scheduler_key if self . _lock_acquired : self . connection . delete ( key ) | Remove acquired lock . |
9,691 | def _install_signal_handlers ( self ) : def stop ( signum , frame ) : self . log . info ( 'Shutting down RQ scheduler...' ) self . register_death ( ) self . remove_lock ( ) raise SystemExit ( ) signal . signal ( signal . SIGINT , stop ) signal . signal ( signal . SIGTERM , stop ) | Installs signal handlers for handling SIGINT and SIGTERM gracefully . |
9,692 | def _create_job ( self , func , args = None , kwargs = None , commit = True , result_ttl = None , ttl = None , id = None , description = None , queue_name = None , timeout = None , meta = None ) : if args is None : args = ( ) if kwargs is None : kwargs = { } job = self . job_class . create ( func , args = args , connec... | Creates an RQ job and saves it to Redis . |
9,693 | def enqueue_at ( self , scheduled_time , func , * args , ** kwargs ) : timeout = kwargs . pop ( 'timeout' , None ) job_id = kwargs . pop ( 'job_id' , None ) job_ttl = kwargs . pop ( 'job_ttl' , None ) job_result_ttl = kwargs . pop ( 'job_result_ttl' , None ) job_description = kwargs . pop ( 'job_description' , None ) m... | Pushes a job to the scheduler queue . The scheduled queue is a Redis sorted set ordered by timestamp - which in this case is job s scheduled execution time . |
9,694 | def schedule ( self , scheduled_time , func , args = None , kwargs = None , interval = None , repeat = None , result_ttl = None , ttl = None , timeout = None , id = None , description = None , queue_name = None , meta = None ) : if interval is not None and result_ttl is None : result_ttl = - 1 job = self . _create_job ... | Schedule a job to be periodically executed at a certain interval . |
9,695 | def cron ( self , cron_string , func , args = None , kwargs = None , repeat = None , queue_name = None , id = None , timeout = None , description = None , meta = None ) : scheduled_time = get_next_scheduled_time ( cron_string ) job = self . _create_job ( func , args = args , kwargs = kwargs , commit = False , result_tt... | Schedule a cronjob |
9,696 | def cancel ( self , job ) : if isinstance ( job , self . job_class ) : self . connection . zrem ( self . scheduled_jobs_key , job . id ) else : self . connection . zrem ( self . scheduled_jobs_key , job ) | Pulls a job from the scheduler queue . This function accepts either a job_id or a job instance . |
9,697 | def change_execution_time ( self , job , date_time ) : with self . connection . pipeline ( ) as pipe : while 1 : try : pipe . watch ( self . scheduled_jobs_key ) if pipe . zscore ( self . scheduled_jobs_key , job . id ) is None : raise ValueError ( 'Job not in scheduled jobs queue' ) pipe . zadd ( self . scheduled_jobs... | Change a job s execution time . |
9,698 | def count ( self , until = None ) : until = rationalize_until ( until ) return self . connection . zcount ( self . scheduled_jobs_key , 0 , until ) | Returns the total number of jobs that are scheduled for all queues . This function accepts datetime timedelta instances as well as integers representing epoch values . |
9,699 | def get_jobs ( self , until = None , with_times = False , offset = None , length = None ) : def epoch_to_datetime ( epoch ) : return from_unix ( float ( epoch ) ) until = rationalize_until ( until ) job_ids = self . connection . zrangebyscore ( self . scheduled_jobs_key , 0 , until , withscores = with_times , score_cas... | Returns a iterator of job instances that will be queued until the given time . If no until argument is given all jobs are returned . |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.