async def filtred_log_get(request): try: # TODO: сделать фильтрацию # запросы в базу с 'where' return web.Response(text='Ok') except Exception as e: return web.HTTPServerError(text=f'error: {e}')
async def register(request): username = await authorized_userid(request) if username: return web.HTTPOk() data = await request.json() username = data["username"] password = data["password"] email = data.get("email", None) if User.by_name(username): return web.HTTPConflict(reason="Username already taken") elif not username: return web.HTTPBadRequest(reason="Please provide a username") elif not password: return web.HTTPBadRequest(reason="Please provide a password") else: try: with db.atomic(): u = User(name=username) u.set_password(password) if email: u.email = email u.save() except: return web.HTTPServerError( reason= "An unexpected error occured on the server during account creation. Operation reverted." ) response = web.HTTPOk() await remember(request, response, username) return response
async def http_error_handler(req: Request, handler: Callable) -> Response: """Middleware for handling exceptions received from the API methods. :param req: A request instance :param handler: A request handler :raises: Reformatted HTTP Exceptions :returns: Successful requests unaffected """ try: response = await handler(req) return response except web.HTTPError as error: details = _json_exception(error.status, error, req.url) LOG.error(details) c_type = "application/problem+json" if error.status == 400: raise web.HTTPBadRequest(text=details, content_type=c_type) elif error.status == 401: raise web.HTTPUnauthorized( headers={"WWW-Authenticate": 'OAuth realm="/", charset="UTF-8"'}, text=details, content_type=c_type ) elif error.status == 403: raise web.HTTPForbidden(text=details, content_type=c_type) elif error.status == 404: raise web.HTTPNotFound(text=details, content_type=c_type) elif error.status == 415: raise web.HTTPUnsupportedMediaType(text=details, content_type=c_type) elif error.status == 422: raise web.HTTPUnprocessableEntity(text=details, content_type=c_type) else: raise web.HTTPServerError()
def critical(self, request: web.Request = None, exception: Exception = None, traceback=None, state: int = 500, headers: dict = {}, **kwargs) -> web.Response: # TODO: process the exception object if not request: request = self.request response_obj = { "status": "Failed", "reason": str(exception), "stacktrace": traceback, } args = { "text": json.dumps(response_obj), "reason": "Server Error", "content_type": "application/json", **kwargs, } if state == 500: # bad request obj = web.HTTPInternalServerError(**args) else: obj = web.HTTPServerError(**args) for header, value in headers.items(): obj.headers[header] = value return obj
async def get_metric_list(project_id: str, cloud_token: str, *, mn2dim_target=False): mn2dim = dict() url = EYE_METRIC_LIST_URL.format(project_id=project_id) headers = {"X-Auth-Token": cloud_token} async with aiohttp.ClientSession() as session: async with session.get(url, headers=headers) as resp: if resp.status != 200: # todo: Понять почему 403 logging.error( f"{await resp.json() = } {resp.status = } {headers = }") raise web.HTTPServerError() resp = await resp.json() def inner(): for metric in resp["metrics"]: yield { "id": metric["namespace"], "metric_name": metric["metric_name"], "name": verbose_namespace(metric["namespace"]), } if mn2dim_target: for metric in resp["metrics"]: mn2dim[metric["metric_name"]] = ','.join([ metric["dimensions"][0]["name"], metric["dimensions"][0]["value"] ]) # todo: ignore kafka with 2 dimensions? return mn2dim return {"metrics": uniques(inner())}
async def code(self, request: web.Request): if 'code' not in request.query: raise web.HTTPFound("/register?" + urlencode({"redirect": request.url})) code = request.query["code"] data = { "code": code, "grant_type": "authorization_code", "redirect_uri": "http://api.typheus.me/hub", "client_id": self.client_id, "client_secret": self.client_secret, "scope": 'identify guilds' } response = await self.session.post( f"https://discordapp.com/api/oauth2/token", data=urlencode(data), headers={'Content-Type': "application/x-www-form-urlencoded"}) js = await response.json() if 'error' in js: raise web.HTTPServerError( reason=f"Invalid code or redirect {js['error']}") token = js['access_token'] logging.info("Received Discord OAuth2 code, grabbing token") raise web.HTTPFound(f"/hub?token={token}")
async def populate(request): N = request.query.get('num_users', 1) errors = await asyncio.gather(*[insert(request.app) for _ in range(N)], return_exceptions=True) if any(errors): msg = " ".joint([e.reason for e in errors if e]) raise web.HTTPServerError(text=msg) raise web.HTTPOk()
async def get_detail(self, request): async with request.app['db'].acquire() as conn: try: procedure = await get_procedure(conn, request) except RecordNotFound as e: raise web.HTTPNotFound(text=str(e)) except TypeError: return web.HTTPServerError(text=str(DataTypeError)) return web.json_response(json_handler(procedure))
async def is_mobile(self, tn): data, status, _ = await \ self.client.request('GET', phone_data_url.format(tn=tn), headers={'Accept': 'application/json'}) if status != 200: raise web.HTTPServerError() data = json.loads(data) if data['carrier'].get('type') == 'mobile': return True return False
async def get_image_png(request): id = request.match_info.get('id', None) frame = _get_image(id) success, buffer = cv2.imencode(".png", frame) if not success: raise web.HTTPServerError() io_buf = BytesIO(buffer) return web.Response(body=io_buf.getvalue(), content_type='image/png')
async def get(self): if not self.riki_path: raise web.HTTPSeeOther(f'{APP_PATH}page/index') page_fs_path = os.path.join(self.data_dir, self.riki_path) pelms = page_fs_path.rsplit('.', 1) page_suff = None if len(pelms) < 2 else pelms[-1] if self.dir_metadata.directory_type == 'gallery': raise web.HTTPSeeOther(f'{APP_PATH}gallery/{self.riki_path}/index') elif files.page_is_dir(page_fs_path): if self.dir_metadata.directory_type == 'page': raise web.HTTPSeeOther( f'{APP_PATH}page/{self.riki_path}/index') else: raise web.HTTPServerError('Unknown page type') elif page_suff and page_suff in appconf.RAW_FILES: with open(page_fs_path, 'rb') as fr: web.header('Content-Type', appconf.RAW_FILES[page_suff]) return fr.read() else: page_fs_path = f'{page_fs_path}.md' curr_dir = os.path.dirname(self.riki_path) page_name = os.path.basename(self.riki_path) # setup the directory information if curr_dir: path_elms = path_dir_elms(curr_dir) curr_dir_fs = os.path.join(self.data_dir, curr_dir) else: curr_dir = '' path_elms = [] curr_dir_fs = self.data_dir # transform the page if files.page_exists(page_fs_path): page_info = files.get_version_info( self.data_dir, page_fs_path, info_encoding=conf.hg_info_encoding) inner_html = load_markdown(page_fs_path) page_template = 'page.html' else: inner_html = '' page_info = files.RevisionInfo() page_template = 'dummy_page.html' data = dict(html=inner_html, page_list=self.generate_page_list(curr_dir_fs), path_elms=path_elms, page_info=page_info, page_name=page_name, curr_dir_name=self.get_current_dirname(curr_dir)) return self.response_html(page_template, data)
async def precache(app, old_id, new_id): with ExitStack() as es: old_dir = es.enter_context(TemporaryDirectory()) new_dir = es.enter_context(TemporaryDirectory()) await asyncio.gather( app.artifact_manager.retrieve_artifacts( old_id, old_dir, filter_fn=is_binary, timeout=PRECACHE_RETRIEVE_TIMEOUT ), app.artifact_manager.retrieve_artifacts( new_id, new_dir, filter_fn=is_binary, timeout=PRECACHE_RETRIEVE_TIMEOUT ), ) old_binaries = find_binaries(old_dir) if not old_binaries: raise ArtifactsMissing(old_id) new_binaries = find_binaries(new_dir) if not new_binaries: raise ArtifactsMissing(new_id) debdiff_cache_path = app.debdiff_cache_path(old_id, new_id) if debdiff_cache_path and not os.path.exists(debdiff_cache_path): with open(debdiff_cache_path, "wb") as f: f.write( await run_debdiff( [p for (n, p) in old_binaries], [p for (n, p) in new_binaries] ) ) logging.info("Precached debdiff result for %s/%s", old_id, new_id) diffoscope_cache_path = app.diffoscope_cache_path(old_id, new_id) if diffoscope_cache_path and not os.path.exists(diffoscope_cache_path): try: diffoscope_diff = await asyncio.wait_for( run_diffoscope( old_binaries, new_binaries, lambda: _set_limits(app.task_memory_limit)), app.task_timeout ) except MemoryError: raise web.HTTPServiceUnavailable(text="diffoscope used too much memory") except asyncio.TimeoutError: raise web.HTTPGatewayTimeout(text="diffoscope timed out") try: with open(diffoscope_cache_path, "w") as f: json.dump(diffoscope_diff, f) except json.JSONDecodeError as e: raise web.HTTPServerError(text=str(e)) logging.info("Precached diffoscope result for %s/%s", old_id, new_id)
async def login_by_vk(request: 'Request'): if VK_CLIENT_ID is None: logger.error('VK_CLIENT_ID not set') raise web.HTTPServerError() opts = { 'client_id': VK_CLIENT_ID, 'redirect_uri': request.app['config']['app']['domain'] + "/oauth/_vk", 'display': 'page', 'scope': (1 << 16) + (1 << 22), 'response_type': 'code', } raise web.HTTPFound('https://oauth.vk.com/authorize?' + urlencode(opts))
def _get_user(cls, token): db = DatabaseManager.DatabaseManager.get_session() try: row = db.query(cls).filter(cls.token == token).one_or_none() if not row: return None else: return row.object_user except Exception as ex: traceback.print_exc() raise web.HTTPServerError(reason=str(ex)) finally: db.close()
def _generate_token(cls, user_id): db = DatabaseManager.DatabaseManager.get_session() try: user = cls._get_user_byid(user_id) if not user: raise web.HTTPNotFound(reason="User not found.") else: token = ChatUserTokens.ChatUserTokens(user.get_id()) db.add(token) db.commit() return token.token except Exception as ex: raise web.HTTPServerError(reason=str(ex)) finally: db.close()
async def post(self): pack = await self.request.content.read() s = pack.split(b"\r")[0][2:] p = mp.MultipartParser(BytesIO(mp.tob(pack)), s) blob = p.parts() """ 0 : chunkNumber 1 : chunkSize 2 : currentChunkSize 3 : totalSize 4 : identifier 5 : filename 6 : relativePath 7 : totalChunks 8 : file """ curr_chunkNumber = int(blob[0].value) totalChunks = blob[7].value filename = blob[5].value file = blob[8].value ret = None try: if filename not in files: f = File(filename, totalChunks) files[filename] = f ret = await handle_chunks(filename, curr_chunkNumber, file) else: ret = await handle_chunks(filename, curr_chunkNumber, file) if ret == False: return web.HTTPExpectationFailed() elif ret: analyz = Analyzes(ret) analyzes[filename] = analyz threading.Thread(target=analyz.start_analysis).start() except Exception as e: print(e) return web.HTTPServerError() return web.HTTPOk()
async def handle_location(req): dbredis = req.app[DB_REDIS] settings = req.app[SETTINGS] session = req.app[HTTP_SESSION] device_id = req.match_info['device_id'] location_id = req.match_info['location_id'] event_name = req.match_info['event_name'] event_marker_id = '{}/{}/{}'.format(device_id, location_id, event_name) logger.info('Received event marker: %s', event_marker_id) data = await req.json() if data['secret'] != IFTTT_APPLET_SECRET: raise web.HTTPForbidden(reason='bad secret') try: if data['action'].lower() == 'entered': occured_at = data.get('occuredAt', None) if occured_at: occured_at = parsedate_to_datetime(occured_at) occured_at = occured_at.timestamp() await store_event_marker(dbredis, event_marker_id, occured_at) if data['action'].lower() == 'exited': started_at = await get_event_marker(dbredis, event_marker_id) if started_at is None: logger.warning('Got exit but never entered for location: %s from device: %s', location_id, device_id) return web.HTTPOk() now = int(time.time()) delta = (now - int(started_at)) / 60. # minutes if delta < 15: logger.warning('Too little time spent in location: %s from device: %s', location_id, device_id) return web.HTTPOk() payload = { 'value1': float("{0:.2f}".format(delta)) } await trigger_maker_event(session, event_name, payload, settings.get(IFTTT_MAKER_KEY)) await remove_event_marker(dbredis, event_marker_id) return web.HTTPOk() except Exception: logger.exception('Cannot handle data: %s', data) raise web.HTTPServerError()
async def create(request: web.Request) -> web.Response: data = await request.json() message = data.get("message", None) if message: try: notification = Notification.create(uuid=uuid.uuid4(), message=message) notification.save() await sio.emit( "Notification.Show", { "uuid": str(notification.uuid), "message": notification.message }, namespace=GAME_NS, ) except: return web.HTTPServerError( reason="Failed to create new notification.") return web.HTTPOk( text=f"Created new notification with id {notification.uuid}") else: return web.HTTPBadRequest(reason="Missing mandatory field 'message'")
async def login(self, request: Request): #print("Line 10 in Users.py\n", await request.json()) try: body = await request.json() user_name = body.get('username') user_pass = body.get('password') if not user_name: return web.HTTPBadRequest(reason="You are missing the username field for the login user.") if not user_pass: return web.HTTPBadRequest(reason="You are missing the password field. Please send hashed password.") else: user: ChatUser.ChatUser = await ChatUser.ChatUser.get_user_byname(user_name) if not user: return web.HTTPBadRequest(reason="This user is not registered with the system.") if await self.run_executor(user.test_password, user_pass): data = {'id': user.get_id(), 'token': await ChatUser.ChatUser.generate_token(user.get_id())} await ChatUser.ChatUser.set_status(user.get_name(), "online") return web.json_response(data) else: return web.HTTPForbidden(reason="Bad password.") except Exception as ex: traceback.print_exc() return web.HTTPServerError(text="{}".format(ex))
async def consumers_statuses(request): """ Function to submit a query. :param request: used to get the params to connect to the db :return: list of json object --- tags: - Dashboard summary: Shows the status of a consumer parameters: [] responses: 200: description: Ok 404: description: Not Found """ try: consumers = await get_consumers_statuses(request.app['engine']) except DatabaseConnectionError as e: raise web.HTTPServerError() from e return web.json_response(consumers)
async def get(self): gallery_fs_dir = os.path.join(self.data_dir, self.riki_path) if files.page_is_dir(gallery_fs_dir): if self.dir_metadata.directory_type == 'page': raise web.HTTPSeeOther( f'{APP_PATH}page/{self.riki_path}/index') elif self.dir_metadata.directory_type == 'gallery': raise web.HTTPSeeOther( f'{APP_PATH}gallery/{self.riki_path}/index') else: raise web.HTTPServerError('Unknown page type') elif os.path.isfile(gallery_fs_dir): raise web.HTTPInternalServerError('Gallery directory malformed') elif os.path.basename(gallery_fs_dir) == 'index': gallery_fs_dir = os.path.dirname(gallery_fs_dir) else: raise web.HTTPNotFound() try: images = files.list_files(gallery_fs_dir, files.file_is_image, recursive=False) except FileNotFoundError: raise web.HTTPNotFound() extended: List[files.FileInfo] = [] for img in images: info = files.get_file_info(img, path_prefix=self.data_dir) info.metadata = pictures.get_metadata(img) extended.append(info) values = dict(files=extended, page_list=[], path_elms=path_dir_elms(self.riki_path), curr_dir_name=self.get_current_dirname(self.riki_path), num_files=await self.get_num_files(gallery_fs_dir), description=self.dir_metadata.description) return self.response_html('gallery.html', values)
async def websocket_handler(request): ws = web.WebSocketResponse() await ws.prepare(request) request.app['websockets'].add(ws) try: p = psutil.Process(int(request.match_info["pid"])) except BaseException: return web.HTTPServerError(reason="Process not found.") try: while True: await ws.send_json({ "name": p.name(), "cpu": p.cpu_percent() / psutil.cpu_count(), "memory": p.memory_info()[1] * 0.000001, "memory_percent": p.memory_percent(), }) await asyncio.sleep(0.5) finally: request.app['websockets'].discard(ws) return ws
async def get_posts(request: web.Request) -> web.Response: """ Getting posts from db with applying query params Args: request: aiohttp request Returns: List with posts """ query_params = request.rel_url.query limit, offset, order_key, order_type = _validate_init_params(query_params) try: posts = await Post.get_list( limit=limit, offset=offset, order_key=order_key, order_type=order_type ) result = views.json_posts(posts) return web.json_response(result) except peewee.DatabaseError: return web.HTTPServerError(text='Something went wrong')
async def _handle_vuespa_ws_http(self, req): ws_id = req.match_info['id'] fn_id = req.match_info['fn'] ws_client = self._websocket_clients.get(ws_id) if ws_client is None: raise web.HTTPNotFound() # Synchronization note: if threaded, this would need a lock. However, # asyncio doesn't need a lock for code which does not include "await". web_id = ws_client._socket_http_next ws_client._socket_http_next += 1 ws_client._socket_http_reqs[web_id] = socket_req = { 'event': asyncio.Event(), 'result': None, 'err': None, } try: args = dict(req.query) if req.has_body: args.update(await req.json()) await ws_client._socket.send_str( json.dumps({ 'type': 'http', 'fn': fn_id, 'id': web_id, 'args': args, })) await socket_req['event'].wait() finally: del ws_client._socket_http_reqs[web_id] if socket_req['err'] is not None: raise web.HTTPServerError(body=socket_req['err']) return web.Response(body=socket_req['result'], content_type='application/json')
async def handle_item_add(self, req): if req.has_body and req.content_type == 'multipart/form-data': reader = await req.multipart() data = {} file_name, temp_path = None, None while True: field = await reader.next() if field is None: break name = field.name if name in self.JSON_FIELDS: try: data[name] = json.loads(await field.text()) except json.JSONDecodeError: if temp_path is not None: os.unlink(temp_path) return web.HTTPBadRequest(text='Invalid field: ' + name) elif name in self.TEXT_FIELDS: data[name] = await field.text() if name == 'FileName': file_name = data[name] elif data[ 'ObjectType'] in self.FILE_TYPES and name == 'FileContent': # Read the file content, if file name is not yet known, # we take it from the request if file_name is None: file_name = field.filename if file_name is None: return web.HTTPBadRequest(text='File name unknown') # https://docs.aiohttp.org/en/stable/web_quickstart.html#file-uploads try: temp_fd, temp_path = tempfile.mkstemp() temp_fp = os.fdopen(temp_fd, mode='wb') while True: chunk = await field.read_chunk( ) # 8192 bytes by default. if not chunk: break temp_fp.write(chunk) temp_fp.close() except: if temp_path is None: logging.exception( 'Failed to create a temporary file') else: os.unlink(temp_path) logging.exception( f'Failed to write file content to {temp_path}') return web.HTTPServerError() else: if temp_path is not None: os.unlink(temp_path) return web.HTTPBadRequest(text='Invalid field: ' + name) data = self._storage.add_object(data, temp_path) if data is not None: print(data) await self._ws_server.broadcast_item_added(data) return web.HTTPNoContent() else: if temp_path is not None: os.unlink(temp_path) return web.HTTPBadRequest(text='Invalid object data') else: return web.HTTPBadRequest(text='Form data required')
async def archive_get_routing(request: web.Request) -> web.StreamResponse: if (GIT_ARCHIVER_ACCESS_KEY and request.headers.get('Authorization', '') != 'Bearer %s' % GIT_ARCHIVER_ACCESS_KEY): return web.HTTPUnauthorized() try: repo = request.query['repo'].strip() clone_options = request.query.get('clone_options', '').strip() disk_quota = int( request.query.get('disk_quota', GIT_ARCHIVER_MAX_DISK_QUOTA)) except Exception: return web.HTTPBadRequest( text='Failed to parse all required parameters') if not (0 < disk_quota <= GIT_ARCHIVER_MAX_DISK_QUOTA): return web.HTTPBadRequest(text='Invalid `disk_quota` parameter') loop = asyncio.get_event_loop() with tempfile.NamedTemporaryFile('w', dir=GIT_ARCHIVER_ARCHIVE_VOLUME_PATH, encoding='utf-8') as run_sh_file: archive_name = '%s.zip' % uuid.uuid4().hex run_sh_file.write( WORKER_CMD_TEMPLATE.format(repo=repo, clone_options=clone_options, archive_filename='/output_mnt/%s' % archive_name)) run_sh_file.flush() archive_host_filename = os.path.join(GIT_ARCHIVER_ARCHIVE_VOLUME_PATH, archive_name) worker_container = None try: async with concurrent_job_semaphore: worker_container = await loop.run_in_executor( thread_executor, functools.partial( docker_client.containers.create, GIT_ARCHIVER_DOCKER_WORKER_IMAGE, ['bash', '/run.sh'], mounts=[ docker.types.Mount('/run.sh', run_sh_file.name, type='bind', read_only=True), docker.types.Mount( '/output_mnt', GIT_ARCHIVER_ARCHIVE_VOLUME_PATH, type='bind'), docker.types.Mount('/tmpfs_mnt', '', type='tmpfs', tmpfs_size=disk_quota) ], user=os.getuid() # type: ignore )) await loop.run_in_executor(thread_executor, worker_container.start) worker_result = await loop.run_in_executor( thread_executor, functools.partial(worker_container.wait, timeout=GIT_ARCHIVER_TIMEOUT)) worker_logs = await loop.run_in_executor( thread_executor, worker_container.logs) worker_logs = worker_logs.decode('utf-8') if worker_result['StatusCode'] != 0: return web.HTTPBadRequest( text= 'Worker is terminated with non-zero status code\n===\n%s' % worker_logs) if not os.path.exists(archive_host_filename): return web.HTTPBadRequest( text='Archive file is not created\n===\n%s' % worker_logs) resp = web.FileResponse(archive_host_filename, headers={ 'Content-Disposition': 'attachment; filename="%s"' % archive_name }) await resp.prepare(request) # TODO: dirty hack to prevent double calling of `FileResponse.prepare()` async def _dummy_prepare(request): return None resp.prepare = _dummy_prepare # type: ignore # From here, `archive_host_filename` doesn't need to be accessbiel anymore return resp except asyncio.CancelledError: logger.debug('The request is cancelled') raise except Exception: logger.exception('Failed to archive git repo') return web.HTTPServerError(text='Unexpected error is occured') finally: if worker_container is not None: await loop.run_in_executor( thread_executor, functools.partial(worker_container.remove, force=True)) if os.path.exists(archive_host_filename): os.unlink(archive_host_filename)
status=400) async with request.app.db.acquire() as conn: # type: aiopg.sa.SAConnection user = await inner_auth(conn, request) data = await conn.execute( r""" DELETE FROM app_templates T WHERE (T.project_id = %s) and (T.user_id = %s) and (T.id = %s) RETURNING T.id """, (project_id, user["id"], template_id)) data = await data.fetchall() if len(data) > 1: logging.error(f"{data = }. query delete few template once") return web.HTTPServerError() elif len(data) == 1: return web.HTTPNoContent() else: return web.HTTPNotFound() def main(): app = Application() app.add_routes([ web.route('POST', '/v1/login', login_handler), web.route('POST', '/v1/projects', projects_handler), web.route('POST', '/v1/eye/metric_list', eye_metric_list_handler), web.route('POST', '/v1/eye/query', eye_query_handler), web.route('POST', '/v1/cts/overview', cts_handler), web.route('POST', '/v1/cts/detail', cts_detail_handler),
async def get_my_profile(request: web.Request): # NOTE: ONLY login required to see its profile. E.g. anonymous can never see its profile @retry(**PostgresRetryPolicyUponOperation(logger).kwargs) async def _query_db(uid: str, engine: Engine) -> List[RowProxy]: async with engine.acquire() as conn: query = (sa.select( [ users.c.email, users.c.role, users.c.name, users.c.primary_gid, groups.c.gid, groups.c.name, groups.c.description, groups.c.type, ], use_labels=True, ).select_from( users.join( user_to_groups.join(groups, user_to_groups.c.gid == groups.c.gid), users.c.id == user_to_groups.c.uid, )).where(users.c.id == uid).order_by(sa.asc(groups.c.name))) result = await conn.execute(query) return await result.fetchall() # here we get all user_group combinations but only the group changes user_groups: List[RowProxy] = await _query_db( uid=request[RQT_USERID_KEY], engine=request.app[APP_DB_ENGINE_KEY]) if not user_groups: raise web.HTTPServerError(reason="could not find profile!") # get the primary group and the all group user_primary_group = all_group = {} other_groups = [] for user_group in user_groups: if user_group["users_primary_gid"] == user_group["groups_gid"]: user_primary_group = user_group elif user_group["groups_type"] == GroupType.EVERYONE: all_group = user_group else: other_groups.append(user_group) parts = user_primary_group["users_name"].split(".") + [""] return { "login": user_primary_group["users_email"], "first_name": parts[0], "last_name": parts[1], "role": user_primary_group["users_role"].name.capitalize(), "gravatar_id": gravatar_hash(user_primary_group["users_email"]), "groups": { "me": { "gid": user_primary_group["groups_gid"], "label": user_primary_group["groups_name"], "description": user_primary_group["groups_description"], }, "organizations": [{ "gid": group["groups_gid"], "label": group["groups_name"], "description": group["groups_description"], } for group in other_groups], "all": { "gid": all_group["groups_gid"], "label": all_group["groups_name"], "description": all_group["groups_description"], }, }, }
async def processor_start(request: web.Request): """ Start a processor from post request. Post params: - id:* id of processor instance max 20 chars, first char must be alphabetic or underscore, other chars must be alphabetic, digit or underscore - start_params: the processor specific start parameters as a json string - input_ref: list of reference values to the inputs to be used - output_ref: list of reference values to the outputs to be used - measurement_ref: list of reference values to the measurement inputs to be used for the inputs. Must be in the same order as input_ref. - measurement_proportion: list of scales to be used on measurement values before inputting them. Must be in the same order as input_ref. """ post = await request.post() processor_id = try_get_validate(post, 'id') if processor_id not in request.app['processors']: raise web.HTTPBadRequest( reason=f'processor with id {processor_id} does not exist') processor_instance: Processor = request.app['processors'][processor_id] input_refs = await try_get_all(post, 'input_ref', int) if post.get('output_ref', '') == 'all': output_refs = 'all' else: output_refs = await try_get_all(post, 'output_ref', int) measurement_refs = await try_get_all(post, 'measurement_ref', int) measurement_proportions = await try_get_all(post, 'measurement_proportion', float) try: start_params = json.loads(post.get('start_params', '{}')) except JSONDecodeError: raise web.HTTPUnprocessableEntity( reason='Could not process start_params as json') if processor_instance.started: raise web.HTTPUnprocessableEntity( reason='Processor has already been started') try: processor_instance.start( input_refs=input_refs, measurement_refs=measurement_refs, measurement_proportions=measurement_proportions, output_refs=output_refs, start_params=start_params) except: raise web.HTTPUnprocessableEntity( reason= f'The selected Processor instance is not startable (probably crashed)' ) start_results = await retrieve_processor_status(request.app, processor_instance) path = os.path.join(request.app['settings'].PROCESSOR_DIR, processor_id + '.json') with open(path, 'w') as f: f.write(dumps(processor_instance)) if 'error' in start_results: raise web.HTTPServerError(body=dumps(start_results), content_type='application/json') raise web.HTTPAccepted(body=dumps(start_results), content_type='application/json')