odoo/odoo/tools/config.py at 19.0 · luminize/odoo

Repository navigation

98

# Part of Odoo. See LICENSE file for full copyright and licensing details.

import collections

import configparser as ConfigParser

import errno

import functools

import logging

import optparse

import glob

import os

import sys

import tempfile

import warnings

from os.path import expandvars, expanduser, abspath, realpath, normcase

from odoo import release

from odoo.tools.func import classproperty

from . import appdirs

from passlib.context import CryptContext

crypt_context = CryptContext(schemes=['pbkdf2_sha512', 'plaintext'],

deprecated=['plaintext'],

pbkdf2_sha512__rounds=600_000)

_dangerous_logger = logging.getLogger(__name__) # use config._log() instead

optparse._ = str # disable gettext

ALL_DEV_MODE = ['access', 'qweb', 'reload', 'xml']

DEFAULT_SERVER_WIDE_MODULES = ['base', 'rpc', 'web']

REQUIRED_SERVER_WIDE_MODULES = ['base', 'web']

class _Empty:

def __repr__(self):

return ''

EMPTY = _Empty()

class _OdooOption(optparse.Option):

config = None # must be overriden

TYPES = ['int', 'float', 'string', 'choice', 'bool', 'path', 'comma',

'addons_path', 'upgrade_path', 'pre_upgrade_scripts', 'without_demo']

@classproperty

def TYPE_CHECKER(cls):

return {

'int': lambda _option, _opt, value: int(value),

'float': lambda _option, _opt, value: float(value),

'string': lambda _option, _opt, value: str(value),

'choice': optparse.check_choice,

'bool': cls.config._check_bool,

'path': cls.config._check_path,

'comma': cls.config._check_comma,

'addons_path': cls.config._check_addons_path,

'upgrade_path': cls.config._check_upgrade_path,

'pre_upgrade_scripts': cls.config._check_scripts,

'without_demo': cls.config._check_without_demo,

}

@classproperty

def TYPE_FORMATTER(cls):

return {

'int': cls.config._format_string,

'float': cls.config._format_string,

'string': cls.config._format_string,

'choice': cls.config._format_string,

'bool': cls.config._format_string,

'path': cls.config._format_string,

'comma': cls.config._format_list,

'addons_path': cls.config._format_list,

'upgrade_path': cls.config._format_list,

'pre_upgrade_scripts': cls.config._format_list,

'without_demo': cls.config._format_without_demo,

}

def __init__(self, *opts, **attrs):

self.my_default = attrs.pop('my_default', None)

self.cli_loadable = attrs.pop('cli_loadable', True)

env_name = attrs.pop('env_name', None)

self.env_name = env_name or ''

self.file_loadable = attrs.pop('file_loadable', True)

self.file_exportable = attrs.pop('file_exportable', self.file_loadable)

self.nargs_ = attrs.get('nargs')

if self.nargs_ == '?':

const = attrs.pop('const', None)

attrs['nargs'] = 1

attrs.setdefault('metavar', attrs.get('type', 'string').upper())

super().__init__(*opts, **attrs)

if 'default' in attrs:

self.config._log(logging.WARNING, "please use my_default= instead of default= with option %s", self)

if self.file_exportable and not self.file_loadable:

e = (f"it makes no sense that the option {self} can be exported "

"to the config file but not loaded from the config file")

raise ValueError(e)

is_new_option = False

if self.dest and self.dest not in self.config.options_index:

self.config.options_index[self.dest] = self

is_new_option = True

if self.nargs_ == '?':

self.const = const

for opt in self._short_opts + self._long_opts:

self.config.optional_options[opt] = self

if env_name is None and is_new_option and self.file_loadable:

# generate an env_name for file_loadable settings that are in the index

self.env_name = 'ODOO_' + self.dest.upper()

elif env_name and not is_new_option:

raise ValueError(f"cannot set env_name to an option that is not indexed: {self}")

def __str__(self):

out = []

if self.cli_loadable:

out.append(super().__str__()) # e.g. -i/--init

if self.file_loadable:

out.append(self.dest)

return '/'.join(out)

class _FileOnlyOption(_OdooOption):

def __init__(self, **attrs):

super().__init__(**attrs, cli_loadable=False, help=optparse.SUPPRESS_HELP)

def _check_opt_strings(self, opts):

if opts:

raise TypeError("No option can be supplied")

def _set_opt_strings(self, opts):

return

class _PosixOnlyOption(_OdooOption):

def __init__(self, *opts, **attrs):

if os.name != 'posix':

attrs['help'] = optparse.SUPPRESS_HELP

attrs['cli_loadable'] = False

attrs['env_name'] = ''

attrs['file_loadable'] = False

attrs['file_exportable'] = False

super().__init__(*opts, **attrs)

def _deduplicate_loggers(loggers):

""" Avoid saving multiple logging levels for the same loggers to a save

file, that just takes space and the list can potentially grow unbounded

if for some odd reason people use :option`--save`` all the time.

"""

# dict(iterable) -> the last item of iterable for any given key wins,

# which is what we want and expect. Output order should not matter as

# there are no duplicates within the output sequence

return (

'{}:{}'.format(logger, level)

for logger, level in dict(it.split(':') for it in loggers).items()

)

class configmanager:

def __init__(self):

self._default_options = {}

self._file_options = {}

self._env_options = {}

