class BluetoothPlugin(ConnectionPlugin):
ADDR_FILE = 'config/bluetooth_address'
def __init__(self):
super().__init__()
self.listener = Listener()
self.addr = self.__get_bluetooth_addr()
# API method
def broadcast(self, msg):
print("BROADCASTING")
NetworkScanner(msg).start()
# API method
def run(self):
self.listener.start()
# API method
def address(self):
return self.addr
def __get_bluetooth_addr(self):
with open(BluetoothPlugin.ADDR_FILE, 'r') as file:
addr = file.read()
print("Bluetooth Address: {}".format(addr))
return addr.strip()
def start(self):
self.running = True
conn_listener = Listener(self.index, self.port, self.clock)
conn_listener.start()
for i in range(constants.EVENTS_COUNT):
if not self.running:
break
sleep(min(random.random() + 0.5, 1))
self.clock.increment()
if random.random() > self.chance:
# local
self.logger.info(f"{perf_counter_ns() // 1000} {self.index} {self.clock.get()}{self.index} l")
else:
# remote
idx, node = self.get_node()
try:
self.send_message(idx, node)
except SocketTimeout:
print(
f"""Error: Timeout sending message to node {idx} ({node["host"]}:{node["port"]})"""
)
break
conn_listener.stop()
def add_macro():
global database, listenter
name = request.form.get("name")
language = request.form.get("language")
age_group = request.form.get("age")
gender = request.form.get("gender")
description = request.form.get("description")
keyboard_events_path = request.form.get("key_file")
event_strings = request.form.get("events_string")
sound_1 = request.form.get("sound_1")
sound_2 = request.form.get("sound_2")
sound_3 = request.form.get("sound_3")
ok, message = training_service.get_model(name, (sound_1, sound_2, sound_3),
language, age_group, gender)
if (not ok):
return jsonify({"message": message})
else:
try:
database.insert((name, language, age_group, gender, description,
event_strings, keyboard_events_path, message))
try:
listenter.stop()
except Exception as e:
pass
if (len(database.get_all()) > 0):
listenter = Listener(sensitivity=args.sensitivity,
speed_factor=args.speed_factor)
listenter.start()
return jsonify({"message": "ok"})
except sqlite3.Error as e:
return jsonify({"message": e.args[0]})
class ReportQueue:
def __init__(self, rr):
self.railroad = rr
self.msgQ = queue.Queue(0)
self.listener = Listener(self, "192.168.1.142", "8001", self.msgQ)
self.listener.start()
def serve_forever(self):
self.forever = True
while self.forever:
try:
msg = self.msgQ.get(True, 0.25)
except queue.Empty:
msg = None
if msg:
#print("(%s)" % msg)
jdata = json.loads(msg)
if "disconnect" in jdata.keys():
self.forever = False
else:
self.railroad.processMsg(jdata)
self.listener.kill()
self.listener.join()
def main():
listener = Listener()
listener.start()
while True:
recv_queue_data = listener.queue.get()
recv_data = recv_queue_data.msgtype
distance = recv_queue_data.msg
if recv_data == 0x05: # Follower to move forward
totalMoves(distance)
print ("Received Follower move forward")
elif recv_data == 0x06: # Follower to move backward
totalMoves(distance)
print ("Received Follower move backward")
elif recv_data == 0x07: # Follower to move left
totalMoves(distance)
print ("Received Follower move left")
elif recv_data == 0x09: # Follower to move right
totalMoves(distance)
print ("Received Follower move right")
elif recv_data == 0x13: # Follower reports found token
followerTokenFND()
elif recv_data == 0x15: # Scanning Follower Servo
print ("Received Scanning Beginning")
elif recv_data == 0x16: # Scan returned Lead Found
scanServo()
elif recv_data == 0x17: # Scan returned Object Found
scanServo()
else:
# Something unexpected happened
print("Received unexpected data %d" % recv_data)
try:
cmdInput(listener.queue)
except KeyboardInterrupt:
pass
listener.close()
def start_ip_listener():
listener_ipv4 = None
listener_ipv6 = None
if socket.has_ipv6:
try:
listener_ipv6 = Listener(shared.listening_host,
shared.listening_port,
family=socket.AF_INET6)
listener_ipv6.start()
except Exception as e:
logging.warning(
'Error while starting IPv6 listener on port {}'.format(
shared.listening_port))
logging.warning(e)
try:
listener_ipv4 = Listener(shared.listening_host, shared.listening_port)
listener_ipv4.start()
except Exception as e:
if listener_ipv6:
logging.warning(
'Error while starting IPv4 listener on port {}. '.format(
shared.listening_port) +
'However the IPv6 one seems to be working and will probably accept IPv4 connections.'
)
else:
logging.error(
'Error while starting IPv4 listener on port {}. '.format(
shared.listening_port) +
'You will not receive incoming connections. Please check your port configuration'
)
logging.error(e)
class BluetoothPlugin(ConnectionPlugin):
ADDR_FILE = 'config/bluetooth_address'
def __init__(self):
super().__init__()
self.listener = Listener()
self.addr = self.__get_bluetooth_addr()
# API method
def broadcast(self, msg):
print("BROADCASTING")
NetworkScanner(msg).start()
# API method
def run(self):
self.listener.start()
# API method
def address(self):
return self.addr
def __get_bluetooth_addr(self):
with open(BluetoothPlugin.ADDR_FILE, 'r') as file:
addr = file.read()
print("Bluetooth Address: {}".format(addr))
return addr.strip()
def main():
listener = Listener()
#incoming_message_Thread = Thread(target=incoming_message_handle, args=[listener.clientList], daemon=True)
listener.start()
#incoming_message_Thread.start()
while True:
try:
recv_queue_data = listener.queue.get(timeout=1)
print("Message : ", recv_queue_data)
except Empty:
print("empty")
pass
try:
recv_data = recv_queue_data.msgtype
message_pack_recv = recv_queue_data.msg
if recv_data == "Rover Move": # Follower to move FORWARD
if message_pack_recv == ROVER_FORWARD:
#totalMoves(distance)
print ("Received Follower move forward")
elif message_pack_recv == ROVER_BACKWARD: # Follower to move BACKWARD
#totalMoves(distance)
print ("Received Follower move backward")
elif message_pack_recv == ROVER_LEFT: # Follower to move LEFT
#totalMoves(distance)
print ("Received Follower move left")
elif message_pack_recv == ROVER_RIGHT: # Follower to move RIGHT
#totalMoves(distance)
print ("Received Follower move right")
elif message_pack_recv == ROVER_STOP: # Follower to STOP
#totalMoves(distance)
print ("Received Follower STOP")
elif recv_data == "Follower Distance": # Follower reports distance traveled
totalMoves(message_pack_recv)
print ("Received Follower Distance: ", message_pack_recv)
elif recv_data == "Follower Token Found": # Follower reports found token
followerTokenFND()
elif recv_data == "Scanning Follower Servo": # Scanning Follower Servo
if message_pack_recv == SCAN_STARTED: # Servo Scan Started
print ("Received Scanning Beginning")
elif message_pack_recv == LEAD_FOUND: # Scan returned Lead Found
scanServo()
elif message_pack_recv == OBJECT_FOUND: # Scan returned Object Found
scanServo()
elif recv_data == "Follower Distance To Lead": # Follower reports found token
print ("Received Follower Distance To Lead: ", message_pack_recv)
else:
# Something unexpected happened
print("Received unexpected data %d" % recv_data)
except KeyboardInterrupt:
print("CTRL C Detected")
return
listener.close()
def delete(id=None):
global listenter, database, args
_, _, _, _, _, _, _, ke_path, model_path = database.get_macro(id)
os.remove(ke_path)
os.remove(model_path)
database.delete_macro(id)
try:
listenter.stop()
except Exception as e:
pass
if (len(database.get_all()) > 0):
listenter = Listener(sensitivity=args.sensitivity,
speed_factor=args.speed_factor)
listenter.start()
return redirect('/')
def main():
logging.basicConfig(filename='/var/log/executioner/executioner.log',
level=logging.INFO,
format='%(asctime)s %(message)s')
#not handling signals because python can't reconcile them with multithreading. supposedly Py3.3 does though.
#signal.signal(signal.SIGINT, handle_signal)
#signal.signal(signal.SIGTERM, handle_signal)
sys.stdout = LoggerWriter(logging.info)
sys.stderr = LoggerWriter(logging.error)
MotorController.init()
SwitchController.init()
listener = Listener()
listener.start()
class DataGen(object):
def __init__(self):
conn1, conn2 = multiprocessing.Pipe()
self.conn = conn2
self.listener = Listener(debug_connection = conn1)
self.listener.start()
self.bpm_to_test = [0]
self.bpm_energies = [0]
def __iter__(self):
return self
def next(self):
while self.conn.poll():
self.bpm_to_test, self.bpm_energies = self.conn.recv()
return (self.bpm_to_test, self.bpm_energies)
class DataGen(object):
def __init__(self):
conn1, conn2 = multiprocessing.Pipe()
self.conn = conn2
self.listener = Listener(debug_connection=conn1)
self.listener.start()
self.bpm_to_test = [0]
self.bpm_energies = [0]
def __iter__(self):
return self
def next(self):
while self.conn.poll():
self.bpm_to_test, self.bpm_energies = self.conn.recv()
return (self.bpm_to_test, self.bpm_energies)
class Communicator:
messageQueue = None
def __init__(self, peer):
# print "A communicator is created!"
self.peer = peer
self.messageQueue = peer.messageQueue
self.mylistener = Listener(peer)
self.mylistener.setDaemon(True)
self.mylistener.start()
# self.operation()
def send(self, host, sendPort, content):
# print "sending ..."
# socket setting
buf = 1024 * 1024
addr = (host, sendPort)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
sock.connect(addr)
except Exception:
print "Connection lost with: ", addr
return False
sock.send(content)
sock.close()
return True
# sock.sendto(content, addr)
# sock.close()
# def rcv(self, myPId):
# msgList = []
# newMsgQueue = []
# for item in self.messageQueue:
# msgList.append(item)
# self.messageQueue = newMsgQueue
# return msgList
def prtMsgQueue(self):
for item in self.messageQueue:
print item
def start_ip_listener():
listener_ipv4 = None
listener_ipv6 = None
if socket.has_ipv6:
try:
listener_ipv6 = Listener(shared.listening_host, shared.listening_port, family=socket.AF_INET6)
listener_ipv6.start()
except Exception as e:
logging.warning('Error while starting IPv6 listener on port {}'.format(shared.listening_port))
logging.warning(e)
try:
listener_ipv4 = Listener(shared.listening_host, shared.listening_port)
listener_ipv4.start()
except Exception as e:
if listener_ipv6:
logging.warning('Error while starting IPv4 listener on port {}. '.format(shared.listening_port) +
'However the IPv6 one seems to be working and will probably accept IPv4 connections.')
else:
logging.error('Error while starting IPv4 listener on port {}. '.format(shared.listening_port) +
'You will not receive incoming connections. Please check your port configuration')
logging.error(e)
def EmonHub():
# Load settings
settings = ConfigObj("emonhub.conf", file_error=True)
# Create queue for node packets
queue = Queue.Queue(0)
# Create and start serial listener
a = Listener(queue, settings)
a.start()
# Create and start http dispatcher
b = Dispatcher(queue, settings)
b.start()
while 1:
try:
time.sleep(0.1)
except KeyboardInterrupt:
print "Stopping threads"
a.stop = True
b.stop = True
break
def EmonHub():
# Load settings
settings = ConfigObj("emonhub.conf", file_error=True)
# Create queue for node packets
queue = Queue.Queue(0)
# Create and start serial listener
a = Listener(queue,settings)
a.start()
# Create and start http dispatcher
b = Dispatcher(queue,settings)
b.start()
while 1:
try:
time.sleep(0.1)
except KeyboardInterrupt:
print "Stopping threads"
a.stop = True
b.stop = True
break
class Main(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
# make variables
self.voltage = 0
self.current = 0
# load gui.ui
self.ui = loadUi('../gui/gui.ui')
self.ui.setAttribute(QtCore.Qt.WA_DeleteOnClose, True)
self.ui.destroyed.connect(self.shutdown)
# show window
self.ui.show()
# make new log object
self.log = Log(self.ui)
# make new sender object
self.sender = Sender(self.ui, self.log)
# set events
self.set_events()
# initial reset
self.sender.reset()
# new listener
self.listener = Listener()
# new_data_received signal
self.listener.data_received.connect(self.new_data_received)
# start listener
self.listener.start()
# new interpreter
self.interpreter = Interpreter(self.log, self.ui)
# add tree
self.add_tree()
def add_tree(self):
# Items for tree
voltage_item = QTreeWidgetItem(["Spannung", str(self.voltage) + " V"])
self.ui.treeView.addTopLevelItem(voltage_item)
current_item = QTreeWidgetItem(["Strom", str(self.current) + " A"])
self.ui.treeView.addTopLevelItem(current_item)
power_item = QTreeWidgetItem(["Watt", "0 W"])
self.ui.treeView.addTopLevelItem(power_item)
def set_events(self):
# sendButton clicked
self.ui.sendButton.clicked.connect(lambda: self.sender.send("debug"))
# holdButton clicked
self.ui.holdButton.clicked.connect(self.log.toggle_hold)
# clearButton clicked
self.ui.clearButton.clicked.connect(self.log.clear_log)
# messageInput return pressed
self.ui.messageInput.returnPressed.connect(lambda: self.sender.send("debug"))
# sliders value changed
self.ui.voltageSlider.sliderReleased.connect(lambda: self.sender.send("slider-voltage"))
self.ui.currentSlider.sliderReleased.connect(lambda: self.sender.send("slider-current"))
# reset action
self.ui.resetActionButton.triggered.connect(self.sender.reset)
# automode checkbox
self.ui.automodeCheckbox.stateChanged.connect(lambda: self.sender.send("checkbox-automode"))
# lamp checkboxes
self.ui.lamp1Checkbox.stateChanged.connect(lambda: self.sender.send("checkbox-lamp"))
self.ui.lamp2Checkbox.stateChanged.connect(lambda: self.sender.send("checkbox-lamp"))
self.ui.lamp3Checkbox.stateChanged.connect(lambda: self.sender.send("checkbox-lamp"))
self.ui.lamp4Checkbox.stateChanged.connect(lambda: self.sender.send("checkbox-lamp"))
def new_data_received(self, text):
self.interpreter.interpret(text)
def shutdown(self):
self.listener.exit()
import redis
from listener import Listener
class Myclass(object):
def __init__(self):
pass
def test(self, a, b, c):
print a, b, c
def sum(self, a, b, c):
print a + b + c
def dispatch(self):
self.dispatcher = {
'test': self.test,
'sum': self.sum
}
r = redis.Redis()
client = Listener(r, ['__key*__:*'], Myclass())
client.start()
import os
import time
import logging
from listener import Listener, worker
if __name__ == '__main__':
logging.basicConfig(filename="log.txt", level=logging.DEBUG, format='%(asctime)s: %(message)s')
os.makedirs('screenshots', exist_ok=True)
listener = Listener()
listener.start()
time.sleep(5)
listener.stop()
worker.stop()
elif msgstring == "start":
try:
testcase = int(input("Select Test Case:"))
assert testcase in range(1, 8)
except (TypeError, AssertionError):
print("Test case does not exist")
continue
listener.queue.put(InternalMessage(ROUTER, START_GAME, bytes([testcase])))
elif msgstring == "end":
listener.queue.put(InternalMessage(ROUTER, END_GAME, bytes([0])))
else:
msgstring = msgstring.encode()
while msgstring:
msg = InternalMessage(ROUTER, DEBUG_MSG, msgstring[:INTERNAL_MSG_SIZE + 1])
listener.queue.put(msg)
msgstring = msgstring[INTERNAL_MSG_SIZE + 1:]
if __name__ == "__main__":
listener = Listener()
outWorker = OutboundWorker(listener.queue, listener.clientList, listener.clientDict)
listener.start()
outWorker.start()
try:
cmdInput(listener)
except KeyboardInterrupt:
pass
listener.close()
#! /usr/bin/env python
from config import Config # this is a subdir
from listener import Listener
from poller import Poller
import sys
if __name__ == "__main__":
"""Run the monitor. The listener class waits for requests. The
poller class polls the PIDs that were input and forwards output
to the output class."""
parpid = sys.argv[1]
cfg = Config()
cfg.add_item('parentpid', parpid)
lst = Listener(cfg)
lst.start()
print "listener started"
# Where is the output class?
pol = Poller(cfg)
pol.start()
print "Poller started"
def start( self ): myConfigurationFile = ConfigurationFile( self.fileName ) myConfiguration = myConfigurationFile.load() myListener = Listener( myConfiguration ) myListener.start()
def launch_listener(final_results_queue, total_metrics):
listener = Listener(final_results_queue, total_metrics)
listener.start()
{
"track" : "Sakhir (Bahrain)",
"weather" : "wi-day-sunny",
"trackTemperature" : "29",
"airTemperature" : "21",
"sessionDuration" : 127,
"sessionType" : 10
}
"""
emit('track', udp_listener.race_info)
if __name__ == '__main__':
"""
Run the Listener to parse UDP in a Thread
Run the Flask website using socketio in a separated Thread
"""
config = configparser.ConfigParser(allow_no_value=True)
config.read('config.ini')
udp_listener = Listener(host=config["UDP"]["host"],
port=int(config["UDP"]["port"]),
my_name=config["UDP"]["my_name"])
udp_listener.start()
socketio.run(app,
debug=bool(int(config["server"]["debug"])),
use_reloader=bool(int(config["server"]["use_reloader"])),
host=config["server"]["host"],
port=int(config["server"]["port"]))
def start(self):
myConfigurationFile = ConfigurationFile(self.fileName)
myConfiguration = myConfigurationFile.load()
myListener = Listener(myConfiguration)
myListener.start()
class MessageHandler(threading.Thread):
def __init__(self,
peer,
messages,
isVerbose=True,
listening_mode=False,
msgs_freq=1,
wait_time=20,
port=2123):
threading.Thread.__init__(self)
self.sock = None
self.TAG_NAME = 'GTPV2 SERVER_LISTENER'
self.peer = peer
self.is_verbose = isVerbose
self.messages = messages
self.is_listening = listening_mode
self.gtp_port = port
self.sock = socket(AF_INET, SOCK_DGRAM)
self.sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
self.sock.bind(('0.0.0.0', self.gtp_port))
self.msgs_freq = msgs_freq
self.wait_time = wait_time
self.listener = None
self.sender = None
signal.signal(signal.SIGQUIT, self.stop)
signal.signal(signal.SIGINT, self.stop)
signal.signal(signal.SIGTERM, self.stop)
##
## @brief Determines if the thread is running
##
## @param self refers to the class itself
##
## @return True if running, False otherwise.
##
def isRunning(self):
return self.is_running
##
## @brief Starts the execution of the thread
##
## @param self refers to the class itself
##
def run(self):
self.is_running = True
if self.is_listening:
if self.is_verbose:
print "\033[34m[*]\033[0m starting the listener ...."
''' START Listener '''
self.listener = Listener(open_sock=self.sock,
isVerbose=self.is_verbose)
self.listener.daemon = True
self.listener.start()
if self.is_verbose:
print "\033[34m[*]\033[0m starting the sender ...."
''' START Sender'''
self.sender = Sender(sock=self.sock,
messages=self.messages,
peers=self.peer,
isVerbose=self.is_verbose,
msg_freq=self.msgs_freq,
wait_time=self.wait_time,
gtp_port=self.gtp_port)
self.sender_daemon = True
self.sender.start()
self.sender.join()
time.sleep(5)
self.stop()
##
## @brief Stops the execution of the thread
##
## @param self refers to the class itself
##
def stop(self):
if self.sender:
self.sender.stop()
if self.listener:
self.listener.stop()
if self.sock:
self.sock.close()
self.is_running = False
if self.is_verbose:
print "%s: Stopped" % (self.TAG_NAME)
parser = argparse.ArgumentParser()
parser.add_argument("--port",
type=int,
help="The port for the server run locally",
default=8000)
parser.add_argument("--sensitivity",
type=float,
help="Model sensitivity",
default=0.35)
parser.add_argument("--speed_factor",
type=float,
help="Keyboard speed factor playback",
default=0)
return parser.parse_args(argv)
args = parse_argument(sys.argv[1:])
if (len(database.get_all()) > 0):
listenter = Listener(sensitivity=args.sensitivity,
speed_factor=args.speed_factor)
listenter.start()
app.run('0.0.0.0', args.port)
sound_recorder.end()
try:
listenter.stop()
except:
pass
database.close()
def main():
signal.signal(signal.SIGINT, handler)
signal.signal(signal.SIGTERM, handler)
logging.basicConfig(level=shared.log_level,
format='[%(asctime)s] [%(levelname)s] %(message)s')
logging.info('Starting MiNode')
if not os.path.exists(shared.data_directory):
try:
os.makedirs(shared.data_directory)
except Exception as e:
logging.warning(
'Error while creating data directory in: {}'.format(
shared.data_directory))
logging.warning(e)
try:
with open(shared.data_directory + 'objects.pickle', mode='br') as file:
shared.objects = pickle.load(file)
except Exception as e:
logging.warning('Error while loading objects from disk.')
logging.warning(e)
try:
with open(shared.data_directory + 'nodes.pickle', mode='br') as file:
shared.node_pool = pickle.load(file)
except Exception as e:
logging.warning('Error while loading nodes from disk.')
logging.warning(e)
with open(os.path.join(shared.source_directory, 'core_nodes.csv'),
mode='r',
newline='') as f:
reader = csv.reader(f)
shared.core_nodes = {tuple(row) for row in reader}
shared.node_pool.update(shared.core_nodes)
if not shared.trusted_peer:
try:
for item in socket.getaddrinfo('bootstrap8080.bitmessage.org', 80):
shared.unchecked_node_pool.add((item[4][0], 8080))
logging.debug(
'Adding ' + item[4][0] +
' to unchecked_node_pool based on DNS bootstrap method')
for item in socket.getaddrinfo('bootstrap8444.bitmessage.org', 80):
shared.unchecked_node_pool.add((item[4][0], 8444))
logging.debug(
'Adding ' + item[4][0] +
' to unchecked_node_pool based on DNS bootstrap method')
except Exception as e:
logging.error('Error during DNS bootstrap')
logging.error(e)
manager = Manager()
manager.clean_objects()
manager.clean_connections()
manager.start()
advertiser = Advertiser()
advertiser.start()
listener_ipv4 = None
listener_ipv6 = None
if shared.listen_for_connections:
if socket.has_ipv6:
try:
listener_ipv6 = Listener('',
shared.listening_port,
family=socket.AF_INET6)
listener_ipv6.start()
except Exception as e:
logging.warning('Error while starting IPv6 listener')
logging.warning(e)
try:
listener_ipv4 = Listener('', shared.listening_port)
listener_ipv4.start()
except Exception as e:
if listener_ipv6:
logging.warning(
'Error while starting IPv4 listener. '
'However the IPv6 one seems to be working and will probably accept IPv4 connections.'
)
else:
logging.error(
'Error while starting IPv4 listener.'
'You will not receive incoming connections. Please check your port configuration'
)
logging.error(e)
class VpnServer(object):
def __init__(self, port, shared_key, connected_callback, broken_conn_callback,
debug_continue, debug, app):
self.port = port
self.shared_key = shared_key
self.connected_callback = connected_callback
self.broken_conn_callback = broken_conn_callback
self.send_queue = Queue()
self.receive_queue = Queue()
self.authenticated = False
self.debug_continue = debug_continue
self.debug = debug
self.waiting = True
self.sender = None
self.receiver = None
self.is_server = True
self.sessionkey=''
self.app = app
def setup(self):
try:
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
except socket.error:
return (-1, "Could not create socket")
try:
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.socket.bind(('', self.port))
Logger.log("Listening for connections...", self.is_server)
self.socket.listen(1)
except socket.error:
return (-1, "Could not bind socket to port " + str(self.port))
return (0, "VPN server set to listen on port " + str(self.port))
def send(self, msg):
if (self.authenticated):
Logger.log("sessionkey: " +self.sessionkey, self.is_server)
emsg = self.auth.encrypt_message(msg, self.auth.get_sessionkey())
self.send_queue.put(emsg)
Logger.log("Put message on send queue: "+ msg, self.is_server)
else:
self.send_queue.put(msg)
Logger.log("Put message on send queue: "+ msg, self.is_server)
def receive(self):
if not self.receive_queue.empty():
msg = self.receive_queue.get()
if (self.authenticated):
msg, valid = self.auth.decrypt_message(msg, self.auth.get_sessionkey())
if valid is False:
return None
Logger.log("Decrypted msg: "+ msg, self.is_server)
return msg
else:
return None
def start(self, callback=None):
self.listener = Listener(self.socket, self.shared_key, self, self.connected_callback, self.app)
self.listener.start()
def bind(self, client_socket):
self.debug_continue.disabled = self.debug
self.sender = Sender(client_socket, self.send_queue, self)
self.receiver = Receiver(client_socket, self.receive_queue, self)
self.sender.start()
self.receiver.start()
def clear_queues(self):
self.receive_queue.queue.clear()
self.send_queue.queue.clear()
def broken_conn(self):
Logger.log("Broken connection", self.is_server)
self.send_queue.queue.clear()
self.receive_queue.queue.clear()
self.sender.close()
self.receiver.close()
self.waiting = True
self.authenticated = False
if (self.listener):
self.listener.broken_conn()
def close(self):
Logger.log("Connection closing", self.is_server)
self.send_queue.queue.clear()
self.receive_queue.queue.clear()
self.listener.close()
self.socket.close()
self.authenticated = False
if self.sender:
self.sender.close()
if self.receiver:
self.receiver.close()
def startGame():
listener = Listener('user_output.txt', shortcut_list)
listener.start()
return getNextLevel()
class NetMgr(Mgr):
def __init__(self, engine,localOptions):
Mgr.__init__(self, engine)
self.engine = engine
self.networkingEnabled = localOptions.enableNetworking
if self.networkingEnabled:
self.server = localOptions.server
else:
self.server = False
self.ip = localOptions.ip
self.remainingIDs = []
self.timeToWaitForPlayers = 10
def initialize(self):
pass
def loadLevel(self):
if self.networkingEnabled:
self.broadcaster = Broadcaster()
self.listener = Listener()
self.listener.start()
self.broadcaster.start()
if self.server or not self.networkingEnabled:
self.remainingIDs.append([1,""])
self.remainingIDs.append([2,""])
def releaseLevel(self):
if self.networkingEnabled:
self.listener.stop()
self.broadcaster.stop()
self.listener.join()
self.broadcaster.join()
def tick(self, dtime):
if self.networkingEnabled:
if dtime < 1 and self.timeToWaitForPlayers > 0:
self.timeToWaitForPlayers -= dtime
# check to see if all players are ready to start the race
if self.timeToWaitForPlayers > 0 and self.engine.gameMgr.allPlayersReady == False:
allReady = True
for ent in self.engine.entMgr.entities:
if not ent.isReady:
allReady = False
if len(self.engine.entMgr.entities) > 1:
self.engine.gameMgr.allPlayersReady = allReady
elif self.timeToWaitForPlayers <= 0:
self.engine.gameMgr.allPlayersReady = True
# get messages
incoming = self.listener.getMessages()
outgoingMsgs = []
for msgs in incoming:
msgType, msg = messages.unpack(msgs)
if msgType == const.STATUS:
found = False
# check to see if the status message is regarding a ship that is already created
for ent in self.engine.entMgr.entities:
if ent.shipId == msg.shipId:
found = True
# if it is, send updates to entity
if found and msg.shipId != self.engine.entMgr.playerIndex:
self.engine.entMgr.entities[msg.shipId].updateQueue.append(msg)
# if it isn't, create that entity
elif not found:
ent = Spaceship("Ship" + str(msg.shipId),msg.shipId, self.engine,const.MESHES[msg.shipId])
ent.pos = self.engine.entMgr.nextPos
self.engine.entMgr.nextPos.x += 40
self.engine.entMgr.entities.append(ent)
# only process requests before game has started
elif msgType == const.REQUEST and self.timeToWaitForPlayers > 0:
for ID in self.remainingIDs:
# if the id has not been issued already, or if the ID corresponds to a user who has been given an ID (but did not recieve their ID), send the ID
if ID[1] == "" or ID[1] == msg.userName:
outgoingMsgs.append(messages.pack(messages.InfoMessage(msg.userName,ID[0]),const.INFO))
ID[1] = msg.userName
# only process info messages when this player has not been handed a playerIndex
elif msgType == const.INFO and not self.server and self.engine.entMgr.playerIndex == -1:
self.engine.entMgr.playerIndex = msg.shipId
found = False
for ent in self.engine.entMgr.entities:
if ent.shipId == msg.shipId:
found = True
if not found:
ent = Spaceship("Ship" + str(msg.shipId),msg.shipId, self.engine,const.MESHES[msg.shipId])
ent.pos = self.engine.entMgr.nextPos
self.engine.entMgr.nextPos.x += 40
self.engine.entMgr.entities.append(ent)
# if this player has not been handed a playerIndex, request one.
if self.engine.entMgr.playerIndex == -1:
outgoingMsgs.append(messages.pack(messages.RequestMessage(str(socket.gethostname())),const.REQUEST))
# if the player has been handed a playerIndex, send the status of your ship
else:
myId = self.engine.entMgr.playerIndex
myEnt = self.engine.entMgr.entities[myId]
outgoingMsgs.append(messages.pack(messages.StatusMessage(myId,myEnt.pos,myEnt.dir,myEnt.colVel,myEnt.speed,myEnt.pitch, myEnt.roll,myEnt.isReady),const.STATUS))
# send outgoing messages
for msg in outgoingMsgs:
self.broadcaster.addMessage(msg)
#! /usr/bin/env python
from config import Config # this is a subdir
from listener import Listener
from poller import Poller
import sys
if __name__ == "__main__":
"""Run the monitor. The listener class waits for requests. The
poller class polls the PIDs that were input and forwards output
to the output class."""
parpid = sys.argv[1]
cfg = Config()
cfg.add_item('parentpid',parpid)
lst = Listener(cfg)
lst.start()
print "listener started"
# Where is the output class?
pol = Poller(cfg)
pol.start()
print "Poller started"
class NodeTester(wx.Frame):
def __init__(self):
wx.Frame.__init__(self, None, wx.ID_ANY, "Node Tester", size=(500, 500))
self.SetBackgroundColour(wx.Colour(255, 255, 255))
self.Bind(wx.EVT_CLOSE, self.onClose)
self.CreateStatusBar()
self.qStatus = queue.Queue()
menuBar = wx.MenuBar()
self.menuServer = wx.Menu()
self.menuServer.Append(MENU_SERVER_NODES, "Nodes Report", "Get Nodes Report")
self.menuServer.Append(MENU_SERVER_SHUTDOWN, "Shut down", "Shut down server")
self.menuNode = wx.Menu()
self.menuNode.Append(MENU_NODE_CONFIG, "Re-Config", "Modify current node configuration")
self.menuNode.Append(MENU_NODE_INIT, "Init", "Reinit the node communicatione with the server")
self.menuWindow = wx.Menu()
self.menuWindow.Append(MENU_WINDOW_INPUTS, "Inputs")
self.menuWindow.Append(MENU_WINDOW_OUTPUTS, "Outputs")
self.menuWindow.Append(MENU_WINDOW_SERVOS, "Servos/Turnouts")
menuBar.Append(self.menuServer, "Server")
menuBar.Append(self.menuNode, "Node")
menuBar.Append(self.menuWindow, "Window")
self.Bind(wx.EVT_MENU, self.onMenuNodes, id=MENU_SERVER_NODES)
self.Bind(wx.EVT_MENU, self.onMenuShutdown, id=MENU_SERVER_SHUTDOWN)
self.Bind(wx.EVT_MENU, self.onMenuConfig, id=MENU_NODE_CONFIG)
self.Bind(wx.EVT_MENU, self.onMenuInit, id=MENU_NODE_INIT)
self.Bind(wx.EVT_MENU, self.onMenuInputs, id=MENU_WINDOW_INPUTS)
self.Bind(wx.EVT_MENU, self.onMenuOutputs, id=MENU_WINDOW_OUTPUTS)
self.Bind(wx.EVT_MENU, self.onMenuServos, id=MENU_WINDOW_SERVOS)
self.SetMenuBar(menuBar)
self.images = Images("images")
self.ipAddress = "192.168.1.142"
self.httpPort = "8000"
self.socketPort = "8001"
self.server = Server()
self.listener = None
self.inputs = 1
self.outputs = 1
self.servos = 1
self.flags = 0
self.registers = 0
self.inputsMap = []
self.outputsMap = []
self.servosMap = []
self.subscribed = False
self.currentNodeAddr = None
self.timer = wx.Timer(self)
self.ticks = 0
self.clearTimer = None
sz = wx.BoxSizer(wx.VERTICAL)
sz.AddSpacer(2)
self.dlgInputs = None
self.dlgOutputs = None
self.dlgServos = None
boxSvr = wx.StaticBox(self, wx.ID_ANY, " Server ")
topBorder, botBorder = boxSvr.GetBordersForSizer()
if os.name != 'nt':
botBorder += 30
bsizer = wx.BoxSizer(wx.VERTICAL)
bsizer.AddSpacer(topBorder)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
hsizer.AddSpacer(10)
hsizer.Add(wx.StaticText(boxSvr, wx.ID_ANY, "IP Address:", size=(SVRLABELW, -1)))
self.teIpAddr = wx.TextCtrl(boxSvr, wx.ID_ANY, self.ipAddress, size=(125, -1))
self.Bind(wx.EVT_TEXT, self.onTeIpAddrChange, self.teIpAddr)
self.teIpAddr.Bind(wx.EVT_KILL_FOCUS, self.onTeIpAddrLoseFocus)
self.teIpAddr.Bind(wx.EVT_SET_FOCUS, self.onTeIpAddrSetFocus)
hsizer.Add(self.teIpAddr)
hsizer.AddSpacer(10)
bsizer.Add(hsizer)
bsizer.AddSpacer(5)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
hsizer.AddSpacer(10)
hsizer.Add(wx.StaticText(boxSvr, wx.ID_ANY, "HTTP Port:", size=(SVRLABELW, -1)))
self.teHPort = wx.TextCtrl(boxSvr, wx.ID_ANY, self.httpPort, size=(125, -1))
self.Bind(wx.EVT_TEXT, self.onTeHPortChange, self.teHPort)
self.teHPort.Bind(wx.EVT_KILL_FOCUS, self.onTeHPortLoseFocus)
self.teHPort.Bind(wx.EVT_SET_FOCUS, self.onTeHPortSetFocus)
hsizer.Add(self.teHPort)
hsizer.AddSpacer(10)
bsizer.Add(hsizer)
bsizer.AddSpacer(5)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
hsizer.AddSpacer(10)
hsizer.Add(wx.StaticText(boxSvr, wx.ID_ANY, "Socket Port:", size=(SVRLABELW, -1)))
self.teSPort = wx.TextCtrl(boxSvr, wx.ID_ANY, self.socketPort, size=(125, -1))
hsizer.Add(self.teSPort)
hsizer.AddSpacer(10)
self.bSubscribe = wx.Button(boxSvr, wx.ID_ANY, "Subscribe")
self.bSubscribe.SetToolTip("Subscribe to receive asynchronous reports from the server")
self.Bind(wx.EVT_BUTTON, self.onSubscribe, self.bSubscribe)
hsizer.Add(self.bSubscribe)
hsizer.AddSpacer(10)
bsizer.Add(hsizer)
bsizer.AddSpacer(botBorder)
boxSvr.SetSizer(bsizer)
sz.Add(boxSvr, 0, wx.EXPAND|wx.ALL, 5)
sz.AddSpacer(10)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
hsizer.AddSpacer(10)
hsizer.Add(wx.StaticText(self, wx.ID_ANY, "Node Address:"))
hsizer.AddSpacer(10)
self.stAddr = wx.StaticText(self, wx.ID_ANY, " ")
hsizer.Add(self.stAddr)
hsizer.AddSpacer(20)
self.bGetAddr = wx.Button(self, wx.ID_ANY, "...", size=(30, -1))
self.bGetAddr.SetToolTip("Select node address")
self.Bind(wx.EVT_BUTTON, self.onGetNodeAddr, self.bGetAddr)
hsizer.Add(self.bGetAddr)
hsizer.AddSpacer(10)
self.bRefresh = wx.Button(self, wx.ID_ANY, "Refresh")
self.bRefresh.SetToolTip("Refresh node information by querying the actual node")
self.Bind(wx.EVT_BUTTON, self.onBRefresh, self.bRefresh)
hsizer.Add(self.bRefresh)
sz.Add(hsizer)
sz.AddSpacer(10)
boxCfg = wx.StaticBox(self, wx.ID_ANY, " Node Config ")
topBorder, botBorder = boxCfg.GetBordersForSizer()
if os.name != 'nt':
botBorder += 30
bsizer = wx.BoxSizer(wx.VERTICAL)
bsizer.AddSpacer(topBorder)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
hsizer.AddSpacer(10)
hsizer.Add(wx.StaticText(boxCfg, wx.ID_ANY, "Inputs:", size=(CFGLABELW, -1)))
self.stInputs = wx.StaticText(boxCfg, wx.ID_ANY, "")
hsizer.Add(self.stInputs)
hsizer.AddSpacer(10)
bsizer.Add(hsizer)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
hsizer.AddSpacer(10)
hsizer.Add(wx.StaticText(boxCfg, wx.ID_ANY, "Outputs:", size=(CFGLABELW, -1)))
self.stOutputs = wx.StaticText(boxCfg, wx.ID_ANY, "")
hsizer.Add(self.stOutputs)
hsizer.AddSpacer(10)
bsizer.Add(hsizer)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
hsizer.AddSpacer(10)
hsizer.Add(wx.StaticText(boxCfg, wx.ID_ANY, "Servos:", size=(CFGLABELW, -1)))
self.stServos = wx.StaticText(boxCfg, wx.ID_ANY, "")
hsizer.Add(self.stServos)
hsizer.AddSpacer(10)
bsizer.Add(hsizer)
bsizer.AddSpacer(botBorder)
self.setConfigValues(1, 1, 1)
boxCfg.SetSizer(bsizer)
sz.Add(boxCfg, 0, wx.EXPAND|wx.ALL, 5)
sz.AddSpacer(20)
mainsz = wx.BoxSizer(wx.HORIZONTAL)
mainsz.AddSpacer(20)
mainsz.Add(sz)
mainsz.AddSpacer(20)
wsz = wx.BoxSizer(wx.VERTICAL)
wsz.Add(mainsz)
self.SetSizer(wsz)
self.Layout()
self.Fit()
self.Show()
self.enableMenuItems(False)
self.server.setServerAddress(self.teIpAddr.GetValue(), self.teHPort.GetValue())
self.serverValueChanged = False
self.hPortValueChanged = False
self.timer.Start(250)
self.Bind(wx.EVT_TIMER, self.onTimer)
self.Bind(EVT_DELIVERY, self.onDeliveryEvent)
self.Bind(EVT_DISCONNECT, self.onDisconnectEvent)
self.sz = self.GetSize()
print("size = ", self.sz)
def onMenuInputs(self, _):
if self.currentNodeAddr is None:
self.setStatusText("Retrieve configuration first")
else:
self.openInputsDlg()
def openInputsDlg(self):
if len(self.inputsMap) == 0:
self.setStatusText("No inputs information available")
return
pos = None
if self.dlgInputs is not None:
try:
pos = self.dlgInputs.GetScreenPosition()
self.dlgInputs.Destroy()
except:
pos = None
self.dlgInputs = InputsDlg(self, self.inputsMap, self.inputs, self.currentNodeAddr)
if pos is not None:
self.dlgInputs.SetPosition(pos)
else:
ppos = self.GetScreenPosition()
self.dlgInputs.SetPosition((ppos[0], ppos[1]+self.sz[1]))
self.dlgInputs.Show()
self.szInputs = self.dlgInputs.GetSize()
def dlgInputsExit(self):
self.dlgInputs = None
def onMenuOutputs(self, _):
if self.currentNodeAddr is None:
self.setStatusText("Retrieve configuration first")
else:
self.openOutputsDlg()
def openOutputsDlg(self):
if len(self.outputsMap) == 0:
self.setStatusText("No outputs information available")
return
pos = None
if self.dlgOutputs is not None:
try:
pos = self.dlgOutputs.GetScreenPosition()
self.dlgOutputs.Destroy()
except:
pos = None
self.dlgOutputs = OutputsDlg(self, self.outputsMap, self.outputs, self.currentNodeAddr)
if pos is not None:
self.dlgOutputs.SetPosition(pos)
else:
ppos = self.GetScreenPosition()
self.dlgOutputs.SetPosition((ppos[0], ppos[1]+self.sz[1]+self.szInputs[1]))
self.dlgOutputs.Show()
self.szOutputs = self.GetSize()
def dlgOutputsExit(self):
self.dlgOutputs = None
def onMenuServos(self, _):
if self.currentNodeAddr is None:
self.setStatusText("Retrieve configuration first")
else:
self.openServosDlg()
def openServosDlg(self):
if len(self.servosMap) == 0:
self.setStatusText("No outputs information available")
return
pos = None
if self.dlgServos is not None:
try:
pos = self.dlgServos.GetScreenPosition()
self.dlgServos.Destroy()
except:
pos = None
self.dlgServos = ServosDlg(self, self.servosMap, self.servos, self.currentNodeAddr)
if pos is not None:
self.dlgServos.SetPosition(pos)
else:
ppos = self.GetScreenPosition()
self.dlgServos.SetPosition((ppos[0]+self.sz[0], ppos[1]))
self.dlgServos.Show()
def dlgServosExit(self):
self.dlgServos = None
def onTeIpAddrSetFocus(self, evt):
self.serverValueChanged = False
evt.Skip()
def onTeIpAddrChange(self, _):
self.serverValueChanged = True
def onTeIpAddrLoseFocus(self, evt):
if self.serverValueChanged:
self.serverValueChanged = False
self.server.setServerAddress(self.teIpAddr.GetValue(), self.teHPort.GetValue())
evt.Skip()
def onTeHPortSetFocus(self, evt):
self.hPortValueChanged = False
evt.Skip()
def onTeHPortChange(self, _):
self.hPortValueChanged = True
def onTeHPortLoseFocus(self, evt):
if self.hPortValueChanged:
self.hPortValueChanged = False
self.server.setServerAddress(self.teIpAddr.GetValue(), self.teHPort.GetValue())
evt.Skip()
def throwTurnout(self, tx, throw):
ip = self.teIpAddr.GetValue()
pt = self.teHPort.GetValue()
addr = self.currentNodeAddr
if throw == "N":
try:
sc, data = self.server.setTurnoutNormal(addr, tx)
except:
self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt))
return False
elif throw == "R":
try:
sc, data = self.server.setTurnoutReverse(addr, tx)
except:
self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt))
return False
else: # throw == "T"
try:
sc, data = self.server.setTurnoutToggle(addr, tx)
except:
self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt))
return False
if sc < 400:
try:
if throw == "N":
self.servosMap[tx][3] = self.servosMap[tx][0]
elif throw == "R":
self.servosMap[tx][3] = self.servosMap[tx][1]
else:
if self.servosMap[tx][3] == self.servosMap[tx][0]:
self.servosMap[tx][3] = self.servosMap[tx][1]
if self.servosMap[tx][3] == self.servosMap[tx][1]:
self.servosMap[tx][3] = self.servosMap[tx][0]
else:
# toggle would have done nothing here
pass
self.setStatusText("Success")
return True
except:
self.setStatusText("Unable to process return data: '%s'" % data)
return False
else:
self.setStatusText("RC <%d> %s" % (sc, data))
return False
def setServoAngle(self, sx, ang):
ip = self.teIpAddr.GetValue()
pt = self.teHPort.GetValue()
addr = self.currentNodeAddr
try:
sc, data = self.server.setServoAngle(addr, sx, ang)
except:
self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt))
return False
if sc < 400:
try:
self.servosMap[sx][3] = ang
self.setStatusText("Success")
return True
except:
self.setStatusText("Unable to process return data: '%s'" % data)
return False
else:
self.setStatusText("RC <%d> %s" % (sc, data))
return False
def setTurnoutLimits(self, tx, norm, rev, ini):
ip = self.teIpAddr.GetValue()
pt = self.teHPort.GetValue()
addr = self.currentNodeAddr
try:
sc, data = self.server.setlimits(addr, tx, norm, rev, ini)
except:
self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt))
return False
if sc < 400:
try:
self.servosMap[tx][0] = norm
self.servosMap[tx][1] = rev
self.servosMap[tx][2] = ini
self.setStatusText("Success")
return True
except:
self.setStatusText("Unable to process return data: '%s'" % data)
return False
else:
self.setStatusText("RC <%d> %s" % (sc, data))
return False
def swapTurnout(self, tx):
ip = self.teIpAddr.GetValue()
pt = self.teHPort.GetValue()
addr = self.currentNodeAddr
sv = self.servosMap[tx]
norm = sv[0]
rev = sv[1]
try:
sc, data = self.server.setlimits(addr, tx, rev, norm, sv[2])
except:
self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt))
return False
if sc < 400:
try:
self.servosMap[tx][0] = rev
self.servosMap[tx][1] = norm
self.setStatusText("Success")
return True
except:
self.setStatusText("Unable to process return data: '%s'" % data)
return False
else:
self.setStatusText("RC <%d> %s" % (sc, data))
return False
def nodeStore(self):
ip = self.teIpAddr.GetValue()
pt = self.teHPort.GetValue()
addr = self.currentNodeAddr
try:
sc, data = self.server.nodeStore(addr)
except:
self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt))
return False
if sc < 400:
self.setStatusText("Success")
return True
else:
self.setStatusText("RC <%d> %s" % (sc, data))
return False
def getServosMap(self):
return self.servosMap
def setOutput(self, bn, newState):
ip = self.teIpAddr.GetValue()
pt = self.teHPort.GetValue()
addr = self.currentNodeAddr
if newState:
try:
sc, data = self.server.setOutputOn(addr, bn)
except:
self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt))
return False
else:
try:
sc, data = self.server.setOutputOff(addr, bn)
except:
self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt))
return False
if sc < 400:
try:
self.outputsMap[bn] = newState
self.setStatusText("Success")
return True
except:
self.setStatusText("Unable to process return data: '%s'" % data)
return False
else:
self.setStatusText("RC <%d> %s" % (sc, data))
return False
def pulseOutput(self, bn, pl):
ip = self.teIpAddr.GetValue()
pt = self.teHPort.GetValue()
addr = self.currentNodeAddr
try:
sc, data = self.server.pulseOutput(addr, bn, pl)
except:
self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt))
return False
if sc < 400:
try:
self.setStatusText("Success")
return True
except:
self.setStatusText("Unable to process return data: '%s'" % data)
return False
else:
self.setStatusText("RC <%d> %s" % (sc, data))
return False
def setConfigValues(self, i, o, s):
self.inputs = i
self.stInputs.SetLabel("%d" % i)
self.outputs = o
self.stOutputs.SetLabel("%d" % o)
self.servos = s
self.stServos.SetLabel("%d" % s)
def onSubscribe(self, _):
if self.subscribed:
self.listener.kill()
self.listener.join()
self.listener = None
self.subscribed = False
self.bSubscribe.SetLabel("Subscribe")
else:
ip = self.teIpAddr.GetValue()
pt = self.teSPort.GetValue()
self.listener = Listener(self, ip, pt)
self.listener.start()
self.subscribed = True
self.bSubscribe.SetLabel("Unsubscribe")
def raiseDeliveryEvent(self, data):
try:
jdata = json.loads(data)
except json.decoder.JSONDecodeError:
print("Unable to parse (%s)" % data)
return
evt = DeliveryEvent(data=jdata)
wx.PostEvent(self, evt)
def raiseDisconnectEvent(self):
evt = DisconnectEvent()
wx.PostEvent(self, evt)
def onDisconnectEvent(self, _):
self.listener = None
self.subscribed = False
self.bSubscribe.SetLabel("Subscribe")
self.setStatusText("Server socket closed")
def setStatusText(self, text):
if self.clearTimer == 0:
self.clearTimer = 10
self.SetStatusText(text)
else:
self.qStatus.put(text)
def onGetNodeAddr(self, _):
nr = self.getNodeRpt()
if nr is None:
dlg = wx.MessageDialog(self, 'Unable to retrieve node report from server',
'Error', wx.OK | wx.ICON_INFORMATION)
dlg.ShowModal()
dlg.Destroy()
return
dlg = NodeDlg(self, self.currentNodeAddr, nr)
rc = dlg.ShowModal()
if rc in [ wx.ID_OK, ID_INIT ]:
n = dlg.getValues()
dlg.Destroy()
if rc not in [ wx.ID_OK, ID_INIT ]:
return
if n is None:
return
if rc == wx.ID_OK:
self.currentNodeAddr = n
self.stAddr.SetLabel("%d" % self.currentNodeAddr)
self.loadConfig()
else:
self.doInit(n)
def onBRefresh(self, _):
ip = self.teIpAddr.GetValue()
pt = self.teHPort.GetValue()
addr = self.currentNodeAddr
try:
sc, data = self.server.nodeRefresh(addr)
except:
self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt))
return
if sc >= 400:
self.setStatusText("RC <%d> %s" % (sc, data))
return False
self.setStatusText("Refresh Success")
self.loadConfig()
def loadConfig(self):
ip = self.teIpAddr.GetValue()
pt = self.teHPort.GetValue()
addr = self.currentNodeAddr
if addr is None:
self.setStatusText("Select node address first")
self.enableMenuItems(False)
self.enableMenuItems(True)
try:
sc, data = self.server.getConfig(addr)
except:
self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt))
if sc < 400:
try:
d = json.loads(data)
self.setConfigValues(d['inputs'], d['outputs'], d['servos'])
self.setStatusText("Retrieve Node Config Success")
except:
self.setStatusText("Unable to process return data: '%s'" % data)
else:
self.setStatusText("RC <%d> %s" % (sc, data))
try:
sc, data = self.server.getInputs(addr)
except:
self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt))
return
if sc < 400:
try:
d = json.loads(data)
self.inputsMap = d["inputs"]["values"]
self.openInputsDlg()
self.setStatusText("Retrieve Inputs Success")
except:
self.inputsMap = []
self.setStatusText("Unable to process return data: '%s'" % data)
else:
self.setStatusText("RC <%d> %s" % (sc, data))
try:
sc, data = self.server.getOutputs(addr)
except:
self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt))
return
if sc < 400:
try:
d = json.loads(data)
self.outputsMap = d["outputs"]["values"]
self.openOutputsDlg()
self.setStatusText("Retrieve Outputs Success")
except:
self.outputsMap = []
self.setStatusText("Unable to process return data: '%s'" % data)
else:
self.setStatusText("RC <%d> %s" % (sc, data))
try:
sc, data = self.server.getTurnouts(addr)
except:
self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt))
return
if sc < 400:
try:
d = json.loads(data)
self.servosMap = d["servos"]["values"]
self.openServosDlg()
self.setStatusText("Retrieve Turnouts Success")
except:
self.servosMap = []
self.setStatusText("Unable to process return data: '%s'" % data)
else:
self.setStatusText("RC <%d> %s" % (sc, data))
def enableMenuItems(self, flag):
self.menuNode.Enable(MENU_NODE_CONFIG, flag)
self.menuWindow.Enable(MENU_WINDOW_INPUTS, flag)
self.menuWindow.Enable(MENU_WINDOW_OUTPUTS, flag)
self.menuWindow.Enable(MENU_WINDOW_SERVOS, flag)
self.bRefresh.Enable(flag)
def onDeliveryEvent(self, evt):
if "inputs" in evt.data:
imsg = evt.data["inputs"]
iaddr = imsg["address"]
if iaddr != self.currentNodeAddr:
return
if "delta" in imsg and imsg["delta"]:
vals = imsg["values"]
if len(vals) > 0:
for inp, val in vals:
self.inputsMap[inp] = val
if self.dlgInputs is not None:
self.dlgInputs.update(self.inputsMap)
else:
vals = imsg["values"]
if len(vals) == len(self.inputsMap):
self.inputsMap = [x for x in vals]
if self.dlgInputs is not None:
self.dlgInputs.update(self.inputsMap)
else:
self.setStatusText("Mismatch number of inputs")
elif "outputs" in evt.data:
omsg = evt.data["outputs"]
iaddr = omsg["address"]
if iaddr != self.currentNodeAddr:
return
if "delta" in omsg and omsg["delta"]:
vals = omsg["values"]
if len(vals) > 0:
for outp, val in vals:
self.outputsMap[outp] = val
if self.dlgOutputs is not None:
self.dlgOutputs.update(self.outputsMap)
else:
vals = omsg["values"]
if len(vals) == len(self.outputsMap):
self.outputsMap = [x for x in vals]
if self.dlgOutputs is not None:
self.dlgOutputs.update(self.outputsMap)
else:
self.setStatusText("Mismatch number of outputs")
elif "servos" in evt.data:
smsg = evt.data["servos"]
iaddr = smsg["address"]
if iaddr != self.currentNodeAddr:
return
if "limits" in smsg and smsg["limits"]:
vals = smsg["values"]
if len(vals) > 0:
for outp, v0, v1, v2 in vals:
self.servosMap[outp][0] = v0
self.servosMap[outp][1] = v1
self.servosMap[outp][2] = v2
if self.dlgServos is not None:
self.dlgServos.update(self.servosMap)
elif "delta" in smsg and smsg["delta"]:
vals = smsg["values"]
if len(vals) > 0:
for outp, val in vals:
self.servosMap[outp][3] = val
if self.dlgServos is not None:
self.dlgServos.update(self.servosMap)
else:
vals = smsg["values"]
if len(vals) == len(self.servosMap):
self.servosMap = [x for x in vals]
if self.dlgServos is not None:
self.dlgServos.update(self.servosMap)
else:
self.setStatusText("Mismatch number of turnouts/servos")
elif "pulse" in evt.data:
pmsg = evt.data["pulse"]
iaddr = pmsg["address"]
if iaddr != self.currentNodeAddr:
return
idx = pmsg["index"]
pl = pmsg["length"]
self.outputsMap[idx] = False # only on for a brief period
if self.dlgOutputs is not None:
self.dlgOutputs.pulseOutput(idx, pl)
elif "nodes" in evt.data:
print(json.dumps(evt.data))
if self.currentNodeAddr is None:
# nothing to do with this is we are not currently looking at a node
return
for nd in evt.data["nodes"]:
if nd["address"] == self.currentNodeAddr and not nd["active"]:
# we are looking at an inactive node - tear down the dialog boxes
if self.dlgInputs is not None:
self.dlgInputs.Destroy()
self.dlgInputs = None
if self.dlgOutputs is not None:
self.dlgOutputs.Destroy()
self.dlgOutputs = None
if self.dlgServos is not None:
self.dlgServos.Destroy()
self.dlgServos = None
self.currentNodeAddr = None
self.stAddr.SetLabel(" ")
break
else:
print("Unknown report type (%s)" % list(evt.data.keys())[0])
def onMessageEvent(self, evt):
self.setStatusText(evt.message)
def getNodeRpt(self):
ip = self.teIpAddr.GetValue()
pt = self.teHPort.GetValue()
try:
sc, data = self.server.getNodeRpt()
except:
self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt))
return None
if sc < 400:
try:
self.setStatusText("Success")
d = json.loads(data)
return d
except:
self.setStatusText("Unable to process return data: '%s'" % data)
return None
else:
self.setStatusText("RC <%d> %s" % (sc, data))
return None
def onMenuNodes(self, _):
d = self.getNodeRpt()
if d is None:
return False
try:
nl = d["nodes"]
except:
return False
rpt = ""
for nd in nl:
active = "Active" if nd["active"] else "Inactive"
rpt += "%20.20s: A:%-2d I:%-2d O:%-2d S:%-2d %s\n" % (
nd["name"], nd["address"], nd["inputs"], nd["outputs"],
nd["servos"], active)
dlg = wx.MessageDialog(self, rpt, "Nodes Report", wx.OK | wx.ICON_INFORMATION)
dlg.ShowModal()
dlg.Destroy()
return True
def onMenuConfig(self, _):
addr = self.currentNodeAddr
dlg = wx.MessageDialog(self,
"Proceeding with this will result in the node restarting\nand will require a reconfiguration and restart of the server process",
"Reconfiguration of Node %d" % addr, wx.OK | wx.CANCEL | wx.ICON_WARNING)
rc = dlg.ShowModal()
dlg.Destroy()
if rc == wx.ID_OK:
dlg = NodeConfigDlg(self, addr, self.inputs, self.outputs, self.servos)
rc = dlg.ShowModal()
if rc == wx.ID_OK:
a, i, o, s = dlg.getValues()
dlg.Destroy()
if rc != wx.ID_OK:
return
ip = self.teIpAddr.GetValue()
pt = self.teHPort.GetValue()
try:
sc, data = self.server.setConfig(addr, a, i, o, s)
except:
self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt))
return False
if sc < 400:
self.setStatusText("Success")
return True
else:
self.setStatusText("RC <%d> %s" % (sc, data))
return False
def onMenuInit(self, _):
if self.currentNodeAddr is None:
return
self.doInit(self.currentNodeAddr)
def doInit(self, addr):
ip = self.teIpAddr.GetValue()
pt = self.teHPort.GetValue()
try:
sc, data = self.server.nodeInit(addr)
except:
self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt))
return False
if sc < 400:
self.setStatusText("Success")
return True
else:
self.setStatusText("RC <%d> %s" % (sc, data))
return False
def onMenuShutdown(self, _):
dlg = wx.MessageDialog(self,
"This will shutdown the server process.\nAre you sure you want to proceed?",
"Continue with server shutdown", wx.YES_NO | wx.NO_DEFAULT | wx.ICON_WARNING)
rc = dlg.ShowModal()
dlg.Destroy()
if rc == wx.ID_YES:
ip = self.teIpAddr.GetValue()
pt = self.teHPort.GetValue()
try:
sc, data = self.server.quit()
except:
self.setStatusText("Unable to connect to node server at address %s:%s" % (ip, pt))
return False
if sc < 400:
self.setStatusText("Success")
return True
else:
self.setStatusText("RC <%d> %s" % (sc, data))
return False
def onTimer(self, _):
# do this every quarter second
if self.dlgOutputs is not None:
self.dlgOutputs.clearPulses()
self.ticks += 1
if self.ticks < 4:
return
self.ticks = 0
# do this once a second
if self.clearTimer is None:
return
if self.clearTimer == 0:
if self.qStatus.empty():
self.SetStatusText("")
self.clearTimer = None
else:
t = self.qStatus.get()
self.SetStatusText(t)
elif self.clearTimer >0:
self.clearTimer -= 1
def onClose(self, _):
if self.listener is not None:
self.setStatusText("destroying listener thread")
self.listener.kill()
self.listener.join()
self.Destroy()
class TIM(QWidget, Ui_Form_For_Main):
grouplist = []
userslist = []
tmpuseritem = []
groupInfo = {}
chatWindow = {}
groupChatWindow = {}
my_groups = [] #Save my group
glist = [] #Save all information for each group
def __init__(self, client):
super().__init__()
self.m_drag = False
self.m_DragPosition = QPoint()
self.cache = Cache(self)
self.setupUi(self)
self.client = client
self.Ui_init()
self.menuflag = 1
self.temp = {}
self.groupTemp = [] #New group id
self.addTemp = [] #Join the group id
self.setStyleSheet(open('styles/style5.qss').read())
self.setWindowIcon(QIcon('img/bubbles-alt-icon.png'))
palette = QPalette()
palette.setBrush(self.backgroundRole(),
QtGui.QBrush(QtGui.QPixmap('img/background/bg1.jpg')))
self.setPalette(palette)
self.setWindowFlag(Qt.FramelessWindowHint)
self.tray = MySystemTray(self)
self.listener = Listener(self)
self.listener.newSysMsgSignal.connect(self.cache.newSysMsg)
self.listener.newFriendMsgSignal.connect(self.newFriendMsg)
self.listener.newGroupMsgSignal.connect(self.newGroupMsg)
self.listener.successAddFriendSignal.connect(self.successAddFriend)
self.listener.friendOfflineSignal.connect(self.dealFriendOffline)
self.listener.friendsOnlineSignal.connect(self.dealFriendOnline)
self.listener.noExistSignal.connect(self.noExist)
self.listener.offlineSignal.connect(self.offline)
self.listener.beDelSignal.connect(self.dealBeDel)
self.listener.createGroupOkSignal.connect(self.dealCreateGroupOk)
self.listener.addGroupOkSignal.connect(self.dealAddGroupOk)
self.listener.start()
def Ui_init(self):
image = QImage()
image.loadFromData(self.client.head)
self.lblHead.setScaledContents(True)
self.lblHead.setPixmap(QPixmap.fromImage(image))
self.lblName.setText(self.client.name)
self.lblId.setText(str(self.client.id))
self.bt_search.setIcon(QIcon('img/search.png'))
self.minBt.setIcon(QIcon('img/min.png'))
self.closeBt.setIcon(QIcon('img/wclose.png'))
self.setupBt.setIcon(QIcon('img/setting.png'))
self.bt_adduser.setIcon(QIcon('img/add.png'))
self.cacheBt.setIcon(QIcon('img/msg.png'))
self.groupBt.setIcon(QIcon('img/群组.png'))
self.faceBt.setIcon(QIcon("img/face.png"))
self.lblIcon.setPixmap(QPixmap('img/chat.png'))
self.tabWidget.setStyleSheet("background-color:rgba(255,255,255,0.7)")
self.treeWidget.setStyleSheet("background-color:rgba(255,255,255,0)")
self.groups.setStyleSheet("background-color:rgba(255,255,255,0)")
self.groupList.setStyleSheet("background-color:rgba(255,255,255,0)")
self.friendList.setStyleSheet("background-color:rgba(255,255,255,0)")
self.m_model = QStandardItemModel(0, 1, self)
m_completer = QCompleter(self.m_model, self)
self.lineEdit.setCompleter(m_completer)
m_completer.activated[str].connect(self.onUsernameChoosed)
self.setupBt.clicked.connect(self.setUp)
self.closeBt.clicked.connect(self.close)
self.minBt.clicked.connect(self.showMinimized)
self.cacheBt.clicked.connect(self.msgCache)
self.groupBt.clicked.connect(self.addGroup)
self.faceBt.clicked.connect(self.changeFace)
self.treeWidget.currentItemChanged.connect(self.restatistic)
self.treeWidget.itemClicked.connect(self.isclick)
self.bt_adduser.clicked.connect(self.on_bt_adduser_clicked)
self.bt_search.clicked.connect(self.on_bt_search_clicked)
self.lineEdit.textChanged[str].connect(self.on_lineEdit_textChanged)
self.treeWidget.itemDoubleClicked.connect(
self.cache.responseFriendItemClicked)
self.groups.itemDoubleClicked.connect(
self.cache.responseGroupItemClicked)
self.treeWidget.setIndentation(0)
self.treeWidget.setColumnCount(1)
self.treeWidget.setColumnWidth(0, 50)
self.treeWidget.setHeaderLabels(['Friend'])
self.treeWidget.header().hide()
self.treeWidget.setIconSize(QSize(70, 70))
self.treeWidget.setFocusPolicy(Qt.NoFocus)
self.treeWidget.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.treeWidget.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.creategroup()
self.initGroup()
def closeWindow(self):
if self.cache.isVisible() == True:
self.cache.close()
for i in self.chatWindow.keys():
self.chatWindow[i].close()
for i in self.groupChatWindow.keys():
self.groupChatWindow[i].close()
def dealCreateGroupOk(self, gid, data):
gname = data.decode('utf-8')
for info in self.groupTemp:
if gname == info[0]:
ghead = info[1]
newG = Group(gname, gid, ghead, [self.client.id])
item = QListWidgetItem(self.groups)
item.setSizeHint(QSize(self.groups.width(), 61))
self.groups.setItemWidget(item, newG)
self.groupTemp.remove(info)
self.my_groups.append(gid)
groupdic = {
'group': item,
'groupid': gid,
'groupname': gname,
'grouphead': ghead,
'groupmember': [self.client.id]
}
self.glist.append(groupdic)
break
def dealAddGroupOk(self, gid, data):
if gid in self.addTemp:
data = data.split('\n'.encode('utf-8'), 2)
gname = data[0].decode('utf-8')
gmembers = json.loads(data[1].decode('utf-8'))
ghead = data[2]
item = QListWidgetItem(self.groups)
item.setSizeHint(QSize(self.groups.width(), 61))
newG = Group(gname, gid, ghead, gmembers)
self.groups.setItemWidget(item, newG)
self.addTemp.remove(gid)
self.my_groups.append(gid)
groupdic = {
'group': item,
'groupid': gid,
'groupname': gname,
'grouphead': ghead,
'groupmember': gmembers
}
self.glist.append(groupdic)
def newGroupMsg(self, groupid, type, data):
if groupid in self.groupChatWindow.keys(
) and self.groupChatWindow[groupid].isVisible():
if (type == Type.GROUP_TEXT):
self.groupChatWindow[groupid].recviveMsg(data.decode('utf-8'))
else:
self.groupChatWindow[groupid].recvivePic(data)
else:
self.cache.newGroupMsg(groupid, type, data)
def newFriendMsg(self, id, type, data):
if type == Type.FILE:
for user in self.userslist:
if id == user['userid']:
name = user['username']
break
filename, file = data.split('\n'.encode('utf-8'), 1)
filename = filename.decode('utf-8')
response = QMessageBox.question(
None, "Message",
"Friend %s (%s) Send file %s，Would you like to accept it?" %
(name, id, filename), QMessageBox.Yes | QMessageBox.No,
QMessageBox.Yes)
if response == QMessageBox.Yes:
filepath = QFileDialog.getSaveFileName(None, 'Save as',
'./' + filename, '')
if filepath[0]:
with open(filepath[0], 'wb') as f:
f.write(file)
self.client.dealAcceptFile(id, filename)
else:
self.client.dealRefuseFile(id, filename)
else:
self.client.dealRefuseFile(id, filename)
elif type == Type.FILE_AC:
for user in self.userslist:
if id == user['userid']:
name = user['username']
break
QMessageBox.information(
None, 'Message', 'Friend %s (%s) Received file %s' %
(name, id, data.decode('utf-8')))
elif type == Type.FILE_RF:
for user in self.userslist:
if id == user['userid']:
name = user['username']
break
QMessageBox.information(
None, 'Message',
'Friend %s (%s) 拒绝接收文件 %s' % (name, id, data.decode('utf-8')))
else:
if id in self.chatWindow.keys() and self.chatWindow[id].isVisible(
):
if type == Type.TEXT:
self.chatWindow[id].recviveMsg(data.decode('utf-8'))
elif type == Type.PIC:
self.chatWindow[id].recvivePic(data)
else:
self.cache.newFriendMsg(id, type, data)
def sendGroupMsg(self, id, text):
self.client.dealSendGroupMsg(id, text)
def sendGroupPic(self, id, pic):
self.client.dealSendGroupPic(id, pic)
def sendMsg(self, id, text):
index = self.searchuser(id)
if self.userslist[index]['ishide'] == 1:
self.chatWindow[id].notOnline()
else:
self.client.dealSendMsg(id, text)
def sendPic(self, id, bytes):
index = self.searchuser(id)
if self.userslist[index]['ishide'] == 1:
self.chatWindow[id].notOnline()
else:
self.client.dealSendPic(id, bytes)
def sendFile(self, id, filename):
index = self.searchuser(id)
if self.userslist[index]['ishide'] == 1:
self.chatWindow[id].notOnline()
else:
self.client.dealSendFile(id, filename)
def initGroup(self): #格式{群id:[群成员id]}?? #grouplist格式为：列表[群id]
self.my_groups = groupInfo = self.client.dealGetGroupList()
for groupid in groupInfo:
groupname, grouphead = self.client.dealGetGroupNameAndHead(groupid)
groupmember = self.client.dealGetGroupMember(groupid)
group = QListWidgetItem(self.groups)
group.setSizeHint(QSize(self.groups.width(), 55))
groupdic = {
'group': group,
'groupid': groupid,
'groupname': groupname,
'grouphead': grouphead,
'groupmember': groupmember
}
g = Group(groupname, str(groupid), grouphead, groupmember)
self.glist.append(groupdic)
self.groups.setItemWidget(group, g)
def addGroup(self):
addG = AddGroup(self.my_groups, self.groupTemp, self.addTemp)
response = addG.exec_()
if response == 1:
gname, ghead = self.groupTemp[-1]
self.client.dealCreateGroup(gname, ghead)
elif response == 2:
gid = self.addTemp[-1]
self.client.dealJoinGroup(gid)
def changeFace(self):
file = QFileDialog.getOpenFileName(self, 'Select background', '.',
("Images (*.png *.jpg *.bmp)"))
if file[0]:
palette = QPalette()
palette.setBrush(self.backgroundRole(),
QtGui.QBrush(QtGui.QPixmap(file[0])))
self.setPalette(palette)
def noExist(self, id):
QMessageBox.information(self, 'Prompt',
'There is no account number %s User!' % (id))
for k, v in self.temp.items():
if k == id:
self.temp.pop(k)
break
def dealBeDel(self, id):
dindex = self.searchuser(id)
ishide = self.userslist[dindex]['ishide']
delitem = self.userslist[dindex]['user']
pindex = delitem.parent().indexOfChild(delitem)
name = self.userslist[dindex]['username']
del self.userslist[dindex]
fathergroup = delitem.parent()
findex = self.searchgroup(fathergroup)
parentName = self.grouplist[findex]['groupname']
if ishide == 1:
self.grouplist[findex]['childishide'] -= 1
self.grouplist[findex]['childcount'] -= 1
else:
self.grouplist[findex]['childcount'] -= 1
delitem.parent().takeChild(pindex)
for user in self.groupInfo[parentName]:
if user['userid'] == id:
self.groupInfo[parentName].remove(user)
break
def offline(self, id):
QMessageBox.information(
self, 'Prompt',
'Account number is %s Users are not online!' % (id))
for k, v in self.temp.items():
if k == id:
self.temp.pop(k)
break
def dealRefuseAdd(self, id):
QMessageBox.information(
self, 'Prompt',
'Account number is %s User rejects your friend request!' % id)
for k, v in self.temp.items():
if k == id:
self.temp.pop(k)
break
def dealFriendOnline(self, id):
useritemindex = self.searchuser(id)
if useritemindex is not None:
self.userslist[useritemindex]['ishide'] = 0
useritem = self.userslist[useritemindex]['user']
parent = useritem.parent()
findex = self.searchgroup(parent)
widget = self.treeWidget.itemWidget(useritem, 0)
widget.lblonlinestate.setPixmap(QPixmap("img/bullet_green.png"))
self.grouplist[findex]['childishide'] -= 1
fathergroupname = self.grouplist[findex]['groupname']
fathergroupname += ' ' + str(
self.grouplist[findex]['childcount'] -
self.grouplist[findex]['childhide']) + '/' + str(
self.grouplist[findex]['childcount'])
parent.setText(0, fathergroupname)
def dealBeAdded(self, widget):
reply = QMessageBox.question(
self, 'Friend add Prompt',
'%s(%s)Add you as a friend' % (widget.name, widget.id),
QMessageBox.Yes | QMessageBox.No, QMessageBox.Yes)
if reply == QMessageBox.No:
self.client.dealRefuseAdded(widget.id)
else:
info = ['my good friend', widget.name]
dialog = Add_Dialog(info)
for g in self.grouplist:
dialog.comboBox.addItem(g['groupname'])
dialog.exec_()
self.client.dealAcceptAdded(widget.id)
newitem = QTreeWidgetItem()
newitem.setSizeHint(0, QSize(self.treeWidget.width(), 55))
head = widget.data.split('\n'.encode('utf-8'), 1)[1]
buddy = Buddy(info[1], str(widget.id), head, 0)
userdic = {
'user': newitem,
'username': info[1],
'userid': widget.id,
'head': head,
'ishide': 0
}
cindex = self.searchgroup(info[0])
group = self.grouplist[cindex]['group']
self.grouplist[cindex]['childcount'] += 1
self.userslist.append(userdic)
group.addChild(newitem)
self.treeWidget.setItemWidget(newitem, 0, buddy)
self.treeWidget.setCurrentItem(newitem)
user = {'username': info[1], 'userid': widget.id, 'ishide': 0}
self.groupInfo[info[0]].append(user)
def dealFriendOffline(self, id):
useritemindex = self.searchuser(id)
if useritemindex is not None:
self.userslist[useritemindex]['ishide'] = 1
useritem = self.userslist[useritemindex]['user']
parent = useritem.parent()
findex = self.searchgroup(parent)
widget = self.treeWidget.itemWidget(useritem, 0)
widget.lblonlinestate.setPixmap(QPixmap('img/bullet-grey.png'))
self.grouplist[findex]['childishide'] += 1
fathergroupname = self.grouplist[findex]['groupname']
fathergroupname += ' ' + str(
self.grouplist[findex]['childcount'] -
self.grouplist[findex]['childhide']) + '/' + str(
self.grouplist[findex]['childcount'])
parent.setText(0, fathergroupname)
self.treeWidget.setCurrentItem(parent)
def on_bt_adduser_clicked(self):
des_id = [-1]
adduser = Dialog_additem(des_id, self.temp, self.userslist,
self.client.id)
for g in self.grouplist:
adduser.comboBox.addItem(g['groupname'])
if adduser.exec_() == 1:
data = self.client.name.encode('utf-8') + "\n".encode(
'utf-8') + self.client.head
protocol = Protocol(len(data), self.client.id, des_id[0],
Type.ADD_FRIEND)
header = protocol.make_packet_header()
self.client.sock.sendall(header + data)
def successAddFriend(self, friend, head):
newitem = QTreeWidgetItem()
newitem.setSizeHint(0, QSize(self.treeWidget.width(), 55))
friendName = friend['name']
friendId = friend['id']
ishide = friend['ishide']
buddy = Buddy(friendName, str(friendId), head, ishide)
userdic = {
'user': newitem,
'username': friendName,
'userid': friendId,
'head': head,
'ishide': ishide
}
for k, v in self.temp.items():
if k == friend['id']:
comboxinfo = self.temp.pop(k)
break
cindex = self.searchgroup(comboxinfo)
group = self.grouplist[cindex]['group']
groupname = self.grouplist[cindex]['groupname']
self.grouplist[cindex]['childcount'] += 1
self.userslist.append(userdic)
group.addChild(newitem)
self.treeWidget.setItemWidget(newitem, 0, buddy)
self.treeWidget.setCurrentItem(newitem)
user = {'username': friendName, 'userid': friendId, 'ishide': 0}
self.groupInfo[groupname].append(user)
def creategroup(self):
self.groupInfo = groupInfo = self.client.dealInitGroupInfo()
for groupname in groupInfo.keys():
hidernum = 0
group = QTreeWidgetItem(self.treeWidget)
groupdic = {
'group': group,
'groupname': groupname,
'childcount': 0,
'childhide': 0
}
icon = self.searchIcon(groupname)
group.setIcon(0, icon)
for friend in groupInfo[groupname]:
child = QTreeWidgetItem()
child.setSizeHint(0, QSize(self.treeWidget.width(), 55))
friendName = friend['username']
friendId = friend['userid']
ishide = friend['ishide']
head = self.client.dealGetHead(friendId)
buddy = Buddy(friendName, str(friendId), head, ishide)
userdic = {
'user': child,
'username': friendName,
'userid': friendId,
'head': head,
'ishide': ishide
}
self.userslist.append(userdic)
if friend['ishide'] == 1:
hidernum += 1
userdic['ishide'] = 1
group.addChild(child)
self.treeWidget.setItemWidget(child, 0, buddy)
childnum = group.childCount()
lastchildnum = childnum - hidernum
groupdic['childcount'] = childnum
groupdic['childishide'] = hidernum
groupname += ' ' + str(lastchildnum) + '/' + str(childnum)
group.setText(0, groupname)
group.setExpanded(True)
self.grouplist.append(groupdic)
def createusers(self, num):
randname = "黑子"
randicon = QIcon(str(num) + '.jpg')
font = QFont()
font.setPointSize(16)
isvip = random.randint(0, 5)
ishider = random.randint(0, 5)
if ishider == 1:
randicon = QIcon(str(num) + 'h.jpg')
return randname, randicon, font, isvip, ishider
def searchIcon(self, gpname2):
if gpname2.find('Friend') >= 0:
return QIcon('img/buddy.ico')
elif gpname2.find('同事'):
return QIcon('img/partner.ico')
elif gpname2.find('黑名单'):
return QIcon('img/blacklist.ico')
else:
return QIcon('img/defalut.ico')
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
self.m_drag = True
self.m_DragPosition = event.globalPos() - self.pos()
event.accept()
def mouseMoveEvent(self, QMouseEvent):
if QMouseEvent.buttons() and Qt.LeftButton:
self.move(QMouseEvent.globalPos() - self.m_DragPosition)
QMouseEvent.accept()
def mouseReleaseEvent(self, QMouseEvent):
self.m_drag = False
def onUsernameChoosed(self, name):
self.lineEdit.setText(name)
def on_lineEdit_textChanged(self, text):
namelist = []
for itm in self.userslist:
username = itm['username']
if username.find(text) >= 0:
namelist.append(itm['username'])
self.m_model.removeRows(0, self.m_model.rowCount())
for i in range(0, len(namelist)):
self.m_model.insertRow(0)
self.m_model.setData(self.m_model.index(0, 0), namelist[i])
def on_bt_search_clicked(self):
username = self.lineEdit.text()
if len(username) > 0:
useritemindex = self.searchuser(username)
if useritemindex is not None:
useritem = self.userslist[useritemindex]['user']
self.treeWidget.setCurrentItem(useritem)
else:
QMessageBox.information(self, 'Message',
'This friend does not exist!')
def closeEvent(self, event):
reply = QMessageBox.question(
self, 'Prompt', 'Are you sure you want to quit the program?',
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if reply == QMessageBox.No:
event.ignore()
else:
self.hide()
self.client.dealUpdate(self.groupInfo)
self.closeWindow()
time.sleep(3)
self.client.dealQuit()
time.sleep(1)
self.listener.terminate()
event.accept()
def msgCache(self):
self.cache.show()
def setUp(self):
setup = SetInfoDialog(self.client)
if setup.exec_() > 0:
self.lblName.setText(
self.client.name
) ################################################################################需要设置头像！！！！！！！
image = QImage()
image.loadFromData(self.client.head)
self.lblHead.setPixmap(QPixmap.fromImage(image))
self.client.dealSetHead()
self.client.dealSetName()
def delGroup(self):
hititem = self.groups.currentItem()
group = self.groups.itemWidget(hititem)
gid = int(group.id.text())
self.client.dealDeleteGroup(gid)
row = self.groups.row(hititem)
self.groups.takeItem(row)
def contextMenuEvent(self, event):
x = QCursor.pos().x()
y = QCursor.pos().y()
widget = QApplication.widgetAt(x, y)
if type(widget) == Group:
menu = QMenu(self)
pDeleteAct = QAction('Delete group', self.groups)
menu.addAction(pDeleteAct)
pDeleteAct.triggered.connect(self.delGroup)
menu.popup(self.mapToGlobal(event.pos()))
elif type(widget) == QWidget:
hititem = self.treeWidget.currentItem()
pgroupmenu = QMenu(self)
pAddgroupAct = QAction('Add group', self.treeWidget)
pRenameAct = QAction('Rename', self.treeWidget)
pDeleteAct = QAction('Delete group', self.treeWidget)
pgroupmenu.addAction(pAddgroupAct)
pgroupmenu.addAction(pRenameAct)
pgroupmenu.addAction(pDeleteAct)
pAddgroupAct.triggered.connect(self.addgroup)
pRenameAct.triggered.connect(self.renamegroup)
if self.treeWidget.itemAbove(hititem) is None:
pDeleteAct.setEnabled(False)
else:
pDeleteAct.setEnabled(True)
pDeleteAct.triggered.connect(self.deletegroup)
pgroupmenu.popup(self.mapToGlobal(event.pos()))
elif type(widget) == Buddy:
hititem = self.treeWidget.currentItem()
root = hititem.parent()
if root.childCount() > 0:
pItemmenu = QMenu(self)
pDeleteItemAct = QAction('Delete contact', pItemmenu)
pItemmenu.addAction(pDeleteItemAct)
pDeleteItemAct.triggered.connect(self.delete)
if len(self.grouplist) > 1:
pSubMenu = QMenu('Transfer contacts to', pItemmenu)
pItemmenu.addMenu(pSubMenu)
for item_dic in self.grouplist:
if item_dic['group'] is not root:
pMoveAct = QAction(item_dic['groupname'],
pItemmenu)
pSubMenu.addAction(pMoveAct)
pMoveAct.triggered.connect(self.moveItem)
if len(self.getListitems(self.menuflag)) == 1:
pRenameItemAct = QAction('Setting note', pItemmenu)
pItemmenu.addAction(pRenameItemAct)
pRenameItemAct.triggered.connect(self.renameItem)
if self.menuflag > 0 and root.childCount() > 1:
pBatchAct = QAction('Batch operation within a group',
pItemmenu)
pItemmenu.addAction(pBatchAct)
pBatchAct.triggered.connect(self.Batchoperation)
elif self.menuflag < 0:
pCancelBatchAct = QAction('Cancel batch operation',
pItemmenu)
pItemmenu.addAction(pCancelBatchAct)
pCancelBatchAct.triggered.connect(
self.CancelBatchoperation)
pItemmenu.popup(self.mapToGlobal(event.pos()))
def moveItem(self):
movelist = self.getListitems(self.menuflag)
togroupname = self.sender().text()
mindex = self.searchgroup(togroupname)
togroup = self.grouplist[mindex]['group']
self.deleteItems(movelist, flag=0)
self.add(togroup, movelist)
self.tmpuseritem.clear()
def delete(self):
delitems = self.getListitems(self.menuflag)
self.deleteItems(delitems)
self.tmpuseritem.clear()
def deleteItems(self, items, flag=1):
for delitem in items:
delitem.setData(0, Qt.CheckStateRole, QVariant())
pindex = delitem.parent().indexOfChild(delitem)
dindex = self.searchuser(delitem)
ishide = self.userslist[dindex]['ishide']
id = self.userslist[dindex]['userid']
if flag == 1:
self.client.dealDelFriend(id)
del self.userslist[dindex]
fathergroup = delitem.parent()
findex = self.searchgroup(fathergroup)
parentName = self.grouplist[findex]['groupname']
for user in self.groupInfo[parentName]:
if user['userid'] == id:
self.groupInfo[parentName].remove(user)
break
fathergroup = delitem.parent()
findex = self.searchgroup(fathergroup)
if ishide == 1:
self.grouplist[findex]['childishide'] -= 1
self.grouplist[findex]['childcount'] -= 1
else:
self.grouplist[findex]['childcount'] -= 1
delitem.parent().takeChild(pindex)
def add(self, group, items):
gindex = self.searchgroup(group)
gname = self.grouplist[gindex]['groupname']
for item in items:
aindex = self.searchuser(item)
ishide = self.userslist[aindex]['ishide']
userid = self.userslist[aindex]['userid']
username = self.userslist[aindex]['username']
head = self.userslist[aindex]['head']
if ishide == 1:
self.grouplist[gindex]['childishide'] += 1
self.grouplist[gindex]['childcount'] += 1
else:
self.grouplist[gindex]['childcount'] += 1
buddy = Buddy(username, str(userid), head, ishide)
group.addChild(item)
self.treeWidget.setItemWidget(item, 0, buddy)
self.treeWidget.itemWidget(item, 0).show()
self.treeWidget.setCurrentItem(item)
user = {'username': username, 'userid': userid, 'ishide': 0}
self.groupInfo[gname].append(user)
def Batchoperation(self):
self.menuflag *= -1
group = self.getListitems()[0].parent()
childnum = group.childCount()
for c in range(childnum):
child = group.child(c)
child.setCheckState(0, Qt.Unchecked)
def CancelBatchoperation(self):
self.menuflag *= -1
group = self.getListitems()[0].parent()
childnum = group.childCount()
for c in range(childnum):
child = group.child(c)
child.setData(0, Qt.CheckStateRole, QVariant())
def isclick(self, item):
if item.checkState(0) == Qt.Checked:
if self.tmpuseritem.count(item) == 0:
self.tmpuseritem.append(item)
else:
if len(self.tmpuseritem) > 0:
if self.tmpuseritem.count(item) != 0:
i = self.tmpuseritem.index(item)
del self.tmpuseritem[i]
def renameItem(self):
hituser = self.treeWidget.currentItem()
widget = self.treeWidget.itemWidget(hituser, 0)
uindex = self.searchuser(hituser)
unewname, ok = QInputDialog.getText(self, 'Prompt Information',
'Please enter a note name')
if ok:
if len(unewname) == 0:
QMessageBox.information(self, 'Prompt',
'Note name cannot be empty')
else:
widget.name.setText(unewname)
self.userslist[uindex]['username'] = unewname
id = self.userslist[uindex]['userid']
parent = hituser.parent()
parentIndex = self.searchgroup(parent)
parentName = self.grouplist[parentIndex]['groupname']
for user in self.groupInfo[parentName]:
if user['userid'] == id:
user['username'] = unewname
def searchuser(self, hituser):
if isinstance(hituser, str):
if hituser.isdigit():
for i, u in enumerate(self.userslist):
if str(u['userid']) == hituser:
return i
else:
for i, u in enumerate(self.userslist):
if u['username'] == hituser:
return i
elif isinstance(hituser, int):
for i, u in enumerate(self.userslist):
if u['userid'] == hituser:
return i
else:
for i, u in enumerate(self.userslist):
if hituser == u['user']:
return i
return None
def getListitems(self, flag=1):
if flag > 0:
return self.treeWidget.selectedItems()
else:
return self.tmpuseritem
def addgroup(self):
gname, ok = QInputDialog.getText(self, 'Prompt Information',
'Please enter a group name')
if ok:
if len(gname) == 0:
QMessageBox.information(self, 'Prompt',
'Group name cannot be empty')
else:
hidernum = 0
group = QTreeWidgetItem(self.treeWidget)
groupdic = {
'group': group,
'groupname': gname,
'childcount': 0,
'childhide': 0
}
#sself.groupInfo[gname] = ''
icon = self.searchIcon(gname)
group.setIcon(0, icon)
childnum = group.childCount()
lastchildnum = childnum - hidernum
groupdic['childcount'] = childnum
groupdic['childishide'] = hidernum
self.groupInfo[gname] = []
gname += ' ' + str(lastchildnum) + '/' + str(childnum)
group.setText(0, gname)
self.grouplist.append(groupdic)
def renamegroup(self):
hitgroup = self.treeWidget.currentItem()
gnewname, ok = QInputDialog.getText(self, 'Prompt',
'Please enter a new group name')
if ok:
if len(gnewname) == 0:
QMessageBox.information(self, 'Prompt',
'Group name cannot be empty')
else:
hitgroup.setText(0, gnewname)
newicon = self.searchIcon(hitgroup.text(0))
hitgroup.setIcon(0, newicon)
gindex = self.searchgroup(hitgroup)
oldname = self.grouplist[gindex]['groupname']
self.grouplist[gindex]['groupname'] = gnewname
self.treeWidget.setCurrentItem(hitgroup.child(0))
self.groupInfo[gnewname] = self.groupInfo.pop(oldname)
def deletegroup(self):
hitgroup = self.treeWidget.currentItem()
gindex = self.searchgroup(hitgroup)
reply = QMessageBox.question(
self, 'Warning', 'Are you sure you want to delete this group?',
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if reply == QMessageBox.Yes:
self.treeWidget.takeTopLevelItem(gindex)
groupname = self.grouplist[gindex]['groupname']
del self.grouplist[gindex]
del self.groupInfo[groupname]
def searchgroup(self, hitgroup):
if isinstance(hitgroup, str):
for i, g in enumerate(self.grouplist):
if g['groupname'] == hitgroup:
return i
else:
for i, g in enumerate(self.grouplist):
if g['group'] == hitgroup:
return i
def restatistic(self, item, preitem):
if item:
fathergroup = item.parent()
if fathergroup:
self.restatistic_op(fathergroup)
else:
self.restatistic_op(item)
elif preitem.parent().childCount() == 1:
lastgroupname = preitem.parent().text(0).split()[0] + ' 0/0'
preitem.parent().setText(0, lastgroupname)
self.menuflag = 1
def restatistic_op(self, itemorgroup):
gindex = self.searchgroup(itemorgroup)
totalcount = self.grouplist[gindex]['childcount']
hidecount = self.grouplist[gindex]['childishide']
fathergroupname = self.grouplist[gindex]['groupname']
fathergroupname += ' ' + str(totalcount -
hidecount) + '/' + str(totalcount)
itemorgroup.setText(0, fathergroupname)
