diff --git a/aim/cli/server/commands.py b/aim/cli/server/commands.py index 53e3f143f2..2bf2119cad 100644 --- a/aim/cli/server/commands.py +++ b/aim/cli/server/commands.py @@ -1,21 +1,25 @@ import os import click -from aim.cli.utils import set_log_level from aim.sdk.repo import Repo, RepoStatus from aim.sdk.utils import clean_repo_path -from aim.ext.transport.config import AIM_SERVER_DEFAULT_HOST, AIM_SERVER_DEFAULT_PORT, AIM_SERVER_MOUNTED_REPO_PATH -from aim.ext.transport.server import run_router +from aim.cli.utils import set_log_level, build_uvicorn_command, get_free_port_num, exec_cmd +from aim.ext.transport.config import ( + AIM_SERVER_DEFAULT_PORT, + AIM_SERVER_DEFAULT_HOST, + AIM_SERVER_MOUNTED_REPO_PATH, + AIM_SERVER_BASE_PATH +) +from aim.web.configs import AIM_ENV_MODE_KEY -@click.command() +@click.command('server') @click.option('-h', '--host', default=AIM_SERVER_DEFAULT_HOST, type=str) @click.option('-p', '--port', default=AIM_SERVER_DEFAULT_PORT, type=int) -@click.option('-w', '--workers', default=1, type=int) -@click.option('--repo', required=False, type=click.Path(exists=True, - file_okay=False, - dir_okay=True, - writable=True)) +@click.option('--repo', required=False, default=os.getcwd(), type=click.Path(exists=True, + file_okay=False, + dir_okay=True, + writable=True)) @click.option('--ssl-keyfile', required=False, type=click.Path(exists=True, file_okay=True, dir_okay=False, @@ -24,15 +28,44 @@ file_okay=True, dir_okay=False, readable=True)) +@click.option('--base-path', required=False, default='', type=str) @click.option('--log-level', required=False, default='', type=str) +@click.option('--dev', is_flag=True, default=False) @click.option('-y', '--yes', is_flag=True, help='Automatically confirm prompt') -def server(host, port, workers, +def server(host, port, repo, ssl_keyfile, ssl_certfile, - log_level, yes): - # TODO [MV, AT] remove code duplication with aim up cmd implementation + base_path, log_level, dev, yes): + """ + Starts the Aim remote tracking server for real-time logging. + + The Aim tracking server facilitates real-time logging of experiments + from remote locations. This command launches the server with specified + configurations, including host, port, and associated repository. + + Like the UI, the server can also run in production or development mode. + """ + if dev: + os.environ[AIM_ENV_MODE_KEY] = 'dev' + log_level = log_level or 'debug' + else: + os.environ[AIM_ENV_MODE_KEY] = 'prod' + if log_level: set_log_level(log_level) + if base_path: + if base_path.endswith('/'): + base_path = base_path[:-1] + if not base_path.startswith('/'): + base_path = f'/{base_path}' + os.environ[AIM_SERVER_BASE_PATH] = base_path + + if port == 0: + try: + port = get_free_port_num() + except Exception: + pass + repo_path = clean_repo_path(repo) or Repo.default_repo_path() repo_status = Repo.check_repo_status(repo_path) if repo_status == RepoStatus.MISSING: @@ -40,7 +73,6 @@ def server(host, port, workers, init_repo = True else: init_repo = click.confirm(f'\'{repo_path}\' is not a valid Aim repository. Do you want to initialize it?') - if not init_repo: click.echo('To initialize repo please run the following command:') click.secho('aim init', fg='yellow') @@ -63,15 +95,16 @@ def server(host, port, workers, os.environ[AIM_SERVER_MOUNTED_REPO_PATH] = repo_inst.path - click.echo( - click.style('Running Aim Server on repo `{}`'.format(repo_inst), - fg='yellow')) - click.echo('Server is mounted on {}:{}'.format(host, port), err=True) + click.secho('Running Aim Server on repo `{}`'.format(repo), fg='yellow') + click.echo('Server is mounted on aim://{}:{}'.format(host, port), err=True) click.echo('Press Ctrl+C to exit') try: - run_router(host, port, workers, ssl_keyfile, ssl_certfile) + cmd = build_uvicorn_command('aim.ext.tracking.run:app', + host=host, port=port, + ssl_keyfile=ssl_keyfile, ssl_certfile=ssl_certfile, log_level=log_level) + exec_cmd(cmd) except Exception: click.echo('Failed to run Aim Tracking Server. ' - 'Please see the logs for details.') - return + 'Please see the logs above for details.') + exit(1) diff --git a/aim/cli/up/commands.py b/aim/cli/up/commands.py index 5ef6ca7cb0..7585bc9b63 100644 --- a/aim/cli/up/commands.py +++ b/aim/cli/up/commands.py @@ -2,7 +2,13 @@ import click from aim.cli.utils import set_log_level -from aim.cli.up.utils import build_db_upgrade_command, build_uvicorn_command, get_free_port_num +from aim.cli.utils import ( + build_db_upgrade_command, + build_uvicorn_command, + get_free_port_num, + exec_cmd, + ShellCommandException +) from aim.web.configs import ( AIM_ENV_MODE_KEY, AIM_TF_LOGS_PATH_KEY, @@ -15,8 +21,6 @@ ) from aim.sdk.repo import Repo, RepoStatus from aim.sdk.utils import clean_repo_path -from aim.web.utils import exec_cmd -from aim.web.utils import ShellCommandException @click.command() @@ -42,14 +46,14 @@ dir_okay=False, readable=True)) @click.option('--base-path', required=False, default='', type=str) -@click.option('--force-init', is_flag=True, default=False) @click.option('--profiler', is_flag=True, default=False) @click.option('--log-level', required=False, default='', type=str) +@click.option('-y', '--yes', is_flag=True, help='Automatically confirm prompt') def up(dev, host, port, workers, uds, repo, tf_logs, ssl_keyfile, ssl_certfile, - base_path, force_init, - profiler, log_level): + base_path, profiler, + log_level, yes): if dev: os.environ[AIM_ENV_MODE_KEY] = 'dev' log_level = log_level or 'debug' @@ -71,7 +75,7 @@ def up(dev, host, port, workers, uds, repo_status = Repo.check_repo_status(repo_path) if repo_status == RepoStatus.MISSING: init_repo = None - if not force_init: + if not yes: init_repo = click.confirm(f'\'{repo_path}\' is not a valid Aim repository. Do you want to initialize it?') else: init_repo = True @@ -129,7 +133,12 @@ def up(dev, host, port, workers, uds, os.environ[AIM_PROFILER_KEY] = '1' try: - server_cmd = build_uvicorn_command(host, port, workers, uds, ssl_keyfile, ssl_certfile, log_level) + server_cmd = build_uvicorn_command( + 'aim._ext.web.run:app', + host=host, port=port, + workers=workers, uds=uds, + ssl_keyfile=ssl_keyfile, ssl_certfile=ssl_certfile, + log_level=log_level) exec_cmd(server_cmd, stream_output=True) except ShellCommandException: click.echo('Failed to run Aim UI. Please see the logs above for details.') diff --git a/aim/cli/up/utils.py b/aim/cli/up/utils.py deleted file mode 100644 index 27985062d5..0000000000 --- a/aim/cli/up/utils.py +++ /dev/null @@ -1,45 +0,0 @@ -import os -import sys - -from aim.web.configs import AIM_ENV_MODE_KEY - - -def build_db_upgrade_command(): - from aim import web - web_dir = os.path.dirname(web.__file__) - migrations_dir = os.path.join(web_dir, 'migrations') - if os.getenv(AIM_ENV_MODE_KEY, 'prod') == 'prod': - ini_file = os.path.join(migrations_dir, 'alembic.ini') - else: - ini_file = os.path.join(migrations_dir, 'alembic_dev.ini') - return [sys.executable, '-m', 'alembic', '-c', ini_file, 'upgrade', 'head'] - - -def build_uvicorn_command(host, port, num_workers, uds_path, ssl_keyfile, ssl_certfile, log_level): - cmd = [sys.executable, '-m', 'uvicorn', - '--host', host, '--port', f'{port}', - '--workers', f'{num_workers}'] - if os.getenv(AIM_ENV_MODE_KEY, 'prod') == 'prod': - log_level = log_level or 'error' - else: - import aim - cmd += ['--reload', '--reload-dir', os.path.dirname(aim.__file__)] - log_level = log_level or 'debug' - if uds_path: - cmd += ['--uds', uds_path] - if ssl_keyfile: - cmd += ['--ssl-keyfile', ssl_keyfile] - if ssl_certfile: - cmd += ['--ssl-certfile', ssl_certfile] - cmd += ['--log-level', log_level.lower()] - cmd += ['aim.web.run:app'] - return cmd - - -def get_free_port_num(): - import socket - s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) - s.bind(('', 0)) - port_num = s.getsockname()[1] - s.close() - return port_num diff --git a/aim/cli/utils.py b/aim/cli/utils.py index e17dabc0d3..4f2f875687 100644 --- a/aim/cli/utils.py +++ b/aim/cli/utils.py @@ -1,11 +1,120 @@ import os +import sys import logging +import subprocess + +from aim.web.configs import AIM_ENV_MODE_KEY from aim.web.configs import AIM_LOG_LEVEL_KEY +class ShellCommandException(Exception): + pass + + +def exec_cmd( + cmd, throw_on_error=True, env=None, stream_output=False, cwd=None, cmd_stdin=None, **kwargs +): + """ + Runs a command as a child process. + A convenience wrapper for running a command from a Python script. + Keyword arguments: + cmd -- the command to run, as a list of strings + throw_on_error -- if true, raises an Exception if the exit code of the program is nonzero + env -- additional environment variables to be defined when running the child process + cwd -- working directory for child process + stream_output -- if true, does not capture standard output and error; if false, captures these + streams and returns them + cmd_stdin -- if specified, passes the specified string as stdin to the child process. + Note on the return value: If stream_output is true, then only the exit code is returned. If + stream_output is false, then a tuple of the exit code, standard output and standard error is + returned. + """ + cmd_env = os.environ.copy() + if env: + cmd_env.update(env) + if stream_output: + child = subprocess.Popen( + cmd, env=cmd_env, cwd=cwd, universal_newlines=True, stdin=subprocess.PIPE, **kwargs + ) + child.communicate(cmd_stdin) + exit_code = child.wait() + if throw_on_error and exit_code != 0: + raise ShellCommandException("Non-zero exitcode: %s" % (exit_code)) + return exit_code + else: + child = subprocess.Popen( + cmd, + env=cmd_env, + stdout=subprocess.PIPE, + stdin=subprocess.PIPE, + stderr=subprocess.PIPE, + cwd=cwd, + universal_newlines=True, + **kwargs + ) + (stdout, stderr) = child.communicate(cmd_stdin) + exit_code = child.wait() + if throw_on_error and exit_code != 0: + raise ShellCommandException( + "Non-zero exit code: %s\n\nSTDOUT:\n%s\n\nSTDERR:%s" % (exit_code, stdout, stderr) + ) + return exit_code, stdout, stderr + + def set_log_level(log_level): numeric_level = getattr(logging, log_level.upper(), None) if not isinstance(numeric_level, int): raise ValueError('Invalid log level: %s' % log_level) os.environ[AIM_LOG_LEVEL_KEY] = str(numeric_level) logging.basicConfig(level=numeric_level) + + +def build_db_upgrade_command(): + from aim import web + web_dir = os.path.dirname(web.__file__) + migrations_dir = os.path.join(web_dir, 'migrations') + if os.getenv(AIM_ENV_MODE_KEY, 'prod') == 'prod': + ini_file = os.path.join(migrations_dir, 'alembic.ini') + else: + ini_file = os.path.join(migrations_dir, 'alembic_dev.ini') + return [sys.executable, '-m', 'alembic', '-c', ini_file, 'upgrade', 'head'] + + +def build_uvicorn_command(app, + host='0.0.0.0', + port=0, + workers=1, + uds=None, + ssl_keyfile=None, + ssl_certfile=None, + log_level='warning', + ): + cmd = [sys.executable, '-m', 'uvicorn', + '--host', host, '--port', f'{port}', + '--workers', f'{workers}'] + + if os.getenv(AIM_ENV_MODE_KEY, 'prod') == 'prod': + log_level = log_level or 'error' + else: + import aim + cmd += ['--reload', '--reload-dir', os.path.dirname(aim.__file__)] + log_level = log_level or 'debug' + + if uds: + cmd += ['--uds', uds] + if ssl_keyfile: + cmd += ['--ssl-keyfile', ssl_keyfile] + if ssl_certfile: + cmd += ['--ssl-certfile', ssl_certfile] + cmd += ['--log-level', log_level.lower()] + cmd += [app] + return cmd + + +def get_free_port_num(): + import socket + s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + s.bind(('', 0)) + port_num = s.getsockname()[1] + s.close() + return port_num diff --git a/aim/ext/transport/__init__.py b/aim/ext/transport/__init__.py index e69de29bb2..3ff722bf11 100644 --- a/aim/ext/transport/__init__.py +++ b/aim/ext/transport/__init__.py @@ -0,0 +1 @@ +from .client import Client diff --git a/aim/ext/transport/client.py b/aim/ext/transport/client.py index 077db6359d..dc66e0ed51 100644 --- a/aim/ext/transport/client.py +++ b/aim/ext/transport/client.py @@ -1,29 +1,28 @@ +import requests +import base64 import logging import os import threading import uuid import weakref -from collections import defaultdict + from copy import deepcopy from typing import Tuple - -import aim.ext.transport.proto.remote_tracking_pb2 as rpc_messages -import aim.ext.transport.proto.remote_router_pb2 as router_messages -import aim.ext.transport.proto.remote_tracking_pb2_grpc as remote_tracking_pb2_grpc -import aim.ext.transport.proto.remote_router_pb2_grpc as remote_router_pb2_grpc - -from aim.ext.transport.message_utils import pack_stream, unpack_stream, raise_exception -from aim.ext.transport.rpc_queue import RpcQueueWithRetry -from aim.ext.transport.heartbeat import RPCHeartbeatSender -from aim.ext.transport.config import ( - AIM_CLIENT_SSL_CERTIFICATES_FILE, - AIM_RT_MAX_MESSAGE_SIZE, - AIM_RT_DEFAULT_MAX_MESSAGE_SIZE, - AIM_CLIENT_QUEUE_MAX_MEMORY, +from websockets.sync.client import connect + +from aim.ext.transport.utils import handle_exception +from aim.ext.transport.message_utils import ( + raise_exception, + pack_args, + unpack_stream, + unpack_args, + encode_tree, + decode_tree ) -from aim.storage.treeutils import encode_tree, decode_tree - +from aim.ext.transport.request_queue import RequestQueue +from aim.ext.transport.heartbeat import HeartbeatSender +AIM_CLIENT_QUEUE_MAX_MEMORY = '__AIM_CLIENT_QUEUE_MAX_MEMORY__' DEFAULT_RETRY_INTERVAL = 0.1 # 100 ms DEFAULT_RETRY_COUNT = 2 @@ -33,83 +32,57 @@ class Client: _thread_local = threading.local() - # per run queues. based on run's hash - _queues = defaultdict(lambda: RpcQueueWithRetry( - 'remote_tracker', max_queue_memory=os.getenv(AIM_CLIENT_QUEUE_MAX_MEMORY, 1024 * 1024 * 1024), - retry_count=DEFAULT_RETRY_COUNT, retry_interval=DEFAULT_RETRY_INTERVAL)) + _queue = RequestQueue( + 'remote_tracker', + max_queue_memory=os.getenv(AIM_CLIENT_QUEUE_MAX_MEMORY, 1024 * 1024 * 1024), + retry_count=DEFAULT_RETRY_COUNT, + retry_interval=DEFAULT_RETRY_INTERVAL + ) def __init__(self, remote_path: str): # temporary workaround for M1 build self._id = str(uuid.uuid4()) - self._remote_path = None - self._sub_path = None - self._separate_paths(remote_path) + if remote_path.endswith('/'): + remote_path = remote_path[:-1] + self._remote_path = remote_path - self._request_metadata = [('x-client', self.uri), ('x-project', self._sub_path)] + self._http_protocol = 'http://' + self._ws_protocol = 'ws://' + self.protocol_probe() self._resource_pool = weakref.WeakValueDictionary() - self._remote_router_channel = None - self._remote_router_stub = None - self._remote_channel = None - self._remote_stub = None - self._remote_worker_address = None - self._create_remote_channels() + self._client_endpoint = f'{self.remote_path}/client' + self._tracking_endpoint = f'{self.remote_path}/tracking' + self.request_headers = {} + self.connect() - self._heartbeat_sender = RPCHeartbeatSender(self) + self._heartbeat_sender = HeartbeatSender(self) self._heartbeat_sender.start() - self._thread_local.atomic_instructions = None + self._thread_local.atomic_instructions = {} + self._ws = None - def _separate_paths(self, remote_path): - hostname, port_sub_path = remote_path.rsplit(':', maxsplit=1) + def protocol_probe(self): + endpoint = f'http://{self.remote_path}/status/' try: - port, sub_path = port_sub_path.split('/', maxsplit=1) - except ValueError: # no sub_path specified - port = port_sub_path - sub_path = '' - self._remote_path = f'{hostname}:{port}' - self._sub_path = sub_path - - def _create_remote_channels(self): - import grpc - - ssl_certfile = os.getenv(AIM_CLIENT_SSL_CERTIFICATES_FILE) - msg_max_size = int(os.getenv(AIM_RT_MAX_MESSAGE_SIZE, AIM_RT_DEFAULT_MAX_MESSAGE_SIZE)) - options = [ - ('grpc.max_send_message_length', msg_max_size), - ('grpc.max_receive_message_length', msg_max_size) - ] - - # open a channel with router - if ssl_certfile: - with open(ssl_certfile, 'rb') as f: - root_certificates = grpc.ssl_channel_credentials(f.read()) - self._remote_router_channel = grpc.secure_channel(self.remote_path, root_certificates, options=options) - else: - self._remote_router_channel = grpc.insecure_channel(self.remote_path, options=options) - self._remote_router_stub = remote_router_pb2_grpc.RemoteRouterServiceStub(self._remote_router_channel) - - # check client/server version compatibility - self._check_remote_version_compatibility() - - # get the available worker address - self._remote_worker_address = self._get_worker_address() - - # if we got the same address as the router, there's no need to open new channels - if self._remote_worker_address == self.remote_path: - self._remote_channel = self._remote_router_channel - - else: - # open a channel with worker for further communication - if ssl_certfile: - self._remote_channel = grpc.secure_channel(self._remote_worker_address, - root_certificates, - options=options) - else: - self._remote_channel = grpc.insecure_channel(self._remote_worker_address, options=options) - - self._remote_stub = remote_tracking_pb2_grpc.RemoteTrackingServiceStub(self._remote_channel) + response = requests.get(endpoint, headers=self.request_headers) + if response.status_code == 200: + if response.url.startswith('https://'): + self._http_protocol = 'https://' + self._ws_protocol = 'wss://' + return + except Exception: + pass + + endpoint = f'https://{self.remote_path}/status/' + try: + response = requests.get(endpoint, headers=self.request_headers) + if response.status_code == 200: + self._http_protocol = 'https://' + self._ws_protocol = 'wss://' + except Exception: + pass def reinitialize_resource(self, handler): # write some request to get a resource on server side with an already given handler @@ -121,9 +94,10 @@ def _reinitialize_all_resources(self): for handler in handlers_list: self.reinitialize_resource(handler) + @handle_exception(requests.ConnectionError, + error_message='Failed to connect to Aim Server. Have you forgot to run `aim server` command?') def _check_remote_version_compatibility(self): from aim.__version__ import __version__ as client_version - import grpc error_message_template = 'The Aim Remote tracking server version ({}) '\ 'is not compatible with the Aim client version ({}).'\ @@ -133,16 +107,10 @@ def _check_remote_version_compatibility(self): 'and the Aim client version ({}) do not match.' \ 'Consider upgrading either the client or remote tracking server.' - try: - remote_version = self.get_version() - except grpc.RpcError as e: - if e.code() == grpc.StatusCode.UNIMPLEMENTED: - remote_version = '<3.15.0' - else: - raise + remote_version = self.get_version() # server doesn't yet have the `get_version()` method implemented - if remote_version == '<3.15.0': + if remote_version == '<3.19.0': RuntimeError(error_message_template.format(remote_version, client_version)) # compare versions @@ -157,87 +125,87 @@ def _check_remote_version_compatibility(self): logger.warning(warning_message_template.format(remote_version, client_version)) # further incompatibility list will be added manually - def _get_worker_address(self): - worker_port_offset = self._get_worker_port_offset() - if worker_port_offset == 0: - return self._remote_path - else: - router_host = self._remote_path.rsplit(':', maxsplit=1)[0] - router_port = int(self._remote_path.rsplit(':', maxsplit=1)[1]) - - return f'{router_host}:{router_port + worker_port_offset}' + def client_heartbeat(self): + endpoint = f'{self._http_protocol}{self._client_endpoint}/heartbeat/{self.uri}/' + response = requests.get(endpoint, headers=self.request_headers) + response_json = response.json() + if response.status_code != 200: + raise_exception(response_json.get('message')) - def _get_worker_port_offset(self): - request = router_messages.ConnectRequest( - client_uri=self.uri - ) - response = self._remote_router_stub.connect(request, metadata=self._request_metadata) - if response.status == router_messages.ConnectResponse.Status.ERROR: - raise_exception(response.exception) + return response - return int(response.worker_index) + def connect(self): + endpoint = f'{self._http_protocol}{self._client_endpoint}/connect/{self.uri}/' + response = requests.get(endpoint, headers=self.request_headers) + response_json = response.json() + if response.status_code != 200: + raise_exception(response_json.get('message')) - def client_heartbeat(self): - request = router_messages.HeartbeatRequest( - client_uri=self.uri, - ) - response = self._remote_router_stub.client_heartbeat(request, metadata=self._request_metadata) return response def reconnect(self): - request = router_messages.ReconnectRequest( - client_uri=self.uri - ) - response = self._remote_router_stub.reconnect(request, metadata=self._request_metadata) - if response.status == router_messages.ReconnectResponse.Status.ERROR: - raise_exception(response.exception) + endpoint = f'{self._http_protocol}{self._client_endpoint}/reconnect/{self.uri}/' + response = requests.get(endpoint, headers=self.request_headers) + response_json = response.json() + if response.status_code != 200: + raise_exception(response_json.get('message')) + self.refresh_ws() self._reinitialize_all_resources() return response def disconnect(self): - request = router_messages.DisconnectRequest( - client_uri=self.uri - ) - response = self._remote_router_stub.disconnect(request, metadata=self._request_metadata) + self._heartbeat_sender.stop() - if response.status == router_messages.DisconnectResponse.Status.ERROR: - raise_exception(response.exception) + endpoint = f'{self._http_protocol}{self._client_endpoint}/disconnect/{self.uri}/' + response = requests.get(endpoint, headers=self.request_headers) + response_json = response.json() + if response.status_code != 200: + raise_exception(response_json.get('message')) - def get_version(self,): - request = router_messages.VersionRequest() - response = self._remote_router_stub.get_version(request, metadata=self._request_metadata) + return response - if response.status == router_messages.VersionResponse.Status.ERROR: - raise_exception(response.exception) - return response.version + def get_version(self,): + endpoint = f'{self._http_protocol}{self._client_endpoint}/get-version/' + response = requests.get(endpoint, headers=self.request_headers) + response_json = response.json() + if response.status_code == 404: + return '<3.19.0' + if response.status_code == 400: + raise_exception(response_json.get('exception')) + return response_json.get('version') def get_resource_handler(self, resource, resource_type, handler='', args=()): - request = rpc_messages.ResourceRequest( - resource_type=resource_type, - handler=handler, - client_uri=self.uri, - args=args - ) - response = self.remote.get_resource(request, metadata=self._request_metadata) - if response.status == rpc_messages.ResourceResponse.Status.ERROR: - raise_exception(response.exception) + endpoint = f'{self._http_protocol}{self._tracking_endpoint}/{self.uri}/get-resource/' - self._resource_pool[response.handler] = resource + request_data = { + 'resource_handler': handler, + 'resource_type': resource_type, + 'args': base64.b64encode(args).decode() + } - return response.handler + response = requests.post(endpoint, json=request_data, headers=self.request_headers) + response_json = response.json() + if response.status_code == 400: + raise_exception(response_json.get('exception')) + elif response.status_code != 200: + raise (Exception(response_json)) + + handler = response_json.get('handler') + self._resource_pool[handler] = resource + + return handler def release_resource(self, queue_id, resource_handler): - request = rpc_messages.ReleaseResourceRequest( - handler=resource_handler, - client_uri=self.uri - ) + endpoint = f'{self._http_protocol}{self._tracking_endpoint}/{self.uri}/release-resource/{resource_handler}/' if queue_id != -1: - self.get_queue(queue_id).wait_for_finish() - response = self.remote.release_resource(request, metadata=self._request_metadata) - if response.status == rpc_messages.ReleaseResourceResponse.Status.ERROR: - raise_exception(response.exception) + self.get_queue().wait_for_finish() + + response = requests.get(endpoint, headers=self.request_headers) + response_json = response.json() + if response.status_code == 400: + raise_exception(response_json.get('exception')) del self._resource_pool[resource_handler] @@ -245,14 +213,15 @@ def run_instruction(self, queue_id, resource, method, args=(), is_write_only=Fal args = deepcopy(args) # self._thread_local can be empty in the 'clean up' phase. - if getattr(self._thread_local, 'atomic_instructions', None) is not None: - assert is_write_only - self._thread_local.atomic_instructions.append((resource, method, args)) - return if is_write_only: assert queue_id != -1 - self.get_queue(queue_id).register_task( + if getattr(self._thread_local, 'atomic_instructions', None) is not None and \ + self._thread_local.atomic_instructions.get(queue_id, None) is not None: + self._thread_local.atomic_instructions[queue_id].append((resource, method, args)) + return + + self.get_queue().register_task( self, self._run_write_instructions, list(encode_tree([(resource, method, args)], strict=False))) return @@ -260,61 +229,59 @@ def run_instruction(self, queue_id, resource, method, args=(), is_write_only=Fal return self._run_read_instructions(queue_id, resource, method, args) def _run_read_instructions(self, queue_id, resource, method, args): - def message_stream_generator(): - header = rpc_messages.InstructionRequest( - header=rpc_messages.RequestHeader( - version='0.1', - handler=resource, - client_uri=self.uri, - method_name=method - ) - ) - yield header - - stream = pack_stream(encode_tree(args)) - for chunk in stream: - yield rpc_messages.InstructionRequest(message=chunk) + endpoint = f'{self._http_protocol}{self._tracking_endpoint}/{self.uri}/read-instruction/' + + request_data = { + 'resource_handler': resource, + 'method_name': method, + 'args': base64.b64encode(pack_args(encode_tree(args))).decode() + } if queue_id != -1: - self.get_queue(queue_id).wait_for_finish() - resp = self.remote.run_instruction(message_stream_generator(), metadata=self._request_metadata) - status_msg = next(resp) + self.get_queue().wait_for_finish() - assert status_msg.WhichOneof('instruction') == 'header' - if status_msg.header.status == rpc_messages.ResponseHeader.Status.ERROR: - raise_exception(status_msg.header.exception) - return decode_tree(unpack_stream(resp)) + response = requests.post(endpoint, json=request_data, stream=True, headers=self.request_headers) + + if response.status_code == 400: + raise_exception(response.json().get('exception')) + return decode_tree(unpack_stream(response.iter_content(chunk_size=None))) def _run_write_instructions(self, instructions: [Tuple[bytes, bytes]]): - stream = pack_stream(iter(instructions)) + msg = pack_args(iter(instructions)) + + self.ws.send(msg) - def message_stream_generator(): - for chunk in stream: - yield rpc_messages.WriteInstructionsRequest( - version='0.1', - client_uri=self.uri, - message=chunk - ) + response = self.ws.recv() + if response == b'OK': + return - response = self.remote.run_write_instructions(message_stream_generator(), metadata=self._request_metadata) - if response.status == rpc_messages.WriteInstructionsResponse.Status.ERROR: - raise_exception(response.exception) + response_json = decode_tree(unpack_args(response)) + raise_exception(response_json) - def start_instructions_batch(self): - self._thread_local.atomic_instructions = [] + def start_instructions_batch(self, hash_): + if getattr(self._thread_local, 'atomic_instructions', None) is None: + self._thread_local.atomic_instructions = {} + self._thread_local.atomic_instructions[hash_] = [] - def flush_instructions_batch(self, queue_id): - if self._thread_local.atomic_instructions is None: + def flush_instructions_batch(self, hash_): + if self._thread_local.atomic_instructions.get(hash_) is None: return - self.get_queue(queue_id).register_task( + self.get_queue().register_task( self, - self._run_write_instructions, list(encode_tree(self._thread_local.atomic_instructions))) - self._thread_local.atomic_instructions = None + self._run_write_instructions, list(encode_tree(self._thread_local.atomic_instructions[hash_]))) + del self._thread_local.atomic_instructions[hash_] + + def refresh_ws(self): + self._ws = connect(f'{self._ws_protocol}{self._tracking_endpoint}/{self.uri}/write-instruction/') @property - def remote(self): # access to low-level interface - return self._remote_stub + def ws(self): + if self._ws is None: + self._ws = connect(f'{self._ws_protocol}{self._tracking_endpoint}/{self.uri}/write-instruction/', + additional_headers=self.request_headers) + + return self._ws @property def uri(self): @@ -324,8 +291,5 @@ def uri(self): def remote_path(self): return self._remote_path - def get_queue(self, queue_id): - return self._queues[queue_id] - - def remove_queue(self, queue_id): - del self._queues[queue_id] + def get_queue(self): + return self._queue diff --git a/aim/ext/transport/config.py b/aim/ext/transport/config.py index 44b08442a9..3f66620288 100644 --- a/aim/ext/transport/config.py +++ b/aim/ext/transport/config.py @@ -2,12 +2,6 @@ AIM_SERVER_DEFAULT_PORT = 53800 AIM_SERVER_DEFAULT_HOST = '0.0.0.0' AIM_SERVER_MOUNTED_REPO_PATH = '__AIM_SERVER_MOUNT_REPO_PATH__' +AIM_SERVER_BASE_PATH = '__AIM_SERVER_BASE_PATH__' -# AIM CLIENT -# The path of the PEM-encoded root certificates. Used for secure channel establishment -AIM_CLIENT_SSL_CERTIFICATES_FILE = '__AIM_CLIENT_SSL_CERTIFICATES_FILE__' -AIM_CLIENT_QUEUE_MAX_MEMORY = '__AIM_CLIENT_QUEUE_MAX_MEMORY__' - -# GRPC OPTIONS -AIM_RT_MAX_MESSAGE_SIZE = '__AIM_RT_MAX_MESSAGE_SIZE__' -AIM_RT_DEFAULT_MAX_MESSAGE_SIZE = 16 * 1024 * 1024 # 16MB +AIM_RT_BEARER_TOKEN = '__AIM_RT_BEARER_TOKEN__' diff --git a/aim/ext/transport/health.py b/aim/ext/transport/health.py deleted file mode 100644 index a9eeb5c26a..0000000000 --- a/aim/ext/transport/health.py +++ /dev/null @@ -1,157 +0,0 @@ -# Copied from -# https://github.com/grpc/grpc/blob/master/src/python/grpcio_health_checking/grpc_health/v1/health.py -# with minimal changes to work within Aim - -import collections -import threading - -from aim.ext.transport.proto import health_pb2 as health_pb2 -from aim.ext.transport.proto import health_pb2_grpc as health_pb2_grpc - - -# The service name of the health checking servicer. -SERVICE_NAME = health_pb2.DESCRIPTOR.services_by_name['Health'].full_name -# The entry of overall health for the entire server. -OVERALL_HEALTH = '' - - -class _Watcher: - - def __init__(self): - self._condition = threading.Condition() - self._responses = collections.deque() - self._open = True - - def __iter__(self): - return self - - def _next(self): - with self._condition: - while not self._responses and self._open: - self._condition.wait() - if self._responses: - return self._responses.popleft() - else: - raise StopIteration() - - def next(self): - return self._next() - - def __next__(self): - return self._next() - - def add(self, response): - with self._condition: - self._responses.append(response) - self._condition.notify() - - def close(self): - with self._condition: - self._open = False - self._condition.notify() - - -def _watcher_to_send_response_callback_adapter(watcher): - - def send_response_callback(response): - if response is None: - watcher.close() - else: - watcher.add(response) - - return send_response_callback - - -class HealthServicer(health_pb2_grpc.HealthServicer): - """Servicer handling RPCs for service statuses.""" - - def __init__(self, - experimental_non_blocking=True, - experimental_thread_pool=None): - self._lock = threading.RLock() - self._server_status = {"": health_pb2.HealthCheckResponse.SERVING} - self._send_response_callbacks = {} - self.Watch.__func__.experimental_non_blocking = experimental_non_blocking - self.Watch.__func__.experimental_thread_pool = experimental_thread_pool - self._gracefully_shutting_down = False - - def _on_close_callback(self, send_response_callback, service): - - def callback(): - with self._lock: - self._send_response_callbacks[service].remove( - send_response_callback) - send_response_callback(None) - - return callback - - def Check(self, request, context): - import grpc - with self._lock: - status = self._server_status.get(request.service) - if status is None: - context.set_code(grpc.StatusCode.NOT_FOUND) - return health_pb2.HealthCheckResponse() - else: - return health_pb2.HealthCheckResponse(status=status) - - # pylint: disable=arguments-differ - def Watch(self, request, context, send_response_callback=None): - blocking_watcher = None - if send_response_callback is None: - # The server does not support the experimental_non_blocking - # parameter. For backwards compatibility, return a blocking response - # generator. - blocking_watcher = _Watcher() - send_response_callback = _watcher_to_send_response_callback_adapter( - blocking_watcher) - service = request.service - with self._lock: - status = self._server_status.get(service) - if status is None: - status = health_pb2.HealthCheckResponse.SERVICE_UNKNOWN # pylint: disable=no-member - send_response_callback( - health_pb2.HealthCheckResponse(status=status)) - if service not in self._send_response_callbacks: - self._send_response_callbacks[service] = set() - self._send_response_callbacks[service].add(send_response_callback) - context.add_callback( - self._on_close_callback(send_response_callback, service)) - return blocking_watcher - - def set(self, service, status): - """Sets the status of a service. - - Args: - service: string, the name of the service. - status: HealthCheckResponse.status enum value indicating the status of - the service - """ - with self._lock: - if self._gracefully_shutting_down: - return - else: - self._server_status[service] = status - if service in self._send_response_callbacks: - for send_response_callback in self._send_response_callbacks[ - service]: - send_response_callback( - health_pb2.HealthCheckResponse(status=status)) - - def enter_graceful_shutdown(self): - """Permanently sets the status of all services to NOT_SERVING. - - This should be invoked when the server is entering a graceful shutdown - period. After this method is invoked, future attempts to set the status - of a service will be ignored. - - This is an EXPERIMENTAL API. - """ - with self._lock: - if self._gracefully_shutting_down: - return - else: - for service in self._server_status: - self.set(service, - health_pb2.HealthCheckResponse.NOT_SERVING) # pylint: disable=no-member - self._gracefully_shutting_down = True diff --git a/aim/ext/transport/heartbeat.py b/aim/ext/transport/heartbeat.py index d0fc3fb930..f174eaa570 100644 --- a/aim/ext/transport/heartbeat.py +++ b/aim/ext/transport/heartbeat.py @@ -7,12 +7,10 @@ from threading import Thread from typing import Union -import aim.ext.transport.proto.remote_router_pb2 as rpc_messages - logger = logging.getLogger(__name__) -class RPCHeartbeatSender(object): +class HeartbeatSender(object): HEARTBEAT_INTERVAL_DEFAULT = 10 NETWORK_CHECK_INTERVAL = 180 @@ -30,7 +28,7 @@ def __init__(self, self._heartbeat_send_interval = interval # network state check vars - self._network_stability_check_interval = RPCHeartbeatSender.NETWORK_CHECK_INTERVAL + self._network_stability_check_interval = HeartbeatSender.NETWORK_CHECK_INTERVAL self._network_unstable_warned = False self._network_absent_warned = False self._heartbeat_responses = Counter(success=0, fail=0) @@ -58,7 +56,7 @@ def _send_heartbeat(self): if self._remote_client(): try: response = self._remote_client().client_heartbeat() - if response.status == rpc_messages.HeartbeatResponse.Status.OK: + if response.status_code == 200: self._heartbeat_responses['success'] += 1 else: self._heartbeat_responses['fail'] += 1 @@ -99,29 +97,27 @@ def reset_responses(): if self._heartbeat_responses['success'] and not self._network_unstable_warned: self._network_unstable_warned = True - logger.warning(RPCHeartbeatSender.NETWORK_UNSTABLE_WARNING_TEMPLATE + logger.warning(HeartbeatSender.NETWORK_UNSTABLE_WARNING_TEMPLATE .format(self._remote_client().uri, self._remote_client().remote_path)) reset_responses() return if not self._network_absent_warned: self._network_absent_warned = True - logger.warning(RPCHeartbeatSender.NETWORK_ABSENT_WARNING_TEMPLATE + logger.warning(HeartbeatSender.NETWORK_ABSENT_WARNING_TEMPLATE .format(self._remote_client().uri, self._remote_client().remote_path)) reset_responses() -class RPCHeartbeatWatcher: +class HeartbeatWatcher: CLIENT_KEEP_ALIVE_TIME_DEFAULT = 30 * 60 # 30 minutes def __init__(self, heartbeat_pool, - worker_pool, keep_alive_time: Union[int, float] = CLIENT_KEEP_ALIVE_TIME_DEFAULT): self._heartbeat_pool = heartbeat_pool - self._worker_pool = worker_pool self._client_keep_alive_time = keep_alive_time @@ -146,10 +142,10 @@ def stop(self): def _release_client_resources(self, dead_client_uri): logger.warning(f'Cleaning up resources for client `{dead_client_uri}`.') - for worker in self._worker_pool: - if dead_client_uri in worker.clients: - worker.cleanup_client_resources(dead_client_uri) - worker.remove_client(dead_client_uri) + from aim.ext.transport.tracking import TrackingRouter + from aim.ext.transport.router import ClientRouter + TrackingRouter.cleanup_client_resources(dead_client_uri) + ClientRouter.remove_client(dead_client_uri) def _interval_check(self): while True: diff --git a/aim/ext/transport/message_utils.py b/aim/ext/transport/message_utils.py index 1664413c68..bcf4a58bc6 100644 --- a/aim/ext/transport/message_utils.py +++ b/aim/ext/transport/message_utils.py @@ -1,17 +1,22 @@ import importlib import struct import json -from typing import Iterator, Tuple, Union +from typing import Iterator, Tuple -import aim.ext.transport.proto.remote_tracking_pb2 as rpc_messages from aim.storage.object import CustomObject from aim.storage.types import BLOB +from aim.storage.treeutils import encode_tree, decode_tree # noqa -Message = Union[rpc_messages.ResourceRequest, rpc_messages.ResourceResponse] +def pack_args(tree: Iterator[Tuple[bytes, bytes]]) -> bytes: + result = [] + for key, val in tree: + if not isinstance(val, BLOB): + result.append(struct.pack('I', len(key)) + key + struct.pack('?', False) + struct.pack('I', len(val)) + val) + else: + val = val.load() + result.append(struct.pack('I', len(key)) + key + struct.pack('?', True) + struct.pack('I', len(val)) + val) -def pack_args(args: Iterator[Tuple[bytes, bytes]]) -> bytes: - result = [struct.pack('I', len(key)) + key + struct.pack('I', len(val)) + val for key, val in args] return b''.join(result) @@ -19,11 +24,14 @@ def unpack_args(args: bytes) -> Tuple[bytes, bytes]: while args: (key_size,), args_tail = struct.unpack('I', args[:4]), args[4:] key, args_tail = args_tail[:key_size], args_tail[key_size:] - + (is_blob,), args_tail = struct.unpack('?', args_tail[:1]), args_tail[1:] (value_size,), args_tail = struct.unpack('I', args_tail[:4]), args_tail[4:] value, args_tail = args_tail[:value_size], args_tail[value_size:] args = args_tail - yield key, value + if is_blob: + yield key, BLOB(data=value) + else: + yield key, value def pack_stream(tree: Iterator[Tuple[bytes, bytes]]) -> bytes: @@ -49,44 +57,24 @@ def unpack_helper(msg: bytes) -> Tuple[bytes, bytes]: yield key, value -def unpack_bytes(stream: Iterator[bytes]) -> Tuple[bytes, bytes]: +def unpack_stream(stream) -> Tuple[bytes, bytes]: for msg in stream: yield from unpack_helper(msg) -def unpack_stream(stream: Iterator[Message]) -> Tuple[bytes, bytes]: - for msg in stream: - if msg.WhichOneof('instruction') == 'header': - # can be header in case of exceptions on server side - assert msg.header.status == rpc_messages.ResponseHeader.Status.ERROR - raise_exception(msg.header.exception) - return - - assert msg.WhichOneof('instruction') == 'message' - msg = msg.message - - yield from unpack_helper(msg) - - -def raise_exception(grpc_exception): - assert grpc_exception is not None - module = importlib.import_module(grpc_exception.module_name) - exception = getattr(module, grpc_exception.class_name) - args = json.loads(grpc_exception.args or []) +def raise_exception(server_exception): + module = importlib.import_module(server_exception.get('module_name')) + exception = getattr(module, server_exception.get('class_name')) + args = json.loads(server_exception.get('args') or []) raise exception(*args) if args else exception() def build_exception(exception: Exception): - return rpc_messages.ExceptionResponse( - module_name=exception.__class__.__module__, - class_name=exception.__class__.__name__, - args=json.dumps(exception.args), - ) - - -class UnauthorizedRequestError(RuntimeError): - def __init__(self, handler, *args, **kwargs): - self.handler = handler + return { + 'module_name': exception.__class__.__module__, + 'class_name': exception.__class__.__name__, + 'args': json.dumps(exception.args), + } @CustomObject.alias('aim.resource') diff --git a/aim/ext/transport/proto/__init__.py b/aim/ext/transport/proto/__init__.py deleted file mode 100644 index e69de29bb2..0000000000 diff --git a/aim/ext/transport/proto/health.proto b/aim/ext/transport/proto/health.proto deleted file mode 100644 index 56785eabcc..0000000000 --- a/aim/ext/transport/proto/health.proto +++ /dev/null @@ -1,23 +0,0 @@ -syntax = "proto3"; - -package grpc.health.v1; - -message HealthCheckRequest { - string service = 1; -} - -message HealthCheckResponse { - enum ServingStatus { - UNKNOWN = 0; - SERVING = 1; - NOT_SERVING = 2; - SERVICE_UNKNOWN = 3; // Used only by the Watch method. - } - ServingStatus status = 1; -} - -service Health { - rpc Check(HealthCheckRequest) returns (HealthCheckResponse); - - rpc Watch(HealthCheckRequest) returns (stream HealthCheckResponse); -} \ No newline at end of file diff --git a/aim/ext/transport/proto/health_pb2.py b/aim/ext/transport/proto/health_pb2.py deleted file mode 100644 index faeb0102fc..0000000000 --- a/aim/ext/transport/proto/health_pb2.py +++ /dev/null @@ -1,8 +0,0 @@ -import google.protobuf - -protobuf_version = google.protobuf.__version__[0] - -if protobuf_version == "3": - from aim.ext.transport.proto.v3.health_pb2 import * -elif protobuf_version == "4": - from aim.ext.transport.proto.v4.health_pb2 import * diff --git a/aim/ext/transport/proto/health_pb2_grpc.py b/aim/ext/transport/proto/health_pb2_grpc.py deleted file mode 100644 index 63ebb795be..0000000000 --- a/aim/ext/transport/proto/health_pb2_grpc.py +++ /dev/null @@ -1,103 +0,0 @@ -# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! -"""Client and server classes corresponding to protobuf-defined services.""" -# temporary workaround for M1 build -try: - import grpc -except ImportError: - grpc = None - -import aim.ext.transport.proto.health_pb2 as health__pb2 - - -class HealthStub(object): - """Missing associated documentation comment in .proto file.""" - - def __init__(self, channel): - """Constructor. - - Args: - channel: A grpc.Channel. - """ - self.Check = channel.unary_unary( - '/grpc.health.v1.Health/Check', - request_serializer=health__pb2.HealthCheckRequest.SerializeToString, - response_deserializer=health__pb2.HealthCheckResponse.FromString, - ) - self.Watch = channel.unary_stream( - '/grpc.health.v1.Health/Watch', - request_serializer=health__pb2.HealthCheckRequest.SerializeToString, - response_deserializer=health__pb2.HealthCheckResponse.FromString, - ) - - -class HealthServicer(object): - """Missing associated documentation comment in .proto file.""" - - def Check(self, request, context): - """Missing associated documentation comment in .proto file.""" - context.set_code(grpc.StatusCode.UNIMPLEMENTED) - context.set_details('Method not implemented!') - raise NotImplementedError('Method not implemented!') - - def Watch(self, request, context): - """Missing associated documentation comment in .proto file.""" - context.set_code(grpc.StatusCode.UNIMPLEMENTED) - context.set_details('Method not implemented!') - raise NotImplementedError('Method not implemented!') - - -def add_HealthServicer_to_server(servicer, server): - rpc_method_handlers = { - 'Check': grpc.unary_unary_rpc_method_handler( - servicer.Check, - request_deserializer=health__pb2.HealthCheckRequest.FromString, - response_serializer=health__pb2.HealthCheckResponse.SerializeToString, - ), - 'Watch': grpc.unary_stream_rpc_method_handler( - servicer.Watch, - request_deserializer=health__pb2.HealthCheckRequest.FromString, - response_serializer=health__pb2.HealthCheckResponse.SerializeToString, - ), - } - generic_handler = grpc.method_handlers_generic_handler( - 'grpc.health.v1.Health', rpc_method_handlers) - server.add_generic_rpc_handlers((generic_handler,)) - - - # This class is part of an EXPERIMENTAL API. -class Health(object): - """Missing associated documentation comment in .proto file.""" - - @staticmethod - def Check(request, - target, - options=(), - channel_credentials=None, - call_credentials=None, - insecure=False, - compression=None, - wait_for_ready=None, - timeout=None, - metadata=None): - return grpc.experimental.unary_unary(request, target, '/grpc.health.v1.Health/Check', - health__pb2.HealthCheckRequest.SerializeToString, - health__pb2.HealthCheckResponse.FromString, - options, channel_credentials, - insecure, call_credentials, compression, wait_for_ready, timeout, metadata) - - @staticmethod - def Watch(request, - target, - options=(), - channel_credentials=None, - call_credentials=None, - insecure=False, - compression=None, - wait_for_ready=None, - timeout=None, - metadata=None): - return grpc.experimental.unary_stream(request, target, '/grpc.health.v1.Health/Watch', - health__pb2.HealthCheckRequest.SerializeToString, - health__pb2.HealthCheckResponse.FromString, - options, channel_credentials, - insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/aim/ext/transport/proto/remote_router.proto b/aim/ext/transport/proto/remote_router.proto deleted file mode 100644 index 98f4bb2ef9..0000000000 --- a/aim/ext/transport/proto/remote_router.proto +++ /dev/null @@ -1,80 +0,0 @@ -syntax = "proto3"; - -import "remote_tracking.proto"; - -message VersionRequest {} - -message VersionResponse { - string version = 1; - enum Status { - OK = 0; - ERROR = 1; - } - Status status = 2; - ExceptionResponse exception = 3; -} - -message HeartbeatRequest { - string client_uri = 1; -} - -message HeartbeatResponse { - enum Status { - OK = 0; - ERROR = 1; - } - Status status = 1; - ExceptionResponse exception = 2; -} - -message ConnectRequest { - string client_uri = 1; -} - -message ConnectResponse { - string port = 1; - string worker_index = 2; - enum Status { - OK = 0; - ERROR = 1; - } - Status status = 3; - ExceptionResponse exception = 4; -} - -message ReconnectRequest { - string client_uri = 1; -} - -message ReconnectResponse { - string port = 1; - enum Status { - OK = 0; - ERROR = 1; - } - Status status = 2; - ExceptionResponse exception = 3; -} - -message DisconnectRequest { - string client_uri = 1; -} - -message DisconnectResponse { - enum Status { - OK = 0; - ERROR = 1; - } - Status status = 1; - ExceptionResponse exception = 3; -} - - - -service RemoteRouterService { - rpc client_heartbeat(HeartbeatRequest) returns (HeartbeatResponse) {} - rpc get_version(VersionRequest) returns (VersionResponse) {} - rpc connect(ConnectRequest) returns (ConnectResponse) {} - rpc reconnect(ReconnectRequest) returns (ReconnectResponse) {} - rpc disconnect(DisconnectRequest) returns (DisconnectResponse) {} -} diff --git a/aim/ext/transport/proto/remote_router_pb2.py b/aim/ext/transport/proto/remote_router_pb2.py deleted file mode 100644 index 6d1f958055..0000000000 --- a/aim/ext/transport/proto/remote_router_pb2.py +++ /dev/null @@ -1,8 +0,0 @@ -import google.protobuf - -protobuf_version = google.protobuf.__version__[0] - -if protobuf_version == "3": - from aim.ext.transport.proto.v3.remote_router_pb2 import * -elif protobuf_version == "4": - from aim.ext.transport.proto.v4.remote_router_pb2 import * diff --git a/aim/ext/transport/proto/remote_router_pb2_grpc.py b/aim/ext/transport/proto/remote_router_pb2_grpc.py deleted file mode 100644 index 8ba0f32788..0000000000 --- a/aim/ext/transport/proto/remote_router_pb2_grpc.py +++ /dev/null @@ -1,202 +0,0 @@ -# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! -"""Client and server classes corresponding to protobuf-defined services.""" -# temporary workaround for M1 build -try: - import grpc -except ImportError: - grpc = None - -import aim.ext.transport.proto.remote_router_pb2 as remote__router__pb2 - - -class RemoteRouterServiceStub(object): - """Missing associated documentation comment in .proto file.""" - - def __init__(self, channel): - """Constructor. - - Args: - channel: A grpc.Channel. - """ - self.client_heartbeat = channel.unary_unary( - '/RemoteRouterService/client_heartbeat', - request_serializer=remote__router__pb2.HeartbeatRequest.SerializeToString, - response_deserializer=remote__router__pb2.HeartbeatResponse.FromString, - ) - self.get_version = channel.unary_unary( - '/RemoteRouterService/get_version', - request_serializer=remote__router__pb2.VersionRequest.SerializeToString, - response_deserializer=remote__router__pb2.VersionResponse.FromString, - ) - self.connect = channel.unary_unary( - '/RemoteRouterService/connect', - request_serializer=remote__router__pb2.ConnectRequest.SerializeToString, - response_deserializer=remote__router__pb2.ConnectResponse.FromString, - ) - self.reconnect = channel.unary_unary( - '/RemoteRouterService/reconnect', - request_serializer=remote__router__pb2.ReconnectRequest.SerializeToString, - response_deserializer=remote__router__pb2.ReconnectResponse.FromString, - ) - self.disconnect = channel.unary_unary( - '/RemoteRouterService/disconnect', - request_serializer=remote__router__pb2.DisconnectRequest.SerializeToString, - response_deserializer=remote__router__pb2.DisconnectResponse.FromString, - ) - - -class RemoteRouterServiceServicer(object): - """Missing associated documentation comment in .proto file.""" - - def client_heartbeat(self, request, context): - """Missing associated documentation comment in .proto file.""" - context.set_code(grpc.StatusCode.UNIMPLEMENTED) - context.set_details('Method not implemented!') - raise NotImplementedError('Method not implemented!') - - def get_version(self, request, context): - """Missing associated documentation comment in .proto file.""" - context.set_code(grpc.StatusCode.UNIMPLEMENTED) - context.set_details('Method not implemented!') - raise NotImplementedError('Method not implemented!') - - def connect(self, request, context): - """Missing associated documentation comment in .proto file.""" - context.set_code(grpc.StatusCode.UNIMPLEMENTED) - context.set_details('Method not implemented!') - raise NotImplementedError('Method not implemented!') - - def reconnect(self, request, context): - """Missing associated documentation comment in .proto file.""" - context.set_code(grpc.StatusCode.UNIMPLEMENTED) - context.set_details('Method not implemented!') - raise NotImplementedError('Method not implemented!') - - def disconnect(self, request, context): - """Missing associated documentation comment in .proto file.""" - context.set_code(grpc.StatusCode.UNIMPLEMENTED) - context.set_details('Method not implemented!') - raise NotImplementedError('Method not implemented!') - - -def add_RemoteRouterServiceServicer_to_server(servicer, server): - rpc_method_handlers = { - 'client_heartbeat': grpc.unary_unary_rpc_method_handler( - servicer.client_heartbeat, - request_deserializer=remote__router__pb2.HeartbeatRequest.FromString, - response_serializer=remote__router__pb2.HeartbeatResponse.SerializeToString, - ), - 'get_version': grpc.unary_unary_rpc_method_handler( - servicer.get_version, - request_deserializer=remote__router__pb2.VersionRequest.FromString, - response_serializer=remote__router__pb2.VersionResponse.SerializeToString, - ), - 'connect': grpc.unary_unary_rpc_method_handler( - servicer.connect, - request_deserializer=remote__router__pb2.ConnectRequest.FromString, - response_serializer=remote__router__pb2.ConnectResponse.SerializeToString, - ), - 'reconnect': grpc.unary_unary_rpc_method_handler( - servicer.reconnect, - request_deserializer=remote__router__pb2.ReconnectRequest.FromString, - response_serializer=remote__router__pb2.ReconnectResponse.SerializeToString, - ), - 'disconnect': grpc.unary_unary_rpc_method_handler( - servicer.disconnect, - request_deserializer=remote__router__pb2.DisconnectRequest.FromString, - response_serializer=remote__router__pb2.DisconnectResponse.SerializeToString, - ), - } - generic_handler = grpc.method_handlers_generic_handler( - 'RemoteRouterService', rpc_method_handlers) - server.add_generic_rpc_handlers((generic_handler,)) - - - # This class is part of an EXPERIMENTAL API. -class RemoteRouterService(object): - """Missing associated documentation comment in .proto file.""" - - @staticmethod - def client_heartbeat(request, - target, - options=(), - channel_credentials=None, - call_credentials=None, - insecure=False, - compression=None, - wait_for_ready=None, - timeout=None, - metadata=None): - return grpc.experimental.unary_unary(request, target, '/RemoteRouterService/client_heartbeat', - remote__router__pb2.HeartbeatRequest.SerializeToString, - remote__router__pb2.HeartbeatResponse.FromString, - options, channel_credentials, - insecure, call_credentials, compression, wait_for_ready, timeout, metadata) - - @staticmethod - def get_version(request, - target, - options=(), - channel_credentials=None, - call_credentials=None, - insecure=False, - compression=None, - wait_for_ready=None, - timeout=None, - metadata=None): - return grpc.experimental.unary_unary(request, target, '/RemoteRouterService/get_version', - remote__router__pb2.VersionRequest.SerializeToString, - remote__router__pb2.VersionResponse.FromString, - options, channel_credentials, - insecure, call_credentials, compression, wait_for_ready, timeout, metadata) - - @staticmethod - def connect(request, - target, - options=(), - channel_credentials=None, - call_credentials=None, - insecure=False, - compression=None, - wait_for_ready=None, - timeout=None, - metadata=None): - return grpc.experimental.unary_unary(request, target, '/RemoteRouterService/connect', - remote__router__pb2.ConnectRequest.SerializeToString, - remote__router__pb2.ConnectResponse.FromString, - options, channel_credentials, - insecure, call_credentials, compression, wait_for_ready, timeout, metadata) - - @staticmethod - def reconnect(request, - target, - options=(), - channel_credentials=None, - call_credentials=None, - insecure=False, - compression=None, - wait_for_ready=None, - timeout=None, - metadata=None): - return grpc.experimental.unary_unary(request, target, '/RemoteRouterService/reconnect', - remote__router__pb2.ReconnectRequest.SerializeToString, - remote__router__pb2.ReconnectResponse.FromString, - options, channel_credentials, - insecure, call_credentials, compression, wait_for_ready, timeout, metadata) - - @staticmethod - def disconnect(request, - target, - options=(), - channel_credentials=None, - call_credentials=None, - insecure=False, - compression=None, - wait_for_ready=None, - timeout=None, - metadata=None): - return grpc.experimental.unary_unary(request, target, '/RemoteRouterService/disconnect', - remote__router__pb2.DisconnectRequest.SerializeToString, - remote__router__pb2.DisconnectResponse.FromString, - options, channel_credentials, - insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/aim/ext/transport/proto/remote_tracking.proto b/aim/ext/transport/proto/remote_tracking.proto deleted file mode 100644 index 09fafc15ea..0000000000 --- a/aim/ext/transport/proto/remote_tracking.proto +++ /dev/null @@ -1,106 +0,0 @@ -syntax = "proto3"; - -message ExceptionResponse { - string module_name = 1; - string class_name = 2; - string args = 3; -} - -message ClientResourceCleanupRequest { - string client_uri = 1; -} - -message ClientResourceCleanupResponse { - enum Status { - OK = 0; - ERROR = 1; - } - Status status = 1; - ExceptionResponse exception = 2; -} - -message ResourceRequest { - string resource_type = 1; - string handler = 2; - string client_uri = 3; - bytes args = 4; -} - -message ResourceResponse { - string handler = 1; - enum Status { - OK = 0; - ERROR = 1; - } - Status status = 2; - ExceptionResponse exception = 3; -} - -message ReleaseResourceRequest { - string handler = 1; - string client_uri = 2; -} - -message ReleaseResourceResponse { - enum Status { - OK = 0; - ERROR = 1; - } - Status status = 2; - ExceptionResponse exception = 3; -} - -message RequestHeader { - string version = 1; - string handler = 2; - string client_uri = 3; - string method_name = 4; -} - -message InstructionRequest { - oneof instruction { - RequestHeader header = 1; - bytes message = 2; - } -} - -message ResponseHeader { - string version = 1; - enum Status { - OK = 0; - ERROR = 1; - } - Status status = 2; - ExceptionResponse exception = 3; -} - -message InstructionResponse { - oneof instruction { - ResponseHeader header = 1; - bytes message = 2; - } -} - -message WriteInstructionsRequest { - string version = 1; - string client_uri = 2; - bytes message = 3; -} - -message WriteInstructionsResponse { - string version = 1; - enum Status { - OK = 0; - ERROR = 1; - } - Status status = 2; - ExceptionResponse exception = 3; -} - -service RemoteTrackingService { - rpc cleanup_client_resources(ClientResourceCleanupRequest) returns (ClientResourceCleanupResponse) {} - rpc get_resource(ResourceRequest) returns (ResourceResponse) {} - rpc release_resource(ReleaseResourceRequest) returns (ReleaseResourceResponse) {} - rpc run_instruction(stream InstructionRequest) returns (stream InstructionResponse) {} - rpc run_write_instructions(stream WriteInstructionsRequest) returns (WriteInstructionsResponse) {} -} diff --git a/aim/ext/transport/proto/remote_tracking_pb2.py b/aim/ext/transport/proto/remote_tracking_pb2.py deleted file mode 100644 index 3feaafe7c4..0000000000 --- a/aim/ext/transport/proto/remote_tracking_pb2.py +++ /dev/null @@ -1,8 +0,0 @@ -import google.protobuf - -protobuf_version = google.protobuf.__version__[0] - -if protobuf_version == "3": - from aim.ext.transport.proto.v3.remote_tracking_pb2 import * -elif protobuf_version == "4": - from aim.ext.transport.proto.v4.remote_tracking_pb2 import * diff --git a/aim/ext/transport/proto/remote_tracking_pb2_grpc.py b/aim/ext/transport/proto/remote_tracking_pb2_grpc.py deleted file mode 100644 index 1d227a45ba..0000000000 --- a/aim/ext/transport/proto/remote_tracking_pb2_grpc.py +++ /dev/null @@ -1,202 +0,0 @@ -# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! -"""Client and server classes corresponding to protobuf-defined services.""" -# temporary workaround for M1 build -try: - import grpc -except ImportError: - grpc = None - -import aim.ext.transport.proto.remote_tracking_pb2 as remote__tracking__pb2 - - -class RemoteTrackingServiceStub(object): - """Missing associated documentation comment in .proto file.""" - - def __init__(self, channel): - """Constructor. - - Args: - channel: A grpc.Channel. - """ - self.cleanup_client_resources = channel.unary_unary( - '/RemoteTrackingService/cleanup_client_resources', - request_serializer=remote__tracking__pb2.ClientResourceCleanupRequest.SerializeToString, - response_deserializer=remote__tracking__pb2.ClientResourceCleanupResponse.FromString, - ) - self.get_resource = channel.unary_unary( - '/RemoteTrackingService/get_resource', - request_serializer=remote__tracking__pb2.ResourceRequest.SerializeToString, - response_deserializer=remote__tracking__pb2.ResourceResponse.FromString, - ) - self.release_resource = channel.unary_unary( - '/RemoteTrackingService/release_resource', - request_serializer=remote__tracking__pb2.ReleaseResourceRequest.SerializeToString, - response_deserializer=remote__tracking__pb2.ReleaseResourceResponse.FromString, - ) - self.run_instruction = channel.stream_stream( - '/RemoteTrackingService/run_instruction', - request_serializer=remote__tracking__pb2.InstructionRequest.SerializeToString, - response_deserializer=remote__tracking__pb2.InstructionResponse.FromString, - ) - self.run_write_instructions = channel.stream_unary( - '/RemoteTrackingService/run_write_instructions', - request_serializer=remote__tracking__pb2.WriteInstructionsRequest.SerializeToString, - response_deserializer=remote__tracking__pb2.WriteInstructionsResponse.FromString, - ) - - -class RemoteTrackingServiceServicer(object): - """Missing associated documentation comment in .proto file.""" - - def cleanup_client_resources(self, request, context): - """Missing associated documentation comment in .proto file.""" - context.set_code(grpc.StatusCode.UNIMPLEMENTED) - context.set_details('Method not implemented!') - raise NotImplementedError('Method not implemented!') - - def get_resource(self, request, context): - """Missing associated documentation comment in .proto file.""" - context.set_code(grpc.StatusCode.UNIMPLEMENTED) - context.set_details('Method not implemented!') - raise NotImplementedError('Method not implemented!') - - def release_resource(self, request, context): - """Missing associated documentation comment in .proto file.""" - context.set_code(grpc.StatusCode.UNIMPLEMENTED) - context.set_details('Method not implemented!') - raise NotImplementedError('Method not implemented!') - - def run_instruction(self, request_iterator, context): - """Missing associated documentation comment in .proto file.""" - context.set_code(grpc.StatusCode.UNIMPLEMENTED) - context.set_details('Method not implemented!') - raise NotImplementedError('Method not implemented!') - - def run_write_instructions(self, request_iterator, context): - """Missing associated documentation comment in .proto file.""" - context.set_code(grpc.StatusCode.UNIMPLEMENTED) - context.set_details('Method not implemented!') - raise NotImplementedError('Method not implemented!') - - -def add_RemoteTrackingServiceServicer_to_server(servicer, server): - rpc_method_handlers = { - 'cleanup_client_resources': grpc.unary_unary_rpc_method_handler( - servicer.cleanup_client_resources, - request_deserializer=remote__tracking__pb2.ClientResourceCleanupRequest.FromString, - response_serializer=remote__tracking__pb2.ClientResourceCleanupResponse.SerializeToString, - ), - 'get_resource': grpc.unary_unary_rpc_method_handler( - servicer.get_resource, - request_deserializer=remote__tracking__pb2.ResourceRequest.FromString, - response_serializer=remote__tracking__pb2.ResourceResponse.SerializeToString, - ), - 'release_resource': grpc.unary_unary_rpc_method_handler( - servicer.release_resource, - request_deserializer=remote__tracking__pb2.ReleaseResourceRequest.FromString, - response_serializer=remote__tracking__pb2.ReleaseResourceResponse.SerializeToString, - ), - 'run_instruction': grpc.stream_stream_rpc_method_handler( - servicer.run_instruction, - request_deserializer=remote__tracking__pb2.InstructionRequest.FromString, - response_serializer=remote__tracking__pb2.InstructionResponse.SerializeToString, - ), - 'run_write_instructions': grpc.stream_unary_rpc_method_handler( - servicer.run_write_instructions, - request_deserializer=remote__tracking__pb2.WriteInstructionsRequest.FromString, - response_serializer=remote__tracking__pb2.WriteInstructionsResponse.SerializeToString, - ), - } - generic_handler = grpc.method_handlers_generic_handler( - 'RemoteTrackingService', rpc_method_handlers) - server.add_generic_rpc_handlers((generic_handler,)) - - - # This class is part of an EXPERIMENTAL API. -class RemoteTrackingService(object): - """Missing associated documentation comment in .proto file.""" - - @staticmethod - def cleanup_client_resources(request, - target, - options=(), - channel_credentials=None, - call_credentials=None, - insecure=False, - compression=None, - wait_for_ready=None, - timeout=None, - metadata=None): - return grpc.experimental.unary_unary(request, target, '/RemoteTrackingService/cleanup_client_resources', - remote__tracking__pb2.ClientResourceCleanupRequest.SerializeToString, - remote__tracking__pb2.ClientResourceCleanupResponse.FromString, - options, channel_credentials, - insecure, call_credentials, compression, wait_for_ready, timeout, metadata) - - @staticmethod - def get_resource(request, - target, - options=(), - channel_credentials=None, - call_credentials=None, - insecure=False, - compression=None, - wait_for_ready=None, - timeout=None, - metadata=None): - return grpc.experimental.unary_unary(request, target, '/RemoteTrackingService/get_resource', - remote__tracking__pb2.ResourceRequest.SerializeToString, - remote__tracking__pb2.ResourceResponse.FromString, - options, channel_credentials, - insecure, call_credentials, compression, wait_for_ready, timeout, metadata) - - @staticmethod - def release_resource(request, - target, - options=(), - channel_credentials=None, - call_credentials=None, - insecure=False, - compression=None, - wait_for_ready=None, - timeout=None, - metadata=None): - return grpc.experimental.unary_unary(request, target, '/RemoteTrackingService/release_resource', - remote__tracking__pb2.ReleaseResourceRequest.SerializeToString, - remote__tracking__pb2.ReleaseResourceResponse.FromString, - options, channel_credentials, - insecure, call_credentials, compression, wait_for_ready, timeout, metadata) - - @staticmethod - def run_instruction(request_iterator, - target, - options=(), - channel_credentials=None, - call_credentials=None, - insecure=False, - compression=None, - wait_for_ready=None, - timeout=None, - metadata=None): - return grpc.experimental.stream_stream(request_iterator, target, '/RemoteTrackingService/run_instruction', - remote__tracking__pb2.InstructionRequest.SerializeToString, - remote__tracking__pb2.InstructionResponse.FromString, - options, channel_credentials, - insecure, call_credentials, compression, wait_for_ready, timeout, metadata) - - @staticmethod - def run_write_instructions(request_iterator, - target, - options=(), - channel_credentials=None, - call_credentials=None, - insecure=False, - compression=None, - wait_for_ready=None, - timeout=None, - metadata=None): - return grpc.experimental.stream_unary(request_iterator, target, '/RemoteTrackingService/run_write_instructions', - remote__tracking__pb2.WriteInstructionsRequest.SerializeToString, - remote__tracking__pb2.WriteInstructionsResponse.FromString, - options, channel_credentials, - insecure, call_credentials, compression, wait_for_ready, timeout, metadata) diff --git a/aim/ext/transport/proto/v3/__init__.py b/aim/ext/transport/proto/v3/__init__.py deleted file mode 100644 index e69de29bb2..0000000000 diff --git a/aim/ext/transport/proto/v3/health_pb2.py b/aim/ext/transport/proto/v3/health_pb2.py deleted file mode 100644 index 674d896b4b..0000000000 --- a/aim/ext/transport/proto/v3/health_pb2.py +++ /dev/null @@ -1,184 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: health.proto -"""Generated protocol buffer code.""" -from google.protobuf import descriptor as _descriptor -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - - - -DESCRIPTOR = _descriptor.FileDescriptor( - name='health.proto', - package='grpc.health.v1', - syntax='proto3', - serialized_options=None, - create_key=_descriptor._internal_create_key, - serialized_pb=b'\n\x0chealth.proto\x12\x0egrpc.health.v1\"%\n\x12HealthCheckRequest\x12\x0f\n\x07service\x18\x01 \x01(\t\"\xa9\x01\n\x13HealthCheckResponse\x12\x41\n\x06status\x18\x01 \x01(\x0e\x32\x31.grpc.health.v1.HealthCheckResponse.ServingStatus\"O\n\rServingStatus\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x0b\n\x07SERVING\x10\x01\x12\x0f\n\x0bNOT_SERVING\x10\x02\x12\x13\n\x0fSERVICE_UNKNOWN\x10\x03\x32\xae\x01\n\x06Health\x12P\n\x05\x43heck\x12\".grpc.health.v1.HealthCheckRequest\x1a#.grpc.health.v1.HealthCheckResponse\x12R\n\x05Watch\x12\".grpc.health.v1.HealthCheckRequest\x1a#.grpc.health.v1.HealthCheckResponse0\x01\x62\x06proto3' -) - - - -_HEALTHCHECKRESPONSE_SERVINGSTATUS = _descriptor.EnumDescriptor( - name='ServingStatus', - full_name='grpc.health.v1.HealthCheckResponse.ServingStatus', - filename=None, - file=DESCRIPTOR, - create_key=_descriptor._internal_create_key, - values=[ - _descriptor.EnumValueDescriptor( - name='UNKNOWN', index=0, number=0, - serialized_options=None, - type=None, - create_key=_descriptor._internal_create_key), - _descriptor.EnumValueDescriptor( - name='SERVING', index=1, number=1, - serialized_options=None, - type=None, - create_key=_descriptor._internal_create_key), - _descriptor.EnumValueDescriptor( - name='NOT_SERVING', index=2, number=2, - serialized_options=None, - type=None, - create_key=_descriptor._internal_create_key), - _descriptor.EnumValueDescriptor( - name='SERVICE_UNKNOWN', index=3, number=3, - serialized_options=None, - type=None, - create_key=_descriptor._internal_create_key), - ], - containing_type=None, - serialized_options=None, - serialized_start=162, - serialized_end=241, -) -_sym_db.RegisterEnumDescriptor(_HEALTHCHECKRESPONSE_SERVINGSTATUS) - - -_HEALTHCHECKREQUEST = _descriptor.Descriptor( - name='HealthCheckRequest', - full_name='grpc.health.v1.HealthCheckRequest', - filename=None, - file=DESCRIPTOR, - containing_type=None, - create_key=_descriptor._internal_create_key, - fields=[ - _descriptor.FieldDescriptor( - name='service', full_name='grpc.health.v1.HealthCheckRequest.service', index=0, - number=1, type=9, cpp_type=9, label=1, - has_default_value=False, default_value=b"".decode('utf-8'), - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - ], - extensions=[ - ], - nested_types=[], - enum_types=[ - ], - serialized_options=None, - is_extendable=False, - syntax='proto3', - extension_ranges=[], - oneofs=[ - ], - serialized_start=32, - serialized_end=69, -) - - -_HEALTHCHECKRESPONSE = _descriptor.Descriptor( - name='HealthCheckResponse', - full_name='grpc.health.v1.HealthCheckResponse', - filename=None, - file=DESCRIPTOR, - containing_type=None, - create_key=_descriptor._internal_create_key, - fields=[ - _descriptor.FieldDescriptor( - name='status', full_name='grpc.health.v1.HealthCheckResponse.status', index=0, - number=1, type=14, cpp_type=8, label=1, - has_default_value=False, default_value=0, - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - ], - extensions=[ - ], - nested_types=[], - enum_types=[ - _HEALTHCHECKRESPONSE_SERVINGSTATUS, - ], - serialized_options=None, - is_extendable=False, - syntax='proto3', - extension_ranges=[], - oneofs=[ - ], - serialized_start=72, - serialized_end=241, -) - -_HEALTHCHECKRESPONSE.fields_by_name['status'].enum_type = _HEALTHCHECKRESPONSE_SERVINGSTATUS -_HEALTHCHECKRESPONSE_SERVINGSTATUS.containing_type = _HEALTHCHECKRESPONSE -DESCRIPTOR.message_types_by_name['HealthCheckRequest'] = _HEALTHCHECKREQUEST -DESCRIPTOR.message_types_by_name['HealthCheckResponse'] = _HEALTHCHECKRESPONSE -_sym_db.RegisterFileDescriptor(DESCRIPTOR) - -HealthCheckRequest = _reflection.GeneratedProtocolMessageType('HealthCheckRequest', (_message.Message,), { - 'DESCRIPTOR' : _HEALTHCHECKREQUEST, - '__module__' : 'health_pb2' - # @@protoc_insertion_point(class_scope:grpc.health.v1.HealthCheckRequest) - }) -_sym_db.RegisterMessage(HealthCheckRequest) - -HealthCheckResponse = _reflection.GeneratedProtocolMessageType('HealthCheckResponse', (_message.Message,), { - 'DESCRIPTOR' : _HEALTHCHECKRESPONSE, - '__module__' : 'health_pb2' - # @@protoc_insertion_point(class_scope:grpc.health.v1.HealthCheckResponse) - }) -_sym_db.RegisterMessage(HealthCheckResponse) - - - -_HEALTH = _descriptor.ServiceDescriptor( - name='Health', - full_name='grpc.health.v1.Health', - file=DESCRIPTOR, - index=0, - serialized_options=None, - create_key=_descriptor._internal_create_key, - serialized_start=244, - serialized_end=418, - methods=[ - _descriptor.MethodDescriptor( - name='Check', - full_name='grpc.health.v1.Health.Check', - index=0, - containing_service=None, - input_type=_HEALTHCHECKREQUEST, - output_type=_HEALTHCHECKRESPONSE, - serialized_options=None, - create_key=_descriptor._internal_create_key, - ), - _descriptor.MethodDescriptor( - name='Watch', - full_name='grpc.health.v1.Health.Watch', - index=1, - containing_service=None, - input_type=_HEALTHCHECKREQUEST, - output_type=_HEALTHCHECKRESPONSE, - serialized_options=None, - create_key=_descriptor._internal_create_key, - ), -]) -_sym_db.RegisterServiceDescriptor(_HEALTH) - -DESCRIPTOR.services_by_name['Health'] = _HEALTH - -# @@protoc_insertion_point(module_scope) diff --git a/aim/ext/transport/proto/v3/remote_router_pb2.py b/aim/ext/transport/proto/v3/remote_router_pb2.py deleted file mode 100644 index 1f1db2e88a..0000000000 --- a/aim/ext/transport/proto/v3/remote_router_pb2.py +++ /dev/null @@ -1,699 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: remote_router.proto -"""Generated protocol buffer code.""" -from google.protobuf import descriptor as _descriptor -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - -import aim.ext.transport.proto.v3.remote_tracking_pb2 as remote__tracking__pb2 - - -DESCRIPTOR = _descriptor.FileDescriptor( - name='remote_router.proto', - package='', - syntax='proto3', - serialized_options=None, - create_key=_descriptor._internal_create_key, - serialized_pb=b'\n\x13remote_router.proto\x1a\x15remote_tracking.proto\"\x10\n\x0eVersionRequest\"\x8f\x01\n\x0fVersionResponse\x12\x0f\n\x07version\x18\x01 \x01(\t\x12\'\n\x06status\x18\x02 \x01(\x0e\x32\x17.VersionResponse.Status\x12%\n\texception\x18\x03 \x01(\x0b\x32\x12.ExceptionResponse\"\x1b\n\x06Status\x12\x06\n\x02OK\x10\x00\x12\t\n\x05\x45RROR\x10\x01\"&\n\x10HeartbeatRequest\x12\x12\n\nclient_uri\x18\x01 \x01(\t\"\x82\x01\n\x11HeartbeatResponse\x12)\n\x06status\x18\x01 \x01(\x0e\x32\x19.HeartbeatResponse.Status\x12%\n\texception\x18\x02 \x01(\x0b\x32\x12.ExceptionResponse\"\x1b\n\x06Status\x12\x06\n\x02OK\x10\x00\x12\t\n\x05\x45RROR\x10\x01\"$\n\x0e\x43onnectRequest\x12\x12\n\nclient_uri\x18\x01 \x01(\t\"\xa2\x01\n\x0f\x43onnectResponse\x12\x0c\n\x04port\x18\x01 \x01(\t\x12\x14\n\x0cworker_index\x18\x02 \x01(\t\x12\'\n\x06status\x18\x03 \x01(\x0e\x32\x17.ConnectResponse.Status\x12%\n\texception\x18\x04 \x01(\x0b\x32\x12.ExceptionResponse\"\x1b\n\x06Status\x12\x06\n\x02OK\x10\x00\x12\t\n\x05\x45RROR\x10\x01\"&\n\x10ReconnectRequest\x12\x12\n\nclient_uri\x18\x01 \x01(\t\"\x90\x01\n\x11ReconnectResponse\x12\x0c\n\x04port\x18\x01 \x01(\t\x12)\n\x06status\x18\x02 \x01(\x0e\x32\x19.ReconnectResponse.Status\x12%\n\texception\x18\x03 \x01(\x0b\x32\x12.ExceptionResponse\"\x1b\n\x06Status\x12\x06\n\x02OK\x10\x00\x12\t\n\x05\x45RROR\x10\x01\"\'\n\x11\x44isconnectRequest\x12\x12\n\nclient_uri\x18\x01 \x01(\t\"\x84\x01\n\x12\x44isconnectResponse\x12*\n\x06status\x18\x01 \x01(\x0e\x32\x1a.DisconnectResponse.Status\x12%\n\texception\x18\x03 \x01(\x0b\x32\x12.ExceptionResponse\"\x1b\n\x06Status\x12\x06\n\x02OK\x10\x00\x12\t\n\x05\x45RROR\x10\x01\x32\xa5\x02\n\x13RemoteRouterService\x12;\n\x10\x63lient_heartbeat\x12\x11.HeartbeatRequest\x1a\x12.HeartbeatResponse\"\x00\x12\x32\n\x0bget_version\x12\x0f.VersionRequest\x1a\x10.VersionResponse\"\x00\x12.\n\x07\x63onnect\x12\x0f.ConnectRequest\x1a\x10.ConnectResponse\"\x00\x12\x34\n\treconnect\x12\x11.ReconnectRequest\x1a\x12.ReconnectResponse\"\x00\x12\x37\n\ndisconnect\x12\x12.DisconnectRequest\x1a\x13.DisconnectResponse\"\x00\x62\x06proto3' - , - dependencies=[remote__tracking__pb2.DESCRIPTOR,]) - - - -_VERSIONRESPONSE_STATUS = _descriptor.EnumDescriptor( - name='Status', - full_name='VersionResponse.Status', - filename=None, - file=DESCRIPTOR, - create_key=_descriptor._internal_create_key, - values=[ - _descriptor.EnumValueDescriptor( - name='OK', index=0, number=0, - serialized_options=None, - type=None, - create_key=_descriptor._internal_create_key), - _descriptor.EnumValueDescriptor( - name='ERROR', index=1, number=1, - serialized_options=None, - type=None, - create_key=_descriptor._internal_create_key), - ], - containing_type=None, - serialized_options=None, - serialized_start=181, - serialized_end=208, -) -_sym_db.RegisterEnumDescriptor(_VERSIONRESPONSE_STATUS) - -_HEARTBEATRESPONSE_STATUS = _descriptor.EnumDescriptor( - name='Status', - full_name='HeartbeatResponse.Status', - filename=None, - file=DESCRIPTOR, - create_key=_descriptor._internal_create_key, - values=[ - _descriptor.EnumValueDescriptor( - name='OK', index=0, number=0, - serialized_options=None, - type=None, - create_key=_descriptor._internal_create_key), - _descriptor.EnumValueDescriptor( - name='ERROR', index=1, number=1, - serialized_options=None, - type=None, - create_key=_descriptor._internal_create_key), - ], - containing_type=None, - serialized_options=None, - serialized_start=181, - serialized_end=208, -) -_sym_db.RegisterEnumDescriptor(_HEARTBEATRESPONSE_STATUS) - -_CONNECTRESPONSE_STATUS = _descriptor.EnumDescriptor( - name='Status', - full_name='ConnectResponse.Status', - filename=None, - file=DESCRIPTOR, - create_key=_descriptor._internal_create_key, - values=[ - _descriptor.EnumValueDescriptor( - name='OK', index=0, number=0, - serialized_options=None, - type=None, - create_key=_descriptor._internal_create_key), - _descriptor.EnumValueDescriptor( - name='ERROR', index=1, number=1, - serialized_options=None, - type=None, - create_key=_descriptor._internal_create_key), - ], - containing_type=None, - serialized_options=None, - serialized_start=181, - serialized_end=208, -) -_sym_db.RegisterEnumDescriptor(_CONNECTRESPONSE_STATUS) - -_RECONNECTRESPONSE_STATUS = _descriptor.EnumDescriptor( - name='Status', - full_name='ReconnectResponse.Status', - filename=None, - file=DESCRIPTOR, - create_key=_descriptor._internal_create_key, - values=[ - _descriptor.EnumValueDescriptor( - name='OK', index=0, number=0, - serialized_options=None, - type=None, - create_key=_descriptor._internal_create_key), - _descriptor.EnumValueDescriptor( - name='ERROR', index=1, number=1, - serialized_options=None, - type=None, - create_key=_descriptor._internal_create_key), - ], - containing_type=None, - serialized_options=None, - serialized_start=181, - serialized_end=208, -) -_sym_db.RegisterEnumDescriptor(_RECONNECTRESPONSE_STATUS) - -_DISCONNECTRESPONSE_STATUS = _descriptor.EnumDescriptor( - name='Status', - full_name='DisconnectResponse.Status', - filename=None, - file=DESCRIPTOR, - create_key=_descriptor._internal_create_key, - values=[ - _descriptor.EnumValueDescriptor( - name='OK', index=0, number=0, - serialized_options=None, - type=None, - create_key=_descriptor._internal_create_key), - _descriptor.EnumValueDescriptor( - name='ERROR', index=1, number=1, - serialized_options=None, - type=None, - create_key=_descriptor._internal_create_key), - ], - containing_type=None, - serialized_options=None, - serialized_start=181, - serialized_end=208, -) -_sym_db.RegisterEnumDescriptor(_DISCONNECTRESPONSE_STATUS) - - -_VERSIONREQUEST = _descriptor.Descriptor( - name='VersionRequest', - full_name='VersionRequest', - filename=None, - file=DESCRIPTOR, - containing_type=None, - create_key=_descriptor._internal_create_key, - fields=[ - ], - extensions=[ - ], - nested_types=[], - enum_types=[ - ], - serialized_options=None, - is_extendable=False, - syntax='proto3', - extension_ranges=[], - oneofs=[ - ], - serialized_start=46, - serialized_end=62, -) - - -_VERSIONRESPONSE = _descriptor.Descriptor( - name='VersionResponse', - full_name='VersionResponse', - filename=None, - file=DESCRIPTOR, - containing_type=None, - create_key=_descriptor._internal_create_key, - fields=[ - _descriptor.FieldDescriptor( - name='version', full_name='VersionResponse.version', index=0, - number=1, type=9, cpp_type=9, label=1, - has_default_value=False, default_value=b"".decode('utf-8'), - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - _descriptor.FieldDescriptor( - name='status', full_name='VersionResponse.status', index=1, - number=2, type=14, cpp_type=8, label=1, - has_default_value=False, default_value=0, - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - _descriptor.FieldDescriptor( - name='exception', full_name='VersionResponse.exception', index=2, - number=3, type=11, cpp_type=10, label=1, - has_default_value=False, default_value=None, - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - ], - extensions=[ - ], - nested_types=[], - enum_types=[ - _VERSIONRESPONSE_STATUS, - ], - serialized_options=None, - is_extendable=False, - syntax='proto3', - extension_ranges=[], - oneofs=[ - ], - serialized_start=65, - serialized_end=208, -) - - -_HEARTBEATREQUEST = _descriptor.Descriptor( - name='HeartbeatRequest', - full_name='HeartbeatRequest', - filename=None, - file=DESCRIPTOR, - containing_type=None, - create_key=_descriptor._internal_create_key, - fields=[ - _descriptor.FieldDescriptor( - name='client_uri', full_name='HeartbeatRequest.client_uri', index=0, - number=1, type=9, cpp_type=9, label=1, - has_default_value=False, default_value=b"".decode('utf-8'), - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - ], - extensions=[ - ], - nested_types=[], - enum_types=[ - ], - serialized_options=None, - is_extendable=False, - syntax='proto3', - extension_ranges=[], - oneofs=[ - ], - serialized_start=210, - serialized_end=248, -) - - -_HEARTBEATRESPONSE = _descriptor.Descriptor( - name='HeartbeatResponse', - full_name='HeartbeatResponse', - filename=None, - file=DESCRIPTOR, - containing_type=None, - create_key=_descriptor._internal_create_key, - fields=[ - _descriptor.FieldDescriptor( - name='status', full_name='HeartbeatResponse.status', index=0, - number=1, type=14, cpp_type=8, label=1, - has_default_value=False, default_value=0, - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - _descriptor.FieldDescriptor( - name='exception', full_name='HeartbeatResponse.exception', index=1, - number=2, type=11, cpp_type=10, label=1, - has_default_value=False, default_value=None, - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - ], - extensions=[ - ], - nested_types=[], - enum_types=[ - _HEARTBEATRESPONSE_STATUS, - ], - serialized_options=None, - is_extendable=False, - syntax='proto3', - extension_ranges=[], - oneofs=[ - ], - serialized_start=251, - serialized_end=381, -) - - -_CONNECTREQUEST = _descriptor.Descriptor( - name='ConnectRequest', - full_name='ConnectRequest', - filename=None, - file=DESCRIPTOR, - containing_type=None, - create_key=_descriptor._internal_create_key, - fields=[ - _descriptor.FieldDescriptor( - name='client_uri', full_name='ConnectRequest.client_uri', index=0, - number=1, type=9, cpp_type=9, label=1, - has_default_value=False, default_value=b"".decode('utf-8'), - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - ], - extensions=[ - ], - nested_types=[], - enum_types=[ - ], - serialized_options=None, - is_extendable=False, - syntax='proto3', - extension_ranges=[], - oneofs=[ - ], - serialized_start=383, - serialized_end=419, -) - - -_CONNECTRESPONSE = _descriptor.Descriptor( - name='ConnectResponse', - full_name='ConnectResponse', - filename=None, - file=DESCRIPTOR, - containing_type=None, - create_key=_descriptor._internal_create_key, - fields=[ - _descriptor.FieldDescriptor( - name='port', full_name='ConnectResponse.port', index=0, - number=1, type=9, cpp_type=9, label=1, - has_default_value=False, default_value=b"".decode('utf-8'), - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - _descriptor.FieldDescriptor( - name='worker_index', full_name='ConnectResponse.worker_index', index=1, - number=2, type=9, cpp_type=9, label=1, - has_default_value=False, default_value=b"".decode('utf-8'), - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - _descriptor.FieldDescriptor( - name='status', full_name='ConnectResponse.status', index=2, - number=3, type=14, cpp_type=8, label=1, - has_default_value=False, default_value=0, - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - _descriptor.FieldDescriptor( - name='exception', full_name='ConnectResponse.exception', index=3, - number=4, type=11, cpp_type=10, label=1, - has_default_value=False, default_value=None, - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - ], - extensions=[ - ], - nested_types=[], - enum_types=[ - _CONNECTRESPONSE_STATUS, - ], - serialized_options=None, - is_extendable=False, - syntax='proto3', - extension_ranges=[], - oneofs=[ - ], - serialized_start=422, - serialized_end=584, -) - - -_RECONNECTREQUEST = _descriptor.Descriptor( - name='ReconnectRequest', - full_name='ReconnectRequest', - filename=None, - file=DESCRIPTOR, - containing_type=None, - create_key=_descriptor._internal_create_key, - fields=[ - _descriptor.FieldDescriptor( - name='client_uri', full_name='ReconnectRequest.client_uri', index=0, - number=1, type=9, cpp_type=9, label=1, - has_default_value=False, default_value=b"".decode('utf-8'), - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - ], - extensions=[ - ], - nested_types=[], - enum_types=[ - ], - serialized_options=None, - is_extendable=False, - syntax='proto3', - extension_ranges=[], - oneofs=[ - ], - serialized_start=586, - serialized_end=624, -) - - -_RECONNECTRESPONSE = _descriptor.Descriptor( - name='ReconnectResponse', - full_name='ReconnectResponse', - filename=None, - file=DESCRIPTOR, - containing_type=None, - create_key=_descriptor._internal_create_key, - fields=[ - _descriptor.FieldDescriptor( - name='port', full_name='ReconnectResponse.port', index=0, - number=1, type=9, cpp_type=9, label=1, - has_default_value=False, default_value=b"".decode('utf-8'), - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - _descriptor.FieldDescriptor( - name='status', full_name='ReconnectResponse.status', index=1, - number=2, type=14, cpp_type=8, label=1, - has_default_value=False, default_value=0, - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - _descriptor.FieldDescriptor( - name='exception', full_name='ReconnectResponse.exception', index=2, - number=3, type=11, cpp_type=10, label=1, - has_default_value=False, default_value=None, - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - ], - extensions=[ - ], - nested_types=[], - enum_types=[ - _RECONNECTRESPONSE_STATUS, - ], - serialized_options=None, - is_extendable=False, - syntax='proto3', - extension_ranges=[], - oneofs=[ - ], - serialized_start=627, - serialized_end=771, -) - - -_DISCONNECTREQUEST = _descriptor.Descriptor( - name='DisconnectRequest', - full_name='DisconnectRequest', - filename=None, - file=DESCRIPTOR, - containing_type=None, - create_key=_descriptor._internal_create_key, - fields=[ - _descriptor.FieldDescriptor( - name='client_uri', full_name='DisconnectRequest.client_uri', index=0, - number=1, type=9, cpp_type=9, label=1, - has_default_value=False, default_value=b"".decode('utf-8'), - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - ], - extensions=[ - ], - nested_types=[], - enum_types=[ - ], - serialized_options=None, - is_extendable=False, - syntax='proto3', - extension_ranges=[], - oneofs=[ - ], - serialized_start=773, - serialized_end=812, -) - - -_DISCONNECTRESPONSE = _descriptor.Descriptor( - name='DisconnectResponse', - full_name='DisconnectResponse', - filename=None, - file=DESCRIPTOR, - containing_type=None, - create_key=_descriptor._internal_create_key, - fields=[ - _descriptor.FieldDescriptor( - name='status', full_name='DisconnectResponse.status', index=0, - number=1, type=14, cpp_type=8, label=1, - has_default_value=False, default_value=0, - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - _descriptor.FieldDescriptor( - name='exception', full_name='DisconnectResponse.exception', index=1, - number=3, type=11, cpp_type=10, label=1, - has_default_value=False, default_value=None, - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - ], - extensions=[ - ], - nested_types=[], - enum_types=[ - _DISCONNECTRESPONSE_STATUS, - ], - serialized_options=None, - is_extendable=False, - syntax='proto3', - extension_ranges=[], - oneofs=[ - ], - serialized_start=815, - serialized_end=947, -) - -_VERSIONRESPONSE.fields_by_name['status'].enum_type = _VERSIONRESPONSE_STATUS -_VERSIONRESPONSE.fields_by_name['exception'].message_type = remote__tracking__pb2._EXCEPTIONRESPONSE -_VERSIONRESPONSE_STATUS.containing_type = _VERSIONRESPONSE -_HEARTBEATRESPONSE.fields_by_name['status'].enum_type = _HEARTBEATRESPONSE_STATUS -_HEARTBEATRESPONSE.fields_by_name['exception'].message_type = remote__tracking__pb2._EXCEPTIONRESPONSE -_HEARTBEATRESPONSE_STATUS.containing_type = _HEARTBEATRESPONSE -_CONNECTRESPONSE.fields_by_name['status'].enum_type = _CONNECTRESPONSE_STATUS -_CONNECTRESPONSE.fields_by_name['exception'].message_type = remote__tracking__pb2._EXCEPTIONRESPONSE -_CONNECTRESPONSE_STATUS.containing_type = _CONNECTRESPONSE -_RECONNECTRESPONSE.fields_by_name['status'].enum_type = _RECONNECTRESPONSE_STATUS -_RECONNECTRESPONSE.fields_by_name['exception'].message_type = remote__tracking__pb2._EXCEPTIONRESPONSE -_RECONNECTRESPONSE_STATUS.containing_type = _RECONNECTRESPONSE -_DISCONNECTRESPONSE.fields_by_name['status'].enum_type = _DISCONNECTRESPONSE_STATUS -_DISCONNECTRESPONSE.fields_by_name['exception'].message_type = remote__tracking__pb2._EXCEPTIONRESPONSE -_DISCONNECTRESPONSE_STATUS.containing_type = _DISCONNECTRESPONSE -DESCRIPTOR.message_types_by_name['VersionRequest'] = _VERSIONREQUEST -DESCRIPTOR.message_types_by_name['VersionResponse'] = _VERSIONRESPONSE -DESCRIPTOR.message_types_by_name['HeartbeatRequest'] = _HEARTBEATREQUEST -DESCRIPTOR.message_types_by_name['HeartbeatResponse'] = _HEARTBEATRESPONSE -DESCRIPTOR.message_types_by_name['ConnectRequest'] = _CONNECTREQUEST -DESCRIPTOR.message_types_by_name['ConnectResponse'] = _CONNECTRESPONSE -DESCRIPTOR.message_types_by_name['ReconnectRequest'] = _RECONNECTREQUEST -DESCRIPTOR.message_types_by_name['ReconnectResponse'] = _RECONNECTRESPONSE -DESCRIPTOR.message_types_by_name['DisconnectRequest'] = _DISCONNECTREQUEST -DESCRIPTOR.message_types_by_name['DisconnectResponse'] = _DISCONNECTRESPONSE -_sym_db.RegisterFileDescriptor(DESCRIPTOR) - -VersionRequest = _reflection.GeneratedProtocolMessageType('VersionRequest', (_message.Message,), { - 'DESCRIPTOR' : _VERSIONREQUEST, - '__module__' : 'remote_router_pb2' - # @@protoc_insertion_point(class_scope:VersionRequest) - }) -_sym_db.RegisterMessage(VersionRequest) - -VersionResponse = _reflection.GeneratedProtocolMessageType('VersionResponse', (_message.Message,), { - 'DESCRIPTOR' : _VERSIONRESPONSE, - '__module__' : 'remote_router_pb2' - # @@protoc_insertion_point(class_scope:VersionResponse) - }) -_sym_db.RegisterMessage(VersionResponse) - -HeartbeatRequest = _reflection.GeneratedProtocolMessageType('HeartbeatRequest', (_message.Message,), { - 'DESCRIPTOR' : _HEARTBEATREQUEST, - '__module__' : 'remote_router_pb2' - # @@protoc_insertion_point(class_scope:HeartbeatRequest) - }) -_sym_db.RegisterMessage(HeartbeatRequest) - -HeartbeatResponse = _reflection.GeneratedProtocolMessageType('HeartbeatResponse', (_message.Message,), { - 'DESCRIPTOR' : _HEARTBEATRESPONSE, - '__module__' : 'remote_router_pb2' - # @@protoc_insertion_point(class_scope:HeartbeatResponse) - }) -_sym_db.RegisterMessage(HeartbeatResponse) - -ConnectRequest = _reflection.GeneratedProtocolMessageType('ConnectRequest', (_message.Message,), { - 'DESCRIPTOR' : _CONNECTREQUEST, - '__module__' : 'remote_router_pb2' - # @@protoc_insertion_point(class_scope:ConnectRequest) - }) -_sym_db.RegisterMessage(ConnectRequest) - -ConnectResponse = _reflection.GeneratedProtocolMessageType('ConnectResponse', (_message.Message,), { - 'DESCRIPTOR' : _CONNECTRESPONSE, - '__module__' : 'remote_router_pb2' - # @@protoc_insertion_point(class_scope:ConnectResponse) - }) -_sym_db.RegisterMessage(ConnectResponse) - -ReconnectRequest = _reflection.GeneratedProtocolMessageType('ReconnectRequest', (_message.Message,), { - 'DESCRIPTOR' : _RECONNECTREQUEST, - '__module__' : 'remote_router_pb2' - # @@protoc_insertion_point(class_scope:ReconnectRequest) - }) -_sym_db.RegisterMessage(ReconnectRequest) - -ReconnectResponse = _reflection.GeneratedProtocolMessageType('ReconnectResponse', (_message.Message,), { - 'DESCRIPTOR' : _RECONNECTRESPONSE, - '__module__' : 'remote_router_pb2' - # @@protoc_insertion_point(class_scope:ReconnectResponse) - }) -_sym_db.RegisterMessage(ReconnectResponse) - -DisconnectRequest = _reflection.GeneratedProtocolMessageType('DisconnectRequest', (_message.Message,), { - 'DESCRIPTOR' : _DISCONNECTREQUEST, - '__module__' : 'remote_router_pb2' - # @@protoc_insertion_point(class_scope:DisconnectRequest) - }) -_sym_db.RegisterMessage(DisconnectRequest) - -DisconnectResponse = _reflection.GeneratedProtocolMessageType('DisconnectResponse', (_message.Message,), { - 'DESCRIPTOR' : _DISCONNECTRESPONSE, - '__module__' : 'remote_router_pb2' - # @@protoc_insertion_point(class_scope:DisconnectResponse) - }) -_sym_db.RegisterMessage(DisconnectResponse) - - - -_REMOTEROUTERSERVICE = _descriptor.ServiceDescriptor( - name='RemoteRouterService', - full_name='RemoteRouterService', - file=DESCRIPTOR, - index=0, - serialized_options=None, - create_key=_descriptor._internal_create_key, - serialized_start=950, - serialized_end=1243, - methods=[ - _descriptor.MethodDescriptor( - name='client_heartbeat', - full_name='RemoteRouterService.client_heartbeat', - index=0, - containing_service=None, - input_type=_HEARTBEATREQUEST, - output_type=_HEARTBEATRESPONSE, - serialized_options=None, - create_key=_descriptor._internal_create_key, - ), - _descriptor.MethodDescriptor( - name='get_version', - full_name='RemoteRouterService.get_version', - index=1, - containing_service=None, - input_type=_VERSIONREQUEST, - output_type=_VERSIONRESPONSE, - serialized_options=None, - create_key=_descriptor._internal_create_key, - ), - _descriptor.MethodDescriptor( - name='connect', - full_name='RemoteRouterService.connect', - index=2, - containing_service=None, - input_type=_CONNECTREQUEST, - output_type=_CONNECTRESPONSE, - serialized_options=None, - create_key=_descriptor._internal_create_key, - ), - _descriptor.MethodDescriptor( - name='reconnect', - full_name='RemoteRouterService.reconnect', - index=3, - containing_service=None, - input_type=_RECONNECTREQUEST, - output_type=_RECONNECTRESPONSE, - serialized_options=None, - create_key=_descriptor._internal_create_key, - ), - _descriptor.MethodDescriptor( - name='disconnect', - full_name='RemoteRouterService.disconnect', - index=4, - containing_service=None, - input_type=_DISCONNECTREQUEST, - output_type=_DISCONNECTRESPONSE, - serialized_options=None, - create_key=_descriptor._internal_create_key, - ), -]) -_sym_db.RegisterServiceDescriptor(_REMOTEROUTERSERVICE) - -DESCRIPTOR.services_by_name['RemoteRouterService'] = _REMOTEROUTERSERVICE - -# @@protoc_insertion_point(module_scope) diff --git a/aim/ext/transport/proto/v3/remote_tracking_pb2.py b/aim/ext/transport/proto/v3/remote_tracking_pb2.py deleted file mode 100644 index fe6b4dcb66..0000000000 --- a/aim/ext/transport/proto/v3/remote_tracking_pb2.py +++ /dev/null @@ -1,932 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: remote_tracking.proto -"""Generated protocol buffer code.""" -from google.protobuf import descriptor as _descriptor -from google.protobuf import message as _message -from google.protobuf import reflection as _reflection -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - - - -DESCRIPTOR = _descriptor.FileDescriptor( - name='remote_tracking.proto', - package='', - syntax='proto3', - serialized_options=None, - create_key=_descriptor._internal_create_key, - serialized_pb=b'\n\x15remote_tracking.proto\"J\n\x11\x45xceptionResponse\x12\x13\n\x0bmodule_name\x18\x01 \x01(\t\x12\x12\n\nclass_name\x18\x02 \x01(\t\x12\x0c\n\x04\x61rgs\x18\x03 \x01(\t\"2\n\x1c\x43lientResourceCleanupRequest\x12\x12\n\nclient_uri\x18\x01 \x01(\t\"\x9a\x01\n\x1d\x43lientResourceCleanupResponse\x12\x35\n\x06status\x18\x01 \x01(\x0e\x32%.ClientResourceCleanupResponse.Status\x12%\n\texception\x18\x02 \x01(\x0b\x32\x12.ExceptionResponse\"\x1b\n\x06Status\x12\x06\n\x02OK\x10\x00\x12\t\n\x05\x45RROR\x10\x01\"[\n\x0fResourceRequest\x12\x15\n\rresource_type\x18\x01 \x01(\t\x12\x0f\n\x07handler\x18\x02 \x01(\t\x12\x12\n\nclient_uri\x18\x03 \x01(\t\x12\x0c\n\x04\x61rgs\x18\x04 \x01(\x0c\"\x91\x01\n\x10ResourceResponse\x12\x0f\n\x07handler\x18\x01 \x01(\t\x12(\n\x06status\x18\x02 \x01(\x0e\x32\x18.ResourceResponse.Status\x12%\n\texception\x18\x03 \x01(\x0b\x32\x12.ExceptionResponse\"\x1b\n\x06Status\x12\x06\n\x02OK\x10\x00\x12\t\n\x05\x45RROR\x10\x01\"=\n\x16ReleaseResourceRequest\x12\x0f\n\x07handler\x18\x01 \x01(\t\x12\x12\n\nclient_uri\x18\x02 \x01(\t\"\x8e\x01\n\x17ReleaseResourceResponse\x12/\n\x06status\x18\x02 \x01(\x0e\x32\x1f.ReleaseResourceResponse.Status\x12%\n\texception\x18\x03 \x01(\x0b\x32\x12.ExceptionResponse\"\x1b\n\x06Status\x12\x06\n\x02OK\x10\x00\x12\t\n\x05\x45RROR\x10\x01\"Z\n\rRequestHeader\x12\x0f\n\x07version\x18\x01 \x01(\t\x12\x0f\n\x07handler\x18\x02 \x01(\t\x12\x12\n\nclient_uri\x18\x03 \x01(\t\x12\x13\n\x0bmethod_name\x18\x04 \x01(\t\"X\n\x12InstructionRequest\x12 \n\x06header\x18\x01 \x01(\x0b\x32\x0e.RequestHeaderH\x00\x12\x11\n\x07message\x18\x02 \x01(\x0cH\x00\x42\r\n\x0binstruction\"\x8d\x01\n\x0eResponseHeader\x12\x0f\n\x07version\x18\x01 \x01(\t\x12&\n\x06status\x18\x02 \x01(\x0e\x32\x16.ResponseHeader.Status\x12%\n\texception\x18\x03 \x01(\x0b\x32\x12.ExceptionResponse\"\x1b\n\x06Status\x12\x06\n\x02OK\x10\x00\x12\t\n\x05\x45RROR\x10\x01\"Z\n\x13InstructionResponse\x12!\n\x06header\x18\x01 \x01(\x0b\x32\x0f.ResponseHeaderH\x00\x12\x11\n\x07message\x18\x02 \x01(\x0cH\x00\x42\r\n\x0binstruction\"P\n\x18WriteInstructionsRequest\x12\x0f\n\x07version\x18\x01 \x01(\t\x12\x12\n\nclient_uri\x18\x02 \x01(\t\x12\x0f\n\x07message\x18\x03 \x01(\x0c\"\xa3\x01\n\x19WriteInstructionsResponse\x12\x0f\n\x07version\x18\x01 \x01(\t\x12\x31\n\x06status\x18\x02 \x01(\x0e\x32!.WriteInstructionsResponse.Status\x12%\n\texception\x18\x03 \x01(\x0b\x32\x12.ExceptionResponse\"\x1b\n\x06Status\x12\x06\n\x02OK\x10\x00\x12\t\n\x05\x45RROR\x10\x01\x32\x8d\x03\n\x15RemoteTrackingService\x12[\n\x18\x63leanup_client_resources\x12\x1d.ClientResourceCleanupRequest\x1a\x1e.ClientResourceCleanupResponse\"\x00\x12\x35\n\x0cget_resource\x12\x10.ResourceRequest\x1a\x11.ResourceResponse\"\x00\x12G\n\x10release_resource\x12\x17.ReleaseResourceRequest\x1a\x18.ReleaseResourceResponse\"\x00\x12\x42\n\x0frun_instruction\x12\x13.InstructionRequest\x1a\x14.InstructionResponse\"\x00(\x01\x30\x01\x12S\n\x16run_write_instructions\x12\x19.WriteInstructionsRequest\x1a\x1a.WriteInstructionsResponse\"\x00(\x01\x62\x06proto3' -) - - - -_CLIENTRESOURCECLEANUPRESPONSE_STATUS = _descriptor.EnumDescriptor( - name='Status', - full_name='ClientResourceCleanupResponse.Status', - filename=None, - file=DESCRIPTOR, - create_key=_descriptor._internal_create_key, - values=[ - _descriptor.EnumValueDescriptor( - name='OK', index=0, number=0, - serialized_options=None, - type=None, - create_key=_descriptor._internal_create_key), - _descriptor.EnumValueDescriptor( - name='ERROR', index=1, number=1, - serialized_options=None, - type=None, - create_key=_descriptor._internal_create_key), - ], - containing_type=None, - serialized_options=None, - serialized_start=281, - serialized_end=308, -) -_sym_db.RegisterEnumDescriptor(_CLIENTRESOURCECLEANUPRESPONSE_STATUS) - -_RESOURCERESPONSE_STATUS = _descriptor.EnumDescriptor( - name='Status', - full_name='ResourceResponse.Status', - filename=None, - file=DESCRIPTOR, - create_key=_descriptor._internal_create_key, - values=[ - _descriptor.EnumValueDescriptor( - name='OK', index=0, number=0, - serialized_options=None, - type=None, - create_key=_descriptor._internal_create_key), - _descriptor.EnumValueDescriptor( - name='ERROR', index=1, number=1, - serialized_options=None, - type=None, - create_key=_descriptor._internal_create_key), - ], - containing_type=None, - serialized_options=None, - serialized_start=281, - serialized_end=308, -) -_sym_db.RegisterEnumDescriptor(_RESOURCERESPONSE_STATUS) - -_RELEASERESOURCERESPONSE_STATUS = _descriptor.EnumDescriptor( - name='Status', - full_name='ReleaseResourceResponse.Status', - filename=None, - file=DESCRIPTOR, - create_key=_descriptor._internal_create_key, - values=[ - _descriptor.EnumValueDescriptor( - name='OK', index=0, number=0, - serialized_options=None, - type=None, - create_key=_descriptor._internal_create_key), - _descriptor.EnumValueDescriptor( - name='ERROR', index=1, number=1, - serialized_options=None, - type=None, - create_key=_descriptor._internal_create_key), - ], - containing_type=None, - serialized_options=None, - serialized_start=281, - serialized_end=308, -) -_sym_db.RegisterEnumDescriptor(_RELEASERESOURCERESPONSE_STATUS) - -_RESPONSEHEADER_STATUS = _descriptor.EnumDescriptor( - name='Status', - full_name='ResponseHeader.Status', - filename=None, - file=DESCRIPTOR, - create_key=_descriptor._internal_create_key, - values=[ - _descriptor.EnumValueDescriptor( - name='OK', index=0, number=0, - serialized_options=None, - type=None, - create_key=_descriptor._internal_create_key), - _descriptor.EnumValueDescriptor( - name='ERROR', index=1, number=1, - serialized_options=None, - type=None, - create_key=_descriptor._internal_create_key), - ], - containing_type=None, - serialized_options=None, - serialized_start=281, - serialized_end=308, -) -_sym_db.RegisterEnumDescriptor(_RESPONSEHEADER_STATUS) - -_WRITEINSTRUCTIONSRESPONSE_STATUS = _descriptor.EnumDescriptor( - name='Status', - full_name='WriteInstructionsResponse.Status', - filename=None, - file=DESCRIPTOR, - create_key=_descriptor._internal_create_key, - values=[ - _descriptor.EnumValueDescriptor( - name='OK', index=0, number=0, - serialized_options=None, - type=None, - create_key=_descriptor._internal_create_key), - _descriptor.EnumValueDescriptor( - name='ERROR', index=1, number=1, - serialized_options=None, - type=None, - create_key=_descriptor._internal_create_key), - ], - containing_type=None, - serialized_options=None, - serialized_start=281, - serialized_end=308, -) -_sym_db.RegisterEnumDescriptor(_WRITEINSTRUCTIONSRESPONSE_STATUS) - - -_EXCEPTIONRESPONSE = _descriptor.Descriptor( - name='ExceptionResponse', - full_name='ExceptionResponse', - filename=None, - file=DESCRIPTOR, - containing_type=None, - create_key=_descriptor._internal_create_key, - fields=[ - _descriptor.FieldDescriptor( - name='module_name', full_name='ExceptionResponse.module_name', index=0, - number=1, type=9, cpp_type=9, label=1, - has_default_value=False, default_value=b"".decode('utf-8'), - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - _descriptor.FieldDescriptor( - name='class_name', full_name='ExceptionResponse.class_name', index=1, - number=2, type=9, cpp_type=9, label=1, - has_default_value=False, default_value=b"".decode('utf-8'), - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - _descriptor.FieldDescriptor( - name='args', full_name='ExceptionResponse.args', index=2, - number=3, type=9, cpp_type=9, label=1, - has_default_value=False, default_value=b"".decode('utf-8'), - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - ], - extensions=[ - ], - nested_types=[], - enum_types=[ - ], - serialized_options=None, - is_extendable=False, - syntax='proto3', - extension_ranges=[], - oneofs=[ - ], - serialized_start=25, - serialized_end=99, -) - - -_CLIENTRESOURCECLEANUPREQUEST = _descriptor.Descriptor( - name='ClientResourceCleanupRequest', - full_name='ClientResourceCleanupRequest', - filename=None, - file=DESCRIPTOR, - containing_type=None, - create_key=_descriptor._internal_create_key, - fields=[ - _descriptor.FieldDescriptor( - name='client_uri', full_name='ClientResourceCleanupRequest.client_uri', index=0, - number=1, type=9, cpp_type=9, label=1, - has_default_value=False, default_value=b"".decode('utf-8'), - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - ], - extensions=[ - ], - nested_types=[], - enum_types=[ - ], - serialized_options=None, - is_extendable=False, - syntax='proto3', - extension_ranges=[], - oneofs=[ - ], - serialized_start=101, - serialized_end=151, -) - - -_CLIENTRESOURCECLEANUPRESPONSE = _descriptor.Descriptor( - name='ClientResourceCleanupResponse', - full_name='ClientResourceCleanupResponse', - filename=None, - file=DESCRIPTOR, - containing_type=None, - create_key=_descriptor._internal_create_key, - fields=[ - _descriptor.FieldDescriptor( - name='status', full_name='ClientResourceCleanupResponse.status', index=0, - number=1, type=14, cpp_type=8, label=1, - has_default_value=False, default_value=0, - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - _descriptor.FieldDescriptor( - name='exception', full_name='ClientResourceCleanupResponse.exception', index=1, - number=2, type=11, cpp_type=10, label=1, - has_default_value=False, default_value=None, - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - ], - extensions=[ - ], - nested_types=[], - enum_types=[ - _CLIENTRESOURCECLEANUPRESPONSE_STATUS, - ], - serialized_options=None, - is_extendable=False, - syntax='proto3', - extension_ranges=[], - oneofs=[ - ], - serialized_start=154, - serialized_end=308, -) - - -_RESOURCEREQUEST = _descriptor.Descriptor( - name='ResourceRequest', - full_name='ResourceRequest', - filename=None, - file=DESCRIPTOR, - containing_type=None, - create_key=_descriptor._internal_create_key, - fields=[ - _descriptor.FieldDescriptor( - name='resource_type', full_name='ResourceRequest.resource_type', index=0, - number=1, type=9, cpp_type=9, label=1, - has_default_value=False, default_value=b"".decode('utf-8'), - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - _descriptor.FieldDescriptor( - name='handler', full_name='ResourceRequest.handler', index=1, - number=2, type=9, cpp_type=9, label=1, - has_default_value=False, default_value=b"".decode('utf-8'), - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - _descriptor.FieldDescriptor( - name='client_uri', full_name='ResourceRequest.client_uri', index=2, - number=3, type=9, cpp_type=9, label=1, - has_default_value=False, default_value=b"".decode('utf-8'), - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - _descriptor.FieldDescriptor( - name='args', full_name='ResourceRequest.args', index=3, - number=4, type=12, cpp_type=9, label=1, - has_default_value=False, default_value=b"", - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - ], - extensions=[ - ], - nested_types=[], - enum_types=[ - ], - serialized_options=None, - is_extendable=False, - syntax='proto3', - extension_ranges=[], - oneofs=[ - ], - serialized_start=310, - serialized_end=401, -) - - -_RESOURCERESPONSE = _descriptor.Descriptor( - name='ResourceResponse', - full_name='ResourceResponse', - filename=None, - file=DESCRIPTOR, - containing_type=None, - create_key=_descriptor._internal_create_key, - fields=[ - _descriptor.FieldDescriptor( - name='handler', full_name='ResourceResponse.handler', index=0, - number=1, type=9, cpp_type=9, label=1, - has_default_value=False, default_value=b"".decode('utf-8'), - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - _descriptor.FieldDescriptor( - name='status', full_name='ResourceResponse.status', index=1, - number=2, type=14, cpp_type=8, label=1, - has_default_value=False, default_value=0, - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - _descriptor.FieldDescriptor( - name='exception', full_name='ResourceResponse.exception', index=2, - number=3, type=11, cpp_type=10, label=1, - has_default_value=False, default_value=None, - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - ], - extensions=[ - ], - nested_types=[], - enum_types=[ - _RESOURCERESPONSE_STATUS, - ], - serialized_options=None, - is_extendable=False, - syntax='proto3', - extension_ranges=[], - oneofs=[ - ], - serialized_start=404, - serialized_end=549, -) - - -_RELEASERESOURCEREQUEST = _descriptor.Descriptor( - name='ReleaseResourceRequest', - full_name='ReleaseResourceRequest', - filename=None, - file=DESCRIPTOR, - containing_type=None, - create_key=_descriptor._internal_create_key, - fields=[ - _descriptor.FieldDescriptor( - name='handler', full_name='ReleaseResourceRequest.handler', index=0, - number=1, type=9, cpp_type=9, label=1, - has_default_value=False, default_value=b"".decode('utf-8'), - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - _descriptor.FieldDescriptor( - name='client_uri', full_name='ReleaseResourceRequest.client_uri', index=1, - number=2, type=9, cpp_type=9, label=1, - has_default_value=False, default_value=b"".decode('utf-8'), - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - ], - extensions=[ - ], - nested_types=[], - enum_types=[ - ], - serialized_options=None, - is_extendable=False, - syntax='proto3', - extension_ranges=[], - oneofs=[ - ], - serialized_start=551, - serialized_end=612, -) - - -_RELEASERESOURCERESPONSE = _descriptor.Descriptor( - name='ReleaseResourceResponse', - full_name='ReleaseResourceResponse', - filename=None, - file=DESCRIPTOR, - containing_type=None, - create_key=_descriptor._internal_create_key, - fields=[ - _descriptor.FieldDescriptor( - name='status', full_name='ReleaseResourceResponse.status', index=0, - number=2, type=14, cpp_type=8, label=1, - has_default_value=False, default_value=0, - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - _descriptor.FieldDescriptor( - name='exception', full_name='ReleaseResourceResponse.exception', index=1, - number=3, type=11, cpp_type=10, label=1, - has_default_value=False, default_value=None, - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - ], - extensions=[ - ], - nested_types=[], - enum_types=[ - _RELEASERESOURCERESPONSE_STATUS, - ], - serialized_options=None, - is_extendable=False, - syntax='proto3', - extension_ranges=[], - oneofs=[ - ], - serialized_start=615, - serialized_end=757, -) - - -_REQUESTHEADER = _descriptor.Descriptor( - name='RequestHeader', - full_name='RequestHeader', - filename=None, - file=DESCRIPTOR, - containing_type=None, - create_key=_descriptor._internal_create_key, - fields=[ - _descriptor.FieldDescriptor( - name='version', full_name='RequestHeader.version', index=0, - number=1, type=9, cpp_type=9, label=1, - has_default_value=False, default_value=b"".decode('utf-8'), - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - _descriptor.FieldDescriptor( - name='handler', full_name='RequestHeader.handler', index=1, - number=2, type=9, cpp_type=9, label=1, - has_default_value=False, default_value=b"".decode('utf-8'), - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - _descriptor.FieldDescriptor( - name='client_uri', full_name='RequestHeader.client_uri', index=2, - number=3, type=9, cpp_type=9, label=1, - has_default_value=False, default_value=b"".decode('utf-8'), - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - _descriptor.FieldDescriptor( - name='method_name', full_name='RequestHeader.method_name', index=3, - number=4, type=9, cpp_type=9, label=1, - has_default_value=False, default_value=b"".decode('utf-8'), - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - ], - extensions=[ - ], - nested_types=[], - enum_types=[ - ], - serialized_options=None, - is_extendable=False, - syntax='proto3', - extension_ranges=[], - oneofs=[ - ], - serialized_start=759, - serialized_end=849, -) - - -_INSTRUCTIONREQUEST = _descriptor.Descriptor( - name='InstructionRequest', - full_name='InstructionRequest', - filename=None, - file=DESCRIPTOR, - containing_type=None, - create_key=_descriptor._internal_create_key, - fields=[ - _descriptor.FieldDescriptor( - name='header', full_name='InstructionRequest.header', index=0, - number=1, type=11, cpp_type=10, label=1, - has_default_value=False, default_value=None, - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - _descriptor.FieldDescriptor( - name='message', full_name='InstructionRequest.message', index=1, - number=2, type=12, cpp_type=9, label=1, - has_default_value=False, default_value=b"", - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - ], - extensions=[ - ], - nested_types=[], - enum_types=[ - ], - serialized_options=None, - is_extendable=False, - syntax='proto3', - extension_ranges=[], - oneofs=[ - _descriptor.OneofDescriptor( - name='instruction', full_name='InstructionRequest.instruction', - index=0, containing_type=None, - create_key=_descriptor._internal_create_key, - fields=[]), - ], - serialized_start=851, - serialized_end=939, -) - - -_RESPONSEHEADER = _descriptor.Descriptor( - name='ResponseHeader', - full_name='ResponseHeader', - filename=None, - file=DESCRIPTOR, - containing_type=None, - create_key=_descriptor._internal_create_key, - fields=[ - _descriptor.FieldDescriptor( - name='version', full_name='ResponseHeader.version', index=0, - number=1, type=9, cpp_type=9, label=1, - has_default_value=False, default_value=b"".decode('utf-8'), - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - _descriptor.FieldDescriptor( - name='status', full_name='ResponseHeader.status', index=1, - number=2, type=14, cpp_type=8, label=1, - has_default_value=False, default_value=0, - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - _descriptor.FieldDescriptor( - name='exception', full_name='ResponseHeader.exception', index=2, - number=3, type=11, cpp_type=10, label=1, - has_default_value=False, default_value=None, - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - ], - extensions=[ - ], - nested_types=[], - enum_types=[ - _RESPONSEHEADER_STATUS, - ], - serialized_options=None, - is_extendable=False, - syntax='proto3', - extension_ranges=[], - oneofs=[ - ], - serialized_start=942, - serialized_end=1083, -) - - -_INSTRUCTIONRESPONSE = _descriptor.Descriptor( - name='InstructionResponse', - full_name='InstructionResponse', - filename=None, - file=DESCRIPTOR, - containing_type=None, - create_key=_descriptor._internal_create_key, - fields=[ - _descriptor.FieldDescriptor( - name='header', full_name='InstructionResponse.header', index=0, - number=1, type=11, cpp_type=10, label=1, - has_default_value=False, default_value=None, - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - _descriptor.FieldDescriptor( - name='message', full_name='InstructionResponse.message', index=1, - number=2, type=12, cpp_type=9, label=1, - has_default_value=False, default_value=b"", - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - ], - extensions=[ - ], - nested_types=[], - enum_types=[ - ], - serialized_options=None, - is_extendable=False, - syntax='proto3', - extension_ranges=[], - oneofs=[ - _descriptor.OneofDescriptor( - name='instruction', full_name='InstructionResponse.instruction', - index=0, containing_type=None, - create_key=_descriptor._internal_create_key, - fields=[]), - ], - serialized_start=1085, - serialized_end=1175, -) - - -_WRITEINSTRUCTIONSREQUEST = _descriptor.Descriptor( - name='WriteInstructionsRequest', - full_name='WriteInstructionsRequest', - filename=None, - file=DESCRIPTOR, - containing_type=None, - create_key=_descriptor._internal_create_key, - fields=[ - _descriptor.FieldDescriptor( - name='version', full_name='WriteInstructionsRequest.version', index=0, - number=1, type=9, cpp_type=9, label=1, - has_default_value=False, default_value=b"".decode('utf-8'), - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - _descriptor.FieldDescriptor( - name='client_uri', full_name='WriteInstructionsRequest.client_uri', index=1, - number=2, type=9, cpp_type=9, label=1, - has_default_value=False, default_value=b"".decode('utf-8'), - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - _descriptor.FieldDescriptor( - name='message', full_name='WriteInstructionsRequest.message', index=2, - number=3, type=12, cpp_type=9, label=1, - has_default_value=False, default_value=b"", - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - ], - extensions=[ - ], - nested_types=[], - enum_types=[ - ], - serialized_options=None, - is_extendable=False, - syntax='proto3', - extension_ranges=[], - oneofs=[ - ], - serialized_start=1177, - serialized_end=1257, -) - - -_WRITEINSTRUCTIONSRESPONSE = _descriptor.Descriptor( - name='WriteInstructionsResponse', - full_name='WriteInstructionsResponse', - filename=None, - file=DESCRIPTOR, - containing_type=None, - create_key=_descriptor._internal_create_key, - fields=[ - _descriptor.FieldDescriptor( - name='version', full_name='WriteInstructionsResponse.version', index=0, - number=1, type=9, cpp_type=9, label=1, - has_default_value=False, default_value=b"".decode('utf-8'), - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - _descriptor.FieldDescriptor( - name='status', full_name='WriteInstructionsResponse.status', index=1, - number=2, type=14, cpp_type=8, label=1, - has_default_value=False, default_value=0, - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - _descriptor.FieldDescriptor( - name='exception', full_name='WriteInstructionsResponse.exception', index=2, - number=3, type=11, cpp_type=10, label=1, - has_default_value=False, default_value=None, - message_type=None, enum_type=None, containing_type=None, - is_extension=False, extension_scope=None, - serialized_options=None, file=DESCRIPTOR, create_key=_descriptor._internal_create_key), - ], - extensions=[ - ], - nested_types=[], - enum_types=[ - _WRITEINSTRUCTIONSRESPONSE_STATUS, - ], - serialized_options=None, - is_extendable=False, - syntax='proto3', - extension_ranges=[], - oneofs=[ - ], - serialized_start=1260, - serialized_end=1423, -) - -_CLIENTRESOURCECLEANUPRESPONSE.fields_by_name['status'].enum_type = _CLIENTRESOURCECLEANUPRESPONSE_STATUS -_CLIENTRESOURCECLEANUPRESPONSE.fields_by_name['exception'].message_type = _EXCEPTIONRESPONSE -_CLIENTRESOURCECLEANUPRESPONSE_STATUS.containing_type = _CLIENTRESOURCECLEANUPRESPONSE -_RESOURCERESPONSE.fields_by_name['status'].enum_type = _RESOURCERESPONSE_STATUS -_RESOURCERESPONSE.fields_by_name['exception'].message_type = _EXCEPTIONRESPONSE -_RESOURCERESPONSE_STATUS.containing_type = _RESOURCERESPONSE -_RELEASERESOURCERESPONSE.fields_by_name['status'].enum_type = _RELEASERESOURCERESPONSE_STATUS -_RELEASERESOURCERESPONSE.fields_by_name['exception'].message_type = _EXCEPTIONRESPONSE -_RELEASERESOURCERESPONSE_STATUS.containing_type = _RELEASERESOURCERESPONSE -_INSTRUCTIONREQUEST.fields_by_name['header'].message_type = _REQUESTHEADER -_INSTRUCTIONREQUEST.oneofs_by_name['instruction'].fields.append( - _INSTRUCTIONREQUEST.fields_by_name['header']) -_INSTRUCTIONREQUEST.fields_by_name['header'].containing_oneof = _INSTRUCTIONREQUEST.oneofs_by_name['instruction'] -_INSTRUCTIONREQUEST.oneofs_by_name['instruction'].fields.append( - _INSTRUCTIONREQUEST.fields_by_name['message']) -_INSTRUCTIONREQUEST.fields_by_name['message'].containing_oneof = _INSTRUCTIONREQUEST.oneofs_by_name['instruction'] -_RESPONSEHEADER.fields_by_name['status'].enum_type = _RESPONSEHEADER_STATUS -_RESPONSEHEADER.fields_by_name['exception'].message_type = _EXCEPTIONRESPONSE -_RESPONSEHEADER_STATUS.containing_type = _RESPONSEHEADER -_INSTRUCTIONRESPONSE.fields_by_name['header'].message_type = _RESPONSEHEADER -_INSTRUCTIONRESPONSE.oneofs_by_name['instruction'].fields.append( - _INSTRUCTIONRESPONSE.fields_by_name['header']) -_INSTRUCTIONRESPONSE.fields_by_name['header'].containing_oneof = _INSTRUCTIONRESPONSE.oneofs_by_name['instruction'] -_INSTRUCTIONRESPONSE.oneofs_by_name['instruction'].fields.append( - _INSTRUCTIONRESPONSE.fields_by_name['message']) -_INSTRUCTIONRESPONSE.fields_by_name['message'].containing_oneof = _INSTRUCTIONRESPONSE.oneofs_by_name['instruction'] -_WRITEINSTRUCTIONSRESPONSE.fields_by_name['status'].enum_type = _WRITEINSTRUCTIONSRESPONSE_STATUS -_WRITEINSTRUCTIONSRESPONSE.fields_by_name['exception'].message_type = _EXCEPTIONRESPONSE -_WRITEINSTRUCTIONSRESPONSE_STATUS.containing_type = _WRITEINSTRUCTIONSRESPONSE -DESCRIPTOR.message_types_by_name['ExceptionResponse'] = _EXCEPTIONRESPONSE -DESCRIPTOR.message_types_by_name['ClientResourceCleanupRequest'] = _CLIENTRESOURCECLEANUPREQUEST -DESCRIPTOR.message_types_by_name['ClientResourceCleanupResponse'] = _CLIENTRESOURCECLEANUPRESPONSE -DESCRIPTOR.message_types_by_name['ResourceRequest'] = _RESOURCEREQUEST -DESCRIPTOR.message_types_by_name['ResourceResponse'] = _RESOURCERESPONSE -DESCRIPTOR.message_types_by_name['ReleaseResourceRequest'] = _RELEASERESOURCEREQUEST -DESCRIPTOR.message_types_by_name['ReleaseResourceResponse'] = _RELEASERESOURCERESPONSE -DESCRIPTOR.message_types_by_name['RequestHeader'] = _REQUESTHEADER -DESCRIPTOR.message_types_by_name['InstructionRequest'] = _INSTRUCTIONREQUEST -DESCRIPTOR.message_types_by_name['ResponseHeader'] = _RESPONSEHEADER -DESCRIPTOR.message_types_by_name['InstructionResponse'] = _INSTRUCTIONRESPONSE -DESCRIPTOR.message_types_by_name['WriteInstructionsRequest'] = _WRITEINSTRUCTIONSREQUEST -DESCRIPTOR.message_types_by_name['WriteInstructionsResponse'] = _WRITEINSTRUCTIONSRESPONSE -_sym_db.RegisterFileDescriptor(DESCRIPTOR) - -ExceptionResponse = _reflection.GeneratedProtocolMessageType('ExceptionResponse', (_message.Message,), { - 'DESCRIPTOR' : _EXCEPTIONRESPONSE, - '__module__' : 'remote_tracking_pb2' - # @@protoc_insertion_point(class_scope:ExceptionResponse) - }) -_sym_db.RegisterMessage(ExceptionResponse) - -ClientResourceCleanupRequest = _reflection.GeneratedProtocolMessageType('ClientResourceCleanupRequest', (_message.Message,), { - 'DESCRIPTOR' : _CLIENTRESOURCECLEANUPREQUEST, - '__module__' : 'remote_tracking_pb2' - # @@protoc_insertion_point(class_scope:ClientResourceCleanupRequest) - }) -_sym_db.RegisterMessage(ClientResourceCleanupRequest) - -ClientResourceCleanupResponse = _reflection.GeneratedProtocolMessageType('ClientResourceCleanupResponse', (_message.Message,), { - 'DESCRIPTOR' : _CLIENTRESOURCECLEANUPRESPONSE, - '__module__' : 'remote_tracking_pb2' - # @@protoc_insertion_point(class_scope:ClientResourceCleanupResponse) - }) -_sym_db.RegisterMessage(ClientResourceCleanupResponse) - -ResourceRequest = _reflection.GeneratedProtocolMessageType('ResourceRequest', (_message.Message,), { - 'DESCRIPTOR' : _RESOURCEREQUEST, - '__module__' : 'remote_tracking_pb2' - # @@protoc_insertion_point(class_scope:ResourceRequest) - }) -_sym_db.RegisterMessage(ResourceRequest) - -ResourceResponse = _reflection.GeneratedProtocolMessageType('ResourceResponse', (_message.Message,), { - 'DESCRIPTOR' : _RESOURCERESPONSE, - '__module__' : 'remote_tracking_pb2' - # @@protoc_insertion_point(class_scope:ResourceResponse) - }) -_sym_db.RegisterMessage(ResourceResponse) - -ReleaseResourceRequest = _reflection.GeneratedProtocolMessageType('ReleaseResourceRequest', (_message.Message,), { - 'DESCRIPTOR' : _RELEASERESOURCEREQUEST, - '__module__' : 'remote_tracking_pb2' - # @@protoc_insertion_point(class_scope:ReleaseResourceRequest) - }) -_sym_db.RegisterMessage(ReleaseResourceRequest) - -ReleaseResourceResponse = _reflection.GeneratedProtocolMessageType('ReleaseResourceResponse', (_message.Message,), { - 'DESCRIPTOR' : _RELEASERESOURCERESPONSE, - '__module__' : 'remote_tracking_pb2' - # @@protoc_insertion_point(class_scope:ReleaseResourceResponse) - }) -_sym_db.RegisterMessage(ReleaseResourceResponse) - -RequestHeader = _reflection.GeneratedProtocolMessageType('RequestHeader', (_message.Message,), { - 'DESCRIPTOR' : _REQUESTHEADER, - '__module__' : 'remote_tracking_pb2' - # @@protoc_insertion_point(class_scope:RequestHeader) - }) -_sym_db.RegisterMessage(RequestHeader) - -InstructionRequest = _reflection.GeneratedProtocolMessageType('InstructionRequest', (_message.Message,), { - 'DESCRIPTOR' : _INSTRUCTIONREQUEST, - '__module__' : 'remote_tracking_pb2' - # @@protoc_insertion_point(class_scope:InstructionRequest) - }) -_sym_db.RegisterMessage(InstructionRequest) - -ResponseHeader = _reflection.GeneratedProtocolMessageType('ResponseHeader', (_message.Message,), { - 'DESCRIPTOR' : _RESPONSEHEADER, - '__module__' : 'remote_tracking_pb2' - # @@protoc_insertion_point(class_scope:ResponseHeader) - }) -_sym_db.RegisterMessage(ResponseHeader) - -InstructionResponse = _reflection.GeneratedProtocolMessageType('InstructionResponse', (_message.Message,), { - 'DESCRIPTOR' : _INSTRUCTIONRESPONSE, - '__module__' : 'remote_tracking_pb2' - # @@protoc_insertion_point(class_scope:InstructionResponse) - }) -_sym_db.RegisterMessage(InstructionResponse) - -WriteInstructionsRequest = _reflection.GeneratedProtocolMessageType('WriteInstructionsRequest', (_message.Message,), { - 'DESCRIPTOR' : _WRITEINSTRUCTIONSREQUEST, - '__module__' : 'remote_tracking_pb2' - # @@protoc_insertion_point(class_scope:WriteInstructionsRequest) - }) -_sym_db.RegisterMessage(WriteInstructionsRequest) - -WriteInstructionsResponse = _reflection.GeneratedProtocolMessageType('WriteInstructionsResponse', (_message.Message,), { - 'DESCRIPTOR' : _WRITEINSTRUCTIONSRESPONSE, - '__module__' : 'remote_tracking_pb2' - # @@protoc_insertion_point(class_scope:WriteInstructionsResponse) - }) -_sym_db.RegisterMessage(WriteInstructionsResponse) - - - -_REMOTETRACKINGSERVICE = _descriptor.ServiceDescriptor( - name='RemoteTrackingService', - full_name='RemoteTrackingService', - file=DESCRIPTOR, - index=0, - serialized_options=None, - create_key=_descriptor._internal_create_key, - serialized_start=1426, - serialized_end=1823, - methods=[ - _descriptor.MethodDescriptor( - name='cleanup_client_resources', - full_name='RemoteTrackingService.cleanup_client_resources', - index=0, - containing_service=None, - input_type=_CLIENTRESOURCECLEANUPREQUEST, - output_type=_CLIENTRESOURCECLEANUPRESPONSE, - serialized_options=None, - create_key=_descriptor._internal_create_key, - ), - _descriptor.MethodDescriptor( - name='get_resource', - full_name='RemoteTrackingService.get_resource', - index=1, - containing_service=None, - input_type=_RESOURCEREQUEST, - output_type=_RESOURCERESPONSE, - serialized_options=None, - create_key=_descriptor._internal_create_key, - ), - _descriptor.MethodDescriptor( - name='release_resource', - full_name='RemoteTrackingService.release_resource', - index=2, - containing_service=None, - input_type=_RELEASERESOURCEREQUEST, - output_type=_RELEASERESOURCERESPONSE, - serialized_options=None, - create_key=_descriptor._internal_create_key, - ), - _descriptor.MethodDescriptor( - name='run_instruction', - full_name='RemoteTrackingService.run_instruction', - index=3, - containing_service=None, - input_type=_INSTRUCTIONREQUEST, - output_type=_INSTRUCTIONRESPONSE, - serialized_options=None, - create_key=_descriptor._internal_create_key, - ), - _descriptor.MethodDescriptor( - name='run_write_instructions', - full_name='RemoteTrackingService.run_write_instructions', - index=4, - containing_service=None, - input_type=_WRITEINSTRUCTIONSREQUEST, - output_type=_WRITEINSTRUCTIONSRESPONSE, - serialized_options=None, - create_key=_descriptor._internal_create_key, - ), -]) -_sym_db.RegisterServiceDescriptor(_REMOTETRACKINGSERVICE) - -DESCRIPTOR.services_by_name['RemoteTrackingService'] = _REMOTETRACKINGSERVICE - -# @@protoc_insertion_point(module_scope) diff --git a/aim/ext/transport/proto/v4/__init__.py b/aim/ext/transport/proto/v4/__init__.py deleted file mode 100644 index e69de29bb2..0000000000 diff --git a/aim/ext/transport/proto/v4/health_pb2.py b/aim/ext/transport/proto/v4/health_pb2.py deleted file mode 100644 index fe0b2adf7d..0000000000 --- a/aim/ext/transport/proto/v4/health_pb2.py +++ /dev/null @@ -1,31 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: health.proto -"""Generated protocol buffer code.""" -from google.protobuf.internal import builder as _builder -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0chealth.proto\x12\x0egrpc.health.v1\"%\n\x12HealthCheckRequest\x12\x0f\n\x07service\x18\x01 \x01(\t\"\xa9\x01\n\x13HealthCheckResponse\x12\x41\n\x06status\x18\x01 \x01(\x0e\x32\x31.grpc.health.v1.HealthCheckResponse.ServingStatus\"O\n\rServingStatus\x12\x0b\n\x07UNKNOWN\x10\x00\x12\x0b\n\x07SERVING\x10\x01\x12\x0f\n\x0bNOT_SERVING\x10\x02\x12\x13\n\x0fSERVICE_UNKNOWN\x10\x03\x32\xae\x01\n\x06Health\x12P\n\x05\x43heck\x12\".grpc.health.v1.HealthCheckRequest\x1a#.grpc.health.v1.HealthCheckResponse\x12R\n\x05Watch\x12\".grpc.health.v1.HealthCheckRequest\x1a#.grpc.health.v1.HealthCheckResponse0\x01\x62\x06proto3') - -_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals()) -_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'health_pb2', globals()) -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - _HEALTHCHECKREQUEST._serialized_start=32 - _HEALTHCHECKREQUEST._serialized_end=69 - _HEALTHCHECKRESPONSE._serialized_start=72 - _HEALTHCHECKRESPONSE._serialized_end=241 - _HEALTHCHECKRESPONSE_SERVINGSTATUS._serialized_start=162 - _HEALTHCHECKRESPONSE_SERVINGSTATUS._serialized_end=241 - _HEALTH._serialized_start=244 - _HEALTH._serialized_end=418 -# @@protoc_insertion_point(module_scope) diff --git a/aim/ext/transport/proto/v4/remote_router_pb2.py b/aim/ext/transport/proto/v4/remote_router_pb2.py deleted file mode 100644 index bf5dd2f44e..0000000000 --- a/aim/ext/transport/proto/v4/remote_router_pb2.py +++ /dev/null @@ -1,52 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: remote_router.proto -"""Generated protocol buffer code.""" -from google.protobuf.internal import builder as _builder -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x13remote_router.proto\x1a\x15remote_tracking.proto\"\x10\n\x0eVersionRequest\"\x8f\x01\n\x0fVersionResponse\x12\x0f\n\x07version\x18\x01 \x01(\t\x12\'\n\x06status\x18\x02 \x01(\x0e\x32\x17.VersionResponse.Status\x12%\n\texception\x18\x03 \x01(\x0b\x32\x12.ExceptionResponse\"\x1b\n\x06Status\x12\x06\n\x02OK\x10\x00\x12\t\n\x05\x45RROR\x10\x01\"&\n\x10HeartbeatRequest\x12\x12\n\nclient_uri\x18\x01 \x01(\t\"\x82\x01\n\x11HeartbeatResponse\x12)\n\x06status\x18\x01 \x01(\x0e\x32\x19.HeartbeatResponse.Status\x12%\n\texception\x18\x02 \x01(\x0b\x32\x12.ExceptionResponse\"\x1b\n\x06Status\x12\x06\n\x02OK\x10\x00\x12\t\n\x05\x45RROR\x10\x01\"$\n\x0e\x43onnectRequest\x12\x12\n\nclient_uri\x18\x01 \x01(\t\"\xa2\x01\n\x0f\x43onnectResponse\x12\x0c\n\x04port\x18\x01 \x01(\t\x12\x14\n\x0cworker_index\x18\x02 \x01(\t\x12\'\n\x06status\x18\x03 \x01(\x0e\x32\x17.ConnectResponse.Status\x12%\n\texception\x18\x04 \x01(\x0b\x32\x12.ExceptionResponse\"\x1b\n\x06Status\x12\x06\n\x02OK\x10\x00\x12\t\n\x05\x45RROR\x10\x01\"&\n\x10ReconnectRequest\x12\x12\n\nclient_uri\x18\x01 \x01(\t\"\x90\x01\n\x11ReconnectResponse\x12\x0c\n\x04port\x18\x01 \x01(\t\x12)\n\x06status\x18\x02 \x01(\x0e\x32\x19.ReconnectResponse.Status\x12%\n\texception\x18\x03 \x01(\x0b\x32\x12.ExceptionResponse\"\x1b\n\x06Status\x12\x06\n\x02OK\x10\x00\x12\t\n\x05\x45RROR\x10\x01\"\'\n\x11\x44isconnectRequest\x12\x12\n\nclient_uri\x18\x01 \x01(\t\"\x84\x01\n\x12\x44isconnectResponse\x12*\n\x06status\x18\x01 \x01(\x0e\x32\x1a.DisconnectResponse.Status\x12%\n\texception\x18\x03 \x01(\x0b\x32\x12.ExceptionResponse\"\x1b\n\x06Status\x12\x06\n\x02OK\x10\x00\x12\t\n\x05\x45RROR\x10\x01\x32\xa5\x02\n\x13RemoteRouterService\x12;\n\x10\x63lient_heartbeat\x12\x11.HeartbeatRequest\x1a\x12.HeartbeatResponse\"\x00\x12\x32\n\x0bget_version\x12\x0f.VersionRequest\x1a\x10.VersionResponse\"\x00\x12.\n\x07\x63onnect\x12\x0f.ConnectRequest\x1a\x10.ConnectResponse\"\x00\x12\x34\n\treconnect\x12\x11.ReconnectRequest\x1a\x12.ReconnectResponse\"\x00\x12\x37\n\ndisconnect\x12\x12.DisconnectRequest\x1a\x13.DisconnectResponse\"\x00\x62\x06proto3') - -_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals()) -_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'remote_router_pb2', globals()) -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - _VERSIONREQUEST._serialized_start=46 - _VERSIONREQUEST._serialized_end=62 - _VERSIONRESPONSE._serialized_start=65 - _VERSIONRESPONSE._serialized_end=208 - _VERSIONRESPONSE_STATUS._serialized_start=181 - _VERSIONRESPONSE_STATUS._serialized_end=208 - _HEARTBEATREQUEST._serialized_start=210 - _HEARTBEATREQUEST._serialized_end=248 - _HEARTBEATRESPONSE._serialized_start=251 - _HEARTBEATRESPONSE._serialized_end=381 - _HEARTBEATRESPONSE_STATUS._serialized_start=181 - _HEARTBEATRESPONSE_STATUS._serialized_end=208 - _CONNECTREQUEST._serialized_start=383 - _CONNECTREQUEST._serialized_end=419 - _CONNECTRESPONSE._serialized_start=422 - _CONNECTRESPONSE._serialized_end=584 - _CONNECTRESPONSE_STATUS._serialized_start=181 - _CONNECTRESPONSE_STATUS._serialized_end=208 - _RECONNECTREQUEST._serialized_start=586 - _RECONNECTREQUEST._serialized_end=624 - _RECONNECTRESPONSE._serialized_start=627 - _RECONNECTRESPONSE._serialized_end=771 - _RECONNECTRESPONSE_STATUS._serialized_start=181 - _RECONNECTRESPONSE_STATUS._serialized_end=208 - _DISCONNECTREQUEST._serialized_start=773 - _DISCONNECTREQUEST._serialized_end=812 - _DISCONNECTRESPONSE._serialized_start=815 - _DISCONNECTRESPONSE._serialized_end=947 - _DISCONNECTRESPONSE_STATUS._serialized_start=181 - _DISCONNECTRESPONSE_STATUS._serialized_end=208 - _REMOTEROUTERSERVICE._serialized_start=950 - _REMOTEROUTERSERVICE._serialized_end=1243 -# @@protoc_insertion_point(module_scope) diff --git a/aim/ext/transport/proto/v4/remote_tracking_pb2.py b/aim/ext/transport/proto/v4/remote_tracking_pb2.py deleted file mode 100644 index cd1fd45e91..0000000000 --- a/aim/ext/transport/proto/v4/remote_tracking_pb2.py +++ /dev/null @@ -1,61 +0,0 @@ -# -*- coding: utf-8 -*- -# Generated by the protocol buffer compiler. DO NOT EDIT! -# source: remote_tracking.proto -"""Generated protocol buffer code.""" -from google.protobuf.internal import builder as _builder -from google.protobuf import descriptor as _descriptor -from google.protobuf import descriptor_pool as _descriptor_pool -from google.protobuf import symbol_database as _symbol_database -# @@protoc_insertion_point(imports) - -_sym_db = _symbol_database.Default() - - - - -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x15remote_tracking.proto\"J\n\x11\x45xceptionResponse\x12\x13\n\x0bmodule_name\x18\x01 \x01(\t\x12\x12\n\nclass_name\x18\x02 \x01(\t\x12\x0c\n\x04\x61rgs\x18\x03 \x01(\t\"2\n\x1c\x43lientResourceCleanupRequest\x12\x12\n\nclient_uri\x18\x01 \x01(\t\"\x9a\x01\n\x1d\x43lientResourceCleanupResponse\x12\x35\n\x06status\x18\x01 \x01(\x0e\x32%.ClientResourceCleanupResponse.Status\x12%\n\texception\x18\x02 \x01(\x0b\x32\x12.ExceptionResponse\"\x1b\n\x06Status\x12\x06\n\x02OK\x10\x00\x12\t\n\x05\x45RROR\x10\x01\"[\n\x0fResourceRequest\x12\x15\n\rresource_type\x18\x01 \x01(\t\x12\x0f\n\x07handler\x18\x02 \x01(\t\x12\x12\n\nclient_uri\x18\x03 \x01(\t\x12\x0c\n\x04\x61rgs\x18\x04 \x01(\x0c\"\x91\x01\n\x10ResourceResponse\x12\x0f\n\x07handler\x18\x01 \x01(\t\x12(\n\x06status\x18\x02 \x01(\x0e\x32\x18.ResourceResponse.Status\x12%\n\texception\x18\x03 \x01(\x0b\x32\x12.ExceptionResponse\"\x1b\n\x06Status\x12\x06\n\x02OK\x10\x00\x12\t\n\x05\x45RROR\x10\x01\"=\n\x16ReleaseResourceRequest\x12\x0f\n\x07handler\x18\x01 \x01(\t\x12\x12\n\nclient_uri\x18\x02 \x01(\t\"\x8e\x01\n\x17ReleaseResourceResponse\x12/\n\x06status\x18\x02 \x01(\x0e\x32\x1f.ReleaseResourceResponse.Status\x12%\n\texception\x18\x03 \x01(\x0b\x32\x12.ExceptionResponse\"\x1b\n\x06Status\x12\x06\n\x02OK\x10\x00\x12\t\n\x05\x45RROR\x10\x01\"Z\n\rRequestHeader\x12\x0f\n\x07version\x18\x01 \x01(\t\x12\x0f\n\x07handler\x18\x02 \x01(\t\x12\x12\n\nclient_uri\x18\x03 \x01(\t\x12\x13\n\x0bmethod_name\x18\x04 \x01(\t\"X\n\x12InstructionRequest\x12 \n\x06header\x18\x01 \x01(\x0b\x32\x0e.RequestHeaderH\x00\x12\x11\n\x07message\x18\x02 \x01(\x0cH\x00\x42\r\n\x0binstruction\"\x8d\x01\n\x0eResponseHeader\x12\x0f\n\x07version\x18\x01 \x01(\t\x12&\n\x06status\x18\x02 \x01(\x0e\x32\x16.ResponseHeader.Status\x12%\n\texception\x18\x03 \x01(\x0b\x32\x12.ExceptionResponse\"\x1b\n\x06Status\x12\x06\n\x02OK\x10\x00\x12\t\n\x05\x45RROR\x10\x01\"Z\n\x13InstructionResponse\x12!\n\x06header\x18\x01 \x01(\x0b\x32\x0f.ResponseHeaderH\x00\x12\x11\n\x07message\x18\x02 \x01(\x0cH\x00\x42\r\n\x0binstruction\"P\n\x18WriteInstructionsRequest\x12\x0f\n\x07version\x18\x01 \x01(\t\x12\x12\n\nclient_uri\x18\x02 \x01(\t\x12\x0f\n\x07message\x18\x03 \x01(\x0c\"\xa3\x01\n\x19WriteInstructionsResponse\x12\x0f\n\x07version\x18\x01 \x01(\t\x12\x31\n\x06status\x18\x02 \x01(\x0e\x32!.WriteInstructionsResponse.Status\x12%\n\texception\x18\x03 \x01(\x0b\x32\x12.ExceptionResponse\"\x1b\n\x06Status\x12\x06\n\x02OK\x10\x00\x12\t\n\x05\x45RROR\x10\x01\x32\x8d\x03\n\x15RemoteTrackingService\x12[\n\x18\x63leanup_client_resources\x12\x1d.ClientResourceCleanupRequest\x1a\x1e.ClientResourceCleanupResponse\"\x00\x12\x35\n\x0cget_resource\x12\x10.ResourceRequest\x1a\x11.ResourceResponse\"\x00\x12G\n\x10release_resource\x12\x17.ReleaseResourceRequest\x1a\x18.ReleaseResourceResponse\"\x00\x12\x42\n\x0frun_instruction\x12\x13.InstructionRequest\x1a\x14.InstructionResponse\"\x00(\x01\x30\x01\x12S\n\x16run_write_instructions\x12\x19.WriteInstructionsRequest\x1a\x1a.WriteInstructionsResponse\"\x00(\x01\x62\x06proto3') - -_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals()) -_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'remote_tracking_pb2', globals()) -if _descriptor._USE_C_DESCRIPTORS == False: - - DESCRIPTOR._options = None - _EXCEPTIONRESPONSE._serialized_start=25 - _EXCEPTIONRESPONSE._serialized_end=99 - _CLIENTRESOURCECLEANUPREQUEST._serialized_start=101 - _CLIENTRESOURCECLEANUPREQUEST._serialized_end=151 - _CLIENTRESOURCECLEANUPRESPONSE._serialized_start=154 - _CLIENTRESOURCECLEANUPRESPONSE._serialized_end=308 - _CLIENTRESOURCECLEANUPRESPONSE_STATUS._serialized_start=281 - _CLIENTRESOURCECLEANUPRESPONSE_STATUS._serialized_end=308 - _RESOURCEREQUEST._serialized_start=310 - _RESOURCEREQUEST._serialized_end=401 - _RESOURCERESPONSE._serialized_start=404 - _RESOURCERESPONSE._serialized_end=549 - _RESOURCERESPONSE_STATUS._serialized_start=281 - _RESOURCERESPONSE_STATUS._serialized_end=308 - _RELEASERESOURCEREQUEST._serialized_start=551 - _RELEASERESOURCEREQUEST._serialized_end=612 - _RELEASERESOURCERESPONSE._serialized_start=615 - _RELEASERESOURCERESPONSE._serialized_end=757 - _RELEASERESOURCERESPONSE_STATUS._serialized_start=281 - _RELEASERESOURCERESPONSE_STATUS._serialized_end=308 - _REQUESTHEADER._serialized_start=759 - _REQUESTHEADER._serialized_end=849 - _INSTRUCTIONREQUEST._serialized_start=851 - _INSTRUCTIONREQUEST._serialized_end=939 - _RESPONSEHEADER._serialized_start=942 - _RESPONSEHEADER._serialized_end=1083 - _RESPONSEHEADER_STATUS._serialized_start=281 - _RESPONSEHEADER_STATUS._serialized_end=308 - _INSTRUCTIONRESPONSE._serialized_start=1085 - _INSTRUCTIONRESPONSE._serialized_end=1175 - _WRITEINSTRUCTIONSREQUEST._serialized_start=1177 - _WRITEINSTRUCTIONSREQUEST._serialized_end=1257 - _WRITEINSTRUCTIONSRESPONSE._serialized_start=1260 - _WRITEINSTRUCTIONSRESPONSE._serialized_end=1423 - _WRITEINSTRUCTIONSRESPONSE_STATUS._serialized_start=281 - _WRITEINSTRUCTIONSRESPONSE_STATUS._serialized_end=308 - _REMOTETRACKINGSERVICE._serialized_start=1426 - _REMOTETRACKINGSERVICE._serialized_end=1823 -# @@protoc_insertion_point(module_scope) diff --git a/aim/ext/transport/remote_resource.py b/aim/ext/transport/remote_resource.py index 7aac224f73..9a68bbe31b 100644 --- a/aim/ext/transport/remote_resource.py +++ b/aim/ext/transport/remote_resource.py @@ -1,5 +1,5 @@ from aim.ext.cleanup import AutoClean -from aim.ext.transport.client import Client +from .client import Client class RemoteResourceAutoClean(AutoClean): diff --git a/aim/ext/transport/remote_tracking.py b/aim/ext/transport/remote_tracking.py deleted file mode 100644 index 2a642c1b1a..0000000000 --- a/aim/ext/transport/remote_tracking.py +++ /dev/null @@ -1,185 +0,0 @@ -from typing import Dict, Union - -import aim.ext.transport.proto.remote_tracking_pb2 as tracking_rpc -import aim.ext.transport.proto.remote_tracking_pb2_grpc as tracking_pb2_grpc -import aim.ext.transport.message_utils as utils - -from aim.ext.transport.handlers import get_handler -from aim.storage.treeutils import encode_tree, decode_tree - - -class ResourceTypeRegistry: - def __init__(self): - self._registry: Dict[str, type] = {} - - def register(self, type_name: str, resource_getter: Union[type, callable]): - self._registry[type_name] = resource_getter - - def __getitem__(self, type_name: str): - return self._registry[type_name] - - -class RemoteTrackingServicer(tracking_pb2_grpc.RemoteTrackingServiceServicer): - resource_pool = dict() - - def __init__(self, resource_registry: ResourceTypeRegistry): - self.registry = resource_registry - - def cleanup_client_resources(self, request: tracking_rpc.ClientResourceCleanupRequest, _context): - dead_client_uri = request.client_uri - - resource_handlers = list(self.resource_pool.keys()) - for handler in resource_handlers: - (client_uri, _) = self.resource_pool[handler] - if dead_client_uri == client_uri: - del self.resource_pool[handler] - - return tracking_rpc.ResourceResponse(status=tracking_rpc.ResourceResponse.Status.OK) - - def get_resource(self, request: tracking_rpc.ResourceRequest, _context): - if not request.handler: - resource_handler = get_handler() - else: - resource_handler = request.handler - - try: - resource_cls = self.registry[request.resource_type] - if len(request.args) > 0: - kwargs = decode_tree(utils.unpack_args(request.args)) - checked_kwargs = {} - for argname, arg in kwargs.items(): - if isinstance(arg, utils.ResourceObject): - handler = arg.storage['handler'] - self._verify_resource_handler(handler, request.client_uri) - checked_kwargs[argname] = self.resource_pool[handler][1].ref - else: - checked_kwargs[argname] = arg - - res = resource_cls(**checked_kwargs) - else: - res = resource_cls() - - self.resource_pool[resource_handler] = (request.client_uri, res) - return tracking_rpc.ResourceResponse(handler=resource_handler, - status=tracking_rpc.ResourceResponse.Status.OK) - except Exception as e: - try: - # clean up resource_pool - # because no one will call release_resource in case of Exception - del self.resource_pool[resource_handler] - except KeyError: - pass - - return tracking_rpc.ResourceResponse( - handler=None, - status=tracking_rpc.ResourceResponse.Status.ERROR, - exception=utils.build_exception(e), - ) - - def release_resource(self, request: tracking_rpc.ReleaseResourceRequest, _context): - try: - resource_handler = request.handler - client_uri = request.client_uri - self._verify_resource_handler(resource_handler, client_uri) - del self.resource_pool[resource_handler] - return tracking_rpc.ReleaseResourceResponse(status=tracking_rpc.ReleaseResourceResponse.Status.OK) - except Exception as e: - # Should we clean ed resource_pool in case of exceptions? what if UnauthorizedRequest? - # del self.resource_pool[resource_handler] - return tracking_rpc.ReleaseResourceResponse( - status=tracking_rpc.ReleaseResourceResponse.Status.ERROR, - exception=utils.build_exception(e), - ) - - def run_instruction(self, request_iterator, _context) -> tracking_rpc.InstructionResponse: - try: - header = next(request_iterator) - assert header.WhichOneof('instruction') == 'header' - - resource_handler = header.header.handler - client_uri = header.header.client_uri - self._verify_resource_handler(resource_handler, client_uri) - - args = decode_tree(utils.unpack_stream(request_iterator)) - checked_args = [] - for arg in args: - if isinstance(arg, utils.ResourceObject): - handler = arg.storage['handler'] - self._verify_resource_handler(handler, client_uri) - checked_args.append(self.resource_pool[handler][1].ref) - else: - checked_args.append(arg) - - method_name = header.header.method_name - - resource = self.resource_pool[resource_handler][1].ref - if method_name.endswith('.setter'): - attr_name = method_name.split('.')[0] - setattr(resource, attr_name, checked_args[0]) - result = None - else: - attr = getattr(resource, method_name) - if callable(attr): - result = attr(*checked_args) - else: - result = attr - - yield tracking_rpc.InstructionResponse(header=tracking_rpc.ResponseHeader( - version='0.1', - status=tracking_rpc.ResponseHeader.Status.OK - )) - for chunk in utils.pack_stream(encode_tree(result)): - yield tracking_rpc.InstructionResponse(message=chunk) - - except Exception as e: - yield tracking_rpc.InstructionResponse(header=tracking_rpc.ResponseHeader( - version='0.1', - status=tracking_rpc.ResponseHeader.Status.ERROR, - exception=utils.build_exception(e), - )) - return - - def run_write_instructions(self, request_iterator, _context) -> tracking_rpc.WriteInstructionsResponse: - try: - raw_message = [] - client_uri = None # TODO [AD] move to header interface? - # TODO [AD] raw_message = [request.message for request in request_iterator] - for request in request_iterator: - raw_message.append(request.message) - client_uri = request.client_uri - write_instructions = decode_tree(utils.unpack_bytes(raw_message)) - for instruction in write_instructions: - resource_handler, method_name, args = instruction - - self._verify_resource_handler(resource_handler, client_uri) - - checked_args = [] - for arg in args: - if isinstance(arg, utils.ResourceObject): - handler = arg.storage['handler'] - self._verify_resource_handler(handler, client_uri) - checked_args.append(self.resource_pool[handler][1].ref) - else: - checked_args.append(arg) - - resource = self.resource_pool[resource_handler][1].ref - if method_name.endswith('.setter'): - attr_name = method_name.split('.')[0] - setattr(resource, attr_name, checked_args[0]) - else: - attr = getattr(resource, method_name) - assert callable(attr) - attr(*checked_args) - - return tracking_rpc.WriteInstructionsResponse(status=tracking_rpc.WriteInstructionsResponse.Status.OK) - except Exception as e: - return tracking_rpc.WriteInstructionsResponse( - version='0.1', - status=tracking_rpc.WriteInstructionsResponse.Status.ERROR, - exception=utils.build_exception(e), - ) - - def _verify_resource_handler(self, resource_handler, client_uri): - res_info = self.resource_pool.get(resource_handler, None) - if not res_info or res_info[0] != client_uri: - raise utils.UnauthorizedRequestError(resource_handler) diff --git a/aim/ext/transport/rpc_queue.py b/aim/ext/transport/request_queue.py similarity index 95% rename from aim/ext/transport/rpc_queue.py rename to aim/ext/transport/request_queue.py index 8317d53e66..36142aaa87 100644 --- a/aim/ext/transport/rpc_queue.py +++ b/aim/ext/transport/request_queue.py @@ -7,7 +7,7 @@ logger = logging.getLogger(__name__) -class RpcQueueWithRetry(object): +class RequestQueue(object): def __init__(self, name, max_queue_memory=0, retry_count=0, retry_interval=0): @@ -64,7 +64,7 @@ def worker(self): def _try_exec_task(self, task_f, *args): # temporary workaround for M1 build - import grpc + from websockets.exceptions import ConnectionClosedError retry = 0 while retry < self.retry_count: @@ -80,9 +80,7 @@ def _try_exec_task(self, task_f, *args): try: task_f(*args) return True - except grpc.RpcError as e: - if e.code() != grpc.StatusCode.UNAVAILABLE: - raise e + except ConnectionClosedError as e: self._needs_reconnect = True retry += 1 diff --git a/aim/ext/transport/router.py b/aim/ext/transport/router.py index 5033cf0890..f30fa473cc 100644 --- a/aim/ext/transport/router.py +++ b/aim/ext/transport/router.py @@ -1,79 +1,43 @@ import datetime -from typing import List, TYPE_CHECKING +from fastapi import APIRouter -import aim.ext.transport.proto.remote_router_pb2 as router_rpc -import aim.ext.transport.proto.remote_router_pb2_grpc as router_pb2_grpc -from aim.ext.transport.message_utils import build_exception - -if TYPE_CHECKING: - from aim.ext.transport.worker import RemoteWorker - - -class RemoteRouterServicer(router_pb2_grpc.RemoteRouterServiceServicer): +class ClientRouter: client_heartbeat_pool = dict() - - def __init__(self, worker_pool: List['RemoteWorker']): - self.worker_pool = worker_pool - - def new_client(self, client_uri): - sorted_workers_pool = sorted(self.worker_pool, key=lambda w: w.client_count) - - worker = sorted_workers_pool[0] - worker.add_client(client_uri) - return worker - - def get_version(self, request: router_rpc.VersionRequest, _context): + clients = [] + + def __init__(self): + self.router = APIRouter() + self.router.add_api_route('/get-version/', self.get_version, methods=['GET']) + self.router.add_api_route('/heartbeat/{client_uri}/', self.heartbeat, methods=['GET']) + self.router.add_api_route('/connect/{client_uri}/', self.connect, methods=['GET']) + self.router.add_api_route('/reconnect/{client_uri}/', self.reconnect, methods=['GET']) + self.router.add_api_route('/disconnect/{client_uri}/', self.disconnect, methods=['GET']) + + @classmethod + def add_client(cls, client_uri): + cls.clients.append(client_uri) + + @classmethod + def remove_client(cls, client_uri): + if client_uri in cls.clients: + cls.clients.remove(client_uri) + + async def get_version(self): from aim.__version__ import __version__ as aim_version - return router_rpc.VersionResponse(version=aim_version, - status=router_rpc.VersionResponse.Status.OK) - - def client_heartbeat(self, request: router_rpc.HeartbeatRequest, _context): - try: - client_uri = request.client_uri - self.client_heartbeat_pool[client_uri] = datetime.datetime.now().timestamp() - return router_rpc.HeartbeatResponse(status=router_rpc.HeartbeatResponse.Status.OK) - except Exception as e: - return router_rpc.HeartbeatResponse( - status=router_rpc.HeartbeatRequest.Status.ERROR, - exception=build_exception(e), - ) + return {'version': aim_version} - def connect(self, request: router_rpc.ConnectRequest, _context): - try: - worker = self.new_client(request.client_uri) - return router_rpc.ConnectResponse(port=worker.port, - worker_index=worker.index, - status=router_rpc.ConnectResponse.Status.OK) - except Exception as e: - return router_rpc.ConnectResponse(status=router_rpc.ConnectResponse.Status.ERROR, - exception=build_exception(e)) + async def heartbeat(self, client_uri): + self.client_heartbeat_pool[client_uri] = datetime.datetime.now().timestamp() - def reconnect(self, request: router_rpc.ReconnectRequest, _context): - try: - client_uri = request.client_uri - for worker in self.worker_pool: - if client_uri in worker.clients: - worker.restart() - return router_rpc.ReconnectResponse(port=worker.port, - status=router_rpc.ReconnectResponse.Status.OK) - # if client wasn't found in the list of clients of any worker fallback to connection logic - worker = self.new_client(client_uri) - return router_rpc.ReconnectResponse(port=worker.port, - status=router_rpc.ReconnectResponse.Status.OK) - except Exception as e: - return router_rpc.ReconnectResponse(status=router_rpc.ReconnectResponse.Status.ERROR, - exception=build_exception(e)) + async def connect(self, client_uri): + self.add_client(client_uri) - def disconnect(self, request: router_rpc.DisconnectRequest, _context): - try: - client_uri = request.client_uri - for worker in self.worker_pool: - worker.remove_client(client_uri) + async def reconnect(self, client_uri): + if client_uri not in self.clients: + self.add_client(client_uri) - return router_rpc.DisconnectResponse(status=router_rpc.DisconnectResponse.Status.OK) - except Exception as e: - return router_rpc.DisconnectResponse(status=router_rpc.DisconnectResponse.Status.ERROR, - exception=build_exception(e)) + async def disconnect(self, client_uri): + self.remove_client(client_uri) diff --git a/aim/ext/transport/run.py b/aim/ext/transport/run.py new file mode 100644 index 0000000000..7b9db8c310 --- /dev/null +++ b/aim/ext/transport/run.py @@ -0,0 +1,3 @@ +from aim.ext.transport.server import create_app + +app = create_app() diff --git a/aim/ext/transport/server.py b/aim/ext/transport/server.py index bae6b2b04e..dbddd37c86 100644 --- a/aim/ext/transport/server.py +++ b/aim/ext/transport/server.py @@ -1,12 +1,13 @@ import os -import time -from typing import Optional -from concurrent import futures +from fastapi import FastAPI +from fastapi.middleware.cors import CORSMiddleware +from fastapi.exceptions import HTTPException -from aim.ext.cleanup import AutoClean - -from aim.ext.transport.config import AIM_RT_MAX_MESSAGE_SIZE, AIM_RT_DEFAULT_MAX_MESSAGE_SIZE +from aim.ext.utils import http_exception_handler, fallback_exception_handler +from aim.ext.transport.router import ClientRouter +from aim.ext.transport.tracking import TrackingRouter, ResourceTypeRegistry +from aim.ext.transport.heartbeat import HeartbeatWatcher from aim.ext.transport.handlers import ( get_tree, get_structured_run, @@ -15,64 +16,7 @@ get_run_heartbeat, get_file_manager ) -from aim.ext.transport.heartbeat import RPCHeartbeatWatcher -from aim.ext.transport.worker import RemoteWorker, LocalWorker -from aim.ext.transport.health import HealthServicer, health_pb2_grpc -from aim.ext.transport.router import RemoteRouterServicer, router_pb2_grpc -from aim.ext.transport.remote_tracking import RemoteTrackingServicer, tracking_pb2_grpc, ResourceTypeRegistry - - -def _wait_forever(): - while True: - time.sleep(24 * 60 * 60) # sleep for a day - - -class RPCServerAutoClean(AutoClean['RPCServer']): - PRIORITY = 150 - - def __init__(self, instance: 'RPCServer'): - super().__init__(instance) - self.server = instance.server - - def _close(self): - self.server.stop(grace=None) - - -class RPCServer: - def __init__(self): - import grpc # temporary workaround for M1 build - - self._resources: Optional[RPCServerAutoClean] = None - self._server = grpc.server(futures.ThreadPoolExecutor(), options=self._get_grpc_server_options()) - self.resource = RPCServerAutoClean(self) - - def start(self, host, port, ssl_keyfile, ssl_certfile): - import grpc # temporary workaround for M1 build - - if ssl_keyfile and ssl_certfile: - with open(ssl_keyfile, 'rb') as f: - private_key = f.read() - with open(ssl_certfile, 'rb') as f: - certificate_chain = f.read() - server_credentials = grpc.ssl_server_credentials([(private_key, certificate_chain,)]) - self._server.add_secure_port(f'{host}:{port}', server_credentials) - else: - self._server.add_insecure_port(f'{host}:{port}') - - self._server.start() - - @staticmethod - def _get_grpc_server_options(): - msg_max_size = int(os.getenv(AIM_RT_MAX_MESSAGE_SIZE, AIM_RT_DEFAULT_MAX_MESSAGE_SIZE)) - options = [ - ('grpc.max_send_message_length', msg_max_size), - ('grpc.max_receive_message_length', msg_max_size) - ] - return options - - @property - def server(self): - return self._server +from aim.ext.transport.config import AIM_SERVER_BASE_PATH def prepare_resource_registry(): @@ -86,51 +30,45 @@ def prepare_resource_registry(): return registry -def run_router(host, port, workers=1, ssl_keyfile=None, ssl_certfile=None): - # start workers - worker_pool = [] - - if workers == 1: - worker = LocalWorker(lambda: None, host=host, port=port, index=0, - ssl_keyfile=ssl_keyfile, ssl_certfile=ssl_certfile) - worker_pool.append(worker) - else: - for i in range(1, workers + 1): - worker_port = port + i - worker = RemoteWorker(run_worker, host=host, port=worker_port, index=i, - ssl_keyfile=ssl_keyfile, ssl_certfile=ssl_certfile) - worker_pool.append(worker) - worker.start() - - # start routing RPC server - server = RPCServer() - router_pb2_grpc.add_RemoteRouterServiceServicer_to_server(RemoteRouterServicer(worker_pool), server.server) - health_pb2_grpc.add_HealthServicer_to_server(HealthServicer(), server.server) - - if workers == 1: - # add worker servicers to router as well - registry = prepare_resource_registry() - tracking_pb2_grpc.add_RemoteTrackingServiceServicer_to_server(RemoteTrackingServicer(registry), server.server) - - server.start(host, port, ssl_keyfile, ssl_certfile) - - # start client heartbeat service - heartbeat_watcher = RPCHeartbeatWatcher( - RemoteRouterServicer.client_heartbeat_pool, - worker_pool, +def create_app(): + app = FastAPI(title=__name__) + + app.add_middleware( + CORSMiddleware, + allow_origins=['*'], + allow_methods=['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS', 'HEAD'], + allow_headers=['Origin', 'X-Requested-With', + 'Content-Type', 'Accept', 'Authorization', 'X-Timezone-Offset'], + allow_credentials=True, + max_age=86400 + ) + + registry = ResourceTypeRegistry() + registry.register('TreeView', get_tree) + registry.register('FileManager', get_file_manager) + registry.register('Repo', get_repo) + + client_router = ClientRouter() + tracking_router = TrackingRouter(registry) + + watcher = HeartbeatWatcher( + ClientRouter.client_heartbeat_pool, ) - heartbeat_watcher.start() + watcher.start() + + api_app = FastAPI() - _wait_forever() + api_app.add_exception_handler(HTTPException, http_exception_handler) + api_app.add_exception_handler(Exception, fallback_exception_handler) + api_app.include_router(client_router.router, prefix='/client') + api_app.include_router(tracking_router.router, prefix='/tracking') -def run_worker(host, port, ssl_keyfile=None, ssl_certfile=None): - # register resource handlers - registry = prepare_resource_registry() + base_path = os.environ.get(AIM_SERVER_BASE_PATH, '') + app.mount(f'{base_path}/', api_app) - # start tracking RPC server - server = RPCServer() - tracking_pb2_grpc.add_RemoteTrackingServiceServicer_to_server(RemoteTrackingServicer(registry), server.server) - server.start(host, port, ssl_keyfile, ssl_certfile) + @api_app.get('/status/') + async def status(): + return {'status': 'OK'} - _wait_forever() + return app diff --git a/aim/ext/transport/tracking.py b/aim/ext/transport/tracking.py new file mode 100644 index 0000000000..7561d67b36 --- /dev/null +++ b/aim/ext/transport/tracking.py @@ -0,0 +1,220 @@ +import uuid +import base64 +import logging + +from typing import Dict, Union, List +from fastapi import WebSocket, Request, APIRouter, WebSocketDisconnect +from fastapi.responses import StreamingResponse, JSONResponse + +from aim.ext.transport.message_utils import ( + encode_tree, + decode_tree, + unpack_args, + pack_args, + pack_stream, + build_exception, + ResourceObject, +) + +logger = logging.getLogger(__name__) + + +def get_handler(): + return str(uuid.uuid4()) + + +class UnauthorizedRequestError(RuntimeError): + def __init__(self, handler, *args, **kwargs): + self.handler = handler + + +class ResourceTypeRegistry: + def __init__(self): + self._registry: Dict[str, type] = {} + + def register(self, type_name: str, resource_getter: Union[type, callable]): + self._registry[type_name] = resource_getter + + def __getitem__(self, type_name: str): + return self._registry[type_name] + + +class ConnectionManager: + def __init__(self): + self.active_connections: List[WebSocket] = [] + + async def connect(self, websocket: WebSocket): + await websocket.accept() + self.active_connections.append(websocket) + + def disconnect(self, websocket: WebSocket): + self.active_connections.remove(websocket) + + async def send_personal_message(self, message: str, websocket: WebSocket): + await websocket.send_text(message) + + async def broadcast(self, message: str): + for connection in self.active_connections: + await connection.send_text(message) + + +class TrackingRouter: + resource_pool = dict() + manager = ConnectionManager() + + def __init__(self, resource_registry: ResourceTypeRegistry): + self.registry = resource_registry + self.router = APIRouter() + self.router.add_api_route('/{client_uri}/get-resource/', + self.get_resource, methods=['POST']) + self.router.add_api_route('/{client_uri}/release-resource/{resource_handler}/', + self.release_resource, methods=['GET']) + self.router.add_api_route('/{client_uri}/read-instruction/', self.run_instruction, methods=['POST']) + self.router.add_api_websocket_route('/{client_uri}/write-instruction/', self.run_write_instructions) + + @classmethod + def cleanup_client_resources(cls, dead_client_uri): + resource_handlers = list(cls.resource_pool.keys()) + for handler in resource_handlers: + (client_uri, _) = cls.resource_pool[handler] + if dead_client_uri == client_uri: + del cls.resource_pool[handler] + + @classmethod + def _verify_resource_handler(cls, resource_handler, client_uri): + res_info = cls.resource_pool.get(resource_handler, None) + if not res_info or res_info[0] != client_uri: + raise UnauthorizedRequestError(resource_handler) + + async def get_resource(self, + client_uri: str, + request: Request,): + request_data = await request.json() + resource_handler = request_data.get('resource_handler') + resource_type = request_data.get('resource_type') + args = request_data.get('args') + + if not resource_handler: + resource_handler = get_handler() + + try: + resource_cls = self.registry[resource_type] + if len(args) > 0: + kwargs = decode_tree(unpack_args(base64.b64decode(args))) + checked_kwargs = {} + for argname, arg in kwargs.items(): + if isinstance(arg, ResourceObject): + handler = arg.storage['handler'] + self._verify_resource_handler(handler, client_uri) + checked_kwargs[argname] = self.resource_pool[handler][1].ref + else: + checked_kwargs[argname] = arg + + res = resource_cls(**checked_kwargs) + else: + res = resource_cls() + + self.resource_pool[resource_handler] = (client_uri, res) + return {'handler': resource_handler} + + except Exception as e: + try: + # clean up resource_pool + # because no one will call release_resource in case of Exception + del self.resource_pool[resource_handler] + except KeyError: + pass + + logger.debug(f'Caught exception {e}. Sending response 400.') + return JSONResponse({ + 'exception': build_exception(e), + }, status_code=400) + + async def release_resource(self, client_uri, resource_handler): + try: + self._verify_resource_handler(resource_handler, client_uri) + del self.resource_pool[resource_handler] + except Exception as e: + logger.debug(f'Caught exception {e}. Sending response 400.') + return JSONResponse({ + 'exception': build_exception(e), + }, status_code=400) + + async def run_instruction(self, client_uri: str, + request: Request,): + try: + request_data = await request.json() + resource_handler = request_data.get('resource_handler') + method_name = request_data.get('method_name') + args = request_data.get('args') + + self._verify_resource_handler(resource_handler, client_uri) + + args = decode_tree(unpack_args(base64.b64decode(args))) + + checked_args = [] + for arg in args: + if isinstance(arg, ResourceObject): + handler = arg.storage['handler'] + self._verify_resource_handler(handler, client_uri) + checked_args.append(self.resource_pool[handler][1].ref) + else: + checked_args.append(arg) + + resource = self.resource_pool[resource_handler][1].ref + if method_name.endswith('.setter'): + attr_name = method_name.split('.')[0] + setattr(resource, attr_name, checked_args[0]) + result = None + else: + attr = getattr(resource, method_name) + if callable(attr): + result = attr(*checked_args) + else: + result = attr + + return StreamingResponse(pack_stream(encode_tree(result))) + except Exception as e: + logger.debug(f'Caught exception {e}. Sending response 400.') + return JSONResponse({ + 'exception': build_exception(e), + }, status_code=400) + + async def run_write_instructions(self, websocket: WebSocket, client_uri: str): + await self.manager.connect(websocket) + + try: + while True: + raw_message = await websocket.receive_bytes() + write_instructions = decode_tree( + unpack_args(raw_message)) + for instruction in write_instructions: + resource_handler, method_name, args = instruction + self._verify_resource_handler( + resource_handler, client_uri) + checked_args = [] + for arg in args: + if isinstance(arg, ResourceObject): + handler = arg.storage['handler'] + self._verify_resource_handler( + handler, client_uri) + checked_args.append( + self.resource_pool[handler][1].ref) + else: + checked_args.append(arg) + + resource = self.resource_pool[resource_handler][1].ref + if method_name.endswith('.setter'): + attr_name = method_name.split('.')[0] + setattr(resource, attr_name, checked_args[0]) + else: + attr = getattr(resource, method_name) + assert callable(attr) + attr(*checked_args) + + await websocket.send_bytes(b'OK') + except WebSocketDisconnect: + self.manager.disconnect(websocket) + + except Exception as e: + await websocket.send_bytes(pack_args(encode_tree(build_exception(e)))) diff --git a/aim/ext/transport/utils.py b/aim/ext/transport/utils.py new file mode 100644 index 0000000000..bbf8d84cb8 --- /dev/null +++ b/aim/ext/transport/utils.py @@ -0,0 +1,22 @@ +import logging + +from functools import wraps +from typing import Type, Optional + +logger = logging.getLogger(__name__) + + +def handle_exception(exc_type: Type[Exception], error_message: Optional[str] = None): + def inner(func): + @wraps(func) + def wrapper(*args, **kwargs): + try: + return func(*args, **kwargs) + except exc_type as e: # noqa + if error_message is not None: + logger.error(error_message) + raise RuntimeError(error_message) + else: # silent mode + pass + return wrapper + return inner diff --git a/aim/ext/transport/worker.py b/aim/ext/transport/worker.py deleted file mode 100644 index 819f5e3ef4..0000000000 --- a/aim/ext/transport/worker.py +++ /dev/null @@ -1,117 +0,0 @@ -import datetime - -from multiprocessing import Process -from typing import Optional - -import aim.ext.transport.proto.remote_tracking_pb2 as rpc_messages -import aim.ext.transport.proto.remote_tracking_pb2_grpc as remote_tracking_pb2_grpc -from aim.ext.cleanup import AutoClean - - -class RemoteWorkerAutoClean(AutoClean['RemoteWorker']): - PRIORITY = 120 - - def __init__(self, instance: 'RemoteWorker'): - super().__init__(instance) - self.worker_process = instance.worker_process - - def _close(self) -> None: - self.worker_process.join() - - -class RemoteWorker: - WORKER_START_GRACE_PERIOD = datetime.timedelta(minutes=5) - - def __init__(self, target_f, *, host, port, index, ssl_keyfile=None, ssl_certfile=None): - self._resources: Optional[RemoteWorkerAutoClean] = None - self.worker_process = Process(target=target_f, args=(host, port, ssl_keyfile, ssl_certfile)) - self._host = host - self._port = port - self._idx = index - self._ssl_keyfile = ssl_keyfile - self._ssl_certfile = ssl_certfile - self._start_time = None - self._clients = [] - self._resources = RemoteWorkerAutoClean(self) - - def start(self): - self.worker_process.start() - self._start_time = datetime.datetime.now() - - def stop(self): - self.worker_process.join() - - def restart(self): - if datetime.datetime.now() - self.start_time > self.WORKER_START_GRACE_PERIOD: - self.stop() - self.start() - - def add_client(self, client_uri): - self._clients.append(client_uri) - - def remove_client(self, client_uri): - if client_uri in self._clients: - self._clients.remove(client_uri) - - @property - def clients(self): - return self._clients - - @property - def start_time(self): - return self._start_time - - @property - def host(self): - return self._host - - @property - def port(self): - return str(self._port) - - @property - def address(self): - return f'{self._host}:{self._port}' - - @property - def client_count(self): - return len(self._clients) - - @property - def index(self): - return str(self._idx) - - def cleanup_client_resources(self, client_uri): - import grpc - - if self._ssl_certfile: - with open(self._ssl_certfile, 'rb') as f: - root_certificates = grpc.ssl_channel_credentials(f.read()) - _remote_worker_channel = grpc.secure_channel(self.address, root_certificates) - else: - _remote_worker_channel = grpc.insecure_channel(self.address) - - _remote_worker_stub = remote_tracking_pb2_grpc.RemoteTrackingServiceStub(_remote_worker_channel) - request = rpc_messages.ClientResourceCleanupRequest(client_uri=client_uri) - _remote_worker_stub.cleanup_client_resources(request) - - -class LocalWorker(RemoteWorker): - def __init__(self, target_f, *, host, port, index, ssl_keyfile=None, ssl_certfile=None): - self._resources: Optional[RemoteWorkerAutoClean] = None - self._host = host - self._port = port - self._idx = index - self._ssl_keyfile = ssl_keyfile - self._ssl_certfile = ssl_certfile - self._start_time = None - self._clients = [] - - def start(self): - self._start_time = datetime.datetime.now() - - def stop(self): - pass - - def restart(self): - self.start() diff --git a/aim/ext/utils.py b/aim/ext/utils.py index ba7ab6a020..89721c865e 100644 --- a/aim/ext/utils.py +++ b/aim/ext/utils.py @@ -1,5 +1,6 @@ import logging import subprocess +from fastapi.responses import JSONResponse logger = logging.getLogger(__name__) @@ -71,3 +72,27 @@ def get_git_info(): }) return git_info + + +async def http_exception_handler(request, exc): + message = str(exc.detail) + detail = None + + if isinstance(exc.detail, dict): + message = exc.detail.pop('message', message) + detail = exc.detail.pop('detail', None) + + response = {'message': message} + if detail: + response.update({'detail': detail}) + else: + response.update({'detail': str(exc)}) + return JSONResponse(response, status_code=exc.status_code) + + +async def fallback_exception_handler(request, exc): + response = { + 'message': f'\'{type(exc)}\' exception raised!', + 'detail': str(exc) + } + return JSONResponse(response, status_code=500) diff --git a/aim/web/api/__init__.py b/aim/web/api/__init__.py index cce2c41b7b..e931903bad 100644 --- a/aim/web/api/__init__.py +++ b/aim/web/api/__init__.py @@ -4,36 +4,12 @@ from fastapi.exceptions import HTTPException from fastapi.middleware.cors import CORSMiddleware from fastapi.middleware.gzip import GZipMiddleware -from fastapi.responses import JSONResponse from aim.sdk.configs import get_aim_repo_name from aim.web.configs import AIM_PROFILER_KEY from aim.web.middlewares.profiler import PyInstrumentProfilerMiddleware from aim.web.utils import get_root_path - - -async def http_exception_handler(request, exc): - message = str(exc.detail) - detail = None - - if isinstance(exc.detail, dict): - message = exc.detail.pop('message', message) - detail = exc.detail.pop('detail', None) - - response = {'message': message} - if detail: - response.update({'detail': detail}) - else: - response.update({'detail': str(exc)}) - return JSONResponse(response, status_code=exc.status_code) - - -async def fallback_exception_handler(request, exc): - response = { - 'message': f'\'{type(exc)}\' exception raised!', - 'detail': str(exc) - } - return JSONResponse(response, status_code=500) +from aim.ext.utils import http_exception_handler, fallback_exception_handler def create_app(): diff --git a/aim/web/utils.py b/aim/web/utils.py index b213f0d224..50a03ab952 100644 --- a/aim/web/utils.py +++ b/aim/web/utils.py @@ -7,60 +7,6 @@ from aim.sdk.utils import clean_repo_path -class ShellCommandException(Exception): - pass - - -def exec_cmd( - cmd, throw_on_error=True, env=None, stream_output=False, cwd=None, cmd_stdin=None, **kwargs -): - """ - Runs a command as a child process. - A convenience wrapper for running a command from a Python script. - Keyword arguments: - cmd -- the command to run, as a list of strings - throw_on_error -- if true, raises an Exception if the exit code of the program is nonzero - env -- additional environment variables to be defined when running the child process - cwd -- working directory for child process - stream_output -- if true, does not capture standard output and error; if false, captures these - streams and returns them - cmd_stdin -- if specified, passes the specified string as stdin to the child process. - Note on the return value: If stream_output is true, then only the exit code is returned. If - stream_output is false, then a tuple of the exit code, standard output and standard error is - returned. - """ - cmd_env = os.environ.copy() - if env: - cmd_env.update(env) - if stream_output: - child = subprocess.Popen( - cmd, env=cmd_env, cwd=cwd, universal_newlines=True, stdin=subprocess.PIPE, **kwargs - ) - child.communicate(cmd_stdin) - exit_code = child.wait() - if throw_on_error and exit_code != 0: - raise ShellCommandException("Non-zero exitcode: %s" % (exit_code)) - return exit_code - else: - child = subprocess.Popen( - cmd, - env=cmd_env, - stdout=subprocess.PIPE, - stdin=subprocess.PIPE, - stderr=subprocess.PIPE, - cwd=cwd, - universal_newlines=True, - **kwargs - ) - (stdout, stderr) = child.communicate(cmd_stdin) - exit_code = child.wait() - if throw_on_error and exit_code != 0: - raise ShellCommandException( - "Non-zero exit code: %s\n\nSTDOUT:\n%s\n\nSTDERR:%s" % (exit_code, stdout, stderr) - ) - return exit_code, stdout, stderr - - def get_module(name, required=True): try: return import_module(name) diff --git a/setup.py b/setup.py index 444a44fbee..b40840a6a0 100644 --- a/setup.py +++ b/setup.py @@ -73,6 +73,7 @@ def package_files(directory): 'packaging>=15.0', 'python-dateutil', 'requests', + 'websockets' ] if platform.machine() != 'arm64':