server/sqlutils.py
changeset 2759 23d7a75693f8
parent 2739 2403260cb5b4
child 3623 9b838e2d72bb
equal deleted inserted replaced
2758:8a54f91a43e1 2759:23d7a75693f8
   118     w(dropschema2sql(schema, prefix=SQL_PREFIX,
   118     w(dropschema2sql(schema, prefix=SQL_PREFIX,
   119                      skip_entities=skip_entities,
   119                      skip_entities=skip_entities,
   120                      skip_relations=skip_relations))
   120                      skip_relations=skip_relations))
   121     return '\n'.join(output)
   121     return '\n'.join(output)
   122 
   122 
   123 
       
   124 def sql_source_backup(source, sqladapter, confirm, backupfile,
       
   125                       askconfirm=False):
       
   126     if exists(backupfile):
       
   127         if not confirm('Backup file %s exists, overwrite it?' % backupfile):
       
   128             return
       
   129     elif askconfirm and not confirm('Backup %s database?'
       
   130                                     % source.repo.config.appid):
       
   131         print '-> no backup done.'
       
   132         return
       
   133     # should close opened connection before backuping
       
   134     source.close_pool_connections()
       
   135     try:
       
   136         sqladapter.backup_to_file(backupfile, confirm)
       
   137     finally:
       
   138         source.open_pool_connections()
       
   139 
       
   140 def sql_source_restore(source, sqladapter, confirm, backupfile, drop=True,
       
   141                        askconfirm=False):
       
   142     if not exists(backupfile):
       
   143         raise Exception("backup file %s doesn't exist" % backupfile)
       
   144     app = source.repo.config.appid
       
   145     if askconfirm and not confirm('Restore %s %s database from %s ?'
       
   146                                   % (app, source.uri, backupfile)):
       
   147         return
       
   148     # should close opened connection before restoring
       
   149     source.close_pool_connections()
       
   150     try:
       
   151         sqladapter.restore_from_file(backupfile, confirm, drop=drop)
       
   152     finally:
       
   153         source.open_pool_connections()
       
   154 
       
   155 
       
   156 try:
   123 try:
   157     from mx.DateTime import DateTimeType, DateTimeDeltaType
   124     from mx.DateTime import DateTimeType, DateTimeDeltaType
   158 except ImportError:
   125 except ImportError:
   159     DateTimeType = DateTimeDeltaType = None
   126     DateTimeType = DateTimeDeltaType = None
   160 
   127 
   194                                         port=self.dbport)
   161                                         port=self.dbport)
   195         init_cnx(self.dbdriver, cnx)
   162         init_cnx(self.dbdriver, cnx)
   196         #self.dbapi_module.type_code_test(cnx.cursor())
   163         #self.dbapi_module.type_code_test(cnx.cursor())
   197         return cnx
   164         return cnx
   198 
   165 
   199     def backup_to_file(self, backupfile, confirm):
   166     def backup_to_file(self, backupfile):
   200         cmd = self.dbhelper.backup_command(self.dbname, self.dbhost,
   167         cmd = self.dbhelper.backup_command(self.dbname, self.dbhost,
   201                                            self.dbuser, backupfile,
   168                                            self.dbuser, backupfile,
   202                                            keepownership=False)
   169                                            keepownership=False)
   203         backupdir = os.path.dirname(backupfile)
       
   204         if not os.path.exists(backupdir):
       
   205             if confirm('%s does not exist. Create it?' % backupdir,
       
   206                        abort=False, shell=False):
       
   207                 os.makedirs(backupdir)
       
   208             else:
       
   209                 print '-> failed to backup instance'
       
   210                 return
       
   211         if os.system(cmd):
   170         if os.system(cmd):
   212             print '-> error trying to backup with command', cmd
   171             raise Exception('Failed command: %s' % cmd)
   213             if not confirm('Continue anyway?', default='n'):
       
   214                 raise SystemExit(1)
       
   215         else:
       
   216             print '-> backup file',  backupfile
       
   217             restrict_perms_to_user(backupfile, self.info)
       
   218 
   172 
   219     def restore_from_file(self, backupfile, confirm, drop=True):
   173     def restore_from_file(self, backupfile, confirm, drop=True):
   220         for cmd in self.dbhelper.restore_commands(self.dbname, self.dbhost,
   174         for cmd in self.dbhelper.restore_commands(self.dbname, self.dbhost,
   221                                                   self.dbuser, backupfile,
   175                                                   self.dbuser, backupfile,
   222                                                   self.encoding,
   176                                                   self.encoding,
   223                                                   keepownership=False,
   177                                                   keepownership=False,
   224                                                   drop=drop):
   178                                                   drop=drop):
   225             while True:
   179             if os.system(cmd):
   226                 print cmd
   180                 raise Exception('Failed command: %s' % cmd)
   227                 if os.system(cmd):
       
   228                     print '-> error while restoring the base'
       
   229                     answer = confirm('Continue anyway?',
       
   230                                      shell=False, abort=False, retry=True)
       
   231                     if not answer:
       
   232                         raise SystemExit(1)
       
   233                     if answer == 1: # 1: continue, 2: retry
       
   234                         break
       
   235                 else:
       
   236                     break
       
   237         print '-> database restored.'
       
   238 
   181 
   239     def merge_args(self, args, query_args):
   182     def merge_args(self, args, query_args):
   240         if args is not None:
   183         if args is not None:
   241             args = dict(args)
   184             args = dict(args)
   242             for key, val in args.items():
   185             for key, val in args.items():