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)