// ConcatEndpointFactory transforms host:port strings into Endpoints. func (c client) ConcatEndpoint(instance string) (endpoint.Endpoint, io.Closer, error) { transportSocket, err := thrift.NewTSocket(instance) if err != nil { c.Logger.Log("during", "thrift.NewTSocket", "err", err) return nil, nil, err } trans := c.TTransportFactory.GetTransport(transportSocket) if err := trans.Open(); err != nil { c.Logger.Log("during", "thrift transport.Open", "err", err) return nil, nil, err } cli := thriftadd.NewAddServiceClientFactory(trans, c.TProtocolFactory) return func(ctx context.Context, request interface{}) (interface{}, error) { concatRequest := request.(server.ConcatRequest) reply, err := cli.Concat(concatRequest.A, concatRequest.B) if err != nil { return server.ConcatResponse{}, err } return server.ConcatResponse{V: reply.Value}, nil }, trans, nil }
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 := add.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) } }
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) } }