##// END OF EJS Templates
Change User-agent field in client to have a lot more info.
Eric Hopper -
r6285:4b81eecc default
parent child Browse files
Show More
@@ -1,458 +1,458 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 bin, hex
10 10 from remoterepo import remoterepository
11 11 from i18n import _
12 12 import repo, os, urllib, urllib2, urlparse, zlib, util, httplib
13 import errno, keepalive, socket, changegroup
13 import errno, keepalive, socket, changegroup, version
14 14
15 15 class passwordmgr(urllib2.HTTPPasswordMgrWithDefaultRealm):
16 16 def __init__(self, ui):
17 17 urllib2.HTTPPasswordMgrWithDefaultRealm.__init__(self)
18 18 self.ui = ui
19 19
20 20 def find_user_password(self, realm, authuri):
21 21 authinfo = urllib2.HTTPPasswordMgrWithDefaultRealm.find_user_password(
22 22 self, realm, authuri)
23 23 user, passwd = authinfo
24 24 if user and passwd:
25 25 return (user, passwd)
26 26
27 27 if not self.ui.interactive:
28 28 raise util.Abort(_('http authorization required'))
29 29
30 30 self.ui.write(_("http authorization required\n"))
31 31 self.ui.status(_("realm: %s\n") % realm)
32 32 if user:
33 33 self.ui.status(_("user: %s\n") % user)
34 34 else:
35 35 user = self.ui.prompt(_("user:"), default=None)
36 36
37 37 if not passwd:
38 38 passwd = self.ui.getpass()
39 39
40 40 self.add_password(realm, authuri, user, passwd)
41 41 return (user, passwd)
42 42
43 43 def netlocsplit(netloc):
44 44 '''split [user[:passwd]@]host[:port] into 4-tuple.'''
45 45
46 46 a = netloc.find('@')
47 47 if a == -1:
48 48 user, passwd = None, None
49 49 else:
50 50 userpass, netloc = netloc[:a], netloc[a+1:]
51 51 c = userpass.find(':')
52 52 if c == -1:
53 53 user, passwd = urllib.unquote(userpass), None
54 54 else:
55 55 user = urllib.unquote(userpass[:c])
56 56 passwd = urllib.unquote(userpass[c+1:])
57 57 c = netloc.find(':')
58 58 if c == -1:
59 59 host, port = netloc, None
60 60 else:
61 61 host, port = netloc[:c], netloc[c+1:]
62 62 return host, port, user, passwd
63 63
64 64 def netlocunsplit(host, port, user=None, passwd=None):
65 65 '''turn host, port, user, passwd into [user[:passwd]@]host[:port].'''
66 66 if port:
67 67 hostport = host + ':' + port
68 68 else:
69 69 hostport = host
70 70 if user:
71 71 if passwd:
72 72 userpass = urllib.quote(user) + ':' + urllib.quote(passwd)
73 73 else:
74 74 userpass = urllib.quote(user)
75 75 return userpass + '@' + hostport
76 76 return hostport
77 77
78 78 # work around a bug in Python < 2.4.2
79 79 # (it leaves a "\n" at the end of Proxy-authorization headers)
80 80 class request(urllib2.Request):
81 81 def add_header(self, key, val):
82 82 if key.lower() == 'proxy-authorization':
83 83 val = val.strip()
84 84 return urllib2.Request.add_header(self, key, val)
85 85
86 86 class httpsendfile(file):
87 87 def __len__(self):
88 88 return os.fstat(self.fileno()).st_size
89 89
90 90 def _gen_sendfile(connection):
91 91 def _sendfile(self, data):
92 92 # send a file
93 93 if isinstance(data, httpsendfile):
94 94 # if auth required, some data sent twice, so rewind here
95 95 data.seek(0)
96 96 for chunk in util.filechunkiter(data):
97 97 connection.send(self, chunk)
98 98 else:
99 99 connection.send(self, data)
100 100 return _sendfile
101 101
102 102 class httpconnection(keepalive.HTTPConnection):
103 103 # must be able to send big bundle as stream.
104 104 send = _gen_sendfile(keepalive.HTTPConnection)
105 105
106 106 class httphandler(keepalive.HTTPHandler):
107 107 def http_open(self, req):
108 108 return self.do_open(httpconnection, req)
109 109
110 110 def __del__(self):
111 111 self.close_all()
112 112
113 113 has_https = hasattr(urllib2, 'HTTPSHandler')
114 114 if has_https:
115 115 class httpsconnection(httplib.HTTPSConnection):
116 116 response_class = keepalive.HTTPResponse
117 117 # must be able to send big bundle as stream.
118 118 send = _gen_sendfile(httplib.HTTPSConnection)
119 119
120 120 class httpshandler(keepalive.KeepAliveHandler, urllib2.HTTPSHandler):
121 121 def https_open(self, req):
122 122 return self.do_open(httpsconnection, req)
123 123
124 124 # In python < 2.5 AbstractDigestAuthHandler raises a ValueError if
125 125 # it doesn't know about the auth type requested. This can happen if
126 126 # somebody is using BasicAuth and types a bad password.
127 127 class httpdigestauthhandler(urllib2.HTTPDigestAuthHandler):
128 128 def http_error_auth_reqed(self, auth_header, host, req, headers):
129 129 try:
130 130 return urllib2.HTTPDigestAuthHandler.http_error_auth_reqed(
131 131 self, auth_header, host, req, headers)
132 132 except ValueError, inst:
133 133 arg = inst.args[0]
134 134 if arg.startswith("AbstractDigestAuthHandler doesn't know "):
135 135 return
136 136 raise
137 137
138 138 def zgenerator(f):
139 139 zd = zlib.decompressobj()
140 140 try:
141 141 for chunk in util.filechunkiter(f):
142 142 yield zd.decompress(chunk)
143 143 except httplib.HTTPException, inst:
144 144 raise IOError(None, _('connection ended unexpectedly'))
145 145 yield zd.flush()
146 146
147 147 _safe = ('abcdefghijklmnopqrstuvwxyz'
148 148 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
149 149 '0123456789' '_.-/')
150 150 _safeset = None
151 151 _hex = None
152 152 def quotepath(path):
153 153 '''quote the path part of a URL
154 154
155 155 This is similar to urllib.quote, but it also tries to avoid
156 156 quoting things twice (inspired by wget):
157 157
158 158 >>> quotepath('abc def')
159 159 'abc%20def'
160 160 >>> quotepath('abc%20def')
161 161 'abc%20def'
162 162 >>> quotepath('abc%20 def')
163 163 'abc%20%20def'
164 164 >>> quotepath('abc def%20')
165 165 'abc%20def%20'
166 166 >>> quotepath('abc def%2')
167 167 'abc%20def%252'
168 168 >>> quotepath('abc def%')
169 169 'abc%20def%25'
170 170 '''
171 171 global _safeset, _hex
172 172 if _safeset is None:
173 173 _safeset = util.set(_safe)
174 174 _hex = util.set('abcdefABCDEF0123456789')
175 175 l = list(path)
176 176 for i in xrange(len(l)):
177 177 c = l[i]
178 178 if c == '%' and i + 2 < len(l) and (l[i+1] in _hex and l[i+2] in _hex):
179 179 pass
180 180 elif c not in _safeset:
181 181 l[i] = '%%%02X' % ord(c)
182 182 return ''.join(l)
183 183
184 184 class httprepository(remoterepository):
185 185 def __init__(self, ui, path):
186 186 self.path = path
187 187 self.caps = None
188 188 self.handler = None
189 189 scheme, netloc, urlpath, query, frag = urlparse.urlsplit(path)
190 190 if query or frag:
191 191 raise util.Abort(_('unsupported URL component: "%s"') %
192 192 (query or frag))
193 193 if not urlpath:
194 194 urlpath = '/'
195 195 urlpath = quotepath(urlpath)
196 196 host, port, user, passwd = netlocsplit(netloc)
197 197
198 198 # urllib cannot handle URLs with embedded user or passwd
199 199 self._url = urlparse.urlunsplit((scheme, netlocunsplit(host, port),
200 200 urlpath, '', ''))
201 201 self.ui = ui
202 202 self.ui.debug(_('using %s\n') % self._url)
203 203
204 204 proxyurl = ui.config("http_proxy", "host") or os.getenv('http_proxy')
205 205 # XXX proxyauthinfo = None
206 206 handlers = [httphandler()]
207 207 if has_https:
208 208 handlers.append(httpshandler())
209 209
210 210 if proxyurl:
211 211 # proxy can be proper url or host[:port]
212 212 if not (proxyurl.startswith('http:') or
213 213 proxyurl.startswith('https:')):
214 214 proxyurl = 'http://' + proxyurl + '/'
215 215 snpqf = urlparse.urlsplit(proxyurl)
216 216 proxyscheme, proxynetloc, proxypath, proxyquery, proxyfrag = snpqf
217 217 hpup = netlocsplit(proxynetloc)
218 218
219 219 proxyhost, proxyport, proxyuser, proxypasswd = hpup
220 220 if not proxyuser:
221 221 proxyuser = ui.config("http_proxy", "user")
222 222 proxypasswd = ui.config("http_proxy", "passwd")
223 223
224 224 # see if we should use a proxy for this url
225 225 no_list = [ "localhost", "127.0.0.1" ]
226 226 no_list.extend([p.lower() for
227 227 p in ui.configlist("http_proxy", "no")])
228 228 no_list.extend([p.strip().lower() for
229 229 p in os.getenv("no_proxy", '').split(',')
230 230 if p.strip()])
231 231 # "http_proxy.always" config is for running tests on localhost
232 232 if (not ui.configbool("http_proxy", "always") and
233 233 host.lower() in no_list):
234 234 # avoid auto-detection of proxy settings by appending
235 235 # a ProxyHandler with no proxies defined.
236 236 handlers.append(urllib2.ProxyHandler({}))
237 237 ui.debug(_('disabling proxy for %s\n') % host)
238 238 else:
239 239 proxyurl = urlparse.urlunsplit((
240 240 proxyscheme, netlocunsplit(proxyhost, proxyport,
241 241 proxyuser, proxypasswd or ''),
242 242 proxypath, proxyquery, proxyfrag))
243 243 handlers.append(urllib2.ProxyHandler({scheme: proxyurl}))
244 244 ui.debug(_('proxying through http://%s:%s\n') %
245 245 (proxyhost, proxyport))
246 246
247 247 # urllib2 takes proxy values from the environment and those
248 248 # will take precedence if found, so drop them
249 249 for env in ["HTTP_PROXY", "http_proxy", "no_proxy"]:
250 250 try:
251 251 if env in os.environ:
252 252 del os.environ[env]
253 253 except OSError:
254 254 pass
255 255
256 256 passmgr = passwordmgr(ui)
257 257 if user:
258 258 ui.debug(_('http auth: user %s, password %s\n') %
259 259 (user, passwd and '*' * len(passwd) or 'not set'))
260 260 netloc = host
261 261 if port:
262 262 netloc += ':' + port
263 263 # Python < 2.4.3 uses only the netloc to search for a password
264 264 passmgr.add_password(None, (self._url, netloc), user, passwd or '')
265 265
266 266 handlers.extend((urllib2.HTTPBasicAuthHandler(passmgr),
267 267 httpdigestauthhandler(passmgr)))
268 268 opener = urllib2.build_opener(*handlers)
269 269
270 270 # 1.0 here is the _protocol_ version
271 opener.addheaders = [('User-agent', 'mercurial/proto-1.0')]
271 opener.addheaders = [('User-agent', version.get_useragent())]
272 272 urllib2.install_opener(opener)
273 273
274 274 def url(self):
275 275 return self.path
276 276
277 277 # look up capabilities only when needed
278 278
279 279 def get_caps(self):
280 280 if self.caps is None:
281 281 try:
282 282 self.caps = util.set(self.do_read('capabilities').split())
283 283 except repo.RepoError:
284 284 self.caps = util.set()
285 285 self.ui.debug(_('capabilities: %s\n') %
286 286 (' '.join(self.caps or ['none'])))
287 287 return self.caps
288 288
289 289 capabilities = property(get_caps)
290 290
291 291 def lock(self):
292 292 raise util.Abort(_('operation not supported over http'))
293 293
294 294 def do_cmd(self, cmd, **args):
295 295 data = args.pop('data', None)
296 296 headers = args.pop('headers', {})
297 297 self.ui.debug(_("sending %s command\n") % cmd)
298 298 q = {"cmd": cmd}
299 299 q.update(args)
300 300 qs = '?%s' % urllib.urlencode(q)
301 301 cu = "%s%s" % (self._url, qs)
302 302 try:
303 303 if data:
304 304 self.ui.debug(_("sending %s bytes\n") % len(data))
305 305 resp = urllib2.urlopen(request(cu, data, headers))
306 306 except urllib2.HTTPError, inst:
307 307 if inst.code == 401:
308 308 raise util.Abort(_('authorization failed'))
309 309 raise
310 310 except httplib.HTTPException, inst:
311 311 self.ui.debug(_('http error while sending %s command\n') % cmd)
312 312 self.ui.print_exc()
313 313 raise IOError(None, inst)
314 314 except IndexError:
315 315 # this only happens with Python 2.3, later versions raise URLError
316 316 raise util.Abort(_('http error, possibly caused by proxy setting'))
317 317 # record the url we got redirected to
318 318 resp_url = resp.geturl()
319 319 if resp_url.endswith(qs):
320 320 resp_url = resp_url[:-len(qs)]
321 321 if self._url != resp_url:
322 322 self.ui.status(_('real URL is %s\n') % resp_url)
323 323 self._url = resp_url
324 324 try:
325 325 proto = resp.getheader('content-type')
326 326 except AttributeError:
327 327 proto = resp.headers['content-type']
328 328
329 329 # accept old "text/plain" and "application/hg-changegroup" for now
330 330 if not (proto.startswith('application/mercurial-') or
331 331 proto.startswith('text/plain') or
332 332 proto.startswith('application/hg-changegroup')):
333 333 self.ui.debug(_("Requested URL: '%s'\n") % cu)
334 334 raise repo.RepoError(_("'%s' does not appear to be an hg repository")
335 335 % self._url)
336 336
337 337 if proto.startswith('application/mercurial-'):
338 338 try:
339 339 version = proto.split('-', 1)[1]
340 340 version_info = tuple([int(n) for n in version.split('.')])
341 341 except ValueError:
342 342 raise repo.RepoError(_("'%s' sent a broken Content-Type "
343 343 "header (%s)") % (self._url, proto))
344 344 if version_info > (0, 1):
345 345 raise repo.RepoError(_("'%s' uses newer protocol %s") %
346 346 (self._url, version))
347 347
348 348 return resp
349 349
350 350 def do_read(self, cmd, **args):
351 351 fp = self.do_cmd(cmd, **args)
352 352 try:
353 353 return fp.read()
354 354 finally:
355 355 # if using keepalive, allow connection to be reused
356 356 fp.close()
357 357
358 358 def lookup(self, key):
359 359 self.requirecap('lookup', _('look up remote revision'))
360 360 d = self.do_cmd("lookup", key = key).read()
361 361 success, data = d[:-1].split(' ', 1)
362 362 if int(success):
363 363 return bin(data)
364 364 raise repo.RepoError(data)
365 365
366 366 def heads(self):
367 367 d = self.do_read("heads")
368 368 try:
369 369 return map(bin, d[:-1].split(" "))
370 370 except:
371 371 raise util.UnexpectedOutput(_("unexpected response:"), d)
372 372
373 373 def branches(self, nodes):
374 374 n = " ".join(map(hex, nodes))
375 375 d = self.do_read("branches", nodes=n)
376 376 try:
377 377 br = [ tuple(map(bin, b.split(" "))) for b in d.splitlines() ]
378 378 return br
379 379 except:
380 380 raise util.UnexpectedOutput(_("unexpected response:"), d)
381 381
382 382 def between(self, pairs):
383 383 n = "\n".join(["-".join(map(hex, p)) for p in pairs])
384 384 d = self.do_read("between", pairs=n)
385 385 try:
386 386 p = [ l and map(bin, l.split(" ")) or [] for l in d.splitlines() ]
387 387 return p
388 388 except:
389 389 raise util.UnexpectedOutput(_("unexpected response:"), d)
390 390
391 391 def changegroup(self, nodes, kind):
392 392 n = " ".join(map(hex, nodes))
393 393 f = self.do_cmd("changegroup", roots=n)
394 394 return util.chunkbuffer(zgenerator(f))
395 395
396 396 def changegroupsubset(self, bases, heads, source):
397 397 self.requirecap('changegroupsubset', _('look up remote changes'))
398 398 baselst = " ".join([hex(n) for n in bases])
399 399 headlst = " ".join([hex(n) for n in heads])
400 400 f = self.do_cmd("changegroupsubset", bases=baselst, heads=headlst)
401 401 return util.chunkbuffer(zgenerator(f))
402 402
403 403 def unbundle(self, cg, heads, source):
404 404 # have to stream bundle to a temp file because we do not have
405 405 # http 1.1 chunked transfer.
406 406
407 407 type = ""
408 408 types = self.capable('unbundle')
409 409 # servers older than d1b16a746db6 will send 'unbundle' as a
410 410 # boolean capability
411 411 try:
412 412 types = types.split(',')
413 413 except AttributeError:
414 414 types = [""]
415 415 if types:
416 416 for x in types:
417 417 if x in changegroup.bundletypes:
418 418 type = x
419 419 break
420 420
421 421 tempname = changegroup.writebundle(cg, None, type)
422 422 fp = httpsendfile(tempname, "rb")
423 423 try:
424 424 try:
425 425 rfp = self.do_cmd(
426 426 'unbundle', data=fp,
427 427 headers={'Content-Type': 'application/octet-stream'},
428 428 heads=' '.join(map(hex, heads)))
429 429 try:
430 430 ret = int(rfp.readline())
431 431 self.ui.write(rfp.read())
432 432 return ret
433 433 finally:
434 434 rfp.close()
435 435 except socket.error, err:
436 436 if err[0] in (errno.ECONNRESET, errno.EPIPE):
437 437 raise util.Abort(_('push failed: %s') % err[1])
438 438 raise util.Abort(err[1])
439 439 finally:
440 440 fp.close()
441 441 os.unlink(tempname)
442 442
443 443 def stream_out(self):
444 444 return self.do_cmd('stream_out')
445 445
446 446 class httpsrepository(httprepository):
447 447 def __init__(self, ui, path):
448 448 if not has_https:
449 449 raise util.Abort(_('Python support for SSL and HTTPS '
450 450 'is not installed'))
451 451 httprepository.__init__(self, ui, path)
452 452
453 453 def instance(ui, path, create):
454 454 if create:
455 455 raise util.Abort(_('cannot create new http repository'))
456 456 if path.startswith('https:'):
457 457 return httpsrepository(ui, path)
458 458 return httprepository(ui, path)
@@ -1,77 +1,89 b''
1 1 # Copyright (C) 2005, 2006, 2008 by Intevation GmbH
2 2 # Author(s):
3 3 # Thomas Arendsen Hein <thomas@intevation.de>
4 4 #
5 5 # This program is free software under the GNU GPL (>=v2)
6 6 # Read the file COPYING coming with the software for details.
7 7
8 8 """
9 9 Mercurial version
10 10 """
11 11
12 12 import os
13 import os.path
14 import sys
13 15 import re
14 16 import time
15 17
16 18 unknown_version = 'unknown'
17 19 remembered_version = False
18 20
19 21 def get_version(doreload=False):
20 22 """Return version information if available."""
21 23 try:
22 24 import mercurial.__version__
23 25 if doreload:
24 26 reload(mercurial.__version__)
25 27 version = mercurial.__version__.version
26 28 except ImportError:
27 29 version = unknown_version
28 30 return version
29 31
32 def get_useragent():
33 """Return some extended version information for the User-Agent
34 field in http requests."""
35 hgver = get_version()
36 pyver = '%s(%s)' % (sys.version.split()[0], hex(sys.hexversion))
37 ostype = os.name
38 plat = sys.platform
39 return 'mercurial/proto-1.0 (Python/%s; Mercurial/%s; %s/%s)' % \
40 (pyver, hgver, ostype, plat)
41
30 42 def write_version(version):
31 43 """Overwrite version file."""
32 44 if version == get_version():
33 45 return
34 46 directory = os.path.dirname(__file__)
35 47 for suffix in ['py', 'pyc', 'pyo']:
36 48 try:
37 49 os.unlink(os.path.join(directory, '__version__.%s' % suffix))
38 50 except OSError:
39 51 pass
40 52 f = open(os.path.join(directory, '__version__.py'), 'w')
41 53 f.write("# This file is auto-generated.\n")
42 54 f.write("version = %r\n" % version)
43 55 f.close()
44 56 # reload the file we've just written
45 57 get_version(True)
46 58
47 59 def remember_version(version=None):
48 60 """Store version information."""
49 61 global remembered_version
50 62 if not version and os.path.isdir(".hg"):
51 63 f = os.popen("hg identify") # use real hg installation
52 64 ident = f.read()[:-1]
53 65 if not f.close() and ident:
54 66 ids = ident.split(' ', 1)
55 67 version = ids.pop(0)
56 68 if version[-1] == '+':
57 69 version = version[:-1]
58 70 modified = True
59 71 else:
60 72 modified = False
61 73 if version.isalnum() and ids:
62 74 for tag in ids[0].split('/'):
63 75 # is a tag is suitable as a version number?
64 76 if re.match(r'^(\d+\.)+[\w.-]+$', tag):
65 77 version = tag
66 78 break
67 79 if modified:
68 80 version += time.strftime('+%Y%m%d')
69 81 if version:
70 82 remembered_version = True
71 83 write_version(version)
72 84
73 85 def forget_version():
74 86 """Remove version information."""
75 87 if remembered_version:
76 88 write_version(unknown_version)
77 89
General Comments 0
You need to be logged in to leave comments. Login now