##// END OF EJS Templates
Subclass file with a __len__ method instead of setting Content-length...
Benoit Boissinot -
r4025:d8b3edf8 default
parent child Browse files
Show More
@@ -1,389 +1,387 b''
1 1 # httprepo.py - HTTP repository proxy classes for mercurial
2 2 #
3 3 # Copyright 2005, 2006 Matt Mackall <mpm@selenic.com>
4 4 # Copyright 2006 Vadim Gelfer <vadim.gelfer@gmail.com>
5 5 #
6 6 # This software may be used and distributed according to the terms
7 7 # of the GNU General Public License, incorporated herein by reference.
8 8
9 9 from node import *
10 10 from remoterepo import *
11 11 from i18n import gettext as _
12 12 from demandload import *
13 13 demandload(globals(), "hg os urllib urllib2 urlparse zlib util httplib")
14 14 demandload(globals(), "errno keepalive tempfile socket changegroup")
15 15
16 16 class passwordmgr(urllib2.HTTPPasswordMgrWithDefaultRealm):
17 17 def __init__(self, ui):
18 18 urllib2.HTTPPasswordMgrWithDefaultRealm.__init__(self)
19 19 self.ui = ui
20 20
21 21 def find_user_password(self, realm, authuri):
22 22 authinfo = urllib2.HTTPPasswordMgrWithDefaultRealm.find_user_password(
23 23 self, realm, authuri)
24 24 user, passwd = authinfo
25 25 if user and passwd:
26 26 return (user, passwd)
27 27
28 28 if not self.ui.interactive:
29 29 raise util.Abort(_('http authorization required'))
30 30
31 31 self.ui.write(_("http authorization required\n"))
32 32 self.ui.status(_("realm: %s\n") % realm)
33 33 if user:
34 34 self.ui.status(_("user: %s\n") % user)
35 35 else:
36 36 user = self.ui.prompt(_("user:"), default=None)
37 37
38 38 if not passwd:
39 39 passwd = self.ui.getpass()
40 40
41 41 self.add_password(realm, authuri, user, passwd)
42 42 return (user, passwd)
43 43
44 44 def netlocsplit(netloc):
45 45 '''split [user[:passwd]@]host[:port] into 4-tuple.'''
46 46
47 47 a = netloc.find('@')
48 48 if a == -1:
49 49 user, passwd = None, None
50 50 else:
51 51 userpass, netloc = netloc[:a], netloc[a+1:]
52 52 c = userpass.find(':')
53 53 if c == -1:
54 54 user, passwd = urllib.unquote(userpass), None
55 55 else:
56 56 user = urllib.unquote(userpass[:c])
57 57 passwd = urllib.unquote(userpass[c+1:])
58 58 c = netloc.find(':')
59 59 if c == -1:
60 60 host, port = netloc, None
61 61 else:
62 62 host, port = netloc[:c], netloc[c+1:]
63 63 return host, port, user, passwd
64 64
65 65 def netlocunsplit(host, port, user=None, passwd=None):
66 66 '''turn host, port, user, passwd into [user[:passwd]@]host[:port].'''
67 67 if port:
68 68 hostport = host + ':' + port
69 69 else:
70 70 hostport = host
71 71 if user:
72 72 if passwd:
73 73 userpass = urllib.quote(user) + ':' + urllib.quote(passwd)
74 74 else:
75 75 userpass = urllib.quote(user)
76 76 return userpass + '@' + hostport
77 77 return hostport
78 78
79 class httpconnection(keepalive.HTTPConnection):
80 # must be able to send big bundle as stream.
79 class httpsendfile(file):
80 def __len__(self):
81 return os.fstat(self.fileno()).st_size
81 82
82 def send(self, data):
83 if isinstance(data, str):
84 keepalive.HTTPConnection.send(self, data)
85 else:
83 def _gen_sendfile(connection):
84 def _sendfile(self, data):
85 # send a file
86 if isinstance(data, httpsendfile):
86 87 # if auth required, some data sent twice, so rewind here
87 88 data.seek(0)
88 89 for chunk in util.filechunkiter(data):
89 keepalive.HTTPConnection.send(self, chunk)
90 connection.send(self, chunk)
91 else:
92 connection.send(self, data)
93 return _sendfile
94
95 class httpconnection(keepalive.HTTPConnection):
96 # must be able to send big bundle as stream.
97 send = _gen_sendfile(keepalive.HTTPConnection)
90 98
91 99 class basehttphandler(keepalive.HTTPHandler):
92 100 def http_open(self, req):
93 101 return self.do_open(httpconnection, req)
94 102
95 103 has_https = hasattr(urllib2, 'HTTPSHandler')
96 104 if has_https:
97 105 class httpsconnection(httplib.HTTPSConnection):
98 106 response_class = keepalive.HTTPResponse
99 107 # must be able to send big bundle as stream.
100
101 def send(self, data):
102 if isinstance(data, str):
103 httplib.HTTPSConnection.send(self, data)
104 else:
105 # if auth required, some data sent twice, so rewind here
106 data.seek(0)
107 for chunk in util.filechunkiter(data):
108 httplib.HTTPSConnection.send(self, chunk)
108 send = _gen_sendfile(httplib.HTTPSConnection)
109 109
110 110 class httphandler(basehttphandler, urllib2.HTTPSHandler):
111 111 def https_open(self, req):
112 112 return self.do_open(httpsconnection, req)
113 113 else:
114 114 class httphandler(basehttphandler):
115 115 pass
116 116
117 117 def zgenerator(f):
118 118 zd = zlib.decompressobj()
119 119 try:
120 120 for chunk in util.filechunkiter(f):
121 121 yield zd.decompress(chunk)
122 122 except httplib.HTTPException, inst:
123 123 raise IOError(None, _('connection ended unexpectedly'))
124 124 yield zd.flush()
125 125
126 126 class httprepository(remoterepository):
127 127 def __init__(self, ui, path):
128 128 self.path = path
129 129 self.caps = None
130 130 scheme, netloc, urlpath, query, frag = urlparse.urlsplit(path)
131 131 if query or frag:
132 132 raise util.Abort(_('unsupported URL component: "%s"') %
133 133 (query or frag))
134 134 if not urlpath: urlpath = '/'
135 135 host, port, user, passwd = netlocsplit(netloc)
136 136
137 137 # urllib cannot handle URLs with embedded user or passwd
138 138 self._url = urlparse.urlunsplit((scheme, netlocunsplit(host, port),
139 139 urlpath, '', ''))
140 140 self.ui = ui
141 141
142 142 proxyurl = ui.config("http_proxy", "host") or os.getenv('http_proxy')
143 143 # XXX proxyauthinfo = None
144 144 handlers = [httphandler()]
145 145
146 146 if proxyurl:
147 147 # proxy can be proper url or host[:port]
148 148 if not (proxyurl.startswith('http:') or
149 149 proxyurl.startswith('https:')):
150 150 proxyurl = 'http://' + proxyurl + '/'
151 151 snpqf = urlparse.urlsplit(proxyurl)
152 152 proxyscheme, proxynetloc, proxypath, proxyquery, proxyfrag = snpqf
153 153 hpup = netlocsplit(proxynetloc)
154 154
155 155 proxyhost, proxyport, proxyuser, proxypasswd = hpup
156 156 if not proxyuser:
157 157 proxyuser = ui.config("http_proxy", "user")
158 158 proxypasswd = ui.config("http_proxy", "passwd")
159 159
160 160 # see if we should use a proxy for this url
161 161 no_list = [ "localhost", "127.0.0.1" ]
162 162 no_list.extend([p.lower() for
163 163 p in ui.configlist("http_proxy", "no")])
164 164 no_list.extend([p.strip().lower() for
165 165 p in os.getenv("no_proxy", '').split(',')
166 166 if p.strip()])
167 167 # "http_proxy.always" config is for running tests on localhost
168 168 if (not ui.configbool("http_proxy", "always") and
169 169 host.lower() in no_list):
170 170 ui.debug(_('disabling proxy for %s\n') % host)
171 171 else:
172 172 proxyurl = urlparse.urlunsplit((
173 173 proxyscheme, netlocunsplit(proxyhost, proxyport,
174 174 proxyuser, proxypasswd or ''),
175 175 proxypath, proxyquery, proxyfrag))
176 176 handlers.append(urllib2.ProxyHandler({scheme: proxyurl}))
177 177 ui.debug(_('proxying through http://%s:%s\n') %
178 178 (proxyhost, proxyport))
179 179
180 180 # urllib2 takes proxy values from the environment and those
181 181 # will take precedence if found, so drop them
182 182 for env in ["HTTP_PROXY", "http_proxy", "no_proxy"]:
183 183 try:
184 184 if os.environ.has_key(env):
185 185 del os.environ[env]
186 186 except OSError:
187 187 pass
188 188
189 189 passmgr = passwordmgr(ui)
190 190 if user:
191 191 ui.debug(_('http auth: user %s, password %s\n') %
192 192 (user, passwd and '*' * len(passwd) or 'not set'))
193 193 passmgr.add_password(None, host, user, passwd or '')
194 194
195 195 handlers.extend((urllib2.HTTPBasicAuthHandler(passmgr),
196 196 urllib2.HTTPDigestAuthHandler(passmgr)))
197 197 opener = urllib2.build_opener(*handlers)
198 198
199 199 # 1.0 here is the _protocol_ version
200 200 opener.addheaders = [('User-agent', 'mercurial/proto-1.0')]
201 201 urllib2.install_opener(opener)
202 202
203 203 def url(self):
204 204 return self.path
205 205
206 206 # look up capabilities only when needed
207 207
208 208 def get_caps(self):
209 209 if self.caps is None:
210 210 try:
211 211 self.caps = self.do_read('capabilities').split()
212 212 except hg.RepoError:
213 213 self.caps = ()
214 214 self.ui.debug(_('capabilities: %s\n') %
215 215 (' '.join(self.caps or ['none'])))
216 216 return self.caps
217 217
218 218 capabilities = property(get_caps)
219 219
220 220 def lock(self):
221 221 raise util.Abort(_('operation not supported over http'))
222 222
223 223 def do_cmd(self, cmd, **args):
224 224 data = args.pop('data', None)
225 225 headers = args.pop('headers', {})
226 226 self.ui.debug(_("sending %s command\n") % cmd)
227 227 q = {"cmd": cmd}
228 228 q.update(args)
229 229 qs = '?%s' % urllib.urlencode(q)
230 230 cu = "%s%s" % (self._url, qs)
231 231 try:
232 232 if data:
233 233 self.ui.debug(_("sending %s bytes\n") %
234 234 headers.get('content-length', 'X'))
235 235 resp = urllib2.urlopen(urllib2.Request(cu, data, headers))
236 236 except urllib2.HTTPError, inst:
237 237 if inst.code == 401:
238 238 raise util.Abort(_('authorization failed'))
239 239 raise
240 240 except httplib.HTTPException, inst:
241 241 self.ui.debug(_('http error while sending %s command\n') % cmd)
242 242 self.ui.print_exc()
243 243 raise IOError(None, inst)
244 244 except IndexError:
245 245 # this only happens with Python 2.3, later versions raise URLError
246 246 raise util.Abort(_('http error, possibly caused by proxy setting'))
247 247 # record the url we got redirected to
248 248 resp_url = resp.geturl()
249 249 if resp_url.endswith(qs):
250 250 resp_url = resp_url[:-len(qs)]
251 251 if self._url != resp_url:
252 252 self.ui.status(_('real URL is %s\n') % resp_url)
253 253 self._url = resp_url
254 254 try:
255 255 proto = resp.getheader('content-type')
256 256 except AttributeError:
257 257 proto = resp.headers['content-type']
258 258
259 259 # accept old "text/plain" and "application/hg-changegroup" for now
260 260 if not proto.startswith('application/mercurial-') and \
261 261 not proto.startswith('text/plain') and \
262 262 not proto.startswith('application/hg-changegroup'):
263 263 raise hg.RepoError(_("'%s' does not appear to be an hg repository") %
264 264 self._url)
265 265
266 266 if proto.startswith('application/mercurial-'):
267 267 try:
268 268 version = float(proto[22:])
269 269 except ValueError:
270 270 raise hg.RepoError(_("'%s' sent a broken Content-type "
271 271 "header (%s)") % (self._url, proto))
272 272 if version > 0.1:
273 273 raise hg.RepoError(_("'%s' uses newer protocol %s") %
274 274 (self._url, version))
275 275
276 276 return resp
277 277
278 278 def do_read(self, cmd, **args):
279 279 fp = self.do_cmd(cmd, **args)
280 280 try:
281 281 return fp.read()
282 282 finally:
283 283 # if using keepalive, allow connection to be reused
284 284 fp.close()
285 285
286 286 def lookup(self, key):
287 287 d = self.do_cmd("lookup", key = key).read()
288 288 success, data = d[:-1].split(' ', 1)
289 289 if int(success):
290 290 return bin(data)
291 291 raise hg.RepoError(data)
292 292
293 293 def heads(self):
294 294 d = self.do_read("heads")
295 295 try:
296 296 return map(bin, d[:-1].split(" "))
297 297 except:
298 298 raise util.UnexpectedOutput(_("unexpected response:"), d)
299 299
300 300 def branches(self, nodes):
301 301 n = " ".join(map(hex, nodes))
302 302 d = self.do_read("branches", nodes=n)
303 303 try:
304 304 br = [ tuple(map(bin, b.split(" "))) for b in d.splitlines() ]
305 305 return br
306 306 except:
307 307 raise util.UnexpectedOutput(_("unexpected response:"), d)
308 308
309 309 def between(self, pairs):
310 310 n = "\n".join(["-".join(map(hex, p)) for p in pairs])
311 311 d = self.do_read("between", pairs=n)
312 312 try:
313 313 p = [ l and map(bin, l.split(" ")) or [] for l in d.splitlines() ]
314 314 return p
315 315 except:
316 316 raise util.UnexpectedOutput(_("unexpected response:"), d)
317 317
318 318 def changegroup(self, nodes, kind):
319 319 n = " ".join(map(hex, nodes))
320 320 f = self.do_cmd("changegroup", roots=n)
321 321 return util.chunkbuffer(zgenerator(f))
322 322
323 323 def changegroupsubset(self, bases, heads, source):
324 324 baselst = " ".join([hex(n) for n in bases])
325 325 headlst = " ".join([hex(n) for n in heads])
326 326 f = self.do_cmd("changegroupsubset", bases=baselst, heads=headlst)
327 327 return util.chunkbuffer(zgenerator(f))
328 328
329 329 def unbundle(self, cg, heads, source):
330 330 # have to stream bundle to a temp file because we do not have
331 331 # http 1.1 chunked transfer.
332 332
333 333 type = ""
334 334 types = self.capable('unbundle')
335 335 # servers older than d1b16a746db6 will send 'unbundle' as a
336 336 # boolean capability
337 337 try:
338 338 types = types.split(',')
339 339 except AttributeError:
340 340 types = [""]
341 341 if types:
342 342 for x in types:
343 343 if x in changegroup.bundletypes:
344 344 type = x
345 345 break
346 346
347 347 tempname = changegroup.writebundle(cg, None, type)
348 fp = file(tempname, "rb")
348 fp = httpsendfile(tempname, "rb")
349 349 try:
350 length = os.stat(tempname).st_size
351 350 try:
352 351 rfp = self.do_cmd(
353 352 'unbundle', data=fp,
354 headers={'content-length': str(length),
355 'content-type': 'application/octet-stream'},
353 headers={'content-type': 'application/octet-stream'},
356 354 heads=' '.join(map(hex, heads)))
357 355 try:
358 356 ret = int(rfp.readline())
359 357 self.ui.write(rfp.read())
360 358 return ret
361 359 finally:
362 360 rfp.close()
363 361 except socket.error, err:
364 362 if err[0] in (errno.ECONNRESET, errno.EPIPE):
365 363 raise util.Abort(_('push failed: %s') % err[1])
366 364 raise util.Abort(err[1])
367 365 finally:
368 366 fp.close()
369 367 os.unlink(tempname)
370 368
371 369 def stream_out(self):
372 370 return self.do_cmd('stream_out')
373 371
374 372 class httpsrepository(httprepository):
375 373 def __init__(self, ui, path):
376 374 if not has_https:
377 375 raise util.Abort(_('Python support for SSL and HTTPS '
378 376 'is not installed'))
379 377 httprepository.__init__(self, ui, path)
380 378
381 379 def instance(ui, path, create):
382 380 if create:
383 381 raise util.Abort(_('cannot create new http repository'))
384 382 if path.startswith('hg:'):
385 383 ui.warn(_("hg:// syntax is deprecated, please use http:// instead\n"))
386 384 path = 'http:' + path[3:]
387 385 if path.startswith('https:'):
388 386 return httpsrepository(ui, path)
389 387 return httprepository(ui, path)
General Comments 0
You need to be logged in to leave comments. Login now