def run(self): cr = db_connect(self.dbname).cursor() pool = pooler.get_pool(cr.dbname) deferred_obj = pool.get('deferred_processing.task') self._start_time = time.time() deferred_obj.write(cr, self.uid, self._process_id, {'state':'process'}) cr.commit() self._state = 'process' if 'context' in self.kwargs: self.kwargs['context'].update({'deferred_process':self}) else: self.args[-1].update({'deferred_process':self}) if self.kwargs: self.result = apply(self.method, (cr,self.uid)+self.args, self.kwargs) else: self.result = apply(self.method, (cr,self.uid)+self.args) self.refresh_status() self.get_speed() self._state = 'done' self._processed = self._total self._progress = 100.0 to_write = {'state':'done'} if self.result and type(self.result)!=bool: if self._result_parser: self.result = eval(self._result_parser, {}, {'result':self.result}) to_write['result'] = base64.encodestring(self.result) cr.rollback() deferred_obj.write(cr, self.uid, self._process_id, to_write) cr.commit() cr.close()
def db_list(self): """Get the list of available databases, with FTPd support """ s = netsvc.ExportService.getService('db') result = s.exp_list(document=True) self.db_name_list = [] for db_name in result: db, cr = None, None try: try: db = sql_db.db_connect(db_name) cr = db.cursor() cr.execute("SELECT 1 FROM pg_class WHERE relkind = 'r' AND relname = 'ir_module_module'") if not cr.fetchone(): continue cr.execute("SELECT id FROM ir_module_module WHERE name = 'document_ftp' AND state IN ('installed', 'to install', 'to upgrade') ") res = cr.fetchone() if res and len(res): self.db_name_list.append(db_name) cr.commit() except Exception: self._log.warning('Cannot use db "%s".', db_name) finally: if cr is not None: cr.close() return self.db_name_list
def exp_list(self, document=False): if not tools.config['list_db'] and not document: raise Exception('AccessDenied') db = sql_db.db_connect('template1') cr = db.cursor() try: try: db_user = tools.config["db_user"] if not db_user and os.name == 'posix': import pwd db_user = pwd.getpwuid(os.getuid())[0] if not db_user: cr.execute("select decode(usename, 'escape') from pg_user where usesysid=(select datdba from pg_database where datname=%s)", (tools.config["db_name"],)) res = cr.fetchone() db_user = res and str(res[0]) if db_user: cr.execute("select decode(datname, 'escape') from pg_database where datdba=(select usesysid from pg_user where usename=%s) and datname not in ('template0', 'template1', 'postgres') order by datname", (db_user,)) else: cr.execute("select decode(datname, 'escape') from pg_database where datname not in('template0', 'template1','postgres') order by datname") res = [str(name) for (name,) in cr.fetchall()] except: res = [] finally: cr.close() res.sort() return res
def emit(self, record): ct = threading.current_thread() ct_db = getattr(ct, "dbname", None) dbname = tools.config["log_db"] or ct_db if not dbname: return with tools.ignore(Exception), tools.mute_logger("openerp.sql_db"), sql_db.db_connect(dbname).cursor() as cr: msg = tools.ustr(record.msg) if record.args: msg = msg % record.args traceback = getattr(record, "exc_text", "") if traceback: msg = "%s\n%s" % (msg, traceback) # we do not use record.levelname because it may have been changed by ColoredFormatter. levelname = logging.getLevelName(record.levelno) val = ( "server", ct_db, record.name, levelname, msg, record.pathname[len(path_prefix) + 1 :], record.lineno, record.funcName, ) cr.execute( """ INSERT INTO ir_logging(create_date, type, dbname, name, level, message, path, line, func) VALUES (NOW() at time zone 'UTC', %s, %s, %s, %s, %s, %s, %s, %s) """, val, )
def exp_list(self, document=False): if not tools.config['list_db'] and not document: raise Exception('AccessDenied') db = sql_db.db_connect('template1') cr = db.cursor() try: try: db_user = tools.config["db_user"] if not db_user and os.name == 'posix': import pwd db_user = pwd.getpwuid(os.getuid())[0] if not db_user: cr.execute("select decode(usename, 'escape') from pg_user where usesysid=(select datdba from pg_database where datname=%s)", (tools.config["db_name"],)) res = cr.fetchone() db_user = res and str(res[0]) if db_user: cr.execute("select decode(datname, 'escape') from pg_database where datdba=(select usesysid from pg_user where usename=%s) and datname not in ('template0', 'template1', 'postgres') order by datname", (db_user,)) else: cr.execute("select decode(datname, 'escape') from pg_database where datname not in('template0', 'template1','postgres') order by datname") res = [str(name) for (name,) in cr.fetchall()] except Exception: res = [] finally: cr.close() res.sort() return res
def emit(self, record): ct = threading.current_thread() ct_db = getattr(ct, 'dbname', None) dbname = tools.config['log_db'] if tools.config[ 'log_db'] and tools.config['log_db'] != '%d' else ct_db if not dbname: return with tools.ignore(Exception), tools.mute_logger( 'openerp.sql_db'), sql_db.db_connect( dbname, allow_uri=True).cursor() as cr: msg = tools.ustr(record.msg) if record.args: msg = msg % record.args traceback = getattr(record, 'exc_text', '') if traceback: msg = "%s\n%s" % (msg, traceback) # we do not use record.levelname because it may have been changed by ColoredFormatter. levelname = logging.getLevelName(record.levelno) val = ('server', ct_db, record.name, levelname, msg, record.pathname[len(path_prefix) + 1:], record.lineno, record.funcName) cr.execute( """ INSERT INTO ir_logging(create_date, type, dbname, name, level, message, path, line, func) VALUES (NOW() at time zone 'UTC', %s, %s, %s, %s, %s, %s, %s, %s) """, val)
def exp_server_version(self, dbname=False): """ Return the version of the server from the sql table sync_client_version. If it's not found return the version found from the unified-version.txt (old base) Used by the client to verify the compatibility with its own version """ if not dbname: return release.version db = sql_db.db_connect(dbname) cr = db.cursor() # check sync_client_version table existance cr.execute("SELECT relname FROM pg_class WHERE relkind IN ('r','v') AND relname='sync_client_version'") if not cr.fetchone(): # the table sync_client_version doesn't exists, fallback on the # version from release.py file return release.version or 'UNKNOWN_VERSION' cr.execute("SELECT name, sum FROM sync_client_version WHERE state='installed' ORDER BY applied DESC") res = cr.fetchone() cr.close(True) if res and res[0]: return res[0] elif res[1]: version_list = get_server_version() for version in version_list: if res[1] == version['md5sum'] and version['name']: return version['name'] return 'UNKNOWN_VERSION'
def db_list(self): """Get the list of available databases, with FTPd support """ s = netsvc.ExportService.getService('db') result = s.exp_list(document=True) self.db_name_list = [] for db_name in result: db, cr = None, None try: try: db = sql_db.db_connect(db_name) cr = db.cursor() cr.execute( "SELECT 1 FROM pg_class WHERE relkind = 'r' AND relname = 'ir_module_module'" ) if not cr.fetchone(): continue cr.execute( "SELECT id FROM ir_module_module WHERE name = 'document_ftp' AND state IN ('installed', 'to install', 'to upgrade') " ) res = cr.fetchone() if res and len(res): self.db_name_list.append(db_name) cr.commit() except Exception: self._log.warning('Cannot use db "%s"', db_name) finally: if cr is not None: cr.close() return self.db_name_list
def _create_empty_database(self, name): db = sql_db.db_connect('template1') cr = db.cursor() try: cr.autocommit(True) # avoid transaction block cr.execute("""CREATE DATABASE "%s" ENCODING 'unicode' TEMPLATE "template0" """ % name) finally: cr.close()
def search(self, db, uid, passwd, model, filter, offset=0, limit=None, order=None, context=None, count=False, group=False): security.check(db, uid, passwd) conn = sql_db.db_connect(db) cr = conn.cursor() try: return self.exp_search(cr, uid, model, filter, offset, limit, order, context, count, group) finally: cr.close()
def indexedModels(self, db, uid, passwd, context=None): security.check(db, uid, passwd) conn = sql_db.db_connect(db) cr = conn.cursor() result = self.exp_indexedModels(cr, uid, context) cr.close() return result
def grant(self, ip_address, dbname): cr= sql_db.db_connect(dbname).cursor() cr.execute("""SELECT id FROM res_computer WHERE ip_address='%s'""" % ip_address) if not cr.rowcount: raise 'AccessDenied' if not self.external_users: cr.execute("""SELECT user_computer, user_customer, user_provider FROM res_company LIMIT 1""") self.external_users= cr.dictfetchone() cr.close() return self.external_users["user_computer"]
def get_db_only(db_name): # ATTENTION: # do not put this import outside this function # sql_db must not be loaded before the logger is initialized. # sql_db import psycopg2.tool which create a default logger if there is not. # this resulting of having the logs outputed twice... import sql_db db = sql_db.db_connect(db_name) return db
def login(self, dbname, email, passwd): cr= sql_db.db_connect(dbname).cursor() cr.execute("""SELECT p.id FROM res_partner p, res_partner_address a WHERE a.partner_id=p.id AND a.email='%s' AND p.pasword='%s' LIMIT 1""" % (email, passwd)) try: ret= cr.fetchone()[0] except: ret= False cr.close() return ret
def drop_database(self): import sql_db sql_db.close_db(self.db_name) conn = sql_db.db_connect('template1') cursor = conn.cursor() try: logger.info('Droping database %s', self.db_name) cursor.autocommit(True) cursor.execute('DROP DATABASE ' + self.db_name) finally: cursor.close()
def exp_check_timezone(self): db = sql_db.db_connect('template1') cr = db.cursor() try: cr.execute('select now() - %s', (datetime.datetime.now(),)) now = cr.fetchone()[0] if abs(now) >= datetime.timedelta(hours=1): return _('Time zones of UniField server and PostgreSQL server differ. Please check the computer configuration.') finally: cr.close() return ''
def __call__(self, serv, id, db_name, demo, lang, user_password='******'): cr = None try: serv.actions[id]['progress'] = 0 cr = sql_db.db_connect(db_name).cursor() tools.init_db(cr) tools.config['lang'] = lang cr.commit() cr.close(True) cr = None pool = pooler.restart_pool(db_name, demo, serv.actions[id], update_module=True)[1] cr = sql_db.db_connect(db_name).cursor() if lang: modobj = pool.get('ir.module.module') mids = modobj.search(cr, 1, [('state', '=', 'installed')]) modobj.update_translations(cr, 1, mids, lang) cr.execute('UPDATE res_users SET password=%s, context_lang=%s, active=True WHERE login=%s', ( user_password, lang, 'admin')) cr.execute('SELECT login, password, name ' \ ' FROM res_users ' \ ' ORDER BY login') serv.actions[id]['users'] = cr.dictfetchall() serv.actions[id]['clean'] = True cr.commit() cr.close(True) except Exception, e: serv.actions[id]['clean'] = False serv.actions[id]['exception'] = e import traceback e_str = StringIO() traceback.print_exc(file=e_str) traceback_str = e_str.getvalue() e_str.close() netsvc.Logger().notifyChannel('web-services', netsvc.LOG_ERROR, 'CREATE DATABASE\n%s' % (traceback_str)) serv.actions[id]['traceback'] = traceback_str if cr: cr.close(True)
def __call__(self, serv, id, db_name, demo, lang, user_password='******'): cr = None try: serv.actions[id]['progress'] = 0 cr = sql_db.db_connect(db_name).cursor() tools.init_db(cr) tools.config['lang'] = lang cr.commit() cr.close() cr = None pool = pooler.restart_pool(db_name, demo, serv.actions[id], update_module=True)[1] cr = sql_db.db_connect(db_name).cursor() if lang: modobj = pool.get('ir.module.module') mids = modobj.search(cr, 1, [('state', '=', 'installed')]) modobj.update_translations(cr, 1, mids, lang) cr.execute('UPDATE res_users SET password=%s, context_lang=%s, active=True WHERE login=%s', ( user_password, lang, 'admin')) cr.execute('SELECT login, password, name ' \ ' FROM res_users ' \ ' ORDER BY login') serv.actions[id]['users'] = cr.dictfetchall() serv.actions[id]['clean'] = True cr.commit() cr.close() except Exception, e: serv.actions[id]['clean'] = False serv.actions[id]['exception'] = e import traceback e_str = StringIO() traceback.print_exc(file=e_str) traceback_str = e_str.getvalue() e_str.close() netsvc.Logger().notifyChannel('web-services', netsvc.LOG_ERROR, 'CREATE DATABASE\n%s' % (traceback_str)) serv.actions[id]['traceback'] = traceback_str if cr: cr.close()
def createdb(dbname=False): conn = sql_db.db_connect('postgres') cursor = conn.cursor() if not dbname: dbname = 'translate_{}'.format(str(int(time.time()))) try: cursor.autocommit(True) cursor.execute('CREATE DATABASE {}'.format(dbname)) return dbname finally: cursor.close() sql_db.close_db('postgres')
def grant(self, ip_address, dbname): cr = sql_db.db_connect(dbname).cursor() cr.execute("""SELECT id FROM res_computer WHERE ip_address='%s'""" % ip_address) if not cr.rowcount: raise 'AccessDenied' if not self.external_users: cr.execute( """SELECT user_computer, user_customer, user_provider FROM res_company LIMIT 1""" ) self.external_users = cr.dictfetchone() cr.close() return self.external_users["user_computer"]
def create_database(self): db_name = 'test_' + str(int(time.time())) import sql_db conn = sql_db.db_connect('template1') cursor = conn.cursor() try: logger.info('Creating database %s', db_name) cursor.autocommit(True) cursor.execute('CREATE DATABASE ' + db_name + ' WITH TEMPLATE base') return db_name finally: cursor.close()
def login(self, dbname, email, passwd): cr = sql_db.db_connect(dbname).cursor() cr.execute("""SELECT p.id FROM res_partner p, res_partner_address a WHERE a.partner_id=p.id AND a.email='%s' AND p.pasword='%s' LIMIT 1""" % (email, passwd)) try: ret = cr.fetchone()[0] except: ret = False cr.close() return ret
def grant(self, dbname, partner_id, passwd, type): if not type in ("provider","customer"): raise 'AccessDenied' cr= sql_db.db_connect(dbname).cursor() sql= '' if type=="provider": sql= " AND id IN (SELECT name FROM product_supplierinfo GROUP BY 1)" cr.execute("""SELECT password='******'%s FROM res_partner WHERE id=%d""" % (passwd, sql, partner_id)) if not cr.rowcount: raise 'AccessDenied' if not cr.fetchone()[0]: raise 'AccessDenied' if not self.external_users: cr.execute("""SELECT user_computer, user_customer, user_provider FROM res_company LIMIT 1""") self.external_users= cr.dictfetchone() cr.close() return self.external_users["user_%s" % type]
def exp_rename(self, old_name, new_name): sql_db.close_db(old_name) logger = netsvc.Logger() db = sql_db.db_connect('template1') cr = db.cursor() cr.autocommit(True) # avoid transaction block try: try: cr.execute('ALTER DATABASE "%s" RENAME TO "%s"' % (old_name, new_name)) except Exception, e: logger.notifyChannel("web-services", netsvc.LOG_ERROR, 'RENAME DB: %s -> %s failed:\n%s' % (old_name, new_name, e)) raise Exception("Couldn't rename database %s to %s: %s" % (old_name, new_name, e)) else:
def exp_drop(self, db_name): sql_db.close_db(db_name) logger = netsvc.Logger() db = sql_db.db_connect('template1') cr = db.cursor() cr.autocommit(True) # avoid transaction block try: try: cr.execute('DROP DATABASE "%s"' % db_name) except Exception, e: logger.notifyChannel("web-services", netsvc.LOG_ERROR, 'DROP DB: %s failed:\n%s' % (db_name, e)) raise Exception("Couldn't drop database %s: %s" % (db_name, e)) else:
def db_list(self): s = netsvc.ExportService.getService('db') result = s.exp_list() self.db_name_list=[] for db_name in result: cr = None try: db = sql_db.db_connect(db_name) cr = db.cursor() cr.execute("SELECT id FROM ir_module_module WHERE name = 'document' AND state='installed' ") res=cr.fetchone() if res and len(res): self.db_name_list.append(db_name) except Exception, e: self.parent.log_error("Exception in db list: %s" % e) finally:
def grant(self, dbname, partner_id, passwd, type): if not type in ("provider", "customer"): raise 'AccessDenied' cr = sql_db.db_connect(dbname).cursor() sql = '' if type == "provider": sql = " AND id IN (SELECT name FROM product_supplierinfo GROUP BY 1)" cr.execute("""SELECT password='******'%s FROM res_partner WHERE id=%d""" % (passwd, sql, partner_id)) if not cr.rowcount: raise 'AccessDenied' if not cr.fetchone()[0]: raise 'AccessDenied' if not self.external_users: cr.execute( """SELECT user_computer, user_customer, user_provider FROM res_company LIMIT 1""" ) self.external_users = cr.dictfetchone() cr.close() return self.external_users["user_%s" % type]
def db_list(self): s = netsvc.ExportService.getService('db') result = s.exp_list() self.db_name_list = [] for db_name in result: cr = None try: db = sql_db.db_connect(db_name) cr = db.cursor() cr.execute( "SELECT id FROM ir_module_module WHERE name = 'document' AND state='installed' " ) res = cr.fetchone() if res and len(res): self.db_name_list.append(db_name) except Exception, e: self.parent.log_error("Exception in db list: %s" % e) finally:
def contacts(self, db, uid, passwd, model, ids, field, context={}): security.check(db, uid, passwd) conn = sql_db.db_connect(db) cr = conn.cursor() pool = pooler.get_pool(db) # Try to find if there's any relation with 'res.partner.address' (or 'res.partner') # in the given model: addressField = None partnerField = None columns = pool.get( model )._columns for key, value in columns.items(): if value._type == 'many2one': if value._obj == 'res.partner.address': addressField = key break elif value._obj == 'res.parnter': partnerField = key elif value._type == 'one2many' and value._obj == 'res.partner.address': addressField = key elif value._type == 'many2many' and value._obj == 'res.partner.address': addressField = key # Now that we have which field relates to 'res.partner.address' (or 'res.partner') # browse all records and return a list of e-mails for each of them. res = {} for record in pool.get( model ).browse( cr, uid, ids, context=context ): emails = [] if model == 'res.partner.address': if r.email: emails = [r.email] elif addressField: value = record.__getattr__(addressField) if value and isinstance(value, osv.orm.browse_record): if value.email: emails = [value.email] elif value and isinstance(value, osv.orm.browse_record_list): emails = [x.email for x in record.address if x.email] elif partnerField: value = record.__getattr__(partnerField) if value: emails = [x.email for x in value.address if x.email] res[ str(record.id) ] = [ email.strip() for email in emails ] return res
def setValue(self, db, uid, passwd, model, ids, fields, predicate, value, context={}): security.check(db, uid, passwd) conn = sql_db.db_connect(db) cr = conn.cursor() pool = pooler.get_pool(db) model = pool.get('ir.model').search(cr, uid, [('model','=',model)])[0] data = { 'subject_model': model, 'predicate': predicate, 'object': value } for id in ids: data[ 'subject_id' ] = id data[ 'subject_field' ] = None pool.get('nan.semantic.triple').create(cr, uid, data ) for field in fields: data[ 'subject_field' ] = field pool.get('nan.semantic.triple').create(cr, uid, data ) return True
def drop_database(self): """Drop database from `self.db_name` """ import sql_db sql_db.close_db(self.db_name) conn = sql_db.db_connect('template1') cursor = conn.cursor() try: logger.info('Droping database %s', self.db_name) cursor.autocommit(True) logger.info('Disconnect all sessions from database %s', self.db_name) cursor.execute( "SELECT pg_terminate_backend(pg_stat_activity.pid) " " FROM pg_stat_activity " " WHERE pg_stat_activity.datname = '{}'" " AND pid <> pg_backend_pid() ".format(self.db_name) ) cursor.execute('DROP DATABASE ' + self.db_name) finally: cursor.close()
def search(self, db, uid, passwd, text, limit, offset, model, context=None): security.check(db, uid, passwd) pool = pooler.get_pool(db) conn = sql_db.db_connect(db) cr = conn.cursor() try: return self.exp_search(cr, uid, text, limit, offset, model, context) except Exception as e: print("EX: ", str(e)) finally: cr.close()
def value(self, db, uid, passwd, model, ids, field, predicate, context={}): security.check(db, uid, passwd) conn = sql_db.db_connect(db) cr = conn.cursor() pool = pooler.get_pool(db) modelId = pool.get('ir.model').search(cr, uid, [('model','=',model)])[0] query = [('subject_model','=',modelId),('subject_id','in',ids),('predicate','=',predicate)] if field: print("FIELD: ", field) fieldId = pool.get('ir.model.fields').search(cr, uid, [('model','=',modelId),('name','=',field)])[0] query.append( ('subject_field','=',fieldId) ) tripleIds = pool.get('nan.semantic.triple').search(cr, uid, query) data = pool.get('nan.semantic.triple').read(cr, uid, tripleIds, ['subject_id','object']) d = {} for x in data: d[ str(x['subject_id']) ] = x['object'] for x in ids: if str(x) not in d: d[ str(x) ] = -1 return d
def drop_database(self): """Drop database from `self.db_name` """ import sql_db sql_db.close_db(self.db_name) conn = sql_db.db_connect('template1') cursor = conn.cursor() try: logger.info('Droping database %s', self.db_name) cursor.autocommit(True) logger.info('Disconnect all sessions from database %s', self.db_name) cursor.execute("SELECT pg_terminate_backend(pg_stat_activity.pid) " " FROM pg_stat_activity " " WHERE pg_stat_activity.datname = '{}'" " AND pid <> pg_backend_pid() ".format( self.db_name)) cursor.execute('DROP DATABASE ' + self.db_name) finally: cursor.close()
def create_database(self, template=True): """Creates a new database. :param template: use a template (name must be `base`) (default True) """ db_name = 'test_' + str(int(time.time())) import sql_db conn = sql_db.db_connect('template1') cursor = conn.cursor() try: logger.info('Creating database %s', db_name) cursor.autocommit(True) if template: cursor.execute('CREATE DATABASE {} WITH TEMPLATE base'.format( db_name )) else: cursor.execute('CREATE DATABASE {}'.format(db_name)) return db_name finally: cursor.close()
def tags(self, db, uid, passwd, model, ids, field, context={}): security.check(db, uid, passwd) conn = sql_db.db_connect(db) cr = conn.cursor() pool = pooler.get_pool(db) mids = pool.get('ir.model').search(cr, uid, [('model','=',model)], context=context) modelName = pool.get('ir.model').read(cr, uid, mids, ['name'], context=context)[0]['name'] commonTags = [ 'OpenERP', modelName ] res = {} for id in ids: ts = commonTags[:] if model == 'ir.attachment': modelName = pool.get('ir.attachment').read(cr, uid, id, ['res_model'], context=context)['res_model'] mids = pool.get('ir.model').search(cr, uid, [('model','=',modelName)], context=context) modelName = pool.get('ir.model').read(cr, uid, mids, ['name'], context=context)[0]['name'] ts.append( modelName ) res[str(id)] = ts return res
def description(self, db, uid, passwd, model, ids, field, context={}): security.check(db, uid, passwd) conn = sql_db.db_connect(db) cr = conn.cursor() pool = pooler.get_pool(db) descriptionField = None columns = pool.get( model )._columns possibleFields = ['description', 'notes', 'note', 'comment', 'comments'] for f in possibleFields: if f in columns: descriptionField = f res = {} data = pool.get( model ).read(cr, uid, ids, ['id', descriptionField], context=context) for record in data: if descriptionField and record[descriptionField]: value = record[descriptionField] else: value = '' res[ str(record['id']) ] = value return res
def emit(self, record): ct = threading.current_thread() ct_db = getattr(ct, 'dbname', None) ct_uid = getattr(ct, 'uid', None) dbname = tools.config['log_db'] or ct_db if not dbname: return with tools.ignore(Exception), sql_db.db_connect(dbname).cursor() as cr: msg = tools.ustr(record.msg) if record.args: msg = msg % record.args traceback = getattr(record, 'exc_text', '') if traceback: msg = "%s\n%s" % (msg, traceback) # we do not use record.levelname because it may have been changed by ColoredFormatter. levelname = logging.getLevelName(record.levelno) val = (ct_uid, ct_uid, 'server', ct_db, record.name, levelname, msg, record.pathname, record.lineno, record.funcName) cr.execute(""" INSERT INTO ir_logging(create_date, write_date, create_uid, write_uid, type, dbname, name, level, message, path, line, func) VALUES (NOW() at time zone 'UTC', NOW() at time zone 'UTC', %s, %s, %s, %s, %s, %s, %s, %s, %s, %s) """, val)
def emit(self, record): ct = threading.current_thread() ct_db = getattr(ct, 'dbname', None) dbname = tools.config['log_db'] if tools.config['log_db'] and tools.config['log_db'] != '%d' else ct_db if not dbname: return with tools.ignore(Exception), tools.mute_logger('openerp.sql_db'), sql_db.db_connect(dbname, allow_uri=True).cursor() as cr: cr.autocommit(True) msg = tools.ustr(record.msg) if record.args: msg = msg % record.args traceback = getattr(record, 'exc_text', '') if traceback: msg = "%s\n%s" % (msg, traceback) # we do not use record.levelname because it may have been changed by ColoredFormatter. levelname = logging.getLevelName(record.levelno) val = ('server', ct_db, record.name, levelname, msg, record.pathname[len(path_prefix)+1:], record.lineno, record.funcName) cr.execute(""" INSERT INTO ir_logging(create_date, type, dbname, name, level, message, path, line, func) VALUES (NOW() at time zone 'UTC', %s, %s, %s, %s, %s, %s, %s, %s) """, val)
def exp_connected_to_prod_sync_server(self, db_name): """Return True if db_name is connected to a production SYNC_SERVER, False otherwise""" connection = sql_db.db_connect(db_name) # it the db connnected to a sync_server ? server_connecion_module = pooler.get_pool(db_name, upgrade_modules=False).get('sync.client.sync_server_connection') if not server_connecion_module: return False if not getattr(server_connecion_module, '_uid', False): return False cr = connection.cursor() cr.execute('''SELECT host, database FROM sync_client_sync_server_connection''') host, database = cr.fetchone() cr.close() if host and database and database.strip() == 'SYNC_SERVER' and \ ('sync.unifield.net' in host.lower() or '212.95.73.129' in host): return True return False
def create_database(self, template=True): """ Creates a new database. :param template: use a template (name must be `base`) (default True) """ db_name = 'test_' + str(int(time.time())) import sql_db conn = sql_db.db_connect('postgres') cursor = conn.cursor() try: self.logger.info('Creating database %s', db_name) cursor.autocommit(True) if template: cursor.execute( 'CREATE DATABASE {} WITH TEMPLATE base'.format(db_name)) else: cursor.execute('CREATE DATABASE {}'.format(db_name)) return db_name finally: cursor.close() sql_db.close_db('postgres')
def emit(self, record): ct = threading.current_thread() ct_db = getattr(ct, 'dbname', None) ct_uid = getattr(ct, 'uid', None) dbname = tools.config['log_db'] or ct_db if dbname: cr = None try: cr = sql_db.db_connect(dbname).cursor() msg = unicode(record.msg) traceback = getattr(record, 'exc_text', '') if traceback: msg = "%s\n%s" % (msg, traceback) level = logging.getLevelName(record.levelno) val = (ct_uid, ct_uid, 'server', ct_db, record.name, level, msg, record.pathname, record.lineno, record.funcName) cr.execute(""" INSERT INTO ir_logging(create_date, write_date, create_uid, write_uid, type, dbname, name, level, message, path, line, func) VALUES (NOW() at time zone 'UTC', NOW() at time zone 'UTC', %s, %s, %s, %s, %s, %s, %s, %s, %s, %s) """, val ) cr.commit() except Exception, e: pass finally:
def exp_check_connectivity(self): return bool(sql_db.db_connect('template1'))
def exp_db_exist(self, db_name): ## Not True: in fact, check if connection to database is possible. The database may exists return bool(sql_db.db_connect(db_name))
def _cr(): """docstring for _cr""" if orm['cr']._Cursor__closed: db = sql_db.db_connect(orm['cr'].dbname) orm['cr'] = db.cursor() return orm['cr']