def get_services_aggregator(agg_conf): services = {} add_attr = {} add_attr_order = [] added_hosts = [] tmp_add_verb_attr = [] for name, hostname, verb, _attr_values in agg_conf: if hostname not in services: services[hostname] = service(name, hostname) service_obj = services[hostname] attr_values, order = process_service_attr_values(_attr_values) if verb == "add": host = attr_values['host'] if "sets" in attr_values: attr_values['sets'] = attr_values['sets'].replace(host + "/", "") attr_values['host'] = "" if add_attr == attr_values: added_hosts.append(host) else: """ Done with the current 'add' verb. This is true because the query is ordered by the cmd_id. All hosts (specified with the current host) that have the same interval, xprt, port, etc as the current one are found already. """ if len(added_hosts) > 0: added_hosts.sort() add_attr['host'] = osqlite_util.collapse_string(added_hosts) tmp_add_verb_attr.append({'verb': verb, \ 'attr_values': (add_attr, add_attr_order)}) add_attr = attr_values add_attr_order = order added_hosts = [host] else: if len(added_hosts) > 0: added_hosts.sort() add_attr['host'] = osqlite_util.collapse_string(added_hosts) tmp_add_verb_attr.append({'verb': "add", \ 'attr_values': (add_attr, add_attr_order)}) tmp_add_verb_attr.reverse() service_obj.merge_verb_attr(tmp_add_verb_attr) tmp_add_verb_attr = [] add_attr = {} add_attr_order = [] added_hosts = [] if "hosts" in attr_values: value_s = osqlite_util.collapse_string(attr_values['hosts'].split(",")) attr_values['hosts'] = value_s service_obj.add_verb_attr(verb, attr_values, order) return services
def __str__(self): s = INDENT + "template_name: " + self.name + NEWLINE name_s = "" for comp_type in self.component_ordering: ids = self.component[comp_type]['identifier'] names = self.component[comp_type]['name'] id_s = osqlite_util.collapse_string(ids) if len(names) > 0: name_s = osqlite_util.collapse_string(names) s += INDENT + INDENT + "component: " + comp_type + "{" + id_s + "}" + NEWLINE if name_s != "": s += INDENT + INDENT + INDENT + "name: " + name_s + NEWLINE return s
def process_balerd_hosts(s): hosts = s.split(";") names = [] for host in hosts: tmp = host.split(":") names.append(tmp[0]) return ({'names': osqlite_util.collapse_string(names)}, ["names"])
def process_identifier_name_map(identifiers, names): # TODO: call with the sony-test n_names = len(names) n_identifiers = len(identifiers) if (n_names == 0) or (n_identifiers == 0): raise ValueError("Unexpected identifier and name map. " \ "The list of either names or identifiers is empty") if n_names == 1: return (osqlite_util.collapse_string(identifiers), names[0]) # Number of names > 1 if n_names != n_identifiers: error_s = "Number of names and number of identifiers are different. " \ "Identifiers: " + ",".join(identifiers) + ". " \ "Names: " + ",".join(names) raise ValueError("Unexpected identifier and name map. " + error_s) identifiers_s = osqlite_util.collapse_string(identifiers) names_s = osqlite_util.collapse_string(names) if identifiers_s.count("[") > 1: pass return (identifiers_s, names_s)
def _process_event_components(cursor, event): components_text = "" comp_types = {} for comp_id in sorted(event.components.keys()): ctype = event.components[comp_id]['comp_type'] if ctype not in comp_types: comp_types[ctype] = [] comp_types[ctype].append(event.components[comp_id]['identifier']) for ctype in comp_types: cursor.execute("SELECT COUNT(*) FROM components WHERE type = ?", (ctype,)) num = cursor.fetchone()[0] if components_text != "": components_text += "," if num == len(comp_types[ctype]): components_text += ctype + "{*}" else: components_text += ctype + "{" components_text += osqlite_util.collapse_string(comp_types[ctype]) components_text += "}" return components_text
def _get_component_tree_text(comp_tree, comp_id, num_indent): node = comp_tree.get_node_data(comp_id) if node is None: raise OCSqliteError("comp " + str(comp_id) + " not found") comp = node['comp'] leaves = {} leaves_order = [] if comp_tree.is_leaf(comp_id) or node['visited']: ''' If leave, just return the empty string and itself ''' node['visited'] = True return ("", node) else: s = (INDENT * num_indent) + comp.comp_type + "{" + comp.identifier + "}" s += "/" + NEWLINE num_indent += 1 for child in comp_tree.get_children(comp_id): tmp = _get_component_tree_text(comp_tree, child, num_indent) leaf = tmp[1] if leaf is not None: comp = leaf['comp'] if comp.comp_type not in leaves: leaves[comp.comp_type] = [] leaves_order.append(comp.comp_type) if comp.identifier not in leaves[comp.comp_type]: leaves[comp.comp_type].append(comp.identifier) else: s += tmp[0] if len(leaves) > 0: for child_type in leaves_order: s += (INDENT * num_indent) + child_type + \ "{" + osqlite_util.collapse_string(leaves[child_type]) + "}" \ + NEWLINE node['visited'] = True return (s, None)
def get_event_metrics_components_text(cursor, event): metrics_text = "" components_text = "" try: if event.model_id == USER_EVENT_MODEL_ID: components_text = _process_event_components(cursor, event) return (metrics_text, components_text) mname_fmt = {'base': "", 'ext': []} for metric_id in sorted(event.metrics.keys()): mname = event.metrics[metric_id] # Find the name format if 'baler_ptn' in mname: mname_fmt['base'] = '%baler_ptn%' idx = mname.index('#') ext = mname[:idx] elif '#' in mname: idx = mname.index('#') + 1 mname_fmt['base'] = mname[:idx] + "%" ext = mname[idx:] else: mname_fmt['base'] = mname ext = "" if ext not in mname_fmt['ext']: mname_fmt['ext'].append(ext) # Query distinct components collecting the metrics cursor.execute("SELECT COUNT(DISTINCT(comp_id)) FROM metrics " \ "JOIN components WHERE coll_comp = components.name AND " \ "metrics.name LIKE '" + mname_fmt['base'] + "' ORDER BY comp_id") exp_num = cursor.fetchone() if exp_num is None: raise Exception(event.name + ": components collecting the metrics not found") exp_num = exp_num[0] if len(event.components) == exp_num: components_text = "*" else: components_text = _process_event_components(cursor, event) # Find the total number of metrics with the name format cursor.execute("SELECT COUNT(DISTINCT(name)) FROM metrics " \ "WHERE name LIKE '" + mname_fmt['base'] + "'") exp_count = cursor.fetchone() if exp_count is None: raise OCSqliteError(event.name + ": metric " + mname_fmt + " not found") exp_count = exp_count[0] if len(mname_fmt['ext']) == exp_count: if 'baler_ptn' in mname_fmt['base']: metrics_text = "[*]#baler_ptn" else: metrics_text = mname_fmt['base'].replace("%", "[*]") else: mname_fmt['base'] = mname_fmt['base'].replace("%", "") if 'baler_ptn' in mname_fmt['base']: full_name_s = [s + "#" + mname_fmt['base'] for s in sorted(mname_fmt['ext'])] metrics_text = osqlite_util.collapse_string(full_name_s) else: full_name_s = [mname_fmt['base'] + s for s in sorted(mname_fmt['ext'])] metrics_text = osqlite_util.collapse_string(full_name_s) return (metrics_text, components_text) except Exception: raise
def _process_components_text(self): if len(self.components) == 0: return "" comps = sorted(self.components.keys()) comps = map(str, comps) return osqlite_util.collapse_string(comps)
def _process_metric_names(self): tmp = [self.metrics[x] for x in sorted(self.metrics.keys())] return osqlite_util.collapse_string(tmp)