pkg/core/runtime/builder.go

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package runtime

import (
	"context"
	"fmt"
	"os"
	"sync"
	"time"
)

import (
	"dubbo.apache.org/dubbo-go/v3/config_center"
	"dubbo.apache.org/dubbo-go/v3/metadata/report"
	dubboRegistry "dubbo.apache.org/dubbo-go/v3/registry"

	"github.com/pkg/errors"
)

import (
	dubbo_cp "github.com/apache/dubbo-kubernetes/pkg/config/app/dubbo-cp"
	"github.com/apache/dubbo-kubernetes/pkg/core"
	config_manager "github.com/apache/dubbo-kubernetes/pkg/core/config/manager"
	"github.com/apache/dubbo-kubernetes/pkg/core/datasource"
	"github.com/apache/dubbo-kubernetes/pkg/core/dns/lookup"
	"github.com/apache/dubbo-kubernetes/pkg/core/governance"
	"github.com/apache/dubbo-kubernetes/pkg/core/reg_client"
	"github.com/apache/dubbo-kubernetes/pkg/core/registry"
	core_manager "github.com/apache/dubbo-kubernetes/pkg/core/resources/manager"
	core_store "github.com/apache/dubbo-kubernetes/pkg/core/resources/store"
	"github.com/apache/dubbo-kubernetes/pkg/core/runtime/component"
	dds_context "github.com/apache/dubbo-kubernetes/pkg/dds/context"
	dp_server "github.com/apache/dubbo-kubernetes/pkg/dp-server/server"
	"github.com/apache/dubbo-kubernetes/pkg/events"
	"github.com/apache/dubbo-kubernetes/pkg/xds/cache/mesh"
)

// BuilderContext provides access to Builder's interim state.
type BuilderContext interface {
	ComponentManager() component.Manager
	ResourceStore() core_store.CustomizableResourceStore
	Transactions() core_store.Transactions
	ConfigStore() core_store.ResourceStore
	ResourceManager() core_manager.CustomizableResourceManager
	Config() dubbo_cp.Config
	RegistryCenter() dubboRegistry.Registry
	RegClient() reg_client.RegClient
	MetadataReportCenter() report.MetadataReport
	AdminRegistry() *registry.Registry
	ServiceDiscovery() dubboRegistry.ServiceDiscovery
	ConfigCenter() config_center.DynamicConfiguration
	Governance() governance.GovernanceConfig
	Extensions() context.Context
	ConfigManager() config_manager.ConfigManager
	LeaderInfo() component.LeaderInfo
	EventBus() events.EventBus
	DpServer() *dp_server.DpServer
	DataplaneCache() *sync.Map
	DDSContext() *dds_context.Context
	ResourceValidators() ResourceValidators
	AppRegCtx() *registry.ApplicationContext
	InfRegCtx() *registry.InterfaceContext
}

var _ BuilderContext = &Builder{}

// Builder represents a multi-step initialization process.
type Builder struct {
	cfg                  dubbo_cp.Config
	cm                   component.Manager
	rs                   core_store.CustomizableResourceStore
	cs                   core_store.ResourceStore
	txs                  core_store.Transactions
	rm                   core_manager.CustomizableResourceManager
	rom                  core_manager.ReadOnlyResourceManager
	ext                  context.Context
	meshCache            *mesh.Cache
	lif                  lookup.LookupIPFunc
	configm              config_manager.ConfigManager
	leadInfo             component.LeaderInfo
	erf                  events.EventBus
	dsl                  datasource.Loader
	dps                  *dp_server.DpServer
	registryCenter       dubboRegistry.Registry
	metadataReportCenter report.MetadataReport
	configCenter         config_center.DynamicConfiguration
	adminRegistry        *registry.Registry
	governance           governance.GovernanceConfig
	rv                   ResourceValidators
	ddsctx               *dds_context.Context
	appCtx               context.Context
	dCache               *sync.Map
	regClient            reg_client.RegClient
	serviceDiscover      dubboRegistry.ServiceDiscovery
	appRegCtx            *registry.ApplicationContext
	infRegCtx            *registry.InterfaceContext
	*runtimeInfo
}

