def __init__(self, _transport, _format):
self._format = _format
self.transport = _transport.clone('.dummy')
self.root_transport = _transport
self._mode_check_done = False
self._control_files = lockable_files.LockableFiles(
self.transport, "lock", lockable_files.TransportLock)
def initialize(self, a_bzrdir, shared=False, _internal=False):
"""Create a weave repository."""
if shared:
raise errors.IncompatibleFormat(self, a_bzrdir._format)
if not _internal:
# always initialized when the bzrdir is.
return self.open(a_bzrdir, _found=True)
# Create an empty weave
sio = StringIO()
weavefile.write_weave_v5(weave.Weave(), sio)
empty_weave = sio.getvalue()
mutter('creating repository in %s.', a_bzrdir.transport.base)
# FIXME: RBC 20060125 don't peek under the covers
# NB: no need to escape relative paths that are url safe.
control_files = lockable_files.LockableFiles(
a_bzrdir.transport, 'branch-lock', lockable_files.TransportLock)
control_files.create_lock()
control_files.lock_write()
transport = a_bzrdir.transport
try:
transport.mkdir_multi(['revision-store', 'weaves'],
mode=a_bzrdir._get_dir_mode())
transport.put_bytes_non_atomic('inventory.weave', empty_weave)
finally:
control_files.unlock()
return self.open(a_bzrdir, _found=True)
def open(self, a_bzrdir, _found=False, _override_transport=None):
"""See RepositoryFormat.open().
:param _override_transport: INTERNAL USE ONLY. Allows opening the
repository at a slightly different url
than normal. I.e. during 'upgrade'.
"""
if not _found:
format = RepositoryFormat.find_format(a_bzrdir)
if _override_transport is not None:
repo_transport = _override_transport
else:
repo_transport = a_bzrdir.get_repository_transport(None)
control_files = lockable_files.LockableFiles(repo_transport, 'lock',
lockdir.LockDir)
repo = self.repository_class(
_format=self,
a_bzrdir=a_bzrdir,
control_files=control_files,
_commit_builder_class=self._commit_builder_class,
_serializer=self._serializer)
repo.revisions = self._get_revisions(repo_transport, repo)
repo.signatures = self._get_signatures(repo_transport, repo)
repo.inventories = self._get_inventories(repo_transport, repo)
repo.texts = self._get_texts(repo_transport, repo)
repo._transport = repo_transport
return repo
def initialize(self, a_bzrdir, shared=False):
"""Create a knit format 1 repository.
:param a_bzrdir: bzrdir to contain the new repository; must already
be initialized.
:param shared: If true the repository will be initialized as a shared
repository.
"""
mutter('creating repository in %s.', a_bzrdir.transport.base)
dirs = ['knits']
files = []
utf8_files = [('format', self.get_format_string())]
self._upload_blank_content(a_bzrdir, dirs, files, utf8_files, shared)
repo_transport = a_bzrdir.get_repository_transport(None)
control_files = lockable_files.LockableFiles(repo_transport, 'lock',
lockdir.LockDir)
transaction = transactions.WriteTransaction()
result = self.open(a_bzrdir=a_bzrdir, _found=True)
result.lock_write()
# the revision id here is irrelevant: it will not be stored, and cannot
# already exist, we do this to create files on disk for older clients.
result.inventories.get_parent_map([('A', )])
result.revisions.get_parent_map([('A', )])
result.signatures.get_parent_map([('A', )])
result.unlock()
return result
def open(self, a_bzrdir, _found=False, _override_transport=None):
"""See RepositoryFormat.open().
:param _override_transport: INTERNAL USE ONLY. Allows opening the
repository at a slightly different url
than normal. I.e. during 'upgrade'.
"""
if not _found:
format = RepositoryFormatMetaDir.find_format(a_bzrdir)
if _override_transport is not None:
repo_transport = _override_transport
else:
repo_transport = a_bzrdir.get_repository_transport(None)
control_files = lockable_files.LockableFiles(repo_transport, 'lock',
lockdir.LockDir)
result = WeaveMetaDirRepository(_format=self,
a_bzrdir=a_bzrdir,
control_files=control_files)
result.revisions = self._get_revisions(repo_transport, result)
result.signatures = self._get_signatures(repo_transport, result)
result.inventories = self._get_inventories(repo_transport, result)
result.texts = self._get_texts(repo_transport, result)
result.chk_bytes = None
result._transport = repo_transport
return result
def initialize_on_transport(self, transport):
"""Initialize a new bzrdir in the base directory of a Transport."""
# Since we don't have a .bzr directory, inherit the
# mode from the root directory
temp_control = lockable_files.LockableFiles(
transport, '', lockable_files.TransportLock)
temp_control._transport.mkdir(
'.dummy',
# FIXME: RBC 20060121 don't peek under
# the covers
mode=temp_control._dir_mode)
del temp_control
bzrdir_transport = transport.clone('.dummy')
# NB: no need to escape relative paths that are url safe.
control_files = lockable_files.LockableFiles(bzrdir_transport,
self._lock_file_name,
self._lock_class)
control_files.create_lock()
return self.open(transport, _found=True)
def __init__(self, bzrdir, repo, branch):
self.basedir = bzrdir.transport.base
self.bzrdir = bzrdir
self.repository = repo
self._branch = branch
self._transport = bzrdir.transport
self.controldir = urlutils.join(self.repository._git.path, 'bzr')
try:
os.makedirs(self.controldir)
os.makedirs(os.path.join(self.controldir, 'lock'))
except OSError:
pass
self._control_files = lockable_files.LockableFiles(
transport.get_transport(self.controldir), 'lock', lockdir.LockDir)
self._format = GitWorkingTreeFormat()
self.index = Index(
os.path.join(self.repository._git.controldir(), "index"))
def open(self,
a_bzrdir,
name=None,
_found=False,
ignore_fallbacks=False,
found_repository=None):
if name is None:
name = a_bzrdir._get_selected_branch()
if not _found:
raise NotImplementedError
try:
transport = a_bzrdir.get_branch_transport(None, name=name)
control_files = lockable_files.LockableFiles(
transport, 'lock', lockdir.LockDir)
if found_repository is None:
found_repository = a_bzrdir.find_repository()
return DummyForeignVcsBranch(_format=self,
_control_files=control_files,
a_bzrdir=a_bzrdir,
_repository=found_repository,
name=name)
except errors.NoSuchFile:
raise errors.NotBranchError(path=transport.base)
