func handleContainerStop(netPlugin *plugin.NetPlugin, crt *crt.CRT, opts *cliOpts,
	contID string) error {
	// If CONTIV_DIND_HOST_GOPATH env variable is set we can assume we are in docker in docker testbed
	// Here we need to set the network namespace of the ports created by netplugin back to NS of the docker host
	hostGoPath := os.Getenv("CONTIV_DIND_HOST_GOPATH")
	if hostGoPath != "" {
		osCmd := exec.Command("github.com/contiv/netplugin/scripts/dockerhost/setlocalns.sh")
		osCmd.Dir = os.Getenv("GOSRC")
		output, err := osCmd.Output()
		if err != nil {
			log.Errorf("setlocalns failed. Error: %s Output: \n%s\n",
				err, output)
			return err
		}
		return err
	}

	if opts.forceDeleteEp {
		log.Infof("deleting operEp for container with uuid %s \n", contID)
		epIDs, err := getEpIDByContainerUUID(netPlugin, contID)
		if err != nil {
			log.Errorf("error obtaining container's epid for uuid %s: %v \n", contID, err)
			return err
		}
		for _, epID := range epIDs {
			err = netPlugin.DeleteEndpoint(epID)
			if err != nil {
				log.Errorf("error deleting an endpoint upon container stop: %v \n", err)
				return err
			}
		}
	}

	return nil
}

// delete master node
func deleteMaster(netplugin *plugin.NetPlugin, srvInfo core.ServiceInfo) error {
	// delete from the db
	delete(masterDB, masterKey(srvInfo))

	// tel plugin about it
	return netplugin.DeleteMaster(srvInfo)
}

func createContainerEpOper(netPlugin *plugin.NetPlugin, contUUID, contName string) error {
	epIDs, err := getEpIDByContainerName(netPlugin, contName)
	if err != nil {
		log.Debugf("unable to find ep for container %s, error %v\n", contName, err)
		return err
	}

	for _, epID := range epIDs {
		operEp := &drivers.OvsOperEndpointState{}
		operEp.StateDriver = netPlugin.StateDriver
		err = operEp.Read(epID)
		if core.ErrIfKeyExists(err) != nil {
			return err
		}

		if err == nil {
			operEp.ContUUID = contUUID
			err = operEp.Write()
			if err != nil {
				log.Errorf("error updating oper state for ep %s \n", contName)
				return err
			}

			log.Infof("updating container '%s' with id '%s' \n", contName, contUUID)
		} else {
			err = netPlugin.CreateEndpoint(epID)
			if err != nil {
				log.Errorf("Endpoint creation failed. Error: %s", err)
				return err
			}
			log.Infof("Endpoint operation create succeeded")
		}
	}
	return err
}

// Add a master node
func addMaster(netplugin *plugin.NetPlugin, srvInfo core.ServiceInfo) error {
	// save it in db
	masterDB[masterKey(srvInfo)] = &srvInfo

	// tell the plugin about the master
	return netplugin.AddMaster(srvInfo)
}

func processPeerEvent(netPlugin *plugin.NetPlugin, opts cliOpts, peerID string, isDelete bool) (err error) {
	// if this is our own peer info coming back to us, ignore it
	if peerID == opts.hostLabel {
		return nil
	}

	// take a lock to ensure we are programming one event at a time.
	netPlugin.Lock()
	defer func() { netPlugin.Unlock() }()

	operStr := ""
	if isDelete {
		err = netPlugin.DeletePeerHost(peerID)
		operStr = "delete"
	} else {
		err = netPlugin.CreatePeerHost(peerID)
		operStr = "create"
	}
	if err != nil {
		log.Errorf("PeerHost operation %s failed. Error: %s", operStr, err)
	} else {
		log.Infof("PeerHost operation %s succeeded", operStr)
	}

	return
}

func processNetEvent(netPlugin *plugin.NetPlugin, netID string,
	isDelete bool) (err error) {
	// take a lock to ensure we are programming one event at a time.
	// Also network create events need to be processed before endpoint creates
	// and reverse shall happen for deletes. That order is ensured by netmaster,
	// so we don't need to worry about that here
	netPlugin.Lock()
	defer func() { netPlugin.Unlock() }()

	operStr := ""
	if isDelete {
		err = netPlugin.DeleteNetwork(netID)
		operStr = "delete"
	} else {
		err = netPlugin.CreateNetwork(netID)
		operStr = "create"
	}
	if err != nil {
		log.Errorf("Network operation %s failed. Error: %s", operStr, err)
	} else {
		log.Infof("Network operation %s succeeded", operStr)
	}

	return
}

