// Run configures and runs listener service.
func Run(rootServiceURL string, cred *common.Credential) (*common.RestServiceInfo, error) {
clientConfig := common.GetDefaultRestClientConfig(rootServiceURL)
clientConfig.Credential = cred
client, err := common.NewRestClient(clientConfig)
if err != nil {
return nil, err
}
KubeListener := &KubeListener{}
KubeListener.restClient = client
config, err := client.GetServiceConfig(KubeListener.Name())
if err != nil {
return nil, err
}
return common.InitializeService(KubeListener, *config, cred)
}
// romanaHostAdd connects to romana API and adds a node to
// the romana cluster.
func romanaHostAdd(node *v1.Node) error {
if node.Name == "" || len(node.Status.Addresses) < 1 {
log.Printf("Error: received invalid host name or IP Address: (%s)", node)
return errors.New("Error: received invalid host name or IP Address.")
}
hostname := node.Name
hostIP := node.Status.Addresses[0].Address
rootURL := config.GetString("RootURL")
client, err := common.NewRestClient(common.GetDefaultRestClientConfig(rootURL))
if err != nil {
return err
}
topologyURL, err := client.GetServiceUrl("topology")
if err != nil {
return err
}
index := common.IndexResponse{}
err = client.Get(topologyURL, &index)
if err != nil {
return err
}
host := common.Host{
Name: hostname,
Ip: hostIP,
}
data := common.Host{}
err = client.Post(topologyURL+"/hosts", host, &data)
if err != nil {
log.Printf("Error adding host (%s).\n", hostname)
return err
}
log.Printf("Host (%s) added successfully.\n", hostname)
return nil
}
// Test the service list.
func (s *MySuite) TestAuth(c *check.C) {
fmt.Println("Entering TestServiceList")
dir, _ := os.Getwd()
fmt.Println("In", dir)
err := s.RomanaTestSuite.MockConfig("../common/testdata/romana.auth.yaml")
if err != nil {
c.Fatal(err)
}
fmt.Printf("Calling Run(%s)", s.RomanaTestSuite.ConfigFile)
svcInfo, err := Run(s.RomanaTestSuite.ConfigFile)
if err != nil {
c.Fatal(err)
}
fmt.Println("Waiting for message")
msg := <-svcInfo.Channel
fmt.Println("Root service said:", msg)
addr := fmt.Sprintf("http://%s", svcInfo.Address)
clientConfig := common.GetDefaultRestClientConfig(addr)
clientConfig.Credential = &common.Credential{Type: common.CredentialUsernamePassword, Username: "******", Password: "******"}
client, err := common.NewRestClient(clientConfig)
if err != nil {
c.Fatal(err)
}
r := common.IndexResponse{}
err = client.Get("", &r)
if err != nil {
c.Fatal(err)
}
fmt.Println("Received: ", r)
svcName := r.ServiceName
fmt.Printf("Service name: %s", svcName)
if svcName != "root" {
c.Fatalf("Expected serviceName to be root, got %s", svcName)
}
}
// Test the service list.
func (s *MySuite) TestServiceList(c *check.C) {
fmt.Println("Entering TestServiceList")
dir, _ := os.Getwd()
fmt.Println("In", dir)
err := s.RomanaTestSuite.MockConfig(common.DefaultTestConfigFile)
if err != nil {
c.Fatal(err)
}
fmt.Printf("Calling Run(%s)", s.RomanaTestSuite.ConfigFile)
svcInfo, err := Run(s.RomanaTestSuite.ConfigFile)
if err != nil {
c.Fatal(err)
}
fmt.Println("Waiting for message")
msg := <-svcInfo.Channel
fmt.Println("Root service said:", msg)
rootURL := fmt.Sprintf("http://%s", svcInfo.Address)
client, err := common.NewRestClient(common.GetDefaultRestClientConfig(rootURL))
if err != nil {
c.Fatal(err)
}
r := common.IndexResponse{}
err = client.Get("", &r)
if err != nil {
c.Fatal(err)
}
fmt.Println("Received: ", r)
svcName := r.ServiceName
fmt.Printf("Service name: %s", svcName)
if svcName != "root" {
c.Fatalf("Expected serviceName to be root, got %s", svcName)
}
}
// getRestClient gets the rest client instance with the
// configured root URL and the credential object that was
// built at initalization.
func getRestClient() (*common.RestClient, error) {
rootURL := config.GetString("RootURL")
cfg := common.GetDefaultRestClientConfig(rootURL)
cfg.Credential = credential
return common.NewRestClient(cfg)
}
func (s *MySuite) TestPolicy(c *check.C) {
cfg := &common.ServiceConfig{Common: common.CommonConfig{Api: &common.Api{Port: 0, RestTimeoutMillis: 100}}}
log.Printf("Test: Mock service config:\n\t%#v\n\t%#v\n", cfg.Common.Api, cfg.ServiceSpecific)
svc := &mockSvc{mySuite: s}
svc.tenants = make(map[uint64]string)
svc.tenantsStr = make(map[string]uint64)
svc.segments = make(map[uint64]string)
svc.segmentsStr = make(map[string]uint64)
svcInfo, err := common.InitializeService(svc, *cfg, nil)
if err != nil {
c.Error(err)
c.FailNow()
}
msg := <-svcInfo.Channel
log.Printf("Test: Mock service says %s; listening on %s\n", msg, svcInfo.Address)
addrComponents := strings.Split(svcInfo.Address, ":")
portStr := addrComponents[len(addrComponents)-1]
s.servicePort, err = strconv.ParseUint(portStr, 10, 64)
if err != nil {
c.Error(err)
c.FailNow()
}
s.serviceURL = fmt.Sprintf("http://%s", svcInfo.Address)
log.Printf("Test: Mock service listens at %s\n", s.serviceURL)
polSvc := &PolicySvc{}
err = common.SimpleOverwriteSchema(polSvc, s.serviceURL)
if err != nil {
c.Fatal(err)
}
log.Printf("Policy schema created.")
svcInfo, err = common.SimpleStartService(polSvc, s.serviceURL)
if err != nil {
c.Fatal(err)
}
msg = <-svcInfo.Channel
fmt.Printf("Policy service listening %s on said: %s", svcInfo.Address, msg)
clientConfig := common.GetDefaultRestClientConfig(s.serviceURL)
client, err := common.NewRestClient(clientConfig)
if err != nil {
c.Fatal(err)
}
polURL := "http://" + svcInfo.Address + "/policies"
log.Println("1. Add policy pol1")
policyIn := common.Policy{}
err = json.Unmarshal([]byte(romanaPolicy1), &policyIn)
if err != nil {
c.Fatal(err)
c.FailNow()
}
policyOut := common.Policy{}
err = client.Post(polURL, policyIn, &policyOut)
if err != nil {
c.Error(err)
c.FailNow()
}
log.Printf("Added policy result: %s", policyOut)
c.Assert(policyOut.Name, check.Equals, "pol1")
c.Assert(policyOut.ID, check.Equals, uint64(1))
c.Assert(len(policyOut.AppliedTo), check.Equals, len(policyIn.AppliedTo))
c.Assert(len(policyOut.Ingress[0].Peers), check.Equals, len(policyIn.Ingress[0].Peers))
c.Assert(client.GetStatusCode(), check.Equals, 200)
pol1ExternalID := policyIn.ExternalID
policyIn.ExternalID = "asdfghjkl"
policyIn.ID = policyOut.ID
log.Printf("2. Add policy again with different External ID %s but same ID %d", policyIn.ExternalID, policyIn.ID)
err = client.Post(polURL, policyIn, &policyOut)
c.Assert(err.(common.HttpError).StatusCode, check.Equals, http.StatusConflict)
log.Printf("2. Result: %+v", policyOut)
log.Println("3. Add policy again")
policyIn.ExternalID = pol1ExternalID
policyIn.ID = 0
err = client.Post(polURL, policyIn, &policyOut)
c.Assert(err.(common.HttpError).StatusCode, check.Equals, http.StatusConflict)
log.Printf("3. Result: %+v", policyOut)
log.Println("4. Add policy pol2")
err = json.Unmarshal([]byte(romanaPolicy2), &policyIn)
if err != nil {
c.Fatal(err)
}
err = client.Post(polURL, policyIn, &policyOut)
if err != nil {
c.Fatal(err)
}
log.Printf("Added policy result: %s", policyOut)
c.Assert(client.GetStatusCode(), check.Equals, 200)
c.Assert(policyOut.Name, check.Equals, "pol2")
log.Println("5. Add default policy")
one := uint64(1)
defPol := common.Policy{
Direction: common.PolicyDirectionIngress,
Name: "default",
ExternalID: "default",
AppliedTo: []common.Endpoint{{TenantNetworkID: &one}},
Ingress: []common.RomanaIngress{
common.RomanaIngress{
Peers: []common.Endpoint{{Peer: common.Wildcard}},
Rules: []common.Rule{{Protocol: common.Wildcard}},
},
},
}
err = client.Post(polURL, defPol, &policyOut)
if err != nil {
c.Fatal(err)
}
log.Printf("Added policy result: %s", policyOut)
c.Assert(client.GetStatusCode(), check.Equals, 200)
c.Assert(policyOut.Name, check.Equals, "default")
log.Println("6. Test list policies - should have 3.")
var policies []common.Policy
err = client.Get(polURL, &policies)
if err != nil {
c.Fatal(err)
}
c.Assert(len(policies), check.Equals, 3)
c.Assert(client.GetStatusCode(), check.Equals, 200)
c.Assert(policies[0].Name, check.Equals, "pol1")
c.Assert(policies[1].Name, check.Equals, "pol2")
c.Assert(policies[2].Name, check.Equals, "default")
log.Println("7. Test get policy.")
policyGet := common.Policy{}
err = client.Get(polURL+"/1", &policyGet)
if err != nil {
c.Fatal(err)
}
c.Assert(policyGet.Name, check.Equals, policies[0].Name)
c.Assert(client.GetStatusCode(), check.Equals, 200)
log.Println("8. Test delete by ID - delete pol1")
policyOut = common.Policy{}
err = client.Delete(polURL+"/1", nil, &policyOut)
if err != nil {
c.Fatal(err)
}
log.Printf("Deleted policy result: %s", policyOut)
c.Assert(policyOut.Name, check.Equals, "pol1")
c.Assert(policyOut.ID, check.Equals, uint64(1))
c.Assert(client.GetStatusCode(), check.Equals, 200)
log.Println("9. Test list policies - should have 2 now - pol2 and default.")
err = client.Get(polURL, &policies)
if err != nil {
c.Fatal(err)
}
c.Assert(len(policies), check.Equals, 2)
c.Assert(policies[0].Name, check.Equals, "pol2")
c.Assert(policies[1].Name, check.Equals, "default")
c.Assert(client.GetStatusCode(), check.Equals, 200)
log.Println("10. Test delete by ExternalID - delete policy 2")
err = json.Unmarshal([]byte(romanaPolicy2), &policyIn)
if err != nil {
c.Fatal(err)
}
log.Printf("Unmarshaled %s to %v", romanaPolicy2, policyIn)
policyOut = common.Policy{}
err = client.Delete(polURL, policyIn, &policyOut)
if err != nil {
c.Fatal(err)
}
log.Printf("Deleted policy result: %s", policyOut)
c.Assert(client.GetStatusCode(), check.Equals, 200)
c.Assert(policyOut.Name, check.Equals, policyIn.Name)
log.Println("10. Test list policies - should have 1 now - only default")
err = client.Get(polURL, &policies)
if err != nil {
c.Fatal(err)
}
c.Assert(client.GetStatusCode(), check.Equals, 200)
c.Assert(len(policies), check.Equals, 1)
c.Assert(policies[0].Name, check.Equals, "default")
log.Println("11. Test find by name policies - should find it")
findURL := "http://" + svcInfo.Address + "/find/policies"
err = client.Get(findURL+"/default", &policyOut)
if err != nil {
c.Fatal(err)
}
c.Assert(policyOut.Name, check.Equals, "default")
log.Println("12. Test find by name policies with non-existent policy - should NOT find it")
err = client.Get(findURL+"/blabla", &policyOut)
httpErr := err.(common.HttpError)
c.Assert(client.GetStatusCode(), check.Equals, http.StatusNotFound)
c.Assert(httpErr.ResourceType, check.Equals, "policy")
c.Assert(httpErr.StatusCode, check.Equals, http.StatusNotFound)
c.Assert(httpErr.ResourceID, check.Equals, "blabla")
log.Printf("%v", err)
log.Println("13. Test delete by ExternalID - delete default policy")
policyOut = common.Policy{}
err = client.Delete(polURL, defPol, &policyOut)
if err != nil {
c.Fatal(err)
}
log.Printf("Deleted policy result: %s", policyOut)
c.Assert(policyOut.Name, check.Equals, defPol.Name)
c.Assert(client.GetStatusCode(), check.Equals, 200)
log.Println("14. Test list policies - should have 0 now")
err = client.Get(polURL, &policies)
if err != nil {
c.Fatal(err)
}
c.Assert(len(policies), check.Equals, 0)
log.Println("15. Test delete by ExternalID - delete default policy - should be Not Found error now")
policyOut = common.Policy{}
err = client.Delete(polURL, defPol, &policyOut)
if err == nil {
panic("Expected error")
}
httpErr = err.(common.HttpError)
c.Assert(client.GetStatusCode(), check.Equals, http.StatusNotFound)
c.Assert(httpErr.ResourceType, check.Equals, "policy")
c.Assert(httpErr.StatusCode, check.Equals, http.StatusNotFound)
// TODO
// Important! This should really be done in policy agent.
// Only done here as temporary measure.
id := makeId(defPol.AppliedTo, defPol.Name)
c.Assert(httpErr.ResourceID, check.Equals, id)
// c.Assert(httpErr.ResourceID, check.Equals, "default")
log.Printf("%v", err)
}
func (s *MySuite) TestHooks(c *check.C) {
fmt.Println("Entering TestHooks")
dir, _ := os.Getwd()
fmt.Println("In", dir)
yamlFileName := "../common/testdata/romana.hooks.yaml"
svcInfo, err := Run(yamlFileName)
if err != nil {
fmt.Println(err.Error())
}
fmt.Println("Waiting for message")
msg := <-svcInfo.Channel
fmt.Println("Root service said:", msg)
rootURL := fmt.Sprintf("http://%s", svcInfo.Address)
client, err := common.NewRestClient(common.GetDefaultRestClientConfig(rootURL))
if err != nil {
c.Fatal(err)
}
result1 := make(map[string]interface{})
err = client.Get("/config/ipam", &result1)
if err != nil {
c.Fatal(err)
}
fmt.Println("Received: ", result1)
file, err := os.Open("/tmp/hook.txt")
if err != nil {
c.Fatal(err)
}
data := make([]byte, 1024)
n, err := file.Read(data)
if err != nil {
c.Fatal(err)
}
str := strings.TrimSpace(string(data[0:n]))
fmt.Printf("Hook output: [%s]", str)
expect := "Hello, world and body= serviceName=ipam"
if str != expect {
c.Fatalf("Expected %s, received %s", expect, str)
}
url := fmt.Sprintf("%s/config/ipam/port", rootURL)
result2 := make(map[string]interface{})
portMsg := common.PortUpdateMessage{Port: 12345}
err = client.Post(url, portMsg, &result2)
fmt.Printf("Got %v", err)
if err == nil {
c.Fatal("Expected error, got nothing")
}
fmt.Println("Received: ", result2)
file, err = os.Open("/tmp/hook_bad.txt")
if err != nil {
c.Fatal(err)
}
data = make([]byte, 1024)
n, err = file.Read(data)
if err != nil {
c.Fatal(err)
}
str = strings.TrimSpace(string(data[0:n]))
fmt.Printf("Hook output: [%s]", str)
expect = "Good-bye, cruel world"
if str != expect {
c.Fatalf("Expected %s, received %s", expect, str)
}
}
// Test the topology service
func (s *MySuite) TestTopology(c *check.C) {
myLog(c, "Entering TestTopology()")
dir, _ := os.Getwd()
myLog(c, "In", dir)
myLog(c, "Starting topology service")
topoSvc := &TopologySvc{}
svcInfo, err := common.SimpleStartService(topoSvc, s.rootURL)
if err != nil {
c.Error(err)
}
msg := <-svcInfo.Channel
myLog(c, "Topology service said:", msg)
addr := "http://" + svcInfo.Address
client, err := common.NewRestClient(common.GetDefaultRestClientConfig(addr))
if err != nil {
c.Error(err)
}
myLog(c, "Calling ", addr)
topIndex := &common.IndexResponse{}
err = client.Get("/", &topIndex)
if err != nil {
c.Error(err)
c.FailNow()
}
c.Assert(topIndex.ServiceName, check.Equals, "topology")
hostsRelURL := topIndex.Links.FindByRel("host-list")
hostsURL := addr + hostsRelURL
myLog(c, "Host list URL: ", hostsURL)
// Get list of hosts - should be empty for now.
var hostList []common.Host
err = client.Get(hostsRelURL, &hostList)
if err != nil {
c.Error(err)
c.FailNow()
}
myLog(c, "Host list: ", hostList)
c.Assert(len(hostList), check.Equals, 0)
newHostReq := common.Host{Ip: "10.10.10.10", AgentPort: 9999, Name: "host10", RomanaIp: "15.15.15.15"}
newHostResp := common.Host{}
err = client.Post(hostsRelURL, newHostReq, &newHostResp)
if err != nil {
c.Error(err)
c.FailNow()
}
myLog(c, "Response: ", newHostResp)
myLog(c, "Waiting for....", time.Hour)
// time.Sleep(time.Hour)
c.Assert(newHostResp.Ip, check.Equals, "10.10.10.10")
c.Assert(newHostResp.ID, check.Equals, uint64(1))
newHostReq = common.Host{Ip: "10.10.10.11", AgentPort: 9999, Name: "host11", RomanaIp: "15.15.15.16"}
newHostResp = common.Host{}
err = client.Post(hostsRelURL, newHostReq, &newHostResp)
if err != nil {
c.Error(err)
c.FailNow()
}
myLog(c, "Response: ", newHostResp)
c.Assert(newHostResp.ID, check.Equals, uint64(2))
err = client.Post(hostsRelURL, newHostReq, &newHostResp)
httpErr := err.(common.HttpError)
myLog(c, "Attempt to add duplicate host: %v", httpErr)
c.Assert(httpErr.StatusCode, check.Equals, 409)
newHostReqWithoutRomanaIP := common.Host{Ip: "10.10.10.12", AgentPort: 9999, Name: "host12"}
newHostRespWithoutRomanaIP := common.Host{}
err = client.Post(hostsRelURL, newHostReqWithoutRomanaIP, &newHostRespWithoutRomanaIP)
if err != nil {
c.Error(err)
c.FailNow()
}
myLog(c, "Response: ", newHostRespWithoutRomanaIP)
c.Assert(newHostRespWithoutRomanaIP.Ip, check.Equals, "10.10.10.12")
c.Assert(newHostRespWithoutRomanaIP.RomanaIp, check.Equals, "10.2.0.0/16")
c.Assert(newHostRespWithoutRomanaIP.ID, check.Equals, uint64(3))
newHostReqWithoutRomanaIP = common.Host{Ip: "10.10.10.13", AgentPort: 9999, Name: "host13"}
newHostRespWithoutRomanaIP = common.Host{}
err = client.Post(hostsRelURL, newHostReqWithoutRomanaIP, &newHostRespWithoutRomanaIP)
if err != nil {
c.Error(err)
c.FailNow()
}
myLog(c, "Response: ", newHostRespWithoutRomanaIP)
c.Assert(newHostRespWithoutRomanaIP.Ip, check.Equals, "10.10.10.13")
c.Assert(newHostRespWithoutRomanaIP.RomanaIp, check.Equals, "10.3.0.0/16")
c.Assert(newHostRespWithoutRomanaIP.ID, check.Equals, uint64(4))
// TODO: auto generation of romana cidr currently don't
// handle manually assigned one gracefully, thus tests
// to be added here once that support is added.
var hostList2 []common.Host
err = client.Get(hostsRelURL, &hostList2)
if err != nil {
c.Error(err)
c.FailNow()
}
myLog(c, "Host list: ", hostList2)
c.Assert(len(hostList2), check.Equals, 4)
}