github.com/rawahars/moby@v24.0.4+incompatible/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/types"
    15  	"github.com/sirupsen/logrus"
    16  )
    17  
    18  const (
    19  	networkType = "overlay"
    20  )
    21  
    22  type driver struct {
    23  	config   map[string]interface{}
    24  	networks networkTable
    25  	sync.Mutex
    26  }
    27  
    28  // Register registers a new instance of the overlay driver.
    29  func Register(r driverapi.Registerer, config map[string]interface{}) error {
    30  	c := driverapi.Capability{
    31  		DataScope:         datastore.GlobalScope,
    32  		ConnectivityScope: datastore.GlobalScope,
    33  	}
    34  
    35  	d := &driver{
    36  		networks: networkTable{},
    37  		config:   config,
    38  	}
    39  
    40  	d.restoreHNSNetworks()
    41  
    42  	return r.RegisterDriver(networkType, d, c)
    43  }
    44  
    45  func (d *driver) restoreHNSNetworks() error {
    46  	logrus.Infof("Restoring existing overlay networks from HNS into docker")
    47  
    48  	hnsresponse, err := hcsshim.HNSListNetworkRequest("GET", "", "")
    49  	if err != nil {
    50  		return err
    51  	}
    52  
    53  	for _, v := range hnsresponse {
    54  		if v.Type != networkType {
    55  			continue
    56  		}
    57  
    58  		logrus.Infof("Restoring overlay network: %s", v.Name)
    59  		n := d.convertToOverlayNetwork(&v)
    60  		d.addNetwork(n)
    61  
    62  		//
    63  		// We assume that any network will be recreated on daemon restart
    64  		// and therefore don't restore hns endpoints for now
    65  		//
    66  		//n.restoreNetworkEndpoints()
    67  	}
    68  
    69  	return nil
    70  }
    71  
    72  func (d *driver) convertToOverlayNetwork(v *hcsshim.HNSNetwork) *network {
    73  	n := &network{
    74  		id:              v.Name,
    75  		hnsID:           v.Id,
    76  		driver:          d,
    77  		endpoints:       endpointTable{},
    78  		subnets:         []*subnet{},
    79  		providerAddress: v.ManagementIP,
    80  	}
    81  
    82  	for _, hnsSubnet := range v.Subnets {
    83  		vsidPolicy := &hcsshim.VsidPolicy{}
    84  		for _, policy := range hnsSubnet.Policies {
    85  			if err := json.Unmarshal([]byte(policy), &vsidPolicy); err == nil && vsidPolicy.Type == "VSID" {
    86  				break
    87  			}
    88  		}
    89  
    90  		gwIP := net.ParseIP(hnsSubnet.GatewayAddress)
    91  		localsubnet := &subnet{
    92  			vni:  uint32(vsidPolicy.VSID),
    93  			gwIP: &gwIP,
    94  		}
    95  
    96  		_, subnetIP, err := net.ParseCIDR(hnsSubnet.AddressPrefix)
    97  
    98  		if err != nil {
    99  			logrus.Errorf("Error parsing subnet address %s ", hnsSubnet.AddressPrefix)
   100  			continue
   101  		}
   102  
   103  		localsubnet.subnetIP = subnetIP
   104  
   105  		n.subnets = append(n.subnets, localsubnet)
   106  	}
   107  
   108  	return n
   109  }
   110  
   111  func (d *driver) Type() string {
   112  	return networkType
   113  }
   114  
   115  func (d *driver) IsBuiltIn() bool {
   116  	return true
   117  }
   118  
   119  // DiscoverNew is a notification for a new discovery event, such as a new node joining a cluster
   120  func (d *driver) DiscoverNew(dType discoverapi.DiscoveryType, data interface{}) error {
   121  	return types.NotImplementedErrorf("not implemented")
   122  }
   123  
   124  // DiscoverDelete is a notification for a discovery delete event, such as a node leaving a cluster
   125  func (d *driver) DiscoverDelete(dType discoverapi.DiscoveryType, data interface{}) error {
   126  	return types.NotImplementedErrorf("not implemented")
   127  }