Let's read the GO source code #1 dial.go
Dial.go는 네트워크의 연결 설정을 위한 코드입니다.
변수, 함수별로 끊어서 분석을 해보도록 하겠습니다.
const (
defaultTCPKeepAliveIdle = 15 * time.Second
defaultTCPKeepAliveInterval = 15 * time.Second
defaultTCPKeepAliveCount = 9
defaultMPTCPEnabledListen = true
defaultMPTCPEnabledDial = false
)
defaultTCPKeepAliveIdle: TCP 연결이 비활성 상태일 때 초기 Idle 시간입니다.
defaultTCPKeepAliveInterval: Keep-alive 패킷을 전송하는 간격입니다.
defaultTCPKeepAliveCount: TCP_KEEP_CNT를 통해 시도하는 Keep-alive 패킷 수입니다.
defaultMPTCPEnabledListen: Multipath TCP가 리스너에서 기본적으로 활성화된 상태입니다.
defaultMPTCPEnabledDial: Multipath TCP가 다이얼러에서 비활성화된 상태입니다.
var multipathtcp = godebug.New("multipathtcp")godebug는 디버깅 용도로 사용되는 변수를 설정하는 데 사용됩니다. 이를 통해 Multipath TCP 기능을 활성화할 수 있습니다.
type mptcpStatusDial uint8
const (
mptcpUseDefaultDial mptcpStatusDial = iota
mptcpEnabledDial
mptcpDisabledDial
)mptcpStatusDial: Multipath TCP의 활성화 상태를 나타내는 열거형으로, 3가지 상태(기본값, 활성화, 비활성화)를 가집니다. 이 타입은 Dialer에서 사용됩니다.
iota를 통해 상수의 값을 자동으로 증가시킵니다.
func (m *mptcpStatusDial) get() bool {
switch *m {
case mptcpEnabledDial:
return true
case mptcpDisabledDial:
return false
}
if multipathtcp.Value() == "1" || multipathtcp.Value() == "3" {
multipathtcp.IncNonDefault()
return true
}
return defaultMPTCPEnabledDial
}이 메서드는 현재 MPTCP 상태를 확인하고 반환합니다.
multipathtcp.Value()에 따라 MPTCP의 활성화 여부를 동적으로 결정할 수 있습니다.
func (m *mptcpStatusDial) set(use bool) {
if use {
*m = mptcpEnabledDial
} else {
*m = mptcpDisabledDial
}
}MPTCP 사용 상태를 설정합니다. 매개변수 use가 true이면 MPTCP 활성화, false이면 비활성화합니다.
type mptcpStatusListen uint8
const (
mptcpUseDefaultListen mptcpStatusListen = iota
mptcpEnabledListen
mptcpDisabledListen
)mptcpStatusListen: 서버에서의 Multipath TCP 상태를 나타냅니다. uint8 타입으로 컴퓨터 메모리에서 작고 빠르며 기계어로 쉽게 다룰 수 있어서 효율적입니다.
0: 기본값으로, 시스템에 따라 MPTCP가 활성화됩니다.
1: MPTCP가 활성화된 상태입니다.
2: MPTCP가 비활성화된 상태입니다.
func (m *mptcpStatusListen) get() bool {
switch *m {
case mptcpEnabledListen:
return true
case mptcpDisabledListen:
return false
}
if multipathtcp.Value() == "0" || multipathtcp.Value() == "3" {
multipathtcp.IncNonDefault()
return false
}
return defaultMPTCPEnabledListen
}현재 MPTCP의 상태를 확인하고 반환합니다.
각 상태를 확인하고, 상태가 기본값이라면 시스템 설정 값에 의존합니다. GODEBUG 설정에 따라 활성화 여부를 확인합니다.
func (m *mptcpStatusListen) set(use bool) {
if use {
*m = mptcpEnabledListen
} else {
*m = mptcpDisabledListen
}
}MPTCP 사용 여부를 설정합니다.
매개변수 use가 true일 경우 MPTCP를 활성화하고, false일 경우 비활성화합니다.
// A Dialer contains options for connecting to an address.
//
// The zero value for each field is equivalent to dialing
// without that option. Dialing with the zero value of Dialer
// is therefore equivalent to just calling the [Dial] function.
//
// It is safe to call Dialer's methods concurrently.
type Dialer struct {
// Timeout is the maximum amount of time a dial will wait for
// a connect to complete. If Deadline is also set, it may fail
// earlier.
//
// The default is no timeout.
//
// When using TCP and dialing a host name with multiple IP
// addresses, the timeout may be divided between them.
//
// With or without a timeout, the operating system may impose
// its own earlier timeout. For instance, TCP timeouts are
// often around 3 minutes.
Timeout time.Duration
// Deadline is the absolute point in time after which dials
// will fail. If Timeout is set, it may fail earlier.
// Zero means no deadline, or dependent on the operating system
// as with the Timeout option.
Deadline time.Time
// LocalAddr is the local address to use when dialing an
// address. The address must be of a compatible type for the
// network being dialed.
// If nil, a local address is automatically chosen.
LocalAddr Addr
// DualStack previously enabled RFC 6555 Fast Fallback
// support, also known as "Happy Eyeballs", in which IPv4 is
// tried soon if IPv6 appears to be misconfigured and
// hanging.
//
// Deprecated: Fast Fallback is enabled by default. To
// disable, set FallbackDelay to a negative value.
DualStack bool
// FallbackDelay specifies the length of time to wait before
// spawning a RFC 6555 Fast Fallback connection. That is, this
// is the amount of time to wait for IPv6 to succeed before
// assuming that IPv6 is misconfigured and falling back to
// IPv4.
//
// If zero, a default delay of 300ms is used.
// A negative value disables Fast Fallback support.
FallbackDelay time.Duration
// KeepAlive specifies the interval between keep-alive
// probes for an active network connection.
//
// KeepAlive is ignored if KeepAliveConfig.Enable is true.
//
// If zero, keep-alive probes are sent with a default value
// (currently 15 seconds), if supported by the protocol and operating
// system. Network protocols or operating systems that do
// not support keep-alive ignore this field.
// If negative, keep-alive probes are disabled.
KeepAlive time.Duration
// KeepAliveConfig specifies the keep-alive probe configuration
// for an active network connection, when supported by the
// protocol and operating system.
//
// If KeepAliveConfig.Enable is true, keep-alive probes are enabled.
// If KeepAliveConfig.Enable is false and KeepAlive is negative,
// keep-alive probes are disabled.
KeepAliveConfig KeepAliveConfig
// Resolver optionally specifies an alternate resolver to use.
Resolver *Resolver
// Cancel is an optional channel whose closure indicates that
// the dial should be canceled. Not all types of dials support
// cancellation.
//
// Deprecated: Use DialContext instead.
Cancel <-chan struct{}
// If Control is not nil, it is called after creating the network
// connection but before actually dialing.
//
// Network and address parameters passed to Control function are not
// necessarily the ones passed to Dial. Calling Dial with TCP networks
// will cause the Control function to be called with "tcp4" or "tcp6",
// UDP networks become "udp4" or "udp6", IP networks become "ip4" or "ip6",
// and other known networks are passed as-is.
//
// Control is ignored if ControlContext is not nil.
Control func(network, address string, c syscall.RawConn) error
// If ControlContext is not nil, it is called after creating the network
// connection but before actually dialing.
//
// Network and address parameters passed to ControlContext function are not
// necessarily the ones passed to Dial. Calling Dial with TCP networks
// will cause the ControlContext function to be called with "tcp4" or "tcp6",
// UDP networks become "udp4" or "udp6", IP networks become "ip4" or "ip6",
// and other known networks are passed as-is.
//
// If ControlContext is not nil, Control is ignored.
ControlContext func(ctx context.Context, network, address string, c syscall.RawConn) error
// If mptcpStatus is set to a value allowing Multipath TCP (MPTCP) to be
// used, any call to Dial with "tcp(4|6)" as network will use MPTCP if
// supported by the operating system.
mptcpStatus mptcpStatusDial
}상세한 설명은 위 주석에 모두 포함되어 있습니다만, 줄여서 한 줄로 간단히 표현하자면 Dialer는 네트워크 주소에 연결하기 위한 옵션을 포함하고 있는 구조체입니다.
// dualStack 함수는 FallbackDelay가 0 이상의 값을 가지면 true를 반환합니다.
// 이는 Dual Stack 모드가 활성화되어 있다는 것을 의미합니다. Dual Stack 모드는
// IPv4와 IPv6 모두에서 연결을 시도할 수 있도록 하여 유연성을 제공합니다.
func (d *Dialer) dualStack() bool {
return d.FallbackDelay >= 0
}// minNonzeroTime 함수는 두 개의 시간 값 a와 b를 비교하여 둘 중 코드를 기반한
// 비제로(즉, 0이 아닌) 값을 반환합니다. a가 0이면 b를 반환하며,
// b가 0이거나 a가 b보다 빠르면 a를 반환하고, 그렇지 않으면 b를 반환합니다.
func minNonzeroTime(a, b time.Time) time.Time {
if a.IsZero() {
return b
}
if b.IsZero() || a.Before(b) {
return a
}
return b
}// deadline 함수는 다음의 값 중 가장 이른 것을 반환합니다:
// - 현재 시간에 Timeout을 더한 값
// - Dialer의 Deadline
// - Context의 Deadline
// 만약 Timeout, Deadline 및 Context의 Deadline이 모두 설정되어 있지 않다면, 제로 값을 반환합니다.
func (d *Dialer) deadline(ctx context.Context, now time.Time) (earliest time.Time) {
if d.Timeout != 0 { // 역사적인 이유로 음수 포함(실사용되는지는 모르겠습니다)
earliest = now.Add(d.Timeout)
}
if d, ok := ctx.Deadline(); ok {
earliest = minNonzeroTime(earliest, d)
}
return minNonzeroTime(earliest, d.Deadline)
}
// resolver 함수는 주요 Resolver가 설정되어 있는지 확인하고,
// 설정되어 있다면 그 Resolver를 반환합니다. 설정되어 있지 않다면,
// DefaultResolver를 반환합니다.
func (d *Dialer) resolver() *Resolver {
if d.Resolver != nil {
return d.Resolver
}
return DefaultResolver
}
// partialDeadline 함수는 다수의 주소가 대기하고 있을 때,
// 단일 주소에 사용될 마감 시간을 반환합니다.
func partialDeadline(now, deadline time.Time, addrsRemaining int) (time.Time, error) {
if deadline.IsZero() {
return deadline, nil
}
timeRemaining := deadline.Sub(now)
if timeRemaining <= 0 {
return time.Time{}, errTimeout // 만약 시간이 초과했다면 시간 초과 오류 반환
}
// 남은 주소 수에 따라 시간 균등 분배
timeout := timeRemaining / time.Duration(addrsRemaining)
// 주소당 시간 분배가 너무 짧으면 목록의 끝에서 빼오기
const saneMinimum = 2 * time.Second
if timeout < saneMinimum {
if timeRemaining < saneMinimum {
timeout = timeRemaining
} else {
timeout = saneMinimum
}
}
return now.Add(timeout), nil
}// fallbackDelay 함수는 FallbackDelay가 0보다 큰 경우에는 그 값을 반환하고,
// 그렇지 않으면 기본값인 300ms를 반환합니다.
func (d *Dialer) fallbackDelay() time.Duration {
if d.FallbackDelay > 0 {
return d.FallbackDelay
} else {
return 300 * time.Millisecond
}
}func parseNetwork(ctx context.Context, network string, needsProto bool) (afnet string, proto int, err error) {
i := bytealg.LastIndexByteString(network, ':')
if i < 0 { // no colon
switch network {
case "tcp", "tcp4", "tcp6":
case "udp", "udp4", "udp6":
case "ip", "ip4", "ip6":
if needsProto {
return "", 0, UnknownNetworkError(network)
}
case "unix", "unixgram", "unixpacket":
default:
return "", 0, UnknownNetworkError(network)
}
return network, 0, nil
}
afnet = network[:i]
switch afnet {
case "ip", "ip4", "ip6":
protostr := network[i+1:]
proto, i, ok := dtoi(protostr)
if !ok || i != len(protostr) {
proto, err = lookupProtocol(ctx, protostr)
if err != nil {
return "", 0, err
}
}
return afnet, proto, nil
}
return "", 0, UnknownNetworkError(network)
}
주어진 네트워크 문자열을 해석하여 네트워크 유형(IPv4, IPv6 등) 및 프로토콜 번호를 반환합니다.
ctx: 컨텍스트를 통한 상태 관리.
network: 처리할 네트워크 문자열 (예: "tcp", "udp" 등).
needsProto: 프로토콜이 필요한지 여부를 나타내는 불린 값.
afnet: 네트워크의 기본 형태 (예: tcp, udp).
proto: 프로토콜 번호.
err: 에러 발생 시의 에러 정보.
1. 입력된 네트워크 문자열에서 마지막 콜론(:)의 인덱스를 찾습니다.
2. 콜론이 없을 경우, 지원하는 네트워크 타입인지 확인 후, 올바르지 않으면 UnknownNetworkError를 반환합니다.
3. 네트워크 타입이 올바른 경우, 기본 네트워크 이름(예: "tcp", "udp")을 반환합니다.
4. 콜론이 있는 경우, 문자열을 나누고 프로토콜 번호를 얻으려 노력한 뒤, 필요한 경우 lookupProtocol 함수를 사용합니다.
func (r *Resolver) resolveAddrList(ctx context.Context, op, network, addr string, hint Addr) (addrList, error) {
afnet, _, err := parseNetwork(ctx, network, true)
if err != nil {
return nil, err
}
if op == "dial" && addr == "" {
return nil, errMissingAddress
}
switch afnet {
case "unix", "unixgram", "unixpacket":
addr, err := ResolveUnixAddr(afnet, addr)
if err != nil {
return nil, err
}
if op == "dial" && hint != nil && addr.Network() != hint.Network() {
return nil, &AddrError{Err: "mismatched local address type", Addr: hint.String()}
}
return addrList{addr}, nil
}
addrs, err := r.internetAddrList(ctx, afnet, addr)
if err != nil || op != "dial" || hint == nil {
return addrs, err
}
var (
tcp *TCPAddr
udp *UDPAddr
ip *IPAddr
wildcard bool
)
switch hint := hint.(type) {
case *TCPAddr:
tcp = hint
wildcard = tcp.isWildcard()
case *UDPAddr:
udp = hint
wildcard = udp.isWildcard()
case *IPAddr:
ip = hint
wildcard = ip.isWildcard()
}
naddrs := addrs[:0]
for _, addr := range addrs {
if addr.Network() != hint.Network() {
return nil, &AddrError{Err: "mismatched local address type", Addr: hint.String()}
}
switch addr := addr.(type) {
case *TCPAddr:
if !wildcard && !addr.isWildcard() && !addr.IP.matchAddrFamily(tcp.IP) {
continue
}
naddrs = append(naddrs, addr)
case *UDPAddr:
if !wildcard && !addr.isWildcard() && !addr.IP.matchAddrFamily(udp.IP) {
continue
}
naddrs = append(naddrs, addr)
case *IPAddr:
if !wildcard && !addr.isWildcard() && !addr.IP.matchAddrFamily(ip.IP) {
continue
}
naddrs = append(naddrs, addr)
}
}
if len(naddrs) == 0 {
return nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: hint.String()}
}
return naddrs, nil
}
주어진 네트워크와 주소를 해석하고, 유효한 주소 목록을 반환합니다.
ctx: 컨텍스트를 통한 상태 관리.
op: 현재 작업 (예: "dial", "listen").
network: 처리할 네트워크 문자열.
addr: 해석할 주소 문자열.
hint: 주소 힌트 (옵션).
addrList: 유효한 주소 목록.
error: 에러 발생 시의 에러 정보.
1. parseNetwork 함수를 호출하여 네트워크 타입과 프로토콜 번호를 가져옵니다.
2. 다이얼 작업에서 주소가 비어 있으면 오류를 반환합니다.
3. 지원하는 네트워크 유형에 따라 unix, unixgram, unixpacket일 경우, 해당 주소를 해석합니다.
4. 다이얼링이 아닌 경우, 또는 유효한 주소가 아닌 경우는 모든 주소를 반환합니다.
5. 주소 필터링 단계에서는 입력된 힌트에 맞는 주소만을 목록으로 필터링하여 최종적으로 반환합니다.
// MultipathTCP reports whether MPTCP will be used.
func (d *Dialer) MultipathTCP() bool {
return d.mptcpStatus.get()
}Multipath TCP(MPTCP)가 사용될 것인지 여부를 반환합니다.
MPTCP가 활성화되어 있으면 true, 그렇지 않으면 false를 반환합니다.
이 메서드는 운영 체제가 MPTCP를 지원하는지를 체크하지 않습니다. 단순히 현재 설정된 상태를 반환합니다.
// SetMultipathTCP directs the [Dial] methods to use, or not use, MPTCP.
func (d *Dialer) SetMultipathTCP(use bool) {
d.mptcpStatus.set(use)
}Dial 메서드에서 MPTCP 사용 여부를 설정합니다.
use로 MPTCP 사용 여부를 제어 (true 또는 false).
시스템 기본값이나 GODEBUG 설정을 오버라이드하여 MPTCP를 설정할 수 있습니다. 만약 MPTCP가 사용 불가능하거나 서버가 지원하지 않을 경우, TCP로 대체됩니다.
// Dial connects to the address on the named network.
func Dial(network, address string) (Conn, error) {
var d Dialer
return d.Dial(network, address)
}주어진 네트워크 및 주소로 연결을 시도합니다.
network: (예: "tcp", "udp" 등) 연결할 네트워크 유형.
address: 연결할 주소 (포함되어야 하는 포트 번호 포함).
연결이 성공하면 Conn 객체를, 실패하면 에러를 반환합니다.
Dialer의 기본 설정을 사용하여 호출됩니다. 사용자가 이 설정을 수정할 수 있습니다.
// DialTimeout acts like [Dial] but takes a timeout.
func DialTimeout(network, address string, timeout time.Duration) (Conn, error) {
d := Dialer{Timeout: timeout}
return d.Dial(network, address)
}Dial의 타임아웃 기능을 추가하여 연결을 시도합니다.
network: 연결할 네트워크 유형.
address: 연결할 주소.
timeout: 연결 타임아웃 설정 (Duration 타입).
연결이 성공하면 Conn 객체를 반환하고, 실패하면 에러를 반환합니다.
type sysDialer struct {
Dialer
network, address string
testHookDialTCP func(ctx context.Context, net string, laddr, raddr *TCPAddr) (*TCPConn, error)
}Dialer: sysDialer는 Dialer 구조체를 임베딩하고 있는데 sysDialer가 Dialer의 모든 메서드와 필드를 상속받는다는 의미입니다.
network, address: 연결할 네트워크 종류와 주소를 저장하는 필드입니다. testHookDialTCP: 테스트를 위한 훅(hook) 함수로, TCP 연결을 시뮬레이트하거나 테스트할 때 사용됩니다.
func (d *Dialer) Dial(network, address string) (Conn, error) {
return d.DialContext(context.Background(), network, address)
}Dial: network와 address를 인자로 받아 네트워크 연결을 시도합니다.
내부적으로 DialContext를 호출하며, context.Background()를 사용하여 기본 컨텍스트를 제공합니다.
context.Background(): 기본 컨텍스트로, 시간 제한이나 취소 기능이 없는 컨텍스트입니다.
func (d *Dialer) DialContext(ctx context.Context, network, address string) (Conn, error) {
if ctx == nil {
panic("nil context")
}
deadline := d.deadline(ctx, time.Now())
if !deadline.IsZero() {
testHookStepTime()
if d, ok := ctx.Deadline(); !ok || deadline.Before(d) {
subCtx, cancel := context.WithDeadline(ctx, deadline)
defer cancel()
ctx = subCtx
}
}
if oldCancel := d.Cancel; oldCancel != nil {
subCtx, cancel := context.WithCancel(ctx)
defer cancel()
go func() {
select {
case <-oldCancel:
cancel()
case <-subCtx.Done():
}
}()
ctx = subCtx
}
// Shadow the nettrace (if any) during resolve so Connect events don't fire for DNS lookups.
resolveCtx := ctx
if trace, _ := ctx.Value(nettrace.TraceKey{}).(*nettrace.Trace); trace != nil {
shadow := *trace
shadow.ConnectStart = nil
shadow.ConnectDone = nil
resolveCtx = context.WithValue(resolveCtx, nettrace.TraceKey{}, &shadow)
}
addrs, err := d.resolver().resolveAddrList(resolveCtx, "dial", network, address, d.LocalAddr)
if err != nil {
return nil, &OpError{Op: "dial", Net: network, Source: nil, Addr: nil, Err: err}
}
sd := &sysDialer{
Dialer: *d,
network: network,
address: address,
}
var primaries, fallbacks addrList
if d.dualStack() && network == "tcp" {
primaries, fallbacks = addrs.partition(isIPv4)
} else {
primaries = addrs
}
return sd.dialParallel(ctx, primaries, fallbacks)
}DialContext: context.Context를 사용하여 네트워크 연결을 시도합니다. 컨텍스트는 연결 시도에 대한 시간 제한, 취소 등을 관리합니다.
ctx == nil: 컨텍스트가 nil인 경우 패닉을 발생시킵니다.
deadline: 컨텍스트에서 데드라인을 계산하고, 데드라인이 설정된 경우 서브 컨텍스트를 생성하여 연결 시도 시간을 관리합니다.
oldCancel: 기존의 취소 채널이 있는 경우, 새로운 컨텍스트를 생성하고 기존 취소 채널과 연결합니다.
resolveCtx: DNS 조회 중에 네트워크 추적 이벤트가 발생하지 않도록 컨텍스트를 조정합니다.
addrs: 주소 목록을 조회하고, 조회 중 오류가 발생하면 OpError를 반환합니다. sysDialer: sysDialer 구조체를 생성하고, 네트워크와 주소를 설정합니다.
primaries, fallbacks: 듀얼 스택(IPv4와 IPv6) 지원 여부에 따라 주소 목록을 분할합니다.
dialParallel: 병렬로 여러 주소에 대해 연결을 시도합니다.
func (sd *sysDialer) dialParallel(ctx context.Context, primaries, fallbacks addrList) (Conn, error) {
if len(fallbacks) == 0 {
return sd.dialSerial(ctx, primaries)
}
returned := make(chan struct{})
defer close(returned)
type dialResult struct {
Conn
error
primary bool
done bool
}
results := make(chan dialResult) // unbuffered
startRacer := func(ctx context.Context, primary bool) {
ras := primaries
if !primary {
ras = fallbacks
}
c, err := sd.dialSerial(ctx, ras)
select {
case results <- dialResult{Conn: c, error: err, primary: primary, done: true}:
case <-returned:
if c != nil {
c.Close()
}
}
}
var primary, fallback dialResult
// Start the main racer.
primaryCtx, primaryCancel := context.WithCancel(ctx)
defer primaryCancel()
go startRacer(primaryCtx, true)
// Start the timer for the fallback racer.
fallbackTimer := time.NewTimer(sd.fallbackDelay())
defer fallbackTimer.Stop()
for {
select {
case <-fallbackTimer.C:
fallbackCtx, fallbackCancel := context.WithCancel(ctx)
defer fallbackCancel()
go startRacer(fallbackCtx, false)
case res := <-results:
if res.error == nil {
return res.Conn, nil
}
if res.primary {
primary = res
} else {
fallback = res
}
if primary.done && fallback.done {
return nil, primary.error
}
if res.primary && fallbackTimer.Stop() {
// If we were able to stop the timer, that means it
// was running (hadn't yet started the fallback), but
// we just got an error on the primary path, so start
// the fallback immediately (in 0 nanoseconds).
fallbackTimer.Reset(0)
}
}
}
}dialParallel: 이 함수는 primaries와 fallbacks 두 개의 주소 목록을 받아 병렬로 연결을 시도합니다.
primaries는 주요 주소 목록이고, fallbacks는 대체 주소 목록입니다.
returned: 이 채널은 함수가 반환될 때 닫히며, 이를 통해 연결 시도 중인 고루틴들이 종료되도록 합니다.
dialResult: 연결 결과를 저장하는 구조체로, 연결 객체(Conn), 오류(error), 주요 주소 여부(primary), 완료 여부(done)를 포함합니다.
startRacer: 이 함수는 주어진 컨텍스트와 주소 목록을 사용하여 dialSerial을 호출하고, 결과를 results 채널로 보냅니다. 만약 returned 채널이 닫히면 연결을 닫습니다. primaryCtx, primaryCancel: 주요 주소에 대한 연결 시도를 관리하는 컨텍스트와 취소 함수입니다.
fallbackTimer: 대체 주소에 대한 연결 시도를 시작하기 위한 타이머입니다. for 루프: 이 루프는 타이머 이벤트와 결과 채널 이벤트를 처리합니다. 타이머가 만료되면 대체 주소에 대한 연결 시도를 시작하고, 결과 채널에서 결과를 받아 처리합니다. fallbackTimer.Stop(): 주요 주소 연결 시도가 실패하면 대체 주소 연결 시도를 즉시 시작합니다.
func (sd *sysDialer) dialSerial(ctx context.Context, ras addrList) (Conn, error) {
var firstErr error // The error from the first address is most relevant.
for i, ra := range ras {
select {
case <-ctx.Done():
return nil, &OpError{Op: "dial", Net: sd.network, Source: sd.LocalAddr, Addr: ra, Err: mapErr(ctx.Err())}
default:
}
dialCtx := ctx
if deadline, hasDeadline := ctx.Deadline(); hasDeadline {
partialDeadline, err := partialDeadline(time.Now(), deadline, len(ras)-i)
if err != nil {
// Ran out of time.
if firstErr == nil {
firstErr = &OpError{Op: "dial", Net: sd.network, Source: sd.LocalAddr, Addr: ra, Err: err}
}
break
}
if partialDeadline.Before(deadline) {
var cancel context.CancelFunc
dialCtx, cancel = context.WithDeadline(ctx, partialDeadline)
defer cancel()
}
}
c, err := sd.dialSingle(dialCtx, ra)
if err == nil {
return c, nil
}
if firstErr == nil {
firstErr = err
}
}
if firstErr == nil {
firstErr = &OpError{Op: "dial", Net: sd.network, Source: nil, Addr: nil, Err: errMissingAddress}
}
return nil, firstErr
}(글이 너무 지저분해보여서 글자에 효과를 앞으로 넣도록 하겠습니다..)
dialSerial: 이 함수는 주어진 주소 목록(ras)에 대해 순차적으로 연결을 시도합니다. 첫 번째로 성공한 연결을 반환하거나, 모든 시도가 실패하면 첫 번째 오류를 반환합니다.firstErr: 첫 번째 오류를 저장하는 변수입니다.for루프: 주소 목록을 순회하며 각 주소에 대해 연결을 시도합니다.ctx.Done(): 컨텍스트가 취소되면 연결 시도를 중단하고 오류를 반환합니다.partialDeadline: 각 주소에 대한 부분 데드라인을 계산합니다. 이는 전체 데드라인을 주소 수에 따라 분할하여 각 주소에 할당합니다.dialSingle: 단일 주소에 대해 연결을 시도합니다. 성공하면 연결 객체를 반환하고, 실패하면 오류를 저장합니다.firstErr: 모든 시도가 실패하면 첫 번째 오류를 반환합니다. 만약 오류가 없으면errMissingAddress오류를 반환합니다.
func (sd *sysDialer) dialSingle(ctx context.Context, ra Addr) (c Conn, err error) {
trace, _ := ctx.Value(nettrace.TraceKey{}).(*nettrace.Trace)
if trace != nil {
raStr := ra.String()
if trace.ConnectStart != nil {
trace.ConnectStart(sd.network, raStr)
}
if trace.ConnectDone != nil {
defer func() { trace.ConnectDone(sd.network, raStr, err) }()
}
}
la := sd.LocalAddr
switch ra := ra.(type) {
case *TCPAddr:
la, _ := la.(*TCPAddr)
if sd.MultipathTCP() {
c, err = sd.dialMPTCP(ctx, la, ra)
} else {
c, err = sd.dialTCP(ctx, la, ra)
}
case *UDPAddr:
la, _ := la.(*UDPAddr)
c, err = sd.dialUDP(ctx, la, ra)
case *IPAddr:
la, _ := la.(*IPAddr)
c, err = sd.dialIP(ctx, la, ra)
case *UnixAddr:
la, _ := la.(*UnixAddr)
c, err = sd.dialUnix(ctx, la, ra)
default:
return nil, &OpError{Op: "dial", Net: sd.network, Source: la, Addr: ra, Err: &AddrError{Err: "unexpected address type", Addr: sd.address}}
}
if err != nil {
return nil, &OpError{Op: "dial", Net: sd.network, Source: la, Addr: ra, Err: err} // c is non-nil interface containing nil pointer
}
return c, nil
}dialSingle: 이 함수는 단일 주소(ra)에 대해 네트워크 연결을 시도합니다.trace: 컨텍스트에서 네트워크 추적 정보를 가져와 연결 시작 및 완료 이벤트를 기록합니다.la: 로컬 주소를 저장합니다.switch ra := ra.(type): 주소 타입에 따라 적절한 연결 함수를 호출합니다.*TCPAddr: TCP 주소인 경우dialTCP또는dialMPTCP를 호출합니다.*UDPAddr: UDP 주소인 경우dialUDP를 호출합니다.*IPAddr: IP 주소인 경우dialIP를 호출합니다.*UnixAddr: Unix 도메인 소켓 주소인 경우dialUnix를 호출합니다.default: 지원되지 않는 주소 타입인 경우 오류를 반환합니다.
err: 연결 시도 중 오류가 발생하면OpError를 반환합니다.
type ListenConfig struct {
Control func(network, address string, c syscall.RawConn) error
KeepAlive time.Duration
KeepAliveConfig KeepAliveConfig
mptcpStatus mptcpStatusListen
}Control: 네트워크 연결 생성 후 운영 체제에 바인딩하기 전에 호출되는 함수입니다.KeepAlive: 네트워크 연결의 keep-alive 주기를 지정합니다.KeepAliveConfig: keep-alive 프로브 구성을 지정합니다.mptcpStatus: MPTCP(Multipath TCP) 사용 여부를 저장합니다.
func (lc *ListenConfig) MultipathTCP() bool {
return lc.mptcpStatus.get()
}
func (lc *ListenConfig) SetMultipathTCP(use bool) {
lc.mptcpStatus.set(use)
}MultipathTCP: MPTCP 사용 여부를 반환합니다.SetMultipathTCP: MPTCP 사용 여부를 설정합니다.
func (lc *ListenConfig) Listen(ctx context.Context, network, address string) (Listener, error) {
addrs, err := DefaultResolver.resolveAddrList(ctx, "listen", network, address, nil)
if err != nil {
return nil, &OpError{Op: "listen", Net: network, Source: nil, Addr: nil, Err: err}
}
sl := &sysListener{
ListenConfig: *lc,
network: network,
address: address,
}
var l Listener
la := addrs.first(isIPv4)
switch la := la.(type) {
case *TCPAddr:
if sl.MultipathTCP() {
l, err = sl.listenMPTCP(ctx, la)
} else {
l, err = sl.listenTCP(ctx, la)
}
case *UnixAddr:
l, err = sl.listenUnix(ctx, la)
default:
return nil, &OpError{Op: "listen", Net: sl.network, Source: nil, Addr: la, Err: &AddrError{Err: "unexpected address type", Addr: address}}
}
if err != nil {
return nil, &OpError{Op: "listen", Net: sl.network, Source: nil, Addr: la, Err: err} // l is non-nil interface containing nil pointer
}
return l, nil
}Listen: 이 메서드는 주어진 네트워크와 주소에 대해 리스너를 생성합니다.addrs: 주소 목록을 조회합니다.sl:sysListener구조체를 생성합니다.la: 첫 번째 주소를 가져옵니다.switch la := la.(type): 주소 타입에 따라 적절한 리스너 함수를 호출합니다.*TCPAddr: TCP 주소인 경우listenTCP또는listenMPTCP를 호출합니다.*UnixAddr: Unix 도메인 소켓 주소인 경우listenUnix를 호출합니다.default: 지원되지 않는 주소 타입인 경우 오류를 반환합니다.
err: 리스너 생성 중 오류가 발생하면OpError를 반환합니다.
func (lc *ListenConfig) ListenPacket(ctx context.Context, network, address string) (PacketConn, error) {
addrs, err := DefaultResolver.resolveAddrList(ctx, "listen", network, address, nil)
if err != nil {
return nil, &OpError{Op: "listen", Net: network, Source: nil, Addr: nil, Err: err}
}
sl := &sysListener{
ListenConfig: *lc,
network: network,
address: address,
}
var c PacketConn
la := addrs.first(isIPv4)
switch la := la.(type) {
case *UDPAddr:
c, err = sl.listenUDP(ctx, la)
case *IPAddr:
c, err = sl.listenIP(ctx, la)
case *UnixAddr:
c, err = sl.listenUnixgram(ctx, la)
default:
return nil, &OpError{Op: "listen", Net: sl.network, Source: nil, Addr: la, Err: &AddrError{Err: "unexpected address type", Addr: address}}
}
if err != nil {
return nil, &OpError{Op: "listen", Net: sl.network, Source: nil, Addr: la, Err: err} // c is non-nil interface containing nil pointer
}
return c, nil
}ListenPacket: 이 메서드는 주어진 네트워크와 주소에 대해 패킷 연결을 생성합니다.addrs: 주소 목록을 조회합니다.sl:sysListener구조체를 생성합니다.la: 첫 번째 주소를 가져옵니다.switch la := la.(type): 주소 타입에 따라 적절한 패킷 연결 함수를 호출합니다.*UDPAddr: UDP 주소인 경우listenUDP를 호출합니다.*IPAddr: IP 주소인 경우listenIP를 호출합니다.*UnixAddr: Unix 도메인 소켓 주소인 경우listenUnixgram를 호출합니다.default: 지원되지 않는 주소 타입인 경우 오류를 반환합니다.
err: 패킷 연결 생성 중 오류가 발생하면OpError를 반환합니다.
type sysListener struct {
ListenConfig
network, address string
}sysListener:ListenConfig를 임베딩하고 있으며, 네트워크와 주소를 저장합니다.
func Listen(network, address string) (Listener, error) {
var lc ListenConfig
return lc.Listen(context.Background(), network, address)
}
func ListenPacket(network, address string) (PacketConn, error) {
var lc ListenConfig
return lc.ListenPacket(context.Background(), network, address)
}Listen: 기본ListenConfig를 사용하여 리스너를 생성합니다.ListenPacket: 기본ListenConfig를 사용하여 패킷 연결을 생성합니다.
Go 언어에서 네트워크 연결을 만드는 핵심인 dial.go에 대해서 러프하게 정의들을 분석해보았습니다.
다음에 시간 여유가 생기면 IP 주소를 처리하는 부분인 ip.go를 분석해보겠습니다
감사합니다