( )⚙ 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
Lint Skipped
Unit
Unit Tests Skipped

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 4669

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."""