/brz/remove-bazaar

# Copyright (C) 2006, 2007, 2008 Canonical Ltd

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

# TODO: At some point, handle upgrades by just passing the whole request

# across to run on the server.

import bz2

import struct

from bzrlib import (

    branch,

    bzrdir,

    debug,

    errors,

    graph,

    lockdir,

    repository,

    revision,

    symbol_versioning,

    urlutils,

)

from bzrlib.branch import BranchReferenceFormat

from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat

from bzrlib.decorators import needs_read_lock, needs_write_lock

from bzrlib.errors import (

    NoSuchRevision,

    SmartProtocolError,

    )

from bzrlib.lockable_files import LockableFiles

from bzrlib.smart import client, vfs

from bzrlib.revision import ensure_null, NULL_REVISION

from bzrlib.trace import mutter, note, warning

class _RpcHelper(object):

    """Mixin class that helps with issuing RPCs."""

    def _call(self, method, *args, **err_context):

        try:

            return self._client.call(method, *args)

        except errors.ErrorFromSmartServer, err:

            self._translate_error(err, **err_context)

    def _call_expecting_body(self, method, *args, **err_context):

        try:

            return self._client.call_expecting_body(method, *args)

        except errors.ErrorFromSmartServer, err:

            self._translate_error(err, **err_context)

    def _call_with_body_bytes_expecting_body(self, method, args, body_bytes,

                                             **err_context):

        try:

            return self._client.call_with_body_bytes_expecting_body(

                method, args, body_bytes)

        except errors.ErrorFromSmartServer, err:

            self._translate_error(err, **err_context)

# Note: RemoteBzrDirFormat is in bzrdir.py

