def get_api_factory():
settings = dict(cookie_secret=randbits(128),
debug=GLSettings.log_requests_responses,
gzip=True)
GLAPIFactory = web.Application(spec, **settings)
GLAPIFactory.protocol = base.GLHTTPConnection
return GLAPIFactory
class GlobalHandler(HandlerTestCase):
app = web.Application(mainAPI, name='mainAPI')
@defer.inlineCallbacks
def test_global_handler(self):
response = yield self.request("/foo")
res = json.loads(response.body)
self.assertIn("error", res.keys())
self.assertIn(404, res.values())
def notaryAPI(notary):
HTTPAPI.notary = notary
app = web.Application([
(r'/chisel/scroll/(' + hash_regexp + ')/policy', ScrollPolicyHandler),
(r'/chisel/scroll/(' + hash_regexp + ')', ScrollReadHandler),
(r'/chisel/scroll', ScrollListHandler),
(r'/chisel/item/(' + hash_regexp + ')', ItemRWHandler),
(r'/chisel/item', ItemListHandler),
(r'/chisel/subscribe', SubscribeHandler),
(r'/.*', HTTPAPI),
])
return app
def get_app():
handlers = [
(r'/', IndexHandler),
(r'/search', SearchHandler),
]
app_settings = dict(
(k, getattr(settings, v.upper())) for (k, v) in SETTINGS_MAP)
# setup xapian
searchpool = SearchPool(settings.XAPIAN_DB)
reactor.callWhenRunning(searchpool.start)
app_settings['searchpool'] = searchpool
return web.Application(handlers, **app_settings)
def get_factory(self):
# create the hidden service directory of the panel
if not os.path.exists(self._paneldir):
os.mkdir(self._paneldir)
app = web.Application(
self.urls,
debug=True,
cookie_secret=config.custom['cookie_secret'],
login_url='/login.html',
xsrf_cookies=True,
template_path=self.templates_dir,
)
app.conf = self.conf
return app
class TestDefaultCollector(BaseTestBouncer):
app = web.Application(bouncerAPI, name='bouncerAPI')
def setUp(self, *args, **kw):
with open(bouncer_filename, 'w') as bouncer_file:
bouncer_file.write(fake_default_collector)
super(TestDefaultCollector, self).setUp()
@defer.inlineCallbacks
def test_default_collector(self):
data = {
'net-tests': [{
"test-helpers": [],
"input-hashes": [],
"name": 'imaginary_nettest',
"version": '1.0',
}]
}
response = yield self.request('/bouncer/net-tests', 'POST', data)
response_body = json.loads(response.body)
self.assertIn('net-tests', response_body)
self.assertEqual(len(response_body['net-tests']), 1)
self.assertIn('name', response_body['net-tests'][0])
self.assertEqual(response_body['net-tests'][0]['name'],
'imaginary_nettest')
self.assertIn('version', response_body['net-tests'][0])
self.assertEqual(response_body['net-tests'][0]['version'], '1.0')
self.assertIn('input-hashes', response_body['net-tests'][0])
self.assertEqual(len(response_body['net-tests'][0]['input-hashes']), 0)
self.assertIn('test-helpers', response_body['net-tests'][0])
self.assertEqual(len(response_body['net-tests'][0]['test-helpers']), 0)
self.assertIn('collector', response_body['net-tests'][0])
self.assertEqual(response_body['net-tests'][0]['collector'],
'default_collector')
self.assertIn('collector-alternate', response_body['net-tests'][0])
collector_alternate = response_body['net-tests'][0][
'collector-alternate']
self.assertEqual(collector_alternate[0], {
'type': 'https',
'address': 'https://a.collector.ooni.io'
})
self.assertEqual(collector_alternate[1], {
'type': 'http',
'address': 'http://a.collector.ooni.io'
})
def get_app():
handlers = [
(r'/', IndexHandler),
(r'/browse/?', BrowseHandler),
(r'/search/?', SearchHandler),
(r'/({})/?'.format(r'|'.join(CATEGORY_MAP.keys())), CategoryHandler),
]
app_settings = dict(
(k, getattr(settings, v.upper())) for (k,v) in SETTINGS_MAP
)
# leveldb
app_settings['levelpool'] = datastore.pool
# search
app_settings['searchclient'] = SearchClient(settings.SEARCH_ENDPOINT)
return web.Application(handlers, **app_settings)
def __init__(self, cfg):
cfg = cfg
bus0 = Relay(cfg.get("http", "multicast"), "leela.%s.http.multicast" % config.hostname())
bus1 = Relay(cfg.get("http", "timeline"), "leela.%s.http.timeline" % config.hostname())
sto = cassandra_proto.CassandraProto(cfg)
app = web.Application([
(r"^/v1/version$" , http_proto.Version),
(r"^/v1/data/past24/(.*)" , http_proto.Past24 , {"storage": sto, "class_" : data.Data}),
(r"^/v1/data/pastweek/(.*)" , http_proto.PastWeek , {"storage": sto, "class_" : data.Data}),
(r"^/v1/data/(\d+)/(\d+)/(\d+)/(.*)", http_proto.YearMonthDay , {"storage": sto, "class_" : data.Data}),
(r"^/v1/data/(\d+)/(\d+)/(.*)" , http_proto.YearMonth , {"storage": sto, "class_" : data.Data}),
(r"^/v1/data/(.*)" , http_proto.RangeDataRdwr , {"storage": sto, "class_" : data.Data, "relay": bus0}),
(r"^/v1/past24/(.*)" , http_proto.Past24 , {"storage": sto, "class_" : event.Event}),
(r"^/v1/pastweek/(.*)" , http_proto.PastWeek , {"storage": sto, "class_" : event.Event}),
(r"^/v1/(\d+)/(\d+)/(\d+)/(.*)" , http_proto.YearMonthDay , {"storage": sto, "class_" : event.Event}),
(r"^/v1/(\d+)/(\d+)/(.*)" , http_proto.YearMonth , {"storage": sto, "class_" : event.Event}),
(r"^/v1/(.*)" , http_proto.RangeMetricRdwr, {"storage": sto, "class_" : event.Event, "relay": bus1}),
(r".*" , resthandler.Always404)
])
self.srv = service.MultiService()
self.srv.addService(service.IService(internet.TCPServer(cfg.getint("http", "port"), app, interface=cfg.get("http", "address"))))
self.srv.addService(sto)
class TestMultipleCollectors(BaseTestBouncer):
app = web.Application(bouncerAPI, name='bouncerAPI')
def setUp(self, *args, **kw):
with open(bouncer_filename, 'w') as bouncer_file:
bouncer_file.write(fake_bouncer_file_multiple_collectors)
super(TestMultipleCollectors, self).setUp()
@defer.inlineCallbacks
def test_multiple_collectors(self):
data = {
'net-tests': [
{
"test-helpers": [],
"input-hashes": [],
"name": 'fake_nettest',
"version": '1.0',
},
]
}
response = yield self.request('/bouncer/net-tests', 'POST', data)
response_body = json.loads(response.body)
self.assertIn('net-tests', response_body)
self.assertEqual(len(response_body['net-tests']), 1)
self.assertIn('name', response_body['net-tests'][0])
self.assertEqual(response_body['net-tests'][0]['name'], 'fake_nettest')
self.assertIn('version', response_body['net-tests'][0])
self.assertEqual(response_body['net-tests'][0]['version'], '1.0')
self.assertIn('input-hashes', response_body['net-tests'][0])
self.assertEqual(len(response_body['net-tests'][0]['input-hashes']), 0)
self.assertIn('test-helpers', response_body['net-tests'][0])
self.assertEqual(len(response_body['net-tests'][0]['test-helpers']), 0)
self.assertIn('collector', response_body['net-tests'][0])
self.assertIn(response_body['net-tests'][0]['collector'],
['fake_addressA', 'fake_addressB'])
from cyclone import web
from oonib.deck.api import deckAPI
from oonib.report.api import reportAPI
from oonib.input.api import inputAPI
from oonib.policy.api import policyAPI
from oonib.bouncer.api import bouncerAPI
from oonib import config
ooniBouncer = None
ooniBackendAPI = []
ooniBackendAPI += reportAPI
if config.main.input_dir:
ooniBackendAPI += inputAPI
if config.main.deck_dir:
ooniBackendAPI += deckAPI
if config.main.policy_file:
ooniBackendAPI += policyAPI
if config.main.bouncer_file:
ooniBouncer = web.Application(bouncerAPI, debug=True)
ooniBackend = web.Application(ooniBackendAPI, debug=True)
class TestReport(HandlerTestCase):
app = web.Application(reportAPI, name='reportAPI')
@defer.inlineCallbacks
def update_report(self, report_id, content=sample_report_entry):
data = {
'content': content
}
response = yield self.request(
'/report/%s' % report_id,
"POST", data)
defer.returnValue(response)
@defer.inlineCallbacks
def test_create_valid_report(self):
data = {
'software_name': 'ooni-test',
'software_version': '0.1',
'test_name': 'some-test',
'test_version': '0.1',
'probe_asn': 'AS0'
}
response = yield self.request('/report', "POST", data)
response_body = json.loads(response.body)
self.assertIn('backend_version', response_body)
self.assertIn('report_id', response_body)
self.filenames.add(response_body['report_id'])
@defer.inlineCallbacks
def test_create_valid_report_with_content(self):
data = {
'software_name': 'ooni-test',
'software_version': '0.1',
'test_name': 'some-test',
'test_version': '0.1',
'probe_asn': 'AS0',
'content': sample_report_header
}
response = yield self.request('/report', "POST", data)
response_body = json.loads(response.body)
self.assertIn('backend_version', response_body)
self.assertIn('report_id', response_body)
self.filenames.add(response_body['report_id'])
@defer.inlineCallbacks
def test_create_invalid_report(self):
data = {
'software_name': 'ooni-test',
'software_version': '0.1',
'test_name': 'some-test',
'test_version': '0.1',
'probe_asn': 'XXX'
}
response = yield self.request('/report', "POST", data)
response_body = json.loads(response.body)
self.assertIn('error', response_body)
self.assertEqual(response_body['error'],
'invalid-request-field probe_asn')
@defer.inlineCallbacks
def test_create_and_update_report(self):
report_header = {
'software_name': 'ooni-test',
'software_version': '0.1',
'test_name': 'some-test',
'test_version': '0.1',
'probe_asn': 'AS0'
}
response = yield self.request('/report', "POST", report_header)
response_body = json.loads(response.body)
self.assertIn('backend_version', response_body)
self.assertIn('report_id', response_body)
report_id = response_body['report_id']
response = yield self.update_report(report_id)
response_body = json.loads(response.body)
with open(report_id) as f:
self.filenames.add(report_id)
written_report = yaml.safe_load_all(f)
written_report_header = written_report.next()
for key in report_header.keys():
self.assertEqual(written_report_header[key], report_header[key])
self.assertEqual(yaml.safe_load(sample_report_entry),
written_report.next())
@defer.inlineCallbacks
def test_create_update_and_close_report(self):
report_header = {
'software_name': 'ooni-test',
'software_version': '0.1',
'test_name': 'some-test',
'test_version': '0.1',
'probe_asn': 'AS0'
}
response = yield self.request('/report', "POST", report_header)
response_body = json.loads(response.body)
self.assertIn('backend_version', response_body)
self.assertIn('report_id', response_body)
report_entry_count = 100
report_id = response_body['report_id']
for i in range(report_entry_count):
yield self.update_report(report_id)
with open(report_id) as f:
written_report = yaml.safe_load_all(f)
written_report_header = written_report.next()
for key in report_header.keys():
self.assertEqual(written_report_header[key],
report_header[key])
self.assertEqual(yaml.safe_load(sample_report_entry),
written_report.next())
response = yield self.request('/report/%s/close' % report_id, "POST")
written_report_path = report_file_name(".", written_report_header)
with open(written_report_path) as f:
self.filenames.add(written_report_path)
written_report = yaml.safe_load_all(f)
written_report.next()
for i in range(report_entry_count):
self.assertEqual(yaml.safe_load(sample_report_entry),
written_report.next())
self.directories.add('ZZ')
report_data = parsed_request
new_report = models.Report()
print "Got %s as request" % parsed_request
result = yield new_report.new(report_data)
self.write(result)
self.finish()
def put(self):
"""
Update an already existing report.
{'report_id': 'XXX',
'content': 'XXX'
}
"""
pass
class PCAPReportHandler(web.RequestHandler):
def get(self):
pass
def post(self):
pass
reportingBackendAPI = [(r"/report/new", NewReportHandlerFile),
(r"/report/pcap", PCAPReportHandler)]
reportingBackend = web.Application(reportingBackendAPI, debug=True)
class TestReport(HandlerTestCase):
app = web.Application(reportAPI, name='reportAPI')
@defer.inlineCallbacks
def update_report(self,
report_id,
content=sample_report_entry_yaml,
format="yaml"):
data = {'content': content, 'format': format}
response = yield self.request('/report/%s' % report_id, "POST", data)
defer.returnValue(response)
@defer.inlineCallbacks
def test_create_valid_report(self):
response = yield self.request('/report', "POST", dummy_data)
response_body = json.loads(response.body)
self.assertIn('backend_version', response_body)
self.assertIn('report_id', response_body)
self.filenames.add(response_body['report_id'])
@defer.inlineCallbacks
def test_create_valid_report_with_content(self):
data = deepcopy(dummy_data)
data['content'] = sample_report_header_yaml
response = yield self.request('/report', "POST", data)
response_body = json.loads(response.body)
self.assertIn('backend_version', response_body)
self.assertIn('report_id', response_body)
self.filenames.add(response_body['report_id'])
closeReport(response_body['report_id'])
@defer.inlineCallbacks
def test_create_invalid_report(self):
data = deepcopy(dummy_data)
data['probe_asn'] = 'XXXINVALID'
response = yield self.request('/report', "POST", data)
response_body = json.loads(response.body)
self.assertIn('error', response_body)
self.assertEqual(response_body['error'],
'invalid-request-field probe_asn')
@defer.inlineCallbacks
def test_create_and_update_report(self):
response = yield self.request('/report', "POST", dummy_data)
response_body = json.loads(response.body)
self.assertIn('backend_version', response_body)
self.assertIn('report_id', response_body)
report_id = response_body['report_id']
response = yield self.update_report(report_id)
response_body = json.loads(response.body)
with open(report_id) as f:
self.filenames.add(report_id)
written_report = yaml.safe_load_all(f)
written_report_header = written_report.next()
for key in dummy_data.keys():
self.assertEqual(written_report_header[key], dummy_data[key])
self.assertEqual(yaml.safe_load(sample_report_entry_yaml),
written_report.next())
closeReport(report_id)
@defer.inlineCallbacks
def test_create_update_and_close_report(self):
response = yield self.request('/report', "POST", dummy_data)
response_body = json.loads(response.body)
self.assertIn('backend_version', response_body)
self.assertIn('report_id', response_body)
report_entry_count = 100
report_id = response_body['report_id']
for i in range(report_entry_count):
yield self.update_report(report_id)
with open(report_id) as f:
written_report = yaml.safe_load_all(f)
written_report_header = written_report.next()
for key in dummy_data.keys():
self.assertEqual(written_report_header[key], dummy_data[key])
self.assertEqual(yaml.safe_load(sample_report_entry_yaml),
written_report.next())
response = yield self.request('/report/%s/close' % report_id, "POST")
written_report_header['format'] = 'yaml'
written_report_path = report_file_path(FilePath("."),
written_report_header,
report_id)
with written_report_path.open('r') as f:
self.filenames.add(written_report_path.path)
written_report = yaml.safe_load_all(f)
written_report.next()
for i in range(report_entry_count):
self.assertEqual(yaml.safe_load(sample_report_entry_yaml),
written_report.next())
@defer.inlineCallbacks
def test_create_update_and_close_report_json(self):
report_header = dummy_data.copy()
report_header['format'] = 'json'
response = yield self.request('/report', "POST", report_header)
response_body = json.loads(response.body)
self.assertIn('backend_version', response_body)
self.assertIn('report_id', response_body)
report_entry_count = 100
report_id = response_body['report_id']
for i in range(report_entry_count):
yield self.update_report(report_id,
content=sample_report_entry,
format="json")
response = yield self.request('/report/%s/close' % report_id, "POST")
written_report_path = report_file_path(FilePath("."), report_header,
report_id)
with written_report_path.open('r') as f:
self.filenames.add(written_report_path.path)
for line in f:
written_report = json.loads(line)
self.assertEqual(sample_report_entry, written_report)
@defer.inlineCallbacks
def test_create_update_reap(self):
mock_time = MockTime()
report_header = dummy_data.copy()
report_header['format'] = 'json'
response = yield self.request('/report', "POST", report_header)
response_body = json.loads(response.body)
self.assertIn('backend_version', response_body)
self.assertIn('report_id', response_body)
report_entry_count = 100
report_id = response_body['report_id']
for i in range(report_entry_count):
yield self.update_report(report_id,
content=sample_report_entry,
format="json")
mock_time.advance(config.main.stale_time + 1)
delayed_call = checkForStaleReports(mock_time)
delayed_call.cancel()
written_report_path = report_file_path(FilePath("."), report_header,
report_id)
with written_report_path.open('r') as f:
self.filenames.add(written_report_path.path)
for line in f:
written_report = json.loads(line)
self.assertEqual(sample_report_entry, written_report)
# do all the necessary high level wiring to make everything work together.
# Specifically we create the cyclone web.Application from the API specification,
# we create a TCPServer for it and setup logging.
# We also set to kill the threadpool (the one used by Storm) when the
# application shuts down.
from twisted.application.service import Application
from twisted.application import internet
from cyclone import web
from globaleaks.utils.utility import randbits
from globaleaks.settings import GLSetting
from globaleaks.rest import api
from globaleaks.handlers.base import GLHTTPServer
application = Application('GLBackend')
settings = dict(cookie_secret=randbits(128),
xsrf_cookies=True,
debug=GLSetting.http_log)
# Initialize the web API event listener, handling all the synchronous operations
GLBackendAPIFactory = web.Application(api.spec, **settings)
GLBackendAPIFactory.protocol = GLHTTPServer
for ip in GLSetting.bind_addresses:
GLBackendAPI = internet.TCPServer(GLSetting.bind_port, GLBackendAPIFactory, interface=ip)
GLBackendAPI.setServiceParent(application)
# define exit behaviour
#!/usr/bin/env python
from twisted.application.service import Application
from twisted.application import internet
from cyclone import web
from bridgeherder import log, api
application = Application('BridgeHerder')
bridgeHerderAPIFactory = web.Application(api.spec, debug=True)
bridgeHerderAPI = internet.TCPServer(31337, bridgeHerderAPIFactory)
bridgeHerderAPI.setServiceParent(application)
# instantiate an interface manager and configure addresses
# using auto=True will automatically manage networks attached
# to this computer
#ai = AutoInterfaceManager(auto=True)
# given some configuration options, and an interface manager, map
# addresses and ports into a set of bridge config files
#m = BridgeManager(config=hc, interface_manager=ai)
#m = addWebServer(hc, ai)
#m.start()
from cyclone import web
from oonib.main.api import mainAPI
from oonib.deck.api import deckAPI
from oonib.report.api import reportAPI
from oonib.input.api import inputAPI
from oonib.policy.api import policyAPI
from oonib.bouncer.api import bouncerAPI
from oonib.config import config
ooniBouncer = None
ooniBackendAPI = []
ooniBackendAPI += reportAPI
if config.main.input_dir:
ooniBackendAPI += inputAPI
if config.main.deck_dir:
ooniBackendAPI += deckAPI
if config.main.policy_file:
ooniBackendAPI += policyAPI
if config.main.bouncer_file:
ooniBouncer = web.Application(bouncerAPI, debug=True, name='bouncer')
ooniBackendAPI += mainAPI
ooniBackend = web.Application(ooniBackendAPI, debug=True, name='collector')
class TestHelperTests(BaseTestBouncer):
app = web.Application(bouncerAPI, name='bouncerAPI')
def setUp(self, *args, **kw):
with open(bouncer_filename, 'w') as bouncer_file:
bouncer_file.write(fake_for_test_helper_request)
super(TestHelperTests, self).setUp()
@defer.inlineCallbacks
def test_invalid_helper(self):
data = {
'test-helpers': ['invalid_test_helper']
}
response = yield self.request('/bouncer/test-helpers', 'POST', data)
response_body = json.loads(response.body)
self.assertIn('error', response_body)
self.assertEqual('test-helper-not-found', response_body['error'])
@defer.inlineCallbacks
def test_multiple_collectors(self):
data = {
'test-helpers': ['fake_test_helper']
}
response = yield self.request('/bouncer/test-helpers', 'POST', data)
response_body = json.loads(response.body)
self.assertEqual(len(response_body), 2)
self.assertIn('fake_test_helper', response_body)
self.assertIn('collector', response_body['fake_test_helper'])
self.assertIn(response_body['fake_test_helper']['collector'], ['fake_addressA', 'fake_addressB'])
self.assertIn('address', response_body['fake_test_helper'])
self.assertEqual('fake_hostname', response_body['fake_test_helper']['address'])
self.assertIn('default', response_body)
self.assertIn('collector', response_body['default'])
self.assertEqual('fake_addressB', response_body['default']['collector'])
@defer.inlineCallbacks
def test_backward_compatibility(self):
data = {
'test-helpers': ['fake_test_helper']
}
response = yield self.request('/bouncer', 'POST', data)
response_body = json.loads(response.body)
self.assertEqual(len(response_body), 2)
self.assertIn('fake_test_helper', response_body)
self.assertIn('collector', response_body['fake_test_helper'])
self.assertIn(response_body['fake_test_helper']['collector'], ['fake_addressA', 'fake_addressB'])
self.assertIn('address', response_body['fake_test_helper'])
self.assertEqual('fake_hostname', response_body['fake_test_helper']['address'])
self.assertIn('default', response_body)
self.assertIn('collector', response_body['default'])
self.assertEqual('fake_addressB', response_body['default']['collector'])
@defer.inlineCallbacks
def test_multiple_helpers(self):
data = {
'test-helpers': ['fake_test_helper', 'exotic_test_helper']
}
response = yield self.request('/bouncer/test-helpers', 'POST', data)
response_body = json.loads(response.body)
self.assertEqual(len(response_body), 3)
self.assertIn('fake_test_helper', response_body)
self.assertIn('exotic_test_helper', response_body)
self.assertIn('default', response_body)
self.assertIn(response_body['fake_test_helper']['collector'], ['fake_addressA', 'fake_addressB'])
self.assertEqual(response_body['exotic_test_helper']['collector'], 'fake_addressA')
self.assertEqual('fake_addressB', response_body['default']['collector'])
class TestProductionTests(BaseTestBouncer):
app = web.Application(bouncerAPI, name='bouncerAPI')
def setUp(self, *args, **kw):
with open(bouncer_filename, 'w') as bouncer_file:
bouncer_file.write(production_bouncer_file)
super(TestProductionTests, self).setUp()
@defer.inlineCallbacks
def test_default_deck(self):
data = {
'net-tests': [{
'test-helpers': ['tcp-echo'],
'version': '0.2',
'name': 'http_invalid_request_line',
'input-hashes': []
}, {
'test-helpers': ['http-return-json-headers'],
'version': '0.1.5',
'name': 'http_header_field_manipulation',
'input-hashes': []
}, {
'test-helpers': ['web-connectivity'],
'version':
'0.1.0',
'name':
'web_connectivity',
'input-hashes': [
'b8c6c07b3bce38bd15e4253ee99b5193880881653153d9c065f06c29735a1be6'
]
}, {
'test-helpers': ['web-connectivity'],
'version':
'0.1.0',
'name':
'web_connectivity',
'input-hashes': [
'86a8bb1d2eddb562388b8c040534284f7796976c3ef3984c9b10c8ac0e83853b'
]
}]
}
response = yield self.request('/bouncer/net-tests', 'POST', data)
response_body = json.loads(response.body)
self.assertEqual(len(response_body['net-tests']), 4)
@defer.inlineCallbacks
def test_traceroute(self):
data = {
'net-tests': [
{
'test-helpers': ['traceroute'],
'version': '0.2',
'name': 'traceroute',
'input-hashes': []
},
]
}
response = yield self.request('/bouncer/net-tests', 'POST', data)
response_body = json.loads(response.body)
print(response_body['net-tests'])
args = ap.parse_args()
l = logging.getLogger()
l.setLevel(loglevel)
format_str = '[cp_pushd' \
+ ':%(module)s:%(name)s:%(lineno)d] ' \
'%(levelname)s: %(message)s'
term_format = logging.Formatter(fmt='%(asctime)s ' + format_str)
# log to stdout for now
h = logging.StreamHandler(sys.stdout)
h.setFormatter(term_format)
l.addHandler(h)
obs = twisted_log.PythonLoggingObserver()
obs.start()
# init catchpoint node list
nodes = catchpoint_nodes(args.key, args.secret)
nodes.update_node_list()
tsdb = OpenTSDBFactory()
reactor.connectTCP(args.tsdb_host, args.tsdb_port, tsdb)
app = web.Application([(r'/', cp_push_request, dict(tsdb=tsdb))],
xheaders=True,
debug=True)
reactor.listenTCP(port=args.listen, factory=app)
reactor.run()
class TestBouncer(BaseTestBouncer):
app = web.Application(bouncerAPI, name='bouncerAPI')
def setUp(self, *args, **kw):
with open(bouncer_filename, 'w') as bouncer_file:
bouncer_file.write(fake_bouncer_file)
super(TestBouncer, self).setUp()
@defer.inlineCallbacks
def test_void_net_tests(self):
data = {
'net-tests': [
{
"test-helpers": ['fake_test_helper'],
"input-hashes": [],
"name": '',
"version": '',
},
]
}
response = yield self.request('/bouncer/net-tests', 'POST', data)
response_body = json.loads(response.body)
self.assertIn('error', response_body)
self.assertEqual('collector-not-found', response_body['error'])
@defer.inlineCallbacks
def test_net_tests(self):
data = {
'net-tests': [
{
"test-helpers": [],
"input-hashes": [],
"name": 'fake_nettest',
"version": '1.0',
},
]
}
response = yield self.request('/bouncer/net-tests', 'POST', data)
response_body = json.loads(response.body)
self.assertIn('net-tests', response_body)
self.assertEqual(len(response_body['net-tests']), 1)
self.assertIn('name', response_body['net-tests'][0])
self.assertEqual(response_body['net-tests'][0]['name'], 'fake_nettest')
self.assertIn('version', response_body['net-tests'][0])
self.assertEqual(response_body['net-tests'][0]['version'], '1.0')
self.assertIn('input-hashes', response_body['net-tests'][0])
self.assertEqual(len(response_body['net-tests'][0]['input-hashes']), 0)
self.assertIn('test-helpers', response_body['net-tests'][0])
self.assertEqual(len(response_body['net-tests'][0]['test-helpers']), 0)
self.assertIn('collector', response_body['net-tests'][0])
self.assertEqual(response_body['net-tests'][0]['collector'], 'fake_address')
@defer.inlineCallbacks
def test_backward_compatibility(self):
data = {
'net-tests': [
{
"test-helpers": [],
"input-hashes": [],
"name": 'fake_nettest',
"version": '1.0',
},
]
}
response = yield self.request('/bouncer', 'POST', data)
response_body = json.loads(response.body)
self.assertIn('net-tests', response_body)
self.assertEqual(len(response_body['net-tests']), 1)
self.assertIn('name', response_body['net-tests'][0])
self.assertEqual(response_body['net-tests'][0]['name'], 'fake_nettest')
self.assertIn('version', response_body['net-tests'][0])
self.assertEqual(response_body['net-tests'][0]['version'], '1.0')
self.assertIn('input-hashes', response_body['net-tests'][0])
self.assertEqual(len(response_body['net-tests'][0]['input-hashes']), 0)
self.assertIn('test-helpers', response_body['net-tests'][0])
self.assertEqual(len(response_body['net-tests'][0]['test-helpers']), 0)
self.assertIn('collector', response_body['net-tests'][0])
self.assertEqual(response_body['net-tests'][0]['collector'], 'fake_address')
@defer.inlineCallbacks
def test_multiple_net_tests(self):
data = {
'net-tests': [
{
"test-helpers": [],
"input-hashes": [],
"name": 'fake_nettest',
"version": '1.0',
},
{
"test-helpers": [],
"input-hashes": [],
"name": 'another_fake_nettest',
"version": '1.0',
}
]
}
response = yield self.request('/bouncer/net-tests', 'POST', data)
response_body = json.loads(response.body)
self.assertIn('net-tests', response_body)
self.assertEqual(len(response_body['net-tests']), 2)
self.assertIn('name', response_body['net-tests'][0])
self.assertEqual(response_body['net-tests'][0]['name'], 'fake_nettest')
self.assertIn('name', response_body['net-tests'][1])
self.assertEqual(response_body['net-tests'][1]['name'], 'another_fake_nettest')
@defer.inlineCallbacks
def test_invalid_net_test(self):
data = {
'net-tests': [
{
"test-helpers": [],
"input-hashes": [],
"name": 'invalid_nettest',
"version": '1.0',
},
]
}
response = yield self.request('/bouncer/net-tests', 'POST', data)
response_body = json.loads(response.body)
self.assertIn('error', response_body)
self.assertEqual('collector-not-found', response_body['error'])
@defer.inlineCallbacks
def test_net_tests_with_input(self):
data = {
'net-tests': [
{
"test-helpers": [],
"input-hashes": ['fake_id'],
"name": 'fake_nettest',
"version": '1.0',
},
]
}
response = yield self.request('/bouncer/net-tests', 'POST', data)
response_body = json.loads(response.body)
self.assertIn('net-tests', response_body)
self.assertEqual(len(response_body['net-tests']), 1)
self.assertIn('name', response_body['net-tests'][0])
self.assertEqual(response_body['net-tests'][0]['name'], 'fake_nettest')
self.assertIn('input-hashes', response_body['net-tests'][0])
self.assertEqual(len(response_body['net-tests'][0]['input-hashes']), 1)
self.assertEqual(response_body['net-tests'][0]['input-hashes'][0], 'fake_id')
@defer.inlineCallbacks
def test_net_tests_with_input_invalid_id(self):
data = {
'net-tests': [
{
"test-helpers": [],
"input-hashes": ['invalid_id'],
"name": 'fake_nettest',
"version": '1.0',
},
]
}
response = yield self.request('/bouncer/net-tests', 'POST', data)
response_body = json.loads(response.body)
self.assertIn('error', response_body)
self.assertEqual('collector-not-found', response_body['error'])
@defer.inlineCallbacks
def test_net_tests_with_test_helper(self):
data = {
'net-tests': [
{
"test-helpers": ['fake_test_helper'],
"input-hashes": [],
"name": 'fake_nettest',
"version": '1.0',
},
]
}
response = yield self.request('/bouncer/net-tests', 'POST', data)
response_body = json.loads(response.body)
self.assertIn('net-tests', response_body)
self.assertEqual(len(response_body['net-tests']), 1)
self.assertIn('name', response_body['net-tests'][0])
self.assertEqual(response_body['net-tests'][0]['name'], 'fake_nettest')
self.assertIn('test-helpers', response_body['net-tests'][0])
self.assertEqual(len(response_body['net-tests'][0]['test-helpers']), 1)
self.assertEqual(response_body['net-tests'][0]['test-helpers']['fake_test_helper'], 'fake_hostname')
@defer.inlineCallbacks
def test_net_tests_with_invalid_test_helper(self):
data = {
'net-tests': [
{
"test-helpers": ['invalid_test_helper'],
"input-hashes": [],
"name": 'fake_nettest',
"version": '1.0',
},
]
}
response = yield self.request('/bouncer/net-tests', 'POST', data)
response_body = json.loads(response.body)
self.assertIn('error', response_body)
self.assertEqual('collector-not-found', response_body['error'])
@defer.inlineCallbacks
def test_invalid_request(self):
data = {
'something_weird': 'nsa'
}
response = yield self.request('/bouncer', 'POST', data)
response_body = json.loads(response.body)
self.assertIn('error', response_body)
self.assertEqual('test-helpers-or-net-test-key-missing', response_body['error'])
@check_xsrf
def get(self, test_id):
"""
Returns the requested test_id details and the stored results for such
test.
"""
try:
test = copy.deepcopy(oonidApplication.director.netTests[test_id])
test.pop('path')
test['results'] = get_test_results(test_id)
self.write(test)
except KeyError:
self.write({'error':
'Test with such ID not found!'})
config.read_config_file()
oonidAPI = [
(r"/status", Status),
(r"/inputs", Inputs),
(r"/test", ListTests),
(r"/test/(.*)/start", StartTest),
(r"/test/(.*)/stop", StopTest),
(r"/test/(.*)", TestStatus),
(r"/(.*)", web.StaticFileHandler,
{"path": os.path.join(config.data_directory, 'ui', 'app'),
"default_filename": "index.html"})
]
oonidApplication = web.Application(oonidAPI, debug=True)
