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))
