339 lines
11 KiB
Python
339 lines
11 KiB
Python
import configparser
|
|
import csv
|
|
import os
|
|
import sys
|
|
import traceback
|
|
from pathlib import Path
|
|
|
|
import yaml
|
|
from loguru import logger
|
|
|
|
from odoo_openupgrade_wizard.configuration_version_dependant import (
|
|
get_base_module_folder,
|
|
get_odoo_folder,
|
|
get_odoo_run_command,
|
|
get_server_wide_modules_upgrade,
|
|
skip_addon_path,
|
|
)
|
|
from odoo_openupgrade_wizard.tools_docker import kill_container, run_container
|
|
from odoo_openupgrade_wizard.tools_postgres import get_postgres_container
|
|
from odoo_openupgrade_wizard.tools_system import get_script_folder
|
|
|
|
|
|
def get_odoo_addons_path(
|
|
ctx, root_path: Path, migration_step: dict, execution_context: str = False
|
|
) -> str:
|
|
odoo_version = get_odoo_version_from_migration_step(ctx, migration_step)
|
|
repo_file = get_odoo_env_path(ctx, odoo_version) / Path("repos.yml")
|
|
base_module_folder = get_base_module_folder(migration_step)
|
|
stream = open(repo_file, "r")
|
|
data = yaml.safe_load(stream)
|
|
data = data
|
|
|
|
addons_path = []
|
|
for key in data.keys():
|
|
path = root_path / Path(key)
|
|
if str(path).endswith(
|
|
get_odoo_folder(migration_step, execution_context)
|
|
):
|
|
# Add two folder for odoo folder
|
|
addons_path.append(path / Path("addons"))
|
|
addons_path.append(
|
|
path / Path(base_module_folder) / Path("addons")
|
|
)
|
|
elif skip_addon_path(migration_step, path):
|
|
pass
|
|
else:
|
|
addons_path.append(path)
|
|
|
|
return addons_path
|
|
|
|
|
|
def get_odoo_env_path(ctx, odoo_version: dict) -> Path:
|
|
folder_name = "env_%s" % str(odoo_version["release"]).rjust(4, "0")
|
|
return ctx.obj["src_folder_path"] / folder_name
|
|
|
|
|
|
def get_docker_image_tag(ctx, odoo_version: dict) -> str:
|
|
"""Return a docker image tag, based on project name and odoo release"""
|
|
return "odoo-openupgrade-wizard-image__%s__%s" % (
|
|
ctx.obj["config"]["project_name"],
|
|
str(odoo_version["release"]).rjust(4, "0"),
|
|
)
|
|
|
|
|
|
def get_docker_container_name(ctx, migration_step: dict) -> str:
|
|
"""Return a docker container name, based on project name,
|
|
odoo release and migration step"""
|
|
return "odoo-openupgrade-wizard-container__%s__%s__step-%s" % (
|
|
ctx.obj["config"]["project_name"],
|
|
str(migration_step["release"]).rjust(4, "0"),
|
|
str(migration_step["name"]).rjust(2, "0"),
|
|
)
|
|
|
|
|
|
def get_odoo_version_from_migration_step(ctx, migration_step: dict) -> dict:
|
|
for odoo_version in ctx.obj["config"]["odoo_versions"]:
|
|
if odoo_version["release"] == migration_step["release"]:
|
|
return odoo_version
|
|
# TODO, improve exception
|
|
raise Exception
|
|
|
|
|
|
def generate_odoo_command(
|
|
ctx,
|
|
migration_step: dict,
|
|
execution_context: str,
|
|
database: str,
|
|
update: str,
|
|
init: str,
|
|
stop_after_init: bool,
|
|
shell: bool,
|
|
demo: bool,
|
|
) -> str:
|
|
database_cmd = database and "--database %s" % database or ""
|
|
update_cmd = update and "--update %s" % update or ""
|
|
init_cmd = init and "--init %s" % init or ""
|
|
stop_after_init_cmd = stop_after_init and "--stop-after-init" or ""
|
|
shell_cmd = shell and "shell" or ""
|
|
demo_cmd = not demo and "--without-demo all" or ""
|
|
command = (
|
|
Path("/odoo_env")
|
|
/ Path(get_odoo_folder(migration_step, execution_context))
|
|
/ Path(get_odoo_run_command(migration_step))
|
|
)
|
|
result = (
|
|
f" {command}"
|
|
f" {shell_cmd}"
|
|
f" --config /odoo_env/_auto_generated_odoo.cfg"
|
|
f" {demo_cmd}"
|
|
f" {database_cmd}"
|
|
f" {update_cmd}"
|
|
f" {init_cmd}"
|
|
f" {stop_after_init_cmd}"
|
|
)
|
|
return result
|
|
|
|
|
|
def generate_odoo_config_file(
|
|
ctx, migration_step, log_file, execution_context
|
|
):
|
|
"""Create a config file name _auto_generated_odoo.cfg
|
|
in the according environment (defined by migration_step)
|
|
This configuration file is a merge of the odoo.cfg file that can
|
|
contain custom values, and the values required to run the docker container.
|
|
"""
|
|
odoo_version = get_odoo_version_from_migration_step(ctx, migration_step)
|
|
odoo_env_path = get_odoo_env_path(ctx, odoo_version)
|
|
|
|
custom_odoo_config_file = odoo_env_path / "odoo.cfg"
|
|
auto_generated_odoo_config_file = (
|
|
odoo_env_path / "_auto_generated_odoo.cfg"
|
|
)
|
|
|
|
parser = configparser.RawConfigParser()
|
|
# Read custom file
|
|
parser.read(custom_odoo_config_file)
|
|
|
|
# compute addons_path
|
|
addons_path = ",".join(
|
|
[
|
|
str(x)
|
|
for x in get_odoo_addons_path(
|
|
ctx, Path("/odoo_env"), migration_step, execution_context
|
|
)
|
|
]
|
|
)
|
|
|
|
# compute server wides modules
|
|
server_wide_modules = parser.get(
|
|
"options", "server_wide_modules", fallback=[]
|
|
)
|
|
server_wide_modules += get_server_wide_modules_upgrade(migration_step)
|
|
|
|
# Add required keys
|
|
if "options" not in parser:
|
|
parser.add_section("options")
|
|
parser.set("options", "db_host", "db")
|
|
parser.set("options", "db_port", 5432)
|
|
parser.set("options", "db_user", "odoo")
|
|
parser.set("options", "db_password", "odoo")
|
|
parser.set("options", "workers", 0)
|
|
parser.set("options", "data_dir", "/env/filestore/")
|
|
parser.set("options", "logfile", log_file)
|
|
parser.set("options", "addons_path", addons_path)
|
|
if server_wide_modules:
|
|
parser.set(
|
|
"options", "server_wide_modules", ",".join(server_wide_modules)
|
|
)
|
|
|
|
parser.write(open(auto_generated_odoo_config_file, "w"))
|
|
|
|
|
|
def run_odoo(
|
|
ctx,
|
|
migration_step: dict,
|
|
detached_container: bool = False,
|
|
database: str = False,
|
|
update: str = False,
|
|
init: str = False,
|
|
stop_after_init: bool = False,
|
|
shell: bool = False,
|
|
demo: bool = False,
|
|
execution_context: str = False,
|
|
alternative_xml_rpc_port: int = False,
|
|
links: dict = {},
|
|
):
|
|
# Ensure that Postgres container exist
|
|
get_postgres_container(ctx)
|
|
logger.info(
|
|
"Launching Odoo Container (Release {release}) for {db_text}"
|
|
" in {execution_context} mode. Demo Data is {demo_text}"
|
|
" {stop_text} {init_text} {update_text}".format(
|
|
release=migration_step["release"],
|
|
db_text=database and "database '%s'" % database or "any databases",
|
|
execution_context=execution_context
|
|
or migration_step["execution_context"],
|
|
demo_text=demo and "enabled" or "disabled",
|
|
stop_text=stop_after_init and " (stop-after-init)" or "",
|
|
init_text=init and " (Init : %s)" % init or "",
|
|
update_text=update and " (Update : %s)" % update or "",
|
|
)
|
|
)
|
|
odoo_version = get_odoo_version_from_migration_step(ctx, migration_step)
|
|
env_path = ctx.obj["env_folder_path"]
|
|
odoo_env_path = get_odoo_env_path(ctx, odoo_version)
|
|
log_file = "/env/log/{}____{}.log".format(
|
|
ctx.obj["log_prefix"], migration_step["complete_name"]
|
|
)
|
|
generate_odoo_config_file(ctx, migration_step, log_file, execution_context)
|
|
|
|
command = generate_odoo_command(
|
|
ctx,
|
|
migration_step,
|
|
execution_context,
|
|
database=database,
|
|
update=update,
|
|
init=init,
|
|
stop_after_init=stop_after_init,
|
|
shell=shell,
|
|
demo=demo,
|
|
)
|
|
|
|
host_xmlrpc_port = (
|
|
alternative_xml_rpc_port
|
|
and alternative_xml_rpc_port
|
|
or ctx.obj["config"]["odoo_host_xmlrpc_port"]
|
|
)
|
|
links.update({ctx.obj["config"]["postgres_container_name"]: "db"})
|
|
return run_container(
|
|
get_docker_image_tag(ctx, odoo_version),
|
|
get_docker_container_name(ctx, migration_step),
|
|
command=command,
|
|
ports={
|
|
host_xmlrpc_port: 8069,
|
|
},
|
|
volumes={
|
|
env_path: "/env/",
|
|
odoo_env_path: "/odoo_env/",
|
|
},
|
|
links=links,
|
|
detach=detached_container,
|
|
auto_remove=True,
|
|
)
|
|
|
|
|
|
def kill_odoo(ctx, migration_step: dict):
|
|
kill_container(get_docker_container_name(ctx, migration_step))
|
|
|
|
|
|
def execute_click_odoo_python_files(
|
|
ctx,
|
|
database: str,
|
|
migration_step: dict,
|
|
python_files: list = [],
|
|
execution_context: str = False,
|
|
):
|
|
|
|
if not python_files:
|
|
# Get post-migration python scripts to execute
|
|
script_folder = get_script_folder(ctx, migration_step)
|
|
python_files = [
|
|
Path("scripts") / Path(migration_step["complete_name"]) / Path(f)
|
|
for f in os.listdir(script_folder)
|
|
if os.path.isfile(os.path.join(script_folder, f))
|
|
and f[-3:] == ".py"
|
|
]
|
|
python_files = sorted(python_files)
|
|
|
|
# Prepare data information for docker
|
|
odoo_version = get_odoo_version_from_migration_step(ctx, migration_step)
|
|
links = {ctx.obj["config"]["postgres_container_name"]: "db"}
|
|
env_path = ctx.obj["env_folder_path"]
|
|
odoo_env_path = get_odoo_env_path(ctx, odoo_version)
|
|
|
|
# Generate odoo config file
|
|
log_file = "/env/log/{}____{}__post_migration.log".format(
|
|
ctx.obj["log_prefix"], migration_step["complete_name"]
|
|
)
|
|
generate_odoo_config_file(ctx, migration_step, log_file, execution_context)
|
|
|
|
for python_file in python_files:
|
|
# TODO, check if we should set python2 for old version of Odoo
|
|
# or just 'python'
|
|
command = (
|
|
"click-odoo"
|
|
" --database {database}"
|
|
" --config /odoo_env/_auto_generated_odoo.cfg"
|
|
" /env/{python_file}"
|
|
).format(
|
|
database=database,
|
|
python_file=str(python_file),
|
|
)
|
|
try:
|
|
logger.info(
|
|
"Executing script %s / %s"
|
|
% (migration_step["complete_name"], python_file)
|
|
)
|
|
run_container(
|
|
get_docker_image_tag(ctx, odoo_version),
|
|
get_docker_container_name(ctx, migration_step),
|
|
command=command,
|
|
ports={},
|
|
volumes={
|
|
env_path: "/env/",
|
|
odoo_env_path: "/odoo_env/",
|
|
},
|
|
links=links,
|
|
detach=False,
|
|
auto_remove=True,
|
|
)
|
|
except Exception as e:
|
|
traceback.print_exc()
|
|
logger.error(
|
|
"An error occured. Exiting. %s\n%s"
|
|
% (e, traceback.print_exception(*sys.exc_info()))
|
|
)
|
|
raise e
|
|
finally:
|
|
kill_odoo(ctx, migration_step)
|
|
|
|
|
|
def get_odoo_modules_from_csv(module_file_path: Path) -> list:
|
|
logger.debug("Reading '%s' file ..." % module_file_path)
|
|
module_names = []
|
|
csvfile = open(module_file_path, "r")
|
|
spamreader = csv.reader(csvfile, delimiter=",", quotechar='"')
|
|
for row in spamreader:
|
|
# Try to guess that a line is not correct
|
|
if not row:
|
|
continue
|
|
if not row[0]:
|
|
continue
|
|
if " " in row[0]:
|
|
continue
|
|
if any([x.isupper() for x in row[0]]):
|
|
continue
|
|
module_names.append(row[0])
|
|
return module_names
|