def __init__(self):
EchoServer.__init__(self)
self._loop = asyncio.get_event_loop()
self.perform_mainloop()
def test_connect_timeout(mocked_accept, mocked_settimeout, mocked_listen,
mocked_bind, client_address):
mocked_accept.side_effect = OSError()
srv = EchoServer()
srv.connect()
mocked_accept.assert_called_once_with()
def test_connect(mocked_accept, mocked_settimeout, mocked_listen, mocked_bind,
client_address):
mocked_accept.return_value = (client_address, socket.socket())
srv = EchoServer()
srv.connect()
mocked_accept.assert_called_once_with()
def test_mainloop(mocked_perform_mainloop, mocked_accept, mocked_settimeout,
mocked_listen, mocked_bind, client_address):
mocked_perform_mainloop.side_effect = KeyboardInterrupt()
mocked_accept.return_value = (client_address, socket.socket())
srv = EchoServer()
srv.mainloop()
mocked_accept.assert_called_once_with()
def test_read(mocked_settimeout, mocked_listen, mocked_bind, mocked_connect,
mocked_send, mocked_recv):
clt = EchoClient()
srv = EchoServer()
srv.connect()
clt.write('body')
srv.read(clt._sock, ['localhost', 8000])
request = srv._requests[0]
assert 'body' in request.body
def test_write(mocked_settimeout, mocked_listen, mocked_bind, mocked_connect,
mocked_send, mocked_recvsend, mocked_request, capsys):
clt = EchoClient()
srv = EchoServer()
srv.connect()
request = mocked_request
srv.write(clt._sock, request, ['localhost', 8000])
clt.read()
out, err = capsys.readouterr()
assert 'server received message from client' in out
def run_server():
server = EchoServer()
server.run()
serial_node.run()
def controller():
rate = rospy.Rate(10) # 10hz
while not rospy.is_shutdown():
try:
server_data = serial_node.server.handler.data
except Exception as e:
print(e)
server_data = None
rospy.Subscriber("from_motor_controller", String, callback)
data = "From TCP: %s" % str(server_data)
#rospy.loginfo(data)
pub.publish(data)
rate.sleep()
if __name__ == '__main__':
try:
tcp_server = EchoServer(HOST, PORT)
serial_node = SerialNode(tcp_server)
communication_thread = threading.Thread(target=communication)
communication_thread.daemon = True
communication_thread.start()
controller()
except rospy.ROSInterruptException:
pass
def __init__(self):
EchoServer.__init__(self)
self.database = SqliteDB()
self.desc = Descriptor()
def build_standalone_switches(key_funcs: list, attr_funcs: list, raw_queries, alert_func, n: int = 1):
server = EchoServer(alert_func)
queries = compile_queries(raw_queries)
switches = [SingleStandaloneSwitch(server, key_funcs, attr_funcs, queries) for i in range(n)]
return switches, server
def main():
tcp_server = EchoServer(HOST, PORT)
serial_node = SerialNode(tcp_server)
serial_node.run()
def test_perform_mainloop(mocked_settimeout, mocked_listen, mocked_bind,
server_timeout):
srv = EchoServer()
srv.perform_mainloop()
def test_settimeout(mocked_settimeout, mocked_listen, mocked_bind,
server_timeout):
EchoServer()
mocked_settimeout.assert_called_once_with(server_timeout)
def test_listen(mocked_settimeout, mocked_listen, mocked_bind, clients_number):
EchoServer()
mocked_listen.assert_called_once_with(clients_number)
def test_bind(mocked_settimeout, mocked_listen, mocked_bind, client_address):
EchoServer()
mocked_bind.assert_called_once_with(client_address)