~bzr-pqm/bzr/bzr.dev

# Copyright (C) 2005, 2006, 2007 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

from bzrlib.lazy_import import lazy_import

lazy_import(globals(), """

from itertools import izip

import math

import md5

import time

from bzrlib import (

        debug,

        pack,

        ui,

        )

from bzrlib.index import (

    GraphIndex,

    GraphIndexBuilder,

    InMemoryGraphIndex,

    CombinedGraphIndex,

    GraphIndexPrefixAdapter,

    )

from bzrlib.knit import KnitGraphIndex, _PackAccess, _KnitData

from bzrlib.pack import ContainerWriter

from bzrlib.store import revision

""")

from bzrlib import (

    bzrdir,

    deprecated_graph,

    errors,

    knit,

    lockable_files,

    lockdir,

    osutils,

    transactions,

    xml5,

    xml7,

    )

from bzrlib.decorators import needs_read_lock, needs_write_lock

from bzrlib.repofmt.knitrepo import KnitRepository, KnitRepository3

from bzrlib.repository import (

    CommitBuilder,

    MetaDirRepository,

    MetaDirRepositoryFormat,

    RootCommitBuilder,

    )

import bzrlib.revision as _mod_revision

from bzrlib.store.revision.knit import KnitRevisionStore

from bzrlib.store.versioned import VersionedFileStore

from bzrlib.trace import mutter, note, warning

class PackCommitBuilder(CommitBuilder):

    """A subclass of CommitBuilder to add texts with pack semantics.

    Specifically this uses one knit object rather than one knit object per

    added text, reducing memory and object pressure.

    """

    def _add_text_to_weave(self, file_id, new_lines, parents, nostore_sha):

        return self.repository._packs._add_text_to_weave(file_id,

            self._new_revision_id, new_lines, parents, nostore_sha,

            self.random_revid)

class PackRootCommitBuilder(RootCommitBuilder):

    """A subclass of RootCommitBuilder to add texts with pack semantics.

    Specifically this uses one knit object rather than one knit object per

    added text, reducing memory and object pressure.

    """

    def _add_text_to_weave(self, file_id, new_lines, parents, nostore_sha):

        return self.repository._packs._add_text_to_weave(file_id,

            self._new_revision_id, new_lines, parents, nostore_sha,

            self.random_revid)

class Pack(object):

    """An in memory proxy for a .pack and its indices."""

    def __init__(self):

        self.revision_index = None

        self.inventory_index = None

        self.text_index = None

        self.signature_index = None

        self.name = None

        self.transport = None

    def get_revision_count(self):

        return self.revision_index.key_count()

