宝塔UDP服务器部署记录,unityClient,pythonServer

🕗 发布于 2025-01-23 04:07 udp 服务器 网络协议 python 宝塔

在这里插入图片描述

最近项目接到新需求，需要用Unity 客户端（发送端）控制另一台 Unity 客户端（接收端），中间用UDP服务器做数据中转。

先测试一下连通性，我用 Python 搞了个服务器 demo。

在正式开发之前，先做一个连通性测试，于是用python写UDP服务器demo，并部署到宝塔面板上。

代码

server.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import socket
import sys
import subprocess
import time
import threading

class UDPServer:
    def __init__(self, host='0.0.0.0', port=7789):
        self.host = host
        self.port = port
        print(f"Server initializing on {host}:{port}")
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.clients = {}
        self.running = True
        
    def start(self):
        try:
            self.sock.bind((self.host, self.port))
            print("Server started successfully")
        except Exception as e:
            print(f"Server start failed: {e}")
            return

        cleanup_thread = threading.Thread(target=self.cleanup_inactive_clients)
        cleanup_thread.daemon = True
        cleanup_thread.start()
        
        while self.running:
            try:
                data, addr = self.sock.recvfrom(1024)
                message = data.decode('utf-8')
                self.handle_message(message, addr)
            except Exception as e:
                print(f"Error: {e}")

    def handle_message(self, data, addr):
        try:
            commands = data.split('|')
            command_type = commands[0]
            
            if command_type == "Heartbeat":
                self.clients[addr] = time.time()
                return
                
            elif command_type == "Disconnect":
                if addr in self.clients:
                    del self.clients[addr]
                    print(f"Client {addr} disconnected")
                return
                
            self.clients[addr] = time.time()
            
            if command_type == "CustomText":
                if len(commands) > 1:
                    content = commands[1]
                    self.broadcast_message(f"CustomText|{content}", exclude_addr=addr)
                    self.sock.sendto("Message broadcasted".encode(), addr)
            
        except Exception as e:
            print(f"Message handling error: {e}")

    def cleanup_inactive_clients(self):
        while self.running:
            try:
                current_time = time.time()
                inactive_clients = [
                    addr for addr, last_time in self.clients.items()
                    if current_time - last_time > 30
                ]
                
                for addr in inactive_clients:
                    del self.clients[addr]
                    print(f"Removed inactive client: {addr}")
                
                time.sleep(10)
            except Exception as e:
                print(f"Cleanup error: {e}")

    def broadcast_message(self, message, exclude_addr=None):
        for client_addr in list(self.clients.keys()):
            if client_addr != exclude_addr:
                try:
                    self.sock.sendto(message.encode(), client_addr)
                except Exception as e:
                    print(f"Broadcast error to {client_addr}: {e}")
                    del self.clients[client_addr]

    def stop(self):
        self.running = False
        self.sock.close()
        print("Server stopped")

if __name__ == "__main__":
    server = UDPServer()
    try:
        server.start()
    except KeyboardInterrupt:
        server.stop()

unity发送端UDPController.cs

using UnityEngine;
using System;
using System.Text;
using System.Net.Sockets;
using System.Net;
using UnityEngine.UI;

public class UDPController : MonoBehaviour
{
    public InputField inputField;
    public Text messageLog;
    public Button sendButton;
    
    private UdpClient udp;
    private string serverIP = "0.0.0.0";  // 服务器IP
    private int serverPort = 7789;          // 服务器端口
    private string pendingMessage = null;    // 待处理的消息
    private float heartbeatInterval = 10f;  // 心跳间隔
    private float nextHeartbeatTime = 0f;

    void Start()
    {
        InitializeUDP();
        if (sendButton != null)
        {
            sendButton.onClick.AddListener(SendCustomText);
        }
    }

