template_files.go

// Code generated by go-bindata.
// sources:
// codegen/templates/endpoint.tmpl
// codegen/templates/endpoint_register.tmpl
// codegen/templates/endpoint_test.tmpl
// codegen/templates/http_client.tmpl
// codegen/templates/init_clients.tmpl
// codegen/templates/main.tmpl
// codegen/templates/main_test.tmpl
// codegen/templates/structs.tmpl
// codegen/templates/tchannel_client.tmpl
// codegen/templates/tchannel_client_test_server.tmpl
// DO NOT EDIT!

package templates

import (
	"fmt"
	"io/ioutil"
	"os"
	"path/filepath"
	"strings"
	"time"
)

type asset struct {
	bytes []byte
	info  os.FileInfo
}

type bindataFileInfo struct {
	name    string
	size    int64
	mode    os.FileMode
	modTime time.Time
}

func (fi bindataFileInfo) Name() string {
	return fi.name
}
func (fi bindataFileInfo) Size() int64 {
	return fi.size
}
func (fi bindataFileInfo) Mode() os.FileMode {
	return fi.mode
}
func (fi bindataFileInfo) ModTime() time.Time {
	return fi.modTime
}
func (fi bindataFileInfo) IsDir() bool {
	return false
}
func (fi bindataFileInfo) Sys() interface{} {
	return nil
}

