def loadNodes(self):
self.__logging.info("Start loading units")
try:
raw_stats = self.__session.stat_log()
for raw_node in raw_stats:
bla.add_raw_node(raw_node)
for group_id in bla.all_group_ids():
self.__tq.add_task_in(
get_symm_group_update_task_id(group_id),
get_config_value("symm_group_read_gap", 1),
self.updateSymmGroup,
group_id)
try:
max_group = int(self.__node.meta_session.read(mastermind_max_group_key))
except:
max_group = 0
curr_max_group = max(bla.all_group_ids())
if curr_max_group > max_group:
self.__node.meta_session.write(mastermind_max_group_key, str(curr_max_group))
except Exception as e:
self.__logging.error("Error while loading node stats: %s\n%s" % (str(e), traceback.format_exc()))
finally:
self.__tq.add_task_in("load_nodes", get_config_value("nodes_reload_period", 60), self.loadNodes)
self.__nodeUpdateTimestamps = self.__nodeUpdateTimestamps[1:] + (time.time(),)
bla.setConfigValue("dynamic_too_old_age", time.time() - self.__nodeUpdateTimestamps[0])
def balance(n, request):
global stats, groups, symm_groups
try:
logging.info("----------------------------------------")
logging.info("New request" + str(len(request)))
logging.info(request)
weighted_groups = get_group_weights(n)
target_groups = []
if manifest().get("symmetric_groups", False):
lsymm_groups = weighted_groups[request[0]]
for (gr_list, weight) in lsymm_groups:
logging.info("gr_list: %s %d" % (str(gr_list), request[0]))
grl = {'rating': weight, 'groups': gr_list}
logging.info("grl: %s" % str(grl))
target_groups.append(grl)
logging.info("target_groups: %s" % str(target_groups))
if target_groups:
sorted_groups = sorted(target_groups, key=lambda gr: gr['rating'], reverse=True)[0]
logging.info(sorted_groups)
result = (sorted_groups['groups'], request[1])
else:
result = ([], request[1])
else:
for group_id in bla.all_group_ids():
target_groups.append(bla.get_group(int(group_id)))
sorted_groups = sorted(target_groups, key=lambda gr: gr.freeSpaceInKb(), reverse=True)[:int(request[0])]
logging.info(sorted_groups)
result = ([g.groupId() for g in sorted_groups], request[1])
logging.info("result: %s" % str(result))
return result
except Exception as e:
logging.error("Balancer error: " + str(e) + "\n" + traceback.format_exc())
return {'Balancer error': str(e)}
def get_groups(n):
return bla.all_group_ids()
