UDPClient.go

package ipc

import (
	"bytes"
	"encoding/gob"
	"log"
	"net"
	"time"
)

type UDPClient struct {
	UDPBase
	conn *net.UDPConn
	addr *net.UDPAddr
}

func NewUDPClient(addr string, port int) *UDPClient {
	client := &UDPClient{
		UDPBase: UDPBase{
			addr: addr,
			port: port,
			mtu:  32000,
			timeout: 100 * time.Millisecond,
		},
	}
	client.create(addr, port)
	return client
}

func (u *UDPClient) create(addr string, port int) {
	u.addr, _ = net.ResolveUDPAddr("udp", net.JoinHostPort(addr, string(port)))
	u.conn, _ = net.DialUDP("udp", nil, u.addr)
	u.conn.SetReadDeadline(time.Now().Add(u.timeout))
}

func (u *UDPClient) reconnect() {
	if u.conn != nil {
		log.Println("Reconnecting UDP client..")
		u.conn.Close()
		u.create(u.addr.IP.String(), u.addr.Port)
		time.Sleep(u.timeout)
	}
}

func (u *UDPClient) send(command string, data []byte, retry int, sleep time.Duration) ([]byte, error) {
	_, err := u.conn.Write(data)
	if err != nil {
		return nil, err
	}

	buffer := make([]byte, u.mtu)
	for i := 0; i < retry; i++ {
		u.conn.SetReadDeadline(time.Now().Add(u.timeout))
		n, _, err := u.conn.ReadFromUDP(buffer)
		if err == nil && buffer[0] == command[0] {
			return buffer[1:n], nil
		}
		time.Sleep(sleep)
	}
	return nil, err
}

func (u *UDPClient) Once(command string, data interface{}) (interface{}, error) {
	var buf bytes.Buffer
	enc := gob.NewEncoder(&buf)
	err := enc.Encode(data)
	if err != nil {
		return nil, err
	}

	serialized := append([]byte(command), buf.Bytes()...)
	result, err := u.send(command, serialized, 3, 100*time.Microsecond)
	if err != nil {
		return nil, err
	}

	var res interface{}
	dec := gob.NewDecoder(bytes.NewReader(result))
	err = dec.Decode(&res)
	return res, err
}

func (u *UDPClient) Rewind(command string, data interface{}) (interface{}, error) {
	var buf bytes.Buffer
	enc := gob.NewEncoder(&buf)
	err := enc.Encode(data)
	if err != nil {
		return nil, err
	}

	serialized := append([]byte(command), buf.Bytes()...)
	var result []byte
	var res interface{}

	for {
		result, err = u.send(command, serialized, 20, 100*time.Microsecond)
		if err == nil {
			break
		}
		u.reconnect()
		time.Sleep(u.timeout * 2)
	}

	dec := gob.NewDecoder(bytes.NewReader(result))
	err = dec.Decode(&res)
	return res, err
}

이 코드는 UDP 클라이언트를 관리하고, 서버와 데이터를 주고받기 위한 UDPClient 구조체와 그 메서드들을 정의한 Go 패키지입니다. 비전공자도 이해할 수 있도록 각 부분을 설명하겠습니다.

개요

UDPClient는 UDP를 통해 네트워크 통신을 수행하는 클라이언트입니다. 데이터를 서버로 보내고 응답을 받아 처리하는 기능을 제공합니다.

UDPClient 구조체

type UDPClient struct {
    UDPBase
    conn *net.UDPConn  // UDP 연결을 관리하는 포인터
    addr *net.UDPAddr  // 통신할 서버의 주소
}

• UDPBase: UDP 통신에 필요한 기본 설정을 포함하는 구조체를 상속받습니다.

• conn: UDP 연결을 관리하는 포인터입니다.

• addr: 통신할 서버의 주소를 나타냅니다.

NewUDPClient 함수

func NewUDPClient(addr string, port int) *UDPClient {
    client := &UDPClient{
        UDPBase: UDPBase{
            addr:    addr,
            port:    port,
            mtu:     32000,
            timeout: 100 * time.Millisecond,
        },
    }
    client.create(addr, port)
    return client
}

이 함수는 UDPClient의 새로운 인스턴스를 생성하고 초기화합니다. 기본 설정을 통해 UDP 클라이언트를 설정한 후, create 메서드를 호출하여 연결을 만듭니다.