self._cli_options = {}

self._runtime_options = {}

self.options = collections.ChainMap(

self._runtime_options,

self._cli_options,

self._env_options,

self._file_options,

self._default_options,

)

# dictionary mapping option destination (keys in self.options) to OdooOptions.

self.options_index = {}

# list of nargs='?' options, indexed by short/long option (-x, --xx)

self.optional_options = {}

# map old name -> new name

self.aliases = {

"import_image_maxbytes": "import_file_maxbytes",

"import_image_regex": "import_url_regex",

"import_image_timeout": "import_file_timeout",

}

self.parser = self._build_cli()

self._load_default_options()

self._parse_config()

@property

def rcfile(self):

self._warn("Since 19.0, use odoo.tools.config['config'] instead", DeprecationWarning, stacklevel=2)

return self['config']

@rcfile.setter

def rcfile(self, rcfile):

self._warn(f"Since 19.0, use odoo.tools.config['config'] = {rcfile!r} instead", DeprecationWarning, stacklevel=2)

self._runtime_options['config'] = rcfile

def _build_cli(self):

OdooOption = type('OdooOption', (_OdooOption,), {'config': self})

FileOnlyOption = type('FileOnlyOption', (_FileOnlyOption, OdooOption), {})

PosixOnlyOption = type('PosixOnlyOption', (_PosixOnlyOption, OdooOption), {})

version = "%s %s" % (release.description, release.version)

parser = optparse.OptionParser(version=version, option_class=OdooOption)

parser.add_option(FileOnlyOption(dest='admin_passwd', my_default='admin'))

parser.add_option(FileOnlyOption(dest='bin_path', type='path', my_default='', file_exportable=False))

parser.add_option(FileOnlyOption(dest='csv_internal_sep', my_default=','))

parser.add_option(FileOnlyOption(dest='default_productivity_apps', type='bool', my_default=False, file_exportable=False))

parser.add_option(FileOnlyOption(dest='import_file_maxbytes', type='int', my_default=10 * 1024 * 1024, file_exportable=False))

parser.add_option(FileOnlyOption(dest='import_file_timeout', type='int', my_default=3, file_exportable=False))

parser.add_option(FileOnlyOption(dest='import_url_regex', my_default=r"^(?:http|https)://", file_exportable=False))

parser.add_option(FileOnlyOption(dest='proxy_access_token', my_default='', file_exportable=False))

parser.add_option(FileOnlyOption(dest='publisher_warranty_url', my_default='http://services.odoo.com/publisher-warranty/', file_exportable=False))

parser.add_option(FileOnlyOption(dest='reportgz', action='store_true', my_default=False))

parser.add_option(FileOnlyOption(dest='websocket_keep_alive_timeout', type='int', my_default=3600))

parser.add_option(FileOnlyOption(dest='websocket_rate_limit_burst', type='int', my_default=10))

parser.add_option(FileOnlyOption(dest='websocket_rate_limit_delay', type='float', my_default=0.2))

# Server startup config

group = optparse.OptionGroup(parser, "Common options")

group.add_option("-c", "--config", dest="config", type='path', file_loadable=False, env_name='ODOO_RC',

help="specify alternate config file")

group.add_option("-s", "--save", action="store_true", dest="save", my_default=False, file_loadable=False,

help="save configuration to ~/.odoorc (or to ~/.openerp_serverrc if it exists)")

group.add_option("-i", "--init", dest="init", type='comma', metavar="MODULE,...", my_default=[], file_loadable=False,

help="install one or more modules (comma-separated list, use \"all\" for all modules), requires -d")

group.add_option("-u", "--update", dest="update", type='comma', metavar="MODULE,...", my_default=[], file_loadable=False,

help="update one or more modules (comma-separated list, use \"all\" for all modules). Requires -d.")

group.add_option("--reinit", dest="reinit", type='comma', metavar="MODULE,...", my_default=[], file_loadable=False,

help="reinitialize one or more modules (comma-separated list), requires -d")

group.add_option("--with-demo", dest="with_demo", action='store_true', my_default=False,

help="install demo data in new databases")

group.add_option("--without-demo", dest="with_demo", type='without_demo', metavar='BOOL', nargs='?', const=True,

help="don't install demo data in new databases (default)")

group.add_option("--skip-auto-install", dest="skip_auto_install", action="store_true", my_default=False,

help="skip the automatic installation of modules marked as auto_install")

group.add_option("-P", "--import-partial", dest="import_partial", type='path', my_default='', file_loadable=False,

help="Use this for big data importation, if it crashes you will be able to continue at the current state. Provide a filename to store intermediate importation states.")

group.add_option("--pidfile", dest="pidfile", type='path', my_default='',

help="file where the server pid will be stored")

group.add_option("--addons-path", dest="addons_path", type='addons_path', metavar='PATH,...', my_default=[],

help="specify additional addons paths (separated by commas).")

group.add_option("--upgrade-path", dest="upgrade_path", type='upgrade_path', metavar='PATH,...', my_default=[],

help="specify an additional upgrade path.")

group.add_option('--pre-upgrade-scripts', dest='pre_upgrade_scripts', type='pre_upgrade_scripts', metavar='PATH,...', my_default=[],

help="Run specific upgrade scripts before loading any module when -u is provided.")

