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())