var _endpointTmpl = []byte(`{{/* template to render gateway http endpoint code */ -}}

package {{.PackageName}}

import (
	"context"
	"io/ioutil"
	"net/http"

	"github.com/pkg/errors"
	"go.uber.org/zap"
	"{{.GatewayPackageName}}/clients"
	zanzibar "github.com/uber/zanzibar/runtime"

	{{range $idx, $pkg := .IncludedPackages -}}
	{{$pkg.AliasName}} "{{$pkg.PackageName}}"
	{{end -}}

	{{if .Method.Downstream }}
	{{- range $idx, $pkg := .Method.Downstream.IncludedPackages -}}
	{{$file := basePath $pkg.PackageName -}}
	{{$pkg.AliasName}} "{{$pkg.PackageName}}"
	{{end}}
	{{- end}}
)

{{ $workflow := .WorkflowName -}}
{{ $reqHeaderMap := .ReqHeaderMap -}}
{{ $reqHeaderMapKeys := .ReqHeaderMapKeys -}}
{{ $resHeaderMap := .ResHeaderMap -}}
{{ $resHeaderMapKeys := .ResHeaderMapKeys -}}
{{ $clientName := title .ClientName -}}
{{ $handlerName := title .Method.Name | printf "%sHandler" }}
{{ $responseType := .Method.ResponseType}}
{{with .Method -}}

// {{$handlerName}} is the handler for "{{.HTTPPath}}"
type {{$handlerName}} struct {
	Clients *clients.Clients
}

// New{{title .Name}}Endpoint creates a handler
func New{{title .Name}}Endpoint(
	gateway *zanzibar.Gateway,
) *{{$handlerName}} {
	return &{{$handlerName}}{
		Clients: gateway.Clients.(*clients.Clients),
	}
}

// HandleRequest handles "{{.HTTPPath}}".
func (handler *{{$handlerName}}) HandleRequest(
	ctx context.Context,
	req *zanzibar.ServerHTTPRequest,
	res *zanzibar.ServerHTTPResponse,
) {
	{{- if .ReqHeaders -}}
	if !req.CheckHeaders({{.ReqHeaders | printf "%#v" }}) {
		return
	}
	{{- end -}}

	{{if ne .RequestType ""}}
	var requestBody {{.RequestType}}
	if ok := req.ReadAndUnmarshalBody(&requestBody); !ok {
		return
	}
	{{end}}

	workflow := {{$workflow}}{
		Clients: handler.Clients,
		Logger: req.Logger,
		Request: req,
	}

	{{if and (eq .RequestType "") (eq .ResponseType "")}}
	cliRespHeaders, err := workflow.Handle(ctx, req.Header)
	{{else if eq .RequestType ""}}
	response, cliRespHeaders, err := workflow.Handle(ctx, req.Header)
	{{else if eq .ResponseType ""}}
	cliRespHeaders, err := workflow.Handle(ctx, req.Header, &requestBody)
	{{else}}
	response, cliRespHeaders, err := workflow.Handle(ctx, req.Header, &requestBody)
	{{end -}}
	if err != nil {
		switch errValue := err.(type) {
			{{range $idx, $exception := .Exceptions}}
			case *{{$exception.Type}}:
				res.WriteJSON(
					{{$exception.StatusCode.Code}}, cliRespHeaders, errValue,
				)
				return
			{{end}}
			default:
				req.Logger.Warn("Workflow for endpoint returned error",
					zap.String("error", errValue.Error()),
				)
				res.SendErrorString(500, "Unexpected server error")
				return
		}
	}

	{{- if .ReqHeaders }}
	// TODO(sindelar): implement check headers on response
	{{- end }}

	{{if eq .ResponseType "" -}}
	res.WriteJSONBytes({{.OKStatusCode.Code}}, cliRespHeaders, nil)
	{{- else -}}
	res.WriteJSON({{.OKStatusCode.Code}}, cliRespHeaders, response)
	{{- end }}
}

{{end -}}

{{- if .Method.Downstream }}
{{- with .Method -}}
{{- $methodName := title .Name }}
{{- $clientPackage := .Downstream.PackageName -}}
{{- $clientMethod := .DownstreamMethod -}}
{{- $clientReqType := fullTypeName ($clientMethod).RequestType ($clientPackage) -}}
{{- $clientResType := fullTypeName  ($clientMethod).ResponseType ($clientPackage) -}}
{{- $clientMethodName := title ($clientMethod).Name -}}
{{- $clientExceptions := .DownstreamMethod.Exceptions -}}

// {{$workflow}} calls thrift client {{$clientName}}.{{$clientMethodName}}
type {{$workflow}} struct {
	Clients *clients.Clients
	Logger  *zap.Logger
	Request *zanzibar.ServerHTTPRequest
}

// Handle calls thrift client.
func (w {{$workflow}}) Handle(
{{- if and (eq .RequestType "") (eq .ResponseType "") }}
	ctx context.Context,
	reqHeaders zanzibar.Header,
) (zanzibar.Header, error) {
{{else if eq .RequestType "" }}
	ctx context.Context,
	reqHeaders zanzibar.Header,
) (*{{.ResponseType}}, zanzibar.Header, error) {
{{else if eq .ResponseType "" }}
	ctx context.Context,
	reqHeaders zanzibar.Header,
	r *{{.RequestType}},
) (zanzibar.Header, error) {
{{else}}
	ctx context.Context,
	reqHeaders zanzibar.Header,	
	r *{{.RequestType}},
) (*{{.ResponseType}}, zanzibar.Header, error) {
{{- end}}
	{{- if ne .RequestType "" -}}
	clientRequest := convertTo{{title .Name}}ClientRequest(r)
	{{end}}
	clientHeaders := map[string]string{}
	{{if (ne (len $reqHeaderMapKeys) 0) }}
	var ok bool
	var h string
	{{- end -}}
	{{range $i, $k := $reqHeaderMapKeys}}
	h, ok = reqHeaders.Get("{{$k}}")
	if ok {
		clientHeaders["{{index $reqHeaderMap $k}}"] = h
	}
	{{- end}}
	{{if and (eq $clientReqType "") (eq $clientResType "")}}
		{{if (eq (len $resHeaderMap) 0) -}}
		_, err := w.Clients.{{$clientName}}.{{$clientMethodName}}(ctx, clientHeaders)
		{{else}}
		cliRespHeaders, err := w.Clients.{{$clientName}}.{{$clientMethodName}}(ctx, clientHeaders)
		{{- end }}
	{{else if eq $clientReqType ""}}
		{{if (eq (len $resHeaderMap) 0) -}}
		clientRespBody, _, err := w.Clients.{{$clientName}}.{{$clientMethodName}}(
			ctx, clientHeaders,
		)
		{{else}}
		clientRespBody, cliRespHeaders, err := w.Clients.{{$clientName}}.{{$clientMethodName}}(
			ctx, clientHeaders,
		)
		{{- end }}
	{{else if eq $clientResType ""}}
		{{if (eq (len $resHeaderMap) 0) -}}
		_, err := w.Clients.{{$clientName}}.{{$clientMethodName}}(
			ctx, clientHeaders, clientRequest,
		)
		{{else}}
		cliRespHeaders, err := w.Clients.{{$clientName}}.{{$clientMethodName}}(
			ctx, clientHeaders, clientRequest,
		)
		{{- end }}
	{{else}}
		{{if (eq (len $resHeaderMap) 0) -}}
		clientRespBody, _, err := w.Clients.{{$clientName}}.{{$clientMethodName}}(
			ctx, clientHeaders, clientRequest,
		)
		{{else}}
		clientRespBody, cliRespHeaders, err := w.Clients.{{$clientName}}.{{$clientMethodName}}(
			ctx, clientHeaders, clientRequest,
		)
		{{- end }}
	{{end -}}

	{{- $responseType := .ResponseType }}
	if err != nil {
		switch errValue := err.(type) {
			{{range $idx, $cException := $clientExceptions}}
			case *{{$cException.Type}}:
				serverErr := convert{{$methodName}}{{title $cException.Name}}(
					errValue,
				)
				// TODO(sindelar): Consider returning partial headers
				{{if eq $responseType ""}}
				return nil, serverErr
				{{else}}
				return nil, nil, serverErr
				{{end}}
			{{end}}
			default:
				w.Logger.Warn("Could not make client request",
					zap.String("error", errValue.Error()),
				)
				// TODO(sindelar): Consider returning partial headers
				{{if eq $responseType ""}}
				return nil, err
				{{else}}
				return nil, nil, err
				{{end}}
		}
	}

	// Filter and map response headers from client to server response.

	// TODO: Add support for TChannel Headers with a switch here
	resHeaders := zanzibar.ServerHTTPHeader{}
	{{range $i, $k := $resHeaderMapKeys}}
	resHeaders.Set("{{index $resHeaderMap $k}}", cliRespHeaders["{{$k}}"])
	{{- end}}

	{{if eq .ResponseType "" -}}
	return resHeaders, nil
	{{- else -}}
	response := convert{{title .Name}}ClientResponse(clientRespBody)
	return response, resHeaders, nil
	{{- end -}}
}

{{if and (ne .RequestType "") (ne $clientReqType "") -}}
func convertTo{{title .Name}}ClientRequest(body *{{title .RequestType}}) *{{$clientReqType}} {
	clientRequest := &{{$clientReqType}}{}

	{{ range $key, $value := .RequestFieldMap -}}
	{{ range $name, $type := $.Method.RequestTypeMap -}} {{if eq $name $key -}}
	clientRequest.{{title $key }} = {{ $type }}(body.{{title $value }})
	{{ end -}}
	{{ end -}}
	{{ end }}
	return clientRequest
}
{{end -}}

{{- $exceptionIndex := .ExceptionsIndex }}
{{range $idx, $cException := $clientExceptions}}
{{- $sException := index $exceptionIndex $cException.Name -}}

func convert{{$methodName}}{{title $cException.Name}}(
	clientError *{{$cException.Type}},
) *{{$sException.Type}} {
	// TODO: Add error fields mapping here.
	serverError := &{{$sException.Type}}{}
	return serverError
}
{{end}}

{{if and (ne .ResponseType "") (ne $clientResType "") -}}
func convert{{title .Name}}ClientResponse(body *{{$clientResType}}) *{{.ResponseType}} {
	// TODO: Add response fields mapping here.
	downstreamResponse := (*{{.ResponseType}})(body)
	return downstreamResponse
}
{{end -}}

{{end -}}
{{end -}}
`)

