|
| 1 | +# Copyright 2015 ARM Limited, All rights reserved |
| 2 | +# |
| 3 | +# Licensed under the Apache License, Version 2.0 (the "License"); |
| 4 | +# you may not use this file except in compliance with the License. |
| 5 | +# You may obtain a copy of the License at |
| 6 | +# |
| 7 | +# http://www.apache.org/licenses/LICENSE-2.0 |
| 8 | +# |
| 9 | +# Unless required by applicable law or agreed to in writing, software |
| 10 | +# distributed under the License is distributed on an "AS IS" BASIS, |
| 11 | +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 12 | +# See the License for the specific language governing permissions and |
| 13 | +# limitations under the License. |
| 14 | + |
| 15 | +import sys |
| 16 | +import select |
| 17 | +import socket |
| 18 | +import logging |
| 19 | +from threading import Thread |
| 20 | +from sys import stdout |
| 21 | +from SocketServer import BaseRequestHandler, TCPServer |
| 22 | +from mbed_host_tests import BaseHostTest, event_callback |
| 23 | + |
| 24 | + |
| 25 | +class TCPEchoClientHandler(BaseRequestHandler): |
| 26 | + def handle(self): |
| 27 | + """ |
| 28 | + Handles a connection. Test starts by client(i.e. mbed) connecting to server. |
| 29 | + This connection handler receives data and echoes back to the client util |
| 30 | + {{end}} is received. Then it sits on recv() for client to terminate the |
| 31 | + connection. |
| 32 | +
|
| 33 | + Note: reason for not echoing data back after receiving {{end}} is that send |
| 34 | + fails raising a SocketError as client closes connection. |
| 35 | + """ |
| 36 | + while self.server.isrunning(): |
| 37 | + try: |
| 38 | + data = self.recv() |
| 39 | + if not data: break |
| 40 | + except Exception as e: |
| 41 | + break |
| 42 | + |
| 43 | + try: |
| 44 | + # echo data back to the client |
| 45 | + self.send(data) |
| 46 | + except Exception as e: |
| 47 | + break |
| 48 | + |
| 49 | + def recv(self): |
| 50 | + """ |
| 51 | + Try to receive until server is shutdown |
| 52 | + """ |
| 53 | + while self.server.isrunning(): |
| 54 | + rl, wl, xl = select.select([self.request], [], [], 1) |
| 55 | + if len(rl): |
| 56 | + return self.request.recv(1024) |
| 57 | + |
| 58 | + def send(self, data): |
| 59 | + """ |
| 60 | + Try to send until server is shutdown |
| 61 | + """ |
| 62 | + while self.server.isrunning(): |
| 63 | + rl, wl, xl = select.select([], [self.request], [], 1) |
| 64 | + if len(wl): |
| 65 | + self.request.sendall(data) |
| 66 | + break |
| 67 | + |
| 68 | + |
| 69 | +class TCPServerWrapper(TCPServer): |
| 70 | + """ |
| 71 | + Wrapper over TCP server to implement server initiated shutdown. |
| 72 | + Adds a flag:= running that a request handler can check and come out of |
| 73 | + recv loop when shutdown is called. |
| 74 | + """ |
| 75 | + |
| 76 | + def __init__(self, addr, request_handler): |
| 77 | + # hmm, TCPServer is not sub-classed from object! |
| 78 | + if issubclass(TCPServer, object): |
| 79 | + super(TCPServerWrapper, self).__init__(addr, request_handler) |
| 80 | + else: |
| 81 | + TCPServer.__init__(self, addr, request_handler) |
| 82 | + self.running = False |
| 83 | + |
| 84 | + def serve_forever(self): |
| 85 | + self.running = True |
| 86 | + if issubclass(TCPServer, object): |
| 87 | + super(TCPServerWrapper, self).serve_forever() |
| 88 | + else: |
| 89 | + TCPServer.serve_forever(self) |
| 90 | + |
| 91 | + def shutdown(self): |
| 92 | + self.running = False |
| 93 | + if issubclass(TCPServer, object): |
| 94 | + super(TCPServerWrapper, self).shutdown() |
| 95 | + else: |
| 96 | + TCPServer.shutdown(self) |
| 97 | + |
| 98 | + def isrunning(self): |
| 99 | + return self.running |
| 100 | + |
| 101 | + |
| 102 | +class TCPEchoClientTest(BaseHostTest): |
| 103 | + |
| 104 | + def __init__(self): |
| 105 | + """ |
| 106 | + Initialise test parameters. |
| 107 | +
|
| 108 | + :return: |
| 109 | + """ |
| 110 | + BaseHostTest.__init__(self) |
| 111 | + self.SERVER_IP = None # Will be determined after knowing the target IP |
| 112 | + self.SERVER_PORT = 0 # Let TCPServer choose an arbitrary port |
| 113 | + self.server = None |
| 114 | + self.server_thread = None |
| 115 | + self.target_ip = None |
| 116 | + |
| 117 | + @staticmethod |
| 118 | + def find_interface_to_target_addr(target_ip): |
| 119 | + """ |
| 120 | + Finds IP address of the interface through which it is connected to the target. |
| 121 | +
|
| 122 | + :return: |
| 123 | + """ |
| 124 | + s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) |
| 125 | + try: |
| 126 | + s.connect((target_ip, 0)) # Target IP, any port |
| 127 | + except socket.error: |
| 128 | + s.connect((target_ip, 8000)) # Target IP, 'random' port |
| 129 | + ip = s.getsockname()[0] |
| 130 | + s.close() |
| 131 | + return ip |
| 132 | + |
| 133 | + def setup_tcp_server(self): |
| 134 | + """ |
| 135 | + sets up a TCP server for target to connect and send test data. |
| 136 | +
|
| 137 | + :return: |
| 138 | + """ |
| 139 | + # !NOTE: There should mechanism to assert in the host test |
| 140 | + if self.SERVER_IP is None: |
| 141 | + self.log("setup_tcp_server() called before determining server IP!") |
| 142 | + self.notify_complete(False) |
| 143 | + |
| 144 | + # Returning none will suppress host test from printing success code |
| 145 | + self.server = TCPServerWrapper((self.SERVER_IP, self.SERVER_PORT), TCPEchoClientHandler) |
| 146 | + ip, port = self.server.server_address |
| 147 | + self.SERVER_PORT = port |
| 148 | + self.server.allow_reuse_address = True |
| 149 | + self.log("HOST: Listening for TCP connections: " + self.SERVER_IP + ":" + str(self.SERVER_PORT)) |
| 150 | + self.server_thread = Thread(target=TCPEchoClientTest.server_thread_func, args=(self,)) |
| 151 | + self.server_thread.start() |
| 152 | + |
| 153 | + @staticmethod |
| 154 | + def server_thread_func(this): |
| 155 | + """ |
| 156 | + Thread function to run TCP server forever. |
| 157 | +
|
| 158 | + :param this: |
| 159 | + :return: |
| 160 | + """ |
| 161 | + this.server.serve_forever() |
| 162 | + |
| 163 | + @event_callback("target_ip") |
| 164 | + def _callback_target_ip(self, key, value, timestamp): |
| 165 | + """ |
| 166 | + Callback to handle reception of target's IP address. |
| 167 | +
|
| 168 | + :param key: |
| 169 | + :param value: |
| 170 | + :param timestamp: |
| 171 | + :return: |
| 172 | + """ |
| 173 | + self.target_ip = value |
| 174 | + self.SERVER_IP = self.find_interface_to_target_addr(self.target_ip) |
| 175 | + self.setup_tcp_server() |
| 176 | + |
| 177 | + @event_callback("host_ip") |
| 178 | + def _callback_host_ip(self, key, value, timestamp): |
| 179 | + """ |
| 180 | + Callback for request for host IP Addr |
| 181 | +
|
| 182 | + """ |
| 183 | + self.send_kv("host_ip", self.SERVER_IP) |
| 184 | + |
| 185 | + @event_callback("host_port") |
| 186 | + def _callback_host_port(self, key, value, timestamp): |
| 187 | + """ |
| 188 | + Callback for request for host port |
| 189 | + """ |
| 190 | + self.send_kv("host_port", self.SERVER_PORT) |
| 191 | + |
| 192 | + def teardown(self): |
| 193 | + if self.server: |
| 194 | + self.server.shutdown() |
| 195 | + self.server_thread.join() |
0 commit comments