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)
}