def get_stopped_processes(self):
base_tups = extract_prog_tuples(parse_content(self.get_base_conf()))
state_tups = extract_prog_tuples(parse_content(self.get_state_conf()))
base_progs = set(ele[0] for ele in base_tups)
state_progs = set(ele[0] for ele in state_tups)
stopped_progs = (base_progs - state_progs)
base_conf = extract_programs(parse_content(self.get_base_conf()))
out = []
for (name, body) in base_conf.items():
if name in stopped_progs:
body['name'] = name
out.append(body)
return out
def _distribute(self, work, toolchains):
# Distribute conf across toolchains
assigned_work = distribute_work(work, toolchains)
for (toolchain, awork) in assigned_work.items():
conf = self.interpolate_vars_in_conf(
unparse(build_conf(awork, parse_content(work))))
self.zk.set(self.path.toolchain(toolchain), conf)
def get_previous_program_state(self, program_name):
# Try getting program from backup state
bkp_conf_tuples = extract_prog_tuples(
parse_content(self.eye.get_bkp_conf()))
try:
program_tuple = next(ele for ele in bkp_conf_tuples
if ele[0] == program_name)
except StopIteration:
# Try getting program from base conf
base_conf_tuples = extract_prog_tuples(
parse_content(self.eye.get_base_conf()))
try:
program_tuple = next(ele for ele in base_conf_tuples
if ele[0] == program_name)
except StopIteration:
return None
return program_tuple
def distribute_work(conf, toolchains):
logger.info('distributing work across toolchains')
conf = parse_content(conf)
prog_tuples = extract_prog_tuples(conf)
work_splits = split_work(prog_tuples, len(toolchains))
assigned = {}
for (tc, split) in zip(toolchains, work_splits):
assigned[tc] = split
return assigned
def start_program(self, program_name):
prog_tuples = extract_prog_tuples(
parse_content(self.eye.get_state_conf()))
has_program = any(ele for ele in prog_tuples if ele[0] == program_name)
if has_program:
logger.info('Already contains program')
return False
program_tuple = self.get_previous_program_state(program_name)
if program_tuple is None:
logger.info('Program does not exist')
return False
# Program did not exist, let's add it now
# Note: We set numprocs to one while adding
prog_tuples.append(program_tuple)
# Update conf and distribute
self.eye.set_state_conf(
unparse(
build_conf(prog_tuples,
parse_content(self.eye.get_base_conf()))))
return True
def decrease_procs(self, program_name, factor=1):
logger.info('Decreasing procs')
def subtractor(x):
return x - factor
new_conf = manipulate_numprocs(
parse_content(self.eye.get_state_conf()), program_name, subtractor)
# Simply set the conf to trigger a distribute and sync
self.eye.set_state_conf(new_conf)
return True
def list_processes(self):
# Build list of processes for each orc
procs = []
for orc in self.list_orcs():
procs.extend(self.list_processes_for_orc(orc))
# Remap tuples with program body
parsed = parse_content(self.get_state_conf())
out = {}
for proc in procs:
out[proc[0]] = extract_section(parsed,
section_from_program(proc[0]))
return out
def on_base_conf_change(self, data, stat, event):
if event and event.type == EventType.CHANGED:
logger.info('Handling base conf change')
state_programs = {
name: (numprocs, weight)
for name, numprocs, weight in extract_prog_tuples(
parse_content(self.get_state_conf()))
}
base_conf = parse_content(data)
base_tuples = extract_prog_tuples(base_conf)
# Rebuild state conf
prog_tuples = []
for (program_name, numprocs, weight) in base_tuples:
tup = (program_name, )
if program_name in state_programs:
tup += state_programs[program_name]
else:
tup += (numprocs, weight)
prog_tuples.append(tup)
# Trigger distribute
state_conf = unparse(build_conf(prog_tuples, base_conf))
self.set_state_conf(state_conf)
def stop_program(self, program_name):
logger.info('Stopping program')
conf = parse_content(self.eye.get_state_conf())
# Check if program exists
prog_tuples = extract_prog_tuples(conf)
for (pos, (prog_name, _, _)) in enumerate(prog_tuples):
if prog_name == program_name:
del prog_tuples[pos]
break
else:
logger.info('Program is either already stopped/not defined')
return False
# Backup state first to hold nummprocs of program
self.eye.backup_state()
self.eye.set_state_conf(unparse(build_conf(prog_tuples, conf)))
return True
def list_processes_for_orc(self, orc):
return extract_prog_tuples(
parse_content(self.zk.get(self.path.toolchain(orc))[0]))
