def _file_grep_list_only_wtree(file, path, opts, path_prefix=None):
# test and skip binary files
if b'\x00' in file.read(1024):
if opts.verbose:
trace.warning("Binary file '%s' skipped.", path)
return
file.seek(0) # search from beginning
found = False
if opts.fixed_string:
pattern = opts.pattern.encode(_user_encoding, 'replace')
for line in file:
if pattern in line:
found = True
break
else: # not fixed_string
for line in file:
if opts.patternc.search(line):
found = True
break
if (opts.files_with_matches and found) or \
(opts.files_without_match and not found):
if path_prefix and path_prefix != '.':
# user has passed a dir arg, show that as result prefix
path = osutils.pathjoin(path_prefix, path)
opts.outputter.get_writer(path, None, None)()
def warn_codeplex(host):
global _warned_codeplex
if not _warned_codeplex:
warning("Please note %s is hosted on Codeplex which runs a broken "
"Subversion server. Please consider using the bzr-tfs plugin, "
"which provides support for CodePlex' native Team Foundation Server." % host)
_warned_codeplex = True
def set_user_option(self,
name,
value,
store=STORE_LOCATION,
warn_masked=False):
if store == STORE_GLOBAL:
self._get_global_config().set_user_option(name, value)
elif store == STORE_BRANCH:
raise NotImplementedError(
"Saving in branch config not supported for Subversion "
"branches")
else:
self._get_location_config().set_user_option(name, value, store)
if not warn_masked:
return
if store in (STORE_GLOBAL, STORE_BRANCH):
mask_value = self._get_location_config().get_user_option(name)
if mask_value is not None:
trace.warning(
'Value "%s" is masked by "%s" from'
' locations.conf', value, mask_value)
else:
if store == STORE_GLOBAL:
branch_config = self._get_branch_data_config()
mask_value = branch_config.get_user_option(name)
if mask_value is not None:
trace.warning(
'Value "%s" is masked by "%s" from'
' branch.conf', value, mask_value)
def __init__(self):
super(BzrSvnMapping, self).__init__(foreign_vcs_svn)
if ((version_info[3] == 'exp' or self.experimental)
and not BzrSvnMapping._warned_experimental):
from breezy.trace import warning
warning("using experimental bzr-svn mappings; may break existing "
"branches in the most horrible ways")
BzrSvnMapping._warned_experimental = True
def wipe_commit_data(self):
if (self.tree.branch.get_physical_lock_status()
or self.tree.branch.is_locked()):
# XXX maybe show this in a GUI MessageBox (information box)???
from breezy.trace import warning
warning("Cannot wipe commit data because the branch is locked.")
return
self.ci_data.wipe()
def check_pysqlite_version(sqlite3):
"""Check that sqlite library is compatible.
"""
if (sqlite3.sqlite_version_info[0] < 3
or (sqlite3.sqlite_version_info[0] == 3
and sqlite3.sqlite_version_info[1] < 3)):
trace.warning('Needs at least sqlite 3.3.x')
raise errors.BzrError("incompatible sqlite library")
def warn_uuid_reuse(uuid, location):
"""Warn that a UUID is being reused for different repositories."""
global _reuse_uuids_warned
if uuid in _reuse_uuids_warned:
return
trace.warning(
"Repository with UUID %s at %s contains fewer revisions "
"than cache. This either means that this repository contains an out "
"of date mirror of another repository (harmless), or that the UUID "
"is being used for two different Subversion repositories ("
"potential repository corruption).", uuid, location)
_reuse_uuids_warned.add(uuid)
def __init__(self, path=None):
self.path = path
if path is None:
self.db = {}
else:
import tdb
if not mapdbs().has_key(path):
mapdbs()[path] = tdb.Tdb(path, TDB_HASH_SIZE, tdb.DEFAULT,
os.O_RDWR | os.O_CREAT)
self.db = mapdbs()[path]
try:
if int(self.db["version"]) != TDB_MAP_VERSION:
trace.warning(
"SHA Map is incompatible (%s -> %d), rebuilding database.",
self.db["version"], TDB_MAP_VERSION)
self.db.clear()
self.db["version"] = str(TDB_MAP_VERSION)
except KeyError:
self.db["version"] = str(TDB_MAP_VERSION)
def _finish_computing_transform(self):
"""Finalize the transform and report the changes.
This is the second half of _compute_transform.
"""
child_pb = ui.ui_factory.nested_progress_bar()
try:
fs_conflicts = transform.resolve_conflicts(
self.tt, child_pb,
lambda t, c: transform.conflict_pass(t, c, self.other_tree))
finally:
child_pb.finished()
if self.change_reporter is not None:
from breezy import delta
delta.report_changes(self.tt.iter_changes(), self.change_reporter)
self.cook_conflicts(fs_conflicts)
from breezy import trace
for conflict in self.cooked_conflicts:
trace.warning(conflict)
def warn_slow_revprops(config, server):
global _warned_slow_revprops
if _warned_slow_revprops:
return
try:
warn_upgrade = config.get_bool("warn-upgrade")
except KeyError:
warn_upgrade = True
if warn_upgrade:
if server:
trace.warning(
"Upgrade server to svn 1.5 or higher for faster retrieving "
"of revision properties.")
else:
trace.warning(
"Upgrade to svn 1.5 or higher for faster retrieving of "
"revision properties.")
_warned_slow_revprops = True
def save_commit_data(self):
if (self.tree.branch.get_physical_lock_status()
or self.tree.branch.is_locked()):
# XXX maybe show this in a GUI MessageBox (information box)???
from breezy.trace import warning
warning("Cannot save commit data because the branch is locked.")
return
# collect data
ci_data = QBzrCommitData(tree=self.tree)
message = str(self.message.toPlainText()).strip()
if message:
ci_data['message'] = message
bug_str = ''
if self.bugsCheckBox.isChecked():
bug_str = str(self.bugs.text()).strip()
if bug_str:
ci_data['bugs'] = bug_str
# save only if data different
if not ci_data.compare_data(self.ci_data, all_keys=False):
ci_data.save()
def serve_svn(transport, host=None, port=None, inet=False):
trace.warning("server support in bzr-svn is experimental.")
if transport.base.startswith("readonly+"):
url = transport.base[len("readonly+"):]
path = urlutils.local_path_from_url(url)
backend = BzrServerBackend(path)
if inet:
def send_fn(data):
sys.stdout.write(data)
sys.stdout.flush()
server = SVNServer(backend, sys.stdin.read, send_fn)
else:
if port is None:
port = SVN_PORT
if host is None:
host = '0.0.0.0'
server = TCPSVNServer(backend, (host, port))
server.serve()
def warn(self, *msg):
for x in msg:
trace.warning("hg: %s" % x.rstrip())
def _warn_busy_cache(self):
trace.warning("Cache for repository %s busy, ignoring")
def sprout(self,
url,
revision_id=None,
force_new_repo=False,
recurse='down',
possible_transports=None,
accelerator_tree=None,
hardlink=False,
stacked=False,
source_branch=None,
create_tree_if_local=True):
from breezy.repository import InterRepository
from breezy.transport.local import LocalTransport
relpath = self._determine_relpath(None)
if relpath == u"":
guessed_layout = self.find_repository().get_guessed_layout()
if guessed_layout is not None and not guessed_layout.is_branch(
u""):
trace.warning(
'Cloning Subversion repository as branch. '
'To import the individual branches in the repository, '
'use "bzr svn-import".')
target_transport = get_transport(url, possible_transports)
target_transport.ensure_base()
require_colocated = ("branch"
in target_transport.get_segment_parameters())
cloning_format = self.cloning_metadir(
require_colocated=require_colocated)
# Create/update the result branch
result = cloning_format.initialize_on_transport(target_transport)
source_repository = self.find_repository()
if force_new_repo:
result_repo = result.create_repository()
target_is_empty = True
else:
try:
result_repo = result.find_repository()
except errors.NoRepositoryPresent:
result_repo = result.create_repository()
target_is_empty = True
else:
target_is_empty = None # Unknown
if stacked:
raise UnstackableBranchFormat(self._format.get_branch_format(),
self.root_transport.base)
interrepo = InterRepository.get(source_repository, result_repo)
try:
source_branch = self.open_branch()
except errors.NotBranchError:
source_branch = None
project = None
mapping = None
else:
project = source_branch.project
mapping = source_branch.mapping
interrepo.fetch(revision_id=revision_id,
project=project,
mapping=mapping,
target_is_empty=target_is_empty,
exclude_non_mainline=False)
if source_branch is not None:
if revision_id is None:
revision_id = source_branch.last_revision()
result_branch = source_branch.sprout(result,
revision_id=revision_id,
repository=result_repo)
interbranch = InterBranch.get(source_branch, result_branch)
interbranch.fetch(stop_revision=revision_id,
exclude_non_mainline=False) # For the tags
else:
result_branch = result.create_branch()
if (create_tree_if_local
and isinstance(target_transport, LocalTransport)
and (result_repo is None or result_repo.make_working_trees())):
result.create_workingtree(accelerator_tree=accelerator_tree,
hardlink=hardlink,
from_branch=result_branch)
return result
def versioned_grep(opts):
wt, branch, relpath = \
controldir.ControlDir.open_containing_tree_or_branch('.')
with branch.lock_read():
start_rev = opts.revision[0]
start_revid = start_rev.as_revision_id(branch)
if start_revid is None:
start_rev = RevisionSpec_revno.from_string("revno:1")
start_revid = start_rev.as_revision_id(branch)
srevno_tuple = branch.revision_id_to_dotted_revno(start_revid)
if len(opts.revision) == 2:
end_rev = opts.revision[1]
end_revid = end_rev.as_revision_id(branch)
if end_revid is None:
end_revno, end_revid = branch.last_revision_info()
erevno_tuple = branch.revision_id_to_dotted_revno(end_revid)
grep_mainline = (_rev_on_mainline(srevno_tuple)
and _rev_on_mainline(erevno_tuple))
# ensure that we go in reverse order
if srevno_tuple > erevno_tuple:
srevno_tuple, erevno_tuple = erevno_tuple, srevno_tuple
start_revid, end_revid = end_revid, start_revid
# Optimization: Traversing the mainline in reverse order is much
# faster when we don't want to look at merged revs. We try this
# with _linear_view_revisions. If all revs are to be grepped we
# use the slower _graph_view_revisions
if opts.levels == 1 and grep_mainline:
given_revs = _linear_view_revisions(
branch, start_revid, end_revid)
else:
given_revs = _graph_view_revisions(
branch, start_revid, end_revid)
else:
# We do an optimization below. For grepping a specific revison
# We don't need to call _graph_view_revisions which is slow.
# We create the start_rev_tuple for only that specific revision.
# _graph_view_revisions is used only for revision range.
start_revno = '.'.join(map(str, srevno_tuple))
start_rev_tuple = (start_revid, start_revno, 0)
given_revs = [start_rev_tuple]
# GZ 2010-06-02: Shouldn't be smuggling this on opts, but easy for now
opts.outputter = _Outputter(opts, use_cache=True)
for revid, revno, merge_depth in given_revs:
if opts.levels == 1 and merge_depth != 0:
# with level=1 show only top level
continue
rev = RevisionSpec_revid.from_string(
"revid:" + revid.decode('utf-8'))
tree = rev.as_tree(branch)
for path in opts.path_list:
tree_path = osutils.pathjoin(relpath, path)
if not tree.has_filename(tree_path):
trace.warning("Skipped unknown file '%s'.", path)
continue
if osutils.isdir(path):
path_prefix = path
dir_grep(tree, path, relpath, opts, revno, path_prefix)
else:
versioned_file_grep(
tree, tree_path, '.', path, opts, revno)
def _log_cleanup_error(exc):
trace.mutter('Cleanup failed:')
trace.log_exception_quietly()
if 'cleanup' in debug.debug_flags:
trace.warning('brz: warning: Cleanup failed: %s', exc)
def _compare_trees(old_tree, new_tree, want_unchanged, specific_files,
include_root, extra_trees=None,
require_versioned=False, want_unversioned=False):
"""Worker function that implements Tree.changes_from."""
delta = TreeDelta()
# mutter('start compare_trees')
for change in new_tree.iter_changes(
old_tree, want_unchanged, specific_files, extra_trees=extra_trees,
require_versioned=require_versioned,
want_unversioned=want_unversioned):
if change.versioned == (False, False):
delta.unversioned.append(change)
continue
if not include_root and (None, None) == change.parent_id:
continue
fully_present = tuple(
(change.versioned[x] and change.kind[x] is not None)
for x in range(2))
if fully_present[0] != fully_present[1]:
if fully_present[1] is True:
delta.added.append(change)
else:
if change.kind[0] == 'symlink' and not new_tree.supports_symlinks():
trace.warning(
'Ignoring "%s" as symlinks '
'are not supported on this filesystem.' % (change.path[0],))
else:
delta.removed.append(change)
elif fully_present[0] is False:
delta.missing.append(change)
elif change.name[0] != change.name[1] or change.parent_id[0] != change.parent_id[1]:
# If the name changes, or the parent_id changes, we have a rename or copy
# (if we move a parent, that doesn't count as a rename for the
# file)
if change.copied:
delta.copied.append(change)
else:
delta.renamed.append(change)
elif change.kind[0] != change.kind[1]:
delta.kind_changed.append(change)
elif change.changed_content or change.executable[0] != change.executable[1]:
delta.modified.append(change)
else:
delta.unchanged.append(change)
def change_key(change):
if change.path[0] is None:
path = change.path[1]
else:
path = change.path[0]
return (path, change.file_id)
delta.removed.sort(key=change_key)
delta.added.sort(key=change_key)
delta.renamed.sort(key=change_key)
delta.copied.sort(key=change_key)
delta.missing.sort(key=change_key)
# TODO: jam 20060529 These lists shouldn't need to be sorted
# since we added them in alphabetical order.
delta.modified.sort(key=change_key)
delta.unchanged.sort(key=change_key)
delta.unversioned.sort(key=change_key)
return delta
def _file_grep(file_text, path, opts, revno, path_prefix=None, cache_id=None):
# test and skip binary files
if b'\x00' in file_text[:1024]:
if opts.verbose:
trace.warning("Binary file '%s' skipped.", path)
return
if path_prefix and path_prefix != '.':
# user has passed a dir arg, show that as result prefix
path = osutils.pathjoin(path_prefix, path)
# GZ 2010-06-07: There's no actual guarentee the file contents will be in
# the user encoding, but we have to guess something and it
# is a reasonable default without a better mechanism.
file_encoding = _user_encoding
pattern = opts.pattern.encode(_user_encoding, 'replace')
writeline = opts.outputter.get_writer(path, revno, cache_id)
if opts.files_with_matches or opts.files_without_match:
if opts.fixed_string:
found = pattern in file_text
else:
search = opts.patternc.search
if b"$" not in pattern:
found = search(file_text) is not None
else:
for line in file_text.splitlines():
if search(line):
found = True
break
else:
found = False
if (opts.files_with_matches and found) or \
(opts.files_without_match and not found):
writeline()
elif opts.fixed_string:
# Fast path for no match, search through the entire file at once rather
# than a line at a time. <http://effbot.org/zone/stringlib.htm>
i = file_text.find(pattern)
if i == -1:
return
b = file_text.rfind(b"\n", 0, i) + 1
if opts.line_number:
start = file_text.count(b"\n", 0, b) + 1
file_text = file_text[b:]
if opts.line_number:
for index, line in enumerate(file_text.splitlines()):
if pattern in line:
line = line.decode(file_encoding, 'replace')
writeline(lineno=index + start, line=line)
else:
for line in file_text.splitlines():
if pattern in line:
line = line.decode(file_encoding, 'replace')
writeline(line=line)
else:
# Fast path on no match, the re module avoids bad behaviour in most
# standard cases, but perhaps could try and detect backtracking
# patterns here and avoid whole text search in those cases
search = opts.patternc.search
if b"$" not in pattern:
# GZ 2010-06-05: Grr, re.MULTILINE can't save us when searching
# through revisions as bazaar returns binary mode
# and trailing \r breaks $ as line ending match
m = search(file_text)
if m is None:
return
b = file_text.rfind(b"\n", 0, m.start()) + 1
if opts.line_number:
start = file_text.count(b"\n", 0, b) + 1
file_text = file_text[b:]
else:
start = 1
if opts.line_number:
for index, line in enumerate(file_text.splitlines()):
if search(line):
line = line.decode(file_encoding, 'replace')
writeline(lineno=index + start, line=line)
else:
for line in file_text.splitlines():
if search(line):
line = line.decode(file_encoding, 'replace')
writeline(line=line)
if (sqlite3.sqlite_version_info[0] < 3
or (sqlite3.sqlite_version_info[0] == 3
and sqlite3.sqlite_version_info[1] < 3)):
trace.warning('Needs at least sqlite 3.3.x')
raise errors.BzrError("incompatible sqlite library")
try:
try:
import sqlite3
check_pysqlite_version(sqlite3)
except (ImportError, errors.BzrError) as e:
from pysqlite2 import dbapi2 as sqlite3
check_pysqlite_version(sqlite3)
except:
trace.warning('Needs at least Python2.5 or Python2.4 with the pysqlite2 '
'module')
raise errors.BzrError("missing sqlite library")
def _connect_sqlite3_file(path):
return sqlite3.connect(path, timeout=20.0, isolation_level=None)
connect_cachefile = _connect_sqlite3_file
class CacheTable(object):
"""Simple base class for SQLite-based caches."""
def __init__(self, cache_db=None):
if cache_db is None:
self.cachedb = sqlite3.connect(":memory:")
