/alps/pcitool

To get this branch, use:
bzr branch http://suren.me/webbzr/alps/pcitool

« back to all changes in this revision

Viewing changes to html_server/html_server.py

  • Committer: Vasilii Chernov
  • Date: 2016-03-01 15:42:48 UTC
  • mto: This revision was merged to the branch mainline in revision 367.
  • Revision ID: vchernov@inr.ru-20160301154248-dpu4wdachiezj2fb
1. api-serer:
   - change multiprosessing work mechanism
   - add new pywrap functions handling
2. html-server: 
   - now works through api-server

Show diffs side-by-side

added added

removed removed

Lines of Context:
html_server/html_server.py
1
 
import pcipywrap
2
1
import json
3
 
from optparse import OptionParser
 
2
 
 
3
from optparse import OptionParser, OptionGroup
 
4
from multiprocessing import Process
 
5
 
 
6
import requests
 
7
from api_server import ApiServer
4
8
 
5
9
#import flask elements
6
10
from flask import render_template
9
13
from flask import url_for
10
14
from flask import redirect
11
15
from flask import send_from_directory
 
16
from flask import make_response
12
17
 
13
18
app = Flask(__name__)
14
 
pcilib = 0;
15
 
device = '/dev/fpga0'
16
 
model = ''
17
 
 
18
 
# property json api
19
 
@app.route("/property_info_json")
20
 
def get_property_list_json():
21
 
   branch = request.args.get('branch')
22
 
   if not branch is None:
23
 
      branch = str(branch)
24
 
   
25
 
   prop_info = 0
26
 
   try:
27
 
      prop_info = pcilib.get_property_list(branch)
28
 
      return json.dumps(prop_info)
29
 
   except Exception as e:
30
 
      return json.dumps({'error': str(e)})
31
 
 
32
 
@app.route('/get_property_json')
33
 
def get_property_json():
34
 
   prop = request.args.get('prop')
35
 
 
36
 
   try:
37
 
      val = pcilib.get_property(str(prop))
38
 
      return json.dumps({'value': val})
39
 
   except Exception as e:
40
 
      return json.dumps({'error': str(e)})
41
 
      
42
 
@app.route('/set_property_json')
43
 
def set_property_json():
44
 
   val = request.args.get('val')
45
 
   prop = request.args.get('prop')
46
 
 
47
 
   try:
48
 
      pcilib.set_property(float(val), str(prop))
49
 
      return json.dumps({'status': 'ok'})
50
 
   except Exception as e:
51
 
      return json.dumps({'error': str(e)})
52
 
      
53
 
# register json api
54
 
@app.route("/registers_list_json")
55
 
def get_registers_list_json():
56
 
   reg_list = 0
57
 
   try:
58
 
      reg_list = pcilib.get_registers_list()
59
 
      return json.dumps(reg_list)
60
 
   except Exception as e:
61
 
      return json.dumps({'error': str(e)})
62
 
 
63
 
@app.route('/read_register_json')
64
 
def read_register_json():
65
 
   name = request.args.get('name')
66
 
   bank = request.args.get('bank')
67
 
   
68
 
   try:
69
 
      value = pcilib.read_register(str(name), str(bank))
70
 
      return json.dumps({'value': value})
71
 
   except Exception as e:
72
 
      return json.dumps({'error': str(e)})
73
 
 
74
 
@app.route('/write_register_json')
75
 
def write_register_json():
76
 
   val = request.args.get('val')
77
 
   name = request.args.get('name')
78
 
   bank = request.args.get('bank')
79
 
 
80
 
   try:
81
 
      pcilib.write_register(float(val), str(name), str(bank))
82
 
      return json.dumps({'status': 'ok'})
83
 
   except Exception as e:
84
 
      return json.dumps({'error': str(e)})
 
19
api_server_port = 9000
 
20
api_server_host = '0.0.0.0'
 
21
 
 
22
@app.route("/json/<command>")
 
23
def process_json_command(command):
 
24
   headers = {'content-type': 'application/json'}
 
25
   message = {'command': command}
 
26
   
 
27
   for arg in request.args:
 
28
      message[arg] = request.args[arg]
 
29
      
 
30
   r = 0;
 
31
   try:
 
32
      r = requests.get('http://' + api_server_host + ':' + str(api_server_port),
 
33
                       data=json.dumps(message),
 
34
                       headers=headers)
 
35
   except Exception as e:
 
36
      return str(json.dumps({'status':'error', 'description': e}))
 
37
   
 
38
   #application/octet-stream
 
39
   response = make_response(r.content)
 
