Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.
 
 
 
 
 
 

243 lignes
6.4 KiB

  1. import os,sys
  2. cgi_bin_path = os.path.sep.join(__file__.split(os.path.sep)[:-3])
  3. sys.path.append(cgi_bin_path)
  4. #
  5. # make a copy of defs.py (if not exists)
  6. #
  7. def copy_defs():
  8. global cgi_bin_path
  9. if not os.path.exists(os.path.join(cgi_bin_path, 'webnotes', 'defs.py')):
  10. ret = os.system('cp '+ os.path.join(cgi_bin_path, 'webnotes', 'defs_template.py')+\
  11. ' '+os.path.join(cgi_bin_path, 'webnotes', 'defs.py'))
  12. print 'Made copy of defs.py'
  13. #
  14. # Main Installer Class
  15. #
  16. class Installer:
  17. def __init__(self, root_login, root_password):
  18. self.root_password = root_password
  19. from webnotes.model.db_schema import DbManager
  20. self.conn = webnotes.db.Database(user=root_login, password=root_password)
  21. webnotes.conn=self.conn
  22. webnotes.session= {'user':'Administrator'}
  23. self.dbman = DbManager(self.conn)
  24. self.mysql_path = hasattr(defs, 'mysql_path') and webnotes.defs.mysql_path or ''
  25. #
  26. # run framework related cleanups
  27. #
  28. def framework_cleanups(self, target):
  29. self.dbman.drop_table('__DocTypeCache')
  30. webnotes.conn.sql("create table `__DocTypeCache` (name VARCHAR(120), modified DATETIME, content TEXT, server_code_compiled TEXT)")
  31. # set the basic passwords
  32. webnotes.conn.begin()
  33. webnotes.conn.sql("update tabProfile set password = password('admin') where name='Administrator'")
  34. webnotes.conn.commit()
  35. def import_core_module(self):
  36. """
  37. Imports the "Core" module from .txt file and creates
  38. Creates profile Administrator
  39. """
  40. from webnotes.modules.import_module import import_module
  41. from webnotes.modules.module_manager import reload_doc
  42. reload_doc('core','doctype','doctype')
  43. reload_doc('core','doctype','docfield')
  44. reload_doc('core','doctype','docperm')
  45. import_module('core')
  46. def create_users(self):
  47. """
  48. Create Administrator / Guest
  49. """
  50. webnotes.conn.begin()
  51. from webnotes.model.doc import Document
  52. p = Document('Profile')
  53. p.name = p.first_name = 'Administrator'
  54. p.email = 'admin@localhost'
  55. p.save(new = 1)
  56. ur = Document('UserRole')
  57. ur.parent = 'Administrator'
  58. ur.role = 'Administrator'
  59. ur.parenttype = 'Profile'
  60. ur.parentfield = 'userroles'
  61. p.enabled = 1
  62. ur.save(1)
  63. p = Document('Profile')
  64. p.name = p.first_name = 'Guest'
  65. p.email = 'guest@localhost'
  66. p.enabled = 1
  67. p.save(new = 1)
  68. ur = Document('UserRole')
  69. ur.parent = 'Guest'
  70. ur.role = 'Guest'
  71. ur.parenttype = 'Profile'
  72. ur.parentfield = 'userroles'
  73. ur.save(1)
  74. webnotes.conn.commit()
  75. #
  76. # main script to create a database from
  77. #
  78. def import_from_db(self, target, source_path='', password = 'admin', verbose=0):
  79. """
  80. a very simplified version, just for the time being..will eventually be deprecated once the framework stabilizes.
  81. """
  82. # delete user (if exists)
  83. self.dbman.delete_user(target)
  84. # create user and db
  85. self.dbman.create_user(target,getattr(defs,'db_password',None))
  86. if verbose: print "Created user %s" % target
  87. # create a database
  88. self.dbman.create_database(target)
  89. if verbose: print "Created database %s" % target
  90. # grant privileges to user
  91. self.dbman.grant_all_privileges(target,target)
  92. if verbose: print "Granted privileges to user %s and database %s" % (target, target)
  93. # flush user privileges
  94. self.dbman.flush_privileges()
  95. self.conn.use(target)
  96. # import in target
  97. if verbose: print "Starting database import..."
  98. # get the path of the sql file to import
  99. source_given = True
  100. if not source_path:
  101. source_given = False
  102. source_path = os.path.join(os.path.sep.join(os.path.abspath(webnotes.__file__).split(os.path.sep)[:-3]), 'data', 'Framework.sql')
  103. self.dbman.restore_database(target, source_path, self.root_password)
  104. if verbose: print "Imported from database %s" % source_path
  105. if not source_given:
  106. if verbose: print "Importing core module..."
  107. self.import_core_module()
  108. self.create_users()
  109. # framework cleanups
  110. self.framework_cleanups(target)
  111. if verbose: print "Ran framework startups on %s" % target
  112. return target
  113. def make_scheduler(root_login, root_password, verbose):
  114. """
  115. Make the database where all scheduler events will be stored from multiple datbases
  116. See webnotes.utils.scheduler for more information
  117. """
  118. conn = webnotes.db.Database(user=root_login, password=root_password)
  119. from webnotes.model.db_schema import DbManager
  120. dbman = DbManager(conn)
  121. # delete user (if exists)
  122. dbman.delete_user('master_scheduler')
  123. # create user and db
  124. dbman.create_user('master_scheduler', getattr(defs,'db_password',None))
  125. if verbose: print "Created user master_scheduler"
  126. # create a database
  127. dbman.create_database('master_scheduler')
  128. if verbose: print "Created database master_scheduler"
  129. # grant privileges to user
  130. dbman.grant_all_privileges('master_scheduler','master_scheduler')
  131. # flush user privileges
  132. dbman.flush_privileges()
  133. conn.use('master_scheduler')
  134. # create events table
  135. conn.sql("""create table Event(
  136. `db_name` varchar(60),
  137. `event` varchar(180),
  138. `interval` int(20),
  139. `next_execution` timestamp,
  140. `recurring` int(1),
  141. primary key (`db_name`, `event`),
  142. index next_execution(next_execution)
  143. )""")
  144. conn.sql("""create table EventLog(
  145. `db_name` varchar(180),
  146. `event` varchar(180),
  147. `executed_on` timestamp,
  148. `log` text,
  149. index executed_on(executed_on))
  150. """)
  151. #
  152. # load the options
  153. #
  154. def get_parser():
  155. from optparse import OptionParser
  156. parser = OptionParser(usage="usage: %prog [options] ROOT_LOGIN ROOT_PASSWORD DBNAME")
  157. parser.add_option("-x", "--database-password", dest="password", default="admin", help="Optional: New password for the Framework Administrator, default 'admin'")
  158. parser.add_option("-s", "--source", dest="source_path", default=None, help="Optional: Path of the sql file from which you want to import the instance, default 'data/Framework.sql'")
  159. return parser
  160. #
  161. # execution here
  162. #
  163. if __name__=='__main__':
  164. parser = get_parser()
  165. (options, args) = parser.parse_args()
  166. try:
  167. from webnotes import defs
  168. import webnotes
  169. import webnotes.db
  170. except ImportError:
  171. copy_defs()
  172. from webnotes import defs
  173. import webnotes
  174. import webnotes.db
  175. if len(args)==3:
  176. root_login, root_password, db_name = args[0], args[1], args[2]
  177. if db_name=='master_scheduler':
  178. make_scheduler(root_login, root_password, 1)
  179. else:
  180. inst = Installer(root_login, root_password)
  181. inst.import_from_db(db_name, source_path=options.source_path, \
  182. password = options.password, verbose = 1)
  183. print "Database created, please edit defs.py to get started"
  184. else:
  185. parser.print_help()