def latest(rebuild_website_config=True, quiet=False): import frappe.modules.patch_handler import frappe.model.sync from frappe.website import rebuild_config from frappe.utils.fixtures import sync_fixtures import frappe.translate from frappe.website import statics verbose = not quiet frappe.connect() try: # run patches frappe.modules.patch_handler.run_all() # sync frappe.model.sync.sync_all(verbose=verbose) sync_fixtures() statics.sync().start() # build website config if any changes in templates etc. if rebuild_website_config: rebuild_config() frappe.translate.clear_cache() finally: frappe.destroy()
def scheduler_task(site, event, handler, now=False):
from frappe.utils.scheduler import log
traceback = ""
task_logger.info('running {handler} for {site} for event: {event}'.format(handler=handler, site=site, event=event))
try:
frappe.init(site=site)
if not create_lock(handler):
return
if not now:
frappe.connect(site=site)
frappe.get_attr(handler)()
except Exception:
frappe.db.rollback()
traceback = log(handler, "Method: {event}, Handler: {handler}".format(event=event, handler=handler))
task_logger.warn(traceback)
raise
else:
frappe.db.commit()
finally:
delete_lock(handler)
if not now:
frappe.destroy()
task_logger.info('ran {handler} for {site} for event: {event}'.format(handler=handler, site=site, event=event))
def execute(context, method, args=None, kwargs=None):
"execute a function"
for site in context.sites:
try:
frappe.init(site=site)
frappe.connect()
if args:
args = eval(args)
else:
args = ()
if kwargs:
kwargs = eval(args)
else:
kwargs = {}
ret = frappe.get_attr(method)(*args, **kwargs)
if frappe.db:
frappe.db.commit()
finally:
frappe.destroy()
if ret:
print json.dumps(ret)
def list_apps(context):
"List apps in site"
site = get_site(context)
frappe.init(site=site)
frappe.connect()
print("\n".join(frappe.get_installed_apps()))
frappe.destroy()
def backup(
context, with_files=False, backup_path_db=None, backup_path_files=None, backup_path_private_files=None, quiet=False
):
"Backup"
from frappe.utils.backups import scheduled_backup
verbose = context.verbose
for site in context.sites:
frappe.init(site=site)
frappe.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 frappe.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()
frappe.destroy()
def sendmail(site, communication_name, print_html=None, print_format=None, attachments=None,
recipients=None, cc=None):
try:
frappe.connect(site=site)
# upto 3 retries
for i in xrange(3):
try:
communication = frappe.get_doc("Communication", communication_name)
communication._notify(print_html=print_html, print_format=print_format, attachments=attachments,
recipients=recipients, cc=cc)
except MySQLdb.OperationalError, e:
# deadlock, try again
if e.args[0]==1213:
frappe.db.rollback()
time.sleep(1)
continue
else:
raise
else:
break
except:
frappe.db.rollback()
else:
frappe.db.commit()
finally:
frappe.destroy()
def build_website(verbose=False): from frappe.website import render, statics frappe.connect() render.clear_cache() statics.sync(verbose=verbose).start(True) frappe.db.commit() frappe.destroy()
def enqueue_events_for_site(site, queued_jobs):
try:
frappe.init(site=site)
if frappe.local.conf.maintenance_mode:
return
if frappe.local.conf.pause_scheduler:
return
frappe.connect()
if is_scheduler_disabled():
return
enqueue_events(site=site, queued_jobs=queued_jobs)
# TODO this print call is a tempfix till logging is fixed!
print 'Queued events for site {0}'.format(site)
frappe.logger(__name__).debug('Queued events for site {0}'.format(site))
except:
frappe.logger(__name__).error('Exception in Enqueue Events for Site {0}'.format(site))
raise
finally:
frappe.destroy()
def request(context, args=None, path=None):
"Run a request as an admin"
import frappe.handler
import frappe.api
for site in context.sites:
try:
frappe.init(site=site)
frappe.connect()
if args:
if "?" in args:
frappe.local.form_dict = frappe._dict([a.split("=") for a in args.split("?")[-1].split("&")])
else:
frappe.local.form_dict = frappe._dict()
if args.startswith("/api/method"):
frappe.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())
frappe.local.form_dict = frappe._dict(args)
frappe.handler.execute_cmd(frappe.form_dict.cmd)
print(frappe.response)
finally:
frappe.destroy()
def send_newsletter(site, newsletter, event):
# hack! pass event="bulk_long" to queue in longjob queue
try:
frappe.connect(site=site)
doc = frappe.get_doc("Newsletter", newsletter)
doc.send_bulk()
except:
frappe.db.rollback()
task_logger.error(site)
task_logger.error(frappe.get_traceback())
# wasn't able to send emails :(
doc.db_set("email_sent", 0)
frappe.db.commit()
log("send_newsletter")
raise
else:
frappe.db.commit()
finally:
frappe.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 tool"
from frappe.core.page.data_import_tool import importer
from frappe.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())
frappe.init(site=site)
frappe.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)
frappe.db.commit()
except Exception:
print(frappe.get_traceback())
frappe.destroy()
def reset_perms():
frappe.connect()
for d in frappe.db.sql_list("""select name from `tabDocType`
where ifnull(istable, 0)=0 and ifnull(custom, 0)=0"""):
frappe.clear_cache(doctype=d)
frappe.reset_perms(d)
frappe.destroy()
def _new_site(db_name, site, mariadb_root_username=None, mariadb_root_password=None, admin_password=None, verbose=False, install_apps=None, source_sql=None,force=False, reinstall=False):
"Install a new Frappe site"
from frappe.installer import install_db, make_site_dirs
from frappe.installer import install_app as _install_app
import frappe.utils.scheduler
frappe.init(site=site)
try:
# enable scheduler post install?
enable_scheduler = _is_scheduler_enabled()
except:
enable_scheduler = False
install_db(root_login=mariadb_root_username, root_password=mariadb_root_password, db_name=db_name, admin_password=admin_password, verbose=verbose, source_sql=source_sql,force=force, reinstall=reinstall)
make_site_dirs()
_install_app("frappe", verbose=verbose, set_as_patched=not source_sql)
if frappe.conf.get("install_apps"):
for app in frappe.conf.install_apps:
_install_app(app, verbose=verbose, set_as_patched=not source_sql)
if install_apps:
for app in install_apps:
_install_app(app, verbose=verbose, set_as_patched=not source_sql)
frappe.utils.scheduler.toggle_scheduler(enable_scheduler)
scheduler_status = "disabled" if frappe.utils.scheduler.is_scheduler_disabled() else "enabled"
print "*** Scheduler is", scheduler_status, "***"
frappe.destroy()
def disable_scheduler(): import frappe.utils.scheduler frappe.connect() frappe.utils.scheduler.disable_scheduler() frappe.db.commit() print "Disabled" frappe.destroy()
def scheduler(context, state, site=None):
from frappe.installer import update_site_config
import frappe.utils.scheduler
if not site:
site = get_site(context)
try:
frappe.init(site=site)
if state == "pause":
update_site_config("pause_scheduler", 1)
elif state == "resume":
update_site_config("pause_scheduler", 0)
elif state == "disable":
frappe.connect()
frappe.utils.scheduler.disable_scheduler()
frappe.db.commit()
elif state == "enable":
frappe.connect()
frappe.utils.scheduler.enable_scheduler()
frappe.db.commit()
print "Scheduler {0}d for site {1}".format(state, site)
finally:
frappe.destroy()
def import_csv(context, path, only_insert=False, submit_after_import=False, ignore_encoding_errors=False):
"Import CSV using data import tool"
from frappe.core.page.data_import_tool import importer
from frappe.utils.csvutils import read_csv_content
site = get_site(context)
with open(path, "r") as csvfile:
content = read_csv_content(csvfile.read())
frappe.init(site=site)
frappe.connect()
try:
importer.upload(
content,
submit_after_import=submit_after_import,
ignore_encoding_errors=ignore_encoding_errors,
overwrite=not only_insert,
via_console=True,
)
frappe.db.commit()
except Exception:
print frappe.get_traceback()
frappe.destroy()
def list_apps(context): "Reinstall site ie. wipe all data and start over" site = get_single_site(context) frappe.init(site=site) frappe.connect() print "\n".join(frappe.get_installed_apps()) frappe.destroy()
def execute(method): frappe.connect() ret = frappe.get_attr(method)() frappe.db.commit() frappe.destroy() if ret: print ret
def clear_cache(): import frappe.sessions from frappe.core.doctype.notification_count.notification_count import clear_notifications frappe.connect() frappe.clear_cache() clear_notifications() frappe.destroy()
def set_config(context, key, value): "Insert/Update a value in site_config.json" from frappe.installer import update_site_config for site in context.sites: frappe.init(site=site) update_site_config(key, value) frappe.destroy()
def patch(patch_module, force=False): import frappe.modules.patch_handler frappe.connect() frappe.local.patch_log_list = [] frappe.modules.patch_handler.run_single(patch_module, force=force) print "\n".join(frappe.local.patch_log_list) frappe.destroy()
def set_admin_password(admin_password):
import frappe
frappe.connect()
frappe.db.sql("""update __Auth set `password`=password(%s)
where user='******'""", (admin_password,))
frappe.db.commit()
frappe.destroy()
def migrate(context, rebuild_website=False): "Run patches, sync schema and rebuild files/translations" import frappe.modules.patch_handler import frappe.model.sync from frappe.utils.fixtures import sync_fixtures import frappe.translate from frappe.desk.notifications import clear_notifications for site in context.sites: print 'Migrating', site frappe.init(site=site) frappe.connect() try: prepare_for_update() # run patches frappe.modules.patch_handler.run_all() # sync frappe.model.sync.sync_all(verbose=context.verbose) frappe.translate.clear_cache() sync_fixtures() clear_notifications() finally: frappe.destroy() if rebuild_website: call_command(build_website, context) else: call_command(sync_www, context)
def scheduler(context, state, site=None):
from frappe.installer import update_site_config
import frappe.utils.scheduler
if not site:
site = get_site(context)
try:
frappe.init(site=site)
if state == 'pause':
update_site_config('pause_scheduler', 1)
elif state == 'resume':
update_site_config('pause_scheduler', 0)
elif state == 'disable':
frappe.connect()
frappe.utils.scheduler.disable_scheduler()
frappe.db.commit()
elif state == 'enable':
frappe.connect()
frappe.utils.scheduler.enable_scheduler()
frappe.db.commit()
print('Scheduler {0}d for site {1}'.format(state, site))
finally:
frappe.destroy()
def latest(rebuild_website=True, quiet=False): import frappe.modules.patch_handler import frappe.model.sync from frappe.utils.fixtures import sync_fixtures import frappe.translate from frappe.core.doctype.notification_count.notification_count import clear_notifications verbose = not quiet frappe.connect() try: # run patches frappe.modules.patch_handler.run_all() # sync frappe.model.sync.sync_all(verbose=verbose) frappe.translate.clear_cache() sync_fixtures() clear_notifications() if rebuild_website: build_website() finally: frappe.destroy()
def add_to_installed_apps(*apps): from frappe.installer import add_to_installed_apps frappe.connect() all_apps = frappe.get_all_apps(with_frappe=True) for each in apps: if each in all_apps: add_to_installed_apps(each, rebuild_website=False) frappe.destroy()
def domain(host_url=None):
frappe.connect()
if host_url:
frappe.db.set_value("Website Settings", None, "subdomain", host_url)
frappe.db.commit()
else:
print frappe.db.get_value("Website Settings", None, "subdomain")
frappe.destroy()
def pull_from_email_account(site, email_account):
try:
frappe.init(site=site)
frappe.connect(site=site)
email_account = frappe.get_doc("Email Account", email_account)
email_account.receive()
frappe.db.commit()
finally:
frappe.destroy()
def make(domain='Manufacturing'): frappe.flags.domain = domain frappe.flags.mute_emails = True setup_data() site = frappe.local.site frappe.destroy() frappe.init(site) frappe.connect() simulate()
def validate(site):
frappe.init(site=site, sites_path=sites_path)
make_site_dirs()
backup()
frappe.init(site=site, sites_path=sites_path)
frappe.connect()
if not executed(last_3_patch):
raise Exception, "site not ready to migrate to version 4"
frappe.destroy()
def execute(**kwargs):
"""
Use this to install apps; it checks for apps that are already installed.
bench --site [site_name] execute [module_name].install_apps.execute
--kwargs "{'apps': ['rebrandly_integration', 'printnode_integration']}"
"""
apps_installed = frappe.db.sql(
"""SELECT DISTINCT app_name FROM `tabModule Def`""", as_dict=True)
apps_installed = [v.app_name for v in apps_installed]
for app in kwargs['apps']:
if app not in apps_installed:
print 'Installing app {0}'.format(app)
frappe.init(site=kwargs['site'])
frappe.connect()
try:
_install_app(app, verbose=False)
finally:
frappe.destroy()
def import_csv(context, path, only_insert=False, submit_after_import=False, ignore_encoding_errors=False): "Import CSV using data import tool" from frappe.core.page.data_import_tool import importer from frappe.utils.csvutils import read_csv_content site = get_single_site(context) with open(path, 'r') as csvfile: content = read_csv_content(csvfile.read()) frappe.init(site=site) frappe.connect() try: importer.upload(content, submit_after_import=submit_after_import, ignore_encoding_errors=ignore_encoding_errors, overwrite=not only_insert, via_console=True) frappe.db.commit() except Exception: print frappe.get_traceback() frappe.destroy()
def migrate(context, rebuild_website=False, skip_failing=False):
"Run patches, sync schema and rebuild files/translations"
from frappe.migrate import migrate
for site in context.sites:
print('Migrating', site)
frappe.init(site=site)
frappe.connect()
try:
migrate(context.verbose,
rebuild_website=rebuild_website,
skip_failing=skip_failing)
finally:
frappe.destroy()
if not context.sites:
raise SiteNotSpecifiedError
print("Compiling Python Files...")
compileall.compile_dir('../apps',
quiet=1,
rx=re.compile('.*node_modules.*'))
def extract_tar_files(site_name, file_path, folder_name):
# Need to do frappe.init to maintain the site locals
frappe.init(site=site_name)
abs_site_path = os.path.abspath(frappe.get_site_path())
# Copy the files to the parent directory and extract
shutil.copy2(os.path.abspath(file_path), abs_site_path)
# Get the file name splitting the file path on
tar_name = os.path.split(file_path)[1]
tar_path = os.path.join(abs_site_path, tar_name)
try:
subprocess.check_output(['tar', 'xvf', tar_path, '--strip', '2'],
cwd=abs_site_path)
except:
raise
finally:
frappe.destroy()
return tar_path
def request(context, args):
"Run a request as an admin"
import frappe.handler
import frappe.api
for site in context.sites:
try:
frappe.init(site=site)
frappe.connect()
if "?" in args:
frappe.local.form_dict = frappe._dict([a.split("=") for a in args.split("?")[-1].split("&")])
else:
frappe.local.form_dict = frappe._dict()
if args.startswith("/api/method"):
frappe.local.form_dict.cmd = args.split("?")[0].split("/")[-1]
frappe.handler.execute_cmd(frappe.form_dict.cmd)
print frappe.response
finally:
frappe.destroy()
def migrate_sites(maintenance_mode=False):
installed_sites = ":".join(get_sites())
sites = os.environ.get("SITES", installed_sites).split(":")
if not maintenance_mode:
maintenance_mode = cint(os.environ.get("MAINTENANCE_MODE"))
if maintenance_mode:
set_maintenance_mode(True)
for site in sites:
print('Migrating', site)
frappe.init(site=site)
frappe.connect()
try:
from frappe.migrate import migrate
migrate()
finally:
frappe.destroy()
# Disable maintenance mode after migration
set_maintenance_mode(False)
def move(dest_dir=None, site=None): import os if not dest_dir: raise Exception, "--dest_dir is required for --move" if not os.path.isdir(dest_dir): raise Exception, "destination is not a directory or does not exist" old_path = frappe.utils.get_site() new_path = os.path.join(dest_dir, site) # check if site dump of same name already exists site_dump_exists = True count = 0 while site_dump_exists: final_new_path = new_path + (count and str(count) or "") site_dump_exists = os.path.exists(final_new_path) count = int(count or 0) + 1 os.rename(old_path, final_new_path) frappe.destroy() return os.path.basename(final_new_path)
def trigger_scheduler_event(context, event):
import frappe.utils.scheduler
exit_code = 0
for site in context.sites:
try:
frappe.init(site=site)
frappe.connect()
try:
frappe.get_doc("Scheduled Job Type", {"method": event}).execute()
except frappe.DoesNotExistError:
click.secho(f"Event {event} does not exist!", fg="red")
exit_code = 1
finally:
frappe.destroy()
if not context.sites:
raise SiteNotSpecifiedError
sys.exit(exit_code)
def _build_docs_once(site,
app,
docs_version,
target,
local,
only_content_updated=False):
from frappe.utils.setup_docs import setup_docs
try:
frappe.init(site=site)
frappe.connect()
make = setup_docs(app)
if not only_content_updated:
make.build(docs_version)
make.make_docs(target, local)
finally:
frappe.destroy()
def migrate_sites(maintenance_mode=False):
installed_sites = ":".join(get_sites())
sites = os.environ.get("SITES", installed_sites).split(":")
if not maintenance_mode:
maintenance_mode = True if os.environ.get(
"MAINTENANCE_MODE") else False
if maintenance_mode:
set_maintenance_mode(True)
for site in sites:
print('Migrating', site)
frappe.init(site=site)
frappe.connect()
try:
migrate()
finally:
frappe.destroy()
if maintenance_mode:
set_maintenance_mode(False)
def set_admin_password(context, admin_password, logout_all_sessions=False):
"Set Administrator password for a site"
import getpass
from frappe.utils.password import update_password
for site in context.sites:
try:
frappe.init(site=site)
while not admin_password:
admin_password = getpass.getpass(
"Administrator's password for {0}: ".format(site))
frappe.connect()
update_password(user='******',
pwd=admin_password,
logout_all_sessions=logout_all_sessions)
frappe.db.commit()
admin_password = None
finally:
frappe.destroy()
def execute_job(site, method, event, job_name, kwargs):
'''Executes job in a worker, performs commit/rollback and logs if there is any error'''
from frappe.utils.scheduler import log
frappe.connect(site)
if isinstance(method, basestring):
method_name = method
method = frappe.get_attr(method)
else:
method_name = cstr(method)
try:
method(**kwargs)
except:
frappe.db.rollback()
log(method_name)
raise
else:
frappe.db.commit()
finally:
frappe.destroy()
def sendmail(site,
communication_name,
print_html=None,
print_format=None,
attachments=None,
recipients=None,
cc=None):
try:
frappe.connect(site=site)
# upto 3 retries
for i in xrange(3):
try:
communication = frappe.get_doc("Communication",
communication_name)
communication._notify(print_html=print_html,
print_format=print_format,
attachments=attachments,
recipients=recipients,
cc=cc)
except MySQLdb.OperationalError, e:
# deadlock, try again
if e.args[0] == 1213:
frappe.db.rollback()
time.sleep(1)
continue
else:
raise
else:
break
except:
frappe.db.rollback()
raise
else:
frappe.db.commit()
finally:
frappe.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 frappe.core.doctype.data_import_legacy import importer
from frappe.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())
frappe.init(site=site)
frappe.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,
)
frappe.db.commit()
except Exception:
print(frappe.get_traceback())
frappe.destroy()
def auto_deploy(context, app, migrate=False, restart=False, remote='upstream'):
'''Pull and migrate sites that have new version'''
from frappe.utils.gitutils import get_app_branch
from frappe.utils import get_sites
branch = get_app_branch(app)
app_path = frappe.get_app_path(app)
# fetch
subprocess.check_output(['git', 'fetch', remote, branch], cwd=app_path)
# get diff
if subprocess.check_output(
['git', 'diff', '{0}..upstream/{0}'.format(branch)], cwd=app_path):
print('Updates found for {0}'.format(app))
if app == 'frappe':
# run bench update
subprocess.check_output(['bench', 'update', '--no-backup'],
cwd='..')
else:
updated = False
subprocess.check_output(
['git', 'pull', '--rebase', 'upstream', branch], cwd=app_path)
# find all sites with that app
for site in get_sites():
frappe.init(site)
if app in frappe.get_installed_apps():
print('Updating {0}'.format(site))
updated = True
subprocess.check_output(
['bench', '--site', site, 'clear-cache'], cwd='..')
if migrate:
subprocess.check_output(
['bench', '--site', site, 'migrate'], cwd='..')
frappe.destroy()
if updated and restart:
subprocess.check_output(['bench', 'restart'], cwd='..')
else:
print('No Updates')
def set_user_password(site, user, password, logout_all_sessions=False):
import getpass
from frappe.utils.password import update_password
try:
frappe.init(site=site)
while not password:
password = getpass.getpass(f"{user}'s password for {site}: ")
frappe.connect()
if not frappe.db.exists("User", user):
print(f"User {user} does not exist")
sys.exit(1)
update_password(user=user,
pwd=password,
logout_all_sessions=logout_all_sessions)
frappe.db.commit()
password = None
finally:
frappe.destroy()
def send_newsletter(site, newsletter, event):
# hack! pass event="bulk_long" to queue in longjob queue
try:
frappe.connect(site=site)
doc = frappe.get_doc("Newsletter", newsletter)
doc.send_bulk()
except:
frappe.db.rollback()
task_logger.warn(frappe.get_traceback())
# wasn't able to send emails :(
doc.db_set("email_sent", 0)
frappe.db.commit()
raise
else:
frappe.db.commit()
finally:
frappe.destroy()
def _reinstall(site, admin_password=None, mariadb_root_username=None, mariadb_root_password=None, yes=False, verbose=False):
from frappe.installer import _new_site
if not yes:
click.confirm('This will wipe your database. Are you sure you want to reinstall?', abort=True)
try:
frappe.init(site=site)
frappe.connect()
frappe.clear_cache()
installed = frappe.get_installed_apps()
frappe.clear_cache()
except Exception:
installed = []
finally:
if frappe.db:
frappe.db.close()
frappe.destroy()
frappe.init(site=site)
_new_site(frappe.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,
quiet=False):
"Backup"
from frappe.utils.backups import scheduled_backup
verbose = context.verbose
for site in context.sites:
frappe.init(site=site)
frappe.connect()
odb = scheduled_backup(ignore_files=not with_files,
backup_path_db=backup_path_db,
backup_path_files=backup_path_files,
force=True)
if verbose:
from frappe.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(
)
frappe.destroy()
def execute(context, method, args=None, kwargs=None, profile=False):
"Execute a function"
for site in context.sites:
try:
frappe.init(site=site)
frappe.connect()
if args:
try:
args = eval(args)
except NameError:
args = [args]
else:
args = ()
if kwargs:
kwargs = eval(kwargs)
else:
kwargs = {}
if profile:
pr = cProfile.Profile()
pr.enable()
ret = frappe.get_attr(method)(*args, **kwargs)
if profile:
pr.disable()
s = StringIO()
pstats.Stats(pr,
stream=s).sort_stats('cumulative').print_stats(.5)
print(s.getvalue())
if frappe.db:
frappe.db.commit()
finally:
frappe.destroy()
if ret:
print(json.dumps(ret, default=json_handler))
def set_config(context, key, value, global_=False, as_dict=False):
"Insert/Update a value in site_config.json"
from frappe.installer import update_site_config
import ast
if as_dict:
value = ast.literal_eval(value)
if global_:
sites_path = os.getcwd() # big assumption.
common_site_config_path = os.path.join(sites_path,
'common_site_config.json')
update_site_config(key,
value,
validate=False,
site_config_path=common_site_config_path)
else:
for site in context.sites:
frappe.init(site=site)
update_site_config(key, value, validate=False)
frappe.destroy()
else:
raise SiteNotSpecifiedError
def ready_for_migration(context, site=None):
from frappe.utils.doctor import get_pending_jobs
if not site:
site = get_site(context)
try:
frappe.init(site=site)
pending_jobs = get_pending_jobs(site=site)
if pending_jobs:
print 'NOT READY for migration: site {0} has pending background jobs'.format(
site)
sys.exit(1)
else:
print 'READY for migration: site {0} does not have any background jobs'.format(
site)
return 0
finally:
frappe.destroy()
def get_site_status(verbose=False):
import frappe
import frappe.utils
from frappe.profile import get_system_managers
from frappe.core.doctype.profile.profile import get_total_users, get_active_users, \
get_website_users, get_active_website_users
import json
frappe.connect()
ret = {
'last_backup_on': frappe.local.conf.last_backup_on,
'active_users': get_active_users(),
'total_users': get_total_users(),
'active_website_users': get_active_website_users(),
'website_users': get_website_users(),
'system_managers': "\n".join(get_system_managers()),
'default_company': frappe.db.get_default("company"),
'disk_usage': frappe.utils.get_disk_usage(),
'working_directory': frappe.local.site_path
}
# country, timezone, industry
control_panel_details = frappe.db.get_value("Control Panel", "Control Panel",
["country", "time_zone", "industry"], as_dict=True)
if control_panel_details:
ret.update(control_panel_details)
# basic usage/progress analytics
for doctype in ("Company", "Customer", "Item", "Quotation", "Sales Invoice",
"Journal Voucher", "Stock Ledger Entry"):
key = doctype.lower().replace(" ", "_") + "_exists"
ret[key] = 1 if frappe.db.count(doctype) else 0
frappe.destroy()
if verbose:
print json.dumps(ret, indent=1, sort_keys=True)
return ret
def reinstall(context, admin_password=None, yes=False):
"Reinstall site ie. wipe all data and start over"
if not yes:
click.confirm('This will wipe your database. Are you sure you want to reinstall?', abort=True)
site = get_site(context)
try:
frappe.init(site=site)
frappe.connect()
frappe.clear_cache()
installed = frappe.get_installed_apps()
frappe.clear_cache()
except Exception:
installed = []
finally:
if frappe.db:
frappe.db.close()
frappe.destroy()
frappe.init(site=site)
_new_site(frappe.conf.db_name, site, verbose=context.verbose, force=True, reinstall=True,
install_apps=installed, admin_password=admin_password)
def reinstall(context):
"Reinstall site ie. wipe all data and start over"
site = get_single_site(context)
try:
frappe.init(site=site)
frappe.connect()
frappe.clear_cache()
installed = frappe.get_installed_apps()
frappe.clear_cache()
except Exception:
installed = []
finally:
if frappe.db:
frappe.db.close()
frappe.destroy()
frappe.init(site=site)
_new_site(frappe.conf.db_name,
site,
verbose=context.verbose,
force=True,
reinstall=True,
install_apps=installed)
def publish_realtime(context, event, message, room, user, doctype, docname,
after_commit):
"Publish realtime event from bench"
from frappe import publish_realtime
for site in context.sites:
try:
frappe.init(site=site)
frappe.connect()
publish_realtime(
event,
message=message,
room=room,
user=user,
doctype=doctype,
docname=docname,
after_commit=after_commit,
)
frappe.db.commit()
finally:
frappe.destroy()
if not context.sites:
raise SiteNotSpecifiedError
def _migrate(site, verbose=False):
import frappe.modules.patch_handler
import frappe.model.sync
from frappe.utils.fixtures import sync_fixtures
import frappe.translate
from frappe.desk.notifications import clear_notifications
frappe.init(site=site)
frappe.connect()
try:
prepare_for_update()
# run patches
frappe.modules.patch_handler.run_all()
# sync
frappe.model.sync.sync_all(verbose=verbose)
frappe.translate.clear_cache()
sync_fixtures()
clear_notifications()
finally:
frappe.publish_realtime("version-update")
frappe.destroy()
def scheduler_task(site, event, handler, now=False):
from frappe.utils.scheduler import log
traceback = ""
task_logger.info('running {handler} for {site} for event: {event}'.format(
handler=handler, site=site, event=event))
try:
if site not in ['tailorpad.com', 'testfirst']:
exec_cmd("../env/bin/frappe --use %s" % (site),
cwd="/home/erpnext/admin_site/frappe-bench/sites")
frappe.init(site=site)
if not create_lock(handler):
return
if not now:
frappe.connect(site=site)
frappe.get_attr(handler)()
except Exception:
frappe.db.rollback()
traceback = log(
handler,
"Method: {event}, Handler: {handler}".format(event=event,
handler=handler))
task_logger.warn(traceback)
raise
else:
frappe.db.commit()
finally:
delete_lock(handler)
if not now:
frappe.destroy()
task_logger.info('ran {handler} for {site} for event: {event}'.format(
handler=handler, site=site, event=event))
def latest(rebuild_website_config=True, quiet=False): import frappe.modules.patch_handler import frappe.model.sync from frappe.website import rebuild_config from frappe.utils.fixtures import sync_fixtures import frappe.translate from frappe.website import statics verbose = not quiet frappe.connect() try: # run patches frappe.local.patch_log_list = [] frappe.modules.patch_handler.run_all() if verbose: print "\n".join(frappe.local.patch_log_list) # sync frappe.model.sync.sync_all(verbose=verbose) sync_fixtures() statics.sync().start() # build website config if any changes in templates etc. if rebuild_website_config: rebuild_config() frappe.translate.clear_cache() except frappe.modules.patch_handler.PatchError: print "\n".join(frappe.local.patch_log_list) raise finally: frappe.destroy()
def enqueue_events_for_site(site, queued_jobs):
try:
frappe.init(site=site)
if frappe.local.conf.maintenance_mode:
return
if frappe.local.conf.pause_scheduler:
return
frappe.connect()
if is_scheduler_disabled():
return
enqueue_events(site=site, queued_jobs=queued_jobs)
frappe.logger(__name__).debug('Queued events for site {0}'.format(site))
except:
frappe.logger(__name__).error('Exception in Enqueue Events for Site {0}'.format(site) +
'\n' + frappe.get_traceback())
raise
finally:
frappe.destroy()
