Cara Baru Membuat Chat Room Multi Client Dengan Python

Artikel ini menunjukkan - Cara mengatur server Chat Room sederhana dan memungkinkan banyak Client untuk terhubung menggunakan skrip sisi Client. Kode menggunakan konsep soket dan threading.

Pemrograman soket

Soket dapat dianggap sebagai titik akhir dalam saluran komunikasi yang bersifat dua arah, dan membangun komunikasi antara server dan satu atau lebih klien. Di sini, kami menyiapkan soket di setiap ujung dan memungkinkan klien untuk berinteraksi dengan klien lain melalui server. Soket di sisi server mengasosiasikan dirinya dengan beberapa port perangkat keras di sisi server. Setiap klien yang memiliki soket yang terkait dengan port yang sama dapat berkomunikasi dengan soket server.

Multi-Threading

Utas adalah sub proses yang menjalankan serangkaian perintah secara terpisah dari utas lainnya. Jadi, setiap kali pengguna terhubung ke server, utas terpisah dibuat untuk pengguna itu dan komunikasi dari server ke klien berlangsung di sepanjang utas individu berdasarkan objek soket yang dibuat demi identitas masing-masing klien. 

Kami akan membutuhkan dua skrip untuk membuat ruang obrolan ini. Satu untuk menjaga penayangan tetap berjalan, dan lainnya yang harus dijalankan setiap klien untuk terhubung ke server.

• 
  

Skrip Sisi Server

Skrip sisi server akan berusaha membuat soket dan mengikatnya ke alamat IP dan port yang ditentukan oleh pengguna (pengguna windows mungkin harus membuat pengecualian untuk nomor port yang ditentukan dalam pengaturan firewall mereka, atau lebih baik dapat menggunakan port yang sudah terbuka). Skrip kemudian akan tetap terbuka dan menerima permintaan koneksi, dan akan menambahkan objek soket masing-masing ke daftar untuk melacak koneksi aktif. Setiap kali pengguna terhubung, 

utas terpisah akan dibuat untuk pengguna itu. Di setiap utas, server menunggu pesan, dan mengirim pesan itu ke pengguna lain yang sedang mengobrol. Jika server menemukan kesalahan saat mencoba menerima pesan dari utas tertentu, itu akan keluar dari utas itu.

Pemakaian

Server ini dapat diatur pada jaringan area lokal dengan memilih sembarang komputer untuk menjadi node server, dan menggunakan alamat IP pribadi komputer tersebut sebagai alamat IP server. 

Misalnya, jika jaringan area lokal memiliki satu set alamat IP pribadi yang ditetapkan mulai dari 192.168.1.2 hingga 192.168.1.100, maka komputer apa pun dari 99 node ini dapat bertindak sebagai server, dan node yang tersisa dapat terhubung ke node server dengan menggunakan alamat IP pribadi server. Harus diperhatikan untuk memilih port yang saat ini tidak digunakan. Sebagai contoh, port 22 adalah default untuk ssh, dan port 80 adalah default untuk protokol HTTP. Jadi kedua port ini sebaiknya, tidak boleh digunakan atau dikonfigurasi ulang untuk membuatnya bebas untuk digunakan.

Namun, jika server dimaksudkan untuk dapat diakses di luar jaringan lokal, alamat IP publik akan diperlukan untuk penggunaan. Ini akan memerlukan port forwarding dalam kasus di mana sebuah node dari jaringan lokal (node ​​yang bukan router) ingin meng-host server. Dalam hal ini, saya akan meminta semua permintaan yang datang ke alamat IP publik untuk dialihkan ke alamat IP pribadi saya di jaringan lokal saya, dan karenanya akan memerlukan penerusan port. 

/ * Baik skrip server dan klien kemudian dapat dijalankan 
   dari Command prompt (di Windows) atau dari bash 
   Terminal (pengguna Linux) hanya dengan mengetik 
   "python chat_server.py" atau "python client.py". 
   Sebagai contoh, * / 
python chat_server.py 192.168.55.13 8081 
python client.py 192.168.55.13 8081

Di bawah ini adalah skrip sisi Server yang harus dijalankan setiap saat akan menjalankan Chat Room tetap berjalan.

# Python program to implement server side of chat room. 
import socket 
import select 
import sys 
from thread import *

"""The first argument AF_INET is the address domain of the 
socket. This is used when we have an Internet Domain with 
any two hosts The second argument is the type of socket. 
SOCK_STREAM means that data or characters are read in 
a continuous flow."""
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) 

# checks whether sufficient arguments have been provided 
if len(sys.argv) != 3: 
print "Correct usage: script, IP address, port number"
exit() 

