( )⚙ D1792 py3: use node.hex(h.digest()) instead of h.hexdigest()

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D1792

py3: use node.hex(h.digest()) instead of h.hexdigest()
ClosedPublic

Authored by pulkit on Dec 28 2017, 7:48 PM.

Details

Reviewers
durin42
Group Reviewers
hg-reviewers
Commits
rHG72b91f905065: py3: use node.hex(h.digest()) instead of h.hexdigest()
Summary

hashlib.sha1.hexdigest() returns str on Python 3.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

pulkit created this revision.Dec 28 2017, 7:48 PM
durin42 accepted this revision.Jan 10 2018, 5:56 PM
This revision is now accepted and ready to land.Jan 10 2018, 5:56 PM
Closed by commit rHG72b91f905065: py3: use node.hex(h.digest()) instead of h.hexdigest() (authored by pulkit). · Explain WhyJan 10 2018, 6:03 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 4775

mercurial/chgserver.py

from .i18n import _ from .i18n import _
from . import ( from . import (
commandserver, commandserver,
encoding, encoding,
error, error,
extensions, extensions,
node,
pycompat, pycompat,
util, util,
) )
_log = commandserver.log _log = commandserver.log
def _hashlist(items): def _hashlist(items):
"""return sha1 hexdigest for a list""" """return sha1 hexdigest for a list"""
return hashlib.sha1(str(items)).hexdigest() return node.hex(hashlib.sha1(str(items)).digest())
# sensitive config sections affecting confighash # sensitive config sections affecting confighash
_configsections = [ _configsections = [
'alias', # affects global state commands.table 'alias', # affects global state commands.table
'eol', # uses setconfig('eol', ...) 'eol', # uses setconfig('eol', ...)
'extdiff', # uisetup will register new commands 'extdiff', # uisetup will register new commands
'extensions', 'extensions',
] ]

mercurial/hg.py

else: else:
ui.status(_('(not using pooled storage: ' ui.status(_('(not using pooled storage: '
'remote appears to be empty)\n')) 'remote appears to be empty)\n'))
except error.RepoLookupError: except error.RepoLookupError:
ui.status(_('(not using pooled storage: ' ui.status(_('(not using pooled storage: '
'unable to resolve identity of remote)\n')) 'unable to resolve identity of remote)\n'))
elif sharenamemode == 'remote': elif sharenamemode == 'remote':
sharepath = os.path.join( sharepath = os.path.join(
sharepool, hashlib.sha1(source).hexdigest()) sharepool, node.hex(hashlib.sha1(source).digest()))
else: else:
raise error.Abort(_('unknown share naming mode: %s') % raise error.Abort(_('unknown share naming mode: %s') %
sharenamemode) sharenamemode)
if sharepath: if sharepath:
return clonewithshare(ui, peeropts, sharepath, source, srcpeer, return clonewithshare(ui, peeropts, sharepath, source, srcpeer,
dest, pull=pull, rev=rev, update=update, dest, pull=pull, rev=rev, update=update,
stream=stream) stream=stream)

mercurial/keepalive.py