40
   for header in r.headers:
 
41
      response.headers[header] = r.headers[header]
 
42
      
 
43
   return response
85
44
 
86
45
#html api
87
 
@app.route('/set_property')
88
 
def set_property():
89
 
   val = request.args.get('val')
90
 
   prop = request.args.get('prop')
91
 
 
92
 
   try:
93
 
      pcilib.set_property(float(val), str(prop))
94
 
      return redirect(url_for('get_property_list', branch=prop))
95
 
   except Exception as e:
96
 
      return str(e)
97
 
   
98
 
@app.route('/write_register')
99
 
def write_register():
100
 
   val = request.args.get('val')
101
 
   name = request.args.get('name')
102
 
   bank = request.args.get('bank')
103
 
 
104
 
   try:
105
 
      pcilib.write_register(float(val), str(name), str(bank))
106
 
      return redirect(url_for('get_register_info', name=name, bank=bank))
107
 
   except Exception as e:
108
 
      return str(e)
109
 
 
110
46
@app.route('/register_info')
111
47
def get_register_info():
 
48
   #get parameters
112
49
   name = request.args.get('name')
113
50
   bank = request.args.get('bank')
114
51
   
 
52
   #load register info
115
53
   reg_info = 0
116
54
   value = dict()
117
55
   try:
118
 
      reg_info = pcilib.get_register_info(str(name), str(bank))
119
 
      value[name] = pcilib.read_register(str(name), str(bank))
 
56
      r = requests.get(url_for('process_json_command', 
 
57
                               command = 'get_register_info',
 
58
                               bank = bank,
 
59
                               reg = name, _external = True))
 
60
      if(r.json().get('status') == 'error'):
 
61
         return 'Error: ' + r.json()['description']
 
62
         
 
63
      reg_info = r.json()['register']
 
64
      
 
65
      #get register value
 
66
      r = requests.get(url_for('process_json_command', 
 
67
                               command = 'read_register',
 
68
                               bank = bank,
 
69
                               reg = name, _external = True))
 
70
      if(r.json().get('status') == 'error'):
 
71
         return 'Error: ' + r.json()['description']
 
72
         
 
73
      value[name] = r.json()['value']
120
74
   except Exception as e:
121
75
      return str(e)
 
76
   
122
77
   return render_template('register_info.html',
123
78
                          register=reg_info,
124
79
                          value=value)
125
80
                             
126
81
@app.route("/registers_list")
127
82
def get_registers_list():
 
83
   #get parameters
128
84
   bank = request.args.get('bank')
129
85
   if not bank is None:
130
86
      bank = str(bank)
131
 
      
132
 
   reg_list = 0
 
87
   
 
88
   #load registers list
 
89
   reg_list = []
133
90
   try:
134
 
      reg_list = pcilib.get_registers_list(bank)
 
91
      r = requests.get(url_for('process_json_command', 
 
92
                               command = 'get_registers_list',
 
93
                               bank = bank, _external = True))
 
94
      if(r.json().get('status') == 'error'):
 
95
         return 'Error: ' + r.json()['description']
 
96
      reg_list = r.json()['registers']
135
97
   except Exception as e:
136
98
      return str(e)
137
99
   
 
100
   #get register values
138
101
   value = dict()
139
102
   for reg in reg_list:
140
103
      try:
141
 
         value[reg['name']] = pcilib.read_register(str(reg['name']),
142
 
                                                   str(reg['bank']))
 
104
         r = requests.get(url_for('process_json_command', 
 
105
                                  command = 'read_register',
 
106
                                  bank = str(reg['bank']), 
 
107
                                  reg = str(reg['name']), _external = True))
 
108
         if(r.json().get('status') == 'error'):
 
109
            value[reg['name']] = 'Error: ' + r.json()['description']
 
110
         else:
 
111
            value[reg['name']] = r.json()['value']
 
112
         
143
113
      except Exception as e:
144
 
         value[reg['name']] = str(e)
 
114
         value[reg['name']] = 'Error: ' + str(e)
145
115
 
 
116
   #render result
