##// END OF EJS Templates
pull-requests: introduce operation state for pull requests to prevent from...
marcink -
r3371:e7214a9f default
parent child Browse files
Show More
This diff has been collapsed as it changes many lines, (4759 lines changed) Show them Hide them
@@ -0,0 +1,4759 b''
1 # -*- coding: utf-8 -*-
2
3 # Copyright (C) 2010-2019 RhodeCode GmbH
4 #
5 # This program is free software: you can redistribute it and/or modify
6 # it under the terms of the GNU Affero General Public License, version 3
7 # (only), as published by the Free Software Foundation.
8 #
9 # This program is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 # GNU General Public License for more details.
13 #
14 # You should have received a copy of the GNU Affero General Public License
15 # along with this program. If not, see <http://www.gnu.org/licenses/>.
16 #
17 # This program is dual-licensed. If you wish to learn more about the
18 # RhodeCode Enterprise Edition, including its added features, Support services,
19 # and proprietary license terms, please see https://rhodecode.com/licenses/
20
21 """
22 Database Models for RhodeCode Enterprise
23 """
24
25 import re
26 import os
27 import time
28 import hashlib
29 import logging
30 import datetime
31 import warnings
32 import ipaddress
33 import functools
34 import traceback
35 import collections
36
37 from sqlalchemy import (
38 or_, and_, not_, func, TypeDecorator, event,
39 Index, Sequence, UniqueConstraint, ForeignKey, CheckConstraint, Column,
40 Boolean, String, Unicode, UnicodeText, DateTime, Integer, LargeBinary,
41 Text, Float, PickleType)
42 from sqlalchemy.sql.expression import true, false
43 from sqlalchemy.sql.functions import coalesce, count # pragma: no cover
44 from sqlalchemy.orm import (
45 relationship, joinedload, class_mapper, validates, aliased)
46 from sqlalchemy.ext.declarative import declared_attr
47 from sqlalchemy.ext.hybrid import hybrid_property
48 from sqlalchemy.exc import IntegrityError # pragma: no cover
49 from sqlalchemy.dialects.mysql import LONGTEXT
50 from zope.cachedescriptors.property import Lazy as LazyProperty
51
52 from pyramid.threadlocal import get_current_request
53
54 from rhodecode.translation import _
55 from rhodecode.lib.vcs import get_vcs_instance
56 from rhodecode.lib.vcs.backends.base import EmptyCommit, Reference
57 from rhodecode.lib.utils2 import (
58 str2bool, safe_str, get_commit_safe, safe_unicode, sha1_safe,
59 time_to_datetime, aslist, Optional, safe_int, get_clone_url, AttributeDict,
60 glob2re, StrictAttributeDict, cleaned_uri)
61 from rhodecode.lib.jsonalchemy import MutationObj, MutationList, JsonType, \
62 JsonRaw
63 from rhodecode.lib.ext_json import json
64 from rhodecode.lib.caching_query import FromCache
65 from rhodecode.lib.encrypt import AESCipher
66
67 from rhodecode.model.meta import Base, Session
68
69 URL_SEP = '/'
70 log = logging.getLogger(__name__)
71
72 # =============================================================================
73 # BASE CLASSES
74 # =============================================================================
75
76 # this is propagated from .ini file rhodecode.encrypted_values.secret or
77 # beaker.session.secret if first is not set.
78 # and initialized at environment.py
79 ENCRYPTION_KEY = None
80
81 # used to sort permissions by types, '#' used here is not allowed to be in
82 # usernames, and it's very early in sorted string.printable table.
83 PERMISSION_TYPE_SORT = {
84 'admin': '####',
85 'write': '###',
86 'read': '##',
87 'none': '#',
88 }
89
90
91 def display_user_sort(obj):
92 """
93 Sort function used to sort permissions in .permissions() function of
94 Repository, RepoGroup, UserGroup. Also it put the default user in front
95 of all other resources
96 """
97
98 if obj.username == User.DEFAULT_USER:
99 return '#####'
100 prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '')
101 return prefix + obj.username
102
103
104 def display_user_group_sort(obj):
105 """
106 Sort function used to sort permissions in .permissions() function of
107 Repository, RepoGroup, UserGroup. Also it put the default user in front
108 of all other resources
109 """
110
111 prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '')
112 return prefix + obj.users_group_name
113
114
115 def _hash_key(k):
116 return sha1_safe(k)
117
118
119 def in_filter_generator(qry, items, limit=500):
120 """
121 Splits IN() into multiple with OR
122 e.g.::
123 cnt = Repository.query().filter(
124 or_(
125 *in_filter_generator(Repository.repo_id, range(100000))
126 )).count()
127 """
128 if not items:
129 # empty list will cause empty query which might cause security issues
130 # this can lead to hidden unpleasant results
131 items = [-1]
132
133 parts = []
134 for chunk in xrange(0, len(items), limit):
135 parts.append(
136 qry.in_(items[chunk: chunk + limit])
137 )
138
139 return parts
140
141
142 base_table_args = {
143 'extend_existing': True,
144 'mysql_engine': 'InnoDB',
145 'mysql_charset': 'utf8',
146 'sqlite_autoincrement': True
147 }
148
149
150 class EncryptedTextValue(TypeDecorator):
151 """
152 Special column for encrypted long text data, use like::
153
154 value = Column("encrypted_value", EncryptedValue(), nullable=False)
155
156 This column is intelligent so if value is in unencrypted form it return
157 unencrypted form, but on save it always encrypts
158 """
159 impl = Text
160
161 def process_bind_param(self, value, dialect):
162 if not value:
163 return value
164 if value.startswith('enc$aes$') or value.startswith('enc$aes_hmac$'):
165 # protect against double encrypting if someone manually starts
166 # doing
167 raise ValueError('value needs to be in unencrypted format, ie. '
168 'not starting with enc$aes')
169 return 'enc$aes_hmac$%s' % AESCipher(
170 ENCRYPTION_KEY, hmac=True).encrypt(value)
171
172 def process_result_value(self, value, dialect):
173 import rhodecode
174
175 if not value:
176 return value
177
178 parts = value.split('$', 3)
179 if not len(parts) == 3:
180 # probably not encrypted values
181 return value
182 else:
183 if parts[0] != 'enc':
184 # parts ok but without our header ?
185 return value
186 enc_strict_mode = str2bool(rhodecode.CONFIG.get(
187 'rhodecode.encrypted_values.strict') or True)
188 # at that stage we know it's our encryption
189 if parts[1] == 'aes':
190 decrypted_data = AESCipher(ENCRYPTION_KEY).decrypt(parts[2])
191 elif parts[1] == 'aes_hmac':
192 decrypted_data = AESCipher(
193 ENCRYPTION_KEY, hmac=True,
194 strict_verification=enc_strict_mode).decrypt(parts[2])
195 else:
196 raise ValueError(
197 'Encryption type part is wrong, must be `aes` '
198 'or `aes_hmac`, got `%s` instead' % (parts[1]))
199 return decrypted_data
200
201
202 class BaseModel(object):
203 """
204 Base Model for all classes
205 """
206
207 @classmethod
208 def _get_keys(cls):
209 """return column names for this model """
210 return class_mapper(cls).c.keys()
211
212 def get_dict(self):
213 """
214 return dict with keys and values corresponding
215 to this model data """
216
217 d = {}
218 for k in self._get_keys():
219 d[k] = getattr(self, k)
220
221 # also use __json__() if present to get additional fields
222 _json_attr = getattr(self, '__json__', None)
223 if _json_attr:
224 # update with attributes from __json__
225 if callable(_json_attr):
226 _json_attr = _json_attr()
227 for k, val in _json_attr.iteritems():
228 d[k] = val
229 return d
230
231 def get_appstruct(self):
232 """return list with keys and values tuples corresponding
233 to this model data """
234
235 lst = []
236 for k in self._get_keys():
237 lst.append((k, getattr(self, k),))
238 return lst
239
240 def populate_obj(self, populate_dict):
241 """populate model with data from given populate_dict"""
242
243 for k in self._get_keys():
244 if k in populate_dict:
245 setattr(self, k, populate_dict[k])
246
247 @classmethod
248 def query(cls):
249 return Session().query(cls)
250
251 @classmethod
252 def get(cls, id_):
253 if id_:
254 return cls.query().get(id_)
255
256 @classmethod
257 def get_or_404(cls, id_):
258 from pyramid.httpexceptions import HTTPNotFound
259
260 try:
261 id_ = int(id_)
262 except (TypeError, ValueError):
263 raise HTTPNotFound()
264
265 res = cls.query().get(id_)
266 if not res:
267 raise HTTPNotFound()
268 return res
269
270 @classmethod
271 def getAll(cls):
272 # deprecated and left for backward compatibility
273 return cls.get_all()
274
275 @classmethod
276 def get_all(cls):
277 return cls.query().all()
278
279 @classmethod
280 def delete(cls, id_):
281 obj = cls.query().get(id_)
282 Session().delete(obj)
283
284 @classmethod
285 def identity_cache(cls, session, attr_name, value):
286 exist_in_session = []
287 for (item_cls, pkey), instance in session.identity_map.items():
288 if cls == item_cls and getattr(instance, attr_name) == value:
289 exist_in_session.append(instance)
290 if exist_in_session:
291 if len(exist_in_session) == 1:
292 return exist_in_session[0]
293 log.exception(
294 'multiple objects with attr %s and '
295 'value %s found with same name: %r',
296 attr_name, value, exist_in_session)
297
298 def __repr__(self):
299 if hasattr(self, '__unicode__'):
300 # python repr needs to return str
301 try:
302 return safe_str(self.__unicode__())
303 except UnicodeDecodeError:
304 pass
305 return '<DB:%s>' % (self.__class__.__name__)
306
307
308 class RhodeCodeSetting(Base, BaseModel):
309 __tablename__ = 'rhodecode_settings'
310 __table_args__ = (
311 UniqueConstraint('app_settings_name'),
312 base_table_args
313 )
314
315 SETTINGS_TYPES = {
316 'str': safe_str,
317 'int': safe_int,
318 'unicode': safe_unicode,
319 'bool': str2bool,
320 'list': functools.partial(aslist, sep=',')
321 }
322 DEFAULT_UPDATE_URL = 'https://rhodecode.com/api/v1/info/versions'
323 GLOBAL_CONF_KEY = 'app_settings'
324
325 app_settings_id = Column("app_settings_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
326 app_settings_name = Column("app_settings_name", String(255), nullable=True, unique=None, default=None)
327 _app_settings_value = Column("app_settings_value", String(4096), nullable=True, unique=None, default=None)
328 _app_settings_type = Column("app_settings_type", String(255), nullable=True, unique=None, default=None)
329
330 def __init__(self, key='', val='', type='unicode'):
331 self.app_settings_name = key
332 self.app_settings_type = type
333 self.app_settings_value = val
334
335 @validates('_app_settings_value')
336 def validate_settings_value(self, key, val):
337 assert type(val) == unicode
338 return val
339
340 @hybrid_property
341 def app_settings_value(self):
342 v = self._app_settings_value
343 _type = self.app_settings_type
344 if _type:
345 _type = self.app_settings_type.split('.')[0]
346 # decode the encrypted value
347 if 'encrypted' in self.app_settings_type:
348 cipher = EncryptedTextValue()
349 v = safe_unicode(cipher.process_result_value(v, None))
350
351 converter = self.SETTINGS_TYPES.get(_type) or \
352 self.SETTINGS_TYPES['unicode']
353 return converter(v)
354
355 @app_settings_value.setter
356 def app_settings_value(self, val):
357 """
358 Setter that will always make sure we use unicode in app_settings_value
359
360 :param val:
361 """
362 val = safe_unicode(val)
363 # encode the encrypted value
364 if 'encrypted' in self.app_settings_type:
365 cipher = EncryptedTextValue()
366 val = safe_unicode(cipher.process_bind_param(val, None))
367 self._app_settings_value = val
368
369 @hybrid_property
370 def app_settings_type(self):
371 return self._app_settings_type
372
373 @app_settings_type.setter
374 def app_settings_type(self, val):
375 if val.split('.')[0] not in self.SETTINGS_TYPES:
376 raise Exception('type must be one of %s got %s'
377 % (self.SETTINGS_TYPES.keys(), val))
378 self._app_settings_type = val
379
380 @classmethod
381 def get_by_prefix(cls, prefix):
382 return RhodeCodeSetting.query()\
383 .filter(RhodeCodeSetting.app_settings_name.startswith(prefix))\
384 .all()
385
386 def __unicode__(self):
387 return u"<%s('%s:%s[%s]')>" % (
388 self.__class__.__name__,
389 self.app_settings_name, self.app_settings_value,
390 self.app_settings_type
391 )
392
393
394 class RhodeCodeUi(Base, BaseModel):
395 __tablename__ = 'rhodecode_ui'
396 __table_args__ = (
397 UniqueConstraint('ui_key'),
398 base_table_args
399 )
400
401 HOOK_REPO_SIZE = 'changegroup.repo_size'
402 # HG
403 HOOK_PRE_PULL = 'preoutgoing.pre_pull'
404 HOOK_PULL = 'outgoing.pull_logger'
405 HOOK_PRE_PUSH = 'prechangegroup.pre_push'
406 HOOK_PRETX_PUSH = 'pretxnchangegroup.pre_push'
407 HOOK_PUSH = 'changegroup.push_logger'
408 HOOK_PUSH_KEY = 'pushkey.key_push'
409
410 # TODO: johbo: Unify way how hooks are configured for git and hg,
411 # git part is currently hardcoded.
412
413 # SVN PATTERNS
414 SVN_BRANCH_ID = 'vcs_svn_branch'
415 SVN_TAG_ID = 'vcs_svn_tag'
416
417 ui_id = Column(
418 "ui_id", Integer(), nullable=False, unique=True, default=None,
419 primary_key=True)
420 ui_section = Column(
421 "ui_section", String(255), nullable=True, unique=None, default=None)
422 ui_key = Column(
423 "ui_key", String(255), nullable=True, unique=None, default=None)
424 ui_value = Column(
425 "ui_value", String(255), nullable=True, unique=None, default=None)
426 ui_active = Column(
427 "ui_active", Boolean(), nullable=True, unique=None, default=True)
428
429 def __repr__(self):
430 return '<%s[%s]%s=>%s]>' % (self.__class__.__name__, self.ui_section,
431 self.ui_key, self.ui_value)
432
433
434 class RepoRhodeCodeSetting(Base, BaseModel):
435 __tablename__ = 'repo_rhodecode_settings'
436 __table_args__ = (
437 UniqueConstraint(
438 'app_settings_name', 'repository_id',
439 name='uq_repo_rhodecode_setting_name_repo_id'),
440 base_table_args
441 )
442
443 repository_id = Column(
444 "repository_id", Integer(), ForeignKey('repositories.repo_id'),
445 nullable=False)
446 app_settings_id = Column(
447 "app_settings_id", Integer(), nullable=False, unique=True,
448 default=None, primary_key=True)
449 app_settings_name = Column(
450 "app_settings_name", String(255), nullable=True, unique=None,
451 default=None)
452 _app_settings_value = Column(
453 "app_settings_value", String(4096), nullable=True, unique=None,
454 default=None)
455 _app_settings_type = Column(
456 "app_settings_type", String(255), nullable=True, unique=None,
457 default=None)
458
459 repository = relationship('Repository')
460
461 def __init__(self, repository_id, key='', val='', type='unicode'):
462 self.repository_id = repository_id
463 self.app_settings_name = key
464 self.app_settings_type = type
465 self.app_settings_value = val
466
467 @validates('_app_settings_value')
468 def validate_settings_value(self, key, val):
469 assert type(val) == unicode
470 return val
471
472 @hybrid_property
473 def app_settings_value(self):
474 v = self._app_settings_value
475 type_ = self.app_settings_type
476 SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES
477 converter = SETTINGS_TYPES.get(type_) or SETTINGS_TYPES['unicode']
478 return converter(v)
479
480 @app_settings_value.setter
481 def app_settings_value(self, val):
482 """
483 Setter that will always make sure we use unicode in app_settings_value
484
485 :param val:
486 """
487 self._app_settings_value = safe_unicode(val)
488
489 @hybrid_property
490 def app_settings_type(self):
491 return self._app_settings_type
492
493 @app_settings_type.setter
494 def app_settings_type(self, val):
495 SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES
496 if val not in SETTINGS_TYPES:
497 raise Exception('type must be one of %s got %s'
498 % (SETTINGS_TYPES.keys(), val))
499 self._app_settings_type = val
500
501 def __unicode__(self):
502 return u"<%s('%s:%s:%s[%s]')>" % (
503 self.__class__.__name__, self.repository.repo_name,
504 self.app_settings_name, self.app_settings_value,
505 self.app_settings_type
506 )
507
508
509 class RepoRhodeCodeUi(Base, BaseModel):
510 __tablename__ = 'repo_rhodecode_ui'
511 __table_args__ = (
512 UniqueConstraint(
513 'repository_id', 'ui_section', 'ui_key',
514 name='uq_repo_rhodecode_ui_repository_id_section_key'),
515 base_table_args
516 )
517
518 repository_id = Column(
519 "repository_id", Integer(), ForeignKey('repositories.repo_id'),
520 nullable=False)
521 ui_id = Column(
522 "ui_id", Integer(), nullable=False, unique=True, default=None,
523 primary_key=True)
524 ui_section = Column(
525 "ui_section", String(255), nullable=True, unique=None, default=None)
526 ui_key = Column(
527 "ui_key", String(255), nullable=True, unique=None, default=None)
528 ui_value = Column(
529 "ui_value", String(255), nullable=True, unique=None, default=None)
530 ui_active = Column(
531 "ui_active", Boolean(), nullable=True, unique=None, default=True)
532
533 repository = relationship('Repository')
534
535 def __repr__(self):
536 return '<%s[%s:%s]%s=>%s]>' % (
537 self.__class__.__name__, self.repository.repo_name,
538 self.ui_section, self.ui_key, self.ui_value)
539
540
541 class User(Base, BaseModel):
542 __tablename__ = 'users'
543 __table_args__ = (
544 UniqueConstraint('username'), UniqueConstraint('email'),
545 Index('u_username_idx', 'username'),
546 Index('u_email_idx', 'email'),
547 base_table_args
548 )
549
550 DEFAULT_USER = 'default'
551 DEFAULT_USER_EMAIL = 'anonymous@rhodecode.org'
552 DEFAULT_GRAVATAR_URL = 'https://secure.gravatar.com/avatar/{md5email}?d=identicon&s={size}'
553
554 user_id = Column("user_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
555 username = Column("username", String(255), nullable=True, unique=None, default=None)
556 password = Column("password", String(255), nullable=True, unique=None, default=None)
557 active = Column("active", Boolean(), nullable=True, unique=None, default=True)
558 admin = Column("admin", Boolean(), nullable=True, unique=None, default=False)
559 name = Column("firstname", String(255), nullable=True, unique=None, default=None)
560 lastname = Column("lastname", String(255), nullable=True, unique=None, default=None)
561 _email = Column("email", String(255), nullable=True, unique=None, default=None)
562 last_login = Column("last_login", DateTime(timezone=False), nullable=True, unique=None, default=None)
563 last_activity = Column('last_activity', DateTime(timezone=False), nullable=True, unique=None, default=None)
564
565 extern_type = Column("extern_type", String(255), nullable=True, unique=None, default=None)
566 extern_name = Column("extern_name", String(255), nullable=True, unique=None, default=None)
567 _api_key = Column("api_key", String(255), nullable=True, unique=None, default=None)
568 inherit_default_permissions = Column("inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)
569 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
570 _user_data = Column("user_data", LargeBinary(), nullable=True) # JSON data
571
572 user_log = relationship('UserLog')
573 user_perms = relationship('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id", cascade='all')
574
575 repositories = relationship('Repository')
576 repository_groups = relationship('RepoGroup')
577 user_groups = relationship('UserGroup')
578
579 user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all')
580 followings = relationship('UserFollowing', primaryjoin='UserFollowing.user_id==User.user_id', cascade='all')
581
582 repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all')
583 repo_group_to_perm = relationship('UserRepoGroupToPerm', primaryjoin='UserRepoGroupToPerm.user_id==User.user_id', cascade='all')
584 user_group_to_perm = relationship('UserUserGroupToPerm', primaryjoin='UserUserGroupToPerm.user_id==User.user_id', cascade='all')
585
586 group_member = relationship('UserGroupMember', cascade='all')
587
588 notifications = relationship('UserNotification', cascade='all')
589 # notifications assigned to this user
590 user_created_notifications = relationship('Notification', cascade='all')
591 # comments created by this user
592 user_comments = relationship('ChangesetComment', cascade='all')
593 # user profile extra info
594 user_emails = relationship('UserEmailMap', cascade='all')
595 user_ip_map = relationship('UserIpMap', cascade='all')
596 user_auth_tokens = relationship('UserApiKeys', cascade='all')
597 user_ssh_keys = relationship('UserSshKeys', cascade='all')
598
599 # gists
600 user_gists = relationship('Gist', cascade='all')
601 # user pull requests
602 user_pull_requests = relationship('PullRequest', cascade='all')
603 # external identities
604 extenal_identities = relationship(
605 'ExternalIdentity',
606 primaryjoin="User.user_id==ExternalIdentity.local_user_id",
607 cascade='all')
608 # review rules
609 user_review_rules = relationship('RepoReviewRuleUser', cascade='all')
610
611 def __unicode__(self):
612 return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
613 self.user_id, self.username)
614
615 @hybrid_property
616 def email(self):
617 return self._email
618
619 @email.setter
620 def email(self, val):
621 self._email = val.lower() if val else None
622
623 @hybrid_property
624 def first_name(self):
625 from rhodecode.lib import helpers as h
626 if self.name:
627 return h.escape(self.name)
628 return self.name
629
630 @hybrid_property
631 def last_name(self):
632 from rhodecode.lib import helpers as h
633 if self.lastname:
634 return h.escape(self.lastname)
635 return self.lastname
636
637 @hybrid_property
638 def api_key(self):
639 """
640 Fetch if exist an auth-token with role ALL connected to this user
641 """
642 user_auth_token = UserApiKeys.query()\
643 .filter(UserApiKeys.user_id == self.user_id)\
644 .filter(or_(UserApiKeys.expires == -1,
645 UserApiKeys.expires >= time.time()))\
646 .filter(UserApiKeys.role == UserApiKeys.ROLE_ALL).first()
647 if user_auth_token:
648 user_auth_token = user_auth_token.api_key
649
650 return user_auth_token
651
652 @api_key.setter
653 def api_key(self, val):
654 # don't allow to set API key this is deprecated for now
655 self._api_key = None
656
657 @property
658 def reviewer_pull_requests(self):
659 return PullRequestReviewers.query() \
660 .options(joinedload(PullRequestReviewers.pull_request)) \
661 .filter(PullRequestReviewers.user_id == self.user_id) \
662 .all()
663
664 @property
665 def firstname(self):
666 # alias for future
667 return self.name
668
669 @property
670 def emails(self):
671 other = UserEmailMap.query()\
672 .filter(UserEmailMap.user == self) \
673 .order_by(UserEmailMap.email_id.asc()) \
674 .all()
675 return [self.email] + [x.email for x in other]
676
677 @property
678 def auth_tokens(self):
679 auth_tokens = self.get_auth_tokens()
680 return [x.api_key for x in auth_tokens]
681
682 def get_auth_tokens(self):
683 return UserApiKeys.query()\
684 .filter(UserApiKeys.user == self)\
685 .order_by(UserApiKeys.user_api_key_id.asc())\
686 .all()
687
688 @LazyProperty
689 def feed_token(self):
690 return self.get_feed_token()
691
692 def get_feed_token(self, cache=True):
693 feed_tokens = UserApiKeys.query()\
694 .filter(UserApiKeys.user == self)\
695 .filter(UserApiKeys.role == UserApiKeys.ROLE_FEED)
696 if cache:
697 feed_tokens = feed_tokens.options(
698 FromCache("sql_cache_short", "get_user_feed_token_%s" % self.user_id))
699
700 feed_tokens = feed_tokens.all()
701 if feed_tokens:
702 return feed_tokens[0].api_key
703 return 'NO_FEED_TOKEN_AVAILABLE'
704
705 @classmethod
706 def get(cls, user_id, cache=False):
707 if not user_id:
708 return
709
710 user = cls.query()
711 if cache:
712 user = user.options(
713 FromCache("sql_cache_short", "get_users_%s" % user_id))
714 return user.get(user_id)
715
716 @classmethod
717 def extra_valid_auth_tokens(cls, user, role=None):
718 tokens = UserApiKeys.query().filter(UserApiKeys.user == user)\
719 .filter(or_(UserApiKeys.expires == -1,
720 UserApiKeys.expires >= time.time()))
721 if role:
722 tokens = tokens.filter(or_(UserApiKeys.role == role,
723 UserApiKeys.role == UserApiKeys.ROLE_ALL))
724 return tokens.all()
725
726 def authenticate_by_token(self, auth_token, roles=None, scope_repo_id=None):
727 from rhodecode.lib import auth
728
729 log.debug('Trying to authenticate user: %s via auth-token, '
730 'and roles: %s', self, roles)
731
732 if not auth_token:
733 return False
734
735 crypto_backend = auth.crypto_backend()
736
737 roles = (roles or []) + [UserApiKeys.ROLE_ALL]
738 tokens_q = UserApiKeys.query()\
739 .filter(UserApiKeys.user_id == self.user_id)\
740 .filter(or_(UserApiKeys.expires == -1,
741 UserApiKeys.expires >= time.time()))
742
743 tokens_q = tokens_q.filter(UserApiKeys.role.in_(roles))
744
745 plain_tokens = []
746 hash_tokens = []
747
748 user_tokens = tokens_q.all()
749 log.debug('Found %s user tokens to check for authentication', len(user_tokens))
750 for token in user_tokens:
751 log.debug('AUTH_TOKEN: checking if user token with id `%s` matches',
752 token.user_api_key_id)
753 # verify scope first, since it's way faster than hash calculation of
754 # encrypted tokens
755 if token.repo_id:
756 # token has a scope, we need to verify it
757 if scope_repo_id != token.repo_id:
758 log.debug(
759 'AUTH_TOKEN: scope mismatch, token has a set repo scope: %s, '
760 'and calling scope is:%s, skipping further checks',
761 token.repo, scope_repo_id)
762 # token has a scope, and it doesn't match, skip token
763 continue
764
765 if token.api_key.startswith(crypto_backend.ENC_PREF):
766 hash_tokens.append(token.api_key)
767 else:
768 plain_tokens.append(token.api_key)
769
770 is_plain_match = auth_token in plain_tokens
771 if is_plain_match:
772 return True
773
774 for hashed in hash_tokens:
775 # NOTE(marcink): this is expensive to calculate, but most secure
776 match = crypto_backend.hash_check(auth_token, hashed)
777 if match:
778 return True
779
780 return False
781
782 @property
783 def ip_addresses(self):
784 ret = UserIpMap.query().filter(UserIpMap.user == self).all()
785 return [x.ip_addr for x in ret]
786
787 @property
788 def username_and_name(self):
789 return '%s (%s %s)' % (self.username, self.first_name, self.last_name)
790
791 @property
792 def username_or_name_or_email(self):
793 full_name = self.full_name if self.full_name is not ' ' else None
794 return self.username or full_name or self.email
795
796 @property
797 def full_name(self):
798 return '%s %s' % (self.first_name, self.last_name)
799
800 @property
801 def full_name_or_username(self):
802 return ('%s %s' % (self.first_name, self.last_name)
803 if (self.first_name and self.last_name) else self.username)
804
805 @property
806 def full_contact(self):
807 return '%s %s <%s>' % (self.first_name, self.last_name, self.email)
808
809 @property
810 def short_contact(self):
811 return '%s %s' % (self.first_name, self.last_name)
812
813 @property
814 def is_admin(self):
815 return self.admin
816
817 def AuthUser(self, **kwargs):
818 """
819 Returns instance of AuthUser for this user
820 """
821 from rhodecode.lib.auth import AuthUser
822 return AuthUser(user_id=self.user_id, username=self.username, **kwargs)
823
824 @hybrid_property
825 def user_data(self):
826 if not self._user_data:
827 return {}
828
829 try:
830 return json.loads(self._user_data)
831 except TypeError:
832 return {}
833
834 @user_data.setter
835 def user_data(self, val):
836 if not isinstance(val, dict):
837 raise Exception('user_data must be dict, got %s' % type(val))
838 try:
839 self._user_data = json.dumps(val)
840 except Exception:
841 log.error(traceback.format_exc())
842
843 @classmethod
844 def get_by_username(cls, username, case_insensitive=False,
845 cache=False, identity_cache=False):
846 session = Session()
847
848 if case_insensitive:
849 q = cls.query().filter(
850 func.lower(cls.username) == func.lower(username))
851 else:
852 q = cls.query().filter(cls.username == username)
853
854 if cache:
855 if identity_cache:
856 val = cls.identity_cache(session, 'username', username)
857 if val:
858 return val
859 else:
860 cache_key = "get_user_by_name_%s" % _hash_key(username)
861 q = q.options(
862 FromCache("sql_cache_short", cache_key))
863
864 return q.scalar()
865
866 @classmethod
867 def get_by_auth_token(cls, auth_token, cache=False):
868 q = UserApiKeys.query()\
869 .filter(UserApiKeys.api_key == auth_token)\
870 .filter(or_(UserApiKeys.expires == -1,
871 UserApiKeys.expires >= time.time()))
872 if cache:
873 q = q.options(
874 FromCache("sql_cache_short", "get_auth_token_%s" % auth_token))
875
876 match = q.first()
877 if match:
878 return match.user
879
880 @classmethod
881 def get_by_email(cls, email, case_insensitive=False, cache=False):
882
883 if case_insensitive:
884 q = cls.query().filter(func.lower(cls.email) == func.lower(email))
885
886 else:
887 q = cls.query().filter(cls.email == email)
888
889 email_key = _hash_key(email)
890 if cache:
891 q = q.options(
892 FromCache("sql_cache_short", "get_email_key_%s" % email_key))
893
894 ret = q.scalar()
895 if ret is None:
896 q = UserEmailMap.query()
897 # try fetching in alternate email map
898 if case_insensitive:
899 q = q.filter(func.lower(UserEmailMap.email) == func.lower(email))
900 else:
901 q = q.filter(UserEmailMap.email == email)
902 q = q.options(joinedload(UserEmailMap.user))
903 if cache:
904 q = q.options(
905 FromCache("sql_cache_short", "get_email_map_key_%s" % email_key))
906 ret = getattr(q.scalar(), 'user', None)
907
908 return ret
909
910 @classmethod
911 def get_from_cs_author(cls, author):
912 """
913 Tries to get User objects out of commit author string
914
915 :param author:
916 """
917 from rhodecode.lib.helpers import email, author_name
918 # Valid email in the attribute passed, see if they're in the system
919 _email = email(author)
920 if _email:
921 user = cls.get_by_email(_email, case_insensitive=True)
922 if user:
923 return user
924 # Maybe we can match by username?
925 _author = author_name(author)
926 user = cls.get_by_username(_author, case_insensitive=True)
927 if user:
928 return user
929
930 def update_userdata(self, **kwargs):
931 usr = self
932 old = usr.user_data
933 old.update(**kwargs)
934 usr.user_data = old
935 Session().add(usr)
936 log.debug('updated userdata with ', kwargs)
937
938 def update_lastlogin(self):
939 """Update user lastlogin"""
940 self.last_login = datetime.datetime.now()
941 Session().add(self)
942 log.debug('updated user %s lastlogin', self.username)
943
944 def update_password(self, new_password):
945 from rhodecode.lib.auth import get_crypt_password
946
947 self.password = get_crypt_password(new_password)
948 Session().add(self)
949
950 @classmethod
951 def get_first_super_admin(cls):
952 user = User.query()\
953 .filter(User.admin == true()) \
954 .order_by(User.user_id.asc()) \
955 .first()
956
957 if user is None:
958 raise Exception('FATAL: Missing administrative account!')
959 return user
960
961 @classmethod
962 def get_all_super_admins(cls):
963 """
964 Returns all admin accounts sorted by username
965 """
966 return User.query().filter(User.admin == true())\
967 .order_by(User.username.asc()).all()
968
969 @classmethod
970 def get_default_user(cls, cache=False, refresh=False):
971 user = User.get_by_username(User.DEFAULT_USER, cache=cache)
972 if user is None:
973 raise Exception('FATAL: Missing default account!')
974 if refresh:
975 # The default user might be based on outdated state which
976 # has been loaded from the cache.
977 # A call to refresh() ensures that the
978 # latest state from the database is used.
979 Session().refresh(user)
980 return user
981
982 def _get_default_perms(self, user, suffix=''):
983 from rhodecode.model.permission import PermissionModel
984 return PermissionModel().get_default_perms(user.user_perms, suffix)
985
986 def get_default_perms(self, suffix=''):
987 return self._get_default_perms(self, suffix)
988
989 def get_api_data(self, include_secrets=False, details='full'):
990 """
991 Common function for generating user related data for API
992
993 :param include_secrets: By default secrets in the API data will be replaced
994 by a placeholder value to prevent exposing this data by accident. In case
995 this data shall be exposed, set this flag to ``True``.
996
997 :param details: details can be 'basic|full' basic gives only a subset of
998 the available user information that includes user_id, name and emails.
999 """
1000 user = self
1001 user_data = self.user_data
1002 data = {
1003 'user_id': user.user_id,
1004 'username': user.username,
1005 'firstname': user.name,
1006 'lastname': user.lastname,
1007 'email': user.email,
1008 'emails': user.emails,
1009 }
1010 if details == 'basic':
1011 return data
1012
1013 auth_token_length = 40
1014 auth_token_replacement = '*' * auth_token_length
1015
1016 extras = {
1017 'auth_tokens': [auth_token_replacement],
1018 'active': user.active,
1019 'admin': user.admin,
1020 'extern_type': user.extern_type,
1021 'extern_name': user.extern_name,
1022 'last_login': user.last_login,
1023 'last_activity': user.last_activity,
1024 'ip_addresses': user.ip_addresses,
1025 'language': user_data.get('language')
1026 }
1027 data.update(extras)
1028
1029 if include_secrets:
1030 data['auth_tokens'] = user.auth_tokens
1031 return data
1032
1033 def __json__(self):
1034 data = {
1035 'full_name': self.full_name,
1036 'full_name_or_username': self.full_name_or_username,
1037 'short_contact': self.short_contact,
1038 'full_contact': self.full_contact,
1039 }
1040 data.update(self.get_api_data())
1041 return data
1042
1043
1044 class UserApiKeys(Base, BaseModel):
1045 __tablename__ = 'user_api_keys'
1046 __table_args__ = (
1047 Index('uak_api_key_idx', 'api_key', unique=True),
1048 Index('uak_api_key_expires_idx', 'api_key', 'expires'),
1049 base_table_args
1050 )
1051 __mapper_args__ = {}
1052
1053 # ApiKey role
1054 ROLE_ALL = 'token_role_all'
1055 ROLE_HTTP = 'token_role_http'
1056 ROLE_VCS = 'token_role_vcs'
1057 ROLE_API = 'token_role_api'
1058 ROLE_FEED = 'token_role_feed'
1059 ROLE_PASSWORD_RESET = 'token_password_reset'
1060
1061 ROLES = [ROLE_ALL, ROLE_HTTP, ROLE_VCS, ROLE_API, ROLE_FEED]
1062
1063 user_api_key_id = Column("user_api_key_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1064 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
1065 api_key = Column("api_key", String(255), nullable=False, unique=True)
1066 description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
1067 expires = Column('expires', Float(53), nullable=False)
1068 role = Column('role', String(255), nullable=True)
1069 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
1070
1071 # scope columns
1072 repo_id = Column(
1073 'repo_id', Integer(), ForeignKey('repositories.repo_id'),
1074 nullable=True, unique=None, default=None)
1075 repo = relationship('Repository', lazy='joined')
1076
1077 repo_group_id = Column(
1078 'repo_group_id', Integer(), ForeignKey('groups.group_id'),
1079 nullable=True, unique=None, default=None)
1080 repo_group = relationship('RepoGroup', lazy='joined')
1081
1082 user = relationship('User', lazy='joined')
1083
1084 def __unicode__(self):
1085 return u"<%s('%s')>" % (self.__class__.__name__, self.role)
1086
1087 def __json__(self):
1088 data = {
1089 'auth_token': self.api_key,
1090 'role': self.role,
1091 'scope': self.scope_humanized,
1092 'expired': self.expired
1093 }
1094 return data
1095
1096 def get_api_data(self, include_secrets=False):
1097 data = self.__json__()
1098 if include_secrets:
1099 return data
1100 else:
1101 data['auth_token'] = self.token_obfuscated
1102 return data
1103
1104 @hybrid_property
1105 def description_safe(self):
1106 from rhodecode.lib import helpers as h
1107 return h.escape(self.description)
1108
1109 @property
1110 def expired(self):
1111 if self.expires == -1:
1112 return False
1113 return time.time() > self.expires
1114
1115 @classmethod
1116 def _get_role_name(cls, role):
1117 return {
1118 cls.ROLE_ALL: _('all'),
1119 cls.ROLE_HTTP: _('http/web interface'),
1120 cls.ROLE_VCS: _('vcs (git/hg/svn protocol)'),
1121 cls.ROLE_API: _('api calls'),
1122 cls.ROLE_FEED: _('feed access'),
1123 }.get(role, role)
1124
1125 @property
1126 def role_humanized(self):
1127 return self._get_role_name(self.role)
1128
1129 def _get_scope(self):
1130 if self.repo:
1131 return repr(self.repo)
1132 if self.repo_group:
1133 return repr(self.repo_group) + ' (recursive)'
1134 return 'global'
1135
1136 @property
1137 def scope_humanized(self):
1138 return self._get_scope()
1139
1140 @property
1141 def token_obfuscated(self):
1142 if self.api_key:
1143 return self.api_key[:4] + "****"
1144
1145
1146 class UserEmailMap(Base, BaseModel):
1147 __tablename__ = 'user_email_map'
1148 __table_args__ = (
1149 Index('uem_email_idx', 'email'),
1150 UniqueConstraint('email'),
1151 base_table_args
1152 )
1153 __mapper_args__ = {}
1154
1155 email_id = Column("email_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1156 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
1157 _email = Column("email", String(255), nullable=True, unique=False, default=None)
1158 user = relationship('User', lazy='joined')
1159
1160 @validates('_email')
1161 def validate_email(self, key, email):
1162 # check if this email is not main one
1163 main_email = Session().query(User).filter(User.email == email).scalar()
1164 if main_email is not None:
1165 raise AttributeError('email %s is present is user table' % email)
1166 return email
1167
1168 @hybrid_property
1169 def email(self):
1170 return self._email
1171
1172 @email.setter
1173 def email(self, val):
1174 self._email = val.lower() if val else None
1175
1176
1177 class UserIpMap(Base, BaseModel):
1178 __tablename__ = 'user_ip_map'
1179 __table_args__ = (
1180 UniqueConstraint('user_id', 'ip_addr'),
1181 base_table_args
1182 )
1183 __mapper_args__ = {}
1184
1185 ip_id = Column("ip_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1186 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
1187 ip_addr = Column("ip_addr", String(255), nullable=True, unique=False, default=None)
1188 active = Column("active", Boolean(), nullable=True, unique=None, default=True)
1189 description = Column("description", String(10000), nullable=True, unique=None, default=None)
1190 user = relationship('User', lazy='joined')
1191
1192 @hybrid_property
1193 def description_safe(self):
1194 from rhodecode.lib import helpers as h
1195 return h.escape(self.description)
1196
1197 @classmethod
1198 def _get_ip_range(cls, ip_addr):
1199 net = ipaddress.ip_network(safe_unicode(ip_addr), strict=False)
1200 return [str(net.network_address), str(net.broadcast_address)]
1201
1202 def __json__(self):
1203 return {
1204 'ip_addr': self.ip_addr,
1205 'ip_range': self._get_ip_range(self.ip_addr),
1206 }
1207
1208 def __unicode__(self):
1209 return u"<%s('user_id:%s=>%s')>" % (self.__class__.__name__,
1210 self.user_id, self.ip_addr)
1211
1212
1213 class UserSshKeys(Base, BaseModel):
1214 __tablename__ = 'user_ssh_keys'
1215 __table_args__ = (
1216 Index('usk_ssh_key_fingerprint_idx', 'ssh_key_fingerprint'),
1217
1218 UniqueConstraint('ssh_key_fingerprint'),
1219
1220 base_table_args
1221 )
1222 __mapper_args__ = {}
1223
1224 ssh_key_id = Column('ssh_key_id', Integer(), nullable=False, unique=True, default=None, primary_key=True)
1225 ssh_key_data = Column('ssh_key_data', String(10240), nullable=False, unique=None, default=None)
1226 ssh_key_fingerprint = Column('ssh_key_fingerprint', String(255), nullable=False, unique=None, default=None)
1227
1228 description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
1229
1230 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
1231 accessed_on = Column('accessed_on', DateTime(timezone=False), nullable=True, default=None)
1232 user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
1233
1234 user = relationship('User', lazy='joined')
1235
1236 def __json__(self):
1237 data = {
1238 'ssh_fingerprint': self.ssh_key_fingerprint,
1239 'description': self.description,
1240 'created_on': self.created_on
1241 }
1242 return data
1243
1244 def get_api_data(self):
1245 data = self.__json__()
1246 return data
1247
1248
1249 class UserLog(Base, BaseModel):
1250 __tablename__ = 'user_logs'
1251 __table_args__ = (
1252 base_table_args,
1253 )
1254
1255 VERSION_1 = 'v1'
1256 VERSION_2 = 'v2'
1257 VERSIONS = [VERSION_1, VERSION_2]
1258
1259 user_log_id = Column("user_log_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1260 user_id = Column("user_id", Integer(), ForeignKey('users.user_id',ondelete='SET NULL'), nullable=True, unique=None, default=None)
1261 username = Column("username", String(255), nullable=True, unique=None, default=None)
1262 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id', ondelete='SET NULL'), nullable=True, unique=None, default=None)
1263 repository_name = Column("repository_name", String(255), nullable=True, unique=None, default=None)
1264 user_ip = Column("user_ip", String(255), nullable=True, unique=None, default=None)
1265 action = Column("action", Text().with_variant(Text(1200000), 'mysql'), nullable=True, unique=None, default=None)
1266 action_date = Column("action_date", DateTime(timezone=False), nullable=True, unique=None, default=None)
1267
1268 version = Column("version", String(255), nullable=True, default=VERSION_1)
1269 user_data = Column('user_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=LONGTEXT()))))
1270 action_data = Column('action_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=LONGTEXT()))))
1271
1272 def __unicode__(self):
1273 return u"<%s('id:%s:%s')>" % (
1274 self.__class__.__name__, self.repository_name, self.action)
1275
1276 def __json__(self):
1277 return {
1278 'user_id': self.user_id,
1279 'username': self.username,
1280 'repository_id': self.repository_id,
1281 'repository_name': self.repository_name,
1282 'user_ip': self.user_ip,
1283 'action_date': self.action_date,
1284 'action': self.action,
1285 }
1286
1287 @hybrid_property
1288 def entry_id(self):
1289 return self.user_log_id
1290
1291 @property
1292 def action_as_day(self):
1293 return datetime.date(*self.action_date.timetuple()[:3])
1294
1295 user = relationship('User')
1296 repository = relationship('Repository', cascade='')
1297
1298
1299 class UserGroup(Base, BaseModel):
1300 __tablename__ = 'users_groups'
1301 __table_args__ = (
1302 base_table_args,
1303 )
1304
1305 users_group_id = Column("users_group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1306 users_group_name = Column("users_group_name", String(255), nullable=False, unique=True, default=None)
1307 user_group_description = Column("user_group_description", String(10000), nullable=True, unique=None, default=None)
1308 users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None)
1309 inherit_default_permissions = Column("users_group_inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)
1310 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
1311 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
1312 _group_data = Column("group_data", LargeBinary(), nullable=True) # JSON data
1313
1314 members = relationship('UserGroupMember', cascade="all, delete, delete-orphan", lazy="joined")
1315 users_group_to_perm = relationship('UserGroupToPerm', cascade='all')
1316 users_group_repo_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
1317 users_group_repo_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
1318 user_user_group_to_perm = relationship('UserUserGroupToPerm', cascade='all')
1319 user_group_user_group_to_perm = relationship('UserGroupUserGroupToPerm ', primaryjoin="UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id", cascade='all')
1320
1321 user_group_review_rules = relationship('RepoReviewRuleUserGroup', cascade='all')
1322 user = relationship('User', primaryjoin="User.user_id==UserGroup.user_id")
1323
1324 @classmethod
1325 def _load_group_data(cls, column):
1326 if not column:
1327 return {}
1328
1329 try:
1330 return json.loads(column) or {}
1331 except TypeError:
1332 return {}
1333
1334 @hybrid_property
1335 def description_safe(self):
1336 from rhodecode.lib import helpers as h
1337 return h.escape(self.user_group_description)
1338
1339 @hybrid_property
1340 def group_data(self):
1341 return self._load_group_data(self._group_data)
1342
1343 @group_data.expression
1344 def group_data(self, **kwargs):
1345 return self._group_data
1346
1347 @group_data.setter
1348 def group_data(self, val):
1349 try:
1350 self._group_data = json.dumps(val)
1351 except Exception:
1352 log.error(traceback.format_exc())
1353
1354 @classmethod
1355 def _load_sync(cls, group_data):
1356 if group_data:
1357 return group_data.get('extern_type')
1358
1359 @property
1360 def sync(self):
1361 return self._load_sync(self.group_data)
1362
1363 def __unicode__(self):
1364 return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
1365 self.users_group_id,
1366 self.users_group_name)
1367
1368 @classmethod
1369 def get_by_group_name(cls, group_name, cache=False,
1370 case_insensitive=False):
1371 if case_insensitive:
1372 q = cls.query().filter(func.lower(cls.users_group_name) ==
1373 func.lower(group_name))
1374
1375 else:
1376 q = cls.query().filter(cls.users_group_name == group_name)
1377 if cache:
1378 q = q.options(
1379 FromCache("sql_cache_short", "get_group_%s" % _hash_key(group_name)))
1380 return q.scalar()
1381
1382 @classmethod
1383 def get(cls, user_group_id, cache=False):
1384 if not user_group_id:
1385 return
1386
1387 user_group = cls.query()
1388 if cache:
1389 user_group = user_group.options(
1390 FromCache("sql_cache_short", "get_users_group_%s" % user_group_id))
1391 return user_group.get(user_group_id)
1392
1393 def permissions(self, with_admins=True, with_owner=True):
1394 """
1395 Permissions for user groups
1396 """
1397 _admin_perm = 'usergroup.admin'
1398
1399 owner_row = []
1400 if with_owner:
1401 usr = AttributeDict(self.user.get_dict())
1402 usr.owner_row = True
1403 usr.permission = _admin_perm
1404 owner_row.append(usr)
1405
1406 super_admin_ids = []
1407 super_admin_rows = []
1408 if with_admins:
1409 for usr in User.get_all_super_admins():
1410 super_admin_ids.append(usr.user_id)
1411 # if this admin is also owner, don't double the record
1412 if usr.user_id == owner_row[0].user_id:
1413 owner_row[0].admin_row = True
1414 else:
1415 usr = AttributeDict(usr.get_dict())
1416 usr.admin_row = True
1417 usr.permission = _admin_perm
1418 super_admin_rows.append(usr)
1419
1420 q = UserUserGroupToPerm.query().filter(UserUserGroupToPerm.user_group == self)
1421 q = q.options(joinedload(UserUserGroupToPerm.user_group),
1422 joinedload(UserUserGroupToPerm.user),
1423 joinedload(UserUserGroupToPerm.permission),)
1424
1425 # get owners and admins and permissions. We do a trick of re-writing
1426 # objects from sqlalchemy to named-tuples due to sqlalchemy session
1427 # has a global reference and changing one object propagates to all
1428 # others. This means if admin is also an owner admin_row that change
1429 # would propagate to both objects
1430 perm_rows = []
1431 for _usr in q.all():
1432 usr = AttributeDict(_usr.user.get_dict())
1433 # if this user is also owner/admin, mark as duplicate record
1434 if usr.user_id == owner_row[0].user_id or usr.user_id in super_admin_ids:
1435 usr.duplicate_perm = True
1436 usr.permission = _usr.permission.permission_name
1437 perm_rows.append(usr)
1438
1439 # filter the perm rows by 'default' first and then sort them by
1440 # admin,write,read,none permissions sorted again alphabetically in
1441 # each group
1442 perm_rows = sorted(perm_rows, key=display_user_sort)
1443
1444 return super_admin_rows + owner_row + perm_rows
1445
1446 def permission_user_groups(self):
1447 q = UserGroupUserGroupToPerm.query().filter(UserGroupUserGroupToPerm.target_user_group == self)
1448 q = q.options(joinedload(UserGroupUserGroupToPerm.user_group),
1449 joinedload(UserGroupUserGroupToPerm.target_user_group),
1450 joinedload(UserGroupUserGroupToPerm.permission),)
1451
1452 perm_rows = []
1453 for _user_group in q.all():
1454 usr = AttributeDict(_user_group.user_group.get_dict())
1455 usr.permission = _user_group.permission.permission_name
1456 perm_rows.append(usr)
1457
1458 perm_rows = sorted(perm_rows, key=display_user_group_sort)
1459 return perm_rows
1460
1461 def _get_default_perms(self, user_group, suffix=''):
1462 from rhodecode.model.permission import PermissionModel
1463 return PermissionModel().get_default_perms(user_group.users_group_to_perm, suffix)
1464
1465 def get_default_perms(self, suffix=''):
1466 return self._get_default_perms(self, suffix)
1467
1468 def get_api_data(self, with_group_members=True, include_secrets=False):
1469 """
1470 :param include_secrets: See :meth:`User.get_api_data`, this parameter is
1471 basically forwarded.
1472
1473 """
1474 user_group = self
1475 data = {
1476 'users_group_id': user_group.users_group_id,
1477 'group_name': user_group.users_group_name,
1478 'group_description': user_group.user_group_description,
1479 'active': user_group.users_group_active,
1480 'owner': user_group.user.username,
1481 'sync': user_group.sync,
1482 'owner_email': user_group.user.email,
1483 }
1484
1485 if with_group_members:
1486 users = []
1487 for user in user_group.members:
1488 user = user.user
1489 users.append(user.get_api_data(include_secrets=include_secrets))
1490 data['users'] = users
1491
1492 return data
1493
1494
1495 class UserGroupMember(Base, BaseModel):
1496 __tablename__ = 'users_groups_members'
1497 __table_args__ = (
1498 base_table_args,
1499 )
1500
1501 users_group_member_id = Column("users_group_member_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1502 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
1503 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
1504
1505 user = relationship('User', lazy='joined')
1506 users_group = relationship('UserGroup')
1507
1508 def __init__(self, gr_id='', u_id=''):
1509 self.users_group_id = gr_id
1510 self.user_id = u_id
1511
1512
1513 class RepositoryField(Base, BaseModel):
1514 __tablename__ = 'repositories_fields'
1515 __table_args__ = (
1516 UniqueConstraint('repository_id', 'field_key'), # no-multi field
1517 base_table_args,
1518 )
1519
1520 PREFIX = 'ex_' # prefix used in form to not conflict with already existing fields
1521
1522 repo_field_id = Column("repo_field_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
1523 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
1524 field_key = Column("field_key", String(250))
1525 field_label = Column("field_label", String(1024), nullable=False)
1526 field_value = Column("field_value", String(10000), nullable=False)
1527 field_desc = Column("field_desc", String(1024), nullable=False)
1528 field_type = Column("field_type", String(255), nullable=False, unique=None)
1529 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
1530
1531 repository = relationship('Repository')
1532
1533 @property
1534 def field_key_prefixed(self):
1535 return 'ex_%s' % self.field_key
1536
1537 @classmethod
1538 def un_prefix_key(cls, key):
1539 if key.startswith(cls.PREFIX):
1540 return key[len(cls.PREFIX):]
1541 return key
1542
1543 @classmethod
1544 def get_by_key_name(cls, key, repo):
1545 row = cls.query()\
1546 .filter(cls.repository == repo)\
1547 .filter(cls.field_key == key).scalar()
1548 return row
1549
1550
1551 class Repository(Base, BaseModel):
1552 __tablename__ = 'repositories'
1553 __table_args__ = (
1554 Index('r_repo_name_idx', 'repo_name', mysql_length=255),
1555 base_table_args,
1556 )
1557 DEFAULT_CLONE_URI = '{scheme}://{user}@{netloc}/{repo}'
1558 DEFAULT_CLONE_URI_ID = '{scheme}://{user}@{netloc}/_{repoid}'
1559 DEFAULT_CLONE_URI_SSH = 'ssh://{sys_user}@{hostname}/{repo}'
1560
1561 STATE_CREATED = 'repo_state_created'
1562 STATE_PENDING = 'repo_state_pending'
1563 STATE_ERROR = 'repo_state_error'
1564
1565 LOCK_AUTOMATIC = 'lock_auto'
1566 LOCK_API = 'lock_api'
1567 LOCK_WEB = 'lock_web'
1568 LOCK_PULL = 'lock_pull'
1569
1570 NAME_SEP = URL_SEP
1571
1572 repo_id = Column(
1573 "repo_id", Integer(), nullable=False, unique=True, default=None,
1574 primary_key=True)
1575 _repo_name = Column(
1576 "repo_name", Text(), nullable=False, default=None)
1577 _repo_name_hash = Column(
1578 "repo_name_hash", String(255), nullable=False, unique=True)
1579 repo_state = Column("repo_state", String(255), nullable=True)
1580
1581 clone_uri = Column(
1582 "clone_uri", EncryptedTextValue(), nullable=True, unique=False,
1583 default=None)
1584 push_uri = Column(
1585 "push_uri", EncryptedTextValue(), nullable=True, unique=False,
1586 default=None)
1587 repo_type = Column(
1588 "repo_type", String(255), nullable=False, unique=False, default=None)
1589 user_id = Column(
1590 "user_id", Integer(), ForeignKey('users.user_id'), nullable=False,
1591 unique=False, default=None)
1592 private = Column(
1593 "private", Boolean(), nullable=True, unique=None, default=None)
1594 archived = Column(
1595 "archived", Boolean(), nullable=True, unique=None, default=None)
1596 enable_statistics = Column(
1597 "statistics", Boolean(), nullable=True, unique=None, default=True)
1598 enable_downloads = Column(
1599 "downloads", Boolean(), nullable=True, unique=None, default=True)
1600 description = Column(
1601 "description", String(10000), nullable=True, unique=None, default=None)
1602 created_on = Column(
1603 'created_on', DateTime(timezone=False), nullable=True, unique=None,
1604 default=datetime.datetime.now)
1605 updated_on = Column(
1606 'updated_on', DateTime(timezone=False), nullable=True, unique=None,
1607 default=datetime.datetime.now)
1608 _landing_revision = Column(
1609 "landing_revision", String(255), nullable=False, unique=False,
1610 default=None)
1611 enable_locking = Column(
1612 "enable_locking", Boolean(), nullable=False, unique=None,
1613 default=False)
1614 _locked = Column(
1615 "locked", String(255), nullable=True, unique=False, default=None)
1616 _changeset_cache = Column(
1617 "changeset_cache", LargeBinary(), nullable=True) # JSON data
1618
1619 fork_id = Column(
1620 "fork_id", Integer(), ForeignKey('repositories.repo_id'),
1621 nullable=True, unique=False, default=None)
1622 group_id = Column(
1623 "group_id", Integer(), ForeignKey('groups.group_id'), nullable=True,
1624 unique=False, default=None)
1625
1626 user = relationship('User', lazy='joined')
1627 fork = relationship('Repository', remote_side=repo_id, lazy='joined')
1628 group = relationship('RepoGroup', lazy='joined')
1629 repo_to_perm = relationship(
1630 'UserRepoToPerm', cascade='all',
1631 order_by='UserRepoToPerm.repo_to_perm_id')
1632 users_group_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
1633 stats = relationship('Statistics', cascade='all', uselist=False)
1634
1635 followers = relationship(
1636 'UserFollowing',
1637 primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id',
1638 cascade='all')
1639 extra_fields = relationship(
1640 'RepositoryField', cascade="all, delete, delete-orphan")
1641 logs = relationship('UserLog')
1642 comments = relationship(
1643 'ChangesetComment', cascade="all, delete, delete-orphan")
1644 pull_requests_source = relationship(
1645 'PullRequest',
1646 primaryjoin='PullRequest.source_repo_id==Repository.repo_id',
1647 cascade="all, delete, delete-orphan")
1648 pull_requests_target = relationship(
1649 'PullRequest',
1650 primaryjoin='PullRequest.target_repo_id==Repository.repo_id',
1651 cascade="all, delete, delete-orphan")
1652 ui = relationship('RepoRhodeCodeUi', cascade="all")
1653 settings = relationship('RepoRhodeCodeSetting', cascade="all")
1654 integrations = relationship('Integration',
1655 cascade="all, delete, delete-orphan")
1656
1657 scoped_tokens = relationship('UserApiKeys', cascade="all")
1658
1659 def __unicode__(self):
1660 return u"<%s('%s:%s')>" % (self.__class__.__name__, self.repo_id,
1661 safe_unicode(self.repo_name))
1662
1663 @hybrid_property
1664 def description_safe(self):
1665 from rhodecode.lib import helpers as h
1666 return h.escape(self.description)
1667
1668 @hybrid_property
1669 def landing_rev(self):
1670 # always should return [rev_type, rev]
1671 if self._landing_revision:
1672 _rev_info = self._landing_revision.split(':')
1673 if len(_rev_info) < 2:
1674 _rev_info.insert(0, 'rev')
1675 return [_rev_info[0], _rev_info[1]]
1676 return [None, None]
1677
1678 @landing_rev.setter
1679 def landing_rev(self, val):
1680 if ':' not in val:
1681 raise ValueError('value must be delimited with `:` and consist '
1682 'of <rev_type>:<rev>, got %s instead' % val)
1683 self._landing_revision = val
1684
1685 @hybrid_property
1686 def locked(self):
1687 if self._locked:
1688 user_id, timelocked, reason = self._locked.split(':')
1689 lock_values = int(user_id), timelocked, reason
1690 else:
1691 lock_values = [None, None, None]
1692 return lock_values
1693
1694 @locked.setter
1695 def locked(self, val):
1696 if val and isinstance(val, (list, tuple)):
1697 self._locked = ':'.join(map(str, val))
1698 else:
1699 self._locked = None
1700
1701 @hybrid_property
1702 def changeset_cache(self):
1703 from rhodecode.lib.vcs.backends.base import EmptyCommit
1704 dummy = EmptyCommit().__json__()
1705 if not self._changeset_cache:
1706 return dummy
1707 try:
1708 return json.loads(self._changeset_cache)
1709 except TypeError:
1710 return dummy
1711 except Exception:
1712 log.error(traceback.format_exc())
1713 return dummy
1714
1715 @changeset_cache.setter
1716 def changeset_cache(self, val):
1717 try:
1718 self._changeset_cache = json.dumps(val)
1719 except Exception:
1720 log.error(traceback.format_exc())
1721
1722 @hybrid_property
1723 def repo_name(self):
1724 return self._repo_name
1725
1726 @repo_name.setter
1727 def repo_name(self, value):
1728 self._repo_name = value
1729 self._repo_name_hash = hashlib.sha1(safe_str(value)).hexdigest()
1730
1731 @classmethod
1732 def normalize_repo_name(cls, repo_name):
1733 """
1734 Normalizes os specific repo_name to the format internally stored inside
1735 database using URL_SEP
1736
1737 :param cls:
1738 :param repo_name:
1739 """
1740 return cls.NAME_SEP.join(repo_name.split(os.sep))
1741
1742 @classmethod
1743 def get_by_repo_name(cls, repo_name, cache=False, identity_cache=False):
1744 session = Session()
1745 q = session.query(cls).filter(cls.repo_name == repo_name)
1746
1747 if cache:
1748 if identity_cache:
1749 val = cls.identity_cache(session, 'repo_name', repo_name)
1750 if val:
1751 return val
1752 else:
1753 cache_key = "get_repo_by_name_%s" % _hash_key(repo_name)
1754 q = q.options(
1755 FromCache("sql_cache_short", cache_key))
1756
1757 return q.scalar()
1758
1759 @classmethod
1760 def get_by_id_or_repo_name(cls, repoid):
1761 if isinstance(repoid, (int, long)):
1762 try:
1763 repo = cls.get(repoid)
1764 except ValueError:
1765 repo = None
1766 else:
1767 repo = cls.get_by_repo_name(repoid)
1768 return repo
1769
1770 @classmethod
1771 def get_by_full_path(cls, repo_full_path):
1772 repo_name = repo_full_path.split(cls.base_path(), 1)[-1]
1773 repo_name = cls.normalize_repo_name(repo_name)
1774 return cls.get_by_repo_name(repo_name.strip(URL_SEP))
1775
1776 @classmethod
1777 def get_repo_forks(cls, repo_id):
1778 return cls.query().filter(Repository.fork_id == repo_id)
1779
1780 @classmethod
1781 def base_path(cls):
1782 """
1783 Returns base path when all repos are stored
1784
1785 :param cls:
1786 """
1787 q = Session().query(RhodeCodeUi)\
1788 .filter(RhodeCodeUi.ui_key == cls.NAME_SEP)
1789 q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
1790 return q.one().ui_value
1791
1792 @classmethod
1793 def get_all_repos(cls, user_id=Optional(None), group_id=Optional(None),
1794 case_insensitive=True, archived=False):
1795 q = Repository.query()
1796
1797 if not archived:
1798 q = q.filter(Repository.archived.isnot(true()))
1799
1800 if not isinstance(user_id, Optional):
1801 q = q.filter(Repository.user_id == user_id)
1802
1803 if not isinstance(group_id, Optional):
1804 q = q.filter(Repository.group_id == group_id)
1805
1806 if case_insensitive:
1807 q = q.order_by(func.lower(Repository.repo_name))
1808 else:
1809 q = q.order_by(Repository.repo_name)
1810
1811 return q.all()
1812
1813 @property
1814 def forks(self):
1815 """
1816 Return forks of this repo
1817 """
1818 return Repository.get_repo_forks(self.repo_id)
1819
1820 @property
1821 def parent(self):
1822 """
1823 Returns fork parent
1824 """
1825 return self.fork
1826
1827 @property
1828 def just_name(self):
1829 return self.repo_name.split(self.NAME_SEP)[-1]
1830
1831 @property
1832 def groups_with_parents(self):
1833 groups = []
1834 if self.group is None:
1835 return groups
1836
1837 cur_gr = self.group
1838 groups.insert(0, cur_gr)
1839 while 1:
1840 gr = getattr(cur_gr, 'parent_group', None)
1841 cur_gr = cur_gr.parent_group
1842 if gr is None:
1843 break
1844 groups.insert(0, gr)
1845
1846 return groups
1847
1848 @property
1849 def groups_and_repo(self):
1850 return self.groups_with_parents, self
1851
1852 @LazyProperty
1853 def repo_path(self):
1854 """
1855 Returns base full path for that repository means where it actually
1856 exists on a filesystem
1857 """
1858 q = Session().query(RhodeCodeUi).filter(
1859 RhodeCodeUi.ui_key == self.NAME_SEP)
1860 q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
1861 return q.one().ui_value
1862
1863 @property
1864 def repo_full_path(self):
1865 p = [self.repo_path]
1866 # we need to split the name by / since this is how we store the
1867 # names in the database, but that eventually needs to be converted
1868 # into a valid system path
1869 p += self.repo_name.split(self.NAME_SEP)
1870 return os.path.join(*map(safe_unicode, p))
1871
1872 @property
1873 def cache_keys(self):
1874 """
1875 Returns associated cache keys for that repo
1876 """
1877 invalidation_namespace = CacheKey.REPO_INVALIDATION_NAMESPACE.format(
1878 repo_id=self.repo_id)
1879 return CacheKey.query()\
1880 .filter(CacheKey.cache_args == invalidation_namespace)\
1881 .order_by(CacheKey.cache_key)\
1882 .all()
1883
1884 @property
1885 def cached_diffs_relative_dir(self):
1886 """
1887 Return a relative to the repository store path of cached diffs
1888 used for safe display for users, who shouldn't know the absolute store
1889 path
1890 """
1891 return os.path.join(
1892 os.path.dirname(self.repo_name),
1893 self.cached_diffs_dir.split(os.path.sep)[-1])
1894
1895 @property
1896 def cached_diffs_dir(self):
1897 path = self.repo_full_path
1898 return os.path.join(
1899 os.path.dirname(path),
1900 '.__shadow_diff_cache_repo_{}'.format(self.repo_id))
1901
1902 def cached_diffs(self):
1903 diff_cache_dir = self.cached_diffs_dir
1904 if os.path.isdir(diff_cache_dir):
1905 return os.listdir(diff_cache_dir)
1906 return []
1907
1908 def shadow_repos(self):
1909 shadow_repos_pattern = '.__shadow_repo_{}'.format(self.repo_id)
1910 return [
1911 x for x in os.listdir(os.path.dirname(self.repo_full_path))
1912 if x.startswith(shadow_repos_pattern)]
1913
1914 def get_new_name(self, repo_name):
1915 """
1916 returns new full repository name based on assigned group and new new
1917
1918 :param group_name:
1919 """
1920 path_prefix = self.group.full_path_splitted if self.group else []
1921 return self.NAME_SEP.join(path_prefix + [repo_name])
1922
1923 @property
1924 def _config(self):
1925 """
1926 Returns db based config object.
1927 """
1928 from rhodecode.lib.utils import make_db_config
1929 return make_db_config(clear_session=False, repo=self)
1930
1931 def permissions(self, with_admins=True, with_owner=True):
1932 """
1933 Permissions for repositories
1934 """
1935 _admin_perm = 'repository.admin'
1936
1937 owner_row = []
1938 if with_owner:
1939 usr = AttributeDict(self.user.get_dict())
1940 usr.owner_row = True
1941 usr.permission = _admin_perm
1942 usr.permission_id = None
1943 owner_row.append(usr)
1944
1945 super_admin_ids = []
1946 super_admin_rows = []
1947 if with_admins:
1948 for usr in User.get_all_super_admins():
1949 super_admin_ids.append(usr.user_id)
1950 # if this admin is also owner, don't double the record
1951 if usr.user_id == owner_row[0].user_id:
1952 owner_row[0].admin_row = True
1953 else:
1954 usr = AttributeDict(usr.get_dict())
1955 usr.admin_row = True
1956 usr.permission = _admin_perm
1957 usr.permission_id = None
1958 super_admin_rows.append(usr)
1959
1960 q = UserRepoToPerm.query().filter(UserRepoToPerm.repository == self)
1961 q = q.options(joinedload(UserRepoToPerm.repository),
1962 joinedload(UserRepoToPerm.user),
1963 joinedload(UserRepoToPerm.permission),)
1964
1965 # get owners and admins and permissions. We do a trick of re-writing
1966 # objects from sqlalchemy to named-tuples due to sqlalchemy session
1967 # has a global reference and changing one object propagates to all
1968 # others. This means if admin is also an owner admin_row that change
1969 # would propagate to both objects
1970 perm_rows = []
1971 for _usr in q.all():
1972 usr = AttributeDict(_usr.user.get_dict())
1973 # if this user is also owner/admin, mark as duplicate record
1974 if usr.user_id == owner_row[0].user_id or usr.user_id in super_admin_ids:
1975 usr.duplicate_perm = True
1976 # also check if this permission is maybe used by branch_permissions
1977 if _usr.branch_perm_entry:
1978 usr.branch_rules = [x.branch_rule_id for x in _usr.branch_perm_entry]
1979
1980 usr.permission = _usr.permission.permission_name
1981 usr.permission_id = _usr.repo_to_perm_id
1982 perm_rows.append(usr)
1983
1984 # filter the perm rows by 'default' first and then sort them by
1985 # admin,write,read,none permissions sorted again alphabetically in
1986 # each group
1987 perm_rows = sorted(perm_rows, key=display_user_sort)
1988
1989 return super_admin_rows + owner_row + perm_rows
1990
1991 def permission_user_groups(self):
1992 q = UserGroupRepoToPerm.query().filter(
1993 UserGroupRepoToPerm.repository == self)
1994 q = q.options(joinedload(UserGroupRepoToPerm.repository),
1995 joinedload(UserGroupRepoToPerm.users_group),
1996 joinedload(UserGroupRepoToPerm.permission),)
1997
1998 perm_rows = []
1999 for _user_group in q.all():
2000 usr = AttributeDict(_user_group.users_group.get_dict())
2001 usr.permission = _user_group.permission.permission_name
2002 perm_rows.append(usr)
2003
2004 perm_rows = sorted(perm_rows, key=display_user_group_sort)
2005 return perm_rows
2006
2007 def get_api_data(self, include_secrets=False):
2008 """
2009 Common function for generating repo api data
2010
2011 :param include_secrets: See :meth:`User.get_api_data`.
2012
2013 """
2014 # TODO: mikhail: Here there is an anti-pattern, we probably need to
2015 # move this methods on models level.
2016 from rhodecode.model.settings import SettingsModel
2017 from rhodecode.model.repo import RepoModel
2018
2019 repo = self
2020 _user_id, _time, _reason = self.locked
2021
2022 data = {
2023 'repo_id': repo.repo_id,
2024 'repo_name': repo.repo_name,
2025 'repo_type': repo.repo_type,
2026 'clone_uri': repo.clone_uri or '',
2027 'push_uri': repo.push_uri or '',
2028 'url': RepoModel().get_url(self),
2029 'private': repo.private,
2030 'created_on': repo.created_on,
2031 'description': repo.description_safe,
2032 'landing_rev': repo.landing_rev,
2033 'owner': repo.user.username,
2034 'fork_of': repo.fork.repo_name if repo.fork else None,
2035 'fork_of_id': repo.fork.repo_id if repo.fork else None,
2036 'enable_statistics': repo.enable_statistics,
2037 'enable_locking': repo.enable_locking,
2038 'enable_downloads': repo.enable_downloads,
2039 'last_changeset': repo.changeset_cache,
2040 'locked_by': User.get(_user_id).get_api_data(
2041 include_secrets=include_secrets) if _user_id else None,
2042 'locked_date': time_to_datetime(_time) if _time else None,
2043 'lock_reason': _reason if _reason else None,
2044 }
2045
2046 # TODO: mikhail: should be per-repo settings here
2047 rc_config = SettingsModel().get_all_settings()
2048 repository_fields = str2bool(
2049 rc_config.get('rhodecode_repository_fields'))
2050 if repository_fields:
2051 for f in self.extra_fields:
2052 data[f.field_key_prefixed] = f.field_value
2053
2054 return data
2055
2056 @classmethod
2057 def lock(cls, repo, user_id, lock_time=None, lock_reason=None):
2058 if not lock_time:
2059 lock_time = time.time()
2060 if not lock_reason:
2061 lock_reason = cls.LOCK_AUTOMATIC
2062 repo.locked = [user_id, lock_time, lock_reason]
2063 Session().add(repo)
2064 Session().commit()
2065
2066 @classmethod
2067 def unlock(cls, repo):
2068 repo.locked = None
2069 Session().add(repo)
2070 Session().commit()
2071
2072 @classmethod
2073 def getlock(cls, repo):
2074 return repo.locked
2075
2076 def is_user_lock(self, user_id):
2077 if self.lock[0]:
2078 lock_user_id = safe_int(self.lock[0])
2079 user_id = safe_int(user_id)
2080 # both are ints, and they are equal
2081 return all([lock_user_id, user_id]) and lock_user_id == user_id
2082
2083 return False
2084
2085 def get_locking_state(self, action, user_id, only_when_enabled=True):
2086 """
2087 Checks locking on this repository, if locking is enabled and lock is
2088 present returns a tuple of make_lock, locked, locked_by.
2089 make_lock can have 3 states None (do nothing) True, make lock
2090 False release lock, This value is later propagated to hooks, which
2091 do the locking. Think about this as signals passed to hooks what to do.
2092
2093 """
2094 # TODO: johbo: This is part of the business logic and should be moved
2095 # into the RepositoryModel.
2096
2097 if action not in ('push', 'pull'):
2098 raise ValueError("Invalid action value: %s" % repr(action))
2099
2100 # defines if locked error should be thrown to user
2101 currently_locked = False
2102 # defines if new lock should be made, tri-state
2103 make_lock = None
2104 repo = self
2105 user = User.get(user_id)
2106
2107 lock_info = repo.locked
2108
2109 if repo and (repo.enable_locking or not only_when_enabled):
2110 if action == 'push':
2111 # check if it's already locked !, if it is compare users
2112 locked_by_user_id = lock_info[0]
2113 if user.user_id == locked_by_user_id:
2114 log.debug(
2115 'Got `push` action from user %s, now unlocking', user)
2116 # unlock if we have push from user who locked
2117 make_lock = False
2118 else:
2119 # we're not the same user who locked, ban with
2120 # code defined in settings (default is 423 HTTP Locked) !
2121 log.debug('Repo %s is currently locked by %s', repo, user)
2122 currently_locked = True
2123 elif action == 'pull':
2124 # [0] user [1] date
2125 if lock_info[0] and lock_info[1]:
2126 log.debug('Repo %s is currently locked by %s', repo, user)
2127 currently_locked = True
2128 else:
2129 log.debug('Setting lock on repo %s by %s', repo, user)
2130 make_lock = True
2131
2132 else:
2133 log.debug('Repository %s do not have locking enabled', repo)
2134
2135 log.debug('FINAL locking values make_lock:%s,locked:%s,locked_by:%s',
2136 make_lock, currently_locked, lock_info)
2137
2138 from rhodecode.lib.auth import HasRepoPermissionAny
2139 perm_check = HasRepoPermissionAny('repository.write', 'repository.admin')
2140 if make_lock and not perm_check(repo_name=repo.repo_name, user=user):
2141 # if we don't have at least write permission we cannot make a lock
2142 log.debug('lock state reset back to FALSE due to lack '
2143 'of at least read permission')
2144 make_lock = False
2145
2146 return make_lock, currently_locked, lock_info
2147
2148 @property
2149 def last_db_change(self):
2150 return self.updated_on
2151
2152 @property
2153 def clone_uri_hidden(self):
2154 clone_uri = self.clone_uri
2155 if clone_uri:
2156 import urlobject
2157 url_obj = urlobject.URLObject(cleaned_uri(clone_uri))
2158 if url_obj.password:
2159 clone_uri = url_obj.with_password('*****')
2160 return clone_uri
2161
2162 @property
2163 def push_uri_hidden(self):
2164 push_uri = self.push_uri
2165 if push_uri:
2166 import urlobject
2167 url_obj = urlobject.URLObject(cleaned_uri(push_uri))
2168 if url_obj.password:
2169 push_uri = url_obj.with_password('*****')
2170 return push_uri
2171
2172 def clone_url(self, **override):
2173 from rhodecode.model.settings import SettingsModel
2174
2175 uri_tmpl = None
2176 if 'with_id' in override:
2177 uri_tmpl = self.DEFAULT_CLONE_URI_ID
2178 del override['with_id']
2179
2180 if 'uri_tmpl' in override:
2181 uri_tmpl = override['uri_tmpl']
2182 del override['uri_tmpl']
2183
2184 ssh = False
2185 if 'ssh' in override:
2186 ssh = True
2187 del override['ssh']
2188
2189 # we didn't override our tmpl from **overrides
2190 if not uri_tmpl:
2191 rc_config = SettingsModel().get_all_settings(cache=True)
2192 if ssh:
2193 uri_tmpl = rc_config.get(
2194 'rhodecode_clone_uri_ssh_tmpl') or self.DEFAULT_CLONE_URI_SSH
2195 else:
2196 uri_tmpl = rc_config.get(
2197 'rhodecode_clone_uri_tmpl') or self.DEFAULT_CLONE_URI
2198
2199 request = get_current_request()
2200 return get_clone_url(request=request,
2201 uri_tmpl=uri_tmpl,
2202 repo_name=self.repo_name,
2203 repo_id=self.repo_id, **override)
2204
2205 def set_state(self, state):
2206 self.repo_state = state
2207 Session().add(self)
2208 #==========================================================================
2209 # SCM PROPERTIES
2210 #==========================================================================
2211
2212 def get_commit(self, commit_id=None, commit_idx=None, pre_load=None):
2213 return get_commit_safe(
2214 self.scm_instance(), commit_id, commit_idx, pre_load=pre_load)
2215
2216 def get_changeset(self, rev=None, pre_load=None):
2217 warnings.warn("Use get_commit", DeprecationWarning)
2218 commit_id = None
2219 commit_idx = None
2220 if isinstance(rev, basestring):
2221 commit_id = rev
2222 else:
2223 commit_idx = rev
2224 return self.get_commit(commit_id=commit_id, commit_idx=commit_idx,
2225 pre_load=pre_load)
2226
2227 def get_landing_commit(self):
2228 """
2229 Returns landing commit, or if that doesn't exist returns the tip
2230 """
2231 _rev_type, _rev = self.landing_rev
2232 commit = self.get_commit(_rev)
2233 if isinstance(commit, EmptyCommit):
2234 return self.get_commit()
2235 return commit
2236
2237 def update_commit_cache(self, cs_cache=None, config=None):
2238 """
2239 Update cache of last changeset for repository, keys should be::
2240
2241 short_id
2242 raw_id
2243 revision
2244 parents
2245 message
2246 date
2247 author
2248
2249 :param cs_cache:
2250 """
2251 from rhodecode.lib.vcs.backends.base import BaseChangeset
2252 if cs_cache is None:
2253 # use no-cache version here
2254 scm_repo = self.scm_instance(cache=False, config=config)
2255
2256 empty = scm_repo.is_empty()
2257 if not empty:
2258 cs_cache = scm_repo.get_commit(
2259 pre_load=["author", "date", "message", "parents"])
2260 else:
2261 cs_cache = EmptyCommit()
2262
2263 if isinstance(cs_cache, BaseChangeset):
2264 cs_cache = cs_cache.__json__()
2265
2266 def is_outdated(new_cs_cache):
2267 if (new_cs_cache['raw_id'] != self.changeset_cache['raw_id'] or
2268 new_cs_cache['revision'] != self.changeset_cache['revision']):
2269 return True
2270 return False
2271
2272 # check if we have maybe already latest cached revision
2273 if is_outdated(cs_cache) or not self.changeset_cache:
2274 _default = datetime.datetime.utcnow()
2275 last_change = cs_cache.get('date') or _default
2276 if self.updated_on and self.updated_on > last_change:
2277 # we check if last update is newer than the new value
2278 # if yes, we use the current timestamp instead. Imagine you get
2279 # old commit pushed 1y ago, we'd set last update 1y to ago.
2280 last_change = _default
2281 log.debug('updated repo %s with new cs cache %s',
2282 self.repo_name, cs_cache)
2283 self.updated_on = last_change
2284 self.changeset_cache = cs_cache
2285 Session().add(self)
2286 Session().commit()
2287 else:
2288 log.debug('Skipping update_commit_cache for repo:`%s` '
2289 'commit already with latest changes', self.repo_name)
2290
2291 @property
2292 def tip(self):
2293 return self.get_commit('tip')
2294
2295 @property
2296 def author(self):
2297 return self.tip.author
2298
2299 @property
2300 def last_change(self):
2301 return self.scm_instance().last_change
2302
2303 def get_comments(self, revisions=None):
2304 """
2305 Returns comments for this repository grouped by revisions
2306
2307 :param revisions: filter query by revisions only
2308 """
2309 cmts = ChangesetComment.query()\
2310 .filter(ChangesetComment.repo == self)
2311 if revisions:
2312 cmts = cmts.filter(ChangesetComment.revision.in_(revisions))
2313 grouped = collections.defaultdict(list)
2314 for cmt in cmts.all():
2315 grouped[cmt.revision].append(cmt)
2316 return grouped
2317
2318 def statuses(self, revisions=None):
2319 """
2320 Returns statuses for this repository
2321
2322 :param revisions: list of revisions to get statuses for
2323 """
2324 statuses = ChangesetStatus.query()\
2325 .filter(ChangesetStatus.repo == self)\
2326 .filter(ChangesetStatus.version == 0)
2327
2328 if revisions:
2329 # Try doing the filtering in chunks to avoid hitting limits
2330 size = 500
2331 status_results = []
2332 for chunk in xrange(0, len(revisions), size):
2333 status_results += statuses.filter(
2334 ChangesetStatus.revision.in_(
2335 revisions[chunk: chunk+size])
2336 ).all()
2337 else:
2338 status_results = statuses.all()
2339
2340 grouped = {}
2341
2342 # maybe we have open new pullrequest without a status?
2343 stat = ChangesetStatus.STATUS_UNDER_REVIEW
2344 status_lbl = ChangesetStatus.get_status_lbl(stat)
2345 for pr in PullRequest.query().filter(PullRequest.source_repo == self).all():
2346 for rev in pr.revisions:
2347 pr_id = pr.pull_request_id
2348 pr_repo = pr.target_repo.repo_name
2349 grouped[rev] = [stat, status_lbl, pr_id, pr_repo]
2350
2351 for stat in status_results:
2352 pr_id = pr_repo = None
2353 if stat.pull_request:
2354 pr_id = stat.pull_request.pull_request_id
2355 pr_repo = stat.pull_request.target_repo.repo_name
2356 grouped[stat.revision] = [str(stat.status), stat.status_lbl,
2357 pr_id, pr_repo]
2358 return grouped
2359
2360 # ==========================================================================
2361 # SCM CACHE INSTANCE
2362 # ==========================================================================
2363
2364 def scm_instance(self, **kwargs):
2365 import rhodecode
2366
2367 # Passing a config will not hit the cache currently only used
2368 # for repo2dbmapper
2369 config = kwargs.pop('config', None)
2370 cache = kwargs.pop('cache', None)
2371 full_cache = str2bool(rhodecode.CONFIG.get('vcs_full_cache'))
2372 # if cache is NOT defined use default global, else we have a full
2373 # control over cache behaviour
2374 if cache is None and full_cache and not config:
2375 return self._get_instance_cached()
2376 return self._get_instance(cache=bool(cache), config=config)
2377
2378 def _get_instance_cached(self):
2379 from rhodecode.lib import rc_cache
2380
2381 cache_namespace_uid = 'cache_repo_instance.{}'.format(self.repo_id)
2382 invalidation_namespace = CacheKey.REPO_INVALIDATION_NAMESPACE.format(
2383 repo_id=self.repo_id)
2384 region = rc_cache.get_or_create_region('cache_repo_longterm', cache_namespace_uid)
2385
2386 @region.conditional_cache_on_arguments(namespace=cache_namespace_uid)
2387 def get_instance_cached(repo_id, context_id):
2388 return self._get_instance()
2389
2390 # we must use thread scoped cache here,
2391 # because each thread of gevent needs it's own not shared connection and cache
2392 # we also alter `args` so the cache key is individual for every green thread.
2393 inv_context_manager = rc_cache.InvalidationContext(
2394 uid=cache_namespace_uid, invalidation_namespace=invalidation_namespace,
2395 thread_scoped=True)
2396 with inv_context_manager as invalidation_context:
2397 args = (self.repo_id, inv_context_manager.cache_key)
2398 # re-compute and store cache if we get invalidate signal
2399 if invalidation_context.should_invalidate():
2400 instance = get_instance_cached.refresh(*args)
2401 else:
2402 instance = get_instance_cached(*args)
2403
2404 log.debug(
2405 'Repo instance fetched in %.3fs', inv_context_manager.compute_time)
2406 return instance
2407
2408 def _get_instance(self, cache=True, config=None):
2409 config = config or self._config
2410 custom_wire = {
2411 'cache': cache # controls the vcs.remote cache
2412 }
2413 repo = get_vcs_instance(
2414 repo_path=safe_str(self.repo_full_path),
2415 config=config,
2416 with_wire=custom_wire,
2417 create=False,
2418 _vcs_alias=self.repo_type)
2419
2420 return repo
2421
2422 def __json__(self):
2423 return {'landing_rev': self.landing_rev}
2424
2425 def get_dict(self):
2426
2427 # Since we transformed `repo_name` to a hybrid property, we need to
2428 # keep compatibility with the code which uses `repo_name` field.
2429
2430 result = super(Repository, self).get_dict()
2431 result['repo_name'] = result.pop('_repo_name', None)
2432 return result
2433
2434
2435 class RepoGroup(Base, BaseModel):
2436 __tablename__ = 'groups'
2437 __table_args__ = (
2438 UniqueConstraint('group_name', 'group_parent_id'),
2439 CheckConstraint('group_id != group_parent_id'),
2440 base_table_args,
2441 )
2442 __mapper_args__ = {'order_by': 'group_name'}
2443
2444 CHOICES_SEPARATOR = '/' # used to generate select2 choices for nested groups
2445
2446 group_id = Column("group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2447 group_name = Column("group_name", String(255), nullable=False, unique=True, default=None)
2448 group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None)
2449 group_description = Column("group_description", String(10000), nullable=True, unique=None, default=None)
2450 enable_locking = Column("enable_locking", Boolean(), nullable=False, unique=None, default=False)
2451 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
2452 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
2453 updated_on = Column('updated_on', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)
2454 personal = Column('personal', Boolean(), nullable=True, unique=None, default=None)
2455
2456 repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id')
2457 users_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
2458 parent_group = relationship('RepoGroup', remote_side=group_id)
2459 user = relationship('User')
2460 integrations = relationship('Integration',
2461 cascade="all, delete, delete-orphan")
2462
2463 def __init__(self, group_name='', parent_group=None):
2464 self.group_name = group_name
2465 self.parent_group = parent_group
2466
2467 def __unicode__(self):
2468 return u"<%s('id:%s:%s')>" % (
2469 self.__class__.__name__, self.group_id, self.group_name)
2470
2471 @hybrid_property
2472 def description_safe(self):
2473 from rhodecode.lib import helpers as h
2474 return h.escape(self.group_description)
2475
2476 @classmethod
2477 def _generate_choice(cls, repo_group):
2478 from webhelpers.html import literal as _literal
2479 _name = lambda k: _literal(cls.CHOICES_SEPARATOR.join(k))
2480 return repo_group.group_id, _name(repo_group.full_path_splitted)
2481
2482 @classmethod
2483 def groups_choices(cls, groups=None, show_empty_group=True):
2484 if not groups:
2485 groups = cls.query().all()
2486
2487 repo_groups = []
2488 if show_empty_group:
2489 repo_groups = [(-1, u'-- %s --' % _('No parent'))]
2490
2491 repo_groups.extend([cls._generate_choice(x) for x in groups])
2492
2493 repo_groups = sorted(
2494 repo_groups, key=lambda t: t[1].split(cls.CHOICES_SEPARATOR)[0])
2495 return repo_groups
2496
2497 @classmethod
2498 def url_sep(cls):
2499 return URL_SEP
2500
2501 @classmethod
2502 def get_by_group_name(cls, group_name, cache=False, case_insensitive=False):
2503 if case_insensitive:
2504 gr = cls.query().filter(func.lower(cls.group_name)
2505 == func.lower(group_name))
2506 else:
2507 gr = cls.query().filter(cls.group_name == group_name)
2508 if cache:
2509 name_key = _hash_key(group_name)
2510 gr = gr.options(
2511 FromCache("sql_cache_short", "get_group_%s" % name_key))
2512 return gr.scalar()
2513
2514 @classmethod
2515 def get_user_personal_repo_group(cls, user_id):
2516 user = User.get(user_id)
2517 if user.username == User.DEFAULT_USER:
2518 return None
2519
2520 return cls.query()\
2521 .filter(cls.personal == true()) \
2522 .filter(cls.user == user) \
2523 .order_by(cls.group_id.asc()) \
2524 .first()
2525
2526 @classmethod
2527 def get_all_repo_groups(cls, user_id=Optional(None), group_id=Optional(None),
2528 case_insensitive=True):
2529 q = RepoGroup.query()
2530
2531 if not isinstance(user_id, Optional):
2532 q = q.filter(RepoGroup.user_id == user_id)
2533
2534 if not isinstance(group_id, Optional):
2535 q = q.filter(RepoGroup.group_parent_id == group_id)
2536
2537 if case_insensitive:
2538 q = q.order_by(func.lower(RepoGroup.group_name))
2539 else:
2540 q = q.order_by(RepoGroup.group_name)
2541 return q.all()
2542
2543 @property
2544 def parents(self):
2545 parents_recursion_limit = 10
2546 groups = []
2547 if self.parent_group is None:
2548 return groups
2549 cur_gr = self.parent_group
2550 groups.insert(0, cur_gr)
2551 cnt = 0
2552 while 1:
2553 cnt += 1
2554 gr = getattr(cur_gr, 'parent_group', None)
2555 cur_gr = cur_gr.parent_group
2556 if gr is None:
2557 break
2558 if cnt == parents_recursion_limit:
2559 # this will prevent accidental infinit loops
2560 log.error('more than %s parents found for group %s, stopping '
2561 'recursive parent fetching', parents_recursion_limit, self)
2562 break
2563
2564 groups.insert(0, gr)
2565 return groups
2566
2567 @property
2568 def last_db_change(self):
2569 return self.updated_on
2570
2571 @property
2572 def children(self):
2573 return RepoGroup.query().filter(RepoGroup.parent_group == self)
2574
2575 @property
2576 def name(self):
2577 return self.group_name.split(RepoGroup.url_sep())[-1]
2578
2579 @property
2580 def full_path(self):
2581 return self.group_name
2582
2583 @property
2584 def full_path_splitted(self):
2585 return self.group_name.split(RepoGroup.url_sep())
2586
2587 @property
2588 def repositories(self):
2589 return Repository.query()\
2590 .filter(Repository.group == self)\
2591 .order_by(Repository.repo_name)
2592
2593 @property
2594 def repositories_recursive_count(self):
2595 cnt = self.repositories.count()
2596
2597 def children_count(group):
2598 cnt = 0
2599 for child in group.children:
2600 cnt += child.repositories.count()
2601 cnt += children_count(child)
2602 return cnt
2603
2604 return cnt + children_count(self)
2605
2606 def _recursive_objects(self, include_repos=True):
2607 all_ = []
2608
2609 def _get_members(root_gr):
2610 if include_repos:
2611 for r in root_gr.repositories:
2612 all_.append(r)
2613 childs = root_gr.children.all()
2614 if childs:
2615 for gr in childs:
2616 all_.append(gr)
2617 _get_members(gr)
2618
2619 _get_members(self)
2620 return [self] + all_
2621
2622 def recursive_groups_and_repos(self):
2623 """
2624 Recursive return all groups, with repositories in those groups
2625 """
2626 return self._recursive_objects()
2627
2628 def recursive_groups(self):
2629 """
2630 Returns all children groups for this group including children of children
2631 """
2632 return self._recursive_objects(include_repos=False)
2633
2634 def get_new_name(self, group_name):
2635 """
2636 returns new full group name based on parent and new name
2637
2638 :param group_name:
2639 """
2640 path_prefix = (self.parent_group.full_path_splitted if
2641 self.parent_group else [])
2642 return RepoGroup.url_sep().join(path_prefix + [group_name])
2643
2644 def permissions(self, with_admins=True, with_owner=True):
2645 """
2646 Permissions for repository groups
2647 """
2648 _admin_perm = 'group.admin'
2649
2650 owner_row = []
2651 if with_owner:
2652 usr = AttributeDict(self.user.get_dict())
2653 usr.owner_row = True
2654 usr.permission = _admin_perm
2655 owner_row.append(usr)
2656
2657 super_admin_ids = []
2658 super_admin_rows = []
2659 if with_admins:
2660 for usr in User.get_all_super_admins():
2661 super_admin_ids.append(usr.user_id)
2662 # if this admin is also owner, don't double the record
2663 if usr.user_id == owner_row[0].user_id:
2664 owner_row[0].admin_row = True
2665 else:
2666 usr = AttributeDict(usr.get_dict())
2667 usr.admin_row = True
2668 usr.permission = _admin_perm
2669 super_admin_rows.append(usr)
2670
2671 q = UserRepoGroupToPerm.query().filter(UserRepoGroupToPerm.group == self)
2672 q = q.options(joinedload(UserRepoGroupToPerm.group),
2673 joinedload(UserRepoGroupToPerm.user),
2674 joinedload(UserRepoGroupToPerm.permission),)
2675
2676 # get owners and admins and permissions. We do a trick of re-writing
2677 # objects from sqlalchemy to named-tuples due to sqlalchemy session
2678 # has a global reference and changing one object propagates to all
2679 # others. This means if admin is also an owner admin_row that change
2680 # would propagate to both objects
2681 perm_rows = []
2682 for _usr in q.all():
2683 usr = AttributeDict(_usr.user.get_dict())
2684 # if this user is also owner/admin, mark as duplicate record
2685 if usr.user_id == owner_row[0].user_id or usr.user_id in super_admin_ids:
2686 usr.duplicate_perm = True
2687 usr.permission = _usr.permission.permission_name
2688 perm_rows.append(usr)
2689
2690 # filter the perm rows by 'default' first and then sort them by
2691 # admin,write,read,none permissions sorted again alphabetically in
2692 # each group
2693 perm_rows = sorted(perm_rows, key=display_user_sort)
2694
2695 return super_admin_rows + owner_row + perm_rows
2696
2697 def permission_user_groups(self):
2698 q = UserGroupRepoGroupToPerm.query().filter(
2699 UserGroupRepoGroupToPerm.group == self)
2700 q = q.options(joinedload(UserGroupRepoGroupToPerm.group),
2701 joinedload(UserGroupRepoGroupToPerm.users_group),
2702 joinedload(UserGroupRepoGroupToPerm.permission),)
2703
2704 perm_rows = []
2705 for _user_group in q.all():
2706 usr = AttributeDict(_user_group.users_group.get_dict())
2707 usr.permission = _user_group.permission.permission_name
2708 perm_rows.append(usr)
2709
2710 perm_rows = sorted(perm_rows, key=display_user_group_sort)
2711 return perm_rows
2712
2713 def get_api_data(self):
2714 """
2715 Common function for generating api data
2716
2717 """
2718 group = self
2719 data = {
2720 'group_id': group.group_id,
2721 'group_name': group.group_name,
2722 'group_description': group.description_safe,
2723 'parent_group': group.parent_group.group_name if group.parent_group else None,
2724 'repositories': [x.repo_name for x in group.repositories],
2725 'owner': group.user.username,
2726 }
2727 return data
2728
2729
2730 class Permission(Base, BaseModel):
2731 __tablename__ = 'permissions'
2732 __table_args__ = (
2733 Index('p_perm_name_idx', 'permission_name'),
2734 base_table_args,
2735 )
2736
2737 PERMS = [
2738 ('hg.admin', _('RhodeCode Super Administrator')),
2739
2740 ('repository.none', _('Repository no access')),
2741 ('repository.read', _('Repository read access')),
2742 ('repository.write', _('Repository write access')),
2743 ('repository.admin', _('Repository admin access')),
2744
2745 ('group.none', _('Repository group no access')),
2746 ('group.read', _('Repository group read access')),
2747 ('group.write', _('Repository group write access')),
2748 ('group.admin', _('Repository group admin access')),
2749
2750 ('usergroup.none', _('User group no access')),
2751 ('usergroup.read', _('User group read access')),
2752 ('usergroup.write', _('User group write access')),
2753 ('usergroup.admin', _('User group admin access')),
2754
2755 ('branch.none', _('Branch no permissions')),
2756 ('branch.merge', _('Branch access by web merge')),
2757 ('branch.push', _('Branch access by push')),
2758 ('branch.push_force', _('Branch access by push with force')),
2759
2760 ('hg.repogroup.create.false', _('Repository Group creation disabled')),
2761 ('hg.repogroup.create.true', _('Repository Group creation enabled')),
2762
2763 ('hg.usergroup.create.false', _('User Group creation disabled')),
2764 ('hg.usergroup.create.true', _('User Group creation enabled')),
2765
2766 ('hg.create.none', _('Repository creation disabled')),
2767 ('hg.create.repository', _('Repository creation enabled')),
2768 ('hg.create.write_on_repogroup.true', _('Repository creation enabled with write permission to a repository group')),
2769 ('hg.create.write_on_repogroup.false', _('Repository creation disabled with write permission to a repository group')),
2770
2771 ('hg.fork.none', _('Repository forking disabled')),
2772 ('hg.fork.repository', _('Repository forking enabled')),
2773
2774 ('hg.register.none', _('Registration disabled')),
2775 ('hg.register.manual_activate', _('User Registration with manual account activation')),
2776 ('hg.register.auto_activate', _('User Registration with automatic account activation')),
2777
2778 ('hg.password_reset.enabled', _('Password reset enabled')),
2779 ('hg.password_reset.hidden', _('Password reset hidden')),
2780 ('hg.password_reset.disabled', _('Password reset disabled')),
2781
2782 ('hg.extern_activate.manual', _('Manual activation of external account')),
2783 ('hg.extern_activate.auto', _('Automatic activation of external account')),
2784
2785 ('hg.inherit_default_perms.false', _('Inherit object permissions from default user disabled')),
2786 ('hg.inherit_default_perms.true', _('Inherit object permissions from default user enabled')),
2787 ]
2788
2789 # definition of system default permissions for DEFAULT user, created on
2790 # system setup
2791 DEFAULT_USER_PERMISSIONS = [
2792 # object perms
2793 'repository.read',
2794 'group.read',
2795 'usergroup.read',
2796 # branch, for backward compat we need same value as before so forced pushed
2797 'branch.push_force',
2798 # global
2799 'hg.create.repository',
2800 'hg.repogroup.create.false',
2801 'hg.usergroup.create.false',
2802 'hg.create.write_on_repogroup.true',
2803 'hg.fork.repository',
2804 'hg.register.manual_activate',
2805 'hg.password_reset.enabled',
2806 'hg.extern_activate.auto',
2807 'hg.inherit_default_perms.true',
2808 ]
2809
2810 # defines which permissions are more important higher the more important
2811 # Weight defines which permissions are more important.
2812 # The higher number the more important.
2813 PERM_WEIGHTS = {
2814 'repository.none': 0,
2815 'repository.read': 1,
2816 'repository.write': 3,
2817 'repository.admin': 4,
2818
2819 'group.none': 0,
2820 'group.read': 1,
2821 'group.write': 3,
2822 'group.admin': 4,
2823
2824 'usergroup.none': 0,
2825 'usergroup.read': 1,
2826 'usergroup.write': 3,
2827 'usergroup.admin': 4,
2828
2829 'branch.none': 0,
2830 'branch.merge': 1,
2831 'branch.push': 3,
2832 'branch.push_force': 4,
2833
2834 'hg.repogroup.create.false': 0,
2835 'hg.repogroup.create.true': 1,
2836
2837 'hg.usergroup.create.false': 0,
2838 'hg.usergroup.create.true': 1,
2839
2840 'hg.fork.none': 0,
2841 'hg.fork.repository': 1,
2842 'hg.create.none': 0,
2843 'hg.create.repository': 1
2844 }
2845
2846 permission_id = Column("permission_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
2847 permission_name = Column("permission_name", String(255), nullable=True, unique=None, default=None)
2848 permission_longname = Column("permission_longname", String(255), nullable=True, unique=None, default=None)
2849
2850 def __unicode__(self):
2851 return u"<%s('%s:%s')>" % (
2852 self.__class__.__name__, self.permission_id, self.permission_name
2853 )
2854
2855 @classmethod
2856 def get_by_key(cls, key):
2857 return cls.query().filter(cls.permission_name == key).scalar()
2858
2859 @classmethod
2860 def get_default_repo_perms(cls, user_id, repo_id=None):
2861 q = Session().query(UserRepoToPerm, Repository, Permission)\
2862 .join((Permission, UserRepoToPerm.permission_id == Permission.permission_id))\
2863 .join((Repository, UserRepoToPerm.repository_id == Repository.repo_id))\
2864 .filter(UserRepoToPerm.user_id == user_id)
2865 if repo_id:
2866 q = q.filter(UserRepoToPerm.repository_id == repo_id)
2867 return q.all()
2868
2869 @classmethod
2870 def get_default_repo_branch_perms(cls, user_id, repo_id=None):
2871 q = Session().query(UserToRepoBranchPermission, UserRepoToPerm, Permission) \
2872 .join(
2873 Permission,
2874 UserToRepoBranchPermission.permission_id == Permission.permission_id) \
2875 .join(
2876 UserRepoToPerm,
2877 UserToRepoBranchPermission.rule_to_perm_id == UserRepoToPerm.repo_to_perm_id) \
2878 .filter(UserRepoToPerm.user_id == user_id)
2879
2880 if repo_id:
2881 q = q.filter(UserToRepoBranchPermission.repository_id == repo_id)
2882 return q.order_by(UserToRepoBranchPermission.rule_order).all()
2883
2884 @classmethod
2885 def get_default_repo_perms_from_user_group(cls, user_id, repo_id=None):
2886 q = Session().query(UserGroupRepoToPerm, Repository, Permission)\
2887 .join(
2888 Permission,
2889 UserGroupRepoToPerm.permission_id == Permission.permission_id)\
2890 .join(
2891 Repository,
2892 UserGroupRepoToPerm.repository_id == Repository.repo_id)\
2893 .join(
2894 UserGroup,
2895 UserGroupRepoToPerm.users_group_id ==
2896 UserGroup.users_group_id)\
2897 .join(
2898 UserGroupMember,
2899 UserGroupRepoToPerm.users_group_id ==
2900 UserGroupMember.users_group_id)\
2901 .filter(
2902 UserGroupMember.user_id == user_id,
2903 UserGroup.users_group_active == true())
2904 if repo_id:
2905 q = q.filter(UserGroupRepoToPerm.repository_id == repo_id)
2906 return q.all()
2907
2908 @classmethod
2909 def get_default_repo_branch_perms_from_user_group(cls, user_id, repo_id=None):
2910 q = Session().query(UserGroupToRepoBranchPermission, UserGroupRepoToPerm, Permission) \
2911 .join(
2912 Permission,
2913 UserGroupToRepoBranchPermission.permission_id == Permission.permission_id) \
2914 .join(
2915 UserGroupRepoToPerm,
2916 UserGroupToRepoBranchPermission.rule_to_perm_id == UserGroupRepoToPerm.users_group_to_perm_id) \
2917 .join(
2918 UserGroup,
2919 UserGroupRepoToPerm.users_group_id == UserGroup.users_group_id) \
2920 .join(
2921 UserGroupMember,
2922 UserGroupRepoToPerm.users_group_id == UserGroupMember.users_group_id) \
2923 .filter(
2924 UserGroupMember.user_id == user_id,
2925 UserGroup.users_group_active == true())
2926
2927 if repo_id:
2928 q = q.filter(UserGroupToRepoBranchPermission.repository_id == repo_id)
2929 return q.order_by(UserGroupToRepoBranchPermission.rule_order).all()
2930
2931 @classmethod
2932 def get_default_group_perms(cls, user_id, repo_group_id=None):
2933 q = Session().query(UserRepoGroupToPerm, RepoGroup, Permission)\
2934 .join(
2935 Permission,
2936 UserRepoGroupToPerm.permission_id == Permission.permission_id)\
2937 .join(
2938 RepoGroup,
2939 UserRepoGroupToPerm.group_id == RepoGroup.group_id)\
2940 .filter(UserRepoGroupToPerm.user_id == user_id)
2941 if repo_group_id:
2942 q = q.filter(UserRepoGroupToPerm.group_id == repo_group_id)
2943 return q.all()
2944
2945 @classmethod
2946 def get_default_group_perms_from_user_group(
2947 cls, user_id, repo_group_id=None):
2948 q = Session().query(UserGroupRepoGroupToPerm, RepoGroup, Permission)\
2949 .join(
2950 Permission,
2951 UserGroupRepoGroupToPerm.permission_id ==
2952 Permission.permission_id)\
2953 .join(
2954 RepoGroup,
2955 UserGroupRepoGroupToPerm.group_id == RepoGroup.group_id)\
2956 .join(
2957 UserGroup,
2958 UserGroupRepoGroupToPerm.users_group_id ==
2959 UserGroup.users_group_id)\
2960 .join(
2961 UserGroupMember,
2962 UserGroupRepoGroupToPerm.users_group_id ==
2963 UserGroupMember.users_group_id)\
2964 .filter(
2965 UserGroupMember.user_id == user_id,
2966 UserGroup.users_group_active == true())
2967 if repo_group_id:
2968 q = q.filter(UserGroupRepoGroupToPerm.group_id == repo_group_id)
2969 return q.all()
2970
2971 @classmethod
2972 def get_default_user_group_perms(cls, user_id, user_group_id=None):
2973 q = Session().query(UserUserGroupToPerm, UserGroup, Permission)\
2974 .join((Permission, UserUserGroupToPerm.permission_id == Permission.permission_id))\
2975 .join((UserGroup, UserUserGroupToPerm.user_group_id == UserGroup.users_group_id))\
2976 .filter(UserUserGroupToPerm.user_id == user_id)
2977 if user_group_id:
2978 q = q.filter(UserUserGroupToPerm.user_group_id == user_group_id)
2979 return q.all()
2980
2981 @classmethod
2982 def get_default_user_group_perms_from_user_group(
2983 cls, user_id, user_group_id=None):
2984 TargetUserGroup = aliased(UserGroup, name='target_user_group')
2985 q = Session().query(UserGroupUserGroupToPerm, UserGroup, Permission)\
2986 .join(
2987 Permission,
2988 UserGroupUserGroupToPerm.permission_id ==
2989 Permission.permission_id)\
2990 .join(
2991 TargetUserGroup,
2992 UserGroupUserGroupToPerm.target_user_group_id ==
2993 TargetUserGroup.users_group_id)\
2994 .join(
2995 UserGroup,
2996 UserGroupUserGroupToPerm.user_group_id ==
2997 UserGroup.users_group_id)\
2998 .join(
2999 UserGroupMember,
3000 UserGroupUserGroupToPerm.user_group_id ==
3001 UserGroupMember.users_group_id)\
3002 .filter(
3003 UserGroupMember.user_id == user_id,
3004 UserGroup.users_group_active == true())
3005 if user_group_id:
3006 q = q.filter(
3007 UserGroupUserGroupToPerm.user_group_id == user_group_id)
3008
3009 return q.all()
3010
3011
3012 class UserRepoToPerm(Base, BaseModel):
3013 __tablename__ = 'repo_to_perm'
3014 __table_args__ = (
3015 UniqueConstraint('user_id', 'repository_id', 'permission_id'),
3016 base_table_args
3017 )
3018
3019 repo_to_perm_id = Column("repo_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3020 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
3021 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
3022 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
3023
3024 user = relationship('User')
3025 repository = relationship('Repository')
3026 permission = relationship('Permission')
3027
3028 branch_perm_entry = relationship('UserToRepoBranchPermission', cascade="all, delete, delete-orphan", lazy='joined')
3029
3030 @classmethod
3031 def create(cls, user, repository, permission):
3032 n = cls()
3033 n.user = user
3034 n.repository = repository
3035 n.permission = permission
3036 Session().add(n)
3037 return n
3038
3039 def __unicode__(self):
3040 return u'<%s => %s >' % (self.user, self.repository)
3041
3042
3043 class UserUserGroupToPerm(Base, BaseModel):
3044 __tablename__ = 'user_user_group_to_perm'
3045 __table_args__ = (
3046 UniqueConstraint('user_id', 'user_group_id', 'permission_id'),
3047 base_table_args
3048 )
3049
3050 user_user_group_to_perm_id = Column("user_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3051 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
3052 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
3053 user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
3054
3055 user = relationship('User')
3056 user_group = relationship('UserGroup')
3057 permission = relationship('Permission')
3058
3059 @classmethod
3060 def create(cls, user, user_group, permission):
3061 n = cls()
3062 n.user = user
3063 n.user_group = user_group
3064 n.permission = permission
3065 Session().add(n)
3066 return n
3067
3068 def __unicode__(self):
3069 return u'<%s => %s >' % (self.user, self.user_group)
3070
3071
3072 class UserToPerm(Base, BaseModel):
3073 __tablename__ = 'user_to_perm'
3074 __table_args__ = (
3075 UniqueConstraint('user_id', 'permission_id'),
3076 base_table_args
3077 )
3078
3079 user_to_perm_id = Column("user_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3080 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
3081 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
3082
3083 user = relationship('User')
3084 permission = relationship('Permission', lazy='joined')
3085
3086 def __unicode__(self):
3087 return u'<%s => %s >' % (self.user, self.permission)
3088
3089
3090 class UserGroupRepoToPerm(Base, BaseModel):
3091 __tablename__ = 'users_group_repo_to_perm'
3092 __table_args__ = (
3093 UniqueConstraint('repository_id', 'users_group_id', 'permission_id'),
3094 base_table_args
3095 )
3096
3097 users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3098 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
3099 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
3100 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
3101
3102 users_group = relationship('UserGroup')
3103 permission = relationship('Permission')
3104 repository = relationship('Repository')
3105 user_group_branch_perms = relationship('UserGroupToRepoBranchPermission', cascade='all')
3106
3107 @classmethod
3108 def create(cls, users_group, repository, permission):
3109 n = cls()
3110 n.users_group = users_group
3111 n.repository = repository
3112 n.permission = permission
3113 Session().add(n)
3114 return n
3115
3116 def __unicode__(self):
3117 return u'<UserGroupRepoToPerm:%s => %s >' % (self.users_group, self.repository)
3118
3119
3120 class UserGroupUserGroupToPerm(Base, BaseModel):
3121 __tablename__ = 'user_group_user_group_to_perm'
3122 __table_args__ = (
3123 UniqueConstraint('target_user_group_id', 'user_group_id', 'permission_id'),
3124 CheckConstraint('target_user_group_id != user_group_id'),
3125 base_table_args
3126 )
3127
3128 user_group_user_group_to_perm_id = Column("user_group_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3129 target_user_group_id = Column("target_user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
3130 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
3131 user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
3132
3133 target_user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id')
3134 user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.user_group_id==UserGroup.users_group_id')
3135 permission = relationship('Permission')
3136
3137 @classmethod
3138 def create(cls, target_user_group, user_group, permission):
3139 n = cls()
3140 n.target_user_group = target_user_group
3141 n.user_group = user_group
3142 n.permission = permission
3143 Session().add(n)
3144 return n
3145
3146 def __unicode__(self):
3147 return u'<UserGroupUserGroup:%s => %s >' % (self.target_user_group, self.user_group)
3148
3149
3150 class UserGroupToPerm(Base, BaseModel):
3151 __tablename__ = 'users_group_to_perm'
3152 __table_args__ = (
3153 UniqueConstraint('users_group_id', 'permission_id',),
3154 base_table_args
3155 )
3156
3157 users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3158 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
3159 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
3160
3161 users_group = relationship('UserGroup')
3162 permission = relationship('Permission')
3163
3164
3165 class UserRepoGroupToPerm(Base, BaseModel):
3166 __tablename__ = 'user_repo_group_to_perm'
3167 __table_args__ = (
3168 UniqueConstraint('user_id', 'group_id', 'permission_id'),
3169 base_table_args
3170 )
3171
3172 group_to_perm_id = Column("group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3173 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
3174 group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
3175 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
3176
3177 user = relationship('User')
3178 group = relationship('RepoGroup')
3179 permission = relationship('Permission')
3180
3181 @classmethod
3182 def create(cls, user, repository_group, permission):
3183 n = cls()
3184 n.user = user
3185 n.group = repository_group
3186 n.permission = permission
3187 Session().add(n)
3188 return n
3189
3190
3191 class UserGroupRepoGroupToPerm(Base, BaseModel):
3192 __tablename__ = 'users_group_repo_group_to_perm'
3193 __table_args__ = (
3194 UniqueConstraint('users_group_id', 'group_id'),
3195 base_table_args
3196 )
3197
3198 users_group_repo_group_to_perm_id = Column("users_group_repo_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3199 users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
3200 group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
3201 permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
3202
3203 users_group = relationship('UserGroup')
3204 permission = relationship('Permission')
3205 group = relationship('RepoGroup')
3206
3207 @classmethod
3208 def create(cls, user_group, repository_group, permission):
3209 n = cls()
3210 n.users_group = user_group
3211 n.group = repository_group
3212 n.permission = permission
3213 Session().add(n)
3214 return n
3215
3216 def __unicode__(self):
3217 return u'<UserGroupRepoGroupToPerm:%s => %s >' % (self.users_group, self.group)
3218
3219
3220 class Statistics(Base, BaseModel):
3221 __tablename__ = 'statistics'
3222 __table_args__ = (
3223 base_table_args
3224 )
3225
3226 stat_id = Column("stat_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3227 repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True, default=None)
3228 stat_on_revision = Column("stat_on_revision", Integer(), nullable=False)
3229 commit_activity = Column("commit_activity", LargeBinary(1000000), nullable=False)#JSON data
3230 commit_activity_combined = Column("commit_activity_combined", LargeBinary(), nullable=False)#JSON data
3231 languages = Column("languages", LargeBinary(1000000), nullable=False)#JSON data
3232
3233 repository = relationship('Repository', single_parent=True)
3234
3235
3236 class UserFollowing(Base, BaseModel):
3237 __tablename__ = 'user_followings'
3238 __table_args__ = (
3239 UniqueConstraint('user_id', 'follows_repository_id'),
3240 UniqueConstraint('user_id', 'follows_user_id'),
3241 base_table_args
3242 )
3243
3244 user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3245 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
3246 follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None)
3247 follows_user_id = Column("follows_user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
3248 follows_from = Column('follows_from', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)
3249
3250 user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id')
3251
3252 follows_user = relationship('User', primaryjoin='User.user_id==UserFollowing.follows_user_id')
3253 follows_repository = relationship('Repository', order_by='Repository.repo_name')
3254
3255 @classmethod
3256 def get_repo_followers(cls, repo_id):
3257 return cls.query().filter(cls.follows_repo_id == repo_id)
3258
3259
3260 class CacheKey(Base, BaseModel):
3261 __tablename__ = 'cache_invalidation'
3262 __table_args__ = (
3263 UniqueConstraint('cache_key'),
3264 Index('key_idx', 'cache_key'),
3265 base_table_args,
3266 )
3267
3268 CACHE_TYPE_FEED = 'FEED'
3269 CACHE_TYPE_README = 'README'
3270 # namespaces used to register process/thread aware caches
3271 REPO_INVALIDATION_NAMESPACE = 'repo_cache:{repo_id}'
3272 SETTINGS_INVALIDATION_NAMESPACE = 'system_settings'
3273
3274 cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
3275 cache_key = Column("cache_key", String(255), nullable=True, unique=None, default=None)
3276 cache_args = Column("cache_args", String(255), nullable=True, unique=None, default=None)
3277 cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False)
3278
3279 def __init__(self, cache_key, cache_args=''):
3280 self.cache_key = cache_key
3281 self.cache_args = cache_args
3282 self.cache_active = False
3283
3284 def __unicode__(self):
3285 return u"<%s('%s:%s[%s]')>" % (
3286 self.__class__.__name__,
3287 self.cache_id, self.cache_key, self.cache_active)
3288
3289 def _cache_key_partition(self):
3290 prefix, repo_name, suffix = self.cache_key.partition(self.cache_args)
3291 return prefix, repo_name, suffix
3292
3293 def get_prefix(self):
3294 """
3295 Try to extract prefix from existing cache key. The key could consist
3296 of prefix, repo_name, suffix
3297 """
3298 # this returns prefix, repo_name, suffix
3299 return self._cache_key_partition()[0]
3300
3301 def get_suffix(self):
3302 """
3303 get suffix that might have been used in _get_cache_key to
3304 generate self.cache_key. Only used for informational purposes
3305 in repo_edit.mako.
3306 """
3307 # prefix, repo_name, suffix
3308 return self._cache_key_partition()[2]
3309
3310 @classmethod
3311 def delete_all_cache(cls):
3312 """
3313 Delete all cache keys from database.
3314 Should only be run when all instances are down and all entries
3315 thus stale.
3316 """
3317 cls.query().delete()
3318 Session().commit()
3319
3320 @classmethod
3321 def set_invalidate(cls, cache_uid, delete=False):
3322 """
3323 Mark all caches of a repo as invalid in the database.
3324 """
3325
3326 try:
3327 qry = Session().query(cls).filter(cls.cache_args == cache_uid)
3328 if delete:
3329 qry.delete()
3330 log.debug('cache objects deleted for cache args %s',
3331 safe_str(cache_uid))
3332 else:
3333 qry.update({"cache_active": False})
3334 log.debug('cache objects marked as invalid for cache args %s',
3335 safe_str(cache_uid))
3336
3337 Session().commit()
3338 except Exception:
3339 log.exception(
3340 'Cache key invalidation failed for cache args %s',
3341 safe_str(cache_uid))
3342 Session().rollback()
3343
3344 @classmethod
3345 def get_active_cache(cls, cache_key):
3346 inv_obj = cls.query().filter(cls.cache_key == cache_key).scalar()
3347 if inv_obj:
3348 return inv_obj
3349 return None
3350
3351
3352 class ChangesetComment(Base, BaseModel):
3353 __tablename__ = 'changeset_comments'
3354 __table_args__ = (
3355 Index('cc_revision_idx', 'revision'),
3356 base_table_args,
3357 )
3358
3359 COMMENT_OUTDATED = u'comment_outdated'
3360 COMMENT_TYPE_NOTE = u'note'
3361 COMMENT_TYPE_TODO = u'todo'
3362 COMMENT_TYPES = [COMMENT_TYPE_NOTE, COMMENT_TYPE_TODO]
3363
3364 comment_id = Column('comment_id', Integer(), nullable=False, primary_key=True)
3365 repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)
3366 revision = Column('revision', String(40), nullable=True)
3367 pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)
3368 pull_request_version_id = Column("pull_request_version_id", Integer(), ForeignKey('pull_request_versions.pull_request_version_id'), nullable=True)
3369 line_no = Column('line_no', Unicode(10), nullable=True)
3370 hl_lines = Column('hl_lines', Unicode(512), nullable=True)
3371 f_path = Column('f_path', Unicode(1000), nullable=True)
3372 user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)
3373 text = Column('text', UnicodeText().with_variant(UnicodeText(25000), 'mysql'), nullable=False)
3374 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
3375 modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
3376 renderer = Column('renderer', Unicode(64), nullable=True)
3377 display_state = Column('display_state', Unicode(128), nullable=True)
3378
3379 comment_type = Column('comment_type', Unicode(128), nullable=True, default=COMMENT_TYPE_NOTE)
3380 resolved_comment_id = Column('resolved_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'), nullable=True)
3381
3382 resolved_comment = relationship('ChangesetComment', remote_side=comment_id, back_populates='resolved_by')
3383 resolved_by = relationship('ChangesetComment', back_populates='resolved_comment')
3384
3385 author = relationship('User', lazy='joined')
3386 repo = relationship('Repository')
3387 status_change = relationship('ChangesetStatus', cascade="all, delete, delete-orphan", lazy='joined')
3388 pull_request = relationship('PullRequest', lazy='joined')
3389 pull_request_version = relationship('PullRequestVersion')
3390
3391 @classmethod
3392 def get_users(cls, revision=None, pull_request_id=None):
3393 """
3394 Returns user associated with this ChangesetComment. ie those
3395 who actually commented
3396
3397 :param cls:
3398 :param revision:
3399 """
3400 q = Session().query(User)\
3401 .join(ChangesetComment.author)
3402 if revision:
3403 q = q.filter(cls.revision == revision)
3404 elif pull_request_id:
3405 q = q.filter(cls.pull_request_id == pull_request_id)
3406 return q.all()
3407
3408 @classmethod
3409 def get_index_from_version(cls, pr_version, versions):
3410 num_versions = [x.pull_request_version_id for x in versions]
3411 try:
3412 return num_versions.index(pr_version) +1
3413 except (IndexError, ValueError):
3414 return
3415
3416 @property
3417 def outdated(self):
3418 return self.display_state == self.COMMENT_OUTDATED
3419
3420 def outdated_at_version(self, version):
3421 """
3422 Checks if comment is outdated for given pull request version
3423 """
3424 return self.outdated and self.pull_request_version_id != version
3425
3426 def older_than_version(self, version):
3427 """
3428 Checks if comment is made from previous version than given
3429 """
3430 if version is None:
3431 return self.pull_request_version_id is not None
3432
3433 return self.pull_request_version_id < version
3434
3435 @property
3436 def resolved(self):
3437 return self.resolved_by[0] if self.resolved_by else None
3438
3439 @property
3440 def is_todo(self):
3441 return self.comment_type == self.COMMENT_TYPE_TODO
3442
3443 @property
3444 def is_inline(self):
3445 return self.line_no and self.f_path
3446
3447 def get_index_version(self, versions):
3448 return self.get_index_from_version(
3449 self.pull_request_version_id, versions)
3450
3451 def __repr__(self):
3452 if self.comment_id:
3453 return '<DB:Comment #%s>' % self.comment_id
3454 else:
3455 return '<DB:Comment at %#x>' % id(self)
3456
3457 def get_api_data(self):
3458 comment = self
3459 data = {
3460 'comment_id': comment.comment_id,
3461 'comment_type': comment.comment_type,
3462 'comment_text': comment.text,
3463 'comment_status': comment.status_change,
3464 'comment_f_path': comment.f_path,
3465 'comment_lineno': comment.line_no,
3466 'comment_author': comment.author,
3467 'comment_created_on': comment.created_on
3468 }
3469 return data
3470
3471 def __json__(self):
3472 data = dict()
3473 data.update(self.get_api_data())
3474 return data
3475
3476
3477 class ChangesetStatus(Base, BaseModel):
3478 __tablename__ = 'changeset_statuses'
3479 __table_args__ = (
3480 Index('cs_revision_idx', 'revision'),
3481 Index('cs_version_idx', 'version'),
3482 UniqueConstraint('repo_id', 'revision', 'version'),
3483 base_table_args
3484 )
3485
3486 STATUS_NOT_REVIEWED = DEFAULT = 'not_reviewed'
3487 STATUS_APPROVED = 'approved'
3488 STATUS_REJECTED = 'rejected'
3489 STATUS_UNDER_REVIEW = 'under_review'
3490
3491 STATUSES = [
3492 (STATUS_NOT_REVIEWED, _("Not Reviewed")), # (no icon) and default
3493 (STATUS_APPROVED, _("Approved")),
3494 (STATUS_REJECTED, _("Rejected")),
3495 (STATUS_UNDER_REVIEW, _("Under Review")),
3496 ]
3497
3498 changeset_status_id = Column('changeset_status_id', Integer(), nullable=False, primary_key=True)
3499 repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)
3500 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None)
3501 revision = Column('revision', String(40), nullable=False)
3502 status = Column('status', String(128), nullable=False, default=DEFAULT)
3503 changeset_comment_id = Column('changeset_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'))
3504 modified_at = Column('modified_at', DateTime(), nullable=False, default=datetime.datetime.now)
3505 version = Column('version', Integer(), nullable=False, default=0)
3506 pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)
3507
3508 author = relationship('User', lazy='joined')
3509 repo = relationship('Repository')
3510 comment = relationship('ChangesetComment', lazy='joined')
3511 pull_request = relationship('PullRequest', lazy='joined')
3512
3513 def __unicode__(self):
3514 return u"<%s('%s[v%s]:%s')>" % (
3515 self.__class__.__name__,
3516 self.status, self.version, self.author
3517 )
3518
3519 @classmethod
3520 def get_status_lbl(cls, value):
3521 return dict(cls.STATUSES).get(value)
3522
3523 @property
3524 def status_lbl(self):
3525 return ChangesetStatus.get_status_lbl(self.status)
3526
3527 def get_api_data(self):
3528 status = self
3529 data = {
3530 'status_id': status.changeset_status_id,
3531 'status': status.status,
3532 }
3533 return data
3534
3535 def __json__(self):
3536 data = dict()
3537 data.update(self.get_api_data())
3538 return data
3539
3540
3541 class _PullRequestBase(BaseModel):
3542 """
3543 Common attributes of pull request and version entries.
3544 """
3545
3546 # .status values
3547 STATUS_NEW = u'new'
3548 STATUS_OPEN = u'open'
3549 STATUS_CLOSED = u'closed'
3550
3551 # available states
3552 STATE_CREATING = u'creating'
3553 STATE_UPDATING = u'updating'
3554 STATE_MERGING = u'merging'
3555 STATE_CREATED = u'created'
3556
3557 title = Column('title', Unicode(255), nullable=True)
3558 description = Column(
3559 'description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'),
3560 nullable=True)
3561 description_renderer = Column('description_renderer', Unicode(64), nullable=True)
3562
3563 # new/open/closed status of pull request (not approve/reject/etc)
3564 status = Column('status', Unicode(255), nullable=False, default=STATUS_NEW)
3565 created_on = Column(
3566 'created_on', DateTime(timezone=False), nullable=False,
3567 default=datetime.datetime.now)
3568 updated_on = Column(
3569 'updated_on', DateTime(timezone=False), nullable=False,
3570 default=datetime.datetime.now)
3571
3572 pull_request_state = Column("pull_request_state", String(255), nullable=True)
3573
3574 @declared_attr
3575 def user_id(cls):
3576 return Column(
3577 "user_id", Integer(), ForeignKey('users.user_id'), nullable=False,
3578 unique=None)
3579
3580 # 500 revisions max
3581 _revisions = Column(
3582 'revisions', UnicodeText().with_variant(UnicodeText(20500), 'mysql'))
3583
3584 @declared_attr
3585 def source_repo_id(cls):
3586 # TODO: dan: rename column to source_repo_id
3587 return Column(
3588 'org_repo_id', Integer(), ForeignKey('repositories.repo_id'),
3589 nullable=False)
3590
3591 _source_ref = Column('org_ref', Unicode(255), nullable=False)
3592
3593 @hybrid_property
3594 def source_ref(self):
3595 return self._source_ref
3596
3597 @source_ref.setter
3598 def source_ref(self, val):
3599 parts = (val or '').split(':')
3600 if len(parts) != 3:
3601 raise ValueError(
3602 'Invalid reference format given: {}, expected X:Y:Z'.format(val))
3603 self._source_ref = safe_unicode(val)
3604
3605 _target_ref = Column('other_ref', Unicode(255), nullable=False)
3606
3607 @hybrid_property
3608 def target_ref(self):
3609 return self._target_ref
3610
3611 @target_ref.setter
3612 def target_ref(self, val):
3613 parts = (val or '').split(':')
3614 if len(parts) != 3:
3615 raise ValueError(
3616 'Invalid reference format given: {}, expected X:Y:Z'.format(val))
3617 self._target_ref = safe_unicode(val)
3618
3619 @declared_attr
3620 def target_repo_id(cls):
3621 # TODO: dan: rename column to target_repo_id
3622 return Column(
3623 'other_repo_id', Integer(), ForeignKey('repositories.repo_id'),
3624 nullable=False)
3625
3626 _shadow_merge_ref = Column('shadow_merge_ref', Unicode(255), nullable=True)
3627
3628 # TODO: dan: rename column to last_merge_source_rev
3629 _last_merge_source_rev = Column(
3630 'last_merge_org_rev', String(40), nullable=True)
3631 # TODO: dan: rename column to last_merge_target_rev
3632 _last_merge_target_rev = Column(
3633 'last_merge_other_rev', String(40), nullable=True)
3634 _last_merge_status = Column('merge_status', Integer(), nullable=True)
3635 merge_rev = Column('merge_rev', String(40), nullable=True)
3636
3637 reviewer_data = Column(
3638 'reviewer_data_json', MutationObj.as_mutable(
3639 JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))
3640
3641 @property
3642 def reviewer_data_json(self):
3643 return json.dumps(self.reviewer_data)
3644
3645 @hybrid_property
3646 def description_safe(self):
3647 from rhodecode.lib import helpers as h
3648 return h.escape(self.description)
3649
3650 @hybrid_property
3651 def revisions(self):
3652 return self._revisions.split(':') if self._revisions else []
3653
3654 @revisions.setter
3655 def revisions(self, val):
3656 self._revisions = ':'.join(val)
3657
3658 @hybrid_property
3659 def last_merge_status(self):
3660 return safe_int(self._last_merge_status)
3661
3662 @last_merge_status.setter
3663 def last_merge_status(self, val):
3664 self._last_merge_status = val
3665
3666 @declared_attr
3667 def author(cls):
3668 return relationship('User', lazy='joined')
3669
3670 @declared_attr
3671 def source_repo(cls):
3672 return relationship(
3673 'Repository',
3674 primaryjoin='%s.source_repo_id==Repository.repo_id' % cls.__name__)
3675
3676 @property
3677 def source_ref_parts(self):
3678 return self.unicode_to_reference(self.source_ref)
3679
3680 @declared_attr
3681 def target_repo(cls):
3682 return relationship(
3683 'Repository',
3684 primaryjoin='%s.target_repo_id==Repository.repo_id' % cls.__name__)
3685
3686 @property
3687 def target_ref_parts(self):
3688 return self.unicode_to_reference(self.target_ref)
3689
3690 @property
3691 def shadow_merge_ref(self):
3692 return self.unicode_to_reference(self._shadow_merge_ref)
3693
3694 @shadow_merge_ref.setter
3695 def shadow_merge_ref(self, ref):
3696 self._shadow_merge_ref = self.reference_to_unicode(ref)
3697
3698 @staticmethod
3699 def unicode_to_reference(raw):
3700 """
3701 Convert a unicode (or string) to a reference object.
3702 If unicode evaluates to False it returns None.
3703 """
3704 if raw:
3705 refs = raw.split(':')
3706 return Reference(*refs)
3707 else:
3708 return None
3709
3710 @staticmethod
3711 def reference_to_unicode(ref):
3712 """
3713 Convert a reference object to unicode.
3714 If reference is None it returns None.
3715 """
3716 if ref:
3717 return u':'.join(ref)
3718 else:
3719 return None
3720
3721 def get_api_data(self, with_merge_state=True):
3722 from rhodecode.model.pull_request import PullRequestModel
3723
3724 pull_request = self
3725 if with_merge_state:
3726 merge_status = PullRequestModel().merge_status(pull_request)
3727 merge_state = {
3728 'status': merge_status[0],
3729 'message': safe_unicode(merge_status[1]),
3730 }
3731 else:
3732 merge_state = {'status': 'not_available',
3733 'message': 'not_available'}
3734
3735 merge_data = {
3736 'clone_url': PullRequestModel().get_shadow_clone_url(pull_request),
3737 'reference': (
3738 pull_request.shadow_merge_ref._asdict()
3739 if pull_request.shadow_merge_ref else None),
3740 }
3741
3742 data = {
3743 'pull_request_id': pull_request.pull_request_id,
3744 'url': PullRequestModel().get_url(pull_request),
3745 'title': pull_request.title,
3746 'description': pull_request.description,
3747 'status': pull_request.status,
3748 'created_on': pull_request.created_on,
3749 'updated_on': pull_request.updated_on,
3750 'commit_ids': pull_request.revisions,
3751 'review_status': pull_request.calculated_review_status(),
3752 'mergeable': merge_state,
3753 'source': {
3754 'clone_url': pull_request.source_repo.clone_url(),
3755 'repository': pull_request.source_repo.repo_name,
3756 'reference': {
3757 'name': pull_request.source_ref_parts.name,
3758 'type': pull_request.source_ref_parts.type,
3759 'commit_id': pull_request.source_ref_parts.commit_id,
3760 },
3761 },
3762 'target': {
3763 'clone_url': pull_request.target_repo.clone_url(),
3764 'repository': pull_request.target_repo.repo_name,
3765 'reference': {
3766 'name': pull_request.target_ref_parts.name,
3767 'type': pull_request.target_ref_parts.type,
3768 'commit_id': pull_request.target_ref_parts.commit_id,
3769 },
3770 },
3771 'merge': merge_data,
3772 'author': pull_request.author.get_api_data(include_secrets=False,
3773 details='basic'),
3774 'reviewers': [
3775 {
3776 'user': reviewer.get_api_data(include_secrets=False,
3777 details='basic'),
3778 'reasons': reasons,
3779 'review_status': st[0][1].status if st else 'not_reviewed',
3780 }
3781 for obj, reviewer, reasons, mandatory, st in
3782 pull_request.reviewers_statuses()
3783 ]
3784 }
3785
3786 return data
3787
3788
3789 class PullRequest(Base, _PullRequestBase):
3790 __tablename__ = 'pull_requests'
3791 __table_args__ = (
3792 base_table_args,
3793 )
3794
3795 pull_request_id = Column(
3796 'pull_request_id', Integer(), nullable=False, primary_key=True)
3797
3798 def __repr__(self):
3799 if self.pull_request_id:
3800 return '<DB:PullRequest #%s>' % self.pull_request_id
3801 else:
3802 return '<DB:PullRequest at %#x>' % id(self)
3803
3804 reviewers = relationship('PullRequestReviewers',
3805 cascade="all, delete, delete-orphan")
3806 statuses = relationship('ChangesetStatus',
3807 cascade="all, delete, delete-orphan")
3808 comments = relationship('ChangesetComment',
3809 cascade="all, delete, delete-orphan")
3810 versions = relationship('PullRequestVersion',
3811 cascade="all, delete, delete-orphan",
3812 lazy='dynamic')
3813
3814 @classmethod
3815 def get_pr_display_object(cls, pull_request_obj, org_pull_request_obj,
3816 internal_methods=None):
3817
3818 class PullRequestDisplay(object):
3819 """
3820 Special object wrapper for showing PullRequest data via Versions
3821 It mimics PR object as close as possible. This is read only object
3822 just for display
3823 """
3824
3825 def __init__(self, attrs, internal=None):
3826 self.attrs = attrs
3827 # internal have priority over the given ones via attrs
3828 self.internal = internal or ['versions']
3829
3830 def __getattr__(self, item):
3831 if item in self.internal:
3832 return getattr(self, item)
3833 try:
3834 return self.attrs[item]
3835 except KeyError:
3836 raise AttributeError(
3837 '%s object has no attribute %s' % (self, item))
3838
3839 def __repr__(self):
3840 return '<DB:PullRequestDisplay #%s>' % self.attrs.get('pull_request_id')
3841
3842 def versions(self):
3843 return pull_request_obj.versions.order_by(
3844 PullRequestVersion.pull_request_version_id).all()
3845
3846 def is_closed(self):
3847 return pull_request_obj.is_closed()
3848
3849 @property
3850 def pull_request_version_id(self):
3851 return getattr(pull_request_obj, 'pull_request_version_id', None)
3852
3853 attrs = StrictAttributeDict(pull_request_obj.get_api_data())
3854
3855 attrs.author = StrictAttributeDict(
3856 pull_request_obj.author.get_api_data())
3857 if pull_request_obj.target_repo:
3858 attrs.target_repo = StrictAttributeDict(
3859 pull_request_obj.target_repo.get_api_data())
3860 attrs.target_repo.clone_url = pull_request_obj.target_repo.clone_url
3861
3862 if pull_request_obj.source_repo:
3863 attrs.source_repo = StrictAttributeDict(
3864 pull_request_obj.source_repo.get_api_data())
3865 attrs.source_repo.clone_url = pull_request_obj.source_repo.clone_url
3866
3867 attrs.source_ref_parts = pull_request_obj.source_ref_parts
3868 attrs.target_ref_parts = pull_request_obj.target_ref_parts
3869 attrs.revisions = pull_request_obj.revisions
3870
3871 attrs.shadow_merge_ref = org_pull_request_obj.shadow_merge_ref
3872 attrs.reviewer_data = org_pull_request_obj.reviewer_data
3873 attrs.reviewer_data_json = org_pull_request_obj.reviewer_data_json
3874
3875 return PullRequestDisplay(attrs, internal=internal_methods)
3876
3877 def is_closed(self):
3878 return self.status == self.STATUS_CLOSED
3879
3880 def __json__(self):
3881 return {
3882 'revisions': self.revisions,
3883 }
3884
3885 def calculated_review_status(self):
3886 from rhodecode.model.changeset_status import ChangesetStatusModel
3887 return ChangesetStatusModel().calculated_review_status(self)
3888
3889 def reviewers_statuses(self):
3890 from rhodecode.model.changeset_status import ChangesetStatusModel
3891 return ChangesetStatusModel().reviewers_statuses(self)
3892
3893 @property
3894 def workspace_id(self):
3895 from rhodecode.model.pull_request import PullRequestModel
3896 return PullRequestModel()._workspace_id(self)
3897
3898 def get_shadow_repo(self):
3899 workspace_id = self.workspace_id
3900 vcs_obj = self.target_repo.scm_instance()
3901 shadow_repository_path = vcs_obj._get_shadow_repository_path(
3902 self.target_repo.repo_id, workspace_id)
3903 if os.path.isdir(shadow_repository_path):
3904 return vcs_obj._get_shadow_instance(shadow_repository_path)
3905
3906
3907 class PullRequestVersion(Base, _PullRequestBase):
3908 __tablename__ = 'pull_request_versions'
3909 __table_args__ = (
3910 base_table_args,
3911 )
3912
3913 pull_request_version_id = Column(
3914 'pull_request_version_id', Integer(), nullable=False, primary_key=True)
3915 pull_request_id = Column(
3916 'pull_request_id', Integer(),
3917 ForeignKey('pull_requests.pull_request_id'), nullable=False)
3918 pull_request = relationship('PullRequest')
3919
3920 def __repr__(self):
3921 if self.pull_request_version_id:
3922 return '<DB:PullRequestVersion #%s>' % self.pull_request_version_id
3923 else:
3924 return '<DB:PullRequestVersion at %#x>' % id(self)
3925
3926 @property
3927 def reviewers(self):
3928 return self.pull_request.reviewers
3929
3930 @property
3931 def versions(self):
3932 return self.pull_request.versions
3933
3934 def is_closed(self):
3935 # calculate from original
3936 return self.pull_request.status == self.STATUS_CLOSED
3937
3938 def calculated_review_status(self):
3939 return self.pull_request.calculated_review_status()
3940
3941 def reviewers_statuses(self):
3942 return self.pull_request.reviewers_statuses()
3943
3944
3945 class PullRequestReviewers(Base, BaseModel):
3946 __tablename__ = 'pull_request_reviewers'
3947 __table_args__ = (
3948 base_table_args,
3949 )
3950
3951 @hybrid_property
3952 def reasons(self):
3953 if not self._reasons:
3954 return []
3955 return self._reasons
3956
3957 @reasons.setter
3958 def reasons(self, val):
3959 val = val or []
3960 if any(not isinstance(x, basestring) for x in val):
3961 raise Exception('invalid reasons type, must be list of strings')
3962 self._reasons = val
3963
3964 pull_requests_reviewers_id = Column(
3965 'pull_requests_reviewers_id', Integer(), nullable=False,
3966 primary_key=True)
3967 pull_request_id = Column(
3968 "pull_request_id", Integer(),
3969 ForeignKey('pull_requests.pull_request_id'), nullable=False)
3970 user_id = Column(
3971 "user_id", Integer(), ForeignKey('users.user_id'), nullable=True)
3972 _reasons = Column(
3973 'reason', MutationList.as_mutable(
3974 JsonType('list', dialect_map=dict(mysql=UnicodeText(16384)))))
3975
3976 mandatory = Column("mandatory", Boolean(), nullable=False, default=False)
3977 user = relationship('User')
3978 pull_request = relationship('PullRequest')
3979
3980 rule_data = Column(
3981 'rule_data_json',
3982 JsonType(dialect_map=dict(mysql=UnicodeText(16384))))
3983
3984 def rule_user_group_data(self):
3985 """
3986 Returns the voting user group rule data for this reviewer
3987 """
3988
3989 if self.rule_data and 'vote_rule' in self.rule_data:
3990 user_group_data = {}
3991 if 'rule_user_group_entry_id' in self.rule_data:
3992 # means a group with voting rules !
3993 user_group_data['id'] = self.rule_data['rule_user_group_entry_id']
3994 user_group_data['name'] = self.rule_data['rule_name']
3995 user_group_data['vote_rule'] = self.rule_data['vote_rule']
3996
3997 return user_group_data
3998
3999 def __unicode__(self):
4000 return u"<%s('id:%s')>" % (self.__class__.__name__,
4001 self.pull_requests_reviewers_id)
4002
4003
4004 class Notification(Base, BaseModel):
4005 __tablename__ = 'notifications'
4006 __table_args__ = (
4007 Index('notification_type_idx', 'type'),
4008 base_table_args,
4009 )
4010
4011 TYPE_CHANGESET_COMMENT = u'cs_comment'
4012 TYPE_MESSAGE = u'message'
4013 TYPE_MENTION = u'mention'
4014 TYPE_REGISTRATION = u'registration'
4015 TYPE_PULL_REQUEST = u'pull_request'
4016 TYPE_PULL_REQUEST_COMMENT = u'pull_request_comment'
4017
4018 notification_id = Column('notification_id', Integer(), nullable=False, primary_key=True)
4019 subject = Column('subject', Unicode(512), nullable=True)
4020 body = Column('body', UnicodeText().with_variant(UnicodeText(50000), 'mysql'), nullable=True)
4021 created_by = Column("created_by", Integer(), ForeignKey('users.user_id'), nullable=True)
4022 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
4023 type_ = Column('type', Unicode(255))
4024
4025 created_by_user = relationship('User')
4026 notifications_to_users = relationship('UserNotification', lazy='joined',
4027 cascade="all, delete, delete-orphan")
4028
4029 @property
4030 def recipients(self):
4031 return [x.user for x in UserNotification.query()\
4032 .filter(UserNotification.notification == self)\
4033 .order_by(UserNotification.user_id.asc()).all()]
4034
4035 @classmethod
4036 def create(cls, created_by, subject, body, recipients, type_=None):
4037 if type_ is None:
4038 type_ = Notification.TYPE_MESSAGE
4039
4040 notification = cls()
4041 notification.created_by_user = created_by
4042 notification.subject = subject
4043 notification.body = body
4044 notification.type_ = type_
4045 notification.created_on = datetime.datetime.now()
4046
4047 # For each recipient link the created notification to his account
4048 for u in recipients:
4049 assoc = UserNotification()
4050 assoc.user_id = u.user_id
4051 assoc.notification = notification
4052
4053 # if created_by is inside recipients mark his notification
4054 # as read
4055 if u.user_id == created_by.user_id:
4056 assoc.read = True
4057 Session().add(assoc)
4058
4059 Session().add(notification)
4060
4061 return notification
4062
4063
4064 class UserNotification(Base, BaseModel):
4065 __tablename__ = 'user_to_notification'
4066 __table_args__ = (
4067 UniqueConstraint('user_id', 'notification_id'),
4068 base_table_args
4069 )
4070
4071 user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), primary_key=True)
4072 notification_id = Column("notification_id", Integer(), ForeignKey('notifications.notification_id'), primary_key=True)
4073 read = Column('read', Boolean, default=False)
4074 sent_on = Column('sent_on', DateTime(timezone=False), nullable=True, unique=None)
4075
4076 user = relationship('User', lazy="joined")
4077 notification = relationship('Notification', lazy="joined",
4078 order_by=lambda: Notification.created_on.desc(),)
4079
4080 def mark_as_read(self):
4081 self.read = True
4082 Session().add(self)
4083
4084
4085 class Gist(Base, BaseModel):
4086 __tablename__ = 'gists'
4087 __table_args__ = (
4088 Index('g_gist_access_id_idx', 'gist_access_id'),
4089 Index('g_created_on_idx', 'created_on'),
4090 base_table_args
4091 )
4092
4093 GIST_PUBLIC = u'public'
4094 GIST_PRIVATE = u'private'
4095 DEFAULT_FILENAME = u'gistfile1.txt'
4096
4097 ACL_LEVEL_PUBLIC = u'acl_public'
4098 ACL_LEVEL_PRIVATE = u'acl_private'
4099
4100 gist_id = Column('gist_id', Integer(), primary_key=True)
4101 gist_access_id = Column('gist_access_id', Unicode(250))
4102 gist_description = Column('gist_description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
4103 gist_owner = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True)
4104 gist_expires = Column('gist_expires', Float(53), nullable=False)
4105 gist_type = Column('gist_type', Unicode(128), nullable=False)
4106 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
4107 modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
4108 acl_level = Column('acl_level', Unicode(128), nullable=True)
4109
4110 owner = relationship('User')
4111
4112 def __repr__(self):
4113 return '<Gist:[%s]%s>' % (self.gist_type, self.gist_access_id)
4114
4115 @hybrid_property
4116 def description_safe(self):
4117 from rhodecode.lib import helpers as h
4118 return h.escape(self.gist_description)
4119
4120 @classmethod
4121 def get_or_404(cls, id_):
4122 from pyramid.httpexceptions import HTTPNotFound
4123
4124 res = cls.query().filter(cls.gist_access_id == id_).scalar()
4125 if not res:
4126 raise HTTPNotFound()
4127 return res
4128
4129 @classmethod
4130 def get_by_access_id(cls, gist_access_id):
4131 return cls.query().filter(cls.gist_access_id == gist_access_id).scalar()
4132
4133 def gist_url(self):
4134 from rhodecode.model.gist import GistModel
4135 return GistModel().get_url(self)
4136
4137 @classmethod
4138 def base_path(cls):
4139 """
4140 Returns base path when all gists are stored
4141
4142 :param cls:
4143 """
4144 from rhodecode.model.gist import GIST_STORE_LOC
4145 q = Session().query(RhodeCodeUi)\
4146 .filter(RhodeCodeUi.ui_key == URL_SEP)
4147 q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
4148 return os.path.join(q.one().ui_value, GIST_STORE_LOC)
4149
4150 def get_api_data(self):
4151 """
4152 Common function for generating gist related data for API
4153 """
4154 gist = self
4155 data = {
4156 'gist_id': gist.gist_id,
4157 'type': gist.gist_type,
4158 'access_id': gist.gist_access_id,
4159 'description': gist.gist_description,
4160 'url': gist.gist_url(),
4161 'expires': gist.gist_expires,
4162 'created_on': gist.created_on,
4163 'modified_at': gist.modified_at,
4164 'content': None,
4165 'acl_level': gist.acl_level,
4166 }
4167 return data
4168
4169 def __json__(self):
4170 data = dict(
4171 )
4172 data.update(self.get_api_data())
4173 return data
4174 # SCM functions
4175
4176 def scm_instance(self, **kwargs):
4177 full_repo_path = os.path.join(self.base_path(), self.gist_access_id)
4178 return get_vcs_instance(
4179 repo_path=safe_str(full_repo_path), create=False)
4180
4181
4182 class ExternalIdentity(Base, BaseModel):
4183 __tablename__ = 'external_identities'
4184 __table_args__ = (
4185 Index('local_user_id_idx', 'local_user_id'),
4186 Index('external_id_idx', 'external_id'),
4187 base_table_args
4188 )
4189
4190 external_id = Column('external_id', Unicode(255), default=u'', primary_key=True)
4191 external_username = Column('external_username', Unicode(1024), default=u'')
4192 local_user_id = Column('local_user_id', Integer(), ForeignKey('users.user_id'), primary_key=True)
4193 provider_name = Column('provider_name', Unicode(255), default=u'', primary_key=True)
4194 access_token = Column('access_token', String(1024), default=u'')
4195 alt_token = Column('alt_token', String(1024), default=u'')
4196 token_secret = Column('token_secret', String(1024), default=u'')
4197
4198 @classmethod
4199 def by_external_id_and_provider(cls, external_id, provider_name, local_user_id=None):
4200 """
4201 Returns ExternalIdentity instance based on search params
4202
4203 :param external_id:
4204 :param provider_name:
4205 :return: ExternalIdentity
4206 """
4207 query = cls.query()
4208 query = query.filter(cls.external_id == external_id)
4209 query = query.filter(cls.provider_name == provider_name)
4210 if local_user_id:
4211 query = query.filter(cls.local_user_id == local_user_id)
4212 return query.first()
4213
4214 @classmethod
4215 def user_by_external_id_and_provider(cls, external_id, provider_name):
4216 """
4217 Returns User instance based on search params
4218
4219 :param external_id:
4220 :param provider_name:
4221 :return: User
4222 """
4223 query = User.query()
4224 query = query.filter(cls.external_id == external_id)
4225 query = query.filter(cls.provider_name == provider_name)
4226 query = query.filter(User.user_id == cls.local_user_id)
4227 return query.first()
4228
4229 @classmethod
4230 def by_local_user_id(cls, local_user_id):
4231 """
4232 Returns all tokens for user
4233
4234 :param local_user_id:
4235 :return: ExternalIdentity
4236 """
4237 query = cls.query()
4238 query = query.filter(cls.local_user_id == local_user_id)
4239 return query
4240
4241 @classmethod
4242 def load_provider_plugin(cls, plugin_id):
4243 from rhodecode.authentication.base import loadplugin
4244 _plugin_id = 'egg:rhodecode-enterprise-ee#{}'.format(plugin_id)
4245 auth_plugin = loadplugin(_plugin_id)
4246 return auth_plugin
4247
4248
4249 class Integration(Base, BaseModel):
4250 __tablename__ = 'integrations'
4251 __table_args__ = (
4252 base_table_args
4253 )
4254
4255 integration_id = Column('integration_id', Integer(), primary_key=True)
4256 integration_type = Column('integration_type', String(255))
4257 enabled = Column('enabled', Boolean(), nullable=False)
4258 name = Column('name', String(255), nullable=False)
4259 child_repos_only = Column('child_repos_only', Boolean(), nullable=False,
4260 default=False)
4261
4262 settings = Column(
4263 'settings_json', MutationObj.as_mutable(
4264 JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))
4265 repo_id = Column(
4266 'repo_id', Integer(), ForeignKey('repositories.repo_id'),
4267 nullable=True, unique=None, default=None)
4268 repo = relationship('Repository', lazy='joined')
4269
4270 repo_group_id = Column(
4271 'repo_group_id', Integer(), ForeignKey('groups.group_id'),
4272 nullable=True, unique=None, default=None)
4273 repo_group = relationship('RepoGroup', lazy='joined')
4274
4275 @property
4276 def scope(self):
4277 if self.repo:
4278 return repr(self.repo)
4279 if self.repo_group:
4280 if self.child_repos_only:
4281 return repr(self.repo_group) + ' (child repos only)'
4282 else:
4283 return repr(self.repo_group) + ' (recursive)'
4284 if self.child_repos_only:
4285 return 'root_repos'
4286 return 'global'
4287
4288 def __repr__(self):
4289 return '<Integration(%r, %r)>' % (self.integration_type, self.scope)
4290
4291
4292 class RepoReviewRuleUser(Base, BaseModel):
4293 __tablename__ = 'repo_review_rules_users'
4294 __table_args__ = (
4295 base_table_args
4296 )
4297
4298 repo_review_rule_user_id = Column('repo_review_rule_user_id', Integer(), primary_key=True)
4299 repo_review_rule_id = Column("repo_review_rule_id", Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))
4300 user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False)
4301 mandatory = Column("mandatory", Boolean(), nullable=False, default=False)
4302 user = relationship('User')
4303
4304 def rule_data(self):
4305 return {
4306 'mandatory': self.mandatory
4307 }
4308
4309
4310 class RepoReviewRuleUserGroup(Base, BaseModel):
4311 __tablename__ = 'repo_review_rules_users_groups'
4312 __table_args__ = (
4313 base_table_args
4314 )
4315
4316 VOTE_RULE_ALL = -1
4317
4318 repo_review_rule_users_group_id = Column('repo_review_rule_users_group_id', Integer(), primary_key=True)
4319 repo_review_rule_id = Column("repo_review_rule_id", Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))
4320 users_group_id = Column("users_group_id", Integer(),ForeignKey('users_groups.users_group_id'), nullable=False)
4321 mandatory = Column("mandatory", Boolean(), nullable=False, default=False)
4322 vote_rule = Column("vote_rule", Integer(), nullable=True, default=VOTE_RULE_ALL)
4323 users_group = relationship('UserGroup')
4324
4325 def rule_data(self):
4326 return {
4327 'mandatory': self.mandatory,
4328 'vote_rule': self.vote_rule
4329 }
4330
4331 @property
4332 def vote_rule_label(self):
4333 if not self.vote_rule or self.vote_rule == self.VOTE_RULE_ALL:
4334 return 'all must vote'
4335 else:
4336 return 'min. vote {}'.format(self.vote_rule)
4337
4338
4339 class RepoReviewRule(Base, BaseModel):
4340 __tablename__ = 'repo_review_rules'
4341 __table_args__ = (
4342 base_table_args
4343 )
4344
4345 repo_review_rule_id = Column(
4346 'repo_review_rule_id', Integer(), primary_key=True)
4347 repo_id = Column(
4348 "repo_id", Integer(), ForeignKey('repositories.repo_id'))
4349 repo = relationship('Repository', backref='review_rules')
4350
4351 review_rule_name = Column('review_rule_name', String(255))
4352 _branch_pattern = Column("branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*') # glob
4353 _target_branch_pattern = Column("target_branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*') # glob
4354 _file_pattern = Column("file_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*') # glob
4355
4356 use_authors_for_review = Column("use_authors_for_review", Boolean(), nullable=False, default=False)
4357 forbid_author_to_review = Column("forbid_author_to_review", Boolean(), nullable=False, default=False)
4358 forbid_commit_author_to_review = Column("forbid_commit_author_to_review", Boolean(), nullable=False, default=False)
4359 forbid_adding_reviewers = Column("forbid_adding_reviewers", Boolean(), nullable=False, default=False)
4360
4361 rule_users = relationship('RepoReviewRuleUser')
4362 rule_user_groups = relationship('RepoReviewRuleUserGroup')
4363
4364 def _validate_pattern(self, value):
4365 re.compile('^' + glob2re(value) + '$')
4366
4367 @hybrid_property
4368 def source_branch_pattern(self):
4369 return self._branch_pattern or '*'
4370
4371 @source_branch_pattern.setter
4372 def source_branch_pattern(self, value):
4373 self._validate_pattern(value)
4374 self._branch_pattern = value or '*'
4375
4376 @hybrid_property
4377 def target_branch_pattern(self):
4378 return self._target_branch_pattern or '*'
4379
4380 @target_branch_pattern.setter
4381 def target_branch_pattern(self, value):
4382 self._validate_pattern(value)
4383 self._target_branch_pattern = value or '*'
4384
4385 @hybrid_property
4386 def file_pattern(self):
4387 return self._file_pattern or '*'
4388
4389 @file_pattern.setter
4390 def file_pattern(self, value):
4391 self._validate_pattern(value)
4392 self._file_pattern = value or '*'
4393
4394 def matches(self, source_branch, target_branch, files_changed):
4395 """
4396 Check if this review rule matches a branch/files in a pull request
4397
4398 :param source_branch: source branch name for the commit
4399 :param target_branch: target branch name for the commit
4400 :param files_changed: list of file paths changed in the pull request
4401 """
4402
4403 source_branch = source_branch or ''
4404 target_branch = target_branch or ''
4405 files_changed = files_changed or []
4406
4407 branch_matches = True
4408 if source_branch or target_branch:
4409 if self.source_branch_pattern == '*':
4410 source_branch_match = True
4411 else:
4412 if self.source_branch_pattern.startswith('re:'):
4413 source_pattern = self.source_branch_pattern[3:]
4414 else:
4415 source_pattern = '^' + glob2re(self.source_branch_pattern) + '$'
4416 source_branch_regex = re.compile(source_pattern)
4417 source_branch_match = bool(source_branch_regex.search(source_branch))
4418 if self.target_branch_pattern == '*':
4419 target_branch_match = True
4420 else:
4421 if self.target_branch_pattern.startswith('re:'):
4422 target_pattern = self.target_branch_pattern[3:]
4423 else:
4424 target_pattern = '^' + glob2re(self.target_branch_pattern) + '$'
4425 target_branch_regex = re.compile(target_pattern)
4426 target_branch_match = bool(target_branch_regex.search(target_branch))
4427
4428 branch_matches = source_branch_match and target_branch_match
4429
4430 files_matches = True
4431 if self.file_pattern != '*':
4432 files_matches = False
4433 if self.file_pattern.startswith('re:'):
4434 file_pattern = self.file_pattern[3:]
4435 else:
4436 file_pattern = glob2re(self.file_pattern)
4437 file_regex = re.compile(file_pattern)
4438 for filename in files_changed:
4439 if file_regex.search(filename):
4440 files_matches = True
4441 break
4442
4443 return branch_matches and files_matches
4444
4445 @property
4446 def review_users(self):
4447 """ Returns the users which this rule applies to """
4448
4449 users = collections.OrderedDict()
4450
4451 for rule_user in self.rule_users:
4452 if rule_user.user.active:
4453 if rule_user.user not in users:
4454 users[rule_user.user.username] = {
4455 'user': rule_user.user,
4456 'source': 'user',
4457 'source_data': {},
4458 'data': rule_user.rule_data()
4459 }
4460
4461 for rule_user_group in self.rule_user_groups:
4462 source_data = {
4463 'user_group_id': rule_user_group.users_group.users_group_id,
4464 'name': rule_user_group.users_group.users_group_name,
4465 'members': len(rule_user_group.users_group.members)
4466 }
4467 for member in rule_user_group.users_group.members:
4468 if member.user.active:
4469 key = member.user.username
4470 if key in users:
4471 # skip this member as we have him already
4472 # this prevents from override the "first" matched
4473 # users with duplicates in multiple groups
4474 continue
4475
4476 users[key] = {
4477 'user': member.user,
4478 'source': 'user_group',
4479 'source_data': source_data,
4480 'data': rule_user_group.rule_data()
4481 }
4482
4483 return users
4484
4485 def user_group_vote_rule(self, user_id):
4486
4487 rules = []
4488 if not self.rule_user_groups:
4489 return rules
4490
4491 for user_group in self.rule_user_groups:
4492 user_group_members = [x.user_id for x in user_group.users_group.members]
4493 if user_id in user_group_members:
4494 rules.append(user_group)
4495 return rules
4496
4497 def __repr__(self):
4498 return '<RepoReviewerRule(id=%r, repo=%r)>' % (
4499 self.repo_review_rule_id, self.repo)
4500
4501
4502 class ScheduleEntry(Base, BaseModel):
4503 __tablename__ = 'schedule_entries'
4504 __table_args__ = (
4505 UniqueConstraint('schedule_name', name='s_schedule_name_idx'),
4506 UniqueConstraint('task_uid', name='s_task_uid_idx'),
4507 base_table_args,
4508 )
4509
4510 schedule_types = ['crontab', 'timedelta', 'integer']
4511 schedule_entry_id = Column('schedule_entry_id', Integer(), primary_key=True)
4512
4513 schedule_name = Column("schedule_name", String(255), nullable=False, unique=None, default=None)
4514 schedule_description = Column("schedule_description", String(10000), nullable=True, unique=None, default=None)
4515 schedule_enabled = Column("schedule_enabled", Boolean(), nullable=False, unique=None, default=True)
4516
4517 _schedule_type = Column("schedule_type", String(255), nullable=False, unique=None, default=None)
4518 schedule_definition = Column('schedule_definition_json', MutationObj.as_mutable(JsonType(default=lambda: "", dialect_map=dict(mysql=LONGTEXT()))))
4519
4520 schedule_last_run = Column('schedule_last_run', DateTime(timezone=False), nullable=True, unique=None, default=None)
4521 schedule_total_run_count = Column('schedule_total_run_count', Integer(), nullable=True, unique=None, default=0)
4522
4523 # task
4524 task_uid = Column("task_uid", String(255), nullable=False, unique=None, default=None)
4525 task_dot_notation = Column("task_dot_notation", String(4096), nullable=False, unique=None, default=None)
4526 task_args = Column('task_args_json', MutationObj.as_mutable(JsonType(default=list, dialect_map=dict(mysql=LONGTEXT()))))
4527 task_kwargs = Column('task_kwargs_json', MutationObj.as_mutable(JsonType(default=dict, dialect_map=dict(mysql=LONGTEXT()))))
4528
4529 created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
4530 updated_on = Column('updated_on', DateTime(timezone=False), nullable=True, unique=None, default=None)
4531
4532 @hybrid_property
4533 def schedule_type(self):
4534 return self._schedule_type
4535
4536 @schedule_type.setter
4537 def schedule_type(self, val):
4538 if val not in self.schedule_types:
4539 raise ValueError('Value must be on of `{}` and got `{}`'.format(
4540 val, self.schedule_type))
4541
4542 self._schedule_type = val
4543
4544 @classmethod
4545 def get_uid(cls, obj):
4546 args = obj.task_args
4547 kwargs = obj.task_kwargs
4548 if isinstance(args, JsonRaw):
4549 try:
4550 args = json.loads(args)
4551 except ValueError:
4552 args = tuple()
4553
4554 if isinstance(kwargs, JsonRaw):
4555 try:
4556 kwargs = json.loads(kwargs)
4557 except ValueError:
4558 kwargs = dict()
4559
4560 dot_notation = obj.task_dot_notation
4561 val = '.'.join(map(safe_str, [
4562 sorted(dot_notation), args, sorted(kwargs.items())]))
4563 return hashlib.sha1(val).hexdigest()
4564
4565 @classmethod
4566 def get_by_schedule_name(cls, schedule_name):
4567 return cls.query().filter(cls.schedule_name == schedule_name).scalar()
4568
4569 @classmethod
4570 def get_by_schedule_id(cls, schedule_id):
4571 return cls.query().filter(cls.schedule_entry_id == schedule_id).scalar()
4572
4573 @property
4574 def task(self):
4575 return self.task_dot_notation
4576
4577 @property
4578 def schedule(self):
4579 from rhodecode.lib.celerylib.utils import raw_2_schedule
4580 schedule = raw_2_schedule(self.schedule_definition, self.schedule_type)
4581 return schedule
4582
4583 @property
4584 def args(self):
4585 try:
4586 return list(self.task_args or [])
4587 except ValueError:
4588 return list()
4589
4590 @property
4591 def kwargs(self):
4592 try:
4593 return dict(self.task_kwargs or {})
4594 except ValueError:
4595 return dict()
4596
4597 def _as_raw(self, val):
4598 if hasattr(val, 'de_coerce'):
4599 val = val.de_coerce()
4600 if val:
4601 val = json.dumps(val)
4602
4603 return val
4604
4605 @property
4606 def schedule_definition_raw(self):
4607 return self._as_raw(self.schedule_definition)
4608
4609 @property
4610 def args_raw(self):
4611 return self._as_raw(self.task_args)
4612
4613 @property
4614 def kwargs_raw(self):
4615 return self._as_raw(self.task_kwargs)
4616
4617 def __repr__(self):
4618 return '<DB:ScheduleEntry({}:{})>'.format(
4619 self.schedule_entry_id, self.schedule_name)
4620
4621
4622 @event.listens_for(ScheduleEntry, 'before_update')
4623 def update_task_uid(mapper, connection, target):
4624 target.task_uid = ScheduleEntry.get_uid(target)
4625
4626
4627 @event.listens_for(ScheduleEntry, 'before_insert')
4628 def set_task_uid(mapper, connection, target):
4629 target.task_uid = ScheduleEntry.get_uid(target)
4630
4631
4632 class _BaseBranchPerms(BaseModel):
4633 @classmethod
4634 def compute_hash(cls, value):
4635 return sha1_safe(value)
4636
4637 @hybrid_property
4638 def branch_pattern(self):
4639 return self._branch_pattern or '*'
4640
4641 @hybrid_property
4642 def branch_hash(self):
4643 return self._branch_hash
4644
4645 def _validate_glob(self, value):
4646 re.compile('^' + glob2re(value) + '$')
4647
4648 @branch_pattern.setter
4649 def branch_pattern(self, value):
4650 self._validate_glob(value)
4651 self._branch_pattern = value or '*'
4652 # set the Hash when setting the branch pattern
4653 self._branch_hash = self.compute_hash(self._branch_pattern)
4654
4655 def matches(self, branch):
4656 """
4657 Check if this the branch matches entry
4658
4659 :param branch: branch name for the commit
4660 """
4661
4662 branch = branch or ''
4663
4664 branch_matches = True
4665 if branch:
4666 branch_regex = re.compile('^' + glob2re(self.branch_pattern) + '$')
4667 branch_matches = bool(branch_regex.search(branch))
4668
4669 return branch_matches
4670
4671
4672 class UserToRepoBranchPermission(Base, _BaseBranchPerms):
4673 __tablename__ = 'user_to_repo_branch_permissions'
4674 __table_args__ = (
4675 {'extend_existing': True, 'mysql_engine': 'InnoDB',
4676 'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
4677 )
4678
4679 branch_rule_id = Column('branch_rule_id', Integer(), primary_key=True)
4680
4681 repository_id = Column('repository_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
4682 repo = relationship('Repository', backref='user_branch_perms')
4683
4684 permission_id = Column('permission_id', Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
4685 permission = relationship('Permission')
4686
4687 rule_to_perm_id = Column('rule_to_perm_id', Integer(), ForeignKey('repo_to_perm.repo_to_perm_id'), nullable=False, unique=None, default=None)
4688 user_repo_to_perm = relationship('UserRepoToPerm')
4689
4690 rule_order = Column('rule_order', Integer(), nullable=False)
4691 _branch_pattern = Column('branch_pattern', UnicodeText().with_variant(UnicodeText(2048), 'mysql'), default=u'*') # glob
4692 _branch_hash = Column('branch_hash', UnicodeText().with_variant(UnicodeText(2048), 'mysql'))
4693
4694 def __unicode__(self):
4695 return u'<UserBranchPermission(%s => %r)>' % (
4696 self.user_repo_to_perm, self.branch_pattern)
4697
4698
4699 class UserGroupToRepoBranchPermission(Base, _BaseBranchPerms):
4700 __tablename__ = 'user_group_to_repo_branch_permissions'
4701 __table_args__ = (
4702 {'extend_existing': True, 'mysql_engine': 'InnoDB',
4703 'mysql_charset': 'utf8', 'sqlite_autoincrement': True,}
4704 )
4705
4706 branch_rule_id = Column('branch_rule_id', Integer(), primary_key=True)
4707
4708 repository_id = Column('repository_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
4709 repo = relationship('Repository', backref='user_group_branch_perms')
4710
4711 permission_id = Column('permission_id', Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
4712 permission = relationship('Permission')
4713
4714 rule_to_perm_id = Column('rule_to_perm_id', Integer(), ForeignKey('users_group_repo_to_perm.users_group_to_perm_id'), nullable=False, unique=None, default=None)
4715 user_group_repo_to_perm = relationship('UserGroupRepoToPerm')
4716
4717 rule_order = Column('rule_order', Integer(), nullable=False)
4718 _branch_pattern = Column('branch_pattern', UnicodeText().with_variant(UnicodeText(2048), 'mysql'), default=u'*') # glob
4719 _branch_hash = Column('branch_hash', UnicodeText().with_variant(UnicodeText(2048), 'mysql'))
4720
4721 def __unicode__(self):
4722 return u'<UserBranchPermission(%s => %r)>' % (
4723 self.user_group_repo_to_perm, self.branch_pattern)
4724
4725
4726 class DbMigrateVersion(Base, BaseModel):
4727 __tablename__ = 'db_migrate_version'
4728 __table_args__ = (
4729 base_table_args,
4730 )
4731
4732 repository_id = Column('repository_id', String(250), primary_key=True)
4733 repository_path = Column('repository_path', Text)
4734 version = Column('version', Integer)
4735
4736 @classmethod
4737 def set_version(cls, version):
4738 """
4739 Helper for forcing a different version, usually for debugging purposes via ishell.
4740 """
4741 ver = DbMigrateVersion.query().first()
4742 ver.version = version
4743 Session().commit()
4744
4745
4746 class DbSession(Base, BaseModel):
4747 __tablename__ = 'db_session'
4748 __table_args__ = (
4749 base_table_args,
4750 )
4751
4752 def __repr__(self):
4753 return '<DB:DbSession({})>'.format(self.id)
4754
4755 id = Column('id', Integer())
4756 namespace = Column('namespace', String(255), primary_key=True)
4757 accessed = Column('accessed', DateTime, nullable=False)
4758 created = Column('created', DateTime, nullable=False)
4759 data = Column('data', PickleType, nullable=False)
@@ -0,0 +1,37 b''
1 import logging
2
3 from sqlalchemy import *
4
5 from rhodecode.model import meta
6 from rhodecode.lib.dbmigrate.versions import _reset_base, notify
7
8 log = logging.getLogger(__name__)
9
10
11 def upgrade(migrate_engine):
12 """
13 Upgrade operations go here.
14 Don't create your own engine; bind migrate_engine to your metadata
15 """
16 _reset_base(migrate_engine)
17 from rhodecode.lib.dbmigrate.schema import db_4_13_0_0 as db
18
19 pull_request = db.PullRequest.__table__
20 pull_request_version = db.PullRequestVersion.__table__
21
22 repo_state_1 = Column("pull_request_state", String(255), nullable=True)
23 repo_state_1.create(table=pull_request)
24
25 repo_state_2 = Column("pull_request_state", String(255), nullable=True)
26 repo_state_2.create(table=pull_request_version)
27
28 fixups(db, meta.Session)
29
30
31 def downgrade(migrate_engine):
32 meta = MetaData()
33 meta.bind = migrate_engine
34
35
36 def fixups(models, _SESSION):
37 pass
@@ -0,0 +1,41 b''
1 import logging
2
3 from sqlalchemy import *
4
5 from rhodecode.model import meta
6 from rhodecode.lib.dbmigrate.versions import _reset_base, notify
7
8 log = logging.getLogger(__name__)
9
10
11 def upgrade(migrate_engine):
12 """
13 Upgrade operations go here.
14 Don't create your own engine; bind migrate_engine to your metadata
15 """
16 _reset_base(migrate_engine)
17 from rhodecode.lib.dbmigrate.schema import db_4_16_0_0 as db
18
19 fixups(db, meta.Session)
20
21
22 def downgrade(migrate_engine):
23 meta = MetaData()
24 meta.bind = migrate_engine
25
26
27 def fixups(models, _SESSION):
28 # move the builtin token to external tokens
29
30 log.info('Updating pull request pull_request_state to %s',
31 models.PullRequest.STATE_CREATED)
32 qry = _SESSION().query(models.PullRequest)
33 qry.update({"pull_request_state": models.PullRequest.STATE_CREATED})
34 _SESSION().commit()
35
36 log.info('Updating pull_request_version pull_request_state to %s',
37 models.PullRequest.STATE_CREATED)
38 qry = _SESSION().query(models.PullRequestVersion)
39 qry.update({"pull_request_state": models.PullRequest.STATE_CREATED})
40 _SESSION().commit()
41
@@ -18,12 +18,6 b''
18 18 # RhodeCode Enterprise Edition, including its added features, Support services,
19 19 # and proprietary license terms, please see https://rhodecode.com/licenses/
20 20
21 """
22
23 RhodeCode, a web based repository management software
24 versioning implementation: http://www.python.org/dev/peps/pep-0386/
25 """
26
27 21 import os
28 22 import sys
29 23 import platform
@@ -51,7 +45,7 b' PYRAMID_SETTINGS = {}'
51 45 EXTENSIONS = {}
52 46
53 47 __version__ = ('.'.join((str(each) for each in VERSION[:3])))
54 __dbversion__ = 91 # defines current db version for migrations
48 __dbversion__ = 93 # defines current db version for migrations
55 49 __platform__ = platform.system()
56 50 __license__ = 'AGPLv3, and Commercial License'
57 51 __author__ = 'RhodeCode GmbH'
@@ -65,6 +65,7 b' class TestGetPullRequest(object):'
65 65 'title': pull_request.title,
66 66 'description': pull_request.description,
67 67 'status': pull_request.status,
68 'state': pull_request.pull_request_state,
68 69 'created_on': pull_request.created_on,
69 70 'updated_on': pull_request.updated_on,
70 71 'commit_ids': pull_request.revisions,
@@ -29,11 +29,10 b' from rhodecode.api.tests.utils import ('
29 29
30 30 @pytest.mark.usefixtures("testuser_api", "app")
31 31 class TestMergePullRequest(object):
32
32 33 @pytest.mark.backends("git", "hg")
33 34 def test_api_merge_pull_request_merge_failed(self, pr_util, no_notifications):
34 35 pull_request = pr_util.create_pull_request(mergeable=True)
35 author = pull_request.user_id
36 repo = pull_request.target_repo.repo_id
37 36 pull_request_id = pull_request.pull_request_id
38 37 pull_request_repo = pull_request.target_repo.repo_name
39 38
@@ -46,8 +45,7 b' class TestMergePullRequest(object):'
46 45
47 46 # The above api call detaches the pull request DB object from the
48 47 # session because of an unconditional transaction rollback in our
49 # middleware. Therefore we need to add it back here if we want to use
50 # it.
48 # middleware. Therefore we need to add it back here if we want to use it.
51 49 Session().add(pull_request)
52 50
53 51 expected = 'merge not possible for following reasons: ' \
@@ -55,6 +53,29 b' class TestMergePullRequest(object):'
55 53 assert_error(id_, expected, given=response.body)
56 54
57 55 @pytest.mark.backends("git", "hg")
56 def test_api_merge_pull_request_merge_failed_disallowed_state(
57 self, pr_util, no_notifications):
58 pull_request = pr_util.create_pull_request(mergeable=True, approved=True)
59 pull_request_id = pull_request.pull_request_id
60 pull_request_repo = pull_request.target_repo.repo_name
61
62 pr = PullRequest.get(pull_request_id)
63 pr.pull_request_state = pull_request.STATE_UPDATING
64 Session().add(pr)
65 Session().commit()
66
67 id_, params = build_data(
68 self.apikey, 'merge_pull_request',
69 repoid=pull_request_repo,
70 pullrequestid=pull_request_id)
71
72 response = api_call(self.app, params)
73 expected = 'Operation forbidden because pull request is in state {}, '\
74 'only state {} is allowed.'.format(PullRequest.STATE_UPDATING,
75 PullRequest.STATE_CREATED)
76 assert_error(id_, expected, given=response.body)
77
78 @pytest.mark.backends("git", "hg")
58 79 def test_api_merge_pull_request(self, pr_util, no_notifications):
59 80 pull_request = pr_util.create_pull_request(mergeable=True, approved=True)
60 81 author = pull_request.user_id
@@ -123,8 +144,7 b' class TestMergePullRequest(object):'
123 144 assert_error(id_, expected, given=response.body)
124 145
125 146 @pytest.mark.backends("git", "hg")
126 def test_api_merge_pull_request_non_admin_with_userid_error(self,
127 pr_util):
147 def test_api_merge_pull_request_non_admin_with_userid_error(self, pr_util):
128 148 pull_request = pr_util.create_pull_request(mergeable=True)
129 149 id_, params = build_data(
130 150 self.apikey_regular, 'merge_pull_request',
@@ -32,7 +32,7 b' from rhodecode.lib.base import vcs_opera'
32 32 from rhodecode.lib.utils2 import str2bool
33 33 from rhodecode.model.changeset_status import ChangesetStatusModel
34 34 from rhodecode.model.comment import CommentsModel
35 from rhodecode.model.db import Session, ChangesetStatus, ChangesetComment
35 from rhodecode.model.db import Session, ChangesetStatus, ChangesetComment, PullRequest
36 36 from rhodecode.model.pull_request import PullRequestModel, MergeCheck
37 37 from rhodecode.model.settings import SettingsModel
38 38 from rhodecode.model.validation_schema import Invalid
@@ -128,11 +128,15 b' def get_pull_request(request, apiuser, p'
128 128 else:
129 129 repo = pull_request.target_repo
130 130
131 if not PullRequestModel().check_user_read(
132 pull_request, apiuser, api=True):
131 if not PullRequestModel().check_user_read(pull_request, apiuser, api=True):
133 132 raise JSONRPCError('repository `%s` or pull request `%s` '
134 133 'does not exist' % (repoid, pullrequestid))
135 data = pull_request.get_api_data()
134
135 # NOTE(marcink): only calculate and return merge state if the pr state is 'created'
136 # otherwise we can lock the repo on calculation of merge state while update/merge
137 # is happening.
138 merge_state = pull_request.pull_request_state == pull_request.STATE_CREATED
139 data = pull_request.get_api_data(with_merge_state=merge_state)
136 140 return data
137 141
138 142
@@ -283,8 +287,16 b' def merge_pull_request('
283 287 else:
284 288 raise JSONRPCError('userid is not the same as your user')
285 289
290 if pull_request.pull_request_state != PullRequest.STATE_CREATED:
291 raise JSONRPCError(
292 'Operation forbidden because pull request is in state {}, '
293 'only state {} is allowed.'.format(
294 pull_request.pull_request_state, PullRequest.STATE_CREATED))
295
296 with pull_request.set_state(PullRequest.STATE_UPDATING):
286 297 check = MergeCheck.validate(
287 pull_request, auth_user=apiuser, translator=request.translate)
298 pull_request, auth_user=apiuser,
299 translator=request.translate)
288 300 merge_possible = not check.failed
289 301
290 302 if not merge_possible:
@@ -302,6 +314,7 b' def merge_pull_request('
302 314 request.environ, repo_name=target_repo.repo_name,
303 315 username=apiuser.username, action='push',
304 316 scm=target_repo.repo_type)
317 with pull_request.set_state(PullRequest.STATE_UPDATING):
305 318 merge_response = PullRequestModel().merge_repo(
306 319 pull_request, apiuser, extras=extras)
307 320 if merge_response.executed:
@@ -829,9 +842,16 b' def update_pull_request('
829 842
830 843 commit_changes = {"added": [], "common": [], "removed": []}
831 844 if str2bool(Optional.extract(update_commits)):
845
846 if pull_request.pull_request_state != PullRequest.STATE_CREATED:
847 raise JSONRPCError(
848 'Operation forbidden because pull request is in state {}, '
849 'only state {} is allowed.'.format(
850 pull_request.pull_request_state, PullRequest.STATE_CREATED))
851
852 with pull_request.set_state(PullRequest.STATE_UPDATING):
832 853 if PullRequestModel().has_valid_update_type(pull_request):
833 update_response = PullRequestModel().update_commits(
834 pull_request)
854 update_response = PullRequestModel().update_commits(pull_request)
835 855 commit_changes = update_response.changes or commit_changes
836 856 Session().commit()
837 857
@@ -655,20 +655,20 b' class TestPullrequestsView(object):'
655 655
656 656 # create pr from a in source to A in target
657 657 pull_request = PullRequest()
658
658 659 pull_request.source_repo = source
659 # TODO: johbo: Make sure that we write the source ref this way!
660 660 pull_request.source_ref = 'branch:{branch}:{commit_id}'.format(
661 661 branch=backend.default_branch_name, commit_id=commit_ids['change'])
662
662 663 pull_request.target_repo = target
663
664 664 pull_request.target_ref = 'branch:{branch}:{commit_id}'.format(
665 branch=backend.default_branch_name,
666 commit_id=commit_ids['ancestor'])
665 branch=backend.default_branch_name, commit_id=commit_ids['ancestor'])
666
667 667 pull_request.revisions = [commit_ids['change']]
668 668 pull_request.title = u"Test"
669 669 pull_request.description = u"Description"
670 pull_request.author = UserModel().get_by_username(
671 TEST_USER_ADMIN_LOGIN)
670 pull_request.author = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
671 pull_request.pull_request_state = PullRequest.STATE_CREATED
672 672 Session().add(pull_request)
673 673 Session().commit()
674 674 pull_request_id = pull_request.pull_request_id
@@ -679,23 +679,21 b' class TestPullrequestsView(object):'
679 679 # update PR
680 680 self.app.post(
681 681 route_path('pullrequest_update',
682 repo_name=target.repo_name, pull_request_id=pull_request_id),
683 params={'update_commits': 'true', 'csrf_token': csrf_token})
684
685 response = self.app.get(
686 route_path('pullrequest_show',
682 687 repo_name=target.repo_name,
683 pull_request_id=pull_request_id),
684 params={'update_commits': 'true',
685 'csrf_token': csrf_token})
688 pull_request_id=pull_request.pull_request_id))
689
690 assert response.status_int == 200
691 assert 'Pull request updated to' in response.body
692 assert 'with 1 added, 0 removed commits.' in response.body
686 693
687 694 # check that we have now both revisions
688 695 pull_request = PullRequest.get(pull_request_id)
689 assert pull_request.revisions == [
690 commit_ids['change-2'], commit_ids['change']]
691
692 # TODO: johbo: this should be a test on its own
693 response = self.app.get(route_path(
694 'pullrequest_new',
695 repo_name=target.repo_name))
696 assert response.status_int == 200
697 assert 'Pull request updated to' in response.body
698 assert 'with 1 added, 0 removed commits.' in response.body
696 assert pull_request.revisions == [commit_ids['change-2'], commit_ids['change']]
699 697
700 698 def test_update_target_revision(self, backend, csrf_token):
701 699 commits = [
@@ -710,21 +708,21 b' class TestPullrequestsView(object):'
710 708
711 709 # create pr from a in source to A in target
712 710 pull_request = PullRequest()
711
713 712 pull_request.source_repo = source
714 # TODO: johbo: Make sure that we write the source ref this way!
715 713 pull_request.source_ref = 'branch:{branch}:{commit_id}'.format(
716 714 branch=backend.default_branch_name, commit_id=commit_ids['change'])
715
717 716 pull_request.target_repo = target
718 # TODO: johbo: Target ref should be branch based, since tip can jump
719 # from branch to branch
720 717 pull_request.target_ref = 'branch:{branch}:{commit_id}'.format(
721 branch=backend.default_branch_name,
722 commit_id=commit_ids['ancestor'])
718 branch=backend.default_branch_name, commit_id=commit_ids['ancestor'])
719
723 720 pull_request.revisions = [commit_ids['change']]
724 721 pull_request.title = u"Test"
725 722 pull_request.description = u"Description"
726 pull_request.author = UserModel().get_by_username(
727 TEST_USER_ADMIN_LOGIN)
723 pull_request.author = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
724 pull_request.pull_request_state = PullRequest.STATE_CREATED
725
728 726 Session().add(pull_request)
729 727 Session().commit()
730 728 pull_request_id = pull_request.pull_request_id
@@ -739,21 +737,19 b' class TestPullrequestsView(object):'
739 737 route_path('pullrequest_update',
740 738 repo_name=target.repo_name,
741 739 pull_request_id=pull_request_id),
742 params={'update_commits': 'true',
743 'csrf_token': csrf_token},
740 params={'update_commits': 'true', 'csrf_token': csrf_token},
744 741 status=200)
745 742
746 743 # check that we have now both revisions
747 744 pull_request = PullRequest.get(pull_request_id)
748 745 assert pull_request.revisions == [commit_ids['change-rebased']]
749 746 assert pull_request.target_ref == 'branch:{branch}:{commit_id}'.format(
750 branch=backend.default_branch_name,
751 commit_id=commit_ids['ancestor-new'])
747 branch=backend.default_branch_name, commit_id=commit_ids['ancestor-new'])
752 748
753 # TODO: johbo: This should be a test on its own
754 response = self.app.get(route_path(
755 'pullrequest_new',
756 repo_name=target.repo_name))
749 response = self.app.get(
750 route_path('pullrequest_show',
751 repo_name=target.repo_name,
752 pull_request_id=pull_request.pull_request_id))
757 753 assert response.status_int == 200
758 754 assert 'Pull request updated to' in response.body
759 755 assert 'with 1 added, 1 removed commits.' in response.body
@@ -775,17 +771,14 b' class TestPullrequestsView(object):'
775 771 # create pr from a in source to A in target
776 772 pull_request = PullRequest()
777 773 pull_request.source_repo = source
778 # TODO: johbo: Make sure that we write the source ref this way!
774
779 775 pull_request.source_ref = 'branch:{branch}:{commit_id}'.format(
780 776 branch=backend.default_branch_name,
781 777 commit_id=commit_ids['master-commit-3-change-2'])
782 778
783 779 pull_request.target_repo = target
784 # TODO: johbo: Target ref should be branch based, since tip can jump
785 # from branch to branch
786 780 pull_request.target_ref = 'branch:{branch}:{commit_id}'.format(
787 branch=backend.default_branch_name,
788 commit_id=commit_ids['feat-commit-2'])
781 branch=backend.default_branch_name, commit_id=commit_ids['feat-commit-2'])
789 782
790 783 pull_request.revisions = [
791 784 commit_ids['feat-commit-1'],
@@ -793,8 +786,8 b' class TestPullrequestsView(object):'
793 786 ]
794 787 pull_request.title = u"Test"
795 788 pull_request.description = u"Description"
796 pull_request.author = UserModel().get_by_username(
797 TEST_USER_ADMIN_LOGIN)
789 pull_request.author = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
790 pull_request.pull_request_state = PullRequest.STATE_CREATED
798 791 Session().add(pull_request)
799 792 Session().commit()
800 793 pull_request_id = pull_request.pull_request_id
@@ -810,13 +803,10 b' class TestPullrequestsView(object):'
810 803 route_path('pullrequest_update',
811 804 repo_name=target.repo_name,
812 805 pull_request_id=pull_request_id),
813 params={'update_commits': 'true',
814 'csrf_token': csrf_token},
806 params={'update_commits': 'true', 'csrf_token': csrf_token},
815 807 status=200)
816 808
817 response = self.app.get(route_path(
818 'pullrequest_new',
819 repo_name=target.repo_name))
809 response = self.app.get(route_path('pullrequest_new', repo_name=target.repo_name))
820 810 assert response.status_int == 200
821 811 response.mustcontain('Pull request updated to')
822 812 response.mustcontain('with 0 added, 0 removed commits.')
@@ -836,21 +826,17 b' class TestPullrequestsView(object):'
836 826 # create pr from a in source to A in target
837 827 pull_request = PullRequest()
838 828 pull_request.source_repo = source
839 # TODO: johbo: Make sure that we write the source ref this way!
829
840 830 pull_request.source_ref = 'branch:{branch}:{commit_id}'.format(
841 branch=backend.default_branch_name,
842 commit_id=commit_ids['change'])
831 branch=backend.default_branch_name, commit_id=commit_ids['change'])
843 832 pull_request.target_repo = target
844 # TODO: johbo: Target ref should be branch based, since tip can jump
845 # from branch to branch
846 833 pull_request.target_ref = 'branch:{branch}:{commit_id}'.format(
847 branch=backend.default_branch_name,
848 commit_id=commit_ids['ancestor'])
834 branch=backend.default_branch_name, commit_id=commit_ids['ancestor'])
849 835 pull_request.revisions = [commit_ids['change']]
850 836 pull_request.title = u"Test"
851 837 pull_request.description = u"Description"
852 pull_request.author = UserModel().get_by_username(
853 TEST_USER_ADMIN_LOGIN)
838 pull_request.author = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
839 pull_request.pull_request_state = PullRequest.STATE_CREATED
854 840 Session().add(pull_request)
855 841 Session().commit()
856 842 pull_request_id = pull_request.pull_request_id
@@ -863,10 +849,8 b' class TestPullrequestsView(object):'
863 849 # update PR
864 850 self.app.post(
865 851 route_path('pullrequest_update',
866 repo_name=target.repo_name,
867 pull_request_id=pull_request_id),
868 params={'update_commits': 'true',
869 'csrf_token': csrf_token},
852 repo_name=target.repo_name, pull_request_id=pull_request_id),
853 params={'update_commits': 'true', 'csrf_token': csrf_token},
870 854 status=200)
871 855
872 856 # Expect the target reference to be updated correctly
@@ -893,13 +877,12 b' class TestPullrequestsView(object):'
893 877 pull_request.source_ref = 'branch:{branch}:{commit_id}'.format(
894 878 branch=branch_name, commit_id=commit_ids['new-feature'])
895 879 pull_request.target_ref = 'branch:{branch}:{commit_id}'.format(
896 branch=backend_git.default_branch_name,
897 commit_id=commit_ids['old-feature'])
880 branch=backend_git.default_branch_name, commit_id=commit_ids['old-feature'])
898 881 pull_request.revisions = [commit_ids['new-feature']]
899 882 pull_request.title = u"Test"
900 883 pull_request.description = u"Description"
901 pull_request.author = UserModel().get_by_username(
902 TEST_USER_ADMIN_LOGIN)
884 pull_request.author = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
885 pull_request.pull_request_state = PullRequest.STATE_CREATED
903 886 Session().add(pull_request)
904 887 Session().commit()
905 888
@@ -273,9 +273,22 b' class RepoPullRequestsView(RepoAppView, '
273 273 route_name='pullrequest_show', request_method='GET',
274 274 renderer='rhodecode:templates/pullrequests/pullrequest_show.mako')
275 275 def pull_request_show(self):
276 pull_request_id = self.request.matchdict['pull_request_id']
276 _ = self.request.translate
277 c = self.load_default_context()
278
279 pull_request = PullRequest.get_or_404(
280 self.request.matchdict['pull_request_id'])
281 pull_request_id = pull_request.pull_request_id
277 282
278 c = self.load_default_context()
283 if pull_request.pull_request_state != PullRequest.STATE_CREATED:
284 log.debug('show: forbidden because pull request is in state %s',
285 pull_request.pull_request_state)
286 msg = _(u'Cannot show pull requests in state other than `{}`. '
287 u'Current state is: `{}`').format(PullRequest.STATE_CREATED,
288 pull_request.pull_request_state)
289 h.flash(msg, category='error')
290 raise HTTPFound(h.route_path('pullrequest_show_all',
291 repo_name=self.db_repo_name))
279 292
280 293 version = self.request.GET.get('version')
281 294 from_version = self.request.GET.get('from_version') or version
@@ -919,12 +932,17 b' class RepoPullRequestsView(RepoAppView, '
919 932 source_db_repo = Repository.get_by_repo_name(_form['source_repo'])
920 933 target_db_repo = Repository.get_by_repo_name(_form['target_repo'])
921 934
935 if not (source_db_repo or target_db_repo):
936 h.flash(_('source_repo or target repo not found'), category='error')
937 raise HTTPFound(
938 h.route_path('pullrequest_new', repo_name=self.db_repo_name))
939
922 940 # re-check permissions again here
923 941 # source_repo we must have read permissions
924 942
925 943 source_perm = HasRepoPermissionAny(
926 'repository.read',
927 'repository.write', 'repository.admin')(source_db_repo.repo_name)
944 'repository.read', 'repository.write', 'repository.admin')(
945 source_db_repo.repo_name)
928 946 if not source_perm:
929 947 msg = _('Not Enough permissions to source repo `{}`.'.format(
930 948 source_db_repo.repo_name))
@@ -938,8 +956,8 b' class RepoPullRequestsView(RepoAppView, '
938 956 # target repo we must have read permissions, and also later on
939 957 # we want to check branch permissions here
940 958 target_perm = HasRepoPermissionAny(
941 'repository.read',
942 'repository.write', 'repository.admin')(target_db_repo.repo_name)
959 'repository.read', 'repository.write', 'repository.admin')(
960 target_db_repo.repo_name)
943 961 if not target_perm:
944 962 msg = _('Not Enough permissions to target repo `{}`.'.format(
945 963 target_db_repo.repo_name))
@@ -1042,6 +1060,15 b' class RepoPullRequestsView(RepoAppView, '
1042 1060 h.flash(msg, category='error')
1043 1061 return True
1044 1062
1063 if pull_request.pull_request_state != PullRequest.STATE_CREATED:
1064 log.debug('update: forbidden because pull request is in state %s',
1065 pull_request.pull_request_state)
1066 msg = _(u'Cannot update pull requests in state other than `{}`. '
1067 u'Current state is: `{}`').format(PullRequest.STATE_CREATED,
1068 pull_request.pull_request_state)
1069 h.flash(msg, category='error')
1070 return True
1071
1045 1072 # only owner or admin can update it
1046 1073 allowed_to_update = PullRequestModel().check_user_update(
1047 1074 pull_request, self._rhodecode_user)
@@ -1084,6 +1111,8 b' class RepoPullRequestsView(RepoAppView, '
1084 1111
1085 1112 def _update_commits(self, pull_request):
1086 1113 _ = self.request.translate
1114
1115 with pull_request.set_state(PullRequest.STATE_UPDATING):
1087 1116 resp = PullRequestModel().update_commits(pull_request)
1088 1117
1089 1118 if resp.executed:
@@ -1097,8 +1126,7 b' class RepoPullRequestsView(RepoAppView, '
1097 1126 else:
1098 1127 changed = 'nothing'
1099 1128
1100 msg = _(
1101 u'Pull request updated to "{source_commit_id}" with '
1129 msg = _(u'Pull request updated to "{source_commit_id}" with '
1102 1130 u'{count_added} added, {count_removed} removed commits. '
1103 1131 u'Source of changes: {change_source}')
1104 1132 msg = msg.format(
@@ -1109,8 +1137,7 b' class RepoPullRequestsView(RepoAppView, '
1109 1137 h.flash(msg, category='success')
1110 1138
1111 1139 channel = '/repo${}$/pr/{}'.format(
1112 pull_request.target_repo.repo_name,
1113 pull_request.pull_request_id)
1140 pull_request.target_repo.repo_name, pull_request.pull_request_id)
1114 1141 message = msg + (
1115 1142 ' - <a onclick="window.location.reload()">'
1116 1143 '<strong>{}</strong></a>'.format(_('Reload page')))
@@ -1143,8 +1170,23 b' class RepoPullRequestsView(RepoAppView, '
1143 1170 """
1144 1171 pull_request = PullRequest.get_or_404(
1145 1172 self.request.matchdict['pull_request_id'])
1173 _ = self.request.translate
1174
1175 if pull_request.pull_request_state != PullRequest.STATE_CREATED:
1176 log.debug('show: forbidden because pull request is in state %s',
1177 pull_request.pull_request_state)
1178 msg = _(u'Cannot merge pull requests in state other than `{}`. '
1179 u'Current state is: `{}`').format(PullRequest.STATE_CREATED,
1180 pull_request.pull_request_state)
1181 h.flash(msg, category='error')
1182 raise HTTPFound(
1183 h.route_path('pullrequest_show',
1184 repo_name=pull_request.target_repo.repo_name,
1185 pull_request_id=pull_request.pull_request_id))
1146 1186
1147 1187 self.load_default_context()
1188
1189 with pull_request.set_state(PullRequest.STATE_UPDATING):
1148 1190 check = MergeCheck.validate(
1149 1191 pull_request, auth_user=self._rhodecode_user,
1150 1192 translator=self.request.translate)
@@ -1159,6 +1201,7 b' class RepoPullRequestsView(RepoAppView, '
1159 1201 self.request.environ, repo_name=pull_request.target_repo.repo_name,
1160 1202 username=self._rhodecode_db_user.username, action='push',
1161 1203 scm=pull_request.target_repo.repo_type)
1204 with pull_request.set_state(PullRequest.STATE_UPDATING):
1162 1205 self._merge_pull_request(
1163 1206 pull_request, self._rhodecode_db_user, extras)
1164 1207 else:
@@ -3538,6 +3538,32 b' class ChangesetStatus(Base, BaseModel):'
3538 3538 return data
3539 3539
3540 3540
3541 class _SetState(object):
3542 """
3543 Context processor allowing changing state for sensitive operation such as
3544 pull request update or merge
3545 """
3546
3547 def __init__(self, pull_request, pr_state, back_state=None):
3548 self._pr = pull_request
3549 self._org_state = back_state or pull_request.pull_request_state
3550 self._pr_state = pr_state
3551
3552 def __enter__(self):
3553 log.debug('StateLock: entering set state context, setting state to: `%s`',
3554 self._pr_state)
3555 self._pr.pull_request_state = self._pr_state
3556 Session().add(self._pr)
3557 Session().commit()
3558
3559 def __exit__(self, exc_type, exc_val, exc_tb):
3560 log.debug('StateLock: exiting set state context, setting state to: `%s`',
3561 self._org_state)
3562 self._pr.pull_request_state = self._org_state
3563 Session().add(self._pr)
3564 Session().commit()
3565
3566
3541 3567 class _PullRequestBase(BaseModel):
3542 3568 """
3543 3569 Common attributes of pull request and version entries.
@@ -3548,6 +3574,12 b' class _PullRequestBase(BaseModel):'
3548 3574 STATUS_OPEN = u'open'
3549 3575 STATUS_CLOSED = u'closed'
3550 3576
3577 # available states
3578 STATE_CREATING = u'creating'
3579 STATE_UPDATING = u'updating'
3580 STATE_MERGING = u'merging'
3581 STATE_CREATED = u'created'
3582
3551 3583 title = Column('title', Unicode(255), nullable=True)
3552 3584 description = Column(
3553 3585 'description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'),
@@ -3563,6 +3595,8 b' class _PullRequestBase(BaseModel):'
3563 3595 'updated_on', DateTime(timezone=False), nullable=False,
3564 3596 default=datetime.datetime.now)
3565 3597
3598 pull_request_state = Column("pull_request_state", String(255), nullable=True)
3599
3566 3600 @declared_attr
3567 3601 def user_id(cls):
3568 3602 return Column(
@@ -3737,6 +3771,7 b' class _PullRequestBase(BaseModel):'
3737 3771 'title': pull_request.title,
3738 3772 'description': pull_request.description,
3739 3773 'status': pull_request.status,
3774 'state': pull_request.pull_request_state,
3740 3775 'created_on': pull_request.created_on,
3741 3776 'updated_on': pull_request.updated_on,
3742 3777 'commit_ids': pull_request.revisions,
@@ -3777,6 +3812,20 b' class _PullRequestBase(BaseModel):'
3777 3812
3778 3813 return data
3779 3814
3815 def set_state(self, pull_request_state, final_state=None):
3816 """
3817 # goes from initial state to updating to initial state.
3818 # initial state can be changed by specifying back_state=
3819 with pull_request_obj.set_state(PullRequest.STATE_UPDATING):
3820 pull_request.merge()
3821
3822 :param pull_request_state:
3823 :param final_state:
3824
3825 """
3826
3827 return _SetState(self, pull_request_state, back_state=final_state)
3828
3780 3829
3781 3830 class PullRequest(Base, _PullRequestBase):
3782 3831 __tablename__ = 'pull_requests'
@@ -138,7 +138,7 b' class PullRequestModel(BaseModel):'
138 138
139 139 def _prepare_get_all_query(self, repo_name, source=False, statuses=None,
140 140 opened_by=None, order_by=None,
141 order_dir='desc'):
141 order_dir='desc', only_created=True):
142 142 repo = None
143 143 if repo_name:
144 144 repo = self._get_repo(repo_name)
@@ -159,6 +159,10 b' class PullRequestModel(BaseModel):'
159 159 if opened_by:
160 160 q = q.filter(PullRequest.user_id.in_(opened_by))
161 161
162 # only get those that are in "created" state
163 if only_created:
164 q = q.filter(PullRequest.pull_request_state == PullRequest.STATE_CREATED)
165
162 166 if order_by:
163 167 order_map = {
164 168 'name_raw': PullRequest.pull_request_id,
@@ -429,7 +433,7 b' class PullRequestModel(BaseModel):'
429 433 pull_request.description_renderer = description_renderer
430 434 pull_request.author = created_by_user
431 435 pull_request.reviewer_data = reviewer_data
432
436 pull_request.pull_request_state = pull_request.STATE_CREATING
433 437 Session().add(pull_request)
434 438 Session().flush()
435 439
@@ -497,7 +501,14 b' class PullRequestModel(BaseModel):'
497 501 # that for large repos could be long resulting in long row locks
498 502 Session().commit()
499 503
500 # prepare workspace, and run initial merge simulation
504 # prepare workspace, and run initial merge simulation. Set state during that
505 # operation
506 pull_request = PullRequest.get(pull_request.pull_request_id)
507
508 # set as merging, for simulation, and if finished to created so we mark
509 # simulation is working fine
510 with pull_request.set_state(PullRequest.STATE_MERGING,
511 final_state=PullRequest.STATE_CREATED):
501 512 MergeCheck.validate(
502 513 pull_request, auth_user=auth_user, translator=translator)
503 514
@@ -653,8 +664,7 b' class PullRequestModel(BaseModel):'
653 664 target_ref_id = pull_request.target_ref_parts.commit_id
654 665
655 666 if not self.has_valid_update_type(pull_request):
656 log.debug(
657 "Skipping update of pull request %s due to ref type: %s",
667 log.debug("Skipping update of pull request %s due to ref type: %s",
658 668 pull_request, source_ref_type)
659 669 return UpdateResponse(
660 670 executed=False,
@@ -801,8 +811,7 b' class PullRequestModel(BaseModel):'
801 811 pull_request.source_ref_parts.commit_id,
802 812 pull_request_version.pull_request_version_id)
803 813 Session().commit()
804 self._trigger_pull_request_hook(
805 pull_request, pull_request.author, 'update')
814 self._trigger_pull_request_hook(pull_request, pull_request.author, 'update')
806 815
807 816 return UpdateResponse(
808 817 executed=True, reason=UpdateFailureReason.NONE,
@@ -814,6 +823,7 b' class PullRequestModel(BaseModel):'
814 823 version.title = pull_request.title
815 824 version.description = pull_request.description
816 825 version.status = pull_request.status
826 version.pull_request_state = pull_request.pull_request_state
817 827 version.created_on = datetime.datetime.now()
818 828 version.updated_on = pull_request.updated_on
819 829 version.user_id = pull_request.user_id
@@ -1614,8 +1624,7 b' class MergeCheck(object):'
1614 1624
1615 1625 msg = _('Pull request reviewer approval is pending.')
1616 1626
1617 merge_check.push_error(
1618 'warning', msg, cls.REVIEW_CHECK, review_status)
1627 merge_check.push_error('warning', msg, cls.REVIEW_CHECK, review_status)
1619 1628
1620 1629 if fail_early:
1621 1630 return merge_check
@@ -1624,7 +1633,7 b' class MergeCheck(object):'
1624 1633 todos = CommentsModel().get_unresolved_todos(pull_request)
1625 1634 if todos:
1626 1635 log.debug("MergeCheck: cannot merge, {} "
1627 "unresolved todos left.".format(len(todos)))
1636 "unresolved TODOs left.".format(len(todos)))
1628 1637
1629 1638 if len(todos) == 1:
1630 1639 msg = _('Cannot merge, {} TODO still not resolved.').format(
@@ -1645,8 +1654,7 b' class MergeCheck(object):'
1645 1654 merge_check.merge_possible = merge_status
1646 1655 merge_check.merge_msg = msg
1647 1656 if not merge_status:
1648 log.debug(
1649 "MergeCheck: cannot merge, pull request merge not possible.")
1657 log.debug("MergeCheck: cannot merge, pull request merge not possible.")
1650 1658 merge_check.push_error('warning', msg, cls.MERGE_CHECK, None)
1651 1659
1652 1660 if fail_early:
@@ -1677,6 +1685,7 b' class MergeCheck(object):'
1677 1685 close_branch = model._close_branch_before_merging(pull_request)
1678 1686 if close_branch:
1679 1687 repo_type = pull_request.target_repo.repo_type
1688 close_msg = ''
1680 1689 if repo_type == 'hg':
1681 1690 close_msg = _('Source branch will be closed after merge.')
1682 1691 elif repo_type == 'git':
@@ -1689,6 +1698,7 b' class MergeCheck(object):'
1689 1698
1690 1699 return merge_details
1691 1700
1701
1692 1702 ChangeTuple = collections.namedtuple(
1693 1703 'ChangeTuple', ['added', 'common', 'removed', 'total'])
1694 1704
@@ -257,8 +257,7 b' class TestPullRequestModel(object):'
257 257 def has_largefiles(self, repo):
258 258 return repo == pull_request.source_repo
259 259
260 patcher = mock.patch.object(
261 PullRequestModel, '_has_largefiles', has_largefiles)
260 patcher = mock.patch.object(PullRequestModel, '_has_largefiles', has_largefiles)
262 261 with patcher:
263 262 status, msg = PullRequestModel().merge_status(pull_request)
264 263
@@ -270,8 +269,7 b' class TestPullRequestModel(object):'
270 269 def has_largefiles(self, repo):
271 270 return repo == pull_request.target_repo
272 271
273 patcher = mock.patch.object(
274 PullRequestModel, '_has_largefiles', has_largefiles)
272 patcher = mock.patch.object(PullRequestModel, '_has_largefiles', has_largefiles)
275 273 with patcher:
276 274 status, msg = PullRequestModel().merge_status(pull_request)
277 275
@@ -314,9 +312,50 b' class TestPullRequestModel(object):'
314 312 self.pull_request, self.pull_request.author, 'merge')
315 313
316 314 pull_request = PullRequest.get(pull_request.pull_request_id)
317 assert (
318 pull_request.merge_rev ==
319 '6126b7bfcc82ad2d3deaee22af926b082ce54cc6')
315 assert pull_request.merge_rev == '6126b7bfcc82ad2d3deaee22af926b082ce54cc6'
316
317 def test_merge_with_status_lock(self, pull_request, merge_extras):
318 user = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
319 merge_ref = Reference(
320 'type', 'name', '6126b7bfcc82ad2d3deaee22af926b082ce54cc6')
321 self.merge_mock.return_value = MergeResponse(
322 True, True, merge_ref, MergeFailureReason.NONE)
323
324 merge_extras['repository'] = pull_request.target_repo.repo_name
325
326 with pull_request.set_state(PullRequest.STATE_UPDATING):
327 assert pull_request.pull_request_state == PullRequest.STATE_UPDATING
328 PullRequestModel().merge_repo(
329 pull_request, pull_request.author, extras=merge_extras)
330
331 assert pull_request.pull_request_state == PullRequest.STATE_CREATED
332
333 message = (
334 u'Merge pull request #{pr_id} from {source_repo} {source_ref_name}'
335 u'\n\n {pr_title}'.format(
336 pr_id=pull_request.pull_request_id,
337 source_repo=safe_unicode(
338 pull_request.source_repo.scm_instance().name),
339 source_ref_name=pull_request.source_ref_parts.name,
340 pr_title=safe_unicode(pull_request.title)
341 )
342 )
343 self.merge_mock.assert_called_with(
344 self.repo_id, self.workspace_id,
345 pull_request.target_ref_parts,
346 pull_request.source_repo.scm_instance(),
347 pull_request.source_ref_parts,
348 user_name=user.short_contact, user_email=user.email, message=message,
349 use_rebase=False, close_branch=False
350 )
351 self.invalidation_mock.assert_called_once_with(
352 pull_request.target_repo.repo_name)
353
354 self.hook_mock.assert_called_with(
355 self.pull_request, self.pull_request.author, 'merge')
356
357 pull_request = PullRequest.get(pull_request.pull_request_id)
358 assert pull_request.merge_rev == '6126b7bfcc82ad2d3deaee22af926b082ce54cc6'
320 359
321 360 def test_merge_failed(self, pull_request, merge_extras):
322 361 user = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
General Comments 0
You need to be logged in to leave comments. Login now