func processPeerEvent(netPlugin *plugin.NetPlugin, opts cliOpts,
	peerInfo *drivers.PeerHostState, isDelete bool) (err error) {

	// if this is our own peer info coming back to us, ignore it
	if peerInfo.ID == opts.hostLabel {
		return nil
	}

	nodeInfo := core.ServiceInfo{
		HostAddr: peerInfo.HostAddr,
		Port:     0,
	}

	// take a lock to ensure we are programming one event at a time.
	netPlugin.Lock()
	defer func() { netPlugin.Unlock() }()

	operStr := ""
	if isDelete {
		err = netPlugin.DeletePeerHost(nodeInfo)
		operStr = "delete"
	} else {
		err = netPlugin.AddPeerHost(nodeInfo)
		operStr = "create"
	}
	if err != nil {
		log.Errorf("PeerHost operation %s failed. Error: %s", operStr, err)
	} else {
		log.Infof("PeerHost operation %s succeeded", operStr)
	}

	return
}

// Main loop to discover peer hosts and masters
func peerDiscoveryLoop(netplugin *plugin.NetPlugin, objdbClient objdb.ObjdbApi) {
	// Create channels for watch thread
	nodeEventCh := make(chan objdb.WatchServiceEvent, 1)
	watchStopCh := make(chan bool, 1)
	masterEventCh := make(chan objdb.WatchServiceEvent, 1)
	masterWatchStopCh := make(chan bool, 1)

	// Get the local address
	localIP, err := objdbClient.GetLocalAddr()
	if err != nil {
		log.Fatalf("Error getting locla IP address. Err: %v", err)
	}

	// Start a watch on netplugin service so that we dont miss any
	err = objdbClient.WatchService("netplugin", nodeEventCh, watchStopCh)
	if err != nil {
		log.Fatalf("Could not start a watch on netplugin service. Err: %v", err)
	}

	// Start a watch on netmaster too
	err = objdbClient.WatchService("netmaster", masterEventCh, masterWatchStopCh)
	if err != nil {
		log.Fatalf("Could not start a watch on netmaster service. Err: %v", err)
	}

	// Get a list of all existing netplugin nodes
	nodeList, err := objdbClient.GetService("netplugin")
	if err != nil {
		log.Errorf("Error getting node list from objdb. Err: %v", err)
	}

	log.Infof("Got netplugin service list: %+v", nodeList)

	// walk each node and add it as a PeerHost
	for _, node := range nodeList {
		// Ignore if its our own info
		if node.HostAddr == localIP {
			continue
		}
		// add the node
		err := netplugin.AddPeerHost(core.ServiceInfo{
			HostAddr: node.HostAddr,
			Port:     ofnet.OFNET_AGENT_PORT,
		})
		if err != nil {
			log.Errorf("Error adding node {%+v}. Err: %v", node, err)
		}
	}

	// Get a list of all existing netmasters
	masterList, err := objdbClient.GetService("netmaster")
	if err != nil {
		log.Errorf("Error getting master list from objdb. Err: %v", err)
	}

	log.Infof("Got netmaster service list: %+v", masterList)

	// Walk each master and add it
	for _, master := range masterList {
		// Add the master
		err := netplugin.AddMaster(core.ServiceInfo{
			HostAddr: master.HostAddr,
			Port:     ofnet.OFNET_MASTER_PORT,
		})
		if err != nil {
			log.Errorf("Error adding master {%+v}. Err: %v", master, err)
		}
	}

	for {
		select {
		case srvEvent := <-nodeEventCh:
			log.Infof("Received netplugin service watch event: %+v", srvEvent)

			// collect the info about the node
			nodeInfo := srvEvent.ServiceInfo

			// check if its our on info coming back to us
			if nodeInfo.HostAddr == localIP {
				break
			}

			// Handle based on event type
			if srvEvent.EventType == objdb.WatchServiceEventAdd {
				log.Infof("Node add event for {%+v}", nodeInfo)

				// add the node
				err := netplugin.AddPeerHost(core.ServiceInfo{
					HostAddr: nodeInfo.HostAddr,
					Port:     ofnet.OFNET_AGENT_PORT,
				})
				if err != nil {
					log.Errorf("Error adding node {%+v}. Err: %v", nodeInfo, err)
				}
			} else if srvEvent.EventType == objdb.WatchServiceEventDel {
				log.Infof("Node delete event for {%+v}", nodeInfo)

				// remove the node
				err := netplugin.DeletePeerHost(core.ServiceInfo{
//.........这里部分代码省略.........

func processEpEvent(netPlugin *plugin.NetPlugin, crt *crt.CRT, opts cliOpts,
	epID string, isDelete bool) (err error) {
	// take a lock to ensure we are programming one event at a time.
	// Also network create events need to be processed before endpoint creates
	// and reverse shall happen for deletes. That order is ensured by netmaster,
	// so we don't need to worry about that here
	netPlugin.Lock()
	defer func() { netPlugin.Unlock() }()

	homingHost := ""
	vtepIP := ""

	if !isDelete {
		epCfg := &drivers.OvsCfgEndpointState{}
		epCfg.StateDriver = netPlugin.StateDriver
		err = epCfg.Read(epID)
		if err != nil {
			log.Errorf("Failed to read config for ep '%s' \n", epID)
			return
		}
		homingHost = epCfg.HomingHost
		vtepIP = epCfg.VtepIP
	} else {
		epOper := &drivers.OvsOperEndpointState{}
		epOper.StateDriver = netPlugin.StateDriver
		err = epOper.Read(epID)
		if err != nil {
			log.Errorf("Failed to read oper for ep %s, err '%s' \n", epID, err)
			return
		}
		homingHost = epOper.HomingHost
		vtepIP = epOper.VtepIP
	}
	if skipHost(vtepIP, homingHost, opts.hostLabel) {
		log.Infof("skipping mismatching host for ep %s. EP's host %s (my host: %s)",
			epID, homingHost, opts.hostLabel)
		return
	}

	// read the context before to be compared with what changed after
	contEpContext, err := getEndpointContainerContext(
		netPlugin.StateDriver, epID)
	if err != nil {
		log.Errorf("Failed to obtain the container context for ep '%s' \n",
			epID)
		return
	}

	log.Debugf("read endpoint context: %s \n", contEpContext)

	operStr := ""
	if isDelete {
		err = netPlugin.DeleteEndpoint(epID)
		operStr = "delete"
	} else {
		err = netPlugin.CreateEndpoint(epID)
		operStr = "create"
	}
	if err != nil {
		log.Errorf("Endpoint operation %s failed. Error: %s",
			operStr, err)
		return
	}

	log.Infof("Endpoint operation %s succeeded", operStr)

	// attach or detach an endpoint to a container
	if isDelete || contAttachPointDeleted(contEpContext) {
		err = crt.ContainerIf.DetachEndpoint(contEpContext)
		if err != nil {
			log.Errorf("Endpoint detach container '%s' from ep '%s' failed . "+
				"Error: %s", contEpContext.CurrContName, epID, err)
		} else {
			log.Infof("Endpoint detach container '%s' from ep '%s' succeeded",
				contEpContext.CurrContName, epID)
		}
	}
	if !isDelete && contAttachPointAdded(contEpContext) {
		// re-read post ep updated state
		newContEpContext, err1 := getEndpointContainerContext(
			netPlugin.StateDriver, epID)
		if err1 != nil {
			log.Errorf("Failed to obtain the container context for ep '%s' \n", epID)
			return
		}
		contEpContext.InterfaceID = newContEpContext.InterfaceID
		contEpContext.IPAddress = newContEpContext.IPAddress
		contEpContext.SubnetLen = newContEpContext.SubnetLen

		err = crt.ContainerIf.AttachEndpoint(contEpContext)
		if err != nil {
			log.Errorf("Endpoint attach container '%s' to ep '%s' failed . "+
				"Error: %s", contEpContext.NewContName, epID, err)
		} else {
			log.Infof("Endpoint attach container '%s' to ep '%s' succeeded",
				contEpContext.NewContName, epID)
		}
		contID := crt.ContainerIf.GetContainerID(contEpContext.NewContName)
		if contID != "" {
		}
//.........这里部分代码省略.........