def test_chain(self):
try:
from OpenSSL import SSL # noqa
except ImportError:
logging.warning(
"Skipping chain test (install pyOpenSSL to activate test)")
return
client = http.Client()
try:
client.get_server_certificate_chain(
uri.URI.from_octets("http://www.pyslet.org/"))
self.fail("Can't get certificate chain from http URL")
except ValueError:
pass
chain = client.get_server_certificate_chain(
uri.URI.from_octets("https://code.google.com/p/qtimigration/"))
fpath = os.path.join(self.d, 'ca_certs.txt')
with open(fpath, 'wb') as f:
f.write(chain)
client = http.Client(ca_certs=fpath)
request = http.ClientRequest("https://code.google.com/p/qtimigration/")
try:
client.process_request(request)
except messages.HTTPException as err:
logging.error(err)
client.close()
def setUp(self): # noqa
self.port = random.randint(1111, 9999)
self.server = server.Server(port=self.port,
app=self.legacy_app,
protocol=params.HTTP_1p0)
self.server.timeout = 0.5
self.client = http.Client()
def __init__(self):
super(MultiTenantTPApp, self).__init__()
mt_settings = self.settings['MultiTenantTPApp']
self.google_id = mt_settings['google_client_id']
self.google_secret = mt_settings['google_client_secret']
# TODO: add configuration of certificates!
self.http = http.Client(ca_certs=self.cert_file)
def test_google_insecure(self):
client = http.Client()
request = http.ClientRequest("https://code.google.com/p/qtimigration/")
try:
client.process_request(request)
except messages.HTTPException as err:
logging.error(err)
client.close()
def setUp(self): # noqa
self.port = random.randint(1111, 9999)
self.server = server.Server(port=self.port,
app=self.legacy_app,
protocol=params.HTTP_1p0)
# We need to give time to prevent handle_request doing nothing
self.server.timeout = 10
self.client = http.Client()
def test_google_secure(self):
client = http.Client(
ca_certs=os.path.join(TEST_DATA_DIR, "ca_certs.txt"))
request = http.ClientRequest("https://code.google.com/p/qtimigration/")
try:
client.process_request(request)
except messages.HTTPException as err:
logging.error(err)
client.close()
client = http.Client(
ca_certs=os.path.join(TEST_DATA_DIR, "no_certs.txt"))
request = http.ClientRequest("https://code.google.com/p/qtimigration/")
try:
client.process_request(request)
if request.status != 0:
self.fail("Expected status=0 after security failure")
if not request.error:
self.fail("Expected error after security failure")
logging.info(str(request.error))
except messages.HTTPException as err:
logging.error(str(err))
client.close()
def fetch_url(url, username=None, password=None):
mgr = http.Client()
url = uri.URI.from_octets(url)
# does url end with $metadata?
if url.get_file_name() != "$metadata":
url = uri.URI.from_octets("$metadata").resolve(url)
if username:
cred = auth.BasicCredentials()
cred.userid = username
cred.password = password
cred.protectionSpace = url.get_canonical_root()
mgr.add_credentials(cred)
doc = edmx.Document(baseURI=url, reqManager=mgr)
doc.Read()
mgr.close()
if not doc.root.GetBase():
doc.root.SetBase(url)
return doc
def setup(cls, options=None, args=None, **kwargs):
"""Adds multi-tenant initialisation"""
super(MultiTenantTPApp, cls).setup(options, args, **kwargs)
mt_settings = cls.settings.setdefault('MultiTenantTPApp', {})
mt_settings.setdefault('google_client_id', '')
mt_settings.setdefault('google_client_secret', '')
cert_url = mt_settings.setdefault('google_certs', 'google_certs.pem')
cls.cert_file = cls.resolve_setup_path(cert_url)
if options and options.google_certs:
# update the certs_file and exit
c = http.Client()
certs = []
for s in ('https://accounts.google.com',
'https://www.googleapis.com', ):
url = URI.from_octets(s)
certs.append(c.get_server_certificate_chain(url))
with open(cls.cert_file, 'wb') as f:
f.write(string.join(certs, ''))
sys.exit(0)
def run_weather_loader(container=None,
max_load=30,
not_before="19950630T000000"):
"""Monitors the DTG website for new values
container
The EntityContainer containing the weather data.
max_load
The maximum number of days worth of data to load. When setting
up a new server this determines the rate at which the new server
will catch up.
This function is designed to be called once per day, it loads
historical data from the DTG website one day at a time up to a
maximum of max_load. If the data can't be loaded, e.g., because the
DTG site is not reachable, then the method backs off until it has
waited for approximately 1 hour after which it gives up. Therefore,
you should always set max_load greater than 1 to ensure that the
method catches up with the data after an outage.
The earliest date it will load is 30th June 1995, the latest date it
will load is yesterday."""
if container is None:
doc = load_metadata()
container = make_container(doc)
client = http.Client()
weather_data = container['DataPoints']
dtg = "http://www.cl.cam.ac.uk/research/dtg/weather/daily-text.cgi?%s"
not_before_point = iso.TimePoint.from_str(not_before)
with weather_data.open() as collection:
collection.set_orderby(
core.CommonExpression.orderby_from_str('TimePoint desc'))
sleep_interval = 60
collection.set_page(1)
last_point = list(collection.iterpage())
if last_point:
last_point = last_point[0]['TimePoint'].value
if last_point < not_before_point:
last_point = not_before_point
else:
last_point = not_before_point
next_day = last_point.date
n_loaded = 0
while n_loaded < max_load:
today = iso.TimePoint.from_now_utc().date
if next_day < today:
# Load in next_day
logging.info("Requesting data for %s", str(next_day))
century, year, month, day = next_day.get_calendar_day()
request = http.ClientRequest(dtg % str(next_day))
client.process_request(request)
if request.status == 200:
# process this file and move on to the next day
f = StringIO.StringIO(request.res_body)
load_data_from_file(weather_data, f, century * 100 + year,
month, day)
n_loaded += 1
next_day = next_day.offset(days=1)
if sleep_interval > 10:
sleep_interval = sleep_interval // 2
else:
# back off and try again
sleep_interval = sleep_interval * 2
else:
# we're done for today
client.idle_cleanup(0)
break
client.idle_cleanup(0)
if sleep_interval > 3600:
# site might be down, postpone
break
time.sleep(sleep_interval)
