def get_group_weights(n):
try:
size_to_sgs = {}
(good, bad) = bla.filter_symm_groups()
all_symm_groups = list(good) + list(bad)
all_symm_group_objects = []
for tuple_symm_group in all_symm_groups:
symm_group = bla.SymmGroup(tuple_symm_group)
sized_symm_groups = size_to_sgs.setdefault(len(tuple_symm_group), [])
sized_symm_groups.append(symm_group)
all_symm_group_objects.append(symm_group)
logging.info(str(symm_group))
result = {}
for size in size_to_sgs:
(group_weights, info) = balancelogic.rawBalance(all_symm_group_objects, bla.getConfig(), bla.GroupSizeEquals(size))
result[size] = [item for item in group_weights.items()]
logging.info("Cluster info: " + str(info))
logging.info(str(result))
return result
except Exception as e:
logging.error("Balancelogic error: " + str(e) + "\n" + traceback.format_exc())
return {'Balancelogic error': str(e)}
def repair_groups(n, request):
global stats, groups, symm_groups, bad_groups
try:
logging.info("----------------------------------------")
logging.info("New repair groups request: " + str(request))
logging.info(request)
group_id = int(request)
(good_symm_groups, bad_symm_groups) = bla.filter_symm_groups(group_id)
if good_symm_groups:
logging.error("Balancer error: cannot repair, group %d is in couple %s" % (group_id, str(good_symm_groups[0])))
return {"Balancer error" : "cannot repair, group %d is in couple %s" % (group_id, str(good_symm_groups[0]))}
if not bad_symm_groups:
logging.error("Balancer error: cannot repair, group %d is not a member of any couple" % group_id)
return {"Balancer error" : "cannot repair, group %d is not a member of any couple" % group_id}
if len(bad_symm_groups) > 1:
logging.error("Balancer error: cannot repair, group %d is a member of several couples: %s" % (group_id, str(bad_symm_groups)))
return {"Balancer error" : "cannot repair, group %d is a member of several couples: %s" % (group_id, str(bad_symm_groups))}
couple = list(bad_symm_groups)[0]
(good, bad) = make_symm_group(n, couple)
if bad:
raise bad[1]
return {"message": "Successfully repaired couple", 'couple': couple}
except Exception as e:
logging.error("Balancer error: " + str(e) + "\n" + traceback.format_exc())
return {'Balancer error': str(e)}
def get_bad_groups(n):
if manifest().get("symmetric_groups", False):
(good_symm_groups, bad_symm_groups) = bla.filter_symm_groups()
result = list(bad_symm_groups)
logging.info("bad_symm_groups: " + str(result))
return result
else:
return None
def break_couple(n, request):
try:
logging.info("----------------------------------------")
logging.info("New break couple request: " + str(request))
logging.info(request)
(good_symm_groups, bad_symm_groups) = bla.filter_symm_groups()
groups = set([int(g) for g in request[0]])
sorted_groups = list(groups)
sorted_groups.sort()
confirm = request[1]
logging.info("groups: %s; confirmation: \"%s\"" % (sorted_groups, confirm))
for symm_group in good_symm_groups:
if set(symm_group) == groups:
correct_confirm = "Yes, I want to break good couple " + ':'.join([str(g) for g in request[0]])
if confirm != correct_confirm:
raise Exception('Incorrect confirmation string')
kill_symm_group(n, sorted_groups)
return True
for symm_group in bad_symm_groups:
if set(symm_group) == groups:
correct_confirm = "Yes, I want to break bad couple " + ':'.join([str(g) for g in request[0]])
if confirm != correct_confirm:
raise Exception('Incorrect confirmation string')
kill_symm_group(n, sorted_groups)
return True
raise Exception("No group found")
except Exception as e:
logging.error("Balancer error: " + str(e) + "\n" + traceback.format_exc())
return {'Balancer error': str(e)}
