def open_connection(self, con_params):
try:
repo_base = con_params.user
if con_params.repo_base and con_params.repo_base != '':
repo_base = con_params.repo_base
user = ''
is_app = False
if con_params.user:
user = con_params.user
DataHubConnection(user=con_params.user,
password=hashlib.sha1(
con_params.password).hexdigest(),
repo_base=repo_base)
else:
user = con_params.app_id
is_app = True
DataHubConnection(user=con_params.app_id,
password=hashlib.sha1(
con_params.app_token).hexdigest(),
repo_base=repo_base)
'''
res = DataHubManager.has_base_privilege(user, repo_base, 'CONNECT')
if not (res and res['tuples'][0][0]):
raise Exception('Access denied. Missing required privileges.')
'''
con = Connection(user=user, is_app=is_app, repo_base=repo_base)
return con
except Exception as e:
raise DBException(message=str(e))
def has_base_privilege(login, repo_base, privilege):
superuser_con = DataHubConnection(
user=settings.DATABASES['default']['USER'],
password=settings.DATABASES['default']['USER'],
repo_base=repo_base)
return superuser_con.has_base_privilege(login=login,
privilege=privilege)
def delete_collaborator(self, repo, collaborator):
superuser_con = DataHubConnection(
user=settings.DATABASES['default']['USER'],
password=settings.DATABASES['default']['USER'],
repo_base=self.repo_base)
repo_collaborators = superuser_con.list_collaborators(repo=repo)
# The reason we're enforcing permission checks this way is to deal
# with the edge case where a user removes himself as a collaborator
# from another user's repo.
if collaborator not in repo_collaborators:
raise Exception('Failed to delete collaborator.'
' %s is not a collaborator in the specified'
'repository.' % collaborator)
if self.username != collaborator and self.username != self.repo_base:
raise PermissionDenied(
'Access denied. Missing required privileges')
collab = User.objects.get(username=collaborator)
Collaborator.objects.get(user=collab,
repo_name=repo,
repo_base=self.repo_base).delete()
return superuser_con.delete_collaborator(repo=repo,
collaborator=collaborator)
def __init__(self, user=settings.ANONYMOUS_ROLE, repo_base=None,
is_app=False):
# blank users are set to anonymous role
if user == '':
user = settings.ANONYMOUS_ROLE
username = None
password = None
if is_app:
app = App.objects.get(app_id=user)
username = app.app_id
password = hashlib.sha1(app.app_token).hexdigest()
else:
user = User.objects.get(username=user)
username = user.username
password = user.password
if not repo_base:
repo_base = username
self.username = username
self.repo_base = repo_base
self.user_con = DataHubConnection(
user=username,
repo_base=repo_base,
password=password)
def create_user(username, password, create_db=True):
superuser_con = DataHubConnection(
user=settings.DATABASES['default']['USER'],
password=settings.DATABASES['default']['USER'])
return superuser_con.create_user(username=username,
password=password,
create_db=create_db)
def remove_app(app_id):
app = App.objects.get(app_id=app_id)
app.delete()
superuser_con = DataHubConnection(
user=settings.DATABASES['default']['USER'],
password=settings.DATABASES['default']['USER'])
superuser_con.remove_user(username=app_id)
def list_all_databases():
'''
lists all user databases. Does not list some,
like postgres, templates0, templates1, or datahub
'''
superuser_con = DataHubConnection(
user=settings.DATABASES['default']['USER'],
password=settings.DATABASES['default']['USER'])
return superuser_con.list_all_databases()
def import_file(username,
repo_base,
repo,
table,
file_name,
file_format='CSV',
delimiter=',',
header=True,
encoding='ISO-8859-1',
quote_character='"'):
# check for permissions
delimiter = delimiter.decode('string_escape')
res = DataHubManager.has_repo_privilege(username, repo_base, repo,
'CREATE')
if not res:
raise PermissionDenied(
'Access denied. Missing required privileges.')
# prepare some variables
file_path = user_data_path(repo_base, repo, file_name)
table_name, _ = os.path.splitext(file_name)
table_name = clean_str(table_name, 'table')
dh_table_name = '%s.%s.%s' % (repo_base, repo, table_name)
# open the file
f = codecs.open(file_path, 'r', 'ISO-8859-1')
data = csv.reader(f, delimiter=delimiter)
# create a table for the data
cells = data.next()
columns = [clean_str(str(i), 'col') for i in range(0, len(cells))]
if header:
columns = map(lambda x: clean_str(x, 'col'), cells)
columns = rename_duplicates(columns)
query = 'CREATE TABLE %s (%s text' % (dh_table_name, columns[0])
for column in columns[1:len(columns)]:
query += ', %s %s' % (column, 'text')
query += ')'
manager = DataHubManager(user=username, repo_base=repo_base)
manager.execute_sql(query=query)
# populate the newly created table with data from the csv
superuser_con = DataHubConnection(
user=settings.DATABASES['default']['USER'],
password=settings.DATABASES['default']['USER'],
repo_base=repo_base)
return superuser_con.import_file(table_name=dh_table_name,
file_path=file_path,
file_format=file_format,
delimiter=delimiter,
header=header,
encoding=encoding,
quote_character=quote_character)
def create_user(username, password, create_db=True):
"""Creates a DB role, database, and data folder for a new user."""
superuser_con = DataHubConnection(
user=settings.DATABASES['default']['USER'],
password=settings.DATABASES['default']['USER'])
res = superuser_con.create_user(username=username,
password=password,
create_db=create_db)
DataHubManager.create_user_data_folder(username)
return res
def remove_database(repo_name, revoke_collaborators=True):
collaborators = Collaborator.objects.filter(repo_name=repo_name)
for collaborator in collaborators:
collaborator.delete()
DataHubManager.delete_user_data_folder(repo_name)
superuser_con = DataHubConnection(
user=settings.DATABASES['default']['USER'],
password=settings.DATABASES['default']['USER'])
return superuser_con.remove_database(repo_name, revoke_collaborators)
def export_query(repo_base,
query,
file_path,
file_format='CSV',
delimiter=',',
header=True):
superuser_con = DataHubConnection(
user=settings.DATABASES['default']['USER'],
password=settings.DATABASES['default']['USER'],
repo_base=repo_base)
return superuser_con.export_query(query=query,
file_path=file_path,
file_format=file_format,
delimiter=delimiter,
header=header)
def __init__(self, user, repo_base=None, is_app=False):
username = None
password = None
if is_app:
app = App.objects.get(app_id=user)
username = app.app_id
password = hashlib.sha1(app.app_token).hexdigest()
else:
user = User.objects.get(username=user)
username = user.username
password = user.password
self.user_con = DataHubConnection(user=username,
repo_base=repo_base,
password=password)
def remove_user(username, remove_db=True):
# get the user associated with the username, and delete their apps
try:
user = User.objects.get(username=username)
apps = App.objects.filter(user=user)
for app in apps:
app_id = app.app_id
DataHubManager.remove_app(app_id=app_id)
Collaborator.objects.filter(user=user).delete()
except:
user = None
# do the same thing for legacy users
try:
legacy_user = DataHubLegacyUser.objects.get(username=username)
apps = App.objects.filter(legacy_user=legacy_user)
for app in apps:
app_id = app.app_id
DataHubManager.remove_app(app_id=app_id)
except:
legacy_user = None
# delete the users
if user:
user.delete()
if legacy_user:
legacy_user.delete()
# delete the user's db
if remove_db:
DataHubManager.remove_database(username)
# make a connection, and delete the user's database account
superuser_con = DataHubConnection(
user=settings.DATABASES['default']['USER'],
password=settings.DATABASES['default']['USER'])
try:
return superuser_con.remove_user(username=username)
except:
all_db_list = DataHubManager.list_all_databases()
for db in all_db_list:
DataHubManager.drop_owned_by(username=username, repo_base=db)
return superuser_con.remove_user(username=username)
def import_file(repo_base,
table_name,
file_path,
file_format='CSV',
delimiter=',',
header=True,
encoding='ISO-8859-1',
quote_character='"'):
superuser_con = DataHubConnection(
user=settings.DATABASES['default']['USER'],
password=settings.DATABASES['default']['USER'],
repo_base=repo_base)
return superuser_con.import_file(table_name=table_name,
file_path=file_path,
file_format=file_format,
delimiter=delimiter,
header=header,
encoding=encoding,
quote_character=quote_character)
def export_table(username,
repo_base,
repo,
table,
file_format='CSV',
delimiter=',',
header=True):
"""
Export a table to a CSV file in the same repo.
Only superusers can execute the copy command, so this function
passes the username, and verifies user's permissions.
"""
# check for permissions
res = DataHubManager.has_repo_privilege(username, repo_base, repo,
'CREATE')
if not res:
raise PermissionDenied(
'Access denied. Missing required privileges.')
# make the base_repo and repo's folder, if they don't already exist
DataHubManager.create_user_data_folder(repo_base, repo)
# define the file path for the new table
file_name = clean_file_name(table)
file_path = user_data_path(repo_base, repo, file_name, file_format)
# format the full table name
long_table_name = '%s.%s.%s' % (repo_base, repo, table)
# pass arguments to the connector
superuser_con = DataHubConnection(
user=settings.DATABASES['default']['USER'],
password=settings.DATABASES['default']['USER'],
repo_base=repo_base)
return superuser_con.export_table(table_name=long_table_name,
file_path=file_path,
file_format=file_format,
delimiter=delimiter,
header=header)
def list_all_users():
superuser_con = DataHubConnection(
user=settings.DATABASES['default']['USER'],
password=settings.DATABASES['default']['USER'])
return superuser_con.list_all_users()
def remove_user(username):
superuser_con = DataHubConnection(
user=settings.DATABASES['default']['USER'],
password=settings.DATABASES['default']['USER'])
return superuser_con.remove_user(username=username)
def __enter__(self):
self.superuser_con = DataHubConnection(
user=settings.DATABASES['default']['USER'],
password=settings.DATABASES['default']['PASSWORD'],
repo_base=self.repo_base)
return self.superuser_con
def list_collaborators(self, repo):
superuser_con = DataHubConnection(
user=settings.DATABASES['default']['USER'],
password=settings.DATABASES['default']['USER'],
repo_base=self.repo_base)
return superuser_con.list_collaborators(repo=repo)
def database_exists(db_name):
superuser_con = DataHubConnection(
user=settings.DATABASES['default']['USER'],
password=settings.DATABASES['default']['USER'])
return superuser_con.database_exists(db_name)
def drop_owned_by(username, repo_base):
superuser_con = DataHubConnection(
user=settings.DATABASES['default']['USER'],
password=settings.DATABASES['default']['USER'],
repo_base=repo_base)
return superuser_con.drop_owned_by(username)
def change_password(username, password):
superuser_con = DataHubConnection(
user=settings.DATABASES['default']['USER'],
password=settings.DATABASES['default']['USER'])
return superuser_con.change_password(username=username,
password=password)
