def test_unix_already_listening_cant_delete(self):
"""
A config with type = "unix" will create an endpoint for a UNIX socket
at the given path, and delete it if required. If it can't delete it, it
will raise an exception.
"""
parent_fp = FilePath("/tmp").child(uuid4().hex)
parent_fp.makedirs()
fp = parent_fp.child(uuid4().hex)
# Something is already there
fp.setContent(b"")
fp.chmod(0o544)
parent_fp.chmod(0o544)
reactor = SelectReactor()
config = {"type": "unix", "path": fp.path}
with self.assertRaises(OSError) as e:
create_listening_endpoint_from_config(config, self.cbdir, reactor,
self.log)
self.assertEqual(e.exception.errno, 13) # Permission Denied
parent_fp.chmod(0o777)
parent_fp.remove()
def __init__(self):
self.prefix = 'W:'
self.suffix = ' '
self.tooltip_heading = 'Wireless LAN Status:\n'
self.iface = None # Set to interface name to override interface selection
self.build_ui()
# Needed by wpa_supplicant.core
self.reactor = SelectReactor()
thread = threading.Thread(target=self.reactor.run,
kwargs={'installSignalHandlers': 0})
thread.daemon = True
thread.start()
time.sleep(0.1) # let reactor start
self.wpasup = None
self.wpasup_running = False
self.wlan = None
self.wlan_signal = None
# Monitor the availability of wpa_supplicant via DBus
self.dbus = SystemBus()
# watch_name() fires an event as soon as GLib.MainLoop() starts, so we don't need to explicitly
# call get_wpa_supplicant() here
self.dbus.watch_name(BUS_NAME, 0, self.get_wpa_supplicant,
self.get_wpa_supplicant)
self.start_watch_thread()
def _start_run(self, config, app, stdout_expected, stderr_expected,
end_on):
with open(self.config, "wb") as f:
f.write(json.dumps(config, ensure_ascii=False).encode('utf8'))
with open(self.code_location + "/myapp.py", "w") as f:
f.write(app)
reactor = SelectReactor()
make_lc(self, reactor, end_on)
# In case it hard-locks
reactor.callLater(self._subprocess_timeout, reactor.stop)
main.main("crossbar",
["start",
"--cbdir={}".format(self.cbdir),
"--logformat=syslogd"],
reactor=reactor)
out = self.stdout.getvalue()
err = self.stderr.getvalue()
for i in stdout_expected:
if i not in out:
self.fail("Error: '{}' not in:\n{}".format(i, out))
for i in stderr_expected:
if i not in err:
self.fail("Error: '{}' not in:\n{}".format(i, err))
def test_unix_already_listening_cant_delete(self):
"""
A config with type = "unix" will create an endpoint for a UNIX socket
at the given path, and delete it if required. If it can't delete it, it
will raise an exception.
"""
parent_fp = os.path.join("/", "tmp", uuid4().hex)
os.makedirs(parent_fp)
fp = os.path.join(parent_fp, uuid4().hex)
# Something is already there
open(fp, "w").close()
os.chmod(fp, 0o544)
os.chmod(parent_fp, 0o544)
reactor = SelectReactor()
config = {"type": "unix", "path": fp}
with self.assertRaises(OSError) as e:
create_listening_endpoint_from_config(config, self.cbdir, reactor,
self.log)
self.assertEqual(e.exception.errno, 13) # Permission Denied
os.chmod(parent_fp, 0o700)
shutil.rmtree(parent_fp)
def test_unix_already_listening(self):
"""
A config with type = "unix" will create an endpoint for a UNIX socket
at the given path, and delete it if required.
"""
path = os.path.join("/", "tmp", uuid4().hex)
self.addCleanup(os.remove, path)
# Something is already there
open(path, "w").close()
reactor = SelectReactor()
config = {
"type": "unix",
"path": path
}
endpoint = create_listening_endpoint_from_config(config, self.cbdir,
reactor, self.log)
self.assertTrue(isinstance(endpoint, UNIXServerEndpoint))
factory = Factory.forProtocol(Echo)
endpoint.listen(factory)
self.assertIn(
factory,
[getattr(x, "factory", None) for x in reactor.getReaders()])
def test_uninvited_pubrel(host, port):
record = [
Frame(
send=True,
data=Connect(client_id=u"test_pubrel",
flags=ConnectFlags(clean_session=True))),
Frame(
send=False,
data=ConnACK(session_present=False, return_code=0)),
Frame(
send=True,
data=PubREL(packet_identifier=1234)),
Frame(
send=False,
data=PubCOMP(packet_identifier=1234)),
Frame(
send=True,
data=Disconnect()),
ConnectionLoss(),
]
r = SelectReactor()
f = ReplayClientFactory(r, record)
e = TCP4ClientEndpoint(r, host, port)
e.connect(f)
r.run()
return Result("uninvited_pubrel", f.success, f.reason, f.client_transcript)
def test_self_subscribe(host, port):
record = [
Frame(send=True,
data=Connect(client_id="test_selfsub",
flags=ConnectFlags(clean_session=True))),
Frame(send=False, data=ConnACK(session_present=False, return_code=0)),
Frame(send=True,
data=Subscribe(
packet_identifier=1234,
topic_requests=[SubscriptionTopicRequest("foo", 2)])),
Frame(send=False,
data=SubACK(packet_identifier=1234, return_codes=[2])),
Frame(send=True,
data=Publish(duplicate=False,
qos_level=0,
topic_name="foo",
payload=b"abc",
retain=False)),
Frame(send=False,
data=Publish(duplicate=False,
qos_level=0,
topic_name="foo",
payload=b"abc",
retain=False)),
Frame(send=True, data=Disconnect()),
ConnectionLoss(),
]
r = SelectReactor()
f = ReplayClientFactory(r, record)
e = TCP4ClientEndpoint(r, host, port)
e.connect(f)
r.run()
return Result("self_subscribe", f.success, f.reason, f.client_transcript)
def __init__(self):
# Start a simple Twisted SelectReactor
self.ssid_list = []
self.bssid_list = []
self.key_mgmt_list = []
self.pairwise_list = []
self.net_cfg = {}
self.reactor = SelectReactor()
self.thread1 = threading.Thread(target=self.reactor.run,
kwargs={'installSignalHandlers': 0})
self.thread1.setDaemon(True)
self.thread1.start()
time.sleep(0.1)
self.f = open('pass.txt', encoding='utf-8')
self.passwords = self.f.readlines()
# Start Driver
self.driver = WpaSupplicantDriver(self.reactor)
# Connect to the supplicant, which returns the "root" D-Bus object for wpa_supplicant
self.supplicant = self.driver.connect()
try:
self.interface = str(self.supplicant.get_interface('wlan0'))
self.interface = self.supplicant.remove_interface(
self.interface.split(',')[0][16:])
except:
pass
self.interface = self.supplicant.create_interface('wlan0')
self.scn()
self.spray()
def start_reactor(self):
reactor = SelectReactor()
t = threading.Thread(target=reactor.run,
kwargs={'installSignalHandlers': 0})
t.setDaemon(True)
t.start()
time.sleep(0.1)
return reactor, t
def test_root_not_required(self):
"""
Not including a '/' path will mean that path has a 404, but children
will still be routed correctly.
"""
temp_reactor = SelectReactor()
r = router.RouterWorkerSession(config=self.config,
reactor=temp_reactor)
# Open the transport
transport = FakeWAMPTransport(r)
r.onOpen(transport)
realm_config = {u"name": u"realm1", u'roles': []}
# Make a file
self.cbdir.child('file.txt').setContent(b"hello!")
r.start_router_realm("realm1", realm_config)
r.start_router_transport(
"component1", {
u"type": u"web",
u"endpoint": {
u"type": u"tcp",
u"port": 8080
},
u"paths": {
u"static": {
"directory": self.cbdir.asTextMode().path,
"type": u"static"
}
}
})
# Make a request to the WSGI app.
d1 = treq.get("http://localhost:8080/", reactor=temp_reactor)
d1.addCallback(lambda resp: self.assertEqual(resp.code, 404))
d2 = treq.get("http://localhost:8080/static/file.txt",
reactor=temp_reactor)
d2.addCallback(treq.content)
d2.addCallback(self.assertEqual, b"hello!")
def done(results):
for item in results:
if not item[0]:
raise item[1]
d = defer.DeferredList([d1, d2])
d.addCallback(done)
d.addCallback(lambda _: temp_reactor.stop())
def escape():
if temp_reactor.running:
temp_reactor.stop()
temp_reactor.callLater(1, escape)
temp_reactor.run()
def test_threads(self):
"""
A basic WSGI app can be ran, with subresources
"""
temp_reactor = SelectReactor()
r = router.RouterWorkerSession(config=self.config,
reactor=temp_reactor)
# Open the transport
transport = FakeWAMPTransport(r)
r.onOpen(transport)
realm_config = {u"name": u"realm1", u'roles': []}
threads = 20
r.start_router_realm("realm1", realm_config)
r.start_router_transport(
"component1", {
u"type": u"web",
u"endpoint": {
u"type": u"tcp",
u"port": 8080
},
u"paths": {
u"/": {
"module": u"crossbar.worker.test.test_router",
"object": u"sleep",
"type": u"wsgi",
"maxthreads": threads,
}
}
})
deferreds = []
results = []
for i in range(threads):
d = treq.get("http://localhost:8080/", reactor=temp_reactor)
d.addCallback(treq.content)
d.addCallback(results.append)
deferreds.append(d)
def done(_):
max_concurrency = max([int(x) for x in results])
assert max_concurrency == threads, "Maximum concurrency was %s, not %s" % (
max_concurrency, threads)
temp_reactor.stop()
defer.DeferredList(deferreds).addCallback(done)
def escape():
if temp_reactor.running:
temp_reactor.stop()
temp_reactor.callLater(1, escape)
temp_reactor.run()
def test_twisted_server(self):
reactor = SelectReactor()
config = {
"type": "twisted",
"server_string": "tcp:9876:interface=127.0.0.1",
}
endpoint = create_listening_endpoint_from_config(config, self.cbdir, reactor, self.log)
self.assertTrue(isinstance(endpoint, TCP4ServerEndpoint))
def test_twisted_client(self):
reactor = SelectReactor()
config = {
"type": "twisted",
"client_string": "tcp:host=127.0.0.1:port=9876",
}
endpoint = create_connecting_endpoint_from_config(config, self.cbdir, reactor, self.log)
self.assertTrue(isinstance(endpoint, TCP4ClientEndpoint))
def __init__(self):
self._reactor = SelectReactor()
threading.Thread(target=self._reactor.run,
kwargs={
'installSignalHandlers': 0
}).start()
time.sleep(0.1) # let reactor start
driver = WpaSupplicantDriver(self._reactor)
supplicant = driver.connect()
self.interface = supplicant.get_interface('wlan0')
def setUp(self):
mocks.init()
self._taskrunner = ThreadedTaskRunner()
self._taskrunner.start()
self._reactor = SelectReactor()
self._driver = WpaSupplicantDriver(self._reactor)
self._reactor_thread = threading.Thread(
target=self._reactor.run, kwargs={'installSignalHandlers': 0})
self._reactor_thread.start()
time.sleep(0.1)
self._supplicant = self._driver.connect()
def test_basic_subresources(self):
"""
A basic WSGI app can be ran, with subresources
"""
temp_reactor = SelectReactor()
r = router.RouterWorkerSession(config=self.config,
reactor=temp_reactor)
# Open the transport
transport = FakeWAMPTransport(r)
r.onOpen(transport)
realm_config = {
u"name": u"realm1",
u'roles': []
}
r.start_router_realm(u"realm1", realm_config)
r.start_router_transport(
"component1",
{
u"type": u"web",
u"endpoint": {
u"type": u"tcp",
u"port": 8080
},
u"paths": {
u"/": {
"module": u"crossbar.worker.test.test_router",
"object": u"hello",
"type": u"wsgi"
},
u"json": {
"type": u"json",
"value": {}
}
}
})
# Make a request to the /json endpoint, which is technically a child of
# the WSGI app, but is not served by WSGI.
d = treq.get("http://localhost:8080/json", reactor=temp_reactor)
d.addCallback(treq.content)
d.addCallback(self.assertEqual, b"{}")
d.addCallback(lambda _: temp_reactor.stop())
def escape():
if temp_reactor.running:
temp_reactor.stop()
temp_reactor.callLater(1, escape)
temp_reactor.run()
return d
def test_basic(self):
"""
Just running `crossbar version` gets us the versions.
"""
reactor = SelectReactor()
main.main("crossbar", ["version"], reactor=reactor)
self.assertIn("Crossbar.io", self.stdout.getvalue())
self.assertIn(("Twisted : \x1b[33m\x1b[1m" +
twisted.version.short() + "-SelectReactor"),
self.stdout.getvalue())
def test_hello(self):
def _check(lc, reactor):
if "published to 'oncounter'" in self.stdout.getvalue():
lc.stop()
try:
reactor.stop()
except:
pass
appdir = self.mktemp()
cbdir = os.path.join(appdir, ".crossbar")
reactor = SelectReactor()
main.main("crossbar",
["init",
"--appdir={}".format(appdir),
"--template=hello:python"],
reactor=reactor)
self.assertIn("Application template initialized",
self.stdout.getvalue())
reactor = SelectReactor()
make_lc(self, reactor, _check)
# In case it hard-locks
reactor.callLater(self._subprocess_timeout, reactor.stop)
main.main("crossbar",
["start",
"--cbdir={}".format(cbdir.path),
"--logformat=syslogd"],
reactor=reactor)
stdout_expected = ["published to 'oncounter'"]
for i in stdout_expected:
self.assertIn(i, self.stdout.getvalue())
def AttemptConnection(self):
print "attempting a connection to", serverHost, serverPort
self.state = NetworkServerView.STATE_CONNECTING
if self.reactor:
self.reactor.stop()
self.PumpReactor()
else:
self.reactor = SelectReactor()
installReactor(self.reactor)
connection = self.reactor.connectTCP(serverHost, serverPort,
self.pbClientFactory)
deferred = self.pbClientFactory.getRootObject()
deferred.addCallback(self.Connected)
deferred.addErrback(self.ConnectFailed)
self.reactor.startRunning()
def test_debug(self):
"""
Running `crossbar version` will give us the versions, plus the
locations of some of them.
"""
reactor = SelectReactor()
main.main("crossbar", ["version", "--loglevel=debug"], reactor=reactor)
self.assertIn("Crossbar.io", self.stdout.getvalue())
self.assertIn(("Twisted : \x1b[33m\x1b[1m" +
twisted.version.short() + "-SelectReactor"),
self.stdout.getvalue())
self.assertIn(("[twisted.internet.selectreactor.SelectReactor]"),
self.stdout.getvalue())
def reactor():
timeout_secs = 3
# We want a reactor that works on all platforms.
from twisted.internet.selectreactor import SelectReactor
r = SelectReactor()
d = {'forced': False} # No `nonlocal` in Python 2
def force_stop():
d['forced'] = True
r.stop()
r.callLater(timeout_secs, force_stop)
yield r
if d['forced']:
pytest.fail(
'Test did not stop reactor within {} secs'.format(timeout_secs))
def test_start(self):
"""
A basic start, that doesn't actually enter the reactor.
"""
with open(self.config, "w") as f:
f.write("""{"controller": {}}""")
reactor = SelectReactor()
reactor.run = lambda: False
main.main(
"crossbar",
["start", "--cbdir={}".format(self.cbdir), "--logformat=syslogd"],
reactor=reactor)
self.assertIn("Entering reactor event loop", self.stdout.getvalue())
def test_qos1_send_wrong_confirm(host, port):
record = [
Frame(
send=True,
data=Connect(client_id=u"test_wrong_confirm_qos1",
flags=ConnectFlags(clean_session=True))),
Frame(
send=False,
data=ConnACK(session_present=False, return_code=0)),
Frame(
send=True,
data=Subscribe(packet_identifier=1234,
topic_requests=[SubscriptionTopicRequest(u"foo", 2)])),
Frame(
send=False,
data=SubACK(packet_identifier=1234, return_codes=[2])),
Frame(
send=True,
data=Publish(duplicate=False, qos_level=1, topic_name=u"foo",
payload=b"abc", retain=False, packet_identifier=12)),
Frame(
send=False,
data=[
PubACK(packet_identifier=12),
Publish(duplicate=False, qos_level=1, topic_name=u"foo",
payload=b"abc", retain=False, packet_identifier=1)]),
# We send a pubrel to the packet_id expecting a puback
Frame(
send=True,
data=PubREL(packet_identifier=1)),
# ..aaaaand we get a pubcomp back (even though mosquitto warns).
Frame(
send=False,
data=PubCOMP(packet_identifier=1)),
Frame(
send=True,
data=Disconnect()),
ConnectionLoss(),
]
r = SelectReactor()
f = ReplayClientFactory(r, record)
e = TCP4ClientEndpoint(r, host, port)
e.connect(f)
r.run()
return Result("qos1_wrong_confirm", f.success, f.reason, f.client_transcript)
def test_quirks_mode_connect(host, port):
record = [
Frame(
send=True,
data=b"\x10\x15\x00\x04MQTT\x04\x02\x00x\x00\x07testqrk\x00\x00"),
Frame(send=False, data=ConnACK(session_present=False, return_code=0)),
Frame(send=True, data=Disconnect()),
ConnectionLoss(),
]
r = SelectReactor()
f = ReplayClientFactory(r, record)
e = TCP4ClientEndpoint(r, host, port)
e.connect(f)
r.run()
return Result("connect_quirks", f.success, f.reason, f.client_transcript)
def test_connect(host, port):
record = [
Frame(send=True,
data=Connect(client_id="test_cleanconnect",
flags=ConnectFlags(clean_session=True))),
Frame(send=False, data=ConnACK(session_present=False, return_code=0)),
Frame(send=True, data=Disconnect()),
ConnectionLoss(),
]
r = SelectReactor()
f = ReplayClientFactory(r, record)
e = TCP4ClientEndpoint(r, host, port)
e.connect(f)
r.run()
return Result("connect", f.success, f.reason, f.client_transcript)
def test_basic(self):
"""
A basic WSGI app can be ran.
"""
temp_reactor = SelectReactor()
r = router.RouterWorkerSession(config=self.config,
reactor=temp_reactor)
# Open the transport
transport = FakeWAMPTransport(r)
r.onOpen(transport)
realm_config = {u"name": u"realm1", u'roles': []}
r.start_router_realm("realm1", realm_config)
r.start_router_transport(
"component1", {
u"type": u"web",
u"endpoint": {
u"type": u"tcp",
u"port": 8080
},
u"paths": {
u"/": {
"module": u"crossbar.worker.test.test_router",
"object": u"hello",
"type": u"wsgi"
}
}
})
# Make a request to the WSGI app.
d = treq.get("http://localhost:8080/", reactor=temp_reactor)
d.addCallback(treq.content)
d.addCallback(self.assertEqual, b"hello!")
d.addCallback(lambda _: temp_reactor.stop())
def escape():
if temp_reactor.running:
temp_reactor.stop()
temp_reactor.callLater(1, escape)
temp_reactor.run()
return d
def supplicant():
"""Run a reactor and provide access to the supplicant driver"""
reactor = SelectReactor()
t = threading.Thread(target=reactor.run,
kwargs={'installSignalHandlers': 0})
t.start()
time.sleep(0.1) # let reactor start
driver = WpaSupplicantDriver(reactor)
supplicant = driver.connect()
try:
yield supplicant
except Exception as e:
print('FAIL - {}'.format(e))
else:
print('OK')
reactor.disconnectAll()
reactor.sigTerm()
t.join()
def AttemptConnection(self):
print "attempting a connection to", serverHost, serverPort
self.state = NetworkServerView.STATE_CONNECTING
if self.reactor:
self.reactor.stop()
self.PumpReactor()
else:
self.reactor = SelectReactor()
installReactor(self.reactor)
connection = self.reactor.connectTCP(serverHost, serverPort,
self.pbClientFactory)
# TODO: make this anonymous login()
#deferred = self.pbClientFactory.login(credentials.Anonymous())
userCred = credentials.UsernamePassword(avatarID, 'pass1')
controller = NetworkServerController(self.evManager)
deferred = self.pbClientFactory.login(userCred, client=controller)
deferred.addCallback(self.Connected)
deferred.addErrback(self.ConnectFailed)
self.reactor.startRunning()
def test_reserved_packet_0(host, port):
record = [
Frame(send=True,
data=Connect(client_id="test_reserved0",
flags=ConnectFlags(clean_session=True))),
Frame(send=False, data=ConnACK(session_present=False, return_code=0)),
Frame(
send=True,
# v pkt 0 right here
data=b"\x00\x13\x00\x04MQTT\x04\x02\x00\x02\x00\x07test123"),
ConnectionLoss()
]
r = SelectReactor()
f = ReplayClientFactory(r, record)
e = TCP4ClientEndpoint(r, host, port)
e.connect(f)
r.run()
return Result("reserved_pkt0", f.success, f.reason, f.client_transcript)
def test_fileLogging(self):
"""
Running `crossbar start --logtofile` will log to cbdir/node.log.
"""
with open(self.config, "w") as f:
f.write("""{"controller": {}}""")
reactor = SelectReactor()
reactor.run = lambda: None
main.main("crossbar",
["start", "--cbdir={}".format(self.cbdir), "--logtofile"],
reactor=reactor)
with open(os.path.join(self.cbdir, "node.log"), "r") as f:
logFile = f.read()
self.assertIn("Entering reactor event loop", logFile)
self.assertEqual("", self.stderr.getvalue())
self.assertEqual("", self.stdout.getvalue())
