def got_response(self, stream, request, response):
if response.code != "200":
LOG.complete("bad response")
self._schedule()
else:
LOG.complete()
s = response.body.read()
try:
m1 = marshal.unmarshal_object(s, "application/json", compat.RendezvousResponse)
except ValueError:
LOG.exception()
self._schedule()
else:
if "version" in m1.update and "uri" in m1.update:
ver, uri = m1.update["version"], m1.update["uri"]
LOG.info("Version %s available at %s" % (ver, uri))
STATE.update("update", {"version": ver, "uri": uri})
_open_browser_on_windows("update.html")
# Update tests known by the runner
runner_lst.update(m1.available)
#
# Choose the test we would like to run even if
# we're not going to run it because we're running
# in debug mode or tests are disabled.
# This allows us to print to the logger the test
# we /would/ have choosen if we were allowed to run
# it.
#
test = runner_lst.get_next_test()
if not test:
LOG.warning("No test available")
self._schedule()
return
LOG.info("* Chosen test: %s" % test)
# Are we allowed to run a test?
if not CONFIG["enabled"] or CONFIG["rendezvous.client.debug"]:
LOG.info("Tests are disabled... not running")
self._schedule()
else:
# Do we have negotiate URI for test?
negotiate_uri = runner_lst.test_to_negotiate_uri(test)
if not negotiate_uri:
LOG.warning("No negotiate URI for test")
self._schedule()
else:
# Actually run the test
runner_core.run(test, negotiate_uri, self._schedule)
def got_request_headers(self, stream, request):
ret = True
TRACKER.register_connection(stream, request["authorization"])
if request.uri == "/speedtest/upload":
request.body.write = lambda octets: None
only_auth = self.conf.get("speedtest.negotiate.auth_only", False)
if (only_auth and request.uri != "/speedtest/negotiate" and
not TRACKER.session_active(request["authorization"])):
LOG.warning("* Connection %s: Forbidden" % stream.logname)
ret = False
return ret
def collect_legacy(self, stream, request_body, request):
''' Invoked when we must save the result of a session '''
ident = str(hash(stream))
if ident not in self.clients:
#
# Before Neubot 0.4.2 we were using multiple connections
# for speedtest, which were used both for testing and for
# negotiating/collecting. Sometimes the connection used
# to collect is not the one used to negotiate: the code
# uses the one that terminates the upload first.
# When this happens we inspect the Authorization header
# before deciding the collect request is an abuse.
#
authorization = request['Authorization']
if authorization not in self.clients:
raise RuntimeError('Not authorized to collect')
else:
LOG.warning('speedtest: working around multiple conns issue')
ident = authorization
# Note: no more than one collect per session
self.clients.remove(ident)
#
# Backward compatibility: the variable name changed from
# can_share to can_publish after Neubot 0.4.5
#
if 'privacy_can_share' in request_body:
request_body['privacy_can_publish'] = request_body[
'privacy_can_share']
del request_body['privacy_can_share']
if privacy.collect_allowed(request_body):
table_speedtest.insert(DATABASE.connection(), request_body)
else:
LOG.warning('* bad privacy settings: %s' % str(stream))
return {}
def accept_failed(self, listener, exception):
''' Print a warning if accept() fails (often due to SSL) '''
LOG.warning("ServerHTTP: accept() failed: %s" % str(exception))
def accept_failed(self, listener, exception):
LOG.warning("ServerHTTP: accept() failed: %s" % str(exception))
logging.info("INFO w/ logging.info")
# The following should work because it should not interpolate
logging.debug("DEBUG w/ logging.debug", "ciao")
logging.warning("WARNING w/ logging.warning")
logging.error("ERROR w/ logging.error")
LOG.verbose()
logging.info("INFO w/ logging.info")
logging.debug("DEBUG w/ logging.debug")
logging.warning("WARNING w/ logging.warning")
logging.error("ERROR w/ logging.error")
LOG.error("testing neubot logger -- This is an error message")
LOG.warning("testing neubot logger -- This is an warning message")
LOG.info("testing neubot logger -- This is an info message")
LOG.debug("testing neubot logger -- This is a debug message")
print compat.json.dumps(LOG.listify())
try:
raise Exception("Testing LOG.exception")
except (KeyboardInterrupt, SystemExit):
raise
except:
LOG.exception()
LOG.exception(func=LOG.warning)
LOG.start("Testing the in-progress feature")
LOG.progress("...")
LOG.progress()
def got_response(self, stream, request, response):
if response.code != "200":
LOG.complete("bad response")
self._schedule()
else:
LOG.complete()
s = response.body.read()
try:
m1 = marshal.unmarshal_object(s, "application/json",
compat.RendezvousResponse)
except ValueError:
LOG.exception()
self._schedule()
else:
if "version" in m1.update and "uri" in m1.update:
ver, uri = m1.update["version"], m1.update["uri"]
LOG.info("Version %s available at %s" % (ver, uri))
STATE.update("update", {"version": ver, "uri": uri})
#
# Choose the test we would like to run even if
# we're not going to run it because we're running
# in debug mode or tests are disabled.
# This allows us to print to the logger the test
# we /would/ have choosen if we were allowed to run
# it.
#
tests = []
if "speedtest" in m1.available:
tests.append("speedtest")
if "bittorrent" in m1.available:
tests.append("bittorrent")
#XXX alternate the two tests
if self._latest:
tests.remove(self._latest)
test = random.choice(tests)
self._latest = test
LOG.info("* Chosen test: %s" % test)
# Are we allowed to run a test?
if not CONFIG["enabled"] or CONFIG["rendezvous.client.debug"]:
LOG.info("Tests are disabled... not running")
self._schedule()
else:
if (CONFIG["privacy.informed"] and
not CONFIG["privacy.can_collect"]):
LOG.warning("cannot run test without permission "
"to save the results")
self._schedule()
else:
conf = self.conf.copy()
#
# Subscribe _before_ connecting. This way we
# immediately see "testdone" if the connection fails
# and we can _schedule the next attempt.
#
NOTIFIER.subscribe("testdone", lambda *a, **kw: \
self._schedule())
if test == "speedtest":
conf["speedtest.client.uri"] = m1.available[
"speedtest"][0]
client = ClientSpeedtest(POLLER)
client.configure(conf)
client.connect_uri()
elif test == "bittorrent":
conf["bittorrent._uri"] = m1.available[
"bittorrent"][0]
bittorrent.run(POLLER, conf)
else:
NOTIFIER.publish("testdone")
def complain():
''' Complain with the user about privacy settings '''
LOG.warning('Neubot is disabled because privacy settings are not OK.')
LOG.warning('Please, set privacy settings via web user interface.')
LOG.warning('Alternatively, you can use the `neubot privacy` command.')
def __init__(self, key):
LOG.warning("arcfour: ARC4 support not available")
self.key = key
def process_request(self, stream, request):
''' Process rendezvous request '''
if request['content-type'] == 'application/json':
ibody = marshal.unmarshal_object(request.body.read(),
'application/json', compat.RendezvousRequest)
else:
ibody = marshal.unmarshal_object(request.body.read(),
"application/xml", compat.RendezvousRequest)
obody = compat.RendezvousResponse()
#
# If we don't say anything the rendezvous server is not
# going to prompt for updates. We need to specify the
# updated version number explicitly when we start it up.
# This should guarantee that we do not advertise -rc
# releases and other weird things.
#
version = self.conf["rendezvous.server.update_version"]
if version and ibody.version:
diff = utils_version.compare(version, ibody.version)
LOG.debug('rendezvous: version=%s ibody.version=%s diff=%f' % (
version, ibody.version, diff))
if diff > 0:
obody.update["uri"] = self.conf["rendezvous.server.update_uri"]
obody.update["version"] = version
#
# Select test server address.
# The default test server is the master server itself.
# If we know the country, lookup the list of servers for
# that country in the database.
# We only redirect to other servers clients that have
# agreed to give us the permission to publish, in order
# to be compliant with M-Lab policy.
# If there are no servers for that country, register
# the master server for the country so that we can notice
# we have new users and can take the proper steps to
# deploy nearby servers.
#
server = self.conf.get("rendezvous.server.default",
"master.neubot.org")
LOG.debug("* default test server: %s" % server)
#
# Backward compatibility: the variable name changed from
# can_share to can_publish after Neubot 0.4.5
#
request_body = ibody.__dict__.copy()
if 'privacy_can_share' in request_body:
request_body['privacy_can_publish'] = request_body[
'privacy_can_share']
del request_body['privacy_can_share']
# Redirect IFF have ALL privacy permissions
if privacy.count_valid(request_body, 'privacy_') == 3:
agent_address = stream.peername[0]
country = GEOLOCATOR.lookup_country(agent_address)
if country:
servers = table_geoloc.lookup_servers(DATABASE.connection(),
country)
if not servers:
LOG.info("* learning new country: %s" % country)
table_geoloc.insert_server(DATABASE.connection(),
country, server)
servers = [server]
server = random.choice(servers)
LOG.info("rendezvous_server: %s[%s] -> %s", agent_address,
country, server)
else:
LOG.warning('rendezvous_server: cannot redirect to M-Lab: %s',
request_body)
#
# We require at least informed and can_collect since 0.4.4
# (released 25 October 2011), so stop clients with empty
# privacy settings, who were still using master.
#
if privacy.collect_allowed(request_body):
if "speedtest" in ibody.accept:
obody.available["speedtest"] = [
"http://%s/speedtest" % server ]
if "bittorrent" in ibody.accept:
obody.available["bittorrent"] = [ "http://%s/" % server ]
#
# Neubot <=0.3.7 expects to receive an XML document while
# newer Neubots want a JSON. I hope old clients will upgrade
# pretty soon.
#
if ibody.version and utils_version.compare(ibody.version, "0.3.7") >= 0:
body = marshal.marshal_object(obody, "application/json")
mimetype = "application/json"
else:
body = compat.adhoc_marshaller(obody)
mimetype = "text/xml"
response = Message()
response.compose(code="200", reason="Ok",
mimetype=mimetype, body=body)
stream.send_response(request, response)
def got_have(self, index):
if self.state != UPLOADING:
raise RuntimeError("HAVE when state != UPLOADING")
self.peer_bitfield[index] = 1
# We don't use HAVE messages at the moment
LOG.warning("Ignoring unexpected HAVE message")