Attachment #70801 for bug #109477




        
        @param authname: user name for authorization
        """
        from trac.versioncontrol import get_repository
        return get_repository(self, authname)
        from trac.versioncontrol.svn_fs import SubversionRepository
        repos_dir = self.config.get('trac', 'repository_dir')
        if not repos_dir:
            raise EnvironmentError, 'Path to repository not configured'
        authz = None
        if authname:
            authz = SubversionAuthorizer(self, authname)
        repos = SubversionRepository(repos_dir, authz, self.log)
        return CachedRepository(self.get_db_cnx(), repos, authz, self.log)

    def create(self, db_str=None):
        """Create the basic directory structure of the environment, initialize

Lines 24-30 Link Here

(-)upstream/trac/Timeline.py (-1 lines)
24	from trac.perm import IPermissionRequestor	24	from trac.perm import IPermissionRequestor
25	from trac.util import enum, escape, format_date, format_time, http_date, \	25	from trac.util import enum, escape, format_date, format_time, http_date, \
26	shorten_line	26	shorten_line
27	from trac.versioncontrol.svn_authz import SubversionAuthorizer
28	from trac.web import IRequestHandler	27	from trac.web import IRequestHandler
29	from trac.web.chrome import add_link, add_stylesheet, INavigationContributor	28	from trac.web.chrome import add_link, add_stylesheet, INavigationContributor
30		29





    def get_changes(self):
        """
        Generator that produces a (path, kind, change, base_path, base_rev)
        tuple for every change in the changeset, where change can be one of
        Changeset.ADD, Changeset.COPY, Changeset.DELETE, Changeset.EDIT or
        Changeset.MOVE, and kind is one of Node.FILE or Node.DIRECTORY.
        """
        raise NotImplementedError

    def insert_in_cache(self, cursor, kindmap, actionmap, log):
        """
        Insert this changeset in the cache db.
        """
        cursor.execute("INSERT INTO revision (rev,time,author,message) "
                       "VALUES (%s,%s,%s,%s)", (str(self.rev),
                       self.date, self.author,
                       self.message))
        for path,kind,action,base_path,base_rev in self.get_changes():
            log.debug("Caching node change in [%s]: %s"
                      % (self.rev, (path, kind, action,
                                    base_path, base_rev)))
            kind = kindmap[kind]
            action = actionmap[action]
            cursor.execute("INSERT INTO node_change (rev,path,kind,"
                           "change,base_path,base_rev) "
                           "VALUES (%s,%s,%s,%s,%s,%s)",
                           (str(self.rev), path, kind, action,
                           base_path, base_rev))