group.add_option("--load", dest="server_wide_modules", type='comma', metavar='MODULE,...', my_default=DEFAULT_SERVER_WIDE_MODULES,

help="Comma-separated list of server-wide modules.")

group.add_option("-D", "--data-dir", dest="data_dir", type='path', # sensitive default set in _load_default_options

help="Directory where to store Odoo data")

parser.add_option_group(group)

# HTTP

group = o 10000 ptparse.OptionGroup(parser, "HTTP Service Configuration")

group.add_option("--http-interface", dest="http_interface", my_default='0.0.0.0',

help="Listen interface address for HTTP services.")

group.add_option("-p", "--http-port", dest="http_port", my_default=8069,

help="Listen port for the main HTTP service", type="int", metavar="PORT")

group.add_option("--gevent-port", dest="gevent_port", my_default=8072,

help="Listen port for the gevent worker", type="int", metavar="PORT")

group.add_option("--no-http", dest="http_enable", action="store_false", my_default=True,

help="Disable the HTTP and Longpolling services entirely")

group.add_option("--proxy-mode", dest="proxy_mode", action="store_true", my_default=False,

help="Activate reverse proxy WSGI wrappers (headers rewriting) "

"Only enable this when running behind a trusted web proxy!")

group.add_option("--x-sendfile", dest="x_sendfile", action="store_true", my_default=False,

help="Activate X-Sendfile (apache) and X-Accel-Redirect (nginx) "

"HTTP response header to delegate the delivery of large "

"files (assets/attachments) to the web server.")

parser.add_option_group(group)

# WEB

group = optparse.OptionGroup(parser, "Web interface Configuration")

group.add_option("--db-filter", dest="dbfilter", my_default='', metavar="REGEXP",

help="Regular expressions for filtering available databases for Web UI. "

"The expression can use %d (domain) and %h (host) placeholders.")

parser.add_option_group(group)

# Testing Group

group = optparse.OptionGroup(parser, "Testing Configuration")

group.add_option("--test-file", dest="test_file", type='path', my_default='', file_loadable=False,

help="Launch a python test file.")

group.add_option("--test-enable", dest='test_enable', action="store_true", file_loadable=False,

help="Enable unit tests. Implies --stop-after-init")

group.add_option("--test-tags", dest="test_tags", file_loadable=False,

help="Comma-separated list of specs to filter which tests to execute. Enable unit tests if set. "

"A filter spec has the format: [-][tag][/module][:class][.method][[params]] "

"The '-' specifies if we want to include or exclude tests matching this spec. "

"The tag will match tags added on a class with a @tagged decorator "

"(all Test classes have 'standard' and 'at_install' tags "

"until explicitly removed, see the decorator documentation). "

"'*' will match all tags. "

"If tag is omitted on include mode, its value is 'standard'. "

"If tag is omitted on exclude mode, its value is '*'. "

"The module, class, and method will respectively match the module name, test class name and test method name. "

"Example: --test-tags :TestClass.test_func,/test_module,external "

"It is also possible to provide parameters to a test method that supports them"

"Example: --test-tags /web.test_js[mail]"

"If negated, a test-tag with parameter will negate the parameter when passing it to the test"

"Filtering and executing the tests happens twice: right "

"after each module installation/update and at the end "

"of the modules loading. At each stage tests are filtered "

"by --test-tags specs and additionally by dynamic specs "

"'at_install' and 'post_install' correspondingly. Implies --stop-after-init")

group.add_option("--screencasts", dest="screencasts", type='path', my_default='',

metavar='DIR',

help="Screencasts will go in DIR/{db_name}/screencasts.")

temp_tests_dir = os.path.join(tempfile.gettempdir(), 'odoo_tests')

group.add_option("--screenshots", dest="screenshots", type='path', my_default=temp_tests_dir,

metavar='DIR',

help="Screenshots will go in DIR/{db_name}/screenshots. Defaults to %s." % temp_tests_dir)

parser.add_option_group(group)

# Logging Group

group = optparse.OptionGroup(parser, "Logging Configuration")

group.add_option("--logfile", dest="logfile", type='path', my_default='',

help="file where the server log will be stored")

group.add_option("--syslog", action="store_true", dest="syslog", my_default=False,

help="Send the log to the syslog server")

group.add_option('--log-handler', action="append", type='comma', my_default=[':INFO'], metavar="MODULE:LEVEL",

help='setup a handler at LEVEL for a given MODULE. An empty MODULE indicates the root logger. '

'This option can be repeated. Example: "odoo.orm:DEBUG" or "werkzeug:CRITICAL" (default: ":INFO")')

group.add_option('--log-web', action="append_const", dest="log_handler", const=("odoo.http:DEBUG",),

help='shortcut for --log-handler=odoo.http:DEBUG')

group.add_option('--log-sql', action="append_const", dest="log_handler", const=("odoo.sql_db:DEBUG",),

help='shortcut for --log-handler=odoo.sql_db:DEBUG')

group.add_option('--log-db', dest='log_db', help="Logging database", my_default='')

group.add_option('--log-db-level', dest='log_db_level', my_default='warning', help="Logging database level")

# For backward-compatibility, map the old log levels to something

# quite close.

levels = [

'info', 'debug_rpc', 'warn', 'test', 'critical', 'runbot',

'debug_sql', 'error', 'debug', 'debug_rpc_answer', 'notset'

]