import errno import errno
import hashlib import hashlib
import socket import socket
import sys import sys
import threading import threading
from .i18n import _ from .i18n import _
from . import ( from . import (
node,
pycompat, pycompat,
urllibcompat, urllibcompat,
util, util,
) )
httplib = util.httplib httplib = util.httplib
urlerr = util.urlerr urlerr = util.urlerr
urlreq = util.urlreq urlreq = util.urlreq
# first fetch the file with the normal http handler # first fetch the file with the normal http handler
opener = urlreq.buildopener() opener = urlreq.buildopener()
urlreq.installopener(opener) urlreq.installopener(opener)
fo = urlreq.urlopen(url) fo = urlreq.urlopen(url)
foo = fo.read() foo = fo.read()
fo.close() fo.close()
m = md5(foo) m = md5(foo)
print(format % ('normal urllib', m.hexdigest())) print(format % ('normal urllib', node.hex(m.digest())))
# now install the keepalive handler and try again # now install the keepalive handler and try again
opener = urlreq.buildopener(HTTPHandler()) opener = urlreq.buildopener(HTTPHandler())
urlreq.installopener(opener) urlreq.installopener(opener)
fo = urlreq.urlopen(url) fo = urlreq.urlopen(url)
foo = fo.read() foo = fo.read()
fo.close() fo.close()
m = md5(foo) m = md5(foo)
print(format % ('keepalive read', m.hexdigest())) print(format % ('keepalive read', node.hex(m.digest())))
fo = urlreq.urlopen(url) fo = urlreq.urlopen(url)
foo = '' foo = ''
while True: while True:
f = fo.readline() f = fo.readline()
if f: if f:
foo = foo + f foo = foo + f
else: else:
break break
fo.close() fo.close()
m = md5(foo) m = md5(foo)
print(format % ('keepalive readline', m.hexdigest())) print(format % ('keepalive readline', node.hex(m.digest())))
def comp(N, url): def comp(N, url):
print(' making %i connections to:\n %s' % (N, url)) print(' making %i connections to:\n %s' % (N, url))
util.stdout.write(' first using the normal urllib handlers') util.stdout.write(' first using the normal urllib handlers')
# first use normal opener # first use normal opener
opener = urlreq.buildopener() opener = urlreq.buildopener()
urlreq.installopener(opener) urlreq.installopener(opener)

mercurial/patch.py

added, removed and copy to start with it.''' added, removed and copy to start with it.'''
def gitindex(text): def gitindex(text):
if not text: if not text:
text = "" text = ""
l = len(text) l = len(text)
s = hashlib.sha1('blob %d\0' % l) s = hashlib.sha1('blob %d\0' % l)
s.update(text) s.update(text)
return s.hexdigest() return hex(s.digest())
if opts.noprefix: if opts.noprefix:
aprefix = bprefix = '' aprefix = bprefix = ''
else: else:
aprefix = 'a/' aprefix = 'a/'
bprefix = 'b/' bprefix = 'b/'
def diffline(f, revs): def diffline(f, revs):

mercurial/sparse.py

