from g1 import scripts
from g1.bases import argparses
from g1.bases import oses
from g1.bases.assertions import ASSERT
from . import alerts
from . import bases
from . import envs
from . import pod_ops_dirs
from . import tokens
from . import xar_ops_dirs
@argparses.begin_parser(
'init',
**argparses.make_help_kwargs('initialize operations repository'),
)
@argparses.argument(
'--bootstrap',
action=argparses.StoreBoolAction,
default=False,
help='enable bootstrap mode (default: %(default_string)s)',
)
@argparses.end
def cmd_init(args):
oses.assert_root_privilege()
# Check pod and XAR dependencies.
if not args.bootstrap:
scripts.assert_command_exist('ctr')
scripts.assert_command_exist('systemctl')
from g1.apps import bases as apps_bases
from g1.bases import argparses
from g1.bases.assertions import ASSERT
from g1.texts import columns
from g1.texts.columns import argparses as columns_argparses
from . import bases
from . import builders
from . import images
from . import models
from . import pods
from . import xars
@argparses.begin_parser(
'images', **argparses.make_help_kwargs('manage container images')
)
@argparses.begin_subparsers_for_subcmds(dest='command')
@argparses.include(builders.cmd_build_base_image)
@argparses.include(builders.cmd_prepare_base_rootfs)
@argparses.include(builders.cmd_setup_base_rootfs)
@argparses.include(images.cmd_build_image)
@argparses.include(images.cmd_import)
@argparses.include(images.cmd_list)
@argparses.include(images.cmd_tag)
@argparses.include(images.cmd_remove_tag)
@argparses.include(images.cmd_remove)
@argparses.include(images.cmd_cleanup)
@argparses.end
@argparses.end
def cmd_images(args):
'version',
'id',
'name',
'active',
)
_POD_LIST_STRINGIFIERS = {
'auto-start': bool_to_str,
'auto-stop': bool_to_str,
'enabled': bool_to_str,
'active': bool_to_str,
}
ASSERT.issuperset(_POD_LIST_COLUMNS, _POD_LIST_DEFAULT_COLUMNS)
ASSERT.issuperset(_POD_LIST_COLUMNS, _POD_LIST_STRINGIFIERS)
@argparses.begin_parser('list', **argparses.make_help_kwargs('list pods'))
@columns_argparses.columnar_arguments(
_POD_LIST_COLUMNS, _POD_LIST_DEFAULT_COLUMNS
)
@argparses.end
def cmd_list(args):
columnar = columns.Columnar(
**columns_argparses.make_columnar_kwargs(args),
stringifiers=_POD_LIST_STRINGIFIERS,
)
with pod_ops_dirs.make_ops_dirs().listing_ops_dirs() as active_ops_dirs:
for ops_dir in active_ops_dirs:
for config in ops_dir.metadata.systemd_unit_configs:
columnar.append({
'label': ops_dir.label,
'version': ops_dir.version,
'version',
'zipapp',
))
_XAR_LIST_DEFAULT_COLUMNS = (
'label',
'version',
'zipapp',
)
_XAR_LIST_STRINGIFIERS = {
'zipapp': lambda active: 'true' if active else 'false',
}
ASSERT.issuperset(_XAR_LIST_COLUMNS, _XAR_LIST_DEFAULT_COLUMNS)
ASSERT.issuperset(_XAR_LIST_COLUMNS, _XAR_LIST_STRINGIFIERS)
@argparses.begin_parser('list', **argparses.make_help_kwargs('list xars'))
@columns_argparses.columnar_arguments(_XAR_LIST_COLUMNS,
_XAR_LIST_DEFAULT_COLUMNS)
@argparses.end
def cmd_list(args):
columnar = columns.Columnar(
**columns_argparses.make_columnar_kwargs(args),
stringifiers=_XAR_LIST_STRINGIFIERS,
)
with xar_ops_dirs.make_ops_dirs().listing_ops_dirs() as active_ops_dirs:
for ops_dir in active_ops_dirs:
columnar.append({
'label': ops_dir.label,
'version': ops_dir.version,
'zipapp': ops_dir.metadata.is_zipapp(),
})
from . import models
_ENV_LIST_COLUMNS = frozenset((
'name',
'value',
))
_ENV_LIST_DEFAULT_COLUMNS = (
'name',
'value',
)
ASSERT.issuperset(_ENV_LIST_COLUMNS, _ENV_LIST_DEFAULT_COLUMNS)
@argparses.begin_parser(
'list',
**argparses.make_help_kwargs('list environment variables'),
)
@columns_argparses.columnar_arguments(_ENV_LIST_COLUMNS,
_ENV_LIST_DEFAULT_COLUMNS)
@argparses.end
def cmd_list(args):
columnar = columns.Columnar(**columns_argparses.make_columnar_kwargs(args))
for name, value in envs.load().items():
columnar.append({'name': name, 'value': value})
columnar.output(sys.stdout)
return 0
@argparses.begin_parser(
'set',
**argparses.make_help_kwargs('create or update an environment variable'),
))
_DEFINITION_LIST_DEFAULT_COLUMNS = (
'token-name',
'range',
'values',
)
_DEFINITION_LIST_STRINGIFIERS = {
'range': lambda args: ' '.join(map(str, args)),
'values': ' '.join,
}
ASSERT.issuperset(_DEFINITION_LIST_COLUMNS, _DEFINITION_LIST_DEFAULT_COLUMNS)
ASSERT.issuperset(_DEFINITION_LIST_COLUMNS, _DEFINITION_LIST_STRINGIFIERS)
@argparses.begin_parser('list-definitions',
**argparses.make_help_kwargs('list token definitions'))
@columns_argparses.columnar_arguments(_DEFINITION_LIST_COLUMNS,
_DEFINITION_LIST_DEFAULT_COLUMNS)
@argparses.end
def cmd_list_definitions(args):
columnar = columns.Columnar(
**columns_argparses.make_columnar_kwargs(args),
stringifiers=_DEFINITION_LIST_STRINGIFIERS,
)
for token_name, definition in (
tokens.make_tokens_database().get().definitions.items()):
if definition.kind == 'range':
columnar.append({
'token-name': token_name,
'range': definition.args,
'values': (),
select_label_argument = argparses.argument(
'label',
type=foreman.Label.parse,
help='provide pod label',
)
select_version_argument = argparses.argument(
'version',
help='provide build artifact version',
)
@argparses.begin_parser(
'build',
**argparses.make_help_kwargs('build pod or image'),
)
@argparses.argument(
'--also-release',
action=argparses.StoreBoolAction,
default=True,
help='also set pod release version (default: %(default_string)s)',
)
@select_env_argument
@argparses.argument(
'--args-file',
type=Path,
action='append',
required=True,
help='add json file of foreman build command-line arguments',
)
'name',
'version',
'active',
'last-updated',
'ref-count',
)
POD_LIST_STRINGIFIERS = {
'images': ' '.join,
'active': lambda active: 'true' if active else 'false',
'last-updated': _stringify_last_updated,
}
ASSERT.issuperset(_POD_LIST_COLUMNS, _POD_LIST_DEFAULT_COLUMNS)
ASSERT.issuperset(_POD_LIST_COLUMNS, POD_LIST_STRINGIFIERS)
@argparses.begin_parser('list', **argparses.make_help_kwargs('list pods'))
@columns_argparses.columnar_arguments(
_POD_LIST_COLUMNS, _POD_LIST_DEFAULT_COLUMNS
)
@argparses.end
def cmd_list():
# Don't need root privilege here.
with locks.acquiring_shared(_get_active_path()):
for pod_dir_path, config in _iter_configs():
pod_status = _get_pod_status(pod_dir_path, config)
yield {
'id': _get_id(pod_dir_path),
'name': config.name,
'version': config.version,
# Use _iter_image_ids rather than _iter_ref_image_ids
# for ordered results.
import os
import sys
from pathlib import Path
from g1.bases import argparses
from g1.bases import datetimes
from g1.bases import oses
from g1.bases.assertions import ASSERT
from g1.containers import models as ctr_models
from . import alerts
@argparses.begin_parser(
'set-config',
**argparses.make_help_kwargs('copy config file'),
)
@argparses.argument(
'path',
type=Path,
help='provide path to config file to be copied from',
)
@argparses.end
def cmd_set_config(args):
oses.assert_root_privilege()
alerts.save(alerts.load(args.path))
return 0
@argparses.begin_parser(
'send',
#
_select_xar_arguments = argparses.argument('name',
type=models.validate_xar_name,
help='provide xar name')
def cmd_init():
oses.assert_root_privilege()
ASSERT.predicate(_get_xar_runner_script_dir_path(), Path.is_dir)
bases.make_dir(_get_xars_repo_path(), 0o750, bases.chown_app)
@argparses.begin_parser(
'install',
**argparses.make_help_kwargs('install an image to xar repository'),
)
@images.select_image_arguments
@_select_xar_arguments
@argparses.argument('exec',
type=Path,
help='provide executable path, relative to image root')
@argparses.end
def cmd_install(
*,
image_id=None,
name=None,
version=None,
tag=None,
xar_name,
exec_relpath,
import logging
import foreman
from g1.bases import argparses
from g1.bases.assertions import ASSERT
from . import repos
LOG = logging.getLogger(__name__)
@argparses.begin_parser(
'cleanup',
**argparses.make_help_kwargs('clean up build artifacts'),
)
@argparses.argument(
'--also-base',
action=argparses.StoreBoolAction,
default=False,
help=('also clean up the base image - '
'you mostly should set this to false because you usually need '
'the base image even when no pod refers to it temporarily '
'(default: %(default_string)s)'),
)
@argparses.argument(
'--also-builder',
action=argparses.StoreBoolAction,
default=False,
help=('also clean up builder images - '
from . import models
LOG = logging.getLogger(__name__)
def cmd_init():
scripts.check_command_exist('debootstrap')
#
# Base image.
#
@argparses.begin_parser(
'build-base', **argparses.make_help_kwargs('build a base image')
)
@argparses.argument(
'--prune-stash-path',
metavar='PATH',
type=Path,
help='provide path to stash pruned files',
)
@images.image_output_arguments
@argparses.end
def cmd_build_base_image(name, version, base_image_path, prune_stash_path):
oses.assert_root_privilege()
LOG.info('create base image: %s', base_image_path)
images.build_image(
images.ImageMetadata(name=name, version=version),
lambda dst_path: _create_image_rootfs(dst_path, prune_stash_path),
def cmd_init():
"""Initialize the image repository."""
# For _extract_image.
scripts.assert_command_exist('tar')
# For build_image.
scripts.check_command_exist('tar')
oses.assert_root_privilege()
bases.make_dir(_get_image_repo_path(), 0o750, bases.chown_app)
bases.make_dir(_get_tags_path(), 0o750, bases.chown_app)
bases.make_dir(_get_tmp_path(), 0o750, bases.chown_app)
bases.make_dir(get_trees_path(), 0o750, bases.chown_app)
@argparses.begin_parser('build', **argparses.make_help_kwargs('build image'))
@argparses.argument(
'--rootfs',
type=Path,
required=True,
help='provide rootfs path',
)
@image_output_arguments
@argparses.end
def cmd_build_image(name, version, rootfs_path, output_path):
# Although root privilege is not required, most likely you need it
# to finish this.
ASSERT.predicate(rootfs_path, Path.is_dir)
build_image(
ImageMetadata(name=name, version=version),
lambda dst_path: bases.rsync_copy(rootfs_path, dst_path),