class RemoteBzrDir(BzrDir, _RpcHelper):

    """Control directory on a remote server, accessed via bzr:// or similar."""

    def __init__(self, transport, format, _client=None):

        """Construct a RemoteBzrDir.

        :param _client: Private parameter for testing. Disables probing and the

            use of a real bzrdir.

        """

        BzrDir.__init__(self, transport, format)

        # this object holds a delegated bzrdir that uses file-level operations

        # to talk to the other side

        self._real_bzrdir = None

        if _client is None:

            medium = transport.get_smart_medium()

            self._client = client._SmartClient(medium)

        else:

            self._client = _client

            return

        path = self._path_for_remote_call(self._client)

        response = self._call('BzrDir.open', path)

        if response not in [('yes',), ('no',)]:

            raise errors.UnexpectedSmartServerResponse(response)

        if response == ('no',):

            raise errors.NotBranchError(path=transport.base)

    def _ensure_real(self):

        """Ensure that there is a _real_bzrdir set.

        Used before calls to self._real_bzrdir.

        """

        if not self._real_bzrdir:

            self._real_bzrdir = BzrDir.open_from_transport(

                self.root_transport, _server_formats=False)

    def _translate_error(self, err, **context):

        _translate_error(err, bzrdir=self, **context)

    def cloning_metadir(self, stacked=False):

        self._ensure_real()

        return self._real_bzrdir.cloning_metadir(stacked)

    def create_repository(self, shared=False):

        # as per meta1 formats - just delegate to the format object which may

        # be parameterised.

        result = self._format.repository_format.initialize(self, shared)

        if not isinstance(result, RemoteRepository):

            return self.open_repository()

        else:

            return result

    def destroy_repository(self):

        """See BzrDir.destroy_repository"""

        self._ensure_real()

        self._real_bzrdir.destroy_repository()

    def create_branch(self):

        # as per meta1 formats - just delegate to the format object which may

        # be parameterised.

        real_branch = self._format.get_branch_format().initialize(self)

        if not isinstance(real_branch, RemoteBranch):

            return RemoteBranch(self, self.find_repository(), real_branch)

        else:

            return real_branch

    def destroy_branch(self):

        """See BzrDir.destroy_branch"""

        self._ensure_real()

        self._real_bzrdir.destroy_branch()

    def create_workingtree(self, revision_id=None, from_branch=None):

        raise errors.NotLocalUrl(self.transport.base)

    def find_branch_format(self):

        """Find the branch 'format' for this bzrdir.

        This might be a synthetic object for e.g. RemoteBranch and SVN.

        """

        b = self.open_branch()

        return b._format

    def get_branch_reference(self):

        """See BzrDir.get_branch_reference()."""

        path = self._path_for_remote_call(self._client)

        response = self._call('BzrDir.open_branch', path)

        if response[0] == 'ok':

            if response[1] == '':

                # branch at this location.

                return None

            else:

                # a branch reference, use the existing BranchReference logic.

                return response[1]

        else:

            raise errors.UnexpectedSmartServerResponse(response)

    def _get_tree_branch(self):

        """See BzrDir._get_tree_branch()."""

        return None, self.open_branch()

    def open_branch(self, _unsupported=False):

        if _unsupported:

            raise NotImplementedError('unsupported flag support not implemented yet.')

        reference_url = self.get_branch_reference()

        if reference_url is None:

            # branch at this location.

            return RemoteBranch(self, self.find_repository())

        else:

            # a branch reference, use the existing BranchReference logic.

            format = BranchReferenceFormat()

            return format.open(self, _found=True, location=reference_url)

    def open_repository(self):

        path = self._path_for_remote_call(self._client)

        verb = 'BzrDir.find_repositoryV2'

        try:

            response = self._call(verb, path)

        except errors.UnknownSmartMethod:

            verb = 'BzrDir.find_repository'

            response = self._call(verb, path)

        if response[0] != 'ok':

            raise errors.UnexpectedSmartServerResponse(response)

        if verb == 'BzrDir.find_repository':

            # servers that don't support the V2 method don't support external

            # references either.

            response = response + ('no', )

        if not (len(response) == 5):

            raise SmartProtocolError('incorrect response length %s' % (response,))

        if response[1] == '':

            format = RemoteRepositoryFormat()

            format.rich_root_data = (response[2] == 'yes')

            format.supports_tree_reference = (response[3] == 'yes')

            # No wire format to check this yet.

            format.supports_external_lookups = (response[4] == 'yes')

            # Used to support creating a real format instance when needed.

            format._creating_bzrdir = self

            remote_repo = RemoteRepository(self, format)

            format._creating_repo = remote_repo

            return remote_repo

        else:

            raise errors.NoRepositoryPresent(self)

    def open_workingtree(self, recommend_upgrade=True):

        self._ensure_real()

        if self._real_bzrdir.has_workingtree():

            raise errors.NotLocalUrl(self.root_transport)

        else:

            raise errors.NoWorkingTree(self.root_transport.base)

    def _path_for_remote_call(self, client):

        """Return the path to be used for this bzrdir in a remote call."""

        return client.remote_path_from_transport(self.root_transport)

    def get_branch_transport(self, branch_format):

        self._ensure_real()

        return self._real_bzrdir.get_branch_transport(branch_format)

    def get_repository_transport(self, repository_format):

        self._ensure_real()

        return self._real_bzrdir.get_repository_transport(repository_format)

    def get_workingtree_transport(self, workingtree_format):

        self._ensure_real()

        return self._real_bzrdir.get_workingtree_transport(workingtree_format)

    def can_convert_format(self):

        """Upgrading of remote bzrdirs is not supported yet."""

        return False

    def needs_format_conversion(self, format=None):

        """Upgrading of remote bzrdirs is not supported yet."""

        if format is None:

            symbol_versioning.warn(symbol_versioning.deprecated_in((1, 13, 0))

                % 'needs_format_conversion(format=None)')

        return False

    def clone(self, url, revision_id=None, force_new_repo=False,

              preserve_stacking=False):

        self._ensure_real()

        return self._real_bzrdir.clone(url, revision_id=revision_id,

            force_new_repo=force_new_repo, preserve_stacking=preserve_stacking)

    def get_config(self):

        self._ensure_real()

        return self._real_bzrdir.get_config()

