gotsrpc/example/errors/service/backend/gotsrpc_gen.go

// Code generated by gotsrpc https://github.com/foomo/gotsrpc/v2  - DO NOT EDIT.

package backend

import (
	io "io"
	http "net/http"
	time "time"

	gotsrpc "github.com/foomo/gotsrpc/v2"
)

const (
	ServiceGoTSRPCProxyCustomError       = "CustomError"
	ServiceGoTSRPCProxyError             = "Error"
	ServiceGoTSRPCProxyMultiScalar       = "MultiScalar"
	ServiceGoTSRPCProxyScalar            = "Scalar"
	ServiceGoTSRPCProxyScalarError       = "ScalarError"
	ServiceGoTSRPCProxyStruct            = "Struct"
	ServiceGoTSRPCProxyStructError       = "StructError"
	ServiceGoTSRPCProxyTypedCustomError  = "TypedCustomError"
	ServiceGoTSRPCProxyTypedError        = "TypedError"
	ServiceGoTSRPCProxyTypedScalarError  = "TypedScalarError"
	ServiceGoTSRPCProxyTypedWrappedError = "TypedWrappedError"
	ServiceGoTSRPCProxyWrappedError      = "WrappedError"
)

type ServiceGoTSRPCProxy struct {
	EndPoint string
	service  Service
}

func NewDefaultServiceGoTSRPCProxy(service Service) *ServiceGoTSRPCProxy {
	return NewServiceGoTSRPCProxy(service, "/service/backend")
}

func NewServiceGoTSRPCProxy(service Service, endpoint string) *ServiceGoTSRPCProxy {
	return &ServiceGoTSRPCProxy{
		EndPoint: endpoint,
		service:  service,
	}
}

