func TestMasterService(t *testing.T) {
_, s := framework.RunAMaster(framework.NewIntegrationTestMasterConfig())
defer s.Close()
client := client.NewOrDie(&restclient.Config{Host: s.URL, ContentConfig: restclient.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}})
err := wait.Poll(time.Second, time.Minute, func() (bool, error) {
svcList, err := client.Services(api.NamespaceDefault).List(api.ListOptions{})
if err != nil {
t.Errorf("unexpected error: %v", err)
return false, nil
}
found := false
for i := range svcList.Items {
if svcList.Items[i].Name == "kubernetes" {
found = true
}
}
if found {
ep, err := client.Endpoints(api.NamespaceDefault).Get("kubernetes")
if err != nil {
return false, nil
}
if countEndpoints(ep) == 0 {
return false, fmt.Errorf("no endpoints for kubernetes service: %v", ep)
}
return true, nil
}
return false, nil
})
if err != nil {
t.Errorf("unexpected error: %v", err)
}
}
func TestMasterService(t *testing.T) {
// TODO: Limit the test to a single non-default namespace and clean this up at the end.
framework.DeleteAllEtcdKeys()
m, err := master.New(framework.NewIntegrationTestMasterConfig())
if err != nil {
t.Fatalf("Error in bringing up the master: %v", err)
}
s := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
m.Handler.ServeHTTP(w, req)
}))
defer s.Close()
client := client.NewOrDie(&restclient.Config{Host: s.URL, ContentConfig: restclient.ContentConfig{GroupVersion: testapi.Default.GroupVersion()}})
err = wait.Poll(time.Second, time.Minute, func() (bool, error) {
svcList, err := client.Services(api.NamespaceDefault).List(api.ListOptions{})
if err != nil {
t.Errorf("unexpected error: %v", err)
return false, nil
}
found := false
for i := range svcList.Items {
if svcList.Items[i].Name == "kubernetes" {
found = true
}
}
if found {
ep, err := client.Endpoints(api.NamespaceDefault).Get("kubernetes")
if err != nil {
return false, nil
}
if countEndpoints(ep) == 0 {
return false, fmt.Errorf("no endpoints for kubernetes service: %v", ep)
}
return true, nil
}
return false, nil
})
if err != nil {
t.Errorf("unexpected error: %v", err)
}
}
// Find all sibling pods in the service and post to their /write handler.
func contactOthers(state *State) {
defer state.doneContactingPeers()
client, err := client.NewInCluster()
if err != nil {
log.Fatalf("Unable to create client; error: %v\n", err)
}
// Double check that that worked by getting the server version.
if v, err := client.Discovery().ServerVersion(); err != nil {
log.Fatalf("Unable to get server version: %v\n", err)
} else {
log.Printf("Server version: %#v\n", v)
}
// Do this repeatedly, in case there's some propagation delay with getting
// newly started pods into the endpoints list.
for i := 0; i < 15; i++ {
endpoints, err := client.Endpoints(*namespace).Get(*service)
if err != nil {
state.Logf("Unable to read the endpoints for %v/%v: %v; will try again.", *namespace, *service, err)
time.Sleep(time.Duration(1+rand.Intn(10)) * time.Second)
}
eps := sets.String{}
for _, ss := range endpoints.Subsets {
for _, a := range ss.Addresses {
for _, p := range ss.Ports {
eps.Insert(fmt.Sprintf("http://%s:%d", a.IP, p.Port))
}
}
}
for ep := range eps {
state.Logf("Attempting to contact %s", ep)
contactSingle(ep, state)
}
time.Sleep(5 * time.Second)
}
}
func main() {
flag.Parse()
log.Println("Connecting to kubernetes via url " + kServer)
log.Println("Connecting to vulcand via url " + vServer)
log.Println("Provided label query: " + labelQuery)
log.Println("Observing endpoints within namespace: " + namespace)
vClient := vClient.NewClient(vServer, vPlugin.NewRegistry())
kClient, err := kClient.New(&kClient.Config{Host: kServer})
if err != nil {
log.Println("Error encountered when connecting to kubernetes api." + err.Error())
panic(err)
}
var labelSelector labels.Selector = nil
if labelQuery != "" {
labelSelector, err = labels.Parse(labelQuery)
if err != nil {
log.Println("Error parsing the provided label query.")
panic(err)
}
} else {
labelSelector = labels.Everything()
}
socket, err := kClient.Endpoints(namespace).
Watch(labelSelector, fields.Everything(), api.ListOptions{Watch: true})
if err != nil {
log.Println("Error obtaining a watch on the kubernetes endpoints.")
panic(err)
}
// poll the channel indefinitely
for {
select {
case event := <-socket.ResultChan():
switch event.Type {
case watch.Added:
endpoint, _ := deserialize(event.Object)
ensureEndpointConfiguredForVulcand(vClient, endpoint)
log.Println("Endpoint was added: \n" + endpoint.Name)
case watch.Modified:
endpoint, _ := deserialize(event.Object)
ensureEndpointConfiguredForVulcand(vClient, endpoint)
log.Println("Endpoint was modified: \n" + endpoint.Name)
case watch.Deleted:
endpoint, _ := deserialize(event.Object)
removeUnusedEndpointsFromVulcand(vClient, endpoint)
log.Println("Endpoint was deleted: \n" + endpoint.Name)
case watch.Error:
log.Println("Encountered an error from the endpoints socket. Continuing...")
}
default:
time.Sleep(1 * time.Second)
}
}
}