func testServer(t *testing.T) (cancel, step func(), resp <-chan *http.Response) { var ( ctx, cancelfn = context.WithCancel(context.Background()) stepch = make(chan bool) endpoint = func(context.Context, interface{}) (interface{}, error) { <-stepch; return struct{}{}, nil } response = make(chan *http.Response) handler = httptransport.NewServer( ctx, endpoint, func(*http.Request) (interface{}, error) { return struct{}{}, nil }, func(http.ResponseWriter, interface{}) error { return nil }, httptransport.ServerBefore(func(ctx context.Context, r *http.Request) context.Context { return ctx }), httptransport.ServerAfter(func(ctx context.Context, w http.ResponseWriter) { return }), ) ) go func() { server := httptest.NewServer(handler) defer server.Close() resp, err := http.Get(server.URL) if err != nil { t.Error(err) return } response <- resp }() return cancelfn, func() { stepch <- true }, response }
func main() { logger := log.NewLogfmtLogger(os.Stdout) ctx := context.Background() c := &countService{} var svc endpoint.Endpoint svc = makeAddEndpoint(c) limit := ratelimit.NewBucket(2*time.Second, 1) svc = kitratelimit.NewTokenBucketLimiter(limit)(svc) requestCount := expvar.NewCounter("request.count") svc = metricsMiddleware(requestCount)(svc) svc = loggingMiddlware(logger)(svc) addHandler := httptransport.NewServer( ctx, svc, decodeAddRequest, encodeResponse, httptransport.ServerBefore(beforeIDExtractor, beforePATHExtractor), ) http.Handle("/add", addHandler) port := os.Getenv("PORT") logger.Log("listening on", port) if err := http.ListenAndServe(":"+port, nil); err != nil { logger.Log("listen.error", err) } }
// MakeHTTPHandler returns a handler that makes a set of endpoints available // on predefined paths. func MakeHTTPHandler(ctx context.Context, endpoints Endpoints, tracer stdopentracing.Tracer, logger log.Logger) http.Handler { options := []httptransport.ServerOption{ httptransport.ServerErrorEncoder(errorEncoder), httptransport.ServerErrorLogger(logger), } m := http.NewServeMux() m.Handle("/sum", httptransport.NewServer( ctx, endpoints.SumEndpoint, DecodeHTTPSumRequest, EncodeHTTPGenericResponse, append(options, httptransport.ServerBefore(opentracing.FromHTTPRequest(tracer, "Sum", logger)))..., )) m.Handle("/concat", httptransport.NewServer( ctx, endpoints.ConcatEndpoint, DecodeHTTPConcatRequest, EncodeHTTPGenericResponse, append(options, httptransport.ServerBefore(opentracing.FromHTTPRequest(tracer, "Concat", logger)))..., )) return m }
// Handler returns go-kit http transport server // of the given definition func (s Service) Handler() http.Handler { ep := s.Middlewares.Chain()(s.Endpoint) options := append([]httptransport.ServerOption{ httptransport.ServerBefore(s.Before...), httptransport.ServerAfter(s.After...), httptransport.ServerErrorEncoder(s.ErrorEncoder), }, s.Options...) return httptransport.NewServer( s.Context, ep, s.DecodeFunc, s.EncodeFunc, options...) }
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) }
"io" "net/http" "golang.org/x/net/context" "github.com/tgulacsi/agostle/converter" kithttp "github.com/go-kit/kit/transport/http" ) var outlookToEmailServer = kithttp.NewServer( context.Background(), outlookToEmailEP, outlookToEmailDecode, outlookToEmailEncode, kithttp.ServerBefore(defaultBeforeFuncs...), kithttp.ServerAfter(kithttp.SetContentType("mail/rfc822")), ) func outlookToEmailDecode(r *http.Request) (interface{}, error) { return getOneRequestFile(r) } func outlookToEmailEP(ctx context.Context, request interface{}) (response interface{}, err error) { f := request.(reqFile) defer f.Close() return converter.NewOLEStorageReader(f) } func outlookToEmailEncode(w http.ResponseWriter, response interface{}) error { res := response.(io.ReadCloser)
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) }
"regexp" "strings" "golang.org/x/net/context" "github.com/tgulacsi/agostle/converter" kithttp "github.com/go-kit/kit/transport/http" ) var emailConvertServer = kithttp.NewServer( context.Background(), emailConvertEP, emailConvertDecode, emailConvertEncode, kithttp.ServerBefore(append([]kithttp.RequestFunc{SaveRequest}, defaultBeforeFuncs...)...), kithttp.ServerAfter(kithttp.SetContentType("application/zip")), ) type convertParams struct { ContentType, OutImg, ImgSize string Splitted bool } func (p convertParams) String() string { c := "m" if p.Splitted { c = "s" } return strings.Replace(p.ContentType, "/", "--", -1) + "_" + strings.Replace(p.OutImg, "/", "--", -1) + "_" + p.ImgSize + "_" + c }