comparison mercurial/bundle2.py @ 35046:241d9caca11e

bundle2: use os.SEEK_* constants

Constants make code easier to read than magic numbers.

I also threw in an explicit argument in a caller to further
increase code comprehension.

Differential Revision: https://phab.mercurial-scm.org/D1370

35045:b0262b25ab48

"""

from __future__ import absolute_import, division

import errno
import re
import string
import struct
import sys

            itr = enumerate(self.unbundler.iterparts())
            for count, p in itr:
                self.count = count
                self.current = p
                yield p
                p.seek(0, 2)
                self.current = None
        self.iterator = func()
        return self.iterator

    def __exit__(self, type, exc, tb):

            # re-raise the original error.
            seekerror = False
            try:
                if self.current:
                    # consume the part content to not corrupt the stream.
                    self.current.seek(0, 2)

                for part in self.iterator:
                    # consume the bundle content
                    part.seek(0, 2)
            except Exception:
                seekerror = True

            # Small hack to let caller code distinguish exceptions from bundle2
            # processing from processing the old format. This is mostly needed

            part = unbundlepart(self.ui, headerblock, self._fp)
            yield part
            # Seek to the end of the part to force it's consumption so the next
            # part can be read. But then seek back to the beginning so the
            # code consuming this generator has a part that starts at 0.
            part.seek(0, 2)
            part.seek(0)
            headerblock = self._readpartheader()
        indebug(self.ui, 'end of bundle2 stream')

    def _readpartheader(self):
        """reads a part header size and return the bytes blob

        except (SystemExit, KeyboardInterrupt):
            hardabort = True
            raise
        finally:
            if not hardabort:
                part.seek(0, 2)
        self.ui.debug('bundle2-input-stream-interrupt:'
                      ' closing out of band context\n')

class interruptoperation(object):
    """A limited operation to be use by part handler during interruption

        return data

    def tell(self):
        return self._pos

    def seek(self, offset, whence=0):
        if whence == 0:
            newpos = offset
        elif whence == 1:
            newpos = self._pos + offset
        elif whence == 2:
            if not self.consumed:
                self.read()
            newpos = self._chunkindex[-1][0] - offset
        else:
            raise ValueError('Unknown whence value: %r' % (whence,))

35046:241d9caca11e

"""

from __future__ import absolute_import, division

import errno
import os
import re
import string
import struct
import sys

            itr = enumerate(self.unbundler.iterparts())
            for count, p in itr:
                self.count = count
                self.current = p
                yield p
                p.seek(0, os.SEEK_END)
                self.current = None
        self.iterator = func()
        return self.iterator

    def __exit__(self, type, exc, tb):

            # re-raise the original error.
            seekerror = False
            try:
                if self.current:
                    # consume the part content to not corrupt the stream.
                    self.current.seek(0, os.SEEK_END)

                for part in self.iterator:
                    # consume the bundle content
                    part.seek(0, os.SEEK_END)
            except Exception:
                seekerror = True

            # Small hack to let caller code distinguish exceptions from bundle2
            # processing from processing the old format. This is mostly needed

            part = unbundlepart(self.ui, headerblock, self._fp)
            yield part
            # Seek to the end of the part to force it's consumption so the next
            # part can be read. But then seek back to the beginning so the
            # code consuming this generator has a part that starts at 0.
            part.seek(0, os.SEEK_END)
            part.seek(0, os.SEEK_SET)
            headerblock = self._readpartheader()
        indebug(self.ui, 'end of bundle2 stream')

    def _readpartheader(self):
        """reads a part header size and return the bytes blob

        except (SystemExit, KeyboardInterrupt):
            hardabort = True
            raise
        finally:
            if not hardabort:
                part.seek(0, os.SEEK_END)
        self.ui.debug('bundle2-input-stream-interrupt:'
                      ' closing out of band context\n')

class interruptoperation(object):
    """A limited operation to be use by part handler during interruption

        return data

    def tell(self):
        return self._pos

    def seek(self, offset, whence=os.SEEK_SET):
        if whence == os.SEEK_SET:
            newpos = offset
        elif whence == os.SEEK_CUR:
            newpos = self._pos + offset
        elif whence == os.SEEK_END:
            if not self.consumed:
                self.read()
            newpos = self._chunkindex[-1][0] - offset
        else:
            raise ValueError('Unknown whence value: %r' % (whence,))