Using XmlRPC through a proxy server for a host with authorization

Immediately make a reservation that we are talking about Python 2.X.

The task: to force xmlrpclib in Python to work through a proxy server with Basic and NTLM authorization, as well as with a host requiring authentication and Cookies.

I needed this for the bugreport system in our application, where when sending an error message to TRAC , a ticket with a description, logs, and other things should be created. Communication with TRAC goes through xmlRPC (using XmlRpcPlugin ). Application users mainly work behind a proxy server within the corporate network.
')
This is accomplished through the creation of a transport based on urllib , which redirects XML requests through a proxy server.

On the Internet you can find a couple of examples to support a proxy without authorization, written on the first urllib . At first I tried to take this example and add authorization to it, but in the end it became clear that it is better to rewrite it under urllib2 , where it is much easier to do this.

This transport option also supports operation without a proxy server (if a direct connection is available, and the specified proxy server is not, then the connection will occur directly - this is a feature of urllib2).

Python-ntlm is used to support NTLM authentication.

Just in case, I warn you that the code is presented only as an example and requires mandatory testing and modification for your needs.

Example of use:

Copy Source | Copy HTML serverURL = "http://some.server.com/xmlrpc" xmlTransport= UrllibTransport() server = xmlrpclib .ServerProxy(serverURL, transport = xmlTransport)

1. Copy Source | Copy HTML serverURL = "http://some.server.com/xmlrpc" xmlTransport= UrllibTransport() server = xmlrpclib .ServerProxy(serverURL, transport = xmlTransport)
3. Copy Source | Copy HTML serverURL = "http://some.server.com/xmlrpc" xmlTransport= UrllibTransport() server = xmlrpclib .ServerProxy(serverURL, transport = xmlTransport)
4. Copy Source | Copy HTML serverURL = "http://some.server.com/xmlrpc" xmlTransport= UrllibTransport() server = xmlrpclib .ServerProxy(serverURL, transport = xmlTransport)

The transport script itself:

Copy Source | Copy HTML

1. # - * - coding: utf8 - * -
3. # Requires python-ntlm (http://code.google.com/p/python-ntlm/) package
4. from ntlm import HTTPNtlmAuthHandler
6. import sys, os, tempfile, pickle
7. import xmlrpclib, getpass, string
8. import base64, urllib2, cookielib
9. from urllib import unquote, splittype, splithost, getproxies
10. import urllib2
12. ##################################
14. useProxy = True
15. useAuthOnProxy = True
17. proxyUser = "username"
18. proxyPassword = "password"
19. proxyServer = "http://proxy.org:37128"
21. httpAuthName = "user"
22. httpAuthPassword = "password"
23. serverTopLevelURL = "http://my.server.com"
25. ##################################
27. class UrllibTransport ( xmlrpclib .Transport):
28. def request (self, host, handler, request_body, verbose = 0 ):
29. self .verbose = verbose
31. if useProxy:
32. if useAuthOnProxy:
33. self .proxyurl = "http: //" + proxyUser + ":" \
34. + proxyPassword + "@" \
35. + proxyServer [ 7 :]
36. else :
37. self .proxyurl = proxyServer
38. else :
39. self .proxyurl = None
41. puser_pass = None
43. if self .proxyurl is not None:
44. type r_type = splittype ( self .proxyurl)
45. phost, XXX = splithost (r_type)
47. if '@' in phost:
48. user_pass, phost = phost.split ( '@' , 1 )
49. if ':' in user_pass:
50. user, password = user_pass.split ( ':' , 1 )
51. puser_pass = base64 .encodestring (
52. '% s:% s' % (unquote (user), unquote (password))). strip ()
54. proxies = { 'http' : 'http: //% s' % phost}
56. host = unquote (host)
57. address = "http: //% s% s" % (host, handler)
59. request = urllib2 .Request (address)
60. request .add_data (request_body)
61. request .add_header ( 'User-agent' , self .user_agent)
62. request .add_header ( "Content-Type" , "text / xml" )
64. # HTTP Auth
65. password_mgr = urllib2 .HTTPPasswordMgrWithDefaultRealm ()
66. top_level_url = serverTopLevelURL
67. password_mgr.add_password (None,
68. top_level_url,
69. httpAuthName,
70. httpAuthPassword)
71. handler = urllib2 .HTTPBasicAuthHandler (password_mgr)
73. # Cookies
74. cj = cookielib .CookieJar ()
76. if puser_pass:
77. # NTLM
78. passman = urllib2 .HTTPPasswordMgrWithDefaultRealm ()
79. passman.add_password (None, serverTopLevelURL, user, password)
81. authNTLM = HTTPNtlmAuthHandler.HTTPNtlmAuthHandler (passman)
82. request .add_header ( 'Proxy-authorization' , 'Basic' + puser_pass)
84. proxy_support = urllib2 .ProxyHandler (proxies)
86. opener = urllib2 .build_opener (handler, proxy_support,
87. urllib2 .HTTPCookieProcessor (cj),
88. authNTLM)
89. elif self .proxyurl:
90. # Proxy without auth
91. proxy_support = urllib2 .ProxyHandler (proxies)
92. opener = urllib2 .build_opener (proxy_support,
93. handler,
94. urllib2 .HTTPCookieProcessor (cj))
95. else :
96. # Direct connection
97. proxy_support = urllib2 .ProxyHandler ({})
98. opener = urllib2 .build_opener (proxy_support,
99. handler,
100. urllib2 .HTTPCookieProcessor (cj))
102. urllib2 .install_opener (opener)
103. response = urllib2 .urlopen ( request )
105. return self .parse_response (response)

PS
For anyone interested in urllib2, I recommend to look at urllib2 - The Missing Manual - an excellent document, which describes in detail the features of working with it, in particular, error handling and exceptions.