// the test here creates a fake server implementation, a fake client
// implementation, and runs the test suite against the setup.
func TestGoRPCBinlogStreamer(t *testing.T) {
// Listen on a random port
listener, err := net.Listen("tcp", ":0")
if err != nil {
t.Fatalf("Cannot listen: %v", err)
}
host := listener.Addr().(*net.TCPAddr).IP.String()
port := listener.Addr().(*net.TCPAddr).Port
// Create a Go Rpc server and listen on the port
server := rpcplus.NewServer()
fakeUpdateStream := binlogplayertest.NewFakeBinlogStreamer(t)
server.Register(gorpcbinlogstreamer.New(fakeUpdateStream))
// create the HTTP server, serve the server from it
handler := http.NewServeMux()
bsonrpc.ServeCustomRPC(handler, server)
httpServer := http.Server{
Handler: handler,
}
go httpServer.Serve(listener)
// Create a Go Rpc client to talk to the fake tablet
c := &client{}
// and send it to the test suite
binlogplayertest.Run(t, c, &pb.EndPoint{
Host: host,
PortMap: map[string]int32{
"vt": int32(port),
},
}, fakeUpdateStream)
}
// the test here creates a fake server implementation, a fake client
// implementation, and runs the test suite against the setup.
func TestGoRPCBinlogStreamer(t *testing.T) {
// Listen on a random port
listener, err := net.Listen("tcp", ":0")
if err != nil {
t.Fatalf("Cannot listen: %v", err)
}
// Create a Go Rpc server and listen on the port
server := rpcplus.NewServer()
fakeUpdateStream := binlogplayertest.NewFakeBinlogStreamer(t)
server.Register(gorpcbinlogstreamer.New(fakeUpdateStream))
// create the HTTP server, serve the server from it
handler := http.NewServeMux()
bsonrpc.ServeCustomRPC(handler, server, false)
httpServer := http.Server{
Handler: handler,
}
go httpServer.Serve(listener)
// Create a Go Rpc client to talk to the fake tablet
client := &GoRpcBinlogPlayerClient{}
// and send it to the test suite
binlogplayertest.Run(t, client, listener.Addr().String(), fakeUpdateStream)
}
// This test makes sure the go rpc service works
func testGoRPCTabletConn(t *testing.T) {
// fake service
service := tabletconntest.CreateFakeServer(t)
// listen on a random port
listener, err := net.Listen("tcp", ":0")
if err != nil {
t.Fatalf("Cannot listen: %v", err)
}
defer listener.Close()
port := listener.Addr().(*net.TCPAddr).Port
// Create a Go Rpc server and listen on the port
server := rpcplus.NewServer()
server.Register(gorpcqueryservice.New(service))
// create the HTTP server, serve the server from it
handler := http.NewServeMux()
bsonrpc.ServeCustomRPC(handler, server)
httpServer := http.Server{
Handler: handler,
}
go httpServer.Serve(listener)
// run the test suite
tabletconntest.TestSuite(t, protocolName, &pb.EndPoint{
Host: "localhost",
PortMap: map[string]int32{
"vt": int32(port),
},
}, service)
}
// TestGoRPCGoClient tests the go client using goRPC
func TestGoRPCGoClient(t *testing.T) {
service := createService()
// listen on a random port
listener, err := net.Listen("tcp", ":0")
if err != nil {
t.Fatalf("Cannot listen: %v", err)
}
defer listener.Close()
// Create a Go Rpc server and listen on the port
server := rpcplus.NewServer()
server.Register(gorpcvtgateservice.New(service))
// create the HTTP server, serve the server from it
handler := http.NewServeMux()
bsonrpc.ServeCustomRPC(handler, server, false)
httpServer := http.Server{
Handler: handler,
}
go httpServer.Serve(listener)
// and run the test suite
testGoClient(t, "gorpc", listener.Addr().String())
}
func TestMain(m *testing.M) {
// fake service
service := CreateFakeServer()
// listen on a random port
listener, err := net.Listen("tcp", ":0")
if err != nil {
panic(fmt.Sprintf("Cannot listen: %v", err))
}
// Create a Go Rpc server and listen on the port
server := rpcplus.NewServer()
server.Register(gorpcvtgateservice.New(service))
// create the HTTP server, serve the server from it
handler := http.NewServeMux()
bsonrpc.ServeCustomRPC(handler, server, false)
httpServer := http.Server{
Handler: handler,
}
go httpServer.Serve(listener)
testAddress = listener.Addr().String()
os.Exit(m.Run())
}
func main() {
server := rpcplus.NewServer()
server.Register(new(twitterapi.Account))
server.Register(new(twitterapi.Profile))
server.Register(new(twitterapi.Tweet))
rpcwrap.ServeCustomRPC(
Mux,
server,
false, // use auth
"json", // codec name
jsonrpc.NewServerCodec,
)
rpcwrap.ServeHTTPRPC(
Mux, // httpmuxer
server, // rpcserver
"http_json", // codec name
jsonrpc.NewServerCodec, // jsoncodec
ContextCreator, // contextCreator
)
fmt.Println("Server listening on 3000")
http.ListenAndServe("localhost:3000", Mux)
}
func startListeningWithContext(ctx context.Context) net.Listener {
server := rpcplus.NewServer()
server.Register(new(Arith))
mux := http.NewServeMux()
contextCreator := func(req *http.Request) context.Context {
return ctx
}
ServeHTTPRPC(
mux, // httpmuxer
server, // rpcserver
"json", // codec name
jsonrpc.NewServerCodec, // jsoncodec
contextCreator, // contextCreator
)
l, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
log.Fatal(err)
}
go http.Serve(l, mux)
return l
}
// This test makes sure the go rpc service works
func TestGoRPCVTGateConn(t *testing.T) {
// fake service
service := vtgateconntest.CreateFakeServer(t)
// listen on a random port
listener, err := net.Listen("tcp", ":0")
if err != nil {
t.Fatalf("Cannot listen: %v", err)
}
// Create a Go Rpc server and listen on the port
server := rpcplus.NewServer()
server.Register(gorpcvtgateservice.New(service))
// create the HTTP server, serve the server from it
handler := http.NewServeMux()
bsonrpc.ServeCustomRPC(handler, server, false)
httpServer := http.Server{
Handler: handler,
}
go httpServer.Serve(listener)
// Create a Go RPC client connecting to the server
ctx := context.Background()
client, err := dial(ctx, listener.Addr().String(), 30*time.Second)
if err != nil {
t.Fatalf("dial failed: %v", err)
}
// run the test suite
vtgateconntest.TestSuite(t, client, service)
// and clean up
client.Close()
}
// StartActionLoop will start the action loop for a fake tablet,
// using ft.FakeMysqlDaemon as the backing mysqld.
func (ft *FakeTablet) StartActionLoop(t *testing.T, wr *wrangler.Wrangler) {
if ft.Agent != nil {
t.Fatalf("Agent for %v is already running", ft.Tablet.Alias)
}
// Listen on a random port
var err error
ft.Listener, err = net.Listen("tcp", ":0")
if err != nil {
t.Fatalf("Cannot listen: %v", err)
}
port := ft.Listener.Addr().(*net.TCPAddr).Port
// create a test agent on that port, and re-read the record
// (it has new ports and IP)
ft.Agent = tabletmanager.NewTestActionAgent(context.Background(), wr.TopoServer(), ft.Tablet.Alias, port, ft.FakeMysqlDaemon)
ft.Tablet = ft.Agent.Tablet().Tablet
// create the RPC server
ft.RPCServer = rpcplus.NewServer()
gorpctmserver.RegisterForTest(ft.RPCServer, ft.Agent)
// create the HTTP server, serve the server from it
handler := http.NewServeMux()
bsonrpc.ServeCustomRPC(handler, ft.RPCServer, false)
ft.HTTPServer = http.Server{
Handler: handler,
}
go ft.HTTPServer.Serve(ft.Listener)
}
// the test here creates a fake server implementation, a fake client
// implementation, and runs the test suite against the setup.
func TestVtctlServer(t *testing.T) {
ts := vtctlclienttest.CreateTopoServer(t)
// Listen on a random port
listener, err := net.Listen("tcp", ":0")
if err != nil {
t.Fatalf("Cannot listen: %v", err)
}
// Create a Go Rpc server and listen on the port
server := rpcplus.NewServer()
server.Register(gorpcvtctlserver.NewVtctlServer(ts))
// Create the HTTP server, serve the server from it
handler := http.NewServeMux()
bsonrpc.ServeCustomRPC(handler, server)
httpServer := http.Server{
Handler: handler,
}
go httpServer.Serve(listener)
// Create a VtctlClient Go Rpc client to talk to the fake server
client, err := goRPCVtctlClientFactory(listener.Addr().String(), 30*time.Second)
if err != nil {
t.Fatalf("Cannot create client: %v", err)
}
defer client.Close()
vtctlclienttest.TestSuite(t, ts, client)
}
func NewRpcServer(address string) *RpcServer {
return &RpcServer{
rpc: rpc.NewServer(),
address: address,
exit: make(chan chan error),
}
}
// NewVtctlPipe creates a new VtctlPipe based on the given topo server.
func NewVtctlPipe(t *testing.T, ts topo.Server) *VtctlPipe {
// Listen on a random port
listener, err := net.Listen("tcp", ":0")
if err != nil {
t.Fatalf("Cannot listen: %v", err)
}
// Create a Go Rpc server and listen on the port
server := rpcplus.NewServer()
server.Register(gorpcvtctlserver.NewVtctlServer(ts))
// Create the HTTP server, serve the server from it
handler := http.NewServeMux()
bsonrpc.ServeCustomRPC(handler, server, false)
httpServer := http.Server{
Handler: handler,
}
go httpServer.Serve(listener)
// Create a VtctlClient Go Rpc client to talk to the fake server
client, err := vtctlclient.New(listener.Addr().String(), 30*time.Second)
if err != nil {
t.Fatalf("Cannot create client: %v", err)
}
return &VtctlPipe{
listener: listener,
client: client,
t: t,
}
}
func newRpcServer(opts ...Option) Server {
return &rpcServer{
opts: newOptions(opts...),
rpc: rpc.NewServer(),
handlers: make(map[string]Handler),
subscribers: make(map[*subscriber][]broker.Subscriber),
exit: make(chan chan error),
}
}
// This test makes sure the go rpc service works
func testGoRPCTabletConn(t *testing.T, rpcOnlyInReply bool) {
// fake service
service := tabletconntest.CreateFakeServer(t)
// listen on a random port
listener, err := net.Listen("tcp", ":0")
if err != nil {
t.Fatalf("Cannot listen: %v", err)
}
defer listener.Close()
port := listener.Addr().(*net.TCPAddr).Port
// Create a Go Rpc server and listen on the port
server := rpcplus.NewServer()
server.Register(gorpcqueryservice.New(service))
// create the HTTP server, serve the server from it
handler := http.NewServeMux()
bsonrpc.ServeCustomRPC(handler, server, false)
httpServer := http.Server{
Handler: handler,
}
go httpServer.Serve(listener)
// Handle errors appropriately
*tabletserver.RPCErrorOnlyInReply = rpcOnlyInReply
// Create a Go RPC client connecting to the server
ctx := context.Background()
client, err := DialTablet(ctx, topo.EndPoint{
Host: "localhost",
NamedPortMap: map[string]int{
"vt": port,
},
}, tabletconntest.TestKeyspace, tabletconntest.TestShard, 30*time.Second)
if err != nil {
t.Fatalf("dial failed: %v", err)
}
// run the test suite
tabletconntest.TestSuite(t, client, service)
// and clean up
client.Close()
}
// TestGoRPCVTGateConn makes sure the gorpc (BsonRPC) service works
func TestGoRPCVTGateConn(t *testing.T) {
// fake service
service := vtgateconntest.CreateFakeServer(t)
// listen on a random port
listener, err := net.Listen("tcp", ":0")
if err != nil {
t.Fatalf("Cannot listen: %v", err)
}
// Create a Go Rpc server and listen on the port
server := rpcplus.NewServer()
server.Register(gorpcvtgateservice.New(service))
// TODO(aaijazi): remove this flag once all VtGate Gorpc clients properly support the new behavior
*vtgate.RPCErrorOnlyInReply = true
// create the HTTP server, serve the server from it
handler := http.NewServeMux()
bsonrpc.ServeCustomRPC(handler, server)
httpServer := http.Server{
Handler: handler,
}
go httpServer.Serve(listener)
// Create a Go RPC client connecting to the server
ctx := context.Background()
client, err := dial(ctx, listener.Addr().String(), 30*time.Second)
if err != nil {
t.Fatalf("dial failed: %v", err)
}
vtgateconntest.RegisterTestDialProtocol(client)
// run the test suite
vtgateconntest.TestSuite(t, client, service)
vtgateconntest.TestErrorSuite(t, service)
// and clean up
client.Close()
}
// TestGoRPCVTGateConn makes sure the gorpc (BsonRPC) service works
func TestGoRPCVTGateConn(t *testing.T) {
// fake service
service := vtgateconntest.CreateFakeServer(t)
// listen on a random port
listener, err := net.Listen("tcp", ":0")
if err != nil {
t.Fatalf("Cannot listen: %v", err)
}
// Create a Go Rpc server and listen on the port
server := rpcplus.NewServer()
server.Register(gorpcvtgateservice.New(service))
// create the HTTP server, serve the server from it
handler := http.NewServeMux()
bsonrpc.ServeCustomRPC(handler, server)
httpServer := http.Server{
Handler: handler,
}
go httpServer.Serve(listener)
// Create a Go RPC client connecting to the server
ctx := context.Background()
client, err := dial(ctx, listener.Addr().String(), 30*time.Second)
if err != nil {
t.Fatalf("dial failed: %v", err)
}
vtgateconntest.RegisterTestDialProtocol(client)
// run the test suite
vtgateconntest.TestSuite(t, client, service)
// TODO(sougou/alainjobart): find out why this was commmented out for grpc.
// This is now failing for gorpc also.
//vtgateconntest.TestErrorSuite(t, service)
// and clean up
client.Close()
}
// the test here creates a fake server implementation, a fake client
// implementation, and runs the test suite against the setup.
func TestGoRPCTMServer(t *testing.T) {
// Listen on a random port
listener, err := net.Listen("tcp", ":0")
if err != nil {
t.Fatalf("Cannot listen: %v", err)
}
defer listener.Close()
port := int32(listener.Addr().(*net.TCPAddr).Port)
// Create a Go Rpc server and listen on the port
server := rpcplus.NewServer()
fakeAgent := agentrpctest.NewFakeRPCAgent(t)
server.Register(&TabletManager{fakeAgent})
// create the HTTP server, serve the server from it
handler := http.NewServeMux()
bsonrpc.ServeCustomRPC(handler, server)
httpServer := http.Server{
Handler: handler,
}
go httpServer.Serve(listener)
// Create a Go Rpc client to talk to the fake tablet
client := &gorpctmclient.GoRPCTabletManagerClient{}
ti := topo.NewTabletInfo(&pb.Tablet{
Alias: &pb.TabletAlias{
Cell: "test",
Uid: 123,
},
Hostname: "localhost",
PortMap: map[string]int32{
"vt": port,
},
}, 0)
// and run the test suite
agentrpctest.Run(t, client, ti, fakeAgent)
}
"github.com/youtube/vitess/go/rpcwrap/bsonrpc"
)
var (
// The flags used when calling RegisterDefaultSecureFlags.
SecurePort *int
CertFile *string
KeyFile *string
CACertFile *string
// Flags to alter the behavior of the library.
secureThrottle = flag.Int64("secure-accept-rate", 64, "Maximum number of secure connection accepts per second")
secureMaxBuffer = flag.Int("secure-max-buffer", 1500, "Maximum number of secure accepts allowed to accumulate")
// The rpc servers to use
secureRpcServer = rpcplus.NewServer()
authenticatedSecureRpcServer = rpcplus.NewServer()
)
// secureRegister registers the provided server to be served on the
// secure port, if enabled by the service map.
func secureRegister(name string, rcvr interface{}) {
if SecurePort == nil || *SecurePort == 0 {
return
}
if ServiceMap["bsonrpc-vts-"+name] {
log.Infof("Registering %v for bsonrpc over vts port, disable it with -bsonrpc-vts-%v service_map parameter", name, name)
secureRpcServer.Register(rcvr)
} else {
log.Infof("Not registering %v for bsonrpc over vts port, enable it with bsonrpc-vts-%v service_map parameter", name, name)
}
return err
}
if err = json.Unmarshal(data, c); err != nil {
return err
}
log.Infof("Loaded credentials from %s.", filename)
return nil
}
// CRAMMD5MaxRequests is the maximum number of requests that an
// unauthenticated client is allowed to make (this should be enough to
// perform authentication).
const CRAMMD5MaxRequests = 2
var (
AuthenticationServer = rpc.NewServer()
DefaultAuthenticatorCRAMMD5 = NewAuthenticatorCRAMMD5()
)
// AuthenticationFailed is returned when the client fails to
// authenticate.
var AuthenticationFailed = errors.New("authentication error: authentication failed")
func NewAuthenticatorCRAMMD5() *AuthenticatorCRAMMD5 {
return &AuthenticatorCRAMMD5{make(cramMD5Credentials)}
}
// LoadCredentials loads credentials stored in the JSON file named
// filename into the default authenticator.
func LoadCredentials(filename string) error {
return DefaultAuthenticatorCRAMMD5.Credentials.Load(filename)
// ServeAuthRPC handles authenticated rpc requests using the hijack
// scheme of rpc
func ServeAuthRPC(codecName string, cFactory ServerCodecFactory) {
http.Handle(GetRpcPath(codecName, true), &rpcHandler{cFactory, AuthenticatedServer, true})
}
// ServeCustomRPC serves the given rpc requests with the provided ServeMux,
// authenticated or not
func ServeCustomRPC(handler *http.ServeMux, server *rpc.Server, useAuth bool, codecName string, cFactory ServerCodecFactory) {
handler.Handle(GetRpcPath(codecName, useAuth), &rpcHandler{cFactory, server, useAuth})
}
// AuthenticatedServer is an rpc.Server instance that serves
// authenticated calls.
var AuthenticatedServer = rpc.NewServer()
// rpcHandler handles rpc queries for a 'CONNECT' method.
type rpcHandler struct {
cFactory ServerCodecFactory
server *rpc.Server
useAuth bool
}
// ServeHTTP implements http.Handler's ServeHTTP
func (h *rpcHandler) ServeHTTP(c http.ResponseWriter, req *http.Request) {
if req.Method != "CONNECT" {
c.Header().Set("Content-Type", "text/plain; charset=utf-8")
c.WriteHeader(http.StatusMethodNotAllowed)
io.WriteString(c, "405 must CONNECT\n")
return
"net"
"net/http"
"os"
log "github.com/golang/glog"
"github.com/youtube/vitess/go/rpcplus"
"github.com/youtube/vitess/go/rpcwrap"
"github.com/youtube/vitess/go/rpcwrap/bsonrpc"
)
var (
// The flags used when calling RegisterDefaultSocketFileFlags.
SocketFile *string
// The rpc servers to use
socketFileRpcServer = rpcplus.NewServer()
authenticatedSocketFileRpcServer = rpcplus.NewServer()
)
// socketFileRegister registers the provided server to be served on the
// SocketFile, if enabled by the service map.
func socketFileRegister(name string, rcvr interface{}) {
if SocketFile == nil || *SocketFile == "" {
return
}
if ServiceMap["bsonrpc-unix-"+name] {
log.Infof("Registering %v for bsonrpc over unix socket, disable it with -bsonrpc-unix-%v service_map parameter", name, name)
socketFileRpcServer.Register(rcvr)
} else {
log.Infof("Not registering %v for bsonrpc over unix socket, enable it with bsonrpc-unix-%v service_map parameter", name, name)
}