def retry_http_krb_sspi_auth(self, host, req):
url = req.full_url
scheme, _, host, path = url.split('/', 3)
h = HTTPConnection(host) if scheme == 'http:' else HTTPSConnection(
host)
headers = dict(req.unredirected_hdrs)
headers.update(
dict((k, v) for k, v in req.headers.items() if k not in headers))
try:
__, krb_context = kerberos.authGSSClientInit("HTTP@" + host)
kerberos.authGSSClientStep(krb_context, "")
negotiate_details = kerberos.authGSSClientResponse(krb_context)
headers["Connection"] = "Keep-Alive"
headers["Authorization"] = "Negotiate " + negotiate_details
h.request(req.get_method(), req.selector, req.data, headers)
response = h.getresponse()
return addinfourl(response, response.msg, req.get_full_url(),
response.status)
except:
# e = sys.exc_info()[0]
# _log.warning(str(e))
# _log.warning('Failed Kerberos authentication')
return None
def s3_open(self, req):
orig_url = req.get_full_url()
from botocore.exceptions import ClientError
try:
url, headers, stream = _s3_open(orig_url)
return urllib_response.addinfourl(stream, headers, url)
except ClientError as err:
# if no such [KEY], but [KEY]/index.html exists,
# return that, instead.
if err.response['Error']['Code'] == 'NoSuchKey':
try:
_, headers, stream = _s3_open(
url_util.join(orig_url, 'index.html'))
return urllib_response.addinfourl(
stream, headers, orig_url)
except ClientError as err2:
if err.response['Error']['Code'] == 'NoSuchKey':
# raise original error
raise urllib_error.URLError(err)
raise urllib_error.URLError(err2)
raise urllib_error.URLError(err)
def gcs_open(req, *args, **kwargs):
"""Open a reader stream to a blob object on GCS
"""
import spack.util.gcs as gcs_util
url = url_util.parse(req.get_full_url())
gcsblob = gcs_util.GCSBlob(url)
if not gcsblob.exists():
raise web_util.SpackWebError('GCS blob {0} does not exist'.format(
gcsblob.blob_path))
stream = gcsblob.get_blob_byte_stream()
headers = gcsblob.get_blob_headers()
return urllib_response.addinfourl(stream, headers, url)
def open_local_file(self, req):
try:
host = req.host
filename = req.selector
# if that bombs, then go on with original method
localfile = url.url2pathname(host + filename)
stats = os.stat(localfile)
size = stats.st_size
modified = email.utils.formatdate(stats.st_mtime, usegmt=True)
mtype = mimetypes.guess_type(filename)[0]
headers = email.message_from_string(
'Content-type: %s\nContent-length: %d\nLast-modified: %s\n'
% (mtype or 'text/plain', size, modified))
origurl = 'file://' + host + filename
return addinfourl(open(localfile, 'rb'), headers, origurl)
except:
pass
return url.FileHandler.open_local_file(self, req)
def on_result(self):
if self._response is None:
return
fp = socket._fileobject(self._response, close=True)
result = urllib_response.addinfourl(fp, self._response.msg,
self._request.get_full_url())
result.code = self._response.status
result.msg = self._response.reason
# Run response processors
protocol = self._request.get_type()
method_name = protocol + '_response'
try:
for processor in self._processors.get(protocol, []):
method = getattr(processor, method_name)
result = method(self.request, result)
if result:
break
except Exception as err:
self.on_error(err)
else:
if self._on_result:
self._on_result(result)
def retry_http_ntlm_sspi_auth(self, host, req, authenticatehdr,
auth_header):
url = req.full_url
scheme, _, host, path = url.split('/', 3)
h = HTTPConnection(host) if scheme == 'http:' else HTTPSConnection(
host)
headers = dict(req.unredirected_hdrs)
headers.update(
dict((k, v) for k, v in req.headers.items() if k not in headers))
headers["Connection"] = "Keep-Alive"
headers[auth_header] = "NTLM " + self.get_auth_req()
h.request(req.get_method(), req.selector, req.data, headers)
response = h.getresponse()
response.fp = None # keep-alive
ntlmauth = response.headers.get(authenticatehdr)
if ntlmauth is not None and ntlmauth.startswith('NTLM '):
challenge = ntlmauth[5:]
challenge_response = self.create_challenge_response(challenge)
if challenge_response is None:
_log.warning('Failed to authenticate using NTLM')
return None
headers["Connection"] = "Close"
headers[auth_header] = "NTLM " + challenge_response
h.request(req.get_method(), req.selector, req.data, headers)
response = h.getresponse()
return addinfourl(response, response.msg, req.get_full_url(),
response.status)
def http_error_302(self, req, fp, code, msg, headers):
infourl = addinfourl(fp, headers, req.get_full_url())
infourl.status = code
infourl.code = code
return infourl
def add_response(self, url, status_code, headers, body=None):
response = addinfourl(StringIO(body or ''), headers, url, status_code)
responses = list(self.http_mock.side_effect)
responses.append(response)
self.http_mock.side_effect = responses
def http_error_206(self, req, fp, code, msg, hdrs):
# Range header supported
r = addinfourl(fp, hdrs, req.get_full_url())
r.code = code
r.msg = msg
return r
def add_response(self, url, status_code, headers, body=None):
response = addinfourl(StringIO(body or ''), headers, url, status_code)
responses = list(self.http_mock.side_effect)
responses.append(response)
self.http_mock.side_effect = responses
def https_open(self, req):
resp = addinfourl(StringIO(req.get_header('Cookie')), "mock message",
req.get_full_url())
resp.code = 200
resp.msg = "OK"
return resp
