def create_config_set(request):
logger.debug('---- topology create_config_set ----')
required_fields = set(['name', 'description', 'topoId'])
if not required_fields.issubset(request.POST):
return render(request, 'ajax/ajaxError.html', {'error': "Invalid Parameters in POST"})
topology_id = request.POST["topoId"]
name = request.POST["name"]
description = request.POST["description"]
topology = get_object_or_404(Topology, pk=topology_id)
try:
# let's parse the json and convert to simple lists and dicts
config = wistarUtils.load_config_from_topology_json(topology.json, topology_id)
except Exception as e:
return render(request, 'ajax/ajaxError.html', {'error': str(e)})
c = ConfigSet(name=name, description=description, topology=topology)
c.save()
for device in config["devices"]:
if device["type"] == "junos_vmx" or device["type"] == "junos_vsrx":
try:
device_config = junosUtils.get_config(device["ip"], device["password"])
cfg = Config(ip=device["ip"], name=device["name"], password=device["password"],
deviceConfig=device_config, configSet=c)
cfg.save()
except Exception as e:
logger.error('exception: %s' % e)
logger.debug("Could not connect to " + device["ip"], e)
return HttpResponseRedirect('/topologies/' + topology_id + '/')
def export_as_heat_template(request, topology_id):
"""
:param request: Django request
:param topology_id: id of the topology to export
:return: renders the heat template
"""
logger.debug('---- topology export heat ----')
try:
topology = Topology.objects.get(pk=topology_id)
except ObjectDoesNotExist:
logger.error('topology id %s was not found!' % topology_id)
return render(request, 'error.html', {'error': "Topology not found!"})
try:
# let's parse the json and convert to simple lists and dicts
config = wistarUtils.load_config_from_topology_json(topology.json, topology_id)
heat_template = wistarUtils.get_heat_json_from_topology_config(config)
heat_template_object = json.loads(heat_template)
heat_template_yaml = yaml.safe_dump(heat_template_object)
return HttpResponse(heat_template_yaml, content_type="text/plain")
except Exception as e:
logger.debug("Caught Exception in deploy heat")
logger.error('exception: %s' % e)
return render(request, 'error.html', {'error': str(e)})
def export_as_parameterized_heat_template(request, topology_id):
"""
Same as exporting raw heat, but include parameters for things like public network, mgmt network,
topo_name, and a count / index parameter. This is useful when generating heat templates for consumption
by some other tool
:param request: Django request
:param topology_id: id of the topology to export
:return: renders the heat template
"""
logger.debug('---- topology export parameterized heat ----')
try:
topology = Topology.objects.get(pk=topology_id)
except ObjectDoesNotExist:
logger.error('topology id %s was not found!' % topology_id)
return render(request, 'error.html', {'error': "Topology not found!"})
try:
# let's parse the json and convert to simple lists and dicts
config = wistarUtils.load_config_from_topology_json(topology.json, topology_id)
heat_template = wistarUtils.get_heat_json_from_topology_config(config, parameterize=True)
heat_template_object = json.loads(heat_template)
heat_template_yaml = yaml.safe_dump(heat_template_object).replace('\'{', '{').replace('}\'', '}')
return HttpResponse(heat_template_yaml, content_type="text/plain")
except Exception as e:
logger.debug("Caught Exception in deploy heat")
logger.error('exception: %s' % e)
err = traceback.format_exc()
logger.debug(err)
logger.debug(e)
return render(request, 'error.html', {'error': str(err)})
def start_topology(request):
logger.debug("---- start_topology ---- ")
json_string = request.body
json_body = json.loads(json_string)
try:
if "name" in json_body[0]:
topology_name = json_body[0]["name"]
# get the topology by name
topology = Topology.objects.get(name=topology_name)
domain_list = libvirtUtils.get_domains_for_topology(
"t" + str(topology.id) + "_")
if len(domain_list) == 0:
# it has not yet been deployed!
logger.debug("not yet deployed!")
# let's parse the json and convert to simple lists and dicts
config = wistarUtils.load_config_from_topology_json(
topology.json, topology.id)
if config is None:
return apiUtils(
False,
"Could not load config for topology: %s" % topology.id)
logger.debug("Deploying to hypervisor now")
# FIXME - should this be pushed into another module?
av.inline_deploy_topology(config)
# now, topology should be deployed and ready to go!
network_list = libvirtUtils.get_networks_for_topology(
"t" + str(topology.id) + "_")
domain_list = libvirtUtils.get_domains_for_topology(
"t" + str(topology.id) + "_")
for network in network_list:
logger.debug("starting network: %s" % network["name"])
libvirtUtils.start_network(network["name"])
time.sleep(.5)
for domain in domain_list:
# no sleep time? Just go ahead and melt the disks!
time.sleep(.5)
logger.debug("starting domain: %s" % domain["uuid"])
libvirtUtils.start_domain(domain["uuid"])
return apiUtils.return_json(True,
'Topology started!',
topology_id=topology.id)
except Topology.DoesNotExist:
return apiUtils.return_json(False, 'Topology Does not Exist')
except Exception as ex:
logger.debug(str(ex))
return apiUtils.return_json(False, 'Could not start topology!')
def launch(request, topology_id):
logger.debug('---- topology launch ----')
try:
topology = Topology.objects.get(pk=topology_id)
except ObjectDoesNotExist as ex:
logger.debug(ex)
return render(request, 'error.html', {'error': "Topology not found!"})
if configuration.deployment_backend == 'openstack':
ret = av.deploy_stack(request, topology_id)
if ret is not None:
inventory = wistarUtils.get_topology_inventory(topology)
wistarUtils.send_new_topology_event(inventory)
try:
# let's parse the json and convert to simple lists and dicts
config = wistarUtils.load_config_from_topology_json(topology.json, topology_id)
logger.debug("Deploying topology: %s" % topology_id)
# this is a hack - inline deploy should be moved elsewhere
# but the right structure isn't really there for a middle layer other
# than utility and view layers ... unless I want to mix utility libs
av.inline_deploy_topology(config)
inventory = wistarUtils.get_topology_inventory(topology)
wistarUtils.send_new_topology_event(inventory)
except Exception as e:
logger.error('exception: %s' % e)
return render(request, 'error.html', {'error': str(e)})
if configuration.deployment_backend != 'kvm':
# only continue in kvm case, openstack will start instances for us on deployment
return
domain_list = libvirtUtils.get_domains_for_topology("t%s_" % topology_id)
network_list = []
if osUtils.check_is_linux():
network_list = libvirtUtils.get_networks_for_topology("t%s_" % topology_id)
for network in network_list:
logger.debug("Starting network: " + network["name"])
if libvirtUtils.start_network(network["name"]):
time.sleep(1)
else:
return render(request, 'error.html', {'error': "Could not start network: " + network["name"]})
num_domains = len(domain_list)
iter_counter = 1
for domain in domain_list:
logger.debug("Starting domain " + domain["name"])
if libvirtUtils.start_domain(domain["uuid"]):
if iter_counter < num_domains:
time.sleep(1)
iter_counter += 1
else:
return render(request, 'error.html', {'error': "Could not start domain: " + domain["name"]})
logger.debug("All domains started")
messages.info(request, 'Topology %s launched successfully' % topology.name)
return HttpResponseRedirect('/topologies/')
def redeploy_topology(request):
required_fields = set(['json', 'topologyId'])
if not required_fields.issubset(request.POST):
return render(request, 'ajax/ajaxError.html',
{'error': "No Topology Id in request"})
topology_id = request.POST['topologyId']
j = request.POST['json']
try:
topo = Topology.objects.get(pk=topology_id)
topo.json = j
topo.save()
except ObjectDoesNotExist:
return render(request, 'ajax/ajaxError.html',
{'error': "Topology doesn't exist"})
try:
domains = libvirtUtils.get_domains_for_topology(topology_id)
config = wistarUtils.load_config_from_topology_json(
topo.json, topology_id)
logger.debug('checking for orphaned domains first')
# find domains we no longer need
for d in domains:
logger.debug('checking domain: %s' % d['name'])
found = False
for config_device in config["devices"]:
if config_device['name'] == d['name']:
found = True
continue
if not found:
logger.info("undefine domain: " + d["name"])
source_file = libvirtUtils.get_image_for_domain(d["uuid"])
if libvirtUtils.undefine_domain(d["uuid"]):
if source_file is not None:
osUtils.remove_instance(source_file)
osUtils.remove_cloud_init_seed_dir_for_domain(d['name'])
except Exception as e:
logger.debug("Caught Exception in redeploy")
logger.debug(str(e))
return render(request, 'ajax/ajaxError.html', {'error': str(e)})
# forward onto deploy topo
try:
inline_deploy_topology(config)
inventory = wistarUtils.get_topology_inventory(topo)
wistarUtils.send_new_topology_event(inventory)
except Exception as e:
logger.debug("Caught Exception in inline_deploy")
logger.debug(str(e))
return render(request, 'ajax/ajaxError.html', {'error': str(e)})
return refresh_deployment_status(request)
def deploy_stack(request, topology_id):
"""
:param request: Django request
:param topology_id: id of the topology to export
:return: renders the heat template
"""
try:
topology = Topology.objects.get(pk=topology_id)
except ObjectDoesNotExist:
return render(request, 'error.html', {'error': "Topology not found!"})
try:
# generate a stack name
# FIXME should add a check to verify this is a unique name
stack_name = topology.name.replace(' ', '_')
# let's parse the json and convert to simple lists and dicts
logger.debug("loading config")
config = wistarUtils.load_config_from_topology_json(
topology.json, topology_id)
logger.debug("Config is loaded")
heat_template = wistarUtils.get_heat_json_from_topology_config(
config, parameterize=False)
logger.debug("heat template created")
if not openstackUtils.connect_to_openstack():
return render(request, 'error.html',
{'error': "Could not connect to Openstack"})
# get the tenant_id of the desired project
tenant_id = openstackUtils.get_project_id(
configuration.openstack_project)
logger.debug("using tenant_id of: %s" % tenant_id)
if tenant_id is None:
raise Exception("No project found for %s" %
configuration.openstack_project)
# FIXME - verify all images are in glance before jumping off here!
ret = openstackUtils.create_stack(stack_name, heat_template)
if ret is not None:
inventory = wistarUtils.get_topology_inventory(topology)
wistarUtils.send_new_topology_event(inventory)
return HttpResponseRedirect('/topologies/' + topology_id + '/')
except Exception as e:
logger.debug("Caught Exception in deploy")
logger.debug(str(e))
return render(request, 'error.html', {'error': str(e)})
def deploy_topology(request):
if 'topologyId' not in request.POST:
return render(request, 'ajax/ajaxError.html',
{'error': "No Topology Id in request"})
topology_id = request.POST['topologyId']
try:
topo = Topology.objects.get(pk=topology_id)
except ObjectDoesNotExist:
return render(request, 'ajax/ajaxError.html',
{'error': "Topology not found!"})
try:
# let's parse the json and convert to simple lists and dicts
config = wistarUtils.load_config_from_topology_json(
topo.json, topology_id)
# FIXME - should this be pushed into another module?
inline_deploy_topology(config)
inventory = wistarUtils.get_topology_inventory(topo)
wistarUtils.send_new_topology_event(inventory)
except Exception as e:
logger.debug("Caught Exception in deploy")
logger.debug(str(e))
return render(request, 'ajax/ajaxError.html', {'error': str(e)})
domain_list = libvirtUtils.get_domains_for_topology("t" + topology_id +
"_")
network_list = []
if osUtils.check_is_linux():
network_list = libvirtUtils.get_networks_for_topology("t" +
topology_id +
"_")
context = {
'domain_list': domain_list,
'network_list': network_list,
'isLinux': True,
'topologyId': topology_id
}
return render(request, 'ajax/deploymentStatus.html', context)
def get_topology_config(request):
"""
Grab a json object representing the topology config
as well as the domain status for each object
This is useful to get a list of all objects on the topolgy,
filter for objects of a specific type, and verify their boot up state.
i.e. to run a command against all Junos devices for example
"""
if 'topologyId' not in request.POST:
return render(request, 'ajax/ajaxError.html',
{'error': "No Topology Id in request"})
topology_id = request.POST['topologyId']
try:
topo = Topology.objects.get(pk=topology_id)
# let's parse the json and convert to simple lists and dicts
config = wistarUtils.load_config_from_topology_json(
topo.json, topology_id)
domain_status = libvirtUtils.get_domains_for_topology("t" +
topology_id +
"_")
context = {
'config': config,
'domain_status': domain_status,
'topologyId': topology_id
}
logger.debug("returning")
return HttpResponse(json.dumps(context),
content_type="application/json")
except Exception as ex:
logger.debug(ex)
return render(request, 'ajax/ajaxError.html',
{'error': "Topology not found!"})
def start_topology_old(request):
"""
DEPRECATED
verify the topology exists and is started!
required parameters: topology_name, id of which to clone, cloud_init data
returns json { "status": "running|unknown|powered off", "topology_id": "0" }
"""
context = {"status": "unknown"}
required_fields = set(
['topology_name', 'clone_id', 'script_id', 'script_param'])
if not required_fields.issubset(request.POST):
context["status"] = "unknown"
context["message"] = "Invalid parameters in POST"
return HttpResponse(json.dumps(context),
content_type="application/json")
topology_name = request.POST['topology_name']
clone_id = request.POST['clone_id']
script_id = request.POST['script_id']
script_param = request.POST['script_param']
try:
# get the topology by name
topo = Topology.objects.get(name=topology_name)
except ObjectDoesNotExist:
# uh-oh! it doesn't exist, let's clone it and keep going
# clone the topology with the new name specified!
topology = Topology.objects.get(pk=clone_id)
# get a list of all the currently used IPs defined
all_used_ips = wistarUtils.get_used_ips()
logger.debug(str(all_used_ips))
raw_json = json.loads(topology.json)
for json_object in raw_json:
if "userData" in json_object and "wistarVm" in json_object[
"userData"]:
ud = json_object["userData"]
ip = ud["ip"]
ip_octets = ip.split('.')
# get the next available ip
next_ip = wistarUtils.get_next_ip(all_used_ips, 2)
# mark it as used so it won't appear in the next iteration
all_used_ips.append(next_ip)
ip_octets[3] = str(next_ip)
newIp = ".".join(ip_octets)
ud["ip"] = newIp
ud["configScriptId"] = script_id
ud["configScriptParam"] = script_param
description = "Clone from: %s\nScript Id: %s\nScript Param: %s" % (
clone_id, script_id, script_param)
topo = Topology(name=topology_name,
description=description,
json=json.dumps(raw_json))
topo.save()
try:
# by this point, the topology already exists
logger.debug("Got topo " + str(topo.id))
domain_status = libvirtUtils.get_domains_for_topology("t" +
str(topo.id) +
"_")
if len(domain_status) == 0:
# it has not yet been deployed!
logger.debug("not yet deployed!")
# let's parse the json and convert to simple lists and dicts
config = wistarUtils.load_config_from_topology_json(
topo.json, topo.id)
logger.debug("Deploying to hypervisor now")
# FIXME - should this be pushed into another module?
av.inline_deploy_topology(config)
time.sleep(1)
except Exception as e:
logger.debug(str(e))
context["status"] = "unknown"
context["message"] = "Exception"
return HttpResponse(json.dumps(context),
content_type="application/json")
try:
# at this point, the topology now exists and is deployed!
network_list = libvirtUtils.get_networks_for_topology("t" +
str(topo.id) +
"_")
domain_list = libvirtUtils.get_domains_for_topology("t" +
str(topo.id) + "_")
for network in network_list:
libvirtUtils.start_network(network["name"])
time.sleep(1)
for domain in domain_list:
time.sleep(10)
libvirtUtils.start_domain(domain["uuid"])
context = {
'status': 'booting',
'topologyId': topo.id,
'message': 'sandbox is booting'
}
logger.debug("returning")
return HttpResponse(json.dumps(context),
content_type="application/json")
except Exception as ex:
logger.debug(str(ex))
context["status"] = "unknown"
context["message"] = "Caught Exception %s" % ex
return HttpResponse(json.dumps(context),
content_type="application/json")
def start_topology(request):
logger.debug("---- start_topology ---- ")
json_string = request.body
try:
json_body = json.loads(json_string)
except ValueError:
return apiUtils(False, "Could not load json payload")
try:
if "name" in json_body[0]:
topology_name = json_body[0]["name"]
# do we have a specified delay between starting domains?
if 'start_delay' in json_body[0]:
delay = int(json_body[0]['start_delay'])
else:
delay = 0.5
# get the topology by name
try:
topology = Topology.objects.get(name=topology_name)
except ObjectDoesNotExist:
logger.error('Could not find topology with name: %s' %
topology_name)
return apiUtils(
False,
"Could not find topology with name: %s" % topology_name)
domain_list = libvirtUtils.get_domains_for_topology(
"t" + str(topology.id) + "_")
if len(domain_list) == 0:
# it has not yet been deployed!
logger.debug("not yet deployed!")
# let's parse the json and convert to simple lists and dicts
config = wistarUtils.load_config_from_topology_json(
topology.json, topology.id)
if config is None:
return apiUtils(
False,
"Could not load config for topology: %s" % topology.id)
logger.debug("Deploying to hypervisor now")
# FIXME - should this be pushed into another module?
av.inline_deploy_topology(config)
# now, topology should be deployed and ready to go!
network_list = libvirtUtils.get_networks_for_topology(
"t" + str(topology.id) + "_")
domain_list = libvirtUtils.get_domains_for_topology(
"t" + str(topology.id) + "_")
for network in network_list:
logger.debug("starting network: %s" % network["name"])
libvirtUtils.start_network(network["name"])
time.sleep(delay)
for domain in domain_list:
# no sleep time? Just go ahead and melt the disks!
if domain["state"] != 'running':
logger.debug("starting domain: %s" % domain["uuid"])
libvirtUtils.start_domain(domain["uuid"])
time.sleep(delay)
return apiUtils.return_json(True,
'Topology started!',
topology_id=topology.id)
except Exception as ex:
logger.debug(str(ex))
return apiUtils.return_json(False, 'Could not start topology!')
