void apr_hash_this(apr_hash_index_t *hi, void **key,
long *klen, void **val)
+cdef extern from "apr_time.h":
+ ctypedef unsigned long long apr_time_t
+
credentials.has_key("verify_certificates") and
credentials["verify_certificates"] == False):
ssl_server_trust.accepted_failures = (
- svn.core.SVN_AUTH_SSL_NOTYETVALID +
- svn.core.SVN_AUTH_SSL_EXPIRED +
- svn.core.SVN_AUTH_SSL_CNMISMATCH +
- svn.core.SVN_AUTH_SSL_UNKNOWNCA +
- svn.core.SVN_AUTH_SSL_OTHER)
+ core.SVN_AUTH_SSL_NOTYETVALID +
+ core.SVN_AUTH_SSL_EXPIRED +
+ core.SVN_AUTH_SSL_CNMISMATCH +
+ core.SVN_AUTH_SSL_UNKNOWNCA +
+ core.SVN_AUTH_SSL_OTHER)
else:
ssl_server_trust.accepted_failures = 0
ssl_server_trust.may_save = False
from bzrlib.revision import ensure_null
from bzrlib.workingtree import WorkingTree
-import svn.client, svn.core
-from svn.core import SubversionException, Pool
+import svn.client, core
+from core import SubversionException, Pool
from commit import push
from errors import NotSvnBranchPath
self._branch_path = branch_path.strip("/")
try:
if self.repository.transport.check_path(branch_path.strip("/"),
- self.get_revnum()) != svn.core.svn_node_dir:
+ self.get_revnum()) != core.svn_node_dir:
raise NotBranchError(self.base)
except SubversionException, (_, num):
- if num == svn.core.SVN_ERR_FS_NO_SUCH_REVISION:
+ if num == core.SVN_ERR_FS_NO_SUCH_REVISION:
raise NotBranchError(self.base)
raise
if not self.mapping.is_branch(branch_path):
from cache import CacheTable
-from svn.core import SubversionException, Pool
-import svn.core
+from core import SubversionException, Pool
class BranchPropertyList(CacheTable):
"""Simple class that retrieves file properties set on branches."""
(_, _, props) = self.log._get_transport().get_dir(path,
revnum)
except SubversionException, (_, num):
- if num == svn.core.SVN_ERR_FS_NO_SUCH_REVISION:
+ if num == core.SVN_ERR_FS_NO_SUCH_REVISION:
raise NoSuchRevision(self, revnum)
raise
"""Committing and pushing to Subversion repositories."""
import svn.delta
-from svn.core import Pool, SubversionException, svn_time_to_cstring
+from svn.core import Pool, SubversionException
+
+from core import time_to_cstring
from bzrlib import debug, osutils, urlutils
from bzrlib.branch import Branch
for i in range(len(bp_parts), 0, -1):
current = bp_parts[:i]
path = "/".join(current).strip("/")
- if transport.check_path(path, base_rev) == svn.core.svn_node_dir:
+ if transport.check_path(path, base_rev) == core.svn_node_dir:
return current
return []
for (name, value) in revprops.items():
try:
transport.change_rev_prop(revnum, name, value)
- except SubversionException, (_, svn.core.SVN_ERR_REPOS_DISABLED_FEATURE):
+ except SubversionException, (_, core.SVN_ERR_REPOS_DISABLED_FEATURE):
raise RevpropChangeFailed(name)
if child_baton is not None:
if old_executable != child_ie.executable:
if child_ie.executable:
- value = svn.core.SVN_PROP_EXECUTABLE_VALUE
+ value = core.SVN_PROP_EXECUTABLE_VALUE
else:
value = None
self.editor.change_file_prop(child_baton,
- svn.core.SVN_PROP_EXECUTABLE, value, self.pool)
+ core.SVN_PROP_EXECUTABLE, value, self.pool)
if old_special != (child_ie.kind == 'symlink'):
if child_ie.kind == 'symlink':
- value = svn.core.SVN_PROP_SPECIAL_VALUE
+ value = core.SVN_PROP_SPECIAL_VALUE
else:
value = None
self.editor.change_file_prop(child_baton,
- svn.core.SVN_PROP_SPECIAL, value, self.pool)
+ core.SVN_PROP_SPECIAL, value, self.pool)
# handle the file
if child_ie.file_id in self.modified_files:
fileids[path] = id
self.base_mapping.export_fileid_map(fileids, self._svn_revprops, self._svnprops)
- self._svn_revprops[svn.core.SVN_PROP_REVISION_LOG] = message.encode("utf-8")
+ self._svn_revprops[core.SVN_PROP_REVISION_LOG] = message.encode("utf-8")
try:
existing_bp_parts = _check_dirs_exist(self.repository.transport,
raise
# Try without bzr: revprops
self.editor = self.repository.transport.get_commit_editor({
- svn.core.SVN_PROP_REVISION_LOG: self._svn_revprops[svn.core.SVN_PROP_REVISION_LOG]},
+ core.SVN_PROP_REVISION_LOG: self._svn_revprops[svn.core.SVN_PROP_REVISION_LOG]},
done, None, False)
- del self._svn_revprops[svn.core.SVN_PROP_REVISION_LOG]
+ del self._svn_revprops[core.SVN_PROP_REVISION_LOG]
root = self.editor.open_root(self.base_revnum)
if self.repository.get_config().get_override_svn_revprops():
set_svn_revprops(self.repository.transport,
self.revision_metadata.revision, {
- svn.core.SVN_PROP_REVISION_AUTHOR: self._committer,
- svn.core.SVN_PROP_REVISION_DATE: svn_time_to_cstring(1000000*self._timestamp)})
+ core.SVN_PROP_REVISION_AUTHOR: self._committer,
+ core.SVN_PROP_REVISION_DATE: svn_time_to_cstring(1000000*self._timestamp)})
try:
set_svn_revprops(self.repository.transport, self.revision_metadata.revision,
try:
builder.commit(rev.message)
except SubversionException, (_, num):
- if num == svn.core.SVN_ERR_FS_TXN_OUT_OF_DATE:
+ if num == core.SVN_ERR_FS_TXN_OUT_OF_DATE:
raise DivergedBranches(source, target)
raise
except ChangesRootLHSHistory:
from format import get_rich_root_format
-import svn.core, svn.repos
+import core, svn.repos
def transport_makedirs(transport, location_url):
"""Create missing directories.
try:
svn.repos.load_fs2(repos, file, StringIO(),
svn.repos.load_uuid_default, '', 0, 0, None)
- except svn.core.SubversionException, (_, num):
- if num == svn.core.SVN_ERR_STREAM_MALFORMED_DATA:
+ except core.SubversionException, (_, num):
+ if num == core.SVN_ERR_STREAM_MALFORMED_DATA:
raise NotDumpFile(dumpfile)
raise
return repos
source_repos.find_branchpaths(source_repos.get_scheme()))]
def is_dir((branch, revnum)):
- return source_repos.transport.check_path(branch, revnum) == svn.core.svn_node_dir
+ return source_repos.transport.check_path(branch, revnum) == core.svn_node_dir
existing_branches = filter(is_dir, existing_branches)
TransportError, UnexpectedEndOfContainerError)
import urllib
-import svn.core
-
-# APR define, not in svn.core
-SVN_ERR_UNKNOWN_HOSTNAME = 670002
+import core
+from bzrlib.plugins.svn import constants
class NotSvnBranchPath(NotBranchError):
"""Error raised when a path was specified that did not exist."""
"""
(msg, num) = err.args
- if num == svn.core.SVN_ERR_RA_SVN_CONNECTION_CLOSED:
+ if num == core.SVN_ERR_RA_SVN_CONNECTION_CLOSED:
return ConnectionReset(msg=msg)
- elif num == svn.core.SVN_ERR_WC_LOCKED:
+ elif num == core.SVN_ERR_WC_LOCKED:
return LockError(message=msg)
- elif num == svn.core.SVN_ERR_RA_NOT_AUTHORIZED:
+ elif num == core.SVN_ERR_RA_NOT_AUTHORIZED:
return PermissionDenied('.', msg)
- elif num == svn.core.SVN_ERR_INCOMPLETE_DATA:
+ elif num == core.SVN_ERR_INCOMPLETE_DATA:
return UnexpectedEndOfContainerError()
- elif num == svn.core.SVN_ERR_RA_SVN_MALFORMED_DATA:
+ elif num == core.SVN_ERR_RA_SVN_MALFORMED_DATA:
return TransportError("Malformed data", msg)
- elif num == svn.core.SVN_ERR_RA_NOT_IMPLEMENTED:
+ elif num == core.SVN_ERR_RA_NOT_IMPLEMENTED:
return NotImplementedError("Function not implemented in remote server")
- elif num == SVN_ERR_UNKNOWN_HOSTNAME:
+ elif num == constants.ERR_UNKNOWN_HOSTNAME:
return ConnectionError(msg=msg)
elif num > 0 and num < 1000:
return OSError(num, msg)
def convert(*args, **kwargs):
try:
return unbound(*args, **kwargs)
- except svn.core.SubversionException, e:
+ except core.SubversionException, e:
raise convert_error(e)
convert.__doc__ = unbound.__doc__
from cStringIO import StringIO
import md5
-from svn.core import Pool
-import svn.core
+from core import Pool
+import core
from bzrlib.plugins.svn.errors import InvalidFileName
from mapping import (SVN_PROP_BZR_ANCESTRY, SVN_PROP_BZR_MERGE,
mutter('rogue %r on non-root directory' % SVN_PROP_BZR_REVISION_INFO)
return
- elif name in (svn.core.SVN_PROP_ENTRY_COMMITTED_DATE,
- svn.core.SVN_PROP_ENTRY_COMMITTED_REV,
- svn.core.SVN_PROP_ENTRY_LAST_AUTHOR,
- svn.core.SVN_PROP_ENTRY_LOCK_TOKEN,
- svn.core.SVN_PROP_ENTRY_UUID,
- svn.core.SVN_PROP_EXECUTABLE):
+ elif name in (core.SVN_PROP_ENTRY_COMMITTED_DATE,
+ core.SVN_PROP_ENTRY_COMMITTED_REV,
+ core.SVN_PROP_ENTRY_LAST_AUTHOR,
+ core.SVN_PROP_ENTRY_LOCK_TOKEN,
+ core.SVN_PROP_ENTRY_UUID,
+ core.SVN_PROP_EXECUTABLE):
pass
- elif name.startswith(svn.core.SVN_PROP_WC_PREFIX):
+ elif name.startswith(core.SVN_PROP_WC_PREFIX):
pass
elif name in (SVN_PROP_BZR_MERGE, SVN_PROP_BZR_FILEIDS):
pass
- elif (name.startswith(svn.core.SVN_PROP_PREFIX) or
+ elif (name.startswith(core.SVN_PROP_PREFIX) or
name.startswith(SVN_PROP_BZR_PREFIX)):
mutter('unsupported dir property %r' % name)
def change_file_prop(self, id, name, value, pool):
- if name == svn.core.SVN_PROP_EXECUTABLE:
+ if name == core.SVN_PROP_EXECUTABLE:
# You'd expect executable to match
- # svn.core.SVN_PROP_EXECUTABLE_VALUE, but that's not
+ # core.SVN_PROP_EXECUTABLE_VALUE, but that's not
# how SVN behaves. It appears to consider the presence
# of the property sufficient to mark it executable.
self.is_executable = (value != None)
- elif (name == svn.core.SVN_PROP_SPECIAL):
+ elif (name == core.SVN_PROP_SPECIAL):
self.is_symlink = (value != None)
- elif name == svn.core.SVN_PROP_ENTRY_COMMITTED_REV:
+ elif name == core.SVN_PROP_ENTRY_COMMITTED_REV:
self.last_file_rev = int(value)
- elif name in (svn.core.SVN_PROP_ENTRY_COMMITTED_DATE,
- svn.core.SVN_PROP_ENTRY_LAST_AUTHOR,
- svn.core.SVN_PROP_ENTRY_LOCK_TOKEN,
- svn.core.SVN_PROP_ENTRY_UUID,
- svn.core.SVN_PROP_MIME_TYPE):
+ elif name in (core.SVN_PROP_ENTRY_COMMITTED_DATE,
+ core.SVN_PROP_ENTRY_LAST_AUTHOR,
+ core.SVN_PROP_ENTRY_LOCK_TOKEN,
+ core.SVN_PROP_ENTRY_UUID,
+ core.SVN_PROP_MIME_TYPE):
pass
- elif name.startswith(svn.core.SVN_PROP_WC_PREFIX):
+ elif name.startswith(core.SVN_PROP_WC_PREFIX):
pass
- elif (name.startswith(svn.core.SVN_PROP_PREFIX) or
+ elif (name.startswith(core.SVN_PROP_PREFIX) or
name.startswith(SVN_PROP_BZR_PREFIX)):
mutter('unsupported file property %r' % name)
@classmethod
def probe_transport(klass, transport):
from transport import get_svn_ra_transport
- import svn.core
+ import core
format = klass()
try:
transport = get_svn_ra_transport(transport)
- except svn.core.SubversionException, (_, num):
- if num in (svn.core.SVN_ERR_RA_ILLEGAL_URL, \
- svn.core.SVN_ERR_RA_LOCAL_REPOS_OPEN_FAILED, \
- svn.core.SVN_ERR_BAD_URL):
+ except core.SubversionException, (_, num):
+ if num in (core.SVN_ERR_RA_ILLEGAL_URL, \
+ core.SVN_ERR_RA_LOCAL_REPOS_OPEN_FAILED, \
+ core.SVN_ERR_BAD_URL):
raise bzr_errors.NotBranchError(path=transport.base)
return format
def _open(self, transport):
- import svn.core
+ import core
try:
return remote.SvnRemoteAccess(transport, self)
- except svn.core.SubversionException, (_, num):
- if num == svn.core.SVN_ERR_RA_DAV_REQUEST_FAILED:
+ except core.SubversionException, (_, num):
+ if num == core.SVN_ERR_RA_DAV_REQUEST_FAILED:
raise bzr_errors.NotBranchError(transport.base)
raise
raise bzr_errors.NotBranchError(path=transport.base)
def _open(self, transport):
- import svn.core
+ import core
from workingtree import SvnCheckout
- subr_version = svn.core.svn_subr_version()
+ subr_version = core.svn_subr_version()
if subr_version.major == 1 and subr_version.minor < 4:
raise errors.NoCheckoutSupport()
try:
return SvnCheckout(transport, self)
- except svn.core.SubversionException, (_, num):
- if num in (svn.core.SVN_ERR_RA_LOCAL_REPOS_OPEN_FAILED,):
+ except core.SubversionException, (_, num):
+ if num in (core.SVN_ERR_RA_LOCAL_REPOS_OPEN_FAILED,):
raise errors.NoSvnRepositoryPresent(transport.base)
raise
import bzrlib.ui as ui
from copy import copy
-from svn.core import SubversionException, Pool
+from core import SubversionException, Pool
from transport import SvnRaTransport
-import svn.core
+import core
from cache import sqlite3
finally:
pb.finished()
except SubversionException, (_, num):
- if num == svn.core.SVN_ERR_FS_NO_SUCH_REVISION:
+ if num == core.SVN_ERR_FS_NO_SUCH_REVISION:
raise NoSuchRevision(branch=self,
revision="Revision number %d" % to_revnum)
raise
path = path.strip("/")
transport = self._get_transport()
ft = transport.check_path(path, revnum)
- if ft == svn.core.svn_node_file:
+ if ft == core.svn_node_file:
return []
- assert ft == svn.core.svn_node_dir
+ assert ft == core.svn_node_dir
class TreeLister(svn.delta.Editor):
def __init__(self, base):
return filter(lambda x: x != "", line.split("\t"))
def parse_svn_revprops(svn_revprops, rev):
- if svn_revprops.has_key(svn.core.SVN_PROP_REVISION_AUTHOR):
- rev.committer = svn_revprops[svn.core.SVN_PROP_REVISION_AUTHOR]
+ if svn_revprops.has_key(core.SVN_PROP_REVISION_AUTHOR):
+ rev.committer = svn_revprops[core.SVN_PROP_REVISION_AUTHOR]
else:
rev.committer = ""
- rev.message = svn_revprops.get(svn.core.SVN_PROP_REVISION_LOG)
+ rev.message = svn_revprops.get(core.SVN_PROP_REVISION_LOG)
if rev.message:
try:
except UnicodeDecodeError:
pass
- if svn_revprops.has_key(svn.core.SVN_PROP_REVISION_DATE):
- rev.timestamp = 1.0 * svn.core.secs_from_timestr(svn_revprops[svn.core.SVN_PROP_REVISION_DATE], None)
+ if svn_revprops.has_key(core.SVN_PROP_REVISION_DATE):
+ rev.timestamp = 1.0 * core.secs_from_timestr(svn_revprops[core.SVN_PROP_REVISION_DATE], None)
else:
rev.timestamp = 0.0 # FIXME: Obtain repository creation time
rev.timezone = None
apr_initialize()
-cdef apr_pool_t *Pool(apr_pool_t *parent):
- cdef apr_status_t status
- cdef apr_pool_t *ret
- ret = NULL
- status = apr_pool_create(&ret, parent)
- if status != 0:
- # FIXME: Clearer error
- raise Exception("APR Error")
- return ret
-
cdef extern from "svn_auth.h":
ctypedef struct svn_auth_baton_t
void svn_auth_open(svn_auth_baton_t **auth_baton,
apr_pool_t *pool)
void svn_auth_set_parameter(svn_auth_baton_t *auth_baton,
char *name, void *value)
- void * svn_auth_get_parameter(svn_auth_baton_t *auth_baton,
+ void *svn_auth_get_parameter(svn_auth_baton_t *auth_baton,
char *name)
ctypedef struct svn_auth_provider_t:
ctypedef svn_error_t *(*svn_txdelta_window_handler_t) (svn_txdelta_window_t *window, void *baton)
ctypedef struct svn_delta_editor_t:
- svn_error_t *(*set_target_revision)(void *edit_baton, long target_revision, apr_pool_t *pool)
+ svn_error_t *(*set_target_revision)(void *edit_baton,
+ svn_revnum_t target_revision, apr_pool_t *pool)
svn_error_t *(*open_root)(void *edit_baton, long base_revision,
apr_pool_t *dir_pool, void **root_baton)
cdef apr_pool_t *pool
def set_path(self, path, revision, start_empty, lock_token):
- _check_error(self.reporter.set_path(self.report_baton, path, revision,
+ check_error(self.reporter.set_path(self.report_baton, path, revision,
start_empty, lock_token, self.pool))
def delete_path(self, path):
- _check_error(self.reporter.delete_path(self.report_baton, path,
+ check_error(self.reporter.delete_path(self.report_baton, path,
self.pool))
def link_path(self, path, url, revision, start_empty, lock_token):
- _check_error(self.reporter.link_path(self.report_baton, path, url,
+ check_error(self.reporter.link_path(self.report_baton, path, url,
revision, start_empty, lock_token, self.pool))
def finish_report(self):
- _check_error(self.reporter.finish_report(self.report_baton, self.pool))
+ check_error(self.reporter.finish_report(self.report_baton, self.pool))
def abort_report(self):
- _check_error(self.reporter.abort_report(self.report_baton, self.pool))
+ check_error(self.reporter.abort_report(self.report_baton, self.pool))
def version():
return (svn_ra_version().major, svn_ra_version().minor,
svn_ra_version().minor, svn_ra_version().tag)
-cdef void _check_error(svn_error_t *error):
- if error:
- # FIXME
- raise Exception("SVN error")
cdef class RemoteAccess:
+ """Connection to a remote Subversion repository."""
cdef svn_ra_session_t *ra
cdef apr_pool_t *pool
cdef char *url
self.url = url
self.pool = Pool(NULL)
assert self.pool != NULL
- _check_error(svn_ra_create_callbacks(&callbacks2, self.pool))
+ check_error(svn_ra_create_callbacks(&callbacks2, self.pool))
config_hash = apr_hash_make(self.pool)
for (key, val) in config.items():
apr_hash_set(config_hash, key, len(key), val)
- _check_error(svn_ra_open2(&self.ra, url, callbacks2, None, config_hash,
+ check_error(svn_ra_open2(&self.ra, url, callbacks2, None, config_hash,
self.pool))
def get_uuid(self):
cdef char *uuid
cdef apr_pool_t *temp_pool
temp_pool = Pool(self.pool)
- _check_error(svn_ra_get_uuid(self.ra, &uuid, temp_pool))
+ check_error(svn_ra_get_uuid(self.ra, &uuid, temp_pool))
apr_pool_destroy(temp_pool)
return uuid
"""Switch to a different url."""
cdef apr_pool_t *temp_pool
temp_pool = Pool(self.pool)
- _check_error(svn_ra_reparent(self.ra, url, temp_pool))
+ check_error(svn_ra_reparent(self.ra, url, temp_pool))
apr_pool_destroy(temp_pool)
def get_latest_revnum(self):
cdef long latest_revnum
cdef apr_pool_t *temp_pool
temp_pool = Pool(self.pool)
- _check_error(svn_ra_get_latest_revnum(self.ra, &latest_revnum,
+ check_error(svn_ra_get_latest_revnum(self.ra, &latest_revnum,
temp_pool))
apr_pool_destroy(temp_pool)
return latest_revnum
revprops=[SVN_PROP_REVISION_LOG,SVN_PROP_REVISION_AUTHOR,SVN_PROP_REVISION_DATE]):
cdef apr_array_header_t *paths_array
cdef apr_pool_t *temp_pool
- _check_error(svn_ra_get_log(self.ra, paths_array, start, end, limit,
+ check_error(svn_ra_get_log(self.ra, paths_array, start, end, limit,
discover_changed_paths, strict_node_history, py_svn_log_wrapper,
callback, temp_pool))
apr_pool_destroy(temp_pool)
cdef char *root
cdef apr_pool_t *temp_pool
temp_pool = Pool(self.pool)
- _check_error(svn_ra_get_repos_root(self.ra, &root,
+ check_error(svn_ra_get_repos_root(self.ra, &root,
temp_pool))
apr_pool_destroy(temp_pool)
return root
cdef apr_pool_t *temp_pool
cdef svn_delta_editor_t *editor
temp_pool = Pool(self.pool)
- _check_error(svn_ra_do_update(self.ra, &reporter, &report_baton,
+ check_error(svn_ra_do_update(self.ra, &reporter, &report_baton,
revision_to_update_to, update_target, recurse,
editor, update_editor, temp_pool))
apr_pool_destroy(temp_pool)
cdef apr_pool_t *temp_pool
cdef svn_delta_editor_t *editor
temp_pool = Pool(self.pool)
- _check_error(svn_ra_do_update(self.ra, &reporter, &report_baton,
+ check_error(svn_ra_do_update(self.ra, &reporter, &report_baton,
revision_to_update_to, update_target, recurse,
editor, update_editor, temp_pool))
apr_pool_destroy(temp_pool)
cdef apr_pool_t *temp_pool
cdef svn_delta_editor_t *editor
temp_pool = Pool(self.pool)
- _check_error(svn_ra_replay(self.ra, revision, low_water_mark,
+ check_error(svn_ra_replay(self.ra, revision, low_water_mark,
send_deltas, editor, update_editor, temp_pool))
apr_pool_destroy(temp_pool)
return Reporter(reporter, report_baton, temp_pool)
cdef apr_pool_t *temp_pool
cdef apr_hash_t *props
temp_pool = Pool(self.pool)
- _check_error(svn_ra_rev_proplist(self.ra, rev, &props, temp_pool))
+ check_error(svn_ra_rev_proplist(self.ra, rev, &props, temp_pool))
py_props = {}
# FIXME: Convert props to py_props
apr_pool_destroy(temp_pool)
cdef void *edit_baton
cdef apr_hash_t *hash_lock_tokens
temp_pool = Pool(self.pool)
- _check_error(svn_ra_get_commit_editor2(self.ra, &editor,
+ check_error(svn_ra_get_commit_editor2(self.ra, &editor,
&edit_baton, revprops[SVN_PROP_REVISION_LOG], py_commit_callback,
commit_callback, hash_lock_tokens, keep_locks, temp_pool))
apr_pool_destroy(temp_pool)
cdef svn_string_t *val_string
temp_pool = Pool(self.pool)
val_string = svn_string_ncreate(value, len(value), temp_pool)
- _check_error(svn_ra_change_rev_prop(self.ra, rev, name,
+ check_error(svn_ra_change_rev_prop(self.ra, rev, name,
val_string, temp_pool))
apr_pool_destroy(temp_pool)
cdef apr_hash_t *props
cdef long fetch_rev
temp_pool = Pool(self.pool)
- _check_error(svn_ra_get_dir2(self.ra, &dirents, &fetch_rev, &props,
+ check_error(svn_ra_get_dir2(self.ra, &dirents, &fetch_rev, &props,
path, revision, dirent_fields, temp_pool))
# FIXME: Convert dirents to python hash
# FIXME: Convert props to python hash
cdef svn_lock_t *lock
cdef apr_pool_t *temp_pool
temp_pool = Pool(self.pool)
- _check_error(svn_ra_get_lock(self.ra, &lock, path, temp_pool))
+ check_error(svn_ra_get_lock(self.ra, &lock, path, temp_pool))
apr_pool_destroy(temp_pool)
return lock
cdef svn_node_kind_t kind
cdef apr_pool_t *temp_pool
temp_pool = Pool(self.pool)
- _check_error(svn_ra_check_path(self.ra, path, revision, &kind,
+ check_error(svn_ra_check_path(self.ra, path, revision, &kind,
temp_pool))
apr_pool_destroy(temp_pool)
return kind
cdef apr_pool_t *temp_pool
cdef int has
temp_pool = Pool(self.pool)
- _check_error(svn_ra_has_capability(self.ra, &has, capability,
+ check_error(svn_ra_has_capability(self.ra, &has, capability,
temp_pool))
apr_pool_destroy(temp_pool)
return has
cdef apr_hash_t *hash_path_tokens
temp_pool = Pool(self.pool)
# FIXME: Convert path_tokens to a apr_hash
- _check_error(svn_ra_unlock(self.ra, hash_path_tokens, break_lock,
+ check_error(svn_ra_unlock(self.ra, hash_path_tokens, break_lock,
py_lock_func, lock_func, temp_pool))
apr_pool_destroy(temp_pool)
cdef apr_hash_t *hash_path_revs
# FIXME: Create hash_path_revs
temp_pool = Pool(self.pool)
- _check_error(svn_ra_lock(self.ra, hash_path_revs, comment, steal_lock,
+ check_error(svn_ra_lock(self.ra, hash_path_revs, comment, steal_lock,
py_lock_func, lock_func, temp_pool))
apr_pool_destroy(temp_pool)
NoWorkingTree, AlreadyBranchError)
from bzrlib.transport.local import LocalTransport
-from svn.core import SubversionException
-import svn.core, svn.repos
+from core import SubversionException
+import core, svn.repos
from errors import NoSvnRepositoryPresent
from format import get_rich_root_format, SvnRemoteFormat
full_branch_url = urlutils.join(repos.transport.base,
target_branch_path)
if repos.transport.check_path(target_branch_path,
- repos.transport.get_latest_revnum()) != svn.core.svn_node_none:
+ repos.transport.get_latest_revnum()) != core.svn_node_none:
raise AlreadyBranchError(full_branch_url)
push_new(repos, target_branch_path, source, stop_revision)
branch = self.open_branch()
from bzrlib.transport import Transport, get_transport
from bzrlib.trace import info, mutter
-from svn.core import SubversionException, Pool
-import svn.core
+from core import SubversionException, Pool
+import core
import os
def done(revmetadata, pool):
pass
editor = self.transport.get_commit_editor(
- {svn.core.SVN_PROP_REVISION_LOG: "Updating branching scheme for Bazaar."},
+ {core.SVN_PROP_REVISION_LOG: "Updating branching scheme for Bazaar."},
done, None, False)
root = editor.open_root(-1)
editor.change_dir_prop(root, SVN_PROP_BZR_BRANCHING_SCHEME,
return False
try:
- return (svn.core.svn_node_dir == self.transport.check_path(path, revnum))
+ return (core.svn_node_dir == self.transport.check_path(path, revnum))
except SubversionException, (_, num):
- if num == svn.core.SVN_ERR_FS_NO_SUCH_REVISION:
+ if num == core.SVN_ERR_FS_NO_SUCH_REVISION:
return False
raise
(bzr_revno, revid) = mapping.get_revision_id(path, revprops,
fileprops)
except SubversionException, (_, num):
- if num == svn.core.SVN_ERR_FS_NO_SUCH_REVISION:
+ if num == core.SVN_ERR_FS_NO_SUCH_REVISION:
raise NoSuchRevision(path, revnum)
raise
elif (scheme.is_branch_parent(n) or
scheme.is_tag_parent(n)):
parents.append(n)
- except SubversionException, (_, svn.core.SVN_ERR_FS_NOT_DIRECTORY):
+ except SubversionException, (_, core.SVN_ERR_FS_NOT_DIRECTORY):
pass
finally:
pb.finished()
packages=['bzrlib.plugins.svn',
'bzrlib.plugins.svn.tests'],
ext_modules=[
+ Extension("core", ["core.pyx"], libraries=["svn_subr-1"],
+ include_dirs=[apr_include_dir(), svn_include_dir()]),
Extension("ra", ["ra.pyx"], libraries=["svn_ra-1"],
include_dirs=[apr_include_dir(), svn_include_dir()]),
Extension("wc", ["wc.pyx"], libraries=["svn_wc-1"],
from bzrlib.trace import mutter
from bzrlib.transport import Transport
-from svn.core import SubversionException, Pool
+from core import SubversionException, Pool
import ra
-import svn.core
+import core
import svn.client
from errors import convert_svn_error, NoSvnRepositoryPresent
-svn_config = svn.core.svn_config_get_config(None)
+svn_config = core.svn_config_get_config(None)
def get_client_string():
"""Return a string that can be send as part of the User Agent string."""
# providers.h
providers = []
- if svn.core.SVN_VER_MAJOR == 1 and svn.core.SVN_VER_MINOR >= 5:
+ if core.SVN_VER_MAJOR == 1 and svn.core.SVN_VER_MINOR >= 5:
import auth
providers += auth.SubversionAuthenticationConfig().get_svn_auth_providers()
providers += [auth.get_ssl_client_cert_pw_provider(1)]
if hasattr(svn.client, 'get_windows_ssl_server_trust_provider'):
providers.append(svn.client.get_windows_ssl_server_trust_provider(pool))
- return svn.core.svn_auth_open(providers, pool)
+ return core.svn_auth_open(providers, pool)
def create_svn_client(pool):
self._ra = svn.client.open_ra_session(self._backing_url.encode('utf8'),
self._client, self.pool)
except SubversionException, (_, num):
- if num in (svn.core.SVN_ERR_RA_SVN_REPOS_NOT_FOUND,):
+ if num in (core.SVN_ERR_RA_SVN_REPOS_NOT_FOUND,):
raise NoSvnRepositoryPresent(url=url)
- if num == svn.core.SVN_ERR_BAD_URL:
+ if num == core.SVN_ERR_BAD_URL:
raise InvalidURL(url)
raise
# slash while other backends don't.
fields = 0
if kind:
- fields += svn.core.SVN_DIRENT_KIND
+ fields += core.SVN_DIRENT_KIND
return self._ra.get_dir(path, revnum, fields)
def _request_path(self, relpath):
(dirents, _, _) = self.get_dir(self._request_path(relpath),
self.get_latest_revnum())
except SubversionException, (msg, num):
- if num == svn.core.SVN_ERR_FS_NOT_DIRECTORY:
+ if num == core.SVN_ERR_FS_NOT_DIRECTORY:
raise NoSuchFile(relpath)
raise
return dirents.keys()
try:
svn.client.mkdir([path.encode("utf-8")], self._client)
except SubversionException, (msg, num):
- if num == svn.core.SVN_ERR_FS_NOT_FOUND:
+ if num == core.SVN_ERR_FS_NOT_FOUND:
raise NoSuchFile(path)
- if num == svn.core.SVN_ERR_FS_ALREADY_EXISTS:
+ if num == core.SVN_ERR_FS_ALREADY_EXISTS:
raise FileExists(path)
raise
from cStringIO import StringIO
import urllib
-import svn.core, svn.wc, svn.delta
-from svn.core import Pool
+import core, svn.wc, svn.delta
+from core import Pool
# Deal with Subversion 1.5 and the patched Subversion 1.4 (which are
# slightly different).
SVN_PROP_BZR_FILEIDS, SVN_PROP_BZR_REVISION_ID,
SVN_PROP_BZR_BRANCHING_SCHEME, SVN_PROP_BZR_MERGE)
- if name == svn.core.SVN_PROP_ENTRY_COMMITTED_REV:
+ if name == core.SVN_PROP_ENTRY_COMMITTED_REV:
self.dir_revnum[id] = int(value)
- elif name == svn.core.SVN_PROP_IGNORE:
+ elif name == core.SVN_PROP_IGNORE:
self.dir_ignores[id] = value
elif name.startswith(SVN_PROP_BZR_ANCESTRY):
if id != self.tree._inventory.root.file_id:
if id != self.tree._inventory.root.file_id:
mutter('%r set on non-root dir!' % name)
return
- elif name in (svn.core.SVN_PROP_ENTRY_COMMITTED_DATE,
- svn.core.SVN_PROP_ENTRY_LAST_AUTHOR,
- svn.core.SVN_PROP_ENTRY_LOCK_TOKEN,
- svn.core.SVN_PROP_ENTRY_UUID,
- svn.core.SVN_PROP_EXECUTABLE):
+ elif name in (SVN_PROP_ENTRY_COMMITTED_DATE,
+ SVN_PROP_ENTRY_LAST_AUTHOR,
+ SVN_PROP_ENTRY_LOCK_TOKEN,
+ SVN_PROP_ENTRY_UUID,
+ SVN_PROP_EXECUTABLE):
pass
- elif name.startswith(svn.core.SVN_PROP_WC_PREFIX):
+ elif name.startswith(core.SVN_PROP_WC_PREFIX):
pass
elif (name == SVN_PROP_BZR_REVISION_INFO or
name.startswith(SVN_PROP_BZR_REVISION_ID)):
pass
elif name == SVN_PROP_BZR_MERGE:
pass
- elif (name.startswith(svn.core.SVN_PROP_PREFIX) or
+ elif (name.startswith(core.SVN_PROP_PREFIX) or
name.startswith(SVN_PROP_BZR_PREFIX)):
mutter('unsupported dir property %r' % name)
def change_file_prop(self, id, name, value, pool):
from mapping import SVN_PROP_BZR_PREFIX
- if name == svn.core.SVN_PROP_EXECUTABLE:
+ if name == core.SVN_PROP_EXECUTABLE:
self.is_executable = (value != None)
- elif name == svn.core.SVN_PROP_SPECIAL:
+ elif name == core.SVN_PROP_SPECIAL:
self.is_symlink = (value != None)
- elif name == svn.core.SVN_PROP_ENTRY_COMMITTED_REV:
+ elif name == core.SVN_PROP_ENTRY_COMMITTED_REV:
self.last_file_rev = int(value)
- elif name in (svn.core.SVN_PROP_ENTRY_COMMITTED_DATE,
- svn.core.SVN_PROP_ENTRY_LAST_AUTHOR,
- svn.core.SVN_PROP_ENTRY_LOCK_TOKEN,
- svn.core.SVN_PROP_ENTRY_UUID,
- svn.core.SVN_PROP_MIME_TYPE):
+ elif name in (core.SVN_PROP_ENTRY_COMMITTED_DATE,
+ core.SVN_PROP_ENTRY_LAST_AUTHOR,
+ core.SVN_PROP_ENTRY_LOCK_TOKEN,
+ core.SVN_PROP_ENTRY_UUID,
+ core.SVN_PROP_MIME_TYPE):
pass
- elif name.startswith(svn.core.SVN_PROP_WC_PREFIX):
+ elif name.startswith(core.SVN_PROP_WC_PREFIX):
pass
- elif (name.startswith(svn.core.SVN_PROP_PREFIX) or
+ elif (name.startswith(core.SVN_PROP_PREFIX) or
name.startswith(SVN_PROP_BZR_PREFIX)):
mutter('unsupported file property %r' % name)
props = svn.wc.get_prop_diffs(self.workingtree.abspath(relpath), wc)
if isinstance(props, list): # Subversion 1.5
props = props[1]
- if props.has_key(svn.core.SVN_PROP_SPECIAL):
+ if props.has_key(core.SVN_PROP_SPECIAL):
ie = self._inventory.add_path(relpath, 'symlink', id)
ie.symlink_target = open(self._abspath(relpath)).read()[len("link "):]
ie.text_sha1 = None
data = osutils.fingerprint_file(open(self._abspath(relpath)))
ie.text_sha1 = data['sha1']
ie.text_size = data['size']
- ie.executable = props.has_key(svn.core.SVN_PROP_EXECUTABLE)
+ ie.executable = props.has_key(core.SVN_PROP_EXECUTABLE)
ie.revision = revid
return ie
entry = entries[name]
assert entry
- if entry.kind == svn.core.svn_node_dir:
+ if entry.kind == core.svn_node_dir:
subwc = svn.wc.adm_open3(wc,
self.workingtree.abspath(subrelpath),
False, 0, None)
cdef extern from "svn_error.h":
- ctypedef struct svn_error_t
+ ctypedef struct svn_error_t:
+ apr_status_t apr_err
+ char *message
+ char *file
+ char *line
cdef extern from "svn_types.h":
ctypedef int svn_boolean_t
ctypedef svn_error_t *(*svn_cancel_func_t)(cancel_baton)
+ ctypedef long svn_revnum_t
cdef extern from "svn_string.h":
ctypedef struct svn_string_t:
include "apr.pxi"
include "types.pxi"
+from core import check_error, Pool
+
+cdef svn_error_t *py_cancel_func(cancel_baton):
+ cancel_baton()
+ return NULL
+
apr_initialize()
cdef extern from "svn_wc.h":
svn_error_t *svn_wc_adm_open3(svn_wc_adm_access_t **adm_access,
svn_wc_adm_access_t *associated,
char *path,
- types.svn_boolean_t write_lock,
+ svn_boolean_t write_lock,
int depth,
- types.svn_cancel_func_t cancel_func,
+ svn_cancel_func_t cancel_func,
cancel_baton,
- apr.apr_pool_t *pool)
+ apr_pool_t *pool)
svn_error_t *svn_wc_adm_close(svn_wc_adm_access_t *adm_access)
char *svn_wc_adm_access_path(svn_wc_adm_access_t *adm_access)
svn_boolean_t svn_wc_adm_locked(svn_wc_adm_access_t *adm_access)
- svn_error_t *svn_wc_locked(svn_boolean_t *locked, char *path, apr.apr_pool_t *pool)
+ svn_error_t *svn_wc_locked(svn_boolean_t *locked, char *path, apr_pool_t *pool)
ctypedef struct svn_wc_revision_status_t:
long min_rev
long max_rev
svn_error_t *svn_wc_revision_status(svn_wc_revision_status_t **result_p,
char *wc_path,
char *trail_url,
- types.svn_boolean_t committed,
- types.svn_cancel_func_t cancel_func,
+ svn_boolean_t committed,
+ svn_cancel_func_t cancel_func,
void *cancel_baton,
- apr.apr_pool_t *pool)
+ apr_pool_t *pool)
svn_error_t *svn_wc_prop_get(svn_string_t **value,
char *name,
char *path,
svn_wc_adm_access_t *adm_access,
- apr.apr_pool_t *pool)
+ apr_pool_t *pool)
svn_error_t *svn_wc_entries_read(apr_hash_t **entries,
svn_wc_adm_access_t *adm_access,
svn_boolean_t show_hidden,
- apr.apr_pool_t *pool)
+ apr_pool_t *pool)
def version():
"""Get libsvn_wc version information.
cdef class WorkingCopy:
cdef svn_wc_adm_access_t *adm
+ cdef apr_pool_t *pool
def __init__(self, path, associated=None, write_lock=False, depth=0,
cancel_func=None):
self.pool = Pool(NULL)
- _check_error(svn_wc_adm_open3(&self.adm, associated, path,
+ check_error(svn_wc_adm_open3(&self.adm, associated, path,
write_lock, depth, py_cancel_func, cancel_func,
self.pool))
def prop_get(self, name, path):
cdef svn_string_t *value
- _check_error(svn_wc_prop_get(&value, name, path, self.adm, temp_pool))
- return PyString_FromStringAndSize(value.data, value.length)
+ check_error(svn_wc_prop_get(&value, name, path, self.adm, temp_pool))
+ return PyString_FromStringAndSize(value.data, value.len)
def entries_read(self, show_hidden):
cdef apr_hash_t *entries
- _check_error(svn_wc_entries_read(&entries, self.adm,
+ check_error(svn_wc_entries_read(&entries, self.adm,
show_hidden, temp_pool))
# FIXME: Create py_entries
py_entries = {}
def revision_status(wc_path, trail_url, committed, cancel_func=None):
cdef svn_wc_revision_status_t *revstatus
- _check_error(svn_wc_revision_status(&revstatus, wc_path, trail_url,
+ check_error(svn_wc_revision_status(&revstatus, wc_path, trail_url,
committed, py_cancel_func, cancel_func, temp_pool))
return (revstatus.min_rev, revstatus.max_rev,
revstatus.switched, revstatus.modified)
import os
import urllib
-import svn.core, svn.wc
-from svn.core import SubversionException, Pool, svn_time_to_cstring
+import core. svn.wc
+from core.import SubversionException, Pool, svn_time_to_cstring
from errors import NoCheckoutSupport
from format import get_rich_root_format
status = wc.revision_status(self.basedir, None, True)
if status.min_rev != status.max_rev:
#raise WorkingTreeInconsistent(status.min_rev, status.max_rev)
- rev = svn.core.svn_opt_revision_t()
- rev.kind = svn.core.svn_opt_revision_number
+ rev = core.svn_opt_revision_t()
+ rev.kind = core.svn_opt_revision_number
rev.value.number = status.max_rev
assert status.max_rev == svn.client.update(self.basedir, rev,
True, self.client_ctx, Pool())
ignores.update(wc.get_default_ignores(svn_config))
def dir_add(wc, prefix, patprefix):
- ignorestr = wc.prop_get(svn.core.SVN_PROP_IGNORE,
+ ignorestr = wc.prop_get(core.SVN_PROP_IGNORE,
self.abspath(prefix).rstrip("/"))
if ignorestr is not None:
for pat in ignorestr.splitlines():
if entry == "":
continue
- if entries[entry].kind != svn.core.svn_node_dir:
+ if entries[entry].kind != core.svn_node_dir:
continue
subprefix = os.path.join(prefix, entry)
raise NotImplementedError(self.apply_inventory_delta)
def update(self, change_reporter=None):
- rev = svn.core.svn_opt_revision_t()
- rev.kind = svn.core.svn_opt_revision_head
+ rev = core.svn_opt_revision_t()
+ rev.kind = core.svn_opt_revision_head
svn.client.update(self.basedir, rev, True, self.client_ctx)
def remove(self, files, verbose=False, to_file=None):
def move(self, from_paths, to_dir=None, after=False, **kwargs):
# FIXME: Use after argument
assert after != True
- revt = svn.core.svn_opt_revision_t()
- revt.kind = svn.core.svn_opt_revision_working
+ revt = core.svn_opt_revision_t()
+ revt.kind = core.svn_opt_revision_working
for entry in from_paths:
try:
to_wc = self._get_wc(to_dir, write_lock=True)
def rename_one(self, from_rel, to_rel, after=False):
# FIXME: Use after
assert after != True
- revt = svn.core.svn_opt_revision_t()
- revt.kind = svn.core.svn_opt_revision_unspecified
+ revt = core.svn_opt_revision_t()
+ revt.kind = core.svn_opt_revision_unspecified
(to_wc, to_file) = self._get_rel_wc(to_rel, write_lock=True)
if os.path.dirname(from_rel) == os.path.dirname(to_rel):
# Prevent lock contention
entry = entries[name]
assert entry
- if entry.kind == svn.core.svn_node_dir:
+ if entry.kind == core.svn_node_dir:
subwc = svn.wc.adm_open3(wc, self.abspath(subrelpath),
False, 0, None)
try:
commit_info = svn.client.commit3(specific_files, True, False,
self.client_ctx)
except SubversionException, (_, num):
- if num == svn.core.SVN_ERR_FS_TXN_OUT_OF_DATE:
+ if num == core.SVN_ERR_FS_TXN_OUT_OF_DATE:
raise OutOfDateTree(self)
raise
except:
if ids is not None:
self._change_fileid_mapping(ids.next(), f, wc)
except SubversionException, (_, num):
- if num == svn.core.SVN_ERR_ENTRY_EXISTS:
+ if num == core.SVN_ERR_ENTRY_EXISTS:
continue
- elif num == svn.core.SVN_ERR_WC_PATH_NOT_FOUND:
+ elif num == core.SVN_ERR_WC_PATH_NOT_FOUND:
raise NoSuchFile(path=f)
raise
finally:
(result.old_revno, result.old_revid) = self.branch.last_revision_info()
if stop_revision is None:
stop_revision = self.branch.last_revision()
- rev = svn.core.svn_opt_revision_t()
- rev.kind = svn.core.svn_opt_revision_number
+ rev = core.svn_opt_revision_t()
+ rev.kind = core.svn_opt_revision_number
rev.value.number = self.branch.lookup_revision_id(stop_revision)
fetched = svn.client.update(self.basedir, rev, True, self.client_ctx)
self.base_revid = self.branch.generate_revision_id(fetched)
branch = SvnBranch(self.svn_root_transport.base, repos,
self.remote_bzrdir.branch_path)
except SubversionException, (_, num):
- if num == svn.core.SVN_ERR_WC_NOT_DIRECTORY:
+ if num == core.SVN_ERR_WC_NOT_DIRECTORY:
raise NotBranchError(path=self.base)
raise
git.samba.org / jelmer / subvertpy.git / commitdiff