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()