# sparse.py - functionality for sparse checkouts # sparse.py - functionality for sparse checkouts
# #
# Copyright 2014 Facebook, Inc. # Copyright 2014 Facebook, Inc.
# #
# This software may be used and distributed according to the terms of the # This software may be used and distributed according to the terms of the
# GNU General Public License version 2 or any later version. # GNU General Public License version 2 or any later version.
from __future__ import absolute_import from __future__ import absolute_import
import collections import collections
import hashlib import hashlib
import os import os
from .i18n import _ from .i18n import _
from .node import nullid from .node import (
hex,
nullid,
)
from . import ( from . import (
error, error,
match as matchmod, match as matchmod,
merge as mergemod, merge as mergemod,
pathutil, pathutil,
pycompat, pycompat,
scmutil, scmutil,
util, util,
signature = cache.get('signature') signature = cache.get('signature')
if includetemp: if includetemp:
tempsignature = cache.get('tempsignature') tempsignature = cache.get('tempsignature')
else: else:
tempsignature = '0' tempsignature = '0'
if signature is None or (includetemp and tempsignature is None): if signature is None or (includetemp and tempsignature is None):
signature = hashlib.sha1(repo.vfs.tryread('sparse')).hexdigest() signature = hex(hashlib.sha1(repo.vfs.tryread('sparse')).digest())
cache['signature'] = signature cache['signature'] = signature
if includetemp: if includetemp:
raw = repo.vfs.tryread('tempsparse') raw = repo.vfs.tryread('tempsparse')
tempsignature = hashlib.sha1(raw).hexdigest() tempsignature = hex(hashlib.sha1(raw).digest())
cache['tempsignature'] = tempsignature cache['tempsignature'] = tempsignature
return '%s %s' % (signature, tempsignature) return '%s %s' % (signature, tempsignature)
def writeconfig(repo, includes, excludes, profiles): def writeconfig(repo, includes, excludes, profiles):
"""Write the sparse config file given a sparse configuration.""" """Write the sparse config file given a sparse configuration."""
with repo.vfs('sparse', 'wb') as fh: with repo.vfs('sparse', 'wb') as fh:
for p in sorted(profiles): for p in sorted(profiles):

mercurial/sslutil.py

import hashlib import hashlib
import os import os
import re import re
import ssl import ssl
from .i18n import _ from .i18n import _
from . import ( from . import (
error, error,
node,
pycompat, pycompat,
util, util,
) )
# Python 2.7.9+ overhauled the built-in SSL/TLS features of Python. It added # Python 2.7.9+ overhauled the built-in SSL/TLS features of Python. It added
# support for TLS 1.1, TLS 1.2, SNI, system CA stores, etc. These features are # support for TLS 1.1, TLS 1.2, SNI, system CA stores, etc. These features are
# all exposed via the "ssl" module. # all exposed via the "ssl" module.
# #
ui.warn(_('warning: connection security to %s is disabled per current ' ui.warn(_('warning: connection security to %s is disabled per current '
'settings; communication is susceptible to eavesdropping ' 'settings; communication is susceptible to eavesdropping '
'and tampering\n') % host) 'and tampering\n') % host)
return return
# If a certificate fingerprint is pinned, use it and only it to # If a certificate fingerprint is pinned, use it and only it to
# validate the remote cert. # validate the remote cert.
peerfingerprints = { peerfingerprints = {
'sha1': hashlib.sha1(peercert).hexdigest(), 'sha1': node.hex(hashlib.sha1(peercert).digest()),
'sha256': hashlib.sha256(peercert).hexdigest(), 'sha256': node.hex(hashlib.sha256(peercert).digest()),
'sha512': hashlib.sha512(peercert).hexdigest(), 'sha512': node.hex(hashlib.sha512(peercert).digest()),
} }
def fmtfingerprint(s): def fmtfingerprint(s):
return ':'.join([s[x:x + 2] for x in range(0, len(s), 2)]) return ':'.join([s[x:x + 2] for x in range(0, len(s), 2)])
nicefingerprint = 'sha256:%s' % fmtfingerprint(peerfingerprints['sha256']) nicefingerprint = 'sha256:%s' % fmtfingerprint(peerfingerprints['sha256'])
if settings['certfingerprints']: if settings['certfingerprints']:

mercurial/store.py

import errno import errno
import hashlib import hashlib
import os import os
import stat import stat
from .i18n import _ from .i18n import _
from . import ( from . import (
error, error,
node,
policy, policy,
pycompat, pycompat,
util, util,
vfs as vfsmod, vfs as vfsmod,
) )
parsers = policy.importmod(r'parsers') parsers = policy.importmod(r'parsers')
path[i] = n[:-1] + "~%02x" % ord(n[-1:]) path[i] = n[:-1] + "~%02x" % ord(n[-1:])
return path return path
_maxstorepathlen = 120 _maxstorepathlen = 120
_dirprefixlen = 8 _dirprefixlen = 8
_maxshortdirslen = 8 * (_dirprefixlen + 1) - 4 _maxshortdirslen = 8 * (_dirprefixlen + 1) - 4
def _hashencode(path, dotencode): def _hashencode(path, dotencode):
digest = hashlib.sha1(path).hexdigest() digest = node.hex(hashlib.sha1(path).digest())
le = lowerencode(path[5:]).split('/') # skips prefix 'data/' or 'meta/' le = lowerencode(path[5:]).split('/') # skips prefix 'data/' or 'meta/'
parts = _auxencode(le, dotencode) parts = _auxencode(le, dotencode)
basename = parts[-1] basename = parts[-1]
_root, ext = os.path.splitext(basename) _root, ext = os.path.splitext(basename)
sdirs = [] sdirs = []
sdirslen = 0 sdirslen = 0
for p in parts[:-1]: for p in parts[:-1]:
d = p[:_dirprefixlen] d = p[:_dirprefixlen]

mercurial/subrepo.py

expandedpath = util.urllocalpath(util.expandpath(path)) expandedpath = util.urllocalpath(util.expandpath(path))
u = util.url(expandedpath) u = util.url(expandedpath)
if not u.scheme: if not u.scheme:
path = util.normpath(os.path.abspath(u.path)) path = util.normpath(os.path.abspath(u.path))
return path return path
def _getstorehashcachename(remotepath): def _getstorehashcachename(remotepath):
'''get a unique filename for the store hash cache of a remote repository''' '''get a unique filename for the store hash cache of a remote repository'''
return hashlib.sha1(_expandedabspath(remotepath)).hexdigest()[0:12] return node.hex(hashlib.sha1(_expandedabspath(remotepath)).digest())[0:12]
class SubrepoAbort(error.Abort): class SubrepoAbort(error.Abort):
"""Exception class used to avoid handling a subrepo error more than once""" """Exception class used to avoid handling a subrepo error more than once"""
def __init__(self, *args, **kw): def __init__(self, *args, **kw):
self.subrepo = kw.pop(r'subrepo', None) self.subrepo = kw.pop(r'subrepo', None)
self.cause = kw.pop(r'cause', None) self.cause = kw.pop(r'cause', None)
error.Abort.__init__(self, *args, **kw) error.Abort.__init__(self, *args, **kw)
This method is used to to detect when there are changes that may This method is used to to detect when there are changes that may
require a push to a given remote path.''' require a push to a given remote path.'''
# sort the files that will be hashed in increasing (likely) file size # sort the files that will be hashed in increasing (likely) file size
filelist = ('bookmarks', 'store/phaseroots', 'store/00changelog.i') filelist = ('bookmarks', 'store/phaseroots', 'store/00changelog.i')
yield '# %s\n' % _expandedabspath(remotepath) yield '# %s\n' % _expandedabspath(remotepath)
vfs = self._repo.vfs vfs = self._repo.vfs
for relname in filelist: for relname in filelist:
filehash = hashlib.sha1(vfs.tryread(relname)).hexdigest() filehash = node.hex(hashlib.sha1(vfs.tryread(relname)).digest())
yield '%s = %s\n' % (relname, filehash) yield '%s = %s\n' % (relname, filehash)
@propertycache @propertycache
def _cachestorehashvfs(self): def _cachestorehashvfs(self):
return vfsmod.vfs(self._repo.vfs.join('cache/storehash')) return vfsmod.vfs(self._repo.vfs.join('cache/storehash'))
def _readstorehashcache(self, remotepath): def _readstorehashcache(self, remotepath):
'''read the store hash cache for a given remote repository''' '''read the store hash cache for a given remote repository'''

mercurial/util.py

import traceback import traceback
import warnings import warnings
import zlib import zlib
from . import ( from . import (
encoding, encoding,
error, error,
i18n, i18n,
node as nodemod,
policy, policy,
pycompat, pycompat,
urllibcompat, urllibcompat,
) )
base85 = policy.importmod(r'base85') base85 = policy.importmod(r'base85')
osutil = policy.importmod(r'osutil') osutil = policy.importmod(r'osutil')
parsers = policy.importmod(r'parsers') parsers = policy.importmod(r'parsers')
def update(self, data): def update(self, data):
for h in self._hashes.values(): for h in self._hashes.values():
h.update(data) h.update(data)
def __getitem__(self, key): def __getitem__(self, key):
if key not in DIGESTS: if key not in DIGESTS:
raise Abort(_('unknown digest type: %s') % k) raise Abort(_('unknown digest type: %s') % k)
return self._hashes[key].hexdigest() return nodemod.hex(self._hashes[key].digest())
def __iter__(self): def __iter__(self):
return iter(self._hashes) return iter(self._hashes)
@staticmethod @staticmethod
def preferred(supported): def preferred(supported):
"""returns the strongest digest type in both supported and DIGESTS.""" """returns the strongest digest type in both supported and DIGESTS."""