def TreeToGraph(i, g, root):
'''build a graph from root node via
@param i: node number in this tree
@param g: pydotplus.graphviz.Dot() object
@param root: the root node
@return i: node number after modified
@return g: pydotplus.graphviz.Dot() object after modified
@return g_node: the current root node in graphviz
'''
try:
from pydotplus import graphviz
except ImportError:
print("module pydotplus.graphviz not found")
if root.attr == None:
g_node_label = "Node:%d\n好瓜:%s" % (i, root.label)
else:
g_node_label = "Node:%d\n好瓜%s\nattribute:%s" % (i, root.label,
root.attr)
g_node = i
g.add_node(
graphviz.Node(g_node,
label=g_node_label,
fontname="Microsoft YaHei",
fontsize=10))
for value in list(root.sub_attr):
i, g_child = TreeToGraph(i + 1, g, root.sub_attr[value])
g.add_edge(
graphviz.Edge(g_node,
g_child,
label=value,
fontname="Microsoft YaHei",
fontsize=10))
return i, g_node
def TreeToGraph(i, father_node, g):
"""
给定起始节点的名字i（用数字记录节点名）、节点、和 标签名字
用i+1，和子节点及标签名作为递归输入
返回的是i和子节点的名称
将所有的节点遍历完成后返回
:param i: 为了避免迭代时子节点重新从零开始计，这里传入参数i用来累加迭代
:param node:根节点
:param df:根节点的数据
"""
from pydotplus import graphviz
if father_node.attr == None:
node_label = 'Node: %d\n好瓜: %s' % (i, father_node.label)
else:
node_label = 'Node: %d\n好瓜: %s\n属性: %s' % (i, father_node.label,
father_node.attr)
father_node_name = i
node_graph_obj = graphviz.Node(father_node_name,
label=node_label,
fontname='SimHei') # 创建graphviz.Node对象
g.add_node(node_graph_obj) # 将创建的graphviz节点对象添加到graphviz点图Dot对象
if father_node.attr != None:
for value in father_node.attr_down:
child_node = father_node.attr_down[value]
i, child_node_name = TreeToGraph(i + 1, child_node, g)
g_edge = graphviz.Edge(father_node_name,
child_node_name,
label=value,
fontname='SimHei')
# 创建edge对象，将父节点与子节点进行连接
g.add_edge(g_edge) # 将edge对象加入到点图dot对象中
return i, father_node_name
def _add_pydot_nodes(graph, node_dict, n, ilev, level):
"""
Parameters
----------
graph
node_dict
n
ilev
level
Returns
-------
"""
if ilev == level:
return
if n in node_dict:
return
ttl = os.path.basename(n.name)
pydotnode = pydot.Node(ttl, style="filled", fillcolor="red", label=ttl)
node_dict[n] = pydotnode
graph.add_node(pydotnode)
if len(n.dependencies) > 0:
for m in n.dependencies:
_add_pydot_nodes(graph, node_dict, m, ilev + 1, level)
return
def TreeToGraph(i, g, root):
"""
build a graph from root on
@param i: node number in this tree
@param g: pydotplus.graphviz.Dot() object
@param root: the root node
@return i: node number after modified
@return g: pydotplus.graphviz.Dot() object after modified
@return g_node: the current root node in graphviz
"""
try:
from pydotplus import graphviz
except ImportError:
print("module pydotplus.graphviz not found")
if root.attr == None:
g_node_label = "Node:%d\n好瓜:%s" % (i, root.label)
else:
g_node_label = "Node:%d\n好瓜:%s\n属性:%s" % (i, root.label, root.attr)
g_node = i
g.add_node(graphviz.Node(g_node, label=g_node_label, fontname="FangSong"))
for value in list(root.attr_down):
i, g_child = TreeToGraph(i + 1, g, root.attr_down[value])
g.add_edge(graphviz.Edge(g_node, g_child, label=value, fontname="FangSong"))
return i, g_node
def tree2graph(i, g, root):
'''
build a graph from root
Inputs:
i: node id in this tree
g: pydotplus.graphviz.Dot() object
root: the root node
Outputs:
i: node id after modified
g: pydotplus.graphviz.Dot() object after modified
g_node: the current root node in graphviz
'''
try:
from pydotplus import graphviz
except ImportError:
print("module pydotplus.graphviz not found")
if root.attr == None:
g_node_label = "Node:%d\n好瓜:%s" % (i, root.label)
else:
g_node_label = "Node:%d\n好瓜:%s\n属性:%s" % (i, root.label, root.attr)
g_node = i
g.add_node(graphviz.Node(g_node, label=g_node_label))
for value in sorted(root.branch):
i, g_child = tree2graph(i + 1, g, root.branch[value])
g.add_edge(graphviz.Edge(g_node, g_child, label=value))
return i, g_node
def draw_proxies(self, graph, resolve_dns=False):
method_nodes = {}
drawn_edges = []
for portnum, proxies in sorted(self.ports.items()):
for proxy in proxies:
(method, logic, dst_node, dst_port) = proxy
dst_node.draw(graph, resolve_dns)
mnode_name = 'method_%s' % mk_dot_name('%s_%s' %
(str(self.ip), method))
if mnode_name not in method_nodes:
# Make a new method node
mnode = pd.Node(mnode_name)
mnode.set('shape', 'record')
mnode.set('style', 'rounded')
mnode.set('color', 'gray')
# we use it to track things for us
mnode.logics = [logic]
graph.add_node(mnode)
method_nodes[mnode_name] = mnode
else:
mnode = method_nodes[mnode_name]
if logic not in mnode.logics:
mnode.logics.append(logic)
left_label = '<m_%s>%s' % (method, method)
label_array = []
for logic in mnode.logics:
label_array.append('<l_%s>%s' %
(mk_dot_name(logic), logic))
right_label = '|'.join(label_array)
label = '{%s|{%s}}' % (left_label, right_label)
mnode.set('label', label)
# Draw edge from mother node to this method if not present already
src_from = '%s:p_%s' % (self.nodename, portnum)
src_to = '%s:m_%s' % (mnode_name, mk_dot_name(method))
if (src_from, src_to) not in drawn_edges:
graph.add_edge(pd.Edge(src_from, src_to, dir='none'))
drawn_edges.append((src_from, src_to))
# Draw edge from this logic to the destination node/port
tgt_from = '%s:l_%s' % (mnode_name, mk_dot_name(logic))
if dst_node.cluster and dst_node.cluster.lb_node:
tgt_to = '%s:p_%s' % (dst_node.cluster.lb_node, dst_port)
else:
tgt_to = '%s:p_%s' % (dst_node.nodename, dst_port)
if (tgt_from, tgt_to) not in drawn_edges:
graph.add_edge(pd.Edge(tgt_from, tgt_to, dir='none'))
drawn_edges.append((tgt_from, tgt_to))
def TreeToGraph(root, i, g):
if root.attr == None:
g_node_label = "Node:%d\n好瓜:%s" % (i, root.label)
else:
g_node_label = "Node:%d\n好瓜:%s\n属性:%s\n" % (i, root.label, root.attr)
g_node = i
g.add_node(graphviz.Node(g_node, label=g_node_label))
for value in list(root.attr_down):
i, g_child = TreeToGraph(root.attr_down[value], i+1, g)
g.add_edge(graphviz.Edge(g_node, g_child, label=value))
return i, g_node
def add_pydot_nodes(graph, node_dict, n, ilev, level):
if ilev == level:
return
if n in node_dict:
return
ttl = os.path.basename(n.name)
pydotnode = pydot.Node(ttl, style="filled", fillcolor="red")
node_dict[n] = pydotnode
graph.add_node(pydotnode)
if len(n.dependencies) > 0:
for m in n.dependencies:
add_pydot_nodes(graph, node_dict, m, ilev + 1, level)
return
def make_graph_node(c, p_rowid, show_trust=False):
c.execute(
'''SELECT pub.*,
uid.uiddata
FROM uid JOIN pub
ON uid.pubrowid = pub.rowid
WHERE pub.rowid=? AND uid.is_primary = 1''', (p_rowid, ))
(kid, val, size, algo, cre, exp, trust, uiddata) = c.fetchone()
nodename = 'a_%s' % p_rowid
anode = pd.Node(nodename)
anode.set('shape', 'record')
anode.set('style', 'rounded')
if trust == 'u':
anode.set('color', 'purple')
elif trust == 'f':
anode.set('color', 'red')
elif trust == 'm':
anode.set('color', 'blue')
else:
anode.set('color', 'gray')
uiddata = uiddata.replace('"', '')
name = uiddata.split('<')[0].replace('"', '').strip()
name = name.split('(')[0].strip()
try:
email = uiddata.split('<')[1].replace('>', '').strip()
try:
domain = email.split('@')[1]
show = domain
except IndexError:
show = email
except IndexError:
show = ''
if algo in ALGOS.keys():
keyline = '{%s %s|%s}' % (ALGOS[algo], size, kid)
else:
keyline = '{%s}' % kid
if show_trust:
anode.set(
'label', '{{%s\n%s|{val: %s|tru: %s}}|%s}' %
(name, show, val, trust, keyline))
else:
anode.set('label', '{%s\n%s|%s}' % (name, show, keyline))
return anode
def __fill_graph(self, node, father, branch, g, label_title=None):
if node.attr is None:
if label_title is not None:
title = "{}: {}".format(label_title, node.label)
else:
title = "{}".format(node.label)
else:
title = "{}".format(node.attr)
g_node = graphviz.Node(self.__seq, label=title)
g.add_node(g_node)
if father is not None:
g.add_edge(graphviz.Edge(father, g_node, label=branch))
for val, child in node.branches.items():
self.__seq += 1
self.__fill_graph(child, g_node, val, g, label_title)
def to_pydot(dag, filename='mygraph.png'):
# Create the graph
graph = pydot.Dot(graph_type='digraph')
# Add the nodes
node_dict = {}
for n in dag.nodelist:
pydotnode = pydot.Node(n.name, style="filled", fillcolor="red")
node_dict[n] = pydotnode
graph.add_node(pydotnode)
# Add the edges
for n in dag.nodelist:
for m in n.dependencies:
graph.add_edge(pydot.Edge(node_dict[n], node_dict[m]))
graph.write_png(filename)
return
def TreeToGraph(i, g, root):
try:
from pydotplus import graphviz
except ImportError:
print("module pydotplus.graphviz not found")
if root.attr == None:
g_node_label = "Node:%d\n好瓜:%s" % (i, root.label)
else:
g_node_label = "Node:%d\n好瓜:%s\n属性:%s" % (i, root.label, root.attr)
g_node = i
g.add_node(graphviz.Node(g_node, label=g_node_label, fontname="FangSong"))
for value in list(root.attr_down):
i, g_child = TreeToGraph(i + 1, g, root.attr_down[value])
g.add_edge(graphviz.Edge(g_node, g_child, label=value, fontname="FangSong"))
return i, g_node
def TreeToGraph(i, g, root):
'''
@param i: 树中节点的数目
@param g: pydotplus.graphviz.Dot() object
@param root: 根节点
@return i: node number after modified
@return g: pydotplus.graphviz.Dot() object after modified
@return g_node: the current root node in graphviz
'''
if root.attr == None:
g_node_label = "Node:%d\n好瓜:%s" % (i, root.label)
else:
g_node_label = "Node:%d\n好瓜:%s\n属性:%s" % (i, root.label, root.attr)
g_node = i
g.add_node(graphviz.Node(g_node, label=g_node_label))
for value in list(root.attr_down):
i, g_child = TreeToGraph(i + 1, g, root.attr_down[value])
g.add_edge(graphviz.Edge(g_node, g_child, label=value))
return i, g_node
def to_pydot(dag, filename="mygraph.png"):
"""Create a png file of a Directed Acyclic Graph
Parameters
----------
dag : object
directed acyclic graph
filename : str
path of the graph png
Returns
-------
"""
# evaluate if pydot plus is installed
if pydot is None:
msg = "pydotplus must be installed to use " + "{}".format(
make_plots.__module__ + "." + make_plots.__name__)
raise ModuleNotFoundError(msg)
# Create the graph
graph = pydot.Dot(graph_type="digraph")
# Add the nodes
node_dict = {}
for n in dag.nodelist:
pydotnode = pydot.Node(n.name, style="filled", fillcolor="red")
node_dict[n] = pydotnode
graph.add_node(pydotnode)
# Add the edges
for n in dag.nodelist:
for m in n.dependencies:
graph.add_edge(pydot.Edge(node_dict[n], node_dict[m]))
graph.write_png(filename)
return
def draw(self, graph, resolve_dns=False):
if self.is_on_graph:
return
if self.cluster and self.cluster.lb_node is not None:
# We already drew the LB cluster node
return
gnode = pd.Node(self.nodename)
gnode.set('shape', 'record')
subnet = get_subnet_by_ip(self.ip)
if not subnet:
color = 'gray'
else:
color = subnet.color
gnode.set('color', color)
# make the ports label
# we need to add <p_foo> endpoint parts for each port
pary = []
for portnum in sorted(self.ports.keys()):
try:
service = socket.getservbyport(portnum)
except OSError:
service = 'unknown'
if portnum in self.prodvers and len(self.prodvers[portnum]):
pary.append(
'<p_%s>%s/%s\n[%s]' %
(portnum, portnum, service, self.prodvers[portnum]))
else:
pary.append('<p_%s>%s/%s' % (portnum, portnum, service))
plabel = '%s' % '|'.join(pary)
hlabel = str(self.ip)
if not self.hostname and resolve_dns:
try:
hostname = socket.gethostbyaddr(str(self.ip))[0]
logger.debug('%s -> %s' % (str(self.ip), hostname))
self.hostname = hostname
except socket.herror:
pass
hostname = self.hostname
if self.hostname and self.subnet and len(self.subnet.trimdomain):
hostname = re.sub('\.%s$' % self.subnet.trimdomain, '',
self.hostname)
if hostname:
hlabel = '%s\n\%s' % (self.ip, hostname)
if self.cluster and self.cluster.has_vip(self.ip):
hlabel = '%s\n%s' % ('VIP', hlabel)
if self.cluster and self.cluster.type == 'lb':
# LB clusters replace all nodes with a single one
# to avoid drawing a bajillion lines.
# Did we already make a node for this?
if not self.cluster.lb_node:
hlabel = '|'.join(self.cluster.rips)
label = '{{%s}|{cluster ips:|%s}}' % (plabel, hlabel)
gnode.set('label', label)
self.cluster.lb_node = self.nodename
else:
# on the src node, the ports are on the right
if self.is_src_node:
label = '{%s|{%s}}' % (hlabel, plabel)
gnode.set('label', label)
self.draw_proxies(graph, resolve_dns)
else:
label = '{{%s}|%s}' % (plabel, hlabel)
gnode.set('label', label)
# if we're in a cluster, we'll be adding ourselves to a subgraph instead
if self.cluster is not None:
self.cluster.subgraph.add_node(gnode)
else:
graph.add_node(gnode)
self.is_on_graph = True
