Exemplo n.º 1
0
func (s *HTTPSuite) TestUpdateServiceDefaults(c *C) {
	svcCfg := client.ServiceConfig{
		Name: "TestService",
		Addr: "127.0.0.1:9000",
		Backends: []client.BackendConfig{
			client.BackendConfig{
				Name: "Backend1",
				Addr: "127.0.0.1:9001",
			},
		},
	}

	svcDef := bytes.NewBuffer(svcCfg.Marshal())
	req, _ := http.NewRequest("PUT", s.httpSvr.URL+"/TestService", svcDef)
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		c.Fatal(err)
	}
	resp.Body.Close()

	// Now update the Service in-place
	svcCfg.ServerTimeout = 1234
	svcDef.Reset()
	svcDef.Write(svcCfg.Marshal())

	req, _ = http.NewRequest("PUT", s.httpSvr.URL+"/TestService", svcDef)
	resp, err = http.DefaultClient.Do(req)
	if err != nil {
		c.Fatal(err)
	}

	body, _ := ioutil.ReadAll(resp.Body)
	resp.Body.Close()

	config := client.Config{}
	err = json.Unmarshal(body, &config)
	if err != nil {
		c.Fatal(err)
	}

	// make sure we don't see a second value
	found := false

	for _, svc := range config.Services {
		if svc.Name == "TestService" {
			if svc.ServerTimeout != svcCfg.ServerTimeout {
				c.Fatal("Service not updated")
			} else if found {
				c.Fatal("Multiple Service Definitions")
			}
			found = true
		}
	}
}
Exemplo n.º 2
0
func (s *HTTPSuite) TestSimulAdd(c *C) {
	start := make(chan struct{})
	testWG := new(sync.WaitGroup)

	svcCfg := client.ServiceConfig{
		Name:         "TestService",
		Addr:         "127.0.0.1:9000",
		VirtualHosts: []string{"test-vhost"},
		Backends: []client.BackendConfig{
			client.BackendConfig{
				Name: "vhost1",
				Addr: "127.0.0.1:9001",
			},
			client.BackendConfig{
				Name: "vhost2",
				Addr: "127.0.0.1:9002",
			},
		},
	}

	for i := 0; i < 8; i++ {
		testWG.Add(1)
		go func() {
			defer testWG.Done()
			//wait to start all at once
			<-start
			svcDef := bytes.NewReader(svcCfg.Marshal())
			req, _ := http.NewRequest("PUT", s.httpSvr.URL+"/TestService", svcDef)
			resp, err := http.DefaultClient.Do(req)
			if err != nil {
				c.Fatal(err)
			}

			body, _ := ioutil.ReadAll(resp.Body)

			respCfg := client.Config{}
			err = json.Unmarshal(body, &respCfg)

			// We're only checking to ensure we have 1 service with the proper number of backends
			c.Assert(len(respCfg.Services), Equals, 1)
			c.Assert(len(respCfg.Services[0].Backends), Equals, 2)
			c.Assert(len(respCfg.Services[0].VirtualHosts), Equals, 1)
		}()
	}

	close(start)
	testWG.Wait()
}
Exemplo n.º 3
0
// Set some global defaults, and check that a new service inherits them all
func (s *HTTPSuite) TestGlobalDefaults(c *C) {
	globalCfg := client.Config{
		Balance:       "LC",
		CheckInterval: 101,
		Fall:          7,
		Rise:          8,
		ClientTimeout: 102,
		ServerTimeout: 103,
		DialTimeout:   104,
	}

	globalDef := bytes.NewBuffer(globalCfg.Marshal())
	req, _ := http.NewRequest("PUT", s.httpSvr.URL+"/", globalDef)
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		c.Fatal(err)
	}
	resp.Body.Close()

	svcCfg := client.ServiceConfig{
		Name: "TestService",
		Addr: "127.0.0.1:9000",
	}

	svcDef := bytes.NewBuffer(svcCfg.Marshal())
	req, _ = http.NewRequest("PUT", s.httpSvr.URL+"/TestService", svcDef)
	resp, err = http.DefaultClient.Do(req)
	if err != nil {
		c.Fatal(err)
	}
	resp.Body.Close()

	config := Registry.Config()

	c.Assert(len(config.Services), Equals, 1)
	service := config.Services[0]

	c.Assert(globalCfg.Balance, Equals, service.Balance)
	c.Assert(globalCfg.CheckInterval, Equals, service.CheckInterval)
	c.Assert(globalCfg.Fall, Equals, service.Fall)
	c.Assert(globalCfg.Rise, Equals, service.Rise)
	c.Assert(globalCfg.ClientTimeout, Equals, service.ClientTimeout)
	c.Assert(globalCfg.ServerTimeout, Equals, service.ServerTimeout)
	c.Assert(globalCfg.DialTimeout, Equals, service.DialTimeout)
}
Exemplo n.º 4
0
func (s *HTTPSuite) TestHTTPAddRemoveBackends(c *C) {
	svcCfg := client.ServiceConfig{
		Name: "VHostTest",
		Addr: "127.0.0.1:9000",
	}

	err := Registry.AddService(svcCfg)
	if err != nil {
		c.Fatal(err)
	}

	for _, srv := range s.backendServers {
		cfg := client.BackendConfig{
			Addr: srv.addr,
			Name: srv.addr,
		}
		svcCfg.Backends = append(svcCfg.Backends, cfg)
	}

	req, _ := http.NewRequest("PUT", s.httpSvr.URL+"/VHostTest", bytes.NewReader(svcCfg.Marshal()))
	_, err = http.DefaultClient.Do(req)
	if err != nil {
		c.Fatal(err)
	}

	cfg := Registry.Config()
	if !svcCfg.DeepEqual(cfg.Services[0]) {
		c.Errorf("we should have 1 service, we have %d", len(cfg.Services))
		c.Errorf("we should have 4 backends, we have %d", len(cfg.Services[0].Backends))
	}

	// remove a backend from the config and submit it again
	svcCfg.Backends = svcCfg.Backends[:3]
	err = Registry.UpdateService(svcCfg)
	if err != nil {
		c.Fatal(err)
	}

	req, _ = http.NewRequest("PUT", s.httpSvr.URL+"/VHostTest", bytes.NewReader(svcCfg.Marshal()))
	_, err = http.DefaultClient.Do(req)
	if err != nil {
		c.Fatal(err)
	}

	// now check the config via what's returned from the http server
	resp, err := http.Get(s.httpSvr.URL + "/_config")
	if err != nil {
		c.Fatal(err)
	}
	defer resp.Body.Close()

	cfg = client.Config{}
	body, _ := ioutil.ReadAll(resp.Body)
	err = json.Unmarshal(body, &cfg)
	if err != nil {
		c.Fatal(err)
	}

	if !svcCfg.DeepEqual(cfg.Services[0]) {
		c.Errorf("we should have 1 service, we have %d", len(cfg.Services))
		c.Errorf("we should have 3 backends, we have %d", len(cfg.Services[0].Backends))
	}
}