biothings.hub.api

class biothings.hub.api.EndpointDefinition

Bases: dict

biothings.hub.api.create_handlers(shell, command_defs)

biothings.hub.api.generate_api_routes(shell, commands)

biothings.hub.api.generate_endpoint_for_callable(name, command, method, force_bodyargs)

biothings.hub.api.generate_endpoint_for_composite_command(name, command, method)

biothings.hub.api.generate_endpoint_for_display(name, command, method)

biothings.hub.api.generate_handler(shell, name, command_defs)

biothings.hub.api.start_api(app, port, check=True, wait=5, retry=5, settings=None)

biothings.hub.api.managers

class biothings.hub.api.manager.APIManager(log_folder=None, *args, **kwargs)

Bases: BaseManager

create_api(api_id, es_host, index, doc_type, port, description=None, **kwargs)

delete_api(api_id)

get_apis()

get_pinfo()

Return dict containing information about the current process (used to report in the hub)

get_predicates()

import_config_web()

log_pytests(pytest_path, host)

Run the pytests for the given pytest path and host. We create a LoggerFile object to redirect stdout and stderr to the logger.

register_status(api_id, status, **extra)

restore_running_apis()

If some APIs were running but the hub stopped, re-start APIs as hub restarts

setup()

setup_log()

start_api(api_id)

stop_api(api_id)

test_api(api_id)

Run pytests for the given api id. If no pytest path is found in the config_web_local.py then log an error. APITEST_CONFIG_ROOT: root directory containing the config_web APITEST_CONFIG: name of the config file containing the api web configuration APITEST_ROOT: root directory containing the conftest.py file for the pytests APITEST_PATH: path to the directory containing the pytests

exception biothings.hub.api.manager.APIManagerException

Bases: Exception

class biothings.hub.api.manager.LoggerFile(logger, level)

Bases: object

File-like object that writes to a logger at a specific level. This object is used to redirect stdout/stderr to a logger.

flush()

isatty()

write(message)

biothings.hub.api.handlers.base

class biothings.hub.api.handlers.base.BaseHandler(application: Application, request: HTTPServerRequest, **kwargs: Any)

Bases: DefaultHandler

initialize(managers, **kwargs)

class biothings.hub.api.handlers.base.DefaultHandler(application: Application, request: HTTPServerRequest, **kwargs: Any)

Bases: RequestHandler

options(*args, **kwargs)

set_default_headers()

Override this to set HTTP headers at the beginning of the request.

For example, this is the place to set a custom Server header. Note that setting such headers in the normal flow of request processing may not do what you want, since headers may be reset during error handling.

write(result)

Writes the given chunk to the output buffer.

To write the output to the network, use the flush() method below.

If the given chunk is a dictionary, we write it as JSON and set the Content-Type of the response to be application/json. (if you want to send JSON as a different Content-Type, call set_header after calling write()).

Note that lists are not converted to JSON because of a potential cross-site security vulnerability. All JSON output should be wrapped in a dictionary. More details at http://haacked.com/archive/2009/06/25/json-hijacking.aspx/ and https://github.com/facebook/tornado/issues/1009

write_error(status_code, **kwargs)

Override to implement custom error pages.

write_error may call write, render, set_header, etc to produce output as usual.

If this error was caused by an uncaught exception (including HTTPError), an exc_info triple will be available as kwargs["exc_info"]. Note that this exception may not be the “current” exception for purposes of methods like sys.exc_info() or traceback.format_exc.

class biothings.hub.api.handlers.base.GenericHandler(application: Application, request: HTTPServerRequest, **kwargs: Any)

Bases: DefaultHandler

delete(*args, **kwargs)

get(*args, **kwargs)

head(*args, **kwargs)

initialize(shell, **kwargs)

post(*args, **kwargs)

put(*args, **kwargs)

class biothings.hub.api.handlers.base.RootHandler(application: Application, request: HTTPServerRequest, **kwargs: Any)

Bases: DefaultHandler

async get()

initialize(features, hub_name=None, **kwargs)

biothings.hub.api.handlers.log

class biothings.hub.api.handlers.log.DefaultCORSHeaderMixin

Bases: object

set_default_headers()

class biothings.hub.api.handlers.log.HubLogDirHandler(application: Application, request: HTTPServerRequest, **kwargs: Any)

Bases: DefaultCORSHeaderMixin, RequestHandler

get(filename)

initialize(path)

class biothings.hub.api.handlers.log.HubLogFileHandler(application: Application, request: HTTPServerRequest, **kwargs: Any)

Bases: DefaultCORSHeaderMixin, StaticFileHandler

async get(path: str, include_body: bool = True) → None

If request path is a gz file, we will uncompress it first, then return get with the uncompress file path

options(*args, **kwargs)

biothings.hub.api.handlers.log.get_log_content(file_path, **kwargs)

biothings.hub.api.handlers.shell

class biothings.hub.api.handlers.shell.ShellHandler(application: Application, request: HTTPServerRequest, **kwargs: Any)

Bases: GenericHandler

initialize(shell, shellog, **kwargs)

put()

biothings.hub.api.handlers.upload

class biothings.hub.api.handlers.upload.UploadHandler(application: Application, request: HTTPServerRequest, **kwargs: Any)

Bases: GenericHandler

data_received(chunk)

Implement this method to handle streamed request data.

Requires the .stream_request_body decorator.

May be a coroutine for flow control.

initialize(upload_root, **kwargs)

parse_head()

post(src_name)

prepare()

Called at the beginning of a request before get/post/etc.

Override this method to perform common initialization regardless of the request method. There is no guarantee that prepare will be called if an error occurs that is handled by the framework.

Asynchronous support: Use async def or decorate this method with .gen.coroutine to make it asynchronous. If this method returns an Awaitable execution will not proceed until the Awaitable is done.

Added in version 3.1: Asynchronous support.

biothings.hub.api.handlers.ws

class biothings.hub.api.handlers.ws.HubDBListener

Bases: ChangeListener

Get events from Hub DB and propagate them through the websocket instance

read(event)

class biothings.hub.api.handlers.ws.LogListener(*args, **kwargs)

Bases: ChangeListener

read(event)

class biothings.hub.api.handlers.ws.ShellListener(*args, **kwargs)

Bases: LogListener

class biothings.hub.api.handlers.ws.WebSocketConnection(session, listeners)

Bases: SockJSConnection

Listen to Hub DB through a listener object, and publish events to any client connected

SockJSConnection.__init__() takes only a session as argument, and there’s no way to pass custom settings. In order to use that class, we need to use partial to partially init the instance with ‘listeners’ and let the rest use the ‘session’

parameter:

pconn = partial(WebSocketConnection,listeners=listeners) ws_router = sockjs.tornado.SockJSRouter(pconn,”/path”)

clients = {}

on_close()

Default on_close handler.

on_message(message)

Default on_message handler. Must be overridden in your application

on_open(info)

Default on_open() handler.

Override when you need to do some initialization or request validation. If you return False, connection will be rejected.

You can also throw Tornado HTTPError to close connection.

request

ConnectionInfo object which contains caller IP address, query string parameters and cookies associated with this request (if any).

publish(message)