仓颉语言中网络套接字的高级封装：从原生API到生产级框架

// 传统的原生套接字使用方式
func rawSocketExample() {
    // 创建套接字
    let sockfd = socket(AF_INET, SOCK_STREAM, 0)
    if (sockfd < 0) {
        println("Socket creation failed")
        return
    }
    
    // 手动配置地址
    var serverAddr = sockaddr_in()
    serverAddr.sin_family = AF_INET
    serverAddr.sin_port = htons(8080)
    serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1")
    
    // 连接
    if (connect(sockfd, &serverAddr, sizeof(serverAddr)) < 0) {
        close(sockfd)
        println("Connection failed")
        return
    }
    
    // 发送数据
    let data = "Hello World".toUtf8()
    if (send(sockfd, data, data.size, 0) < 0) {
        close(sockfd)
        println("Send failed")
        return
    }
    
    // 接收数据
    var buffer = Array<UInt8>(1024, item: 0)
    let bytesRead = recv(sockfd, buffer, buffer.size, 0)
    
    // 必须手动关闭
    close(sockfd)
}

// 套接字异常类
public class SocketException <: Exception {
    private let errorMessage: String
    
    public init(message: String) {
        this.errorMessage = message
        super()
    }
    
    public func getMessage(): String {
        return errorMessage
    }
}

// 套接字状态枚举
public enum SocketState {
    | Closed
    | Connected
    | Listening
    | Error
}

// 核心套接字包装类
public class SocketWrapper {
    private var sockfd: Int32 = -1
    private var state: SocketState = SocketState.Closed
    private var remoteAddress: String = ""
    private var remotePort: Int32 = 0
    private var isClosed: Bool = true
    
    // 私有构造函数，通过工厂方法创建
    private init() {}
    
    // 创建TCP客户端套接字
    public static func createTcpClient(host: String, port: Int32): SocketWrapper {
        let wrapper = SocketWrapper()
        wrapper.connect(host, port)
        return wrapper
    }
    
    // 创建TCP服务器套接字
    public static func createTcpServer(port: Int32, backlog: Int32 = 128): SocketWrapper {
        let wrapper = SocketWrapper()
        wrapper.bind(port)
        wrapper.listen(backlog)
        return wrapper
    }
    
    // 从文件描述符创建（用于accept）
    private static func fromFd(fd: Int32, addr: String, port: Int32): SocketWrapper {
        let wrapper = SocketWrapper()
        wrapper.sockfd = fd
        wrapper.state = SocketState.Connected
        wrapper.remoteAddress = addr
        wrapper.remotePort = port
        wrapper.isClosed = false
        return wrapper
    }
}

extension SocketWrapper {
    // 连接到服务器
    private func connect(host: String, port: Int32) {
        // 创建套接字
        this.sockfd = socket(AF_INET, SOCK_STREAM, 0)
        if (this.sockfd < 0) {
            throw SocketException("Failed to create socket")
        }
        
        // 配置服务器地址
        var serverAddr = sockaddr_in()
        serverAddr.sin_family = AF_INET
        serverAddr.sin_port = htons(UInt16(port))
        
        // 解析主机地址
        if (inet_pton(AF_INET, host.toCString(), &serverAddr.sin_addr) <= 0) {
            this.close()
            throw SocketException("Invalid address: ${host}")
        }
        
        // 执行连接
        if (connect(this.sockfd, &serverAddr as UnsafePointer<sockaddr>, 
                    sizeof(sockaddr_in)) < 0) {
            this.close()
            throw SocketException("Connection failed to ${host}:${port}")
        }
        
        this.state = SocketState.Connected
        this.remoteAddress = host
        this.remotePort = port
        this.isClosed = false
    }
    
