def enqueue_events_for_site(site, queued_jobs): def log_and_raise(): dataent.logger(__name__).error( 'Exception in Enqueue Events for Site {0}'.format(site) + '\n' + dataent.get_traceback()) raise # pylint: disable=misplaced-bare-raise try: dataent.init(site=site) if dataent.local.conf.maintenance_mode: return if dataent.local.conf.pause_scheduler: return dataent.connect() if is_scheduler_disabled(): return enqueue_events(site=site, queued_jobs=queued_jobs) dataent.logger(__name__).debug( 'Queued events for site {0}'.format(site)) except pymysql.OperationalError as e: if e.args[0] == ER.ACCESS_DENIED_ERROR: dataent.logger(__name__).debug( 'Access denied for site {0}'.format(site)) else: log_and_raise() except: log_and_raise() finally: dataent.destroy()
def _reinstall(site, admin_password=None, mariadb_root_username=None, mariadb_root_password=None, yes=False, verbose=False): if not yes: click.confirm( 'This will wipe your database. Are you sure you want to reinstall?', abort=True) try: dataent.init(site=site) dataent.connect() dataent.clear_cache() installed = dataent.get_installed_apps() dataent.clear_cache() except Exception: installed = [] finally: if dataent.db: dataent.db.close() dataent.destroy() dataent.init(site=site) _new_site(dataent.conf.db_name, site, verbose=verbose, force=True, reinstall=True, install_apps=installed, mariadb_root_username=mariadb_root_username, mariadb_root_password=mariadb_root_password, admin_password=admin_password)
def backup(context, with_files=False, backup_path_db=None, backup_path_files=None, backup_path_private_files=None, quiet=False): "Backup" from dataent.utils.backups import scheduled_backup verbose = context.verbose for site in context.sites: dataent.init(site=site) dataent.connect() odb = scheduled_backup( ignore_files=not with_files, backup_path_db=backup_path_db, backup_path_files=backup_path_files, backup_path_private_files=backup_path_private_files, force=True) if verbose: from dataent.utils import now print("database backup taken -", odb.backup_path_db, "- on", now()) if with_files: print("files backup taken -", odb.backup_path_files, "- on", now()) print("private files backup taken -", odb.backup_path_private_files, "- on", now()) dataent.destroy()
def scheduler(context, state, site=None): from dataent.installer import update_site_config import dataent.utils.scheduler if not site: site = get_site(context) try: dataent.init(site=site) if state == 'pause': update_site_config('pause_scheduler', 1) elif state == 'resume': update_site_config('pause_scheduler', 0) elif state == 'disable': dataent.connect() dataent.utils.scheduler.disable_scheduler() dataent.db.commit() elif state == 'enable': dataent.connect() dataent.utils.scheduler.enable_scheduler() dataent.db.commit() print('Scheduler {0}d for site {1}'.format(state, site)) finally: dataent.destroy()
def request(context, args=None, path=None): "Run a request as an admin" import dataent.handler import dataent.api for site in context.sites: try: dataent.init(site=site) dataent.connect() if args: if "?" in args: dataent.local.form_dict = dataent._dict( [a.split("=") for a in args.split("?")[-1].split("&")]) else: dataent.local.form_dict = dataent._dict() if args.startswith("/api/method"): dataent.local.form_dict.cmd = args.split("?")[0].split( "/")[-1] elif path: with open(os.path.join('..', path), 'r') as f: args = json.loads(f.read()) dataent.local.form_dict = dataent._dict(args) dataent.handler.execute_cmd(dataent.form_dict.cmd) print(dataent.response) finally: dataent.destroy()
def list_apps(context): "List apps in site" site = get_site(context) dataent.init(site=site) dataent.connect() print("\n".join(dataent.get_installed_apps())) dataent.destroy()
def import_csv(context, path, only_insert=False, submit_after_import=False, ignore_encoding_errors=False, no_email=True): "Import CSV using data import" from dataent.core.doctype.data_import import importer from dataent.utils.csvutils import read_csv_content site = get_site(context) if not os.path.exists(path): path = os.path.join('..', path) if not os.path.exists(path): print('Invalid path {0}'.format(path)) sys.exit(1) with open(path, 'r') as csvfile: content = read_csv_content(csvfile.read()) dataent.init(site=site) dataent.connect() try: importer.upload(content, submit_after_import=submit_after_import, no_email=no_email, ignore_encoding_errors=ignore_encoding_errors, overwrite=not only_insert, via_console=True) dataent.db.commit() except Exception: print(dataent.get_traceback()) dataent.destroy()
def export_csv(context, doctype, path): "Export data import template with data for DocType" from dataent.core.doctype.data_import import data_import for site in context.sites: try: dataent.init(site=site) dataent.connect() data_import.export_csv(doctype, path) finally: dataent.destroy()
def export_json(context, doctype, path, name=None): "Export doclist as json to the given path, use '-' as name for Singles." from dataent.core.doctype.data_import import data_import for site in context.sites: try: dataent.init(site=site) dataent.connect() data_import.export_json(doctype, path, name=name) finally: dataent.destroy()
def export_doc(context, doctype, docname): "Export a single document to csv" import dataent.modules for site in context.sites: try: dataent.init(site=site) dataent.connect() dataent.modules.export_doc(doctype, docname) finally: dataent.destroy()
def remove_from_installed_apps(context, app): "Remove app from site's installed-apps list" from dataent.installer import remove_from_installed_apps for site in context.sites: try: dataent.init(site=site) dataent.connect() remove_from_installed_apps(app) finally: dataent.destroy()
def reload_doctype(context, doctype): "Reload schema for a DocType" for site in context.sites: try: dataent.init(site=site) dataent.connect() dataent.reload_doctype(doctype, force=context.force) dataent.db.commit() finally: dataent.destroy()
def install_app(context, app): "Install a new app to site" from dataent.installer import install_app as _install_app for site in context.sites: dataent.init(site=site) dataent.connect() try: _install_app(app, verbose=context.verbose) finally: dataent.destroy()
def export_fixtures(context): "Export fixtures" from dataent.utils.fixtures import export_fixtures for site in context.sites: try: dataent.init(site=site) dataent.connect() export_fixtures() finally: dataent.destroy()
def uninstall(context, app, dry_run=False, yes=False): "Remove app and linked modules from site" from dataent.installer import remove_app for site in context.sites: try: dataent.init(site=site) dataent.connect() remove_app(app, dry_run, yes) finally: dataent.destroy()
def clear_website_cache(context): "Clear website cache" import dataent.website.render for site in context.sites: try: dataent.init(site=site) dataent.connect() dataent.website.render.clear_cache() finally: dataent.destroy()
def trigger_scheduler_event(context, event): "Trigger a scheduler event" import dataent.utils.scheduler for site in context.sites: try: dataent.init(site=site) dataent.connect() dataent.utils.scheduler.trigger(site, event, now=True) finally: dataent.destroy()
def set_maintenance_mode(context, state, site=None): from dataent.installer import update_site_config if not site: site = get_site(context) try: dataent.init(site=site) update_site_config('maintenance_mode', 1 if (state == 'on') else 0) finally: dataent.destroy()
def run_patch(context, module): "Run a particular patch" import dataent.modules.patch_handler for site in context.sites: dataent.init(site=site) try: dataent.connect() dataent.modules.patch_handler.run_single(module, force=context.force) finally: dataent.destroy()
def destroy_all_sessions(context, reason=None): "Clear sessions of all users (logs them out)" import dataent.sessions for site in context.sites: try: dataent.init(site=site) dataent.connect() dataent.sessions.clear_all_sessions(reason) dataent.db.commit() finally: dataent.destroy()
def add_system_manager(context, email, first_name, last_name, send_welcome_email, password): "Add a new system manager to a site" import dataent.utils.user for site in context.sites: dataent.connect(site=site) try: dataent.utils.user.add_system_manager(email, first_name, last_name, send_welcome_email, password) dataent.db.commit() finally: dataent.destroy()
def application(request): response = None try: rollback = True init_request(request) if dataent.local.form_dict.cmd: response = dataent.handler.handle() elif dataent.request.path.startswith("/api/"): if dataent.local.form_dict.data is None: dataent.local.form_dict.data = request.get_data() response = dataent.api.handle() elif dataent.request.path.startswith('/backups'): response = dataent.utils.response.download_backup(request.path) elif dataent.request.path.startswith('/private/files/'): response = dataent.utils.response.download_private_file( request.path) elif dataent.local.request.method in ('GET', 'HEAD', 'POST'): response = dataent.website.render.render() else: raise NotFound except HTTPException as e: return e except dataent.SessionStopped as e: response = dataent.utils.response.handle_session_stopped() except Exception as e: response = handle_exception(e) else: rollback = after_request(rollback) finally: if dataent.local.request.method in ("POST", "PUT") and dataent.db and rollback: dataent.db.rollback() # set cookies if response and hasattr(dataent.local, 'cookie_manager'): dataent.local.cookie_manager.flush_cookies(response=response) dataent.destroy() return response
def disable_scheduler(context): "Disable scheduler" import dataent.utils.scheduler for site in context.sites: try: dataent.init(site=site) dataent.connect() dataent.utils.scheduler.disable_scheduler() dataent.db.commit() print("Disabled for", site) finally: dataent.destroy()
def clear_cache(context): "Clear cache, doctype cache and defaults" import dataent.sessions import dataent.website.render from dataent.desk.notifications import clear_notifications for site in context.sites: try: dataent.connect(site) dataent.clear_cache() clear_notifications() dataent.website.render.clear_cache() finally: dataent.destroy()
def reset_perms(context): "Reset permissions for all doctypes" from dataent.permissions import reset_perms for site in context.sites: try: dataent.init(site=site) dataent.connect() for d in dataent.db.sql_list("""select name from `tabDocType` where istable=0 and custom=0"""): dataent.clear_cache(doctype=d) reset_perms(d) finally: dataent.destroy()
def execute_job(site, method, event, job_name, kwargs, user=None, is_async=True, retry=0): '''Executes job in a worker, performs commit/rollback and logs if there is any error''' from dataent.utils.scheduler import log if is_async: dataent.connect(site) if os.environ.get('CI'): dataent.flags.in_test = True if user: dataent.set_user(user) if isinstance(method, string_types): method_name = method method = dataent.get_attr(method) else: method_name = cstr(method.__name__) try: method(**kwargs) except (pymysql.InternalError, dataent.RetryBackgroundJobError) as e: dataent.db.rollback() if (retry < 5 and (isinstance(e, dataent.RetryBackgroundJobError) or e.args[0] in (ER.LOCK_DEADLOCK, ER.LOCK_WAIT_TIMEOUT))): # retry the job if # 1213 = deadlock # 1205 = lock wait timeout # or RetryBackgroundJobError is explicitly raised dataent.destroy() time.sleep(retry+1) return execute_job(site, method, event, job_name, kwargs, is_async=is_async, retry=retry+1) else: log(method_name, message=repr(locals())) raise except: dataent.db.rollback() log(method_name, message=repr(locals())) raise else: dataent.db.commit() finally: if is_async: dataent.destroy()
def _build_docs_once(site, app, docs_version, target, local, only_content_updated=False): from dataent.utils.setup_docs import setup_docs try: dataent.init(site=site) dataent.connect() make = setup_docs(app, target) if not only_content_updated: make.build(docs_version) #make.make_docs(target, local) finally: dataent.destroy()
def migrate(context, rebuild_website=False): "Run patches, sync schema and rebuild files/translations" from dataent.migrate import migrate for site in context.sites: print('Migrating', site) dataent.init(site=site) dataent.connect() try: migrate(context.verbose, rebuild_website=rebuild_website) finally: dataent.destroy() compileall.compile_dir('../apps', quiet=1, rx=re.compile('.*node_modules.*'))
def _bulk_rename(context, doctype, path): "Rename multiple records via CSV file" from dataent.model.rename_doc import bulk_rename from dataent.utils.csvutils import read_csv_content site = get_site(context) with open(path, 'r') as csvfile: rows = read_csv_content(csvfile.read()) dataent.init(site=site) dataent.connect() bulk_rename(doctype, rows, via_console=True) dataent.destroy()
def rebuild_global_search(context): '''Setup help table in the current site (called after migrate)''' from dataent.utils.global_search import (get_doctypes_with_global_search, rebuild_for_doctype) for site in context.sites: try: dataent.init(site) dataent.connect() doctypes = get_doctypes_with_global_search() for i, doctype in enumerate(doctypes): rebuild_for_doctype(doctype) update_progress_bar('Rebuilding Global Search', i, len(doctypes)) finally: dataent.destroy()