/alps/pcitool

import os

import sys

import pcilib

import time

import json

from optparse import OptionParser

from multiprocessing import Process

if sys.version_info >= (3,0):

   from http.server import HTTPServer, BaseHTTPRequestHandler

   from socketserver import ThreadingMixIn

else:

   from SocketServer import ThreadingMixIn

   from BaseHTTPServer import HTTPServer, BaseHTTPRequestHandler

class MultiThreadedHTTPServer(ThreadingMixIn, HTTPServer):

    pass

class PcilibServerHandler(BaseHTTPRequestHandler):

   def __init__(s, pcilib, *args):

      s.pcilib = pcilib

      BaseHTTPRequestHandler.__init__(s, *args)

   def do_HEAD(s):

      s.send_response(200)

      s.send_header('content-type', 'application/json')

      s.end_headers()

   def do_GET(s):

      #run request in separate process

      p = Process(target=s.do_GET_worker, args=())

      p.start()

      p.join()

   def do_GET_worker(s):

      length = int(s.headers['Content-Length'])

      #deserialize input data

      data = json.loads(s.rfile.read(length).decode('utf-8'))

      if 'command' in data:

         command = data['command']

         if(command == 'help'):

            s.help(data)

         #elif(command == 'open'):

         #   #check required arguments

         #   if not 'device' in data:

         #      s.error('message doesnt contains "device" field, '

         #              'which is required for "open" command', data)

         #      return

         #   #parse command arguments and convert them to string

         #   device = str(data.get('device', None))

         #   model = data.get('model', None)

         #   if not model is None:

			#	model = str(model)

         #   

         #   try:

         #      s.openPcilibInstance(device, model)

         #   except Exception as e:

         #      s.error(str(e), data) 

         #     return

		   #

         #   #Success! Create and send reply

         #   out = dict()

         #   out['status'] = 'ok'

         #   s.wrapMessageAndSend(out, data)

         elif(command == 'get_registers_list'):

            #parse command arguments and convert them to string

            bank = data.get('bank', None)

            if not bank is None:

               bank = str(bank)

            registers = dict()

            try:

               registers = s.pcilib.get_registers_list(bank)

            except Exception as e:

               s.error(str(e), data) 

               return

            #Success! Create and send reply

            out = dict()

            out['status'] = 'ok'

            out['registers'] = registers

            s.wrapMessageAndSend(out, data)

         elif(command == 'get_register_info'):

            #check required arguments

            if not 'reg' in data:

               s.error('message doesnt contains "reg" field, '

                       'which is required for "get_register_info" command', data)

               return

            #parse command arguments and convert them to string

            reg = str(data.get('reg', None))

            bank = data.get('bank', None)

            if not bank is None:

               bank = str(bank)

            register = dict()

            try:

               register = s.pcilib.get_register_info(reg, bank)

            except Exception as e:

               s.error(str(e), data) 

               return

            #Success! Create and send reply

            s.wrapMessageAndSend({'status': 'ok', 'register': register}, data)

         elif(command == 'get_property_list'):   

            #parse command arguments and convert them to string

            branch = data.get('branch', None)

            if not branch is None:

               branch = str(branch)

            properties = dict()

            try:

               properties = s.pcilib.get_property_list(branch)

            except Exception as e:

               s.error(str(e), data) 

               return

            #Success! Create and send reply

            out = dict()

            out['status'] = 'ok'

            out['properties'] = properties

            s.wrapMessageAndSend(out, data)

         elif(command == 'read_register'):

            #check required arguments

            if not 'reg' in data:

               s.error('message doesnt contains "reg" field, '

                       'which is required for "read_register" command', data)

               return

            #parse command arguments and convert them to string

            reg = str(data.get('reg', None))

            bank = data.get('bank', None)

            if(not bank is None):

               bank = str(bank)

            value = 0

            try:

               value = s.pcilib.read_register(reg, bank)

            except Exception as e:

               s.error(str(e), data) 

               return

            #Success! Create and send reply

            out = dict()

            out['status'] = 'ok'

            out['value'] = value

            s.wrapMessageAndSend(out, data)

         elif(command == 'write_register'):

            #check required arguments

            if not 'reg' in data:

               s.error('message doesnt contains "reg" field, '

                       'which is required for "write_register" command', data)

               return

            if not 'value' in data:

               s.error('message doesnt contains "value" field, '

                       'which is required for "write_register" command', data)

               return

            #parse command arguments and convert them to string

            reg = str(data.get('reg', None))

            value = data.get('value', None)

            bank = data.get('bank', None)

            if(not bank is None):

               bank = str(bank)

            try:

               s.pcilib.write_register(value, reg, bank)

            except Exception as e:

               s.error(str(e), data) 

               return

            #Success! Create and send reply

            s.wrapMessageAndSend({'status': 'ok'}, data)

         elif(command == 'get_property'):

            #check required arguments

            if not 'prop' in data:

               s.error('message doesnt contains "prop" field, '

                       'which is required for "get_property" command', data)

               return

            #parse command arguments and convert them to string

            prop = str(data.get('prop', None))

            value = 0

            try:

               value = s.pcilib.get_property(prop)

            except Exception as e:

               s.error(str(e), data) 

               return

            #Success! Create and send reply

            out = dict()

            out['status'] = 'ok'

            out['value'] = value

            s.wrapMessageAndSend(out, data)

         elif(command == 'set_property'):

            #check required arguments

            if not 'prop' in data:

               s.error('message doesnt contains "prop" field, '

                       'which is required for "set_property" command', data)

               return

            if not 'value' in data:

               s.error('message doesnt contains "value" field, '

                       'which is required for "set_property" command', data)

               return

            #parse command arguments and convert them to string

            prop = str(data.get('prop', None))

            value = data.get('value', None)

            try:

               s.pcilib.set_property(value, prop)

            except Exception as e:

               s.error(str(e), data) 

               return

            #Success! Create and send reply

            s.wrapMessageAndSend({'status': 'ok'}, data)

         elif(command == 'lock'):

            #check required arguments

            if not 'lock_id' in data:

               s.error('message doesnt contains "lock_id" field, '

                       'which is required for "lock" command', data)

               return

            #parse command arguments and convert them to string

            lock_id = str(data.get('lock_id'))

            try:

               s.pcilib.lock_persistent(lock_id)

            except Exception as e:

               s.error(str(e), data) 

               return

            #Success! Create and send reply

            s.wrapMessageAndSend({'status': 'ok'}, data)

         elif(command == 'try_lock'):

            #check required arguments

            if not 'lock_id' in data:

               s.error('message doesnt contains "lock_id" field, '

                       'which is required for "try_lock" command', data)

               return

            #parse command arguments and convert them to string

            lock_id = str(data.get('lock_id'))

            persistent = bool(data.get('persistent', False))

            try:

               if persistent:

                  s.pcilib.try_lock_persistent(lock_id)

               else:

                  s.pcilib.try_lock(lock_id)

            except Exception as e:

               s.error(str(e), data) 

               return

            #Success! Create and send reply

            s.wrapMessageAndSend({'status': 'ok'}, data)

         elif(command == 'unlock'):

            #check required arguments

            if not 'lock_id' in data:

               s.error('message doesnt contains "lock_id" field, '

                       'which is required for "unlock" command', data)

               return

            #parse command arguments and convert them to string

            lock_id = str(data.get('lock_id'))

            persistent = bool(data.get('persistent', False))

            try:

               if persistent:

                  s.pcilib.unlock_persistent(lock_id)

               else:

                  s.pcilib.unlock(lock_id)

            except Exception as e:

               s.error(str(e), data) 

               return

            #Success! Create and send reply

            s.wrapMessageAndSend({'status': 'ok'}, data)

         elif(command == 'get_scripts_list'):

            scripts = list()

            try:

               scripts = s.pcilib.get_scripts_list()

            except Exception as e:

               s.error(str(e), data) 

               return

            #Success! Create and send reply

            s.wrapMessageAndSend({'status': 'ok', 'scripts': scripts}, data)

         elif(command == 'run_script'):

            #check required arguments

            if not 'script_name' in data:

               s.error('message doesnt contains "script_name" field, '

                       'which is required for "run_script" command', data)

               return

            #parse command arguments and convert them to string

            script_name = str(data.get('script_name'))

            value = data.get('value', None)

            out = None

            try:

               out = s.pcilib.run_script(script_name, value)

            except Exception as e:

               s.error(str(e), data) 

               return

            #Success! Create and send reply

            if(type(out) == bytearray or type(out) == bytes):

               s.send_response(200)

               s.send_header('content-disposition', 'inline; filename=value')

               s.send_header('content-type', 'application/octet-stream')

               s.end_headers()

               s.wfile.write(out)

            else:

               s.wrapMessageAndSend({'status': 'ok', 'value': out}, data)

         #elif(command == 'lock_global'):

         #   #check if global_lock already setted by server

         #   try:

         #      s.pcilib.lock_global()

         #   except Exception as e:

         #      s.error(str(e), data)

         #      return

         #   

         #   #Success! Create and send reply

         #   s.wrapMessageAndSend({'status': 'ok'}, data)

         #elif(command == 'unlock_global'):

         #   try:

         #      s.pcilib.unlock_global()

         #   except Exception as e:

         #      s.error(str(e), data)

         #      return

         #   

         #   #Success! Create and send reply

         #   s.wrapMessageAndSend({'status': 'ok'}, data)

         else:

            s.error('command "' + command + '" undefined', data)

            return

      else:

         s.error('message doesnt contains "command" field, which is required', data)

         return

   #open device context 

   #def openPcilibInstance(s, device, model):

   #   s.pcilib = pcipywrap.create_pcilib_instance(device, model)

   #Send help message

   def help(s, received_message = None):

      usage = str('Usage:\n'

      '  Server receive commands via http GET with json packet.\n'

      '  content-type should have value "application/json"\n'

      '  Server could handle only commands. to set command, you\n'

      '  should specify field "command" in packet with command name\n\n'

      '  If you use html server, you should call commands via GET request\n'

      '  like http://<server_host>:<port>/json/<command>?<arg1>=<arg_val1>&... \n'

      '\n'

      '  List of commands:\n'

      '\n'

      '  command: help - Get help. This will return usage\n'

      '\n'

      #'  command: open - Opens context of device. It will be reopened if already open.\n'

      #'    required fields\n'

      #'      device:       - path to the device file [/dev/fpga0]\n'

      #'    optional fields\n'

      #'      model:       - specifies the model of hardware, autodetected if doesnt exists\n'

      #'\n'

      '  command: get_registers_list - Returns the list of registers provided by the hardware model.\n'

      '    optional fields\n'

      '      bank:        - if set, only register within the specified bank will be returned\n'

      '\n'

      '  command: get_register_info - Returns the information about the specified register.\n'

      '    required fields\n'

      '      reg:         - the name of the register\n'

      '    optional fields\n'

      '      bank:        - if set, only register within the specified bank will be returned\n'

      '\n'

      '  command: get_property_list - Returns the list of properties available under the specified path.\n'

      '    optional fields\n'

      '     branch:        - Path. If not set, will return the top-level properties\n'

      '\n'

      '  command: read_register - Reads the specified register.\n'

      '    required fields\n'

      '      reg:         - the name of the register\n'

      '    optional fields\n'

      '      bank:        - if set, only register within the specified bank will be processed\n'

      '\n'

      '  command: write_register - Writes to specified register.\n'

      '    required fields\n'

      '      reg:         - the name of the register\n'

      '      value:       - the register value to write. Should be int, float or string (with number)\n'

      '    optional fields\n'

      '      bank:        - if set, only register within the specified bank will be processed\n'

      '\n'

      '  command: get_property - Reads / computes the property value.\n'

      '    required fields\n'

      '      prop:         - full name including path\n'

      '\n'

      '  command: set_property - Writes the property value or executes the code associated with property.\n'

      '    required fields\n'

      '      prop:        - full name including path\n'

      '      value:       - the property value to write. Should be int, float or string (with number)\n'

      '\n'

      '  command: lock - function to acquire a lock, and wait till the lock can be acquire.\n'

      '    required fields\n'

      '      lock_id: - lock id\n'

      '\n'

      '  command: try_lock - this function will try to take a lock for the mutex pointed by \n'

      '                    lockfunction to acquire a lock, but that returns immediatly if the\n'

      '                    lock can\'t be acquired on first try\n'

      '    required fields\n'

      '      lock_id: - lock id\n'

      '    optional fields\n'

      '      persistent: - 1 - lock is persistent, 0 othervise (default: 0)\n'

      '\n'

      '  command: unlock - this function unlocks the lock.\n'

      '    required fields\n'

      '      lock_id: - lock id\n'

      '    optional fields\n'

      '      persistent: - 1 - lock is persistent, 0 othervise (default: 0)\n'

      '\n'

      '  command: get_scripts_list - Get aviable scripts with description\n'

      '\n'

      '  command: run_script - Run specified script\n'

      '    required fields\n'

      '      script_name: - script name (without extension)\n'

      '      value: - input value in json format\n'

      '\n'

      '\n')

      #send help as plain text

      s.send_response(200)

      s.send_header('content-type', 'text/plain')

      s.end_headers()

      if sys.version_info >= (3,0):

         s.wfile.write(bytes(usage, 'UTF-8'))

      else:

         s.wfile.write(usage)

   #Send error message with text description    

   def error(s, info, received_message = None):

      out = dict()

      out['status'] = 'error'

      out['description'] = info

      out['note'] = 'send {"command" : "help"} to get help'

      s.wrapMessageAndSend(out, received_message, 400)

   def wrapMessageAndSend(s, message, received_message = None, response = 200):

      s.send_response(response)

      s.send_header('content-type', 'application/json')

      s.end_headers()

      if not received_message is None:

         message['received_message'] = received_message

      if sys.version_info >= (3,0):

         s.wfile.write(bytes(json.dumps(message), 'UTF-8'))

      else:

         s.wfile.write(json.dumps(message))

