Changeset 73:06bfa9e5819c in repositorymanagerplugin

Timestamp:

15.05.2015 16:21:46 (9 years ago)

Author:

Tobias Föhst <foehst@…>

Branch:

default

Phase:

public

Tags:

tip

Message:

Adds support for deleting and banning changesets from managed repositories

Location:

repo_mgr

Files:

• api.py (modified) (4 diffs)
• templates/changeset_delete.html (added)
• versioncontrol/hg.py (modified) (2 diffs)
• versioncontrol/svn.py (modified) (1 diff)
• web_ui.py (modified) (1 diff)

repo_mgr/api.py

@@ -43 +43 @@
         """Return whether forking is supported by the connector."""
 
+    def can_delete_changesets(repository_type):
+        """Return whether deleting changesets is supported."""
+
+    def can_ban_changesets(repository_type):
+        """Return whether banning changesets is supported."""
+
     def create(repository):
         """Create a new empty repository with given attributes."""
@@ -48 +54 @@
     def fork(repository):
         """Fork from `origin_url` in the given dict."""
+
+    def delete_changeset(repository, revision, ban):
+        """Delete (and optionally ban) a changeset from the repository."""
 
     def update_auth_files(repositories):
@@ -104 +113 @@
         """Return whether the given repository type can be forked."""
         return self._get_repository_connector(type).can_fork(type)
+
+    def can_delete_changesets(self, type):
+        """Return whether the given repository type can delete changesets."""
+        return self._get_repository_connector(type).can_delete_changesets(type)
+
+    def can_ban_changesets(self, type):
+        """Return whether the given repository type can ban changesets."""
+        return self._get_repository_connector(type).can_ban_changesets(type)
 
     def get_forkable_repositories(self):
@@ -259 +276 @@
         self.update_auth_files()
 
+    def delete_changeset(self, repo, rev, ban):
+        """Delete a changeset from a managed repository, if supported.
+
+        Depending on the parameter ban this method also marks the
+        changeset to be kept out of the repository. That features needs
+        special support by the used scm.
+        """
+        convert_managed_repository(self.env, repo)
+        self._get_repository_connector(repo.type).delete_changeset(repo, rev, ban)
+
     def add_role(self, repo, role, subject):
         """Add a role for the given repository."""

repo_mgr/versioncontrol/hg.py

@@ -19 +19 @@
         return True
 
+    def can_delete_changesets(self, type):
+        return True
+
+    def can_ban_changesets(self, type):
+        try:
+            import hgban
+            return True
+        except:
+            return False
+
     def create(self, repo):
         try:
@@ -31 +41 @@
         except Exception, e:
             raise TracError(_("Failed to clone repository: ") + str(e))
+
+    def delete_changeset(self, repo, rev, ban):
+        try:
+            from mercurial import ui, hg, repair
+            hg_repo = hg.repository(ui.ui(), repo.directory)
+            repair.strip(ui.ui(), hg_repo, [ hg_repo[rev].node() ], None)
+        except Exception, e:
+            raise TracError(_("Failed to strip changesets from repository: ") + str(e))
+
+        if ban:
+            try:
+                import hgban
+            except:
+                raise TracError(_("Could not import the hgban extension"))
+            hgrc_path = os.path.join(repo.directory, '.hg/hgrc')
+
+            hgrc = ConfigParser()
+            hgrc.read(hgrc_path)
+
+            if not hgrc.has_section('extensions'):
+                hgrc.add_section('extensions')
+            hgrc.set('extensions', 'hgban', '')
+
+            revsets = ''
+            if hgrc.has_section('hgban'):
+                revsets = hgrc.get('hgban', 'revsets')
+            else:
+                hgrc.add_section('hgban')
+            hgrc.set('hgban', 'revsets', revsets  + "\n" + rev)
+
+            with open(hgrc_path, 'wb') as hgrc_file:
+                hgrc.write(hgrc_file)
+                try:
+                    modes = stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP | stat.S_IWGRP
+                    os.chmod(hgrc_path, modes)
+                except:
+                    pass
 
     def update_auth_files(self, repositories):

repo_mgr/versioncontrol/svn.py

@@ -42 +42 @@
 
     def can_fork(self, type):
+        return False
+
+    def can_delete_changesets(self, type):
+        return False
+
+    def can_ban_changesets(self, type):
         return False
 

repo_mgr/web_ui.py

@@ -497 +497 @@
     except:
         pass
+
+class ChangesetModule(Component):
+    """Supports deleting and banning of changesets from managed repositories"""
+
+    implements(IPermissionRequestor, IRequestFilter, IRequestHandler, ITemplateProvider)
+
+    ### IPermissionRequestor methods
+    def get_permission_actions(self):
+        return ['CHANGESET_DELETE']
+
+    ### IRequestFilter methods
+    def pre_process_request(self, req, handler):
+        return handler
+
+    def post_process_request(self, req, template, data, content_type):
+        match = re.match(r'^/changeset', req.path_info)
+        if 'CHANGESET_DELETE' in req.perm and match:
+            rev = req.args.get('new')
+            path = req.args.get('new_path')
+
+            rm = RepositoryManager(self.env)
+            if rev and path:
+                reponame, repos, path = rm.get_repository_by_path(path)
+                convert_managed_repository(self.env, repos)
+                if (path == '/' and (repos.owner == req.authname or
+                                     'REPOSITORY_ADMIN' in req.perm)
+                    and rm.can_delete_changesets(repos.type)):
+                    add_ctxtnav(req, _("Delete Changeset"),
+                                req.href.deletechangeset(rev, reponame))
+
+        return template, data, content_type
+
+    ### IRequestHandler methods
+    def match_request(self, req):
+        match = re.match(r'^/deletechangeset/([^/]+)/(.+)$', req.path_info)
+        if match:
+            rev, reponame = match.groups()
+            req.args['rev'] = rev
+            req.args['reponame'] = reponame
+            return True
+
+    def process_request(self, req):
+        req.perm.require('CHANGESET_DELETE')
+
+        rm = RepositoryManager(self.env)
+        repos = rm.get_repository(req.args['reponame'], True)
+        if not repos:
+            raise TracError(_('Repository "%(name)s" does not exist.',
+                              name=req.args['reponame']))
+
+        if not (repos.owner == req.authname or
+                'REPOSITORY_ADMIN' in req.perm):
+            message = _('You (%(user)s) are not the owner of "%(name)s"',
+                        user=req.authname, name=repos.reponame)
+            raise PermissionError(message)
+
+        if req.args.get('confirm'):
+            display_rev = repos.display_rev(req.args['rev'])
+            rm.delete_changeset(repos, req.args['rev'], req.args.get('ban'))
+            add_notice(req, _('The changeset "%(rev)s" has been removed.',
+                              rev=display_rev))
+            req.redirect(req.href.log(repos.reponame))
+        elif req.args.get('cancel'):
+            LoginModule(self.env)._redirect_back(req)
+
+        data = {'repository': repos,
+                'rev': req.args['rev'],
+                'cannot_ban': not rm.can_ban_changesets(repos.type)}
+
+        add_stylesheet(req, 'common/css/admin.css')
+        return 'changeset_delete.html', data, None
+
+    ### ITemplateProvider methods
+    def get_templates_dirs(self):
+        from pkg_resources import resource_filename
+        return [resource_filename(__name__, 'templates')]
+
+    def get_htdocs_dirs(self):
+        return []