    private void InitializeUDP()
    {
        try
        {
            udp = new UdpClient();
            
            udp.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
            udp.Client.Bind(new IPEndPoint(IPAddress.Any, 0));
            
            
            udp.Connect(IPAddress.Parse(serverIP), serverPort);
            LogMessage($"控制端初始化成功，本地端口: {((IPEndPoint)udp.Client.LocalEndPoint).Port}");
            
            udp.BeginReceive(new AsyncCallback(OnReceived), udp);
        }
        catch (Exception e)
        {
            LogMessage($"初始化失败: {e.Message}");
        }
    }

    public void SendCustomText()
    {
        if (string.IsNullOrEmpty(inputField.text)) return;
        
        try
        {
            string message = $"CustomText|{inputField.text}";
            byte[] sendBytes = Encoding.UTF8.GetBytes(message);
            udp.Send(sendBytes, sendBytes.Length);
            LogMessage($"已发送: {inputField.text}");
            inputField.text = ""; // 清空输入框
        }
        catch (Exception e)
        {
            LogMessage($"发送失败: {e.Message}");
        }
    }

    private void OnReceived(IAsyncResult result)
    {
        try
        {
            UdpClient socket = result.AsyncState as UdpClient;
            IPEndPoint source = new IPEndPoint(IPAddress.Any, 0);
            byte[] message = socket.EndReceive(result, ref source);
            string receivedData = Encoding.UTF8.GetString(message);
            
            
            pendingMessage = receivedData;
            
            // 继续监听
            socket.BeginReceive(new AsyncCallback(OnReceived), socket);
        }
        catch (Exception e)
        {
            Debug.LogError($"接收消息失败: {e.Message}");
        }
    }

    private void Update()
    {
        
        if (pendingMessage != null)
        {
            LogMessage($"服务器响应: {pendingMessage}");
            pendingMessage = null;
        }

        // 发送心跳
        if (Time.time >= nextHeartbeatTime)
        {
            SendHeartbeat();
            nextHeartbeatTime = Time.time + heartbeatInterval;
        }
    }

    private void SendHeartbeat()
    {
        try
        {
            string message = "Heartbeat|";
            byte[] sendBytes = Encoding.UTF8.GetBytes(message);
            udp.Send(sendBytes, sendBytes.Length);
        }
        catch (Exception e)
        {
            Debug.LogError($"发送心跳失败: {e.Message}");
        }
    }

    private void LogMessage(string message)
    {
        if (messageLog != null)
        {
            messageLog.text += $"\n{message}";
        }
        Debug.Log(message);
    }

    void OnDestroy()
    {
        if (udp != null)
        {
            try
            {
                
                string message = "Disconnect|";
                byte[] sendBytes = Encoding.UTF8.GetBytes(message);
                udp.Send(sendBytes, sendBytes.Length);
            }
            catch (Exception e)
            {
                Debug.LogError($"发送断开消息失败: {e.Message}");
            }
            finally
            {
                udp.Close();
                udp.Dispose();
            }
        }
    }
}

unity接收端UDPReceiver.cs

using UnityEngine;
using System;
using System.Text;
using System.Net.Sockets;
using System.Net;
using UnityEngine.UI;
using UnityEngine.Events;

[System.Serializable]
public class CustomTextEvent : UnityEvent<string> { }

public class UDPReceiver : MonoBehaviour
{
    public Text messageLog;
    public CustomTextEvent onCustomTextReceived;  // Unity事件，用于处理接收到的文本

    private UdpClient udp;
    private string serverIP = "0.0.0.0";  // 服务器IP
    private int serverPort = 7789;          // 服务器端口
    private string pendingMessage = null;    // 待处理的消息
    private string pendingContent = null;    // 待处理的内容
    private float heartbeatInterval = 10f;
    private float nextHeartbeatTime = 0f;

    void Start()
    {
        InitializeUDP();
        if (onCustomTextReceived == null)
        {
            onCustomTextReceived = new CustomTextEvent();
        }
    }

