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) } }
func main() { flag.Usage = Usage var host string var port int var protocol string var urlString string var framed bool var useHttp bool var parsedUrl url.URL var trans thrift.TTransport _ = strconv.Atoi _ = math.Abs flag.Usage = Usage flag.StringVar(&host, "h", "localhost", "Specify host and port") flag.IntVar(&port, "p", 9090, "Specify port") flag.StringVar(&protocol, "P", "binary", "Specify the protocol (binary, compact, simplejson, json)") flag.StringVar(&urlString, "u", "", "Specify the url") flag.BoolVar(&framed, "framed", false, "Use framed transport") flag.BoolVar(&useHttp, "http", false, "Use http") flag.Parse() if len(urlString) > 0 { parsedUrl, err := url.Parse(urlString) if err != nil { fmt.Fprintln(os.Stderr, "Error parsing URL: ", err) flag.Usage() } host = parsedUrl.Host useHttp = len(parsedUrl.Scheme) <= 0 || parsedUrl.Scheme == "http" } else if useHttp { _, err := url.Parse(fmt.Sprint("http://", host, ":", port)) if err != nil { fmt.Fprintln(os.Stderr, "Error parsing URL: ", err) flag.Usage() } } cmd := flag.Arg(0) var err error if useHttp { trans, err = thrift.NewTHttpClient(parsedUrl.String()) } else { portStr := fmt.Sprint(port) if strings.Contains(host, ":") { host, portStr, err = net.SplitHostPort(host) if err != nil { fmt.Fprintln(os.Stderr, "error with host:", err) os.Exit(1) } } trans, err = thrift.NewTSocket(net.JoinHostPort(host, portStr)) if err != nil { fmt.Fprintln(os.Stderr, "error resolving address:", err) os.Exit(1) } if framed { trans = thrift.NewTFramedTransport(trans) } } if err != nil { fmt.Fprintln(os.Stderr, "Error creating transport", err) os.Exit(1) } defer trans.Close() var protocolFactory thrift.TProtocolFactory switch protocol { case "compact": protocolFactory = thrift.NewTCompactProtocolFactory() break case "simplejson": protocolFactory = thrift.NewTSimpleJSONProtocolFactory() break case "json": protocolFactory = thrift.NewTJSONProtocolFactory() break case "binary", "": protocolFactory = thrift.NewTBinaryProtocolFactoryDefault() break default: fmt.Fprintln(os.Stderr, "Invalid protocol specified: ", protocol) Usage() os.Exit(1) } client := addsvc.NewAddServiceClientFactory(trans, protocolFactory) if err := trans.Open(); err != nil { fmt.Fprintln(os.Stderr, "Error opening socket to ", host, ":", port, " ", err) os.Exit(1) } switch cmd { case "Sum": if flag.NArg()-1 != 2 { fmt.Fprintln(os.Stderr, "Sum requires 2 args") flag.Usage() } argvalue0, err6 := (strconv.ParseInt(flag.Arg(1), 10, 64)) if err6 != nil { Usage() return } value0 := argvalue0 argvalue1, err7 := (strconv.ParseInt(flag.Arg(2), 10, 64)) if err7 != nil { Usage() return } value1 := argvalue1 fmt.Print(client.Sum(value0, value1)) fmt.Print("\n") break case "Concat": if flag.NArg()-1 != 2 { fmt.Fprintln(os.Stderr, "Concat requires 2 args") flag.Usage() } argvalue0 := flag.Arg(1) value0 := argvalue0 argvalue1 := flag.Arg(2) value1 := argvalue1 fmt.Print(client.Concat(value0, value1)) fmt.Print("\n") break case "": Usage() break default: fmt.Fprintln(os.Stderr, "Invalid function ", cmd) } }