class ApiServer(MultiThreadedHTTPServer):

   def __init__(self, device='/dev/fpga0', model=None, adress=('0.0.0.0', 9000)):

      #redirect logs to exeption

      pcilib.redirect_logs_to_exeption()

      #pass Pcipywrap to to server handler

      self.lib = pcilib.pcilib(device, model)

      def handler(*args):

         PcilibServerHandler(self.lib, *args)

      MultiThreadedHTTPServer.__init__(self, adress, handler)

if __name__ == '__main__':

   #parce command line options

   parser = OptionParser()

   parser.add_option("-p", "--port",  action="store",

                     type="int", dest="port", default=9000,

                     help="Set server port (9000)")

   parser.add_option("-d", "--device",  action="store",

                     type="string", dest="device", default=str('/dev/fpga0'),

                     help="FPGA device (/dev/fpga0)")                     

   parser.add_option("-m", "--model",  action="store",

                     type="string", dest="model", default=None,

                     help="Memory model (autodetected)")

   opts = parser.parse_args()[0]

   HOST_NAME = '0.0.0.0'

   PORT_NUMBER = opts.port

   MODEL = opts.model

   DEVICE = opts.device

   #start server

   httpd = ApiServer(DEVICE, MODEL, (HOST_NAME, PORT_NUMBER))

   print(time.asctime(), "Server Starts - %s:%s" % (HOST_NAME, PORT_NUMBER))

   try:

      httpd.serve_forever()

   except KeyboardInterrupt:

      pass

   httpd.server_close()

   print(time.asctime(), "Server Stops - %s:%s" % (HOST_NAME, PORT_NUMBER))