hgsubversion: svnwrap/svn_swig_wrapper.py comparison

comparison svnwrap/svn_swig_wrapper.py @ 300:4aba7542f6a9

Various cleanups, cosmetics and removal of superfluous assertions.

author	Dan Villiom Podlaski Christiansen <danchr@gmail.com>
date	Fri, 27 Mar 2009 03:16:21 +0100
parents	32d3f1716e66
children	79440ed81011

comparison

equal deleted inserted replaced

-:3e27514d575c
+:4aba7542f6a9
 import os
 import shutil
 import sys
 import tempfile
 import hashlib
+import collections
+import gc
 from svn import client
 from svn import core
 from svn import delta
 from svn import ra
+from mercurial import util as hgutil
 def version():
 return '%d.%d.%d' % (core.SVN_VER_MAJOR, core.SVN_VER_MINOR, core.SVN_VER_MICRO)
 if (core.SVN_VER_MAJOR, core.SVN_VER_MINOR, core.SVN_VER_MICRO) < (1, 5, 0): #pragma: no cover
 @staticmethod
 def get_client_string(pool):
 return 'hgsubversion'
 def user_pass_prompt(realm, default_username, ms, pool): #pragma: no cover
+# FIXME: should use getpass() and username() from mercurial.ui
 creds = core.svn_auth_cred_simple_t()
 creds.may_save = ms
 if default_username:
 sys.stderr.write('Auth realm: %s\n' % (realm,))
 creds.username = default_username
 def __init__(self, url='', username=''):
 self.svn_url = url
 self.uname = username
 self.auth_baton_pool = core.Pool()
 self.auth_baton = _create_auth_baton(self.auth_baton_pool)
+# self.init_ra_and_client() assumes that a pool already exists
+self.pool = core.Pool()
 self.init_ra_and_client()
 self.uuid = ra.get_uuid(self.ra, self.pool)
 repo_root = ra.get_repos_root(self.ra, self.pool)
 # *will* have a leading '/', would not if we used get_repos_root2
 def init_ra_and_client(self):
 """Initializes the RA and client layers, because sometimes getting
 unified diffs runs the remote server out of open files.
 """
-# while we're in here we'll recreate our pool
+# Debugging code; retained for possible later use.
+if False:
+gc.collect()
+import pympler.muppy.tracker
+try:
+self.memory_tracker
+try:
+self.memory_tracker.print_diff(self.memory_base)
+except:
+print 'HOP'
+self.memory_base = self.memory_tracker.create_summary()
+except:
+print 'HEP'
+self.memory_tracker = pympler.muppy.tracker.SummaryTracker()
+# while we're in here we'll recreate our pool, but first, we clear it
+# and destroy it to make possible leaks cause fatal errors.
+self.pool.clear()
+self.pool.destroy()
 self.pool = core.Pool()
 self.client_context = client.create_context()
 self.client_context.auth_baton = self.auth_baton
 self.client_context.config = svn_config
 return 0
 START = property(START)
 def branches(self):
 """Get the branches defined in this repo assuming a standard layout.
+This method should be eliminated; this class does not have
+sufficient knowledge to yield all known tags.
 """
 branches = self.list_dir('branches').keys()
 branch_info = {}
 head=self.HEAD
 for b in branches:
 def tags(self):
 """Get the current tags in this repo assuming a standard layout.
 This returns a dictionary of tag: (source path, source rev)
+This method should be eliminated; this class does not have
+sufficient knowledge to yield all known tags.
 """
 return self.tags_at_rev(self.HEAD)
 tags = property(tags)
 def tags_at_rev(self, revision):
