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() }
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() }
// 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 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() }
// 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() }
// 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) 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() { 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 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 (this *Engine) launchRpcServe() (done chan interface{}) { var protocolFactory thrift.TProtocolFactory switch this.conf.rpc.protocol { case "binary": protocolFactory = thrift.NewTBinaryProtocolFactoryDefault() case "json": protocolFactory = thrift.NewTJSONProtocolFactory() case "simplejson": protocolFactory = thrift.NewTSimpleJSONProtocolFactory() case "compact": protocolFactory = thrift.NewTCompactProtocolFactory() default: panic(fmt.Sprintf("Invalid protocol: %s", this.conf.rpc.protocol)) } transportFactory := thrift.NewTTransportFactory() if this.conf.rpc.framed { transportFactory = thrift.NewTFramedTransportFactory(transportFactory) } serverTransport, err := thrift.NewTServerSocketTimeout(this.conf.rpc.listenAddr, this.conf.rpc.clientTimeout) if err != nil { panic(err) } this.rpcServer = thrift.NewTSimpleServer4(this.rpcProcessor, serverTransport, transportFactory, protocolFactory) log.Info("RPC server ready at %s", this.conf.rpc.listenAddr) done = make(chan interface{}) go func() { for { err = this.rpcServer.Serve() if err != nil { log.Error(err) break } } done <- 1 }() return done }
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 startRpcServe(port string) { socket, err := thrift.NewTServerSocketTimeout(fmt.Sprintf(":%s", port), TIMEOUT) if err != nil { log.Fatalln("Unable to create server socket", err) } protocol := thrift.NewTBinaryProtocolFactoryDefault() transport := thrift.NewTFramedTransportFactory(thrift.NewTTransportFactory()) processor := thrift.NewTMultiplexedProcessor() registerProcessors(processor) server := thrift.NewTSimpleServer4(processor, socket, transport, protocol) 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 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 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 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 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 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 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 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 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 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 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 _testSetupThriftServer( t *testing.T, host string, port uint16, received *list.List, ch chan int) thrift.TServer { handler := NewTestThriftServerHandler(received, ch) processor := gen.NewThriftLoggingServiceProcessor(handler) address := fmt.Sprintf("%s:%d", host, port) serverTransport, err := thrift.NewTServerSocket(address) require.Nil(t, err) transportFactory := thrift.NewTFramedTransportFactory(thrift.NewTTransportFactory()) protocolFactory := thrift.NewTBinaryProtocolFactoryDefault() server := thrift.NewTSimpleServer4( processor, serverTransport, transportFactory, protocolFactory) go func() { server.Serve() }() return server }
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() }
func NewPelicanServer(host string) *PelicanServer { handler := NewUserHandler() processor := user.NewUserSvcProcessor(handler) transport, err := thrift.NewTServerSocket(host) if err != nil { panic(err) } transportFactory := thrift.NewTFramedTransportFactory(thrift.NewTTransportFactory()) protocolFactory := thrift.NewTBinaryProtocolFactoryDefault() server := thrift.NewTSimpleServer4(processor, transport, transportFactory, protocolFactory) return &PelicanServer{ host: host, handler: handler, processor: processor, transport: transport, transportFactory: transportFactory, protocolFactory: protocolFactory, server: server, } }