client serveur réseau

code serveur :

#-*-coding: utf8-*

import  platform  as p
import  socket
import  select
import  re
import  os

os.system("color 0f")
print(" " * 21 + "***** Serveur Elranet, bienvenue. *****\n\n\n" + " " * 21)
try:
	hote = socket.gethostbyname(socket.gethostname())
except NameError as nom_err:
	print(nom_err)
except TypeError as type_err:
	print(type_err)
print(" " * 21 + "Écoute sur le serveur {0}.\n".format(hote))
while 1:
	sport = input(" " * 21 + "Entrez le port [50000] > ")
	print("\n")
	if sport.strip() == "":
		sport = 50000
		break
	try:
		sport = sport.strip()
		int(sport)
		break
	except ValueError:
		print("Dis Toto, t'as pas compris ? Il me faut un chiffre !\n")
	
print("_" * 80 + "|/-\\" * (81 // 4) + "|   " * (81 // 4))

port = int(sport)
connexion_principale = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
connexion_principale.bind((hote, port))
connexion_principale.listen(5)
#keepalive : option pour savoir qui est en ligne
print("Le serveur écoute à présent sur le port {0} depuis {1}.\n".format(port, hote))
#afficher = lambda cle, valeur: print("{k} :: {v}".format(k=cle, v=valeur))
#systeme            = p.system()
#python             = p.python_version()
#jeu, formatFichier = p.architecture()
#distribution       = p.version()
#afficher("Système      Opérant    ", systeme)
#afficher("Architecture Processeur ", jeu)
#afficher("Version      Système    ", distribution)
#afficher("Version      Python     ", python)

print("")

serveur_lance = True
clients_connectes = []
ok_a_encoder = ""

try:
	id_co, id_co_int, recherche_id = 0, 0, 0
	id_clients = {}
except NameError as nom_err:
	print(nom_err)
	input()
except TypeError as type_err:
	print(type_err)
	input()

while serveur_lance:
	# On va vérifier que de nouveaux clients ne demandent pas à se connecter
	# Pour cela, on écoute la connexion_principale en lecture
	# On attend maximum 50ms
	connexions_demandees, wlist, xlist = select.select([connexion_principale], [], [], 0.05)
	
	for connexion in connexions_demandees:
		connexion_avec_client, infos_connexion = connexion.accept()
		try:
			id_co += 1
			id_co_int = int(id_co)
			connexion_avec_client.send("id_{0}".format(id_co).encode())
			
			# On ajoute le socket connecté à la liste des clients
			clients_connectes.append(connexion_avec_client)
			id_clients[id_co_int] = connexion_avec_client
			
			client_en_cours = id_clients[id_co_int]

			#os_client           = client_en_cours.recv(1024).decode()
			#architecture_client = client_en_cours.recv(1024).decode()
			#v_client            = client_en_cours.recv(1024).decode()
			#python_client       = client_en_cours.recv(1024).decode()
			#print("{0} sous {1} {2} v{3} avec python {4}, id:{5}\nest maintenant connecté à Elranet."
			.format(infos_connexion, os_client, architecture_client, v_client, python_client, id_co))
		except NameError as nom_err:
			print(nom_err)
			input()
		except TypeError as type_err:
			print(type_err)
			input()

	# Maintenant, on écoute la liste des clients connectés
	# Les clients renvoyés par select sont ceux devant être lus (recv)
	# On attend là encore 50ms maximum
	# On enferme l'appel à select.select dans un bloc try
	# En effet, si la liste de clients connectés est vide, une exception
	# Peut être levée
	clients_a_lire = []
	try:
		clients_a_lire, wlist, xlist = select.select(clients_connectes, [], [], 0.05)
	except select.error:
		pass

	finally:
		# On parcourt la liste des clients à lire
		for client in clients_a_lire:
			# Client est de type socket
			msg_recu = ""
			msg_recu = client.recv(1024)
			# Peut planter si le message contient des caractères spéciaux
			msg_recu = msg_recu.decode()
			msg_recu = "{0} a envoyé : {1}".format(infos_connexion, msg_recu)
			print("\n{0}".format(msg_recu))
			ok = "5 / 5"
			ok_a_encoder = ok.encode()
			client.send(ok_a_encoder)
			if re.search(r'ren$', msg_recu) is None:
				for client in clients_connectes:
					client.send(msg_recu.encode())
				ok_a_encoder = ""
			elif re.search(r'ren$', msg_recu) is not None:
				last_name = re.sub(r'(.+)(\nren)', r'\1', msg_recu)
				while recherche_id != id_co_int:
					recherche_id += 1
				if recherche_id == id_co_int:
					envoie_id = id_clients[recherche_id]
				print("{0} a demandé à être renommé en {1}."
				.format(envoie_id, last_name))
				for client in clients_connectes:
					client.send("{0} a demandé à être renommé en {1}."
					.format(envoie_id, last_name).encode())
				ok_a_encoder = ""
				id_co = str(id_co)
				id_co = last_name
				id_client[recherche_id] = last_name
			elif re.search(r'id', msg_recu) is not None:
				while recherche_id != id_co_int:
					recherche_id += 1
				if recherche_id == id_co_int:
					envoie_id = id_clients[recherche_id]
					envoie_id.send("Identifiant utilisateur : {0}, {1}."
					.format(id_co_int, infos_connexion).encode())
			if msg_recu == "fin":
				serveur_lance = False
			msg_recu = ""

print("Fermeture des connexions. Appuyer sur une touche pour continuer . . .")
wait = input()
for client in clients_connectes:
	client.close()
connexion_principale.close()

code client:

#-*-coding: utf8-*

from    threading import Thread
import  platform  as p
import  socket
import  time
import  sys
import  re
import  os

os.system("color 0f")

id_co_individuel = 0
msg_a_envoyer = ""
ligne_a_ajouter = ""
msg_a_encoder = ""

def async_recv(client_socket):
	while 1:
		msg_recu = client_socket.recv(1024)
		if msg_recu == b"":
			client_socket.close()
			print("Le serveur est arrêté.\n")
			break
		if msg_recu != msg_a_encoder:
			msg_recu = msg_recu.decode()
			if re.search(r'^id_', msg_recu) is None:
				print("\n>>>{0}".format(msg_recu))
			else:
				id_co_individuel = int(re.sub(r'(id_)', r'', msg_recu))
		elif msg_a_encoder == msg_recu:
			msg_recu = msg_recu.decode()
			print("\n>>>Envoyé : {0}".format(msg_recu))

def envoie(msg_a_envoyer):
	msg_a_encoder = str(msg_a_envoyer)
	msg_a_encoder = msg_a_encoder.encode()   #Luc: pas la bonne variable (c'était msg_a_envoyer)
	print(". . .")
	connexion_avec_serveur.send(msg_a_encoder)
	msg_a_encoder   = ""
	#msg_a_envoyer   = "" #Luc: cette variable est locale à la fonction ! elle est passée en copie, donc ce n'est pas la même que la variable
		#qui est passée en argument ! La confusion vient que tu as utilisé le même nom !
	#on envoie le message
	#print("")  #Luc: une fonction doit faire seulement ce qu'elle doit faire, ici c'est send donc elle a pas à faire de print sur l'écran

print(" " * 20 + "****** Client Elranet, bienvenue. ******\n\n\n" + " " * 20)
defhote = "127.0.0.1"
try:
	defhote = socket.gethostbyname(socket.gethostname())
except NameError as nom_err:
	print(nom_err)
except TypeError as type_err:
	print(type_err)
hote = input(" " * 21 + "Entrez le nom de l'hôte [{0}]> ".format(defhote))
if hote.strip() == "":
	hote = defhote
while 1:
	sport = input(" " * 21 + "Entrez le port [50000] > ")
	print("\n")
	if sport.strip() == "":
		sport = 50000
		break
	try:
		sport = sport.strip()
		int(sport)
		break
	except ValueError:
		print("Dis Toto, t'as pas compris ? Il me faut un chiffre !\n")
port = int(sport)
print("\n")
print("_" * 80 + "|/-\\" * (81 // 4) + "|   " * (81 // 4))

#afficher = lambda cle, valeur: print("{k} :: {v}".format(k=cle, v=valeur))
#systeme = p.system()
#python = p.python_version()
#jeu, formatFichier = p.architecture()
#distribution = p.version()
#afficher("Système      Opérant    ", systeme)
#afficher("Architecture Processeur ", jeu)
#afficher("Version      Système    ", distribution)
#afficher("Version      Python     ", python)
print("")

connexion_avec_serveur = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print("Connection sur le serveur {0} au port {1} . . .\n".format(hote, port))
connexion_avec_serveur.connect((hote, port))

#envoie(systeme)
#envoie(jeu)
#envoie(distribution)
#envoie(python)

# faire la réception du socket dans un autre thread
thread =  Thread(target=async_recv, args = (connexion_avec_serveur,))
thread.start()

print("Connexion établie avec le serveur sur le port {}.".format(port))

while msg_a_envoyer.lower() != "fin":
	try:
		#partie du code où on va écrire un message pour le client
		while 1:
			ligne_a_ajouter = input("> ")
			if ligne_a_ajouter == "send": #la commande 'fin' demande l'arrêt du serveur 
				break
			elif ligne_a_ajouter.lower() == "fin":
				#on arrete tout :
				break
			elif ligne_a_ajouter == "ren":
				msg_a_envoyer += "\n"
				msg_a_envoyer += ligne_a_ajouter
				ligne_a_ajouter = ""
				envoie(msg_a_envoyer)
				msg_a_envoyer = "" #Luc
			elif ligne_a_ajouter == "id":
				msg_a_envoyer += "\n"
				msg_a_envoyer += ligne_a_ajouter
				ligne_a_ajouter = ""
				envoie(msg_a_envoyer)
				msg_a_envoyer = "" #Luc
			else:
				msg_a_envoyer += "\n"
				msg_a_envoyer += ligne_a_ajouter
				ligne_a_ajouter = ""

		if msg_a_envoyer != "" and ligne_a_ajouter.lower() != "fin" and ligne_a_ajouter != "ren":
			#on envoie
			envoie(msg_a_envoyer)
			msg_a_envoyer = "" #Luc
		#--------------------------------------------------------
		elif ligne_a_ajouter.lower() == "fin":
			msg_a_envoyer = "fin"
			msg_a_encoder = msg_a_envoyer.encode()
			connexion_avec_serveur.send(msg_a_encoder)
			break
		#--------------------------------------------------------
	except NameError as nom_erreur:
		print(nom_erreur)

	except TypeError as type_err:
		print(type_err)

	except EnvironmentError as env_err:
		print(env_err)


thread.stop()
print("Fermeture de la connexion. Appuyer sur une touche pour continuer . . .")
wait = input()
connexion_avec_serveur.close()

Qu'en pensez vous ?

-
Edité par Anonyme 27 août 2014 à 14:31:22

client serveur réseau

Supprimer

Modérer

Signaler le message aux modérateurs