def test_filter_nodes_env(self):
"""Should filter nodes belonging to a given environment"""
data = chef.filter_nodes(chef.get_nodes_extended(), 'production')
self.assertEqual(len(data), 8)
data = chef.filter_nodes(chef.get_nodes_extended(), 'staging')
self.assertEqual(len(data), 1)
data = chef.filter_nodes(chef.get_nodes_extended(), 'non_existing_env')
self.assertEqual(len(data), 0)
def test_filter_nodes_virt(self):
"""Should filter nodes acording to their virt value"""
total_guests = 7
total_hosts = 3
data = chef.filter_nodes(chef.get_nodes_extended(), virt_roles='guest')
self.assertEqual(len(data), total_guests)
data = chef.filter_nodes(chef.get_nodes_extended(), virt_roles='host')
self.assertEqual(len(data), total_hosts)
data = chef.filter_nodes(chef.get_nodes_extended(),
virt_roles='host,guest')
self.assertEqual(len(data), TOTAL_NODES)
def test_filter_nodes_combined(self):
"""Should filter nodes acording to their virt value"""
data = chef.filter_nodes(chef.get_nodes_extended(),
env='production',
roles='loadbalancer,webserver',
virt_roles='guest')
self.assertEqual(len(data), 3)
self.assertEqual(data[0]['name'], "testnode1")
self.assertEqual(data[1]['name'], "testnode2")
self.assertEqual(data[2]['name'], "testnode7")
data = chef.filter_nodes(chef.get_nodes_extended(), env='staging',
roles='webserver', virt_roles='guest')
self.assertEqual(len(data), 1)
self.assertEqual(data[0]['name'], "testnode4")
def _get_data(request, env, roles, virt, group_by_host=False):
"""Returns processed repository data, filtering nodes based on given args
"""
roles = [role for role in roles.split(',') if role]
data = {
'filter_env': env, 'filter_roles': roles, 'filter_virt': virt,
'show_list': SHOW_LIST_VIEW, 'show_virt': SHOW_VIRT_VIEW,
'show_graph': SHOW_GRAPH_VIEW, 'show_links': SHOW_LINKS,
'query_string': request.META['QUERY_STRING']
}
data['roles'] = get_roles()
roles_groups = get_role_groups(data['roles'])
data['roles_groups'] = roles_groups
data['virt_roles'] = ['host', 'guest']
# Get environments before we filter nodes
data['nodes'] = get_nodes()
data['nodes_extended'] = get_nodes_extended(data['nodes'])
data['environments'] = get_environments(data['nodes_extended'])
if group_by_host:
data['nodes_extended'] = group_nodes_by_host(data['nodes_extended'],
roles=data['filter_roles'],
env=data['filter_env'])
elif data['filter_env'] or data['filter_roles'] or data['filter_virt']:
data['nodes_extended'] = filter_nodes(data['nodes_extended'],
data['filter_env'],
data['filter_roles'],
data['filter_virt'])
inject_plugin_data(data['nodes_extended'])
if not data['nodes_extended']:
add_message(request, WARNING,
"There are no nodes that fit the supplied criteria.")
return data
def test_build_links_all(self):
"""Should generate all links when nodes define connections"""
data = chef.filter_nodes(self.nodes, 'production', virt_roles='guest')
links = graphs._build_links(data)
expected = {
'testnode1': {'role_prefix': 'loadbalancer'},
'testnode2': {
'role_prefix': 'webserver',
'client_nodes': [('testnode1', 'apache2')]
},
'testnode3.mydomain.com': {
'role_prefix': 'dbserver',
'client_nodes': [
('testnode2', 'mysql'), ('testnode7', 'mysql')
]
},
'testnode7': {
'role_prefix': 'webserver',
'client_nodes': [('testnode1', 'apache2')]
},
'testnode8': {
'role_prefix': 'worker',
'needs_nodes': [
('testnode3.mydomain.com', 'mysql')
]
}
}
self.assertEqual(links, expected)
def _get_data(request, env, roles, virt, group_by_host=False):
"""Returns processed repository data, filtering nodes based on given args
"""
data = {'filter_env': env, 'filter_roles': roles, 'filter_virt': virt}
data['roles'] = get_roles()
roles_groups = get_role_groups(data['roles'])
data['roles_groups'] = roles_groups
data['virt_roles'] = ['host', 'guest']
# Get environments before we filter nodes
data['nodes'] = get_nodes()
data['nodes_extended'] = get_nodes_extended(data['nodes'])
data['environments'] = get_environments(data['nodes_extended'])
roles_to_filter = '' if group_by_host else data['filter_roles']
if data['filter_env'] or roles_to_filter or data['filter_virt']:
data['nodes_extended'] = filter_nodes(data['nodes_extended'],
data['filter_env'],
roles_to_filter,
data['filter_virt'])
if group_by_host:
data['nodes_extended'] = group_nodes_by_host(
data['nodes_extended'], roles=data['filter_roles'])
inject_plugin_data(data['nodes_extended'])
if not data['nodes_extended']:
add_message(request, WARNING,
"There are no nodes that fit the supplied criteria.")
return data
def test_build_links_all(self):
"""Should generate all links when nodes define connections"""
data = chef.filter_nodes(
self.nodes, 'production')
links = graphs._build_links(data)
expected = {
'testnode2': {'client_nodes': [('testnode1', 'apache2')]},
'testnode3.mydomain.com': {
'client_nodes': [
('testnode2', 'mysql'), ('testnode7', 'mysql')
]
},
'testnode5': {
'client_nodes': [
('testnode2', 'mysql'), ('testnode7', 'mysql')
]
},
'testnode7': {'client_nodes': [('testnode1', 'apache2')]},
'testnode8': {
'needs_nodes': [
('testnode3.mydomain.com', 'mysql'), ('testnode5', 'mysql')
]
}
}
self.assertEqual(links, expected)
def test_generate_empty_graph(self):
"""Should generate an empty graph when no nodes are given"""
data = chef.filter_nodes(self.nodes, "badenv")
graphs.generate_node_map(data, self.roles)
self.assertTrue(os.path.exists(self.filepath))
size = os.path.getsize(self.filepath)
max_size = 650
self.assertTrue(size < max_size, "Size greater than {0}: {1}".format(max_size, size))
def test_build_links_needs_nodes(self):
"""Should generate links when nodes have needs_nodes set"""
data = chef.filter_nodes(self.nodes, "production", "dbserver,worker", "guest")
links = graphs._build_links(data)
expected = {
"testnode3.mydomain.com": {"role_prefix": "dbserver"},
"testnode8": {"role_prefix": "worker", "needs_nodes": [("testnode3.mydomain.com", "mysql")]},
}
self.assertEqual(links, expected)
def test_get_role_relations(self):
"""Should return role dependencies when roles with relationships are given"""
prod_nodes = chef.filter_nodes(self.nodes, "production")
extra_roles = graphs.get_role_relations("production", "dbserver", prod_nodes)
self.assertEqual(extra_roles, ["webserver", "worker"])
extra_roles = graphs.get_role_relations("production", "loadbalancer", prod_nodes)
self.assertEqual(extra_roles, ["webserver"])
extra_roles = graphs.get_role_relations("production", "worker", prod_nodes)
self.assertEqual(extra_roles, ["dbserver"])
extra_roles = graphs.get_role_relations("production", "webserver", prod_nodes)
self.assertEqual(extra_roles, ["dbserver", "loadbalancer"])
def get_nodes(request):
"""Returns node files. If 'extended' is given, the extended version is
returned
"""
if request.GET.get('extended'):
data = chef.get_nodes_extended()
else:
data = chef.get_nodes()
data = chef.filter_nodes(data, request.GET.get('env'))
return HttpResponse(json.dumps(data), content_type="application/json")
def test_graph_timeout(self):
"""Should display an error message when GraphViz excesses the timeout
"""
error_msg = "Unable to draw graph, timeout exceeded"
data = chef.filter_nodes(self.nodes, "production")
with patch("kitchen.dashboard.graphs.GraphThread.isAlive", return_value=True):
with patch("kitchen.dashboard.graphs.GraphThread.kill", return_value=True):
success, msg = graphs.generate_node_map(data, self.roles)
self.assertFalse(success)
self.assertTrue(error_msg in msg)
def test_filter_nodes_roles(self):
"""Should filter nodes acording to their virt value"""
data = chef.filter_nodes(chef.get_nodes_extended(),
roles='dbserver')
self.assertEqual(len(data), 2)
self.assertEqual(data[0]['name'], "testnode3.mydomain.com")
data = chef.filter_nodes(chef.get_nodes_extended(),
roles='loadbalancer')
self.assertEqual(len(data), 1)
self.assertEqual(data[0]['name'], "testnode1")
data = chef.filter_nodes(chef.get_nodes_extended(),
roles='webserver')
self.assertEqual(len(data), 4)
self.assertEqual(data[0]['name'], "testnode2")
data = chef.filter_nodes(chef.get_nodes_extended(),
roles='webserver,dbserver')
self.assertEqual(len(data), 6)
self.assertEqual(data[1]['name'], "testnode3.mydomain.com")
def test_build_links_needs_nodes(self):
"""Should generate links when nodes have needs_nodes set"""
data = chef.filter_nodes(
self.nodes, 'production', 'dbserver,worker')
links = graphs._build_links(data)
expected = {
'testnode8': {
'needs_nodes': [
('testnode3.mydomain.com', 'mysql'), ('testnode5', 'mysql')
]
}
}
self.assertEqual(links, expected)
def test_generate_small_graph(self):
"""Should generate a graph when some nodes are given"""
data = chef.filter_nodes(self.nodes, 'staging', virt_roles='guest')
graphs.generate_node_map(data, self.roles)
self.assertTrue(os.path.exists(self.filepath))
size = os.path.getsize(self.filepath)
#min_size = 3000 # png
#max_size = 4000 # png
min_size = 1000 # svg
max_size = 1500 # svg
self.assertTrue(size > min_size and size < max_size,
"Size not between {0} and {1}: {2}".format(
min_size, max_size, size))
def test_generate_connected_graph(self):
"""Should generate a connected graph when connected nodes are given"""
data = chef.filter_nodes(self.nodes, 'production', virt_roles='guest')
graphs.generate_node_map(data, self.roles)
self.assertTrue(os.path.exists(self.filepath))
size = os.path.getsize(self.filepath)
# Graph size with connections
#min_size = 20000 # png
#max_size = 23000 # png
min_size = 5000 # svg
max_size = 7000 # svg
self.assertTrue(size > min_size and size < max_size,
"Size not between {0} and {1}: {2}".format(
min_size, max_size, size))
def test_get_role_relations(self):
"""Should return role dependencies when roles with relationships are given"""
prod_nodes = chef.filter_nodes(self.nodes, 'production')
extra_roles = graphs.get_role_relations('production', 'dbserver',
prod_nodes)
self.assertEqual(extra_roles, ['webserver', 'worker'])
extra_roles = graphs.get_role_relations('production', 'loadbalancer',
prod_nodes)
self.assertEqual(extra_roles, ['webserver'])
extra_roles = graphs.get_role_relations('production', 'worker',
prod_nodes)
self.assertEqual(extra_roles, ['dbserver'])
extra_roles = graphs.get_role_relations('production', 'webserver',
prod_nodes)
self.assertEqual(extra_roles, ['dbserver', 'loadbalancer'])
def test_build_links_client_nodes(self):
"""Should generate links when nodes have client_nodes set"""
data = chef.filter_nodes(self.nodes, "production", "loadbalancer,webserver,dbserver", "guest")
links = graphs._build_links(data)
self.maxDiff = None
expected = {
"testnode1": {"role_prefix": "loadbalancer"},
"testnode2": {"role_prefix": "webserver", "client_nodes": [("testnode1", "apache2")]},
"testnode3.mydomain.com": {
"role_prefix": "dbserver",
"client_nodes": [("testnode2", "mysql"), ("testnode7", "mysql")],
},
"testnode7": {"role_prefix": "webserver", "client_nodes": [("testnode1", "apache2")]},
}
self.assertEqual(links, expected)
def test_build_links_all(self):
"""Should generate all links when nodes define connections"""
data = chef.filter_nodes(self.nodes, "production", virt_roles="guest")
links = graphs._build_links(data)
expected = {
"testnode1": {"role_prefix": "loadbalancer"},
"testnode2": {"role_prefix": "webserver", "client_nodes": [("testnode1", "apache2")]},
"testnode3.mydomain.com": {
"role_prefix": "dbserver",
"client_nodes": [("testnode2", "mysql"), ("testnode7", "mysql")],
},
"testnode7": {"role_prefix": "webserver", "client_nodes": [("testnode1", "apache2")]},
"testnode8": {"role_prefix": "worker", "needs_nodes": [("testnode3.mydomain.com", "mysql")]},
}
self.assertEqual(links, expected)
def graph(request):
"""Graph view where users can visualize graphs of their nodes
generated using Graphviz open source graph visualization library
"""
_show_repo_sync_date(request)
data = {}
options = _set_options(request.GET.get('options'))
env_filter = request.GET.get('env', REPO['DEFAULT_ENV'])
roles_filter = request.GET.get('roles', '')
env_nodes = []
try:
data = _get_data(request, env_filter, '', 'guest')
except RepoError as e:
add_message(request, ERROR, str(e))
else:
if env_filter:
env_nodes = data['nodes_extended']
if roles_filter:
# Filter the env nodes by role
data['nodes_extended'] = filter_nodes(data['nodes_extended'],
roles=roles_filter)
data['filter_roles'] = roles_filter
success, msg = graphs.generate_node_map(
data['nodes_extended'], data.get('roles', []),
'show_hostnames' in options)
data['draw_graph'] = success
if not success:
add_message(request, ERROR, msg)
else:
data['related_roles'] = graphs.get_role_relations(env_filter,
roles_filter,
env_nodes)
else:
add_message(request, WARNING, "Please select an environment")
data['show_hostnames'] = 'show_hostnames' in options
data['query_string'] = request.META['QUERY_STRING']
return render_to_response('graph.html',
data, context_instance=RequestContext(request))
def test_build_links_client_nodes(self):
"""Should generate links when nodes have client_nodes set"""
data = chef.filter_nodes(
self.nodes, 'production', 'loadbalancer,webserver,dbserver')
links = graphs._build_links(data)
self.maxDiff = None
expected = {
'testnode2': {'client_nodes': [('testnode1', 'apache2')]},
'testnode3.mydomain.com': {
'client_nodes': [
('testnode2', 'mysql'), ('testnode7', 'mysql')
]
},
'testnode5': {
'client_nodes': [
('testnode2', 'mysql'), ('testnode7', 'mysql')
]
},
'testnode7': {'client_nodes': [('testnode1', 'apache2')]}
}
self.assertEqual(links, expected)
def test_filter_nodes_all(self):
"""Should return all nodes when empty filters are are given"""
data = chef.filter_nodes(chef.get_nodes_extended(), '', '')
self.assertEqual(len(data), TOTAL_NODES)
def test_get_role_relations_empty_when_no_roles(self):
"""Should obtain no roles when a role filter list is not given"""
prod_nodes = chef.filter_nodes(self.nodes, 'staging')
extra_roles = graphs.get_role_relations('production', '', prod_nodes)
self.assertEqual(extra_roles, [])
def test_get_role_relations_empty_when_roles(self):
"""Should obtain no roles when the given roles have no extra relationships"""
stag_nodes = chef.filter_nodes(self.nodes, 'staging')
extra_roles = graphs.get_role_relations('staging', 'webserver',
stag_nodes)
self.assertEqual(extra_roles, [])
def test_build_links_empty(self):
"""Should not generate links when nodes do not have any defined"""
data = chef.filter_nodes(self.nodes, "staging", virt_roles="guest")
links = graphs._build_links(data)
expected = {"testnode4": {"role_prefix": "webserver"}}
self.assertEqual(links, expected)
def test_build_links_empty(self):
"""Should not generate links when nodes do not have any defined"""
data = chef.filter_nodes(self.nodes, 'staging', virt_roles='guest')
links = graphs._build_links(data)
expected = {'testnode4': {'role_prefix': 'webserver'}}
self.assertEqual(links, expected)
def test_build_links_empty(self):
"""Should not generate links when nodes do not have any defined"""
data = chef.filter_nodes(self.nodes, 'staging', virt_roles='guest')
links = graphs._build_links(data)
self.assertEqual(links, {})
