"fmt"
	"strconv"
	"strings"
)

// PortRange represents a range of TCP/UDP ports.  To represent a single port,
// set Size to 1.
type PortRange struct {
	Base int
	Size int
}

// Contains tests whether a given port falls within the PortRange.
func (pr *PortRange) Contains(p int) bool {
	return (p >= pr.Base) && ((p - pr.Base) < pr.Size)
}

// String converts the PortRange to a string representation, which can be

apiVersion: kubeproxy.config.k8s.io/v1alpha1
kind: KubeProxyConfiguration
portRange: ""

}

type PortAllocator struct {
	portRange net.PortRange

	alloc allocator.Interface

	// metrics is a metrics recorder that can be disabled
	metrics metricsRecorderInterface
}

// PortAllocator implements Interface and Snapshottable
var _ Interface = &PortAllocator{}

// New creates a PortAllocator over a net.PortRange, calling allocatorFactory to construct the backing store.

    static ReservedPortRange getPortRange(PortDetector portDetector, int startPort, int endPort) {
        ReservedPortRange portRange = new ReservedPortRange(startPort, endPort)
        portRange.portDetector = portDetector
        return portRange
    }

    static boolean isReservedInList(List<ReservedPortRange> reservationList, int startPort, int endPort) {

            reservePortRange()
        }
    }

    private ReservedPortRange reservePortRange() {
        def portRange = getNextPortRange(reservations.size())
        ReservedPortRange range = portRangeFactory.getReservedPortRange(portRange.left, portRange.right)
        reservations.add(range)
        return range
    }

    protected abstract Pair<Integer, Integer> getNextPortRange(int rangeNumber)

	if serverDebugLog {
		fmt.Printf("%s < %d %s\n", sessionID, code, message)
	}
}

func startFTPServer(args []string) {
	var (
		port          int
		publicIP      string
		portRange     string
		tlsPrivateKey string
		tlsPublicCert string
	)

	var err error
	for _, arg := range args {
		tokens := strings.SplitN(arg, "=", 2)
		if len(tokens) != 2 {

  verbosity: 0
metricsBindAddress: 127.0.0.1:10249
mode: ""
nftables:
  masqueradeAll: false
  masqueradeBit: 14
  minSyncPeriod: 1s
  syncPeriod: 30s
nodePortAddresses: null
oomScoreAdj: -999
portRange: ""
showHiddenMetricsForVersion: ""
winkernel:
  enableDSR: false
  forwardHealthCheckVip: false
  networkName: ""
  rootHnsEndpointName: ""

apiVersion: kubeproxy.config.k8s.io/v1alpha1
kind: KubeProxyConfiguration

import (
	"net"

	utilnet "k8s.io/apimachinery/pkg/util/net"
	netutils "k8s.io/utils/net"
)

// DefaultServiceNodePortRange is the default port range for NodePort services.
var DefaultServiceNodePortRange = utilnet.PortRange{Base: 30000, Size: 2768}

// DefaultServiceIPCIDR is a CIDR notation of IP range from which to allocate service cluster IPs
var DefaultServiceIPCIDR = net.IPNet{IP: netutils.ParseIPSloppy("10.0.0.0"), Mask: net.CIDRMask(24, 32)}

		d()
		server.Terminate(t)
	}
	return server, storage, backing, s, destroyFunc
}

func validNewRangeAllocation() *api.RangeAllocation {
	portRange := fmt.Sprintf("%d-%d", basePortRange, basePortRange+sizePortRange-1)
	return &api.RangeAllocation{
		Range: portRange,
	}
}

func key() string {
	return "/ranges/servicenodeports"
}