def connectTCP(self): """ Connect to a running ThreadedTCPServer here... """ # connect to server try: port = self.__opts.port server = self.__opts.addr s = "Connected to server (host addr %s, port %d)" % (server, port) self.__sock=client_sock.ClientSocket(server,port) self.__status_update.update(s, 'red') # # Register the GUI with the server #self.lock.acquire() self.__sock.send("Register GUI\n") #self.lock.release() # # Register the socket with the event_listener and # Spawn the listener thread here.... self.__event_listen.connect(self.__sock) except IOError: del(self.__sock) self.__sock = None s = "EXCEPTION: Could not connect to socket at host addr %s, port %s" % (server, port) print s self.__status_update.update(s,color='red')
def connect(self): """ Connect to TRN filter state telemetry socket and start listener thread. """ if self.thread.isAlive() == True: print "LISTENER THREAD IS ALIVE!" return # connect to server TRN try: port = 50007 server = "127.0.0.1" str = "Connected to server (host addr %s, port %d)" % (server, port) self.sock = client_sock.ClientSocket(server, port) # # Register the GUI with the server self.lock.acquire() self.sock.send("Register GUI\n") self.lock.release() except IOError: str = "EXCEPTION: Could not connect to socket at host addr %s, port %s" % ( server, port) # update status self.status.config(text=str, fg="red") self.connect_bt.config(text="Disconnected", fg="black") self.sock = None return if self.thread.daemon == False: # create background listener thread self.thread = threading.Thread(target=self.enqueue_output, args=(self.sock, self.queue)) # thread dies with the program self.thread.daemon = True # state listener thread here self.thread.start() if self.thread2.daemon == False: # create background sim data generator thread self.thread2 = threading.Thread(target=self.enqueue_sim_output, args=(self.sock, self.queue2)) # thread dies with the program self.thread2.daemon = True # start simulation thread here self.thread2.start() # update status self.status.config(text=str, fg="red") self.connect_bt.config(text="Connected", fg="red")
def get_uplink_server_socket(host, port): """ Register uplink process to server. @param host: Server Address @param port: Server Port @return: Socket object """ global LOGGER sock = client_sock.ClientSocket(host, port) LOGGER.info("Registering UPLINK to server address {} on port {}".format( opts.host, opts.port)) sock.send("Register GUI\n") return sock
def get_downlink_server_socket(host, port): """ Register downlink process to server. @param host: Server Address @param port: Server Port @return: Socket object """ global LOGGER LOGGER.info("Connecting to server socket addr {} port {} ".format(host,port)) try: sock = client_sock.ClientSocket(host, port) sock.send("Register GUI\n") except IOError: LOGGER.info("Unable to conenct.") print "Unable to connect with the socket server. Exiting.\n" LOGGER.info("Successful connection.") return sock
def __init__(self, server_addr='127.0.0.1', port=50000, generated_path='', build_root='', log_file_cmds=None, log_file_events=None, log_file_channel=None, log_file_path=None, log_file_updown=None, listener_enabled=False, verbose=False): """ Constructor. @param server_addr: Socket server addr @param port: Socket server port number @param log_file_cmds: Name of command log file @param log_file_events: Name of log event log file @param log_file_channel: Name of channel telemetry log file @param log_file_path: Name of common directory path to save log files into @param listener_enabled: If True then event/channel telemetry listener thread enabled, else dissabled @param verbose: Enable diagonistic display of information """ # 1. Connect to socket server using controllers.client_sock.py # 2. Create log files and loggers # 3. Load configuration for commands, events, channels, using controllers.XXXXX_loader.py # 3. Start listener thread controllers.event_listern.py # For every console output log to a default file and stdout. logfile = time.strftime("%y%m%d%H%M%S", time.gmtime()) + '_GSEStdOut.log' #p = opts.log_file_path + os.sep + "stdout" p = '.' + os.sep + "stdout" if not os.path.exists(p): os.makedirs(p) f = p + os.sep + logfile # setup default for generated python command / telemetry descriptor files. # these are autocoded descriptions of all. # # Look for BUILD_ROOT and if not set look for generated in "." and then # in ".." and if not found then throw an exception. config = ConfigManager.getInstance() self.build_root = config.get("filepaths", "build_root") if 'BUILD_ROOT' in os.environ: self.build_root = os.environ['BUILD_ROOT'] elif build_root != '': self.build_root = build_root else: print "WARNING: BUILD_ROOT not set. Specify on the command line, the environment, or gse.ini." self.generated_path = config.get("filepaths", "generated_path") if generated_path != '': self.generated_path = generated_path else: print "WARNING: GENERATED_PATH not set. Specify on command line or gse.ini" # display configuration before starting GUI here... sep_line = 80 * "=" if verbose: logger = Logger.connectOutputLogger(f, 'stdout', logging.INFO) else: logger = Logger.connectOutputLogger(f, 'stdout', logging.WARNING) logger.info("Created log: %s" % f) logger.info("User: %s" % os.environ['USER']) (sysname, nodename, release, version, machine) = os.uname() logger.info("OS Name: %s" % sysname) logger.info("Machine Network Host Name: %s" % nodename) logger.info("Release: %s" % release) logger.info("Version: %s" % version) logger.info("Machine: %s" % machine) logger.info(sep_line) # load commands, events, channelized telemetry, and event listener sys.path.append(generated_path) # add path for serializables sys.path.append(generated_path + os.sep + "serializable") self._cmds = command_loader.CommandLoader.getInstance() self._cmds.create(generated_path + os.sep + "commands") self._events = event_loader.EventLoader.getInstance() self._events.create(generated_path + os.sep + "events") self._channels = channel_loader.ChannelLoader.getInstance() self._channels.create(generated_path + os.sep + "channels") self.__args_factory = command_args_factory.CommandArgsFactory() self._ev_listener = event_listener.EventListener.getInstance() self._ev_listener.setupLogging() self.__logger = logger self.__server_addr = server_addr self.__port = port # Uplink and downlink clients will log to null handler if none is specified file_uplink_client.set_logger(log_folder=log_file_updown) file_downlink_client.set_logger(log_folder=log_file_updown) # connect to TCP server try: self.__sock = client_sock.ClientSocket(server_addr, port) self.__sock.send("Register GUI\n") self._ev_listener.connect(self.__sock) except IOError: self.__sock = None super(GseApi, self).__init__()
def main(): port = 50007 s = client_sock.ClientSocket("127.0.0.1", port) print "Test socket client\n" while 1: print "Enter command: \"Register\",\"name of registered client\",\"Listen\",\"List\"" print "Enter command: \"FSW\" for testing" c = sys.stdin.readline() c = c.strip('\n') if c.title() == 'Register': print "Enter client name: " n = sys.stdin.readline() n = n.strip('\n') cmd = c.title() + " " + n + "\n" elif c.title() == "List": cmd = c.title() + "\n" elif c.upper() == 'FSW': desc = u32_type.U32Type(0x5B5B5B5B) desc_len = desc.getSize() server_desc = 'A5A5 GUI ' cmd = '' print "Enter event choice: 0-Event1, 1-Event2, 2-StringEvent, 3-EnumEvent, 4-BoolEvent:" n = sys.stdin.readline() n = int(n.strip('\n')) if n == 0: # Event 1 Generation i = U32Type(100) cmd += i.serialize() # i32 = int(raw_input("Enter I32 arg: ")) i32 = I32Type(i32) cmd += i32.serialize() # f32 = float(raw_input("Enter F32 arg: ")) f32 = F32Type(f32) cmd += f32.serialize() # q = raw_input("Enter Quaternion F32 (Q1, Q2, Q3, Q4): ") q = map(lambda y: float(y), q.split()) q1 = F32Type(q[0]) cmd += q1.serialize() q2 = F32Type(q[1]) cmd += q2.serialize() q3 = F32Type(q[2]) cmd += q3.serialize() q4 = F32Type(q[3]) cmd += q4.serialize() # Make event packet data_len = u32_type.U32Type(desc_len + len(cmd)) cmd = server_desc + data_len.serialize() + desc.serialize( ) + cmd elif n == 1: # Event 2 Generation i = U32Type(101) cmd += i.serialize() # i32 = int(raw_input("Enter I32 arg: ")) i32 = I32Type(i32) cmd += i32.serialize() # u32 = abs(int(raw_input("Enter U32 arg: "))) u32 = U32Type(u32) cmd += u32.serialize() # u8 = abs(int(raw_input("Enter u8 arg: "))) u8 = U8Type(u8) cmd += u8.serialize() # Make event packet data_len = u32_type.U32Type(desc_len + len(cmd)) cmd = server_desc + data_len.serialize() + desc.serialize( ) + cmd elif n == 2: # Event String Generation i = U32Type(102) cmd += i.serialize() # i32 = int(raw_input("Enter I32 arg: ")) i32 = I32Type(i32) cmd += i32.serialize() # string = raw_input("Enter String arg: ") string = StringType(string) cmd += string.serialize() # u8 = int(raw_input("Enter U8 arg: ")) u8 = U8Type(u8) cmd += u8.serialize() # Make event packet data_len = u32_type.U32Type(desc_len + len(cmd)) cmd = server_desc + data_len.serialize() + desc.serialize( ) + cmd elif n == 3: # Event Enum Generation i = U32Type(103) cmd += i.serialize() # i32 = int(raw_input("Enter I32 arg: ")) i32 = I32Type(i32) cmd += i32.serialize() # en = raw_input( "Enter Enum String Value (\"MEMB1\", \"MEMB2\", \"MEMB3\"): " ) en = EnumType("SomeTypeEnum", { "MEMB1": 0, "MEMB2": 7, "MEMB3": 15 }, en) cmd += en.serialize() # u8 = int(raw_input("Enter U8 arg: ")) u8 = U8Type(u8) cmd += u8.serialize() # Make event packet data_len = u32_type.U32Type(desc_len + len(cmd)) cmd = server_desc + data_len.serialize() + desc.serialize( ) + cmd elif n == 4: # Event Enum Generation i = U32Type(104) cmd += i.serialize() # i32 = int(raw_input("Enter I32 arg: ")) i32 = I32Type(i32) cmd += i32.serialize() # b = raw_input( "Enter Bool String Value (\"True\", \"False\"): ") if b == "True": b = BoolType(True) else: b = BoolType(False) cmd += b.serialize() # u8 = int(raw_input("Enter U8 arg: ")) u8 = U8Type(u8) cmd += u8.serialize() # Make event packet data_len = u32_type.U32Type(desc_len + len(cmd)) cmd = server_desc + data_len.serialize() + desc.serialize( ) + cmd else: print "Unrecognized event code!" elif c.title() == 'Listen': while 1: print "Listening:" buff = s.recv(4) desc = U32Type() desc.deserialize(buff, len(buff)) buff = s.recv(4) size = U32Type() size.deserialize(buff, len(buff)) print "Descripter: 0x%x, Size: %d" % (desc.val, size.val) buff = s.recv(size.val) opcode = U32Type() opcode.deserialize(buff, 4) print "0x%x" % opcode.val if opcode.val == 0x600: print "START_PKTS" elif opcode.val == 0x10: print "NO_OP" elif opcode.val == 0x102: print "TEST_CMD_3" # arg1 u32 = I32Type() ptr = 4 u32.deserialize(buff[ptr:], u32.getSize()) ptr += u32.getSize() # arg2 str1 = StringType() # Note must know size apriori... str1.deserialize(buff[ptr:], 22) ptr += str1.getSize() # arg3 u8 = U8Type() u8.deserialize(buff[ptr:], u8.getSize()) print "Args: U32: %d, String: %s, U8: %d" % ( u32.val, str1.val, u8.val) elif opcode.val == 0x100: print "TEST_CMD_1" # arg1 i32 = I32Type() ptr = 4 i32.deserialize(buff[ptr:], i32.getSize()) ptr += i32.getSize() print i32.val # arg2 f32 = F32Type() f32.deserialize(buff[ptr:], f32.getSize()) ptr += f32.getSize() print f32.val # arg3 u8 = U8Type() u8.deserialize(buff[ptr:], u8.getSize()) print "Args: I32: %d, F32: %f, U8: %d" % (i32.val, f32.val, u8.val) elif opcode.val == 0x101: print "TEST_CMD_2" # arg1 i32 = I32Type() ptr = 4 i32.deserialize(buff[ptr:], i32.getSize()) ptr += i32.getSize() # arg2 b = BoolType() b.deserialize(buff[ptr:], b.getSize()) ptr += b.getSize() # arg3 en = EnumType("SomeTypeEnum", { "MEMB1": 0, "MEMB2": 6, "MEMB3": 9 }) en.deserialize(buff[ptr:], en.getSize()) print "Args: I32: %d, BOOL: %s, ENUM: %s" % (i32.val, b.val, en.val) elif opcode.val == 0x11: print "NO_OP_STRING" # arg1 u32 = U32Type() ptr = 4 u32.deserialize(buff[ptr:], u32.getSize()) ptr += u32.getSize() # arg2 str2 = StringType() str2.deserialize(buff[ptr:], u32.val + 4) print "Args: U32: %d, STRING: %s" % (u32.val, str2.val) elif opcode.val == 0x601: print "INJECT_PKT_ERROR" else: print "Unrecognized op code!" else: print "Unreognized command!" continue print "Command is: " + cmd type_base.showBytes(cmd) s.send(cmd)