func mustParseIP4(s string) ip.IP4 {
a, err := ip.ParseIP4(s)
if err != nil {
panic(err)
}
return a
}
func TestAcquireLease(t *testing.T) {
msr := newDummyRegistry()
sm := NewMockManager(msr)
extIaddr, _ := ip.ParseIP4("1.2.3.4")
attrs := LeaseAttrs{
PublicIP: extIaddr,
}
l, err := sm.AcquireLease(context.Background(), "_", &attrs)
if err != nil {
t.Fatal("AcquireLease failed: ", err)
}
if !inAllocatableRange(context.Background(), sm, l.Subnet) {
t.Fatal("Subnet mismatch: expected 10.3.3.0/24, got: ", l.Subnet)
}
// Acquire again, should reuse
l2, err := sm.AcquireLease(context.Background(), "_", &attrs)
if err != nil {
t.Fatal("AcquireLease failed: ", err)
}
if !l.Subnet.Equal(l2.Subnet) {
t.Fatalf("AcquireLease did not reuse subnet; expected %v, got %v", l.Subnet, l2.Subnet)
}
}
func TestConfigChanged(t *testing.T) {
msr := newDummyRegistry()
sm := NewMockManager(msr)
extIaddr, _ := ip.ParseIP4("1.2.3.4")
attrs := LeaseAttrs{
PublicIP: extIaddr,
}
l, err := sm.AcquireLease(context.Background(), "_", &attrs)
if err != nil {
t.Fatal("AcquireLease failed: ", err)
}
if !inAllocatableRange(context.Background(), sm, l.Subnet) {
t.Fatal("Acquired subnet outside of valid range: ", l.Subnet)
}
// Change config
config := `{ "Network": "10.4.0.0/16" }`
msr.setConfig("_", config)
// Acquire again, should not reuse
if l, err = sm.AcquireLease(context.Background(), "_", &attrs); err != nil {
t.Fatal("AcquireLease failed: ", err)
}
if !inAllocatableRange(context.Background(), sm, l.Subnet) {
t.Fatal("Acquired subnet outside of valid range: ", l.Subnet)
}
}
func TestConfigChanged(t *testing.T) {
msr := newDummyRegistry(1000)
sm := newEtcdManager(msr)
extIaddr, _ := ip.ParseIP4("1.2.3.4")
attrs := LeaseAttrs{
PublicIP: extIaddr,
}
l, err := sm.AcquireLease(context.Background(), "", &attrs)
if err != nil {
t.Fatal("AcquireLease failed: ", err)
}
if l.Subnet.String() != "10.3.3.0/24" {
t.Fatal("Subnet mismatch: expected 10.3.3.0/24, got: ", l.Subnet)
}
// Change config
config := `{ "Network": "10.4.0.0/16" }`
msr.setConfig(config)
// Acquire again, should not reuse
if l, err = sm.AcquireLease(context.Background(), "", &attrs); err != nil {
t.Fatal("AcquireLease failed: ", err)
}
newNet := newIP4Net("10.4.0.0", 16)
if !newNet.Contains(l.Subnet.IP) {
t.Fatalf("Subnet mismatch: expected within %v, got: %v", newNet, l.Subnet)
}
}
func TestAcquireLease(t *testing.T) {
msr := newDummyRegistry(1000)
sm := newEtcdManager(msr)
extIaddr, _ := ip.ParseIP4("1.2.3.4")
attrs := LeaseAttrs{
PublicIP: extIaddr,
}
l, err := sm.AcquireLease(context.Background(), "", &attrs)
if err != nil {
t.Fatal("AcquireLease failed: ", err)
}
if l.Subnet.String() != "10.3.3.0/24" {
t.Fatal("Subnet mismatch: expected 10.3.3.0/24, got: ", l.Subnet)
}
// Acquire again, should reuse
if l, err = sm.AcquireLease(context.Background(), "", &attrs); err != nil {
t.Fatal("AcquireLease failed: ", err)
}
if l.Subnet.String() != "10.3.3.0/24" {
t.Fatal("Subnet mismatch: expected 10.3.3.0/24, got: ", l.Subnet)
}
}
func TestRenewLease(t *testing.T) {
msr := newMockSubnetRegistry(1)
sm, err := newSubnetManager(msr)
if err != nil {
t.Fatalf("Failed to create subnet manager: %s", err)
}
ip, _ := ip.ParseIP4("1.2.3.4")
data := `{ "PublicIP": "1.2.3.4" }`
cancel := make(chan bool)
defer close(cancel)
sn, err := sm.AcquireLease(ip, data, cancel)
if err != nil {
t.Fatal("AcquireLease failed: ", err)
}
go sm.LeaseRenewer(cancel)
fmt.Println("Waiting for lease to pass original expiration")
time.Sleep(2 * time.Second)
// check that it's still good
for _, n := range msr.subnets.Nodes {
if n.Key == sn.StringSep(".", "-") {
if n.Expiration.Before(time.Now()) {
t.Fatalf("Failed to renew lease")
}
return
}
}
t.Fatalf("Failed to find acquired lease")
}
func TestAcquireLease(t *testing.T) {
msr := newMockSubnetRegistry(0)
sm, err := newSubnetManager(msr)
if err != nil {
t.Fatalf("Failed to create subnet manager: %s", err)
}
ip, _ := ip.ParseIP4("1.2.3.4")
data := `{ "PublicIP": "1.2.3.4" }`
cancel := make(chan bool)
sn, err := sm.AcquireLease(ip, data, cancel)
if err != nil {
t.Fatal("AcquireLease failed: ", err)
}
if sn.String() != "10.3.3.0/24" {
t.Fatal("Subnet mismatch: expected 10.3.3.0/24, got: ", sn)
}
// Acquire again, should reuse
if sn, err = sm.AcquireLease(ip, data, cancel); err != nil {
t.Fatal("AcquireLease failed: ", err)
}
if sn.String() != "10.3.3.0/24" {
t.Fatal("Subnet mismatch: expected 10.3.3.0/24, got: ", sn)
}
}
func TestRenewLease(t *testing.T) {
msr := newDummyRegistry()
sm := NewMockManager(msr)
now := time.Now()
fakeClock := clockwork.NewFakeClockAt(now)
clock = fakeClock
// Create LeaseAttrs
extIaddr, _ := ip.ParseIP4("1.2.3.4")
attrs := LeaseAttrs{
PublicIP: extIaddr,
BackendType: "vxlan",
}
ld, err := json.Marshal(&leaseData{Dummy: "test string"})
if err != nil {
t.Fatalf("Failed to marshal leaseData: %v", err)
}
attrs.BackendData = json.RawMessage(ld)
// Acquire lease
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
l, err := sm.AcquireLease(ctx, "_", &attrs)
if err != nil {
t.Fatal("AcquireLease failed: ", err)
}
now = now.Add(subnetTTL)
fakeClock.Advance(24 * time.Hour)
if err := sm.RenewLease(ctx, "_", l); err != nil {
t.Fatal("RenewLease failed: ", err)
}
// check that it's still good
n, err := msr.getNetwork(ctx, "_")
if err != nil {
t.Error("Failed to renew lease: could not get networks: %v", err)
}
for _, sn := range n.subnets {
if sn.Subnet.Equal(l.Subnet) {
expected := now.Add(subnetTTL)
if !sn.Expiration.Equal(expected) {
t.Errorf("Failed to renew lease: bad expiration; expected %v, got %v", expected, sn.Expiration)
}
if !reflect.DeepEqual(sn.Attrs, attrs) {
t.Errorf("LeaseAttrs changed: was %#v, now %#v", attrs, sn.Attrs)
}
return
}
}
t.Fatalf("Failed to find acquired lease")
}
func newIP4Net(ipaddr string, prefix uint) ip.IP4Net {
a, err := ip.ParseIP4(ipaddr)
if err != nil {
panic("failed to parse ipaddr")
}
return ip.IP4Net{
IP: a,
PrefixLen: prefix,
}
}
func TestRenewLease(t *testing.T) {
msr := newDummyRegistry(1)
sm := newEtcdManager(msr)
// Create LeaseAttrs
extIaddr, _ := ip.ParseIP4("1.2.3.4")
attrs := LeaseAttrs{
PublicIP: extIaddr,
BackendType: "vxlan",
}
ld, err := json.Marshal(&leaseData{Dummy: "test string"})
if err != nil {
t.Fatalf("Failed to marshal leaseData: %v", err)
}
attrs.BackendData = json.RawMessage(ld)
// Acquire lease
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
l, err := sm.AcquireLease(ctx, "_", &attrs)
if err != nil {
t.Fatal("AcquireLease failed: ", err)
}
go LeaseRenewer(ctx, sm, "_", l)
fmt.Println("Waiting for lease to pass original expiration")
time.Sleep(2 * time.Second)
// check that it's still good
net, err := msr.getNetwork(ctx, "_")
if err != nil {
t.Error("Failed to renew lease: could not get networks: %v", err)
}
for _, n := range net.Node.Nodes {
if n.Key == l.Subnet.StringSep(".", "-") {
if n.Expiration.Before(time.Now()) {
t.Error("Failed to renew lease: expiration did not advance")
}
a := LeaseAttrs{}
if err := json.Unmarshal([]byte(n.Value), &a); err != nil {
t.Errorf("Failed to JSON-decode LeaseAttrs: %v", err)
return
}
if !reflect.DeepEqual(a, attrs) {
t.Errorf("LeaseAttrs changed: was %#v, now %#v", attrs, a)
}
return
}
}
t.Fatalf("Failed to find acquired lease")
}
func acquireLease(ctx context.Context, t *testing.T, sm Manager) *Lease {
extIaddr, _ := ip.ParseIP4("1.2.3.4")
attrs := LeaseAttrs{
PublicIP: extIaddr,
}
l, err := sm.AcquireLease(ctx, "_", &attrs)
if err != nil {
t.Fatal("AcquireLease failed: ", err)
}
return l
}
func nodeToLease(n api.Node) (l subnet.Lease, err error) {
l.Attrs.PublicIP, err = ip.ParseIP4(n.Annotations[backendPublicIPAnnotation])
if err != nil {
return l, err
}
l.Attrs.BackendType = n.Annotations[backendTypeAnnotation]
l.Attrs.BackendData = json.RawMessage(n.Annotations[backendDataAnnotation])
_, cidr, err := net.ParseCIDR(n.Spec.PodCIDR)
if err != nil {
return l, err
}
l.Subnet = ip.FromIPNet(cidr)
l.Expiration = time.Now().Add(24 * time.Hour)
return l, nil
}