+"""Get the tags in this repo at the given revision, assuming a
+standard layout.
+This returns a dictionary of tag: (source path, source rev)
+This method should be eliminated; this class does not have
+sufficient knowledge to yield all known tags.
+"""
 try:
 tags = self.list_dir('tags', revision=revision).keys()
 except core.SubversionException, e:
 if e.apr_err == core.SVN_ERR_FS_NOT_FOUND:
 return {}
 """
 # NB: you'd think this would work, but you'd be wrong. I'm pretty
 # convinced there must be some kind of svn bug here.
 #return self.fetch_history_at_paths(['tags', 'trunk', 'branches'],
 #                                   start=start)
-# this does the same thing, but at the repo root + filtering. It's
+# However, we no longer need such filtering, as we gracefully handle
-# kind of tough cookies, sadly.
+# branches located at arbitrary locations.
-for r in self.fetch_history_at_paths([''], start=start,
+return self.fetch_history_at_paths([''], start=start, stop=stop,
-chunk_size=chunk_size):
+chunk_size=chunk_size)
-should_yield = False
-i = 0
-paths = list(r.paths.keys())
-while i < len(paths) and not should_yield:
-p = paths[i]
-if (p.startswith('trunk') or p.startswith('tags')
-or p.startswith('branches')):
-should_yield = True
-i += 1
-if should_yield:
-yield r
 def fetch_history_at_paths(self, paths, start=None, stop=None,
-chunk_size=1000):
+chunk_size=_chunk_size):
-revisions = []
+'''TODO: This method should be merged with self.revisions() as
-def callback(paths, revnum, author, date, message, pool):
+they are now functionally equivalent.'''
-r = Revision(revnum, author, message, date, paths,
-strip_path=self.subdir)
-revisions.append(r)
 if not start:
 start = self.START
 if not stop:
 stop = self.HEAD
 while stop > start:
-ra.get_log(self.ra,
+def callback(paths, revnum, author, date, message, pool):
-paths,
+r = Revision(revnum, author, message, date, paths,
-start+1,
+strip_path=self.subdir)
-stop,
+revisions.append(r)
-chunk_size, #limit of how many log messages to load
+# use a queue; we only access revisions in a FIFO manner
-True, # don't need to know changed paths
+revisions = collections.deque()
-True, # stop on copies
-callback,
+try:
-self.pool)
+# TODO: using min(start + chunk_size, stop) may be preferable;
-if len(revisions) < chunk_size:
+#       ra.get_log(), even with chunk_size set, takes a while
-# this means there was no history for the path, so force the
+#       when converting the 65k+ rev. in LLVM.
-# loop to exit
+ra.get_log(self.ra,
-start = stop
+paths,
+start+1,
+stop,
+chunk_size, #limit of how many log messages to load
+True, # don't need to know changed paths
+True, # stop on copies
+callback,
+self.pool)
+except core.SubversionException, e:
+if e.apr_err not in [core.SVN_ERR_FS_NOT_FOUND]:
+raise
+else:
+raise hgutil.Abort('%s not found at revision %d!'
+% (self.subdir.rstrip('/'), stop))
+while len(revisions) > 1:
+yield revisions.popleft()
+# Now is a good time to do a quick garbage collection.
+gc.collect(0)
+if len(revisions) == 0:
+# exit the loop; there is no history for the path.
+break
 else:
-start = revisions[-1].revnum
+r = revisions.popleft()
-while len(revisions) > 0:
+start = r.revnum
-yield revisions[0]
+yield r
-revisions.pop(0)
+self.init_ra_and_client()
+# Now is a good time to do a thorough garbage colection.
+gc.collect()
 def commit(self, paths, message, file_data, base_revision, addeddirs,
 deleteddirs, properties, copies):
 """Commits the appropriate targets from revision in editor's store.
 """
 False,
 self.pool)
 checksum = []
 # internal dir batons can fall out of scope and get GCed before svn is
 # done with them. This prevents that (credit to gvn for the idea).
+# TODO: verify that these are not the cause of our leaks
 batons = [edit_baton, ]
 def driver_cb(parent, path, pool):
 if not parent:
 bat = editor.open_root(edit_baton, base_revision, self.pool)
 batons.append(bat)
 frompath, fromrev = copies.get(path, (None, -1))
 if frompath:
 frompath = self.svn_url + '/' + frompath
 baton = editor.add_file(path, parent, frompath, fromrev, pool)
 except (core.SubversionException, TypeError), e: #pragma: no cover
-print e.message
+print e
 raise
 elif action == 'delete':
 baton = editor.delete_entry(path, base_revision, parent, pool)
 compute_delta = False
 delta.path_driver(editor, edit_baton, base_revision, paths, driver_cb,
 self.pool)
 editor.close_edit(edit_baton, self.pool)
 def get_replay(self, revision, editor, oldest_rev_i_have=0):
-# this method has a tendency to chew through RAM if you don't re-init
-self.init_ra_and_client()
 e_ptr, e_baton = delta.make_editor(editor)
 try:
 ra.replay(self.ra, revision, oldest_rev_i_have, True, e_ptr,
 e_baton, self.pool)
 except core.SubversionException, e: #pragma: no cover
-# can I depend on this number being constant?
 if (e.apr_err == core.SVN_ERR_RA_NOT_IMPLEMENTED or
 e.apr_err == core.SVN_ERR_UNSUPPORTED_FEATURE):
 raise SubversionRepoCanNotReplay, ('This Subversion server '
 'is older than 1.4.0, and cannot satisfy replay requests.')
 else:
 deleted=True, ignore_type=False):
 """Gets a unidiff of path at revision against revision-1.
 """
 if not self.hasdiff3:
 raise SubversionRepoCanNotDiff()
-# works around an svn server keeping too many open files (observed
-# in an svnserve from the 1.2 era)
-self.init_ra_and_client()
 assert path[0] != '/'
 url = self.svn_url + '/' + path
 url2 = url
 if other_path is not None:
 mode = ("svn:special" in info) and 'l' or mode
 except core.SubversionException, e:
 notfound = (core.SVN_ERR_FS_NOT_FOUND,
 core.SVN_ERR_RA_DAV_PATH_NOT_FOUND)
 if e.apr_err in notfound: # File not found
-raise IOError()
+raise IOError, e.args[0]
 raise
 if mode  == 'l':
 linkprefix = "link "
 if data.startswith(linkprefix):
 data = data[len(linkprefix):]
 'dirpath' and 'kind' is 'f' if the entry is a file, 'd' if it is a
 directory. Raise IOError if the directory cannot be found at given
 revision.
 """
 dirpath = dirpath.strip('/')
-pool = core.Pool()
 rpath = '/'.join([self.svn_url, dirpath]).strip('/')
 rev = optrev(revision)
 try:
-entries = client.ls(rpath, rev, True, self.client_context, pool)
+entries = client.ls(rpath, rev, True, self.client_context,
+self.pool)
 except core.SubversionException, e:
 if e.apr_err == core.SVN_ERR_FS_NOT_FOUND:
 raise IOError('%s cannot be found at r%d' % (dirpath, revision))
 raise
 for path, e in entries.iteritems():

Mercurial > hgsubversion

comparison svnwrap/svn_swig_wrapper.py @ 300:4aba7542f6a9