2013-09-20 15:55:44 +00:00
|
|
|
import bcrypt
|
2013-09-20 22:38:17 +00:00
|
|
|
import logging
|
2013-09-26 19:58:11 +00:00
|
|
|
import dateutil.parser
|
2013-11-15 21:45:02 +00:00
|
|
|
import json
|
2013-09-20 15:55:44 +00:00
|
|
|
|
2014-09-02 19:27:05 +00:00
|
|
|
from datetime import datetime, timedelta
|
|
|
|
|
2014-09-22 21:27:02 +00:00
|
|
|
from data.database import (User, Repository, Image, AccessToken, Role, RepositoryPermission,
|
|
|
|
Visibility, RepositoryTag, EmailConfirmation, FederatedLogin,
|
|
|
|
LoginService, RepositoryBuild, Team, TeamMember, TeamRole,
|
|
|
|
LogEntryKind, LogEntry, PermissionPrototype, ImageStorage,
|
|
|
|
BuildTriggerService, RepositoryBuildTrigger, NotificationKind,
|
|
|
|
Notification, ImageStorageLocation, ImageStoragePlacement,
|
|
|
|
ExternalNotificationEvent, ExternalNotificationMethod,
|
|
|
|
RepositoryNotification, RepositoryAuthorizedEmail, TeamMemberInvite,
|
|
|
|
random_string_generator, db, BUILD_PHASE)
|
|
|
|
from peewee import JOIN_LEFT_OUTER, fn
|
|
|
|
from util.validation import (validate_username, validate_email, validate_password,
|
|
|
|
INVALID_PASSWORD_MESSAGE)
|
2013-11-20 21:13:03 +00:00
|
|
|
from util.names import format_robot_username
|
2014-09-02 19:27:05 +00:00
|
|
|
from util.backoff import exponential_backoff
|
|
|
|
|
|
|
|
|
|
|
|
EXPONENTIAL_BACKOFF_SCALE = timedelta(seconds=1)
|
2014-09-08 20:43:17 +00:00
|
|
|
PRESUMED_DEAD_BUILD_AGE = timedelta(days=15)
|
2013-09-20 22:38:17 +00:00
|
|
|
|
|
|
|
|
|
|
|
logger = logging.getLogger(__name__)
|
2014-05-13 16:17:26 +00:00
|
|
|
|
|
|
|
|
|
|
|
class Config(object):
|
|
|
|
def __init__(self):
|
|
|
|
self.app_config = None
|
|
|
|
self.store = None
|
|
|
|
|
|
|
|
config = Config()
|
|
|
|
|
2013-09-20 15:55:44 +00:00
|
|
|
|
2013-09-27 19:53:39 +00:00
|
|
|
class DataModelException(Exception):
|
|
|
|
pass
|
|
|
|
|
|
|
|
|
2013-10-10 16:55:03 +00:00
|
|
|
class InvalidEmailAddressException(DataModelException):
|
|
|
|
pass
|
|
|
|
|
|
|
|
|
|
|
|
class InvalidUsernameException(DataModelException):
|
|
|
|
pass
|
|
|
|
|
2013-09-27 22:38:41 +00:00
|
|
|
|
2013-11-01 23:34:17 +00:00
|
|
|
class InvalidOrganizationException(DataModelException):
|
|
|
|
pass
|
|
|
|
|
|
|
|
|
2013-11-20 21:13:03 +00:00
|
|
|
class InvalidRobotException(DataModelException):
|
|
|
|
pass
|
|
|
|
|
|
|
|
|
2013-11-01 23:34:17 +00:00
|
|
|
class InvalidTeamException(DataModelException):
|
|
|
|
pass
|
|
|
|
|
2014-08-15 21:47:43 +00:00
|
|
|
class InvalidTeamMemberException(DataModelException):
|
|
|
|
pass
|
|
|
|
|
2013-11-01 23:34:17 +00:00
|
|
|
|
2013-10-10 16:55:03 +00:00
|
|
|
class InvalidPasswordException(DataModelException):
|
|
|
|
pass
|
|
|
|
|
|
|
|
|
2013-10-16 18:24:10 +00:00
|
|
|
class InvalidTokenException(DataModelException):
|
|
|
|
pass
|
|
|
|
|
|
|
|
|
2013-10-24 20:37:03 +00:00
|
|
|
class InvalidRepositoryBuildException(DataModelException):
|
|
|
|
pass
|
|
|
|
|
|
|
|
|
2014-07-16 20:30:47 +00:00
|
|
|
class InvalidNotificationException(DataModelException):
|
|
|
|
pass
|
|
|
|
|
|
|
|
|
2014-02-18 20:50:15 +00:00
|
|
|
class InvalidBuildTriggerException(DataModelException):
|
|
|
|
pass
|
|
|
|
|
|
|
|
|
2014-05-28 17:51:52 +00:00
|
|
|
class TooManyUsersException(DataModelException):
|
|
|
|
pass
|
|
|
|
|
|
|
|
|
2014-08-18 21:24:00 +00:00
|
|
|
class UserAlreadyInTeam(DataModelException):
|
|
|
|
pass
|
|
|
|
|
|
|
|
|
2014-09-02 19:27:05 +00:00
|
|
|
class TooManyLoginAttemptsException(Exception):
|
|
|
|
def __init__(self, message, retry_after):
|
|
|
|
super(TooManyLoginAttemptsException, self).__init__(message)
|
|
|
|
self.retry_after = retry_after
|
|
|
|
|
2014-09-18 21:36:26 +00:00
|
|
|
def hash_password(password, salt=None):
|
|
|
|
salt = salt or bcrypt.gensalt()
|
|
|
|
return bcrypt.hashpw(password.encode('utf-8'), salt)
|
2014-05-28 17:51:52 +00:00
|
|
|
|
|
|
|
def is_create_user_allowed():
|
2014-08-21 23:21:20 +00:00
|
|
|
return True
|
2014-05-28 17:51:52 +00:00
|
|
|
|
2014-09-22 23:11:48 +00:00
|
|
|
def create_user(username, password, email, auto_verify=False):
|
2014-05-28 17:51:52 +00:00
|
|
|
""" Creates a regular user, if allowed. """
|
|
|
|
if not validate_password(password):
|
|
|
|
raise InvalidPasswordException(INVALID_PASSWORD_MESSAGE)
|
|
|
|
|
|
|
|
if not is_create_user_allowed():
|
|
|
|
raise TooManyUsersException()
|
|
|
|
|
|
|
|
created = _create_user(username, email)
|
2014-09-22 23:11:48 +00:00
|
|
|
created.password_hash = hash_password(password)
|
|
|
|
created.verified = auto_verify
|
2014-05-28 17:51:52 +00:00
|
|
|
created.save()
|
|
|
|
|
|
|
|
return created
|
|
|
|
|
|
|
|
def _create_user(username, email):
|
2013-09-27 22:38:41 +00:00
|
|
|
if not validate_email(email):
|
2013-10-10 16:55:03 +00:00
|
|
|
raise InvalidEmailAddressException('Invalid email address: %s' % email)
|
2014-04-08 00:37:02 +00:00
|
|
|
|
|
|
|
(username_valid, username_issue) = validate_username(username)
|
|
|
|
if not username_valid:
|
|
|
|
raise InvalidUsernameException('Invalid username %s: %s' % (username, username_issue))
|
2013-10-10 16:55:03 +00:00
|
|
|
|
|
|
|
try:
|
|
|
|
existing = User.get((User.username == username) | (User.email == email))
|
|
|
|
|
2013-11-20 21:13:03 +00:00
|
|
|
logger.info('Existing user with same username or email.')
|
2013-10-10 16:55:03 +00:00
|
|
|
|
|
|
|
# A user already exists with either the same username or email
|
|
|
|
if existing.username == username:
|
|
|
|
raise InvalidUsernameException('Username has already been taken: %s' %
|
|
|
|
username)
|
|
|
|
raise InvalidEmailAddressException('Email has already been used: %s' %
|
|
|
|
email)
|
|
|
|
|
|
|
|
except User.DoesNotExist:
|
|
|
|
# This is actually the happy path
|
|
|
|
logger.debug('Email and username are unique!')
|
|
|
|
pass
|
2013-09-27 22:38:41 +00:00
|
|
|
|
2013-09-27 22:16:26 +00:00
|
|
|
try:
|
2014-05-28 17:51:52 +00:00
|
|
|
new_user = User.create(username=username, email=email)
|
2013-09-27 23:29:01 +00:00
|
|
|
return new_user
|
2013-09-27 22:16:26 +00:00
|
|
|
except Exception as ex:
|
|
|
|
raise DataModelException(ex.message)
|
2013-09-27 23:29:01 +00:00
|
|
|
|
|
|
|
|
2014-05-13 16:17:26 +00:00
|
|
|
def is_username_unique(test_username):
|
|
|
|
try:
|
|
|
|
User.get((User.username == test_username))
|
|
|
|
return False
|
|
|
|
except User.DoesNotExist:
|
|
|
|
return True
|
|
|
|
|
|
|
|
|
2013-11-01 23:34:17 +00:00
|
|
|
def create_organization(name, email, creating_user):
|
|
|
|
try:
|
|
|
|
# Create the org
|
2014-05-28 17:51:52 +00:00
|
|
|
new_org = _create_user(name, email)
|
2013-11-01 23:34:17 +00:00
|
|
|
new_org.organization = True
|
|
|
|
new_org.save()
|
|
|
|
|
|
|
|
# Create a team for the owners
|
2013-11-04 21:57:20 +00:00
|
|
|
owners_team = create_team('owners', new_org, 'admin')
|
2013-11-01 23:34:17 +00:00
|
|
|
|
2013-11-04 20:42:08 +00:00
|
|
|
# Add the user who created the org to the owners team
|
2013-11-01 23:34:17 +00:00
|
|
|
add_user_to_team(creating_user, owners_team)
|
|
|
|
|
|
|
|
return new_org
|
|
|
|
except InvalidUsernameException:
|
2014-02-07 00:59:10 +00:00
|
|
|
msg = ('Invalid organization name: %s Organization names must consist ' +
|
|
|
|
'solely of lower case letters, numbers, and underscores. ' +
|
|
|
|
'[a-z0-9_]') % name
|
|
|
|
raise InvalidOrganizationException(msg)
|
2013-11-01 23:34:17 +00:00
|
|
|
|
|
|
|
|
2013-11-20 21:13:03 +00:00
|
|
|
def create_robot(robot_shortname, parent):
|
2014-04-08 00:37:02 +00:00
|
|
|
(username_valid, username_issue) = validate_username(robot_shortname)
|
|
|
|
if not username_valid:
|
|
|
|
raise InvalidRobotException('The name for the robot \'%s\' is invalid: %s' %
|
|
|
|
(robot_shortname, username_issue))
|
2013-11-20 21:13:03 +00:00
|
|
|
|
|
|
|
username = format_robot_username(parent.username, robot_shortname)
|
|
|
|
|
|
|
|
try:
|
|
|
|
User.get(User.username == username)
|
|
|
|
|
|
|
|
msg = 'Existing robot with name: %s' % username
|
|
|
|
logger.info(msg)
|
|
|
|
raise InvalidRobotException(msg)
|
|
|
|
|
|
|
|
except User.DoesNotExist:
|
|
|
|
pass
|
|
|
|
|
|
|
|
try:
|
|
|
|
created = User.create(username=username, robot=True)
|
|
|
|
|
|
|
|
service = LoginService.get(name='quayrobot')
|
|
|
|
password = created.email
|
|
|
|
FederatedLogin.create(user=created, service=service,
|
|
|
|
service_ident=password)
|
|
|
|
|
|
|
|
return created, password
|
|
|
|
except Exception as ex:
|
|
|
|
raise DataModelException(ex.message)
|
|
|
|
|
2014-08-25 21:19:23 +00:00
|
|
|
def get_robot(robot_shortname, parent):
|
|
|
|
robot_username = format_robot_username(parent.username, robot_shortname)
|
|
|
|
robot = lookup_robot(robot_username)
|
|
|
|
|
|
|
|
if not robot:
|
|
|
|
msg = ('Could not find robot with username: %s' %
|
|
|
|
robot_username)
|
|
|
|
raise InvalidRobotException(msg)
|
|
|
|
|
|
|
|
service = LoginService.get(name='quayrobot')
|
|
|
|
login = FederatedLogin.get(FederatedLogin.user == robot, FederatedLogin.service == service)
|
|
|
|
|
|
|
|
return robot, login.service_ident
|
2013-11-20 21:13:03 +00:00
|
|
|
|
2014-03-27 22:33:13 +00:00
|
|
|
def lookup_robot(robot_username):
|
|
|
|
joined = User.select().join(FederatedLogin).join(LoginService)
|
|
|
|
found = list(joined.where(LoginService.name == 'quayrobot',
|
|
|
|
User.username == robot_username))
|
|
|
|
if not found or len(found) < 1 or not found[0].robot:
|
|
|
|
return None
|
|
|
|
|
|
|
|
return found[0]
|
|
|
|
|
2013-11-20 21:13:03 +00:00
|
|
|
def verify_robot(robot_username, password):
|
|
|
|
joined = User.select().join(FederatedLogin).join(LoginService)
|
|
|
|
found = list(joined.where(FederatedLogin.service_ident == password,
|
|
|
|
LoginService.name == 'quayrobot',
|
|
|
|
User.username == robot_username))
|
|
|
|
if not found:
|
|
|
|
msg = ('Could not find robot with username: %s and supplied password.' %
|
|
|
|
robot_username)
|
|
|
|
raise InvalidRobotException(msg)
|
|
|
|
|
|
|
|
return found[0]
|
|
|
|
|
2014-08-25 21:19:23 +00:00
|
|
|
def regenerate_robot_token(robot_shortname, parent):
|
|
|
|
robot_username = format_robot_username(parent.username, robot_shortname)
|
|
|
|
|
|
|
|
robot = lookup_robot(robot_username)
|
|
|
|
if not robot:
|
|
|
|
raise InvalidRobotException('Could not find robot with username: %s' %
|
|
|
|
robot_username)
|
|
|
|
|
|
|
|
password = random_string_generator(length=64)()
|
|
|
|
robot.email = password
|
|
|
|
|
|
|
|
service = LoginService.get(name='quayrobot')
|
|
|
|
login = FederatedLogin.get(FederatedLogin.user == robot, FederatedLogin.service == service)
|
|
|
|
login.service_ident = password
|
|
|
|
|
|
|
|
login.save()
|
|
|
|
robot.save()
|
|
|
|
|
|
|
|
return robot, password
|
2013-11-20 21:13:03 +00:00
|
|
|
|
|
|
|
def delete_robot(robot_username):
|
|
|
|
try:
|
|
|
|
robot = User.get(username=robot_username, robot=True)
|
|
|
|
robot.delete_instance(recursive=True, delete_nullable=True)
|
|
|
|
except User.DoesNotExist:
|
|
|
|
raise InvalidRobotException('Could not find robot with username: %s' %
|
|
|
|
robot_username)
|
|
|
|
|
|
|
|
|
|
|
|
def list_entity_robots(entity_name):
|
|
|
|
selected = User.select(User.username, FederatedLogin.service_ident)
|
|
|
|
joined = selected.join(FederatedLogin)
|
|
|
|
return joined.where(User.robot == True,
|
|
|
|
User.username ** (entity_name + '+%')).tuples()
|
|
|
|
|
|
|
|
|
2013-11-07 21:33:56 +00:00
|
|
|
def convert_user_to_organization(user, admin_user):
|
|
|
|
# Change the user to an organization.
|
|
|
|
user.organization = True
|
|
|
|
|
2013-11-07 23:08:38 +00:00
|
|
|
# disable this account for login.
|
|
|
|
user.password_hash = None
|
2013-11-07 21:33:56 +00:00
|
|
|
user.save()
|
|
|
|
|
2013-11-07 23:08:38 +00:00
|
|
|
# Clear any federated auth pointing to this user
|
|
|
|
FederatedLogin.delete().where(FederatedLogin.user == user).execute()
|
|
|
|
|
2013-11-07 21:33:56 +00:00
|
|
|
# Create a team for the owners
|
|
|
|
owners_team = create_team('owners', user, 'admin')
|
|
|
|
|
|
|
|
# Add the user who will admin the org to the owners team
|
|
|
|
add_user_to_team(admin_user, owners_team)
|
|
|
|
|
|
|
|
return user
|
|
|
|
|
2013-11-20 21:13:03 +00:00
|
|
|
|
2013-11-04 21:57:20 +00:00
|
|
|
def create_team(name, org, team_role_name, description=''):
|
2014-04-08 00:37:02 +00:00
|
|
|
(username_valid, username_issue) = validate_username(name)
|
|
|
|
if not username_valid:
|
|
|
|
raise InvalidTeamException('Invalid team name %s: %s' % (name, username_issue))
|
2013-11-01 23:34:17 +00:00
|
|
|
|
|
|
|
if not org.organization:
|
|
|
|
raise InvalidOrganizationException('User with name %s is not an org.' %
|
|
|
|
org.username)
|
|
|
|
|
2013-11-04 20:42:08 +00:00
|
|
|
team_role = TeamRole.get(TeamRole.name == team_role_name)
|
2013-11-04 21:57:20 +00:00
|
|
|
return Team.create(name=name, organization=org, role=team_role,
|
|
|
|
description=description)
|
2013-11-01 23:34:17 +00:00
|
|
|
|
|
|
|
|
2013-11-27 07:29:31 +00:00
|
|
|
def __get_user_admin_teams(org_name, teamname, username):
|
2013-11-20 21:13:03 +00:00
|
|
|
Org = User.alias()
|
|
|
|
user_teams = Team.select().join(TeamMember).join(User)
|
|
|
|
with_org = user_teams.switch(Team).join(Org,
|
|
|
|
on=(Org.id == Team.organization))
|
|
|
|
with_role = with_org.switch(Team).join(TeamRole)
|
|
|
|
admin_teams = with_role.where(User.username == username,
|
|
|
|
Org.username == org_name,
|
|
|
|
TeamRole.name == 'admin')
|
|
|
|
return admin_teams
|
2013-11-05 23:37:28 +00:00
|
|
|
|
|
|
|
|
|
|
|
def remove_team(org_name, team_name, removed_by_username):
|
|
|
|
joined = Team.select(Team, TeamRole).join(User).switch(Team).join(TeamRole)
|
|
|
|
|
|
|
|
found = list(joined.where(User.organization == True,
|
|
|
|
User.username == org_name,
|
|
|
|
Team.name == team_name))
|
2013-11-05 20:50:56 +00:00
|
|
|
if not found:
|
2013-11-05 23:37:28 +00:00
|
|
|
raise InvalidTeamException('Team \'%s\' is not a team in org \'%s\'' %
|
2013-11-05 20:50:56 +00:00
|
|
|
(team_name, org_name))
|
|
|
|
|
|
|
|
team = found[0]
|
2013-11-05 23:37:28 +00:00
|
|
|
if team.role.name == 'admin':
|
|
|
|
admin_teams = list(__get_user_admin_teams(org_name, team_name,
|
|
|
|
removed_by_username))
|
|
|
|
|
|
|
|
if len(admin_teams) <= 1:
|
|
|
|
# The team we are trying to remove is the only admin team for this user
|
|
|
|
msg = ('Deleting team \'%s\' would remove all admin from user \'%s\'' %
|
|
|
|
(team_name, removed_by_username))
|
|
|
|
raise DataModelException(msg)
|
|
|
|
|
2013-11-05 20:50:56 +00:00
|
|
|
team.delete_instance(recursive=True, delete_nullable=True)
|
|
|
|
|
2013-11-05 03:58:21 +00:00
|
|
|
|
2014-09-22 23:11:48 +00:00
|
|
|
def add_or_invite_to_team(inviter, team, user=None, email=None, requires_invite=True):
|
2014-08-15 21:47:43 +00:00
|
|
|
# If the user is a member of the organization, then we simply add the
|
|
|
|
# user directly to the team. Otherwise, an invite is created for the user/email.
|
2014-09-08 21:20:01 +00:00
|
|
|
# We return None if the user was directly added and the invite object if the user was invited.
|
2014-09-22 23:11:48 +00:00
|
|
|
if user and requires_invite:
|
2014-08-15 21:47:43 +00:00
|
|
|
orgname = team.organization.username
|
|
|
|
|
|
|
|
# If the user is part of the organization (or a robot), then no invite is required.
|
|
|
|
if user.robot:
|
|
|
|
requires_invite = False
|
|
|
|
if not user.username.startswith(orgname + '+'):
|
|
|
|
raise InvalidTeamMemberException('Cannot add the specified robot to this team, ' +
|
|
|
|
'as it is not a member of the organization')
|
|
|
|
else:
|
|
|
|
Org = User.alias()
|
|
|
|
found = User.select(User.username)
|
|
|
|
found = found.where(User.username == user.username).join(TeamMember).join(Team)
|
|
|
|
found = found.join(Org, on=(Org.username == orgname)).limit(1)
|
|
|
|
requires_invite = not any(found)
|
|
|
|
|
|
|
|
# If we have a valid user and no invite is required, simply add the user to the team.
|
|
|
|
if user and not requires_invite:
|
|
|
|
add_user_to_team(user, team)
|
|
|
|
return None
|
|
|
|
|
2014-08-28 23:07:22 +00:00
|
|
|
email_address = email if not user else None
|
|
|
|
return TeamMemberInvite.create(user=user, email=email_address, team=team, inviter=inviter)
|
2014-08-15 21:47:43 +00:00
|
|
|
|
|
|
|
|
2013-11-01 23:34:17 +00:00
|
|
|
def add_user_to_team(user, team):
|
2013-11-07 17:54:21 +00:00
|
|
|
try:
|
|
|
|
return TeamMember.create(user=user, team=team)
|
|
|
|
except Exception:
|
2014-08-18 21:24:00 +00:00
|
|
|
raise UserAlreadyInTeam('User \'%s\' is already a member of team \'%s\'' %
|
|
|
|
(user.username, team.name))
|
2013-11-01 23:34:17 +00:00
|
|
|
|
|
|
|
|
2013-11-05 23:37:28 +00:00
|
|
|
def remove_user_from_team(org_name, team_name, username, removed_by_username):
|
|
|
|
Org = User.alias()
|
|
|
|
joined = TeamMember.select().join(User).switch(TeamMember).join(Team)
|
|
|
|
with_role = joined.join(TeamRole)
|
|
|
|
with_org = with_role.switch(Team).join(Org,
|
|
|
|
on=(Org.id == Team.organization))
|
|
|
|
found = list(with_org.where(User.username == username,
|
|
|
|
Org.username == org_name,
|
|
|
|
Team.name == team_name))
|
|
|
|
|
|
|
|
if not found:
|
|
|
|
raise DataModelException('User %s does not belong to team %s' %
|
2013-11-07 17:54:21 +00:00
|
|
|
(username, team_name))
|
2013-11-05 23:37:28 +00:00
|
|
|
|
|
|
|
if username == removed_by_username:
|
|
|
|
admin_team_query = __get_user_admin_teams(org_name, team_name, username)
|
|
|
|
admin_team_names = {team.name for team in admin_team_query}
|
|
|
|
if team_name in admin_team_names and len(admin_team_names) <= 1:
|
|
|
|
msg = 'User cannot remove themselves from their only admin team.'
|
|
|
|
raise DataModelException(msg)
|
|
|
|
|
|
|
|
user_in_team = found[0]
|
|
|
|
user_in_team.delete_instance()
|
2013-11-04 20:47:27 +00:00
|
|
|
|
|
|
|
|
2013-11-05 03:58:21 +00:00
|
|
|
def get_team_org_role(team):
|
|
|
|
return TeamRole.get(TeamRole.id == team.role.id)
|
|
|
|
|
2013-11-05 23:37:28 +00:00
|
|
|
|
|
|
|
def set_team_org_permission(team, team_role_name, set_by_username):
|
|
|
|
if team.role.name == 'admin' and team_role_name != 'admin':
|
|
|
|
# We need to make sure we're not removing the users only admin role
|
|
|
|
user_admin_teams = __get_user_admin_teams(team.organization.username,
|
|
|
|
team.name, set_by_username)
|
|
|
|
admin_team_set = {admin_team.name for admin_team in user_admin_teams}
|
|
|
|
if team.name in admin_team_set and len(admin_team_set) <= 1:
|
|
|
|
msg = (('Cannot remove admin from team \'%s\' because calling user ' +
|
|
|
|
'would no longer have admin on org \'%s\'') %
|
|
|
|
(team.name, team.organization.username))
|
|
|
|
raise DataModelException(msg)
|
|
|
|
|
2013-11-05 03:58:21 +00:00
|
|
|
new_role = TeamRole.get(TeamRole.name == team_role_name)
|
2013-11-04 20:42:08 +00:00
|
|
|
team.role = new_role
|
|
|
|
team.save()
|
|
|
|
return team
|
2013-11-01 23:34:17 +00:00
|
|
|
|
|
|
|
|
2014-08-11 22:25:01 +00:00
|
|
|
def create_federated_user(username, email, service_name, service_id,
|
|
|
|
set_password_notification, metadata={}):
|
2014-05-28 17:51:52 +00:00
|
|
|
if not is_create_user_allowed():
|
|
|
|
raise TooManyUsersException()
|
|
|
|
|
|
|
|
new_user = _create_user(username, email)
|
2013-11-20 21:13:03 +00:00
|
|
|
new_user.verified = True
|
|
|
|
new_user.save()
|
2013-10-10 16:55:03 +00:00
|
|
|
|
2013-11-20 21:13:03 +00:00
|
|
|
service = LoginService.get(LoginService.name == service_name)
|
|
|
|
FederatedLogin.create(user=new_user, service=service,
|
2014-08-11 22:25:01 +00:00
|
|
|
service_ident=service_id,
|
|
|
|
metadata_json=json.dumps(metadata))
|
2013-11-20 21:13:03 +00:00
|
|
|
|
2014-05-28 17:51:52 +00:00
|
|
|
if set_password_notification:
|
|
|
|
create_notification('password_required', new_user)
|
|
|
|
|
2013-11-20 21:13:03 +00:00
|
|
|
return new_user
|
2013-10-10 03:00:34 +00:00
|
|
|
|
|
|
|
|
2014-08-11 22:25:01 +00:00
|
|
|
def attach_federated_login(user, service_name, service_id, metadata={}):
|
2014-01-14 20:23:44 +00:00
|
|
|
service = LoginService.get(LoginService.name == service_name)
|
2014-08-11 22:25:01 +00:00
|
|
|
FederatedLogin.create(user=user, service=service, service_ident=service_id,
|
|
|
|
metadata_json=json.dumps(metadata))
|
2014-01-14 20:23:44 +00:00
|
|
|
return user
|
|
|
|
|
|
|
|
|
2013-10-10 03:00:34 +00:00
|
|
|
def verify_federated_login(service_name, service_id):
|
2014-05-13 16:17:26 +00:00
|
|
|
try:
|
|
|
|
found = (FederatedLogin
|
|
|
|
.select(FederatedLogin, User)
|
|
|
|
.join(LoginService)
|
|
|
|
.switch(FederatedLogin).join(User)
|
|
|
|
.where(FederatedLogin.service_ident == service_id, LoginService.name == service_name)
|
|
|
|
.get())
|
|
|
|
return found.user
|
|
|
|
except FederatedLogin.DoesNotExist:
|
|
|
|
return None
|
2013-10-10 03:00:34 +00:00
|
|
|
|
|
|
|
|
2014-01-14 20:23:44 +00:00
|
|
|
def list_federated_logins(user):
|
|
|
|
selected = FederatedLogin.select(FederatedLogin.service_ident,
|
2014-08-11 22:25:01 +00:00
|
|
|
LoginService.name, FederatedLogin.metadata_json)
|
2014-01-14 20:23:44 +00:00
|
|
|
joined = selected.join(LoginService)
|
|
|
|
return joined.where(LoginService.name != 'quayrobot',
|
|
|
|
FederatedLogin.user == user)
|
|
|
|
|
|
|
|
|
2014-01-17 22:04:05 +00:00
|
|
|
def create_confirm_email_code(user, new_email=None):
|
|
|
|
if new_email:
|
|
|
|
if not validate_email(new_email):
|
2014-01-22 00:23:26 +00:00
|
|
|
raise InvalidEmailAddressException('Invalid email address: %s' %
|
|
|
|
new_email)
|
2014-01-17 22:04:05 +00:00
|
|
|
|
2014-01-22 00:23:26 +00:00
|
|
|
code = EmailConfirmation.create(user=user, email_confirm=True,
|
|
|
|
new_email=new_email)
|
2013-09-27 23:29:01 +00:00
|
|
|
return code
|
2013-09-20 15:55:44 +00:00
|
|
|
|
|
|
|
|
2013-09-27 23:55:04 +00:00
|
|
|
def confirm_user_email(code):
|
2013-12-19 00:47:42 +00:00
|
|
|
try:
|
|
|
|
code = EmailConfirmation.get(EmailConfirmation.code == code,
|
|
|
|
EmailConfirmation.email_confirm == True)
|
|
|
|
except EmailConfirmation.DoesNotExist:
|
2014-01-17 22:04:05 +00:00
|
|
|
raise DataModelException('Invalid email confirmation code.')
|
2013-09-27 23:55:04 +00:00
|
|
|
|
|
|
|
user = code.user
|
|
|
|
user.verified = True
|
2014-01-17 22:04:05 +00:00
|
|
|
|
2014-09-05 23:57:33 +00:00
|
|
|
old_email = None
|
2014-01-17 22:04:05 +00:00
|
|
|
new_email = code.new_email
|
|
|
|
if new_email:
|
2014-01-17 22:20:51 +00:00
|
|
|
if find_user_by_email(new_email):
|
|
|
|
raise DataModelException('E-mail address already used.')
|
|
|
|
|
2014-09-05 23:57:33 +00:00
|
|
|
old_email = user.email
|
2014-01-17 22:04:05 +00:00
|
|
|
user.email = new_email
|
2014-01-17 22:20:51 +00:00
|
|
|
|
2013-09-27 23:55:04 +00:00
|
|
|
user.save()
|
|
|
|
|
|
|
|
code.delete_instance()
|
|
|
|
|
2014-09-05 23:57:33 +00:00
|
|
|
return user, new_email, old_email
|
2013-09-20 15:55:44 +00:00
|
|
|
|
|
|
|
|
2013-10-14 21:50:07 +00:00
|
|
|
def create_reset_password_email_code(email):
|
|
|
|
try:
|
|
|
|
user = User.get(User.email == email)
|
|
|
|
except User.DoesNotExist:
|
|
|
|
raise InvalidEmailAddressException('Email address was not found.');
|
|
|
|
|
2014-01-10 18:30:17 +00:00
|
|
|
if user.organization:
|
|
|
|
raise InvalidEmailAddressException('Organizations can not have passwords.')
|
|
|
|
|
2013-10-14 21:50:07 +00:00
|
|
|
code = EmailConfirmation.create(user=user, pw_reset=True)
|
|
|
|
return code
|
|
|
|
|
|
|
|
|
|
|
|
def validate_reset_code(code):
|
|
|
|
try:
|
|
|
|
code = EmailConfirmation.get(EmailConfirmation.code == code,
|
|
|
|
EmailConfirmation.pw_reset == True)
|
|
|
|
except EmailConfirmation.DoesNotExist:
|
|
|
|
return None
|
|
|
|
|
|
|
|
user = code.user
|
|
|
|
code.delete_instance()
|
|
|
|
|
|
|
|
return user
|
|
|
|
|
|
|
|
|
2014-01-17 22:04:05 +00:00
|
|
|
def find_user_by_email(email):
|
|
|
|
try:
|
|
|
|
return User.get(User.email == email)
|
|
|
|
except User.DoesNotExist:
|
|
|
|
return None
|
|
|
|
|
|
|
|
|
2013-09-23 16:37:40 +00:00
|
|
|
def get_user(username):
|
|
|
|
try:
|
2013-11-05 20:50:56 +00:00
|
|
|
return User.get(User.username == username, User.organization == False)
|
2013-09-23 16:37:40 +00:00
|
|
|
except User.DoesNotExist:
|
|
|
|
return None
|
|
|
|
|
|
|
|
|
2014-09-18 17:20:32 +00:00
|
|
|
def get_user_or_org(username):
|
|
|
|
try:
|
|
|
|
return User.get(User.username == username, User.robot == False)
|
|
|
|
except User.DoesNotExist:
|
|
|
|
return None
|
|
|
|
|
|
|
|
|
2014-09-22 21:27:02 +00:00
|
|
|
def get_user_by_id(user_db_id):
|
2014-09-18 18:52:29 +00:00
|
|
|
try:
|
2014-09-22 21:27:02 +00:00
|
|
|
return User.get(User.id == user_db_id, User.organization == False)
|
2014-09-18 18:52:29 +00:00
|
|
|
except User.DoesNotExist:
|
|
|
|
return None
|
|
|
|
|
|
|
|
|
2013-11-15 19:42:31 +00:00
|
|
|
def get_user_or_org_by_customer_id(customer_id):
|
|
|
|
try:
|
|
|
|
return User.get(User.stripe_id == customer_id)
|
|
|
|
except User.DoesNotExist:
|
|
|
|
return None
|
|
|
|
|
2013-11-02 01:48:10 +00:00
|
|
|
def get_matching_teams(team_prefix, organization):
|
2013-11-04 23:52:38 +00:00
|
|
|
query = Team.select().where(Team.name ** (team_prefix + '%'),
|
|
|
|
Team.organization == organization)
|
2013-11-08 04:35:20 +00:00
|
|
|
return query.limit(10)
|
2013-11-02 01:48:10 +00:00
|
|
|
|
|
|
|
|
2013-11-20 23:23:59 +00:00
|
|
|
def get_matching_users(username_prefix, robot_namespace=None,
|
|
|
|
organization=None):
|
|
|
|
direct_user_query = (User.username ** (username_prefix + '%') &
|
|
|
|
(User.organization == False) & (User.robot == False))
|
|
|
|
|
|
|
|
if robot_namespace:
|
|
|
|
robot_prefix = format_robot_username(robot_namespace, username_prefix)
|
|
|
|
direct_user_query = (direct_user_query |
|
|
|
|
(User.username ** (robot_prefix + '%') &
|
|
|
|
(User.robot == True)))
|
|
|
|
|
2013-12-27 21:56:31 +00:00
|
|
|
query = (User
|
2014-09-22 22:42:48 +00:00
|
|
|
.select(User.username, User.robot)
|
2013-12-27 22:06:27 +00:00
|
|
|
.group_by(User.username)
|
2013-12-27 21:56:31 +00:00
|
|
|
.where(direct_user_query))
|
2013-11-04 23:52:38 +00:00
|
|
|
|
|
|
|
if organization:
|
2013-12-27 21:56:31 +00:00
|
|
|
query = (query
|
2014-09-22 22:42:48 +00:00
|
|
|
.select(User.username, User.robot, fn.Sum(Team.id))
|
2013-12-27 21:56:31 +00:00
|
|
|
.join(TeamMember, JOIN_LEFT_OUTER)
|
|
|
|
.join(Team, JOIN_LEFT_OUTER, on=((Team.id == TeamMember.team) &
|
|
|
|
(Team.organization == organization))))
|
2013-11-04 23:52:38 +00:00
|
|
|
|
|
|
|
|
|
|
|
class MatchingUserResult(object):
|
|
|
|
def __init__(self, *args):
|
|
|
|
self.username = args[0]
|
2014-09-22 22:42:48 +00:00
|
|
|
self.is_robot = args[1]
|
2013-11-04 23:52:38 +00:00
|
|
|
if organization:
|
2014-09-22 22:42:48 +00:00
|
|
|
self.is_org_member = (args[2] != None)
|
2013-11-04 23:52:38 +00:00
|
|
|
else:
|
2013-11-05 22:10:14 +00:00
|
|
|
self.is_org_member = None
|
2013-11-04 23:52:38 +00:00
|
|
|
|
|
|
|
|
|
|
|
return (MatchingUserResult(*args) for args in query.tuples().limit(10))
|
2013-09-28 00:03:07 +00:00
|
|
|
|
2013-09-27 23:21:54 +00:00
|
|
|
|
2014-01-16 21:14:38 +00:00
|
|
|
def verify_user(username_or_email, password):
|
2013-09-20 15:55:44 +00:00
|
|
|
try:
|
2014-01-22 00:23:26 +00:00
|
|
|
fetched = User.get((User.username == username_or_email) |
|
|
|
|
(User.email == username_or_email))
|
2013-09-20 15:55:44 +00:00
|
|
|
except User.DoesNotExist:
|
|
|
|
return None
|
|
|
|
|
2014-09-02 19:27:05 +00:00
|
|
|
now = datetime.utcnow()
|
|
|
|
|
|
|
|
if fetched.invalid_login_attempts > 0:
|
|
|
|
can_retry_at = exponential_backoff(fetched.invalid_login_attempts, EXPONENTIAL_BACKOFF_SCALE,
|
|
|
|
fetched.last_invalid_login)
|
|
|
|
|
|
|
|
if can_retry_at > now:
|
|
|
|
retry_after = can_retry_at - now
|
|
|
|
raise TooManyLoginAttemptsException('Too many login attempts.', retry_after.total_seconds())
|
|
|
|
|
2014-09-22 21:27:02 +00:00
|
|
|
if (fetched.password_hash and
|
|
|
|
hash_password(password, fetched.password_hash) == fetched.password_hash):
|
2014-09-02 19:27:05 +00:00
|
|
|
if fetched.invalid_login_attempts > 0:
|
|
|
|
fetched.invalid_login_attempts = 0
|
|
|
|
fetched.save()
|
|
|
|
|
2013-09-20 15:55:44 +00:00
|
|
|
return fetched
|
|
|
|
|
2014-09-02 19:27:05 +00:00
|
|
|
fetched.invalid_login_attempts += 1
|
|
|
|
fetched.last_invalid_login = now
|
|
|
|
fetched.save()
|
|
|
|
|
2013-09-20 15:55:44 +00:00
|
|
|
# We weren't able to authorize the user
|
|
|
|
return None
|
|
|
|
|
2013-10-31 22:17:26 +00:00
|
|
|
|
|
|
|
def get_user_organizations(username):
|
2013-11-01 23:34:17 +00:00
|
|
|
UserAlias = User.alias()
|
2013-11-07 05:49:13 +00:00
|
|
|
all_teams = User.select().distinct().join(Team).join(TeamMember)
|
2013-11-01 23:34:17 +00:00
|
|
|
with_user = all_teams.join(UserAlias, on=(UserAlias.id == TeamMember.user))
|
|
|
|
return with_user.where(User.organization == True,
|
|
|
|
UserAlias.username == username)
|
2013-10-31 22:17:26 +00:00
|
|
|
|
|
|
|
|
2013-11-01 23:34:17 +00:00
|
|
|
def get_organization(name):
|
|
|
|
try:
|
2013-11-05 19:55:05 +00:00
|
|
|
return User.get(username=name, organization=True)
|
2013-11-01 23:34:17 +00:00
|
|
|
except User.DoesNotExist:
|
|
|
|
raise InvalidOrganizationException('Organization does not exist: %s' %
|
|
|
|
name)
|
2013-11-04 19:56:54 +00:00
|
|
|
|
|
|
|
|
|
|
|
def get_organization_team(orgname, teamname):
|
|
|
|
joined = Team.select().join(User)
|
2013-11-04 23:52:38 +00:00
|
|
|
query = joined.where(Team.name == teamname, User.organization == True,
|
|
|
|
User.username == orgname).limit(1)
|
2013-11-04 19:56:54 +00:00
|
|
|
result = list(query)
|
|
|
|
if not result:
|
2013-11-04 23:52:38 +00:00
|
|
|
raise InvalidTeamException('Team does not exist: %s/%s', orgname,
|
|
|
|
teamname)
|
2013-11-04 19:56:54 +00:00
|
|
|
|
|
|
|
return result[0]
|
|
|
|
|
|
|
|
|
2013-12-07 00:25:27 +00:00
|
|
|
def get_organization_members_with_teams(organization, membername = None):
|
2013-11-07 00:06:59 +00:00
|
|
|
joined = TeamMember.select().annotate(Team).annotate(User)
|
|
|
|
query = joined.where(Team.organization == organization)
|
2013-12-07 00:25:27 +00:00
|
|
|
if membername:
|
|
|
|
query = query.where(User.username == membername)
|
2013-11-07 00:06:59 +00:00
|
|
|
return query
|
|
|
|
|
2013-11-04 19:56:54 +00:00
|
|
|
def get_organization_team_members(teamid):
|
|
|
|
joined = User.select().join(TeamMember).join(Team)
|
|
|
|
query = joined.where(Team.id == teamid)
|
|
|
|
return query
|
2013-10-31 22:17:26 +00:00
|
|
|
|
2014-08-15 21:47:43 +00:00
|
|
|
def get_organization_team_member_invites(teamid):
|
|
|
|
joined = TeamMemberInvite.select().join(Team).join(User)
|
|
|
|
query = joined.where(Team.id == teamid)
|
|
|
|
return query
|
2013-11-04 21:39:29 +00:00
|
|
|
|
2013-11-04 23:52:38 +00:00
|
|
|
def get_organization_member_set(orgname):
|
|
|
|
Org = User.alias()
|
|
|
|
user_teams = User.select(User.username).join(TeamMember).join(Team)
|
|
|
|
with_org = user_teams.join(Org, on=(Org.username == orgname))
|
|
|
|
return {user.username for user in with_org}
|
|
|
|
|
2013-11-04 21:39:29 +00:00
|
|
|
|
|
|
|
def get_teams_within_org(organization):
|
2013-11-04 21:51:25 +00:00
|
|
|
return Team.select().where(Team.organization == organization)
|
2013-11-04 21:39:29 +00:00
|
|
|
|
|
|
|
|
2013-11-01 23:34:17 +00:00
|
|
|
def get_user_teams_within_org(username, organization):
|
|
|
|
joined = Team.select().join(TeamMember).join(User)
|
|
|
|
return joined.where(Team.organization == organization,
|
|
|
|
User.username == username)
|
2013-10-31 22:17:26 +00:00
|
|
|
|
2013-09-20 15:55:44 +00:00
|
|
|
|
2014-01-22 00:23:26 +00:00
|
|
|
def get_visible_repository_count(username=None, include_public=True,
|
2014-02-16 22:38:47 +00:00
|
|
|
namespace=None):
|
|
|
|
query = _visible_repository_query(username=username,
|
|
|
|
include_public=include_public,
|
|
|
|
namespace=namespace)
|
|
|
|
return query.count()
|
|
|
|
|
2014-01-13 19:49:05 +00:00
|
|
|
|
2014-01-22 00:23:26 +00:00
|
|
|
def get_visible_repositories(username=None, include_public=True, page=None,
|
|
|
|
limit=None, sort=False, namespace=None):
|
2014-03-25 21:26:45 +00:00
|
|
|
query = _visible_repository_query(username=username, include_public=include_public, page=page,
|
|
|
|
limit=limit, namespace=namespace,
|
|
|
|
select_models=[Repository, Visibility])
|
2014-01-13 19:49:05 +00:00
|
|
|
|
2014-02-16 22:38:47 +00:00
|
|
|
if sort:
|
|
|
|
query = query.order_by(Repository.description.desc())
|
2014-01-13 19:49:05 +00:00
|
|
|
|
2014-02-16 22:38:47 +00:00
|
|
|
if limit:
|
|
|
|
query = query.limit(limit)
|
2013-10-02 17:29:18 +00:00
|
|
|
|
2014-02-16 22:38:47 +00:00
|
|
|
return query
|
2013-10-02 17:29:18 +00:00
|
|
|
|
2014-02-16 22:38:47 +00:00
|
|
|
|
|
|
|
def _visible_repository_query(username=None, include_public=True, limit=None,
|
2014-03-25 21:26:45 +00:00
|
|
|
page=None, namespace=None, select_models=[]):
|
2013-11-08 03:44:18 +00:00
|
|
|
query = (Repository
|
2014-03-25 21:26:45 +00:00
|
|
|
.select(*select_models) # Note: We need to leave this blank for the get_count case. Otherwise, MySQL/RDS complains.
|
2013-11-08 03:44:18 +00:00
|
|
|
.distinct()
|
|
|
|
.join(Visibility)
|
|
|
|
.switch(Repository)
|
|
|
|
.join(RepositoryPermission, JOIN_LEFT_OUTER))
|
|
|
|
|
2014-02-16 22:38:47 +00:00
|
|
|
query = _filter_to_repos_for_user(query, username, namespace, include_public)
|
|
|
|
|
|
|
|
if page:
|
|
|
|
query = query.paginate(page, limit)
|
|
|
|
elif limit:
|
|
|
|
query = query.limit(limit)
|
|
|
|
|
|
|
|
return query
|
|
|
|
|
|
|
|
|
|
|
|
def _filter_to_repos_for_user(query, username=None, namespace=None,
|
|
|
|
include_public=True):
|
2014-02-16 23:59:24 +00:00
|
|
|
if not include_public and not username:
|
|
|
|
return Repository.select().where(Repository.id == '-1')
|
|
|
|
|
2013-11-08 03:44:18 +00:00
|
|
|
where_clause = None
|
2013-09-28 03:25:57 +00:00
|
|
|
if username:
|
2013-11-08 03:44:18 +00:00
|
|
|
UserThroughTeam = User.alias()
|
|
|
|
Org = User.alias()
|
|
|
|
AdminTeam = Team.alias()
|
|
|
|
AdminTeamMember = TeamMember.alias()
|
|
|
|
AdminUser = User.alias()
|
|
|
|
|
|
|
|
query = (query
|
2014-09-22 21:27:02 +00:00
|
|
|
.switch(RepositoryPermission)
|
|
|
|
.join(User, JOIN_LEFT_OUTER)
|
|
|
|
.switch(RepositoryPermission)
|
|
|
|
.join(Team, JOIN_LEFT_OUTER)
|
|
|
|
.join(TeamMember, JOIN_LEFT_OUTER)
|
|
|
|
.join(UserThroughTeam, JOIN_LEFT_OUTER, on=(UserThroughTeam.id ==
|
|
|
|
TeamMember.user))
|
|
|
|
.switch(Repository)
|
|
|
|
.join(Org, JOIN_LEFT_OUTER, on=(Org.username == Repository.namespace))
|
|
|
|
.join(AdminTeam, JOIN_LEFT_OUTER, on=(Org.id ==
|
|
|
|
AdminTeam.organization))
|
|
|
|
.join(TeamRole, JOIN_LEFT_OUTER, on=(AdminTeam.role == TeamRole.id))
|
|
|
|
.switch(AdminTeam)
|
|
|
|
.join(AdminTeamMember, JOIN_LEFT_OUTER, on=(AdminTeam.id ==
|
|
|
|
AdminTeamMember.team))
|
|
|
|
.join(AdminUser, JOIN_LEFT_OUTER, on=(AdminTeamMember.user ==
|
|
|
|
AdminUser.id)))
|
2013-11-08 03:44:18 +00:00
|
|
|
|
|
|
|
where_clause = ((User.username == username) |
|
|
|
|
(UserThroughTeam.username == username) |
|
|
|
|
((AdminUser.username == username) &
|
|
|
|
(TeamRole.name == 'admin')))
|
|
|
|
|
|
|
|
if namespace:
|
|
|
|
where_clause = where_clause & (Repository.namespace == namespace)
|
2013-09-28 04:05:32 +00:00
|
|
|
|
2013-11-08 03:44:18 +00:00
|
|
|
if include_public:
|
|
|
|
new_clause = (Visibility.name == 'public')
|
|
|
|
if where_clause:
|
|
|
|
where_clause = where_clause | new_clause
|
|
|
|
else:
|
|
|
|
where_clause = new_clause
|
2013-10-02 17:29:18 +00:00
|
|
|
|
2014-02-16 22:38:47 +00:00
|
|
|
return query.where(where_clause)
|
2013-09-28 04:05:32 +00:00
|
|
|
|
2013-10-08 15:29:42 +00:00
|
|
|
|
2013-09-28 04:05:32 +00:00
|
|
|
def get_matching_repositories(repo_term, username=None):
|
2013-10-01 21:02:49 +00:00
|
|
|
namespace_term = repo_term
|
|
|
|
name_term = repo_term
|
|
|
|
|
2013-09-28 04:05:32 +00:00
|
|
|
visible = get_visible_repositories(username)
|
2013-10-01 21:02:49 +00:00
|
|
|
|
|
|
|
search_clauses = (Repository.name ** ('%' + name_term + '%') |
|
|
|
|
Repository.namespace ** ('%' + namespace_term + '%'))
|
|
|
|
|
|
|
|
# Handle the case where the user has already entered a namespace path.
|
|
|
|
if repo_term.find('/') > 0:
|
|
|
|
parts = repo_term.split('/', 1)
|
|
|
|
namespace_term = '/'.join(parts[:-1])
|
|
|
|
name_term = parts[-1]
|
|
|
|
|
|
|
|
search_clauses = (Repository.name ** ('%' + name_term + '%') &
|
|
|
|
Repository.namespace ** ('%' + namespace_term + '%'))
|
2013-09-28 03:25:57 +00:00
|
|
|
|
2013-09-28 04:05:32 +00:00
|
|
|
final = visible.where(search_clauses).limit(10)
|
2013-09-28 03:25:57 +00:00
|
|
|
return list(final)
|
2013-09-27 23:21:54 +00:00
|
|
|
|
|
|
|
|
2013-09-20 15:55:44 +00:00
|
|
|
def change_password(user, new_password):
|
2013-10-10 17:44:34 +00:00
|
|
|
if not validate_password(new_password):
|
|
|
|
raise InvalidPasswordException(INVALID_PASSWORD_MESSAGE)
|
|
|
|
|
2014-09-18 21:36:26 +00:00
|
|
|
pw_hash = hash_password(new_password)
|
2013-09-20 15:55:44 +00:00
|
|
|
user.password_hash = pw_hash
|
|
|
|
user.save()
|
|
|
|
|
2014-03-12 04:49:03 +00:00
|
|
|
# Remove any password required notifications for the user.
|
|
|
|
delete_notifications_by_kind(user, 'password_required')
|
|
|
|
|
2013-09-20 15:55:44 +00:00
|
|
|
|
2013-11-15 19:42:31 +00:00
|
|
|
def change_invoice_email(user, invoice_email):
|
|
|
|
user.invoice_email = invoice_email
|
|
|
|
user.save()
|
|
|
|
|
|
|
|
|
2014-09-22 23:11:48 +00:00
|
|
|
def update_email(user, new_email, auto_verify=False):
|
2013-09-20 15:55:44 +00:00
|
|
|
user.email = new_email
|
2014-09-22 23:11:48 +00:00
|
|
|
user.verified = auto_verify
|
2013-09-20 15:55:44 +00:00
|
|
|
user.save()
|
|
|
|
|
|
|
|
|
2013-09-27 17:24:07 +00:00
|
|
|
def get_all_user_permissions(user):
|
2013-11-04 20:42:08 +00:00
|
|
|
select = RepositoryPermission.select(RepositoryPermission, Role, Repository)
|
|
|
|
with_role = select.join(Role)
|
|
|
|
with_repo = with_role.switch(RepositoryPermission).join(Repository)
|
|
|
|
through_user = with_repo.switch(RepositoryPermission).join(User,
|
|
|
|
JOIN_LEFT_OUTER)
|
|
|
|
as_perm = through_user.switch(RepositoryPermission)
|
|
|
|
through_team = as_perm.join(Team, JOIN_LEFT_OUTER).join(TeamMember,
|
|
|
|
JOIN_LEFT_OUTER)
|
|
|
|
|
|
|
|
UserThroughTeam = User.alias()
|
|
|
|
with_team_member = through_team.join(UserThroughTeam, JOIN_LEFT_OUTER,
|
|
|
|
on=(UserThroughTeam.id ==
|
|
|
|
TeamMember.user))
|
|
|
|
|
|
|
|
return with_team_member.where((User.id == user) |
|
|
|
|
(UserThroughTeam.id == user))
|
|
|
|
|
|
|
|
|
2014-01-21 19:18:20 +00:00
|
|
|
def delete_prototype_permission(org, uid):
|
|
|
|
found = get_prototype_permission(org, uid)
|
|
|
|
if not found:
|
|
|
|
return None
|
|
|
|
|
|
|
|
found.delete_instance()
|
|
|
|
return found
|
|
|
|
|
|
|
|
|
|
|
|
def get_prototype_permission(org, uid):
|
|
|
|
try:
|
2014-01-21 22:32:49 +00:00
|
|
|
return PermissionPrototype.get(PermissionPrototype.org == org,
|
|
|
|
PermissionPrototype.uuid == uid)
|
2014-01-21 19:18:20 +00:00
|
|
|
except PermissionPrototype.DoesNotExist:
|
|
|
|
return None
|
|
|
|
|
|
|
|
|
|
|
|
def get_prototype_permissions(org):
|
|
|
|
ActivatingUser = User.alias()
|
|
|
|
DelegateUser = User.alias()
|
2014-01-21 22:32:49 +00:00
|
|
|
query = (PermissionPrototype
|
|
|
|
.select()
|
|
|
|
.where(PermissionPrototype.org == org)
|
|
|
|
.join(ActivatingUser, JOIN_LEFT_OUTER,
|
|
|
|
on=(ActivatingUser.id == PermissionPrototype.activating_user))
|
|
|
|
.join(DelegateUser, JOIN_LEFT_OUTER,
|
|
|
|
on=(DelegateUser.id == PermissionPrototype.delegate_user))
|
|
|
|
.join(Team, JOIN_LEFT_OUTER,
|
|
|
|
on=(Team.id == PermissionPrototype.delegate_team))
|
|
|
|
.join(Role, JOIN_LEFT_OUTER, on=(Role.id == PermissionPrototype.role)))
|
|
|
|
return query
|
2014-01-21 19:18:20 +00:00
|
|
|
|
|
|
|
|
|
|
|
def update_prototype_permission(org, uid, role_name):
|
|
|
|
found = get_prototype_permission(org, uid)
|
|
|
|
if not found:
|
|
|
|
return None
|
|
|
|
|
|
|
|
new_role = Role.get(Role.name == role_name)
|
|
|
|
found.role = new_role
|
|
|
|
found.save()
|
|
|
|
return found
|
|
|
|
|
|
|
|
|
2014-01-21 22:32:49 +00:00
|
|
|
def add_prototype_permission(org, role_name, activating_user,
|
|
|
|
delegate_user=None, delegate_team=None):
|
2014-01-21 19:18:20 +00:00
|
|
|
new_role = Role.get(Role.name == role_name)
|
2014-02-04 00:08:37 +00:00
|
|
|
return PermissionPrototype.create(org=org, role=new_role,
|
2014-01-21 22:32:49 +00:00
|
|
|
activating_user=activating_user,
|
2014-01-21 19:18:20 +00:00
|
|
|
delegate_user=delegate_user, delegate_team=delegate_team)
|
|
|
|
|
|
|
|
|
2013-11-04 20:42:08 +00:00
|
|
|
def get_org_wide_permissions(user):
|
|
|
|
Org = User.alias()
|
|
|
|
team_with_role = Team.select(Team, Org, TeamRole).join(TeamRole)
|
|
|
|
with_org = team_with_role.switch(Team).join(Org, on=(Team.organization ==
|
|
|
|
Org.id))
|
|
|
|
with_user = with_org.switch(Team).join(TeamMember).join(User)
|
|
|
|
return with_user.where(User.id == user, Org.organization == True)
|
2013-09-27 17:24:07 +00:00
|
|
|
|
|
|
|
|
2013-11-02 01:48:10 +00:00
|
|
|
def get_all_repo_teams(namespace_name, repository_name):
|
2013-11-04 23:52:38 +00:00
|
|
|
select = RepositoryPermission.select(Team.name.alias('team_name'),
|
|
|
|
Role.name, RepositoryPermission)
|
2013-11-02 01:48:10 +00:00
|
|
|
with_team = select.join(Team)
|
|
|
|
with_role = with_team.switch(RepositoryPermission).join(Role)
|
|
|
|
with_repo = with_role.switch(RepositoryPermission).join(Repository)
|
|
|
|
return with_repo.where(Repository.namespace == namespace_name,
|
|
|
|
Repository.name == repository_name)
|
|
|
|
|
2013-11-04 23:52:38 +00:00
|
|
|
|
2013-09-27 17:24:07 +00:00
|
|
|
def get_all_repo_users(namespace_name, repository_name):
|
2013-11-21 00:43:19 +00:00
|
|
|
select = RepositoryPermission.select(User.username, User.robot, Role.name,
|
2013-09-27 17:24:07 +00:00
|
|
|
RepositoryPermission)
|
|
|
|
with_user = select.join(User)
|
|
|
|
with_role = with_user.switch(RepositoryPermission).join(Role)
|
|
|
|
with_repo = with_role.switch(RepositoryPermission).join(Repository)
|
|
|
|
return with_repo.where(Repository.namespace == namespace_name,
|
|
|
|
Repository.name == repository_name)
|
2013-09-20 22:38:17 +00:00
|
|
|
|
|
|
|
|
2014-08-18 23:19:01 +00:00
|
|
|
def get_all_repo_users_transitive_via_teams(namespace_name, repository_name):
|
|
|
|
select = User.select().distinct()
|
|
|
|
with_team_member = select.join(TeamMember)
|
|
|
|
with_team = with_team_member.join(Team)
|
|
|
|
with_perm = with_team.join(RepositoryPermission)
|
|
|
|
with_repo = with_perm.join(Repository)
|
|
|
|
return with_repo.where(Repository.namespace == namespace_name,
|
|
|
|
Repository.name == repository_name)
|
|
|
|
|
|
|
|
|
|
|
|
def get_all_repo_users_transitive(namespace_name, repository_name):
|
|
|
|
# Load the users found via teams and directly via permissions.
|
|
|
|
via_teams = get_all_repo_users_transitive_via_teams(namespace_name, repository_name)
|
|
|
|
directly = [perm.user for perm in get_all_repo_users(namespace_name, repository_name)]
|
|
|
|
|
|
|
|
# Filter duplicates.
|
|
|
|
user_set = set()
|
|
|
|
|
|
|
|
def check_add(u):
|
|
|
|
if u.username in user_set:
|
|
|
|
return False
|
|
|
|
|
|
|
|
user_set.add(u.username)
|
|
|
|
return True
|
|
|
|
|
|
|
|
return [user for user in list(directly) + list(via_teams) if check_add(user)]
|
|
|
|
|
|
|
|
|
2014-02-14 23:37:06 +00:00
|
|
|
def get_repository_for_resource(resource_key):
|
2014-02-25 23:22:02 +00:00
|
|
|
try:
|
|
|
|
return (Repository
|
|
|
|
.select()
|
|
|
|
.join(RepositoryBuild)
|
|
|
|
.where(RepositoryBuild.resource_key == resource_key)
|
|
|
|
.get())
|
|
|
|
except Repository.DoesNotExist:
|
2014-02-14 23:37:06 +00:00
|
|
|
return None
|
|
|
|
|
|
|
|
|
2014-07-18 02:51:58 +00:00
|
|
|
def lookup_repository(repo_id):
|
|
|
|
try:
|
|
|
|
return Repository.get(Repository.id == repo_id)
|
|
|
|
except Repository.DoesNotExist:
|
|
|
|
return None
|
|
|
|
|
|
|
|
|
2013-09-28 04:05:32 +00:00
|
|
|
def get_repository(namespace_name, repository_name):
|
2013-09-20 15:55:44 +00:00
|
|
|
try:
|
2013-09-28 04:05:32 +00:00
|
|
|
return Repository.get(Repository.name == repository_name,
|
|
|
|
Repository.namespace == namespace_name)
|
2013-09-20 15:55:44 +00:00
|
|
|
except Repository.DoesNotExist:
|
2013-09-20 22:38:17 +00:00
|
|
|
return None
|
|
|
|
|
|
|
|
|
2013-10-19 02:28:46 +00:00
|
|
|
def get_repo_image(namespace_name, repository_name, image_id):
|
2014-06-28 00:04:26 +00:00
|
|
|
def limit_to_image_id(query):
|
|
|
|
return query.where(Image.docker_image_id == image_id)
|
2013-10-19 02:28:46 +00:00
|
|
|
|
2014-06-28 00:04:26 +00:00
|
|
|
images = _get_repository_images_base(namespace_name, repository_name, limit_to_image_id)
|
|
|
|
if not images:
|
|
|
|
return None
|
|
|
|
else:
|
|
|
|
return images[0]
|
2014-06-17 20:03:43 +00:00
|
|
|
|
2013-10-19 02:28:46 +00:00
|
|
|
|
2013-09-28 04:05:32 +00:00
|
|
|
def repository_is_public(namespace_name, repository_name):
|
|
|
|
joined = Repository.select().join(Visibility)
|
|
|
|
query = joined.where(Repository.namespace == namespace_name,
|
|
|
|
Repository.name == repository_name,
|
|
|
|
Visibility.name == 'public')
|
|
|
|
return len(list(query)) > 0
|
2013-09-23 16:37:40 +00:00
|
|
|
|
|
|
|
|
2013-09-28 21:11:10 +00:00
|
|
|
def set_repository_visibility(repo, visibility):
|
|
|
|
visibility_obj = Visibility.get(name=visibility)
|
|
|
|
if not visibility_obj:
|
|
|
|
return
|
|
|
|
|
|
|
|
repo.visibility = visibility_obj
|
|
|
|
repo.save()
|
2013-10-08 15:29:42 +00:00
|
|
|
|
2013-09-28 21:11:10 +00:00
|
|
|
|
2014-01-21 19:20:42 +00:00
|
|
|
def __apply_default_permissions(repo, proto_query, name_property,
|
|
|
|
create_permission_func):
|
|
|
|
final_protos = {}
|
|
|
|
for proto in proto_query:
|
2014-01-21 22:18:12 +00:00
|
|
|
applies_to = proto.delegate_team or proto.delegate_user
|
2014-01-21 19:20:42 +00:00
|
|
|
name = getattr(applies_to, name_property)
|
|
|
|
# We will skip the proto if it is pre-empted by a more important proto
|
|
|
|
if name in final_protos and proto.activating_user is None:
|
|
|
|
continue
|
|
|
|
|
|
|
|
# By this point, it is either a user specific proto, or there is no
|
|
|
|
# proto yet, so we can safely assume it applies
|
|
|
|
final_protos[name] = (applies_to, proto.role)
|
|
|
|
|
|
|
|
for delegate, role in final_protos.values():
|
|
|
|
create_permission_func(delegate, repo, role)
|
|
|
|
|
|
|
|
|
2014-01-21 00:05:26 +00:00
|
|
|
def create_repository(namespace, name, creating_user, visibility='private'):
|
2013-10-25 05:14:38 +00:00
|
|
|
private = Visibility.get(name=visibility)
|
2014-09-22 21:27:02 +00:00
|
|
|
namespace_user = User.get(username=namespace)
|
|
|
|
repo = Repository.create(namespace=namespace, name=name, visibility=private,
|
|
|
|
namespace_user=namespace_user)
|
2013-09-20 22:38:17 +00:00
|
|
|
admin = Role.get(name='admin')
|
2013-11-01 23:34:17 +00:00
|
|
|
|
2014-01-21 00:05:26 +00:00
|
|
|
if creating_user and not creating_user.organization:
|
2014-01-21 19:20:42 +00:00
|
|
|
RepositoryPermission.create(user=creating_user, repository=repo,
|
|
|
|
role=admin)
|
2014-01-21 00:05:26 +00:00
|
|
|
|
|
|
|
if creating_user.username != namespace:
|
|
|
|
# Permission prototypes only work for orgs
|
|
|
|
org = get_organization(namespace)
|
2014-01-22 17:13:51 +00:00
|
|
|
user_clause = ((PermissionPrototype.activating_user == creating_user) |
|
|
|
|
(PermissionPrototype.activating_user >> None))
|
2014-01-21 00:05:26 +00:00
|
|
|
|
|
|
|
team_protos = (PermissionPrototype
|
|
|
|
.select()
|
|
|
|
.where(PermissionPrototype.org == org, user_clause,
|
|
|
|
PermissionPrototype.delegate_user >> None))
|
|
|
|
|
2014-01-21 19:20:42 +00:00
|
|
|
def create_team_permission(team, repo, role):
|
2014-01-21 00:05:26 +00:00
|
|
|
RepositoryPermission.create(team=team, repository=repo, role=role)
|
|
|
|
|
2014-01-21 19:20:42 +00:00
|
|
|
__apply_default_permissions(repo, team_protos, 'name',
|
|
|
|
create_team_permission)
|
|
|
|
|
2014-01-21 00:07:06 +00:00
|
|
|
user_protos = (PermissionPrototype
|
|
|
|
.select()
|
|
|
|
.where(PermissionPrototype.org == org, user_clause,
|
|
|
|
PermissionPrototype.delegate_team >> None))
|
|
|
|
|
2014-01-21 19:20:42 +00:00
|
|
|
def create_user_permission(user, repo, role):
|
2014-01-22 00:23:26 +00:00
|
|
|
# The creating user always gets admin anyway
|
|
|
|
if user.username == creating_user.username:
|
|
|
|
return
|
|
|
|
|
2014-01-21 00:05:26 +00:00
|
|
|
RepositoryPermission.create(user=user, repository=repo, role=role)
|
|
|
|
|
2014-01-21 19:20:42 +00:00
|
|
|
__apply_default_permissions(repo, user_protos, 'username',
|
|
|
|
create_user_permission)
|
|
|
|
|
2013-09-20 15:55:44 +00:00
|
|
|
return repo
|
|
|
|
|
|
|
|
|
2014-06-17 20:03:43 +00:00
|
|
|
def __translate_ancestry(old_ancestry, translations, repository, username, preferred_location):
|
2014-02-21 03:35:54 +00:00
|
|
|
if old_ancestry == '/':
|
|
|
|
return '/'
|
|
|
|
|
2014-02-21 13:00:47 +00:00
|
|
|
def translate_id(old_id):
|
2014-02-25 21:31:52 +00:00
|
|
|
logger.debug('Translating id: %s', old_id)
|
2014-02-21 13:00:47 +00:00
|
|
|
if old_id not in translations:
|
|
|
|
# Figure out which docker_image_id the old id refers to, then find a
|
|
|
|
# a local one
|
|
|
|
old = Image.select(Image.docker_image_id).where(Image.id == old_id).get()
|
2014-06-17 20:03:43 +00:00
|
|
|
image_in_repo = find_create_or_link_image(old.docker_image_id, repository, username,
|
|
|
|
translations, preferred_location)
|
2014-02-25 21:31:52 +00:00
|
|
|
translations[old_id] = image_in_repo.id
|
2014-02-21 13:00:47 +00:00
|
|
|
|
|
|
|
return translations[old_id]
|
|
|
|
|
2014-02-21 03:26:10 +00:00
|
|
|
old_ids = [int(id_str) for id_str in old_ancestry.split('/')[1:-1]]
|
2014-02-21 13:00:47 +00:00
|
|
|
new_ids = [str(translate_id(old_id)) for old_id in old_ids]
|
2014-02-21 03:26:10 +00:00
|
|
|
return '/%s/' % '/'.join(new_ids)
|
|
|
|
|
|
|
|
|
2014-06-17 20:03:43 +00:00
|
|
|
def find_create_or_link_image(docker_image_id, repository, username, translations,
|
|
|
|
preferred_location):
|
2014-05-13 16:17:26 +00:00
|
|
|
with config.app_config['DB_TRANSACTION_FACTORY'](db):
|
2014-02-25 21:31:52 +00:00
|
|
|
repo_image = get_repo_image(repository.namespace, repository.name,
|
|
|
|
docker_image_id)
|
|
|
|
if repo_image:
|
|
|
|
return repo_image
|
|
|
|
|
2014-02-21 03:26:10 +00:00
|
|
|
query = (Image
|
2014-09-22 21:27:02 +00:00
|
|
|
.select(Image, ImageStorage)
|
|
|
|
.distinct()
|
|
|
|
.join(ImageStorage)
|
|
|
|
.switch(Image)
|
|
|
|
.join(Repository)
|
|
|
|
.join(Visibility)
|
|
|
|
.switch(Repository)
|
|
|
|
.join(RepositoryPermission, JOIN_LEFT_OUTER)
|
|
|
|
.where(ImageStorage.uploading == False))
|
2014-02-16 22:38:47 +00:00
|
|
|
|
|
|
|
query = (_filter_to_repos_for_user(query, username)
|
2014-09-22 21:27:02 +00:00
|
|
|
.where(Image.docker_image_id == docker_image_id))
|
|
|
|
|
2014-02-21 03:26:10 +00:00
|
|
|
new_image_ancestry = '/'
|
|
|
|
origin_image_id = None
|
2014-02-16 22:38:47 +00:00
|
|
|
try:
|
2014-02-21 03:26:10 +00:00
|
|
|
to_copy = query.get()
|
2014-02-16 22:38:47 +00:00
|
|
|
msg = 'Linking image to existing storage with docker id: %s and uuid: %s'
|
2014-02-21 03:26:10 +00:00
|
|
|
logger.debug(msg, docker_image_id, to_copy.storage.uuid)
|
2014-09-22 21:27:02 +00:00
|
|
|
|
2014-06-17 20:03:43 +00:00
|
|
|
new_image_ancestry = __translate_ancestry(to_copy.ancestors, translations, repository,
|
|
|
|
username, preferred_location)
|
2014-02-21 03:26:10 +00:00
|
|
|
|
|
|
|
storage = to_copy.storage
|
2014-06-17 20:03:43 +00:00
|
|
|
storage.locations = {placement.location.name
|
|
|
|
for placement in storage.imagestorageplacement_set}
|
2014-02-21 03:26:10 +00:00
|
|
|
origin_image_id = to_copy.id
|
|
|
|
except Image.DoesNotExist:
|
2014-02-16 22:38:47 +00:00
|
|
|
logger.debug('Creating new storage for docker id: %s', docker_image_id)
|
|
|
|
storage = ImageStorage.create()
|
2014-06-17 20:03:43 +00:00
|
|
|
location = ImageStorageLocation.get(name=preferred_location)
|
|
|
|
ImageStoragePlacement.create(location=location, storage=storage)
|
|
|
|
storage.locations = {preferred_location}
|
|
|
|
|
|
|
|
logger.debug('Storage locations: %s', storage.locations)
|
2014-02-16 22:38:47 +00:00
|
|
|
|
|
|
|
new_image = Image.create(docker_image_id=docker_image_id,
|
2014-02-21 03:26:10 +00:00
|
|
|
repository=repository, storage=storage,
|
|
|
|
ancestors=new_image_ancestry)
|
|
|
|
|
2014-06-17 20:03:43 +00:00
|
|
|
logger.debug('new_image storage locations: %s', new_image.storage.locations)
|
|
|
|
|
|
|
|
|
2014-02-21 03:26:10 +00:00
|
|
|
if origin_image_id:
|
2014-02-25 21:31:52 +00:00
|
|
|
logger.debug('Storing translation %s -> %s', origin_image_id, new_image.id)
|
2014-02-21 03:26:10 +00:00
|
|
|
translations[origin_image_id] = new_image.id
|
|
|
|
|
2014-02-16 22:38:47 +00:00
|
|
|
return new_image
|
2013-09-20 15:55:44 +00:00
|
|
|
|
|
|
|
|
2014-01-21 00:05:26 +00:00
|
|
|
def set_image_size(docker_image_id, namespace_name, repository_name,
|
|
|
|
image_size):
|
2014-02-16 22:38:47 +00:00
|
|
|
try:
|
|
|
|
image = (Image
|
|
|
|
.select(Image, ImageStorage)
|
|
|
|
.join(Repository)
|
|
|
|
.switch(Image)
|
|
|
|
.join(ImageStorage, JOIN_LEFT_OUTER)
|
|
|
|
.where(Repository.name == repository_name,
|
|
|
|
Repository.namespace == namespace_name,
|
|
|
|
Image.docker_image_id == docker_image_id)
|
|
|
|
.get())
|
2014-01-03 21:32:00 +00:00
|
|
|
|
2014-02-16 22:38:47 +00:00
|
|
|
except Image.DoesNotExist:
|
2014-01-03 21:32:00 +00:00
|
|
|
raise DataModelException('No image with specified id and repository')
|
|
|
|
|
2014-02-17 19:58:45 +00:00
|
|
|
if image.storage and image.storage.id:
|
2014-02-16 22:38:47 +00:00
|
|
|
image.storage.image_size = image_size
|
|
|
|
image.storage.save()
|
|
|
|
else:
|
|
|
|
image.image_size = image_size
|
|
|
|
image.save()
|
|
|
|
|
|
|
|
return image
|
2014-01-03 21:32:00 +00:00
|
|
|
|
|
|
|
|
2013-10-01 18:14:39 +00:00
|
|
|
def set_image_metadata(docker_image_id, namespace_name, repository_name,
|
2014-01-13 21:32:51 +00:00
|
|
|
created_date_str, comment, command, parent=None):
|
2014-05-13 16:17:26 +00:00
|
|
|
with config.app_config['DB_TRANSACTION_FACTORY'](db):
|
2014-02-16 22:38:47 +00:00
|
|
|
query = (Image
|
|
|
|
.select(Image, ImageStorage)
|
|
|
|
.join(Repository)
|
|
|
|
.switch(Image)
|
|
|
|
.join(ImageStorage)
|
|
|
|
.where(Repository.name == repository_name,
|
|
|
|
Repository.namespace == namespace_name,
|
|
|
|
Image.docker_image_id == docker_image_id))
|
|
|
|
|
|
|
|
try:
|
|
|
|
fetched = query.get()
|
|
|
|
except Image.DoesNotExist:
|
|
|
|
raise DataModelException('No image with specified id and repository')
|
|
|
|
|
2014-03-28 21:52:47 +00:00
|
|
|
fetched.storage.created = dateutil.parser.parse(created_date_str).replace(tzinfo=None)
|
2014-02-16 22:38:47 +00:00
|
|
|
fetched.storage.comment = comment
|
|
|
|
fetched.storage.command = command
|
|
|
|
|
|
|
|
if parent:
|
|
|
|
fetched.ancestors = '%s%s/' % (parent.ancestors, parent.id)
|
|
|
|
|
|
|
|
fetched.save()
|
|
|
|
fetched.storage.save()
|
|
|
|
return fetched
|
2013-09-20 15:55:44 +00:00
|
|
|
|
|
|
|
|
2014-06-28 00:04:26 +00:00
|
|
|
def _get_repository_images_base(namespace_name, repository_name, query_modifier):
|
|
|
|
query = (ImageStoragePlacement
|
2014-06-24 22:48:42 +00:00
|
|
|
.select(ImageStoragePlacement, Image, ImageStorage, ImageStorageLocation)
|
|
|
|
.join(ImageStorageLocation)
|
|
|
|
.switch(ImageStoragePlacement)
|
2014-02-16 22:38:47 +00:00
|
|
|
.join(ImageStorage, JOIN_LEFT_OUTER)
|
2014-06-24 22:48:42 +00:00
|
|
|
.join(Image)
|
|
|
|
.join(Repository)
|
2014-02-16 22:38:47 +00:00
|
|
|
.where(Repository.name == repository_name,
|
2014-06-28 00:04:26 +00:00
|
|
|
Repository.namespace == namespace_name))
|
|
|
|
|
|
|
|
query = query_modifier(query)
|
|
|
|
|
|
|
|
location_list = list(query)
|
2014-06-24 22:48:42 +00:00
|
|
|
|
|
|
|
images = {}
|
|
|
|
for location in location_list:
|
|
|
|
# Make sure we're always retrieving the same image object.
|
|
|
|
image = location.storage.image
|
|
|
|
|
2014-07-22 20:46:36 +00:00
|
|
|
# Set the storage to the one we got from the location, to prevent another query
|
|
|
|
image.storage = location.storage
|
|
|
|
|
2014-06-28 00:04:26 +00:00
|
|
|
if not image.id in images:
|
|
|
|
images[image.id] = image
|
2014-06-24 22:48:42 +00:00
|
|
|
image.storage.locations = set()
|
|
|
|
else:
|
2014-06-28 00:04:26 +00:00
|
|
|
image = images[image.id]
|
2014-06-24 22:48:42 +00:00
|
|
|
|
|
|
|
# Add the location to the image's locations set.
|
2014-06-28 00:04:26 +00:00
|
|
|
image.storage.locations.add(location.location.name)
|
2014-06-24 22:48:42 +00:00
|
|
|
|
|
|
|
return images.values()
|
2013-09-20 15:55:44 +00:00
|
|
|
|
2013-11-06 22:09:22 +00:00
|
|
|
|
2014-06-28 00:04:26 +00:00
|
|
|
def get_repository_images(namespace_name, repository_name):
|
|
|
|
return _get_repository_images_base(namespace_name, repository_name, lambda q: q)
|
|
|
|
|
|
|
|
|
2013-09-25 20:46:28 +00:00
|
|
|
def list_repository_tags(namespace_name, repository_name):
|
|
|
|
select = RepositoryTag.select(RepositoryTag, Image)
|
|
|
|
with_repo = select.join(Repository)
|
|
|
|
with_image = with_repo.switch(RepositoryTag).join(Image)
|
2013-09-26 19:58:11 +00:00
|
|
|
return with_image.where(Repository.name == repository_name,
|
2013-09-25 21:46:42 +00:00
|
|
|
Repository.namespace == namespace_name)
|
2013-09-25 20:46:28 +00:00
|
|
|
|
|
|
|
|
2014-02-06 19:13:35 +00:00
|
|
|
def garbage_collect_repository(namespace_name, repository_name):
|
2014-05-13 19:17:16 +00:00
|
|
|
with config.app_config['DB_TRANSACTION_FACTORY'](db):
|
2014-02-16 22:38:47 +00:00
|
|
|
# Get a list of all images used by tags in the repository
|
|
|
|
tag_query = (RepositoryTag
|
|
|
|
.select(RepositoryTag, Image, ImageStorage)
|
|
|
|
.join(Image)
|
|
|
|
.join(ImageStorage, JOIN_LEFT_OUTER)
|
|
|
|
.switch(RepositoryTag)
|
|
|
|
.join(Repository)
|
|
|
|
.where(Repository.name == repository_name,
|
|
|
|
Repository.namespace == namespace_name))
|
|
|
|
|
|
|
|
referenced_anscestors = set()
|
|
|
|
for tag in tag_query:
|
|
|
|
# The anscestor list is in the format '/1/2/3/', extract just the ids
|
|
|
|
anscestor_id_strings = tag.image.ancestors.split('/')[1:-1]
|
|
|
|
ancestor_list = [int(img_id_str) for img_id_str in anscestor_id_strings]
|
|
|
|
referenced_anscestors = referenced_anscestors.union(set(ancestor_list))
|
|
|
|
referenced_anscestors.add(tag.image.id)
|
|
|
|
|
|
|
|
all_repo_images = get_repository_images(namespace_name, repository_name)
|
|
|
|
all_images = {int(img.id): img for img in all_repo_images}
|
|
|
|
to_remove = set(all_images.keys()).difference(referenced_anscestors)
|
|
|
|
|
|
|
|
logger.info('Cleaning up unreferenced images: %s', to_remove)
|
|
|
|
|
|
|
|
uuids_to_check_for_gc = set()
|
|
|
|
for image_id_to_remove in to_remove:
|
|
|
|
image_to_remove = all_images[image_id_to_remove]
|
|
|
|
|
2014-06-11 19:37:45 +00:00
|
|
|
logger.debug('Adding image storage to the gc list: %s',
|
|
|
|
image_to_remove.storage.uuid)
|
|
|
|
uuids_to_check_for_gc.add(image_to_remove.storage.uuid)
|
2014-02-06 19:13:35 +00:00
|
|
|
|
2014-02-17 19:38:35 +00:00
|
|
|
image_to_remove.delete_instance()
|
2014-02-06 19:13:35 +00:00
|
|
|
|
2014-02-19 01:41:00 +00:00
|
|
|
if uuids_to_check_for_gc:
|
|
|
|
storage_to_remove = (ImageStorage
|
|
|
|
.select()
|
|
|
|
.join(Image, JOIN_LEFT_OUTER)
|
|
|
|
.group_by(ImageStorage)
|
|
|
|
.where(ImageStorage.uuid << list(uuids_to_check_for_gc))
|
|
|
|
.having(fn.Count(Image.id) == 0))
|
2014-02-06 19:13:35 +00:00
|
|
|
|
2014-02-19 01:41:00 +00:00
|
|
|
for storage in storage_to_remove:
|
|
|
|
logger.debug('Garbage collecting image storage: %s', storage.uuid)
|
2014-06-17 20:03:43 +00:00
|
|
|
|
2014-06-11 19:37:45 +00:00
|
|
|
image_path = config.store.image_path(storage.uuid)
|
2014-06-17 20:03:43 +00:00
|
|
|
for placement in storage.imagestorageplacement_set:
|
|
|
|
location_name = placement.location.name
|
|
|
|
placement.delete_instance()
|
2014-06-17 20:37:48 +00:00
|
|
|
config.store.remove({location_name}, image_path)
|
2014-06-17 20:03:43 +00:00
|
|
|
|
|
|
|
storage.delete_instance()
|
2014-02-06 19:13:35 +00:00
|
|
|
|
2014-02-16 23:59:24 +00:00
|
|
|
return len(to_remove)
|
2014-02-06 19:13:35 +00:00
|
|
|
|
|
|
|
|
2013-09-25 20:46:28 +00:00
|
|
|
def get_tag_image(namespace_name, repository_name, tag_name):
|
2014-06-28 00:04:26 +00:00
|
|
|
def limit_to_tag(query):
|
|
|
|
return (query
|
|
|
|
.switch(Image)
|
|
|
|
.join(RepositoryTag)
|
|
|
|
.where(RepositoryTag.name == tag_name))
|
2013-09-30 19:30:00 +00:00
|
|
|
|
2014-06-28 00:04:26 +00:00
|
|
|
images = _get_repository_images_base(namespace_name, repository_name, limit_to_tag)
|
|
|
|
if not images:
|
2013-09-27 19:53:39 +00:00
|
|
|
raise DataModelException('Unable to find image for tag.')
|
2014-06-28 00:04:26 +00:00
|
|
|
else:
|
|
|
|
return images[0]
|
2013-09-26 21:58:41 +00:00
|
|
|
|
2013-09-25 20:46:28 +00:00
|
|
|
|
2013-10-01 18:14:39 +00:00
|
|
|
def get_image_by_id(namespace_name, repository_name, docker_image_id):
|
2014-06-30 18:51:01 +00:00
|
|
|
image = get_repo_image(namespace_name, repository_name, docker_image_id)
|
|
|
|
if not image:
|
2013-11-13 19:41:20 +00:00
|
|
|
raise DataModelException('Unable to find image \'%s\' for repo \'%s/%s\'' %
|
2014-06-30 18:51:01 +00:00
|
|
|
(docker_image_id, namespace_name, repository_name))
|
|
|
|
return image
|
2013-10-01 18:14:39 +00:00
|
|
|
|
2013-09-30 19:30:00 +00:00
|
|
|
|
2014-06-28 00:04:26 +00:00
|
|
|
def get_parent_images(namespace_name, repository_name, image_obj):
|
2013-09-30 19:30:00 +00:00
|
|
|
""" Returns a list of parent Image objects in chronilogical order. """
|
|
|
|
parents = image_obj.ancestors
|
|
|
|
parent_db_ids = parents.strip('/').split('/')
|
|
|
|
|
2013-10-02 21:29:45 +00:00
|
|
|
if parent_db_ids == ['']:
|
|
|
|
return []
|
|
|
|
|
2014-06-28 00:04:26 +00:00
|
|
|
def filter_to_parents(query):
|
|
|
|
return query.where(Image.id << parent_db_ids)
|
|
|
|
|
|
|
|
parents = _get_repository_images_base(namespace_name, repository_name, filter_to_parents)
|
2014-02-16 22:38:47 +00:00
|
|
|
|
2014-06-28 00:04:26 +00:00
|
|
|
id_to_image = {unicode(image.id): image for image in parents}
|
2013-09-30 19:30:00 +00:00
|
|
|
|
|
|
|
return [id_to_image[parent_id] for parent_id in parent_db_ids]
|
|
|
|
|
|
|
|
|
2013-09-25 20:46:28 +00:00
|
|
|
def create_or_update_tag(namespace_name, repository_name, tag_name,
|
2013-10-01 18:14:39 +00:00
|
|
|
tag_docker_image_id):
|
2013-11-07 22:09:15 +00:00
|
|
|
try:
|
|
|
|
repo = Repository.get(Repository.name == repository_name,
|
|
|
|
Repository.namespace == namespace_name)
|
|
|
|
except Repository.DoesNotExist:
|
|
|
|
raise DataModelException('Invalid repository %s/%s' %
|
|
|
|
(namespace_name, repository_name))
|
|
|
|
|
|
|
|
try:
|
2014-02-06 19:49:53 +00:00
|
|
|
image = Image.get(Image.docker_image_id == tag_docker_image_id,
|
|
|
|
Image.repository == repo)
|
2013-11-07 22:09:15 +00:00
|
|
|
except Image.DoesNotExist:
|
|
|
|
raise DataModelException('Invalid image with id: %s' %
|
|
|
|
tag_docker_image_id)
|
2013-09-25 20:46:28 +00:00
|
|
|
|
|
|
|
try:
|
2013-09-26 19:58:11 +00:00
|
|
|
tag = RepositoryTag.get(RepositoryTag.repository == repo,
|
2013-09-25 21:46:42 +00:00
|
|
|
RepositoryTag.name == tag_name)
|
2013-09-25 20:46:28 +00:00
|
|
|
tag.image = image
|
|
|
|
tag.save()
|
|
|
|
except RepositoryTag.DoesNotExist:
|
|
|
|
tag = RepositoryTag.create(repository=repo, image=image, name=tag_name)
|
|
|
|
|
|
|
|
return tag
|
|
|
|
|
|
|
|
|
|
|
|
def delete_tag(namespace_name, repository_name, tag_name):
|
2013-11-07 22:09:15 +00:00
|
|
|
joined = RepositoryTag.select().join(Repository)
|
|
|
|
found = list(joined.where(Repository.name == repository_name,
|
|
|
|
Repository.namespace == namespace_name,
|
|
|
|
RepositoryTag.name == tag_name))
|
|
|
|
|
|
|
|
if not found:
|
|
|
|
msg = ('Invalid repository tag \'%s\' on repository \'%s/%s\'' %
|
|
|
|
(tag_name, namespace_name, repository_name))
|
|
|
|
raise DataModelException(msg)
|
|
|
|
|
|
|
|
found[0].delete_instance()
|
2013-09-25 20:46:28 +00:00
|
|
|
|
|
|
|
|
|
|
|
def delete_all_repository_tags(namespace_name, repository_name):
|
2013-11-07 23:08:38 +00:00
|
|
|
try:
|
|
|
|
repo = Repository.get(Repository.name == repository_name,
|
|
|
|
Repository.namespace == namespace_name)
|
|
|
|
except Repository.DoesNotExist:
|
|
|
|
raise DataModelException('Invalid repository \'%s/%s\'' %
|
|
|
|
(namespace_name, repository_name))
|
2014-02-17 19:38:35 +00:00
|
|
|
RepositoryTag.delete().where(RepositoryTag.repository == repo.id).execute()
|
2013-09-25 20:46:28 +00:00
|
|
|
|
|
|
|
|
2013-11-01 23:34:17 +00:00
|
|
|
def __entity_permission_repo_query(entity_id, entity_table,
|
|
|
|
entity_id_property, namespace_name,
|
|
|
|
repository_name):
|
|
|
|
""" This method works for both users and teams. """
|
|
|
|
selected = RepositoryPermission.select(entity_table, Repository, Role,
|
2013-09-27 19:53:39 +00:00
|
|
|
RepositoryPermission)
|
2013-11-01 23:34:17 +00:00
|
|
|
with_user = selected.join(entity_table)
|
2013-09-27 19:53:39 +00:00
|
|
|
with_role = with_user.switch(RepositoryPermission).join(Role)
|
|
|
|
with_repo = with_role.switch(RepositoryPermission).join(Repository)
|
|
|
|
return with_repo.where(Repository.name == repository_name,
|
|
|
|
Repository.namespace == namespace_name,
|
2013-11-01 23:34:17 +00:00
|
|
|
entity_id_property == entity_id)
|
2013-09-27 19:53:39 +00:00
|
|
|
|
2013-09-27 18:56:14 +00:00
|
|
|
|
2013-09-27 19:53:39 +00:00
|
|
|
def get_user_reponame_permission(username, namespace_name, repository_name):
|
2013-11-01 23:34:17 +00:00
|
|
|
fetched = list(__entity_permission_repo_query(username, User, User.username,
|
|
|
|
namespace_name,
|
|
|
|
repository_name))
|
2013-09-27 19:53:39 +00:00
|
|
|
if not fetched:
|
|
|
|
raise DataModelException('User does not have permission for repo.')
|
2013-09-27 18:56:14 +00:00
|
|
|
|
2013-09-27 19:53:39 +00:00
|
|
|
return fetched[0]
|
|
|
|
|
|
|
|
|
2013-11-01 23:34:17 +00:00
|
|
|
def get_team_reponame_permission(team_name, namespace_name, repository_name):
|
|
|
|
fetched = list(__entity_permission_repo_query(team_name, Team, Team.name,
|
|
|
|
namespace_name,
|
|
|
|
repository_name))
|
|
|
|
if not fetched:
|
|
|
|
raise DataModelException('Team does not have permission for repo.')
|
|
|
|
|
|
|
|
return fetched[0]
|
|
|
|
|
|
|
|
|
|
|
|
def delete_user_permission(username, namespace_name, repository_name):
|
2013-09-27 19:53:39 +00:00
|
|
|
if username == namespace_name:
|
|
|
|
raise DataModelException('Namespace owner must always be admin.')
|
|
|
|
|
2013-11-01 23:34:17 +00:00
|
|
|
fetched = list(__entity_permission_repo_query(username, User, User.username,
|
|
|
|
namespace_name,
|
|
|
|
repository_name))
|
|
|
|
if not fetched:
|
|
|
|
raise DataModelException('User does not have permission for repo.')
|
|
|
|
|
|
|
|
fetched[0].delete_instance()
|
|
|
|
|
|
|
|
|
|
|
|
def delete_team_permission(team_name, namespace_name, repository_name):
|
|
|
|
fetched = list(__entity_permission_repo_query(team_name, Team, Team.name,
|
|
|
|
namespace_name,
|
|
|
|
repository_name))
|
|
|
|
if not fetched:
|
|
|
|
raise DataModelException('Team does not have permission for repo.')
|
|
|
|
|
|
|
|
fetched[0].delete_instance()
|
|
|
|
|
|
|
|
|
2013-11-07 17:54:21 +00:00
|
|
|
def __set_entity_repo_permission(entity, permission_entity_property,
|
|
|
|
namespace_name, repository_name, role_name):
|
2013-09-27 18:56:14 +00:00
|
|
|
repo = Repository.get(Repository.name == repository_name,
|
|
|
|
Repository.namespace == namespace_name)
|
|
|
|
new_role = Role.get(Role.name == role_name)
|
|
|
|
|
2013-11-07 17:54:21 +00:00
|
|
|
# Fetch any existing permission for this entity on the repo
|
2013-09-27 18:56:14 +00:00
|
|
|
try:
|
2013-11-01 23:34:17 +00:00
|
|
|
entity_attr = getattr(RepositoryPermission, permission_entity_property)
|
|
|
|
perm = RepositoryPermission.get(entity_attr == entity,
|
2013-09-27 18:56:14 +00:00
|
|
|
RepositoryPermission.repository == repo)
|
|
|
|
perm.role = new_role
|
|
|
|
perm.save()
|
|
|
|
return perm
|
|
|
|
except RepositoryPermission.DoesNotExist:
|
2013-11-01 23:34:17 +00:00
|
|
|
set_entity_kwargs = {permission_entity_property: entity}
|
|
|
|
new_perm = RepositoryPermission.create(repository=repo, role=new_role,
|
|
|
|
**set_entity_kwargs)
|
2013-09-27 18:56:14 +00:00
|
|
|
return new_perm
|
|
|
|
|
2013-09-28 00:03:07 +00:00
|
|
|
|
2013-11-01 23:34:17 +00:00
|
|
|
def set_user_repo_permission(username, namespace_name, repository_name,
|
|
|
|
role_name):
|
2013-09-27 19:53:39 +00:00
|
|
|
if username == namespace_name:
|
|
|
|
raise DataModelException('Namespace owner must always be admin.')
|
|
|
|
|
2014-03-18 19:58:37 +00:00
|
|
|
try:
|
|
|
|
user = User.get(User.username == username)
|
|
|
|
except User.DoesNotExist:
|
|
|
|
raise InvalidUsernameException('Invalid username: %s' % username)
|
2013-11-07 17:54:21 +00:00
|
|
|
return __set_entity_repo_permission(user, 'user', namespace_name,
|
|
|
|
repository_name, role_name)
|
2013-09-27 19:53:39 +00:00
|
|
|
|
2013-11-01 23:34:17 +00:00
|
|
|
|
|
|
|
def set_team_repo_permission(team_name, namespace_name, repository_name,
|
|
|
|
role_name):
|
2013-11-07 17:54:21 +00:00
|
|
|
team = list(Team.select().join(User).where(Team.name == team_name,
|
|
|
|
User.username == namespace_name))
|
|
|
|
if not team:
|
|
|
|
raise DataModelException('No team \'%s\' in organization \'%s\'.' %
|
|
|
|
(team_name, namespace_name))
|
|
|
|
|
|
|
|
return __set_entity_repo_permission(team[0], 'team', namespace_name,
|
|
|
|
repository_name, role_name)
|
2013-10-01 16:13:25 +00:00
|
|
|
|
2013-10-02 05:40:11 +00:00
|
|
|
|
2013-10-01 16:13:25 +00:00
|
|
|
def purge_repository(namespace_name, repository_name):
|
2014-02-16 22:38:47 +00:00
|
|
|
# Delete all tags to allow gc to reclaim storage
|
|
|
|
delete_all_repository_tags(namespace_name, repository_name)
|
|
|
|
|
|
|
|
# Gc to remove the images and storage
|
|
|
|
garbage_collect_repository(namespace_name, repository_name)
|
|
|
|
|
|
|
|
# Delete the rest of the repository metadata
|
2013-10-01 16:13:25 +00:00
|
|
|
fetched = Repository.get(Repository.name == repository_name,
|
|
|
|
Repository.namespace == namespace_name)
|
2013-12-02 23:16:22 +00:00
|
|
|
fetched.delete_instance(recursive=True)
|
2013-10-02 05:40:11 +00:00
|
|
|
|
|
|
|
|
|
|
|
def get_private_repo_count(username):
|
|
|
|
joined = Repository.select().join(Visibility)
|
|
|
|
return joined.where(Repository.namespace == username,
|
|
|
|
Visibility.name == 'private').count()
|
2013-10-16 18:24:10 +00:00
|
|
|
|
|
|
|
|
|
|
|
def create_access_token(repository, role):
|
|
|
|
role = Role.get(Role.name == role)
|
|
|
|
new_token = AccessToken.create(repository=repository, temporary=True,
|
|
|
|
role=role)
|
|
|
|
return new_token
|
|
|
|
|
|
|
|
|
2014-02-21 22:09:56 +00:00
|
|
|
def create_delegate_token(namespace_name, repository_name, friendly_name,
|
|
|
|
role='read'):
|
|
|
|
read_only = Role.get(name=role)
|
2013-10-16 18:24:10 +00:00
|
|
|
repo = Repository.get(Repository.name == repository_name,
|
|
|
|
Repository.namespace == namespace_name)
|
|
|
|
new_token = AccessToken.create(repository=repo, role=read_only,
|
|
|
|
friendly_name=friendly_name, temporary=False)
|
|
|
|
return new_token
|
|
|
|
|
|
|
|
|
|
|
|
def get_repository_delegate_tokens(namespace_name, repository_name):
|
2014-07-18 18:56:26 +00:00
|
|
|
return (AccessToken.select(AccessToken, Role)
|
|
|
|
.join(Repository)
|
|
|
|
.switch(AccessToken)
|
|
|
|
.join(Role)
|
|
|
|
.switch(AccessToken)
|
|
|
|
.join(RepositoryBuildTrigger, JOIN_LEFT_OUTER)
|
|
|
|
.where(Repository.name == repository_name, Repository.namespace == namespace_name,
|
|
|
|
AccessToken.temporary == False, RepositoryBuildTrigger.uuid >> None))
|
2013-10-16 18:24:10 +00:00
|
|
|
|
|
|
|
|
|
|
|
def get_repo_delegate_token(namespace_name, repository_name, code):
|
|
|
|
repo_query = get_repository_delegate_tokens(namespace_name, repository_name)
|
|
|
|
found = list(repo_query.where(AccessToken.code == code))
|
|
|
|
|
|
|
|
if found:
|
|
|
|
return found[0]
|
|
|
|
else:
|
|
|
|
raise InvalidTokenException('Unable to find token with code: %s' % code)
|
|
|
|
|
|
|
|
|
|
|
|
def set_repo_delegate_token_role(namespace_name, repository_name, code, role):
|
|
|
|
token = get_repo_delegate_token(namespace_name, repository_name, code)
|
|
|
|
|
|
|
|
if role != 'read' and role != 'write':
|
|
|
|
raise DataModelException('Invalid role for delegate token: %s' % role)
|
|
|
|
|
|
|
|
new_role = Role.get(Role.name == role)
|
|
|
|
token.role = new_role
|
|
|
|
token.save()
|
|
|
|
|
|
|
|
return token
|
|
|
|
|
|
|
|
|
|
|
|
def delete_delegate_token(namespace_name, repository_name, code):
|
|
|
|
token = get_repo_delegate_token(namespace_name, repository_name, code)
|
2014-07-18 18:56:26 +00:00
|
|
|
token.delete_instance(recursive=True)
|
2013-11-29 05:04:50 +00:00
|
|
|
return token
|
2013-10-16 18:24:10 +00:00
|
|
|
|
|
|
|
|
|
|
|
def load_token_data(code):
|
|
|
|
""" Load the permissions for any token by code. """
|
|
|
|
selected = AccessToken.select(AccessToken, Repository, Role)
|
|
|
|
with_role = selected.join(Role)
|
|
|
|
with_repo = with_role.switch(AccessToken).join(Repository)
|
|
|
|
fetched = list(with_repo.where(AccessToken.code == code))
|
|
|
|
|
|
|
|
if fetched:
|
|
|
|
return fetched[0]
|
|
|
|
else:
|
|
|
|
raise InvalidTokenException('Invalid delegate token code: %s' % code)
|
2013-10-24 20:37:03 +00:00
|
|
|
|
|
|
|
|
2014-02-04 00:08:37 +00:00
|
|
|
def get_repository_build(namespace_name, repository_name, build_uuid):
|
2014-02-19 21:08:33 +00:00
|
|
|
try:
|
2014-03-05 20:50:32 +00:00
|
|
|
query = list_repository_builds(namespace_name, repository_name, 1)
|
2014-02-19 21:08:33 +00:00
|
|
|
return query.where(RepositoryBuild.uuid == build_uuid).get()
|
2014-02-04 00:08:37 +00:00
|
|
|
|
2014-02-19 21:08:33 +00:00
|
|
|
except RepositoryBuild.DoesNotExist:
|
2014-02-04 00:08:37 +00:00
|
|
|
msg = 'Unable to locate a build by id: %s' % build_uuid
|
2013-11-13 22:29:26 +00:00
|
|
|
raise InvalidRepositoryBuildException(msg)
|
|
|
|
|
|
|
|
|
2014-03-05 20:50:32 +00:00
|
|
|
def list_repository_builds(namespace_name, repository_name, limit,
|
2013-10-27 20:00:44 +00:00
|
|
|
include_inactive=True):
|
2014-02-19 21:08:33 +00:00
|
|
|
query = (RepositoryBuild
|
|
|
|
.select(RepositoryBuild, RepositoryBuildTrigger, BuildTriggerService)
|
|
|
|
.join(Repository)
|
|
|
|
.switch(RepositoryBuild)
|
|
|
|
.join(RepositoryBuildTrigger, JOIN_LEFT_OUTER)
|
|
|
|
.join(BuildTriggerService, JOIN_LEFT_OUTER)
|
|
|
|
.where(Repository.name == repository_name,
|
2014-03-05 20:50:32 +00:00
|
|
|
Repository.namespace == namespace_name)
|
2014-03-05 21:17:01 +00:00
|
|
|
.order_by(RepositoryBuild.started.desc())
|
2014-03-05 20:50:32 +00:00
|
|
|
.limit(limit))
|
2014-02-19 21:08:33 +00:00
|
|
|
|
2013-10-27 20:00:44 +00:00
|
|
|
if not include_inactive:
|
2014-02-19 21:08:33 +00:00
|
|
|
query = query.where(RepositoryBuild.phase != 'error',
|
|
|
|
RepositoryBuild.phase != 'complete')
|
|
|
|
|
|
|
|
return query
|
2013-10-25 19:13:11 +00:00
|
|
|
|
|
|
|
|
2014-02-28 21:23:36 +00:00
|
|
|
def get_recent_repository_build(namespace_name, repository_name):
|
2014-03-05 21:17:01 +00:00
|
|
|
query = list_repository_builds(namespace_name, repository_name, 1)
|
|
|
|
try:
|
|
|
|
return query.get()
|
|
|
|
except RepositoryBuild.DoesNotExist:
|
|
|
|
return None
|
2014-02-28 21:23:36 +00:00
|
|
|
|
|
|
|
|
2014-02-25 23:22:02 +00:00
|
|
|
def create_repository_build(repo, access_token, job_config_obj, dockerfile_id,
|
2014-04-02 01:49:06 +00:00
|
|
|
display_name, trigger=None, pull_robot_name=None):
|
|
|
|
pull_robot = None
|
|
|
|
if pull_robot_name:
|
|
|
|
pull_robot = lookup_robot(pull_robot_name)
|
|
|
|
|
2013-10-25 22:17:43 +00:00
|
|
|
return RepositoryBuild.create(repository=repo, access_token=access_token,
|
2014-02-24 21:11:23 +00:00
|
|
|
job_config=json.dumps(job_config_obj),
|
2014-02-25 23:22:02 +00:00
|
|
|
display_name=display_name, trigger=trigger,
|
2014-04-02 01:49:06 +00:00
|
|
|
resource_key=dockerfile_id,
|
|
|
|
pull_robot=pull_robot)
|
|
|
|
|
2013-11-15 21:45:02 +00:00
|
|
|
|
2014-04-02 01:49:06 +00:00
|
|
|
def get_pull_robot_name(trigger):
|
|
|
|
if not trigger.pull_robot:
|
2014-03-27 22:33:13 +00:00
|
|
|
return None
|
|
|
|
|
2014-04-02 01:49:06 +00:00
|
|
|
return trigger.pull_robot.username
|
|
|
|
|
|
|
|
|
|
|
|
def get_pull_credentials(robotname):
|
|
|
|
robot = lookup_robot(robotname)
|
|
|
|
if not robot:
|
|
|
|
return None
|
|
|
|
|
2014-03-27 22:33:13 +00:00
|
|
|
try:
|
2014-04-02 01:49:06 +00:00
|
|
|
login_info = FederatedLogin.get(user=robot)
|
2014-03-27 22:33:13 +00:00
|
|
|
except FederatedLogin.DoesNotExist:
|
|
|
|
return None
|
|
|
|
|
|
|
|
return {
|
2014-04-02 01:49:06 +00:00
|
|
|
'username': robot.username,
|
2014-03-27 22:33:13 +00:00
|
|
|
'password': login_info.service_ident,
|
2014-05-13 16:17:26 +00:00
|
|
|
'registry': '%s://%s/v1/' % (config.app_config['PREFERRED_URL_SCHEME'],
|
|
|
|
config.app_config['SERVER_HOSTNAME']),
|
2014-03-27 22:33:13 +00:00
|
|
|
}
|
2013-11-15 21:45:02 +00:00
|
|
|
|
2014-04-02 01:49:06 +00:00
|
|
|
|
2014-07-16 20:30:47 +00:00
|
|
|
def create_repo_notification(repo, event_name, method_name, config):
|
|
|
|
event = ExternalNotificationEvent.get(ExternalNotificationEvent.name == event_name)
|
|
|
|
method = ExternalNotificationMethod.get(ExternalNotificationMethod.name == method_name)
|
|
|
|
|
|
|
|
return RepositoryNotification.create(repository=repo, event=event, method=method,
|
2014-07-17 17:32:39 +00:00
|
|
|
config_json=json.dumps(config))
|
2014-07-16 20:30:47 +00:00
|
|
|
|
|
|
|
|
|
|
|
def get_repo_notification(namespace_name, repository_name, uuid):
|
|
|
|
joined = RepositoryNotification.select().join(Repository)
|
|
|
|
found = list(joined.where(Repository.namespace == namespace_name,
|
|
|
|
Repository.name == repository_name,
|
|
|
|
RepositoryNotification.uuid == uuid))
|
|
|
|
|
|
|
|
if not found:
|
|
|
|
raise InvalidNotificationException('No repository notification found with id: %s' % uuid)
|
|
|
|
|
|
|
|
return found[0]
|
|
|
|
|
|
|
|
|
|
|
|
def delete_repo_notification(namespace_name, repository_name, uuid):
|
|
|
|
found = get_repo_notification(namespace_name, repository_name, uuid)
|
|
|
|
found.delete_instance()
|
|
|
|
return found
|
|
|
|
|
|
|
|
|
2014-07-18 02:51:58 +00:00
|
|
|
def list_repo_notifications(namespace_name, repository_name, event_name=None):
|
2014-07-16 20:30:47 +00:00
|
|
|
joined = RepositoryNotification.select().join(Repository)
|
2014-07-18 02:51:58 +00:00
|
|
|
where = joined.where(Repository.namespace == namespace_name,
|
|
|
|
Repository.name == repository_name)
|
|
|
|
|
|
|
|
if event_name:
|
|
|
|
event = ExternalNotificationEvent.get(ExternalNotificationEvent.name == event_name)
|
2014-07-18 20:34:52 +00:00
|
|
|
where = where.where(RepositoryNotification.event == event)
|
2014-07-16 20:30:47 +00:00
|
|
|
|
2014-07-18 02:51:58 +00:00
|
|
|
return where
|
2014-07-16 20:30:47 +00:00
|
|
|
|
2013-12-07 00:25:27 +00:00
|
|
|
|
2014-04-10 04:26:55 +00:00
|
|
|
def list_logs(start_time, end_time, performer=None, repository=None, namespace=None):
|
2014-02-18 20:50:15 +00:00
|
|
|
joined = LogEntry.select().join(User)
|
|
|
|
if repository:
|
|
|
|
joined = joined.where(LogEntry.repository == repository)
|
2013-11-27 07:29:31 +00:00
|
|
|
|
2014-02-18 20:50:15 +00:00
|
|
|
if performer:
|
|
|
|
joined = joined.where(LogEntry.performer == performer)
|
|
|
|
|
2014-04-10 04:26:55 +00:00
|
|
|
if namespace:
|
2014-04-11 23:23:57 +00:00
|
|
|
joined = joined.where(User.username == namespace)
|
2014-04-10 04:26:55 +00:00
|
|
|
|
2014-02-18 20:50:15 +00:00
|
|
|
return joined.where(
|
|
|
|
LogEntry.datetime >= start_time,
|
|
|
|
LogEntry.datetime < end_time).order_by(LogEntry.datetime.desc())
|
|
|
|
|
|
|
|
|
|
|
|
def log_action(kind_name, user_or_organization_name, performer=None,
|
|
|
|
repository=None, access_token=None, ip=None, metadata={},
|
|
|
|
timestamp=None):
|
2013-12-03 21:48:44 +00:00
|
|
|
if not timestamp:
|
|
|
|
timestamp = datetime.today()
|
2013-12-03 21:45:06 +00:00
|
|
|
|
2013-11-27 07:29:31 +00:00
|
|
|
kind = LogEntryKind.get(LogEntryKind.name == kind_name)
|
|
|
|
account = User.get(User.username == user_or_organization_name)
|
2014-02-18 20:50:15 +00:00
|
|
|
LogEntry.create(kind=kind, account=account, performer=performer,
|
|
|
|
repository=repository, access_token=access_token, ip=ip,
|
|
|
|
metadata_json=json.dumps(metadata), datetime=timestamp)
|
|
|
|
|
|
|
|
|
2014-04-02 01:49:06 +00:00
|
|
|
def create_build_trigger(repo, service_name, auth_token, user, pull_robot=None):
|
2014-02-18 20:50:15 +00:00
|
|
|
service = BuildTriggerService.get(name=service_name)
|
|
|
|
trigger = RepositoryBuildTrigger.create(repository=repo, service=service,
|
|
|
|
auth_token=auth_token,
|
2014-03-27 22:33:13 +00:00
|
|
|
connected_user=user,
|
2014-04-02 01:49:06 +00:00
|
|
|
pull_robot=pull_robot)
|
2014-02-18 20:50:15 +00:00
|
|
|
return trigger
|
|
|
|
|
|
|
|
|
|
|
|
def get_build_trigger(namespace_name, repository_name, trigger_uuid):
|
|
|
|
try:
|
|
|
|
return (RepositoryBuildTrigger
|
|
|
|
.select(RepositoryBuildTrigger, BuildTriggerService, Repository)
|
|
|
|
.join(BuildTriggerService)
|
|
|
|
.switch(RepositoryBuildTrigger)
|
|
|
|
.join(Repository)
|
|
|
|
.switch(RepositoryBuildTrigger)
|
|
|
|
.join(User)
|
|
|
|
.where(RepositoryBuildTrigger.uuid == trigger_uuid,
|
|
|
|
Repository.namespace == namespace_name,
|
|
|
|
Repository.name == repository_name)
|
|
|
|
.get())
|
|
|
|
except RepositoryBuildTrigger.DoesNotExist:
|
|
|
|
msg = 'No build trigger with uuid: %s' % trigger_uuid
|
|
|
|
raise InvalidBuildTriggerException(msg)
|
|
|
|
|
|
|
|
|
|
|
|
def list_build_triggers(namespace_name, repository_name):
|
|
|
|
return (RepositoryBuildTrigger
|
|
|
|
.select(RepositoryBuildTrigger, BuildTriggerService, Repository)
|
|
|
|
.join(BuildTriggerService)
|
|
|
|
.switch(RepositoryBuildTrigger)
|
|
|
|
.join(Repository)
|
|
|
|
.where(Repository.namespace == namespace_name,
|
|
|
|
Repository.name == repository_name))
|
|
|
|
|
|
|
|
|
2014-02-19 21:08:33 +00:00
|
|
|
def list_trigger_builds(namespace_name, repository_name, trigger_uuid,
|
2014-03-05 20:50:32 +00:00
|
|
|
limit):
|
2014-03-06 20:04:59 +00:00
|
|
|
return (list_repository_builds(namespace_name, repository_name, limit)
|
2014-02-19 21:08:33 +00:00
|
|
|
.where(RepositoryBuildTrigger.uuid == trigger_uuid))
|
2014-03-12 04:49:03 +00:00
|
|
|
|
|
|
|
|
2014-05-29 15:24:10 +00:00
|
|
|
def create_notification(kind_name, target, metadata={}):
|
|
|
|
kind_ref = NotificationKind.get(name=kind_name)
|
2014-03-12 23:00:24 +00:00
|
|
|
notification = Notification.create(kind=kind_ref, target=target,
|
2014-03-12 04:49:03 +00:00
|
|
|
metadata_json=json.dumps(metadata))
|
|
|
|
return notification
|
|
|
|
|
|
|
|
|
2014-05-29 15:24:10 +00:00
|
|
|
def create_unique_notification(kind_name, target, metadata={}):
|
|
|
|
with config.app_config['DB_TRANSACTION_FACTORY'](db):
|
2014-08-26 19:19:39 +00:00
|
|
|
if list_notifications(target, kind_name, limit=1).count() == 0:
|
2014-05-29 15:24:10 +00:00
|
|
|
create_notification(kind_name, target, metadata)
|
|
|
|
|
|
|
|
|
2014-07-28 22:23:46 +00:00
|
|
|
def lookup_notification(user, uuid):
|
2014-08-26 19:19:39 +00:00
|
|
|
results = list(list_notifications(user, id_filter=uuid, include_dismissed=True, limit=1))
|
2014-07-28 22:23:46 +00:00
|
|
|
if not results:
|
|
|
|
return None
|
|
|
|
|
|
|
|
return results[0]
|
|
|
|
|
|
|
|
|
2014-08-26 19:19:39 +00:00
|
|
|
def list_notifications(user, kind_name=None, id_filter=None, include_dismissed=False,
|
|
|
|
page=None, limit=None):
|
2014-03-12 23:00:24 +00:00
|
|
|
Org = User.alias()
|
|
|
|
AdminTeam = Team.alias()
|
|
|
|
AdminTeamMember = TeamMember.alias()
|
|
|
|
AdminUser = User.alias()
|
2014-03-12 04:49:03 +00:00
|
|
|
|
2014-03-12 23:00:24 +00:00
|
|
|
query = (Notification.select()
|
|
|
|
.join(User)
|
|
|
|
|
|
|
|
.switch(Notification)
|
|
|
|
.join(Org, JOIN_LEFT_OUTER, on=(Org.id == Notification.target))
|
|
|
|
.join(AdminTeam, JOIN_LEFT_OUTER, on=(Org.id ==
|
|
|
|
AdminTeam.organization))
|
|
|
|
.join(TeamRole, JOIN_LEFT_OUTER, on=(AdminTeam.role == TeamRole.id))
|
|
|
|
.switch(AdminTeam)
|
|
|
|
.join(AdminTeamMember, JOIN_LEFT_OUTER, on=(AdminTeam.id ==
|
|
|
|
AdminTeamMember.team))
|
|
|
|
.join(AdminUser, JOIN_LEFT_OUTER, on=(AdminTeamMember.user ==
|
2014-05-29 15:24:10 +00:00
|
|
|
AdminUser.id))
|
|
|
|
.where((Notification.target == user) |
|
|
|
|
((AdminUser.id == user) & (TeamRole.name == 'admin')))
|
|
|
|
.order_by(Notification.created)
|
|
|
|
.desc())
|
2014-07-28 22:23:46 +00:00
|
|
|
|
|
|
|
if not include_dismissed:
|
|
|
|
query = query.switch(Notification).where(Notification.dismissed == False)
|
2014-03-12 23:00:24 +00:00
|
|
|
|
2014-05-29 15:24:10 +00:00
|
|
|
if kind_name:
|
|
|
|
query = (query
|
|
|
|
.switch(Notification)
|
|
|
|
.join(NotificationKind)
|
|
|
|
.where(NotificationKind.name == kind_name))
|
|
|
|
|
2014-07-28 22:23:46 +00:00
|
|
|
if id_filter:
|
|
|
|
query = (query
|
|
|
|
.switch(Notification)
|
|
|
|
.where(Notification.uuid == id_filter))
|
|
|
|
|
2014-08-26 19:19:39 +00:00
|
|
|
if page:
|
|
|
|
query = query.paginate(page, limit)
|
|
|
|
elif limit:
|
|
|
|
query = query.limit(limit)
|
|
|
|
|
2014-05-29 15:24:10 +00:00
|
|
|
return query
|
|
|
|
|
2014-03-12 04:49:03 +00:00
|
|
|
|
2014-05-29 15:24:10 +00:00
|
|
|
def delete_all_notifications_by_kind(kind_name):
|
|
|
|
kind_ref = NotificationKind.get(name=kind_name)
|
|
|
|
(Notification.delete()
|
|
|
|
.where(Notification.kind == kind_ref)
|
|
|
|
.execute())
|
2014-03-12 04:49:03 +00:00
|
|
|
|
|
|
|
|
2014-05-29 15:24:10 +00:00
|
|
|
def delete_notifications_by_kind(target, kind_name):
|
|
|
|
kind_ref = NotificationKind.get(name=kind_name)
|
2014-03-12 23:00:24 +00:00
|
|
|
Notification.delete().where(Notification.target == target,
|
|
|
|
Notification.kind == kind_ref).execute()
|
2014-04-10 04:26:55 +00:00
|
|
|
|
2014-08-18 21:24:00 +00:00
|
|
|
def delete_matching_notifications(target, kind_name, **kwargs):
|
|
|
|
kind_ref = NotificationKind.get(name=kind_name)
|
|
|
|
|
|
|
|
# Load all notifications for the user with the given kind.
|
2014-08-28 23:07:22 +00:00
|
|
|
notifications = Notification.select().where(
|
2014-08-18 21:24:00 +00:00
|
|
|
Notification.target == target,
|
2014-08-28 23:07:22 +00:00
|
|
|
Notification.kind == kind_ref)
|
2014-08-18 21:24:00 +00:00
|
|
|
|
|
|
|
# For each, match the metadata to the specified values.
|
|
|
|
for notification in notifications:
|
|
|
|
matches = True
|
|
|
|
try:
|
|
|
|
metadata = json.loads(notification.metadata_json)
|
|
|
|
except:
|
|
|
|
continue
|
|
|
|
|
|
|
|
for (key, value) in kwargs.iteritems():
|
|
|
|
if not key in metadata or metadata[key] != value:
|
|
|
|
matches = False
|
|
|
|
break
|
|
|
|
|
|
|
|
if not matches:
|
|
|
|
continue
|
|
|
|
|
|
|
|
notification.delete_instance()
|
|
|
|
|
2014-04-10 04:26:55 +00:00
|
|
|
|
|
|
|
def get_active_users():
|
|
|
|
return User.select().where(User.organization == False, User.robot == False)
|
|
|
|
|
|
|
|
def get_active_user_count():
|
|
|
|
return get_active_users().count()
|
|
|
|
|
2014-09-15 16:01:02 +00:00
|
|
|
|
|
|
|
def detach_external_login(user, service_name):
|
|
|
|
try:
|
|
|
|
service = LoginService.get(name = service_name)
|
|
|
|
except LoginService.DoesNotExist:
|
|
|
|
return
|
|
|
|
|
|
|
|
FederatedLogin.delete().where(FederatedLogin.user == user,
|
|
|
|
FederatedLogin.service == service).execute()
|
|
|
|
|
2014-04-10 04:26:55 +00:00
|
|
|
def delete_user(user):
|
|
|
|
user.delete_instance(recursive=True, delete_nullable=True)
|
|
|
|
|
|
|
|
# TODO: also delete any repository data associated
|
2014-05-13 22:53:42 +00:00
|
|
|
|
|
|
|
def check_health():
|
|
|
|
# We will connect to the db, check that it contains some log entry kinds
|
|
|
|
try:
|
|
|
|
found_count = LogEntryKind.select().count()
|
|
|
|
return found_count > 0
|
|
|
|
except:
|
|
|
|
return False
|
2014-07-28 18:58:12 +00:00
|
|
|
|
|
|
|
def get_email_authorized_for_repo(namespace, repository, email):
|
|
|
|
found = list(RepositoryAuthorizedEmail.select()
|
|
|
|
.join(Repository)
|
|
|
|
.where(Repository.namespace == namespace,
|
|
|
|
Repository.name == repository,
|
|
|
|
RepositoryAuthorizedEmail.email == email)
|
|
|
|
.switch(RepositoryAuthorizedEmail)
|
|
|
|
.limit(1))
|
|
|
|
if not found or len(found) < 1:
|
|
|
|
return None
|
|
|
|
|
|
|
|
return found[0]
|
|
|
|
|
|
|
|
|
|
|
|
def create_email_authorization_for_repo(namespace_name, repository_name, email):
|
|
|
|
try:
|
|
|
|
repo = Repository.get(Repository.name == repository_name,
|
|
|
|
Repository.namespace == namespace_name)
|
|
|
|
except Repository.DoesNotExist:
|
|
|
|
raise DataModelException('Invalid repository %s/%s' %
|
|
|
|
(namespace_name, repository_name))
|
|
|
|
|
|
|
|
return RepositoryAuthorizedEmail.create(repository=repo, email=email, confirmed=False)
|
|
|
|
|
|
|
|
|
|
|
|
def confirm_email_authorization_for_repo(code):
|
|
|
|
try:
|
|
|
|
found = RepositoryAuthorizedEmail.get(RepositoryAuthorizedEmail.code == code)
|
|
|
|
except RepositoryAuthorizedEmail.DoesNotExist:
|
|
|
|
raise DataModelException('Invalid confirmation code.')
|
|
|
|
|
|
|
|
found.confirmed = True
|
|
|
|
found.save()
|
|
|
|
|
|
|
|
return found
|
2014-08-18 21:24:00 +00:00
|
|
|
|
|
|
|
|
2014-09-08 21:20:01 +00:00
|
|
|
def delete_team_email_invite(team, email):
|
|
|
|
found = TeamMemberInvite.get(TeamMemberInvite.email == email, TeamMemberInvite.team == team)
|
|
|
|
found.delete_instance()
|
|
|
|
|
|
|
|
def delete_team_user_invite(team, user):
|
|
|
|
try:
|
|
|
|
found = TeamMemberInvite.get(TeamMemberInvite.user == user, TeamMemberInvite.team == team)
|
|
|
|
except TeamMemberInvite.DoesNotExist:
|
|
|
|
return False
|
|
|
|
|
|
|
|
found.delete_instance()
|
|
|
|
return True
|
|
|
|
|
2014-08-18 21:24:00 +00:00
|
|
|
def lookup_team_invites(user):
|
|
|
|
return TeamMemberInvite.select().where(TeamMemberInvite.user == user)
|
|
|
|
|
2014-09-04 22:42:23 +00:00
|
|
|
def lookup_team_invite(code, user=None):
|
2014-08-18 21:24:00 +00:00
|
|
|
# Lookup the invite code.
|
|
|
|
try:
|
|
|
|
found = TeamMemberInvite.get(TeamMemberInvite.invite_token == code)
|
|
|
|
except TeamMemberInvite.DoesNotExist:
|
|
|
|
raise DataModelException('Invalid confirmation code.')
|
|
|
|
|
2014-09-04 22:42:23 +00:00
|
|
|
if user and found.user != user:
|
|
|
|
raise DataModelException('Invalid confirmation code.')
|
2014-08-18 21:24:00 +00:00
|
|
|
|
2014-09-04 22:42:23 +00:00
|
|
|
return found
|
2014-08-18 21:24:00 +00:00
|
|
|
|
2014-09-04 22:42:23 +00:00
|
|
|
def delete_team_invite(code, user=None):
|
2014-08-18 21:24:00 +00:00
|
|
|
found = lookup_team_invite(code, user)
|
|
|
|
|
|
|
|
team = found.team
|
|
|
|
inviter = found.inviter
|
|
|
|
|
|
|
|
found.delete_instance()
|
|
|
|
|
|
|
|
return (team, inviter)
|
|
|
|
|
2014-09-04 22:42:23 +00:00
|
|
|
|
2014-08-18 21:24:00 +00:00
|
|
|
def confirm_team_invite(code, user):
|
2014-09-04 22:42:23 +00:00
|
|
|
found = lookup_team_invite(code)
|
2014-08-18 21:24:00 +00:00
|
|
|
|
2014-09-12 18:29:01 +00:00
|
|
|
# If the invite is for a specific user, we have to confirm that here.
|
|
|
|
if found.user is not None and found.user != user:
|
|
|
|
message = """This invite is intended for user "%s".
|
|
|
|
Please login to that account and try again.""" % found.user.username
|
|
|
|
raise DataModelException(message)
|
|
|
|
|
2014-08-18 21:24:00 +00:00
|
|
|
# Add the user to the team.
|
|
|
|
try:
|
|
|
|
add_user_to_team(user, found.team)
|
|
|
|
except UserAlreadyInTeam:
|
|
|
|
# Ignore.
|
|
|
|
pass
|
2014-09-04 22:42:23 +00:00
|
|
|
|
2014-08-18 21:24:00 +00:00
|
|
|
# Delete the invite and return the team.
|
|
|
|
team = found.team
|
|
|
|
inviter = found.inviter
|
|
|
|
found.delete_instance()
|
|
|
|
return (team, inviter)
|
2014-09-15 21:52:17 +00:00
|
|
|
|
2014-09-08 20:43:17 +00:00
|
|
|
def archivable_buildlogs_query():
|
|
|
|
presumed_dead_date = datetime.utcnow() - PRESUMED_DEAD_BUILD_AGE
|
|
|
|
return (RepositoryBuild.select()
|
|
|
|
.where((RepositoryBuild.phase == BUILD_PHASE.COMPLETE) |
|
|
|
|
(RepositoryBuild.phase == BUILD_PHASE.ERROR) |
|
|
|
|
(RepositoryBuild.started < presumed_dead_date), RepositoryBuild.logs_archived == False))
|