Mercurial Mercurial > public > mercurial-scm > hg / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
mercurial/sshrepo.py
changeset 7642 84346894def8
parent 7641 d2f753830f80
child 7873 4a4c7f6a5912
equal deleted inserted replaced
7641:d2f753830f80 7642:84346894def8 
    24         self._url = path
 
    24         self._url = path
 
    25         self.ui = ui
 
    25         self.ui = ui
 
    26 
    26 
    27         m = re.match(r'^ssh://(([^@]+)@)?([^:/]+)(:(\d+))?(/(.*))?$', path)
 
    27         m = re.match(r'^ssh://(([^@]+)@)?([^:/]+)(:(\d+))?(/(.*))?$', path)
 
    28         if not m:
 
    28         if not m:
 
    29             self.raise_(error.RepoError(_("couldn't parse location %s") % path))
 
    29             self.abort(error.RepoError(_("couldn't parse location %s") % path))
 
    30 
    30 
    31         self.user = m.group(2)
 
    31         self.user = m.group(2)
 
    32         self.host = m.group(3)
 
    32         self.host = m.group(3)
 
    33         self.port = m.group(5)
 
    33         self.port = m.group(5)
 
    34         self.path = m.group(7) or "."
 
    34         self.path = m.group(7) or "."
 
    43             cmd = cmd % (sshcmd, args, remotecmd, self.path)
 
    43             cmd = cmd % (sshcmd, args, remotecmd, self.path)
 
    44 
    44 
    45             ui.note(_('running %s\n') % cmd)
 
    45             ui.note(_('running %s\n') % cmd)
 
    46             res = util.system(cmd)
 
    46             res = util.system(cmd)
 
    47             if res != 0:
 
    47             if res != 0:
 
    48                 self.raise_(error.RepoError(_("could not create remote repo")))
 
    48                 self.abort(error.RepoError(_("could not create remote repo")))
 
    49 
    49 
    50         self.validate_repo(ui, sshcmd, args, remotecmd)
 
    50         self.validate_repo(ui, sshcmd, args, remotecmd)
 
    51 
    51 
    52     def url(self):
 
    52     def url(self):
 
    53         return self._url
 
    53         return self._url
 
    76             if l:
 
    76             if l:
 
    77                 ui.debug(_("remote: "), l)
 
    77                 ui.debug(_("remote: "), l)
 
    78             lines.append(l)
 
    78             lines.append(l)
 
    79             max_noise -= 1
 
    79             max_noise -= 1
 
    80         else:
 
    80         else:
 
    81             self.raise_(error.RepoError(_("no suitable response from remote hg")))
 
    81             self.abort(error.RepoError(_("no suitable response from remote hg")))
 
    82 
    82 
    83         self.capabilities = util.set()
 
    83         self.capabilities = util.set()
 
    84         lines.reverse()
 
    84         lines.reverse()
 
    85         for l in lines:
 
    85         for l in lines:
 
    86             if l.startswith("capabilities:"):
 
    86             if l.startswith("capabilities:"):
 
    93             if size == 0: break
 
    93             if size == 0: break
 
    94             l = self.pipee.readline()
 
    94             l = self.pipee.readline()
 
    95             if not l: break
 
    95             if not l: break
 
    96             self.ui.status(_("remote: "), l)
 
    96             self.ui.status(_("remote: "), l)
 
    97 
    97 
    98     def raise_(self, exception):
 
    98     def abort(self, exception):
 
    99         self.cleanup()
 
    99         self.cleanup()
 
   100         raise exception
 
   100         raise exception
 
   101 
   101 
   102     def cleanup(self):
 
   102     def cleanup(self):
 
   103         try:
 
   103         try:
 
   130         l = self.pipei.readline()
 
   130         l = self.pipei.readline()
 
   131         self.readerr()
 
   131         self.readerr()
 
   132         try:
 
   132         try:
 
   133             l = int(l)
 
   133             l = int(l)
 
   134         except:
 
   134         except:
 
   135             self.raise_(error.ResponseError(_("unexpected response:"), l))
 
   135             self.abort(error.ResponseError(_("unexpected response:"), l))
 
   136         return self.pipei.read(l)
 
   136         return self.pipei.read(l)
 
   137 
   137 
   138     def _send(self, data, flush=False):
 
   138     def _send(self, data, flush=False):
 
   139         self.pipeo.write("%d\n" % len(data))
 
   139         self.pipeo.write("%d\n" % len(data))
 
   140         if data:
 
   140         if data:
 
   155         d = self.call("lookup", key=key)
 
   155         d = self.call("lookup", key=key)
 
   156         success, data = d[:-1].split(" ", 1)
 
   156         success, data = d[:-1].split(" ", 1)
 
   157         if int(success):
 
   157         if int(success):
 
   158             return bin(data)
 
   158             return bin(data)
 
   159         else:
 
   159         else:
 
   160             self.raise_(error.RepoError(data))
 
   160             self.abort(error.RepoError(data))
 
   161 
   161 
   162     def heads(self):
 
   162     def heads(self):
 
   163         d = self.call("heads")
 
   163         d = self.call("heads")
 
   164         try:
 
   164         try:
 
   165             return map(bin, d[:-1].split(" "))
 
   165             return map(bin, d[:-1].split(" "))
 
   166         except:
 
   166         except:
 
   167             self.raise_(error.ResponseError(_("unexpected response:"), d))
 
   167             self.abort(error.ResponseError(_("unexpected response:"), d))
 
   168 
   168 
   169     def branches(self, nodes):
 
   169     def branches(self, nodes):
 
   170         n = " ".join(map(hex, nodes))
 
   170         n = " ".join(map(hex, nodes))
 
   171         d = self.call("branches", nodes=n)
 
   171         d = self.call("branches", nodes=n)
 
   172         try:
 
   172         try:
 
   173             br = [ tuple(map(bin, b.split(" "))) for b in d.splitlines() ]
 
   173             br = [ tuple(map(bin, b.split(" "))) for b in d.splitlines() ]
 
   174             return br
 
   174             return br
 
   175         except:
 
   175         except:
 
   176             self.raise_(error.ResponseError(_("unexpected response:"), d))
 
   176             self.abort(error.ResponseError(_("unexpected response:"), d))
 
   177 
   177 
   178     def between(self, pairs):
 
   178     def between(self, pairs):
 
   179         n = " ".join(["-".join(map(hex, p)) for p in pairs])
 
   179         n = " ".join(["-".join(map(hex, p)) for p in pairs])
 
   180         d = self.call("between", pairs=n)
 
   180         d = self.call("between", pairs=n)
 
   181         try:
 
   181         try:
 
   182             p = [ l and map(bin, l.split(" ")) or [] for l in d.splitlines() ]
 
   182             p = [ l and map(bin, l.split(" ")) or [] for l in d.splitlines() ]
 
   183             return p
 
   183             return p
 
   184         except:
 
   184         except:
 
   185             self.raise_(error.ResponseError(_("unexpected response:"), d))
 
   185             self.abort(error.ResponseError(_("unexpected response:"), d))
 
   186 
   186 
   187     def changegroup(self, nodes, kind):
 
   187     def changegroup(self, nodes, kind):
 
   188         n = " ".join(map(hex, nodes))
 
   188         n = " ".join(map(hex, nodes))
 
   189         return self.do_cmd("changegroup", roots=n)
 
   189         return self.do_cmd("changegroup", roots=n)
 
   190 
   190 
   196 
   196 
   197     def unbundle(self, cg, heads, source):
 
   197     def unbundle(self, cg, heads, source):
 
   198         d = self.call("unbundle", heads=' '.join(map(hex, heads)))
 
   198         d = self.call("unbundle", heads=' '.join(map(hex, heads)))
 
   199         if d:
 
   199         if d:
 
   200             # remote may send "unsynced changes"
 
   200             # remote may send "unsynced changes"
 
   201             self.raise_(error.RepoError(_("push refused: %s") % d))
 
   201             self.abort(error.RepoError(_("push refused: %s") % d))
 
   202 
   202 
   203         while 1:
 
   203         while 1:
 
   204             d = cg.read(4096)
 
   204             d = cg.read(4096)
 
   205             if not d:
 
   205             if not d:
 
   206                 break
 
   206                 break
 
   209         self._send("", flush=True)
 
   209         self._send("", flush=True)
 
   210 
   210 
   211         r = self._recv()
 
   211         r = self._recv()
 
   212         if r:
 
   212         if r:
 
   213             # remote may send "unsynced changes"
 
   213             # remote may send "unsynced changes"
 
   214             self.raise_(error.RepoError(_("push failed: %s") % r))
 
   214             self.abort(error.RepoError(_("push failed: %s") % r))
 
   215 
   215 
   216         r = self._recv()
 
   216         r = self._recv()
 
   217         try:
 
   217         try:
 
   218             return int(r)
 
   218             return int(r)
 
   219         except:
 
   219         except:
 
   220             self.raise_(error.ResponseError(_("unexpected response:"), r))
 
   220             self.abort(error.ResponseError(_("unexpected response:"), r))
 
   221 
   221 
   222     def addchangegroup(self, cg, source, url):
 
   222     def addchangegroup(self, cg, source, url):
 
   223         d = self.call("addchangegroup")
 
   223         d = self.call("addchangegroup")
 
   224         if d:
 
   224         if d:
 
   225             self.raise_(error.RepoError(_("push refused: %s") % d))
 
   225             self.abort(error.RepoError(_("push refused: %s") % d))
 
   226         while 1:
 
   226         while 1:
 
   227             d = cg.read(4096)
 
   227             d = cg.read(4096)
 
   228             if not d:
 
   228             if not d:
 
   229                 break
 
   229                 break
 
   230             self.pipeo.write(d)
 
   230             self.pipeo.write(d)
 
   237         if not r:
 
   237         if not r:
 
   238             return 1
 
   238             return 1
 
   239         try:
 
   239         try:
 
   240             return int(r)
 
   240             return int(r)
 
   241         except:
 
   241         except:
 
   242             self.raise_(error.ResponseError(_("unexpected response:"), r))
 
   242             self.abort(error.ResponseError(_("unexpected response:"), r))
 
   243 
   243 
   244     def stream_out(self):
 
   244     def stream_out(self):
 
   245         return self.do_cmd('stream_out')
 
   245         return self.do_cmd('stream_out')
 
   246 
   246 
   247 instance = sshrepository
 
   247 instance = sshrepository
mercurial-scm/hg