Exemple #1
0
func TestFetchHypervisors(t *testing.T) {

	// Setup
	f := NewFetcher("http://127.0.0.1:4001")
	defer testhelper.Cleanup(f.etcdClient)

	// Create supporting objects
	n, err := testhelper.NewNetwork(f.context)
	h.Ok(t, err)
	s, err := testhelper.NewSubnet(f.context, "10.10.10.0/24", net.IPv4(10, 10, 10, 1), net.IPv4(10, 10, 10, 10), net.IPv4(10, 10, 10, 250), n)
	h.Ok(t, err)

	// Create two hypervisors
	h1, err := testhelper.NewHypervisor(f.context, "de:ad:be:ef:7f:21", net.IPv4(192, 168, 100, 200), net.IPv4(192, 168, 100, 1), net.IPv4(255, 255, 255, 0), "br0", s)
	h.Ok(t, err)
	h2, err := testhelper.NewHypervisor(f.context, "de:ad:be:ef:7f:23", net.IPv4(192, 168, 100, 203), net.IPv4(192, 168, 100, 1), net.IPv4(255, 255, 255, 0), "br0", s)
	h.Ok(t, err)

	// Fetch and make sure they're present
	hvs, err := f.Hypervisors()
	h.Ok(t, err)
	if _, ok := hvs[h1.ID]; !ok {
		t.Error("Hypervisor #1 is missing from list")
	}
	h.Equals(t, hvs[h1.ID].MAC.String(), "de:ad:be:ef:7f:21")
	if _, ok := hvs[h2.ID]; !ok {
		t.Error("Hypervisor #2 is missing from list")
	}
	h.Equals(t, hvs[h2.ID].MAC.String(), "de:ad:be:ef:7f:23")

}
Exemple #2
0
func TestFetchSubnets(t *testing.T) {

	// Setup
	f := NewFetcher("http://127.0.0.1:4001")
	defer testhelper.Cleanup(f.etcdClient)

	// Create supporting object
	n, err := testhelper.NewNetwork(f.context)
	h.Ok(t, err)

	// Create two subnets
	s1, err := testhelper.NewSubnet(f.context, "10.10.10.0/24", net.IPv4(10, 10, 10, 1), net.IPv4(10, 10, 10, 10), net.IPv4(10, 10, 10, 250), n)
	h.Ok(t, err)
	s2, err := testhelper.NewSubnet(f.context, "12.12.12.0/24", net.IPv4(12, 12, 12, 1), net.IPv4(12, 12, 12, 12), net.IPv4(12, 12, 12, 250), n)
	h.Ok(t, err)

	// Fetch and make sure they're present
	ss, err := f.Subnets()
	h.Ok(t, err)
	if _, ok := ss[s1.ID]; !ok {
		t.Error("Subnet #1 is missing from list")
	}
	h.Equals(t, ss[s1.ID].CIDR.String(), "10.10.10.0/24")
	if _, ok := ss[s2.ID]; !ok {
		t.Error("Subnet #2 is missing from list")
	}
	h.Equals(t, ss[s2.ID].CIDR.String(), "12.12.12.0/24")

}
Exemple #3
0
func TestGetHypervisorID(t *testing.T) {
	uuid := "d3cac004-4d89-4f26-9776-97df74a41417"
	id, err := lochness.SetHypervisorID(uuid)
	h.Ok(t, err)
	h.Equals(t, uuid, id)

	id = lochness.GetHypervisorID()
	h.Equals(t, uuid, id)

}
Exemple #4
0
func TestNetworkAddSubnet(t *testing.T) {
	defer contextCleanup(t)
	n := newNetwork(t)
	h.Equals(t, 36, len(n.ID))
	err := n.Save()
	h.Ok(t, err)

	s := newSubnet(t)

	err = n.AddSubnet(s)
	h.Ok(t, err)

	h.Equals(t, 1, len(n.Subnets()))
}
Exemple #5
0
func TestFWGroupJson(t *testing.T) {
	data := `{"id": "EF8D7367-F14F-49C9-B960-2625947CA929", "rules": [ {"source": "192.168.1.0/24", "portStart": 80, "portEnd": 80, "protocol": "tcp", "action": "allow"} ] }`

	f := lochness.FWGroup{}
	err := json.Unmarshal([]byte(data), &f)
	h.Ok(t, err)
	h.Equals(t, "EF8D7367-F14F-49C9-B960-2625947CA929", f.ID)
	h.Equals(t, 1, len(f.Rules))
	h.Equals(t, "192.168.1.0", f.Rules[0].Source.IP.String())

	b, err := json.Marshal(&f)
	h.Ok(t, err)

	h.Assert(t, strings.Contains(string(b), "192.168.1.0/24"), "incorrect source information")
}
Exemple #6
0
func TestNewNetwork(t *testing.T) {
	defer contextCleanup(t)
	n := newNetwork(t)
	h.Equals(t, 36, len(n.ID))
	err := n.Save()
	h.Ok(t, err)
}
Exemple #7
0
func TestHypervisorSetConfig(t *testing.T) {
	hv := newHypervisor(t)
	defer contextCleanup(t)

	h.Ok(t, hv.SetConfig("foo", "bar"))

	h.Equals(t, "bar", hv.Config["foo"])

	h.Ok(t, hv.Refresh())

	h.Equals(t, "bar", hv.Config["foo"])

	h.Ok(t, hv.SetConfig("foo", ""))

	_, ok := hv.Config["foo"]
	h.Equals(t, ok, false)
}
Exemple #8
0
func TestHypervisor(t *testing.T) {
	c := newContext(t)
	defer contextCleanup(t)
	hv := newHypervisor(t)
	id := hv.ID
	hv, err := c.Hypervisor(id)
	h.Ok(t, err)
	h.Equals(t, id, hv.ID)
}
Exemple #9
0
func TestIntegrateSubnetResponses(t *testing.T) {

	// Setup
	f := NewFetcher("http://127.0.0.1:4001")
	defer testhelper.Cleanup(f.etcdClient)
	_, err := f.Subnets()
	h.Ok(t, err)

	// Create-subnet integration
	s := f.context.NewSubnet()
	cidr := "77.77.77.0/24"
	_, s.CIDR, err = net.ParseCIDR(cidr)
	if err != nil {
		t.Error("Could not parse CIDR '" + cidr + "': " + err.Error())
	}
	sj, err := json.Marshal(s)
	h.Ok(t, err)
	key := filepath.Join(lochness.SubnetPath, s.ID, "metadata")
	resp, err := f.etcdClient.Create(key, string(sj), 0)
	h.Ok(t, err)
	refresh, err := f.IntegrateResponse(resp)
	h.Ok(t, err)
	h.Equals(t, refresh, true)
	h.Ok(t, err)
	ss, err := f.Subnets()
	h.Ok(t, err)
	if _, ok := ss[s.ID]; !ok {
		t.Error("Newly integrated subnet is missing from list")
	}
	h.Equals(t, ss[s.ID].CIDR.String(), cidr)

	// Delete-subnet integration
	resp, err = f.etcdClient.Delete(filepath.Join(lochness.SubnetPath, s.ID, "metadata"), false)
	h.Ok(t, err)
	refresh, err = f.IntegrateResponse(resp)
	h.Ok(t, err)
	h.Equals(t, refresh, true)
	ss, err = f.Subnets()
	h.Ok(t, err)
	if _, ok := ss[s.ID]; ok {
		t.Error("Newly deleted subnet is present in list")
	}
}
Exemple #10
0
func reserveAddress(t *testing.T, s *lochness.Subnet) net.IP {
	ip, err := s.ReserveAddress("fake")
	h.Ok(t, err)

	h.Assert(t, strings.Contains(ip.String(), "10.10.10."), "unexpected ip address")

	h.Equals(t, 90, len(s.AvailibleAddresses()))

	h.Equals(t, 1, len(s.Addresses()))

	// make sure change persists
	err = s.Refresh()
	h.Ok(t, err)

	h.Equals(t, 90, len(s.AvailibleAddresses()))

	return ip

}
Exemple #11
0
func TestHandlerFail(t *testing.T) {
	handler := http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
		w.WriteHeader(200)
		fmt.Fprint(w, "Hello World\n")
	})

	ri, err := realip.New([]string{"X-Forwarded-For"}, []string{"8.8.0.0/16"})
	h.Ok(t, err)

	request := newRequest("GET", "/foo", "9.8.8.8:9876", "64.63.62.61")
	recorder := httptest.NewRecorder()
	riHandler := ri.Handler(handler)

	riHandler.ServeHTTP(recorder, request)

	h.Equals(t, 200, recorder.Code)

	h.Equals(t, "9.8.8.8:9876", request.RemoteAddr)
}
Exemple #12
0
func TestSubnetReleaseAddress(t *testing.T) {
	s := newSubnet(t)
	defer removeSubnet(t, s)

	ip := reserveAddress(t, s)
	err := s.ReleaseAddress(ip)
	h.Ok(t, err)

	h.Equals(t, 91, len(s.AvailibleAddresses()))

	// make sure change persists
	err = s.Refresh()
	h.Ok(t, err)

	h.Equals(t, 91, len(s.AvailibleAddresses()))

	h.Equals(t, 0, len(s.Addresses()))

}
Exemple #13
0
func TestIntegrateHypervisorResponses(t *testing.T) {

	// Setup
	f := NewFetcher("http://127.0.0.1:4001")
	defer testhelper.Cleanup(f.etcdClient)
	_, err := f.Hypervisors()
	h.Ok(t, err)

	// Create-hypervisor integration
	hv := f.context.NewHypervisor()
	mac := "55:55:55:55:55:55"
	hv.MAC, err = net.ParseMAC(mac)
	if err != nil {
		t.Error("Could not parse MAC '" + mac + "': " + err.Error())
	}
	hj, err := json.Marshal(hv)
	h.Ok(t, err)
	key := filepath.Join(lochness.HypervisorPath, hv.ID, "metadata")
	resp, err := f.etcdClient.Create(key, string(hj), 0)
	h.Ok(t, err)
	refresh, err := f.IntegrateResponse(resp)
	h.Ok(t, err)
	h.Equals(t, refresh, true)
	hvs, err := f.Hypervisors()
	h.Ok(t, err)
	if _, ok := hvs[hv.ID]; !ok {
		t.Error("Newly integrated hypervisor is missing from list")
	}
	h.Equals(t, hvs[hv.ID].MAC.String(), mac)

	// Delete-hypervisor integration (update requires modifiedIndex, which is not exported)
	resp, err = f.etcdClient.Delete(filepath.Join(lochness.HypervisorPath, hv.ID, "metadata"), false)
	h.Ok(t, err)
	refresh, err = f.IntegrateResponse(resp)
	h.Ok(t, err)
	h.Equals(t, refresh, true)
	hvs, err = f.Hypervisors()
	h.Ok(t, err)
	if _, ok := hvs[hv.ID]; ok {
		t.Error("Newly deleted hypervisor is present in list")
	}
}
Exemple #14
0
func TestIntegrateGuestResponses(t *testing.T) {

	// Setup
	f := NewFetcher("http://127.0.0.1:4001")
	defer testhelper.Cleanup(f.etcdClient)
	_, err := f.Guests()
	h.Ok(t, err)

	// Create-guest integration
	g := f.context.NewGuest()
	mac := "66:66:66:66:66:66"
	g.MAC, err = net.ParseMAC(mac)
	if err != nil {
		t.Error("Could not parse MAC '" + mac + "': " + err.Error())
	}
	gj, err := json.Marshal(g)
	h.Ok(t, err)
	key := filepath.Join(lochness.GuestPath, g.ID, "metadata")
	resp, err := f.etcdClient.Create(key, string(gj), 0)
	h.Ok(t, err)
	refresh, err := f.IntegrateResponse(resp)
	h.Ok(t, err)
	h.Equals(t, refresh, true)
	gs, err := f.Guests()
	h.Ok(t, err)
	if _, ok := gs[g.ID]; !ok {
		t.Error("Newly integrated guest is missing from list")
	}
	h.Equals(t, gs[g.ID].MAC.String(), mac)

	// Delete-guest integration
	resp, err = f.etcdClient.Delete(filepath.Join(lochness.GuestPath, g.ID, "metadata"), false)
	h.Ok(t, err)
	refresh, err = f.IntegrateResponse(resp)
	h.Ok(t, err)
	h.Equals(t, refresh, true)
	gs, err = f.Guests()
	h.Ok(t, err)
	if _, ok := gs[g.ID]; ok {
		t.Error("Newly deleted guest is present in list")
	}
}
Exemple #15
0
func TestVerifyOnHV(t *testing.T) {
	defer contextCleanup(t)
	hv := newHypervisor(t)

	// failing test
	uuid := "d3cac004-4d89-4f26-9776-97df74a41417"
	id, err := lochness.SetHypervisorID(uuid)
	h.Ok(t, err)
	h.Equals(t, uuid, id)

	err = hv.VerifyOnHV()
	h.Assert(t, err != nil, "should have got an error")

	// passing
	id, err = lochness.SetHypervisorID(hv.ID)
	h.Ok(t, err)
	h.Equals(t, hv.ID, id)

	err = hv.VerifyOnHV()
	h.Ok(t, err)
}
Exemple #16
0
func TestFetchGuests(t *testing.T) {

	// Setup
	f := NewFetcher("http://127.0.0.1:4001")
	defer testhelper.Cleanup(f.etcdClient)

	// Create supporting objects
	f1, err := testhelper.NewFlavor(f.context, 4, 4096, 8192)
	h.Ok(t, err)
	n, err := testhelper.NewNetwork(f.context)
	h.Ok(t, err)
	fw, err := testhelper.NewFirewallGroup(f.context)
	h.Ok(t, err)
	s, err := testhelper.NewSubnet(f.context, "10.10.10.0/24", net.IPv4(10, 10, 10, 1), net.IPv4(10, 10, 10, 10), net.IPv4(10, 10, 10, 250), n)
	h.Ok(t, err)
	h1, err := testhelper.NewHypervisor(f.context, "de:ad:be:ef:7f:21", net.IPv4(192, 168, 100, 200), net.IPv4(192, 168, 100, 1), net.IPv4(255, 255, 255, 0), "br0", s)
	h.Ok(t, err)

	// Create two guests
	g1, err := testhelper.NewGuest(f.context, "01:23:45:67:89:ab", n, s, f1, fw, h1)
	h.Ok(t, err)
	g2, err := testhelper.NewGuest(f.context, "23:45:67:89:ab:cd", n, s, f1, fw, h1)
	h.Ok(t, err)

	// Fetch and make sure they're present
	gs, err := f.Guests()
	h.Ok(t, err)
	if _, ok := gs[g1.ID]; !ok {
		t.Error("Guest #1 is missing from list")
	}
	h.Equals(t, gs[g1.ID].MAC.String(), "01:23:45:67:89:ab")
	if _, ok := gs[g2.ID]; !ok {
		t.Error("Guest #2 is missing from list")
	}
	h.Equals(t, gs[g2.ID].MAC.String(), "23:45:67:89:ab:cd")

}
Exemple #17
0
func TestSetHypervisorID(t *testing.T) {
	// passing test with uuid
	uuid := "d3cac004-4d89-4f26-9776-97df74a41417"
	id, err := lochness.SetHypervisorID(uuid)
	h.Ok(t, err)
	h.Equals(t, uuid, id)

	id, err = lochness.SetHypervisorID("foo")
	h.Assert(t, err != nil, "should have got an error")
	h.Equals(t, "", id)

	// set with ENV
	uuid = "3e0f2128-0342-49f6-8e5f-ecd401bae99e"
	if err := os.Setenv("HYPERVISOR_ID", uuid); err != nil {
		log.WithFields(log.Fields{
			"error": err,
			"uuid":  uuid,
		}).Error("failed to set HYPERVISOR_ID env variable")
	}
	id, err = lochness.SetHypervisorID("")
	h.Ok(t, err)
	h.Equals(t, uuid, id)

}
func TestHandlerFail(t *testing.T) {
	handler := http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
		w.WriteHeader(200)
		fmt.Fprint(w, "Hello World\n")
	})

	wl, err := whitelist.New([]string{"8.8.0.0/16"})
	h.Ok(t, err)

	request := newRequest("GET", "/foo", "9.9.9.9:9876")
	recorder := httptest.NewRecorder()
	wlHandler := wl.Handler(handler)

	wlHandler.ServeHTTP(recorder, request)

	h.Equals(t, 403, recorder.Code)
}
Exemple #19
0
func TestSubnetAddresses(t *testing.T) {
	s := newSubnet(t)
	defer removeSubnet(t, s)

	h.Equals(t, 0, len(s.Addresses()))
}
Exemple #20
0
func TestNewSubnet(t *testing.T) {
	c := newContext(t)
	s := c.NewSubnet()
	h.Equals(t, 36, len(s.ID))
}
Exemple #21
0
func TestHypervisorIsAlive(t *testing.T) {
	hv := newHypervisor(t)
	defer contextCleanup(t)
	h.Equals(t, false, hv.IsAlive())
}
Exemple #22
0
func TestNewHypervisor(t *testing.T) {
	hv := newHypervisor(t)
	defer contextCleanup(t)
	h.Equals(t, 36, len(hv.ID))
}
Exemple #23
0
func TestSubnetAvailibleAddresses(t *testing.T) {
	s := newSubnet(t)
	defer removeSubnet(t, s)
	avail := s.AvailibleAddresses()
	h.Equals(t, 91, len(avail))
}
Exemple #24
0
func TestFetchAll(t *testing.T) {

	// Setup
	f := NewFetcher("http://127.0.0.1:4001")
	defer testhelper.Cleanup(f.etcdClient)

	// Create objects
	f1, err := testhelper.NewFlavor(f.context, 4, 4096, 8192)
	h.Ok(t, err)
	f2, err := testhelper.NewFlavor(f.context, 6, 8192, 1024)
	h.Ok(t, err)
	n, err := testhelper.NewNetwork(f.context)
	h.Ok(t, err)
	fw, err := testhelper.NewFirewallGroup(f.context)
	h.Ok(t, err)
	s, err := testhelper.NewSubnet(f.context, "10.10.10.0/24", net.IPv4(10, 10, 10, 1), net.IPv4(10, 10, 10, 10), net.IPv4(10, 10, 10, 250), n)
	h.Ok(t, err)
	h1, err := testhelper.NewHypervisor(f.context, "de:ad:be:ef:7f:21", net.IPv4(192, 168, 100, 200), net.IPv4(192, 168, 100, 1), net.IPv4(255, 255, 255, 0), "br0", s)
	h.Ok(t, err)
	h2, err := testhelper.NewHypervisor(f.context, "de:ad:be:ef:7f:23", net.IPv4(192, 168, 100, 203), net.IPv4(192, 168, 100, 1), net.IPv4(255, 255, 255, 0), "br0", s)
	h.Ok(t, err)
	g1, err := testhelper.NewGuest(f.context, "01:23:45:67:89:ab", n, s, f1, fw, h1)
	h.Ok(t, err)
	g2, err := testhelper.NewGuest(f.context, "23:45:67:89:ab:cd", n, s, f1, fw, h1)
	h.Ok(t, err)
	g3, err := testhelper.NewGuest(f.context, "45:67:89:ab:cd:ef", n, s, f1, fw, h2)
	h.Ok(t, err)
	g4, err := testhelper.NewGuest(f.context, "67:89:ab:cd:ef:01", n, s, f2, fw, h2)
	h.Ok(t, err)

	// Fetch and make sure everything expected is present
	err = f.FetchAll()
	h.Ok(t, err)

	// Check hypervisors
	hvs, err := f.Hypervisors()
	h.Ok(t, err)
	if _, ok := hvs[h1.ID]; !ok {
		t.Error("Hypervisor #1 is missing from list")
	}
	h.Equals(t, hvs[h1.ID].MAC.String(), "de:ad:be:ef:7f:21")
	if _, ok := hvs[h2.ID]; !ok {
		t.Error("Hypervisor #2 is missing from list")
	}
	h.Equals(t, hvs[h2.ID].MAC.String(), "de:ad:be:ef:7f:23")

	// Check guests
	gs, err := f.Guests()
	if _, ok := gs[g1.ID]; !ok {
		t.Error("Guest #1 is missing from list")
	}
	h.Equals(t, gs[g1.ID].MAC.String(), "01:23:45:67:89:ab")
	if _, ok := gs[g2.ID]; !ok {
		t.Error("Guest #2 is missing from list")
	}
	h.Equals(t, gs[g2.ID].MAC.String(), "23:45:67:89:ab:cd")
	if _, ok := gs[g3.ID]; !ok {
		t.Error("Guest #3 is missing from list")
	}
	h.Equals(t, gs[g3.ID].MAC.String(), "45:67:89:ab:cd:ef")
	if _, ok := gs[g4.ID]; !ok {
		t.Error("Guest #4 is missing from list")
	}
	h.Equals(t, gs[g4.ID].MAC.String(), "67:89:ab:cd:ef:01")

	// Check subnet
	ss, err := f.Subnets()
	h.Ok(t, err)
	if _, ok := ss[s.ID]; !ok {
		t.Error("Subnet is missing from list")
	}
	h.Equals(t, ss[s.ID].CIDR.String(), "10.10.10.0/24")

}
Exemple #25
0
func TestNewGuest(t *testing.T) {
	g := newGuest(t)
	h.Equals(t, 36, len(g.ID))
}
Exemple #26
0
func TestGuestCandidates(t *testing.T) {
	c := newContext(t)
	defer contextCleanup(t)

	s := newSubnet(t)
	hv := newHypervisor(t)

	n := c.NewNetwork()
	err := n.Save()
	h.Ok(t, err)
	err = n.AddSubnet(s)
	h.Ok(t, err)

	err = hv.AddSubnet(s, "br0")
	h.Ok(t, err)

	f := c.NewFlavor()
	f.Resources.Memory = 1024
	f.Resources.CPU = 2
	f.Resources.Disk = 8192
	err = f.Save()
	h.Ok(t, err)

	// horrible hack for testing
	hv, err = c.Hypervisor(hv.ID)
	h.Ok(t, err)

	hv.AvailableResources = lochness.Resources{
		Memory: 8192,
		CPU:    4,
		Disk:   65536,
	}

	hv.TotalResources = hv.AvailableResources
	err = hv.Save()
	h.Ok(t, err)

	// cheesy
	_, err = lochness.SetHypervisorID(hv.ID)
	h.Ok(t, err)

	err = hv.Heartbeat(9999 * time.Second)
	h.Ok(t, err)

	g := c.NewGuest()
	g.FlavorID = f.ID
	g.NetworkID = n.ID

	err = g.Save()
	h.Ok(t, err)

	candidates, err := g.Candidates(lochness.DefaultCandidateFunctions...)
	h.Ok(t, err)

	h.Equals(t, 1, len(candidates))

	h.Equals(t, hv.ID, candidates[0].ID)

	// umm what about IP?? we need to reserve an ip on this hv in proper subnet

	err = hv.AddGuest(g)
	h.Ok(t, err)
}