group.add_option('--log-level', dest='log_level', type='choice',

choices=levels, my_default='info',

help='specify the level of the logging. Accepted values: %s.' % (levels,))

parser.add_option_group(group)

# SMTP Group

group = optparse.OptionGroup(parser, "SMTP Configuration")

group.add_option('--email-from', dest='email_from', my_default='',

help='specify the SMTP email address for sending email')

group.add_option('--from-filter', dest='from_filter', my_default='',

help='specify for which email address the SMTP configuration can be used')

group.add_option('--smtp', dest='smtp_server', my_default='localhost',

help='specify the SMTP server for sending email')

group.add_option('--smtp-port', dest='smtp_port', my_default=25,

help='specify the SMTP port', type="int")

group.add_option('--smtp-ssl', dest='smtp_ssl', action='store_true', my_default=False,

help='if passed, SMTP connections will be encrypted with SSL (STARTTLS)')

group.add_option('--smtp-user', dest='smtp_user', my_default='',

help='specify the SMTP username for sending email')

group.add_option('--smtp-password', dest='smtp_password', my_default='',

help='specify the SMTP password for sending email')

group.add_option('--smtp-ssl-certificate-filename', dest='smtp_ssl_certificate_filename', type='path', my_default='',

help='specify the SSL certificate used for authentication')

group.add_option('--smtp-ssl-private-key-filename', dest='smtp_ssl_private_key_filename', type='path', my_default='',

help='specify the SSL private key used for authentication')

parser.add_option_group(group)

# Database Group

group = optparse.OptionGroup(parser, "Database related options")

group.add_option("-d", "--database", dest="db_name", type='comma', metavar="DATABASE,...", my_default=[], env_name='PGDATABASE',

help="database(s) used when installing or updating modules.")

group.add_option("-r", "--db_user", dest="db_user", my_default='', env_name='PGUSER',

help="specify the database user name")

group.add_option("-w", "--db_password", dest="db_password", my_default='', env_name='PGPASSWORD',

help="specify the database password")

group.add_option("--pg_path", dest="pg_path", type='path', my_default='', env_name='PGPATH',

help="specify the pg executable path")

group.add_option("--db_host", dest="db_host", my_default='', env_name='PGHOST',

help="specify the database host")

group.add_option("--db_replica_host", dest="db_replica_host", my_default=None, env_name='PGHOST_REPLICA',

help="specify the replica host")

group.add_option("--db_port", dest="db_port", my_default=None, env_name='PGPORT',

help="specify the database port", type="int")

group.add_option("--db_replica_port", dest="db_replica_port", my_default=None, env_name='PGPORT_REPLICA',

help="specify the replica port", type="int")

group.add_option("--db_sslmode", dest="db_sslmode", type="choice", my_default='prefer', env_name='PGSSLMODE',

choices=['disable', 'allow', 'prefer', 'require', 'verify-ca', 'verify-full'],

help="specify the database ssl connection mode (see PostgreSQL documentation)")

group.add_option("--db_app_name", dest="db_app_name", my_default="odoo-{pid}", env_name='PGAPPNAME',

help="specify the application name in the database, {pid} is substituted by the process pid")

group.add_option("--db_maxconn", dest="db_maxconn", type='int', my_default=64,

help="specify the maximum number of physical connections to PostgreSQL")

group.add_option("--db_maxconn_gevent", dest="db_maxconn_gevent", type='int', my_default=None,

help="specify the maximum number of physical connections to PostgreSQL specifically for the gevent worker")

group.add_option("--db-template", dest="db_template", my_default="template0", env_name='PGDATABASE_TEMPLATE',

help="specify a custom database template to create a new database")

parser.add_option_group(group)

# i18n Group

group = optparse.OptionGroup(parser, "Internationalisation options",

"Use these options to translate Odoo to another language. "

"See i18n section of the user manual. Option '-d' is mandatory. "

"Option '-l' is mandatory in case of importation"

)

group.add_option('--load-language', dest="load_language", file_exportable=False,

help="specifies the languages for the translations you want to be loaded")

group.add_option("--i18n-overwrite", dest="overwrite_existing_translations", action="store_true", my_default=False, file_exportable=False,

help="overwrites existing translation terms on updating a module.")

parser.add_option_group(group)

# Security Group

security = optparse.OptionGroup(parser, 'Security-related options')

security.add_option('--no-database-list', action="store_false", dest='list_db', my_default=True,

help="Disable the ability to obtain or view the list of databases. "

"Also disable access to the database manager and selector, "

"so be sure to set a proper --database parameter first")

parser.add_option_group(security)

# Advanced options

group = optparse.OptionGroup(parser, "Advanced options")

group.add_option('--dev', dest='dev_mode', type='comma', metavar="FEATURE,...", my_default=[], file_exportable=False, env_name='ODOO_DEV',

# optparse uses a fixed 55 chars to print the help no matter the

# terminal size, abuse that to align the features

help="Enable developer features (comma-separated list, use "

'"all" for access,reload,qweb,xml). Available features: '

"- access: log the traceback of access errors "

"- qweb: log the compiled xml with qweb errors "

"- reload: restart server on change in the source code "

"- replica: simulate a deployment with readonly replica "

"- werkzeug: open a html debugger on http request error "

"- xml: read views from the source code, and not the db ")

