tcp

package module
Version: v0.0.0-...-00eab0a Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Nov 12, 2019 License: MIT Imports: 11 Imported by: 12

README

TCP Checker 💓

Go Report Card GoDoc Build Status

This package is used to perform TCP handshake without ACK, which useful for TCP health checking.

HAProxy does this exactly the same, which is:

  1. SYN
  2. SYN-ACK
  3. RST

This implementation has been running on tens of thousands of production servers for years.

Why do I have to do this

In most cases when you establish a TCP connection(e.g. via net.Dial), these are the first three packets between the client and server(TCP three-way handshake):

  1. Client -> Server: SYN
  2. Server -> Client: SYN-ACK
  3. Client -> Server: ACK

This package tries to avoid the last ACK when doing handshakes.

By sending the last ACK, the connection is considered established.

However, as for TCP health checking the server could be considered alive right after it sends back SYN-ACK,

that renders the last ACK unnecessary or even harmful in some cases.

Benefits

By avoiding the last ACK

  1. Less packets better efficiency
  2. The health checking is less obvious

The second one is essential because it bothers the server less.

This means the application level server will not notice the health checking traffic at all, thus the act of health checking will not be considered as some misbehavior of client.

Requirements

  • Linux 2.4 or newer

There is a fake implementation for non-Linux platform which is equivalent to:

conn, err := net.DialTimeout("tcp", addr, timeout)
conn.Close()

Usage

import "github.com/tevino/tcp-shaker"

c := NewChecker()

ctx, stopChecker := context.WithCancel(context.Background())
defer stopChecker()
go func() {
	if err := c.CheckingLoop(ctx); err != nil {
		fmt.Println("checking loop stopped due to fatal error: ", err)
	}
}()

<-c.WaitReady()

timeout := time.Second * 1
err := c.CheckAddr("google.com:80", timeout)
switch err {
case ErrTimeout:
	fmt.Println("Connect to Google timed out")
case nil:
	fmt.Println("Connect to Google succeeded")
default:
	fmt.Println("Error occurred while connecting: ", err)
}

TODO

  • IPv6 support (Test environment needed, PRs are welcome)

Special thanks to contributors

  • @lujjjh Added zero linger support for non-Linux platform
  • @jakubgs Fixed compatibility on Android

Documentation

Overview

Package tcp is used to perform TCP handshake without ACK, which useful for TCP health checking. HAProxy does this exactly the same, which is:

1. SYN
2. SYN-ACK
3. RST

Why do I have to do this

In most cases when you establish a TCP connection(e.g. via net.Dial), these are the first three packets between the client and server(TCP three-way handshake):

1. Client -> Server: SYN
2. Server -> Client: SYN-ACK
3. Client -> Server: ACK

This package tries to avoid the last ACK when doing handshakes.

By sending the last ACK, the connection is considered established.

However, as for TCP health checking the server could be considered alive right after it sends back SYN-ACK, that renders the last ACK unnecessary or even harmful in some cases.

Benefits

By avoiding the last ACK

1. Less packets better efficiency
2. The health checking is less obvious

The second one is essential because it bothers the server less.

This means the application level server will not notice the health checking traffic at all, thus the act of health checking will not be considered as some misbehavior of client.

Index

Examples

Constants

This section is empty.

Variables

View Source
var ErrCheckerAlreadyStarted = errors.New("Checker was already started")

ErrCheckerAlreadyStarted indicates there is another instance of CheckingLoop running.

View Source
var ErrTimeout = &timeoutError{}

ErrTimeout indicates I/O timeout

Functions

This section is empty.

Types

type Checker

type Checker struct {
	// contains filtered or unexported fields
}

Checker contains an epoll instance for TCP handshake checking

Example
c := NewChecker()

ctx, stopChecker := context.WithCancel(context.Background())
defer stopChecker()
go func() {
	if err := c.CheckingLoop(ctx); err != nil {
		fmt.Println("checking loop stopped due to fatal error: ", err)
	}
}()

<-c.WaitReady()

timeout := time.Second * 1
err := c.CheckAddr("google.com:80", timeout)
switch err {
case ErrTimeout:
	fmt.Println("Connect to Google timed out")
case nil:
	fmt.Println("Connect to Google succeeded")
default:
	fmt.Println("Error occurred while connecting: ", err)
}
Output:

func NewChecker

func NewChecker() *Checker

NewChecker creates a Checker with linger set to zero.

func NewCheckerZeroLinger

func NewCheckerZeroLinger(zeroLinger bool) *Checker

NewCheckerZeroLinger creates a Checker with zeroLinger set to given value.

func (*Checker) CheckAddr

func (c *Checker) CheckAddr(addr string, timeout time.Duration) (err error)

CheckAddr performs a TCP check with given TCP address and timeout A successful check will result in nil error ErrTimeout is returned if timeout zeroLinger is an optional parameter indicating if linger should be set to zero for this particular connection Note: timeout includes domain resolving

func (*Checker) CheckAddrZeroLinger

func (c *Checker) CheckAddrZeroLinger(addr string, timeout time.Duration, zeroLinger bool) error

CheckAddrZeroLinger is like CheckAddr with an extra parameter indicating whether to enable zero linger.

func (*Checker) CheckingLoop

func (c *Checker) CheckingLoop(ctx context.Context) error

CheckingLoop must be called before anything else. NOTE: this function blocks until ctx got canceled.

func (*Checker) IsReady

func (c *Checker) IsReady() bool

IsReady returns a bool indicates whether the Checker is ready for use

func (*Checker) PollerFd

func (c *Checker) PollerFd() int

PollerFd returns the inner fd of poller instance. NOTE: Use this only when you really know what you are doing.

func (*Checker) WaitReady

func (c *Checker) WaitReady() <-chan struct{}

WaitReady returns a chan which is closed when the Checker is ready for use.

type ErrConnect

type ErrConnect struct {
	// contains filtered or unexported fields
}

ErrConnect is an error occurs while connecting to the host To get the detail of underlying error, lookup ErrorCode() in 'man 2 connect'

Directories

Path Synopsis
app

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL