def run(self, args): parser = argparse.ArgumentParser( prog="%s cloc" % sys.argv[0].split(os.path.sep)[-1], description=textwrap.dedent(self.__doc__), formatter_class=argparse.RawDescriptionHelpFormatter) parser.add_argument('--database', '-d', dest="database", help="Database name") parser.add_argument('--path', '-p', action='append', help="File or directory path") parser.add_argument('--verbose', '-v', action='count', default=0) opt, unknown = parser.parse_known_args(args) if not opt.database and not opt.path: parser.print_help() sys.exit() c = cloc.Cloc() if opt.database: config.parse_config(['-d', opt.database] + unknown) c.count_database(opt.database) if opt.path: for i in opt.path: c.count_path(i) c.report(opt.verbose)
def test(self, args=None): """ Run tests """ if not args: args = [] if not self._init_odoo(): return False # pylint: disable=C0415,E0401 import odoo from odoo.tools import config # Append needed parameter if self.get(base.SECTION, "coverage"): for path in self.get("odoo", "addons_path", default=[]): args.extend([f"--cov={path}", path]) args += ["--cov-report=html", "--cov-report=term"] # Load the odoo configuration with self._manage(): config.parse_config(["-c", base.ODOO_CONFIG]) odoo.cli.server.report_configuration() # Pass the arguments to pytest sys.argv = sys.argv[:1] + args result = pytest.main() if result and result != pytest.ExitCode.NO_TESTS_COLLECTED: return result return 0
def main(starter, conf, version=None, just_test=False, server_wide_modules=None, gevent_script_path=None): """Call the `starter` script, dispatching configuration. All arguments are set in the standalone script produced by buildout through entry point options. :param starter: path to the main script source file (currently ``openerp-server``) :param conf: path to the Odoo configuration file (managed by the recipe) :param version: Odoo major version :param server_wide_modules: additional server wide modules, to pass with the ``--load`` command-line option (ignored if the option is actually there on the command line) :type version: tuple of integers :param just_test: if True, only run unit tests """ arguments = ['-c', conf] if just_test: arguments.extend(('--log-level', 'test' if version >= (6, 0) else 'info', '--stop-after-init')) if version >= (7, 0): arguments.append('--test-enable') if server_wide_modules: for opt in sys.argv[1:]: if opt.startswith('--load'): break else: arguments.append('--load=' + ','.join(server_wide_modules)) if '--install-all' in sys.argv: sys.argv.remove('--install-all') from odoo.tools import config # Maybe we should preparse config in all cases and therefore avoid # adding the '-c' on the fly ? # Still, cautious about pre-6.1 versions config.parse_config(['-c', conf]) from odoo.modules import get_modules arguments.extend(('-i', ','.join(get_modules()))) insert_args(arguments) if version >= (8, 0): # always true in a.r.odoo, but keeping for now assert gevent_script_path is not None patch_odoo.do_patch(gevent_script_path) os.chdir(os.path.split(starter)[0]) glob = globals() glob['__name__'] = '__main__' glob['__file__'] = starter sys.argv[0] = starter try: execfile(starter, globals()) except SystemExit as exc: return exc.code
def __init__(self, conffile, buildout_dir, parse_config=True): self.buildout_dir = buildout_dir self.openerp_config_file = conffile self._registry = self.cr = None if parse_config: config.parse_config(['-c', conffile])
def apply_action(self, args=None): """ Apply in the configuration defined actions on the database """ actions = self.get("actions", default={}) args, _ = load_action_arguments(args or [], list(actions)) if not self._init_odoo(): return # pylint: disable=C0415,E0401 import odoo from odoo.tools import config # Load the Odoo configuration config.parse_config(["-c", base.ODOO_CONFIG]) odoo.cli.server.report_configuration() db_name = config["db_name"] utils.info(f"Running {args.action}") with self._manage(): with self.env(db_name) as env: for name, item in actions[args.action].items(): utils.info(f"{args.action.capitalize()} {name}") model = item.get("model") if not isinstance(model, str): utils.error("Model must be string") continue domain = item.get("domain", []) if not isinstance(domain, list): utils.error("Domain must be list") continue ctx = env.context.copy() ctx.update(item.get("context") or {}) action_env = odoo.api.Environment(env.cr, env.uid, ctx) act = item.get("action", "update") if act == "update": self._action_update(action_env, model, domain, item) elif act == "delete": self._action_delete(action_env, model, domain, item) elif act == "insert": self._action_insert(action_env, model, domain, item) else: utils.error(f"Undefined action {act}")
def init(self, args): config.parse_config(args) odoo.cli.server.report_configuration() odoo.service.server.start(preload=[], stop=True) signal.signal(signal.SIGINT, raise_keyboard_interrupt)
def main(ctx, database_url, database_maxconn, redis_url, redis_maxconn, aws_access_key_id, aws_secret_access_key, aws_region, s3_bucket, s3_endpoint_url, s3_custom_domain, s3_addressing_style, addons, tmp_dir, debug, ptvsd_url, statsd_host): # Setup logger first, then import further modules import odooku.logger odooku.logger.setup(debug=debug, statsd_host=statsd_host) logger = logging.getLogger(__name__) from odooku.backends import register_backend from odooku.backends.s3 import S3Backend from odooku.backends.redis import RedisBackend # Setup S3 if s3_bucket: register_backend( 's3', S3Backend( bucket=s3_bucket, aws_access_key_id=aws_access_key_id, aws_secret_access_key=aws_secret_access_key, aws_region=aws_region, endpoint_url=s3_endpoint_url, custom_domain=s3_custom_domain, addressing_style=s3_addressing_style, )) # Setup Redis if redis_url: redis_url = urlparse.urlparse(redis_url) register_backend( 'redis', RedisBackend( host=redis_url.hostname, port=redis_url.port, password=redis_url.password, db_number=redis_url.path[1:] if redis_url.path else None, maxconn=redis_maxconn)) # Setup PTVSD if ptvsd_url: if ptvsd: ptvsd_url = urlparse.urlparse(ptvsd_url) ptvsd.enable_attach(ptvsd_url.password, address=(ptvsd_url.hostname, ptvsd_url.port)) logger.warning("PTVSD Enabled") else: logger.warning("PTVSD_URL configured but PTVSD not found.") # Setup Odoo import odoo from odoo.tools import config # Always account for multiple processes: # - we can run multiple dyno's consisting of: # - web # - worker odoo.multi_process = True # Patch odoo config config.parse_config() config['data_dir'] = tmp_dir config['addons_path'] = addons config['demo'] = {} config['without_demo'] = 'all' config['debug_mode'] = debug if database_url: database_url = urlparse.urlparse(database_url) db_name = database_url.path[1:] if database_url.path else False config['db_name'] = db_name config['db_user'] = database_url.username config['db_password'] = database_url.password config['db_host'] = database_url.hostname config['db_port'] = database_url.port config['db_maxconn'] = database_maxconn config['list_db'] = not bool(db_name) else: params.no_db = True ctx.obj.update({ 'debug': debug, 'config': config, 'params': params, 'logger': logger })
def update(self, args=None): """ Install/update Odoo modules """ args, _ = load_update_arguments(args or []) self.generate_config() if not self._init_odoo(): return # pylint: disable=C0415,E0401 import odoo from odoo.tools import config # Load the Odoo configuration config.parse_config(["-c", base.ODOO_CONFIG]) odoo.cli.server.report_configuration() db_name = config["db_name"] with self._manage(): # Ensure that the database is initialized db = odoo.sql_db.db_connect(db_name) initialized = False with closing(db.cursor()) as cr: if not odoo.modules.db.is_initialized(cr): utils.info("Initializing the database") odoo.modules.db.initialize(cr) cr.commit() initialized = True # Execute the pre install script self._run_migration(db_name, "pre_install") # Get the modules to install if initialized: uninstalled = self.get_modules() else: installed = self.get_installed_modules(db_name) modules = self.get_modules() uninstalled = modules.difference(installed) # Install all modules utils.info("Installing all modules") if uninstalled: self.install_all(db_name, uninstalled) # Execute the pre update script self._run_migration(db_name, "pre_update") # Update all modules which aren't installed before if args.modules: self.update_all(db_name, args.modules) elif args.listed: self.update_listed(db_name, uninstalled) elif args.all: self.update_all(db_name, uninstalled) else: self.update_changed(db_name, uninstalled) # Execute the post update script self._run_migration(db_name, "post_update") # Finish everything with self.env(db_name) as env: # Set the user passwords if previously initialized users = self.get("odoo", "users", default={}) if (initialized or args.passwords) and users: utils.info("Setting user passwords") model = env["res.users"] for user, password in users.items(): domain = [("login", "=", user)] model.search(domain).write({"password": password}) # Write the version into the database utils.info("Setting database version") version = self.get(base.SECTION, "version", default="0.0") env["ir.config_parameter"].set_param("db_version", version)
import odoo from odoo.tools import config from odoo.models import DEFAULT_SERVER_DATE_FORMAT from datetime import datetime import time import os import random path = os.path.abspath(os.path.dirname(__file__)) args = [ '-c', './local.conf', '-d', 'mdias2', '--addons-path', '%s,%s' % (os.path.abspath(os.path.join(path, '../../', './%s' % 'mdias_addons')), os.path.abspath(os.path.join(path, '../../', './%s' % 'addons'))) ] config.parse_config(args) config.parse_config(args) db_name = config['db_name'] date_range = ['2019-08-01', '2019-09-05'] DATA_MAX = 10000 DAY_SECOND = 24 * 60 * 60 DISPATCH_STATE = [ 'draft', 'wait_accept', 'accepted', 'wait_executing', 'executing', 'rebacked', 'canceled', 'finished' ]