[release/0.11] Backport networking commits

hcn/hcn.go

@@ -264,6 +264,18 @@ func SetPolicySupported() error {
  return platformDoesNotSupportError("SetPolicy")
 }
 
+// ModifyLoadbalancerSupported returns an error if the HCN version does not support ModifyLoadbalancer.
+func ModifyLoadbalancerSupported() error {
+ supported, err := GetCachedSupportedFeatures()
+ if err != nil {
+ return err
+ }
+ if supported.ModifyLoadbalancer {
+ return nil
+ }
+ return platformDoesNotSupportError("ModifyLoadbalancer")
+}
+
 // VxlanPortSupported returns an error if the HCN version does not support configuring the VXLAN TCP port.
 func VxlanPortSupported() error {
  supported, err := GetCachedSupportedFeatures()

hcn/hcnerrors.go

@@ -51,6 +51,7 @@ type ErrorCode uint32
 const (
  ERROR_NOT_FOUND = ErrorCode(windows.ERROR_NOT_FOUND)
  HCN_E_PORT_ALREADY_EXISTS ErrorCode = ErrorCode(windows.HCN_E_PORT_ALREADY_EXISTS)
+ HCN_E_NOTIMPL ErrorCode = ErrorCode(windows.E_NOTIMPL)
 )
 
 type HcnError struct {
@@ -78,6 +79,10 @@ func IsPortAlreadyExistsError(err error) bool {
  return CheckErrorWithCode(err, HCN_E_PORT_ALREADY_EXISTS)
 }
 
+func IsNotImplemented(err error) bool {
+ return CheckErrorWithCode(err, HCN_E_NOTIMPL)
+}
+
 func new(hr error, title string, rest string) error {
  err := &HcnError{}
  hcsError := hcserror.New(hr, title, rest)

hcn/hcnglobals.go

@@ -84,6 +84,11 @@ var (
 
  //HNS 15.0 allows for NestedIpSet support
  NestedIpSetVersion = VersionRanges{VersionRange{MinVersion: Version{Major: 15, Minor: 0}, MaxVersion: Version{Major: math.MaxInt32, Minor: math.MaxInt32}}}
+
+ //HNS 15.1 allows support for DisableHostPort flag.
+ DisableHostPortVersion = VersionRanges{VersionRange{MinVersion: Version{Major: 15, Minor: 1}, MaxVersion: Version{Major: math.MaxInt32, Minor: math.MaxInt32}}}
+ // HNS 15.4 allows for Modify Loadbalancer support
+ ModifyLoadbalancerVersion = VersionRanges{VersionRange{MinVersion: Version{Major: 15, Minor: 4}, MaxVersion: Version{Major: math.MaxInt32, Minor: math.MaxInt32}}}
 )
 
 // GetGlobals returns the global properties of the HCN Service.

hcn/hcnloadbalancer.go

@@ -163,6 +163,49 @@ func createLoadBalancer(settings string) (*HostComputeLoadBalancer, error) {
  return &outputLoadBalancer, nil
 }
 
+func updateLoadBalancer(loadbalancerId string, settings string) (*HostComputeLoadBalancer, error) {
+ loadBalancerGuid, err := guid.FromString(loadbalancerId)
+ if err != nil {
+ return nil, errInvalidLoadBalancerID
+ }
+ // Update loadBalancer.
+ var (
+ loadBalancerHandle hcnLoadBalancer
+ resultBuffer *uint16
+ propertiesBuffer *uint16
+ )
+ hr := hcnOpenLoadBalancer(&loadBalancerGuid, &loadBalancerHandle, &resultBuffer)
+ if err := checkForErrors("hcnOpenLoadBalancer", hr, resultBuffer); err != nil {
+ return nil, err
+ }
+ hr = hcnModifyLoadBalancer(loadBalancerHandle, settings, &resultBuffer)
+ if err := checkForErrors("hcnModifyLoadBalancer", hr, resultBuffer); err != nil {
+ return nil, err
+ }
+ // Query loadBalancer.
+ hcnQuery := defaultQuery()
+ query, err := json.Marshal(hcnQuery)
+ if err != nil {
+ return nil, err
+ }
+ hr = hcnQueryLoadBalancerProperties(loadBalancerHandle, string(query), &propertiesBuffer, &resultBuffer)
+ if err := checkForErrors("hcnQueryLoadBalancerProperties", hr, resultBuffer); err != nil {
+ return nil, err
+ }
+ properties := interop.ConvertAndFreeCoTaskMemString(propertiesBuffer)
+ // Close loadBalancer.
+ hr = hcnCloseLoadBalancer(loadBalancerHandle)
+ if err := checkForErrors("hcnCloseLoadBalancer", hr, nil); err != nil {
+ return nil, err
+ }
+ // Convert output to HostComputeLoadBalancer
+ var outputLoadBalancer HostComputeLoadBalancer
+ if err := json.Unmarshal([]byte(properties), &outputLoadBalancer); err != nil {
+ return nil, err
+ }
+ return &outputLoadBalancer, nil
+}
+
 func deleteLoadBalancer(loadBalancerID string) error {
  loadBalancerGUID, err := guid.FromString(loadBalancerID)
  if err != nil {
@@ -237,6 +280,23 @@ func (loadBalancer *HostComputeLoadBalancer) Create() (*HostComputeLoadBalancer,
  return loadBalancer, nil
 }
 
+// Update Loadbalancer.
+func (loadBalancer *HostComputeLoadBalancer) Update(hnsLoadbalancerID string) (*HostComputeLoadBalancer, error) {
+ logrus.Debugf("hcn::HostComputeLoadBalancer::Create id=%s", hnsLoadbalancerID)
+
+ jsonString, err := json.Marshal(loadBalancer)
+ if err != nil {
+ return nil, err
+ }
+
+ logrus.Debugf("hcn::HostComputeLoadBalancer::Update JSON: %s", jsonString)
+ loadBalancer, hcnErr := updateLoadBalancer(hnsLoadbalancerID, string(jsonString))
+ if hcnErr != nil {
+ return nil, hcnErr
+ }
+ return loadBalancer, nil
+}
+
 // Delete LoadBalancer.
 func (loadBalancer *HostComputeLoadBalancer) Delete() error {
  logrus.Debugf("hcn::HostComputeLoadBalancer::Delete id=%s", loadBalancer.Id)

hcn/hcnloadbalancer_test.go

@@ -42,6 +42,70 @@ func TestCreateDeleteLoadBalancer(t *testing.T) {
  }
 }
 
+func TestCreateUpdateDeleteLoadBalancer(t *testing.T) {
+ network, err := CreateTestOverlayNetwork()
+ if err != nil {
+ t.Fatal(err)
+ }
+ endpoint, err := HcnCreateTestEndpoint(network)
+ if err != nil {
+ t.Fatal(err)
+ }
+ loadBalancer, err := HcnCreateTestLoadBalancer(endpoint)
+ if err != nil {
+ t.Fatal(err)
+ }
+ jsonString, err := json.Marshal(loadBalancer)
+ if err != nil {
+ t.Fatal(err)
+ }
+ fmt.Printf("LoadBalancer JSON:\n%s \n", jsonString)
+
+ secondEndpoint, err := HcnCreateTestEndpoint(network)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ HcnLoadBalancerTestAddBackend(loadBalancer, secondEndpoint.Id)
+
+ loadBalancer, err = loadBalancer.Update(loadBalancer.Id)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if len(loadBalancer.HostComputeEndpoints) != 2 {
+ t.Fatalf("Update loadBalancer with backend add failed")
+ }
+
+ HcnLoadBalancerTestRemoveBackend(loadBalancer, secondEndpoint.Id)
+
+ loadBalancer, err = loadBalancer.Update(loadBalancer.Id)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if len(loadBalancer.HostComputeEndpoints) != 1 {
+ t.Fatalf("Update loadBalancer with backend remove failed")
+ }
+
+ err = loadBalancer.Delete()
+ if err != nil {
+ t.Fatal(err)
+ }
+ err = secondEndpoint.Delete()
+ if err != nil {
+ t.Fatal(err)
+ }
+ err = endpoint.Delete()
+ if err != nil {
+ t.Fatal(err)
+ }
+ err = network.Delete()
+ if err != nil {
+ t.Fatal(err)
+ }
+}
+
 func TestGetLoadBalancerById(t *testing.T) {
  network, err := CreateTestOverlayNetwork()
  if err != nil {

hcn/hcnpolicy.go

@@ -144,10 +144,11 @@ type QosPolicySetting struct {
 
 // OutboundNatPolicySetting sets outbound Network Address Translation on an Endpoint.
 type OutboundNatPolicySetting struct {
- VirtualIP string `json:",omitempty"`
- Exceptions []string `json:",omitempty"`
- Destinations []string `json:",omitempty"`
- Flags NatFlags `json:",omitempty"`
+ VirtualIP string `json:",omitempty"`
+ Exceptions []string `json:",omitempty"`
+ Destinations []string `json:",omitempty"`
+ Flags NatFlags `json:",omitempty"`
+ MaxPortPoolUsage uint16 `json:",omitempty"`
 }
 
 // SDNRoutePolicySetting sets SDN Route on an Endpoint.

hcn/hcnsupport.go

@@ -37,6 +37,8 @@ type SupportedFeatures struct {
  TierAcl bool `json:"TierAcl"`
  NetworkACL bool `json:"NetworkACL"`
  NestedIpSet bool `json:"NestedIpSet"`
+ DisableHostPort bool `json:"DisableHostPort"`
+ ModifyLoadbalancer bool `json:"ModifyLoadbalancer"`
 }
 
 // AclFeatures are the supported ACL possibilities.
@@ -114,6 +116,8 @@ func getSupportedFeatures() (SupportedFeatures, error) {
  features.TierAcl = isFeatureSupported(globals.Version, TierAclPolicyVersion)
  features.NetworkACL = isFeatureSupported(globals.Version, NetworkACLPolicyVersion)
  features.NestedIpSet = isFeatureSupported(globals.Version, NestedIpSetVersion)
+ features.DisableHostPort = isFeatureSupported(globals.Version, DisableHostPortVersion)
+ features.ModifyLoadbalancer = isFeatureSupported(globals.Version, ModifyLoadbalancerVersion)
 
  log.L.WithFields(logrus.Fields{
  "version": globals.Version,

hcn/hcnutils_test.go

@@ -317,6 +317,23 @@ func HcnCreateTestLoadBalancer(endpoint *HostComputeEndpoint) (*HostComputeLoadB
  return loadBalancer.Create()
 }
 
+func HcnLoadBalancerTestAddBackend(loadBalancer *HostComputeLoadBalancer, endpointId string) {
+ endpointIds := loadBalancer.HostComputeEndpoints
+ endpointIds = append(endpointIds, endpointId)
+ loadBalancer.HostComputeEndpoints = endpointIds
+}
+
+func HcnLoadBalancerTestRemoveBackend(loadBalancer *HostComputeLoadBalancer, endpointId string) {
+ endpointIds := loadBalancer.HostComputeEndpoints
+ for i, v := range endpointIds {
+ if v == endpointId {
+ endpointIds = append(endpointIds[:i], endpointIds[i+1:]...)
+ break
+ }
+ }
+ loadBalancer.HostComputeEndpoints = endpointIds
+}
+
 func HcnCreateTestRemoteSubnetRoute() (*PolicyNetworkRequest, error) {
  rsr := RemoteSubnetRoutePolicySetting{
  DestinationPrefix: "192.168.2.0/24",

internal/hns/hnspolicy.go

@@ -57,9 +57,10 @@ type PaPolicy struct {
 
 type OutboundNatPolicy struct {
  Policy
- VIP string `json:"VIP,omitempty"`
- Exceptions []string `json:"ExceptionList,omitempty"`
- Destinations []string `json:",omitempty"`
+ VIP string `json:"VIP,omitempty"`
+ Exceptions []string `json:"ExceptionList,omitempty"`
+ Destinations []string `json:",omitempty"`
+ MaxPortPoolUsage uint16 `json:",omitempty"`
 }
 
 type ProxyPolicy struct {