func()

in pkg/xds/bootstrap/generator.go [156:248]
84 lines of code
11 McCabe index (conditional complexity)

func (b *bootstrapGenerator) Generate(ctx context.Context, request types.BootstrapRequest) (proto.Message, DubboDpBootstrap, error) {
	if request.ProxyType == "" {
		request.ProxyType = string(mesh_proto.DataplaneProxyType)
	}
	dubboDpBootstrap := DubboDpBootstrap{}
	//if err := b.validateRequest(request); err != nil {
	//	return nil, dubboDpBootstrap, err
	//}
	accessLogSocketPath := request.AccessLogSocketPath
	if accessLogSocketPath == "" {
		accessLogSocketPath = core_xds.AccessLogSocketName(os.TempDir(), request.Name, request.Mesh)
	}
	metricsSocketPath := request.MetricsResources.SocketPath

	if metricsSocketPath == "" {
		metricsSocketPath = core_xds.MetricsHijackerSocketName(os.TempDir(), request.Name, request.Mesh)
	}

	proxyId := core_xds.BuildProxyId(request.Mesh, request.Name)
	params := configParameters{
		Id:                 proxyId.String(),
		AdminAddress:       b.config.Params.AdminAddress,
		AdminAccessLogPath: b.adminAccessLogPath(request.OperatingSystem),
		XdsHost:            b.xdsHost(request),
		XdsPort:            b.config.Params.XdsPort,
		XdsConnectTimeout:  b.config.Params.XdsConnectTimeout.Duration,
		DataplaneToken:     request.DataplaneToken,
		DataplaneTokenPath: request.DataplaneTokenPath,
		DataplaneResource:  request.DataplaneResource,
		Version: &mesh_proto.Version{
			DubboDp: &mesh_proto.DubboDpVersion{
				Version:   request.Version.DubboDp.Version,
				GitTag:    request.Version.DubboDp.GitTag,
				GitCommit: request.Version.DubboDp.GitCommit,
				BuildDate: request.Version.DubboDp.BuildDate,
			},
			Envoy: &mesh_proto.EnvoyVersion{
				Version:           request.Version.Envoy.Version,
				Build:             request.Version.Envoy.Build,
				DubboDpCompatible: request.Version.Envoy.DubboDpCompatible,
			},
		},
		DynamicMetadata:     request.DynamicMetadata,
		DNSPort:             request.DNSPort,
		EmptyDNSPort:        request.EmptyDNSPort,
		ProxyType:           request.ProxyType,
		Features:            request.Features,
		Resources:           request.Resources,
		Workdir:             request.Workdir,
		AccessLogSocketPath: accessLogSocketPath,
		MetricsSocketPath:   metricsSocketPath,
		MetricsCertPath:     request.MetricsResources.CertPath,
		MetricsKeyPath:      request.MetricsResources.KeyPath,
	}

	setAdminPort := func(adminPortFromResource uint32) {
		if adminPortFromResource != 0 {
			params.AdminPort = adminPortFromResource
		} else {
			params.AdminPort = b.defaultAdminPort
		}
	}

	switch mesh_proto.ProxyType(params.ProxyType) {
	case mesh_proto.IngressProxyType:
		zoneIngress, err := b.zoneIngressFor(ctx, request, proxyId)
		if err != nil {
			return nil, dubboDpBootstrap, err
		}
		params.Service = "ingress"
		setAdminPort(zoneIngress.Spec.GetNetworking().GetAdmin().GetPort())
	case mesh_proto.EgressProxyType:
		zoneEgress, err := b.zoneEgressFor(ctx, request, proxyId)
		if err != nil {
			return nil, dubboDpBootstrap, err
		}
		params.Service = "egress"
		setAdminPort(zoneEgress.Spec.GetNetworking().GetAdmin().GetPort())

	default:
		return nil, dubboDpBootstrap, errors.Errorf("unknown proxy type %v", params.ProxyType)
	}
	var err error

	config, err := genConfig(params, b.proxyConfig, b.enableReloadableTokens)
	if err != nil {
		return nil, dubboDpBootstrap, errors.Wrap(err, "failed creating bootstrap conf")
	}
	if err = config.Validate(); err != nil {
		return nil, dubboDpBootstrap, errors.Wrap(err, "Envoy bootstrap config is not valid")
	}
	return config, dubboDpBootstrap, nil
}