def stop(self):
"""Stops the reactor."""
SelectReactor.stop(self)
# If this was called while the reactor was paused we have to resume in order for it to complete
if self.paused:
self.run()
# These need to be re-registered so that the PausingReactor can be safely restarted after a stop
self.addSystemEventTrigger('during', 'shutdown', self.crash)
self.addSystemEventTrigger('during', 'shutdown', self.disconnectAll)
def stop(self):
"""Stops the reactor."""
SelectReactor.stop(self)
# If this was called while the reactor was paused we have to resume in order for it to complete
if self.paused:
self.run()
# These need to be re-registered so that the PausingReactor can be safely restarted after a stop
self.addSystemEventTrigger('during', 'shutdown', self.crash)
self.addSystemEventTrigger('during', 'shutdown', self.disconnectAll)
class ReactorSlaveController(object):
def __init__(self):
self.keepGoing = True
self.reactor = SelectReactor()
installReactor(self.reactor)
connection = self.reactor.connectTCP('localhost', 8000, factory)
self.reactor.startRunning()
self.futureCall = None
self.futureCallTimeout = None
pygame_test.prepare()
def iterate(self):
print 'in iterate'
self.reactor.runUntilCurrent()
self.reactor.doIteration(0)
#t2 = self.reactor.timeout()
#print 'timeout', t2
#t = self.reactor.running and t2
#self.reactor.doIteration(t)
def run(self):
clock = pygame.time.Clock()
self.reactor.callLater(20, stupidTest)
while self.keepGoing:
timeChange = clock.tick(FRAMES_PER_SECOND)
if self.futureCall:
self.futureCallTimeout -= timeChange
print 'future call in', self.futureCallTimeout
if self.futureCallTimeout <= 0:
self.futureCall()
self.futureCallTimeout = None
self.futureCall= None
retval = pygame_test.iterate()
if retval == False:
thingInControl.stop()
self.iterate()
def stop(self):
print 'stopping'
self.reactor.stop()
self.keepGoing = False
def callLater(self, when, fn):
self.futureCallTimeout = when*1000
self.futureCall = fn
print 'future call in', self.futureCallTimeout
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()
class ReactorSpinController:
STATE_STOPPED = 0
STATE_STARTED = 1
STATE_SHUTTING_DOWN = 2
def __init__(self, evManager):
self.state = ReactorSpinController.STATE_STOPPED
self.evManager = evManager
self.evManager.RegisterListener( self )
self.reactor = SelectReactor()
installReactor(self.reactor)
self.loopingCall = LoopingCall(self.FireTick)
#----------------------------------------------------------------------
def FireTick(self):
self.evManager.Post( TickEvent() )
#----------------------------------------------------------------------
def Run(self):
self.state = ReactorSpinController.STATE_STARTED
framesPerSecond = 10
interval = 1.0 / framesPerSecond
self.loopingCall.start(interval)
self.reactor.run()
#----------------------------------------------------------------------
def Stop(self):
print 'stopping the reactor'
self.state = ReactorSpinController.STATE_SHUTTING_DOWN
self.reactor.addSystemEventTrigger('after', 'shutdown',
self.onReactorStop)
self.reactor.stop()
#----------------------------------------------------------------------
def onReactorStop(self):
print 'reactor is now totally stopped'
self.state = ReactorSpinController.STATE_STOPPED
self.reactor = None
#----------------------------------------------------------------------
def Notify(self, event):
if isinstance( event, QuitEvent ):
self.Stop()
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):
"""
A basic WSGI app can be ran.
"""
temp_reactor = SelectReactor()
r = router.RouterController(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(
u"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 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
class NetworkServerView(pb.Root):
"""We SEND events to the server through this object"""
STATE_PREPARING = 0
STATE_CONNECTING = 1
STATE_CONNECTED = 2
STATE_DISCONNECTING = 3
STATE_DISCONNECTED = 4
#----------------------------------------------------------------------
def __init__(self, evManager, sharedObjectRegistry):
self.evManager = evManager
self.evManager.RegisterListener( self )
self.pbClientFactory = pb.PBClientFactory()
self.state = NetworkServerView.STATE_PREPARING
self.reactor = None
self.server = None
self.sharedObjs = sharedObjectRegistry
#----------------------------------------------------------------------
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 Disconnect(self):
print "disconnecting"
if not self.reactor:
return
print 'stopping the reactor'
self.reactor.stop()
self.PumpReactor()
self.state = NetworkServerView.STATE_DISCONNECTING
#----------------------------------------------------------------------
def Connected(self, server):
print "CONNECTED"
self.server = server
self.state = NetworkServerView.STATE_CONNECTED
ev = ServerConnectEvent( server )
self.evManager.Post( ev )
#----------------------------------------------------------------------
def ConnectFailed(self, server):
print "CONNECTION FAILED"
print server
print 'quitting'
self.evManager.Post( QuitEvent() )
#self.state = NetworkServerView.STATE_PREPARING
self.state = NetworkServerView.STATE_DISCONNECTED
#----------------------------------------------------------------------
def PumpReactor(self):
self.reactor.runUntilCurrent()
self.reactor.doIteration(0)
#----------------------------------------------------------------------
def Notify(self, event):
NSV = NetworkServerView
if isinstance( event, TickEvent ):
if self.state == NSV.STATE_PREPARING:
self.AttemptConnection()
elif self.state in [NSV.STATE_CONNECTED,
NSV.STATE_DISCONNECTING,
NSV.STATE_CONNECTING]:
self.PumpReactor()
return
if isinstance( event, QuitEvent ):
self.Disconnect()
return
ev = event
if not isinstance( event, pb.Copyable ):
evName = event.__class__.__name__
copyableClsName = "Copyable"+evName
if not hasattr( network, copyableClsName ):
return
copyableClass = getattr( network, copyableClsName )
#NOTE, never even construct an instance of an event that
# is serverToClient, as a side effect is often adding a
# key to the registry with the local id().
if copyableClass not in network.clientToServerEvents:
return
#print 'creating instance of copyable class', copyableClsName
ev = copyableClass( event, self.sharedObjs )
if ev.__class__ not in network.clientToServerEvents:
#print "CLIENT NOT SENDING: " +str(ev)
return
if self.server:
print " ==== Client sending", str(ev)
remoteCall = self.server.callRemote("EventOverNetwork", ev)
else:
print " =--= Cannot send while disconnected:", str(ev)
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
with open(os.path.join(self.cbdir, 'file.txt'), "wb") as f:
f.write(b"hello!")
r.start_router_realm(u"realm1", realm_config)
r.start_router_transport(
u"component1",
{
u"type": u"web",
u"endpoint": {
u"type": u"tcp",
u"port": 8080
},
u"paths": {
u"static": {
u"directory": u".",
u"type": u"static"
}
}
})
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]:
return 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()
class Wifi():
_LOGGER = logging.getLogger(__name__)
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 __del__(self):
self._reactor.stop()
def scan(self):
scan_results = self.interface.scan(block=True)
networks = []
for bss in scan_results:
networks.append(WifiNetwork(bss=bss))
return networks
def get_known_networks(self):
results = self.interface.get_networks()
networks = []
for network in results:
networks.append(Network(network=network))
return networks
def save_network(self, ssid: str, psk: str, enabled: bool, priority: str):
network_config = {}
#network_config['psk'] = psk
network_config['ssid'] = ssid
network_config['key_mgmt'] = "WPA-PSK"
if enabled:
network_config['disabled'] = 0
else:
network_config['disabled'] = 1
network = self.interface.add_network(network_config)
#Work around for psk invalid message format error
#txdbus.error.RemoteError: org.freedesktop.DBus.Error.InvalidArgs: invalid message format
network_id = os.path.basename(network.get_path())
self._LOGGER.debug("Saving network....Network path:" +
network.get_path() + " Network Id: " + network_id)
cmd = "wpa_cli -i wlan0 set_network " + network_id + " psk " + psk
os.system(cmd)
return Network(network=network)
def get_network_info(self, name: str):
results = self.interface.get_networks()
found_network = None
for network in results:
ssid = network.get_properties().get('ssid')
if ssid.lower() == name.lower():
found_network = Network(network=network)
return found_network
def delete_network(self, name: str):
results = self.interface.get_networks()
for network in results:
ssid = network.get_properties().get('ssid')
if ssid.lower() == name.lower():
self.interface.remove_network(network.get_path())
break
def activate_network(self, name: str):
results = self.interface.get_networks()
for network in results:
ssid = network.get_properties().get('ssid')
if ssid.lower() == name.lower():
self.interface.select_network(network.get_path())
break
def get_active_network(self):
network = self.interface.get_current_network()
return Network(network=network)
def save_config(self):
cmd = "wpa_cli -i wlan0 save_config"
os.system(cmd)
def enable_ap_mode(self):
status = call("", cwd="/opt/observer/ansible", shell=True)
return
def disable_ap_mode(self):
return
@property
def is_ap_mode(self) -> bool:
bus = SystemBus()
systemd = bus.get_object('org.freedesktop.systemd1',
'/org/freedesktop/systemd1')
manager = Interface(systemd,
dbus_interface='org.freedesktop.systemd1.Manager')
appliance_unit = manager.LoadUnit('hostapd.service')
appliance_proxy = bus.get_object('org.freedesktop.systemd1',
str(appliance_unit))
appliance_properties = Interface(
appliance_proxy, dbus_interface='org.freedesktop.DBus.Properties')
return appliance_properties.Get('org.freedesktop.systemd1.Unit',
'ActiveState') != 'inactive'
class NetworkServerView(pb.Root):
"""We SEND events to the server through this object"""
STATE_PREPARING = 0
STATE_CONNECTING = 1
STATE_CONNECTED = 2
STATE_DISCONNECTING = 3
STATE_DISCONNECTED = 4
#----------------------------------------------------------------------
def __init__(self, evManager, sharedObjectRegistry):
self.evManager = evManager
self.evManager.RegisterListener( self )
self.pbClientFactory = pb.PBClientFactory()
self.state = NetworkServerView.STATE_PREPARING
self.reactor = None
self.server = None
self.sharedObjs = sharedObjectRegistry
#----------------------------------------------------------------------
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 Disconnect(self):
print "disconnecting"
if not self.reactor:
return
print 'stopping the reactor'
self.reactor.stop()
self.PumpReactor()
self.state = NetworkServerView.STATE_DISCONNECTING
#----------------------------------------------------------------------
def Connected(self, server):
print "CONNECTED"
self.server = server
self.state = NetworkServerView.STATE_CONNECTED
ev = ServerConnectEvent( server )
self.evManager.Post( ev )
#----------------------------------------------------------------------
def ConnectFailed(self, server):
print "CONNECTION FAILED"
#self.state = NetworkServerView.STATE_PREPARING
self.state = NetworkServerView.STATE_DISCONNECTED
#----------------------------------------------------------------------
def PumpReactor(self):
self.reactor.runUntilCurrent()
self.reactor.doIteration(0)
#----------------------------------------------------------------------
def Notify(self, event):
NSV = NetworkServerView
if isinstance( event, TickEvent ):
if self.state == NSV.STATE_PREPARING:
self.AttemptConnection()
elif self.state in [NSV.STATE_CONNECTED,
NSV.STATE_DISCONNECTING,
NSV.STATE_CONNECTING]:
self.PumpReactor()
return
if isinstance( event, QuitEvent ):
self.Disconnect()
return
ev = event
if not isinstance( event, pb.Copyable ):
evName = event.__class__.__name__
copyableClsName = "Copyable"+evName
if not hasattr( network, copyableClsName ):
return
copyableClass = getattr( network, copyableClsName )
ev = copyableClass( event, self.sharedObjs )
if ev.__class__ not in network.clientToServerEvents:
#print "CLIENT NOT SENDING: " +str(ev)
return
if self.server:
print " ==== Client sending", str(ev)
remoteCall = self.server.callRemote("EventOverNetwork",
ev)
else:
print " =--= Cannot send while disconnected:", str(ev)
class NetworkServerView(pb.Root):
"""We SEND events to the server through this object"""
STATE_PREPARING = 0
STATE_CONNECTING = 1
STATE_CONNECTED = 2
STATE_DISCONNECTING = 3
STATE_DISCONNECTED = 4
#----------------------------------------------------------------------
def __init__(self, evManager, sharedObjectRegistry):
self.evManager = evManager
self.evManager.RegisterListener( self )
self.pbClientFactory = pb.PBClientFactory()
self.state = NetworkServerView.STATE_PREPARING
self.reactor = None
self.server = None
self.sharedObjs = sharedObjectRegistry
#----------------------------------------------------------------------
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 Disconnect(self):
print "disconnecting"
if not self.reactor:
return
print 'stopping the reactor'
self.reactor.stop()
self.PumpReactor()
self.state = NetworkServerView.STATE_DISCONNECTING
#----------------------------------------------------------------------
def Connected(self, server):
print "CONNECTED"
self.server = server
self.state = NetworkServerView.STATE_CONNECTED
ev = ServerConnectEvent( server )
self.evManager.Post( ev )
#----------------------------------------------------------------------
def ConnectFailed(self, server):
print "CONNECTION FAILED"
#self.state = NetworkServerView.STATE_PREPARING
self.state = NetworkServerView.STATE_DISCONNECTED
#----------------------------------------------------------------------
def PumpReactor(self):
self.reactor.runUntilCurrent()
self.reactor.doIteration(0)
#----------------------------------------------------------------------
def Notify(self, event):
NSV = NetworkServerView
if isinstance( event, TickEvent ):
if self.state == NSV.STATE_PREPARING:
self.AttemptConnection()
elif self.state in [NSV.STATE_CONNECTED,
NSV.STATE_DISCONNECTING,
NSV.STATE_CONNECTING]:
self.PumpReactor()
return
if isinstance( event, QuitEvent ):
self.Disconnect()
return
ev = event
if not isinstance( event, pb.Copyable ):
evName = event.__class__.__name__
copyableClsName = "Copyable"+evName
if not hasattr( network, copyableClsName ):
return
copyableClass = getattr( network, copyableClsName )
#NOTE, never even construct an instance of an event that
# is serverToClient, as a side effect is often adding a
# key to the registry with the local id().
if copyableClass not in network.clientToServerEvents:
return
print 'creating instance of copyable class', copyableClsName
ev = copyableClass( event, self.sharedObjs )
if ev.__class__ not in network.clientToServerEvents:
#print "CLIENT NOT SENDING: " +str(ev)
return
if self.server:
print " ==== Client sending", str(ev)
remoteCall = self.server.callRemote("EventOverNetwork", ev)
else:
print " =--= Cannot send while disconnected:", str(ev)
