github.com/Heebron/moby@v0.0.0-20221111184709-6eab4f55faf7/libnetwork/drivers/windows/overlay/overlay_windows.go (about)

     1  package overlay
     2  
     3  //go:generate protoc -I.:../../Godeps/_workspace/src/github.com/gogo/protobuf  --gogo_out=import_path=github.com/docker/docker/libnetwork/drivers/overlay,Mgogoproto/gogo.proto=github.com/gogo/protobuf/gogoproto:. overlay.proto
     4  
     5  import (
     6  	"encoding/json"
     7  	"net"
     8  	"sync"
     9  
    10  	"github.com/Microsoft/hcsshim"
    11  	"github.com/docker/docker/libnetwork/datastore"
    12  	"github.com/docker/docker/libnetwork/discoverapi"
    13  	"github.com/docker/docker/libnetwork/driverapi"
    14  	"github.com/docker/docker/libnetwork/netlabel"
    15  	"github.com/docker/docker/libnetwork/types"
    16  	"github.com/sirupsen/logrus"
    17  )
    18  
    19  const (
    20  	networkType  = "overlay"
    21  	vethPrefix   = "veth"
    22  	vethLen      = 7
    23  	secureOption = "encrypted"
    24  )
    25  
    26  type driver struct {
    27  	config     map[string]interface{}
    28  	networks   networkTable
    29  	store      datastore.DataStore
    30  	localStore datastore.DataStore
    31  	once       sync.Once
    32  	joinOnce   sync.Once
    33  	sync.Mutex
    34  }
    35  
    36  // Init registers a new instance of overlay driver
    37  func Init(dc driverapi.DriverCallback, config map[string]interface{}) error {
    38  	c := driverapi.Capability{
    39  		DataScope:         datastore.GlobalScope,
    40  		ConnectivityScope: datastore.GlobalScope,
    41  	}
    42  
    43  	d := &driver{
    44  		networks: networkTable{},
    45  		config:   config,
    46  	}
    47  
    48  	if data, ok := config[netlabel.GlobalKVClient]; ok {
    49  		var err error
    50  		dsc, ok := data.(discoverapi.DatastoreConfigData)
    51  		if !ok {
    52  			return types.InternalErrorf("incorrect data in datastore configuration: %v", data)
    53  		}
    54  		d.store, err = datastore.NewDataStoreFromConfig(dsc)
    55  		if err != nil {
    56  			return types.InternalErrorf("failed to initialize data store: %v", err)
    57  		}
    58  	}
    59  
    60  	if data, ok := config[netlabel.LocalKVClient]; ok {
    61  		var err error
    62  		dsc, ok := data.(discoverapi.DatastoreConfigData)
    63  		if !ok {
    64  			return types.InternalErrorf("incorrect data in datastore configuration: %v", data)
    65  		}
    66  		d.localStore, err = datastore.NewDataStoreFromConfig(dsc)
    67  		if err != nil {
    68  			return types.InternalErrorf("failed to initialize local data store: %v", err)
    69  		}
    70  	}
    71  
    72  	d.restoreHNSNetworks()
    73  
    74  	return dc.RegisterDriver(networkType, d, c)
    75  }
    76  
    77  func (d *driver) restoreHNSNetworks() error {
    78  	logrus.Infof("Restoring existing overlay networks from HNS into docker")
    79  
    80  	hnsresponse, err := hcsshim.HNSListNetworkRequest("GET", "", "")
    81  	if err != nil {
    82  		return err
    83  	}
    84  
    85  	for _, v := range hnsresponse {
    86  		if v.Type != networkType {
    87  			continue
    88  		}
    89  
    90  		logrus.Infof("Restoring overlay network: %s", v.Name)
    91  		n := d.convertToOverlayNetwork(&v)
    92  		d.addNetwork(n)
    93  
    94  		//
    95  		// We assume that any network will be recreated on daemon restart
    96  		// and therefore don't restore hns endpoints for now
    97  		//
    98  		//n.restoreNetworkEndpoints()
    99  	}
   100  
   101  	return nil
   102  }
   103  
   104  func (d *driver) convertToOverlayNetwork(v *hcsshim.HNSNetwork) *network {
   105  	n := &network{
   106  		id:              v.Name,
   107  		hnsID:           v.Id,
   108  		driver:          d,
   109  		endpoints:       endpointTable{},
   110  		subnets:         []*subnet{},
   111  		providerAddress: v.ManagementIP,
   112  	}
   113  
   114  	for _, hnsSubnet := range v.Subnets {
   115  		vsidPolicy := &hcsshim.VsidPolicy{}
   116  		for _, policy := range hnsSubnet.Policies {
   117  			if err := json.Unmarshal([]byte(policy), &vsidPolicy); err == nil && vsidPolicy.Type == "VSID" {
   118  				break
   119  			}
   120  		}
   121  
   122  		gwIP := net.ParseIP(hnsSubnet.GatewayAddress)
   123  		localsubnet := &subnet{
   124  			vni:  uint32(vsidPolicy.VSID),
   125  			gwIP: &gwIP,
   126  		}
   127  
   128  		_, subnetIP, err := net.ParseCIDR(hnsSubnet.AddressPrefix)
   129  
   130  		if err != nil {
   131  			logrus.Errorf("Error parsing subnet address %s ", hnsSubnet.AddressPrefix)
   132  			continue
   133  		}
   134  
   135  		localsubnet.subnetIP = subnetIP
   136  
   137  		n.subnets = append(n.subnets, localsubnet)
   138  	}
   139  
   140  	return n
   141  }
   142  
   143  func (d *driver) Type() string {
   144  	return networkType
   145  }
   146  
   147  func (d *driver) IsBuiltIn() bool {
   148  	return true
   149  }
   150  
   151  // DiscoverNew is a notification for a new discovery event, such as a new node joining a cluster
   152  func (d *driver) DiscoverNew(dType discoverapi.DiscoveryType, data interface{}) error {
   153  	return types.NotImplementedErrorf("not implemented")
   154  }
   155  
   156  // DiscoverDelete is a notification for a discovery delete event, such as a node leaving a cluster
   157  func (d *driver) DiscoverDelete(dType discoverapi.DiscoveryType, data interface{}) error {
   158  	return types.NotImplementedErrorf("not implemented")
   159  }