    // 绑定端口
    private func bind(port: Int32) {
        // 创建套接字
        this.sockfd = socket(AF_INET, SOCK_STREAM, 0)
        if (this.sockfd < 0) {
            throw SocketException("Failed to create socket")
        }
        
        // 设置端口重用
        var opt: Int32 = 1
        setsockopt(this.sockfd, SOL_SOCKET, SO_REUSEADDR, 
                   &opt, sizeof(Int32))
        
        // 配置绑定地址
        var serverAddr = sockaddr_in()
        serverAddr.sin_family = AF_INET
        serverAddr.sin_addr.s_addr = INADDR_ANY
        serverAddr.sin_port = htons(UInt16(port))
        
        // 执行绑定
        if (bind(this.sockfd, &serverAddr as UnsafePointer<sockaddr>,
                 sizeof(sockaddr_in)) < 0) {
            this.close()
            throw SocketException("Bind failed on port ${port}")
        }
        
        this.isClosed = false
    }
    
    // 监听连接
    private func listen(backlog: Int32) {
        if (listen(this.sockfd, backlog) < 0) {
            this.close()
            throw SocketException("Listen failed")
        }
        this.state = SocketState.Listening
    }
    
    // 接受客户端连接
    public func accept(): SocketWrapper {
        if (this.state != SocketState.Listening) {
            throw SocketException("Socket is not listening")
        }
        
        var clientAddr = sockaddr_in()
        var addrLen: socklen_t = sizeof(sockaddr_in)
        
        let clientFd = accept(this.sockfd, 
                              &clientAddr as UnsafePointer<sockaddr>,
                              &addrLen)
        
        if (clientFd < 0) {
            throw SocketException("Accept failed")
        }
        
        // 提取客户端地址信息
        var addrStr = Array<Int8>(INET_ADDRSTRLEN, item: 0)
        inet_ntop(AF_INET, &clientAddr.sin_addr, addrStr, INET_ADDRSTRLEN)
        let clientHost = String.fromCString(addrStr)
        let clientPort = Int32(ntohs(clientAddr.sin_port))
        
        return SocketWrapper.fromFd(clientFd, clientHost, clientPort)
    }
}

extension SocketWrapper {
    // 发送数据
    public func send(data: Array<UInt8>): Int64 {
        if (this.isClosed || this.state != SocketState.Connected) {
            throw SocketException("Socket is not connected")
        }
        
        var totalSent: Int64 = 0
        var remaining = Int64(data.size)
        
        while (remaining > 0) {
            let bytesSent = send(this.sockfd, 
                                data[Int(totalSent)],
                                Int(remaining), 
                                0)
            
            if (bytesSent < 0) {
                throw SocketException("Send failed")
            }
            
            if (bytesSent == 0) {
                break  // 连接关闭
            }
            
            totalSent += Int64(bytesSent)
            remaining -= Int64(bytesSent)
        }
        
        return totalSent
    }
    
    // 发送字符串
    public func sendString(text: String): Int64 {
        return send(text.toUtf8())
    }
    
    // 接收固定长度数据
    public func receive(length: Int64): Array<UInt8> {
        if (this.isClosed || this.state != SocketState.Connected) {
            throw SocketException("Socket is not connected")
        }
        
        var result = ArrayList<UInt8>()
        var buffer = Array<UInt8>(4096, item: 0)
        var remaining = length
        
        while (remaining > 0) {
            let toRead = if (remaining > 4096) { 4096 } else { Int(remaining) }
            let bytesRead = recv(this.sockfd, buffer, toRead, 0)
            
            if (bytesRead < 0) {
                throw SocketException("Receive failed")
            }
            
            if (bytesRead == 0) {
                break  // 连接关闭
            }
            
            for (i in 0..bytesRead) {
                result.append(buffer[i])
            }
            
            remaining -= Int64(bytesRead)
        }
        
        return result.toArray()
    }
    
    // 接收所有可用数据
    public func receiveAll(): Array<UInt8> {
        if (this.isClosed || this.state != SocketState.Connected) {
            throw SocketException("Socket is not connected")
        }
        
        var result = ArrayList<UInt8>()
        var buffer = Array<UInt8>(4096, item: 0)
        
        while (true) {
            let bytesRead = recv(this.sockfd, buffer, buffer.size, 0)
            
            if (bytesRead < 0) {
                throw SocketException("Receive failed")
            }
            
            if (bytesRead == 0) {
                break  // 连接关闭
            }
            
            for (i in 0..bytesRead) {
                result.append(buffer[i])
            }
            
            // 如果读取的字节少于缓冲区大小，说明没有更多数据
            if (bytesRead < buffer.size) {
                break
            }
        }
        
        return result.toArray()
    }
    