group.add_option("--stop-after-init", action="store_true", dest="stop_after_init", my_default=False, file_exportable=False, file_loadable=False,

help="stop the server after its initialization")

group.add_option("--osv-memory-count-limit", dest="osv_memory_count_limit", my_default=0,

help="Force a limit on the maximum number of records kept in the virtual "

"osv_memory tables. By default there is no limit.",

type="int")

group.add_option("--transient-age-limit", dest="transient_age_limit", my_default=1.0,

help="Time limit (decimal value in hours) records created with a "

"TransientModel (mostly wizard) are kept in the database. Default to 1 hour.",

type="float")

group.add_option("--max-cron-threads", dest="max_cron_threads", my_default=2,

help="Maximum number of threads processing concurrently cron jobs (default 2).",

type="int")

group.add_option("--limit-time-worker-cron", dest="limit_time_worker_cron", my_default=0,

help="Maximum time a cron thread/worker stays alive before it is restarted. "

"Set to 0 to disable. (default: 0)",

type="int")

group.add_option("--unaccent", dest="unaccent", my_default=False, action="store_true",

help="Try to enable the unaccent extension when creating new databases.")

group.add_option("--geoip-city-db", "--geoip-db", dest="geoip_city_db", type='path', my_default='/usr/share/GeoIP/GeoLite2-City.mmdb',

help="Absolute path to the GeoIP City database file.")

group.add_option("--geoip-country-db", dest="geoip_country_db", type='path', my_default='/usr/share/GeoIP/GeoLite2-Country.mmdb',

help="Absolute path to the GeoIP Country database file.")

parser.add_option_group(group)

group = optparse.OptionGroup(parser, "Multiprocessing options")

# TODO sensible default for the three following limits.

group.add_option(PosixOnlyOption(

"--workers", dest="workers", my_default=0,

help="Specify the number of workers, 0 disable prefork mode.",

type="int"))

group.add_option("--limit-memory-soft", dest="limit_memory_soft", my_default=2048 * 1024 * 1024,

help="Maximum allowed virtual memory per worker (in bytes), when reached the worker be "

"reset after the current request (default 2048MiB).",

type="int")

group.add_option(PosixOnlyOption(

"--limit-memory-soft-gevent", dest="limit_memory_soft_gevent", my_default=None,

help="Maximum allowed virtual memory per gevent worker (in bytes), when reached the worker will be "

"reset after the current request. Defaults to `--limit-memory-soft`.",

type="int"))

group.add_option(PosixOnlyOption(

"--limit-memory-hard", dest="limit_memory_hard", my_default=2560 * 1024 * 1024,

help="Maximum allowed virtual memory per worker (in bytes), when reached, any memory "

"allocation will fail (default 2560MiB).",

type="int"))

group.add_option(PosixOnlyOption(

"--limit-memory-hard-gevent", dest="limit_memory_hard_gevent", my_default=None,

help="Maximum allowed virtual memory per gevent worker (in bytes), when reached, any memory "

"allocation will fail. Defaults to `--limit-memory-hard`.",

type="int"))

group.add_option(PosixOnlyOption(

"--limit-time-cpu", dest="limit_time_cpu", my_default=60,

help="Maximum allowed CPU time per request (default 60).",

type="int"))

group.add_option("--limit-time-real", dest="limit_time_real", my_default=120,

help="Maximum allowed Real time per request (default 120).",

type="int")

group.add_option("--limit-time-real-cron", dest="limit_time_real_cron", my_default=-1,

help="Maximum allowed Real time per cron job. (default: --limit-time-real). "

"Set to 0 for no limit. ",

type="int")

group.add_option(PosixOnlyOption(

"--limit-request", dest="limit_request", my_default=2**16,

help="Maximum number of request to be processed per worker (default 65536).",

type="int"))

parser.add_option_group(group)

return parser

def _load_default_options(self):

self._default_options.clear()

self._default_options.update({

option_name: option.my_default

for option_name, option in self.options_index.items()

})

self._default_options['data_dir'] = (

appdirs.user_data_dir(release.product_name, release.author)

if os.path.isdir(os.path.expanduser('~')) else

appdirs.site_data_dir(release.product_name, release.author)

if sys.platform in ['win32', 'darwin'] else

f'/var/lib/{release.product_name}'

)

if os.name == 'nt':

rcfilepath = os.path.join(os.path.abspath(os.path.dirname(sys.argv[0])), 'odoo.conf')

elif os.path.isfile(rcfilepath := os.path.expanduser('~/.odoorc')):

pass

elif os.path.isfile(rcfilepath := os.path.expanduser('~/.openerp_serverrc')):

self._warn("Since ages ago, the ~/.openerp_serverrc file has been replaced by ~/.odoorc", DeprecationWarning)

else:

rcfilepath = '~/.odoorc'

self._default_options['config'] = self._normalize(rcfilepath)

_log_entries = [] # helpers for log() and warn(), accumulate messages

_warn_entries = [] # until logging is configured and the entries flushed

@classmethod

def _log(cls, loglevel, message, *args, **kwargs):

# is replaced by logger.log once logging is ready

cls._log_entries.append((loglevel, message, args, kwargs))

@classmethod

def _warn(cls, message, *args, **kwargs):

# is replaced by warnings.warn once logging is ready

cls._warn_entries.append((message, args, kwargs))

@classmethod

def _flush_log_and_warn_entries(cls):

