github.com/Prakhar-Agarwal-byte/moby@v0.0.0-20231027092010-a14e3e8ab87e/libnetwork/drivers/overlay/overlay.go (about)

     1  //go:build linux
     2  
     3  package overlay
     4  
     5  //go:generate protoc -I=. -I=../../../vendor/ --gogofaster_out=import_path=github.com/Prakhar-Agarwal-byte/moby/libnetwork/drivers/overlay:. overlay.proto
     6  
     7  import (
     8  	"context"
     9  	"fmt"
    10  	"sync"
    11  
    12  	"github.com/containerd/log"
    13  	"github.com/Prakhar-Agarwal-byte/moby/libnetwork/discoverapi"
    14  	"github.com/Prakhar-Agarwal-byte/moby/libnetwork/driverapi"
    15  	"github.com/Prakhar-Agarwal-byte/moby/libnetwork/scope"
    16  )
    17  
    18  const (
    19  	NetworkType  = "overlay"
    20  	vethPrefix   = "veth"
    21  	vethLen      = len(vethPrefix) + 7
    22  	vxlanEncap   = 50
    23  	secureOption = "encrypted"
    24  )
    25  
    26  // overlay driver must implement the discover-API.
    27  var _ discoverapi.Discover = (*driver)(nil)
    28  
    29  type driver struct {
    30  	bindAddress      string
    31  	advertiseAddress string
    32  	config           map[string]interface{}
    33  	peerDb           peerNetworkMap
    34  	secMap           *encrMap
    35  	networks         networkTable
    36  	initOS           sync.Once
    37  	localJoinOnce    sync.Once
    38  	keys             []*key
    39  	peerOpMu         sync.Mutex
    40  	sync.Mutex
    41  }
    42  
    43  // Register registers a new instance of the overlay driver.
    44  func Register(r driverapi.Registerer, config map[string]interface{}) error {
    45  	d := &driver{
    46  		networks: networkTable{},
    47  		peerDb: peerNetworkMap{
    48  			mp: map[string]*peerMap{},
    49  		},
    50  		secMap: &encrMap{nodes: map[string][]*spi{}},
    51  		config: config,
    52  	}
    53  	return r.RegisterDriver(NetworkType, d, driverapi.Capability{
    54  		DataScope:         scope.Global,
    55  		ConnectivityScope: scope.Global,
    56  	})
    57  }
    58  
    59  func (d *driver) configure() error {
    60  	// Apply OS specific kernel configs if needed
    61  	d.initOS.Do(applyOStweaks)
    62  
    63  	return nil
    64  }
    65  
    66  func (d *driver) Type() string {
    67  	return NetworkType
    68  }
    69  
    70  func (d *driver) IsBuiltIn() bool {
    71  	return true
    72  }
    73  
    74  func (d *driver) nodeJoin(advertiseAddress, bindAddress string, self bool) {
    75  	if self {
    76  		d.Lock()
    77  		d.advertiseAddress = advertiseAddress
    78  		d.bindAddress = bindAddress
    79  		d.Unlock()
    80  
    81  		// If containers are already running on this network update the
    82  		// advertise address in the peerDB
    83  		d.localJoinOnce.Do(func() {
    84  			d.peerDBUpdateSelf()
    85  		})
    86  	}
    87  }
    88  
    89  // DiscoverNew is a notification for a new discovery event, such as a new node joining a cluster
    90  func (d *driver) DiscoverNew(dType discoverapi.DiscoveryType, data interface{}) error {
    91  	switch dType {
    92  	case discoverapi.NodeDiscovery:
    93  		nodeData, ok := data.(discoverapi.NodeDiscoveryData)
    94  		if !ok || nodeData.Address == "" {
    95  			return fmt.Errorf("invalid discovery data")
    96  		}
    97  		d.nodeJoin(nodeData.Address, nodeData.BindAddress, nodeData.Self)
    98  	case discoverapi.EncryptionKeysConfig:
    99  		encrData, ok := data.(discoverapi.DriverEncryptionConfig)
   100  		if !ok {
   101  			return fmt.Errorf("invalid encryption key notification data")
   102  		}
   103  		keys := make([]*key, 0, len(encrData.Keys))
   104  		for i := 0; i < len(encrData.Keys); i++ {
   105  			k := &key{
   106  				value: encrData.Keys[i],
   107  				tag:   uint32(encrData.Tags[i]),
   108  			}
   109  			keys = append(keys, k)
   110  		}
   111  		if err := d.setKeys(keys); err != nil {
   112  			log.G(context.TODO()).Warn(err)
   113  		}
   114  	case discoverapi.EncryptionKeysUpdate:
   115  		var newKey, delKey, priKey *key
   116  		encrData, ok := data.(discoverapi.DriverEncryptionUpdate)
   117  		if !ok {
   118  			return fmt.Errorf("invalid encryption key notification data")
   119  		}
   120  		if encrData.Key != nil {
   121  			newKey = &key{
   122  				value: encrData.Key,
   123  				tag:   uint32(encrData.Tag),
   124  			}
   125  		}
   126  		if encrData.Primary != nil {
   127  			priKey = &key{
   128  				value: encrData.Primary,
   129  				tag:   uint32(encrData.PrimaryTag),
   130  			}
   131  		}
   132  		if encrData.Prune != nil {
   133  			delKey = &key{
   134  				value: encrData.Prune,
   135  				tag:   uint32(encrData.PruneTag),
   136  			}
   137  		}
   138  		if err := d.updateKeys(newKey, priKey, delKey); err != nil {
   139  			return err
   140  		}
   141  	default:
   142  	}
   143  	return nil
   144  }
   145  
   146  // DiscoverDelete is a notification for a discovery delete event, such as a node leaving a cluster
   147  func (d *driver) DiscoverDelete(dType discoverapi.DiscoveryType, data interface{}) error {
   148  	return nil
   149  }