permissions: flush permissions correctly for forks/repos when celery is used.

rhodecode/apps/admin/views/repositories.py

@@ -1,194 +1,189 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import logging
 import formencode
 import formencode.htmlfill
 
 from pyramid.httpexceptions import HTTPFound, HTTPForbidden
 from pyramid.view import view_config
 from pyramid.renderers import render
 from pyramid.response import Response
 
 from rhodecode import events
 from rhodecode.apps._base import BaseAppView, DataGridAppView
 from rhodecode.lib.celerylib.utils import get_task_id
 
 from rhodecode.lib.ext_json import json
 from rhodecode.lib.auth import (
     LoginRequired, CSRFRequired, NotAnonymous,
     HasPermissionAny, HasRepoGroupPermissionAny)
 from rhodecode.lib import helpers as h
 from rhodecode.lib.utils import repo_name_slug
 from rhodecode.lib.utils2 import safe_int, safe_unicode
 from rhodecode.model.forms import RepoForm
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.scm import RepoList, RepoGroupList, ScmModel
 from rhodecode.model.settings import SettingsModel
 from rhodecode.model.db import Repository, RepoGroup
 
 log = logging.getLogger(__name__)
 
 
 class AdminReposView(BaseAppView, DataGridAppView):
 
     def load_default_context(self):
         c = self._get_local_tmpl_context()
 
         return c
 
     def _load_form_data(self, c):
         acl_groups = RepoGroupList(RepoGroup.query().all(),
                                    perm_set=['group.write', 'group.admin'])
         c.repo_groups = RepoGroup.groups_choices(groups=acl_groups)
         c.repo_groups_choices = map(lambda k: safe_unicode(k[0]), c.repo_groups)
         c.landing_revs_choices, c.landing_revs = \
             ScmModel().get_repo_landing_revs(self.request.translate)
         c.personal_repo_group = self._rhodecode_user.personal_repo_group
 
     @LoginRequired()
     @NotAnonymous()
     # perms check inside
     @view_config(
         route_name='repos', request_method='GET',
         renderer='rhodecode:templates/admin/repos/repos.mako')
     def repository_list(self):
         c = self.load_default_context()
 
         repo_list = Repository.get_all_repos()
         c.repo_list = RepoList(repo_list, perm_set=['repository.admin'])
         repos_data = RepoModel().get_repos_as_dict(
             repo_list=c.repo_list, admin=True, super_user_actions=True)
         # json used to render the grid
         c.data = json.dumps(repos_data)
 
         return self._get_template_context(c)
 
     @LoginRequired()
     @NotAnonymous()
     # perms check inside
     @view_config(
         route_name='repo_new', request_method='GET',
         renderer='rhodecode:templates/admin/repos/repo_add.mako')
     def repository_new(self):
         c = self.load_default_context()
 
         new_repo = self.request.GET.get('repo', '')
         parent_group = safe_int(self.request.GET.get('parent_group'))
         _gr = RepoGroup.get(parent_group)
 
         if not HasPermissionAny('hg.admin', 'hg.create.repository')():
             # you're not super admin nor have global create permissions,
             # but maybe you have at least write permission to a parent group ?
 
             gr_name = _gr.group_name if _gr else None
             # create repositories with write permission on group is set to true
             create_on_write = HasPermissionAny('hg.create.write_on_repogroup.true')()
             group_admin = HasRepoGroupPermissionAny('group.admin')(group_name=gr_name)
             group_write = HasRepoGroupPermissionAny('group.write')(group_name=gr_name)
             if not (group_admin or (group_write and create_on_write)):
                 raise HTTPForbidden()
 
         self._load_form_data(c)
         c.new_repo = repo_name_slug(new_repo)
 
         # apply the defaults from defaults page
         defaults = SettingsModel().get_default_repo_settings(strip_prefix=True)
         # set checkbox to autochecked
         defaults['repo_copy_permissions'] = True
 
         parent_group_choice = '-1'
         if not self._rhodecode_user.is_admin and self._rhodecode_user.personal_repo_group:
             parent_group_choice = self._rhodecode_user.personal_repo_group
 
         if parent_group and _gr:
             if parent_group in [x[0] for x in c.repo_groups]:
                 parent_group_choice = safe_unicode(parent_group)
 
         defaults.update({'repo_group': parent_group_choice})
 
         data = render('rhodecode:templates/admin/repos/repo_add.mako',
                       self._get_template_context(c), self.request)
         html = formencode.htmlfill.render(
             data,
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False
         )
         return Response(html)
 
     @LoginRequired()
     @NotAnonymous()
     @CSRFRequired()
     # perms check inside
     @view_config(
         route_name='repo_create', request_method='POST',
         renderer='rhodecode:templates/admin/repos/repos.mako')
     def repository_create(self):
         c = self.load_default_context()
 
         form_result = {}
         self._load_form_data(c)
 
         try:
             # CanWriteToGroup validators checks permissions of this POST
             form = RepoForm(
                 self.request.translate, repo_groups=c.repo_groups_choices,
                 landing_revs=c.landing_revs_choices)()
             form_result = form.to_python(dict(self.request.POST))
             copy_permissions = form_result.get('repo_copy_permissions')
             # create is done sometimes async on celery, db transaction
             # management is handled there.
             task = RepoModel().create(form_result, self._rhodecode_user.user_id)
             task_id = get_task_id(task)
         except formencode.Invalid as errors:
             data = render('rhodecode:templates/admin/repos/repo_add.mako',
                           self._get_template_context(c), self.request)
             html = formencode.htmlfill.render(
                 data,
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
                 encoding="UTF-8",
                 force_defaults=False
             )
             return Response(html)
 
         except Exception as e:
             msg = self._log_creation_exception(e, form_result.get('repo_name'))
             h.flash(msg, category='error')
             raise HTTPFound(h.route_path('home'))
 
         repo_name = form_result.get('repo_name_full')
 
         affected_user_ids = [self._rhodecode_user.user_id]
         if copy_permissions:
-            repository = Repository.get_by_repo_name(repo_name)
-            # also include those newly created by copy
-            user_group_perms = repository.permissions(expand_from_user_groups=True)
-            copy_perms = [perm['user_id'] for perm in user_group_perms]
-            # also include those newly created by copy
-            affected_user_ids.extend(copy_perms)
-
+            # permission flush is done in repo creating
+            pass
         events.trigger(events.UserPermissionsChange(affected_user_ids))
 
         raise HTTPFound(
             h.route_path('repo_creating', repo_name=repo_name,
                          _query=dict(task_id=task_id)))

rhodecode/apps/repository/views/repo_checks.py

@@ -1,114 +1,125 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2011-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import logging
 
 from pyramid.view import view_config
 from pyramid.httpexceptions import HTTPFound, HTTPNotFound
 
+from rhodecode import events
 from rhodecode.apps._base import BaseAppView
 from rhodecode.lib import helpers as h
 from rhodecode.lib.auth import (NotAnonymous, HasRepoPermissionAny)
 from rhodecode.model.db import Repository
 from rhodecode.model.validation_schema.types import RepoNameType
 
 log = logging.getLogger(__name__)
 
 
 class RepoChecksView(BaseAppView):
     def load_default_context(self):
         c = self._get_local_tmpl_context()
 
         return c
 
     @NotAnonymous()
     @view_config(
         route_name='repo_creating', request_method='GET',
         renderer='rhodecode:templates/admin/repos/repo_creating.mako')
     def repo_creating(self):
         c = self.load_default_context()
         repo_name = self.request.matchdict['repo_name']
         repo_name = RepoNameType().deserialize(None, repo_name)
         db_repo = Repository.get_by_repo_name(repo_name)
 
         # check if maybe repo is already created
         if db_repo and db_repo.repo_state in [Repository.STATE_CREATED]:
