def server_client_connected(client_reader, client_writer):
nonlocal test_msg, test_msg_received
client = Client(reader=client_reader, writer=client_writer)
async def server_client_disconnected():
print("< [{}] client disconnected".format(client.id))
async def server_msg_callback(msg: ProtocolMessage):
nonlocal client, test_msg
if not msg == test_msg:
print(
"\nFailure for the following two messages (sent/received):"
)
print("\t> {}".format(test_msg))
print("\t< {}".format(msg))
else:
#print("Success for the following message:")
#print("\t {}".format(msg))
pass
test_msg_received.set()
#print("< [{}] {}".format(client.id, msg))
print("< [{}] client connected".format(client.id))
return server_msg_callback, server_client_disconnected
def send_mail(self):
eml_type = self.in_eml_type.text()
eml_file = self.in_eml_template.text()
user_group = self.in_recipient_group.text()
mail_excel = self.in_recipient_excel.text()
annex_file = self.in_annex_file.text()
url = self.data_db[5] if self.data_db else 'http://yumail.myvnc.com'
try:
if self.cb_scheduler.isChecked():
my_time = self.in_scheduler.text()+':00'
client = Client()
client.send(self.data_smtp[:4], self.data_db[:5], eml_type, eml_file, user_group, mail_excel, annex_file, url, my_time)
QMessageBox.information(self, 'Success!', '排程設定成功!', QMessageBox.Ok)
else:
sm = Smtp(self.data_smtp[0], int(self.data_smtp[1]), self.data_smtp[2], self.data_smtp[3]) if self.data_smtp else Smtp()
db = Database(self.data_db[0], int(self.data_db[1]), self.data_db[2], self.data_db[3], self.data_db[4]) if self.data_db else Database()
insert_send_mail(eml_type, eml_file, user_group, mail_excel, sm, db, annex=annex_file, url=url)
sm.close()
db.__disconnect__()
QMessageBox.information(self, 'Success!', '信件寄出成功!', QMessageBox.Ok)
except:
QMessageBox.warning(self, 'Failed!', '信件寄出失敗!', QMessageBox.Ok)
def send_mail(self):
smtp_host = self.smtp_host.text() if self.smtp_host.text(
) else 'localhost'
smtp_port = self.smtp_port.text() if self.smtp_port.text() else 465
smtp_user = self.smtp_user.text() if self.smtp_user.text(
) else '*****@*****.**'
smtp_pw = self.smtp_pw.text() if self.smtp_pw.text() else 'yucc1234'
db_host = self.db_host.text() if self.db_host.text() else 'localhost'
db_port = self.db_port.text() if self.db_port.text() else 3306
db_user = self.db_user.text() if self.db_user.text() else 'socialmails'
db_pw = self.db_pw.text() if self.db_pw.text() else 'socialmails123'
db_db = self.db_db.text() if self.db_db.text() else 'socialmails'
eml_file = self.eml.text()
eml_type = self.eml_type.text()
mails_excel = self.mails.text()
mails_group = self.mails_group.text()
if self.add_cb.isChecked():
my_time = self.datetime_edit.text() + ':00'
client = Client()
client.send(eml_type, eml_file, mails_group, mails_excel, my_time)
else:
db = Database(db_host, db_port, db_user, db_pw, db_db)
sm = Smtp(smtp_host, smtp_port, smtp_user, smtp_pw)
insert_send_mail(eml_type, eml_file, mails_group, mails_excel, sm,
db)
def test_prologue(self):
from server.client import Client
cli = Client()
cli.do_conn('localhost:' + PORT)
while not cli.ping():
time.sleep(1)
cli.do_select('sophia')
ret, response = cli.ask('what is your name')
ans = response.get('text')
names = ['Soepheeyeh', 'Sophia']
self.assertTrue(any([name in ans for name in names]))
def client_connected(self, socket, address):
"""
:param socket:
:type socket:gevent._socket3.socket
:param address:
:type address: tuple
:return:
"""
# Client is now connected, and this is already a GreenLet
socket.sendall('Welcome to SimpleMQ \n'.encode())
# And now create a client and listen the data
client = Client(socket, address, self.queue_manager, self.event_dispatcher)
client.listen()
def main(address, port):
cliSock = socket.socket()
cliSock.settimeout(1)
connected = False
while not connected:
try:
cliSock.connect((address, port))
print("Now connected to game server at {} port {}".format(
address, port))
connected = True
except socket.timeout:
print("Could not connect to server. Please enter address again")
address = input()
client = Client(cliSock)
def printToScreen():
while True:
try:
readData = client.read()
except socket.error:
break
if readData != "":
print(readData)
readThread = threading.Thread(target=printToScreen,
name="Read Thread",
daemon=True)
readThread.start()
while True:
writeData = input()
if writeData in ["quit", "exit", "logout"]:
print("Thanks for playing!")
break
elif writeData in ['reconnect']:
client.close()
print('Reconnecting')
main(address, port)
return
elif writeData in ['restart']:
client.close()
print('Restarting')
run()
return
else:
client.write(writeData)
client.close()
print("Disconnected from server {}".format(address))
def create_client(self, client_id, account, household_id):
new_client = Client(client_id, account, household_id)
self.add(new_client)
return new_client
def p_client(p):
'''
create : CLIENT LB ID SEMICOLON IP SEMICOLON NUMBER RB
'''
client = Client(p[3], p[5], p[7])
client.send_mode()
if args.name == None:
print("No name provided.")
sys.exit(0)
if args.server == None:
print("No report server provided. Using 10.0.0.1.")
args.server = "10.0.0.1"
args.port = 8080
name = args.name
server = args.server
port = args.port
command = args.command
# Client used for server communication
print(server, port)
client = Client(server, port)
client.post("/start", {"done": name})
command_with_flags = " ".join(command + list(command_flags))
command_with_flags = "{} > {}".format(command_with_flags, name)
print("Running {}".format(command_with_flags))
# Run the command
exit = os.system(command_with_flags) >> 8
# Send the response back to the main server
if exit == 0:
print("Job done: {}".format(name))
client.post("/done", {"done": name})
else:
print("Job failed: {}".format(name))
def main():
def send_to_all(msg, sender):
for client_ in client_list:
if client_ != server_client:
try:
client_.send_message(msg, sender)
except ConnectionError:
client_list.remove(client_)
print(f"User {client_.get_username()}"
f" forced disconnection")
def send_user_list_to_all():
for client_ in client_list:
if client_ != server_client:
try:
client_.send_user_list(
[client__.get_username() for client__ in client_list])
except ConnectionError:
client_list.remove(client_)
print(f"User {client_.get_username()}"
f" forced disconnection")
# Create a Client object that is the server
# AF_INET = IPv4
# SOCK_STREAM = TCP
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Set the socket to reuse addresses
# SOL_SOCKET = Socket Option Level
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# Bind socket to server's own ip
server_socket.bind((ip, port))
# Listen for new connections
server_socket.listen()
# Create Client object
server_client = Client(server_socket,
ip,
headerlen,
username="******",
encoding="utf-8",
server=True)
server_client.set_username("server")
# Create a list used to keep track of all connected clients
client_list = [server_client]
# Continuously receive and forward messages
while True:
# Get clients whose sockets are ready for reading
read_clients = [
client for client in client_list if client.get_socket() in
select.select([client_.get_socket()
for client_ in client_list], [], [], 0)[0]
]
# Get clients whose sockets caused an exception
exception_clients = \
[client for client in client_list
if client.get_socket() in
select.select([], [], [client_.get_socket()
for client_ in client_list], 0)[2]]
# Clients whose sockets were notified
for client in read_clients:
# Notified client was the server
# meaning a new user is trying to join
if client == server_client:
# Accept the connection and add user to the list of users
new_user_socket, new_user_address \
= server_client.server_accept_connection()
new_client = Client(new_user_socket, new_user_address,
headerlen)
if not new_client.get_username():
continue
client_list.append(new_client)
print(f"User {new_client.get_username()} joined from"
f"{new_client.get_ip()}")
new_client.send_message(join_message, "server")
# Send user joined message to all clients
send_to_all(f"User {new_client.get_username()} joined",
"server")
send_user_list_to_all()
# notified client was another client
# meaning a client sent a new message
else:
message = client.receive_message()
if not message:
print(f"User {client.get_username()} disconnected.")
name = client.get_username()
client_list.remove(client)
send_to_all(f"User {name} disconnected.", "server")
send_user_list_to_all()
continue
elif message and client.connect_init_finished():
send_to_all(message, client.get_username())
print(f"{client.get_username()} > {message}")
# Kill connections that caused exceptions:
for client in exception_clients:
print(f"{client.get_username()} was in exception clients list"
f" and was removed")
client_list.remove(client)
def __init__(self, username=None):
super(ClientObject, self).__init__()
self._client = Client()
self.username = username if username else choice(member_names)
self.band_members = []
self.client.register_tether_callback(self.on_action)
async def connect(sid, environ):
c = Client(sid)
ClientManager().add_client(c)
await sio.emit("welcome", {"uid": c.uid}, room=sid)
logging.info("{} connected".format(c.uid))