    // 接收一行文本（直到\n）
    public func receiveLine(): String {
        var lineData = ArrayList<UInt8>()
        var buffer = Array<UInt8>(1, item: 0)
        
        while (true) {
            let bytesRead = recv(this.sockfd, buffer, 1, 0)
            
            if (bytesRead <= 0) {
                break
            }
            
            let byte = buffer[0]
            if (byte == UInt8('\n')) {
                break
            }
            
            if (byte != UInt8('\r')) {
                lineData.append(byte)
            }
        }
        
        return String.fromUtf8(lineData.toArray())
    }
}

extension SocketWrapper {
    // 关闭套接字
    public func close() {
        if (!this.isClosed && this.sockfd >= 0) {
            close(this.sockfd)
            this.sockfd = -1
            this.state = SocketState.Closed
            this.isClosed = true
        }
    }
    
    // 析构函数：自动关闭
    public ~SocketWrapper() {
        this.close()
    }
    
    // 设置超时
    public func setTimeout(seconds: Int32) {
        var timeout = timeval()
        timeout.tv_sec = seconds
        timeout.tv_usec = 0
        
        setsockopt(this.sockfd, SOL_SOCKET, SO_RCVTIMEO,
                   &timeout, sizeof(timeval))
        setsockopt(this.sockfd, SOL_SOCKET, SO_SNDTIMEO,
                   &timeout, sizeof(timeval))
    }
    
    // 获取状态信息
    public func getState(): SocketState {
        return this.state
    }
    
    public func getRemoteAddress(): String {
        return "${remoteAddress}:${remotePort}"
    }
    
    public func isConnected(): Bool {
        return !isClosed && state == SocketState.Connected
    }
}

// 连接池配置
public struct PoolConfig {
    let minConnections: Int64 = 5
    let maxConnections: Int64 = 50
    let connectionTimeout: Int32 = 10
    let idleTimeout: Int64 = 300  // 5分钟
}

// 池化连接包装
private class PooledConnection {
    public let socket: SocketWrapper
    public var lastUsedTime: Int64
    public var inUse: Bool = false
    
    public init(socket: SocketWrapper) {
        this.socket = socket
        this.lastUsedTime = System.currentTimeMillis() / 1000
    }
    
    public func updateLastUsed() {
        this.lastUsedTime = System.currentTimeMillis() / 1000
    }
}

// 连接池实现
public class SocketConnectionPool {
    private let host: String
    private let port: Int32
    private let config: PoolConfig
    private var connections: Array<PooledConnection>
    private let lock: Mutex
    
    public init(host: String, port: Int32, config: PoolConfig = PoolConfig()) {
        this.host = host
        this.port = port
        this.config = config
        this.connections = ArrayList<PooledConnection>()
        this.lock = Mutex()
        
        // 预创建最小连接数
        this.initializeConnections()
    }
    
    private func initializeConnections() {
        for (i in 0..config.minConnections) {
            try {
                let socket = SocketWrapper.createTcpClient(host, port)
                socket.setTimeout(config.connectionTimeout)
                connections.append(PooledConnection(socket))
            } catch (e: SocketException) {
                println("Failed to create initial connection: ${e.getMessage()}")
            }
        }
    }
    