func endpointTmplBytes() ([]byte, error) {
	return _endpointTmpl, nil
}

func endpointTmpl() (*asset, error) {
	bytes, err := endpointTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "endpoint.tmpl", size: 8149, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _endpoint_registerTmpl = []byte(`{{- /* template to render gateway endpoint registration */ -}}

package endpoints

import (
	"context"

	{{range $idx, $pkg := .IncludedPackages -}}
	{{$pkg.AliasName}} "{{$pkg.PackageName}}"
	{{end}}

	"github.com/uber/zanzibar/runtime"
)

// Endpoints is a struct that holds all the endpoints
type Endpoints struct {
	{{range $idx, $endpoint := .Endpoints -}}
	{{$endpoint.HandlerName}} *{{$endpoint.HandlerType}}
	{{end}}
}

// CreateEndpoints bootstraps the endpoints.
func CreateEndpoints(
	gateway *zanzibar.Gateway,
) interface{} {
	return &Endpoints{
		{{range $idx, $e := .Endpoints -}}
		{{$e.HandlerName}}:
			{{$e.PackageName}}.New{{$e.MethodName}}Endpoint(gateway),
		{{end}}
	}
}

// Register will register all endpoints
func Register(g *zanzibar.Gateway, router *zanzibar.Router) {
	endpoints := CreateEndpoints(g).(*Endpoints)

	{{range $idx, $endpoint := .Endpoints -}}
	router.Register(
		"{{$endpoint.Method}}", "{{$endpoint.HTTPPath}}",
		zanzibar.NewRouterEndpoint(
			g,
			"{{$endpoint.EndpointID}}",
			"{{$endpoint.HandlerID}}",
			{{ if len $endpoint.Middlewares | ne 0 -}}
			zanzibar.NewStack([]zanzibar.MiddlewareHandle{
				{{range $idx, $middleware := $endpoint.Middlewares -}}
				{{$middleware.Name}}.NewMiddleWare(
					g,
						{{$middleware.Name}}.Options{
						{{range $key, $value := $middleware.Options -}}
								{{$key}} : {{$value}},
						{{end -}}
						},
				),
				{{end -}}
			}, endpoints.{{$endpoint.HandlerName}}.HandleRequest).Handle,
			{{- else -}}
			endpoints.{{$endpoint.HandlerName}}.HandleRequest,
			{{- end}}
			
		),
	)
	{{end}}
}
`)

func endpoint_registerTmplBytes() ([]byte, error) {
	return _endpoint_registerTmpl, nil
}

func endpoint_registerTmpl() (*asset, error) {
	bytes, err := endpoint_registerTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "endpoint_register.tmpl", size: 1595, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _endpoint_testTmpl = []byte(`{{/* template to render gateway http endpoint tests */ -}}

package {{.PackageName}}

import (
	"bytes"
	"path/filepath"
	"net/http"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/uber/zanzibar/test/lib/bench_gateway"
	"github.com/uber/zanzibar/test/lib/test_backend"
	"github.com/uber/zanzibar/test/lib/test_gateway"
)

{{with .Method -}}
{{- $clientPackage := .Downstream.PackageName -}}
{{- $clientName := title .DownstreamService -}}
{{- $clientMethod := .DownstreamMethod -}}
{{- $clientMethodName := $clientMethod.Name | title -}}
{{- $clientMethodRequestType := fullTypeName  ($clientMethod).RequestType ($clientPackage) -}}
{{- $clientMethodResponseType := fullTypeName  ($clientMethod).ResponseType ($clientPackage) -}}
{{- $headers := .ReqHeaders }}


{{range $.TestStubs}}

func Test{{.HandlerID | Title}}{{.TestName | Title}}OKResponse(t *testing.T) {
	var counter int

	gateway, err := testGateway.CreateGateway(t, nil, &testGateway.Options{
		KnownHTTPBackends: []string{"{{$clientName | camel}}"},
		TestBinary: filepath.Join(
			getDirName(), "..", "..", "main.go",
		),
	})
	if !assert.NoError(t, err, "got bootstrap err") {
		return
	}
	defer gateway.Close()

	{{range .ClientStubs}}
	fake{{.ClientMethod | Title}} := func(w http.ResponseWriter, r *http.Request) {

		{{range $k, $v := .ClientReqHeaders -}}
		assert.Equal(
			t,
			"{{$v}}",
			r.Header.Get("{{$k}}"))
		{{end}}

		{{range $k, $v := .ClientResHeaders -}}
		w.Header().Set("{{$k}}", "{{$v}}")
		{{end}}
		w.WriteHeader({{$.Method.OKStatusCode.Code}})
		
		// TODO(zw): generate client response.
		if _, err := w.Write([]byte( ` + "`" + `{{.ClientResponseString}}` + "`" + `)); err != nil {
			t.Fatal("can't write fake response")
		}
		counter++
	}

	gateway.HTTPBackends()["{{$clientName | camel}}"].HandleFunc(
		"{{$clientMethod.HTTPMethod}}", "{{$clientMethod.HTTPPath}}", fake{{.ClientMethod | Title}},
	)

	{{end -}}

	headers := map[string]string{}
	{{ if $headers -}}
	{{range $k, $v := .EndpointReqHeaders -}}
	headers["{{$k}}"] = "{{$v}}"
	{{end}}
	{{- end}}

	res, err := gateway.MakeRequest(
		"{{$.Method.HTTPMethod}}",
		"{{$.Method.HTTPPath}}",
		headers,
		bytes.NewReader([]byte(` + "`" + `{{.EndpointRequestString}}` + "`" + `)),
	)
	if !assert.NoError(t, err, "got http error") {
		return
	}

	assert.Equal(t, {{$.Method.OKStatusCode.Code}}, res.StatusCode)
	{{range $k, $v := .EndpointResHeaders -}}
	assert.Equal(
		t,
		"{{$v}}",
		res.Header.Get("{{$k}}"))	
	{{end}}
	assert.Equal(t, 1, counter)
}

{{end -}}
{{end -}}
`)

func endpoint_testTmplBytes() ([]byte, error) {
	return _endpoint_testTmpl, nil
}

func endpoint_testTmpl() (*asset, error) {
	bytes, err := endpoint_testTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "endpoint_test.tmpl", size: 2503, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _http_clientTmpl = []byte(`{{- /* template to render edge gateway http client code */ -}}

package {{.PackageName}}

import (
	"bytes"
	"context"
	"net/http"
	"strconv"

	"github.com/pkg/errors"
	"github.com/uber/zanzibar/runtime"
	{{range $idx, $pkg := .IncludedPackages -}}
	{{$pkg.AliasName}} "{{$pkg.PackageName}}"
	{{end}}
)

{{- $clientID := .ClientID -}}
{{range .Services}}
{{- $clientName := title .Name | printf "%sClient" }}
// {{$clientName}} is the http client for service {{.Name}}.
type {{$clientName}} struct {
	ClientID string
	HTTPClient   *zanzibar.HTTPClient
}

// NewClient returns a new http client for service {{.Name}}.
func NewClient(
	gateway *zanzibar.Gateway,
) *{{$clientName}} {
	ip := gateway.Config.MustGetString("clients.{{.Name | camel}}.ip")
	port := gateway.Config.MustGetInt("clients.{{.Name | camel}}.port")

	baseURL := "http://" + ip + ":" + strconv.Itoa(int(port))
	return &{{$clientName}}{
		ClientID: "{{$clientID}}",
		HTTPClient: zanzibar.NewHTTPClient(gateway, baseURL),
	}
}

{{/*  ========================= Method =========================  */ -}}

{{range .Methods}}

// {{title .Name}} calls "{{.HTTPPath}}" endpoint.
{{- if and (eq .RequestType "") (eq .ResponseType "") }}
func (c *{{$clientName}}) {{title .Name}}(
	ctx context.Context,
	headers map[string]string,
) (map[string]string, error) {
{{else if eq .RequestType "" }}
func (c *{{$clientName}}) {{title .Name}}(
	ctx context.Context,
	headers map[string]string,
) (*{{.ResponseType}}, map[string]string, error) {
{{else if eq .ResponseType "" }}
func (c *{{$clientName}}) {{title .Name}}(
	ctx context.Context,
	headers map[string]string,
	r *{{.RequestType}},
) (map[string]string, error) {
{{else}}
func (c *{{$clientName}}) {{title .Name}}(
	ctx context.Context,
	headers map[string]string,
	r *{{.RequestType}},
) (*{{.ResponseType}}, map[string]string, error) {
{{end}}
	req := zanzibar.NewClientHTTPRequest(
		c.ClientID, "{{.Name}}", c.HTTPClient,
	)

	// Generate full URL.
	fullURL := c.HTTPClient.BaseURL
	{{- range $k, $segment := .PathSegments -}}
	{{- if eq $segment.Type "static" -}}+"/{{$segment.Text}}"
	{{- else -}}+"/"+string(r.{{$segment.BodyIdentifier | title}})
	{{- end -}}
	{{- end}}

	{{if ne .RequestType ""}}
	err := req.WriteJSON("{{.HTTPMethod}}", fullURL, headers, r)
	{{else}}
	err := req.WriteJSON("{{.HTTPMethod}}", fullURL, headers, nil)
	{{end}} {{- /* <if .RequestType ne ""> */ -}}
	if err != nil {
		return {{if eq .ResponseType ""}}nil, err{{else}}nil, nil, err{{end}}
	}
	res, err := req.Do(ctx)
	if err != nil {
		return {{if eq .ResponseType ""}}nil, err{{else}}nil, nil, err{{end}}
	}

	respHeaders := map[string]string{}
	for k := range res.Header {
		respHeaders[k] = res.Header.Get(k)
	}

	res.CheckOKResponse([]int{
		{{- range $index, $code := .ValidStatusCodes -}}
		{{if $index}},{{end}}{{$code}}
		{{- end -}}
	})

	{{if and (eq .ResponseType "") (eq (len .Exceptions) 0)}}
	switch res.StatusCode {
		case {{.OKStatusCode.Code}}:
			// TODO: log about unexpected body bytes?
			_, err = res.ReadAll()
			if err != nil {
				return respHeaders, err
			}
			return respHeaders, nil
	}
	{{else if eq (len .Exceptions) 0}}
	switch res.StatusCode {
		case {{.OKStatusCode.Code}}:
			var responseBody {{.ResponseType}}
			err = res.ReadAndUnmarshalBody(&responseBody)
			if err != nil {
				return nil, respHeaders, err
			}

			return &responseBody, respHeaders, nil
	}
	{{else if eq .ResponseType ""}}
	switch res.StatusCode {
		case {{.OKStatusCode.Code}}:
			// TODO: log about unexpected body bytes?
			_, err = res.ReadAll()
			if err != nil {
				return respHeaders, err
			}

			return respHeaders, nil
		{{range $idx, $exception := .Exceptions}}
		case {{$exception.StatusCode.Code}}:
			var exception {{$exception.Type}}
			err = res.ReadAndUnmarshalBody(&exception)
			if err != nil {
				return respHeaders, err
			}
			return respHeaders, &exception
		{{end}}
		default:
			// TODO: log about unexpected body bytes?
			_, err = res.ReadAll()
			if err != nil {
				return respHeaders, err
			}
	}
	{{else}}
	switch res.StatusCode {
		case {{.OKStatusCode.Code}}:
			var responseBody {{.ResponseType}}
			err = res.ReadAndUnmarshalBody(&responseBody)
			if err != nil {
				return nil, respHeaders, err
			}

			return &responseBody, respHeaders, nil
		{{range $idx, $exception := .Exceptions}}
		case {{$exception.StatusCode.Code}}:
			var exception {{$exception.Type}}
			err = res.ReadAndUnmarshalBody(&exception)
			if err != nil {
				return nil, respHeaders, err
			}
			return nil, respHeaders, &exception
		{{end}}
		default:
			// TODO: log about unexpected body bytes?
			_, err = res.ReadAll()
			if err != nil {
				return nil, respHeaders, err
			}
	}
	{{end}}

	return {{if ne .ResponseType ""}}nil, {{end}}respHeaders, errors.Errorf(
		"Unexpected http client response (%d)", res.StatusCode,
	)
}
{{end}} {{- /* <range .Methods> */ -}}
{{end}} {{- /* <range .Services> */ -}}
`)

func http_clientTmplBytes() ([]byte, error) {
	return _http_clientTmpl, nil
}

func http_clientTmpl() (*asset, error) {
	bytes, err := http_clientTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "http_client.tmpl", size: 4932, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _init_clientsTmpl = []byte(`{{- /* template to render gateway client initialization */ -}}

package clients

import (
	{{range $idx, $pkg := .IncludedPackages -}}
	{{$pkg.AliasName}} "{{$pkg.PackageName}}"
	{{end}}
	"github.com/uber/zanzibar/runtime"
)

// Clients datastructure that holds all the generated clients
// This should only hold clients generate from specs
type Clients struct {
	{{range $idx, $clientInfo := .ClientInfo -}}
	{{$clientInfo.FieldName}} *{{$clientInfo.PackageName}}.{{$clientInfo.TypeName}}
	{{end}}
}

// CreateClients will make all clients
func CreateClients(
	gateway *zanzibar.Gateway,
) interface{} {
	return &Clients{
		{{range $idx, $cinfo := .ClientInfo -}}
		{{$cinfo.FieldName}}: {{$cinfo.PackageName}}.NewClient(gateway),
		{{end}}
	}
}
`)

func init_clientsTmplBytes() ([]byte, error) {
	return _init_clientsTmpl, nil
}

func init_clientsTmpl() (*asset, error) {
	bytes, err := init_clientsTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "init_clients.tmpl", size: 747, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _mainTmpl = []byte(`{{- /* template to render gateway main.go */ -}}

package main

import (
	"os"
	"path/filepath"
	"runtime"

	"go.uber.org/zap"
	"github.com/uber/zanzibar/runtime"
	{{range $idx, $pkg := .IncludedPackages -}}
	{{$pkg.AliasName}} "{{$pkg.PackageName}}"
	{{end}}
)

func getDirName() string {
	_, file, _, _ := runtime.Caller(0)
	return zanzibar.GetDirnameFromRuntimeCaller(file)
}

func getConfigDirName() string {
	return filepath.Join(
		getDirName(),
		"{{.RelativePathToAppConfig}}",
		"config",
	)
}

func getConfig() *zanzibar.StaticConfig {
	return zanzibar.NewStaticConfigOrDie([]string{
		filepath.Join(getDirName(), "zanzibar-defaults.json"),
		filepath.Join(getConfigDirName(), "production.json"),
		filepath.Join(os.Getenv("CONFIG_DIR"), "production.json"),
	}, nil)
}

func createGateway() (*zanzibar.Gateway, error) {
	config := getConfig()
	
	gateway, err := zanzibar.CreateGateway(config, nil)
	if err != nil {
		return nil, err
	}

	clients := clients.CreateClients(gateway)
	gateway.Clients = clients

	return gateway, nil
}

func logAndWait(server *zanzibar.Gateway) {
	server.Logger.Info("Started {{.GatewayName | pascal}}",
		zap.String("realAddr", server.RealAddr),
		zap.Any("config", server.InspectOrDie()),
	)

	// TODO: handle sigterm gracefully
	server.Wait()
	// TODO: emit metrics about startup.
	// TODO: setup and configure tracing/jeager.
}

func main() {
	server, err := createGateway()
	if err != nil {
		panic(err)
	}

	err = server.Bootstrap(endpoints.Register)
	if err != nil {
		panic(err)
	}
	logAndWait(server)
}
`)

func mainTmplBytes() ([]byte, error) {
	return _mainTmpl, nil
}

func mainTmpl() (*asset, error) {
	bytes, err := mainTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "main.tmpl", size: 1551, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _main_testTmpl = []byte(`{{- /* template to render gateway main_test.go 
This template is the test entrypoint for spawning a gateway
as a child process using the test coverage features etc.
*/ -}}

package main

import (
	"os"
	"os/signal"
	"syscall"
	"testing"

	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
	"github.com/uber/zanzibar/runtime"
	{{range $idx, $pkg := .IncludedPackages -}}
	{{$pkg.AliasName}} "{{$pkg.PackageName}}"
	{{end}}
)

var cachedServer *zanzibar.Gateway

func TestMain(m *testing.M) {
	if os.Getenv("GATEWAY_RUN_CHILD_PROCESS_TEST") != "" {
		listenOnSignals()

		code := m.Run()
		os.Exit(code)
	} else {
		os.Exit(0)
	}
}

func listenOnSignals() {
	sigs := make(chan os.Signal, 1)

	signal.Notify(sigs, syscall.SIGUSR2)

	go func() {
		_ = <-sigs

		if cachedServer != nil {
			cachedServer.Close()
		}
	}()
}

func TestStartGateway(t *testing.T) {
	testLogger := zap.New(
		zapcore.NewCore(
			zapcore.NewJSONEncoder(zap.NewProductionEncoderConfig()),
			os.Stderr,
			zap.InfoLevel,
		),
	)

	server, err := createGateway()
	if err != nil {
		testLogger.Error(
			"Failed to CreateGateway in TestStartGateway()",
			zap.String("error", err.Error()),
		)
		return
	}

	cachedServer = server
	err = server.Bootstrap(endpoints.Register)
	if err != nil {
		testLogger.Error(
			"Failed to Bootstrap in TestStartGateway()",
			zap.String("error", err.Error()),
		)
		return
	}
	logAndWait(server)
}
`)

func main_testTmplBytes() ([]byte, error) {
	return _main_testTmpl, nil
}

func main_testTmpl() (*asset, error) {
	bytes, err := main_testTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "main_test.tmpl", size: 1399, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _structsTmpl = []byte(`{{- /* template to render edge gateway http client code */ -}}

package {{.PackageName}}

import (
	"runtime"
	"path/filepath"

	"github.com/uber/zanzibar/runtime"
	{{range $idx, $pkg := .IncludedPackages -}}
	{{$pkg.AliasName}} "{{$pkg.PackageName}}"
	{{end}}
)

func getDirName() string {
	_, file, _, _ := runtime.Caller(0)
	return zanzibar.GetDirnameFromRuntimeCaller(file)
}

{{range .Services}}

{{/*  ========================= Method =========================  */ -}}

{{range .Methods}}
{{if len .RequestStruct | ne 0}} {{- /* generate struct to wrap request args*/ -}}
// {{.RequestType}} is the http body type for endpoint {{.Name}}.
type {{.RequestType}} struct {
	{{range .RequestStruct -}}
	{{title .Name}} {{.Type}} ` + "`" + `json:"{{.Name}}"` + "`" + `
	{{end -}}
}{{end -}}

{{end}} {{- /* <range .Methods> */ -}}
{{end}} {{- /* <range .Services> */ -}}
`)

func structsTmplBytes() ([]byte, error) {
	return _structsTmpl, nil
}

func structsTmpl() (*asset, error) {
	bytes, err := structsTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "structs.tmpl", size: 851, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _tchannel_clientTmpl = []byte(`{{- /* template to render edge gateway tchannel client code */ -}}

// Package {{.PackageName}} is generated code used to make or handle TChannel calls using Thrift.
package {{.PackageName}}

import (
	"context"
	"errors"
	"strconv"
	"time"

	"github.com/uber/zanzibar/runtime"

	{{range $idx, $pkg := .IncludedPackages -}}
	{{$pkg.AliasName}} "{{$pkg.PackageName}}"
	{{end}}
)

{{$clientID := .ClientID -}}
{{$clientName := title .ClientID | printf "%sClient" -}}
{{range $svc := .Services}}
// NewClient returns a new TChannel client for service {{$clientID}}.
func NewClient(gateway *zanzibar.Gateway) *{{$clientName}} {
	{{- /* this is the service discovery service name */}}
	serviceName := gateway.Config.MustGetString("clients.{{$clientID}}.serviceName")
	sc := gateway.Channel.GetSubChannel(serviceName)

	{{/* TODO: (lu) support multiple host port */ -}}
	ip := gateway.Config.MustGetString("clients.{{$clientID}}.ip")
	port := gateway.Config.MustGetInt("clients.{{$clientID}}.port")
	sc.Peers().Add(ip + ":" + strconv.Itoa(int(port)))

	{{/* TODO: (lu) maybe set these at per method level */ -}}
	timeout := time.Millisecond * time.Duration(
		gateway.Config.MustGetInt("clients.{{$clientID}}.timeout"),
	)
	timeoutPerAttempt := time.Millisecond * time.Duration(
		gateway.Config.MustGetInt("clients.{{$clientID}}.timeoutPerAttempt"),
	)

	client := zanzibar.NewTChannelClient(gateway.Channel,
		&zanzibar.TChannelClientOption{
			ServiceName:       serviceName,
			Timeout:           timeout,
			TimeoutPerAttempt: timeoutPerAttempt,
		},
	)

	return &{{$clientName}}{
		{{- /* this is the thrift service name, different from service discovery service name */}}
		thriftService: "{{$svc.Name}}",
		client:        client,
	}
}

// {{$clientName}} is the TChannel client for downstream service.
type {{$clientName}} struct {
	thriftService string
	client        zanzibar.TChanClient
}

{{range .Methods}}
	// {{.Name}} ...
	func (c *{{$clientName}}) {{.Name}}(
		ctx context.Context,
		reqHeaders map[string]string,
		{{if ne .RequestType "" -}}
		args *{{.RequestType}},
		{{end -}}
	) ({{- if ne .ResponseType "" -}} *{{.ResponseType}}, {{- end -}}map[string]string, error) {
		var result {{.GenCodePkgName}}.{{$svc.Name}}_{{.Name}}_Result

		{{if eq .RequestType "" -}}
			args := &{{.GenCodePkgName}}.{{$svc.Name}}_{{.Name}}_Args{}
		{{end -}}
		success, respHeaders, err := c.client.Call(
			ctx, c.thriftService, "{{.Name}}", reqHeaders, args, &result,
		)

		if err == nil && !success {
			switch {
				{{range .Exceptions -}}
				case result.{{title .Name}} != nil:
					err = result.{{title .Name}}
				{{end -}}
				default:
					err = errors.New("{{$clientName}} received no result or unknown exception for {{title .Name}}")
			}
		}
		if err != nil {
		{{if eq .ResponseType "" -}}
			return nil, err
		{{else -}}
			return nil, nil, err
		{{end -}}
		}

		{{if eq .ResponseType "" -}}
			return respHeaders, err
		{{else -}}
			resp, err := {{.GenCodePkgName}}.{{$svc.Name}}_{{.Name}}_Helper.UnwrapResponse(&result)
			return resp, respHeaders, err
		{{end -}}
	}
{{end -}}
{{end}}
`)

func tchannel_clientTmplBytes() ([]byte, error) {
	return _tchannel_clientTmpl, nil
}

func tchannel_clientTmpl() (*asset, error) {
	bytes, err := tchannel_clientTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "tchannel_client.tmpl", size: 3104, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _tchannel_client_test_serverTmpl = []byte(`{{- /* template to render edge gateway tchannel server code */ -}}

// Package {{.PackageName}} is generated code used to make or handle TChannel calls using Thrift.
package {{.PackageName}}

import (
	"context"
	"errors"
	"time"

	"github.com/uber/zanzibar/runtime"
	"go.uber.org/thriftrw/wire"

	{{range $idx, $pkg := .IncludedPackages -}}
	{{$pkg.AliasName}} "{{$pkg.PackageName}}"
	{{end}}
)

{{range $svc := .Services}}
{{range .Methods}}
{{$privateName := lower .Name -}}
{{$genCodePkg := .GenCodePkgName -}}
{{$func := printf "%s%sFunc" $svc.Name .Name -}}
{{$handler := printf "%s%sHandler" $svc.Name .Name -}}
// {{$func}} is the handler function for "{{.Name}}" method of thrift service "{{$svc.Name}}".
type {{$func}} func (
	ctx context.Context,
	reqHeaders map[string]string,
	{{if ne .RequestType "" -}}
		args *{{.RequestType}},
	{{end -}}
) ({{- if ne .ResponseType "" -}}*{{.ResponseType}}, {{- end -}}map[string]string, error)

// New{{$handler}} wraps a handler function so it can be registered with a thrift server.
func New{{$handler}}(f {{$func}}) zanzibar.TChanHandler {
	return &{{$handler}}{f}
}

// {{$handler}} handles the "{{.Name}}" method call of thrift service "{{$svc.Name}}".
type {{$handler}} struct {
	{{$privateName}} {{$func}}
}

// Handle parses request from wire value and calls corresponding handler function.
func (h *{{$handler}}) Handle(
	ctx context.Context,
	reqHeaders map[string]string,
	wireValue *wire.Value,
) (bool, zanzibar.RWTStruct, map[string]string, error) {
	var req {{$genCodePkg}}.{{$svc.Name}}_{{.Name}}_Args
	var res {{$genCodePkg}}.{{$svc.Name}}_{{.Name}}_Result

	if err := req.FromWire(*wireValue); err != nil {
		return false, nil, nil, err
	}

	{{- if and (eq .RequestType "") (eq .ResponseType "")}}
		respHeaders, err := h.{{$privateName}}(ctx, reqHeaders)
	{{- else if eq .RequestType ""}}
		r, respHeaders, err := h.{{$privateName}}(ctx, reqHeaders)
	{{- else if eq .ResponseType ""}}
		respHeaders, err := h.{{$privateName}}(ctx, reqHeaders, &req)
	{{- else}}
		r, respHeaders, err := h.{{$privateName}}(ctx, reqHeaders, &req)
	{{- end}}

	{{if eq (len .Exceptions) 0 -}}
		if err != nil {
			return false, nil, nil, err
		}
		res.Success = r
	{{else -}}
		if err != nil {
			switch v := err.(type) {
			{{$method := .Name -}}
			{{range .Exceptions -}}
				case *{{$genCodePkg}}.{{title .Name}}:
					if v == nil {
						return false, nil, nil, errors.New(
							"Handler for {{$method}} returned non-nil error type *{{title .Name}} but nil value",
						)
					}
					res.{{title .Name}} = v
			{{end -}}
				default:
					return false, nil, nil, err
			}
		} {{if ne .ResponseType "" -}} else {
			res.Success = r
		} {{end -}}
	{{end}}

	return err == nil, &res, respHeaders, nil
}
{{end -}}

{{end}}
`)

func tchannel_client_test_serverTmplBytes() ([]byte, error) {
	return _tchannel_client_test_serverTmpl, nil
}

func tchannel_client_test_serverTmpl() (*asset, error) {
	bytes, err := tchannel_client_test_serverTmplBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "tchannel_client_test_server.tmpl", size: 2777, mode: os.FileMode(420), modTime: time.Unix(1, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

// Asset loads and returns the asset for the given name.
// It returns an error if the asset could not be found or
// could not be loaded.
func Asset(name string) ([]byte, error) {
	cannonicalName := strings.Replace(name, "\\", "/", -1)
	if f, ok := _bindata[cannonicalName]; ok {
		a, err := f()
		if err != nil {
			return nil, fmt.Errorf("Asset %s can't read by error: %v", name, err)
		}
		return a.bytes, nil
	}
	return nil, fmt.Errorf("Asset %s not found", name)
}

// MustAsset is like Asset but panics when Asset would return an error.
// It simplifies safe initialization of global variables.
func MustAsset(name string) []byte {
	a, err := Asset(name)
	if err != nil {
		panic("asset: Asset(" + name + "): " + err.Error())
	}

	return a
}

// AssetInfo loads and returns the asset info for the given name.
// It returns an error if the asset could not be found or
// could not be loaded.
func AssetInfo(name string) (os.FileInfo, error) {
	cannonicalName := strings.Replace(name, "\\", "/", -1)
	if f, ok := _bindata[cannonicalName]; ok {
		a, err := f()
		if err != nil {
			return nil, fmt.Errorf("AssetInfo %s can't read by error: %v", name, err)
		}
		return a.info, nil
	}
	return nil, fmt.Errorf("AssetInfo %s not found", name)
}

// AssetNames returns the names of the assets.
func AssetNames() []string {
	names := make([]string, 0, len(_bindata))
	for name := range _bindata {
		names = append(names, name)
	}
	return names
}

// _bindata is a table, holding each asset generator, mapped to its name.
var _bindata = map[string]func() (*asset, error){
	"endpoint.tmpl":                    endpointTmpl,
	"endpoint_register.tmpl":           endpoint_registerTmpl,
	"endpoint_test.tmpl":               endpoint_testTmpl,
	"http_client.tmpl":                 http_clientTmpl,
	"init_clients.tmpl":                init_clientsTmpl,
	"main.tmpl":                        mainTmpl,
	"main_test.tmpl":                   main_testTmpl,
	"structs.tmpl":                     structsTmpl,
	"tchannel_client.tmpl":             tchannel_clientTmpl,
	"tchannel_client_test_server.tmpl": tchannel_client_test_serverTmpl,
}

// AssetDir returns the file names below a certain
// directory embedded in the file by go-bindata.
// For example if you run go-bindata on data/... and data contains the
// following hierarchy:
//     data/
//       foo.txt
//       img/
//         a.png
//         b.png
// then AssetDir("data") would return []string{"foo.txt", "img"}
// AssetDir("data/img") would return []string{"a.png", "b.png"}
// AssetDir("foo.txt") and AssetDir("notexist") would return an error
// AssetDir("") will return []string{"data"}.
func AssetDir(name string) ([]string, error) {
	node := _bintree
	if len(name) != 0 {
		cannonicalName := strings.Replace(name, "\\", "/", -1)
		pathList := strings.Split(cannonicalName, "/")
		for _, p := range pathList {
			node = node.Children[p]
			if node == nil {
				return nil, fmt.Errorf("Asset %s not found", name)
			}
		}
	}
	if node.Func != nil {
		return nil, fmt.Errorf("Asset %s not found", name)
	}
	rv := make([]string, 0, len(node.Children))
	for childName := range node.Children {
		rv = append(rv, childName)
	}
	return rv, nil
}

type bintree struct {
	Func     func() (*asset, error)
	Children map[string]*bintree
}

var _bintree = &bintree{nil, map[string]*bintree{
	"endpoint.tmpl":                    {endpointTmpl, map[string]*bintree{}},
	"endpoint_register.tmpl":           {endpoint_registerTmpl, map[string]*bintree{}},
	"endpoint_test.tmpl":               {endpoint_testTmpl, map[string]*bintree{}},
	"http_client.tmpl":                 {http_clientTmpl, map[string]*bintree{}},
	"init_clients.tmpl":                {init_clientsTmpl, map[string]*bintree{}},
	"main.tmpl":                        {mainTmpl, map[string]*bintree{}},
	"main_test.tmpl":                   {main_testTmpl, map[string]*bintree{}},
	"structs.tmpl":                     {structsTmpl, map[string]*bintree{}},
	"tchannel_client.tmpl":             {tchannel_clientTmpl, map[string]*bintree{}},
	"tchannel_client_test_server.tmpl": {tchannel_client_test_serverTmpl, map[string]*bintree{}},
}}

// RestoreAsset restores an asset under the given directory
func RestoreAsset(dir, name string) error {
	data, err := Asset(name)
	if err != nil {
		return err
	}
	info, err := AssetInfo(name)
	if err != nil {
		return err
	}
	err = os.MkdirAll(_filePath(dir, filepath.Dir(name)), os.FileMode(0755))
	if err != nil {
		return err
	}
	err = ioutil.WriteFile(_filePath(dir, name), data, info.Mode())
	if err != nil {
		return err
	}
	err = os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime())
	if err != nil {
		return err
	}
	return nil
}

// RestoreAssets restores an asset under the given directory recursively
func RestoreAssets(dir, name string) error {
	children, err := AssetDir(name)
	// File
	if err != nil {
		return RestoreAsset(dir, name)
	}
	// Dir
	for _, child := range children {
		err = RestoreAssets(dir, filepath.Join(name, child))
		if err != nil {
			return err
		}
	}
	return nil
}

func _filePath(dir, name string) string {
	cannonicalName := strings.Replace(name, "\\", "/", -1)
	return filepath.Join(append([]string{dir}, strings.Split(cannonicalName, "/")...)...)
}