minio/pkg/server/minhttp/net.go

/*
 * Minimalist Object Storage, (C) 2015 Minio, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package minhttp

import (
	"fmt"
	"net"
	"os"
	"os/exec"
	"strconv"
	"strings"
	"sync"

	"github.com/minio/minio/pkg/iodine"
)

// This package is a fork https://github.com/facebookgo/grace
//
// Re-licensing with Apache License 2.0, with code modifications

// This package provides a family of Listen functions that either open a
// fresh connection or provide an inherited connection from when the process
// was started. This behaves like their counterparts in the net pacakge, but
// transparently provide support for graceful restarts without dropping
// connections. This is provided in a systemd socket activation compatible form
// to allow using socket activation.
//

const (
	// Used to indicate a graceful restart in the new process.
	envCountKey       = "LISTEN_FDS" // similar to systemd SDS_LISTEN_FDS
	envCountKeyPrefix = envCountKey + "="
)

// In order to keep the working directory the same as when we started we record
// it at startup.
var originalWD, _ = os.Getwd()

// minNet provides the family of Listen functions and maintains the associated
// state. Typically you will have only once instance of minNet per application.
type minNet struct {
	inheritedListeners []net.Listener
	activeListeners    []net.Listener
	connLimit          int
	mutex              sync.Mutex
	inheritOnce        sync.Once
}

// minAddr simple wrapper over net.Addr interface to implement IsEqual()
type minAddr struct {
	net.Addr
}

// fileListener simple interface to extract file pointers from different types of net.Listener's
type fileListener interface {
	File() (*os.File, error)
}

// getInheritedListeners - look for LISTEN_FDS in environment variables and populate listeners accordingly
func (n *minNet) getInheritedListeners() error {
	var retErr error
	n.inheritOnce.Do(func() {
		n.mutex.Lock()
		defer n.mutex.Unlock()
		countStr := os.Getenv(envCountKey)
		if countStr == "" {
			return
		}
		count, err := strconv.Atoi(countStr)
		if err != nil {
			retErr = fmt.Errorf("found invalid count value: %s=%s", envCountKey, countStr)
			return
		}

		fdStart := 3
		for i := fdStart; i < fdStart+count; i++ {
			file := os.NewFile(uintptr(i), "listener")
			l, err := net.FileListener(file)
			if err != nil {
				file.Close()
				retErr = iodine.New(fmt.Errorf("error inheriting socket fd %d: %s", i, err), nil)
				return
			}
			if err := file.Close(); err != nil {
				retErr = iodine.New(fmt.Errorf("error closing inherited socket fd %d: %s", i, err), nil)
				return
			}
			n.inheritedListeners = append(n.inheritedListeners, l)
		}
	})
	return iodine.New(retErr, nil)
}

// Listen announces on the local network address laddr. The network net must be
// a stream-oriented network: "tcp", "tcp4", "tcp6", "unix" or "unixpacket". It
// returns an inherited net.Listener for the matching network and address, or
// creates a new one using net.Listen()
func (n *minNet) Listen(nett, laddr string) (net.Listener, error) {
	switch nett {
	default:
		return nil, net.UnknownNetworkError(nett)
	case "tcp", "tcp4", "tcp6":
		addr, err := net.ResolveTCPAddr(nett, laddr)
		if err != nil {
			return nil, iodine.New(err, nil)
		}
		return n.ListenTCP(nett, addr)
	case "unix", "unixpacket":
		addr, err := net.ResolveUnixAddr(nett, laddr)
		if err != nil {
			return nil, iodine.New(err, nil)
		}
		return n.ListenUnix(nett, addr)
	}
}

// ListenTCP announces on the local network address laddr. The network net must
// be: "tcp", "tcp4" or "tcp6". It returns an inherited net.Listener for the
// matching network and address, or creates a new one using net.ListenTCP.
func (n *minNet) ListenTCP(nett string, laddr *net.TCPAddr) (net.Listener, error) {
	var err error
	if err := n.getInheritedListeners(); err != nil {
		return nil, iodine.New(err, nil)
	}

	n.mutex.Lock()
	defer n.mutex.Unlock()

	// look for an inherited listener
	for i, l := range n.inheritedListeners {
		if l == nil { // we nil used inherited listeners
			continue
		}
		equal := minAddr{l.Addr()}.IsEqual(laddr)
		if equal {
			n.inheritedListeners[i] = nil
			n.activeListeners = append(n.activeListeners, l)
			return l.(*net.TCPListener), nil
		}
	}

	var l net.Listener
	// make a fresh listener
	l, err = net.ListenTCP(nett, laddr)
	if err != nil {
		return nil, iodine.New(err, nil)
	}
	n.activeListeners = append(n.activeListeners, rateLimitedListener(l, n.connLimit))
	return l, nil
}

// ListenUnix announces on the local network address laddr. The network net
// must be a: "unix" or "unixpacket". It returns an inherited net.Listener for
// the matching network and address, or creates a new one using net.ListenUnix.
func (n *minNet) ListenUnix(nett string, laddr *net.UnixAddr) (net.Listener, error) {
	var err error
	if err := n.getInheritedListeners(); err != nil {
		return nil, iodine.New(err, nil)
	}

	n.mutex.Lock()
	defer n.mutex.Unlock()

	// look for an inherited listener
	for i, l := range n.inheritedListeners {
		if l == nil { // we nil used inherited listeners
			continue
		}
		equal := minAddr{l.Addr()}.IsEqual(laddr)
		if equal {
			n.inheritedListeners[i] = nil
			n.activeListeners = append(n.activeListeners, l)
			return l.(*net.UnixListener), nil
		}
	}

	var l net.Listener
	// make a fresh listener
	l, err = net.ListenUnix(nett, laddr)
	if err != nil {
		return nil, iodine.New(err, nil)
	}
	n.activeListeners = append(n.activeListeners, rateLimitedListener(l, n.connLimit))
	return l, nil
}

// activeListeners returns a snapshot copy of the active listeners.
func (n *minNet) getActiveListeners() ([]net.Listener, error) {
	n.mutex.Lock()
	defer n.mutex.Unlock()
	ls := make([]net.Listener, len(n.activeListeners))
	copy(ls, n.activeListeners)
	return ls, nil
}

// IsEqual is synonymous with IP.IsEqual() method, here IsEqual matches net.Addr instead of net.IP
func (n1 minAddr) IsEqual(n2 net.Addr) bool {
	if n1.Network() != n2.Network() {
		return false
	}
	a1h, a1p, _ := net.SplitHostPort(n1.String())
	a2h, a2p, _ := net.SplitHostPort(n2.String())
	// Special cases since Addr() from net.Listener will
	// add frivolous [::] ipv6 for no ":[PORT]" style addresses
	if a1h == "::" && a2h == "" && a1p == a2p {
		return true
	}
	if a2h == "::" && a1h == "" && a1p == a2p {
		return true
	}
	if net.ParseIP(a1h).Equal(net.ParseIP(a2h)) && a1p == a2p {
		return true
	}
	return false
}

// StartProcess starts a new process passing it the active listeners. It
// doesn't fork, but starts a new process using the same environment and
// arguments as when it was originally started. This allows for a newly
// deployed binary to be started. It returns the pid of the newly started
// process when successful.
func (n *minNet) StartProcess() (int, error) {
	listeners, err := n.getActiveListeners()
	if err != nil {
		return 0, iodine.New(err, nil)
	}

	// Extract the fds from the listeners.
	files := make([]*os.File, len(listeners))
	for i, l := range listeners {
		files[i], err = l.(fileListener).File()
		if err != nil {
			return 0, iodine.New(err, nil)
		}
		defer files[i].Close()
	}

	// Use the original binary location. This works with symlinks such that if
	// the file it points to has been changed we will use the updated symlink.
	argv0, err := exec.LookPath(os.Args[0])
	if err != nil {
		return 0, iodine.New(err, nil)
	}

	// Pass on the environment and replace the old count key with the new one.
	var env []string
	for _, v := range os.Environ() {
		if !strings.HasPrefix(v, envCountKeyPrefix) {
			env = append(env, v)
		}
	}
	env = append(env, fmt.Sprintf("%s%d", envCountKeyPrefix, len(listeners)))

	allFiles := append([]*os.File{os.Stdin, os.Stdout, os.Stderr}, files...)
	process, err := os.StartProcess(argv0, os.Args, &os.ProcAttr{
		Dir:   originalWD,
		Env:   env,
		Files: allFiles,
	})
	if err != nil {
		return 0, iodine.New(err, nil)
	}
	return process.Pid, nil
}