// New returns a stateful factory for Sum and Concat Endpoints
func New(protocol string, bufferSize int, framed bool, logger log.Logger) client {
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:
panic("invalid protocol")
}
var transportFactory thrift.TTransportFactory
if bufferSize > 0 {
transportFactory = thrift.NewTBufferedTransportFactory(bufferSize)
} else {
transportFactory = thrift.NewTTransportFactory()
}
if framed {
transportFactory = thrift.NewTFramedTransportFactory(transportFactory)
}
return client{transportFactory, protocolFactory, logger}
}
// Get clone of default Thrift client options or just return first
// given. This logic is little funny. But very convenient for per-client
// options.
func GetTOptions(options ...*TOptions) (res *TOptions) {
if len(options) > 0 {
return options[0]
}
if defaultTOptions == nil {
defaultTOptions = &TOptions{
DiscoveryBase: ".thrift",
DiscoveryEnv: "",
TransportFactory: thrift.NewTFramedTransportFactory(
thrift.NewTTransportFactory()),
DialTimeout: time.Minute * 3,
PoolCapacity: 32,
PoolMax: 256,
PoolTTL: time.Hour,
ProtoFactory: func() thrift.TProtocolFactory {
return thrift.NewTBinaryProtocolFactoryDefault()
},
Ctx: context.Background(),
HubFactory: DefaultTTransportHub,
}
}
clone := *defaultTOptions
res = &clone
return
}
func GuessTransportFactory(framed bool, buffer int) (res thrift.TTransportFactory) {
if buffer != 0 {
res = thrift.NewTBufferedTransportFactory(buffer)
} else {
res = thrift.NewTTransportFactory()
}
if framed {
res = thrift.NewTFramedTransportFactory(res)
}
return
}
func main() {
transportFactory := thrift.NewTFramedTransportFactory(thrift.NewTTransportFactory())
protocolFactory := thrift.NewTBinaryProtocolFactoryDefault()
transport, err := thrift.NewTSocket(net.JoinHostPort("218.244.131.175", "8900"))
if err != nil {
fmt.Fprintln(os.Stderr, "error resolving address:", err)
os.Exit(1)
}
useTransport := transportFactory.GetTransport(transport)
client := ui2bs.NewBSServiceClientFactory(useTransport, protocolFactory)
if err := transport.Open(); err != nil {
fmt.Fprintln(os.Stderr, "Error opening socket to 127.0.0.1:8084", " ", err)
os.Exit(1)
}
defer transport.Close()
bs_req := new(ui2bs.BSRequest)
bs_req.Searchid = "123"
bs_req.Media = new(ui2bs.Media)
bs_req.Media.Appsid = "123"
bs_req.Media.ChannelId = "123"
bs_req.Adslot = new(ui2bs.AdSlot)
bs_req.Device = new(ui2bs.Device)
bs_req.Device.Os = ui2bs.OSType_ANDROID
bs_resp := new(ui2bs.BSResponse)
// bs_resp.Ads = new([]ui2bs.Ad)
bs_resp, err = client.Search(bs_req)
if err != nil {
fmt.Println("error occuse")
fmt.Println(err)
}
// for i:=0; i < 10; i++ {
// err := client.Search2()
// if err != nil {
// fmt.Println("serach fail")
// transport, err = thrift.NewTSocket(net.JoinHostPort("127.0.0.1", "8084"))
// transport.Open()
// useTransport = transportFactory.GetTransport(transport)
// client = bs.NewBSServiceClientFactory(useTransport, protocolFactory)
// }
// time.Sleep(1*time.Second)
// }
//
fmt.Println(bs_resp)
fmt.Println("I am exit ")
}
func NewTRpcServer(listen string, handler thrift.TProcessor, prot thrift.TProtocolFactory) (*TRpcServer, error) {
transport, err := thrift.NewTServerSocket(listen)
if err != nil {
return nil, err
}
server := thrift.NewTSimpleServer4(
handler,
transport,
thrift.NewTFramedTransportFactory(thrift.NewTTransportFactory()),
prot,
)
return &TRpcServer{server, transport}, nil
}
func main() {
transportFactory := thrift.NewTFramedTransportFactory(thrift.NewTTransportFactory())
protocolFactory := thrift.NewTBinaryProtocolFactoryDefault()
serverTransport, err := thrift.NewTServerSocket(NetworkAddr)
if err != nil {
fmt.Println("new socket fail")
}
handler := &BsServiceImpl{}
processor := bs.NewBSServiceProcessor(handler)
server := thrift.NewTSimpleServer4(processor, serverTransport, transportFactory, protocolFactory)
fmt.Println("server start")
server.Serve()
}
func newScribeServer(t *testing.T) *scribeServer {
protocolFactory := thrift.NewTBinaryProtocolFactoryDefault()
transportFactory := thrift.NewTFramedTransportFactory(thrift.NewTTransportFactory())
var port int
var transport *thrift.TServerSocket
var err error
for i := 0; i < 10; i++ {
port = 10000 + rand.Intn(10000)
transport, err = thrift.NewTServerSocket(fmt.Sprintf(":%d", port))
if err != nil {
t.Logf("port %d: %v", port, err)
continue
}
break
}
if err != nil {
t.Fatal(err)
}
handler := newScribeHandler(t)
server := thrift.NewTSimpleServer4(
scribe.NewScribeProcessor(handler),
transport,
transportFactory,
protocolFactory,
)
go server.Serve()
deadline := time.Now().Add(time.Second)
for !canConnect(port) {
if time.Now().After(deadline) {
t.Fatal("server never started")
}
time.Sleep(time.Millisecond)
}
return &scribeServer{
transport: transport,
address: fmt.Sprintf("127.0.0.1:%d", port),
handler: handler,
}
}
func main() {
transportFactory := thrift.NewTFramedTransportFactory(thrift.NewTTransportFactory())
protocolFactory := thrift.NewTBinaryProtocolFactoryDefault()
transport, err := thrift.NewTSocket(net.JoinHostPort("127.0.0.1", "19090"))
if err != nil {
fmt.Fprintln(os.Stderr, "error resolving address:", err)
os.Exit(1)
}
useTransport := transportFactory.GetTransport(transport)
client := account.NewAccountClientFactory(useTransport, protocolFactory)
if err := transport.Open(); err != nil {
fmt.Fprintln(os.Stderr, "Error opening socket to 127.0.0.1:19090", "", err)
os.Exit(1)
}
defer transport.Close()
// 第一个请求，登录账号
request := &account.Request{
Name: "super",
Password: "******",
Op: account.Operation_LOGIN,
}
r, err := client.DoAction(request)
fmt.Println(r)
// 第二个请求，注册账号
request.Op = account.Operation_REGISTER
r, err = client.DoAction(request)
fmt.Println(r)
// 第三个请求，name为空的请求
request.Name = ""
r, err = client.DoAction(request)
fmt.Println(r)
}
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 (
debugAddr = fs.String("debug.addr", ":8000", "Address for HTTP debug/instrumentation server")
httpAddr = fs.String("http.addr", ":8001", "Address for HTTP (JSON) server")
grpcAddr = fs.String("grpc.addr", ":8002", "Address for gRPC server")
netrpcAddr = fs.String("netrpc.addr", ":8003", "Address for net/rpc server")
thriftAddr = fs.String("thrift.addr", ":8004", "Address for Thrift server")
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")
zipkinHostPort = fs.String("zipkin.host.port", "my.service.domain:12345", "Zipkin host:port")
zipkinServiceName = fs.String("zipkin.service.name", "addsvc", "Zipkin service name")
zipkinCollectorAddr = fs.String("zipkin.collector.addr", "", "Zipkin Scribe collector address (empty will log spans)")
zipkinCollectorTimeout = fs.Duration("zipkin.collector.timeout", time.Second, "Zipkin collector timeout")
zipkinCollectorBatchSize = fs.Int("zipkin.collector.batch.size", 100, "Zipkin collector batch size")
zipkinCollectorBatchInterval = fs.Duration("zipkin.collector.batch.interval", time.Second, "Zipkin collector batch interval")
)
flag.Usage = fs.Usage // only show our flags
if err := fs.Parse(os.Args[1:]); err != nil {
fmt.Fprintf(os.Stderr, "%v", err)
os.Exit(1)
}
// package log
var logger log.Logger
{
logger = log.NewLogfmtLogger(os.Stderr)
logger = log.NewContext(logger).With("ts", log.DefaultTimestampUTC).With("caller", log.DefaultCaller)
stdlog.SetFlags(0) // flags are handled by Go kit's logger
stdlog.SetOutput(log.NewStdlibAdapter(logger)) // redirect anything using stdlib log to us
}
// package metrics
var requestDuration metrics.TimeHistogram
{
requestDuration = metrics.NewTimeHistogram(time.Nanosecond, metrics.NewMultiHistogram(
expvar.NewHistogram("request_duration_ns", 0, 5e9, 1, 50, 95, 99),
prometheus.NewSummary(stdprometheus.SummaryOpts{
Namespace: "myorg",
Subsystem: "addsvc",
Name: "duration_ns",
Help: "Request duration in nanoseconds.",
}, []string{"method"}),
))
}
// package tracing
var collector zipkin.Collector
{
zipkinLogger := log.NewContext(logger).With("component", "zipkin")
collector = loggingCollector{zipkinLogger} // TODO(pb)
if *zipkinCollectorAddr != "" {
var err error
if collector, err = zipkin.NewScribeCollector(
*zipkinCollectorAddr,
*zipkinCollectorTimeout,
zipkin.ScribeBatchSize(*zipkinCollectorBatchSize),
zipkin.ScribeBatchInterval(*zipkinCollectorBatchInterval),
zipkin.ScribeLogger(zipkinLogger),
); err != nil {
zipkinLogger.Log("err", err)
os.Exit(1)
}
}
}
// Business domain
var svc server.AddService
{
svc = pureAddService{}
svc = loggingMiddleware{svc, logger}
svc = instrumentingMiddleware{svc, requestDuration}
}
// Mechanical stuff
rand.Seed(time.Now().UnixNano())
root := context.Background()
errc := make(chan error)
go func() {
errc <- interrupt()
}()
// Debug/instrumentation
go func() {
transportLogger := log.NewContext(logger).With("transport", "debug")
transportLogger.Log("addr", *debugAddr)
errc <- http.ListenAndServe(*debugAddr, nil) // DefaultServeMux
}()
// Transport: HTTP/JSON
go func() {
var (
transportLogger = log.NewContext(logger).With("transport", "HTTP/JSON")
tracingLogger = log.NewContext(transportLogger).With("component", "tracing")
newSumSpan = zipkin.MakeNewSpanFunc(*zipkinHostPort, *zipkinServiceName, "sum")
newConcatSpan = zipkin.MakeNewSpanFunc(*zipkinHostPort, *zipkinServiceName, "concat")
traceSum = zipkin.ToContext(newSumSpan, tracingLogger)
traceConcat = zipkin.ToContext(newConcatSpan, tracingLogger)
mux = http.NewServeMux()
sum, concat endpoint.Endpoint
)
sum = makeSumEndpoint(svc)
sum = zipkin.AnnotateServer(newSumSpan, collector)(sum)
mux.Handle("/sum", httptransport.NewServer(
root,
sum,
server.DecodeSumRequest,
server.EncodeSumResponse,
httptransport.ServerBefore(traceSum),
httptransport.ServerErrorLogger(transportLogger),
))
concat = makeConcatEndpoint(svc)
concat = zipkin.AnnotateServer(newConcatSpan, collector)(concat)
mux.Handle("/concat", httptransport.NewServer(
root,
concat,
server.DecodeConcatRequest,
server.EncodeConcatResponse,
httptransport.ServerBefore(traceConcat),
httptransport.ServerErrorLogger(transportLogger),
))
transportLogger.Log("addr", *httpAddr)
errc <- http.ListenAndServe(*httpAddr, mux)
}()
// Transport: gRPC
go func() {
transportLogger := log.NewContext(logger).With("transport", "gRPC")
ln, err := net.Listen("tcp", *grpcAddr)
if err != nil {
errc <- err
return
}
s := grpc.NewServer() // uses its own, internal context
pb.RegisterAddServer(s, grpcBinding{svc})
transportLogger.Log("addr", *grpcAddr)
errc <- s.Serve(ln)
}()
// Transport: net/rpc
go func() {
transportLogger := log.NewContext(logger).With("transport", "net/rpc")
s := rpc.NewServer()
if err := s.RegisterName("addsvc", netrpcBinding{svc}); err != nil {
errc <- err
return
}
s.HandleHTTP(rpc.DefaultRPCPath, rpc.DefaultDebugPath)
transportLogger.Log("addr", *netrpcAddr)
errc <- http.ListenAndServe(*netrpcAddr, s)
}()
// Transport: Thrift
go func() {
var protocolFactory thrift.TProtocolFactory
switch *thriftProtocol {
case "binary":
protocolFactory = thrift.NewTBinaryProtocolFactoryDefault()
case "compact":
protocolFactory = thrift.NewTCompactProtocolFactory()
case "json":
protocolFactory = thrift.NewTJSONProtocolFactory()
case "simplejson":
protocolFactory = thrift.NewTSimpleJSONProtocolFactory()
default:
errc <- fmt.Errorf("invalid Thrift protocol %q", *thriftProtocol)
return
}
var transportFactory thrift.TTransportFactory
if *thriftBufferSize > 0 {
transportFactory = thrift.NewTBufferedTransportFactory(*thriftBufferSize)
} else {
transportFactory = thrift.NewTTransportFactory()
}
if *thriftFramed {
transportFactory = thrift.NewTFramedTransportFactory(transportFactory)
}
transport, err := thrift.NewTServerSocket(*thriftAddr)
if err != nil {
errc <- err
return
}
transportLogger := log.NewContext(logger).With("transport", "net/rpc")
transportLogger.Log("addr", *thriftAddr)
errc <- thrift.NewTSimpleServer4(
thriftadd.NewAddServiceProcessor(thriftBinding{svc}),
transport,
transportFactory,
protocolFactory,
).Serve()
}()
logger.Log("fatal", <-errc)
}
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 (
debugAddr = fs.String("debug.addr", ":8000", "Address for HTTP debug/instrumentation server")
httpAddr = fs.String("http.addr", ":8001", "Address for HTTP (JSON) server")
grpcAddr = fs.String("grpc.addr", ":8002", "Address for gRPC server")
netrpcAddr = fs.String("netrpc.addr", ":8003", "Address for net/rpc server")
thriftAddr = fs.String("thrift.addr", ":8004", "Address for Thrift server")
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")
proxyHTTPAddr = fs.String("proxy.http.url", "", "if set, proxy requests over HTTP to this addsvc")
zipkinServiceName = fs.String("zipkin.service.name", "addsvc", "Zipkin service name")
zipkinCollectorAddr = fs.String("zipkin.collector.addr", "", "Zipkin Scribe collector address (empty will log spans)")
zipkinCollectorTimeout = fs.Duration("zipkin.collector.timeout", time.Second, "Zipkin collector timeout")
zipkinCollectorBatchSize = fs.Int("zipkin.collector.batch.size", 100, "Zipkin collector batch size")
zipkinCollectorBatchInterval = fs.Duration("zipkin.collector.batch.interval", time.Second, "Zipkin collector batch interval")
)
flag.Usage = fs.Usage // only show our flags
fs.Parse(os.Args[1:])
// `package log` domain
var logger kitlog.Logger
logger = kitlog.NewLogfmtLogger(os.Stderr)
logger = kitlog.With(logger, "ts", kitlog.DefaultTimestampUTC)
stdlog.SetOutput(kitlog.NewStdlibAdapter(logger)) // redirect stdlib logging to us
stdlog.SetFlags(0) // flags are handled in our logger
// `package metrics` domain
requests := metrics.NewMultiCounter(
expvar.NewCounter("requests"),
statsd.NewCounter(ioutil.Discard, "requests_total", time.Second),
prometheus.NewCounter(stdprometheus.CounterOpts{
Namespace: "addsvc",
Subsystem: "add",
Name: "requests_total",
Help: "Total number of received requests.",
}, []string{}),
)
duration := metrics.NewTimeHistogram(time.Nanosecond, metrics.NewMultiHistogram(
expvar.NewHistogram("duration_nanoseconds_total", 0, 1e9, 3, 50, 95, 99),
statsd.NewHistogram(ioutil.Discard, "duration_nanoseconds_total", time.Second),
prometheus.NewSummary(stdprometheus.SummaryOpts{
Namespace: "addsvc",
Subsystem: "add",
Name: "duration_nanoseconds_total",
Help: "Total nanoseconds spend serving requests.",
}, []string{}),
))
// `package tracing` domain
zipkinHostPort := "localhost:1234" // TODO Zipkin makes overly simple assumptions about services
var zipkinCollector zipkin.Collector = loggingCollector{logger}
if *zipkinCollectorAddr != "" {
var err error
if zipkinCollector, err = zipkin.NewScribeCollector(
*zipkinCollectorAddr,
*zipkinCollectorTimeout,
*zipkinCollectorBatchSize,
*zipkinCollectorBatchInterval,
); err != nil {
logger.Log("err", err)
os.Exit(1)
}
}
zipkinMethodName := "add"
zipkinSpanFunc := zipkin.MakeNewSpanFunc(zipkinHostPort, *zipkinServiceName, zipkinMethodName)
zipkin.Log.Swap(logger) // log diagnostic/error details
// Our business and operational domain
var a Add = pureAdd
if *proxyHTTPAddr != "" {
var e endpoint.Endpoint
e = httpclient.NewClient("GET", *proxyHTTPAddr, zipkin.ToRequest(zipkinSpanFunc))
e = zipkin.AnnotateClient(zipkinSpanFunc, zipkinCollector)(e)
a = proxyAdd(e, logger)
}
a = logging(logger)(a)
a = instrument(requests, duration)(a)
// Server domain
var e endpoint.Endpoint
e = makeEndpoint(a)
e = zipkin.AnnotateServer(zipkinSpanFunc, zipkinCollector)(e)
// Mechanical stuff
rand.Seed(time.Now().UnixNano())
root := context.Background()
errc := make(chan error)
go func() {
errc <- interrupt()
}()
// Transport: HTTP (debug/instrumentation)
go func() {
logger.Log("addr", *debugAddr, "transport", "debug")
errc <- http.ListenAndServe(*debugAddr, nil)
}()
// Transport: HTTP (JSON)
go func() {
ctx, cancel := context.WithCancel(root)
defer cancel()
before := []httptransport.BeforeFunc{zipkin.ToContext(zipkinSpanFunc)}
after := []httptransport.AfterFunc{}
handler := makeHTTPBinding(ctx, e, before, after)
logger.Log("addr", *httpAddr, "transport", "HTTP/JSON")
errc <- http.ListenAndServe(*httpAddr, handler)
}()
// Transport: gRPC
go func() {
ln, err := net.Listen("tcp", *grpcAddr)
if err != nil {
errc <- err
return
}
s := grpc.NewServer() // uses its own context?
pb.RegisterAddServer(s, grpcBinding{e})
logger.Log("addr", *grpcAddr, "transport", "gRPC")
errc <- s.Serve(ln)
}()
// Transport: net/rpc
go func() {
ctx, cancel := context.WithCancel(root)
defer cancel()
s := rpc.NewServer()
s.RegisterName("addsvc", NetrpcBinding{ctx, e})
s.HandleHTTP(rpc.DefaultRPCPath, rpc.DefaultDebugPath)
logger.Log("addr", *netrpcAddr, "transport", "net/rpc")
errc <- http.ListenAndServe(*netrpcAddr, s)
}()
// Transport: Thrift
go func() {
ctx, cancel := context.WithCancel(root)
defer cancel()
var protocolFactory thrift.TProtocolFactory
switch *thriftProtocol {
case "binary":
protocolFactory = thrift.NewTBinaryProtocolFactoryDefault()
case "compact":
protocolFactory = thrift.NewTCompactProtocolFactory()
case "json":
protocolFactory = thrift.NewTJSONProtocolFactory()
case "simplejson":
protocolFactory = thrift.NewTSimpleJSONProtocolFactory()
default:
errc <- fmt.Errorf("invalid Thrift protocol %q", *thriftProtocol)
return
}
var transportFactory thrift.TTransportFactory
if *thriftBufferSize > 0 {
transportFactory = thrift.NewTBufferedTransportFactory(*thriftBufferSize)
} else {
transportFactory = thrift.NewTTransportFactory()
}
if *thriftFramed {
transportFactory = thrift.NewTFramedTransportFactory(transportFactory)
}
transport, err := thrift.NewTServerSocket(*thriftAddr)
if err != nil {
errc <- err
return
}
logger.Log("addr", *thriftAddr, "transport", "Thrift")
errc <- thrift.NewTSimpleServer4(
thriftadd.NewAddServiceProcessor(thriftBinding{ctx, e}),
transport,
transportFactory,
protocolFactory,
).Serve()
}()
logger.Log("fatal", <-errc)
}
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)
}
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 (
debugAddr = fs.String("debug.addr", ":8000", "Address for HTTP debug/instrumentation server")
httpAddr = fs.String("http.addr", ":8001", "Address for HTTP (JSON) server")
grpcAddr = fs.String("grpc.addr", ":8002", "Address for gRPC server")
netrpcAddr = fs.String("netrpc.addr", ":8003", "Address for net/rpc server")
thriftAddr = fs.String("thrift.addr", ":8004", "Address for Thrift server")
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")
// Supported OpenTracing backends
zipkinAddr = fs.String("zipkin.kafka.addr", "", "Enable Zipkin tracing via a Kafka server host:port")
appdashAddr = fs.String("appdash.addr", "", "Enable Appdash tracing via an Appdash server host:port")
lightstepAccessToken = fs.String("lightstep.token", "", "Enable LightStep tracing via a LightStep access token")
)
flag.Usage = fs.Usage // only show our flags
if err := fs.Parse(os.Args[1:]); err != nil {
fmt.Fprintf(os.Stderr, "%v", err)
os.Exit(1)
}
// package log
var logger log.Logger
{
logger = log.NewLogfmtLogger(os.Stderr)
logger = log.NewContext(logger).With("ts", log.DefaultTimestampUTC).With("caller", log.DefaultCaller)
stdlog.SetFlags(0) // flags are handled by Go kit's logger
stdlog.SetOutput(log.NewStdlibAdapter(logger)) // redirect anything using stdlib log to us
}
// package metrics
var requestDuration metrics.TimeHistogram
{
requestDuration = metrics.NewTimeHistogram(time.Nanosecond, metrics.NewMultiHistogram(
"request_duration_ns",
expvar.NewHistogram("request_duration_ns", 0, 5e9, 1, 50, 95, 99),
prometheus.NewSummary(stdprometheus.SummaryOpts{
Namespace: "myorg",
Subsystem: "addsvc",
Name: "duration_ns",
Help: "Request duration in nanoseconds.",
}, []string{"method"}),
))
}
// Set up OpenTracing
var tracer opentracing.Tracer
{
switch {
case *appdashAddr != "" && *lightstepAccessToken == "" && *zipkinAddr == "":
tracer = appdashot.NewTracer(appdash.NewRemoteCollector(*appdashAddr))
case *appdashAddr == "" && *lightstepAccessToken != "" && *zipkinAddr == "":
tracer = lightstep.NewTracer(lightstep.Options{
AccessToken: *lightstepAccessToken,
})
defer lightstep.FlushLightStepTracer(tracer)
case *appdashAddr == "" && *lightstepAccessToken == "" && *zipkinAddr != "":
collector, err := zipkin.NewKafkaCollector(
strings.Split(*zipkinAddr, ","),
zipkin.KafkaLogger(logger),
)
if err != nil {
logger.Log("err", "unable to create collector", "fatal", err)
os.Exit(1)
}
tracer, err = zipkin.NewTracer(
zipkin.NewRecorder(collector, false, "localhost:80", "addsvc"),
)
if err != nil {
logger.Log("err", "unable to create zipkin tracer", "fatal", err)
os.Exit(1)
}
case *appdashAddr == "" && *lightstepAccessToken == "" && *zipkinAddr == "":
tracer = opentracing.GlobalTracer() // no-op
default:
logger.Log("fatal", "specify a single -appdash.addr, -lightstep.access.token or -zipkin.kafka.addr")
os.Exit(1)
}
}
// Business domain
var svc server.AddService
{
svc = pureAddService{}
svc = loggingMiddleware{svc, logger}
svc = instrumentingMiddleware{svc, requestDuration}
}
// Mechanical stuff
rand.Seed(time.Now().UnixNano())
root := context.Background()
errc := make(chan error)
go func() {
errc <- interrupt()
}()
// Debug/instrumentation
go func() {
transportLogger := log.NewContext(logger).With("transport", "debug")
transportLogger.Log("addr", *debugAddr)
errc <- http.ListenAndServe(*debugAddr, nil) // DefaultServeMux
}()
// Transport: HTTP/JSON
go func() {
var (
transportLogger = log.NewContext(logger).With("transport", "HTTP/JSON")
tracingLogger = log.NewContext(transportLogger).With("component", "tracing")
mux = http.NewServeMux()
sum, concat endpoint.Endpoint
)
sum = makeSumEndpoint(svc)
sum = kitot.TraceServer(tracer, "sum")(sum)
mux.Handle("/sum", httptransport.NewServer(
root,
sum,
server.DecodeSumRequest,
server.EncodeSumResponse,
httptransport.ServerErrorLogger(transportLogger),
httptransport.ServerBefore(kitot.FromHTTPRequest(tracer, "sum", tracingLogger)),
))
concat = makeConcatEndpoint(svc)
concat = kitot.TraceServer(tracer, "concat")(concat)
mux.Handle("/concat", httptransport.NewServer(
root,
concat,
server.DecodeConcatRequest,
server.EncodeConcatResponse,
httptransport.ServerErrorLogger(transportLogger),
httptransport.ServerBefore(kitot.FromHTTPRequest(tracer, "concat", tracingLogger)),
))
transportLogger.Log("addr", *httpAddr)
errc <- http.ListenAndServe(*httpAddr, mux)
}()
// Transport: gRPC
go func() {
transportLogger := log.NewContext(logger).With("transport", "gRPC")
tracingLogger := log.NewContext(transportLogger).With("component", "tracing")
ln, err := net.Listen("tcp", *grpcAddr)
if err != nil {
errc <- err
return
}
s := grpc.NewServer() // uses its own, internal context
pb.RegisterAddServer(s, newGRPCBinding(root, tracer, svc, tracingLogger))
transportLogger.Log("addr", *grpcAddr)
errc <- s.Serve(ln)
}()
// Transport: net/rpc
go func() {
transportLogger := log.NewContext(logger).With("transport", "net/rpc")
s := rpc.NewServer()
if err := s.RegisterName("addsvc", netrpcBinding{svc}); err != nil {
errc <- err
return
}
s.HandleHTTP(rpc.DefaultRPCPath, rpc.DefaultDebugPath)
transportLogger.Log("addr", *netrpcAddr)
errc <- http.ListenAndServe(*netrpcAddr, s)
}()
// Transport: Thrift
go func() {
var protocolFactory thrift.TProtocolFactory
switch *thriftProtocol {
case "binary":
protocolFactory = thrift.NewTBinaryProtocolFactoryDefault()
case "compact":
protocolFactory = thrift.NewTCompactProtocolFactory()
case "json":
protocolFactory = thrift.NewTJSONProtocolFactory()
case "simplejson":
protocolFactory = thrift.NewTSimpleJSONProtocolFactory()
default:
errc <- fmt.Errorf("invalid Thrift protocol %q", *thriftProtocol)
return
}
var transportFactory thrift.TTransportFactory
if *thriftBufferSize > 0 {
transportFactory = thrift.NewTBufferedTransportFactory(*thriftBufferSize)
} else {
transportFactory = thrift.NewTTransportFactory()
}
if *thriftFramed {
transportFactory = thrift.NewTFramedTransportFactory(transportFactory)
}
transport, err := thrift.NewTServerSocket(*thriftAddr)
if err != nil {
errc <- err
return
}
transportLogger := log.NewContext(logger).With("transport", "thrift")
transportLogger.Log("addr", *thriftAddr)
errc <- thrift.NewTSimpleServer4(
thriftadd.NewAddServiceProcessor(thriftBinding{svc}),
transport,
transportFactory,
protocolFactory,
).Serve()
}()
logger.Log("fatal", <-errc)
}
func main() {
var (
debugAddr = flag.String("debug.addr", ":8080", "Debug and metrics listen address")
httpAddr = flag.String("http.addr", ":8081", "HTTP listen address")
grpcAddr = flag.String("grpc.addr", ":8082", "gRPC (HTTP) listen address")
thriftAddr = flag.String("thrift.addr", ":8083", "Thrift listen address")
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")
zipkinAddr = flag.String("zipkin.addr", "", "Enable Zipkin tracing via a Kafka server host:port")
appdashAddr = flag.String("appdash.addr", "", "Enable Appdash tracing via an Appdash server host:port")
lightstepToken = flag.String("lightstep.token", "", "Enable LightStep tracing via a LightStep access token")
)
flag.Parse()
// Logging domain.
var logger log.Logger
{
logger = log.NewLogfmtLogger(os.Stdout)
logger = log.NewContext(logger).With("ts", log.DefaultTimestampUTC)
logger = log.NewContext(logger).With("caller", log.DefaultCaller)
}
logger.Log("msg", "hello")
defer logger.Log("msg", "goodbye")
// Metrics domain.
var ints, chars metrics.Counter
{
// Business level metrics.
ints = prometheus.NewCounter(stdprometheus.CounterOpts{
Namespace: "addsvc",
Name: "integers_summed",
Help: "Total count of integers summed via the Sum method.",
}, []string{})
chars = prometheus.NewCounter(stdprometheus.CounterOpts{
Namespace: "addsvc",
Name: "characters_concatenated",
Help: "Total count of characters concatenated via the Concat method.",
}, []string{})
}
var duration metrics.TimeHistogram
{
// Transport level metrics.
duration = metrics.NewTimeHistogram(time.Nanosecond, prometheus.NewSummary(stdprometheus.SummaryOpts{
Namespace: "addsvc",
Name: "request_duration_ns",
Help: "Request duration in nanoseconds.",
}, []string{"method", "success"}))
}
// Tracing domain.
var tracer stdopentracing.Tracer
{
if *zipkinAddr != "" {
logger := log.NewContext(logger).With("tracer", "Zipkin")
logger.Log("addr", *zipkinAddr)
collector, err := zipkin.NewKafkaCollector(
strings.Split(*zipkinAddr, ","),
zipkin.KafkaLogger(logger),
)
if err != nil {
logger.Log("err", err)
os.Exit(1)
}
tracer, err = zipkin.NewTracer(
zipkin.NewRecorder(collector, false, "localhost:80", "addsvc"),
)
if err != nil {
logger.Log("err", err)
os.Exit(1)
}
} else if *appdashAddr != "" {
logger := log.NewContext(logger).With("tracer", "Appdash")
logger.Log("addr", *appdashAddr)
tracer = appdashot.NewTracer(appdash.NewRemoteCollector(*appdashAddr))
} else if *lightstepToken != "" {
logger := log.NewContext(logger).With("tracer", "LightStep")
logger.Log() // probably don't want to print out the token :)
tracer = lightstep.NewTracer(lightstep.Options{
AccessToken: *lightstepToken,
})
defer lightstep.FlushLightStepTracer(tracer)
} else {
logger := log.NewContext(logger).With("tracer", "none")
logger.Log()
tracer = stdopentracing.GlobalTracer() // no-op
}
}
// Business domain.
var service addsvc.Service
{
service = addsvc.NewBasicService()
service = addsvc.ServiceLoggingMiddleware(logger)(service)
service = addsvc.ServiceInstrumentingMiddleware(ints, chars)(service)
}
// Endpoint domain.
var sumEndpoint endpoint.Endpoint
{
sumDuration := duration.With(metrics.Field{Key: "method", Value: "Sum"})
sumLogger := log.NewContext(logger).With("method", "Sum")
sumEndpoint = addsvc.MakeSumEndpoint(service)
sumEndpoint = opentracing.TraceServer(tracer, "Sum")(sumEndpoint)
sumEndpoint = addsvc.EndpointInstrumentingMiddleware(sumDuration)(sumEndpoint)
sumEndpoint = addsvc.EndpointLoggingMiddleware(sumLogger)(sumEndpoint)
}
var concatEndpoint endpoint.Endpoint
{
concatDuration := duration.With(metrics.Field{Key: "method", Value: "Concat"})
concatLogger := log.NewContext(logger).With("method", "Concat")
concatEndpoint = addsvc.MakeConcatEndpoint(service)
concatEndpoint = opentracing.TraceServer(tracer, "Concat")(concatEndpoint)
concatEndpoint = addsvc.EndpointInstrumentingMiddleware(concatDuration)(concatEndpoint)
concatEndpoint = addsvc.EndpointLoggingMiddleware(concatLogger)(concatEndpoint)
}
endpoints := addsvc.Endpoints{
SumEndpoint: sumEndpoint,
ConcatEndpoint: concatEndpoint,
}
// Mechanical domain.
errc := make(chan error)
ctx := context.Background()
// Interrupt handler.
go func() {
c := make(chan os.Signal, 1)
signal.Notify(c, syscall.SIGINT, syscall.SIGTERM)
errc <- fmt.Errorf("%s", <-c)
}()
// Debug listener.
go func() {
logger := log.NewContext(logger).With("transport", "debug")
m := http.NewServeMux()
m.Handle("/debug/pprof/", http.HandlerFunc(pprof.Index))
m.Handle("/debug/pprof/cmdline", http.HandlerFunc(pprof.Cmdline))
m.Handle("/debug/pprof/profile", http.HandlerFunc(pprof.Profile))
m.Handle("/debug/pprof/symbol", http.HandlerFunc(pprof.Symbol))
m.Handle("/debug/pprof/trace", http.HandlerFunc(pprof.Trace))
m.Handle("/metrics", stdprometheus.Handler())
logger.Log("addr", *debugAddr)
errc <- http.ListenAndServe(*debugAddr, m)
}()
// HTTP transport.
go func() {
logger := log.NewContext(logger).With("transport", "HTTP")
h := addsvc.MakeHTTPHandler(ctx, endpoints, tracer, logger)
logger.Log("addr", *httpAddr)
errc <- http.ListenAndServe(*httpAddr, h)
}()
// gRPC transport.
go func() {
logger := log.NewContext(logger).With("transport", "gRPC")
ln, err := net.Listen("tcp", *grpcAddr)
if err != nil {
errc <- err
return
}
srv := addsvc.MakeGRPCServer(ctx, endpoints, tracer, logger)
s := grpc.NewServer()
pb.RegisterAddServer(s, srv)
logger.Log("addr", *grpcAddr)
errc <- s.Serve(ln)
}()
// Thrift transport.
go func() {
logger := log.NewContext(logger).With("transport", "Thrift")
var protocolFactory thrift.TProtocolFactory
switch *thriftProtocol {
case "binary":
protocolFactory = thrift.NewTBinaryProtocolFactoryDefault()
case "compact":
protocolFactory = thrift.NewTCompactProtocolFactory()
case "json":
protocolFactory = thrift.NewTJSONProtocolFactory()
case "simplejson":
protocolFactory = thrift.NewTSimpleJSONProtocolFactory()
default:
errc <- fmt.Errorf("invalid Thrift protocol %q", *thriftProtocol)
return
}
var transportFactory thrift.TTransportFactory
if *thriftBufferSize > 0 {
transportFactory = thrift.NewTBufferedTransportFactory(*thriftBufferSize)
} else {
transportFactory = thrift.NewTTransportFactory()
}
if *thriftFramed {
transportFactory = thrift.NewTFramedTransportFactory(transportFactory)
}
transport, err := thrift.NewTServerSocket(*thriftAddr)
if err != nil {
errc <- err
return
}
logger.Log("addr", *thriftAddr)
errc <- thrift.NewTSimpleServer4(
thriftadd.NewAddServiceProcessor(addsvc.MakeThriftHandler(ctx, endpoints)),
transport,
transportFactory,
protocolFactory,
).Serve()
}()
// Run!
logger.Log("exit", <-errc)
}
func main() {
// The addcli presumes no service discovery system, and expects users to
// provide the direct address of an addsvc. This presumption is reflected in
// the addcli binary and the the client packages: the -transport.addr flags
// and various client constructors both expect host:port strings. For an
// example service with a client built on top of a service discovery system,
// see profilesvc.
var (
httpAddr = flag.String("http.addr", "", "HTTP address of addsvc")
grpcAddr = flag.String("grpc.addr", "", "gRPC (HTTP) address of addsvc")
thriftAddr = flag.String("thrift.addr", "", "Thrift address of addsvc")
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")
zipkinAddr = flag.String("zipkin.addr", "", "Enable Zipkin tracing via a Kafka Collector host:port")
appdashAddr = flag.String("appdash.addr", "", "Enable Appdash tracing via an Appdash server host:port")
lightstepToken = flag.String("lightstep.token", "", "Enable LightStep tracing via a LightStep access token")
method = flag.String("method", "sum", "sum, concat")
)
flag.Parse()
if len(flag.Args()) != 2 {
fmt.Fprintf(os.Stderr, "usage: addcli [flags] <a> <b>\n")
os.Exit(1)
}
// This is a demonstration client, which supports multiple tracers.
// Your clients will probably just use one tracer.
var tracer stdopentracing.Tracer
{
if *zipkinAddr != "" {
collector, err := zipkin.NewKafkaCollector(
strings.Split(*zipkinAddr, ","),
zipkin.KafkaLogger(log.NewNopLogger()),
)
if err != nil {
fmt.Fprintf(os.Stderr, "%v\n", err)
os.Exit(1)
}
tracer, err = zipkin.NewTracer(
zipkin.NewRecorder(collector, false, "localhost:8000", "addcli"),
)
if err != nil {
fmt.Fprintf(os.Stderr, "%v\n", err)
os.Exit(1)
}
} else if *appdashAddr != "" {
tracer = appdashot.NewTracer(appdash.NewRemoteCollector(*appdashAddr))
} else if *lightstepToken != "" {
tracer = lightstep.NewTracer(lightstep.Options{
AccessToken: *lightstepToken,
})
defer lightstep.FlushLightStepTracer(tracer)
} else {
tracer = stdopentracing.GlobalTracer() // no-op
}
}
// This is a demonstration client, which supports multiple transports.
// Your clients will probably just define and stick with 1 transport.
var (
service addsvc.Service
err error
)
if *httpAddr != "" {
service, err = httpclient.New(*httpAddr, tracer, log.NewNopLogger())
} else if *grpcAddr != "" {
conn, err := grpc.Dial(*grpcAddr, grpc.WithInsecure(), grpc.WithTimeout(time.Second))
if err != nil {
fmt.Fprintf(os.Stderr, "error: %v", err)
os.Exit(1)
}
defer conn.Close()
service = grpcclient.New(conn, tracer, log.NewNopLogger())
} else if *thriftAddr != "" {
// It's necessary to do all of this construction in the func main,
// because (among other reasons) we need to control the lifecycle of the
// Thrift transport, i.e. close it eventually.
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:
fmt.Fprintf(os.Stderr, "error: invalid protocol %q\n", *thriftProtocol)
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 {
fmt.Fprintf(os.Stderr, "error: %v\n", err)
os.Exit(1)
}
transport := transportFactory.GetTransport(transportSocket)
if err := transport.Open(); err != nil {
fmt.Fprintf(os.Stderr, "error: %v\n", err)
os.Exit(1)
}
defer transport.Close()
client := thriftadd.NewAddServiceClientFactory(transport, protocolFactory)
service = thriftclient.New(client)
} else {
fmt.Fprintf(os.Stderr, "error: no remote address specified\n")
os.Exit(1)
}
if err != nil {
fmt.Fprintf(os.Stderr, "error: %v\n", err)
os.Exit(1)
}
switch *method {
case "sum":
a, _ := strconv.ParseInt(flag.Args()[0], 10, 64)
b, _ := strconv.ParseInt(flag.Args()[1], 10, 64)
v, err := service.Sum(context.Background(), int(a), int(b))
if err != nil {
fmt.Fprintf(os.Stderr, "error: %v\n", err)
os.Exit(1)
}
fmt.Fprintf(os.Stdout, "%d + %d = %d\n", a, b, v)
case "concat":
a := flag.Args()[0]
b := flag.Args()[1]
v, err := service.Concat(context.Background(), a, b)
if err != nil {
fmt.Fprintf(os.Stderr, "error: %v\n", err)
os.Exit(1)
}
fmt.Fprintf(os.Stdout, "%q + %q = %q\n", a, b, v)
default:
fmt.Fprintf(os.Stderr, "error: invalid method %q\n", method)
os.Exit(1)
}
}
