dotcloud/docker

package networkdb

import (
    "context"
    "fmt"

    "github.com/containerd/log"
    "github.com/hashicorp/memberlist"
)

type nodeState int

const (
    nodeNotFound    nodeState = -1
    nodeActiveState nodeState = 0
    nodeLeftState   nodeState = 1
    nodeFailedState nodeState = 2
)

var nodeStateName = map[nodeState]string{
    -1: "NodeNotFound",
    0:  "NodeActive",
    1:  "NodeLeft",
    2:  "NodeFailed",
}

// findNode search the node into the 3 node lists and returns the node pointer and the list
// where it got found
func (nDB *NetworkDB) findNode(nodeName string) (*node, nodeState, map[string]*node) {
    for i, nodes := range []map[string]*node{
        nDB.nodes,
        nDB.leftNodes,
        nDB.failedNodes,
    } {
        if n, ok := nodes[nodeName]; ok {
            return n, nodeState(i), nodes
        }
    }
    return nil, nodeNotFound, nil
}

// changeNodeState changes the state of the node specified, returns true if the node was moved,
// false if there was no need to change the node state. Error will be returned if the node does not
// exists
func (nDB *NetworkDB) changeNodeState(nodeName string, newState nodeState) (bool, error) {
    n, currState, m := nDB.findNode(nodeName)
    if n == nil {
        return false, fmt.Errorf("node %s not found", nodeName)
    }

    switch newState {
    case nodeActiveState:
        if currState == nodeActiveState {
            return false, nil
        }

        delete(m, nodeName)
        // reset the node reap time
        n.reapTime = 0
        nDB.nodes[nodeName] = n
    case nodeLeftState:
        if currState == nodeLeftState {
            return false, nil
        }

        delete(m, nodeName)
        nDB.leftNodes[nodeName] = n
    case nodeFailedState:
        if currState == nodeFailedState {
            return false, nil
        }

        delete(m, nodeName)
        nDB.failedNodes[nodeName] = n
    }

    log.G(context.TODO()).Infof("Node %s change state %s --> %s", nodeName, nodeStateName[currState], nodeStateName[newState])

    if newState == nodeLeftState || newState == nodeFailedState {
        // set the node reap time, if not already set
        // It is possible that a node passes from failed to left and the reaptime was already set so keep that value
        if n.reapTime == 0 {
            n.reapTime = nodeReapInterval
        }
        // The node leave or fails, delete all the entries created by it.
        // If the node was temporary down, deleting the entries will guarantee that the CREATE events will be accepted
        // If the node instead left because was going down, then it makes sense to just delete all its state
        nDB.deleteNodeFromNetworks(n.Name)
        nDB.deleteNodeTableEntries(n.Name)
    }

    return true, nil
}

func (nDB *NetworkDB) purgeReincarnation(mn *memberlist.Node) bool {
    for name, node := range nDB.nodes {
        if node.Addr.Equal(mn.Addr) && node.Port == mn.Port && mn.Name != name {
            log.G(context.TODO()).Infof("Node %s/%s, is the new incarnation of the active node %s/%s", mn.Name, mn.Addr, name, node.Addr)
            nDB.changeNodeState(name, nodeLeftState)
            return true
        }
    }

    for name, node := range nDB.failedNodes {
        if node.Addr.Equal(mn.Addr) && node.Port == mn.Port && mn.Name != name {
            log.G(context.TODO()).Infof("Node %s/%s, is the new incarnation of the failed node %s/%s", mn.Name, mn.Addr, name, node.Addr)
            nDB.changeNodeState(name, nodeLeftState)
            return true
        }
    }

    for name, node := range nDB.leftNodes {
        if node.Addr.Equal(mn.Addr) && node.Port == mn.Port && mn.Name != name {
            log.G(context.TODO()).Infof("Node %s/%s, is the new incarnation of the shutdown node %s/%s", mn.Name, mn.Addr, name, node.Addr)
            nDB.changeNodeState(name, nodeLeftState)
            return true
        }
    }

    return false
}