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")
}
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")
}
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()))
}
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")
}
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)
}
func newSubnet(t *testing.T) *lochness.Subnet {
c := newContext(t)
s := c.NewSubnet()
var err error
_, s.CIDR, err = net.ParseCIDR("10.10.10.0/24")
h.Ok(t, err)
s.StartRange = net.IPv4(10, 10, 10, 10)
s.EndRange = net.IPv4(10, 10, 10, 100)
err = s.Save()
h.Ok(t, err)
return s
}
func TestSubnetSave(t *testing.T) {
s := newSubnet(t)
defer removeSubnet(t, s)
s.Metadata["foo"] = "bar"
err := s.Save()
h.Ok(t, err)
}
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)
}
func TestHypervisorDestroy(t *testing.T) {
defer contextCleanup(t)
hv := newHypervisor(t)
err := hv.Destroy()
h.Ok(t, err)
// need a test with a guest
}
func newHypervisor(t *testing.T) *lochness.Hypervisor {
c := newContext(t)
hv := c.NewHypervisor()
err := hv.Save()
h.Ok(t, err)
return hv
}
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)
}
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()))
}
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
}
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)
}
func contextCleanup(t *testing.T) {
e := etcd.NewClient([]string{"http://127.0.0.1:4001"})
if !e.SyncCluster() {
t.Fatal("cannot sync cluster. make sure etcd is running at http://127.0.0.1:4001")
}
_, err := e.Delete("lochness", true)
if !lochness.IsKeyNotFound(err) {
h.Ok(t, err)
}
}
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)
}
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")
}
}
func TestFirstHypervisor(t *testing.T) {
c := newContext(t)
newHypervisor(t)
newHypervisor(t)
hv := newHypervisor(t)
defer contextCleanup(t)
found, err := c.FirstHypervisor(func(h *lochness.Hypervisor) bool {
return h.ID == "foo"
})
h.Ok(t, err)
h.Assert(t, found == nil, "unexpected value")
found, err = c.FirstHypervisor(func(h *lochness.Hypervisor) bool {
return h.ID == hv.ID
})
h.Ok(t, err)
h.Assert(t, found != nil, "unexpected nil")
}
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)
}
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")
}
}
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")
}
}
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)
}
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")
}
func TestFirstGuest(t *testing.T) {
c := newContext(t)
defer contextCleanup(t)
f := c.NewFlavor()
f.Resources.Memory = 1024
f.Resources.CPU = 2
f.Resources.Disk = 8192
h.Ok(t, f.Save())
g := newGuest(t)
g.MAC, _ = net.ParseMAC("72:00:04:30:c9:e0")
g.FlavorID = f.ID
h.Ok(t, g.Save())
g = newGuest(t)
g.MAC, _ = net.ParseMAC("72:00:04:30:c9:e1")
g.FlavorID = f.ID
h.Ok(t, g.Save())
g = newGuest(t)
g.MAC, _ = net.ParseMAC("72:00:04:30:c9:e2")
g.FlavorID = f.ID
h.Ok(t, g.Save())
found, err := c.FirstGuest(func(g *lochness.Guest) bool {
return g.ID == "foo"
})
h.Ok(t, err)
h.Assert(t, found == nil, "unexpected value")
found, err = c.FirstGuest(func(g2 *lochness.Guest) bool {
return g.ID == g2.ID
})
h.Ok(t, err)
h.Assert(t, found != nil, "unexpected nil")
}
func removeSubnet(t *testing.T, s *lochness.Subnet) {
err := s.Delete()
h.Ok(t, err)
}
func TestNew(t *testing.T) {
_, err := realip.New([]string{"X-Forwarded-For"}, []string{"127.0.0.0/8"})
h.Ok(t, err)
}
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")
}
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)
}
func TestNew(t *testing.T) {
_, err := whitelist.New([]string{"127.0.0.0/8"})
h.Ok(t, err)
}