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 _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 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 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 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 __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 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 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 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 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 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 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 exp_check_connectivity(self):
return bool(sql_db.db_connect('template1'))
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']
