// TestVtctlThrottlerCommands tests all vtctl commands from the
// "Resharding Throttler" group.
func TestVtctlThrottlerCommands(t *testing.T) {
// Run a throttler server using the default process throttle manager.
listener, err := net.Listen("tcp", ":0")
if err != nil {
t.Fatalf("Cannot listen: %v", err)
}
s := grpc.NewServer()
go s.Serve(listener)
grpcthrottlerserver.StartServer(s, throttler.GlobalManager)
addr := fmt.Sprintf("localhost:%v", listener.Addr().(*net.TCPAddr).Port)
ts := zktestserver.New(t, []string{"cell1", "cell2"})
vp := NewVtctlPipe(t, ts)
defer vp.Close()
// Get and set rate commands do not fail when no throttler is registered.
{
got, err := vp.RunAndOutput([]string{"ThrottlerMaxRates", "-server", addr})
if err != nil {
t.Fatalf("VtctlPipe.RunAndStreamOutput() failed: %v", err)
}
want := "no active throttlers"
if !strings.Contains(got, want) {
t.Fatalf("ThrottlerMaxRates() = %v, want substring = %v", got, want)
}
}
{
got, err := vp.RunAndOutput([]string{"ThrottlerSetMaxRate", "-server", addr, "23"})
if err != nil {
t.Fatalf("VtctlPipe.RunAndStreamOutput() failed: %v", err)
}
want := "no active throttlers"
if !strings.Contains(got, want) {
t.Fatalf("ThrottlerSetMaxRate(23) = %v, want substring = %v", got, want)
}
}
// Add a throttler and check the commands again.
t1, err := throttler.NewThrottler("t1", "TPS", 1 /* threadCount */, 2323, throttler.ReplicationLagModuleDisabled)
if err != nil {
t.Fatal(err)
}
defer t1.Close()
// MaxRates() will return the initial rate.
expectRate(t, vp, addr, "2323")
// Disable the module by setting the rate to 'unlimited'.
setRate(t, vp, addr, "unlimited")
expectRate(t, vp, addr, "unlimited")
// Re-enable it by setting a limit.
setRate(t, vp, addr, "9999")
expectRate(t, vp, addr, "9999")
}
// TestThrottlerServerPanics tests the panic handling of the gRPC throttler
// server implementation.
func TestThrottlerServerPanics(t *testing.T) {
s, port := startGRPCServer(t)
// For testing the panic handling, use a fake Manager instead.
grpcthrottlerserver.StartServer(s, &throttlerclienttest.FakeManager{})
// Create a ThrottlerClient gRPC client to talk to the throttler.
client, err := factory(fmt.Sprintf("localhost:%v", port))
if err != nil {
t.Fatalf("Cannot create client: %v", err)
}
defer client.Close()
throttlerclienttest.TestSuitePanics(t, client)
}
// TestThrottlerServer tests the gRPC implementation using a throttler client
// and server.
func TestThrottlerServer(t *testing.T) {
s, port := startGRPCServer(t)
// Use the global manager which is a singleton.
grpcthrottlerserver.StartServer(s, throttler.GlobalManager)
// Create a ThrottlerClient gRPC client to talk to the throttler.
client, err := factory(fmt.Sprintf("localhost:%v", port))
if err != nil {
t.Fatalf("Cannot create client: %v", err)
}
defer client.Close()
throttlerclienttest.TestSuite(t, client)
}
