def __init__(self, root_login, root_password=None):
if root_login:
if not root_password:
root_password = getattr(conf, "root_password", None)
if not root_password:
root_password = getpass.getpass("MySQL root password: ")
self.root_password = root_password
self.conn = webnotes.db.Database(user=root_login,
password=root_password)
webnotes.conn = self.conn
webnotes.session = webnotes._dict({'user': '******'})
self.dbman = DbManager(self.conn)
def make_scheduler(root_login, root_password, verbose):
"""
Make the database where all scheduler events will be stored from multiple datbases
See webnotes.utils.scheduler for more information
"""
conn = webnotes.db.Database(user=root_login, password=root_password)
from webnotes.model.db_schema import DbManager
dbman = DbManager(conn)
# delete user (if exists)
dbman.delete_user('master_scheduler')
# create user and db
dbman.create_user('master_scheduler',
getattr(webnotes.defs, 'scheduler_password', None))
if verbose: print "Created user master_scheduler"
# create a database
dbman.create_database('master_scheduler')
if verbose: print "Created database master_scheduler"
# grant privileges to user
dbman.grant_all_privileges('master_scheduler', 'master_scheduler')
# flush user privileges
dbman.flush_privileges()
conn.use('master_scheduler')
# create events table
conn.sql("""create table Event(
`db_name` varchar(60),
`event` varchar(180),
`interval` int(20),
`next_execution` timestamp,
`recurring` int(1),
primary key (`db_name`, `event`),
index next_execution(next_execution)
)""")
conn.sql("""create table EventLog(
`db_name` varchar(180),
`event` varchar(180),
`executed_on` timestamp,
`log` text,
index executed_on(executed_on))
""")
def __init__(self,
root_login,
root_password=None,
db_name=None,
site=None,
site_config=None):
make_conf(db_name, site=site, site_config=site_config)
self.site = site
self.make_connection(root_login, root_password)
webnotes.local.conn = self.conn
webnotes.local.session = webnotes._dict({'user': '******'})
self.dbman = DbManager(self.conn)
def __init__(self, root_login, root_password):
import webnotes
import webnotes.db
import webnotes.defs
self.root_password = root_password
from webnotes.model.db_schema import DbManager
self.conn = webnotes.db.Database(user=root_login,
password=root_password)
webnotes.conn = self.conn
webnotes.session = {'user': '******'}
self.dbman = DbManager(self.conn)
self.mysql_path = hasattr(
webnotes.defs, 'mysql_path') and webnotes.defs.mysql_path or ''
def __init__(self, root_login, root_password=None):
import webnotes
import webnotes.db
if root_login and not root_password:
import getpass
root_password = getpass.getpass("MySQL root password: ")
self.root_password = root_password
from webnotes.model.db_schema import DbManager
self.conn = webnotes.db.Database(user=root_login,
password=root_password)
webnotes.conn = self.conn
webnotes.session = {'user': '******'}
self.dbman = DbManager(self.conn)
def install(self,
db_name,
source_sql=None,
admin_password='******',
verbose=0,
force=0):
if force or (db_name not in self.dbman.get_database_list()):
# delete user (if exists)
self.dbman.delete_user(db_name)
else:
raise Exception("Database %s already exists" % (db_name, ))
# create user and db
self.dbman.create_user(db_name, webnotes.conf.db_password)
if verbose: print "Created user %s" % db_name
# create a database
self.dbman.create_database(db_name)
if verbose: print "Created database %s" % db_name
# grant privileges to user
self.dbman.grant_all_privileges(db_name, db_name)
if verbose:
print "Granted privileges to user %s and database %s" % (db_name,
db_name)
# flush user privileges
self.dbman.flush_privileges()
# close root connection
self.conn.close()
webnotes.connect(db_name=db_name, site=self.site)
self.dbman = DbManager(webnotes.conn)
# import in db_name
if verbose: print "Starting database import..."
# get the path of the sql file to import
if not source_sql:
source_sql = os.path.join(os.path.dirname(webnotes.__file__), "..",
'conf', 'Framework.sql')
self.dbman.restore_database(db_name, source_sql, db_name,
webnotes.conf.db_password)
if verbose: print "Imported from database %s" % source_sql
self.create_auth_table()
# fresh app
if 'Framework.sql' in source_sql:
if verbose: print "Installing app..."
self.install_app(verbose=verbose)
# update admin password
self.update_admin_password(admin_password)
# create public folder
from webnotes.install_lib import setup_public_folder
setup_public_folder.make(site=self.site)
if not self.site:
from webnotes.build import bundle
bundle(False)
return db_name