proxmaster/proxmaster.py

#. -*- coding: utf-8 -
# required proxmox permissions: PVESysAdmin, PVEVMAdmin
#
# afx 2015-2016

# import site packages
import logging
import falcon
import sys
import json

#import local packages
import ioconfig
import grid
import plugin
import clientsdb

config = ioconfig.parser
logger = ioconfig.logger


def welcome():
    """displays motd in log as welcome message"""
    logger.info('###################################')
    logger.info('# proxmaster ][ (c) 2015-2016 afx #')
    logger.info('###################################')


def selector(fn, req, vmid=0):
    """ try to exec commands """
    json = req.context['doc']
    print(json)
    apipass = json['apikey']
    if apipass != config.get('general', 'apipass'):
        status = falcon.HTTP_403
        body = falcon.HTTP_403
        logger.error('grid> access denied. bad api key!')
        return status, body

    try:
        if fn == 'validate':
            clientemail = json['clientemail']
            passwd = json['password']
            #logger.info('grid> access requested for {} with {}'.format(clientemail, passwd))
            body = clientsdb.validate(clientemail, passwd)

        elif fn == 'create':
            body = plugin.vmcreate(json)

        elif fn == 'status':
            body = plugin.vmstatus(vmid)

        elif fn == 'delete':
            body = plugin.vmdelete(vmid)

        elif fn == 'suspend':
            body = plugin.vmsuspend(vmid)

        elif fn == 'resume':
            body = plugin.vmresume(vmid)

        elif fn == 'start':
            body = plugin.vmstart(vmid)

        elif fn == 'shutdown':
            body = plugin.vmshutdown(vmid)

        elif fn == 'stop':
            body = plugin.vmstop(vmid)

        elif fn == 'vnc':
            body = plugin.vmvnc(vmid)

    except:
        logger.critical('grid> {} malfunction!'.format(fn))
        body = '503 Service Unavailable'
        status = falcon.HTTP_503
        raise

    else:
        logger.info('grid> {} ok'.format(fn))
        status = falcon.HTTP_202

    return status, body
 

class RequireJSON(object):
    def process_request(self, req, resp):
        if not req.client_accepts_json:
            raise falcon.HTTPNotAcceptable(
                'This API only supports responses encoded as JSON.',
                href='http://docs.examples.com/api/json')

        if req.method in ('POST', 'PUT'):
            if 'application/json' not in req.content_type:
                raise falcon.HTTPUnsupportedMediaType(
                    'This API only supports requests encoded as JSON.',
                    href='http://docs.examples.com/api/json')


class JSONTranslator(object):
    def process_request(self, req, resp):
        # req.stream corresponds to the WSGI wsgi.input environ variable,
        # and allows you to read bytes from the request body.
        #
        # See also: PEP 3333
        if req.content_length in (None, 0):
            # Nothing to do
            return

        body = req.stream.read()
        if not body:
            raise falcon.HTTPBadRequest('Empty request body',
                                        'A valid JSON document is required.')

        try:
            req.context['doc'] = json.loads(body.decode('utf-8'))

        except (ValueError, UnicodeDecodeError):
            raise falcon.HTTPError(falcon.HTTP_400,
                                   'Malformed JSON',
                                   'Could not decode the request body. The '
                                   'JSON was incorrect or not encoded as '
                                   'UTF-8.')

    def process_response(self, req, resp, resource):
        if 'result' not in req.context:
            return

        resp.body = json.dumps(req.context['result'])


def max_body(limit):
    def hook(req, resp, resource, params):
        length = req.content_length
        if length is not None and length > limit:
            msg = ('The size of the request is too large. The body must not '
                   'exceed ' + str(limit) + ' bytes in length.')

            raise falcon.HTTPRequestEntityTooLarge(
                'Request body is too large', msg)

    return hook