    private void InitializeUDP()
    {
        try
        {
            udp = new UdpClient();
            
            udp.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
            udp.Client.Bind(new IPEndPoint(IPAddress.Any, 0));
            
            
            byte[] connectMessage = Encoding.UTF8.GetBytes("CustomText|Connected");
            udp.Send(connectMessage, connectMessage.Length, serverIP, serverPort);
            
            udp.BeginReceive(new AsyncCallback(OnReceived), udp);
            LogMessage($"接收端初始化成功，本地端口: {((IPEndPoint)udp.Client.LocalEndPoint).Port}");
        }
        catch (Exception e)
        {
            LogMessage($"初始化失败: {e.Message}");
        }
    }

    private void OnReceived(IAsyncResult result)
    {
        try
        {
            UdpClient socket = result.AsyncState as UdpClient;
            IPEndPoint source = new IPEndPoint(IPAddress.Any, 0);
            byte[] message = socket.EndReceive(result, ref source);
            string receivedData = Encoding.UTF8.GetString(message);
            
            
            pendingMessage = receivedData;
            
            
            socket.BeginReceive(new AsyncCallback(OnReceived), socket);
        }
        catch (Exception e)
        {
            Debug.LogError($"接收消息失败: {e.Message}");
        }
    }

    private void Update()
    {
        
        if (pendingMessage != null)
        {
            HandleMessage(pendingMessage);
            pendingMessage = null;
        }

        
        if (pendingContent != null)
        {
            OnCustomTextReceived(pendingContent);
            pendingContent = null;
        }

        // 发送心跳
        if (Time.time >= nextHeartbeatTime)
        {
            SendHeartbeat();
            nextHeartbeatTime = Time.time + heartbeatInterval;
        }
    }

    private void HandleMessage(string data)
    {
        try
        {
            string[] parts = data.Split('|');
            if (parts.Length < 2) return;

            string messageType = parts[0];
            string content = parts[1];

            switch (messageType)
            {
                case "CustomText":
                    pendingContent = content;
                    break;
            }
        }
        catch (Exception e)
        {
            LogMessage($"处理消息时出错: {e.Message}");
        }
    }

    private void OnCustomTextReceived(string text)
    {
        LogMessage($"收到文本: {text}");
        onCustomTextReceived?.Invoke(text);  // 触发Unity事件
    }

    private void LogMessage(string message)
    {
        if (messageLog != null)
        {
            messageLog.text += $"\n{message}";
        }
        Debug.Log(message);
    }

    private void SendHeartbeat()
    {
        try
        {
            string message = "Heartbeat|";
            byte[] sendBytes = Encoding.UTF8.GetBytes(message);
            udp.Send(sendBytes, sendBytes.Length, serverIP, serverPort);
        }
        catch (Exception e)
        {
            Debug.LogError($"发送心跳失败: {e.Message}");
        }
    }

    void OnDestroy()
    {
        if (udp != null)
        {
            try
            {
                string message = "Disconnect|";
                byte[] sendBytes = Encoding.UTF8.GetBytes(message);
                udp.Send(sendBytes, sendBytes.Length, serverIP, serverPort);
            }
            catch (Exception e)
            {
                Debug.LogError($"发送断开消息失败: {e.Message}");
            }
            finally
            {
                udp.Close();
                udp.Dispose();
            }
        }
    }
}

部署

宝塔面板–文件

创建项目文件夹

server.py上传(其他文件忽略，这是后来生成的)

宝塔面板–网站–python项目

需安装对应的python版本(3.10.14)

点击添加python项目。

项目路径选择刚才创建好的文件夹。

项目名称随意填。

运行文件选择目录内的server.py脚本

项目端口选择7789。(脚本里写的7789)

别忘了勾选放行端口！就是这个导致我后面调试了半小时…我怎么记得我勾选了呢？

python版本根据你开发的版本来。

框架选择python

由于这个demo不需要安装额外依赖，所以不填。

确认上述没问题后点击确定。

可以看到项目运行中

这时候还没结束，需要去开放安全组和对应的防火墙。

这台服务器是阿里云的，到ECS后台–安全组，添加入方向端口号7789，授权对象0.0.0.0