create 메서드

func (u *UDPClient) create(addr string, port int) {
    u.addr, _ = net.ResolveUDPAddr("udp", net.JoinHostPort(addr, string(port)))
    u.conn, _ = net.DialUDP("udp", nil, u.addr)
    u.conn.SetReadDeadline(time.Now().Add(u.timeout))
}

이 메서드는 주어진 주소와 포트로 UDP 연결을 설정합니다. ResolveUDPAddr로 주소를 해결하고, DialUDP로 연결을 만듭니다. 이후 읽기 타임아웃을 설정합니다.

reconnect 메서드

func (u *UDPClient) reconnect() {
    if u.conn != nil {
        log.Println("Reconnecting UDP client..")
        u.conn.Close()
        u.create(u.addr.IP.String(), u.addr.Port)
        time.Sleep(u.timeout)
    }
}

이 메서드는 연결을 재설정합니다. 기존 연결을 닫고, create 메서드를 호출하여 새로운 연결을 만듭니다.

send 메서드

func (u *UDPClient) send(command string, data []byte, retry int, sleep time.Duration) ([]byte, error) {
    _, err := u.conn.Write(data)
    if err != nil {
        return nil, err
    }

    buffer := make([]byte, u.mtu)
    for i := 0; i < retry; i++ {
        u.conn.SetReadDeadline(time.Now().Add(u.timeout))
        n, _, err := u.conn.ReadFromUDP(buffer)
        if err == nil && buffer[0] == command[0] {
            return buffer[1:n], nil
        }
        time.Sleep(sleep)
    }
    return nil, err
}

이 메서드는 데이터를 서버로 보내고, 응답을 기다립니다. 주어진 데이터와 명령어를 보내고, 최대 retry 횟수만큼 재시도합니다. 응답을 성공적으로 받으면 데이터를 반환합니다.

Once 메서드

func (u *UDPClient) Once(command string, data interface{}) (interface{}, error) {
    var buf bytes.Buffer
    enc := gob.NewEncoder(&buf)
    err := enc.Encode(data)
    if err != nil {
        return nil, err
    }

    serialized := append([]byte(command), buf.Bytes()...)
    result, err := u.send(command, serialized, 3, 100*time.Microsecond)
    if err != nil {
        return nil, err
    }

    var res interface{}
    dec := gob.NewDecoder(bytes.NewReader(result))
    err = dec.Decode(&res)
    return res, err
}

이 메서드는 데이터를 서버로 한 번만 보내고 응답을 기다립니다. 주어진 데이터를 직렬화하여 서버로 보내고, 응답을 디코딩하여 반환합니다.

Rewind 메서드

func (u *UDPClient) Rewind(command string, data interface{}) (interface{}, error) {
    var buf bytes.Buffer
    enc := gob.NewEncoder(&buf)
    err := enc.Encode(data)
    if err != nil {
        return nil, err
    }

    serialized := append([]byte(command), buf.Bytes()...)
    var result []byte
    var res interface{}

    for {
        result, err = u.send(command, serialized, 20, 100*time.Microsecond)
        if err == nil {
            break
        }
        u.reconnect()
        time.Sleep(u.timeout * 2)
    }

    dec := gob.NewDecoder(bytes.NewReader(result))
    err = dec.Decode(&res)
    return res, err
}

이 메서드는 데이터를 서버로 반복적으로 보내고, 응답을 받을 때까지 재시도합니다. 재시도 중에 연결이 끊어지면 다시 연결을 설정합니다. 최종적으로 응답을 디코딩하여 반환합니다.

요약

• UDPClient 구조체: UDP를 사용하여 서버와 통신하는 클라이언트를 정의합니다.

• NewUDPClient 함수: 새로운 UDP 클라이언트를 생성하고 초기화합니다.

• create 메서드: 주어진 주소와 포트로 UDP 연결을 설정합니다.

• reconnect 메서드: 연결을 재설정합니다.

• send 메서드: 데이터를 서버로 보내고 응답을 받습니다.

• Once 메서드: 데이터를 한 번만 보내고 응답을 기다립니다.

• Rewind 메서드: 데이터를 반복적으로 보내고 응답을 받을 때까지 재시도합니다.

이렇게 UDP 클라이언트를 설정하고, 데이터를 주고받는 과정을 이해할 수 있습니다.