class ValidateResource(object):
    @falcon.before(max_body(64 * 1024))
    def on_post(self, req, resp):
        """ get clientemail and password and compare it with the client db and returns a list of managed object IDs """
        resp.status, response = selector('validate', req)
        req.context['result'] = response

class CreateResource(object):
    @falcon.before(max_body(64 * 1024))
    def on_post(self, req, resp):
        """Create a cluster node, returns array of: status, vmid, pass, ipv4, """
        logger.info('grid> create ' + str(req.params))
        resp.status, response = selector('create', req)
        req.context['result'] = response

class StatusResource(object):
    @falcon.before(max_body(64 * 1024))
    def on_post(self, req, resp, vmid):
        """ check vm status """
        logger.info('grid> status ' + str(vmid))
        resp.status, response = selector('status', req, vmid)
        req.context['result'] = response

class DeleteResource(object):
    @falcon.before(max_body(64 * 1024))
    def on_post(self, req, resp, vmid):
        """ delete machine completely"""
        logger.info('grid> delete ' + str(vmid))
        resp.status, response = selector('delete', req, vmid)
        req.context['result'] = response

class SuspendResource(object):
    @falcon.before(max_body(64 * 1024))
    def on_post(self, req, resp, vmid):
        """ Temporary suspend the instance """
        logger.info('grid> suspend ' + str(vmid))
        resp.status, response = selector('suspend', req, vmid)
        req.context['result'] = response

class ResumeResource(object):
    @falcon.before(max_body(64 * 1024))
    def on_post(self, req, resp, vmid):
        """ Unuspend the instance """
        logger.info('grid> resume ' + str(vmid))
        resp.status, response = selector('resume', req, vmid)
        req.context['result'] = response

class StartResource(object):
    @falcon.before(max_body(64 * 1024))
    def on_post(self, req, resp, vmid):
        """ Start the instance """
        logger.info('grid> start ' + str(vmid))
        resp.status, response = selector('start', req, vmid)
        req.context['result'] = response

class ShutdownResource(object):
    @falcon.before(max_body(64 * 1024))
    def on_post(self, req, resp, vmid):
        """ ACPI Shutdown the instance """
        logger.info('grid> shutdown ' + str(vmid))
        resp.status, response = selector('shutdown', req, vmid)
        req.context['result'] = response

class StopResource(object):
    @falcon.before(max_body(64 * 1024))
    def on_post(self, req, resp, vmid):
        """ Stop the instance """
        logger.info('grid> stop ' + str(vmid))
        resp.status, response = selector('stop', req, vmid)
        req.context['result'] = response

class VNCResource(object):
    @falcon.before(max_body(64 * 1024))
    def on_post(self, req, resp, vmid):
        """ Create a VNC link to the instance """
        logger.info('grid> vnc ' + str(vmid))
        resp.status, response = selector('vnc', req, vmid)
        req.context['result'] = response

if __name__ == '__main__':
    sys.exit("invoke proxmaster via uwsgi. thanks. bye. o/")

wsgi_app = api = application = falcon.API(middleware=[
    RequireJSON(),
    JSONTranslator(),
])
   
# setup routes
res_validate = ValidateResource()
api.add_route('/validate', res_validate)

res_create = CreateResource()
api.add_route('/create', res_create)

res_status = StatusResource()
api.add_route('/status/{vmid}', res_status)

res_delete = DeleteResource()
api.add_route('/delete/{vmid}', res_delete)

res_suspend = SuspendResource()
api.add_route('/suspend/{vmid}', res_suspend)

res_resume = ResumeResource()
api.add_route('/resume/{vmid}', res_resume)

res_start = StartResource()
api.add_route('/start/{vmid}', res_start)

res_shutdown = ShutdownResource()
api.add_route('/shutdown/{vmid}', res_shutdown)

res_stop = StopResource()
api.add_route('/stop/{vmid}', res_stop)

res_vnc = VNCResource()
api.add_route('/vnc/{vmid}', res_vnc)

#display motd
welcome()