Merge remote-tracking branch 'upstream/develop' into feature/fix-1447

Author: WyRainBow

api/mesh/v1alpha1/runtime_instance_helper.go

@@ -23,4 +23,8 @@ const (
 	StartupProbe   = "startup"
 )
 
-const InstanceTerminating = "Terminating"
+const (
+	InstanceStarting    = "Starting"
+	InstanceCrashing    = "Crashing"
+	InstanceTerminating = "Terminating"
+)

pkg/console/model/application.go

@@ -131,17 +131,18 @@ func NewApplicationTabInstanceInfoReq() *ApplicationTabInstanceInfoReq {
 }
 
 type AppInstanceInfoResp struct {
-	AppName         string            `json:"appName"`
-	CreateTime      string            `json:"createTime"`
-	DeployState     string            `json:"deployState"`
-	DeployClusters  string            `json:"deployClusters"`
-	IP              string            `json:"ip"`
-	Labels          map[string]string `json:"labels"`
-	Name            string            `json:"name"`
-	RegisterCluster string            `json:"registerCluster"`
-	RegisterState   string            `json:"registerState"`
-	RegisterTime    string            `json:"registerTime"`
-	WorkloadName    string            `json:"workloadName"`
+	AppName         string                 `json:"appName"`
+	CreateTime      string                 `json:"createTime"`
+	LifecycleState  InstanceLifecycleState `json:"lifecycleState"`
+	DeployState     InstanceDeployState    `json:"deployState"`
+	DeployClusters  string                 `json:"deployClusters"`
+	IP              string                 `json:"ip"`
+	Labels          map[string]string      `json:"labels"`
+	Name            string                 `json:"name"`
+	RegisterCluster string                 `json:"registerCluster"`
+	RegisterState   InstanceRegisterState  `json:"registerState"`
+	RegisterTime    string                 `json:"registerTime"`
+	WorkloadName    string                 `json:"workloadName"`
 }
 
 type ApplicationServiceReq struct {

pkg/console/model/instance.go

@@ -20,6 +20,7 @@ package model
 import (
 	"github.com/duke-git/lancet/v2/strutil"
 
+	meshproto "github.com/apache/dubbo-admin/api/mesh/v1alpha1"
 	"github.com/apache/dubbo-admin/pkg/config/app"
 	meshresource "github.com/apache/dubbo-admin/pkg/core/resource/apis/mesh/v1alpha1"
 	coremodel "github.com/apache/dubbo-admin/pkg/core/resource/model"
@@ -54,17 +55,18 @@ func NewSearchPaginationResult() *SearchPaginationResult {
 }
 
 type SearchInstanceResp struct {
-	Ip               string            `json:"ip"`
-	Name             string            `json:"name"`
-	WorkloadName     string            `json:"workloadName"`
-	AppName          string            `json:"appName"`
-	DeployState      string            `json:"deployState"`
-	DeployCluster    string            `json:"deployCluster"`
-	RegisterState    string            `json:"registerState"`
-	RegisterClusters []string          `json:"registerClusters"`
-	CreateTime       string            `json:"createTime"`
-	RegisterTime     string            `json:"registerTime"`
-	Labels           map[string]string `json:"labels"`
+	Ip               string                 `json:"ip"`
+	Name             string                 `json:"name"`
+	WorkloadName     string                 `json:"workloadName"`
+	AppName          string                 `json:"appName"`
+	LifecycleState   InstanceLifecycleState `json:"lifecycleState"`
+	DeployState      InstanceDeployState    `json:"deployState"`
+	DeployCluster    string                 `json:"deployCluster"`
+	RegisterState    InstanceRegisterState  `json:"registerState"`
+	RegisterClusters []string               `json:"registerClusters"`
+	CreateTime       string                 `json:"createTime"`
+	RegisterTime     string                 `json:"registerTime"`
+	Labels           map[string]string      `json:"labels"`
 }
 
 func NewSearchInstanceResp() *SearchInstanceResp {
@@ -85,13 +87,10 @@ func (r *SearchInstanceResp) FromInstanceResource(instanceResource *meshresource
 	if cfg.Engine != nil && cfg.Engine.ID == instance.SourceEngine {
 		r.DeployCluster = cfg.Engine.Name
 	}
-	if r.RegisterTime != "" {
-		r.RegisterState = "Registered"
-	} else {
-		r.RegisterState = "UnRegistered"
-	}
+	r.RegisterState = DeriveInstanceRegisterState(instance)
 	r.Labels = instance.Tags
-	r.DeployState = instance.DeployState
+	r.DeployState = DeriveInstanceDeployState(instance)
+	r.LifecycleState = DeriveInstanceLifecycleState(instance, r.DeployState, r.RegisterState)
 	r.WorkloadName = instance.WorkloadName
 	r.AppName = instance.AppName
 	return r
@@ -104,23 +103,74 @@ type State struct {
 	Value string `json:"value"`
 }
 
+// InstanceDeployState describes the runtime deployment state reported by the platform.
+type InstanceDeployState string
+
+const (
+	// InstanceDeployStateUnknown indicates the deployment state cannot be derived from runtime metadata.
+	InstanceDeployStateUnknown InstanceDeployState = "Unknown"
+	// InstanceDeployStatePending indicates the workload has been accepted but is not running yet.
+	InstanceDeployStatePending InstanceDeployState = "Pending"
+	// InstanceDeployStateStarting indicates the workload is running but not ready to serve.
+	InstanceDeployStateStarting InstanceDeployState = "Starting"
+	// InstanceDeployStateRunning indicates the workload is running and ready.
+	InstanceDeployStateRunning InstanceDeployState = "Running"
+	// InstanceDeployStateTerminating indicates the workload is shutting down.
+	InstanceDeployStateTerminating InstanceDeployState = "Terminating"
+	// InstanceDeployStateFailed indicates the workload has failed.
+	InstanceDeployStateFailed InstanceDeployState = "Failed"
+	// InstanceDeployStateSucceeded indicates the workload has completed successfully and exited.
+	InstanceDeployStateSucceeded InstanceDeployState = "Succeeded"
+	// InstanceDeployStateCrashing indicates the workload is repeatedly crashing or restarting.
+	InstanceDeployStateCrashing InstanceDeployState = "Crashing"
+)
+
+// InstanceRegisterState describes whether the instance is visible to the registry.
+type InstanceRegisterState string
+
+const (
+	// InstanceRegisterStateRegistered indicates the instance has been registered to the registry.
+	InstanceRegisterStateRegistered InstanceRegisterState = "Registered"
+	// InstanceRegisterStateUnregistered indicates the instance has not registered yet or has been removed.
+	InstanceRegisterStateUnregistered InstanceRegisterState = "UnRegistered"
+)
+
+// InstanceLifecycleState describes the user-facing lifecycle synthesized from deploy/register signals.
+type InstanceLifecycleState string
+
+const (
+	// InstanceLifecycleStateStarting indicates the instance is still warming up.
+	InstanceLifecycleStateStarting InstanceLifecycleState = "Starting"
+	// InstanceLifecycleStateServing indicates the instance is both running and registered.
+	InstanceLifecycleStateServing InstanceLifecycleState = "Serving"
+	// InstanceLifecycleStateDraining indicates the instance is running but has started unregistering.
+	InstanceLifecycleStateDraining InstanceLifecycleState = "Draining"
+	// InstanceLifecycleStateTerminating indicates the instance is shutting down.
+	InstanceLifecycleStateTerminating InstanceLifecycleState = "Terminating"
+	// InstanceLifecycleStateError indicates the instance is in an unexpected or failed state.
+	InstanceLifecycleStateError InstanceLifecycleState = "Error"
+	// InstanceLifecycleStateUnknown indicates the lifecycle cannot be inferred from current signals.
+	InstanceLifecycleStateUnknown InstanceLifecycleState = "Unknown"
+)
+
 type InstanceDetailResp struct {
-	RpcPort          int64             `json:"rpcPort"`
-	Ip               string            `json:"ip"`
-	AppName          string            `json:"appName"`
-	WorkloadName     string            `json:"workloadName"`
-	Labels           map[string]string `json:"labels"`
-	CreateTime       string            `json:"createTime"`
-	ReadyTime        string            `json:"readyTime"`
-	RegisterTime     string            `json:"registerTime"`
-	RegisterClusters []string          `json:"registerClusters"`
-	DeployCluster    string            `json:"deployCluster"`
-	DeployState      string            `json:"deployState"`
-	RegisterState    string            `json:"registerState"`
-	Node             string            `json:"node"`
-	Image            string            `json:"image"`
-	Probes           ProbeStruct       `json:"probes"`
-	Tags             map[string]string `json:"tags"`
+	RpcPort          int64                  `json:"rpcPort"`
+	Ip               string                 `json:"ip"`
+	AppName          string                 `json:"appName"`
+	WorkloadName     string                 `json:"workloadName"`
+	Labels           map[string]string      `json:"labels"`
+	CreateTime       string                 `json:"createTime"`
+	ReadyTime        string                 `json:"readyTime"`
+	RegisterTime     string                 `json:"registerTime"`
+	RegisterClusters []string               `json:"registerClusters"`
+	DeployCluster    string                 `json:"deployCluster"`
+	LifecycleState   InstanceLifecycleState `json:"lifecycleState"`
+	DeployState      InstanceDeployState    `json:"deployState"`
+	RegisterState    InstanceRegisterState  `json:"registerState"`
+	Node             string                 `json:"node"`
+	Image            string                 `json:"image"`
+	Probes           ProbeStruct            `json:"probes"`
+	Tags             map[string]string      `json:"tags"`
 }
 
 const (
@@ -158,16 +208,9 @@ func FromInstanceResource(res *meshresource.InstanceResource, cfg app.AdminConfi
 	if cfg.Engine.ID == res.Spec.SourceEngine {
 		r.DeployCluster = cfg.Engine.Name
 	}
-	if strutil.IsNotBlank(instance.DeployState) {
-		r.DeployState = instance.DeployState
-	} else {
-		r.DeployState = "Unknown"
-	}
-	if strutil.IsBlank(r.RegisterTime) {
-		r.RegisterState = "UnRegistered"
-	} else {
-		r.RegisterState = "Registered"
-	}
+	r.DeployState = DeriveInstanceDeployState(instance)
+	r.RegisterState = DeriveInstanceRegisterState(instance)
+	r.LifecycleState = DeriveInstanceLifecycleState(instance, r.DeployState, r.RegisterState)
 	r.Node = instance.Node
 	r.Image = instance.Image
 	r.Probes = ProbeStruct{}
@@ -196,3 +239,69 @@ func FromInstanceResource(res *meshresource.InstanceResource, cfg app.AdminConfi
 	}
 	return r
 }
+
+func DeriveInstanceDeployState(instance *meshproto.Instance) InstanceDeployState {
+	if instance == nil || strutil.IsBlank(instance.DeployState) {
+		return InstanceDeployStateUnknown
+	}
+	deployState := InstanceDeployState(instance.DeployState)
+	switch deployState {
+	case InstanceDeployStateRunning:
+		if !isPodReady(instance) {
+			return InstanceDeployStateStarting
+		}
+		return InstanceDeployStateRunning
+	default:
+		return deployState
+	}
+}
+
+func DeriveInstanceRegisterState(instance *meshproto.Instance) InstanceRegisterState {
+	if instance == nil || strutil.IsBlank(instance.RegisterTime) {
+		return InstanceRegisterStateUnregistered
+	}
+	return InstanceRegisterStateRegistered
+}
+
+func DeriveInstanceLifecycleState(
+	instance *meshproto.Instance,
+	deployState InstanceDeployState,
+	registerState InstanceRegisterState,
+) InstanceLifecycleState {
+	switch deployState {
+	case InstanceDeployStateCrashing, InstanceDeployStateFailed, InstanceDeployStateUnknown, InstanceDeployStateSucceeded:
+		return InstanceLifecycleStateError
+	case InstanceDeployStateTerminating:
+		return InstanceLifecycleStateTerminating
+	}
+
+	if registerState == InstanceRegisterStateRegistered {
+		if deployState == InstanceDeployStateRunning {
+			return InstanceLifecycleStateServing
+		}
+		return InstanceLifecycleStateError
+	}
+
+	if instance != nil && deployState == InstanceDeployStateRunning && strutil.IsNotBlank(instance.UnregisterTime) {
+		return InstanceLifecycleStateDraining
+	}
+
+	switch deployState {
+	case InstanceDeployStatePending, InstanceDeployStateStarting, InstanceDeployStateRunning:
+		return InstanceLifecycleStateStarting
+	default:
+		return InstanceLifecycleStateUnknown
+	}
+}
+
+func isPodReady(instance *meshproto.Instance) bool {
+	for _, condition := range instance.Conditions {
+		if condition == nil {
+			continue
+		}
+		if condition.Type == "Ready" {
+			return condition.Status == "True"
+		}
+	}
+	return false
+}

pkg/console/service/application.go

@@ -95,7 +95,8 @@ func buildAppInstanceInfoResp(instanceRes *meshresource.InstanceResource, cfg ap
 	resp.Name = instance.Name
 	resp.AppName = instance.AppName
 	resp.CreateTime = instance.CreateTime
-	resp.DeployState = instance.DeployState
+	resp.DeployState = model.DeriveInstanceDeployState(instance)
+	resp.LifecycleState = model.DeriveInstanceLifecycleState(instance, resp.DeployState, model.DeriveInstanceRegisterState(instance))
 	if cfg.Engine.ID == instance.SourceEngine {
 		resp.DeployClusters = cfg.Engine.Name
 	}
@@ -104,7 +105,7 @@ func buildAppInstanceInfoResp(instanceRes *meshresource.InstanceResource, cfg ap
 	if d := cfg.FindDiscovery(instanceRes.Mesh); d != nil {
 		resp.RegisterCluster = d.Name
 	}
-	resp.RegisterState = "Registered"
+	resp.RegisterState = model.DeriveInstanceRegisterState(instance)
 	resp.RegisterTime = instance.RegisterTime
 	resp.WorkloadName = instance.WorkloadName
 	return resp

pkg/core/controller/informer.go

@@ -229,17 +229,10 @@ func (s *informer) HandleDeltas(obj interface{}, _ bool) error {
 	}
 	// from oldest to newest
 	for _, d := range deltas {
-		var resource model.Resource
-		var object interface{}
-		if o, ok := d.Object.(cache.DeletedFinalStateUnknown); ok {
-			object = o.Obj
-		} else {
-			object = d.Object
-		}
-		resource, ok := object.(model.Resource)
-		if !ok {
-			logger.Errorf("object from ListWatcher is not conformed to Resource, obj: %v", obj)
-			return bizerror.NewAssertionError("Resource", reflect.TypeOf(obj).Name())
+		resource, err := s.toResource(d.Object)
+		if err != nil {
+			logger.Errorf("object from ListWatcher is not conformed to Resource, obj: %v, err: %v", obj, err)
+			return err
 		}
 		switch d.Type {
 		case cache.Sync, cache.Replaced, cache.Added, cache.Updated:
@@ -257,6 +250,8 @@ func (s *informer) HandleDeltas(obj interface{}, _ bool) error {
 				s.EmitEvent(cache.Added, nil, resource)
 			}
 		case cache.Deleted:
+			logger.Infof("informer processing delete delta, resource kind: %s, key: %s",
+				resource.ResourceKind().ToString(), resource.ResourceKey())
 			if err := s.indexer.Delete(resource); err != nil {
 				logger.Errorf("failed to delete resource from informer, cause %v, resource: %s,", err, resource.String())
 				return err
@@ -267,6 +262,31 @@ func (s *informer) HandleDeltas(obj interface{}, _ bool) error {
 	return nil
 }
 
+func (s *informer) toResource(obj interface{}) (model.Resource, error) {
+	object := obj
+	if tombstone, ok := obj.(cache.DeletedFinalStateUnknown); ok {
+		logger.Debugf("informer resolved tombstone object during delete handling, key: %s", tombstone.Key)
+		object = tombstone.Obj
+	}
+	if resource, ok := object.(model.Resource); ok {
+		return resource, nil
+	}
+	if s.transform != nil {
+		transformed, err := s.transform(object)
+		if err != nil {
+			return nil, err
+		}
+		if resource, ok := transformed.(model.Resource); ok {
+			return resource, nil
+		}
+		object = transformed
+	}
+	if object == nil {
+		return nil, bizerror.NewAssertionError("Resource", "nil")
+	}
+	return nil, bizerror.NewAssertionError("Resource", reflect.TypeOf(object).Name())
+}
+
 // EmitEvent emits an event to the event bus.
 func (s *informer) EmitEvent(typ cache.DeltaType, oldObj model.Resource, newObj model.Resource) {
 	event := events.NewResourceChangedEvent(typ, oldObj, newObj)

pkg/core/controller/listwatcher.go

@@ -31,3 +31,9 @@ type ResourceListerWatcher interface {
 	// return nil if there is no need to transform, see cache.SharedInformer for detail
 	TransformFunc() cache.TransformFunc
 }
+
+// ResourceKeyProvider can be optionally implemented by a ResourceListerWatcher when
+// raw watch objects need a key that is consistent with the transformed resource key.
+type ResourceKeyProvider interface {
+	KeyFunc() cache.KeyFunc
+}