宝塔面板–安全这里也要检查下是否有7789的UDP协议的端口号！如果上面没勾选放行端口，这里就没有。

最后在本地客户端上进行验证，同时在服务器–设置–项目日志查看记录

调试命令

服务器上运行以下命令排查。

netstat -nulp | grep 7789检查端口是否在监听

firewall-cmd --list-ports检查服务器防火墙中的端口

用以下命令添加也可以，最好还是宝塔防火墙里直接开放也省事。

# 查看活动的防火墙区域
firewall-cmd --get-active-zones

# 为docker区域添加UDP端口
firewall-cmd --zone=docker --add-port=7789/udp --permanent
firewall-cmd --reload

# 验证端口是否添加成功
firewall-cmd --zone=docker --list-ports

写到最后

切记要检查ECS安全组、宝塔防火墙设置是否开放了端口号！(给自己提个醒)

原文地址：https://blog.csdn.net/weixin_43935971/article/details/145278641

免责声明：本站文章内容转载自网络资源，如侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：【2024年华为OD机试】 (E卷,100分) - 分割数组的最大差值（JavaScript&Java & Python&C/C++）
下一篇：【2024年终总结】我与CSDN的一年

OpenAI-Edge-TTS的使用
例如：【python】 import edge_ttstext = "这是一段需要转换为语音的文本"voice = "zh-CN-YunyangNeural"c
阅读更多2025-01-23
文件快递柜：匿名口令分享工具，轻松安全地存取文本与文件
正是这样一款简单高效的工具，它支持匿名、轻量级的文件与文本分享，无需注册登录，通过随机生成的口令完成存取，就像取快递一样方便快捷。对于初学者来说，文件快递柜是一个功能齐全、代码清晰的项目，适合作为 W
阅读更多2025-01-23
鸿蒙模块概念和应用启动相关类（HAP、HAR、HSP、AbilityStage、UIAbility、WindowStage、window）
hap包是手机安装的最小单元，1个app包含一个或多个hap包。对应到代码工程中是一个module,每个module会有一个module.json5文件作为该module的配置文件，在src/main
阅读更多2025-01-23
AIP-126 枚举
一个域的值集合是一组数量有限的具体值，这是很常见的。此时使用枚举（缩写为“enums”）可有助于明确表达值集合的范围。
阅读更多2025-01-23
【2024年华为OD机试】 (E卷,200分) - 寻找符合要求的最长子串（JavaScript&Java & Python&C/C++）
本题的核心是通过滑动窗口的思想，动态维护一个满足条件的子串窗口，并记录窗口的最大长度。排除指定字符。限制字符的出现次数。高效地调整窗口边界。通过合理的滑动窗口实现，可以在O(n)的时间复杂度内解决问题
阅读更多2025-01-23
使用docker部署自托管密码管理器(vaultwarden)
部署完成后的检查清单✅ 访问 Web 界面确认服务正常运行✅ 完成管理员账号的注册与设置✅ 验证 HTTPS 证书配置是否正确✅ 确认数据备份路径已正确映射安全建议1.定期备份建议每周备份一次数据库将
阅读更多2025-01-23
docker部署flask项目后，请求时总是报拒绝连接错误
docker部署flask项目时，在容器内可以正常访问服务，但是在容器外部，即使在本地服务器也没有办法访问服务，查看了很多解决方法都不能解决这个问题，报错信息如下“curl: (56) Recv fa
阅读更多2025-01-23
java中的泛型
本文详细的介绍了java中的泛型，包括泛型的定义，泛型的使用以及注意事项
阅读更多2025-01-23
Spring Boot 事件驱动：构建灵活可扩展的应用
}} }} }
阅读更多2025-01-23
spring ApplicationContext的事件监听机制
实现ApplicationListener接口定义listenereg:事件发布测试controller中测试发布事件测试输出：本例用springboot开启一个web项目，内置了 bean 直接获取
阅读更多2025-01-23

宝塔UDP服务器部署记录,unityClient,pythonServer

代码

部署

调试命令

写到最后

相关文章