Golang hcsshim.HNSNetworkRequest函數代碼示例

func (d *driver) DeleteNetwork(nid string) error {
	n, err := d.getNetwork(nid)
	if err != nil {
		return types.InternalMaskableErrorf("%s", err)
	}

	n.Lock()
	config := n.config
	n.Unlock()

	// Cannot remove network if endpoints are still present
	if len(n.endpoints) != 0 {
		return fmt.Errorf("network %s has active endpoint", n.id)
	}

	_, err = hcsshim.HNSNetworkRequest("DELETE", config.HnsID, "")
	if err != nil {
		return err
	}

	d.Lock()
	delete(d.networks, nid)
	d.Unlock()

	return nil
}

func (d *driver) DeleteNetwork(nid string) error {
	if nid == "" {
		return fmt.Errorf("invalid network id")
	}

	// Make sure driver resources are initialized before proceeding
	if err := d.configure(); err != nil {
		return err
	}

	n := d.network(nid)
	if n == nil {
		return fmt.Errorf("could not find network with id %s", nid)
	}

	_, err := hcsshim.HNSNetworkRequest("DELETE", n.hnsId, "")
	if err != nil {
		return err
	}

	d.deleteNetwork(nid)
	d.deleteLocalNetworkFromStore(n)

	return nil
}

func (n *network) startResolver() {
	n.resolverOnce.Do(func() {
		log.Debugf("Launching DNS server for network", n.Name())
		options := n.Info().DriverOptions()
		hnsid := options[windows.HNSID]

		hnsresponse, err := hcsshim.HNSNetworkRequest("GET", hnsid, "")
		if err != nil {
			log.Errorf("Resolver Setup/Start failed for container %s, %q", n.Name(), err)
			return
		}

		for _, subnet := range hnsresponse.Subnets {
			if subnet.GatewayAddress != "" {
				resolver := NewResolver(subnet.GatewayAddress, false, "", n)
				log.Debugf("Binding a resolver on network %s gateway %s", n.Name(), subnet.GatewayAddress)
				executeInCompartment(hnsresponse.DNSServerCompartment, resolver.SetupFunc(53))
				if err = resolver.Start(); err != nil {
					log.Errorf("Resolver Setup/Start failed for container %s, %q", n.Name(), err)
				} else {
					n.resolver = append(n.resolver, resolver)
				}
			}
		}
	})
}

// Create a new network
func (d *driver) CreateNetwork(id string, option map[string]interface{}, ipV4Data, ipV6Data []driverapi.IPAMData) error {
	if _, err := d.getNetwork(id); err == nil {
		return types.ForbiddenErrorf("network %s exists", id)
	}

	genData, ok := option[netlabel.GenericData].(map[string]string)
	if !ok {
		return fmt.Errorf("Unknown generic data option")
	}

	// Parse and validate the config. It should not conflict with existing networks' config
	config, err := d.parseNetworkOptions(id, genData)
	if err != nil {
		return err
	}

	err = config.processIPAM(id, ipV4Data, ipV6Data)
	if err != nil {
		return err
	}

	network := &hnsNetwork{
		id:        config.ID,
		endpoints: make(map[string]*hnsEndpoint),
		config:    config,
		driver:    d,
	}

	d.Lock()
	d.networks[config.ID] = network
	d.Unlock()

	// A non blank hnsid indicates that the network was discovered
	// from HNS. No need to call HNS if this network was discovered
	// from HNS
	if config.HnsID == "" {
		subnets := []hcsshim.Subnet{}

		for _, ipData := range ipV4Data {
			subnet := hcsshim.Subnet{
				AddressPrefix:  ipData.Pool.String(),
				GatewayAddress: ipData.Gateway.IP.String(),
			}

			subnets = append(subnets, subnet)
		}

		network := &hcsshim.HNSNetwork{
			Name:    config.Name,
			Type:    d.name,
			Subnets: subnets,
		}

		if network.Name == "" {
			network.Name = id
		}

		configurationb, err := json.Marshal(network)
		if err != nil {
			return err
		}

		configuration := string(configurationb)
		log.Debugf("HNSNetwork Request =%v Address Space=%v", configuration, subnets)

		hnsresponse, err := hcsshim.HNSNetworkRequest("POST", "", configuration)
		if err != nil {
			return err
		}

		config.HnsID = hnsresponse.Id
		genData[HNSID] = config.HnsID
	}

	return nil
}

func (d *driver) findHnsNetwork(n *network) error {
	ln, err := d.getLocalNetworkFromStore(n.id)

	if err != nil {
		return err
	}

	if ln == nil {
		subnets := []hcsshim.Subnet{}

		for _, s := range n.subnets {
			subnet := hcsshim.Subnet{
				AddressPrefix: s.subnetIP.String(),
			}

			if s.gwIP != nil {
				subnet.GatewayAddress = s.gwIP.IP.String()
			}

			vsidPolicy, err := json.Marshal(hcsshim.VsidPolicy{
				Type: "VSID",
				VSID: uint(s.vni),
			})

			if err != nil {
				return err
			}

			subnet.Policies = append(subnet.Policies, vsidPolicy)
			subnets = append(subnets, subnet)
		}

		network := &hcsshim.HNSNetwork{
			Name:               n.name,
			Type:               d.Type(),
			Subnets:            subnets,
			NetworkAdapterName: n.interfaceName,
		}

		configurationb, err := json.Marshal(network)
		if err != nil {
			return err
		}

		configuration := string(configurationb)
		logrus.Infof("HNSNetwork Request =%v", configuration)

		hnsresponse, err := hcsshim.HNSNetworkRequest("POST", "", configuration)
		if err != nil {
			return err
		}

		n.hnsId = hnsresponse.Id
		n.providerAddress = hnsresponse.ManagementIP

		// Save local host specific info
		if err := d.writeLocalNetworkToStore(n); err != nil {
			return fmt.Errorf("failed to update data store for network %v: %v", n.id, err)
		}
	} else {
		n.hnsId = ln.hnsID
		n.providerAddress = ln.providerAddress
	}

	return nil
}