for loglevel, message, args, kwargs in cls._log_entries:

_dangerous_logger.log(loglevel, message, *args, **kwargs)

cls._log_entries.clear()

cls._log = _dangerous_logger.log

for message, args, kwargs in cls._warn_entries:

warnings.warn(message, *args, **kwargs, stacklevel=1)

cls._warn_entries.clear()

cls._warn = warnings.warn

def parse_config(self, args: list[str] | None = None, *, setup_logging: bool | None = None) -> None:

""" Parse the configuration file (if any) and the command-line

arguments.

This method initializes odoo.tools.config and openerp.conf (the

former should be removed in the future) with library-wide

configuration values.

This method must be called before proper usage of this library can be

made.

Typical usage of this method:

odoo.tools.config.parse_config(sys.argv[1:])

"""

from odoo import modules, netsvc # noqa: PLC0415

opt = self._parse_config(args)

if setup_logging is not False:

netsvc.init_logger()

# warn after having done setup, so it has a chance to show up

# (mostly once this warning is bumped to DeprecationWarning proper)

if setup_logging is None:

warnings.warn(

"As of Odoo 18, it's recommended to specify whether"

" you want Odoo to setup its own logging (or want to"

" handle it yourself)",

category=PendingDeprecationWarning,

stacklevel=2,

)

self._warn_deprecated_options()

self._flush_log_and_warn_entries()

modules.module.initialize_sys_path()

return opt

def _parse_config(self, args=None):

# preprocess the args to add support for nargs='?'

for arg_no, arg in enumerate(args or ()):

if option := self.optional_options.get(arg):

if arg_no == len(args) - 1 or args[arg_no + 1].startswith('-'):

args[arg_no] += '=' + self.format(option.dest, option.const)

self._log(logging.DEBUG, "changed %s for %s", arg, args[arg_no])

opt, unknown_args = self.parser.parse_args(args or [])

if unknown_args:

self.parser.error(f"unrecognized parameters: {' '.join(unknown_args)}")

if not opt.save and opt.config and not os.access(opt.config, os.R_OK):

self.parser.error(f"the config file {opt.config!r} selected with -c/--config doesn't exist or is not readable, use -s/--save if you want to generate it")

# Even if they are not exposed on the CLI, cli un-loadable variables still show up in the opt, remove them

for option_name in list(vars(opt).keys()):

if not self.options_index[option_name].cli_loadable:

delattr(opt, option_name) # hence list(...) above

self._load_env_options()

self._load_cli_options(opt)

self._load_file_options(self['config'])

self._postprocess_options()

if opt.save:

self.save()

return opt

def _load_env_options(self):

self._env_options.clear()

environ = os.environ

for option_name, option in self.options_index.items():

env_name = option.env_name

if env_name and env_name in environ:

self._env_options[option_name] = self.parse(option_name, environ[env_name])

if environ.get('OPENERP_SERVER'):

self._warn("Since ages ago, the OPENERP_SERVER environment variable has been replaced by ODOO_RC", DeprecationWarning)

def _load_cli_options(self, opt):

# odoo.cli.command.main parses the config twice, the second time

# without --addons-path but expect the value to be persisted

addons_path = self._cli_options.pop('addons_path', None)

self._cli_options.clear()

if addons_path is not None:

self._cli_options['addons_path'] = addons_path

keys = [

option_name for option_name, option

in self.options_index.items()

if option.cli_loadable

if option.action != 'append'

]

for arg in keys:

if getattr(opt, arg, None) is not None:

self._cli_options[arg] = getattr(opt, arg)

if opt.log_handler:

self._cli_options['log_handler'] = [handler for comma in opt.log_handler for handler in comma]

def _postprocess_options(self):

self._runtime_options.clear()

# check for mutualy exclusive / dependant options

if self.options['syslog'] and self.options['logfile']:

self.parser.error("the syslog and logfile options are exclusive")

if self.options['overwrite_existing_translations'] and not self['update']:

self.parser.error("the i18n-overwrite option cannot be used without the update option")

if len(self['db_name']) > 1 and (self['init'] or self['update']):

self.parser.error("Cannot use -i/--init or -u/--update with multiple databases in the -d/--database/db_name")

# ensure default server wide modules are present

if not self['server_wide_modules']:

self._runtime_options['server_wide_modules'] = DEFAULT_SERVER_WIDE_MODULES

for mod in REQUIRED_SERVER_WIDE_MODULES:

if mod not in self['server_wide_modules']:

self._log(logging.INFO, "adding missing %r to %s", mod, self.options_index['server_wide_modules'])

self._runtime_options['server_wide_modules'] = [mod] + self['server_wide_modules']

# accumulate all log_handlers

self._runtime_options['log_handler'] = list(_deduplicate_loggers([

*self._default_options.get('log_handler', []),

*self._file_options.get('log_handler', []),

*self._env_options.get('log_handler', []),

*self._cli_options.get('log_handler', []),

]))

self._runtime_options['init'] = dict.fromkeys(self['init'], True) or {}

self._runtime_options['update'] = {'base': True} if 'all' in self['update'] else dict.fromkeys(self['update'], True)

# TODO saas-22.1: remove support for the empty db_replica_host

if self['db_replica_host'] == '':

self._runtime_options['db_replica_host'] = None

if 'replica' not in self['dev_mode']:

# Conditional warning so it is possible to have a single