+            self.flush_permissions_on_creation(db_repo)
+
             # re-check permissions before redirecting to prevent resource
             # discovery by checking the 302 code
             perm_set = ['repository.read', 'repository.write', 'repository.admin']
             has_perm = HasRepoPermissionAny(*perm_set)(
                 db_repo.repo_name, 'Repo Creating check')
             if not has_perm:
                 raise HTTPNotFound()
 
             raise HTTPFound(h.route_path(
                 'repo_summary', repo_name=db_repo.repo_name))
 
         c.task_id = self.request.GET.get('task_id')
         c.repo_name = repo_name
 
         return self._get_template_context(c)
 
     @NotAnonymous()
     @view_config(
         route_name='repo_creating_check', request_method='GET',
         renderer='json_ext')
     def repo_creating_check(self):
         _ = self.request.translate
         task_id = self.request.GET.get('task_id')
         self.load_default_context()
 
         repo_name = self.request.matchdict['repo_name']
 
         if task_id and task_id not in ['None']:
             import rhodecode
             from rhodecode.lib.celerylib.loader import celery_app, exceptions
             if rhodecode.CELERY_ENABLED:
                 log.debug('celery: checking result for task:%s', task_id)
                 task = celery_app.AsyncResult(task_id)
                 try:
                     task.get(timeout=10)
                 except exceptions.TimeoutError:
                     task = None
                 if task and task.failed():
                     msg = self._log_creation_exception(task.result, repo_name)
                     h.flash(msg, category='error')
                     raise HTTPFound(h.route_path('home'), code=501)
 
         db_repo = Repository.get_by_repo_name(repo_name)
         if db_repo and db_repo.repo_state == Repository.STATE_CREATED:
             if db_repo.clone_uri:
                 clone_uri = db_repo.clone_uri_hidden
                 h.flash(_('Created repository %s from %s')
                         % (db_repo.repo_name, clone_uri), category='success')
             else:
                 repo_url = h.link_to(
                     db_repo.repo_name,
                     h.route_path('repo_summary', repo_name=db_repo.repo_name))
                 fork = db_repo.fork
                 if fork:
                     fork_name = fork.repo_name
                     h.flash(h.literal(_('Forked repository %s as %s')
                                       % (fork_name, repo_url)), category='success')
                 else:
                     h.flash(h.literal(_('Created repository %s') % repo_url),
                             category='success')
+            self.flush_permissions_on_creation(db_repo)
+
             return {'result': True}
         return {'result': False}
+
+    def flush_permissions_on_creation(self, db_repo):
+        # repo is finished and created, we flush the permissions now
+        user_group_perms = db_repo.permissions(expand_from_user_groups=True)
+        affected_user_ids = [perm['user_id'] for perm in user_group_perms]
+        events.trigger(events.UserPermissionsChange(affected_user_ids))

rhodecode/apps/repository/views/repo_forks.py

