def rpm_archive_with_custom_units(module_tmpdir, project):
unit_template = '''
[Unit]
Description=Tarantool service: ${name}
SIMPLE_UNIT_TEMPLATE
[Service]
Type=simple
ExecStart=${dir}/tarantool ${dir}/init.lua
Environment=TARANTOOL_WORK_DIR=${workdir}
Environment=TARANTOOL_CONSOLE_SOCK=/var/run/tarantool/${name}.control
Environment=TARANTOOL_PID_FILE=/var/run/tarantool/${name}.pid
Environment=TARANTOOL_INSTANCE_NAME=${name}
[Install]
WantedBy=multi-user.target
Alias=${name}
'''
instantiated_unit_template = '''
[Unit]
Description=Tarantool service: ${name} %i
INSTANTIATED_UNIT_TEMPLATE
[Service]
Type=simple
ExecStartPre=mkdir -p ${workdir}.%i
ExecStart=${dir}/tarantool ${dir}/init.lua
Environment=TARANTOOL_WORK_DIR=${workdir}.%i
Environment=TARANTOOL_CONSOLE_SOCK=/var/run/tarantool/${name}.%i.control
Environment=TARANTOOL_PID_FILE=/var/run/tarantool/${name}.%i.pid
Environment=TARANTOOL_INSTANCE_NAME=${name}@%i
[Install]
WantedBy=multi-user.target
Alias=${name}
'''
unit_template_filepath = os.path.join(module_tmpdir, "unit_template.tmpl")
with open(unit_template_filepath, 'w') as f:
f.write(unit_template)
inst_unit_template_filepath = os.path.join(
module_tmpdir, "instantiated_unit_template.tmpl")
with open(inst_unit_template_filepath, 'w') as f:
f.write(instantiated_unit_template)
process = subprocess.run([
os.path.join(basepath, "cartridge"), "pack", "rpm", "--unit_template",
"unit_template.tmpl", "--instantiated_unit_template",
"instantiated_unit_template.tmpl", project['path']
],
cwd=module_tmpdir)
assert process.returncode == 0, \
"Error during creating of rpm archive with project"
archive_name = find_archive(module_tmpdir, project['name'], 'rpm')
assert archive_name is not None, "RPM archive isn't found in work directory"
return {'name': archive_name}
def deb_archive(module_tmpdir, project):
cmd = [os.path.join(basepath, "cartridge"), "pack", "deb", project['path']]
process = subprocess.run(cmd, cwd=module_tmpdir)
assert process.returncode == 0, \
"Error during creating of deb archive with project"
archive_name = find_archive(module_tmpdir, project['name'], 'deb')
assert archive_name is not None, "DEB archive isn't found in work directory"
return {'name': archive_name}
def deb_archive_with_cartridge(cartridge_cmd, tmpdir, project_with_cartridge):
project = project_with_cartridge
pre_install_filepath = os.path.join(tmpdir, "pre.sh")
with open(pre_install_filepath, "w") as f:
f.write("""
/bin/sh -c 'touch $HOME/hello-bin-sh.txt'
/bin/touch $HOME/hello-absolute.txt
""")
post_install_filepath = os.path.join(tmpdir, "post.sh")
with open(post_install_filepath, "w") as f:
f.write("""
/bin/sh -c 'touch $HOME/bye-bin-sh.txt'
/bin/touch $HOME/bye-absolute.txt
""")
deps_filepath = os.path.join(tmpdir, "deps.txt")
with open(deps_filepath, "w") as f:
f.write("unzip>1,<=7\n" +
"stress\n" +
"neofetch < 25")
net_msg_max = 1024
user_param = 'user_data'
systemd_unit_params = os.path.join(tmpdir, "systemd-unit-params.yml")
with open(systemd_unit_params, "w") as f:
yaml.dump({
"instance-env": {"net-msg-max": net_msg_max, "user-param": user_param}
}, f)
replace_project_file(project, 'init.lua', INIT_CHECK_PASSED_PARAMS)
replace_project_file(project, 'stateboard.init.lua', INIT_CHECK_PASSED_PARAMS)
cmd = [
cartridge_cmd,
"pack", "deb",
"--deps-file", deps_filepath,
"--preinst", pre_install_filepath,
"--postinst", post_install_filepath,
"--unit-params-file", systemd_unit_params,
project.path,
"--use-docker",
]
process = subprocess.run(cmd, cwd=tmpdir)
assert process.returncode == 0, \
"Error during creating of deb archive with project"
filepath = find_archive(tmpdir, project.name, 'deb')
assert filepath is not None, "DEB archive isn't found in work directory"
return Archive(filepath=filepath, project=project)
def test_packing_without_path_specifying(project_without_dependencies, tmpdir):
project = project_without_dependencies
# say `cartridge pack rpm` in project directory
cmd = [
os.path.join(basepath, "cartridge"),
"pack", "rpm",
]
process = subprocess.run(cmd, cwd=project.path)
assert process.returncode == 0, 'Packing application failed'
filepath = find_archive(project.path, project.name, 'rpm')
assert filepath is not None, 'Package not found'
def test_custom_unit_files(cartridge_cmd, project_without_dependencies, tmpdir,
unit, pack_format):
project = project_without_dependencies
files_by_units = {
'unit': "%s.service" % project.name,
'instantiated-unit': "%[email protected]" % project.name,
'stateboard-unit': "%s-stateboard.service" % project.name,
}
CUSTOM_UNIT_TEMPLATE = "CUSTOM UNIT"
unit_template_filepath = os.path.join(tmpdir, "systemd-unit-template")
with open(unit_template_filepath, 'w') as f:
f.write(CUSTOM_UNIT_TEMPLATE)
# pass non-existent path
cmd = [
cartridge_cmd, "pack", pack_format,
"--%s-template" % unit, "non-existent-path", project.path
]
if platform.system() == 'Darwin':
cmd.append('--use-docker')
rc, output = run_command_and_get_output(cmd, cwd=tmpdir)
assert rc == 1
assert re.search(r'Failed to read specified .*unit template',
output) is not None
# pass correct path
cmd = [
cartridge_cmd, "pack", pack_format,
"--%s-template" % unit, unit_template_filepath, project.path
]
if platform.system() == 'Darwin':
cmd.append('--use-docker')
process = subprocess.run(cmd, cwd=tmpdir)
assert process.returncode == 0
# extract files from archive
archive_path = find_archive(tmpdir, project.name, pack_format)
extract_dir = os.path.join(tmpdir, 'extract')
extract_app_files(archive_path, pack_format, extract_dir)
filename = files_by_units[unit]
filepath = os.path.join(extract_dir, 'etc/systemd/system', filename)
with open(filepath) as f:
assert f.read() == CUSTOM_UNIT_TEMPLATE
def tgz_archive_with_cartridge(cartridge_cmd, tmpdir,
original_project_with_cartridge, request):
project = original_project_with_cartridge
cmd = [cartridge_cmd, "pack", "tgz", "--use-docker", project.path]
process = subprocess.run(cmd, cwd=tmpdir)
assert process.returncode == 0, \
"Error during creating of tgz archive with project"
filepath = find_archive(tmpdir, project.name, 'tar.gz')
assert filepath is not None, "TGZ archive isn't found in work directory"
return Archive(filepath=filepath, project=project)
def test_project_without_stateboard(cartridge_cmd,
project_without_dependencies, pack_format,
tmpdir):
project = project_without_dependencies
STATEBOARD_ENTRYPOINT_NAME = 'stateboard.init.lua'
# remove stateboard entrypoint from project
os.remove(os.path.join(project.path, STATEBOARD_ENTRYPOINT_NAME))
project.distribution_files.remove(STATEBOARD_ENTRYPOINT_NAME)
cmd = [
cartridge_cmd,
"pack",
pack_format,
project.path,
]
# call cartridge pack
process = subprocess.run(cmd, cwd=tmpdir)
assert process.returncode == 0
# packing should succeed with warning
rc, output = run_command_and_get_output(cmd, cwd=tmpdir)
assert rc == 0
assert "App directory doesn't contain stateboard entrypoint script" in output
# extract files from archive
archive_path = find_archive(tmpdir, project.name, pack_format)
extract_dir = os.path.join(tmpdir, 'extract')
os.makedirs(extract_dir)
if pack_format == 'rpm':
extract_rpm(archive_path, extract_dir)
elif pack_format == 'deb':
extract_deb(archive_path, extract_dir)
with tarfile.open(
name=os.path.join(extract_dir, 'data.tar.xz')) as data_arch:
data_arch.extractall(path=extract_dir)
# check that stateboard unit file wasn't delivered
systemd_dir = (os.path.join(extract_dir, 'etc/systemd/system'))
assert os.path.exists(systemd_dir)
systemd_files = recursive_listdir(systemd_dir)
assert len(systemd_files) == 2
assert '{}-stateboard.service'.format(project.name) not in systemd_files
def tgz_archive(cartridge_cmd, tmpdir, light_project, request):
project = light_project
cmd = [cartridge_cmd, "pack", "tgz", project.path]
if request.param == 'docker':
cmd.append('--use-docker')
process = subprocess.run(cmd, cwd=tmpdir)
assert process.returncode == 0, \
"Error during creating of tgz archive with project"
filepath = find_archive(tmpdir, project.name, 'tar.gz')
assert filepath is not None, "TGZ archive isn't found in work directory"
return Archive(filepath=filepath, project=project)
def deb_archive(tmpdir, light_project, request):
project = light_project
cmd = [os.path.join(basepath, "cartridge"), "pack", "deb", project.path]
if request.param == 'docker':
cmd.append('--use-docker')
process = subprocess.run(cmd, cwd=tmpdir)
assert process.returncode == 0, \
"Error during creating of deb archive with project"
filepath = find_archive(tmpdir, project.name, 'deb')
assert filepath is not None, "DEB archive isn't found in work directory"
return Archive(filepath=filepath, project=project)
def deb_archive_with_cartridge(cartridge_cmd, tmpdir,
original_project_with_cartridge, request):
project = original_project_with_cartridge
cmd = [cartridge_cmd, "pack", "deb", project.path]
if platform.system() == 'Darwin':
cmd.append("--use-docker")
process = subprocess.run(cmd, cwd=tmpdir)
assert process.returncode == 0, \
"Error during creating of deb archive with project"
filepath = find_archive(tmpdir, project.name, 'deb')
assert filepath is not None, "DEB archive isn't found in work directory"
return Archive(filepath=filepath, project=project)
def deb_archive(cartridge_cmd, tmpdir, light_project, request):
project = light_project
cmd = [cartridge_cmd, "pack", "deb", project.path]
if request.param == 'docker':
if project.deprecated_flow_is_used:
pytest.skip()
cmd.append('--use-docker')
process = subprocess.run(cmd, cwd=tmpdir)
assert process.returncode == 0, \
"Error during creating of deb archive with project"
filepath = find_archive(tmpdir, project.name, 'deb')
assert filepath is not None, "DEB archive isn't found in work directory"
return Archive(filepath=filepath, project=project)
def test_project_without_stateboard(cartridge_cmd,
project_without_dependencies, pack_format,
tmpdir):
project = project_without_dependencies
STATEBOARD_ENTRYPOINT_NAME = 'stateboard.init.lua'
# remove stateboard entrypoint from project
os.remove(os.path.join(project.path, STATEBOARD_ENTRYPOINT_NAME))
project.distribution_files.remove(STATEBOARD_ENTRYPOINT_NAME)
cmd = [
cartridge_cmd,
"pack",
pack_format,
project.path,
]
if platform.system() == 'Darwin':
cmd.append('--use-docker')
# call cartridge pack
process = subprocess.run(cmd, cwd=tmpdir)
assert process.returncode == 0
# packing should succeed with warning
rc, output = run_command_and_get_output(cmd, cwd=tmpdir)
assert rc == 0
assert "App directory doesn't contain stateboard entrypoint script" in output
# extract files from archive
archive_path = find_archive(tmpdir, project.name, pack_format)
extract_dir = os.path.join(tmpdir, 'extract')
extract_app_files(archive_path, pack_format, extract_dir)
# check that stateboard unit file wasn't delivered
systemd_dir = (os.path.join(extract_dir, 'etc/systemd/system'))
assert os.path.exists(systemd_dir)
systemd_files = recursive_listdir(systemd_dir)
assert len(systemd_files) == 2
assert '{}-stateboard.service'.format(project.name) not in systemd_files
def rpm_archive(tmpdir, light_project, request):
project = light_project
cmd = [os.path.join(basepath, "cartridge"), "pack", "rpm", project.path]
if request.param == 'docker':
if project.deprecated_flow_is_used:
pytest.skip()
cmd.append('--use-docker')
process = subprocess.run(cmd, cwd=tmpdir)
assert process.returncode == 0, \
"Error during creating of rpm archive with project"
filepath = find_archive(tmpdir, project.name, 'rpm')
assert filepath is not None, "RPM archive isn't found in work directory"
return Archive(filepath=filepath, project=project)
def rpm_archive_with_cartridge(cartridge_cmd, tmpdir, project_with_cartridge):
project = project_with_cartridge
pre_install_filepath = os.path.join(tmpdir, "pre.sh")
with open(pre_install_filepath, "w") as f:
f.write("""
/bin/sh -c 'touch $HOME/hello-bin-sh.txt'
/bin/touch $HOME/hello-absolute.txt
""")
post_install_filepath = os.path.join(tmpdir, "post.sh")
with open(post_install_filepath, "w") as f:
f.write("""
/bin/sh -c 'touch $HOME/bye-bin-sh.txt'
/bin/touch $HOME/bye-absolute.txt
""")
cmd = [
cartridge_cmd,
"pack",
"rpm",
"--deps",
"unzip>1,unzip<=7",
"--deps",
"wget",
"--deps",
"make>0.1.0",
"--preinst",
pre_install_filepath,
"--postinst",
post_install_filepath,
project.path,
"--use-docker",
]
process = subprocess.run(cmd, cwd=tmpdir)
assert process.returncode == 0, \
"Error during creating of rpm archive with project"
filepath = find_archive(tmpdir, project.name, 'rpm')
assert filepath is not None, "RPM archive isn't found in work directory"
return Archive(filepath=filepath, project=project)
def deb_archive(cartridge_cmd, tmpdir, light_project, request):
project = light_project
cmd = [cartridge_cmd, "pack", "deb", project.path]
if request.param == 'docker':
cmd.append('--use-docker')
rc, output = run_command_and_get_output(cmd, cwd=tmpdir)
if request.param == 'local' and platform.system() == 'Darwin':
assert rc == 1
assert "It's not possible to pack application into RPM or DEB on non-linux OS" in output
pytest.skip("Packing RPM and DEB locally should fail for Darwin")
assert rc == 0
filepath = find_archive(tmpdir, project.name, 'deb')
assert filepath is not None, "DEB archive isn't found in work directory"
return Archive(filepath=filepath, project=project)
def tgz_archive_with_cartridge(cartridge_cmd, tmpdir, project_with_cartridge):
project = project_with_cartridge
replace_project_file(project, 'app/roles/custom.lua',
ROUTER_WITH_EVAL_FILEPATH)
replace_project_file(project, 'init.lua',
INIT_ROLES_RELOAD_ALLOWED_FILEPATH)
cmd = [
cartridge_cmd,
"pack",
"tgz",
project.path,
"--use-docker",
]
process = subprocess.run(cmd, cwd=tmpdir)
assert process.returncode == 0, \
"Error during creating of tgz archive with project"
filepath = find_archive(tmpdir, project.name, 'tar.gz')
assert filepath is not None, "TGZ archive isn't found in work directory"
return Archive(filepath=filepath, project=project)
