async def change_bot_state(request: "web.Request") -> "web.Response":
bot = get_bot(request)
action = request.match_info["action"]
if action.lower() == "pause":
bot.pause()
raise web.HTTPAccepted()
elif action.lower() == "resume":
bot.resume()
raise web.HTTPAccepted()
else:
raise web.HTTPBadRequest()
async def change_bot_state(request: 'web.Request') -> 'web.Response':
bot = get_bot(request)
action = request.match_info['action']
if action.lower() == 'pause':
bot.pause()
raise web.HTTPAccepted()
elif action.lower() == 'resume':
bot.resume()
raise web.HTTPAccepted()
else:
raise web.HTTPBadRequest()
async def datasource_start(request: web.Request):
"""Start the datasource"""
source_id = request.match_info['id']
if source_id in request.app['datasources']:
raise web.HTTPBadRequest(reason='Datasource is already running')
path = os.path.join(request.app['settings'].DATASOURCE_DIR, source_id)
if not os.path.exists(path):
raise web.HTTPBadRequest(
reason=f'datasource with id {source_id} does not exists')
with open(path, 'r') as f:
kwargs = json.loads(f.read())
topic = f'{request.app["topic_counter"]:04}'
request.app['topic_counter'] += 1
request.app['datasources'].set_source(
source_id=source_id,
addr=tuple(kwargs['addr']),
topic=topic,
input_byte_format=kwargs['input_byte_format'],
input_names=kwargs['input_names'],
output_refs=kwargs['output_refs'],
time_index=kwargs['time_index'],
)
request.app['topics'][topic] = {
'url':
'/datasources/' + source_id,
'output_names':
request.app['datasources'].get_source(source_id).output_names,
'byte_format':
request.app['datasources'].get_source(source_id).byte_format,
}
return web.HTTPAccepted()
async def create_project(request: web.Request):
r = await request.post()
data = r['file'] # data is the file
headers = request.headers
content_length = int(headers['Content-length'])
projectName = headers["projectName"]
os.makedirs(request.app['settings'].PROJECT_DIR + "/" + projectName,
exist_ok=True)
# Write ".FMM" to disc
if (".fmm" in data.filename):
# request.app cannot be correct?
fmmPath = request.app[
'settings'].PROJECT_DIR + "/" + projectName + "/" + data.filename
with open(fmmPath, 'w', newline='\n') as file:
file.write(data.file.read(content_length).decode(
'ascii')) # writes .fmm to file
print(request.app['settings'].PROJECT_DIR, projectName, data.filename)
# Write ".FMU" to disc
if (".fmu" in data.filename):
fmuPath = request.app[
'settings'].PROJECT_DIR + "/" + projectName + "/" + data.filename
with open(fmuPath, 'wb') as file:
file.write(data.file.read(content_length)) # writes .fmu to file
thread = threading.Thread(target=processFMUfile,
args=(request, fmuPath))
#await processFMUfile(request, fmuPath)
thread.daemon = True # Daemonize thread
thread.start()
return web.HTTPAccepted()
async def processor_inputs_update(request: web.Request):
"""
Update the processor inputs
Post params:
- input_ref: reference values to the inputs to be used
- measurement_ref: reference values to the measurement inputs to be used for the inputs.
Must be in the same order as input_ref.
- measurement_proportion: scale to be used on measurement values before inputting them.
Must be in the same order as input_ref.
"""
post = await request.post()
processor_id = request.match_info['id']
if processor_id not in request.app['processors']:
return web.HTTPNotFound()
input_refs = await try_get_all(post, 'input_ref', int)
measurement_refs = await try_get_all(post, 'measurement_ref', int)
measurement_proportions = await try_get_all(post, 'measurement_proportion',
float)
processor = request.app['processors'][processor_id]
try:
input_names = processor.set_inputs(input_refs, measurement_refs,
measurement_proportions)
except:
raise web.HTTPUnprocessableEntity(
reason='The selected processor does not seem to be running.')
request.app['topics'][processor.topic]['input_names'] = input_names
raise web.HTTPAccepted()
async def processor_outputs_update(request: web.Request):
"""
Update the processor outputs
Post params:
- output_ref: reference values to the outputs to be used
"""
post = await request.post()
processor_id = request.match_info['id']
if processor_id not in request.app['processors']:
return web.HTTPNotFound()
processor: Processor = request.app['processors'][processor_id]
if post.get('output_ref') == 'all':
output_names = processor.set_outputs('all')
else:
output_refs = await try_get_all(post, 'output_ref', int)
try:
output_names = processor.set_outputs(output_refs)
except:
raise web.HTTPUnprocessableEntity(
reason='The selected processor does not seem to be running.')
request.app['topics'][
processor.topic]['byte_format'] = processor.byte_format
request.app['topics'][processor.topic]['output_names'] = output_names
raise web.HTTPAccepted()
async def toggle_job(self, request):
data = await request.post()
self.logger.debug("received toggle request {0}".format(data))
if 'command' not in data or \
'minute' not in data or \
'hour' not in data or \
'dom' not in data or \
'month' not in data or \
'dow' not in data:
return web.Response(status=500,
text='not all mandatory fields submitted')
cron_item = self.generate_cron_item(data)
if cron_item not in self.storage.cluster_jobs:
raise web.HTTPConflict(text='job not found on cluster')
self.logger.debug("broadcasting run result")
broadcast(self.udp_port,
UdpSerializer.dump(Toggle(cron_item), self.hash_key))
raise web.HTTPAccepted()
async def delete_expansion(data_store, amqp, node_id):
expansion = utils.delete_object(data_store, amqp, node_id,
utils.KEY_EXPANSION)
expansion.status = "Deleting"
expansion.deleting = True
data_store.save(expansion)
await send_delete_expansion(data_store, amqp, expansion)
raise web.HTTPAccepted()
async def unsubscribe(request: web.Request):
"""Unsubscribe to the given topic"""
topic = request.match_info['id']
client = await get_client(request)
if topic not in request.app['topics']:
raise web.HTTPNotFound()
request.app['subscribers'][topic].discard(client)
raise web.HTTPAccepted()
async def delete_vpn_connection(data_store, amqp, node_id):
vpn_connection = utils.delete_object(data_store, amqp, node_id,
utils.KEY_CONNECTION)
vpn_connection.status = "Deleting"
vpn_connection.deleting = True
data_store.save(vpn_connection)
await send_delete_connection(data_store, amqp, vpn_connection)
raise web.HTTPAccepted()
async def delete_mptcp_proxy(data_store, amqp, node_id):
mptcp_proxy = utils.delete_object(data_store, amqp, node_id,
utils.KEY_MPTCP_PROXY)
mptcp_proxy.status = "Deleting"
mptcp_proxy.deleting = True
data_store.save(mptcp_proxy)
await send_delete_proxy(data_store, amqp, mptcp_proxy)
raise web.HTTPAccepted()
async def delete_l2_tunnel(data_store, amqp, node_id):
l2_tunnel = utils.delete_object(data_store, amqp, node_id,
utils.KEY_L2_TUNNEL)
l2_tunnel.status = "Deleting"
l2_tunnel.deleting = True
data_store.save(l2_tunnel)
await send_delete_tunnel(data_store, amqp, l2_tunnel)
raise web.HTTPAccepted()
async def handle_message(self, request):
""" Put to message queue and return 202 to client.
"""
if not request.app['agent'].initialized:
raise web.HTTPUnauthorized()
msg = await request.read()
await self.msg_queue.put(msg)
raise web.HTTPAccepted()
async def __call__(self, request):
kw = None
if self._has_var_kw_arg or self._has_named_kw_args or self._has_request_arg:
if request.method == 'POST':
if not request.content_type:
return web.HTTPBadRequest('Missing Content-Type.')
ct = request.content_type.lower()
if ct.startswith('application/json'):
params = await request.json()
if not isinstance(params, dict):
return web.HTTPAccepted('JSON body must be object.')
kw = params
elif ct.startswith('application/x-www-form-urlencoded'
) or ct.startswith('multipart/form-data'):
params = await request.post()
kw = dict(**params)
else:
return web.HTTPBadRequest('Unsupported Content-Type: %s' %
request.content_type)
if request.method == 'GET':
qs = request.query_string
if qs:
kw = dict()
for k, v in parse.parse_qs(qs, True).items():
kw[k] = v[0]
if kw is None:
kw = dict(**request.match_info)
else:
if not self._has_var_kw_arg and self._named_kw_args:
#remove all unamed kw:
copy = dict()
for name in self._named_kw_args:
if name in kw:
copy[name] = kw[name]
kw = copy
# check named arg:
for k, v in request.match_info.items():
if k in kw:
logging.warning(
'Duplicate arg name in named arg and kw args: %s' % k)
kw[k] = v
if self._has_request_arg:
kw['request'] = request
# check required kw:
if self._required_kw_args:
for name in self._required_kw_args:
if not name in kw:
return web.HTTPBadRequest('Missing argument: %s' % name)
logging.info('call with args: %s' % str(kw))
try:
r = await self._func(**kw)
return r
except Exception as e:
#return dict(error=e.error, data=e.data, message=e.message)
pass
async def subscribe(request: web.Request):
"""Subscribe to the given topic"""
topic = request.match_info['id']
client = await get_client(request)
if topic not in request.app['topics']:
raise web.HTTPNotFound()
request.app['subscribers'][topic].add(client)
print("client: ", client, "added to topic ", topic)
raise web.HTTPAccepted()
async def handle_message(self, request):
""" Put connection offer onto the mssage queue and return 202.
"""
if not request.app['agent'].initialized:
raise web.HTTPUnauthorized()
msg = await request.read()
await self.msg_queue.put(msg)
raise web.HTTPAccepted()
async def handle(request):
"""aiohttp handle POST."""
response = []
with channel_manager.reply_handler(response.append):
await channel_manager.handle(await request.read())
if response:
return web.Response(body=response.pop())
raise web.HTTPAccepted()
async def post_handle(request):
"""Handle posted messages."""
response = []
with conn.session(response.append) as session:
await session.handle(await request.read())
if response:
return web.Response(text=response.pop())
raise web.HTTPAccepted()
async def handle(request):
"""aiohttp handle POST."""
response = []
with suite.reply(response.append):
await suite.handle(await request.read())
if response:
return web.Response(body=response.pop())
raise web.HTTPAccepted()
async def handle(request):
"""aiohttp handle POST."""
response = []
with conn.reply_handler(response.append):
await conn.handle(await request.read())
if response:
return web.Response(text=response.pop())
raise web.HTTPAccepted()
async def handle(request):
"""aiohttp handle POST."""
response = []
with conn.session(response.append) as session:
await conn.handle(await request.read(), session)
if response:
return web.Response(body=response.pop())
raise web.HTTPAccepted()
async def datasource_delete(request: web.Request):
"""Delete the datasource"""
source_id = request.match_info['id']
if source_id in request.app['datasources']:
raise web.HTTPBadRequest(reason='Datasource must be stopped first')
path = os.path.join(request.app['settings'].DATASOURCE_DIR, source_id)
if not os.path.exists(path):
raise web.HTTPBadRequest(
reason=f'datasource with id {source_id} does not exists')
os.remove(path)
return web.HTTPAccepted()
async def unlock_key(request):
"""Unlock a key via a POST request.
POST request takes the form:
\{"type": "pgp", "private": "path/to/file.sec", "passphrase": "pass", "expire": "30/MAR/18 08:00:00"\}
"""
key_info = await request.json()
LOG.debug(f'Admin unlocking: {key_info}')
if all(k in key_info for k in ("path", "passphrase", "expire")):
await activate_key(key_info['type'], key_info)
return web.HTTPAccepted()
else:
return web.HTTPBadRequest()
async def unlock_key(request):
"""Unlock a key via a POST request.
POST request takes the form:
{"private": "path/to/file.sec", "passphrase": "pass", "expire": "30/MAR/18 08:00:00"}
"""
key_info = await request.json()
LOG.debug(f'Admin unlocking: {key_info}')
if all(k in key_info for k in ("path", "passphrase", "expire")):
_unlock_key('whichname?', **key_info)
return web.HTTPAccepted()
else:
return web.HTTPBadRequest()
async def post_handle(request):
msg = await request.read()
conn = HTTPConnection(msg)
await request.app['connection_queue'].put(conn)
try:
await asyncio.wait_for(conn.wait(), 5)
except asyncio.TimeoutError:
await conn.close()
if conn.new_msg:
return web.Response(body=conn.new_msg)
raise web.HTTPAccepted()
async def data(request):
if request.body_exists and request.content_type == 'application/json':
try:
data = await request.json()
except json.decoder.JSONDecodeError:
raise web.HTTPBadRequest(text='bad or empty json\n')
print("data recieved:", data)
#await write_into_db(data)
async with request.app['db'].acquire() as conn:
result, err = await save_json(conn, data) #save data into db
if result:
raise web.HTTPAccepted(text='json recieved\n')
else:
raise web.HTTPBadRequest(text=err + '\n')
else:
raise web.HTTPForbidden(text='only json allowed\n')
async def process_single_rpc(self, rpc_data: dict) -> dict:
try:
protocol_version = rpc_data["jsonrpc"]
method_name = rpc_data["method"]
params = rpc_data.get("params", [])
rid = rpc_data.get("id", None)
except KeyError:
raise JsonRpcError(Errors.INVALID_REQUEST)
if protocol_version != PROTOCOL_VERSION:
raise JsonRpcError(
Errors.INVALID_REQUEST,
detail=f"Unsupported protocol version {protocol_version}",
)
if method_name not in self.methods:
raise JsonRpcError(Errors.METHOD_NOT_FOUND, rid=rid)
if not isinstance(params, (list, dict, None)):
raise JsonRpcError(Errors.INVALID_PARAMS, rid=rid)
try:
if isinstance(params, list):
result = await self.methods[method_name](*params)
else:
result = await self.methods[method_name](**params)
except JsonRpcError as exc:
exc.set_context(rid=rid)
raise exc
except TypeError as exc:
new_exp = JsonRpcError(Errors.INVALID_PARAMS,
rid=rid,
detail=exc_message(exc))
raise new_exp.with_traceback() if self.debug else new_exp
except Exception: # pylint: disable=broad-except
exp_class, exc, trace = sys.exc_info()
logger = logging.getLogger("aiohttp.server")
logger.error("".join(format_exception(exp_class, exc, trace)))
new_exc = JsonRpcError(detail=exc_message(exc), rid=rid)
if self.debug:
raise new_exc.with_traceback()
raise new_exc
if not rid:
raise web.HTTPAccepted()
return {"jsonrpc": protocol_version, "result": result, "id": rid}
async def get_file(request: web.Request) -> FileResponse:
"""For worker to pull file for calculating file hash task
request headers:
* X-DISTRIBUTED-WORKER-NAME: worker's name, worker should been registered
already. required
responses:
* 200 OK: file response
* 202 Accepted: wait for processing files timeout and make request again
* 204 No Content: no more files
* 400 Bad Request: missing worker name header
* 400 Bad Request: worker not registered yet
"""
master = request.app["master"]
worker_name = _get_worker_name(request)
_ensure_worker_registered(master, worker_name)
try:
file_path = master.files_queue.get_nowait()
except asyncio.QueueEmpty:
# try to get timeout task
timeout_file = master.get_earlist_timeout_file()
if timeout_file:
_worker_name, file_path, _ = timeout_file
# remove old processing file
master.remove_current_processing_file(_worker_name, file_path)
else:
# try to find out any processing files
if not master.has_processing_files():
# no more files
raise web.HTTPNoContent()
else:
# tell workers to wait until processing files timeout
raise web.HTTPAccepted(
text=("wait for processing files timeout and make request"
" again"))
master.new_processing_file(worker_name, file_path)
master.files_queue.task_done()
full_path = master.home.get_full_path(file_path)
headers = {constants.HTTP_HEADER_X_FILE_PATH: file_path}
return FileResponse(full_path, headers=headers)
async def re_balance(self, request):
self.logger.debug("rebalance request received")
self.scheduler.re_balance()
jobs = self.storage.cluster_jobs.copy()
broadcast(
self.udp_port,
UdpSerializer.dump(ReBalance(timestamp=datetime.now()),
self.hash_key))
time.sleep(5)
for job in jobs:
broadcast(self.udp_port, UdpSerializer.dump(job, self.hash_key))
raise web.HTTPAccepted()
async def upload_datafile(request: web.Request):
r = await request.post()
data = r['file']
headers = request.headers
content_length = int(headers['Content-length'])
project_name = headers["projectName"]
os.makedirs(request.app['settings'].PROJECT_DIR + "/" + project_name + "/files", exist_ok=True)
# Write ".FMU" to disc
if ".csv" in data.filename or ".xlsx" in data.filename:
path = request.app['settings'].PROJECT_DIR + "/" + project_name + "/files/" + data.filename
with open(path, 'wb') as file:
file.write(data.file.read(content_length))
return web.HTTPAccepted()
else:
return web.HTTPBadRequest()