func BuilderFor(appCtx context.Context, cfg dubbo_cp.Config) (*Builder, error) {
	hostname, err := os.Hostname()
	if err != nil {
		return nil, errors.Wrap(err, "could not get hostname")
	}
	suffix := core.NewUUID()[0:4]
	return &Builder{
		cfg: cfg,
		ext: context.Background(),
		runtimeInfo: &runtimeInfo{
			instanceId: fmt.Sprintf("%s-%s", hostname, suffix),
			startTime:  time.Now(),
			mode:       cfg.Mode,
			deployMode: cfg.DeployMode,
		},
		appCtx: appCtx,
	}, nil
}

func (b *Builder) WithAppRegCtx(ctx *registry.ApplicationContext) *Builder {
	b.appRegCtx = ctx
	return b
}

func (b *Builder) WithInfRegCtx(ctx *registry.InterfaceContext) *Builder {
	b.infRegCtx = ctx
	return b
}

func (b *Builder) WithComponentManager(cm component.Manager) *Builder {
	b.cm = cm
	return b
}

func (b *Builder) WithResourceStore(rs core_store.CustomizableResourceStore) *Builder {
	b.rs = rs
	return b
}

func (b *Builder) WithTransactions(txs core_store.Transactions) *Builder {
	b.txs = txs
	return b
}

func (b *Builder) WithConfigStore(cs core_store.ResourceStore) *Builder {
	b.cs = cs
	return b
}

func (b *Builder) WithResourceManager(rm core_manager.CustomizableResourceManager) *Builder {
	b.rm = rm
	return b
}

func (b *Builder) WithReadOnlyResourceManager(rom core_manager.ReadOnlyResourceManager) *Builder {
	b.rom = rom
	return b
}

func (b *Builder) WithExtensions(ext context.Context) *Builder {
	b.ext = ext
	return b
}

func (b *Builder) WithExtension(key interface{}, value interface{}) *Builder {
	b.ext = context.WithValue(b.ext, key, value)
	return b
}

func (b *Builder) WithConfigManager(configm config_manager.ConfigManager) *Builder {
	b.configm = configm
	return b
}

func (b *Builder) WithLeaderInfo(leadInfo component.LeaderInfo) *Builder {
	b.leadInfo = leadInfo
	return b
}

func (b *Builder) WithDataplaneCache(cache *sync.Map) *Builder {
	b.dCache = cache
	return b
}

func (b *Builder) WithLookupIP(lif lookup.LookupIPFunc) *Builder {
	b.lif = lif
	return b
}

func (b *Builder) WithMeshCache(meshCache *mesh.Cache) *Builder {
	b.meshCache = meshCache
	return b
}

func (b *Builder) WithEventBus(erf events.EventBus) *Builder {
	b.erf = erf
	return b
}

func (b *Builder) WithDataSourceLoader(loader datasource.Loader) *Builder {
	b.dsl = loader
	return b
}

func (b *Builder) WithDpServer(dps *dp_server.DpServer) *Builder {
	b.dps = dps
	return b
}

func (b *Builder) MeshCache() *mesh.Cache {
	return b.meshCache
}

func (b *Builder) WithDDSContext(ddsctx *dds_context.Context) *Builder {
	b.ddsctx = ddsctx
	return b
}

func (b *Builder) WithResourceValidators(rv ResourceValidators) *Builder {
	b.rv = rv
	return b
}

func (b *Builder) WithRegClient(regClient reg_client.RegClient) *Builder {
	b.regClient = regClient
	return b
}

func (b *Builder) WithRegistryCenter(rg dubboRegistry.Registry) *Builder {
	b.registryCenter = rg
	return b
}

func (b *Builder) WithGovernanceConfig(gc governance.GovernanceConfig) *Builder {
	b.governance = gc
	return b
}

func (b *Builder) WithMetadataReport(mr report.MetadataReport) *Builder {
	b.metadataReportCenter = mr
	return b
}

func (b *Builder) WithConfigCenter(cc config_center.DynamicConfiguration) *Builder {
	b.configCenter = cc
	return b
}

func (b *Builder) WithAdminRegistry(ag *registry.Registry) *Builder {
	b.adminRegistry = ag
	return b
}

func (b *Builder) WithServiceDiscovery(discovery dubboRegistry.ServiceDiscovery) *Builder {
	b.serviceDiscover = discovery
	return b
}