# config file (with db_replica_host= dev_mode=replica)

# that works in both 18.0 and 19.0.

# TODO saas-21.1:

# move this warning out of the if, as 18.0 won't be

# supported anymore, so people remove db_replica_host=

# from their config.

self._warn((

"Since 19.0, an empty {replica_host} was the 18.0 "

"way to open a replica connection on the same "

"server as {db_host}, for development/testing "

"purpose, the feature now exists as {dev}=replica"

).format(

replica_host=self.options_index['db_replica_host'],

db_host=self.options_index['db_host'],

dev=self.options_index['dev_mode'],

), DeprecationWarning)

self._runtime_options['dev_mode'] = self['dev_mode'] + ['replica']

if 'all' in self['dev_mode']:

self._runtime_options['dev_mode'] = self['dev_mode'] + ALL_DEV_MODE

if test_file := self['test_file']:

if not os.path.isfile(test_file):

self._log(logging.WARNING, f'test file {test_file!r} cannot be found')

elif not test_file.endswith('.py'):

self._log(logging.WARNING, f'test file {test_file!r} is not a python file')

else:

self._log(logging.INFO, 'Transforming --test-file into --test-tags')

test_tags = (self['test_tags'] or '').split(',')

test_tags.append(os.path.abspath(self['test_file']))

self._runtime_options['test_tags'] = ','.join(test_tags)

self._runtime_options['test_enable'] = True

if self['test_enable'] and not self['test_tags']:

self._runtime_options['test_tags'] = "+standard"

self._runtime_options['test_enable'] = bool(self['test_tags'])

if self._runtime_options['test_enable']:

self._runtime_options['stop_after_init'] = True

if not self['db_name']:

self._log(logging.WARNING,

"Empty %s, tests won't run", self.options_index['db_name'])

def _warn_deprecated_options(self):

if self['http_enable'] and not self.http_socket_activation:

for map_ in self.options.maps:

if 'http_interface' in map_:

if map_ is self._file_options and map_['http_interface'] == '': # noqa: PLC1901

del map_['http_interface']

elif map_ is self._default_options:

self._log(logging.WARNING, "missing %s, using 0.0.0.0 by default, will change to 127.0.0.1 in 20.0", self.options_index['http_interface'])

else:

break

for old_option_name, new_option_name in self.aliases.items():

for source_name, deprecated_value in self._get_sources(old_option_name).items():

if deprecated_value is EMPTY:

continue

default_value = self._default_options[new_option_name]

current_value = self[new_option_name]

if deprecated_value in (current_value, default_value):

# Surely this is from a --save that was run in a

# prior version. There is no point in emitting a

# warning because: (1) it holds the same value as

# the correct option, and (2) it is going to be

# automatically removed on the next --save anyway.

self._log(logging.INFO,

f"The {old_option_name!r} option found in the "

f"{source_name} is a deprecated alias to "

f"{new_option_name!r}. The configuration value "

"is the same as the default value, it can "

"safely be removed.")

elif current_value == default_value:

# deprecated_value != current_value == default_value

# assume the new option was not set

self._runtime_options[new_option_name] = self.parse(new_option_name, deprecated_value)

self._warn(

f"The {old_option_name!r} option found in the "

f"{source_name} is a deprecated alias to "

f"{new_option_name!r}, please use the latter.",

DeprecationWarning)

else:

# deprecated_value != current_value != default_value

self.parser.error(

f"The two options {old_option_name!r} "

f"(found in the {source_name} but deprecated) "

f"and {new_option_name!r} are set to different "

"values. Please remove the first one and make "

"sure the second is correct."

)

@classmethod

def _is_addons_path(cls, path):

for f in os.listdir(path):

modpath = os.path.join(path, f)

def hasfile(filename):

return os.path.isfile(os.path.join(modpath, filename))

if hasfile('__init__.py') and hasfile('__manifest__.py'):

return True

return False

@classmethod

def _check_addons_path(cls, option, opt, value):

ad_paths = []

for path in map(cls._normalize, cls._check_comma(option, opt, value)):

if not os.path.isdir(path):

cls._log(logging.WARNING, "option %s, no such directory %r, skipped", opt, path)

continue

if not cls._is_addons_path(path):

cls._log(logging.WARNING, "option %s, invalid addons directory %r, skipped", opt, path)

continue

ad_paths.append(path)

return ad_paths

@classmethod

def _check_upgrade_path(cls, option, opt, value):

upgrade_path = []

for path in map(cls._normalize, cls._check_comma(option, opt, value)):

if not os.path.isdir(path):

cls._log(logging.WARNING, "option %s, no such directory %r, skipped", opt, path)

continue

if not cls._is_upgrades_path(path):

cls._log(logging.WARNING, "option %s, invalid upgrade directory %r, skipped", opt, path)

continue

if path not in upgrade_path:

upgrade_path.append(path)

return upgrade_path

@classmethod

def _check_scripts(cls, option, opt, value):

pre_upgrade_scripts = []

for path in map(cls._normalize, cls._check_comma(option, opt, value)):

if not os.path.isfile(path):

cls._log(logging.WARNING, "option %s, no such file %r, skipped", opt, path)

continue

if path not in pre_upgrade_scripts:

pre_upgrade_scripts.append(path)

return pre_upgrade_scripts

@classmethod

def _is_upgrades_path(cls, path):

