func main() { var ( transport = flag.String("transport", "httpjson", "httpjson, grpc, netrpc, thrift") httpAddr = flag.String("http.addr", "localhost:8001", "Address for HTTP (JSON) server") grpcAddr = flag.String("grpc.addr", "localhost:8002", "Address for gRPC server") netrpcAddr = flag.String("netrpc.addr", "localhost:8003", "Address for net/rpc server") thriftAddr = flag.String("thrift.addr", "localhost:8004", "Address for Thrift server") thriftProtocol = flag.String("thrift.protocol", "binary", "binary, compact, json, simplejson") thriftBufferSize = flag.Int("thrift.buffer.size", 0, "0 for unbuffered") thriftFramed = flag.Bool("thrift.framed", false, "true to enable framing") ) flag.Parse() if len(os.Args) < 4 { fmt.Fprintf(os.Stderr, "\n%s [flags] method arg1 arg2\n\n", filepath.Base(os.Args[0])) flag.Usage() os.Exit(1) } root := context.Background() method, s1, s2 := flag.Arg(0), flag.Arg(1), flag.Arg(2) var logger log.Logger logger = log.NewLogfmtLogger(os.Stdout) logger = log.NewContext(logger).With("caller", log.DefaultCaller) logger = log.NewContext(logger).With("transport", *transport) var svc server.AddService switch *transport { case "grpc": cc, err := grpc.Dial(*grpcAddr) if err != nil { _ = logger.Log("err", err) os.Exit(1) } defer cc.Close() svc = grpcclient.New(root, cc, logger) case "httpjson": rawurl := *httpAddr if !strings.HasPrefix("http", rawurl) { rawurl = "http://" + rawurl } baseurl, err := url.Parse(rawurl) if err != nil { _ = logger.Log("err", err) os.Exit(1) } svc = httpjsonclient.New(root, baseurl, logger, nil) case "netrpc": cli, err := rpc.DialHTTP("tcp", *netrpcAddr) if err != nil { _ = logger.Log("err", err) os.Exit(1) } defer cli.Close() svc = netrpcclient.New(cli, logger) case "thrift": var protocolFactory thrift.TProtocolFactory switch *thriftProtocol { case "compact": protocolFactory = thrift.NewTCompactProtocolFactory() case "simplejson": protocolFactory = thrift.NewTSimpleJSONProtocolFactory() case "json": protocolFactory = thrift.NewTJSONProtocolFactory() case "binary", "": protocolFactory = thrift.NewTBinaryProtocolFactoryDefault() default: _ = logger.Log("protocol", *thriftProtocol, "err", "invalid protocol") os.Exit(1) } var transportFactory thrift.TTransportFactory if *thriftBufferSize > 0 { transportFactory = thrift.NewTBufferedTransportFactory(*thriftBufferSize) } else { transportFactory = thrift.NewTTransportFactory() } if *thriftFramed { transportFactory = thrift.NewTFramedTransportFactory(transportFactory) } transportSocket, err := thrift.NewTSocket(*thriftAddr) if err != nil { _ = logger.Log("during", "thrift.NewTSocket", "err", err) os.Exit(1) } trans := transportFactory.GetTransport(transportSocket) defer trans.Close() if err := trans.Open(); err != nil { _ = logger.Log("during", "thrift transport.Open", "err", err) os.Exit(1) } cli := thriftadd.NewAddServiceClientFactory(trans, protocolFactory) svc = thriftclient.New(cli, logger) default: _ = logger.Log("err", "invalid transport") os.Exit(1) } begin := time.Now() switch method { case "sum": a, _ := strconv.Atoi(s1) b, _ := strconv.Atoi(s2) v := svc.Sum(a, b) _ = logger.Log("method", "sum", "a", a, "b", b, "v", v, "took", time.Since(begin)) case "concat": a, b := s1, s2 v := svc.Concat(a, b) _ = logger.Log("method", "concat", "a", a, "b", b, "v", v, "took", time.Since(begin)) default: _ = logger.Log("err", "invalid method "+method) os.Exit(1) } }
func main() { // Flag domain. Note that gRPC transitively registers flags via its import // of glog. So, we define a new flag set, to keep those domains distinct. fs := flag.NewFlagSet("", flag.ExitOnError) var ( transport = fs.String("transport", "grpc", "http, grpc, netrpc, thrift") httpAddr = fs.String("http.addr", "localhost:8001", "HTTP (JSON) address") grpcAddr = fs.String("grpc.addr", "localhost:8002", "gRPC address") netrpcAddr = fs.String("netrpc.addr", "localhost:8003", "net/rpc address") thriftAddr = fs.String("thrift.addr", "localhost:8004", "Thrift address") thriftProtocol = fs.String("thrift.protocol", "binary", "binary, compact, json, simplejson") thriftBufferSize = fs.Int("thrift.buffer.size", 0, "0 for unbuffered") thriftFramed = fs.Bool("thrift.framed", false, "true to enable framing") a = fs.Int64("a", 1, "a value") b = fs.Int64("b", 2, "b value") ) flag.Usage = fs.Usage // only show our flags fs.Parse(os.Args[1:]) log.SetFlags(0) log.SetOutput(os.Stdout) var e endpoint.Endpoint switch *transport { case "http": if !strings.HasPrefix(*httpAddr, "http") { *httpAddr = "http://" + *httpAddr } u, err := url.Parse(*httpAddr) if err != nil { log.Fatalf("url.Parse: %v", err) } if u.Path == "" { u.Path = "/add" } e = httpclient.NewClient("GET", u.String()) case "grpc": cc, err := grpc.Dial(*grpcAddr) if err != nil { log.Fatalf("grpc.Dial: %v", err) } e = grpcclient.NewClient(cc) case "netrpc": client, err := rpc.DialHTTP("tcp", *netrpcAddr) if err != nil { log.Fatalf("rpc.DialHTTP: %v", err) } e = netrpcclient.NewClient(client) case "thrift": var protocolFactory thrift.TProtocolFactory switch *thriftProtocol { case "compact": protocolFactory = thrift.NewTCompactProtocolFactory() case "simplejson": protocolFactory = thrift.NewTSimpleJSONProtocolFactory() case "json": protocolFactory = thrift.NewTJSONProtocolFactory() case "binary", "": protocolFactory = thrift.NewTBinaryProtocolFactoryDefault() default: log.Fatalf("invalid protocol %q", *thriftProtocol) } var transportFactory thrift.TTransportFactory if *thriftBufferSize > 0 { transportFactory = thrift.NewTBufferedTransportFactory(*thriftBufferSize) } else { transportFactory = thrift.NewTTransportFactory() } if *thriftFramed { transportFactory = thrift.NewTFramedTransportFactory(transportFactory) } transportSocket, err := thrift.NewTSocket(*thriftAddr) if err != nil { log.Fatalf("thrift.NewTSocket: %v", err) } transport := transportFactory.GetTransport(transportSocket) defer transport.Close() if err := transport.Open(); err != nil { log.Fatalf("Thrift transport.Open: %v", err) } e = thriftclient.NewClient(thriftadd.NewAddServiceClientFactory(transport, protocolFactory)) default: log.Fatalf("unsupported transport %q", *transport) } response, err := e(context.Background(), reqrep.AddRequest{A: *a, B: *b}) if err != nil { log.Fatalf("when invoking request: %v", err) } addResponse, ok := response.(reqrep.AddResponse) if !ok { log.Fatalf("when type-asserting response: %v", endpoint.ErrBadCast) } log.Print(addResponse.V) }