Lint on pkg/* packages

- pkg/useragent
- pkg/units
- pkg/ulimit
- pkg/truncindex
- pkg/timeoutconn
- pkg/term
- pkg/tarsum
- pkg/tailfile
- pkg/systemd
- pkg/stringutils
- pkg/stringid
- pkg/streamformatter
- pkg/sockets
- pkg/signal
- pkg/proxy
- pkg/progressreader
- pkg/pools
- pkg/plugins
- pkg/pidfile
- pkg/parsers
- pkg/parsers/filters
- pkg/parsers/kernel
- pkg/parsers/operatingsystem

Signed-off-by: Vincent Demeester <vincent@sbr.pm>

proxy/proxy.go

@@ -1,3 +1,5 @@
+// Package proxy provides a network Proxy interface and implementations for TCP
+// and UDP.
 package proxy
 
 import (
@@ -5,18 +7,24 @@ import (
 	"net"
 )
 
+// Proxy defines the behavior of a proxy. It forwards traffic back and forth
+// between two endpoints : the frontend and the backend.
+// It can be used to do software port-mapping between two addresses.
+// e.g. forward all traffic between the frontend (host) 127.0.0.1:3000
+// to the backend (container) at 172.17.42.108:4000.
 type Proxy interface {
-	// Start forwarding traffic back and forth the front and back-end
-	// addresses.
+	// Run starts forwarding traffic back and forth between the front
+	// and back-end addresses.
 	Run()
-	// Stop forwarding traffic and close both ends of the Proxy.
+	// Close stops forwarding traffic and close both ends of the Proxy.
 	Close()
-	// Return the address on which the proxy is listening.
+	// FrontendAddr returns the address on which the proxy is listening.
 	FrontendAddr() net.Addr
-	// Return the proxied address.
+	// BackendAddr returns the proxied address.
 	BackendAddr() net.Addr
 }
 
+// NewProxy creates a Proxy according to the specified frontendAddr and backendAddr.
 func NewProxy(frontendAddr, backendAddr net.Addr) (Proxy, error) {
 	switch frontendAddr.(type) {
 	case *net.UDPAddr:

proxy/stub_proxy.go

@@ -4,16 +4,25 @@ import (
 	"net"
 )
 
+// StubProxy is a proxy that is a stub (does nothing).
 type StubProxy struct {
 	frontendAddr net.Addr
 	backendAddr  net.Addr
 }
 
-func (p *StubProxy) Run()                   {}
-func (p *StubProxy) Close()                 {}
-func (p *StubProxy) FrontendAddr() net.Addr { return p.frontendAddr }
-func (p *StubProxy) BackendAddr() net.Addr  { return p.backendAddr }
+// Run does nothing.
+func (p *StubProxy) Run() {}
 
+// Close does nothing.
+func (p *StubProxy) Close() {}
+
+// FrontendAddr returns the frontend address.
+func (p *StubProxy) FrontendAddr() net.Addr { return p.frontendAddr }
+
+// BackendAddr returns the backend address.
+func (p *StubProxy) BackendAddr() net.Addr { return p.backendAddr }
+
+// NewStubProxy creates a new StubProxy
 func NewStubProxy(frontendAddr, backendAddr net.Addr) (Proxy, error) {
 	return &StubProxy{
 		frontendAddr: frontendAddr,

proxy/tcp_proxy.go

@@ -8,12 +8,15 @@ import (
 	"github.com/Sirupsen/logrus"
 )
 
+// TCPProxy is a proxy for TCP connections. It implements the Proxy interface to
+// handle TCP traffic forwarding between the frontend and backend addresses.
 type TCPProxy struct {
 	listener     *net.TCPListener
 	frontendAddr *net.TCPAddr
 	backendAddr  *net.TCPAddr
 }
 
+// NewTCPProxy creates a new TCPProxy.
 func NewTCPProxy(frontendAddr, backendAddr *net.TCPAddr) (*TCPProxy, error) {
 	listener, err := net.ListenTCP("tcp", frontendAddr)
 	if err != nil {
@@ -53,7 +56,7 @@ func (proxy *TCPProxy) clientLoop(client *net.TCPConn, quit chan bool) {
 	go broker(client, backend)
 	go broker(backend, client)
 
-	var transferred int64 = 0
+	var transferred int64
 	for i := 0; i < 2; i++ {
 		select {
 		case written := <-event:
@@ -72,6 +75,7 @@ func (proxy *TCPProxy) clientLoop(client *net.TCPConn, quit chan bool) {
 	backend.Close()
 }
 
+// Run starts forwarding the traffic using TCP.
 func (proxy *TCPProxy) Run() {
 	quit := make(chan bool)
 	defer close(quit)
@@ -85,6 +89,11 @@ func (proxy *TCPProxy) Run() {
 	}
 }
 
-func (proxy *TCPProxy) Close()                 { proxy.listener.Close() }
+// Close stops forwarding the traffic.
+func (proxy *TCPProxy) Close() { proxy.listener.Close() }
+
+// FrontendAddr returns the TCP address on which the proxy is listening.
 func (proxy *TCPProxy) FrontendAddr() net.Addr { return proxy.frontendAddr }
-func (proxy *TCPProxy) BackendAddr() net.Addr  { return proxy.backendAddr }
+
+// BackendAddr returns the TCP proxied address.
+func (proxy *TCPProxy) BackendAddr() net.Addr { return proxy.backendAddr }

proxy/udp_proxy.go

@@ -12,8 +12,10 @@ import (
 )
 
 const (
+	// UDPConnTrackTimeout is the timeout used for UDP connection tracking
 	UDPConnTrackTimeout = 90 * time.Second
-	UDPBufSize          = 65507
+	// UDPBufSize is the buffer size for the UDP proxy
+	UDPBufSize = 65507
 )
 
 // A net.Addr where the IP is split into two fields so you can use it as a key
@@ -41,6 +43,9 @@ func newConnTrackKey(addr *net.UDPAddr) *connTrackKey {
 
 type connTrackMap map[connTrackKey]*net.UDPConn
 
+// UDPProxy is proxy for which handles UDP datagrams. It implements the Proxy
+// interface to handle UDP traffic forwarding between the frontend and backend
+// addresses.
 type UDPProxy struct {
 	listener       *net.UDPConn
 	frontendAddr   *net.UDPAddr
@@ -49,6 +54,7 @@ type UDPProxy struct {
 	connTrackLock  sync.Mutex
 }
 
+// NewUDPProxy creates a new UDPProxy.
 func NewUDPProxy(frontendAddr, backendAddr *net.UDPAddr) (*UDPProxy, error) {
 	listener, err := net.ListenUDP("udp", frontendAddr)
 	if err != nil {
@@ -96,6 +102,7 @@ func (proxy *UDPProxy) replyLoop(proxyConn *net.UDPConn, clientAddr *net.UDPAddr
 	}
 }
 
+// Run starts forwarding the traffic using UDP.
 func (proxy *UDPProxy) Run() {
 	readBuf := make([]byte, UDPBufSize)
 	for {
@@ -135,6 +142,7 @@ func (proxy *UDPProxy) Run() {
 	}
 }
 
+// Close stops forwarding the traffic.
 func (proxy *UDPProxy) Close() {
 	proxy.listener.Close()
 	proxy.connTrackLock.Lock()
@@ -144,8 +152,11 @@ func (proxy *UDPProxy) Close() {
 	}
 }
 
+// FrontendAddr returns the UDP address on which the proxy is listening.
 func (proxy *UDPProxy) FrontendAddr() net.Addr { return proxy.frontendAddr }
-func (proxy *UDPProxy) BackendAddr() net.Addr  { return proxy.backendAddr }
+
+// BackendAddr returns the proxied UDP address.
+func (proxy *UDPProxy) BackendAddr() net.Addr { return proxy.backendAddr }
 
 func isClosedError(err error) bool {
 	/* This comparison is ugly, but unfortunately, net.go doesn't export errClosing.