    // 获取连接
    public func acquire(): ?SocketWrapper {
        lock.lock()
        defer { lock.unlock() }
        
        // 查找空闲连接
        for (conn in connections) {
            if (!conn.inUse && conn.socket.isConnected()) {
                conn.inUse = true
                conn.updateLastUsed()
                return conn.socket
            }
        }
        
        // 如果未达到最大连接数，创建新连接
        if (connections.size < config.maxConnections) {
            try {
                let socket = SocketWrapper.createTcpClient(host, port)
                socket.setTimeout(config.connectionTimeout)
                let conn = PooledConnection(socket)
                conn.inUse = true
                connections.append(conn)
                return socket
            } catch (e: SocketException) {
                println("Failed to create new connection: ${e.getMessage()}")
                return None
            }
        }
        
        return None  // 连接池已满
    }
    
    // 释放连接
    public func release(socket: SocketWrapper) {
        lock.lock()
        defer { lock.unlock() }
        
        for (conn in connections) {
            if (conn.socket === socket) {
                conn.inUse = false
                conn.updateLastUsed()
                break
            }
        }
    }
    
    // 清理空闲连接
    public func cleanupIdleConnections() {
        lock.lock()
        defer { lock.unlock() }
        
        let currentTime = System.currentTimeMillis() / 1000
        let toRemove = ArrayList<Int64>()
        
        for (i in 0..connections.size) {
            let conn = connections[Int(i)]
            if (!conn.inUse && 
                currentTime - conn.lastUsedTime > config.idleTimeout &&
                connections.size > config.minConnections) {
                conn.socket.close()
                toRemove.append(i)
            }
        }
        
        // 移除已关闭的连接
        for (index in toRemove.reverse()) {
            connections.removeAt(Int(index))
        }
    }
}

// HTTP请求类
public class HttpRequest {
    public let method: String
    public let path: String
    public let headers: HashMap<String, String>
    public let body: String
    
    public init(method: String, path: String) {
        this.method = method
        this.path = path
        this.headers = HashMap<String, String>()
        this.body = ""
    }
    
    public func addHeader(key: String, value: String) {
        headers.put(key, value)
    }
    
    public func toBytes(): Array<UInt8> {
        var request = "${method} ${path} HTTP/1.1\r\n"
        
        // 添加headers
        let keys = headers.keys()
        for (key in keys) {
            request += "${key}: ${headers.get(key)}\r\n"
        }
        
        request += "\r\n"
        request += body
        
        return request.toUtf8()
    }
}

// HTTP响应类
public class HttpResponse {
    public let statusCode: Int32
    public let headers: HashMap<String, String>
    public let body: String
    
    public init(statusCode: Int32, headers: HashMap<String, String>, body: String) {
        this.statusCode = statusCode
        this.headers = headers
        this.body = body
    }
    
    public static func parse(data: Array<UInt8>): HttpResponse {
        let text = String.fromUtf8(data)
        let lines = text.split('\n')
        
        // 解析状态行
        let statusLine = lines[0]
        let statusParts = statusLine.split(' ')
        let statusCode = Int32.parse(statusParts[1])
        
        // 解析headers
        let headers = HashMap<String, String>()
        var bodyStart = 0
        
        for (i in 1..lines.size) {
            let line = lines[Int(i)].trim()
            if (line.isEmpty()) {
                bodyStart = i + 1
                break
            }
            
            let colonPos = line.indexOf(':')
            if (colonPos > 0) {
                let key = line.substring(0, colonPos).trim()
                let value = line.substring(colonPos + 1).trim()
                headers.put(key, value)
            }
        }
        
        // 提取body
        var body = ""
        for (i in bodyStart..lines.size) {
            body += lines[Int(i)]
            if (i < lines.size - 1) {
                body += "\n"
            }
        }
        
        return HttpResponse(statusCode, headers, body)
    }
}

// HTTP客户端
public class HttpClient {
    private let pool: SocketConnectionPool
    
    public init(host: String, port: Int32 = 80) {
        let config = PoolConfig(
            minConnections: 2,
            maxConnections: 20,
            connectionTimeout: 5
        )
        this.pool = SocketConnectionPool(host, port, config)
    }
    
    public func send(request: HttpRequest): ?HttpResponse {
        let socket = pool.acquire()
        if (socket == None) {
            return None
        }
        
        try {
            // 发送请求
            socket!.send(request.toBytes())
            
            // 接收响应
            let responseData = socket!.receiveAll()
            let response = HttpResponse.parse(responseData)
            
            // 释放连接回池
            pool.release(socket!)
            
            return response
        } catch (e: SocketException) {
            println("HTTP request failed: ${e.getMessage()}")
            return None
        }
    }
    
    public func get(path: String): ?HttpResponse {
        let request = HttpRequest("GET", path)
        request.addHeader("Connection", "keep-alive")
        return send(request)
    }
    
    public func post(path: String, body: String): ?HttpResponse {
        let request = HttpRequest("POST", path)
        request.addHeader("Content-Length", "${body.size}")
        request.addHeader("Connection", "keep-alive")
        request.body = body
        return send(request)
    }
}

// 客户端处理器接口
public interface ClientHandler {
    func handle(client: SocketWrapper)
}

// TCP服务器
public class TcpServer {
    private let port: Int32
    private let serverSocket: SocketWrapper
    private var isRunning: Bool = false
    private let handler: ClientHandler
    private let threadPool: ThreadPool
    
    public init(port: Int32, handler: ClientHandler, maxThreads: Int32 = 10) {
        this.port = port
        this.handler = handler
        this.serverSocket = SocketWrapper.createTcpServer(port)
        this.threadPool = ThreadPool(maxThreads)
    }
    
    public func start() {
        isRunning = true
        println("Server started on port ${port}")
        
        while (isRunning) {
            try {
                // 接受客户端连接
                let client = serverSocket.accept()
                println("New connection from ${client.getRemoteAddress()}")
                
                // 提交到线程池处理
                threadPool.submit({
                    try {
                        handler.handle(client)
                    } catch (e: Exception) {
                        println("Error handling client: ${e.getMessage()}")
                    } finally {
                        client.close()
                    }
                })
            } catch (e: SocketException) {
                if (isRunning) {
                    println("Accept error: ${e.getMessage()}")
                }
            }
        }
    }
    
    public func stop() {
        isRunning = false
        serverSocket.close()
        threadPool.shutdown()
    }
}

// Echo服务处理器
public class EchoHandler <: ClientHandler {
    public func handle(client: SocketWrapper) {
        println("Handling echo client: ${client.getRemoteAddress()}")
        
        while (client.isConnected()) {
            try {
                // 读取一行
                let line = client.receiveLine()
                if (line.isEmpty()) {
                    break
                }
                
                println("Received: ${line}")
                
                // 回显
                client.sendString("ECHO: ${line}\n")
            } catch (e: SocketException) {
                println("Echo error: ${e.getMessage()}")
                break
            }
        }
        
        println("Client disconnected: ${client.getRemoteAddress()}")
    }
}

// 使用示例
main(): Int64 {
    let handler = EchoHandler()
    let server = TcpServer(8080, handler, 20)
    
    // 启动服务器
    server.start()
    
    return 0
}

// 简单HTTP服务处理器
public class SimpleHttpHandler <: ClientHandler {
    public func handle(client: SocketWrapper) {
        try {
            // 读取HTTP请求
            var request = ""
            while (true) {
                let line = client.receiveLine()
                request += line + "\n"
                if (line.isEmpty()) {
                    break
                }
            }
            
            println("HTTP Request:\n${request}")
            
            // 构造响应
            let body = "<html><body><h1>Hello from Cangjie Server!</h1></body></html>"
            let response = """
            HTTP/1.1 200 OK
            Content-Type: text/html
            Content-Length: ${body.size}
            Connection: close
            
            ${body}
            """
            
            // 发送响应
            client.sendString(response)
        } catch (e: SocketException) {
            println("HTTP handling error: ${e.getMessage()}")
        }
    }
}

socket.setTimeout(30)  // 30秒超时

let pool = SocketConnectionPool("api.example.com", 80)
let socket = pool.acquire()
// 使用socket
pool.release(socket)

try {
    socket.sendString("data")
} catch (e: SocketException) {
    // 处理网络错误
    logger.error("Network error: ${e.getMessage()}")
}