@@ -1,270 +1,266 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2011-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import logging
 import datetime
 import formencode
 import formencode.htmlfill
 
 from pyramid.httpexceptions import HTTPFound
 from pyramid.view import view_config
 from pyramid.renderers import render
 from pyramid.response import Response
 
 from rhodecode import events
 from rhodecode.apps._base import RepoAppView, DataGridAppView
 from rhodecode.lib.auth import (
     LoginRequired, HasRepoPermissionAnyDecorator, NotAnonymous,
     HasRepoPermissionAny, HasPermissionAnyDecorator, CSRFRequired)
 import rhodecode.lib.helpers as h
 from rhodecode.lib.celerylib.utils import get_task_id
 from rhodecode.model.db import coalesce, or_, Repository, RepoGroup
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.forms import RepoForkForm
 from rhodecode.model.scm import ScmModel, RepoGroupList
 from rhodecode.lib.utils2 import safe_int, safe_unicode
 
 log = logging.getLogger(__name__)
 
 
 class RepoForksView(RepoAppView, DataGridAppView):
 
     def load_default_context(self):
         c = self._get_local_tmpl_context(include_app_defaults=True)
         c.rhodecode_repo = self.rhodecode_vcs_repo
 
         acl_groups = RepoGroupList(
             RepoGroup.query().all(),
             perm_set=['group.write', 'group.admin'])
         c.repo_groups = RepoGroup.groups_choices(groups=acl_groups)
         c.repo_groups_choices = map(lambda k: safe_unicode(k[0]), c.repo_groups)
         choices, c.landing_revs = ScmModel().get_repo_landing_revs(
             self.request.translate)
         c.landing_revs_choices = choices
         c.personal_repo_group = c.rhodecode_user.personal_repo_group
 
         return c
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_forks_show_all', request_method='GET',
         renderer='rhodecode:templates/forks/forks.mako')
     def repo_forks_show_all(self):
         c = self.load_default_context()
         return self._get_template_context(c)
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_forks_data', request_method='GET',
         renderer='json_ext', xhr=True)
     def repo_forks_data(self):
         _ = self.request.translate
         self.load_default_context()
         column_map = {
             'fork_name': 'repo_name',
             'fork_date': 'created_on',
             'last_activity': 'updated_on'
         }
         draw, start, limit = self._extract_chunk(self.request)
         search_q, order_by, order_dir = self._extract_ordering(
             self.request, column_map=column_map)
 
         acl_check = HasRepoPermissionAny(
             'repository.read', 'repository.write', 'repository.admin')
         repo_id = self.db_repo.repo_id
         allowed_ids = [-1]
         for f in Repository.query().filter(Repository.fork_id == repo_id):
             if acl_check(f.repo_name, 'get forks check'):
                 allowed_ids.append(f.repo_id)
 
         forks_data_total_count = Repository.query()\
             .filter(Repository.fork_id == repo_id)\
             .filter(Repository.repo_id.in_(allowed_ids))\
             .count()
 
         # json generate
         base_q = Repository.query()\
             .filter(Repository.fork_id == repo_id)\
             .filter(Repository.repo_id.in_(allowed_ids))\
 
         if search_q:
             like_expression = u'%{}%'.format(safe_unicode(search_q))
             base_q = base_q.filter(or_(
                 Repository.repo_name.ilike(like_expression),
                 Repository.description.ilike(like_expression),
             ))
 
         forks_data_total_filtered_count = base_q.count()
 
         sort_col = getattr(Repository, order_by, None)
         if sort_col:
             if order_dir == 'asc':
                 # handle null values properly to order by NULL last
                 if order_by in ['last_activity']:
                     sort_col = coalesce(sort_col, datetime.date.max)
                 sort_col = sort_col.asc()
             else:
                 # handle null values properly to order by NULL last
                 if order_by in ['last_activity']:
                     sort_col = coalesce(sort_col, datetime.date.min)
                 sort_col = sort_col.desc()
 
         base_q = base_q.order_by(sort_col)
         base_q = base_q.offset(start).limit(limit)
 
         fork_list = base_q.all()
 
         def fork_actions(fork):
             url_link = h.route_path(
                 'repo_compare',
                 repo_name=fork.repo_name,
                 source_ref_type=self.db_repo.landing_rev[0],
                 source_ref=self.db_repo.landing_rev[1],
                 target_ref_type=self.db_repo.landing_rev[0],
                 target_ref=self.db_repo.landing_rev[1],
                 _query=dict(merge=1, target_repo=f.repo_name))
             return h.link_to(_('Compare fork'), url_link, class_='btn-link')
 
         def fork_name(fork):
             return h.link_to(fork.repo_name,
                       h.route_path('repo_summary', repo_name=fork.repo_name))
 
         forks_data = []
         for fork in fork_list:
             forks_data.append({
                 "username": h.gravatar_with_user(self.request, fork.user.username),
                 "fork_name": fork_name(fork),
                 "description": fork.description_safe,
                 "fork_date": h.age_component(fork.created_on, time_is_local=True),
                 "last_activity": h.format_date(fork.updated_on),
                 "action": fork_actions(fork),
             })
 
         data = ({
             'draw': draw,
             'data': forks_data,
             'recordsTotal': forks_data_total_count,
             'recordsFiltered': forks_data_total_filtered_count,
         })
 
         return data
 
     @LoginRequired()
     @NotAnonymous()
     @HasPermissionAnyDecorator('hg.admin', 'hg.fork.repository')
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_fork_new', request_method='GET',
         renderer='rhodecode:templates/forks/forks.mako')
     def repo_fork_new(self):
         c = self.load_default_context()
 
         defaults = RepoModel()._get_defaults(self.db_repo_name)
         # alter the description to indicate a fork
         defaults['description'] = (
             'fork of repository: %s \n%s' % (
                 defaults['repo_name'], defaults['description']))
         # add suffix to fork
         defaults['repo_name'] = '%s-fork' % defaults['repo_name']
 
         data = render('rhodecode:templates/forks/fork.mako',
                       self._get_template_context(c), self.request)
         html = formencode.htmlfill.render(
             data,
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False
         )
         return Response(html)
 
     @LoginRequired()
     @NotAnonymous()
     @HasPermissionAnyDecorator('hg.admin', 'hg.fork.repository')
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @CSRFRequired()
     @view_config(
         route_name='repo_fork_create', request_method='POST',
         renderer='rhodecode:templates/forks/fork.mako')
     def repo_fork_create(self):
         _ = self.request.translate
         c = self.load_default_context()
 
         _form = RepoForkForm(self.request.translate, old_data={'repo_type': self.db_repo.repo_type},
                              repo_groups=c.repo_groups_choices,
                              landing_revs=c.landing_revs_choices)()
         post_data = dict(self.request.POST)
 
         # forbid injecting other repo by forging a request
         post_data['fork_parent_id'] = self.db_repo.repo_id
 
         form_result = {}
         task_id = None
         try:
             form_result = _form.to_python(post_data)
             copy_permissions = form_result.get('copy_permissions')
             # create fork is done sometimes async on celery, db transaction
             # management is handled there.
             task = RepoModel().create_fork(
                 form_result, c.rhodecode_user.user_id)
 
             task_id = get_task_id(task)
         except formencode.Invalid as errors:
             c.rhodecode_db_repo = self.db_repo
 
             data = render('rhodecode:templates/forks/fork.mako',
                           self._get_template_context(c), self.request)
             html = formencode.htmlfill.render(
                 data,
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
                 encoding="UTF-8",
                 force_defaults=False
             )
             return Response(html)
         except Exception:
             log.exception(
                 u'Exception while trying to fork the repository %s', self.db_repo_name)
             msg = _('An error occurred during repository forking %s') % (self.db_repo_name, )
             h.flash(msg, category='error')
             raise HTTPFound(h.route_path('home'))
 
         repo_name = form_result.get('repo_name_full', self.db_repo_name)
 
         affected_user_ids = [self._rhodecode_user.user_id]
         if copy_permissions:
-            repository = Repository.get_by_repo_name(repo_name)
-            # also include those newly created by copy
-            user_group_perms = repository.permissions(expand_from_user_groups=True)
-            copy_perms = [perm['user_id'] for perm in user_group_perms]
-            # also include those newly created by copy
-            affected_user_ids.extend(copy_perms)
+            # permission flush is done in repo creating
+            pass
 
         events.trigger(events.UserPermissionsChange(affected_user_ids))
 
         raise HTTPFound(
             h.route_path('repo_creating', repo_name=repo_name,
                          _query=dict(task_id=task_id)))