// ServeHTTP exposes your service
func (p *ServiceGoTSRPCProxy) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	if r.Method == http.MethodOptions {
		return
	} else if r.Method != http.MethodPost {
		gotsrpc.ErrorMethodNotAllowed(w)
		return
	}
	defer io.Copy(io.Discard, r.Body) // Drain Request Body

	funcName := gotsrpc.GetCalledFunc(r, p.EndPoint)
	callStats, _ := gotsrpc.GetStatsForRequest(r)
	callStats.Func = funcName
	callStats.Package = "github.com/foomo/gotsrpc/v2/example/errors/service/backend"
	callStats.Service = "Service"
	switch funcName {
	case ServiceGoTSRPCProxyCustomError:
		var (
			args []interface{}
			rets []interface{}
		)
		executionStart := time.Now()
		rw := gotsrpc.ResponseWriter{ResponseWriter: w}
		customErrorE := p.service.CustomError(&rw, r)
		callStats.Execution = time.Since(executionStart)
		if rw.Status() == http.StatusOK {
			rets = []interface{}{customErrorE}
			if err := gotsrpc.Reply(rets, callStats, r, w); err != nil {
				gotsrpc.ErrorCouldNotReply(w)
				return
			}
		}
		gotsrpc.Monitor(w, r, args, rets, callStats)
		return
	case ServiceGoTSRPCProxyError:
		var (
			args []interface{}
			rets []interface{}
		)
		executionStart := time.Now()
		rw := gotsrpc.ResponseWriter{ResponseWriter: w}
		errorE := p.service.Error(&rw, r)
		callStats.Execution = time.Since(executionStart)
		if rw.Status() == http.StatusOK {
			rets = []interface{}{errorE}
			if err := gotsrpc.Reply(rets, callStats, r, w); err != nil {
				gotsrpc.ErrorCouldNotReply(w)
				return
			}
		}
		gotsrpc.Monitor(w, r, args, rets, callStats)
		return
	case ServiceGoTSRPCProxyMultiScalar:
		var (
			args []interface{}
			rets []interface{}
		)
		executionStart := time.Now()
		rw := gotsrpc.ResponseWriter{ResponseWriter: w}
		multiScalarE := p.service.MultiScalar(&rw, r)
		callStats.Execution = time.Since(executionStart)
		if rw.Status() == http.StatusOK {
			rets = []interface{}{multiScalarE}
			if err := gotsrpc.Reply(rets, callStats, r, w); err != nil {
				gotsrpc.ErrorCouldNotReply(w)
				return
			}
		}
		gotsrpc.Monitor(w, r, args, rets, callStats)
		return
	case ServiceGoTSRPCProxyScalar:
		var (
			args []interface{}
			rets []interface{}
		)
		executionStart := time.Now()
		rw := gotsrpc.ResponseWriter{ResponseWriter: w}
		scalarE := p.service.Scalar(&rw, r)
		callStats.Execution = time.Since(executionStart)
		if rw.Status() == http.StatusOK {
			rets = []interface{}{scalarE}
			if err := gotsrpc.Reply(rets, callStats, r, w); err != nil {
				gotsrpc.ErrorCouldNotReply(w)
				return
			}
		}
		gotsrpc.Monitor(w, r, args, rets, callStats)
		return
	case ServiceGoTSRPCProxyScalarError:
		var (
			args []interface{}
			rets []interface{}
		)
		executionStart := time.Now()
		rw := gotsrpc.ResponseWriter{ResponseWriter: w}
		scalarErrorE := p.service.ScalarError(&rw, r)
		callStats.Execution = time.Since(executionStart)
		if rw.Status() == http.StatusOK {
			rets = []interface{}{scalarErrorE}
			if err := gotsrpc.Reply(rets, callStats, r, w); err != nil {
				gotsrpc.ErrorCouldNotReply(w)
				return
			}
		}
		gotsrpc.Monitor(w, r, args, rets, callStats)
		return
	case ServiceGoTSRPCProxyStruct:
		var (
			args []interface{}
			rets []interface{}
		)
		executionStart := time.Now()
		rw := gotsrpc.ResponseWriter{ResponseWriter: w}
		structE := p.service.Struct(&rw, r)
		callStats.Execution = time.Since(executionStart)
		if rw.Status() == http.StatusOK {
			rets = []interface{}{structE}
			if err := gotsrpc.Reply(rets, callStats, r, w); err != nil {
				gotsrpc.ErrorCouldNotReply(w)
				return
			}
		}
		gotsrpc.Monitor(w, r, args, rets, callStats)
		return
	case ServiceGoTSRPCProxyStructError:
		var (
			args []interface{}
			rets []interface{}
		)
		executionStart := time.Now()
		rw := gotsrpc.ResponseWriter{ResponseWriter: w}
		structErrorE := p.service.StructError(&rw, r)
		callStats.Execution = time.Since(executionStart)
		if rw.Status() == http.StatusOK {
			rets = []interface{}{structErrorE}
			if err := gotsrpc.Reply(rets, callStats, r, w); err != nil {
				gotsrpc.ErrorCouldNotReply(w)
				return
			}
		}
		gotsrpc.Monitor(w, r, args, rets, callStats)
		return
	case ServiceGoTSRPCProxyTypedCustomError:
		var (
			args []interface{}
			rets []interface{}
		)
		executionStart := time.Now()
		rw := gotsrpc.ResponseWriter{ResponseWriter: w}
		typedCustomErrorE := p.service.TypedCustomError(&rw, r)
		callStats.Execution = time.Since(executionStart)
		if rw.Status() == http.StatusOK {
			rets = []interface{}{typedCustomErrorE}
			if err := gotsrpc.Reply(rets, callStats, r, w); err != nil {
				gotsrpc.ErrorCouldNotReply(w)
				return
			}
		}
		gotsrpc.Monitor(w, r, args, rets, callStats)
		return
	case ServiceGoTSRPCProxyTypedError:
		var (
			args []interface{}
			rets []interface{}
		)
		executionStart := time.Now()
		rw := gotsrpc.ResponseWriter{ResponseWriter: w}
		typedErrorE := p.service.TypedError(&rw, r)
		callStats.Execution = time.Since(executionStart)
		if rw.Status() == http.StatusOK {
			rets = []interface{}{typedErrorE}
			if err := gotsrpc.Reply(rets, callStats, r, w); err != nil {
				gotsrpc.ErrorCouldNotReply(w)
				return
			}
		}
		gotsrpc.Monitor(w, r, args, rets, callStats)
		return
	case ServiceGoTSRPCProxyTypedScalarError:
		var (
			args []interface{}
			rets []interface{}
		)
		executionStart := time.Now()
		rw := gotsrpc.ResponseWriter{ResponseWriter: w}
		typedScalarErrorE := p.service.TypedScalarError(&rw, r)
		callStats.Execution = time.Since(executionStart)
		if rw.Status() == http.StatusOK {
			rets = []interface{}{typedScalarErrorE}
			if err := gotsrpc.Reply(rets, callStats, r, w); err != nil {
				gotsrpc.ErrorCouldNotReply(w)
				return
			}
		}
		gotsrpc.Monitor(w, r, args, rets, callStats)
		return
	case ServiceGoTSRPCProxyTypedWrappedError:
		var (
			args []interface{}
			rets []interface{}
		)
		executionStart := time.Now()
		rw := gotsrpc.ResponseWriter{ResponseWriter: w}
		typedWrappedErrorE := p.service.TypedWrappedError(&rw, r)
		callStats.Execution = time.Since(executionStart)
		if rw.Status() == http.StatusOK {
			rets = []interface{}{typedWrappedErrorE}
			if err := gotsrpc.Reply(rets, callStats, r, w); err != nil {
				gotsrpc.ErrorCouldNotReply(w)
				return
			}
		}
		gotsrpc.Monitor(w, r, args, rets, callStats)
		return
	case ServiceGoTSRPCProxyWrappedError:
		var (
			args []interface{}
			rets []interface{}
		)
		executionStart := time.Now()
		rw := gotsrpc.ResponseWriter{ResponseWriter: w}
		wrappedErrorE := p.service.WrappedError(&rw, r)
		callStats.Execution = time.Since(executionStart)
		if rw.Status() == http.StatusOK {
			rets = []interface{}{wrappedErrorE}
			if err := gotsrpc.Reply(rets, callStats, r, w); err != nil {
				gotsrpc.ErrorCouldNotReply(w)
				return
			}
		}
		gotsrpc.Monitor(w, r, args, rets, callStats)
		return
	default:
		gotsrpc.ClearStats(r)
		gotsrpc.ErrorFuncNotFound(w)
	}
}