class PartialStore:
"""A store spawned inside mini-jinad container"""
def __init__(self):
self._logger = JinaLogger(self.__class__.__name__, **vars(jinad_args))
self.item = PartialStoreItem()
def add(self, *args, **kwargs) -> PartialStoreItem:
"""Add a new element to the store. This method needs to be overridden by the subclass
.. #noqa: DAR101"""
raise NotImplementedError
def update(self, *args, **kwargs) -> PartialStoreItem:
"""Updates the element to the store. This method needs to be overridden by the subclass
.. #noqa: DAR101"""
raise NotImplementedError
def delete(self) -> None:
"""Terminates the object in the store & stops the server"""
try:
if hasattr(self, 'object'):
self.object.close()
else:
self._logger.warning(f'nothing to close. exiting')
except Exception as e:
self._logger.error(f'{e!r}')
raise
class PartialStore(ABC):
"""A store spawned inside partial-daemon container"""
def __init__(self):
self._logger = JinaLogger(self.__class__.__name__, **vars(jinad_args))
self.item = PartialStoreItem()
self.object: Union['Pea', 'Pod', 'Flow'] = None
@abstractmethod
def add(self, *args, **kwargs) -> PartialStoreItem:
"""Add a new element to the store. This method needs to be overridden by the subclass
.. #noqa: DAR101"""
...
def delete(self) -> None:
"""Terminates the object in the store & stops the server"""
try:
if hasattr(self.object, 'close'):
self.object.close()
else:
self._logger.warning(f'nothing to close. exiting')
except Exception as e:
self._logger.error(f'{e!r}')
raise
class PartialStore(ABC):
"""A store spawned inside partial-daemon container"""
def __init__(self):
self._logger = JinaLogger(self.__class__.__name__, **vars(jinad_args))
self.item = PartialStoreItem()
self.object: Union[Type['BasePod'], Type['BaseDeployment'],
'Flow'] = None
@abstractmethod
def add(self, *args, **kwargs) -> PartialStoreItem:
"""Add a new element to the store. This method needs to be overridden by the subclass
.. #noqa: DAR101"""
...
def delete(self) -> None:
"""Terminates the object in the store & stops the server"""
try:
if hasattr(self.object, 'close'):
self.object.close()
self._logger.info(self.item.arguments)
if self.item.arguments.get('identity'):
self._logger.success(
f'{colored(self.item.arguments["identity"], "cyan")} is removed!'
)
else:
self._logger.success('object is removed!')
else:
self._logger.warning(f'nothing to close. exiting')
except Exception as e:
self._logger.error(f'{e!r}')
raise
else:
self.item = PartialStoreItem()
def send_requests(
client_kwargs,
rolling_event,
client_ready_to_send_event,
exception_to_raise_event,
):
from jina.logging.logger import JinaLogger
from jina.clients import Client
_logger = JinaLogger('test_send_requests')
_logger.debug(f' send request start')
try:
client = Client(**client_kwargs)
client.show_progress = True
_logger.debug(f' Client instantiated with {client_kwargs}')
_logger.debug(f' Set client_ready_to_send_event event')
client_ready_to_send_event.set()
while not rolling_event.is_set():
_logger.debug(f' event is not set')
r = client.post(
'/exec',
[Document() for _ in range(10)],
return_results=True,
port_expose=9090,
)
assert len(r) > 0
assert len(r[0].docs) > 0
for doc in r[0].docs:
assert doc.tags['argument'] in ['value1', 'value2']
time.sleep(0.1)
_logger.debug(f' event is unset')
except:
_logger.error(f' Some error happened while sending requests')
exception_to_raise_event.set()
_logger.debug(f' send requests finished')
def log(logger: JinaLogger):
logger.debug('this is test debug message')
logger.info('this is test info message')
logger.success('this is test success message')
logger.warning('this is test warning message')
logger.error('this is test error message')
logger.critical('this is test critical message')
def _list(
logger: JinaLogger,
image_name: Optional[str] = None,
image_kind: Optional[str] = None,
image_type: Optional[str] = None,
image_keywords: Sequence = (),
) -> Optional[List[Dict[str, Any]]]:
"""Use Hub api to get the list of filtered images.
:param logger: logger to use
:param image_name: name of hub image
:param image_kind: kind of hub image (indexer/encoder/segmenter/crafter/evaluator/ranker etc)
:param image_type: type of hub image (pod/app)
:param image_keywords: keywords added in the manifest yml
:return: a dict of manifest specifications, each coresponds to a hub image
"""
with open(os.path.join(__resources_path__, 'hubapi.yml')) as fp:
hubapi_yml = JAML.load(fp)
hubapi_url = hubapi_yml['hubapi']['url'] + hubapi_yml['hubapi']['list']
params = {
'name': image_name,
'kind': image_kind,
'type': image_type,
'keywords': image_keywords,
}
params = {k: v for k, v in params.items() if v}
if params:
data = urlencode(params, doseq=True)
request = Request(f'{hubapi_url}?{data}')
with TimeContext('searching', logger):
try:
with urlopen(request) as resp:
response = json.load(resp)
except HTTPError as err:
if err.code == 400:
logger.warning(
'no matched executors found. please use different filters and retry.'
)
elif err.code == 500:
logger.error(f'server is down: {err.reason}')
else:
logger.error(f'unknown error: {err.reason}')
return
local_manifest = _load_local_hub_manifest()
if local_manifest:
tb = _make_hub_table_with_local(response, local_manifest)
else:
tb = _make_hub_table(response)
logger.info('\n'.join(tb))
return response
class BaseRuntime:
"""A Jina Runtime is a procedure that blocks the main process once running (i.e. :meth:`run_forever`),
therefore should be put into a separated thread/process, or inside the main process of a docker container.
Any program/library/package/module that blocks the main process, can be formulated into a :class:`BaseRuntime` class
and then be started from a :class:`Pod`.
In the sequel, we call the main process/thread as ``M``, the process/thread blocked :class:`Runtime` as ``S``.
In Jina, a :class:`Pod` object is used to manage a :class:`Runtime` object's lifecycle. A :class:`Pod`
acts as a :class:`multiprocessing.Process` or :class:`threading.Thread`, it starts from ``M`` and once the
``S`` is spawned, it uses :class:`Runtime` as a context manager:
0. :meth:`__init__`
1. :meth: `__enter__`
2. :meth:`run_forever`. Note that this will block ``S``, step 3 won't be
reached until it is unblocked by :meth:`cancel`.
3. When an error occurs during `run_forever` or `cancel` signal is reached by the `runtime`. The `run_forever` method is cancelled and
the managed context is closed. The `__exit__` of `Runtime` guarantees that the `Runtime` is properly shut by calling `teardown`.
The :meth:`__init__` and :meth:`teardown` pair together, which defines instructions that will be executed before
and after. In subclasses, `teardown` is optional.
In order to cancel the `run_forever` method of a `Runtime`, you can use their `static` `cancel` method that will make sure that the runtime is properly cancelled.
- Use :class:`threading.Event` or `multiprocessing.Event`, while :meth:`run_forever` polls for this event
- Use GrpcConnectionPool to send a TERMINATE message, while :meth:`run_forever` polls for this message
Note, another way to jump out from :meth:`run_forever` is raise exceptions from it. This will immediately move to
:meth:`teardown`.
.. note::
Rule of thumb on exception handling: if you are not sure if you should handle exception inside
:meth:`run_forever`, :meth:`cancel`, :meth:`teardown`, then DO NOT catch exception in them.
Exception is MUCH better handled by :class:`Pod`.
.. seealso::
:class:`Pod` for managing a :class:`Runtime` object's lifecycle.
"""
def __init__(
self,
args: 'argparse.Namespace',
**kwargs,
):
super().__init__()
self.args = args
if args.name:
self.name = f'{args.name}/{self.__class__.__name__}'
else:
self.name = self.__class__.__name__
self.logger = JinaLogger(self.name, **vars(self.args))
def run_forever(self):
"""Running the blocking procedure inside ``S``. Note, once this method is called,
``S`` is blocked.
.. note::
If this method raises any exception, :meth:`teardown` will be called.
.. seealso::
:meth:`cancel` for cancelling the forever loop.
"""
raise NotImplementedError
def teardown(self):
"""Method called immediately after :meth:`run_forever` is unblocked.
You can tidy up things here. Optional in subclasses. The default implementation does nothing.
"""
self.logger.close()
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
if exc_type == RuntimeTerminated:
self.logger.debug(f'{self!r} is ended')
elif exc_type == KeyboardInterrupt:
self.logger.debug(f'{self!r} is interrupted by user')
elif exc_type and issubclass(exc_type, Exception):
self.logger.error(
f'{exc_val!r} during {self.run_forever!r}' +
f'\n add "--quiet-error" to suppress the exception details'
if not self.args.quiet_error else '',
exc_info=not self.args.quiet_error,
)
try:
self.teardown()
except OSError:
# OSError(Stream is closed) already
pass
except Exception as ex:
self.logger.error(
f'{ex!r} during {self.teardown!r}' +
f'\n add "--quiet-error" to suppress the exception details'
if not self.args.quiet_error else '',
exc_info=not self.args.quiet_error,
)
# https://stackoverflow.com/a/28158006
# return True will silent all exception stack trace here, silence is desired here as otherwise it is too
# noisy
#
# doc: If an exception is supplied, and the method wishes to suppress the exception (i.e., prevent it
# from being propagated), it should return a true value. Otherwise, the exception will be processed normally
# upon exit from this method.
return True
class HubIO:
""":class:`HubIO` provides the way to interact with Jina Hub registry.
You can use it with CLI to package a directory into a Jina Hub and publish it to the world.
Examples:
- :command:`jina hub push my_executor/` to push the executor package to Jina Hub
- :command:`jina hub pull UUID8` to download the executor identified by UUID8
To create a :class:`HubIO` object, simply:
.. highlight:: python
.. code-block:: python
hubio = HubIO(args)
:param args: arguments
"""
def __init__(self, args: Optional[argparse.Namespace] = None, **kwargs):
if args and isinstance(args, argparse.Namespace):
self.args = args
else:
self.args = ArgNamespace.kwargs2namespace(kwargs, set_hub_parser())
self.logger = JinaLogger(self.__class__.__name__, **vars(args))
with ImportExtensions(required=True):
import rich
import cryptography
import filelock
assert rich #: prevent pycharm auto remove the above line
assert cryptography
assert filelock
def new(self) -> None:
"""Create a new executor folder interactively."""
from rich import print, box
from rich.prompt import Prompt, Confirm
from rich.panel import Panel
from rich.table import Table
from rich.console import Console
from rich.progress import track
from rich.syntax import Syntax
console = Console()
print(
Panel.fit(
'''
[bold green]Executor[/bold green] is how Jina processes [bold]Document[/bold].
This guide helps you to create your own Executor in 30 seconds.''',
title='Create New Executor',
))
exec_name = (self.args.name if self.args.name else Prompt.ask(
':grey_question: What is the [bold]name[/bold] of your executor?\n'
'[dim]CamelCase is required[/dim]',
default=f'MyExecutor{random.randint(0, 100)}',
))
exec_path = (self.args.path if self.args.path else Prompt.ask(
':grey_question: [bold]Which folder[/bold] to store your executor?',
default=os.path.join(os.getcwd(), exec_name),
))
exec_description = '{{}}'
exec_keywords = '{{}}'
exec_url = '{{}}'
is_dockerfile = False
if self.args.advance_configuration or Confirm.ask(
'[green]That\'s all we need to create an Executor![/green]\n'
':grey_question: Or do you want to proceed to advanced configuration',
default=False,
):
exec_description = (
self.args.description if self.args.description else
(Prompt.ask(
':grey_question: Please give a [bold]short description[/bold] of your executor?\n'
f'[dim]Example: {exec_name} embeds images into 128-dim vectors using ResNet.[/dim]'
)))
exec_keywords = (self.args.keywords if self.args.keywords else (
Prompt.ask(
':grey_question: Please give some [bold]keywords[/bold] to help people search your executor [dim](separated by comma)[/dim]\n'
f'[dim]Example: image cv embedding encoding resnet[/dim]'))
)
exec_url = (self.args.url if self.args.url else (Prompt.ask(
':grey_question: What is the [bold]URL[/bold] for GitHub repo?\n'
f'[dim]Example: https://github.com/yourname/my-executor[/dim]')
))
print(
Panel.fit(
'''
[bold]Dockerfile[/bold] describes how this executor will be built. It is useful when
your executor has non-trivial dependencies or must be run under certain environment.
- If the [bold]Dockerfile[/bold] is missing, Jina automatically generates one for you.
- If you provide one, then Jina will respect the given [bold]Dockerfile[/bold].''',
title='[Optional] [bold]Dockerfile[/bold]',
width=80,
))
is_dockerfile = self.args.add_dockerfile or Confirm.ask(
':grey_question: Do you need to write your own [bold]Dockerfile[/bold] instead of the auto-generated one?',
default=False,
)
print('[green]That\'s all we need to create an Executor![/green]')
def mustache_repl(srcs):
for src in track(srcs,
description=f'Creating {exec_name}...',
total=len(srcs)):
with open(
os.path.join(__resources_path__, 'executor-template',
src)) as fp, open(
os.path.join(exec_path, src),
'w') as fpw:
f = (fp.read().replace('{{exec_name}}', exec_name).replace(
'{{exec_description}}', exec_description).replace(
'{{exec_keywords}}',
str(exec_keywords.split(','))).replace(
'{{exec_url}}', exec_url))
f = [
v + '\n' for v in f.split('\n')
if not ('{{' in v or '}}' in v)
]
fpw.writelines(f)
Path(exec_path).mkdir(parents=True, exist_ok=True)
pkg_files = [
'executor.py',
'manifest.yml',
'README.md',
'requirements.txt',
'config.yml',
]
if is_dockerfile:
pkg_files.append('Dockerfile')
mustache_repl(pkg_files)
table = Table(box=box.SIMPLE)
table.add_column('Filename', style='cyan', no_wrap=True)
table.add_column('Description', no_wrap=True)
# adding the columns in order of `ls` output
table.add_row(
'config.yml',
'The YAML config file of the Executor. You can define [bold]__init__[/bold] arguments using [bold]with[/bold] keyword.',
)
table.add_row(
'',
Panel(
Syntax(
f'''
jtype: {exec_name}
with:
foo: 1
bar: hello
metas:
py_modules:
- executor.py
''',
'yaml',
theme='monokai',
line_numbers=True,
word_wrap=True,
),
title='config.yml',
width=50,
expand=False,
),
)
if is_dockerfile:
table.add_row(
'Dockerfile',
'The Dockerfile describes how this executor will be built.',
)
table.add_row('executor.py', 'The main logic file of the Executor.')
table.add_row(
'manifest.yml',
'Metadata for the Executor, for better appeal on Jina Hub.',
)
manifest_fields_table = Table(box=box.SIMPLE)
manifest_fields_table.add_column('Field', style='cyan', no_wrap=True)
manifest_fields_table.add_column('Description', no_wrap=True)
manifest_fields_table.add_row('name',
'Human-readable title of the Executor')
manifest_fields_table.add_row(
'description', 'Human-readable description of the Executor')
manifest_fields_table.add_row(
'url',
'URL to find more information on the Executor (e.g. GitHub repo URL)',
)
manifest_fields_table.add_row(
'keywords', 'Keywords that help user find the Executor')
table.add_row('', manifest_fields_table)
table.add_row('README.md', 'A usage guide of the Executor.')
table.add_row('requirements.txt',
'The Python dependencies of the Executor.')
final_table = Table(box=None)
final_table.add_row(
'Congrats! You have successfully created an Executor! Here are the next steps:'
)
p0 = Panel(
Syntax(
f'cd {exec_path}\nls',
'console',
theme='monokai',
line_numbers=True,
word_wrap=True,
),
title='1. Check out the generated Executor',
width=120,
expand=False,
)
p1 = Panel(
table,
title='2. Understand folder structure',
width=120,
expand=False,
)
p2 = Panel(
Syntax(
f'jina hub push {exec_path}',
'console',
theme='monokai',
line_numbers=True,
word_wrap=True,
),
title='3. Share it to Jina Hub',
width=120,
expand=False,
)
final_table.add_row(p0)
final_table.add_row(p1)
final_table.add_row(p2)
p = Panel(
final_table,
title=':tada: Next steps',
width=130,
expand=False,
)
console.print(p)
def push(self) -> None:
"""Push the executor pacakge to Jina Hub."""
from rich.console import Console
work_path = Path(self.args.path)
exec_tags = None
if self.args.tag:
exec_tags = ','.join(self.args.tag)
dockerfile = None
if self.args.dockerfile:
dockerfile = Path(self.args.dockerfile)
if not dockerfile.exists():
raise Exception(
f'The given Dockerfile `{dockerfile}` does not exist!')
if dockerfile.parent != work_path:
raise Exception(
f'The Dockerfile must be placed at the given folder `{work_path}`'
)
dockerfile = dockerfile.relative_to(work_path)
console = Console()
with console.status(f'Pushing `{self.args.path}` ...') as st:
req_header = get_request_header()
try:
st.update(f'Packaging {self.args.path} ...')
md5_hash = hashlib.md5()
bytesio = archive_package(work_path)
content = bytesio.getvalue()
md5_hash.update(content)
md5_digest = md5_hash.hexdigest()
# upload the archived package
form_data = {
'public':
'True' if getattr(self.args, 'public', None) else 'False',
'private':
'True' if getattr(self.args, 'private', None) else 'False',
'md5sum': md5_digest,
}
if exec_tags:
form_data['tags'] = exec_tags
if dockerfile:
form_data['dockerfile'] = str(dockerfile)
uuid8, secret = load_secret(work_path)
if self.args.force_update or uuid8:
form_data['force'] = self.args.force_update or uuid8
if self.args.secret or secret:
form_data['secret'] = self.args.secret or secret
method = 'put' if ('force' in form_data) else 'post'
st.update(f'Connecting to Jina Hub ...')
hubble_url = get_hubble_url_v1() + '/executors'
# upload the archived executor to Jina Hub
st.update(f'Uploading...')
resp = upload_file(
hubble_url,
'filename',
content,
dict_data=form_data,
headers=req_header,
stream=True,
method=method,
)
result = None
for stream_line in resp.iter_lines():
stream_msg = json.loads(stream_line)
if 'stream' in stream_msg:
st.update(
f'Cloud building ... [dim]{stream_msg["stream"]}[/dim]'
)
elif 'status' in stream_msg:
st.update(
f'Cloud building ... [dim]{stream_msg["status"]}[/dim]'
)
elif 'result' in stream_msg:
result = stream_msg['result']
break
if result is None:
raise Exception('Unknown Error')
elif not result.get('data', None):
msg = result.get('message', 'Unknown Error')
if 'Process(docker) exited on non-zero code' in msg:
self.logger.error('''
Failed on building Docker image. Potential solutions:
- If you haven't provide a Dockerfile in the executor bundle, you may want to provide one,
as the auto-generated one on the cloud did not work.
- If you have provided a Dockerfile, you may want to check the validity of this Dockerfile.
''')
raise Exception(msg)
elif 200 <= result['statusCode'] < 300:
new_uuid8, new_secret = self._prettyprint_result(
console, result)
if new_uuid8 != uuid8 or new_secret != secret:
dump_secret(work_path, new_uuid8, new_secret)
elif result['message']:
raise Exception(result['message'])
elif resp.text:
# NOTE: sometimes resp.text returns empty
raise Exception(resp.text)
else:
resp.raise_for_status()
except KeyboardInterrupt:
pass
except Exception as e: # IO related errors
self.logger.error(
f'''Please report this session_id: {colored(req_header["jinameta-session-id"], color="yellow", attrs="bold")} to https://github.com/jina-ai/jina/issues'
{e!r}''')
raise e
def _prettyprint_result(self, console, result):
# TODO: only support single executor now
from rich.table import Table
from rich.panel import Panel
data = result.get('data', None)
image = data['executors'][0]
uuid8 = image['id']
secret = image['secret']
visibility = image['visibility']
tag = self.args.tag[0] if self.args.tag else None
table = Table.grid()
table.add_column(width=20, no_wrap=True)
table.add_column(style='cyan', no_wrap=True)
table.add_row(
':link: Hub URL',
f'[link=https://hub.jina.ai/executor/{uuid8}/]https://hub.jina.ai/executor/{uuid8}/[/link]',
)
if 'name' in image:
table.add_row(':name_badge: Name', image['name'])
table.add_row(':lock: Secret', secret)
table.add_row(
'',
':point_up:️ [bold red]Please keep this token in a safe place!',
)
table.add_row(':eyes: Visibility', visibility)
p1 = Panel(
table,
title='Published',
width=80,
expand=False,
)
console.print(p1)
presented_id = image.get('name', uuid8)
usage = (f'{presented_id}' if visibility == 'public' else
f'{presented_id}:{secret}') + (f'/{tag}' if tag else '')
if not self.args.no_usage:
self._get_prettyprint_usage(console, usage)
return uuid8, secret
def _get_prettyprint_usage(self, console, executor_name, usage_kind=None):
from rich.panel import Panel
from rich.syntax import Syntax
flow_plain = f'''from jina import Flow
f = Flow().add(uses='jinahub://{executor_name}')
with f:
...'''
flow_docker = f'''from jina import Flow
f = Flow().add(uses='jinahub+docker://{executor_name}')
with f:
...'''
p1 = Panel(
Syntax(flow_plain,
'python',
theme='monokai',
line_numbers=True,
word_wrap=True),
title='Usage',
width=80,
expand=False,
)
p2 = Panel(
Syntax(
flow_docker,
'python',
theme='monokai',
line_numbers=True,
word_wrap=True,
),
title='Docker usage',
width=80,
expand=False,
)
if usage_kind == 'docker':
console.print(p2)
elif usage_kind == 'source':
console.print(p1)
else:
console.print(p1, p2)
@staticmethod
@disk_cache_offline(cache_file=str(_cache_file))
def fetch_meta(
name: str,
tag: str,
secret: Optional[str] = None,
force: bool = False,
) -> HubExecutor:
"""Fetch the executor meta info from Jina Hub.
:param name: the UUID/Name of the executor
:param tag: the tag of the executor if available, otherwise, use `None` as the value
:param secret: the access secret of the executor
:param force: if set to True, access to fetch_meta will always pull latest Executor metas, otherwise, default
to local cache
:return: meta of executor
.. note::
The `name` and `tag` should be passed via ``args`` and `force` and `secret` as ``kwargs``, otherwise,
cache does not work.
"""
with ImportExtensions(required=True):
import requests
pull_url = get_hubble_url_v1() + f'/executors/{name}/?'
path_params = {}
if secret:
path_params['secret'] = secret
if tag:
path_params['tag'] = tag
if path_params:
pull_url += urlencode(path_params)
resp = requests.get(pull_url, headers=get_request_header())
if resp.status_code != 200:
if resp.text:
raise Exception(resp.text)
resp.raise_for_status()
resp = resp.json()
return HubExecutor(
uuid=resp['id'],
name=resp.get('name', None),
sn=resp.get('sn', None),
tag=tag or resp['tag'],
visibility=resp['visibility'],
image_name=resp['image'],
archive_url=resp['package']['download'],
md5sum=resp['package']['md5'],
)
@staticmethod
def deploy_public_sandbox(uses: str):
"""
Deploy a public sandbox to Jina Hub.
:param uses: the executor uses string
:return: the host and port of the sandbox
"""
scheme, name, tag, secret = parse_hub_uri(uses)
payload = {
'name': name,
'tag': tag if tag else 'latest',
'jina': __version__,
}
from rich.progress import Console
import requests
console = Console()
host = None
try:
res = requests.get(
url=get_hubble_url_v2() + '/rpc/sandbox.get',
params=payload,
headers=get_request_header(),
).json()
if res.get('code') == 200:
host = res.get('data', {}).get('host', None)
except Exception:
raise
if host:
return host, 443
with console.status(
f"[bold green]Deploying sandbox for ({name}) since no existing one..."
):
try:
json = requests.post(
url=get_hubble_url_v2() + '/rpc/sandbox.create',
json=payload,
headers=get_request_header(),
).json()
host = json.get('data', {}).get('host', None)
livetime = json.get('data', {}).get('livetime', '15 mins')
if not host:
raise Exception(f'Failed to deploy sandbox: {json}')
console.log(f"Deployment completed: {host}")
console.log(
f"[bold green]This sandbox will be removed when no traffic during {livetime}"
)
except:
console.log("Deployment failed")
raise
return host, 443
def _pull_with_progress(self, log_streams, console):
from rich.progress import Progress, DownloadColumn, BarColumn
with Progress(
"[progress.description]{task.description}",
BarColumn(),
DownloadColumn(),
"[progress.percentage]{task.percentage:>3.0f}%",
console=console,
transient=True,
) as progress:
tasks = {}
for log in log_streams:
if 'status' not in log:
continue
status = log['status']
status_id = log.get('id', None)
pg_detail = log.get('progressDetail', None)
if (pg_detail is None) or (status_id is None):
self.logger.debug(status)
continue
if status_id not in tasks:
tasks[status_id] = progress.add_task(status, total=0)
task_id = tasks[status_id]
if ('current' in pg_detail) and ('total' in pg_detail):
progress.update(
task_id,
completed=pg_detail['current'],
total=pg_detail['total'],
description=status,
)
elif not pg_detail:
progress.update(task_id, advance=0, description=status)
def _load_docker_client(self):
with ImportExtensions(required=True):
import docker.errors
import docker
from docker import APIClient
from jina import __windows__
try:
self._client = docker.from_env()
# low-level client
self._raw_client = APIClient(
base_url=docker.constants.DEFAULT_NPIPE
if __windows__ else docker.constants.DEFAULT_UNIX_SOCKET)
except docker.errors.DockerException:
self.logger.critical(
f'Docker daemon seems not running. Please run Docker daemon and try again.'
)
exit(1)
def pull(self) -> str:
"""Pull the executor package from Jina Hub.
:return: the `uses` string
"""
from rich.console import Console
console = Console()
cached_zip_file = None
executor_name = None
usage_kind = None
try:
need_pull = self.args.force_update
with console.status(f'Pulling {self.args.uri}...') as st:
scheme, name, tag, secret = parse_hub_uri(self.args.uri)
st.update(f'Fetching [bold]{name}[/bold] from Jina Hub ...')
executor, from_cache = HubIO.fetch_meta(name,
tag,
secret=secret,
force=need_pull)
presented_id = getattr(executor, 'name', executor.uuid)
executor_name = (
f'{presented_id}' if executor.visibility == 'public' else
f'{presented_id}:{secret}') + (f'/{tag}' if tag else '')
if scheme == 'jinahub+docker':
self._load_docker_client()
import docker
try:
self._client.images.get(executor.image_name)
except docker.errors.ImageNotFound:
need_pull = True
if need_pull:
st.update(f'Pulling image ...')
log_stream = self._raw_client.pull(executor.image_name,
stream=True,
decode=True)
st.stop()
self._pull_with_progress(
log_stream,
console,
)
usage_kind = 'docker'
return f'docker://{executor.image_name}'
elif scheme == 'jinahub':
import filelock
with filelock.FileLock(get_lockfile(), timeout=-1):
try:
pkg_path, pkg_dist_path = get_dist_path_of_executor(
executor)
# check serial number to upgrade
sn_file_path = pkg_dist_path / f'PKG-SN-{executor.sn or 0}'
if (not sn_file_path.exists()) and any(
pkg_dist_path.glob('PKG-SN-*')):
raise FileNotFoundError(
f'{pkg_path} need to be upgraded')
st.update(
'Installing [bold]requirements.txt[/bold]...')
install_package_dependencies(
install_deps=self.args.install_requirements,
pkg_dist_path=pkg_dist_path,
pkg_path=pkg_dist_path,
)
except FileNotFoundError:
need_pull = True
if need_pull:
# pull the latest executor meta, as the cached data would expire
if from_cache:
executor, _ = HubIO.fetch_meta(name,
tag,
secret=secret,
force=True)
cache_dir = Path(
os.environ.get(
'JINA_HUB_CACHE_DIR',
Path.home().joinpath('.cache', 'jina'),
))
cache_dir.mkdir(parents=True, exist_ok=True)
st.update(f'Downloading {name} ...')
cached_zip_file = download_with_resume(
executor.archive_url,
cache_dir,
f'{executor.uuid}-{executor.md5sum}.zip',
md5sum=executor.md5sum,
)
st.update(f'Unpacking {name} ...')
install_local(
cached_zip_file,
executor,
install_deps=self.args.install_requirements,
)
pkg_path, _ = get_dist_path_of_executor(executor)
usage_kind = 'source'
return f'{pkg_path / "config.yml"}'
else:
raise ValueError(f'{self.args.uri} is not a valid scheme')
except KeyboardInterrupt:
executor_name = None
except Exception:
executor_name = None
raise
finally:
# delete downloaded zip package if existed
if cached_zip_file is not None:
cached_zip_file.unlink()
if not self.args.no_usage and executor_name:
self._get_prettyprint_usage(console, executor_name, usage_kind)
class MongoDBHandler:
"""
Mongodb Handler to connect to the database & insert documents in the collection
MongoDB has no access control by default, hence can be used without username:password.
If username & password are passed, we need to create it (can be changed to existing un:pw)
"""
def __init__(self,
hostname: str = '127.0.0.1',
port: int = 27017,
username: str = None,
password: str = None,
database: str = 'defaultdb',
collection: str = 'defaultcol'):
self.logger = JinaLogger(self.__class__.__name__)
self.hostname = hostname
self.port = port
self.username = username
self.password = password
self.database_name = database
self.collection_name = collection
if self.username and self.password:
self.connection_string = \
f'mongodb://{self.username}:{self.password}@{self.hostname}:{self.port}'
else:
self.connection_string = \
f'mongodb://{self.hostname}:{self.port}'
def __enter__(self):
return self.connect()
def connect(self) -> 'MongoDBHandler':
import pymongo
try:
self.client = pymongo.MongoClient(self.connection_string)
self.client.admin.command('ismaster')
self.logger.info('Successfully connected to the database')
except pymongo.errors.ConnectionFailure:
raise MongoDBException('Database server is not available')
except pymongo.errors.ConfigurationError:
raise MongoDBException('Credentials passed are not correct!')
except pymongo.errors.PyMongoError as exp:
raise MongoDBException(exp)
except Exception as exp:
raise MongoDBException(exp)
return self
@property
def database(self):
return self.client[self.database_name]
@property
def collection(self):
return self.database[self.collection_name]
def find(self, key: int) -> Optional[bytes]:
import pymongo
try:
cursor = self.collection.find({'_id': key})
cursor_contents = list(cursor)
if cursor_contents:
return cursor_contents[0]
return None
except pymongo.errors.PyMongoError as exp:
self.logger.error(
f'Got an error while finding a document in the db {exp}')
def insert(self, documents: Iterator[Dict]) -> Optional[str]:
import pymongo
try:
result = self.collection.insert_many(documents)
self.logger.debug(
f'inserted {len(result.inserted_ids)} documents in the database'
)
return result.inserted_ids
except pymongo.errors.PyMongoError as exp:
self.logger.error(
f'got an error while inserting a document in the db {exp}')
def __exit__(self, exc_type, exc_val, exc_tb):
import pymongo
try:
self.client.close()
except pymongo.errors.PyMongoError as exp:
raise MongoDBException(exp)
def delete(self, keys: Iterator[int], *args, **kwargs):
import pymongo
try:
count = self.collection.delete_many({
'_id': {
'$in': list(keys)
}
}).deleted_count
self.logger.debug(f'deleted {count} documents in the database')
except pymongo.errors.PyMongoError as exp:
self.logger.error(
f'got an error while deleting a document in the db {exp}')
def update(self, keys: Iterator[int], values: Iterator[bytes], *args,
**kwargs):
import pymongo
try:
# update_many updates several keys with the same op. / data.
# we need this instead
count = 0
for k, new_doc in zip(keys, values):
new_doc = {'_id': k, 'values': new_doc}
inserted_doc = self.collection.find_one_and_replace({'_id': k},
new_doc)
if inserted_doc == new_doc:
count += 1
self.logger.debug(f'updated {count} documents in the database')
return
except pymongo.errors.PyMongoError as exp:
self.logger.error(
f'got an error while updating documents in the db {exp}')
def run(
args: 'argparse.Namespace',
name: str,
container_name: str,
net_mode: Optional[str],
runtime_ctrl_address: str,
envs: Dict,
is_started: Union['multiprocessing.Event', 'threading.Event'],
is_shutdown: Union['multiprocessing.Event', 'threading.Event'],
is_ready: Union['multiprocessing.Event', 'threading.Event'],
):
"""Method to be run in a process that stream logs from a Container
This method is the target for the Pod's `thread` or `process`
.. note::
:meth:`run` is running in subprocess/thread, the exception can not be propagated to the main process.
Hence, please do not raise any exception here.
.. note::
Please note that env variables are process-specific. Subprocess inherits envs from
the main process. But Subprocess's envs do NOT affect the main process. It does NOT
mess up user local system envs.
:param args: namespace args from the Pod
:param name: name of the Pod to have proper logging
:param container_name: name to set the Container to
:param net_mode: The network mode where to run the container
:param runtime_ctrl_address: The control address of the runtime in the container
:param envs: Dictionary of environment variables to be set in the docker image
:param is_started: concurrency event to communicate runtime is properly started. Used for better logging
:param is_shutdown: concurrency event to communicate runtime is terminated
:param is_ready: concurrency event to communicate runtime is ready to receive messages
"""
import docker
log_kwargs = copy.deepcopy(vars(args))
log_kwargs['log_config'] = 'docker'
logger = JinaLogger(name, **log_kwargs)
cancel = threading.Event()
fail_to_start = threading.Event()
if not __windows__:
try:
for signame in {signal.SIGINT, signal.SIGTERM}:
signal.signal(signame, lambda *args, **kwargs: cancel.set())
except (ValueError, RuntimeError) as exc:
logger.warning(
f' The process starting the container for {name} will not be able to handle termination signals. '
f' {repr(exc)}')
else:
with ImportExtensions(
required=True,
logger=logger,
help_text=
'''If you see a 'DLL load failed' error, please reinstall `pywin32`.
If you're using conda, please use the command `conda install -c anaconda pywin32`''',
):
import win32api
win32api.SetConsoleCtrlHandler(lambda *args, **kwargs: cancel.set(),
True)
client = docker.from_env()
try:
container = _docker_run(
client=client,
args=args,
container_name=container_name,
envs=envs,
net_mode=net_mode,
logger=logger,
)
client.close()
def _is_ready():
return AsyncNewLoopRuntime.is_ready(runtime_ctrl_address)
def _is_container_alive(container) -> bool:
import docker.errors
try:
container.reload()
except docker.errors.NotFound:
return False
return True
async def _check_readiness(container):
while (_is_container_alive(container) and not _is_ready()
and not cancel.is_set()):
await asyncio.sleep(0.1)
if _is_container_alive(container):
is_started.set()
is_ready.set()
else:
fail_to_start.set()
async def _stream_starting_logs(container):
for line in container.logs(stream=True):
if (not is_started.is_set() and not fail_to_start.is_set()
and not cancel.is_set()):
await asyncio.sleep(0.01)
msg = line.decode().rstrip() # type: str
logger.debug(re.sub(r'\u001b\[.*?[@-~]', '', msg))
async def _run_async(container):
await asyncio.gather(*[
_check_readiness(container),
_stream_starting_logs(container)
])
asyncio.run(_run_async(container))
finally:
client.close()
if not is_started.is_set():
logger.error(
f' Process terminated, the container fails to start, check the arguments or entrypoint'
)
is_shutdown.set()
logger.debug(f'process terminated')
class DaemonWorker(Thread):
"""Worker Thread for JinaD"""
def __init__(self, id: 'DaemonID', files: List[UploadFile], name: str,
*args, **kwargs) -> None:
super().__init__(name=f'{self.__class__.__name__}{name}', daemon=True)
self.id = id
self.files = files
self._logger = JinaLogger(self.name,
workspace_path=self.workdir,
**vars(jinad_args))
self.start()
@cached_property
def arguments(self) -> WorkspaceArguments:
"""sets arguments in workspace store
:return: pydantic model for workspace arguments
"""
try:
_args = store[self.id].arguments.copy(deep=True)
_args.files.extend([f.filename
for f in self.files] if self.files else [])
_args.jinad.update({
'dockerfile': self.daemon_file.dockerfile,
})
_args.requirements = self.daemon_file.requirements
except AttributeError:
_args = WorkspaceArguments(
files=[f.filename for f in self.files] if self.files else [],
jinad={
'dockerfile': self.daemon_file.dockerfile,
},
requirements=self.daemon_file.requirements,
)
return _args
@cached_property
def metadata(self) -> WorkspaceMetadata:
"""sets metadata in workspace store
:return: pydantic model for workspace metadata
"""
image_id = self.generate_image()
try:
_metadata = store[self.id].metadata.copy(deep=True)
_metadata.image_id = image_id
_metadata.image_name = self.id.tag
except AttributeError:
_metadata = WorkspaceMetadata(
image_id=image_id,
image_name=self.id.tag,
network=id_cleaner(self.network_id),
workdir=self.workdir,
)
return _metadata
@cached_property
def workdir(self) -> str:
"""sets workdir for current worker thread
:return: local directory where files would get stored
"""
return get_workspace_path(self.id)
@cached_property
def daemon_file(self) -> DaemonFile:
"""set daemonfile for current worker thread
:return: DaemonFile object representing current workspace
"""
return DaemonFile(workdir=self.workdir, logger=self._logger)
@cached_property
def network_id(self) -> str:
"""create a docker network
:return: network id
"""
return Dockerizer.network(workspace_id=self.id)
def generate_image(self) -> str:
"""build and create a docker image
:return: image id
"""
return Dockerizer.build(
workspace_id=self.id,
daemon_file=self.daemon_file,
logger=JinaLogger(
context=self.name,
# identity=self.id,
workspace_path=self.workdir,
),
)
@cached_property
def container_id(self) -> Optional[str]:
"""creates a container if run command is passed in .jinad file
:return: container id, if created
"""
if self.daemon_file.run:
container, _, _ = Dockerizer.run_custom(
workspace_id=self.id, daemon_file=self.daemon_file)
return id_cleaner(container.id)
else:
return None
def run(self) -> None:
"""
Method representing the worker thread's activity
DaemonWorker is a daemon thread responsible for the following tasks:
During create:
- store uploaded files in a local workspace
- create a docker network for the workspace which would be used by all child containers
- build a docker image to be used by all child containers
- create a container if `run` command is passed
During update:
- update files in the local workspace
- removes the workspace container, if any
- recreate workspace container, if `run` command is passed
"""
try:
store.update(
id=self.id,
value=RemoteWorkspaceState.UPDATING
if store[self.id].arguments else RemoteWorkspaceState.CREATING,
)
store_files_in_workspace(workspace_id=self.id,
files=self.files,
logger=self._logger)
store.update(
id=self.id,
value=WorkspaceItem(
state=RemoteWorkspaceState.UPDATING,
metadata=self.metadata,
arguments=self.arguments,
),
)
# this needs to be done after the initial update, otherwise run won't find the necessary metadata
# If a container exists already, kill it before running again
previous_container = store[self.id].metadata.container_id
if previous_container:
self._logger.info(
f'Deleting previous container {previous_container}')
store[self.id].metadata.container_id = None
del self.container_id
Dockerizer.rm_container(previous_container)
# Create a new container if necessary
store[self.id].metadata.container_id = self.container_id
store[self.id].state = RemoteWorkspaceState.ACTIVE
self._logger.success(
f'workspace {colored(str(self.id), "cyan")} is updated')
except DockerNetworkException as e:
store.update(id=self.id, value=RemoteWorkspaceState.FAILED)
self._logger.error(
f'Error while creating the docker network: {e!r}')
except DockerImageException as e:
store.update(id=self.id, value=RemoteWorkspaceState.FAILED)
self._logger.error(f'Error while building the docker image: {e!r}')
except Exception as e:
# TODO: how to communicate errors to users? users track it via logs?
# TODO: Handle cleanup in case of exception
store.update(id=self.id, value=RemoteWorkspaceState.FAILED)
self._logger.error(f'{e!r}')
class PostgreSQLDBMSHandler:
"""
Postgres Handler to connect to the database and can apply add, update, delete and query.
:param hostname: hostname of the machine
:param port: the port
:param username: the username to authenticate
:param password: the password to authenticate
:param database: the database name
:param collection: the collection name
:param args: other arguments
:param kwargs: other keyword arguments
"""
def __init__(self,
hostname: str = '127.0.0.1',
port: int = 5432,
username: str = 'default_name',
password: str = 'default_pwd',
database: str = 'postgres',
table: Optional[str] = 'default_table',
*args,
**kwargs):
super().__init__(*args, **kwargs)
self.logger = JinaLogger(self.__class__.__name__)
self.hostname = hostname
self.port = port
self.username = username
self.password = password
self.database = database
self.table = table
def __enter__(self):
return self.connect()
def connect(self) -> 'PostgreSQLDBMSHandler':
"""Connect to the database. """
import psycopg2
from psycopg2 import Error
try:
self.connection = psycopg2.connect(user=self.username,
password=self.password,
database=self.database,
host=self.hostname,
port=self.port)
self.cursor = self.connection.cursor()
self.logger.info('Successfully connected to the database')
self.use_table()
self.connection.commit()
except (Exception, Error) as error:
self.logger.error('Error while connecting to PostgreSQL', error)
return self
def use_table(self):
"""
Use table if exists or create one if it doesn't.
Create table if needed with id, vecs and metas.
"""
from psycopg2 import Error
self.cursor.execute(
'select exists(select * from information_schema.tables where table_name=%s)',
(self.table, ))
if self.cursor.fetchone()[0]:
self.logger.info('Using existing table')
else:
try:
self.cursor.execute(f"CREATE TABLE {self.table} ( \
ID VARCHAR PRIMARY KEY, \
VECS BYTEA, \
METAS BYTEA);")
self.logger.info('Successfully created table')
except (Exception, Error) as error:
self.logger.error('Error while creating table!')
def add(self, ids, vecs, metas, *args, **kwargs):
""" Insert the documents into the database.
:param ids: List of doc ids to be added
:param vecs: List of vecs to be added
:param metas: List of metas of docs to be added
:param args: other arguments
:param kwargs: other keyword arguments
:param args: other arguments
:param kwargs: other keyword arguments
:return record: List of Document's id added
"""
row_count = 0
for i in range(len(ids)):
self.cursor.execute(
f'INSERT INTO {self.table} (ID, VECS, METAS) VALUES (%s, %s, %s)',
(ids[i], vecs[i].tobytes(), metas[i]),
)
row_count += self.cursor.rowcount
self.connection.commit()
return row_count
def update(self, ids, vecs, metas, *args, **kwargs):
""" Updated documents from the database.
:param ids: Ids of Doc to be updated
:param vecs: List of vecs to be updated
:param metas: List of metas of docs to be updated
:param args: other arguments
:param kwargs: other keyword arguments
:return record: List of Document's id after update
"""
row_count = 0
for i in range(len(ids)):
self.cursor.execute(
f'UPDATE {self.table} SET VECS = %s, METAS = %s WHERE ID = %s',
(vecs[i].tobytes(), metas[i], ids[i]),
)
row_count += self.cursor.rowcount
self.connection.commit()
return row_count
def delete(self, ids, *args, **kwargs):
""" Delete document from the database.
:param ids: ids of Documents to be removed
:param args: other arguments
:param kwargs: other keyword arguments
:return record: List of Document's id after deletion
"""
row_count = 0
for id in ids:
self.cursor.execute(f'DELETE FROM {self.table} where (ID) = (%s);',
(id, ))
row_count += self.cursor.rowcount
self.connection.commit()
return row_count
def __exit__(self, *args):
""" Make sure the connection to the database is closed."""
from psycopg2 import Error
try:
self.connection.close()
self.cursor.close()
self.logger.info('PostgreSQL connection is closed')
except (Exception, Error) as error:
self.logger.error('Error while closing: ', error)
class MongoDBHandler:
"""
Mongodb Handler to connect to the database & insert documents in the collection
MongoDB has no access control by default, hence can be used without username:password.
If username & password are passed, we need to create it (can be changed to existing un:pw)
"""
def __init__(self,
hostname: str = '127.0.0.1',
port: int = 27017,
username: str = None,
password: str = None,
database: str = 'defaultdb',
collection: str = 'defaultcol'):
self.logger = JinaLogger(self.__class__.__name__)
self.hostname = hostname
self.port = port
self.username = username
self.password = password
self.database_name = database
self.collection_name = collection
if self.username and self.password:
self.connection_string = \
f'mongodb://{self.username}:{self.password}@{self.hostname}:{self.port}'
else:
self.connection_string = \
f'mongodb://{self.hostname}:{self.port}'
def __enter__(self):
return self.connect()
def connect(self) -> 'MongoDBHandler':
import pymongo
try:
self.client = pymongo.MongoClient(self.connection_string)
self.client.admin.command('ismaster')
self.logger.info('Successfully connected to the database')
except pymongo.errors.ConnectionFailure:
raise MongoDBException('Database server is not available')
except pymongo.errors.ConfigurationError:
raise MongoDBException('Credentials passed are not correct!')
except pymongo.errors.PyMongoError as exp:
raise MongoDBException(exp)
except Exception as exp:
raise MongoDBException(exp)
return self
@property
def database(self):
return self.client[self.database_name]
@property
def collection(self):
return self.database[self.collection_name]
def find(self, query: Dict[str, Union[Dict, List]]) -> None:
import pymongo
try:
return self.collection.find(query)
except pymongo.errors.PyMongoError as exp:
self.logger.error(
f'Got an error while finding a document in the db {exp}')
def insert(self, documents: Iterator[Dict]) -> Optional[str]:
import pymongo
try:
result = self.collection.insert_many(documents)
self.logger.debug(f'inserted documents in the database')
return result.inserted_ids
except pymongo.errors.PyMongoError as exp:
self.logger.error(
f'got an error while inserting a document in the db {exp}')
def __exit__(self, exc_type, exc_val, exc_tb):
import pymongo
try:
self.client.close()
except pymongo.errors.PyMongoError as exp:
raise MongoDBException(exp)
class JinaDProcessTarget:
"""Target to be executed on JinaD Process"""
def __call__(
self,
args: 'argparse.Namespace',
is_started: Union['multiprocessing.Event', 'threading.Event'],
is_shutdown: Union['multiprocessing.Event', 'threading.Event'],
is_ready: Union['multiprocessing.Event', 'threading.Event'],
is_cancelled: Union['multiprocessing.Event', 'threading.Event'],
envs: Optional[Dict] = None,
):
"""Method responsible to manage a remote Pod
This method is the target for the Pod's `thread` or `process`
.. note::
Please note that env variables are process-specific. Subprocess inherits envs from
the main process. But Subprocess's envs do NOT affect the main process. It does NOT
mess up user local system envs.
:param args: namespace args from the Pod
:param is_started: concurrency event to communicate runtime is properly started. Used for better logging
:param is_shutdown: concurrency event to communicate runtime is terminated
:param is_ready: concurrency event to communicate runtime is ready to receive messages
:param is_cancelled: concurrency event to receive cancelling signal from the Pod. Needed by some runtimes
:param envs: a dictionary of environment variables to be passed to remote Pod
"""
self.args = args
self.envs = envs
self.is_started = is_started
self.is_shutdown = is_shutdown
self.is_ready = is_ready
self.is_cancelled = is_cancelled
self.pod_id = None
self._logger = JinaLogger('RemotePod', **vars(args))
run_async(self._run)
async def _run(self):
"""Manage a remote Pod"""
try:
await self._create_remote_pod()
except Exception as ex:
self._logger.error(
f'{ex!r} while starting a remote Pod' +
f'\n add "--quiet-error" to suppress the exception details'
if not self.args.quiet_error else '',
exc_info=not self.args.quiet_error,
)
else:
self.is_started.set()
self.is_ready.set()
await self._wait_until_cancelled()
finally:
await self._terminate_remote_pod()
self.is_shutdown.set()
self._logger.debug('JinaDProcessTarget terminated')
async def _create_remote_pod(self):
"""Create Workspace, Pod on remote JinaD server"""
with ImportExtensions(required=True):
# rich & aiohttp are used in `AsyncJinaDClient`
import rich
import aiohttp
from daemon.clients import AsyncJinaDClient
assert rich
assert aiohttp
# NOTE: args.timeout_ready is always set to -1 for JinadRuntime so that wait_for_success doesn't fail in Pod,
# so it can't be used for Client timeout.
self.client = AsyncJinaDClient(host=self.args.host,
port=self.args.port_jinad,
logger=self._logger)
if not await self.client.alive:
raise DaemonConnectivityError
# Create a remote workspace with upload_files
workspace_id = await self.client.workspaces.create(
paths=self.filepaths,
id=self.args.workspace_id,
complete=True,
)
if not workspace_id:
self._logger.critical(f'remote workspace creation failed')
raise DaemonWorkspaceCreationFailed
payload = replace_enum_to_str(vars(self._mask_args()))
# Create a remote Pod in the above workspace
success, response = await self.client.pods.create(
workspace_id=workspace_id, payload=payload, envs=self.envs)
if not success:
self._logger.critical(f'remote pod creation failed')
raise DaemonPodCreationFailed(response)
else:
self.pod_id = response
async def _sleep_forever(self):
"""Sleep forever, no prince will come."""
await asyncio.sleep(1e10)
async def _wait_until_cancelled(self):
while not self.is_cancelled.is_set():
await asyncio.sleep(0.1)
async def _terminate_remote_pod(self):
"""Removes the remote Pod"""
if self.pod_id is not None:
if await self.client.pods.delete(id=self.pod_id):
self._logger.success(
f'Successfully terminated remote Pod {self.pod_id}')
# Don't delete workspace here, as other Executors might use them.
# TODO(Deepankar): probably enable an arg here?
@property
def filepaths(self) -> List[Path]:
"""Get file/directories to be uploaded to remote workspace
:return: filepaths to be uploaded to remote
"""
paths = set()
if not self.args.upload_files:
self._logger.warning(f'no files passed to upload to remote')
else:
for path in self.args.upload_files:
try:
fullpath = Path(complete_path(path))
paths.add(fullpath)
except FileNotFoundError:
self._logger.error(f'invalid path {path} passed')
return list(paths)
def _mask_args(self):
cargs = copy.deepcopy(self.args)
# TODO:/NOTE this prevents jumping from remote to another remote (Han: 2021.1.17)
# _args.host = __default_host__
# host resetting disables dynamic routing. Use `disable_remote` instead
cargs.disable_remote = True
cargs.log_config = '' # do not use local log_config
cargs.upload_files = [] # reset upload files
cargs.noblock_on_start = False # wait until start success
changes = []
for k, v in vars(cargs).items():
if v != getattr(self.args, k):
changes.append(
f'{k:>30s}: {str(getattr(self.args, k)):30s} -> {str(v):30s}'
)
if changes:
changes = [
'note the following arguments have been masked or altered for remote purpose:'
] + changes
self._logger.debug('\n'.join(changes))
return cargs
def run(
args: 'argparse.Namespace',
name: str,
runtime_cls: Type[AsyncNewLoopRuntime],
envs: Dict[str, str],
is_started: Union['multiprocessing.Event', 'threading.Event'],
is_shutdown: Union['multiprocessing.Event', 'threading.Event'],
is_ready: Union['multiprocessing.Event', 'threading.Event'],
cancel_event: Union['multiprocessing.Event', 'threading.Event'],
jaml_classes: Optional[Dict] = None,
):
"""Method representing the :class:`BaseRuntime` activity.
This method is the target for the Pod's `thread` or `process`
.. note::
:meth:`run` is running in subprocess/thread, the exception can not be propagated to the main process.
Hence, please do not raise any exception here.
.. note::
Please note that env variables are process-specific. Subprocess inherits envs from
the main process. But Subprocess's envs do NOT affect the main process. It does NOT
mess up user local system envs.
.. warning::
If you are using ``thread`` as backend, envs setting will likely be overidden by others
.. note::
`jaml_classes` contains all the :class:`JAMLCompatible` classes registered in the main process.
When using `spawn` as the multiprocessing start method, passing this argument to `run` method re-imports
& re-registers all `JAMLCompatible` classes.
:param args: namespace args from the Pod
:param name: name of the Pod to have proper logging
:param runtime_cls: the runtime class to instantiate
:param envs: a dictionary of environment variables to be set in the new Process
:param is_started: concurrency event to communicate runtime is properly started. Used for better logging
:param is_shutdown: concurrency event to communicate runtime is terminated
:param is_ready: concurrency event to communicate runtime is ready to receive messages
:param cancel_event: concurrency event to receive cancelling signal from the Pod. Needed by some runtimes
:param jaml_classes: all the `JAMLCompatible` classes imported in main process
"""
logger = JinaLogger(name, **vars(args))
def _unset_envs():
if envs and args.runtime_backend != RuntimeBackendType.THREAD:
for k in envs.keys():
os.environ.pop(k, None)
def _set_envs():
if args.env:
if args.runtime_backend == RuntimeBackendType.THREAD:
logger.warning(
'environment variables should not be set when runtime="thread".'
)
else:
os.environ.update({k: str(v) for k, v in envs.items()})
try:
_set_envs()
runtime = runtime_cls(
args=args,
cancel_event=cancel_event,
)
except Exception as ex:
logger.error(
f'{ex!r} during {runtime_cls!r} initialization' +
f'\n add "--quiet-error" to suppress the exception details'
if not args.quiet_error else '',
exc_info=not args.quiet_error,
)
else:
if not is_shutdown.is_set():
is_started.set()
with runtime:
is_ready.set()
runtime.run_forever()
finally:
_unset_envs()
is_shutdown.set()
logger.debug(f' Process terminated')
class BasePod(ABC):
"""
:class:`BasePod` is an interface from which all the classes managing the lifetime of a Runtime inside a local process,
container or in a remote JinaD instance (to come) must inherit.
It exposes the required APIs so that the `BasePod` can be handled by the `cli` api as a context manager or by a `Deployment`.
What makes a BasePod a BasePod is that it manages the lifecycle of a Runtime (gateway or not gateway)
"""
def __init__(self, args: 'argparse.Namespace'):
self.args = args
if hasattr(self.args, 'port_expose'):
self.args.port_in = self.args.port_expose
self.args.parallel = self.args.shards
self.name = self.args.name or self.__class__.__name__
self.is_forked = False
self.logger = JinaLogger(self.name, **vars(self.args))
if self.args.runtime_backend == RuntimeBackendType.THREAD:
self.logger.warning(
f' Using Thread as runtime backend is not recommended for production purposes. It is '
f'just supposed to be used for easier debugging. Besides the performance considerations, it is'
f'specially dangerous to mix `Executors` running in different types of `RuntimeBackends`.'
)
self._envs = {'JINA_DEPLOYMENT_NAME': self.name}
if self.args.quiet:
self._envs['JINA_LOG_CONFIG'] = 'QUIET'
if self.args.env:
self._envs.update(self.args.env)
# arguments needed to create `runtime` and communicate with it in the `run` in the stack of the new process
# or thread.f
test_worker = {
RuntimeBackendType.THREAD: threading.Thread,
RuntimeBackendType.PROCESS: multiprocessing.Process,
}.get(getattr(args, 'runtime_backend', RuntimeBackendType.THREAD))()
self.is_ready = _get_event(test_worker)
self.is_shutdown = _get_event(test_worker)
self.cancel_event = _get_event(test_worker)
self.is_started = _get_event(test_worker)
self.ready_or_shutdown = ConditionalEvent(
getattr(args, 'runtime_backend', RuntimeBackendType.THREAD),
events_list=[self.is_ready, self.is_shutdown],
)
self.daemon = self.args.daemon
self.runtime_ctrl_address = self._get_control_address()
self._timeout_ctrl = self.args.timeout_ctrl
def _get_control_address(self):
return f'{self.args.host}:{self.args.port_in}'
def close(self) -> None:
"""Close the Pod
This method makes sure that the `Process/thread` is properly finished and its resources properly released
"""
self.logger.debug('waiting for ready or shutdown signal from runtime')
if not self.is_shutdown.is_set() and self.is_started.is_set():
try:
self.logger.debug(f'terminate')
self._terminate()
if not self.is_shutdown.wait(timeout=self._timeout_ctrl
if not __windows__ else 1.0):
if not __windows__:
raise Exception(
f'Shutdown signal was not received for {self._timeout_ctrl} seconds'
)
else:
self.logger.warning(
'Pod was forced to close after 1 second. Graceful closing is not available on Windows.'
)
except Exception as ex:
self.logger.error(
f'{ex!r} during {self.close!r}' +
f'\n add "--quiet-error" to suppress the exception details'
if not self.args.quiet_error else '',
exc_info=not self.args.quiet_error,
)
else:
# here shutdown has been set already, therefore `run` will gracefully finish
self.logger.debug(
f'{"shutdown is is already set" if self.is_shutdown.is_set() else "Runtime was never started"}. Runtime will end gracefully on its own'
)
pass
self.is_shutdown.set()
self.logger.debug(__stop_msg__)
self.logger.close()
def __enter__(self):
return self.start()
def __exit__(self, exc_type, exc_val, exc_tb):
self.close()
def _wait_for_ready_or_shutdown(self, timeout: Optional[float]):
"""
Waits for the process to be ready or to know it has failed.
:param timeout: The time to wait before readiness or failure is determined
.. # noqa: DAR201
"""
return AsyncNewLoopRuntime.wait_for_ready_or_shutdown(
timeout=timeout,
ready_or_shutdown_event=self.ready_or_shutdown.event,
ctrl_address=self.runtime_ctrl_address,
timeout_ctrl=self._timeout_ctrl,
)
def _fail_start_timeout(self, timeout):
"""
Closes the Pod and raises a TimeoutError with the corresponding warning messages
:param timeout: The time to wait before readiness or failure is determined
.. # noqa: DAR201
"""
_timeout = timeout or -1
self.logger.warning(
f'{self} timeout after waiting for {self.args.timeout_ready}ms, '
f'if your executor takes time to load, you may increase --timeout-ready'
)
self.close()
raise TimeoutError(
f'{typename(self)}:{self.name} can not be initialized after {_timeout * 1e3}ms'
)
def _check_failed_to_start(self):
"""
Raises a corresponding exception if failed to start
"""
if self.is_shutdown.is_set():
# return too early and the shutdown is set, means something fails!!
if not self.is_started.is_set():
raise RuntimeFailToStart
else:
raise RuntimeRunForeverEarlyError
def wait_start_success(self):
"""Block until all pods starts successfully.
If not success, it will raise an error hoping the outer function to catch it
"""
_timeout = self.args.timeout_ready
if _timeout <= 0:
_timeout = None
else:
_timeout /= 1e3
if self._wait_for_ready_or_shutdown(_timeout):
self._check_failed_to_start()
self.logger.debug(__ready_msg__)
else:
self._fail_start_timeout(_timeout)
async def async_wait_start_success(self):
"""
Wait for the `Pod` to start successfully in a non-blocking manner
"""
import asyncio
_timeout = self.args.timeout_ready
if _timeout <= 0:
_timeout = None
else:
_timeout /= 1e3
timeout_ns = 1e9 * _timeout if _timeout else None
now = time.time_ns()
while timeout_ns is None or time.time_ns() - now < timeout_ns:
if self.ready_or_shutdown.event.is_set():
self._check_failed_to_start()
self.logger.debug(__ready_msg__)
return
else:
await asyncio.sleep(0.1)
self._fail_start_timeout(_timeout)
@property
def role(self) -> 'PodRoleType':
"""Get the role of this pod in a deployment
.. #noqa: DAR201"""
return self.args.pod_role
@abstractmethod
def start(self):
"""Start the BasePod.
This method calls :meth:`start` in :class:`threading.Thread` or :class:`multiprocesssing.Process`.
.. #noqa: DAR201
"""
...
@abstractmethod
def _terminate(self):
...
@abstractmethod
def join(self, *args, **kwargs):
"""Joins the BasePod. Wait for the BasePod to properly terminate
:param args: extra positional arguments
:param kwargs: extra keyword arguments
"""
...
