// Serve starts service for the given Computation. // // Must be called from main() function of worker. func Serve(comp Computation) error { bindAddr := os.Getenv(bolt.KConcordEnvKeyClientListenAddr) proxyAddr := os.Getenv(bolt.KConcordEnvKeyClientProxyAddr) // Init transport transport, err := thrift.NewTServerSocket(bindAddr) if err != nil { panic("failed to create server") } factory := thrift.NewTTransportFactory() transportF := thrift.NewTFramedTransportFactory(factory) protocolF := thrift.NewTBinaryProtocolFactoryDefault() proxy, err := newProxy(proxyAddr, comp.Metadata()) if err != nil { panic("failed to initialize proxy") } service := newComputationService(comp, proxy) processor := bolt.NewComputationServiceProcessor(service) srv := thrift.NewTSimpleServer4(processor, transport, transportF, protocolF) return srv.Serve() }
func (t *ThriftExporter) Export(serviceName string, processor thrift.TProcessor) (err error) { var transport thrift.TServerTransport if t.Config.Secure { cfg := new(tls.Config) if cert, err := tls.LoadX509KeyPair(t.Config.CertFile, t.Config.KeyFile); err == nil { cfg.Certificates = append(cfg.Certificates, cert) } else { return err } transport, err = thrift.NewTSSLServerSocket(t.Provider.Addr, cfg) } else { transport, err = thrift.NewTServerSocket(t.Provider.Addr) } if err != nil { return err } server := thrift.NewTSimpleServer4(processor, transport, t.Config.TransFactory, t.Config.ProtocolFactory) err = t.Reg.Register(serviceName, t.Provider) if err != nil { fmt.Println("error when register service", err.Error()) return } fmt.Println("Starting the simple server... on ", t.Provider.Addr) return server.Serve() }
func runServer(transportFactory thrift.TTransportFactory, protocolFactory thrift.TProtocolFactory, addr string, secure bool) error { var transport thrift.TServerTransport var err error transport, err = thrift.NewTServerSocket(addr) if err != nil { return err } fmt.Printf("Transport: %T\n", transport) handler := NewAwesomeServiceHandler() SharedTypes = awesome_service.NewTypes() var f float64 = 1 b := true s := "A" SharedTypes.ShortValue = 1 SharedTypes.IntValue = 1 SharedTypes.LongValue = 1 SharedTypes.DoubleValue = &f SharedTypes.BoolValue = &b SharedTypes.StringValue = &s SharedTypes.ListValue = []string{"A"} SharedTypes.SetValue = map[string]bool{"A": true} SharedTypes.MapValue = make(map[string]int32) // var i int32 for i := 0; i < 50000; i++ { SharedTypes.MapValue[strconv.Itoa(i)] = int32(i) } processor := awesome_service.NewAwesomeServiceProcessor(handler) server := thrift.NewTSimpleServer4(processor, transport, transportFactory, protocolFactory) fmt.Println("Starting the simple server... on ", addr) return server.Serve() }
// NewHbaseServer starts an self-implementation hbase func NewHbaseServer(hb Hbase) (*TestServer, error) { port, _ := GetPort() addr := fmt.Sprintf(":%d", port) // fork a goroutine to serve requests var transportFactory thrift.TTransportFactory protocolFactory := thrift.NewTBinaryProtocolFactoryDefault() transportFactory = thrift.NewTBufferedTransportFactory(8192) transportFactory = thrift.NewTFramedTransportFactory(transportFactory) transport, err := thrift.NewTServerSocket(addr) if err != nil { log.Fatal(err) } srv := thrift.NewTSimpleServer4( NewHbaseProcessor(hb), transport, transportFactory, protocolFactory, ) if err := srv.Listen(); err != nil { log.Fatal(err) } go srv.AcceptLoop() // TODO: stop server when stop chan is closed return &TestServer{ Port: port, stop: make(chan struct{}), }, nil }
func runServer(transportFactory thrift.TTransportFactory, protocolFactory thrift.TProtocolFactory, addr string, secure bool) error { var transport thrift.TServerTransport var err error if secure { cfg := new(tls.Config) if cert, err := tls.LoadX509KeyPair("server.crt", "server.key"); err == nil { cfg.Certificates = append(cfg.Certificates, cert) } else { return err } transport, err = thrift.NewTSSLServerSocket(addr, cfg) } else { transport, err = thrift.NewTServerSocket(addr) } if err != nil { return err } fmt.Printf("%T\n", transport) handler := NewCalculatorHandler() processor := tutorial.NewCalculatorProcessor(handler) server := thrift.NewTSimpleServer4(processor, transport, transportFactory, protocolFactory) fmt.Println("Starting the simple server... on ", addr) return server.Serve() }
// // 两参数是必须的: ProductName, zkAddress, frontAddr可以用来测试 // func (p *ProxyServer) Run() { var transport thrift.TServerTransport var err error log.Printf(Magenta("Start Proxy at Address: %s"), p.proxyAddr) // 读取后端服务的配置 isUnixDomain := false if !strings.Contains(p.proxyAddr, ":") { if FileExist(p.proxyAddr) { os.Remove(p.proxyAddr) } transport, err = NewTServerUnixDomain(p.proxyAddr) isUnixDomain = true } else { transport, err = thrift.NewTServerSocket(p.proxyAddr) } if err != nil { log.ErrorErrorf(err, "Server Socket Create Failed: %v, Front: %s", err, p.proxyAddr) } // 开始监听 // transport.Open() transport.Listen() ch := make(chan thrift.TTransport, 4096) defer close(ch) go func() { var address string for c := range ch { // 为每个Connection建立一个Session socket, ok := c.(SocketAddr) if isUnixDomain { address = p.proxyAddr } else if ok { address = socket.Addr().String() } else { address = "unknow" } x := NewSession(c, address, p.verbose) // Session独立处理自己的请求 go x.Serve(p.router, 1000) } }() // Accept什么时候出错,出错之后如何处理呢? for { c, err := transport.Accept() if err != nil { log.ErrorErrorf(err, "Accept Error: %v", err) break } else { ch <- c } } }
// run a test flume agent func runDummyFlumeAgent(t *testing.T) { transportFactory := thrift.NewTFramedTransportFactory(thrift.NewTTransportFactory()) protocolFactory := thrift.NewTCompactProtocolFactory() transport, _ := thrift.NewTServerSocket("localhost:51515") handler := thriftSourceProtocolHandler{t} processor := flume.NewThriftSourceProtocolProcessor(handler) server := thrift.NewTSimpleServer4(processor, transport, transportFactory, protocolFactory) server.Serve() }
func main() { dcacheHandler := NewDcacheHandler() dcacheServiceProcessor := dcache.NewDcacheServiceProcessor(dcacheHandler) ssock, err := thrift.NewTServerSocket("127.0.0.1:9090") if err != nil { panic("Problem in creating transport") } server := thrift.NewTSimpleServer4(dcacheServiceProcessor, ssock, thrift.NewTBufferedTransportFactory(204800), thrift.NewTBinaryProtocolFactoryDefault()) server.Serve() }
func runServer(transportFactory thrift.TTransportFactory, protocolFactory thrift.TProtocolFactory, addr string) error { transport, err = thrift.NewTServerSocket(addr) //simple case if err != nil { return err } handler := &dataServiceProcessorPull{} processor := crawler.NewDataServiceProcessor(handler) server := thrift.NewTSimpleServer(processor, transport, transportFactory, protocolFactory) fmt.Println("Starting the simple server... on ", transport.Addr()) server.serve() }
func main() { handler := NewCoffeeOrderHandler() processor := co.NewCoffeeOrderProcessor(handler) protocolFactory := thrift.NewTBinaryProtocolFactoryDefault() transportFactory := thrift.NewTTransportFactory() serverTransport, err := thrift.NewTServerSocket("0.0.0.0:9090") if err != nil { log.Println(err) } server := thrift.NewTSimpleServer4(processor, serverTransport, transportFactory, protocolFactory) server.Serve() }
func runServer(transportFactory thrift.TTransportFactory, protocolFactory thrift.TProtocolFactory, addr string) error { transport, err := thrift.NewTServerSocket(addr) if err != nil { return err } handler := NewCalculatorHandler() processor := tutorial.NewCalculatorProcessor(handler) server := thrift.NewTSimpleServer4(processor, transport, transportFactory, protocolFactory) fmt.Println("Starting the simple server... on ", transport.Addr()) return server.Serve() }
func main() { protocolFactory := thrift.NewTBinaryProtocolFactoryDefault() transport, err := thrift.NewTServerSocket("localhost:8090") if err != nil { fmt.Printf("There was an error creating your socket! Here it is %v", err) } transportFactory := thrift.NewTTransportFactory() processor := service.NewMakeTagsProcessor(handler.NewTagsHandler(os.Getenv("ACCESS_TOKEN"))) server := thrift.NewTSimpleServer4(processor, transport, transportFactory, protocolFactory) fmt.Printf("server listening on %s\n", "localhost:8090") server.Serve() }
func main() { transport, err := thrift.NewTServerSocket("localhost:3636") if err != nil { panic(err) } proc := hello.NewHelloProcessor(&HelloHandler{}) server := thrift.NewTSimpleServer4( proc, transport, thrift.NewTFramedTransportFactory(thrift.NewTTransportFactory()), thrift.NewTBinaryProtocolFactoryDefault()) println(server.Serve()) }
func main() { var protocolFactory thrift.TProtocolFactory = thrift.NewTBinaryProtocolFactoryDefault() var transportFactory thrift.TTransportFactory = thrift.NewTBufferedTransportFactory(8192) transport, err := thrift.NewTServerSocket(NetworkAddr) if err != nil { fmt.Println("Error!", err) os.Exit(1) } handler := NewGreeterHandler() processor := greeter.NewGreeterProcessor(handler) server := thrift.NewTSimpleServer4(processor, transport, transportFactory, protocolFactory) fmt.Println("Starting the simple server... on ", NetworkAddr) server.Serve() }
func New(addr string, processor *thrift.TProcessor) (*Server, error) { // Instantiate the thrift server components protocolFactory := thrift.NewTBinaryProtocolFactoryDefault() transportFactory := thrift.NewTTransportFactory() transport, err := thrift.NewTServerSocket(addr) if err != nil { return nil, err } wait := make(chan error) s := Server{Addr: addr, wait: wait, Wait: wait} s.server = thrift.NewTSimpleServer4(*processor, transport, transportFactory, protocolFactory) return &s, nil }
func runServer(transportFactory thrift.TTransportFactory, protocolFactory thrift.TProtocolFactory, addr string) error { var transport thrift.TServerTransport var err error transport, err = thrift.NewTServerSocket(addr) if err != nil { fmt.Println(err) } fmt.Printf("%T\n", transport) handler := NewHelloHandler() processor := hello.NewHelloProcessor(handler) server := thrift.NewTSimpleServer4(processor, transport, transportFactory, protocolFactory) fmt.Println("Starting the simple server... on ", addr) return server.Serve() }
func runServer(listenIp *string, listenPort *int, backendIp *string, backendPort *int, debug *bool) error { transport, err := thrift.NewTServerSocket(fmt.Sprintf("%s:%d", *listenIp, *listenPort)) if err != nil { return err } transportFactory := thrift.NewTTransportFactory() protocolFactory := thrift.NewTBinaryProtocolFactoryDefault() handler := NewDataStoreHandler(backendIp, backendPort, debug) processor := messages.NewDataStoreProcessor(handler) server := thrift.NewTSimpleServer4(processor, transport, transportFactory, protocolFactory) logger.Printf("Thrift Service configured") return server.Serve() }
func main() { var listen string = ":10001" transportFactory := thrift.NewTFramedTransportFactory(thrift.NewTTransportFactory()) protocolFactory := thrift.NewTBinaryProtocolFactoryDefault() serverTransport, err := thrift.NewTServerSocket(listen) if err != nil { fmt.Println("error, thrift init!") return } handler := &Puller{0} processor := puller.NewPullerProcessor(handler) server := thrift.NewTSimpleServer4(processor, serverTransport, transportFactory, protocolFactory) fmt.Printf("server started\n") server.Serve() }
func main() { handler := &HelloServiceImpl{} processor := hello.NewHelloServiceProcessor(handler) listenSocket, err := thrift.NewTServerSocket(":8787") if err != nil { panic(err) } server := thrift.NewTSimpleServer2(processor, listenSocket) fmt.Println("Server ready") if err := server.Serve(); err != nil { panic(err) } }
func runThriftServer(host string, port int, protocol string, framed bool, buffered bool, workerId uint64, datacenterId uint64) { 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: fmt.Fprint(os.Stderr, "Invalid protocol specified", protocol, "\n") Usage() os.Exit(1) } var transportFactory thrift.TTransportFactory if buffered { transportFactory = thrift.NewTBufferedTransportFactory(8192) } else { transportFactory = thrift.NewTTransportFactory() } if framed { transportFactory = thrift.NewTFramedTransportFactory(transportFactory) } var err error var transport thrift.TServerTransport transport, err = thrift.NewTServerSocket(fmt.Sprintf("%s:%d", host, port)) if err != nil { log.Fatal(err) os.Exit(1) } worker, err := idworker.NewIdWorker(workerId, datacenterId) processor := snowflake.NewSnowflakeProcessor(worker) if err == nil { server := thrift.NewTSimpleServer4(processor, transport, transportFactory, protocolFactory) server.Serve() } else { log.Fatal(err) } }
func runFakeRender(addr string) { var tTS fakeRender processor := gopnikrpc.NewRenderProcessor(&tTS) transport, err := thrift.NewTServerSocket(addr) if err != nil { panic(err) } transportFactory := thrift.NewTFramedTransportFactory(thrift.NewTTransportFactory()) protocolFactory := thrift.NewTBinaryProtocolFactoryDefault() server := thrift.NewTSimpleServer4(processor, transport, transportFactory, protocolFactory) if err = server.Serve(); err != nil { panic(err) } }
func rpcListen(addr string) { transportFactory := thrift.NewTFramedTransportFactory(thrift.NewTTransportFactory()) protocolFactory := thrift.NewTBinaryProtocolFactoryDefault() serverTransport, err := thrift.NewTServerSocket(addr) if err != nil { fmt.Println("Error:", err) os.Exit(1) } handler := &MessageServiceImpl{} processor := message.NewMessageServiceProcessor(handler) server := thrift.NewTSimpleServer4(processor, serverTransport, transportFactory, protocolFactory) fmt.Println("thrift server in", addr) server.Serve() }
func startThriftService() { transportFactory := thrift.NewTFramedTransportFactory(thrift.NewTTransportFactory()) protocolFactory := thrift.NewTBinaryProtocolFactoryDefault() serverTransport, err := thrift.NewTServerSocket(global.ServeAddr) if err != nil { fmt.Println("Error!", err) os.Exit(1) } handler := &services.UUIDGenerator{} processor := uuid.NewGeneratorProcessor(handler) server := thrift.NewTSimpleServer4(processor, serverTransport, transportFactory, protocolFactory) fmt.Println("thrift server in", global.ServeAddr) server.Serve() }
func main() { transportFactory := thrift.NewTFramedTransportFactory(thrift.NewTTransportFactory()) protocolFactory := thrift.NewTBinaryProtocolFactoryDefault() serverTransport, err := thrift.NewTServerSocket(NetworkAddr) if err != nil { fmt.Println("Error!", err) os.Exit(1) } handler := &RpcServiceImpl{} processor := push.NewPushServiceProcessor(handler) server := thrift.NewTSimpleServer4(processor, serverTransport, transportFactory, protocolFactory) fmt.Println("thrift server in", NetworkAddr) server.Serve() }
func (s *ThriftService) Start(addr string) error { log.Printf("[thrift] starting service at %s", addr) transport, err := thrift.NewTServerSocket(addr) if err != nil { log.Fatal(err) } server := thrift.NewTSimpleServer4( candy.NewCandyProcessor(s), transport, thrift.NewTFramedTransportFactory(thrift.NewTTransportFactory()), thrift.NewTBinaryProtocolFactoryDefault(), //thrift.NewTDebugProtocolFactory(thrift.NewTJSONProtocolFactory(), "[json]"), ) return server.Serve() }
func serverStub() { transportFactory := thrift.NewTFramedTransportFactory(thrift.NewTTransportFactory()) protocolFactory := thrift.NewTBinaryProtocolFactoryDefault() //protocolFactory := thrift.NewTCompactProtocolFactory() serverTransport, err := thrift.NewTServerSocket(NetworkAddr) if err != nil { log.Error("Error!", err) return } handler := &RpcServiceImpl{} processor := demo.NewRpcServiceProcessor(handler) server := thrift.NewTSimpleServer4(processor, serverTransport, transportFactory, protocolFactory) log.Trace("thrift server in", NetworkAddr) server.Serve() }
func RunServer(addr string, tileServer *TileServer) error { tTS := &thriftTileServer{ tileServer: tileServer, Service: rpcbaseservice.NewService(), } processor := gopnikrpc.NewRenderProcessor(tTS) transport, err := thrift.NewTServerSocket(addr) if err != nil { return err } transportFactory := thrift.NewTFramedTransportFactory(thrift.NewTTransportFactory()) protocolFactory := thrift.NewTBinaryProtocolFactoryDefault() server := thrift.NewTSimpleServer4(processor, transport, transportFactory, protocolFactory) return server.Serve() }
func TestMain(m *testing.M) { transportFactory = thrift.NewTBufferedTransportFactory(8192) transportFactory = thrift.NewTFramedTransportFactory(transportFactory) protocolFactory = thrift.NewTBinaryProtocolFactoryDefault() serverTransport, err := thrift.NewTServerSocket("127.0.0.1:0") if err != nil { panic(err) } // call listen here to avoid synchronizing server.serve with test cases if err = serverTransport.Listen(); err != nil { panic(err) } serverAddr = serverTransport.Addr() handler := &ExampleHandler{} processor := example.NewExampleProcessor(handler) server := thrift.NewTSimpleServer6(processor, serverTransport, transportFactory, transportFactory, protocolFactory, protocolFactory) go server.Serve() os.Exit(m.Run()) }
func runServer(addr string, workQueue chan ops.Work) error { transport, err := thrift.NewTServerSocket(addr) if err != nil { return err } fmt.Printf("%T\n", transport) transportFactory := thrift.NewTTransportFactory() if transportFactory == nil { fmt.Println("Failed to create new TransportFactory") return nil } protocolFactory := thrift.NewTBinaryProtocolFactoryDefault() handler := NewOpsHandler(workQueue) processor := ops.NewProducerProcessor(handler) server := thrift.NewTSimpleServer4(processor, transport, transportFactory, protocolFactory) fmt.Println("Starting the simple server... on ", addr) return server.Serve() }
func main() { handler := UserServicerHandler{} processor := shared.NewBinaryMessengerProcessor(handler) //addr := beego.AppConfig.String("socketAddress") addr := "localhost:3001" var transport thrift.TServerTransport var err error if transport, err = thrift.NewTServerSocket(addr); err != nil { panic(err) //panic("Unable to initialize socket!") } transportFactory := thrift.NewTTransportFactory() protocolFactory := thrift.NewTBinaryProtocolFactoryDefault() server := thrift.NewTSimpleServer4(processor, transport, transportFactory, protocolFactory) fmt.Printf("server started on %v\n", addr) server.Serve() }