This is an archive of the discontinued Mercurial Phabricator instance.

Differential D2028

sshpeer: move ssh command and repo creation logic out of __init__
ClosedPublic

Authored by indygreg on Feb 4 2018, 10:35 PM.

Details

Reviewers
lothiraldan
yuja
Group Reviewers
hg-reviewers
Commits
rHG31449baf0936: sshpeer: move ssh command and repo creation logic out of __init__
Summary

It was easier to move both of these at once because repository
creation requires various variables and I didn't want to add
tons of arguments and code to init that will soon be deleted
anyway. We do add an extra argument so we can proxy values to the
_validaterepo() call. But this is minimally invasive.

Some callers of self._abort() were converted to just raise. Like
before, the _abort() call wasn't necessary because self._pipe*
aren't populated this early in the object's lifetime.

As part of this, various private attributes derived from the parsed
URL are no longer used. So we no longer set them.

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

indygreg created this revision.Feb 4 2018, 10:35 PM
lothiraldan accepted this revision.Feb 5 2018, 7:54 AM
yuja accepted this revision.Feb 6 2018, 8:07 AM
This revision is now accepted and ready to land.Feb 6 2018, 8:07 AM
Closed by commit rHG31449baf0936: sshpeer: move ssh command and repo creation logic out of __init__ (authored by indygreg). · Explain WhyFeb 6 2018, 8:24 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/sshpeer.py (45 lines)
Mtests/test-check-interfaces.py (2 lines)

Diff 5245

mercurial/sshpeer.py

def close(self): def close(self):
return self._main.close() return self._main.close()
def flush(self): def flush(self):
return self._main.flush() return self._main.flush()
class sshpeer(wireproto.wirepeer): class sshpeer(wireproto.wirepeer):
def __init__(self, ui, path, create=False): def __init__(self, ui, path, create=False, sshstate=None):
self._url = path self._url = path
self._ui = ui self._ui = ui
self._pipeo = self._pipei = self._pipee = None self._pipeo = self._pipei = self._pipee = None
u = util.url(path, parsequery=False, parsefragment=False) u = util.url(path, parsequery=False, parsefragment=False)
self._user = u.user
self._host = u.host
self._port = u.port
self._path = u.path or '.' self._path = u.path or '.'
sshcmd = self.ui.config("ui", "ssh") self._validaterepo(*sshstate)
remotecmd = self.ui.config("ui", "remotecmd")
sshaddenv = dict(self.ui.configitems("sshenv"))
sshenv = util.shellenviron(sshaddenv)
args = util.sshargs(sshcmd, self._host, self._user, self._port)
if create:
cmd = '%s %s %s' % (sshcmd, args,
util.shellquote("%s init %s" %
(_serverquote(remotecmd), _serverquote(self._path))))
ui.debug('running %s\n' % cmd)
res = ui.system(cmd, blockedtag='sshpeer', environ=sshenv)
if res != 0:
self._abort(error.RepoError(_("could not create remote repo")))
self._validaterepo(sshcmd, args, remotecmd, sshenv)
# Begin of _basepeer interface. # Begin of _basepeer interface.
@util.propertycache @util.propertycache
def ui(self): def ui(self):
return self._ui return self._ui
def url(self): def url(self):
if u.scheme != 'ssh' or not u.host or u.path is None: if u.scheme != 'ssh' or not u.host or u.path is None:
raise error.RepoError(_("couldn't parse location %s") % path) raise error.RepoError(_("couldn't parse location %s") % path)
util.checksafessh(path) util.checksafessh(path)
if u.passwd is not None: if u.passwd is not None:
raise error.RepoError(_('password in URL not supported')) raise error.RepoError(_('password in URL not supported'))
return sshpeer(ui, path, create=create) sshcmd = ui.config('ui', 'ssh')
remotecmd = ui.config('ui', 'remotecmd')
sshaddenv = dict(ui.configitems('sshenv'))
sshenv = util.shellenviron(sshaddenv)
remotepath = u.path or '.'
args = util.sshargs(sshcmd, u.host, u.user, u.port)
if create:
cmd = '%s %s %s' % (sshcmd, args,
util.shellquote('%s init %s' %
(_serverquote(remotecmd), _serverquote(remotepath))))
ui.debug('running %s\n' % cmd)
res = ui.system(cmd, blockedtag='sshpeer', environ=sshenv)
if res != 0:
raise error.RepoError(_('could not create remote repo'))
sshstate = (sshcmd, args, remotecmd, sshenv)
return sshpeer(ui, path, create=create, sshstate=sshstate)

tests/test-check-interfaces.py

pass pass
def main(): def main():
ui = uimod.ui() ui = uimod.ui()
checkobject(badpeer()) checkobject(badpeer())
checkobject(httppeer.httppeer(ui, 'http://localhost')) checkobject(httppeer.httppeer(ui, 'http://localhost'))
checkobject(localrepo.localpeer(dummyrepo())) checkobject(localrepo.localpeer(dummyrepo()))
checkobject(testingsshpeer(ui, 'ssh://localhost/foo')) checkobject(testingsshpeer(ui, 'ssh://localhost/foo', False, ()))
checkobject(bundlerepo.bundlepeer(dummyrepo())) checkobject(bundlerepo.bundlepeer(dummyrepo()))
checkobject(statichttprepo.statichttppeer(dummyrepo())) checkobject(statichttprepo.statichttppeer(dummyrepo()))
checkobject(unionrepo.unionpeer(dummyrepo())) checkobject(unionrepo.unionpeer(dummyrepo()))
main() main()