github.com/zhuohuang-hust/src-cbuild@v0.0.0-20230105071821-c7aab3e7c840/mergeCode/libnetwork/drivers/overlay/ov_endpoint.go (about)

     1  package overlay
     2  
     3  import (
     4  	"encoding/json"
     5  	"fmt"
     6  	"net"
     7  
     8  	log "github.com/Sirupsen/logrus"
     9  	"github.com/docker/libnetwork/datastore"
    10  	"github.com/docker/libnetwork/driverapi"
    11  	"github.com/docker/libnetwork/netutils"
    12  	"github.com/docker/libnetwork/ns"
    13  	"github.com/docker/libnetwork/types"
    14  )
    15  
    16  type endpointTable map[string]*endpoint
    17  
    18  const overlayEndpointPrefix = "overlay/endpoint"
    19  
    20  type endpoint struct {
    21  	id       string
    22  	nid      string
    23  	ifName   string
    24  	mac      net.HardwareAddr
    25  	addr     *net.IPNet
    26  	dbExists bool
    27  	dbIndex  uint64
    28  }
    29  
    30  func (n *network) endpoint(eid string) *endpoint {
    31  	n.Lock()
    32  	defer n.Unlock()
    33  
    34  	return n.endpoints[eid]
    35  }
    36  
    37  func (n *network) addEndpoint(ep *endpoint) {
    38  	n.Lock()
    39  	n.endpoints[ep.id] = ep
    40  	n.Unlock()
    41  }
    42  
    43  func (n *network) deleteEndpoint(eid string) {
    44  	n.Lock()
    45  	delete(n.endpoints, eid)
    46  	n.Unlock()
    47  }
    48  
    49  func (d *driver) CreateEndpoint(nid, eid string, ifInfo driverapi.InterfaceInfo,
    50  	epOptions map[string]interface{}) error {
    51  	var err error
    52  
    53  	if err = validateID(nid, eid); err != nil {
    54  		return err
    55  	}
    56  
    57  	// Since we perform lazy configuration make sure we try
    58  	// configuring the driver when we enter CreateEndpoint since
    59  	// CreateNetwork may not be called in every node.
    60  	if err := d.configure(); err != nil {
    61  		return err
    62  	}
    63  
    64  	n := d.network(nid)
    65  	if n == nil {
    66  		return fmt.Errorf("network id %q not found", nid)
    67  	}
    68  
    69  	ep := &endpoint{
    70  		id:   eid,
    71  		nid:  n.id,
    72  		addr: ifInfo.Address(),
    73  		mac:  ifInfo.MacAddress(),
    74  	}
    75  	if ep.addr == nil {
    76  		return fmt.Errorf("create endpoint was not passed interface IP address")
    77  	}
    78  
    79  	if s := n.getSubnetforIP(ep.addr); s == nil {
    80  		return fmt.Errorf("no matching subnet for IP %q in network %q\n", ep.addr, nid)
    81  	}
    82  
    83  	if ep.mac == nil {
    84  		ep.mac = netutils.GenerateMACFromIP(ep.addr.IP)
    85  		if err := ifInfo.SetMacAddress(ep.mac); err != nil {
    86  			return err
    87  		}
    88  	}
    89  
    90  	n.addEndpoint(ep)
    91  
    92  	if err := d.writeEndpointToStore(ep); err != nil {
    93  		return fmt.Errorf("failed to update overlay endpoint %s to local store: %v", ep.id[0:7], err)
    94  	}
    95  
    96  	return nil
    97  }
    98  
    99  func (d *driver) DeleteEndpoint(nid, eid string) error {
   100  	nlh := ns.NlHandle()
   101  
   102  	if err := validateID(nid, eid); err != nil {
   103  		return err
   104  	}
   105  
   106  	n := d.network(nid)
   107  	if n == nil {
   108  		return fmt.Errorf("network id %q not found", nid)
   109  	}
   110  
   111  	ep := n.endpoint(eid)
   112  	if ep == nil {
   113  		return fmt.Errorf("endpoint id %q not found", eid)
   114  	}
   115  
   116  	n.deleteEndpoint(eid)
   117  
   118  	if err := d.deleteEndpointFromStore(ep); err != nil {
   119  		log.Warnf("Failed to delete overlay endpoint %s from local store: %v", ep.id[0:7], err)
   120  	}
   121  
   122  	if ep.ifName == "" {
   123  		return nil
   124  	}
   125  
   126  	link, err := nlh.LinkByName(ep.ifName)
   127  	if err != nil {
   128  		log.Debugf("Failed to retrieve interface (%s)'s link on endpoint (%s) delete: %v", ep.ifName, ep.id, err)
   129  		return nil
   130  	}
   131  	if err := nlh.LinkDel(link); err != nil {
   132  		log.Debugf("Failed to delete interface (%s)'s link on endpoint (%s) delete: %v", ep.ifName, ep.id, err)
   133  	}
   134  
   135  	return nil
   136  }
   137  
   138  func (d *driver) EndpointOperInfo(nid, eid string) (map[string]interface{}, error) {
   139  	return make(map[string]interface{}, 0), nil
   140  }
   141  
   142  func (d *driver) deleteEndpointFromStore(e *endpoint) error {
   143  	if d.localStore == nil {
   144  		return fmt.Errorf("overlay local store not initialized, ep not deleted")
   145  	}
   146  
   147  	if err := d.localStore.DeleteObjectAtomic(e); err != nil {
   148  		return err
   149  	}
   150  
   151  	return nil
   152  }
   153  
   154  func (d *driver) writeEndpointToStore(e *endpoint) error {
   155  	if d.localStore == nil {
   156  		return fmt.Errorf("overlay local store not initialized, ep not added")
   157  	}
   158  
   159  	if err := d.localStore.PutObjectAtomic(e); err != nil {
   160  		return err
   161  	}
   162  	return nil
   163  }
   164  
   165  func (ep *endpoint) DataScope() string {
   166  	return datastore.LocalScope
   167  }
   168  
   169  func (ep *endpoint) New() datastore.KVObject {
   170  	return &endpoint{}
   171  }
   172  
   173  func (ep *endpoint) CopyTo(o datastore.KVObject) error {
   174  	dstep := o.(*endpoint)
   175  	*dstep = *ep
   176  	return nil
   177  }
   178  
   179  func (ep *endpoint) Key() []string {
   180  	return []string{overlayEndpointPrefix, ep.id}
   181  }
   182  
   183  func (ep *endpoint) KeyPrefix() []string {
   184  	return []string{overlayEndpointPrefix}
   185  }
   186  
   187  func (ep *endpoint) Index() uint64 {
   188  	return ep.dbIndex
   189  }
   190  
   191  func (ep *endpoint) SetIndex(index uint64) {
   192  	ep.dbIndex = index
   193  	ep.dbExists = true
   194  }
   195  
   196  func (ep *endpoint) Exists() bool {
   197  	return ep.dbExists
   198  }
   199  
   200  func (ep *endpoint) Skip() bool {
   201  	return false
   202  }
   203  
   204  func (ep *endpoint) Value() []byte {
   205  	b, err := json.Marshal(ep)
   206  	if err != nil {
   207  		return nil
   208  	}
   209  	return b
   210  }
   211  
   212  func (ep *endpoint) SetValue(value []byte) error {
   213  	return json.Unmarshal(value, ep)
   214  }
   215  
   216  func (ep *endpoint) MarshalJSON() ([]byte, error) {
   217  	epMap := make(map[string]interface{})
   218  
   219  	epMap["id"] = ep.id
   220  	epMap["nid"] = ep.nid
   221  	if ep.ifName != "" {
   222  		epMap["ifName"] = ep.ifName
   223  	}
   224  	if ep.addr != nil {
   225  		epMap["addr"] = ep.addr.String()
   226  	}
   227  	if len(ep.mac) != 0 {
   228  		epMap["mac"] = ep.mac.String()
   229  	}
   230  
   231  	return json.Marshal(epMap)
   232  }
   233  
   234  func (ep *endpoint) UnmarshalJSON(value []byte) error {
   235  	var (
   236  		err   error
   237  		epMap map[string]interface{}
   238  	)
   239  
   240  	json.Unmarshal(value, &epMap)
   241  
   242  	ep.id = epMap["id"].(string)
   243  	ep.nid = epMap["nid"].(string)
   244  	if v, ok := epMap["mac"]; ok {
   245  		if ep.mac, err = net.ParseMAC(v.(string)); err != nil {
   246  			return types.InternalErrorf("failed to decode endpoint interface mac address after json unmarshal: %s", v.(string))
   247  		}
   248  	}
   249  	if v, ok := epMap["addr"]; ok {
   250  		if ep.addr, err = types.ParseCIDR(v.(string)); err != nil {
   251  			return types.InternalErrorf("failed to decode endpoint interface ipv4 address after json unmarshal: %v", err)
   252  		}
   253  	}
   254  	if v, ok := epMap["ifName"]; ok {
   255  		ep.ifName = v.(string)
   256  	}
   257  
   258  	return nil
   259  }