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 }