func()

in codegen/module_system.go [1044:1134]
76 lines of code
7 McCabe index (conditional complexity)

func (g *gRPCClientGenerator) Generate(
	instance *ModuleInstance,
) (*BuildResult, error) {
	clientSpecUntyped, err := g.ComputeSpec(instance)
	if err != nil {
		return nil, errors.Wrapf(
			err,
			"error initializing GRPCClientSpec for %q",
			instance.InstanceName,
		)
	}
	clientSpec := clientSpecUntyped.(*ClientSpec)

	reversedMethods := reverseExposedMethods(clientSpec)

	serviceNames := map[string]struct{}{}
	for key := range reversedMethods {
		serviceName := strings.Split(key, "::")[0]
		serviceNames[serviceName] = struct{}{}
	}

	services := ServiceSpecs{}
	for name := range serviceNames {
		services = append(services, &ServiceSpec{Name: name})
	}

	sort.Sort(&services)

	var clientQPSLevels map[string]string = GetClientQPSLevels(instance.QPSLevels, reversedMethods, clientSpec.ClientID)

	// @rpatali: Update all struct to use more general field IDLFile instead of thriftFile.
	clientMeta := &ClientMeta{
		ProtoServices:    clientSpec.ModuleSpec.ProtoServices,
		Instance:         instance,
		ExportName:       clientSpec.ExportName,
		ExportType:       clientSpec.ExportType,
		Services:         services,
		IncludedPackages: clientSpec.ModuleSpec.IncludedPackages,
		ClientID:         clientSpec.ClientID,
		ExposedMethods:   reversedMethods,
		QPSLevels:        clientQPSLevels,
	}

	client, err := ExecuteDefaultOrCustomTemplate(
		"grpc_client.tmpl",
		g.templates,
		instance.CustomTemplates,
		instance.Config,
		clientMeta,
		g.packageHelper,
	)
	if err != nil {
		return nil, errors.Wrapf(
			err,
			"Error executing gRPC client template for %q",
			instance.InstanceName,
		)
	}

	// When it is possible to generate structs for all module types, the
	// module system will do this transparently. For now we are opting in
	// on a per-generator basis.
	dependencies, err := GenerateDependencyStruct(
		instance,
		g.packageHelper,
		g.templates,
	)
	if err != nil {
		return nil, errors.Wrapf(
			err,
			"Error generating dependencies struct for %q %q",
			instance.ClassName,
			instance.InstanceName,
		)
	}

	baseName := filepath.Base(instance.Directory)
	clientFilePath := baseName + ".go"

	files := map[string][]byte{
		clientFilePath: client,
	}

	if dependencies != nil {
		files["module/dependencies.go"] = dependencies
	}
	return &BuildResult{
		Files: files,
		Spec:  clientSpec,
	}, nil
}