func (b *Builder) Build() (Runtime, error) {
	if b.cm == nil {
		return nil, errors.Errorf("ComponentManager has not been configured")
	}
	if b.rs == nil {
		return nil, errors.Errorf("ResourceStore has not been configured")
	}
	if b.txs == nil {
		return nil, errors.Errorf("Transactions has not been configured")
	}
	if b.rm == nil {
		return nil, errors.Errorf("ResourceManager has not been configured")
	}
	if b.rom == nil {
		return nil, errors.Errorf("ReadOnlyResourceManager has not been configured")
	}
	if b.ext == nil {
		return nil, errors.Errorf("Extensions have been misconfigured")
	}
	if b.leadInfo == nil {
		return nil, errors.Errorf("LeaderInfo has not been configured")
	}
	if b.erf == nil {
		return nil, errors.Errorf("EventReaderFactory has not been configured")
	}
	if b.dps == nil {
		return nil, errors.Errorf("DpServer has not been configured")
	}
	if b.meshCache == nil {
		return nil, errors.Errorf("MeshCache has not been configured")
	}

	return &runtime{
		RuntimeInfo: b.runtimeInfo,
		RuntimeContext: &runtimeContext{
			cfg:                  b.cfg,
			rm:                   b.rm,
			rom:                  b.rom,
			txs:                  b.txs,
			ddsctx:               b.ddsctx,
			ext:                  b.ext,
			configm:              b.configm,
			registryCenter:       b.registryCenter,
			metadataReportCenter: b.metadataReportCenter,
			configCenter:         b.configCenter,
			adminRegistry:        b.adminRegistry,
			governance:           b.governance,
			leadInfo:             b.leadInfo,
			erf:                  b.erf,
			dCache:               b.dCache,
			dps:                  b.dps,
			serviceDiscovery:     b.serviceDiscover,
			rv:                   b.rv,
			appCtx:               b.appCtx,
			meshCache:            b.meshCache,
			regClient:            b.regClient,
		},
		Manager: b.cm,
	}, nil
}

func (b *Builder) RegClient() reg_client.RegClient {
	return b.regClient
}

func (b *Builder) DataplaneCache() *sync.Map {
	return b.dCache
}

func (b *Builder) Governance() governance.GovernanceConfig {
	return b.governance
}

func (b *Builder) AdminRegistry() *registry.Registry {
	return b.adminRegistry
}

func (b *Builder) ConfigCenter() config_center.DynamicConfiguration {
	return b.configCenter
}

func (b *Builder) ServiceDiscovery() dubboRegistry.ServiceDiscovery {
	return b.serviceDiscover
}

func (b *Builder) RegistryCenter() dubboRegistry.Registry {
	return b.registryCenter
}

func (b *Builder) MetadataReportCenter() report.MetadataReport {
	return b.metadataReportCenter
}

func (b *Builder) ComponentManager() component.Manager {
	return b.cm
}

func (b *Builder) ResourceStore() core_store.CustomizableResourceStore {
	return b.rs
}

func (b *Builder) Transactions() core_store.Transactions {
	return b.txs
}

func (b *Builder) ConfigStore() core_store.ResourceStore {
	return b.cs
}

func (b *Builder) ResourceManager() core_manager.CustomizableResourceManager {
	return b.rm
}

func (b *Builder) ReadOnlyResourceManager() core_manager.ReadOnlyResourceManager {
	return b.rom
}

func (b *Builder) LookupIP() lookup.LookupIPFunc {
	return b.lif
}

func (b *Builder) Config() dubbo_cp.Config {
	return b.cfg
}

func (b *Builder) DDSContext() *dds_context.Context {
	return b.ddsctx
}

func (b *Builder) Extensions() context.Context {
	return b.ext
}

func (b *Builder) ConfigManager() config_manager.ConfigManager {
	return b.configm
}

func (b *Builder) LeaderInfo() component.LeaderInfo {
	return b.leadInfo
}

func (b *Builder) EventBus() events.EventBus {
	return b.erf
}

func (b *Builder) DpServer() *dp_server.DpServer {
	return b.dps
}

func (b *Builder) ResourceValidators() ResourceValidators {
	return b.rv
}

func (b *Builder) AppCtx() context.Context {
	return b.appCtx
}

func (b *Builder) AppRegCtx() *registry.ApplicationContext {
	return b.appRegCtx
}

func (b *Builder) InfRegCtx() *registry.InterfaceContext {
	return b.infRegCtx
}