def on_connect(self, conn):
proxy_auth = _get_proxy_auth()
if conn.uri.is_ssl == "https":
proxy = os.environ.get('https_proxy')
if proxy:
if proxy_auth:
proxy_auth = 'Proxy-authorization: %s' % proxy_auth
proxy_connect = 'CONNECT %s:%s HTTP/1.0\r\n' % conn.addr
user_agent = "User-Agent: restkit/%s\r\n" % __version__
proxy_pieces = '%s%s%s\r\n' % (proxy_connect, proxy_auth,
user_agent)
proxy_uri = urlparse.urlparse(proxy)
proxy_host, proxy_port = util.parse_netloc(proxy_uri)
route = ((proxy_host, proxy_port), True, None, {})
pool = conn.get_pool(route)
try:
p_sock = pool.request()
except socket.error, e:
raise ProxyError(str(e))
conn.sock = p_sock
conn.addr = (proxy_host, proxy_port)
conn.is_ssl = True
def close(self):
""" Close all the connections related to the resource """
pool = self.client_opts.get('pool_instance')
if not pool:
return
parsed_url = urlparse.urlparse(self.uri)
pool.clear_host(util.parse_netloc(parsed_url))
def close(self):
""" Close all the connections related to the resource """
pool = self.client_opts.get('pool_instance')
if not pool:
return
parsed_url = urlparse.urlparse(self.uri)
pool.clear_host(util.parse_netloc(parsed_url))
def parse_url(self, url):
""" parse url and get host/port"""
self.uri = urlparse.urlparse(url)
if self.uri.scheme not in ('http', 'https'):
raise InvalidUrl("None valid url")
host, port = util.parse_netloc(self.uri)
self.host = host
self.port = port
def parse_url(self, url):
""" parse url and get host/port"""
self.uri = urlparse.urlparse(url)
if self.uri.scheme not in ('http', 'https'):
raise InvalidUrl("None valid url")
host, port = util.parse_netloc(self.uri)
self.host = host
self.port = port
def proxy_connection(self, request, req_addr, is_ssl):
""" do the proxy connection """
proxy_settings = os.environ.get('%s_proxy' % request.parsed_url.scheme)
if proxy_settings and proxy_settings is not None:
request.is_proxied = True
proxy_settings, proxy_auth = _get_proxy_auth(proxy_settings)
addr = parse_netloc(urlparse.urlparse(proxy_settings))
if is_ssl:
if proxy_auth:
proxy_auth = 'Proxy-authorization: %s' % proxy_auth
proxy_connect = 'CONNECT %s:%s HTTP/1.0\r\n' % req_addr
user_agent = request.headers.iget('user_agent')
if not user_agent:
user_agent = "User-Agent: restkit/%s\r\n" % __version__
proxy_pieces = '%s%s%s\r\n' % (proxy_connect, proxy_auth,
user_agent)
conn = self._pool.get(host=addr[0],
port=addr[1],
pool=self._pool,
is_ssl=is_ssl,
extra_headers=[],
**self.ssl_args)
conn.send(proxy_pieces)
p = HttpStream(SocketReader(conn.socket()),
kind=1,
decompress=True)
if p.status_code != 200:
raise ProxyError("Tunnel connection failed: %d %s" %
(resp.status_int, body))
_ = p.body_string()
else:
headers = []
if proxy_auth:
headers = [('Proxy-authorization', proxy_auth)]
conn = self._pool.get(host=addr[0],
port=addr[1],
pool=self._pool,
is_ssl=False,
extra_headers=[],
**self.ssl_args)
return conn
return
def on_connect(self, req):
proxy_auth = _get_proxy_auth()
if req.uri.scheme == "https":
proxy = os.environ.get("https_proxy")
if proxy:
if proxy_auth:
proxy_auth = "Proxy-authorization: %s" % proxy_auth
proxy_connect = "CONNECT %s HTTP/1.0\r\n" % (req.uri.netloc)
user_agent = "User-Agent: restkit/%s\r\n" % __version__
proxy_pieces = "%s%s%s\r\n" % (proxy_connect, proxy_auth, user_agent)
proxy_uri = urlparse.urlparse(proxy)
proxy_host, proxy_port = util.parse_netloc(proxy_uri)
if req.pool is not None:
s = req.pool.get((proxy_host, proxy_port))
if s:
self._sock = s
req.host = proxy_host
req.port = proxy_port
return
# Connect to the proxy server,
# very simple recv and error checking
p_sock = sock.connect((proxy_host, int(proxy_port)))
sock.send(p_sock, proxy_pieces)
# wait header
parser = http.ResponseParser(p_sock)
resp = parser.next()
if resp.status_int != 200:
raise ProxyError("Error status=%s" % resp.status)
sock._ssl_wrap_socket(p_sock, None, None)
# update socket
req._sock = p_sock
req.host = proxy_host
req.port = proxy_port
else:
proxy = os.environ.get("http_proxy")
if proxy:
proxy_uri = urlparse.urlparse(proxy)
proxy_host, proxy_port = self._host_port(proxy_uri)
if proxy_auth:
req.headers.append(("Proxy-Authorization", proxy_auth.strip()))
req.host = proxy_host
req.port = proxy_port
def proxy_connection(self, request, req_addr, is_ssl):
""" do the proxy connection """
proxy_settings = os.environ.get('%s_proxy' %
request.parsed_url.scheme)
if proxy_settings and proxy_settings is not None:
request.is_proxied = True
proxy_settings, proxy_auth = _get_proxy_auth(proxy_settings)
addr = parse_netloc(urlparse.urlparse(proxy_settings))
if is_ssl:
if proxy_auth:
proxy_auth = 'Proxy-authorization: %s' % proxy_auth
proxy_connect = 'CONNECT %s:%s HTTP/1.0\r\n' % req_addr
user_agent = request.headers.iget('user_agent')
if not user_agent:
user_agent = "User-Agent: restkit/%s\r\n" % __version__
proxy_pieces = '%s%s%s\r\n' % (proxy_connect, proxy_auth,
user_agent)
conn = self._session.get(host=addr[0], port=addr[1],
pool=self._session, is_ssl=is_ssl,
extra_headers=[], **self.ssl_args)
conn.send(proxy_pieces)
p = HttpStream(SocketReader(conn.socket()), kind=1,
decompress=True)
if p.status_code != 200:
raise ProxyError("Tunnel connection failed: %d %s" %
(resp.status_int, body))
_ = p.body_string()
else:
headers = []
if proxy_auth:
headers = [('Proxy-authorization', proxy_auth)]
conn = self._session.get(host=addr[0], port=addr[1],
pool=self._session, is_ssl=False,
extra_headers=[], **self.ssl_args)
return conn
return
def get_connection(self, request):
""" get a connection from the pool or create new one. """
addr = parse_netloc(request.parsed_url)
is_ssl = request.is_ssl()
extra_headers = []
conn = None
if self.use_proxy:
conn = self.proxy_connection(request, addr, is_ssl)
if not conn:
conn = self._pool.get(
host=addr[0], port=addr[1], pool=self._pool, is_ssl=is_ssl, extra_headers=extra_headers, **self.ssl_args
)
return conn
def proxy_connection(self, request, req_addr, is_ssl):
""" do the proxy connection """
proxy_settings = os.environ.get('%s_proxy' %
request.parsed_url.scheme)
if proxy_settings and proxy_settings is not None:
request.is_proxied = True
proxy_settings, proxy_auth = _get_proxy_auth(proxy_settings)
addr = parse_netloc(urlparse.urlparse(proxy_settings))
if is_ssl:
if proxy_auth:
proxy_auth = 'Proxy-authorization: %s' % proxy_auth
proxy_connect = 'CONNECT %s:%s HTTP/1.0\r\n' % req_addr
user_agent = request.headers.iget('user_agent')
if not user_agent:
user_agent = "User-Agent: restkit/%s\r\n" % __version__
proxy_pieces = '%s%s%s\r\n' % (proxy_connect, proxy_auth,
user_agent)
sck = self._manager.find_socket(addr, is_ssl)
if sck is None:
sck = self.connect(addr, is_ssl)
send(sck, proxy_pieces)
unreader = http.Unreader(sck)
resp = Request(unreader)
body = resp.body.read()
if resp.status_int != 200:
raise ProxyError("Tunnel connection failed: %d %s" %
(resp.status_int, body))
return sck, addr, []
else:
headers = []
if proxy_auth:
headers = [('Proxy-authorization', proxy_auth)]
sck = self._manager.find_socket(addr, is_ssl)
if sck is None:
sck = self.connect(addr, is_ssl)
return sck, addr, headers
return None, req_addr, []
def proxy_connection(self, request, req_addr, is_ssl):
""" do the proxy connection """
proxy_settings = os.environ.get('%s_proxy' %
request.parsed_url.scheme)
if proxy_settings and proxy_settings is not None:
request.is_proxied = True
proxy_settings, proxy_auth = _get_proxy_auth(proxy_settings)
addr = parse_netloc(urlparse.urlparse(proxy_settings))
if is_ssl:
if proxy_auth:
proxy_auth = 'Proxy-authorization: %s' % proxy_auth
proxy_connect = 'CONNECT %s:%s HTTP/1.0\r\n' % req_addr
user_agent = request.headers.iget('user_agent')
if not user_agent:
user_agent = "User-Agent: restkit/%s\r\n" % __version__
proxy_pieces = '%s%s%s\r\n' % (proxy_connect, proxy_auth,
user_agent)
sck = self._manager.find_socket(addr, is_ssl)
if sck is None:
sck = self.connect(addr, is_ssl)
send(sck, proxy_pieces)
unreader = http.Unreader(sck)
resp = http.Request(unreader)
body = resp.body.read()
if resp.status_int != 200:
raise ProxyError("Tunnel connection failed: %d %s" %
(resp.status_int, body))
return sck, addr, []
else:
headers = []
if proxy_auth:
headers = [('Proxy-authorization', proxy_auth)]
sck = self._manager.find_socket(addr, is_ssl)
if sck is None:
sck = self.connect(addr, is_ssl)
return sck, addr, headers
return None, req_addr, []
def proxy_connection(self, request, req_addr, is_ssl):
""" do the proxy connection """
proxy_settings = os.environ.get('%s_proxy' % request.parsed_url.scheme)
if proxy_settings and proxy_settings is not None:
request.is_proxied = True
proxy_settings, proxy_auth = _get_proxy_auth(proxy_settings)
addr = parse_netloc(urllib.parse.urlparse(proxy_settings))
if is_ssl:
if proxy_auth:
proxy_auth = 'Proxy-authorization: %s' % proxy_auth
proxy_connect = 'CONNECT %s:%s HTTP/1.0\r\n' % req_addr
user_agent = request.headers.iget('user_agent')
if not user_agent:
user_agent = "User-Agent: restkit/%s\r\n" % __version__
proxy_pieces = '%s%s%s\r\n' % (proxy_connect, proxy_auth,
user_agent)
conn = self._pool.get(host=addr[0],
port=addr[1],
pool=self._pool,
is_ssl=is_ssl,
timeout=self.timeout,
extra_headers=[],
proxy_pieces=proxy_pieces,
**self.ssl_args)
else:
headers = []
if proxy_auth:
headers = [('Proxy-authorization', proxy_auth)]
conn = self._pool.get(host=addr[0],
port=addr[1],
pool=self._pool,
is_ssl=False,
timeout=self.timeout,
extra_headers=[],
**self.ssl_args)
return conn
return
def get_connection(self, request):
""" get a connection from the pool or create new one. """
addr = parse_netloc(request.parsed_url)
is_ssl = request.is_ssl()
extra_headers = []
conn = None
if self.use_proxy:
conn = self.proxy_connection(request,
addr, is_ssl)
if not conn:
conn = self._pool.get(host=addr[0], port=addr[1],
pool=self._pool, is_ssl=is_ssl,
extra_headers=extra_headers, **self.ssl_args)
return conn
def get_connection(self, request):
""" get a connection from the pool or create new one. """
addr = parse_netloc(request.parsed_url)
is_ssl = request.is_ssl()
extra_headers = []
sck = None
if self.use_proxy:
sck, addr, extra_headers = self.proxy_connection(request, addr, is_ssl)
if not sck:
sck = self._manager.find_socket(addr, is_ssl)
if sck is None:
sck = self.connect(addr, is_ssl)
# set socket timeout in case default has changed
if self.timeout is not None:
sck.settimeout(self.timeout)
connection = Connection(sck, self._manager, addr, ssl=is_ssl, extra_headers=extra_headers)
return connection
def get_connection(self, request):
""" get a connection from the pool or create new one. """
addr = parse_netloc(request.parsed_url)
is_ssl = request.is_ssl()
extra_headers = []
sck = None
if self.use_proxy:
sck, addr, extra_headers = self.proxy_connection(request,
addr, is_ssl)
if not sck:
sck = self._manager.find_socket(addr, is_ssl)
if sck is None:
sck = self.connect(addr, is_ssl)
# set socket timeout in case default has changed
if self.timeout is not None:
sck.settimeout(self.timeout)
connection = Connection(sck, self._manager, addr,
ssl=is_ssl, extra_headers=extra_headers)
return connection
def proxy_connection(self, request, req_addr, is_ssl):
""" do the proxy connection """
proxy_settings = os.environ.get('%s_proxy' %
request.parsed_url.scheme)
if proxy_settings and proxy_settings is not None:
request.is_proxied = True
proxy_settings, proxy_auth = _get_proxy_auth(proxy_settings)
addr = parse_netloc(urlparse.urlparse(proxy_settings))
if is_ssl:
if proxy_auth:
proxy_auth = 'Proxy-authorization: %s' % proxy_auth
proxy_connect = 'CONNECT %s:%s HTTP/1.0\r\n' % req_addr
user_agent = request.headers.iget('user_agent')
if not user_agent:
user_agent = "User-Agent: restkit/%s\r\n" % __version__
proxy_pieces = '%s%s%s\r\n' % (proxy_connect, proxy_auth,
user_agent)
conn = self._pool.get(host=addr[0], port=addr[1],
pool=self._pool, is_ssl=is_ssl,
extra_headers=[], proxy_pieces=proxy_pieces, **self.ssl_args)
else:
headers = []
if proxy_auth:
headers = [('Proxy-authorization', proxy_auth)]
conn = self._pool.get(host=addr[0], port=addr[1],
pool=self._pool, is_ssl=False,
extra_headers=[], **self.ssl_args)
return conn
return
def on_connect(self, conn):
proxy_auth = _get_proxy_auth()
if conn.uri.is_ssl == "https":
proxy = os.environ.get("https_proxy")
if proxy:
if proxy_auth:
proxy_auth = "Proxy-authorization: %s" % proxy_auth
proxy_connect = "CONNECT %s:%s HTTP/1.0\r\n" % conn.addr
user_agent = "User-Agent: restkit/%s\r\n" % __version__
proxy_pieces = "%s%s%s\r\n" % (proxy_connect, proxy_auth, user_agent)
proxy_uri = urlparse.urlparse(proxy)
proxy_host, proxy_port = util.parse_netloc(proxy_uri)
route = ((proxy_host, proxy_port), True, None, {})
pool = conn.get_pool(route)
try:
p_sock = pool.request()
except socket.error, e:
raise ProxyError(str(e))
conn.sock = p_sock
conn.addr = (proxy_host, proxy_port)
conn.is_ssl = True
