299 lines
8.3 KiB
Python
Executable File
299 lines
8.3 KiB
Python
Executable File
#!/usr/bin/python3
|
|
"""Agent for setting up accounts for sysdeploy clients"""
|
|
# pylint: disable=subprocess-run-check,too-few-public-methods
|
|
import os
|
|
import sys
|
|
|
|
import cherrypy
|
|
import libvirt
|
|
import json
|
|
from multiprocessing.pool import ThreadPool
|
|
|
|
pool = ThreadPool(processes=1)
|
|
|
|
import uuid
|
|
from jinja2 import Environment, FileSystemLoader
|
|
|
|
PATH = os.path.dirname(os.path.abspath(__file__))
|
|
|
|
import configparser
|
|
|
|
config = configparser.ConfigParser()
|
|
config.read("config.ini")
|
|
|
|
TEMPLATE_ENVIRONMENT = Environment(
|
|
autoescape=False,
|
|
loader=FileSystemLoader(os.path.join(PATH, "templates")),
|
|
trim_blocks=False,
|
|
)
|
|
|
|
# TEMPLATE_ENVIRONMENT.globals['STATIC_PREFIX'] = '/templates/'
|
|
|
|
|
|
def render_template(template_filename, context):
|
|
return TEMPLATE_ENVIRONMENT.get_template(template_filename).render(context)
|
|
|
|
|
|
class Client:
|
|
"""Main manager class"""
|
|
|
|
""" uris = [
|
|
#'qemu+ssh://pool@reserve.homedevops/system',
|
|
#'qemu+ssh://root@check2.homedevops/system',
|
|
#'qemu+ssh://root@check3.homedevops/system'
|
|
'qemu:///system'
|
|
] """
|
|
|
|
host_str = config["host"]["available_hosts"]
|
|
uris = [
|
|
each.strip()
|
|
for each in host_str.replace("'", "").replace('"', "").split(",")
|
|
if each.strip()
|
|
]
|
|
|
|
def __init__(self):
|
|
self.status = {}
|
|
self.connections = {}
|
|
for i in self.uris:
|
|
self.connections[i] = libvirt.open(i)
|
|
|
|
@cherrypy.expose
|
|
def getavailable(self):
|
|
out = ""
|
|
for n, c in self.connections.items():
|
|
# cmap = c.getCPUMap()
|
|
# out += "CPUs: {}".format(str(cmap[0]))
|
|
# out += "Available: {}".format(str(cmap[1]))
|
|
nodeinfo = c.getInfo()
|
|
mem = nodeinfo[1]
|
|
cpus = nodeinfo[2]
|
|
usedmem = 0
|
|
usedcpus = 0
|
|
|
|
domain_ids = c.listDomainsID()
|
|
for did in domain_ids:
|
|
dom = c.lookupByID(did)
|
|
state, maxmem, mem2, cpus, cput = dom.info()
|
|
usedmem += maxmem / 1024
|
|
usedcpus += cpus
|
|
|
|
out += "{}: {}/{} CPUs free,{}MiB/{}MiB memory free<br/>\n".format(
|
|
n, cpus - usedcpus, cpus, str((mem - usedmem)), str(mem)
|
|
)
|
|
return out
|
|
|
|
@cherrypy.expose
|
|
def create(
|
|
self,
|
|
name,
|
|
iso_source,
|
|
img_source,
|
|
domain_type="kvm",
|
|
memory_unit="MiB",
|
|
memory=1024,
|
|
current_memory=1024,
|
|
vcpu=2,
|
|
arch="x86_64",
|
|
machine="pc-q35-4.2",
|
|
offset="utc",
|
|
emulator="/usr/bin/qemu-system-x86_64",
|
|
):
|
|
|
|
"""create a VM with given specs
|
|
boot it and return the ID for future ref
|
|
"""
|
|
|
|
# TODO: Check host resources(cpus, mem, etc.) before creating a VM
|
|
|
|
param = {
|
|
"name": name,
|
|
"uuid": str(uuid.uuid4()),
|
|
"iso_source": iso_source,
|
|
"img_source": img_source,
|
|
"type": domain_type,
|
|
"memory_unit": memory_unit,
|
|
"memory": memory,
|
|
"current_memory": current_memory,
|
|
"vcpu": vcpu,
|
|
"arch": arch,
|
|
"machine": machine,
|
|
"offset": offset,
|
|
"emulator": emulator,
|
|
}
|
|
|
|
context = {"args": param}
|
|
|
|
xml = render_template("config.tmpl.xml", context)
|
|
# print(xml)
|
|
|
|
host = self.connections[self.uris[0]]
|
|
if host:
|
|
async_result = pool.apply_async(self.__create_vm, (host, xml))
|
|
return async_result.get()
|
|
return "No host available"
|
|
|
|
def __create_vm(self, host, xml):
|
|
try:
|
|
vm = host.createXML(xml)
|
|
return json.dumps({"uuid": vm.UUIDString(), "id": vm.ID(), "status": 1})
|
|
except Exception as e:
|
|
return json.dumps({"err": str(e), "status": 0})
|
|
|
|
@cherrypy.expose
|
|
def gethost(self):
|
|
"""
|
|
It'll show relevant info about all available hosts
|
|
"""
|
|
|
|
host_data = []
|
|
|
|
for i, each in enumerate(self.uris):
|
|
tmp = {}
|
|
c = self.connections[each]
|
|
nodeinfo = c.getInfo()
|
|
mem = nodeinfo[1]
|
|
cpus = nodeinfo[2]
|
|
usedmem = 0
|
|
usedcpus = 0
|
|
|
|
tmp["sn"] = i + 1
|
|
tmp["hostname"] = c.getHostname()
|
|
tmp["status"] = "Alive" if c.isAlive() else "Dead"
|
|
tmp["uri"] = c.getURI()
|
|
tmp["cpu"] = {}
|
|
tmp["mem"] = {}
|
|
|
|
domain_ids = c.listDomainsID()
|
|
for did in domain_ids:
|
|
dom = c.lookupByID(did)
|
|
state, maxmem, mem2, cpus2, cput = dom.info()
|
|
usedmem += maxmem / 1024
|
|
usedcpus += cpus2
|
|
|
|
tmp["cpu"]["total"] = cpus
|
|
tmp["cpu"]["free"] = cpus - usedcpus
|
|
tmp["mem"]["total"] = mem
|
|
tmp["mem"]["free"] = int(mem - usedmem)
|
|
|
|
host_data.append(tmp)
|
|
|
|
return render_template("host.html", {"host_data": host_data})
|
|
|
|
@cherrypy.expose
|
|
def getguest(self):
|
|
"""
|
|
It'll show host-wise available guests and detailed info about them
|
|
"""
|
|
|
|
guest_data = []
|
|
cnt = 0
|
|
for i, each in enumerate(self.uris):
|
|
c = self.connections[each]
|
|
for did in c.listDomainsID():
|
|
dom = c.lookupByID(did)
|
|
tmp = {
|
|
"sn": cnt + 1,
|
|
"guestname": dom.name(),
|
|
"hostname": c.getHostname(),
|
|
"id_": dom.ID(),
|
|
"mem": int(dom.info()[1] / 1024),
|
|
"cpu": dom.info()[3],
|
|
"status": "Active" if dom.isActive() else "Inactive",
|
|
"uuid": dom.UUIDString(),
|
|
}
|
|
|
|
guest_data.append(tmp)
|
|
cnt += 1
|
|
|
|
return render_template("guest.html", {"guest_data": guest_data})
|
|
|
|
@cherrypy.expose
|
|
def manage(self):
|
|
# get available hosts from the database(if it's stored in one)
|
|
# and return the updated template
|
|
|
|
return render_template("manage.html", {})
|
|
|
|
@cherrypy.expose
|
|
@cherrypy.tools.json_in()
|
|
@cherrypy.tools.json_out()
|
|
def query_host(self):
|
|
# make ajax call to query host
|
|
|
|
json_obj = cherrypy.request.json
|
|
print(json_obj)
|
|
import time
|
|
|
|
time.sleep(1) # simulate delay
|
|
return {
|
|
"data": [json_obj["hostname"], 4, 4096, "10.56.0.1", "9C-35-5B-5F-4C-D7"],
|
|
"gpu": True,
|
|
"done": True,
|
|
"msg": "",
|
|
}
|
|
|
|
@cherrypy.expose
|
|
@cherrypy.tools.json_in()
|
|
@cherrypy.tools.json_out()
|
|
def add_host(self):
|
|
# make ajax call to add host, maybe save it in a database
|
|
|
|
json_obj = cherrypy.request.json
|
|
print(json_obj)
|
|
return {"done": True, "msg": ""}
|
|
|
|
@cherrypy.expose
|
|
@cherrypy.tools.json_in()
|
|
@cherrypy.tools.json_out()
|
|
def edit_host(self):
|
|
# make ajax call to edit host. Update it in database
|
|
|
|
json_obj = cherrypy.request.json
|
|
|
|
print(json_obj)
|
|
return {"done": True, "msg": ""}
|
|
|
|
@cherrypy.expose
|
|
@cherrypy.tools.json_in()
|
|
@cherrypy.tools.json_out()
|
|
def delete_host(self):
|
|
# make ajax call to delete host from database
|
|
|
|
json_obj = cherrypy.request.json
|
|
|
|
print(json_obj)
|
|
return {"done": True, "msg": ""}
|
|
|
|
|
|
ROOT = Client()
|
|
CONF = os.path.join(os.path.dirname(__file__), "site.conf")
|
|
|
|
if __name__ == "__main__":
|
|
# cherrypy.config.update(CONF)
|
|
cherrypy.server.socket_host = config["server"].get("server_host", "127.0.0.1")
|
|
cherrypy.server.socket_port = config["server"].getint("server_port", 8080)
|
|
ENGINE = cherrypy.engine
|
|
# cherrypy.process.plugins.Daemonizer(engine).subscribe()
|
|
# cherrypy.process.plugins.DropPrivileges(
|
|
# ENGINE, uid='cherrypy', gid='cherrypy').subscribe()
|
|
cherrypy.tree.mount(
|
|
Client(),
|
|
"/",
|
|
config={
|
|
"/": {
|
|
"tools.staticdir.on": True,
|
|
"tools.staticdir.dir": PATH + "/templates",
|
|
}
|
|
},
|
|
)
|
|
if hasattr(ENGINE, "signal_handler"):
|
|
ENGINE.signal_handler.subscribe()
|
|
if hasattr(ENGINE, "console_control_handler"):
|
|
ENGINE.console_control_handler.subscribe()
|
|
try:
|
|
ENGINE.start()
|
|
except Exception: # pylint: disable=broad-except
|
|
sys.exit(1)
|
|
else:
|
|
ENGINE.block()
|