func()

in codegen/module_system.go [1218:1342]
116 lines of code
13 McCabe index (conditional complexity)

func (g *EndpointGenerator) Generate(
	instance *ModuleInstance,
) (*BuildResult, error) {
	endpointMeta := make([]*EndpointMeta, 0)
	endpointSpecsUntyped, err := g.ComputeSpec(instance)
	if err != nil {
		return nil, errors.Wrapf(
			err,
			"Error generating endpoint specs for %q",
			instance.InstanceName,
		)
	}
	endpointSpecs := endpointSpecsUntyped.([]*EndpointSpec)

	for _, espec := range endpointSpecs {
		// allow configured header to pass down to switch downstream service dynmamic
		reqHeaders := espec.ReqHeaders
		if reqHeaders == nil {
			reqHeaders = make(map[string]*TypedHeader)
		}
		shk := textproto.CanonicalMIMEHeaderKey(g.packageHelper.DeputyReqHeader())
		reqHeaders[shk] = &TypedHeader{
			Name:        shk,
			TransformTo: shk,
			Field:       &compile.FieldSpec{Required: false},
		}
		espec.ReqHeaders = reqHeaders
	}
	var fileMap sync.Map
	runner := parallelize.NewUnboundedRunner(len(endpointSpecs) + 1)
	for _, espec := range endpointSpecs {
		f := func(especInf interface{}) (interface{}, error) {
			espec := especInf.(*EndpointSpec)
			meta, err := g.generateEndpointFile(espec, instance, &fileMap)
			if err != nil {
				err = errors.Wrapf(
					err,
					"Error executing endpoint template %q",
					instance.InstanceName,
				)
				return nil, err
			}
			err = g.generateEndpointTestFile(espec, instance, &fileMap)
			if err != nil {
				err = errors.Wrapf(
					err,
					"Error executing endpoint test template %q",
					instance.InstanceName,
				)
				return nil, err
			}
			return meta, err
		}
		wrk := &parallelize.SingleParamWork{Data: espec, Func: f}
		runner.SubmitWork(wrk)
	}

	f := func() (interface{}, error) {
		dependencies, err := GenerateDependencyStruct(
			instance,
			g.packageHelper,
			g.templates,
		)
		if err != nil {
			err = errors.Wrapf(
				err,
				"Error generating service dependencies for %s",
				instance.InstanceName,
			)
			return nil, err
		}
		if dependencies != nil {
			fileMap.Store("module/dependencies.go", dependencies)
		}
		return nil, nil
	}
	runner.SubmitWork(parallelize.StatelessFunc(f))

	results, err := runner.GetResult()
	if err != nil {
		return nil, err
	}
	for _, meta := range results {
		if meta == nil {
			continue
		}
		endpointMeta = append(endpointMeta, meta.(*EndpointMeta))
	}

	// sort for deterministic code gen order in endpoint.go file
	sort.SliceStable(endpointMeta, func(i, j int) bool {
		return endpointMeta[i].Spec.HandleID < endpointMeta[j].Spec.HandleID
	})

	endpointCollection, err := ExecuteDefaultOrCustomTemplate(
		"endpoint_collection.tmpl",
		g.templates,
		instance.CustomTemplates,
		instance.Config,
		&EndpointCollectionMeta{
			Instance:     instance,
			EndpointMeta: endpointMeta,
		},
		g.packageHelper,
	)
	if err != nil {
		return nil, errors.Wrapf(
			err,
			"Error generating service dependencies for %s",
			instance.InstanceName,
		)
	}
	fileMap.Store("endpoint.go", endpointCollection)

	files := make(map[string][]byte)
	fileMap.Range(func(key, value interface{}) bool {
		files[key.(string)] = value.([]byte)
		return true
	})

	return &BuildResult{
		Files: files,
		Spec:  endpointSpecs,
	}, nil
}