func TestSetContentType(t *testing.T) {
const contentType = "application/json"
r := httptest.NewRecorder()
httptransport.SetContentType(contentType)(context.Background(), r)
if want, have := contentType, r.Header().Get("Content-Type"); want != have {
t.Errorf("want %q, have %q", want, have)
}
}
// NewHandler return a http.Handler for a function endpoint
//
// NewHandler will add an AfterFunc that sets the response content type to application/json; charset=utf-8
func NewHandler(ctx context.Context,
endpoint endpoint.Endpoint,
decode transport.DecodeFunc,
encode transport.EncodeFunc,
before []transport.BeforeFunc,
after []transport.AfterFunc,
) http.Handler {
return transport.Server{
Context: ctx,
Endpoint: endpoint,
DecodeFunc: decode,
EncodeFunc: encode,
Before: before,
After: append([]transport.AfterFunc{
transport.SetContentType("application/json; charset=utf-8"),
}, after...),
}
}
func makeHTTPBinding(ctx context.Context, e endpoint.Endpoint, before []httptransport.RequestFunc, after []httptransport.ResponseFunc) http.Handler {
decode := func(r *http.Request) (interface{}, error) {
var request reqrep.AddRequest
if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
return nil, err
}
return request, nil
}
encode := func(w http.ResponseWriter, response interface{}) error {
return json.NewEncoder(w).Encode(response)
}
return httptransport.Server{
Context: ctx,
Endpoint: e,
DecodeRequestFunc: decode,
EncodeResponseFunc: encode,
Before: before,
After: append([]httptransport.ResponseFunc{httptransport.SetContentType("application/json; charset=utf-8")}, after...),
}
}
"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)
defer res.Close()
"golang.org/x/net/context"
"github.com/tgulacsi/agostle/converter"
kithttp "github.com/go-kit/kit/transport/http"
"gopkg.in/errgo.v1"
)
var pdfMergeServer = kithttp.NewServer(
context.Background(),
pdfMergeEP,
pdfMergeDecode,
pdfMergeEncode,
kithttp.ServerBefore(defaultBeforeFuncs...),
kithttp.ServerAfter(kithttp.SetContentType("application/pdf")),
)
func pdfMergeDecode(r *http.Request) (interface{}, error) {
inputs, err := getRequestFiles(r)
if err != nil {
return nil, err
}
req := pdfMergeRequest{Inputs: inputs}
switch r.URL.Query().Get("sort") {
case "0":
req.Sort = NoSort
case "1":
req.Sort = DoSort
default:
req.Sort = DefaultSort
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")
thriftAddr = fs.String("thrift.addr", ":8003", "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, "caller", kitlog.DefaultCaller)
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.NewMultiHistogram(
expvar.NewHistogram("duration_nanoseconds_total", 0, 100000000, 3),
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 != "" {
codec := jsoncodec.New()
makeResponse := func() interface{} { return &addResponse{} }
var e endpoint.Endpoint
e = httptransport.NewClient(*proxyHTTPAddr, codec, makeResponse, httptransport.ClientBefore(zipkin.ToRequest(zipkinSpanFunc)))
e = zipkin.AnnotateClient(zipkinSpanFunc, zipkinCollector)(e)
a = proxyAdd(e, logger)
}
a = logging(logger)(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()
field := metrics.Field{Key: "transport", Value: "http"}
before := httptransport.BindingBefore(zipkin.ToContext(zipkinSpanFunc))
after := httptransport.BindingAfter(httptransport.SetContentType("application/json"))
makeRequest := func() interface{} { return &addRequest{} }
var handler http.Handler
handler = httptransport.NewBinding(ctx, makeRequest, jsoncodec.New(), e, before, after)
handler = encoding.Gzip(handler)
handler = cors.Middleware(cors.Config{})(handler)
handler = httpInstrument(requests.With(field), duration.With(field))(handler)
mux := http.NewServeMux()
mux.Handle("/add", handler)
logger.Log("addr", *httpAddr, "transport", "HTTP")
errc <- http.ListenAndServe(*httpAddr, mux)
}()
// Transport: gRPC
go func() {
ln, err := net.Listen("tcp", *grpcAddr)
if err != nil {
errc <- err
return
}
s := grpc.NewServer() // uses its own context?
field := metrics.Field{Key: "transport", Value: "grpc"}
var addServer pb.AddServer
addServer = grpcBinding{e}
addServer = grpcInstrument(requests.With(field), duration.With(field))(addServer)
pb.RegisterAddServer(s, addServer)
logger.Log("addr", *grpcAddr, "transport", "gRPC")
errc <- s.Serve(ln)
}()
// 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
}
field := metrics.Field{Key: "transport", Value: "thrift"}
var service thriftadd.AddService
service = thriftBinding{ctx, e}
service = thriftInstrument(requests.With(field), duration.With(field))(service)
logger.Log("addr", *thriftAddr, "transport", "Thrift")
errc <- thrift.NewTSimpleServer4(
thriftadd.NewAddServiceProcessor(service),
transport,
transportFactory,
protocolFactory,
).Serve()
}()
logger.Log("fatal", <-errc)
}
