class Installer:
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 ''
#
# run framework related cleanups
#
def framework_cleanups(self, target):
import webnotes
self.dbman.drop_table('__DocTypeCache')
webnotes.conn.sql("create table `__DocTypeCache` (name VARCHAR(120), modified DATETIME, content TEXT, server_code_compiled TEXT)")
# set the basic passwords
webnotes.conn.begin()
webnotes.conn.sql("update tabProfile set password = password('admin') where name='Administrator'")
webnotes.conn.commit()
def import_core_module(self):
"""
Imports the "Core" module from .txt file and creates
Creates profile Administrator
"""
import webnotes
from webnotes.modules import Module
core = Module('core')
core.reload('doctype','doctype')
core.reload('doctype','docfield')
core.reload('doctype','docperm')
core.sync_all(verbose=1)
def create_users(self):
"""
Create Administrator / Guest
"""
webnotes.conn.begin()
from webnotes.model.doc import Document
p = Document('Profile')
p.name = p.first_name = 'Administrator'
p.email = 'admin@localhost'
p.save(new = 1)
ur = Document('UserRole')
ur.parent = 'Administrator'
ur.role = 'Administrator'
ur.parenttype = 'Profile'
ur.parentfield = 'userroles'
p.enabled = 1
ur.save(1)
p = Document('Profile')
p.name = p.first_name = 'Guest'
p.email = 'guest@localhost'
p.enabled = 1
p.save(new = 1)
ur = Document('UserRole')
ur.parent = 'Guest'
ur.role = 'Guest'
ur.parenttype = 'Profile'
ur.parentfield = 'userroles'
ur.save(1)
webnotes.conn.commit()
def get_db_password(self, db_name):
"""
Get the db_password by method
"""
import webnotes.defs
if hasattr(webnotes.defs, 'get_db_password'):
return webnotes.defs.get_db_password(db_name)
if hasattr(webnotes.defs, 'db_password'):
return webnotes.defs.db_password
return ''
def import_from_db(self, target, source_path='', password = '******', verbose=0):
"""
a very simplified version, just for the time being..will eventually be deprecated once the framework stabilizes.
"""
import webnotes.defs
# delete user (if exists)
self.dbman.delete_user(target)
# create user and db
self.dbman.create_user(target,self.get_db_password(target))
if verbose: print "Created user %s" % target
# create a database
self.dbman.create_database(target)
if verbose: print "Created database %s" % target
# grant privileges to user
self.dbman.grant_all_privileges(target,target)
if verbose: print "Granted privileges to user %s and database %s" % (target, target)
# flush user privileges
self.dbman.flush_privileges()
self.conn.use(target)
# import in target
if verbose: print "Starting database import..."
# get the path of the sql file to import
source_given = True
if not source_path:
source_given = False
source_path = os.path.join(os.path.sep.join(os.path.abspath(webnotes.__file__).split(os.path.sep)[:-3]), 'data', 'Framework.sql')
self.dbman.restore_database(target, source_path, self.root_password)
if verbose: print "Imported from database %s" % source_path
if not source_given:
if verbose: print "Importing core module..."
self.import_core_module()
self.create_users()
# framework cleanups
self.framework_cleanups(target)
if verbose: print "Ran framework startups on %s" % target
return target
class Installer:
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: "******"""
a very simplified version, just for the time being..will eventually be deprecated once the framework stabilizes.
"""
# delete user (if exists)
self.dbman.delete_user(target)
# create user and db
self.dbman.create_user(target, conf.db_password)
if verbose: print "Created user %s" % target
# create a database
self.dbman.create_database(target)
if verbose: print "Created database %s" % target
# grant privileges to user
self.dbman.grant_all_privileges(target, target)
if verbose:
print "Granted privileges to user %s and database %s" % (target,
target)
# flush user privileges
self.dbman.flush_privileges()
self.conn.use(target)
# import in target
if verbose: print "Starting database import..."
# get the path of the sql file to import
source_given = True
if not source_path:
source_given = False
source_path = os.path.join(
os.path.sep.join(
os.path.abspath(webnotes.__file__).split(
os.path.sep)[:-3]), 'data', 'Framework.sql')
self.dbman.restore_database(target, source_path, target,
conf.db_password)
if verbose: print "Imported from database %s" % source_path
# fresh app
if 'Framework.sql' in source_path:
print "Installing app..."
self.install_app()
# update admin password
self.create_auth_table()
self.update_admin_password(password)
return target
def install_app(self):
try:
from startup import install
except ImportError, e:
print "No app install found"
sync_for("lib", force=True, sync_everything=True)
self.import_core_docs()
install.pre_import()
sync_for("app", force=True, sync_everything=True)
print "Completing App Import..."
install.post_import()
print "Updating patches..."
self.set_all_patches_as_completed()
class Installer:
def __init__(self, root_login, root_password=None):
import webnotes
import webnotes.db
if not root_password:
import getpass
root_password = getpass.getpass("MySQL root password: "******"""
a very simplified version, just for the time being..will eventually be deprecated once the framework stabilizes.
"""
import conf
# delete user (if exists)
self.dbman.delete_user(target)
# create user and db
self.dbman.create_user(target,
hasattr(conf, 'db_password') and conf.db_password or password)
if verbose: print "Created user %s" % target
# create a database
self.dbman.create_database(target)
if verbose: print "Created database %s" % target
# grant privileges to user
self.dbman.grant_all_privileges(target,target)
if verbose: print "Granted privileges to user %s and database %s" % (target, target)
# flush user privileges
self.dbman.flush_privileges()
self.conn.use(target)
# import in target
if verbose: print "Starting database import..."
# get the path of the sql file to import
source_given = True
if not source_path:
source_given = False
source_path = os.path.join(os.path.sep.join(os.path.abspath(webnotes.__file__).split(os.path.sep)[:-3]), 'data', 'Framework.sql')
self.dbman.restore_database(target, source_path, self.root_password)
if verbose: print "Imported from database %s" % source_path
# fresh app
if 'Framework.sql' in source_path:
from webnotes.model.sync import sync_install
print "Building tables from all module..."
sync_install()
# framework cleanups
self.framework_cleanups(target)
if verbose: print "Ran framework startups on %s" % target
return target
def framework_cleanups(self, target):
"""create framework internal tables"""
import webnotes
self.create_sessions_table()
self.create_scheduler_log()
self.create_session_cache()
self.create_cache_item()
# set the basic passwords
webnotes.conn.begin()
webnotes.conn.sql("""update tabProfile set password = password('admin')
where name='Administrator'""")
webnotes.conn.commit()
def create_sessions_table(self):
"""create sessions table"""
import webnotes
self.dbman.drop_table('tabSessions')
webnotes.conn.sql("""CREATE TABLE `tabSessions` (
`user` varchar(40) DEFAULT NULL,
`sid` varchar(120) DEFAULT NULL,
`sessiondata` longtext,
`ipaddress` varchar(16) DEFAULT NULL,
`lastupdate` datetime DEFAULT NULL,
`status` varchar(20) DEFAULT NULL,
KEY `sid` (`sid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8""")
def create_scheduler_log(self):
import webnotes
self.dbman.drop_table('__SchedulerLog')
webnotes.conn.sql("""create table __SchedulerLog (
`timestamp` timestamp,
method varchar(200),
error text
) engine=MyISAM""")
def create_session_cache(self):
import webnotes
self.dbman.drop_table('__SessionCache')
webnotes.conn.sql("""create table `__SessionCache` (
user VARCHAR(120),
country VARCHAR(120),
cache LONGTEXT)""")
def create_cache_item(self):
import webnotes
self.dbman.drop_table('__CacheItem')
webnotes.conn.sql("""create table __CacheItem(
`key` VARCHAR(180) NOT NULL PRIMARY KEY,
`value` LONGTEXT,
`expires_on` DATETIME
) ENGINE=MyISAM DEFAULT CHARSET=utf8""")
class Installer:
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 make_connection(self, root_login, root_password):
if root_login:
if not root_password:
root_password = webnotes.conf.get("root_password") or None
if not root_password:
root_password = getpass.getpass("MySQL root password: "******"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
def install_app(self, verbose=False):
sync_for("lib", force=True, sync_everything=True, verbose=verbose)
self.import_core_docs()
try:
from startup import install
except ImportError, e:
install = None
if os.path.exists("app"):
sync_for("app", force=True, sync_everything=True, verbose=verbose)
if os.path.exists(os.path.join("app", "startup", "install_fixtures")):
install_fixtures()
if verbose: print "Completing App Import..."
install and install.post_import()
if verbose: print "Updating patches..."
self.set_all_patches_as_completed()
self.assign_all_role_to_administrator()
class Installer:
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: "******"""
a very simplified version, just for the time being..will eventually be deprecated once the framework stabilizes.
"""
# delete user (if exists)
self.dbman.delete_user(target)
# create user and db
self.dbman.create_user(target, conf.db_password)
if verbose: print "Created user %s" % target
# create a database
self.dbman.create_database(target)
if verbose: print "Created database %s" % target
# grant privileges to user
self.dbman.grant_all_privileges(target,target)
if verbose: print "Granted privileges to user %s and database %s" % (target, target)
# flush user privileges
self.dbman.flush_privileges()
self.conn.use(target)
# import in target
if verbose: print "Starting database import..."
# get the path of the sql file to import
source_given = True
if not source_path:
source_given = False
source_path = os.path.join(os.path.sep.join(os.path.abspath(webnotes.__file__).split(os.path.sep)[:-3]), 'data', 'Framework.sql')
self.dbman.restore_database(target, source_path, target, conf.db_password)
if verbose: print "Imported from database %s" % source_path
# fresh app
if 'Framework.sql' in source_path:
print "Installing app..."
self.install_app()
# update admin password
self.create_auth_table()
self.update_admin_password(password)
return target
def install_app(self):
try:
from startup import install
except ImportError, e:
print "No app install found"
sync_for("lib", force=True, sync_everything=True)
self.import_core_docs()
install.pre_import()
sync_for("app", force=True, sync_everything=True)
print "Completing App Import..."
install.post_import()
print "Updating patches..."
self.set_all_patches_as_completed()
class Installer:
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: "******"""
a very simplified version, just for the time being..will eventually be deprecated once the framework stabilizes.
"""
import conf
# delete user (if exists)
self.dbman.delete_user(target)
# create user and db
self.dbman.create_user(
target,
hasattr(conf, 'db_password') and conf.db_password or password)
if verbose: print "Created user %s" % target
# create a database
self.dbman.create_database(target)
if verbose: print "Created database %s" % target
# grant privileges to user
self.dbman.grant_all_privileges(target, target)
if verbose:
print "Granted privileges to user %s and database %s" % (target,
target)
# flush user privileges
self.dbman.flush_privileges()
self.conn.use(target)
# import in target
if verbose: print "Starting database import..."
# get the path of the sql file to import
source_given = True
if not source_path:
source_given = False
source_path = os.path.join(
os.path.sep.join(
os.path.abspath(webnotes.__file__).split(
os.path.sep)[:-3]), 'data', 'Framework.sql')
self.dbman.restore_database(target, source_path, self.root_password)
if verbose: print "Imported from database %s" % source_path
# fresh app
if 'Framework.sql' in source_path:
from webnotes.model.sync import sync_install
print "Building tables from all module..."
sync_install()
# framework cleanups
self.framework_cleanups(target)
if verbose: print "Ran framework startups on %s" % target
return target
def framework_cleanups(self, target):
"""create framework internal tables"""
import webnotes
self.create_sessions_table()
self.create_scheduler_log()
self.create_auth_table()
# set the basic passwords
webnotes.conn.begin()
webnotes.conn.sql("""update __Auth set password = password('admin')
where user='******'""")
webnotes.conn.commit()
def create_sessions_table(self):
"""create sessions table"""
import webnotes
self.dbman.drop_table('tabSessions')
webnotes.conn.sql("""CREATE TABLE `tabSessions` (
`user` varchar(40) DEFAULT NULL,
`sid` varchar(120) DEFAULT NULL,
`sessiondata` longtext,
`ipaddress` varchar(16) DEFAULT NULL,
`lastupdate` datetime DEFAULT NULL,
`status` varchar(20) DEFAULT NULL,
KEY `sid` (`sid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8""")
def create_scheduler_log(self):
import webnotes
self.dbman.drop_table('__SchedulerLog')
webnotes.conn.sql("""create table __SchedulerLog (
`timestamp` timestamp,
method varchar(200),
error text
) engine=MyISAM""")
def create_auth_table(self):
import webnotes
webnotes.conn.sql("""create table if not exists __Auth (
`user` VARCHAR(180) NOT NULL PRIMARY KEY,
`password` VARCHAR(180) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8""")
class Installer:
def __init__(self, root_login, 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)
self.mysql_path = hasattr(defs, "mysql_path") and webnotes.defs.mysql_path or ""
#
# run framework related cleanups
#
def framework_cleanups(self, target):
self.dbman.drop_table("__DocTypeCache")
webnotes.conn.sql(
"create table `__DocTypeCache` (name VARCHAR(120), modified DATETIME, content TEXT, server_code_compiled TEXT)"
)
# set the basic passwords
webnotes.conn.begin()
webnotes.conn.sql("update tabProfile set password = password('admin') where name='Administrator'")
webnotes.conn.commit()
def import_core_module(self):
"""
Imports the "Core" module from .txt file and creates
Creates profile Administrator
"""
from webnotes.modules.import_module import import_module
from webnotes.modules.module_manager import reload_doc
reload_doc("core", "doctype", "doctype")
reload_doc("core", "doctype", "docfield")
reload_doc("core", "doctype", "docperm")
import_module("core")
webnotes.conn.begin()
from webnotes.model.doc import Document
p = Document("Profile")
p.name = p.first_name = "Administrator"
p.email = "admin@localhost"
p.save(new=1)
ur = Document("UserRole")
ur.parent = "Administrator"
ur.role = "Administrator"
ur.parenttype = "Profile"
ur.parentfield = "userroles"
p.enabled = 1
ur.save(1)
p = Document("Profile")
p.name = p.first_name = "Guest"
p.email = "guest@localhost"
p.enabled = 1
p.save(new=1)
ur = Document("UserRole")
ur.parent = "Guest"
ur.role = "Guest"
ur.parenttype = "Profile"
ur.parentfield = "userroles"
ur.save(1)
webnotes.conn.commit()
#
# main script to create a database from
#
def import_from_db(self, target, source_path="", password="******", verbose=0):
"""
a very simplified version, just for the time being..will eventually be deprecated once the framework stabilizes.
"""
# get the path of the sql file to import
if not source_path:
source_path = os.path.join(
os.path.sep.join(os.path.abspath(webnotes.__file__).split(os.path.sep)[:-3]), "data", "Framework.sql"
)
# delete user (if exists)
self.dbman.delete_user(target)
# create user and db
self.dbman.create_user(target, getattr(defs, "db_password", None))
if verbose:
print "Created user %s" % target
# create a database
self.dbman.create_database(target)
if verbose:
print "Created database %s" % target
# grant privileges to user
self.dbman.grant_all_privileges(target, target)
if verbose:
print "Granted privileges to user %s and database %s" % (target, target)
# flush user privileges
self.dbman.flush_privileges()
self.conn.use(target)
# import in target
if verbose:
print "Starting database import..."
self.dbman.restore_database(target, source_path, self.root_password)
if verbose:
print "Imported from database %s" % source_path
self.import_core_module()
# framework cleanups
self.framework_cleanups(target)
if verbose:
print "Ran framework startups on %s" % target
return target
class Installer:
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 make_connection(self, root_login, root_password):
if root_login:
if not root_password:
root_password = webnotes.conf.get("root_password") or None
if not root_password:
root_password = getpass.getpass("MySQL root password: "******"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
def install_app(self, verbose=False):
sync_for("lib", force=True, sync_everything=True, verbose=verbose)
self.import_core_docs()
try:
from startup import install
except ImportError, e:
install = None
if os.path.exists("app"):
sync_for("app", force=True, sync_everything=True, verbose=verbose)
if os.path.exists(os.path.join("app", "startup", "install_fixtures")):
install_fixtures()
if verbose: print "Completing App Import..."
install and install.post_import()
if verbose: print "Updating patches..."
self.set_all_patches_as_completed()
self.assign_all_role_to_administrator()
class Installer:
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 ''
#
# run framework related cleanups
#
def framework_cleanups(self, target):
import webnotes
self.dbman.drop_table('__DocTypeCache')
webnotes.conn.sql(
"create table `__DocTypeCache` (name VARCHAR(120), modified DATETIME, content TEXT, server_code_compiled TEXT)"
)
# set the basic passwords
webnotes.conn.begin()
webnotes.conn.sql(
"update tabProfile set password = password('admin') where name='Administrator'"
)
webnotes.conn.commit()
def import_core_module(self):
"""
Imports the "Core" module from .txt file and creates
Creates profile Administrator
"""
import webnotes
from webnotes.modules import Module
core = Module('core')
core.reload('doctype', 'doctype')
core.reload('doctype', 'docfield')
core.reload('doctype', 'docperm')
core.sync_all(verbose=1)
def create_users(self):
"""
Create Administrator / Guest
"""
webnotes.conn.begin()
from webnotes.model.doc import Document
p = Document('Profile')
p.name = p.first_name = 'Administrator'
p.email = 'admin@localhost'
p.save(new=1)
ur = Document('UserRole')
ur.parent = 'Administrator'
ur.role = 'Administrator'
ur.parenttype = 'Profile'
ur.parentfield = 'userroles'
p.enabled = 1
ur.save(1)
p = Document('Profile')
p.name = p.first_name = 'Guest'
p.email = 'guest@localhost'
p.enabled = 1
p.save(new=1)
ur = Document('UserRole')
ur.parent = 'Guest'
ur.role = 'Guest'
ur.parenttype = 'Profile'
ur.parentfield = 'userroles'
ur.save(1)
webnotes.conn.commit()
def get_db_password(self, db_name):
"""
Get the db_password by method
"""
import webnotes.defs
if hasattr(webnotes.defs, 'get_db_password'):
return webnotes.defs.get_db_password(db_name)
if hasattr(webnotes.defs, 'db_password'):
return webnotes.defs.db_password
return ''
def import_from_db(self,
target,
source_path='',
password='******',
verbose=0):
"""
a very simplified version, just for the time being..will eventually be deprecated once the framework stabilizes.
"""
import webnotes.defs
# delete user (if exists)
self.dbman.delete_user(target)
# create user and db
self.dbman.create_user(target, self.get_db_password(target))
if verbose: print "Created user %s" % target
# create a database
self.dbman.create_database(target)
if verbose: print "Created database %s" % target
# grant privileges to user
self.dbman.grant_all_privileges(target, target)
if verbose:
print "Granted privileges to user %s and database %s" % (target,
target)
# flush user privileges
self.dbman.flush_privileges()
self.conn.use(target)
# import in target
if verbose: print "Starting database import..."
# get the path of the sql file to import
source_given = True
if not source_path:
source_given = False
source_path = os.path.join(
os.path.sep.join(
os.path.abspath(webnotes.__file__).split(
os.path.sep)[:-3]), 'data', 'Framework.sql')
self.dbman.restore_database(target, source_path, self.root_password)
if verbose: print "Imported from database %s" % source_path
if not source_given:
if verbose: print "Importing core module..."
self.import_core_module()
self.create_users()
# framework cleanups
self.framework_cleanups(target)
if verbose: print "Ran framework startups on %s" % target
return target
