hgsubversion: svnwrap/svn_swig_wrapper.py comparison

comparison svnwrap/svn_swig_wrapper.py @ 304:ce676eff002b

First merge, totally untested.

author	Dan Villiom Podlaski Christiansen <danchr@gmail.com>
date	Fri, 01 May 2009 10:28:59 +0200
parents	79440ed81011 25d843281127
children	97360cb777a8

comparison

equal deleted inserted replaced

-:f423a8780832
+:ce676eff002b
 import getpass
 import os
 import shutil
 import sys
 import tempfile
+import urlparse
+import urllib
 import hashlib
 import collections
-import gc
 from svn import client
 from svn import core
 from svn import delta
 from svn import ra
 def _create_auth_baton(pool):
 """Create a Subversion authentication baton. """
 # Give the client context baton a suite of authentication
 # providers.h
 platform_specific = ['svn_auth_get_gnome_keyring_simple_provider',
 'svn_auth_get_gnome_keyring_ssl_client_cert_pw_provider',
 'svn_auth_get_keychain_simple_provider',
 'svn_auth_get_keychain_ssl_client_cert_pw_provider',
 'svn_auth_get_kwallet_simple_provider',
 'svn_auth_get_kwallet_ssl_client_cert_pw_provider',
 'svn_auth_get_ssl_client_cert_file_provider',
 'svn_auth_get_windows_simple_provider',
 'svn_auth_get_windows_ssl_server_trust_provider',
 ]
 providers = []
+# Platform-dependant authentication methods
-for p in platform_specific:
+getprovider = getattr(core, 'svn_auth_get_platform_specific_provider',
-if hasattr(core, p):
+None)
-try:
+if getprovider:
-providers.append(getattr(core, p)())
+# Available in svn >= 1.6
-except RuntimeError:
+for name in ('gnome_keyring', 'keychain', 'kwallet', 'windows'):
-pass
+for type in ('simple', 'ssl_client_cert_pw', 'ssl_server_trust'):
+p = getprovider(name, type, pool)
+if p:
+providers.append(p)
+else:
+for p in platform_specific:
+if hasattr(core, p):
+try:
+providers.append(getattr(core, p)())
+except RuntimeError:
+pass
 providers += [
 client.get_simple_provider(),
 client.get_username_provider(),
 client.get_ssl_client_cert_file_provider(),
 client.get_simple_prompt_provider(user_pass_prompt, 2),
 ]
 return core.svn_auth_open(providers, pool)
+def parse_url(url):
+"""Parse a URL and return a tuple (username, password, url)
+"""
+scheme, netloc, path, params, query, fragment = urlparse.urlparse(url)
+user, passwd = None, None
+if '@' in netloc:
+userpass, netloc = netloc.split('@')
+if ':' in userpass:
+user, passwd = userpass.split(':')
+user, passwd = urllib.unquote(user) or None, urllib.unquote(passwd) or None
+else:
+user = urllib.unquote(userpass) or None
+url = urlparse.urlunparse((scheme, netloc, path, params, query, fragment))
+return (user, passwd, url)
 class Revision(tuple):
 """Wrapper for a Subversion revision.
 Derives from tuple in an attempt to minimise the memory footprint.
 """Wrapper for a Subversion repository.
 This uses the SWIG Python bindings, and will only work on svn >= 1.4.
 It takes a required param, the URL.
 """
-def __init__(self, url='', username='', head=None):
+def __init__(self, url='', username='', password='', head=None):
-self.svn_url = url
+parsed = parse_url(url)
-self.uname = username
+# --username and --password override URL credentials
+self.username = username or parsed[0]
+self.password = password or parsed[1]
+self.svn_url = parsed[2]
 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()
 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.
 """
-# Debugging code; retained for possible later use.
+# while we're in here we'll recreate our pool
-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()
+if self.username:
+core.svn_auth_set_parameter(self.auth_baton,
+core.SVN_AUTH_PARAM_DEFAULT_USERNAME,
+self.username)
+if self.password:
+core.svn_auth_set_parameter(self.auth_baton,
+core.SVN_AUTH_PARAM_DEFAULT_PASSWORD,
+self.password)
 self.client_context = client.create_context()
 self.client_context.auth_baton = self.auth_baton
 self.client_context.config = svn_config
 callbacks = RaCallbacks()
 if hist.paths[path].copyfrom_path is None:
 return None, None
 source = hist.paths[path].copyfrom_path
 source_rev = 0
 for p in hist.paths:
+if not p.startswith(path):
+continue
 if hist.paths[p].copyfrom_rev:
 # We assume that the revision of the source tree as it was
 # copied was actually the revision of the highest revision
 # copied item. This could be wrong, but in practice it will
 # *probably* be correct
 of revisions at a time.
 The reason this is lazy is so that you can use the same repo object
 to perform RA calls to get deltas.
 """
-# NB: you'd think this would work, but you'd be wrong. I'm pretty
+return self.fetch_history_at_paths([''], start=start,
-# convinced there must be some kind of svn bug here.
-#return self.fetch_history_at_paths(['tags', 'trunk', 'branches'],
-#                                   start=start)
-# However, we no longer need such filtering, as we gracefully handle
-# branches located at arbitrary locations.
-return self.fetch_history_at_paths([''], start=start, stop=stop,
 chunk_size=chunk_size)
 def fetch_history_at_paths(self, paths, start=None, stop=None,
 chunk_size=_chunk_size):
 '''TODO: This method should be merged with self.revisions() as
 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)
 base_text, new_text, action = file_data[path]
 compute_delta = True
 if action == 'modify':
 baton = editor.open_file(path, parent, base_revision, pool)
 elif action == 'add':
-try:
+frompath, fromrev = copies.get(path, (None, -1))
-frompath, fromrev = copies.get(path, (None, -1))
+if frompath:
-if frompath:
+frompath = self.svn_url + '/' + frompath
-frompath = self.svn_url + '/' + frompath
+baton = editor.add_file(path, parent, frompath, fromrev, pool)
-baton = editor.add_file(path, parent, frompath, fromrev, pool)
-except (core.SubversionException, TypeError), e: #pragma: no cover
-print e
-raise
 elif action == 'delete':
 baton = editor.delete_entry(path, base_revision, parent, pool)
 compute_delta = False
 if path in properties:
 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, e.args[0]
+raise IOError()
 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,
+entries = client.ls(rpath, rev, True, self.client_context, pool)
-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 @ 304:ce676eff002b