func main() {
flag.Parse()
processor, serverTransport, transportFactory, protocolFactory, err := common.GetServerParams(*host, *port, *domain_socket, *transport, *protocol, *ssl, *certPath, common.PrintingHandler)
if err != nil {
log.Fatalf("Unable to process server params: ", err)
}
if *transport == "http" {
http.HandleFunc("/", thrift.NewThriftHandlerFunc(processor, protocolFactory, protocolFactory))
if *ssl {
err := http.ListenAndServeTLS(fmt.Sprintf(":%d", *port),
*certPath+"/server.pem", *certPath+"/server.key", nil)
if err != nil {
fmt.Println(err)
return
}
} else {
http.ListenAndServe(fmt.Sprintf(":%d", *port), nil)
}
} else {
server := thrift.NewTSimpleServer4(processor, serverTransport, transportFactory, protocolFactory)
if err = server.Listen(); err != nil {
return
}
go server.AcceptLoop()
server.Serve()
}
}
func RunSocketTestSuite(t *testing.T, protocolFactory thrift.TProtocolFactory,
transportFactory thrift.TTransportFactory) {
// server
var err error
addr = FindAvailableTCPServerPort()
serverTransport, err := thrift.NewTServerSocketTimeout(addr.String(), TIMEOUT)
if err != nil {
t.Fatal("Unable to create server socket", err)
}
processor := thrifttest.NewThriftTestProcessor(NewThriftTestHandler())
server = thrift.NewTSimpleServer4(processor, serverTransport, transportFactory, protocolFactory)
server.Listen()
go server.Serve()
// client
var transport thrift.TTransport = thrift.NewTSocketFromAddrTimeout(addr, TIMEOUT)
transport = transportFactory.GetTransport(transport)
var protocol thrift.TProtocol = protocolFactory.GetProtocol(transport)
thriftTestClient := thrifttest.NewThriftTestClientProtocol(transport, protocol, protocol)
err = transport.Open()
if err != nil {
t.Fatal("Unable to open client socket", err)
}
driver := NewThriftTestDriver(t, thriftTestClient)
driver.Start()
}
func Simple(processor *tutorial.CalculatorProcessor, transportFactory thrift.TTransportFactory, protocolFactory thrift.TProtocolFactory, ch chan int) {
addr, err := net.ResolveTCPAddr("tcp", "localhost:9090")
if err != nil {
fmt.Print("Error resolving address: ", err.String(), "\n")
return
}
serverTransport, err := thrift.NewTServerSocketAddr(addr)
if err != nil {
fmt.Print("Error creating server socket: ", err.String(), "\n")
return
}
server := thrift.NewTSimpleServer4(processor, serverTransport, transportFactory, protocolFactory)
// Use this for a multithreaded server
// TServer server = new TThreadPoolServer(new TThreadPoolServer.Args(serverTransport).processor(processor));
fmt.Print("Starting the simple server... on ", addr, "\n")
for {
err = server.Serve()
if err != nil {
fmt.Print("Error during simple server: ", err.String(), "\n")
return
}
}
fmt.Print("Done with the simple server\n")
ch <- 1
}
func doUnit(t *testing.T, unit *test_unit) {
ctrl := gomock.NewController(t)
defer ctrl.Finish()
handler := NewMockThriftTest(ctrl)
processor, serverTransport, transportFactory, protocolFactory, err := GetServerParams(unit.host, unit.port, unit.domain_socket, unit.transport, unit.protocol, unit.ssl, "../../../keys", handler)
server := thrift.NewTSimpleServer4(processor, serverTransport, transportFactory, protocolFactory)
if err = server.Listen(); err != nil {
return
}
go server.AcceptLoop()
server.Serve()
if err != nil {
t.Errorf("Unable to start server", err)
t.FailNow()
}
defer server.Stop()
client, err := StartClient(unit.host, unit.port, unit.domain_socket, unit.transport, unit.protocol, unit.ssl)
if err != nil {
t.Errorf("Unable to start client", err)
t.FailNow()
}
defer client.Transport.Close()
callEverythingWithMock(t, client, handler)
}
func TestInitTwoServers(t *testing.T) {
var err error
protocolFactory := thrift.NewTBinaryProtocolFactoryDefault()
transportFactory := thrift.NewTTransportFactory()
transportFactory = thrift.NewTFramedTransportFactory(transportFactory)
addr = FindAvailableTCPServerPort()
serverTransport, err := thrift.NewTServerSocketTimeout(addr.String(), TIMEOUT)
if err != nil {
t.Fatal("Unable to create server socket", err)
}
server = thrift.NewTSimpleServer4(processor, serverTransport, transportFactory, protocolFactory)
firstProcessor := multiplexedprotocoltest.NewFirstProcessor(&FirstImpl{})
processor.RegisterProcessor("FirstService", firstProcessor)
secondProcessor := multiplexedprotocoltest.NewSecondProcessor(&SecondImpl{})
processor.RegisterProcessor("SecondService", secondProcessor)
go server.Serve()
}
func main() {
defer os.Exit(1)
serverSocket, err := thrift.NewTServerSocket(remoteAddr)
if err != nil {
fmt.Println("thrift.NewTServerSocket: ", err)
return
}
defer serverSocket.Close()
handler := &rpcService{}
processor := rpc.NewRpcServiceProcessor(handler)
server := thrift.NewTSimpleServer4(processor, serverSocket, transportFactory, protocolFactory)
defer server.Stop()
if err := server.Serve(); err != nil {
fmt.Println("server.Server: ", err)
return
}
}
func main() {
flag.Parse()
if *memprofile != "" {
runtime.MemProfileRate = 100
}
var ok bool
if callType, ok = callTMap[*callName]; !ok {
log.Fatal("Unknown service call", *callName)
}
if *cpuprofile != "" {
f, err := os.Create(*cpuprofile)
if err != nil {
log.Fatal(err)
}
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
}
hostPort = fmt.Sprintf("%s:%d", *host, *port)
var protocolFactory thrift.TProtocolFactory
var transportFactory thrift.TTransportFactory
if *compact {
protocolFactory = thrift.NewTCompactProtocolFactory()
} else {
protocolFactory = thrift.NewTBinaryProtocolFactoryDefault()
}
if *framed {
transportFactory = thrift.NewTTransportFactory()
transportFactory = thrift.NewTFramedTransportFactory(transportFactory)
} else {
transportFactory = thrift.NewTBufferedTransportFactory(8192)
}
if *runserver > 0 {
serverTransport, err := thrift.NewTServerSocket(hostPort)
if err != nil {
log.Fatalf("Unable to create server socket: %s", err)
}
processor := stress.NewServiceProcessor(&handler{})
server := thrift.NewTSimpleServer4(processor, serverTransport, transportFactory, protocolFactory)
if *clients == 0 {
server.Serve()
} else {
go server.Serve()
}
}
//start clients
if *clients != 0 {
ready.Add(*clients + 1)
done.Add(*clients)
for i := 0; i < *clients; i++ {
go client(protocolFactory)
}
ready.Done()
ready.Wait()
//run!
startTime := time.Now()
//wait for completion
done.Wait()
endTime := time.Now()
duration := endTime.Sub(startTime)
log.Printf("%d calls in %v (%f calls per second)\n", clicounter, duration, float64(clicounter)/duration.Seconds())
}
if *memprofile != "" {
f, err := os.Create(*memprofile)
if err != nil {
log.Fatal(err)
}
pprof.WriteHeapProfile(f)
f.Close()
return
}
}
func StartServer(
host string,
port int64,
domain_socket string,
transport string,
protocol string,
ssl bool,
certPath string,
handler thrifttest.ThriftTest) (srv *thrift.TSimpleServer, err error) {
hostPort := fmt.Sprintf("%s:%d", host, port)
var protocolFactory thrift.TProtocolFactory
switch protocol {
case "compact":
protocolFactory = thrift.NewTCompactProtocolFactory()
case "simplejson":
protocolFactory = thrift.NewTSimpleJSONProtocolFactory()
case "json":
protocolFactory = thrift.NewTJSONProtocolFactory()
case "binary":
protocolFactory = thrift.NewTBinaryProtocolFactoryDefault()
default:
return nil, fmt.Errorf("Invalid protocol specified %s", protocol)
}
if debugServerProtocol {
protocolFactory = thrift.NewTDebugProtocolFactory(protocolFactory, "server:")
}
var serverTransport thrift.TServerTransport
if ssl {
cfg := new(tls.Config)
if cert, err := tls.LoadX509KeyPair(certPath+"/server.crt", certPath+"/server.key"); err != nil {
return nil, err
} else {
cfg.Certificates = append(cfg.Certificates, cert)
}
serverTransport, err = thrift.NewTSSLServerSocket(hostPort, cfg)
} else {
if domain_socket != "" {
serverTransport, err = thrift.NewTServerSocket(domain_socket)
} else {
serverTransport, err = thrift.NewTServerSocket(hostPort)
}
}
if err != nil {
return nil, err
}
var transportFactory thrift.TTransportFactory
switch transport {
case "http":
return nil, fmt.Errorf("Http server transport is not supported")
// trans, err = thrift.NewTHttpClient(fmt.Sprintf("http://%s/service", hostPort))
// if err != nil {
// return nil, err
// }
case "framed":
transportFactory = thrift.NewTTransportFactory()
transportFactory = thrift.NewTFramedTransportFactory(transportFactory)
case "buffered":
transportFactory = thrift.NewTBufferedTransportFactory(8192)
case "zlib":
transportFactory = thrift.NewTZlibTransportFactory(zlib.BestCompression)
case "":
transportFactory = thrift.NewTTransportFactory()
default:
return nil, fmt.Errorf("Invalid transport specified %s", transport)
}
processor := thrifttest.NewThriftTestProcessor(handler)
server := thrift.NewTSimpleServer4(processor, serverTransport, transportFactory, protocolFactory)
if err = server.Listen(); err != nil {
return
}
go server.AcceptLoop()
return server, nil
}
