1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
|
# Copyright (c) 2016 Weitian LI <liweitianux@live.com>
# MIT license
"""
Handle the AJAX requests from the client to manage the simulation products.
"""
import os
import logging
import shutil
import tornado.ioloop
from tornado.escape import json_decode, json_encode
from .base import BaseRequestHandler
logger = logging.getLogger(__name__)
class ProductsAJAXHandler(BaseRequestHandler):
"""
Handle the AJAX requests from the client to manage the simulation products.
Attributes
----------
from_localhost : bool
``True`` if the request is from the localhost, otherwise ``False``.
"""
def initialize(self):
"""Hook for subclass initialization. Called for each request."""
self.products = self.application.products
if self.request.remote_ip == "127.0.0.1":
self.from_localhost = True
else:
self.from_localhost = False
def get(self):
"""
Handle the READ-ONLY products manifest manipulations.
Supported actions:
- get: Get the current products manifest
- which: Locate the command/program (check whether the command/program
can be found in PATH and is executable)
- download: TODO
- open: TODO
"""
action = self.get_argument("action", "get")
if action == "get":
# Get current products manifest
response = {
"manifest": self.products.manifest,
"localhost": self.from_localhost,
}
success = True
elif action == "which":
# Locate (and check) the command/program
cmd = json_decode(self.get_argument("cmd"))
cmdpath = shutil.which(cmd)
if cmdpath:
success = True
response = {
"isExecutable": True,
"cmdPath": cmdpath,
}
else:
success = False
reason = "Cannot locate the executable for: {0}".format(cmd)
else:
# ERROR: bad action
success = False
reason = "Bad request action: {0}".format(action)
#
if success:
logger.debug("Response: {0}".format(response))
self.set_header("Content-Type", "application/json; charset=UTF-8")
self.write(json_encode(response))
else:
logger.warning("Request failed: {0}".format(reason))
self.send_error(400, reason=reason)
@tornado.web.authenticated
def post(self):
"""
Handle the READ-WRITE products manifest manipulations.
Supported actions:
- load: Load the products manifest from file
- save: Save the current products manifest to file
- reset: Reset existing products manifest
- convert: Convert the product from HEALPix map to HPX image
"""
request = json_decode(self.request.body)
logger.debug("Received request: {0}".format(request))
action = request.get("action")
response = {"action": action}
if action == "load":
# Load the manifest from supplied file
try:
success, reason = self._load_products(request["manifestfile"])
except KeyError:
success = False
reason = "'manifestfile' is missing"
elif action == "save":
# Save current products manifest to file
try:
success, reason = self._save_products(request["outfile"],
request["clobber"])
except KeyError:
success = False
reason = "'outfile' or 'clobber' is missing"
elif action == "reset":
# Reset existing products manifest
success = self._reset_products()
elif action == "convert":
# Convert the product from HEALPix map to HPX image
try:
comp_id = request["compID"]
freq_id = request["freqID"]
success, reason = self._convert_hpx(comp_id, freq_id)
data = self.products.get_product(comp_id, freq_id)
response["data"] = data
except KeyError:
success = False
reason = "'compID' or 'freqID' is missing"
else:
# ERROR: bad action
success = False
reason = "Bad request action: {0}".format(action)
#
if success:
response["success"] = success
logger.debug("Response: {0}".format(response))
self.set_header("Content-Type", "application/json; charset=UTF-8")
self.write(json_encode(response))
else:
logger.warning("Request failed: {0}".format(reason))
self.send_error(400, reason=reason)
def _reset_products(self):
"""Reset the existing products manifest."""
self.products.reset()
return True
def _load_products(self, manifestfile):
"""
Load the products manifest from file.
Parameters
----------
manifestfile: str
The path to the products manifest file, which must be
an *absolute path*.
Returns
-------
success : bool
``True`` if the operation succeeded, otherwise, ``False``.
error : str
If failed, this ``error`` saves the details, otherwise, ``None``.
"""
success = False
error = None
if os.path.isabs(os.path.expanduser(manifestfile)):
self.products.load(manifestfile)
success = True
else:
error = "Not an absolute path"
return (success, error)
def _save_products(self, outfile, clobber=False):
"""
Save current products manifest to file.
Parameters
----------
outfile: str
The filepath to the output manifest file, which must be
an *absolute path*.
clobber : bool, optional
Whether overwrite the output file if already exists?
Returns
-------
success : bool
``True`` if the operation succeeded, otherwise, ``False``.
error : str
If failed, this ``error`` saves the details, otherwise, ``None``.
"""
success = False
error = None
try:
self.products.dump(outfile, clobber=clobber)
success = True
except (ValueError, OSError) as e:
error = str(e)
return (success, error)
def _convert_hpx(self, comp_id, freq_id):
"""
Convert the HEALPix map of the product to HPX projected FITS image.
FIXME/TODO: make this non-blocking!
"""
success = False
error = None
try:
self.products.convert_hpx(comp_id, freq_id, clobber=True)
success = True
except IOError as e:
error = str(e)
return (success, error)
|