146
117
   return render_template('registers_list.html',
147
118
                          registers = reg_list,
148
119
                          render_template = render_template,
151
122
 
152
123
@app.route("/property_info")
153
124
def get_property_list():
 
125
   #get parameters
154
126
   branch = request.args.get('branch')
155
127
   if not branch is None:
156
128
      branch = str(branch)
157
129
   
158
 
   prop_info = 0
 
130
   #get properties info
 
131
   prop_info = 0  
159
132
   try:
160
 
      prop_info = pcilib.get_property_list(branch)
 
133
      r = requests.get(url_for('process_json_command', 
 
134
                               command = 'get_property_list',
 
135
                               branch = branch, _external = True))
 
136
                               
 
137
      if(r.json().get('status') == 'error'):
 
138
         return 'Error: ' + r.json()['description']
 
139
         
 
140
      prop_info = r.json()['properties']
 
141
      
161
142
   except Exception as e:
162
143
      return str(e)
163
144
   
164
145
   value = dict()
165
 
   if (len(prop_info) == 1) and not ('childs' in (prop_info[0])['flags']):
 
146
   for prop in prop_info:
166
147
      try:
167
 
         branch = (prop_info[0])['path']
168
 
         value[branch] = pcilib.get_property(branch)
 
148
         path = prop['path']
 
149
         r = requests.get(url_for('process_json_command', 
 
150
                                  command = 'get_property',
 
151
                                  prop = path, _external = True))
 
152
         if(r.json().get('status') == 'error'):
 
153
            value[path] = 'Error: ' + r.json()['description']
 
154
         else:   
 
155
            value[path] = r.json()['value']
 
156
            
169
157
      except Exception as e:
170
 
         return str(e) 
171
 
   else:
172
 
      for prop in prop_info:
173
 
         try:
174
 
            path = prop['path']
175
 
            value[path] = pcilib.get_property(path)
176
 
         except Exception as e:
177
 
            value[path] = str(e)
 
158
         value[path] = str(e)
178
159
 
179
160
   return render_template('property_info.html',
180
161
                          value = value,
195
176
   parser.add_option("-p", "--port",  action="store",
196
177
                     type="int", dest="port", default=5000,
197
178
                     help="Set server port (5000)")
198
 
   parser.add_option("-d", "--device",  action="store",
199
 
                     type="string", dest="device", default=str('/dev/fpga0'),
200
 
                     help="FPGA device (/dev/fpga0)")                     
201
 
   parser.add_option("-m", "--model",  action="store",
202
 
                     type="string", dest="model", default=None,
203
 
                     help="Memory model (autodetected)")
 
179
                     
 
180
   pcilib_group = OptionGroup(parser, "Api server",
 
181
                              "Api server options group")
 
182
   pcilib_group.add_option("-e", "--external",  action="store_true",
 
183
                           dest="external_api_server", 
 
184
                           default=False,
 
185
                           help="Dont start own api server. Use external"
 
186
                                " server instead");                     
 
187
   pcilib_group.add_option("--api-server-host", action="store",
 
188
                           type="string", dest="api_server_host",
 
189
                           default='0.0.0.0',
 
190
                           help="Api server ip adress (0.0.0.0)")
 
191
   pcilib_group.add_option("--api-server-port", action="store",
 
192
                           type="int", dest="api_server_port",
 
193
                           default=9000,
 
194
                           help="Api server port (9000)")
 
195
   pcilib_group.add_option("-d", "--device",  action="store",
 
196
                           type="string", dest="device", 
 
197
                           default=str('/dev/fpga0'),
 
198
                           help="FPGA device (/dev/fpga0)")
 
199
   pcilib_group.add_option("-m", "--model",  action="store",
 
200
                           type="string", dest="model", default=None,
 
201
                           help="Memory model (autodetected)")
 
202
                       
 
203
   parser.add_option_group(pcilib_group)
 
204
                     
204
205
   opts = parser.parse_args()[0]
205
206
   
206
207
   HOST_NAME = '0.0.0.0'
209
210
   device = opts.device
210
211
   model = opts.model
211
212
   
212
 
   pcilib = pcipywrap.Pcipywrap(device, model)
213
 
   pcipywrap.__redirect_logs_to_exeption()
214
 
   app.run(host = HOST_NAME, port = PORT_NUMBER, threaded=True)
 
213
   #start api server in separate process
 
214
   api_server_host = opts.api_server_host
 
215
   api_server_port = opts.api_server_port
 
216
   if(not opts.external_api_server):
 
217
      api_server = ApiServer(device, model, (api_server_host, api_server_port))
 
218
      def serve_forever(server):
 
219
         try:
 
220
            server.serve_forever()
 
221
         except KeyboardInterrupt:
 
222
            pass
 
223
      
 
224
      Process(target=serve_forever, args=(api_server,)).start()
 
225
   
 
226
   #start Flask html server
 
227
   app.run(host = HOST_NAME, 
 
228
           port = PORT_NUMBER,
 
229
           threaded=True,
 
230
           #debug=True
 
231
         )