class RepositoryPackCollection(object):

    """Management of packs within a repository."""

    def __init__(self, repo, transport, index_transport):

        """Create a new RepositoryPackCollection.

        :param transport: Addresses the repository base directory 

            (typically .bzr/repository/).

        :param index_transport: Addresses the directory containing indexes.

        """

        self.repo = repo

        self.transport = transport

        self._index_transport = index_transport

        self.packs = []

    def add_pack_to_memory(self, pack):

        """Make a Pack object available to the repository to satisfy queries.

        :param pack: A Pack object.

        """

        self.packs.append(pack)

        if self.repo._revision_all_indices is None:

            # to make this function more useful, perhaps we should make an

            # all_indices object in future?

            pass

        else:

            self.repo._revision_pack_map[pack.revision_index] = (

                pack.transport, pack.name)

            self.repo._revision_all_indices.insert_index(0, pack.revision_index)

        if self.repo._inv_all_indices is not None:

            # inv 'knit' has been used : update it.

            self.repo._inv_all_indices.insert_index(0,

                pack.inventory_index)

            self.repo._inv_pack_map[pack.inventory_index] = pack.transport, pack.name + '.pack'

        if self.repo._text_all_indices is not None:

            # text 'knits' have been used : update it.

            self.repo._text_all_indices.insert_index(0,

                pack.text_index)

        if self.repo._signature_all_indices is not None:

            # sigatures 'knit' accessed : update it.

            self.repo._signature_all_indices.insert_index(0,

                pack.signature_index)

    def _add_text_to_weave(self, file_id, revision_id, new_lines, parents,

        nostore_sha, random_revid):

        file_id_index = GraphIndexPrefixAdapter(

            self.repo._text_all_indices,

            (file_id, ), 1,

            add_nodes_callback=self.repo._text_write_index.add_nodes)

        self.repo._text_knit._index._graph_index = file_id_index

        self.repo._text_knit._index._add_callback = file_id_index.add_nodes

        return self.repo._text_knit.add_lines_with_ghosts(

            revision_id, parents, new_lines, nostore_sha=nostore_sha,

            random_id=random_revid, check_content=False)[0:2]

    def all_pack_details(self):

        """Return a list of all the packs as transport,name tuples.

        :return: A list of (transport, name) tuples for all the packs in the

            repository.

        """

        # XXX: fix me, should be direct rather than indirect

        if self.repo._revision_all_indices is None:

            # trigger creation of the all revision index.

            self.repo._revision_store.get_revision_file(self.repo.get_transaction())

        result = []

        for index, transport_and_name in self.repo._revision_pack_map.iteritems():

            result.append(transport_and_name)

        return result

    def autopack(self):

        """Pack the pack collection incrementally.

        This will not attempt global reorganisation or recompression,

        rather it will just ensure that the total number of packs does

        not grow without bound. It uses the _max_pack_count method to

        determine if autopacking is needed, and the pack_distribution

        method to determine the number of revisions in each pack.

        If autopacking takes place then the packs name collection will have

        been flushed to disk - packing requires updating the name collection

        in synchronisation with certain steps. Otherwise the names collection

        is not flushed.

        :return: True if packing took place.

        """

        if self.repo._revision_all_indices is None:

            # trigger creation of the all revision index.

            self.repo._revision_store.get_revision_file(self.repo.get_transaction())

        total_revisions = self.repo._revision_all_indices.key_count()

        total_packs = len(self._names)

        if self._max_pack_count(total_revisions) >= total_packs:

            return False

        # XXX: the following may want to be a class, to pack with a given

        # policy.

        mutter('Auto-packing repository %s, which has %d pack files, '

            'containing %d revisions into %d packs.', self, total_packs,

            total_revisions, self._max_pack_count(total_revisions))

        # determine which packs need changing

        pack_distribution = self.pack_distribution(total_revisions)

        existing_packs = []

        for index, transport_and_name in self.repo._revision_pack_map.iteritems():

            if index is None:

                continue

            revision_count = index.key_count()

            if revision_count == 0:

                # revision less packs are not generated by normal operation,

                # only by operations like sign-my-commits, and thus will not

                # tend to grow rapdily or without bound like commit containing

                # packs do - leave them alone as packing them really should

                # group their data with the relevant commit, and that may

                # involve rewriting ancient history - which autopack tries to

                # avoid. Alternatively we could not group the data but treat

                # each of these as having a single revision, and thus add 

                # one revision for each to the total revision count, to get

                # a matching distribution.

                continue

            existing_packs.append((revision_count, transport_and_name))

        pack_operations = self.plan_autopack_combinations(

            existing_packs, pack_distribution)

        self._execute_pack_operations(pack_operations)

        return True

    def create_pack_from_packs(self, revision_index_map, inventory_index_map,

        text_index_map, signature_index_map, suffix, revision_ids=None):

        """Create a new pack by reading data from other packs.

        This does little more than a bulk copy of data. One key difference

        is that data with the same item key across multiple packs is elided

        from the output. The new pack is written into the current pack store

        along with its indices, and the name added to the pack names. The 

        source packs are not altered.

        :param revision_index_map: A revision index map.

        :param inventory_index_map: A inventory index map.

        :param text_index_map: A text index map.

        :param signature_index_map: A signature index map.

        :param revision_ids: Either None, to copy all data, or a list

            of revision_ids to limit the copied data to the data they

            introduced.

        :return: A Pack object, or None if nothing was copied.

        """

        # open a pack - using the same name as the last temporary file

        # - which has already been flushed, so its safe.

        # XXX: - duplicate code warning with start_write_group; fix before

        #      considering 'done'.

        if getattr(self.repo, '_open_pack_tuple', None) is not None:

            raise errors.BzrError('call to create_pack_from_packs while '

                'another pack is being written.')

        if revision_ids is not None and len(revision_ids) == 0:

            # silly fetch request.

            return None

        random_name = self.repo.control_files._lock.nonce + suffix

        if 'fetch' in debug.debug_flags:

            plain_pack_list = ['%s%s' % (transport.base, name) for

                transport, name in revision_index_map.itervalues()]

            if revision_ids is not None:

                rev_count = len(revision_ids)

            else:

                rev_count = 'all'

            mutter('%s: create_pack: creating pack from source packs: '

                '%s%s %s revisions wanted %s t=0',

                time.ctime(), self.repo._upload_transport.base, random_name,

                plain_pack_list, rev_count)

            start_time = time.time()

        write_stream = self.repo._upload_transport.open_write_stream(random_name)

        if 'fetch' in debug.debug_flags:

            mutter('%s: create_pack: pack stream open: %s%s t+%6.3fs',

                time.ctime(), self.repo._upload_transport.base, random_name,

                time.time() - start_time)

        pack_hash = md5.new()

        buffer = []

        def write_data(bytes, update=pack_hash.update, write=write_stream.write):

            buffer.append(bytes)

            if len(buffer) == 640:

                bytes = ''.join(buffer)

                write(bytes)

                update(bytes)

                del buffer[:]

        writer = pack.ContainerWriter(write_data)

        writer.begin()

        # open new indices

        revision_index = InMemoryGraphIndex(reference_lists=1)

        inv_index = InMemoryGraphIndex(reference_lists=2)

        text_index = InMemoryGraphIndex(reference_lists=2, key_elements=2)

        signature_index = InMemoryGraphIndex(reference_lists=0)

        # select revisions

        if revision_ids:

            revision_keys = [(revision_id,) for revision_id in revision_ids]

        else:

            revision_keys = None

        revision_nodes = self._index_contents(revision_index_map, revision_keys)

        # copy revision keys and adjust values

        list(self._copy_nodes_graph(revision_nodes, revision_index_map, writer,

            revision_index))

        if 'fetch' in debug.debug_flags:

            mutter('%s: create_pack: revisions copied: %s%s %d items t+%6.3fs',

                time.ctime(), self.repo._upload_transport.base, random_name,

                revision_index.key_count(),

                time.time() - start_time)

        # select inventory keys

        inv_keys = revision_keys # currently the same keyspace

        inv_nodes = self._index_contents(inventory_index_map, inv_keys)

        # copy inventory keys and adjust values

        # XXX: Should be a helper function to allow different inv representation

        # at this point.

        inv_lines = self._copy_nodes_graph(inv_nodes, inventory_index_map,

            writer, inv_index, output_lines=True)

        if revision_ids:

            fileid_revisions = self.repo._find_file_ids_from_xml_inventory_lines(

                inv_lines, revision_ids)

            text_filter = []

            for fileid, file_revids in fileid_revisions.iteritems():

                text_filter.extend(

                    [(fileid, file_revid) for file_revid in file_revids])

        else:

            list(inv_lines)

            text_filter = None

        if 'fetch' in debug.debug_flags:

            mutter('%s: create_pack: inventories copied: %s%s %d items t+%6.3fs',

                time.ctime(), self.repo._upload_transport.base, random_name,

                inv_index.key_count(),

                time.time() - start_time)

        # select text keys

        text_nodes = self._index_contents(text_index_map, text_filter)

        # copy text keys and adjust values

        list(self._copy_nodes_graph(text_nodes, text_index_map, writer,

            text_index))

        if 'fetch' in debug.debug_flags:

            mutter('%s: create_pack: file texts copied: %s%s %d items t+%6.3fs',

                time.ctime(), self.repo._upload_transport.base, random_name,

                text_index.key_count(),

                time.time() - start_time)

        # select signature keys

        signature_filter = revision_keys # same keyspace

        signature_nodes = self._index_contents(signature_index_map,

            signature_filter)

        # copy signature keys and adjust values

        self._copy_nodes(signature_nodes, signature_index_map, writer, signature_index)

        if 'fetch' in debug.debug_flags:

            mutter('%s: create_pack: revision signatures copied: %s%s %d items t+%6.3fs',

                time.ctime(), self.repo._upload_transport.base, random_name,

                signature_index.key_count(),

                time.time() - start_time)

        # finish the pack

        writer.end()

        if len(buffer):

            bytes = ''.join(buffer)

            write_stream.write(bytes)

            pack_hash.update(bytes)

        new_name = pack_hash.hexdigest()

        # if nothing has been written, discard the new pack.

        if 0 == sum((revision_index.key_count(),

            inv_index.key_count(),

            text_index.key_count(),

            signature_index.key_count(),

            )):

            self.repo._upload_transport.delete(random_name)

            return None

        result = Pack()

        result.name = new_name

        result.transport = self.repo._upload_transport.clone('../packs/')

        # write indices

        index_transport = self.repo._upload_transport.clone('../indices')

        rev_index_name = self.repo._revision_store.name_to_revision_index_name(new_name)

        revision_index_length = index_transport.put_file(rev_index_name,

            revision_index.finish())

        if 'fetch' in debug.debug_flags:

            # XXX: size might be interesting?

            mutter('%s: create_pack: wrote revision index: %s%s t+%6.3fs',

                time.ctime(), self.repo._upload_transport.base, random_name,

                time.time() - start_time)

        inv_index_name = self.repo._inv_thunk.name_to_inv_index_name(new_name)

        inventory_index_length = index_transport.put_file(inv_index_name,

            inv_index.finish())

        if 'fetch' in debug.debug_flags:

            # XXX: size might be interesting?

            mutter('%s: create_pack: wrote inventory index: %s%s t+%6.3fs',

                time.ctime(), self.repo._upload_transport.base, random_name,

                time.time() - start_time)

        text_index_name = self.repo.weave_store.name_to_text_index_name(new_name)

        text_index_length = index_transport.put_file(text_index_name,

            text_index.finish())

        if 'fetch' in debug.debug_flags:

            # XXX: size might be interesting?

            mutter('%s: create_pack: wrote file texts index: %s%s t+%6.3fs',

                time.ctime(), self.repo._upload_transport.base, random_name,

                time.time() - start_time)

        signature_index_name = self.repo._revision_store.name_to_signature_index_name(new_name)

        signature_index_length = index_transport.put_file(signature_index_name,

            signature_index.finish())

        if 'fetch' in debug.debug_flags:

            # XXX: size might be interesting?

            mutter('%s: create_pack: wrote revision signatures index: %s%s t+%6.3fs',

                time.ctime(), self.repo._upload_transport.base, random_name,

                time.time() - start_time)

        # add to name

        self.allocate(new_name, revision_index_length, inventory_index_length,

            text_index_length, signature_index_length)

        # rename into place. XXX: should rename each index too rather than just

        # uploading blind under the chosen name.

        write_stream.close()

        self.repo._upload_transport.rename(random_name, '../packs/' + new_name + '.pack')

        if 'fetch' in debug.debug_flags:

            # XXX: size might be interesting?

            mutter('%s: create_pack: pack renamed into place: %s%s->%s%s t+%6.3fs',

                time.ctime(), self.repo._upload_transport.base, random_name,

                result.transport, result.name,

                time.time() - start_time)

        result.revision_index = revision_index

        result.inventory_index = inv_index

        result.text_index = text_index

        result.signature_index = signature_index

        if 'fetch' in debug.debug_flags:

            # XXX: size might be interesting?

            mutter('%s: create_pack: finished: %s%s t+%6.3fs',

                time.ctime(), self.repo._upload_transport.base, random_name,

                time.time() - start_time)

        return result

    def _execute_pack_operations(self, pack_operations):

        """Execute a series of pack operations.

        :param pack_operations: A list of [revision_count, packs_to_combine].

        :return: None.

        """

        for revision_count, pack_details in pack_operations:

            # we may have no-ops from the setup logic

            if len(pack_details) == 0:

                continue

            # have a progress bar?

            self._combine_packs(pack_details)

            for pack_detail in pack_details:

                self._remove_pack_by_name(pack_detail[1])

        # record the newly available packs and stop advertising the old

        # packs

        self.save()

        # move the old packs out of the way

        for revision_count, pack_details in pack_operations:

            self._obsolete_packs(pack_details)

    def pack(self):

        """Pack the pack collection totally."""

        self.ensure_loaded()

        try:

            total_packs = len(self._names)

            if total_packs < 2:

                return

            if self.repo._revision_all_indices is None:

                # trigger creation of the all revision index.

                self.repo._revision_store.get_revision_file(self.repo.get_transaction())

            total_revisions = self.repo._revision_all_indices.key_count()

            # XXX: the following may want to be a class, to pack with a given

            # policy.

            mutter('Packing repository %s, which has %d pack files, '

                'containing %d revisions into 1 packs.', self, total_packs,

                total_revisions)

            # determine which packs need changing

            pack_distribution = [1]

            pack_operations = [[0, []]]

            for index, transport_and_name in self.repo._revision_pack_map.iteritems():

                if index is None:

                    continue

                revision_count = index.key_count()

                pack_operations[-1][0] += revision_count

                pack_operations[-1][1].append(transport_and_name)

            self._execute_pack_operations(pack_operations)

        finally:

            if not self.repo.is_in_write_group():

                self.reset()

    def plan_autopack_combinations(self, existing_packs, pack_distribution):

        if len(existing_packs) <= len(pack_distribution):

            return []

        existing_packs.sort(reverse=True)

        pack_operations = [[0, []]]

        # plan out what packs to keep, and what to reorganise

        while len(existing_packs):

            # take the largest pack, and if its less than the head of the

            # distribution chart we will include its contents in the new pack for

            # that position. If its larger, we remove its size from the

            # distribution chart

            next_pack_rev_count, next_pack_details = existing_packs.pop(0)

            if next_pack_rev_count >= pack_distribution[0]:

                # this is already packed 'better' than this, so we can

                # not waste time packing it.

                while next_pack_rev_count > 0:

                    next_pack_rev_count -= pack_distribution[0]

                    if next_pack_rev_count >= 0:

                        # more to go

                        del pack_distribution[0]

                    else:

                        # didn't use that entire bucket up

                        pack_distribution[0] = -next_pack_rev_count

            else:

                # add the revisions we're going to add to the next output pack

                pack_operations[-1][0] += next_pack_rev_count

                # allocate this pack to the next pack sub operation

                pack_operations[-1][1].append(next_pack_details)

                if pack_operations[-1][0] >= pack_distribution[0]:

                    # this pack is used up, shift left.

                    del pack_distribution[0]

                    pack_operations.append([0, []])

        return pack_operations

    def _combine_packs(self, pack_details):

        """Combine the data from the packs listed in pack_details.

        This does little more than a bulk copy of data. One key difference

        is that data with the same item key across multiple packs is elided

        from the output. The new pack is written into the current pack store

        along with its indices, and the name added to the pack names. The 

        source packs are not altered.

        :param pack_details: A list of tuples with the transport and pack name

            in use.

        :return: None

        """

        # select revision keys

        revision_index_map = self._revision_index_map(pack_details)

        # select inventory keys

        inv_index_map = self._inv_index_map(pack_details)

        # select text keys

        text_index_map = self._text_index_map(pack_details)

        # select signature keys

        signature_index_map = self._signature_index_map(pack_details)

        self.create_pack_from_packs(revision_index_map, inv_index_map,

            text_index_map, signature_index_map, '.autopack')

    def _copy_nodes(self, nodes, index_map, writer, write_index):

        # plan a readv on each source pack:

        # group by pack

        nodes = sorted(nodes)

        # how to map this into knit.py - or knit.py into this?

        # we don't want the typical knit logic, we want grouping by pack

        # at this point - perhaps a helper library for the following code 

        # duplication points?

        request_groups = {}

        for index, key, value in nodes:

            if index not in request_groups:

                request_groups[index] = []

            request_groups[index].append((key, value))

        for index, items in request_groups.iteritems():

            pack_readv_requests = []

            for key, value in items:

                # ---- KnitGraphIndex.get_position

                bits = value[1:].split(' ')

                offset, length = int(bits[0]), int(bits[1])

                pack_readv_requests.append((offset, length, (key, value[0])))

            # linear scan up the pack

            pack_readv_requests.sort()

            # copy the data

            transport, path = index_map[index]

            reader = pack.make_readv_reader(transport, path,

                [offset[0:2] for offset in pack_readv_requests])

            for (names, read_func), (_1, _2, (key, eol_flag)) in \

                izip(reader.iter_records(), pack_readv_requests):

                raw_data = read_func(None)

                pos, size = writer.add_bytes_record(raw_data, names)

                write_index.add_node(key, eol_flag + "%d %d" % (pos, size))

    def _copy_nodes_graph(self, nodes, index_map, writer, write_index,

        output_lines=False):

        """Copy knit nodes between packs.

        :param output_lines: Return lines present in the copied data as

            an iterator.

        """

        # for record verification

        knit_data = _KnitData(None)

        # for line extraction when requested (inventories only)

        if output_lines:

            factory = knit.KnitPlainFactory()

        # plan a readv on each source pack:

        # group by pack

        nodes = sorted(nodes)

        # how to map this into knit.py - or knit.py into this?

        # we don't want the typical knit logic, we want grouping by pack

        # at this point - perhaps a helper library for the following code 

        # duplication points?

        request_groups = {}

        for index, key, value, references in nodes:

            if index not in request_groups:

                request_groups[index] = []

            request_groups[index].append((key, value, references))

        for index, items in request_groups.iteritems():

            pack_readv_requests = []

            for key, value, references in items:

                # ---- KnitGraphIndex.get_position

                bits = value[1:].split(' ')

                offset, length = int(bits[0]), int(bits[1])

                pack_readv_requests.append((offset, length, (key, value[0], references)))

            # linear scan up the pack

            pack_readv_requests.sort()

            # copy the data

            transport, path = index_map[index]

            reader = pack.make_readv_reader(transport, path,

                [offset[0:2] for offset in pack_readv_requests])

            for (names, read_func), (_1, _2, (key, eol_flag, references)) in \

                izip(reader.iter_records(), pack_readv_requests):

                raw_data = read_func(None)

                if output_lines:

                    # read the entire thing

                    content, _ = knit_data._parse_record(key[-1], raw_data)

                    if len(references[-1]) == 0:

                        line_iterator = factory.get_fulltext_content(content)

                    else:

                        line_iterator = factory.get_linedelta_content(content)

                    for line in line_iterator:

                        yield line

                else:

                    # check the header only

                    df, _ = knit_data._parse_record_header(key[-1], raw_data)

                    df.close()

                pos, size = writer.add_bytes_record(raw_data, names)

                write_index.add_node(key, eol_flag + "%d %d" % (pos, size), references)

    def ensure_loaded(self):

        if self._names is None:

            self._names = {}

            for index, key, value in \

                GraphIndex(self.transport, 'pack-names').iter_all_entries():

                name = key[0]

                sizes = [int(digits) for digits in value.split(' ')]

                self._names[name] = sizes

    def allocate(self, name, revision_index_length, inventory_index_length,

        text_index_length, signature_index_length):

        """Allocate name in the list of packs.

        :param name: The basename - e.g. the md5 hash hexdigest.

        :param revision_index_length: The length of the revision index in

            bytes.

        :param inventory_index_length: The length of the inventory index in

            bytes.

        :param text_index_length: The length of the text index in bytes.

        :param signature_index_length: The length of the signature index in

            bytes.

        """

        self.ensure_loaded()

        if name in self._names:

            raise errors.DuplicateKey(name)

        self._names[name] = (revision_index_length, inventory_index_length,

            text_index_length, signature_index_length)

    def _make_index_map(self, suffix):

        """Return information on existing indexes.

        :param suffix: Index suffix added to pack name.

        :returns: (pack_map, indices) where indices is a list of GraphIndex 

        objects, and pack_map is a mapping from those objects to the 

        pack tuple they describe.

        """

        indices = []

        pack_map = {}

        self.ensure_loaded()

        for name in self.names():

            # TODO: maybe this should expose size to us  to allow

            # sorting of the indices for better performance ?

            index_name = name + suffix

            new_index = GraphIndex(self._index_transport, index_name)

            indices.append(new_index)

            pack_map[new_index] = self.repo._pack_tuple(name)

        return pack_map, indices

    def _max_pack_count(self, total_revisions):

        """Return the maximum number of packs to use for total revisions.

        :param total_revisions: The total number of revisions in the

            repository.

        """

        if not total_revisions:

            return 1

        digits = str(total_revisions)