class PermissionDenied(PermissionError):
    """

    def has_permission_for_changeset(self, rev):
        return 1


def get_repository(env, authname):
    """
    Return the right repository backend wrapped by a CachedRepository.

    This looks for a ``darcs:`` or ``bzr:`` prefix on the
    'repository_dir' from the configuration: if present it qualifies
    respectively a Darcs or a Bazaar-NG repository, otherwise it uses
    the Subversion backend.
    """
    
    authz = None
    repos_dir = env.config.get('trac', 'repository_dir')
    db = env.get_db_cnx()
    if not repos_dir:
        raise EnvironmentError, 'Path to repository not configured'
    if repos_dir.startswith('darcs:'):
        from trac.versioncontrol.darcs import DarcsRepository, \
             DarcsCachedRepository as CachedRepository
        repos = DarcsRepository(db, repos_dir[6:], env.log)
    elif repos_dir.startswith('bzr:'):
        from trac.versioncontrol.bzr import BzrRepository, \
             BzrCachedRepository as CachedRepository
        #from trac.versioncontrol.cache import CachedRepository
        repos = BzrRepository(db, repos_dir[4:], env.log)
    else:
        from trac.versioncontrol.svn_authz import SubversionAuthorizer
        from trac.versioncontrol.svn_fs import SubversionRepository
        from trac.versioncontrol.cache import CachedRepository
        if authname:
            authz = SubversionAuthorizer(env, authname)
        repos = SubversionRepository(repos_dir, authz, env.log)
    return CachedRepository(db, repos, authz, env.log)


def get_authorizer(env, authname):
    """
    Return the right authorizer for the configured repository.

    Like ``get_repository()`` this looks for a ``darcs:`` or ``bzr:``
    prefix on the 'repository_dir' setting: if present it returns
    a basic Authorizer(), otherwise a SubversionAuthorizer.
    """
    
    authz = Authorizer()
    repos_dir = env.config.get('trac', 'repository_dir')
    if not repos_dir.startswith('darcs:') \
           and not repos_dir.startswith('bzr:'):
        from trac.versioncontrol.svn_authz import SubversionAuthorizer
        if authname:
            authz = SubversionAuthorizer(env, authname)
    return authz




                current_rev = self.repos.oldest_rev
            while current_rev is not None:
                changeset = self.repos.get_changeset(current_rev)
                changeset.insert_in_cache(cursor, kindmap, actionmap, self.log)
                               "VALUES (%s,%s,%s,%s)", (str(current_rev),
                               changeset.date, changeset.author,
                               changeset.message))
                for path,kind,action,base_path,base_rev in changeset.get_changes():
                    self.log.debug("Caching node change in [%s]: %s"
                                   % (current_rev, (path, kind, action,
                                      base_path, base_rev)))
                    kind = kindmap[kind]
                    action = actionmap[action]
                    cursor.execute("INSERT INTO node_change (rev,path,kind,"
                                   "change,base_path,base_rev) "
                                   "VALUES (%s,%s,%s,%s,%s,%s)",
                                   (str(current_rev), path, kind, action,
                                   base_path, base_rev))
                current_rev = self.repos.next_rev(current_rev)
            self.db.commit()
            self.repos.authz = authz # restore permission checking




from trac.perm import IPermissionRequestor
from trac.Search import ISearchSource, query_to_sql, shorten_result
from trac.Timeline import ITimelineEventProvider
from trac.versioncontrol import Changeset, Node, get_authorizer
from trac.versioncontrol.svn_authz import SubversionAuthorizer
from trac.versioncontrol.diff import get_diff_options, hdf_diff, unified_diff
from trac.web import IRequestHandler
from trac.web.chrome import add_link, add_stylesheet, INavigationContributor


        rev = req.args.get('rev')
        repos = self.env.get_repository(req.authname)
        authzperm = get_authorizer(self.env, req.authname)
        authzperm.assert_permission_for_changeset(rev)

        diff_options = get_diff_options(req)

                                             'changeset_show_files'))
            db = self.env.get_db_cnx()
            repos = self.env.get_repository()
            authzperm = get_authorizer(self.env, req.authname)
            rev = repos.youngest_rev
            while rev:
                if not authzperm.has_permission_for_changeset(rev):

    def get_search_results(self, req, query, filters):
        if not 'changeset' in filters:
            return
        authzperm = get_authorizer(self.env, req.authname)
        db = self.env.get_db_cnx()
        sql = "SELECT rev,time,author,message " \
              "FROM revision WHERE %s OR %s" % \

Return to bug 109477

Lines 131-147 Link Here

(-)upstream/trac/env.py (-11 / +2 lines)
131		131
132	@param authname: user name for authorization	132	@param authname: user name for authorization
133	"""	133	"""
134	from trac.versioncontrol.cache import CachedRepository	134	from trac.versioncontrol import get_repository
135	from trac.versioncontrol.svn_authz import SubversionAuthorizer	135	return get_repository(self, authname)
136	from trac.versioncontrol.svn_fs import SubversionRepository
137	repos_dir = self.config.get('trac', 'repository_dir')
138	if not repos_dir:
139	raise EnvironmentError, 'Path to repository not configured'
140	authz = None
141	if authname:
142	authz = SubversionAuthorizer(self, authname)
143	repos = SubversionRepository(repos_dir, authz, self.log)
144	return CachedRepository(self.get_db_cnx(), repos, authz, self.log)
145		136
146	def create(self, db_str=None):	137	def create(self, db_str=None):
147	"""Create the basic directory structure of the environment, initialize	138	"""Create the basic directory structure of the environment, initialize

Lines 198-210 Link Here

(-)upstream/trac/versioncontrol/api.py (-1 / +72 lines)
198		198
199	def get_changes(self):	199	def get_changes(self):
200	"""	200	"""
201	Generator that produces a (path, kind, change, base_rev, base_path)	201	Generator that produces a (path, kind, change, base_path, base_rev)
202	tuple for every change in the changeset, where change can be one of	202	tuple for every change in the changeset, where change can be one of
203	Changeset.ADD, Changeset.COPY, Changeset.DELETE, Changeset.EDIT or	203	Changeset.ADD, Changeset.COPY, Changeset.DELETE, Changeset.EDIT or
204	Changeset.MOVE, and kind is one of Node.FILE or Node.DIRECTORY.	204	Changeset.MOVE, and kind is one of Node.FILE or Node.DIRECTORY.
205	"""	205	"""
206	raise NotImplementedError	206	raise NotImplementedError
207		207
		208	def insert_in_cache(self, cursor, kindmap, actionmap, log):
		209	"""
		210	Insert this changeset in the cache db.
		211	"""
		212	cursor.execute("INSERT INTO revision (rev,time,author,message) "
		213	"VALUES (%s,%s,%s,%s)", (str(self.rev),
		214	self.date, self.author,
		215	self.message))
		216	for path,kind,action,base_path,base_rev in self.get_changes():
		217	log.debug("Caching node change in [%s]: %s"
		218	% (self.rev, (path, kind, action,
		219	base_path, base_rev)))
		220	kind = kindmap[kind]
		221	action = actionmap[action]
		222	cursor.execute("INSERT INTO node_change (rev,path,kind,"
		223	"change,base_path,base_rev) "
		224	"VALUES (%s,%s,%s,%s,%s,%s)",
		225	(str(self.rev), path, kind, action,
		226	base_path, base_rev))
208		227
209	class PermissionDenied(PermissionError):	228	class PermissionDenied(PermissionError):
210	"""	229	"""
Lines 237-239 Link Here
237	def has_permission_for_changeset(self, rev):	256	def has_permission_for_changeset(self, rev):
238	return 1	257	return 1
239		258
		259
		260	def get_repository(env, authname):
		261	"""
		262	Return the right repository backend wrapped by a CachedRepository.
		263
		264	This looks for a ``darcs:`` or ``bzr:`` prefix on the
		265	'repository_dir' from the configuration: if present it qualifies
		266	respectively a Darcs or a Bazaar-NG repository, otherwise it uses
		267	the Subversion backend.
		268	"""
		269
		270	authz = None
		271	repos_dir = env.config.get('trac', 'repository_dir')
		272	db = env.get_db_cnx()
		273	if not repos_dir:
		274	raise EnvironmentError, 'Path to repository not configured'
		275	if repos_dir.startswith('darcs:'):
		276	from trac.versioncontrol.darcs import DarcsRepository, \
		277	DarcsCachedRepository as CachedRepository
		278	repos = DarcsRepository(db, repos_dir[6:], env.log)
		279	elif repos_dir.startswith('bzr:'):
		280	from trac.versioncontrol.bzr import BzrRepository, \
		281	BzrCachedRepository as CachedRepository
		282	#from trac.versioncontrol.cache import CachedRepository
		283	repos = BzrRepository(db, repos_dir[4:], env.log)
		284	else:
		285	from trac.versioncontrol.svn_authz import SubversionAuthorizer
		286	from trac.versioncontrol.svn_fs import SubversionRepository
		287	from trac.versioncontrol.cache import CachedRepository
		288	if authname:
		289	authz = SubversionAuthorizer(env, authname)
		290	repos = SubversionRepository(repos_dir, authz, env.log)
		291	return CachedRepository(db, repos, authz, env.log)
		292
		293
		294	def get_authorizer(env, authname):
		295	"""
		296	Return the right authorizer for the configured repository.
		297
		298	Like ``get_repository()`` this looks for a ``darcs:`` or ``bzr:``
		299	prefix on the 'repository_dir' setting: if present it returns
		300	a basic Authorizer(), otherwise a SubversionAuthorizer.
		301	"""
		302
		303	authz = Authorizer()
		304	repos_dir = env.config.get('trac', 'repository_dir')
		305	if not repos_dir.startswith('darcs:') \
		306	and not repos_dir.startswith('bzr:'):
		307	from trac.versioncontrol.svn_authz import SubversionAuthorizer
		308	if authname:
		309	authz = SubversionAuthorizer(env, authname)
		310	return authz

Lines 62-82 Link Here

(-)upstream/trac/versioncontrol/cache.py (-15 / +1 lines)
62	current_rev = self.repos.oldest_rev	62	current_rev = self.repos.oldest_rev
63	while current_rev is not None:	63	while current_rev is not None:
64	changeset = self.repos.get_changeset(current_rev)	64	changeset = self.repos.get_changeset(current_rev)
65	cursor.execute("INSERT INTO revision (rev,time,author,message) "	65	changeset.insert_in_cache(cursor, kindmap, actionmap, self.log)
66	"VALUES (%s,%s,%s,%s)", (str(current_rev),
67	changeset.date, changeset.author,
68	changeset.message))
69	for path,kind,action,base_path,base_rev in changeset.get_changes():
70	self.log.debug("Caching node change in [%s]: %s"
71	% (current_rev, (path, kind, action,
72	base_path, base_rev)))
73	kind = kindmap[kind]
74	action = actionmap[action]
75	cursor.execute("INSERT INTO node_change (rev,path,kind,"
76	"change,base_path,base_rev) "
77	"VALUES (%s,%s,%s,%s,%s,%s)",
78	(str(current_rev), path, kind, action,
79	base_path, base_rev))
80	current_rev = self.repos.next_rev(current_rev)	66	current_rev = self.repos.next_rev(current_rev)
81	self.db.commit()	67	self.db.commit()
82	self.repos.authz = authz # restore permission checking	68	self.repos.authz = authz # restore permission checking

Lines 25-32 Link Here

(-)upstream/trac/versioncontrol/web_ui/changeset.py (-5 / +4 lines)
25	from trac.perm import IPermissionRequestor	25	from trac.perm import IPermissionRequestor
26	from trac.Search import ISearchSource, query_to_sql, shorten_result	26	from trac.Search import ISearchSource, query_to_sql, shorten_result
27	from trac.Timeline import ITimelineEventProvider	27	from trac.Timeline import ITimelineEventProvider
28	from trac.versioncontrol import Changeset, Node	28	from trac.versioncontrol import Changeset, Node, get_authorizer
29	from trac.versioncontrol.svn_authz import SubversionAuthorizer
30	from trac.versioncontrol.diff import get_diff_options, hdf_diff, unified_diff	29	from trac.versioncontrol.diff import get_diff_options, hdf_diff, unified_diff
31	from trac.web import IRequestHandler	30	from trac.web import IRequestHandler
32	from trac.web.chrome import add_link, add_stylesheet, INavigationContributor	31	from trac.web.chrome import add_link, add_stylesheet, INavigationContributor
Lines 64-70 Link Here
64		63
65	rev = req.args.get('rev')	64	rev = req.args.get('rev')
66	repos = self.env.get_repository(req.authname)	65	repos = self.env.get_repository(req.authname)
67	authzperm = SubversionAuthorizer(self.env, req.authname)	66	authzperm = get_authorizer(self.env, req.authname)
68	authzperm.assert_permission_for_changeset(rev)	67	authzperm.assert_permission_for_changeset(rev)
69		68
70	diff_options = get_diff_options(req)	69	diff_options = get_diff_options(req)
Lines 106-112 Link Here
106	'changeset_show_files'))	105	'changeset_show_files'))
107	db = self.env.get_db_cnx()	106	db = self.env.get_db_cnx()
108	repos = self.env.get_repository()	107	repos = self.env.get_repository()
109	authzperm = SubversionAuthorizer(self.env, req.authname)	108	authzperm = get_authorizer(self.env, req.authname)
110	rev = repos.youngest_rev	109	rev = repos.youngest_rev
111	while rev:	110	while rev:
112	if not authzperm.has_permission_for_changeset(rev):	111	if not authzperm.has_permission_for_changeset(rev):
Lines 376-382 Link Here
376	def get_search_results(self, req, query, filters):	375	def get_search_results(self, req, query, filters):
377	if not 'changeset' in filters:	376	if not 'changeset' in filters:
378	return	377	return
379	authzperm = SubversionAuthorizer(self.env, req.authname)	378	authzperm = get_authorizer(self.env, req.authname)
380	db = self.env.get_db_cnx()	379	db = self.env.get_db_cnx()
381	sql = "SELECT rev,time,author,message " \	380	sql = "SELECT rev,time,author,message " \
382	"FROM revision WHERE %s OR %s" % \	381	"FROM revision WHERE %s OR %s" % \