示例#1
0
func setupServer(t *testing.T, rest_port, rep_port uint16, cl cluster.Cluster) (replication.Replication, api.Server) {
	var rep replication.Replication
	var server api.Server
	networkAvailable := network.WaitForPrivateNetwork()
	assert.NotNil(t, networkAvailable)

	// Configure and create the cluster module
	if cl == nil {
		return nil, nil
	}
	var err error

	// Configure and create the replication module
	self := cluster.NewMember(network.GetPrivateIP(), rep_port)
	repConfig := &replication.Config{
		Membership:  cl.Membership(),
		Registrator: cl.Registrator(self),
	}
	rep, err = replication.New(repConfig)
	assert.NoError(t, err)
	assert.NotNil(t, rep)

	regConfig := &store.Config{
		DefaultTTL:        time.Duration(30) * time.Second,
		MinimumTTL:        time.Duration(10) * time.Second,
		MaximumTTL:        time.Duration(600) * time.Second,
		SyncWaitTime:      time.Duration(defaultSyncWaitTime) * time.Second,
		NamespaceCapacity: 50,
	}

	reg := store.New(regConfig, rep)
	server, err = api.NewServer(
		&api.Config{
			HTTPAddressSpec: fmt.Sprintf(":%d", rest_port),
			Registry:        reg,
		},
	)

	assert.NoError(t, err)
	assert.NotNil(t, server)

	// Start the API server, and "wait" for it to bind
	go server.Start()
	time.Sleep(100 * time.Millisecond)

	return rep, server
}
示例#2
0
func createMember(port uint16) cluster.Member {
	return cluster.NewMember(network.GetPrivateIP(), port)
}
示例#3
0
func TestGzippedReplication(t *testing.T) {
	if testing.Short() {
		t.Skip()
	}

	cluster := createCluster()

	member1 := createMember(6106)
	repServer1, _ := New(&Config{
		Registrator: cluster.Registrator(member1),
		Membership:  cluster.Membership()})
	defer repServer1.Stop()
	<-repServer1.Sync(1)

	member2 := createMember(6206)
	repServer2, _ := New(&Config{
		Registrator: cluster.Registrator(member2),
		Membership:  cluster.Membership()})
	defer repServer2.Stop()
	<-repServer2.Sync(1)

	var resp *http.Response

	replicator2, _ := repServer2.GetReplicator(auth.NamespaceFrom("ns1"))

	client := http.Client{Transport: &http.Transport{MaxIdleConnsPerHost: 1}}

	var requestData bytes.Buffer
	for i := 0; i < 100; i++ {
		requestData.Write([]byte("9999999999999999999999999999999999"))
	}

	// Iterate over both sync and replication HTTP endpoints
	for _, serviceType := range []string{syncContext, repContext} {
		// Iterate over both content-encoding options- gzip and no zip (identity)
		for _, encoding := range []string{"gzip", "identity"} {
			var dec decoder
			var unZipper *gzip.Reader
			var respBuff bytes.Buffer

			// prepare event that triggers a replication or a sync
			if serviceType == repContext {
				time.AfterFunc(time.Duration(2)*time.Second, func() {
					replicator2.Broadcast(requestData.Bytes())
				})
			} else {
				// grab the channel that was created for us
				// insert an entity inside it and close the channel to signal sync finish
				outMsg := &outMessage{Data: requestData.Bytes()}
				buff, _ := json.Marshal(outMsg)
				time.AfterFunc(time.Duration(2)*time.Second, func() {
					ch := <-repServer2.SyncRequest()
					ch <- buff
					close(ch)
				})
			}

			url := fmt.Sprintf("http://%s:%d/%s/%s", network.GetPrivateIP(), 6206, version, serviceType)
			req, _ := http.NewRequest("GET", url, nil)
			req.Header.Set("Accept-Encoding", encoding)
			req.Header.Set(headerMemberID, "fake member id")
			resp, _ = client.Do(req)
			// wait 4 sec to read enough data, since ioutil.ReadAll blocks until EOF
			// and we use an indefinite connection in case of replication service endpoint
			if serviceType == repContext {
				time.AfterFunc(time.Duration(4)*time.Second, func() { resp.Body.Close() })
			}
			responseData, _ := ioutil.ReadAll(resp.Body)
			respBuff.Write(responseData)

			// if we've sent a gzipped entity, decode it before comparing
			// but also ensure that the returned payload was compressed
			// by comparing the size of the payload to the size sent
			if encoding == "gzip" {
				assert.True(t, len(requestData.Bytes()) > len(responseData),
					"Seems like the gzip hasn't shrunk the payload size enough or at all")
				unZipper, _ = gzip.NewReader(&respBuff)
				dec.Reader = bufio.NewReader(unZipper)
			} else {
				dec.Reader = bufio.NewReader(&respBuff)
			}

			event, _ := dec.Decode()
			if encoding == "gzip" {
				unZipper.Close()
			}
			var entityFromServer outMessage
			json.Unmarshal([]byte(event.Data()), &entityFromServer)
			assert.Equal(t, string(requestData.Bytes()), string(entityFromServer.Data),
				"Didn't receive the same content we sent in the case where encoding is %s", encoding)
		}
	}
}
示例#4
0
文件: main.go 项目: charshy/registry
// registryMain is the logical entry point for the service registry.
func registryMain(conf *config.Values) error {

	// Configure logging
	parsedLogLevel, err := logrus.ParseLevel(conf.LogLevel)
	if err != nil {
		return err
	}
	logrus.SetLevel(parsedLogLevel)

	formatter, err := logging.GetLogFormatter(conf.LogFormat)
	if err != nil {
		return err
	}
	logrus.SetFormatter(formatter)

	// Configure locales and translations
	err = i18n.LoadLocales("./locales")
	if err != nil {
		return err
	}

	var rep replication.Replication
	if conf.Replication {

		// Wait for private network to become available
		// In some cloud environments, that may take several seconds
		networkAvailable := network.WaitForPrivateNetwork()
		if !networkAvailable {
			return fmt.Errorf("No private network is available within defined timeout")
		}

		// Configure and create the cluster module
		clConfig := &cluster.Config{
			BackendType: cluster.FilesystemBackend,
			Directory:   conf.ClusterDirectory,
			Size:        conf.ClusterSize,
		}
		cl, err := cluster.New(clConfig)
		if err != nil {
			return fmt.Errorf("Failed to create the cluster module: %s", err)
		}

		// Configure and create the replication module
		self := cluster.NewMember(network.GetPrivateIP(), conf.ReplicationPort)
		repConfig := &replication.Config{
			Membership:  cl.Membership(),
			Registrator: cl.Registrator(self),
		}
		rep, err = replication.New(repConfig)
		if err != nil {
			return fmt.Errorf("Failed to create the replication module: %s", err)
		}
	}

	var authenticator auth.Authenticator
	if len(conf.AuthModes) > 0 {
		auths := make([]auth.Authenticator, len(conf.AuthModes))
		for i, mode := range conf.AuthModes {
			switch mode {
			case "trusted":
				auths[i] = auth.NewTrustedAuthenticator()
			case "jwt":
				jwtAuth, err := auth.NewJWTAuthenticator([]byte(conf.JWTSecret))
				if err != nil {
					return fmt.Errorf("Failed to create the authentication module: %s", err)
				}
				auths[i] = jwtAuth
			default:
				return fmt.Errorf("Failed to create the authentication module: unrecognized authentication mode '%s'", err)
			}
		}
		authenticator, err = auth.NewChainAuthenticator(auths)
		if err != nil {
			return err
		}
	} else {
		authenticator = auth.DefaultAuthenticator()
	}

	regConfig := &store.Config{
		DefaultTTL:        conf.DefaultTTL,
		MinimumTTL:        conf.MinTTL,
		MaximumTTL:        conf.MaxTTL,
		SyncWaitTime:      conf.SyncTimeout,
		NamespaceCapacity: conf.NamespaceCapacity,
	}
	reg := store.New(regConfig, rep)

	serverConfig := &api.Config{
		HTTPAddressSpec: fmt.Sprintf(":%d", conf.APIPort),
		Registry:        reg,
		Authenticator:   authenticator,
		RequireHTTPS:    conf.RequireHTTPS,
	}
	server, err := api.NewServer(serverConfig)
	if err != nil {
		return err
	}

	go metrics.DumpPeriodically()

	return server.Start()
}