class RemoteRepositoryFormat(repository.RepositoryFormat):

    """Format for repositories accessed over a _SmartClient.

    Instances of this repository are represented by RemoteRepository

    instances.

    The RemoteRepositoryFormat is parameterized during construction

    to reflect the capabilities of the real, remote format. Specifically

    the attributes rich_root_data and supports_tree_reference are set

    on a per instance basis, and are not set (and should not be) at

    the class level.

    :ivar _custom_format: If set, a specific concrete repository format that 

        will be used when initializing a repository with this

        RemoteRepositoryFormat.

    :ivar _creating_repo: If set, the repository object that this

        RemoteRepositoryFormat was created for: it can be called into

        to obtain data like the network name.

    """

    _matchingbzrdir = RemoteBzrDirFormat()

    def __init__(self):

        repository.RepositoryFormat.__init__(self)

        self._custom_format = None

        self._network_name = None

        self._creating_bzrdir = None

    def _vfs_initialize(self, a_bzrdir, shared):

        """Helper for common code in initialize."""

        if self._custom_format:

            # Custom format requested

            result = self._custom_format.initialize(a_bzrdir, shared=shared)

        elif self._creating_bzrdir is not None:

            # Use the format that the repository we were created to back

            # has.

            prior_repo = self._creating_bzrdir.open_repository()

            prior_repo._ensure_real()

            result = prior_repo._real_repository._format.initialize(

                a_bzrdir, shared=shared)

        else:

            # assume that a_bzr is a RemoteBzrDir but the smart server didn't

            # support remote initialization.

            # We delegate to a real object at this point (as RemoteBzrDir

            # delegate to the repository format which would lead to infinite

            # recursion if we just called a_bzrdir.create_repository.

            a_bzrdir._ensure_real()

            result = a_bzrdir._real_bzrdir.create_repository(shared=shared)

        if not isinstance(result, RemoteRepository):

            return self.open(a_bzrdir)

        else:

            return result

    def initialize(self, a_bzrdir, shared=False):

        # Being asked to create on a non RemoteBzrDir:

        if not isinstance(a_bzrdir, RemoteBzrDir):

            return self._vfs_initialize(a_bzrdir, shared)

        medium = a_bzrdir._client._medium

        if medium._is_remote_before((1, 13)):

            return self._vfs_initialize(a_bzrdir, shared)

        # Creating on a remote bzr dir.

        # 1) get the network name to use.

        if self._custom_format:

            network_name = self._custom_format.network_name()

        else:

            # Select the current bzrlib default and ask for that.

            reference_bzrdir_format = bzrdir.format_registry.get('default')()

            reference_format = reference_bzrdir_format.repository_format

            network_name = reference_format.network_name()

        # 2) try direct creation via RPC

        path = a_bzrdir._path_for_remote_call(a_bzrdir._client)

        verb = 'BzrDir.create_repository'

        if shared:

            shared_str = 'True'

        else:

            shared_str = 'False'

        try:

            response = a_bzrdir._call(verb, path, network_name, shared_str)

        except errors.UnknownSmartMethod:

            # Fallback - use vfs methods

            return self._vfs_initialize(a_bzrdir, shared)

        else:

            # Turn the response into a RemoteRepository object.

            format = RemoteRepositoryFormat()

            format.rich_root_data = (response[1] == 'yes')

            format.supports_tree_reference = (response[2] == 'yes')

            format.supports_external_lookups = (response[3] == 'yes')

            format._network_name = response[4]

            # Used to support creating a real format instance when needed.

            format._creating_bzrdir = a_bzrdir

            remote_repo = RemoteRepository(a_bzrdir, format)

            format._creating_repo = remote_repo

            return remote_repo

    def open(self, a_bzrdir):

        if not isinstance(a_bzrdir, RemoteBzrDir):

            raise AssertionError('%r is not a RemoteBzrDir' % (a_bzrdir,))

        return a_bzrdir.open_repository()

    def get_format_description(self):

        return 'bzr remote repository'

    def __eq__(self, other):

        return self.__class__ == other.__class__

    def check_conversion_target(self, target_format):

        if self.rich_root_data and not target_format.rich_root_data:

            raise errors.BadConversionTarget(

                'Does not support rich root data.', target_format)

        if (self.supports_tree_reference and

            not getattr(target_format, 'supports_tree_reference', False)):

            raise errors.BadConversionTarget(

                'Does not support nested trees', target_format)

    def network_name(self):

        if self._network_name:

            return self._network_name

        self._creating_repo._ensure_real()

        return self._creating_repo._real_repository._format.network_name()

    @property

    def _serializer(self):

        # We should only be getting asked for the serializer for

        # RemoteRepositoryFormat objects when the RemoteRepositoryFormat object

        # is a concrete instance for a RemoteRepository. In this case we know

        # the creating_repo and can use it to supply the serializer.

        self._creating_repo._ensure_real()

        return self._creating_repo._real_repository._format._serializer

