func {{$exportName}}()

in codegen/template_bundle/template_files.go [3618:3786]
157 lines of code
16 McCabe index (conditional complexity)

func {{$exportName}}(deps *module.Dependencies) Client {
	{{- /* this is the service discovery service name */}}
	serviceName := deps.Default.Config.MustGetString("clients.{{$clientID}}.serviceName")
	var routingKey string
	if deps.Default.Config.ContainsKey("clients.{{$clientID}}.routingKey") {
		routingKey = deps.Default.Config.MustGetString("clients.{{$clientID}}.routingKey")
	}
	var requestUUIDHeaderKey string
	if deps.Default.Config.ContainsKey("tchannel.clients.requestUUIDHeaderKey") {
		requestUUIDHeaderKey = deps.Default.Config.MustGetString("tchannel.clients.requestUUIDHeaderKey")
	}

	{{if $sidecarRouter -}}
		ip := deps.Default.Config.MustGetString("sidecarRouter.{{$sidecarRouter}}.tchannel.ip")
		port := deps.Default.Config.MustGetInt("sidecarRouter.{{$sidecarRouter}}.tchannel.port")
	{{else -}}
		ip := deps.Default.Config.MustGetString("clients.{{$clientID}}.ip")
		port := deps.Default.Config.MustGetInt("clients.{{$clientID}}.port")
	{{end -}}

	gateway := deps.Default.Gateway
	var channel *tchannel.Channel

	// If dedicated.tchannel.client : true, each tchannel client will create a
	// dedicated connection with local sidecar, else it will use a shared connection
	if deps.Default.Config.ContainsKey("dedicated.tchannel.client") &&
		deps.Default.Config.MustGetBoolean("dedicated.tchannel.client") {
		channel = gateway.SetupClientTChannel(deps.Default.Config, serviceName)
		channel.Peers().Add(ip + ":" + strconv.Itoa(int(port)))
	} else {
		channel = gateway.ServerTChannel
		channel.GetSubChannel(serviceName, tchannel.Isolated).Peers().Add(ip + ":" + strconv.Itoa(int(port)))
	}

	/*Ex:
	{
		"clients.rider-presentation.alternates": {
			"routingConfigs": [
				{
					"headerName": "x-test-env",
					"headerValue": "*",
					"serviceName": "testservice"
				},
				{
					"headerName": "x-container",
					"headerValue": "container*",
					"serviceName": "relayer"
				}
			],
			"servicesDetail": {
				"testservice": {
					"ip": "127.0.0.1",
					"port": 5000
				},
				"relayer": {
					"ip": "127.0.0.1",
					"port": 12000
				}
			}
		}
	}*/
	var re ruleengine.RuleEngine
	var headerPatterns []string
	altChannelMap  := make(map[string]*tchannel.SubChannel)
	headerPatterns, re = initializeDynamicChannel(channel, deps, headerPatterns, altChannelMap, re)
	timeoutVal := int(deps.Default.Config.MustGetInt("clients.{{$clientID}}.timeout"))
	timeout := time.Millisecond * time.Duration(
		timeoutVal,
	)
	timeoutPerAttempt := time.Millisecond * time.Duration(
		deps.Default.Config.MustGetInt("clients.{{$clientID}}.timeoutPerAttempt"),
	)

	methodNames := map[string]string{
		{{range $svc := .Services -}}
		{{range .Methods -}}
		{{$serviceMethod := printf "%s::%s" $svc.Name .Name -}}
		{{$methodName := (title (index $exposedMethods $serviceMethod)) -}}
			{{if $methodName -}}
			"{{$serviceMethod}}": "{{$methodName}}",
			{{end -}}
		{{ end -}}
		{{ end -}}
	}

	//get mapping of client method and it's timeout
	//if mapping is not provided, use client's timeout for all the methods
	clientMethodTimeoutMapping := make(map[string]int64)
	if deps.Default.Config.ContainsKey("clients.{{$clientID}}.methodTimeoutMapping") {
		deps.Default.Config.MustGetStruct("clients.{{$clientID}}.methodTimeoutMapping", &clientMethodTimeoutMapping)
	} else {
		for _, methodName := range methodNames {
			clientMethodTimeoutMapping[methodName] = int64(timeoutVal)
		}
	}

	qpsLevels := map[string]string{
				{{range $methodName, $qpsLevel := $QPSLevels -}}
				"{{$methodName}}": "{{$qpsLevel}}",
				{{end}}
	}

	// circuitBreakerDisabled sets whether circuit-breaker should be disabled
	circuitBreakerDisabled := false
	if deps.Default.Config.ContainsKey("clients.{{$clientID}}.circuitBreakerDisabled") {
		circuitBreakerDisabled = deps.Default.Config.MustGetBoolean("clients.{{$clientID}}.circuitBreakerDisabled")
	}

	if !circuitBreakerDisabled {
		for methodName, methodTimeoutVal := range clientMethodTimeoutMapping{
			circuitBreakerName := "{{$clientID}}" + "-" + methodName
			qpsLevel := "default"
			if level, ok := qpsLevels[circuitBreakerName]; ok {
				qpsLevel = level
			}
			configureCircuitBreaker(deps, int(methodTimeoutVal), circuitBreakerName, qpsLevel)
		}
	}

	var client *zanzibar.TChannelClient

	if  deps.Default.Config.ContainsKey("tchannelclients.retryCount.feature.enabled") && deps.Default.Config.MustGetBoolean("tchannelclients.retryCount.feature.enabled") && deps.Default.Config.ContainsKey("clients.{{$clientID}}.retryCount") && int(deps.Default.Config.MustGetInt("clients.{{$clientID}}.retryCount")) > 0{
		maxAttempts := int(deps.Default.Config.MustGetInt("clients.{{$clientID}}.retryCount"))
		client = zanzibar.NewTChannelClientContext(
				channel,
				deps.Default.ContextLogger,
				deps.Default.ContextMetrics,
				deps.Default.ContextExtractor,
				&zanzibar.TChannelClientOption{
					ServiceName:          serviceName,
					ClientID:             "{{$clientID}}",
					MethodNames:          methodNames,
					Timeout:              timeout,
					TimeoutPerAttempt:    timeoutPerAttempt,
					RoutingKey:           &routingKey,
					RuleEngine:           re,
					HeaderPatterns:       headerPatterns,
					RequestUUIDHeaderKey: requestUUIDHeaderKey,
					AltChannelMap:        altChannelMap,
					MaxAttempts:          maxAttempts,
				},
			)
	}else{
		client = zanzibar.NewTChannelClientContext(
				channel,
				deps.Default.ContextLogger,
				deps.Default.ContextMetrics,
				deps.Default.ContextExtractor,
				&zanzibar.TChannelClientOption{
					ServiceName:          serviceName,
					ClientID:             "{{$clientID}}",
					MethodNames:          methodNames,
					Timeout:              timeout,
					TimeoutPerAttempt:    timeoutPerAttempt,
					RoutingKey:           &routingKey,
					RuleEngine:           re,
					HeaderPatterns:       headerPatterns,
					RequestUUIDHeaderKey: requestUUIDHeaderKey,
					AltChannelMap:        altChannelMap,
				},
			)
	}

	return &{{$clientName}}{
		client: client,
		circuitBreakerDisabled: circuitBreakerDisabled,
		defaultDeps:            deps.Default,
	}
}