def get_userinfo(self, user, password, command=''):
path = urlparse.urlparse(self.path).path
dbname = urllib.unquote_plus(path.split('/', 2)[1])
database = Database().connect()
cursor = database.cursor()
databases = database.list(cursor)
cursor.close()
if not dbname or dbname not in databases:
return True
if user:
user = int(login(dbname, user, password, cache=False))
if not user:
return None
else:
url = urlparse.urlparse(self.path)
query = urlparse.parse_qs(url.query)
path = url.path[len(dbname) + 2:]
if 'key' in query:
key, = query['key']
with Transaction().start(dbname, 0) as transaction:
database_list = Pool.database_list()
pool = Pool(dbname)
if not dbname in database_list:
pool.init()
Share = pool.get('webdav.share')
user = Share.get_login(key, command, path)
transaction.cursor.commit()
if not user:
return None
Transaction().start(dbname, user)
Cache.clean(dbname)
return user
def get_childs(self, uri, filter=None):
res = []
dbname, dburi = self._get_dburi(uri)
if not dbname:
database = Database().connect()
cursor = database.cursor()
try:
lists = database.list(cursor)
except Exception:
lists = []
finally:
cursor.close()
for dbname in lists:
res.append(urlparse.urljoin(uri, dbname))
return res
pool = Pool(Transaction().cursor.database_name)
try:
Collection = pool.get('webdav.collection')
scheme, netloc, path, params, query, fragment = \
urlparse.urlparse(uri)
if path[-1:] != '/':
path += '/'
for child in Collection.get_childs(dburi, filter=filter,
cache=CACHE):
res.append(urlparse.urlunparse((scheme, netloc,
path + child.encode('utf-8'), params, query,
fragment)))
except KeyError:
return res
except (DAV_Error, DAV_NotFound, DAV_Secret, DAV_Forbidden), exception:
self._log_exception(exception)
raise
def init(self):
from trytond.config import CONFIG
CONFIG['database_type'] = 'sqlite'
self.db_name = ':memory:'
from trytond.backend import Database
database = Database()
cursor = database.cursor()
databases = database.list(cursor)
cursor.close()
if self.db_name not in databases:
from trytond.protocols.dispatcher import create
create(self.db_name, 'admin', 'en_US', 'admin')
self.user = 1
self.context = None
from trytond.pool import Pool
from trytond.transaction import Transaction
with Transaction().start(self.db_name, self.user, self.context) as txn:
self.pool = Pool(self.db_name)
self.pool.init()
self.initialised = True
def install_module(name):
'''
Install module for the tested database
'''
database = Database().connect()
cursor = database.cursor()
databases = database.list(cursor)
cursor.close()
if DB_NAME not in databases:
create(DB_NAME, CONFIG['admin_passwd'], 'en_US', USER_PASSWORD)
with Transaction().start(DB_NAME, USER,
context=CONTEXT) as transaction:
module_obj = POOL.get('ir.module.module')
module_ids = module_obj.search([
('name', '=', name),
])
assert module_ids
module_ids = module_obj.search([
('name', '=', name),
('state', '!=', 'installed'),
])
if not module_ids:
return
module_obj.install(module_ids)
transaction.cursor.commit()
install_upgrade_obj = POOL.get('ir.module.module.install_upgrade',
type='wizard')
install_upgrade_obj.transition_upgrade(None)
transaction.cursor.commit()
def database_list():
"""Fetch all databases in current instance"""
from trytond.backend import Database
database = Database().connect()
cursor = database.cursor()
databases = database.list(cursor)
cursor.close()
return databases
def drop_all():
from trytond.backend import Database
database = Database().connect()
cursor = database.cursor()
erase_cursor = database.cursor(autocommit=True)
for db in database.list(cursor):
print "Dropping database %s" % db
database.drop(erase_cursor, db)
erase_cursor.close()
cursor.close()
def dispatch(host, port, protocol, database_name, user, session, object_type,
object_name, method, *args, **kargs):
if object_type == 'common':
if method == 'login':
try:
database = Database(database_name).connect()
cursor = database.cursor()
cursor.close()
except Exception:
return False
res = security.login(database_name, user, session)
Cache.clean(database_name)
logger = logging.getLogger('dispatcher')
msg = res and 'successful login' or 'bad login or password'
logger.info('%s \'%s\' from %s:%d using %s on database \'%s\'' % \
(msg, user, host, port, protocol, database_name))
Cache.resets(database_name)
return res or False
elif method == 'logout':
name = security.logout(database_name, user, session)
logger = logging.getLogger('dispatcher')
logger.info('logout \'%s\' from %s:%d ' \
'using %s on database \'%s\'' %
(name, host, port, protocol, database_name))
return True
elif method == 'version':
return VERSION
elif method == 'timezone_get':
return CONFIG['timezone']
elif method == 'list_lang':
return [
('bg_BG', 'Български'),
('ca_ES', 'Català'),
('cs_CZ', 'Čeština'),
('de_DE', 'Deutsch'),
('en_US', 'English'),
('es_AR', 'Español (Argentina)'),
('es_ES', 'Español (España)'),
('es_CO', 'Español (Colombia)'),
('fr_FR', 'Français'),
('nl_NL', 'Nederlands'),
('ru_RU', 'Russian'),
]
elif method == 'db_exist':
try:
database = Database(*args, **kargs).connect()
cursor = database.cursor()
cursor.close(close=True)
return True
except Exception:
return False
elif method == 'list':
if CONFIG['prevent_dblist']:
raise Exception('AccessDenied')
database = Database().connect()
try:
cursor = database.cursor()
try:
res = database.list(cursor)
finally:
cursor.close(close=True)
except Exception:
res = []
return res
elif method == 'create':
return create(*args, **kargs)
elif method == 'restore':
return restore(*args, **kargs)
elif method == 'drop':
return drop(*args, **kargs)
elif method == 'dump':
return dump(*args, **kargs)
return
elif object_type == 'system':
database = Database(database_name).connect()
database_list = Pool.database_list()
pool = Pool(database_name)
if not database_name in database_list:
pool.init()
if method == 'listMethods':
res = []
for type in ('model', 'wizard', 'report'):
for object_name, obj in pool.iterobject(type=type):
for method in obj._rpc:
res.append(type + '.' + object_name + '.' + method)
return res
elif method == 'methodSignature':
return 'signatures not supported'
elif method == 'methodHelp':
res = []
args_list = args[0].split('.')
object_type = args_list[0]
object_name = '.'.join(args_list[1:-1])
method = args_list[-1]
obj = pool.get(object_name, type=object_type)
return pydoc.getdoc(getattr(obj, method))
user = security.check(database_name, user, session)
Cache.clean(database_name)
database_list = Pool.database_list()
pool = Pool(database_name)
if not database_name in database_list:
with Transaction().start(database_name, user,
readonly=True) as transaction:
pool.init()
obj = pool.get(object_name, type=object_type)
if method in obj._rpc:
readonly = not obj._rpc[method]
elif method in getattr(obj, '_buttons', {}):
readonly = False
else:
raise UserError('Calling method %s on %s %s is not allowed!'
% (method, object_type, object_name))
for count in range(int(CONFIG['retry']), -1, -1):
with Transaction().start(database_name, user,
readonly=readonly) as transaction:
try:
args_without_context = list(args)
if 'context' in kargs:
context = kargs.pop('context')
else:
context = args_without_context.pop()
if '_timestamp' in context:
transaction.timestamp = context['_timestamp']
del context['_timestamp']
transaction.context = context
res = getattr(obj, method)(*args_without_context, **kargs)
if not readonly:
transaction.cursor.commit()
except DatabaseOperationalError, exception:
transaction.cursor.rollback()
if count and not readonly:
continue
raise
except Exception, exception:
if CONFIG['verbose'] and not isinstance(exception, (
NotLogged, ConcurrencyException, UserError,
UserWarning)):
tb_s = ''.join(traceback.format_exception(*sys.exc_info()))
logger = logging.getLogger('dispatcher')
logger.error('Exception calling method %s on '
'%s %s from %s@%s:%d/%s:\n'
% (method, object_type, object_name, user, host, port,
database_name) + tb_s)
transaction.cursor.rollback()
raise
