def run(self, cmds): d.dbg('CmdProcessing.run(): %s' % cmds) for key in cmds.keys(): # check help. if key == 'help': for sub_cmd in cmds[key]: if sub_cmd != 'cfg': # no show while cfg. d.info('help:[help][,cfg]') d.info(' help: show help') d.info(' cfg : show config info') if key in self._cmd_dict: d.dbg(self._cmd_dict[key]) if type(self._cmd_dict[key]) == dict: sub_cmds = self._cmd_dict[key] for sub_key in sub_cmds.iterkeys(): f = sub_cmds[sub_key] d.dbg(f(cmds[key])) else: t = type(self._cmd_dict[key]) if t == list: for f in self._cmd_dict[key]: d.dbg(f(cmds[key])) else: f = self._cmd_dict[key] d.dbg(f(cmds[key])) else: d.err('No handler for: %s' % key)
def __init__(self, url=URL): super(Cwp, self).__init__(url) self._url = url # create cmd process self._cmdHdrs = CmdProcessing() self._cmdHdrs.register_cmd_handler(self.get_cmd_handlers()) d.dbg('Cwp init done!')
def repo_handler(self, cmds): d.dbg('repo_handler: %s' % cmds) for cmd in cmds: if cmd == 'init': self.repo_init() elif cmd == 'sync': self.repo_sync() elif cmd == 'fsync': self.repo_sync(True)
def find_handler(self, cmds): d.dbg('find_handler: {}'.format(cmds)) try: n = len(cmds) if n == 1: self.find('./', cmds[0]) elif n >= 2: self.find(cmds[0], cmds[1]) except KeyError as e: d.err('Error: %s' % e)
def make_image(self, images): d.dbg('Broxton.make_image: {}'.format(images)) make_sh = None for image in images: d.dbg('create makesh for {}'.format(image)) if type(image) is dict: if 'mmm' in image: make_sh = self.create_mmm_sh(image['mmm']) else: d.err('Not support: %s' % str(image)) exit() else: make_sh = self.create_make_sh(image) # set run right cmd = r'chmod a+x {}'.format(make_sh) subprocess.call(cmd, shell=True) # run make sh cmd = r'./{}'.format(make_sh) d.dbg(cmd) subprocess.call(cmd, shell=True) # delete make sh cmd = r'rm -rf {}'.format(make_sh) d.dbg(cmd) subprocess.call(cmd, shell=True)
def __init__(self, url=None, pdt=None, opt=None, user=None): super(Broxton, self).__init__() self._url = url self._pdt = pdt self._opt = opt self._user = user self._fw = r'ifwi_gr_mrb_b1.bin' self._ioc = r'ioc_firmware_gp_mrb_fab_e_slcan.ias_ioc' if self._pdt != None and self._opt != None and self._user != None: self._out = r'out/target/product/{pdt}'.format(pdt=self._pdt) self._flashfiles = r'{out}/{pdt}-flashfiles-eng.{user}'.format(\ out=self._out, pdt=self._pdt, user=self._user) else: self._out = None self._flashfiles = None self.__register_cmd_handlers() d.dbg('Broxton init done!')
def parser_cmd_args(self, cmds): re_dict = re.compile(r'^([\w]+):([\w,\.\/\*\|#-]+)$') re_args = re.compile(r'[\w\.\/\*\|#-]+') re_argv = re.compile('^([\w]+)#([\w,\.\/\*\|-]+)$') output = dict() if len(cmds) == 0: cmds = ['help:help'] for cmd in cmds: dict_cmds = re_dict.match(cmd) if dict_cmds != None: # dict type k, v = dict_cmds.groups() d.dbg((k, v)) if k in output: for x in re_args.findall(v): output[k].append(x) else: output[k] = re_args.findall(v) else: k = None if k in output: for x in re_args.findall(cmd): output[k].append(x) else: output[k] = re_args.findall(cmd) # parse # argv list_argv = output[k] for index in range(len(list_argv)): find_argv = re_argv.match(list_argv[index]) if find_argv != None: dict_argv = dict() argv = find_argv.groups() dict_argv[argv[0]] = list(argv[1:]) list_argv[index] = dict_argv d.dbg('parser_cmd_args(): %s' % output) return output
def avb_make_image(self, image, broxton): # copy image to flashfiles folder cmd = r'cp {out}/{src}.img {flashfiles}/{tar}.img'.format(\ out=broxton._out, src=image, flashfiles=broxton._flashfiles, tar=image) d.dbg(cmd) subprocess.call(cmd, shell=True) d.dbg('avb make image now.') cmd = r'''out/host/linux-x86/bin/avbtool make_vbmeta_image \ --output {}/vbmeta.img \ --include_descriptors_from_image {}/boot.img \ --include_descriptors_from_image {}/system.img \ --include_descriptors_from_image {}/vendor.img \ --include_descriptors_from_image {}/tos.img \ --key external/avb/test/data/testkey_rsa4096.pem \ --algorithm SHA256_RSA4096'''.format( broxton._flashfiles, broxton._flashfiles, broxton._flashfiles, broxton._flashfiles, broxton._flashfiles) d.dbg(cmd) subprocess.call(cmd, shell=True)
def __init__(self): d.dbg('HwInfo init done!')
def run_cmd_handler(self, cmds): d.dbg('adb_handlers: %s' % cmds) for cmd in cmds: if cmd in self.CMD_DICT.keys(): subprocess.call(self.CMD_DICT[cmd], shell=True)
def __init__(self): d.dbg('Android init done.')
def make_image(self, images): d.dbg('_make_image: get input {}'.format(images)) for image in images.values(): d.dbg('_make_image: make {}'.format(image)) cmd = r'make {}'.format(image) subprocess.call(cmd, shell=True)
def __init__(self, url): self._url = url d.dbg('Code init set url={}'.format(url))
def find(self, path, name): cmd = r'find %s -name %s' % (path, name) d.dbg(cmd) return subprocess.call(cmd, shell=True)
def delete(self, f): cmd = r'rm -rf %s' % f d.dbg(cmd) return subprocess.call(cmd, shell=True)
def __init__(self): d.dbg('FileOps init done!')
def __init__(self): d.dbg('Parser init done.')
def find_delete(self, path, name): cmd = r'find %s -name %s | xargs rm -rf {}' % (path, name) d.dbg(cmd) return subprocess.call(cmd, shell=True)
def __init__(self): d.dbg('Input init done.') pass
def get_cups(self, cmds=None): cmd = r'cat /proc/cpuinfo | grep "processor"| wc -l' d.dbg(cmd) return int(subprocess.check_output(cmd, shell=True))
def main(): """Main program.""" global dbg, cleanup_objects sensors = [] itimer_next = {} # Initialize debugging dbg = Debug(level=DEBUG_LVL) cleanup_objects['debug'] = dbg # Initialize sensors for sensor in W1ThermSensor.get_available_sensors(): sensors.append({ 'obj': sensor, 'id_short': sensor.id[-4:], 'value': None, 'read_success': 0, 'read_crc': 0, 'read_nan': 0, 'e_rate': 0 }) if len(sensors) == 0: sys.stderr.write('\nERROR: No sensors found\n') cleanup() exit(0) else: sys.stderr.write('\nINFO: Found {} sensors\n'.format(len(sensors))) active_sensor_idx = 0 # Initialize LCD lcd = disp_init() cleanup_objects['lcd'] = lcd # Very first run for sensor in sensors: read_sensor(sensor) disp_clock(lcd) disp_sensor(lcd, sensors[active_sensor_idx]) # Initialize signal file descriptor # We must set write end of pipe to non blocking mode # Also we don't want to block while read signal numbers from read end pipe_r, pipe_w = os.pipe() cleanup_objects['pipe_r'] = pipe_r cleanup_objects['pipe_w'] = pipe_w flags = fcntl.fcntl(pipe_w, fcntl.F_GETFL, 0) fcntl.fcntl(pipe_w, fcntl.F_SETFL, flags | os.O_NONBLOCK) signal.set_wakeup_fd(pipe_w) flags = fcntl.fcntl(pipe_r, fcntl.F_GETFL, 0) fcntl.fcntl(pipe_r, fcntl.F_SETFL, flags | os.O_NONBLOCK) # Redefine signal handlers cleanup_objects['sigalrm'] = signal.signal(signal.SIGALRM, signal_handler) cleanup_objects['sigint'] = signal.signal(signal.SIGINT, signal_handler) cleanup_objects['sighup'] = signal.signal(signal.SIGHUP, signal_handler) cleanup_objects['sigterm'] = signal.signal(signal.SIGTERM, signal_handler) # Create poller and register file descriptors poller = select.epoll() cleanup_objects['poller'] = poller poller.register(pipe_r, select.EPOLLIN) # Calculate interval timer value itimer_value = gcd(gcd(SENSOR_READ_INTERVAL, SENSOR_DISP_INTERVAL), CLOCK_DISP_INTERVAL) dbg.dbg( 'Calculated itimer interval value is {} seconds'.format(itimer_value)) # Set interval timer # Initial value of timer bounded to measurement itimer_value t = time() t_rest = itimer_value - t % itimer_value # if t_rest < 0: # t_rest += itimer_value t_start = t_rest + ITIMER_START_SHIFT signal.setitimer(signal.ITIMER_REAL, t_start, itimer_value) cleanup_objects['itimer'] = True dbg.dbg('ITIMER_REAL will fire at {} and each {} seconds'.format( itimer_conv(t + t_start), itimer_value)) # Set fire times t_base = t + t_rest dbg.dbg(' Base time is {}'.format(itimer_conv(t_base))) f = lambda x, y: x - x % y + y * ceil((x % y) / y) itimer_next['sensor_read_interval'] = f(t_base, SENSOR_READ_INTERVAL) dbg.dbg(' Wake up time for SENSOR_READ set to {}'.format( itimer_conv(itimer_next['sensor_read_interval']))) itimer_next['sensor_disp_interval'] = f(t_base, SENSOR_DISP_INTERVAL) dbg.dbg(' Wake up time for SENSOR_DISP set to {}'.format( itimer_conv(itimer_next['sensor_disp_interval']))) itimer_next['clock_disp_interval'] = f(t_base, CLOCK_DISP_INTERVAL) dbg.dbg(' Wake up time for CLOCK_DISP set to {}'.format( itimer_conv(itimer_next['clock_disp_interval']))) # Main loop sys.stderr.write('INFO: Entering main loop\n') while True: # Wait for events and process its try: events = poller.poll() except InterruptedError: continue for fd, flags in events: dbg.dbg('Start processing event, fd={}, flags={}'.format( fd, flags)) # Signal received, extract signal numbers from wakeup fd if fd == pipe_r and flags & select.EPOLLIN: dbg.dbg( 'Signal received from wakeup fd, unpacking signal numbers') data = os.read(pipe_r, SIG_WAKEUP_FD_RLEN) signums = struct.unpack('{}B'.format(len(data)), data) dbg.dbg('Signal numbers unpacked: {}'.format(signums)) # Make signal list have unique numbers only signums = set(signums) # Process signals for signum in signums: if signum == signal.SIGALRM: t = time() dbg.dbg('Got SIGALRM, dispatch itimer based tasks') # Display clock if itimer_next['clock_disp_interval'] <= time(): dbg.dbg('Start CLOCK_DISP task') disp_clock(lcd) while itimer_next['clock_disp_interval'] <= time(): itimer_next[ 'clock_disp_interval'] += CLOCK_DISP_INTERVAL dbg.dbg( ' Wake up time for CLOCK_DISP set to {}'. format( itimer_conv( itimer_next['clock_disp_interval']))) # Read sensors if itimer_next['sensor_read_interval'] <= t: dbg.dbg('Start SENSOR_READ task') for sensor in sensors: read_sensor(sensor) while itimer_next['sensor_read_interval'] <= time( ): itimer_next[ 'sensor_read_interval'] += SENSOR_READ_INTERVAL dbg.dbg( ' Wake up time for SENSOR_READ set to {}'. format( itimer_conv( itimer_next['sensor_read_interval']))) # Display sensor if itimer_next['sensor_disp_interval'] <= t: active_sensor = sensors[active_sensor_idx] dbg.dbg( 'Start SENSOR_DISP task, sensor number {} id {}' .format(active_sensor_idx, active_sensor['id_short'])) disp_sensor(lcd, active_sensor) active_sensor_idx += 1 if active_sensor_idx >= len(sensors): active_sensor_idx = 0 while itimer_next['sensor_disp_interval'] <= time( ): itimer_next[ 'sensor_disp_interval'] += SENSOR_DISP_INTERVAL dbg.dbg( ' Wake up time for SENSOR_DISP set to {}'. format( itimer_conv( itimer_next['sensor_disp_interval']))) elif signum == signal.SIGINT: dbg.dbg('Got SIGINT, terminating') sys.stderr.write('\nINFO: SIGINT received\n') cleanup() sys.exit(0) elif signum == signal.SIGTERM: dbg.dbg('Got SIGTERM, terminating') sys.stderr.write('\nINFO: SIGTERM received\n') cleanup() sys.exit(0) elif signum == signal.SIGHUP: dbg.dbg('Got SIGHUP, ignoring') sys.stderr.write('INFO: SIGHUP received\n') else: dbg.dbg( 'Got uncaught signal {}, ignoring'.format(signum)) sys.stderr.write( 'WARNING: Unexpected signal received: {}\n'.format( signum)) # Unexpected event else: dbg.dbg('Unexpected event on fd {}, flags {}'.format( fd, flags)) sys.stderr.write( 'ERROR: Unexpected event on fd {}, flags {}\n'.format( fd, flags))