# takes the first argument from command prompt as IP address 
IP_address = str(sys.argv[1]) 

# takes second argument from command prompt as port number 
Port = int(sys.argv[2]) 

""" 
binds the server to an entered IP address and at the 
specified port number. 
The client must be aware of these parameters 
"""
server.bind((IP_address, Port)) 

""" 
listens for 100 active connections. This number can be 
increased as per convenience. 
"""
server.listen(100) 

list_of_clients = [] 

def clientthread(conn, addr): 

# sends a message to the client whose user object is conn 
conn.send("Welcome to this chatroom!") 

while True: 
try: 
message = conn.recv(2048) 
if message: 

"""prints the message and address of the 
user who just sent the message on the server 
terminal"""
print "<" + addr[0] + "> " + message 

# Calls broadcast function to send message to all 
message_to_send = "<" + addr[0] + "> " + message 
broadcast(message_to_send, conn) 

else: 
"""message may have no content if the connection 
is broken, in this case we remove the connection"""
remove(conn) 

except: 
continue

"""Using the below function, we broadcast the message to all 
clients who's object is not the same as the one sending 
the message """
def broadcast(message, connection): 
for clients in list_of_clients: 
if clients!=connection: 
try: 
clients.send(message) 
except: 
clients.close() 

# if the link is broken, we remove the client 
remove(clients) 

"""The following function simply removes the object 
from the list that was created at the beginning of 
the program"""
def remove(connection): 
if connection in list_of_clients: 
list_of_clients.remove(connection) 

while True: 

"""Accepts a connection request and stores two parameters, 
conn which is a socket object for that user, and addr 
which contains the IP address of the client that just 
connected"""
conn, addr = server.accept() 

"""Maintains a list of clients for ease of broadcasting 
a message to all available people in the chatroom"""
list_of_clients.append(conn) 

# prints the address of the user that just connected 
print addr[0] + " connected"

# creates and individual thread for every user 
# that connects 
start_new_thread(clientthread,(conn,addr))  

conn.close() 

server.close() 

Skrip Sisi Klien

Skrip sisi klien hanya akan mencoba mengakses soket server yang dibuat pada alamat dan port IP yang ditentukan. Setelah terhubung, ia akan terus memeriksa apakah input berasal dari server atau dari klien, dan karenanya mengarahkan kembali output. Jika input dari server, ini menampilkan pesan di terminal. Jika input dari pengguna, ia mengirimkan pesan bahwa pengguna masuk ke server untuk disiarkan ke pengguna lain.

Ini adalah skrip sisi klien, yang harus digunakan setiap pengguna untuk terhubung ke server.

# Python program to implement client side of chat room. 

import socket 

import select 

import sys 

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 

if len(sys.argv) != 3: 

print "Correct usage: script, IP address, port number"

exit() 

IP_address = str(sys.argv[1]) 

Port = int(sys.argv[2]) 

server.connect((IP_address, Port)) 

while True: 

# maintains a list of possible input streams 

sockets_list = [sys.stdin, server] 

""" There are two possible input situations. Either the 

user wants to give manual input to send to other people, 

or the server is sending a message to be printed on the 

screen. Select returns from sockets_list, the stream that 

is reader for input. So for example, if the server wants 

to send a message, then the if condition will hold true 

below.If the user wants to send a message, the else 

condition will evaluate as true"""

read_sockets,write_socket, error_socket = select.select(sockets_list,[],[]) 

for socks in read_sockets: 

if socks == server: 

message = socks.recv(2048) 

print message 

else: 

message = sys.stdin.readline() 

server.send(message) 

sys.stdout.write("<You>") 

sys.stdout.write(message) 

sys.stdout.flush() 

server.close() 

Output: Pada gambar yang diberikan di bawah ini, server telah diinisialisasi di sisi kiri terminal dan skrip klien di sisi kanan terminal. (Pemisahan terminal dilakukan dengan menggunakan tmux, 'sudo apt-get install tmux'). Untuk keperluan inisialisasi, Anda dapat melihat bahwa setiap kali pesan dikirim oleh pengguna, pesan bersama dengan alamat IP ditampilkan di sisi server.

Gambar di bawah ini memiliki percakapan dasar antara dua orang di server yang sama. Banyak klien dapat terhubung ke server dengan cara yang sama!

Sekian Tutorial dari saya...

Silakan tulis komentar jika Anda menemukan sesuatu yang salah, atau Anda ingin berbagi informasi lebih lanjut tentang topik yang dibahas di atas.

Bagikan Artikel ini