570 class mergestate(_mergestate_base):

   571 

   572     statepathv1 = b'merge/state'

   573     statepathv2 = b'merge/state2'

   574 

   575     @staticmethod

   576     def clean(repo):

   577         """Initialize a brand new merge state, removing any existing state on

   578         disk."""

   579         ms = mergestate(repo)

   580         ms.reset()

   581         return ms

   582 

   583     @staticmethod

   584     def read(repo):

   585         """Initialize the merge state, reading it from disk."""

   586         ms = mergestate(repo)

   587         ms._read()

   588         return ms

   589 

   590     def _read(self):

   591         """Analyse each record content to restore a serialized state from disk

   592 

   593         This function process "record" entry produced by the de-serialization

   594         of on disk file.

   595         """

   596         self._mdstate = MERGE_DRIVER_STATE_SUCCESS

   597         unsupported = set()

   598         records = self._readrecords()

   599         for rtype, record in records:

   600             if rtype == RECORD_LOCAL:

   601                 self._local = bin(record)

   602             elif rtype == RECORD_OTHER:

   603                 self._other = bin(record)

   604             elif rtype == RECORD_MERGE_DRIVER_STATE:

   605                 bits = record.split(b'\0', 1)

   606                 mdstate = bits[1]

   607                 if len(mdstate) != 1 or mdstate not in (

   608                     MERGE_DRIVER_STATE_UNMARKED,

   609                     MERGE_DRIVER_STATE_MARKED,

   610                     MERGE_DRIVER_STATE_SUCCESS,

   611                 ):

   612                     # the merge driver should be idempotent, so just rerun it

   613                     mdstate = MERGE_DRIVER_STATE_UNMARKED

   614 

   615                 self._readmergedriver = bits[0]

   616                 self._mdstate = mdstate

   617             elif rtype in (

   618                 RECORD_MERGED,

   619                 RECORD_CHANGEDELETE_CONFLICT,

   620                 RECORD_PATH_CONFLICT,

   621                 RECORD_MERGE_DRIVER_MERGE,

   622                 LEGACY_RECORD_RESOLVED_OTHER,

   623             ):

   624                 bits = record.split(b'\0')

   625                 # merge entry type MERGE_RECORD_MERGED_OTHER is deprecated

   626                 # and we now store related information in _stateextras, so

   627                 # lets write to _stateextras directly

   628                 if bits[1] == MERGE_RECORD_MERGED_OTHER:

   629                     self._stateextras[bits[0]][b'filenode-source'] = b'other'

   630                 else:

   631                     self._state[bits[0]] = bits[1:]

   632             elif rtype == RECORD_FILE_VALUES:

   633                 filename, rawextras = record.split(b'\0', 1)

   634                 extraparts = rawextras.split(b'\0')

   635                 extras = {}

   636                 i = 0

   637                 while i < len(extraparts):

   638                     extras[extraparts[i]] = extraparts[i + 1]

   639                     i += 2

   640 

   641                 self._stateextras[filename] = extras

   642             elif rtype == RECORD_LABELS:

   643                 labels = record.split(b'\0', 2)

   644                 self._labels = [l for l in labels if len(l) > 0]

   645             elif not rtype.islower():

   646                 unsupported.add(rtype)

   647 

   648         if unsupported:

   649             raise error.UnsupportedMergeRecords(unsupported)

   650 

   651     def _readrecords(self):

   652         """Read merge state from disk and return a list of record (TYPE, data)

   653 

   654         We read data from both v1 and v2 files and decide which one to use.

   655 

   656         V1 has been used by version prior to 2.9.1 and contains less data than

   657         v2. We read both versions and check if no data in v2 contradicts

   658         v1. If there is not contradiction we can safely assume that both v1

   659         and v2 were written at the same time and use the extract data in v2. If

   660         there is contradiction we ignore v2 content as we assume an old version

   661         of Mercurial has overwritten the mergestate file and left an old v2

   662         file around.

   663 

   664         returns list of record [(TYPE, data), ...]"""

   665         v1records = self._readrecordsv1()

   666         v2records = self._readrecordsv2()

   667         if self._v1v2match(v1records, v2records):

   668             return v2records

   669         else:

   670             # v1 file is newer than v2 file, use it

   671             # we have to infer the "other" changeset of the merge

   672             # we cannot do better than that with v1 of the format

   673             mctx = self._repo[None].parents()[-1]

   674             v1records.append((RECORD_OTHER, mctx.hex()))

   675             # add place holder "other" file node information

   676             # nobody is using it yet so we do no need to fetch the data

   677             # if mctx was wrong `mctx[bits[-2]]` may fails.

   678             for idx, r in enumerate(v1records):

   679                 if r[0] == RECORD_MERGED:

   680                     bits = r[1].split(b'\0')

   681                     bits.insert(-2, b'')

   682                     v1records[idx] = (r[0], b'\0'.join(bits))

   683             return v1records

   684 

   685     def _v1v2match(self, v1records, v2records):

   686         oldv2 = set()  # old format version of v2 record

   687         for rec in v2records:

   688             if rec[0] == RECORD_LOCAL:

   689                 oldv2.add(rec)

   690             elif rec[0] == RECORD_MERGED:

   691                 # drop the onode data (not contained in v1)

   692                 oldv2.add((RECORD_MERGED, _droponode(rec[1])))

   693         for rec in v1records:

   694             if rec not in oldv2:

   695                 return False

   696         else:

   697             return True

   698 

   699     def _readrecordsv1(self):

   700         """read on disk merge state for version 1 file

   701 

   702         returns list of record [(TYPE, data), ...]

   703 

   704         Note: the "F" data from this file are one entry short

   705               (no "other file node" entry)

   706         """

   707         records = []

   708         try:

   709             f = self._repo.vfs(self.statepathv1)

   710             for i, l in enumerate(f):

   711                 if i == 0:

   712                     records.append((RECORD_LOCAL, l[:-1]))

   713                 else:

   714                     records.append((RECORD_MERGED, l[:-1]))

   715             f.close()

   716         except IOError as err:

   717             if err.errno != errno.ENOENT:

   718                 raise

   719         return records

   720 

   721     def _readrecordsv2(self):

   722         """read on disk merge state for version 2 file

   723 

   724         This format is a list of arbitrary records of the form:

   725 

   726           [type][length][content]

   727 

   728         `type` is a single character, `length` is a 4 byte integer, and

   729         `content` is an arbitrary byte sequence of length `length`.

   730 

   731         Mercurial versions prior to 3.7 have a bug where if there are

   732         unsupported mandatory merge records, attempting to clear out the merge

   733         state with hg update --clean or similar aborts. The 't' record type

   734         works around that by writing out what those versions treat as an

   735         advisory record, but later versions interpret as special: the first

   736         character is the 'real' record type and everything onwards is the data.

   737 

   738         Returns list of records [(TYPE, data), ...]."""

   739         records = []

   740         try:

   741             f = self._repo.vfs(self.statepathv2)

   742             data = f.read()

   743             off = 0

   744             end = len(data)

   745             while off < end:

   746                 rtype = data[off : off + 1]

   747                 off += 1

   748                 length = _unpack(b'>I', data[off : (off + 4)])[0]

   749                 off += 4

   750                 record = data[off : (off + length)]

   751                 off += length

   752                 if rtype == RECORD_OVERRIDE:

   753                     rtype, record = record[0:1], record[1:]

   754                 records.append((rtype, record))

   755             f.close()

   756         except IOError as err:

   757             if err.errno != errno.ENOENT:

   758                 raise

   759         return records

   760 

   761     def _writerecords(self, records):

   762         """Write current state on disk (both v1 and v2)"""

   763         self._writerecordsv1(records)

   764         self._writerecordsv2(records)

   765 

   766     def _writerecordsv1(self, records):

   767         """Write current state on disk in a version 1 file"""

   768         f = self._repo.vfs(self.statepathv1, b'wb')

   769         irecords = iter(records)

   770         lrecords = next(irecords)

   771         assert lrecords[0] == RECORD_LOCAL

   772         f.write(hex(self._local) + b'\n')

   773         for rtype, data in irecords:

   774             if rtype == RECORD_MERGED:

   775                 f.write(b'%s\n' % _droponode(data))

   776         f.close()

   777 

   778     def _writerecordsv2(self, records):

   779         """Write current state on disk in a version 2 file

   780 

   781         See the docstring for _readrecordsv2 for why we use 't'."""

   782         # these are the records that all version 2 clients can read

   783         allowlist = (RECORD_LOCAL, RECORD_OTHER, RECORD_MERGED)

   784         f = self._repo.vfs(self.statepathv2, b'wb')

   785         for key, data in records:

   786             assert len(key) == 1

   787             if key not in allowlist:

   788                 key, data = RECORD_OVERRIDE, b'%s%s' % (key, data)

   789             format = b'>sI%is' % len(data)

   790             f.write(_pack(format, key, len(data), data))

   791         f.close()

   792 

   793     def _make_backup(self, fctx, localkey):

   794         self._repo.vfs.write(b'merge/' + localkey, fctx.data())

   795 

   796     def _restore_backup(self, fctx, localkey, flags):

   797         with self._repo.vfs(b'merge/' + localkey) as f:

   798             fctx.write(f.read(), flags)

   799 

   800     def reset(self):

   801         shutil.rmtree(self._repo.vfs.join(b'merge'), True)

   802 

   803