Python TCP 패킷 뭉침 현상 해결 및 FTP 파일 송수신

TCP 스트리밍 통신에서 발생하는 패킷 뭉침(Nagle's Algorithm) 현상은 데이터를 받는 측에서 데이터의 경계를 명확히 구분하기 어려워 발생하는 문제입니다. 이로 인해 하나의 완전한 메시지 단위로 데이터를 추출하지 못하게 됩니다. UDP는 메시지 경계가 명확하여 이러한 문제가 발생하지 않습니다.

패킷 뭉침 현상 발생 시나리오

  • 데이터를 주고받은 후 즉시 연결을 종료하는 경우: 패킷 뭉침 문제가 발생하지 않습니다.
  • 파일 전송과 같이 데이터 구조가 명확하지 않은 경우: 송신 측은 데이터를 계속 보내고 수신 측은 저장만 하므로 패킷 뭉침을 고려할 필요가 없습니다.
  • 연결 후 일정 시간 동안 여러 구조의 데이터를 주고받는 경우: 패킷 뭉침이 발생할 수 있습니다.

패킷 뭉침 현상 원인

TCP 스트리밍 전송에서 패킷 뭉침은 송신 측과 수신 측 모두의 버퍼 관리 방식에 의해 발생할 수 있습니다.

  1. 송신 측: 버퍼가 가득 찰 때까지 데이터를 기다렸다가 전송하는 경우, 다음 데이터가 버퍼를 채우면서 이전 데이터의 완전성이 손상될 수 있습니다.
  2. 수신 측: 버퍼에 쌓인 패킷을 제때 수신하지 못하면 여러 패킷이 하나로 뭉쳐서 수신될 수 있으며, 이 역시 데이터의 완전성을 해칠 수 있습니다.

패킷 뭉침 현상 해결 방안

패킷 뭉침 문제를 해결하기 위한 핵심은 전송되는 데이터의 완전성을 보장하는 것입니다. 이는 데이터의 시작, 끝, 그리고 길이를 명확히 함으로써 달성할 수 있습니다. 즉, 전송되는 데이터의 바이트 수를 정확히 파악하고 해당 크기만큼의 데이터를 주고받아야 합니다.

일반적으로 socket.recv() 함수의 인자값보다 적은 바이트 수를 보내면 패킷 뭉침이 발생하지 않지만, 이보다 많을 경우 뭉침 현상이 발생할 수 있습니다. 이를 해결하기 위해 데이터 길이를 명시하는 헤더를 함께 전송하는 방식을 사용합니다.

구현 예시: 명령 제어 통신

다음은 사용자 입력을 받아 서버에서 명령을 실행하고 결과를 클라이언트에게 반환하는 예제입니다. 이 예제에서는 struct.pack()을 사용하여 데이터의 길이를 나타내는 헤더를 먼저 전송하고, 그 뒤에 실제 데이터를 전송하는 방식으로 패킷 뭉침을 해결합니다.


# cmd_server.py
import socket
import struct
import subprocess

server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_address = ('127.0.0.1', 8081)
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_socket.bind(server_address)
server_socket.listen(5)
print("서버가 시작되었습니다...")

while True:
    client_connection, client_address = server_socket.accept()
    print(f"클라이언트 연결: {client_address}")
    while True:
        try:
            command_bytes = client_connection.recv(1024)
            if not command_bytes:
                break
            
            command = command_bytes.decode('utf-8')
            process = subprocess.Popen(command,
                                     shell=True,
                                     stdout=subprocess.PIPE,
                                     stderr=subprocess.PIPE)
            stdout_data, stderr_data = process.communicate()
            
            response_data = stdout_data + stderr_data
            response_size = len(response_data)
            
            # 데이터 크기를 나타내는 헤더(4바이트 정수)를 먼저 전송
            header = struct.pack('i', response_size)
            client_connection.send(header)
            
            # 실제 데이터 전송
            client_connection.send(response_data)

        except ConnectionResetError:
            print(f"클라이언트 연결 종료: {client_address}")
            break
        except Exception as e:
            print(f"오류 발생: {e}")
            break
    client_connection.close()

server_socket.close()

# cmd_client.py
import socket
import struct

client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_address = ('127.0.0.1', 8081)
client_socket.connect(server_address)
print("서버에 연결되었습니다.")

while True:
    command_input = input(">>: ").strip()
    if not command_input:
        continue
    
    client_socket.send(command_input.encode('utf-8'))
    
    # 헤더 수신 (데이터 크기)
    header_bytes = client_socket.recv(4)
    if not header_bytes:
        print("서버 연결이 끊어졌습니다.")
        break
    response_size = struct.unpack('i', header_bytes)[0]
    
    # 데이터 수신
    received_bytes = 0
    response_data = b''
    while received_bytes < response_size:
        chunk = client_socket.recv(1024)
        if not chunk:
            break
        response_data += chunk
        received_bytes += len(chunk)
        
    if received_bytes == response_size:
        print(response_data.decode('utf-8', errors='ignore'))
    else:
        print("데이터 수신 중 오류가 발생했습니다.")

client_socket.close()

구현 예시: JSON 기반 헤더 사용

더 유연한 데이터 전송을 위해 JSON 형식으로 헤더 정보를 구성하고, 헤더의 길이를 먼저 전송하는 방식을 사용할 수 있습니다.


# server_json.py
import socket
import struct
import json
import subprocess
import os

class TcpServer:
    def __init__(self, server_address):
        self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.server_socket.bind(server_address)
        self.server_socket.listen(5)
        self.upload_dir = './uploads' # 파일 업로드 디렉토리
        os.makedirs(self.upload_dir, exist_ok=True)
        print(f"서버 시작: {server_address}")

    def handle_client(self, client_connection, client_address):
        print(f"클라이언트 연결: {client_address}")
        while True:
            try:
                # 1. 헤더 길이 수신 (4바이트)
                header_len_bytes = client_connection.recv(4)
                if not header_len_bytes:
                    break
                header_len = struct.unpack('i', header_len_bytes)[0]

                # 2. 헤더 수신
                header_json_bytes = client_connection.recv(header_len)
                header_data = json.loads(header_json_bytes.decode('utf-8'))
                
                command = header_data.get('cmd')
                filename = header_data.get('filename')
                filesize = header_data.get('filesize')

                print(f"수신된 헤더: {header_data}")

                if command == 'put':
                    self.handle_file_upload(client_connection, filename, filesize)
                elif command == 'get':
                    # 파일 다운로드 로직 (추후 구현)
                    pass
                else:
                    print(f"알 수 없는 명령: {command}")

            except (ConnectionResetError, json.JSONDecodeError, KeyError) as e:
                print(f"클라이언트 통신 오류 ({client_address}): {e}")
                break
            except Exception as e:
                print(f"처리 중 오류 발생 ({client_address}): {e}")
                break
        client_connection.close()
        print(f"클라이언트 연결 종료: {client_address}")

    def handle_file_upload(self, client_connection, filename, filesize):
        file_path = os.path.normpath(os.path.join(self.upload_dir, filename))
        received_size = 0
        print(f"파일 업로드 시작: {file_path} (크기: {filesize} 바이트)")
        
        with open(file_path, 'wb') as f:
            while received_size < filesize:
                # 최대 8192 바이트씩 수신
                chunk = client_connection.recv(8192) 
                if not chunk:
                    print("오류: 파일 전송 중 연결이 끊어졌습니다.")
                    break
                f.write(chunk)
                received_size += len(chunk)
                # 진행률 표시 (선택 사항)
                progress = (received_size / filesize) * 100
                print(f"\r업로드 진행률: {received_size}/{filesize} ({progress:.2f}%)", end='')
            print("\n파일 업로드 완료.")

    def run(self):
        while True:
            client_connection, client_address = self.server_socket.accept()
            self.handle_client(client_connection, client_address)

if __name__ == "__main__":
    server_addr = ('127.0.0.1', 9002)
    server = TcpServer(server_addr)
    try:
        server.run()
    except KeyboardInterrupt:
        print("서버를 종료합니다.")
    finally:
        server.server_socket.close()

# client_json.py
import socket
import struct
import json
import os

class TcpClient:
    def __init__(self, server_address):
        self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.server_address = server_address
        self.connect()

    def connect(self):
        try:
            self.client_socket.connect(self.server_address)
            print(f"서버 연결 성공: {self.server_address}")
        except ConnectionRefusedError:
            print(f"서버 연결 실패: {self.server_address}")
            raise

    def send_data(self, data_bytes):
        self.client_socket.sendall(data_bytes)

    def receive_data(self, size):
        data = b''
        while len(data) < size:
            chunk = self.client_socket.recv(min(size - len(data), 8192))
            if not chunk:
                return None
            data += chunk
        return data

    def send_command(self, cmd_dict):
        header_json = json.dumps(cmd_dict).encode('utf-8')
        header_len = len(header_json)
        
        # 1. 헤더 길이 전송
        self.send_data(struct.pack('i', header_len))
        # 2. 헤더 전송
        self.send_data(header_json)

    def upload_file(self, filename):
        if not os.path.isfile(filename):
            print(f"오류: 파일 '{filename}'이 존재하지 않습니다.")
            return

        file_size = os.path.getsize(filename)
        base_filename = os.path.basename(filename)
        
        header = {'cmd': 'put', 'filename': base_filename, 'filesize': file_size}
        self.send_command(header)
        
        print(f"파일 업로드 시작: {base_filename} ({file_size} 바이트)")
        
        sent_size = 0
        with open(filename, 'rb') as f:
            while True:
                chunk = f.read(8192)
                if not chunk:
                    break
                self.send_data(chunk)
                sent_size += len(chunk)
                progress = (sent_size / file_size) * 100
                print(f"\r전송 진행률: {sent_size}/{file_size} ({progress:.2f}%)", end='')
        print("\n파일 업로드 완료.")

    def run(self):
        while True:
            try:
                user_input = input(">>: ").strip()
                if not user_input:
                    continue
                
                parts = user_input.split()
                command = parts[0]

                if command == 'put' and len(parts) == 2:
                    self.upload_file(parts[1])
                elif command == 'quit':
                    break
                else:
                    print("알 수 없는 명령입니다. 'put <filename>' 또는 'quit'을 사용하세요.")
            except KeyboardInterrupt:
                break
            except ConnectionResetError:
                print("서버와의 연결이 끊어졌습니다.")
                break
            except Exception as e:
                print(f"오류 발생: {e}")

        self.client_socket.close()

if __name__ == "__main__":
    server_addr = ('127.0.0.1', 9002)
    client = TcpClient(server_addr)
    client.run()

파일 업로드 및 다운로드 구현

앞서 설명한 헤더 기반 통신 방식을 활용하여 파일 업로드 및 다운로드 기능을 구현할 수 있습니다. 서버는 클라이언트로부터 파일 정보(이름, 크기)를 담은 헤더를 수신한 후, 해당 크기만큼의 데이터를 파일로 저장합니다. 다운로드 시에는 반대로 파일 크기 헤더를 먼저 전송하고, 파일 내용을 청크 단위로 나누어 전송합니다.

실행 방법:

  1. 서버를 실행합니다. (예: python server_json.py)
  2. 클라이언트를 실행합니다. (예: python client_json.py)
  3. 클라이언트에서 put <파일경로> 명령어를 입력하여 파일을 업로드합니다. (예: put /path/to/your/file.txt)

서버의 upload_dir 경로에 업로드된 파일이 저장됩니다.

태그: python tcp socket Networking packet-bundling

10월 20일 08:28에 게시됨