module = '*'

version = '*'

return any(

glob.glob(os.path.join(path, f'{module}/{version}/{prefix}-*.py'))

for prefix in ['pre', 'post', 'end']

)

@classmethod

def _check_bool(cls, option, opt, value):

if value.lower() in ('1', 'yes', 'true', 'on'):

return True

if value.lower() in ('0', 'no', 'false', 'off'):

return False

raise optparse.OptionValueError(

f"option {opt}: invalid boolean value: {value!r}"

)

@classmethod

def _check_comma(cls, option_name, option, value):

return [v for s in value.split(',') if (v := s.strip())]

@classmethod

def _check_path(cls, option, opt, value):

return cls._normalize(value)

@classmethod

def _check_without_demo(cls, option, opt, value):

# invert the result because it is stored in "with_demo"

try:

return not cls._check_bool(option, opt, value)

except optparse.OptionValueError:

cls._log(logging.WARNING, "option %s: since 19.0, invalid boolean value: %r, assume %s", opt, value, value != 'None')

return value == 'None'

def parse(self, option_name, value):

if not isinstance(value, str):

e = f"can only cast strings: {value!r}"

raise TypeError(e)

if value == 'None':

return None

option = self.options_index[option_name]

if option.action in ('store_true', 'store_false'):

check_func = self._check_bool

else:

check_func = self.parser.option_class.TYPE_CHECKER[option.type]

return check_func(option, option_name, value)

@classmethod

def _format_string(cls, value):

return str(value)

@classmethod

def _format_list(cls, value):

return ','.join(filter(bool, (str(elem).strip() for elem in value)))

@classmethod

def _format_without_demo(cls, value):

return str(bool(value))

def format(self, option_name, value):

option = self.options_index[option_name]

if option.action in ('store_true', 'store_false'):

format_func = self.parser.option_class.TYPE_FORMATTER['bool']

else:

format_func = self.parser.option_class.TYPE_FORMATTER[option.type]

return format_func(value)

def load(self):

self._warn("Since 19.0, use config._load_file_options instead", DeprecationWarning, stacklevel=2)

self._load_file_options(self['config'])

def _load_file_options(self, rcfile):

self._file_options.clear()

p = ConfigParser.RawConfigParser()

try:

p.read([rcfile])

for (name, value) in p.items('options'):

if name == 'without_demo':

name = 'with_demo'

value = str(self._check_without_demo(None, 'without_demo', value))

option = self.options_index.get(name)

if not option:

if name not in self.aliases:

self._log(logging.WARNING,

"unknown option %r in the config file at "

"%s, option stored as-is, without parsing",

name, self['config'],

)

self._file_options[name] = value

continue

if not option.file_loadable:

continue

if (

value in ('False', 'false')

and option.action not in ('store_true', 'store_false', 'callback')

and option.nargs_ != '?'

# "False" used to be the my_default of many non-bool options

self._log(logging.WARNING, "option %s reads %r in the config file at %s but isn't a boolean option, skip", name, value, self['config'])

continue

self._file_options[name] = self.parse(name, value)

except IOError:

pass

except ConfigParser.NoSectionError:

pass

def save(self, keys=None):

p = ConfigParser.RawConfigParser()

rc_exists = os.path.exists(self['config'])

if rc_exists and keys:

p.read([self['config']])

if not p.has_section('options'):

p.add_section('options')

for opt in sorted(self.options):

option = self.options_index.get(opt)

if keys is not None and opt not in keys:

continue

if opt == 'version' or (option and not option.file_exportable):

continue

if option:

p.set('options', opt, self.format(opt, self.options[opt]))

else:

p.set('options', opt, self.options[opt])

# try to create the directories and write the file

try:

if not rc_exists and not os.path.exists(os.path.dirname(self['config'])):

os.makedirs(os.path.dirname(self['config']))

try:

with open(self['config'], 'w', encoding='utf-8') as file:

p.write(file)

if not rc_exists:

os.chmod(self['config'], 0o600)

except IOError:

sys.stderr.write("ERROR: couldn't write the config file\n")

except OSError:

# what to do if impossible?

sys.stderr.write("ERROR: couldn't create the config directory\n")

5246 def get(self, key, default=None):

return self.options.get(key, default)

def __setitem__(self, key, value):

if isinstance(value, str) and key in self.options_index:

value = self.parse(key, value)

self.options[key] = value

def __getitem__(self, key):

return self.options[key]

@functools.cached_property

def root_path(self):

return self._normalize(os.path.join(os.path.dirname(__file__), '..'))

@property

def addons_base_dir(self):

return os.path.join(self.root_path, 'addons')

@property

def addons_community_dir(self):

return os.path.join(os.path.dirname(self.root_path), 'addons')

@property

def addons_data_dir(self):

add_dir = os.path.join(self['data_dir'], 'addons')

d = os.path.join(add_dir, release.series)

if not os.path.exists(d):

try:

# bootstrap parent dir +rwx

if not os.path.exists(add_dir):

os.makedirs(add_dir, 0o700)

# try to make +rx placeholder dir, will need manual +w to activate it

os.makedirs(d, 0o500)

except OSError:

self._log(logging.DEBUG, 'Failed to create addons data dir %s', d)

View remainder of file in raw view

FilesExpand file tree

config.py

Latest commit

History

config.py

File metadata and controls