class RemoteRepository(_RpcHelper):

    """Repository accessed over rpc.

    For the moment most operations are performed using local transport-backed

    Repository objects.

    """

    def __init__(self, remote_bzrdir, format, real_repository=None, _client=None):

        """Create a RemoteRepository instance.

        :param remote_bzrdir: The bzrdir hosting this repository.

        :param format: The RemoteFormat object to use.

        :param real_repository: If not None, a local implementation of the

            repository logic for the repository, usually accessing the data

            via the VFS.

        :param _client: Private testing parameter - override the smart client

            to be used by the repository.

        """

        if real_repository:

            self._real_repository = real_repository

        else:

            self._real_repository = None

        self.bzrdir = remote_bzrdir

        if _client is None:

            self._client = remote_bzrdir._client

        else:

            self._client = _client

        self._format = format

        self._lock_mode = None

        self._lock_token = None

        self._lock_count = 0

        self._leave_lock = False

        self._unstacked_provider = graph.CachingParentsProvider(

            get_parent_map=self._get_parent_map_rpc)

        self._unstacked_provider.disable_cache()

        # For tests:

        # These depend on the actual remote format, so force them off for

        # maximum compatibility. XXX: In future these should depend on the

        # remote repository instance, but this is irrelevant until we perform

        # reconcile via an RPC call.

        self._reconcile_does_inventory_gc = False

        self._reconcile_fixes_text_parents = False

        self._reconcile_backsup_inventory = False

        self.base = self.bzrdir.transport.base

        # Additional places to query for data.

        self._fallback_repositories = []

    def __str__(self):

        return "%s(%s)" % (self.__class__.__name__, self.base)

    __repr__ = __str__

    def abort_write_group(self, suppress_errors=False):

        """Complete a write group on the decorated repository.

        Smart methods peform operations in a single step so this api

        is not really applicable except as a compatibility thunk

        for older plugins that don't use e.g. the CommitBuilder

        facility.

        :param suppress_errors: see Repository.abort_write_group.

        """

        self._ensure_real()

        return self._real_repository.abort_write_group(

            suppress_errors=suppress_errors)

    def commit_write_group(self):

        """Complete a write group on the decorated repository.

        Smart methods peform operations in a single step so this api

        is not really applicable except as a compatibility thunk

        for older plugins that don't use e.g. the CommitBuilder

        facility.

        """

        self._ensure_real()

        return self._real_repository.commit_write_group()

    def resume_write_group(self, tokens):

        self._ensure_real()

        return self._real_repository.resume_write_group(tokens)

    def suspend_write_group(self):

        self._ensure_real()

        return self._real_repository.suspend_write_group()

    def _ensure_real(self):

        """Ensure that there is a _real_repository set.

        Used before calls to self._real_repository.

        """

        if self._real_repository is None:

            self.bzrdir._ensure_real()

            self._set_real_repository(

                self.bzrdir._real_bzrdir.open_repository())

    def _translate_error(self, err, **context):

        self.bzrdir._translate_error(err, repository=self, **context)

    def find_text_key_references(self):

        """Find the text key references within the repository.

        :return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of

        revision_ids. Each altered file-ids has the exact revision_ids that

        altered it listed explicitly.

        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)

            to whether they were referred to by the inventory of the

            revision_id that they contain. The inventory texts from all present

            revision ids are assessed to generate this report.

        """

        self._ensure_real()

        return self._real_repository.find_text_key_references()

    def _generate_text_key_index(self):

        """Generate a new text key index for the repository.

        This is an expensive function that will take considerable time to run.

        :return: A dict mapping (file_id, revision_id) tuples to a list of

            parents, also (file_id, revision_id) tuples.

        """

        self._ensure_real()

        return self._real_repository._generate_text_key_index()

    @symbol_versioning.deprecated_method(symbol_versioning.one_four)

    def get_revision_graph(self, revision_id=None):

        """See Repository.get_revision_graph()."""

        return self._get_revision_graph(revision_id)

    def _get_revision_graph(self, revision_id):

        """Private method for using with old (< 1.2) servers to fallback."""

        if revision_id is None:

            revision_id = ''

        elif revision.is_null(revision_id):

            return {}

        path = self.bzrdir._path_for_remote_call(self._client)

        response = self._call_expecting_body(

            'Repository.get_revision_graph', path, revision_id)

        response_tuple, response_handler = response

        if response_tuple[0] != 'ok':

            raise errors.UnexpectedSmartServerResponse(response_tuple)

        coded = response_handler.read_body_bytes()

        if coded == '':

            # no revisions in this repository!

            return {}

        lines = coded.split('\n')

        revision_graph = {}

        for line in lines:

            d = tuple(line.split())

            revision_graph[d[0]] = d[1:]

        return revision_graph

    def _get_sink(self):

        """See Repository._get_sink()."""

        self._ensure_real()

        return self._real_repository._get_sink()

    def has_revision(self, revision_id):

        """See Repository.has_revision()."""

        if revision_id == NULL_REVISION:

            # The null revision is always present.

            return True

        path = self.bzrdir._path_for_remote_call(self._client)

        response = self._call('Repository.has_revision', path, revision_id)

        if response[0] not in ('yes', 'no'):

            raise errors.UnexpectedSmartServerResponse(response)

        if response[0] == 'yes':

            return True

        for fallback_repo in self._fallback_repositories:

            if fallback_repo.has_revision(revision_id):

                return True

        return False

    def has_revisions(self, revision_ids):

        """See Repository.has_revisions()."""

        # FIXME: This does many roundtrips, particularly when there are

        # fallback repositories.  -- mbp 20080905

        result = set()

        for revision_id in revision_ids:

            if self.has_revision(revision_id):

                result.add(revision_id)

        return result

    def has_same_location(self, other):

        return (self.__class__ == other.__class__ and

                self.bzrdir.transport.base == other.bzrdir.transport.base)

    def get_graph(self, other_repository=None):

        """Return the graph for this repository format"""

        parents_provider = self._make_parents_provider(other_repository)

        return graph.Graph(parents_provider)

    def gather_stats(self, revid=None, committers=None):

        """See Repository.gather_stats()."""

        path = self.bzrdir._path_for_remote_call(self._client)

        # revid can be None to indicate no revisions, not just NULL_REVISION

        if revid is None or revision.is_null(revid):

            fmt_revid = ''

        else:

            fmt_revid = revid

        if committers is None or not committers:

            fmt_committers = 'no'

        else:

            fmt_committers = 'yes'

        response_tuple, response_handler = self._call_expecting_body(

            'Repository.gather_stats', path, fmt_revid, fmt_committers)

        if response_tuple[0] != 'ok':

            raise errors.UnexpectedSmartServerResponse(response_tuple)

        body = response_handler.read_body_bytes()

        result = {}

        for line in body.split('\n'):

            if not line:

                continue

            key, val_text = line.split(':')

            if key in ('revisions', 'size', 'committers'):

                result[key] = int(val_text)

            elif key in ('firstrev', 'latestrev'):

                values = val_text.split(' ')[1:]

                result[key] = (float(values[0]), long(values[1]))

        return result

    def find_branches(self, using=False):

        """See Repository.find_branches()."""

        # should be an API call to the server.

        self._ensure_real()

        return self._real_repository.find_branches(using=using)

    def get_physical_lock_status(self):

        """See Repository.get_physical_lock_status()."""

        # should be an API call to the server.

        self._ensure_real()

        return self._real_repository.get_physical_lock_status()

    def is_in_write_group(self):

        """Return True if there is an open write group.

        write groups are only applicable locally for the smart server..

        """

        if self._real_repository:

            return self._real_repository.is_in_write_group()

    def is_locked(self):

        return self._lock_count >= 1

    def is_shared(self):

        """See Repository.is_shared()."""

        path = self.bzrdir._path_for_remote_call(self._client)

        response = self._call('Repository.is_shared', path)

        if response[0] not in ('yes', 'no'):

            raise SmartProtocolError('unexpected response code %s' % (response,))