#!/bin/env python

# -*- coding: utf-8 -*-

# ------------------------------------------------------------

# opensecurityd

# 

# the opensecurityd as RESTful server

#

# Autor: Oliver Maurhart, <oliver.maurhart@ait.ac.at>

#

# Copyright (C) 2013 AIT Austrian Institute of Technology

# AIT Austrian Institute of Technology GmbH

# Donau-City-Strasse 1 | 1220 Vienna | Austria

# http://www.ait.ac.at

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation version 2.

# 

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# 

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, 

# Boston, MA  02110-1301, USA.

# ------------------------------------------------------------

# ------------------------------------------------------------

# imports

import os

import os.path

import subprocess

import sys

import web

from cygwin import Cygwin

from vmmanager import VMManager

# local

from environment import Environment

from opensecurity_util import logger

# ------------------------------------------------------------

# const

__version__ = "0.2"

"""All the URLs we know mapping to class handler"""

opensecurity_urls = (

    #'/device_change',                   'os_device_change',     # http://localhost:8080/device_change                           GET

    #'/sdvm_started',                    'os_sdvm_started',      # http://localhost:8080/sdvm_started                            GET

    '/browsing',                        'os_browsing',          # http://localhost:8080/browsing                                GET

    '/sdvms',                           'os_sdvms',             # http://localhost:8080/sdvms                                   GET, PUT

    '/sdvms/(.*)/application/(.*)',     'os_sdvm_application',  # http://localhost:8080/sdvms/[VMNAME]/application/[COMMAND]    GET

    '/sdvms/(.*)/ip',                   'os_sdvm_ip',           # http://localhost:8080/sdvms/[VMNAME]/ip                       GET

    '/sdvms/(.*)/start',                'os_sdvm_start',        # http://localhost:8080/sdvms/[VMNAME]/start                    GET

    '/sdvms/(.*)/stop',                 'os_sdvm_stop',         # http://localhost:8080/sdvms/[VMNAME]/stop                     GET

    '/sdvms/(.*)',                      'os_sdvm',              # http://localhost:8080/sdvms/[VMNAME]                          GET, DELETE

    '/vms',                             'os_vms',               # http://localhost:8080/vms                                     GET

    '/vms/(.*)',                        'os_vm',                # http://localhost:8080/vms/[VMNAME]                            GET

    '/',                                'os_root',              # http://localhost:8080/                                        GET

    '/update_template',                 'os_update_template'    # http://localhost:8080/update_template                         GET

)

# ------------------------------------------------------------

# vars

# Global VMManager instance

gvm_mgr = None

# ------------------------------------------------------------

# code

#class os_device_change:

#    """OpenSecurity '/device_change' handler"""

#    

#    def GET(self):

#        log_call(web.ctx.environ)

#        try:

#            new_ip = gvm_mgr.handleDeviceChange()

#            return new_ip

#        except:

#            raise web.internalerror()

class os_browsing:

    """OpenSecurity '/browsing' handler

    - GET: Start and prepare a new SecurityVM for Internet Browsing. Return the name of the VM.

    """

    def GET(self):

        log_call(web.ctx.environ)

        try:

            browsingVM = vmmanager().handleBrowsingRequest()

            return browsingVM

        except:

            raise web.internalerror()

#class os_sdvm_started:

#    """OpenSecurity '/sdvm_started' handler"""

#    

#    def GET(self):

#        log_call(web.ctx.environ)

#        remote_ip = web.ctx.environ['REMOTE_ADDR']

#        gvm_mgr.putStartNotification(remote_ip)

#        return "os_sdvm_started"

class os_sdvm:

    """OpenSecurity '/sdvms/[VM]' handler

    - GET: Information about a specific SecurityVM

    - DELETE: Remove a specific

    """

    def GET(self, name):

        log_call(web.ctx.environ)

        return vmmanager().getVMInfo(name)

    def DELETE(self, name):

        log_call(web.ctx.environ)

        return vmmanager().removeVM(name)

class os_sdvm_application:

    """OpenSecurity '/sdvms/[VM]/application/[CMD]' handler

    - GET: start application with given command in the VM.

    """

    def GET(self, name, command):

        log_call(web.ctx.environ)

        command = '/' + command

        result = Cygwin.sshExecuteX11(command, vmmanager().getHostOnlyIP(name), 'osecuser', Cygwin.cygPath(gvm_mgr.getMachineFolder()) + '/' + name + '/dvm_key'  )

        self.poweroffVM(name)

        return vmmanager().removeVM(name)

class os_sdvm_ip:

    """OpenSecurity '/sdvms/[VM]/ip' handler

    - GET: give IP of SecurityVM.

    """

    def GET(self, name):

        log_call(web.ctx.environ)

        return vmmanager().getHostOnlyIP(name)

class os_sdvm_start:

    """OpenSecurity '/sdvms/[VM]/start' handler

    - GET: Start specific SecuirtyVM.

    """

    def GET(self, name):

        log_call(web.ctx.environ)

        return vmmanager().startVM(name)

class os_sdvm_stop:

    """OpenSecurity '/sdvms/[VM]/stop' handler

    - GET: stop specific Secuirty VM.

    """

    def GET(self, name):

        log_call(web.ctx.environ)

        return vmmanager().stopVM(name)

class os_sdvms:

    """OpenSecurity '/sdvms' handler

    - GET: list all available secuirty VMs.

    - POST: create new security vm.

    """

    def GET(self):

        """get the list of SDVMs"""

        log_call(web.ctx.environ)

        return vmmanager().listSDVM() 

    def POST(self):

        """create a new SDVM"""

        log_call(web.ctx.environ)

        # get a new vm-name

        name = vmmanager().generateSDVMName()

        try:

            vmmanager().createVM(name)

        except:

            raise web.internalerror()

        return name

class os_vm:

    """OpenSecurity '/vms/[VM]' handler

    - GET: list information of arbitrary VM.

    """

    def GET(self, name):

        log_call(web.ctx.environ)

        return vmmanager().getVMInfo(name)

class os_vms:

    """OpenSecurity '/vms' handler

    - GET: list all (also non Security) VMs.

    """

    def GET(self):

        log_call(web.ctx.environ)

        return vmmanager().listVM() 

class os_root:

    """OpenSecurity '/' handler

    - GET: give information about current installation.

    """

    def GET(self):

        log_call(web.ctx.environ)

        res = "'os_server': { "

        res += "'version': '" + __version__ + "', "

        res += "'machine_folder': '" + vmmanager().getDefaultMachineFolder() + "' "

        res += "}"

        return res

class os_update_template:

    """OpenSecurity '/update_template' handler

    - GET: update template vm

    """

    def GET(self):

        #return gvm_mgr.guestExecute('SecurityDVM', 'sudo apt-get -y update')

        log_call(web.ctx.environ)

        return vmmanager().updateTemplate()

def log_call(web_environ):

    """log the incoming call to the REST api"""

    try:

        call = 'REST ' +  web_environ['REQUEST_METHOD'] + ' ' + web_environ['REQUEST_URI'] + ' from ' + web_environ['REMOTE_ADDR'] + ':' + web_environ['REMOTE_PORT']

        logger.debug(call)

    except:

        pass

def main():

    """main startup for the opensecuirityd"""

    server = web.application(opensecurity_urls, globals())

    server.run()

def vmmanager():

    """helper method to make lazy init of VMManager"""

    if gvm_mgr is None:

        gvm_mgr = VMManager.getInstance()

    return gvm_mgr    

# start

if __name__ == "__main__":

    main()