339 lines
10 KiB
Python
339 lines
10 KiB
Python
import cherrypy
|
|
import logging
|
|
import json
|
|
from threading import Thread
|
|
|
|
|
|
class Mountable(object):
|
|
"""
|
|
Macro for encapsulating a component's config and methods into one object.
|
|
:param conf: cherrypy config dict for use when mounting this component
|
|
"""
|
|
def __init__(self, conf=None):
|
|
self.conf = conf if conf else {'/': {}}
|
|
|
|
def mount(self, path):
|
|
"""
|
|
Mount this component into the cherrypy tree
|
|
:param path: where to mount it e.g. /v1
|
|
:return: self
|
|
"""
|
|
cherrypy.tree.mount(self, path, self.conf)
|
|
return self
|
|
|
|
|
|
class ZApi(object):
|
|
def __init__(self, master):
|
|
"""
|
|
Main component of the API service. Inits and assembles the various classes. Provides .run() and .stop() to
|
|
control it.
|
|
:param master: parent BastionController reference.
|
|
"""
|
|
self.master = master
|
|
self.app_v1 = ZApiV1(self).mount('/api/v1')
|
|
# self.app_root = BSApiRoot(self).mount('/api')
|
|
# self.ui = Mountable(conf={'/': {
|
|
# 'tools.staticdir.on': True,
|
|
# 'tools.staticdir.dir': os.getcwd() + '/ui/build',
|
|
# 'tools.staticdir.index': 'index.html'}}).mount('/ui')
|
|
|
|
cherrypy.config.update({
|
|
'sessionFilter.on': True,
|
|
'tools.sessions.on': True,
|
|
'tools.sessions.locking': 'explicit',
|
|
'tools.sessions.timeout': 525600,
|
|
'request.show_tracebacks': True,
|
|
'server.socket_port': self.master.config.get("apiport", 3000),
|
|
'server.thread_pool': 25,
|
|
'server.socket_host': '0.0.0.0',
|
|
'server.show_tracebacks': True,
|
|
'server.socket_timeout': 5,
|
|
'log.screen': False,
|
|
'engine.autoreload.on': False
|
|
})
|
|
|
|
def run(self):
|
|
cherrypy.engine.start()
|
|
cherrypy.engine.block()
|
|
logging.info("API has shut down")
|
|
|
|
def stop(self):
|
|
cherrypy.engine.exit()
|
|
logging.info("API shutting down...")
|
|
|
|
|
|
class ZApiV1(Mountable):
|
|
"""
|
|
Provides the /v1/ api.
|
|
"""
|
|
def __init__(self, root):
|
|
super().__init__(conf={
|
|
"/machine": {'request.dispatch': cherrypy.dispatch.MethodDispatcher()},
|
|
"/disk": {'request.dispatch': cherrypy.dispatch.MethodDispatcher()},
|
|
# "/task": {'request.dispatch': cherrypy.dispatch.MethodDispatcher()},
|
|
# "/logs": {
|
|
# 'tools.staticdir.on': True,
|
|
# 'tools.staticdir.dir': root.master.log_path,
|
|
# 'tools.staticdir.content_types': {'log': 'text/plain'}
|
|
# }
|
|
})
|
|
self.root = root
|
|
self.machine = ZApiMachines(self.root)
|
|
self.disk = ZApiDisks(self.root)
|
|
# self.task = BSApiTask(self.root)
|
|
# self.control = BSApiControl(self.root)
|
|
# self.socket = ApiWebsockets(self.root)
|
|
|
|
@cherrypy.expose
|
|
def index(self):
|
|
yield "It works!"
|
|
|
|
|
|
@cherrypy.popargs("machine_id")
|
|
class ZApiMachineStop(object):
|
|
"""
|
|
Endpoint to stop running machines
|
|
"""
|
|
exposed = True
|
|
|
|
def __init__(self, root):
|
|
self.root = root
|
|
|
|
@cherrypy.tools.json_out()
|
|
def GET(self, machine_id):
|
|
"""
|
|
If the machine exists, stop it gracefully. This happens asynchronously.
|
|
"""
|
|
assert machine_id in self.root.master.machines
|
|
Thread(target=lambda: self.root.master.forceful_stop(machine_id)).start()
|
|
return machine_id
|
|
|
|
|
|
@cherrypy.popargs("machine_id")
|
|
class ZApiMachineStart(object):
|
|
"""
|
|
Endpoint to start stopped machines
|
|
"""
|
|
exposed = True
|
|
|
|
def __init__(self, root):
|
|
self.root = root
|
|
|
|
@cherrypy.tools.json_out()
|
|
def GET(self, machine_id=None):
|
|
"""
|
|
Start the machine
|
|
"""
|
|
self.root.master.machines[machine_id].start()
|
|
return machine_id
|
|
|
|
|
|
@cherrypy.popargs("machine_id")
|
|
class ZApiMachineRestart(object):
|
|
"""
|
|
Endpoint to restart machines
|
|
"""
|
|
exposed = True
|
|
|
|
def __init__(self, root):
|
|
self.root = root
|
|
|
|
@cherrypy.tools.json_out()
|
|
def GET(self, machine_id=None):
|
|
"""
|
|
Start the machine
|
|
"""
|
|
assert machine_id in self.root.master.machines
|
|
self.root.master.forceful_stop(machine_id)
|
|
self.root.master.machines[machine_id].start()
|
|
return machine_id
|
|
|
|
|
|
@cherrypy.popargs("prop")
|
|
class ZApiMachineProperty(object):
|
|
"""
|
|
Endpoint to modify machine properties
|
|
"""
|
|
exposed = True
|
|
|
|
def __init__(self, root):
|
|
self.root = root
|
|
|
|
@cherrypy.tools.json_out()
|
|
def GET(self, machine_id, prop):
|
|
"""
|
|
Fetch a property from a machine
|
|
"""
|
|
try:
|
|
machine = self.root.master.machines[machine_id]
|
|
return machine.properties[prop]
|
|
except KeyError:
|
|
raise cherrypy.HTTPError(status=404)
|
|
|
|
@cherrypy.tools.json_out()
|
|
def PUT(self, machine_id, prop, value):
|
|
"""
|
|
Set a property on a machine.
|
|
"""
|
|
value = json.loads(value)
|
|
try:
|
|
machine = self.root.master.machines[machine_id]
|
|
assert machine.machine.get_status() == "stopped", "Machine must be stopped to modify"
|
|
|
|
except KeyError:
|
|
raise cherrypy.HTTPError(status=404)
|
|
|
|
machine.properties[prop] = value
|
|
machine.save()
|
|
return [machine_id, prop, value]
|
|
|
|
@cherrypy.tools.json_out()
|
|
def DELETE(self, machine_id, prop):
|
|
"""
|
|
Remove a property on a machine.
|
|
"""
|
|
try:
|
|
machine = self.root.master.machines[machine_id]
|
|
assert machine.machine.get_status() == "stopped", "Machine must be stopped to modify"
|
|
except KeyError:
|
|
raise cherrypy.HTTPError(status=404)
|
|
|
|
del machine.properties[prop]
|
|
machine.save()
|
|
return [machine_id, prop]
|
|
|
|
|
|
@cherrypy.popargs("machine_id")
|
|
class ZApiMachines():
|
|
"""
|
|
Endpoint for managing machines
|
|
"""
|
|
|
|
exposed = True
|
|
|
|
def __init__(self, root):
|
|
"""
|
|
Endpoint to modify machines. PUT and DELETE require the machine not be running, which can be managed with the
|
|
stop and start methods below
|
|
"""
|
|
self.root = root
|
|
self.stop = ZApiMachineStop(self.root)
|
|
self.start = ZApiMachineStart(self.root)
|
|
self.restart = ZApiMachineRestart(self.root)
|
|
self.property = ZApiMachineProperty(self.root)
|
|
|
|
@cherrypy.tools.json_out()
|
|
def GET(self, machine_id=None, summary=False):
|
|
"""
|
|
Get a list of all machines or specific one if passed
|
|
:param machine_id: machine to retrieve
|
|
"""
|
|
summary = summary in [True, 'True', 'true', 'yes', '1', 1]
|
|
|
|
machines = {}
|
|
for _machine_id, machine_spec in self.root.master.machines.items():
|
|
machine = {"machine_id": _machine_id,
|
|
"_status": machine_spec.machine.get_status()}
|
|
if not summary:
|
|
machine.update({"properties": machine_spec.serialize()})
|
|
|
|
machines[_machine_id] = machine
|
|
if machine_id is not None:
|
|
try:
|
|
return [machines[machine_id]]
|
|
except KeyError:
|
|
raise cherrypy.HTTPError(status=404)
|
|
else:
|
|
return list(machines.values())
|
|
|
|
@cherrypy.tools.json_out()
|
|
def PUT(self, machine_id, machine_spec):
|
|
"""
|
|
Create a new machine or update an existing machine
|
|
:param machine_id: id of machine to create or modify
|
|
'param machine_spec: json dictionary describing the machine. see the 'spec' key of example/banutoo.json
|
|
"""
|
|
|
|
assert machine_id not in self.root.master.machines or \
|
|
self.root.master.machines[machine_id].machine.get_status() == "stopped", \
|
|
"Machine must be stopped to modify"
|
|
|
|
machine_spec = json.loads(machine_spec)
|
|
self.root.master.add_machine(machine_id, machine_spec, write=True)
|
|
return machine_id
|
|
|
|
def DELETE(self, machine_id):
|
|
"""
|
|
Delete a machine. Raises 404 if no machine exists. Raises error if machine is not stopped
|
|
:param machine_id: ID of machine to remove
|
|
"""
|
|
try:
|
|
assert self.root.master.machines[machine_id].machine.get_status() == "stopped", \
|
|
"Machine must be stopped to delete"
|
|
except KeyError:
|
|
raise cherrypy.HTTPError(status=404)
|
|
|
|
self.root.master.remove_machine(machine_id)
|
|
return machine_id
|
|
|
|
|
|
@cherrypy.popargs("disk_id")
|
|
class ZApiDisks():
|
|
"""
|
|
Endpoint for managing disks
|
|
"""
|
|
|
|
exposed = True
|
|
|
|
def __init__(self, root):
|
|
"""
|
|
Endpoint to modify disks. PUT and DELETE require the disk not be attached.
|
|
TODO how to attach/detach?
|
|
"""
|
|
self.root = root
|
|
|
|
@cherrypy.tools.json_out()
|
|
def GET(self, disk_id=None, summary=False):
|
|
"""
|
|
Get a list of disks or a specific one if passed
|
|
:param disk_id: task to retrieve
|
|
"""
|
|
summary = summary in [True, 'True', 'true', 'yes', '1', 1]
|
|
|
|
disks = {}
|
|
for _disk_id, disk_spec in self.root.master.disks.items():
|
|
disk = {"disk_id": _disk_id}
|
|
# "_status": machine_spec.machine.get_status()} attached / detached ?
|
|
# if not summary:
|
|
# machine.update({"machine_type": machine_spec.machine_type,
|
|
# "spec": machine_spec.serialize()})
|
|
disk.update({"spec": disk_spec.serialize()})
|
|
|
|
disks[_disk_id] = disk
|
|
if disk_id is not None:
|
|
try:
|
|
return [disks[disk_id]]
|
|
except KeyError:
|
|
raise cherrypy.HTTPError(status=404)
|
|
else:
|
|
return list(disks.values())
|
|
|
|
@cherrypy.tools.json_out()
|
|
def PUT(self, disk_id, disk_spec):
|
|
"""
|
|
Create a new disk or update an existing disk
|
|
:param disk_id: id of disk to create or modify
|
|
'param disk_spec: json dictionary describing the disk. see the 'spec' key of example/ubuntu-root.json
|
|
"""
|
|
disk_spec = json.loads(disk_spec)
|
|
self.root.master.add_disk(disk_id, disk_spec, write=True)
|
|
return disk_id
|
|
|
|
def DELETE(self, disk_id):
|
|
"""
|
|
Delete a disk. Raises 404 if no such disk exists. Raises error if disk is not idle (detached)
|
|
:param disk_id: ID of disk to remove
|
|
"""
|
|
self.root.master.remove_disk(disk_id)
|
|
return disk_id
|