Source file src/github.com/chaos-mesh/chaos-mesh/pkg/ctrl/server/schema.resolvers.go

Documentation: github.com/chaos-mesh/chaos-mesh/pkg/ctrl/server

     1  package server
     2  
     3  // This file will be automatically regenerated based on the schema, any resolver implementations
     4  // will be copied through when generating and any unknown code will be moved to the end.
     5  
     6  import (
     7  	"bufio"
     8  	"context"
     9  	"encoding/json"
    10  	"errors"
    11  	"fmt"
    12  	"io"
    13  	"time"
    14  
    15  	v1 "k8s.io/api/core/v1"
    16  	v11 "k8s.io/apimachinery/pkg/apis/meta/v1"
    17  	"k8s.io/apimachinery/pkg/types"
    18  	"sigs.k8s.io/controller-runtime/pkg/client"
    19  
    20  	"github.com/chaos-mesh/chaos-mesh/api/v1alpha1"
    21  	"github.com/chaos-mesh/chaos-mesh/pkg/ctrl/server/generated"
    22  	"github.com/chaos-mesh/chaos-mesh/pkg/ctrl/server/model"
    23  	podSelector "github.com/chaos-mesh/chaos-mesh/pkg/selector/pod"
    24  )
    25  
    26  func (r *attrOverrideSpecResolver) Ino(ctx context.Context, obj *v1alpha1.AttrOverrideSpec) (*int, error) {
    27  	if obj.Ino == nil {
    28  		return nil, nil
    29  	}
    30  	ino := (int)(*obj.Ino)
    31  	return &ino, nil
    32  }
    33  
    34  func (r *attrOverrideSpecResolver) Size(ctx context.Context, obj *v1alpha1.AttrOverrideSpec) (*int, error) {
    35  	if obj.Size == nil {
    36  		return nil, nil
    37  	}
    38  	size := (int)(*obj.Size)
    39  	return &size, nil
    40  }
    41  
    42  func (r *attrOverrideSpecResolver) Blocks(ctx context.Context, obj *v1alpha1.AttrOverrideSpec) (*int, error) {
    43  	if obj.Blocks == nil {
    44  		return nil, nil
    45  	}
    46  	blocks := (int)(*obj.Blocks)
    47  	return &blocks, nil
    48  }
    49  
    50  func (r *attrOverrideSpecResolver) Kind(ctx context.Context, obj *v1alpha1.AttrOverrideSpec) (*string, error) {
    51  	if obj.Kind == nil {
    52  		return nil, nil
    53  	}
    54  	kind := (string)(*obj.Kind)
    55  	return &kind, nil
    56  }
    57  
    58  func (r *attrOverrideSpecResolver) Perm(ctx context.Context, obj *v1alpha1.AttrOverrideSpec) (*int, error) {
    59  	if obj.Perm == nil {
    60  		return nil, nil
    61  	}
    62  	perm := (int)(*obj.Perm)
    63  	return &perm, nil
    64  }
    65  
    66  func (r *attrOverrideSpecResolver) Nlink(ctx context.Context, obj *v1alpha1.AttrOverrideSpec) (*int, error) {
    67  	if obj.Nlink == nil {
    68  		return nil, nil
    69  	}
    70  	nlink := (int)(*obj.Nlink)
    71  	return &nlink, nil
    72  }
    73  
    74  func (r *attrOverrideSpecResolver) UID(ctx context.Context, obj *v1alpha1.AttrOverrideSpec) (*int, error) {
    75  	if obj.UID == nil {
    76  		return nil, nil
    77  	}
    78  	uid := (int)(*obj.UID)
    79  	return &uid, nil
    80  }
    81  
    82  func (r *attrOverrideSpecResolver) Gid(ctx context.Context, obj *v1alpha1.AttrOverrideSpec) (*int, error) {
    83  	if obj.GID == nil {
    84  		return nil, nil
    85  	}
    86  	gid := (int)(*obj.GID)
    87  	return &gid, nil
    88  }
    89  
    90  func (r *attrOverrideSpecResolver) Rdev(ctx context.Context, obj *v1alpha1.AttrOverrideSpec) (*int, error) {
    91  	if obj.Rdev == nil {
    92  		return nil, nil
    93  	}
    94  	rdev := (int)(*obj.Rdev)
    95  	return &rdev, nil
    96  }
    97  
    98  func (r *bandwidthSpecResolver) Limit(ctx context.Context, obj *v1alpha1.BandwidthSpec) (int, error) {
    99  	return int(obj.Limit), nil
   100  }
   101  
   102  func (r *bandwidthSpecResolver) Buffer(ctx context.Context, obj *v1alpha1.BandwidthSpec) (int, error) {
   103  	return int(obj.Buffer), nil
   104  }
   105  
   106  func (r *bandwidthSpecResolver) Peakrate(ctx context.Context, obj *v1alpha1.BandwidthSpec) (*int, error) {
   107  	if obj.Peakrate == nil {
   108  		return nil, nil
   109  	}
   110  	value := int(*obj.Peakrate)
   111  	return &value, nil
   112  }
   113  
   114  func (r *bandwidthSpecResolver) Minburst(ctx context.Context, obj *v1alpha1.BandwidthSpec) (*int, error) {
   115  	if obj.Minburst == nil {
   116  		return nil, nil
   117  	}
   118  	value := int(*obj.Minburst)
   119  	return &value, nil
   120  }
   121  
   122  func (r *chaosConditionResolver) Type(ctx context.Context, obj *v1alpha1.ChaosCondition) (string, error) {
   123  	return string(obj.Type), nil
   124  }
   125  
   126  func (r *chaosConditionResolver) Status(ctx context.Context, obj *v1alpha1.ChaosCondition) (string, error) {
   127  	return string(obj.Status), nil
   128  }
   129  
   130  func (r *cidrAndPortResolver) Port(ctx context.Context, obj *v1alpha1.CidrAndPort) (int, error) {
   131  	return int(obj.Port), nil
   132  }
   133  
   134  func (r *containerStateRunningResolver) StartedAt(ctx context.Context, obj *v1.ContainerStateRunning) (*time.Time, error) {
   135  	return &obj.StartedAt.Time, nil
   136  }
   137  
   138  func (r *containerStateTerminatedResolver) StartedAt(ctx context.Context, obj *v1.ContainerStateTerminated) (*time.Time, error) {
   139  	return &obj.StartedAt.Time, nil
   140  }
   141  
   142  func (r *containerStateTerminatedResolver) FinishedAt(ctx context.Context, obj *v1.ContainerStateTerminated) (*time.Time, error) {
   143  	return &obj.FinishedAt.Time, nil
   144  }
   145  
   146  func (r *experimentStatusResolver) DesiredPhase(ctx context.Context, obj *v1alpha1.ExperimentStatus) (string, error) {
   147  	return string(obj.DesiredPhase), nil
   148  }
   149  
   150  func (r *hTTPChaosResolver) UID(ctx context.Context, obj *v1alpha1.HTTPChaos) (string, error) {
   151  	return string(obj.UID), nil
   152  }
   153  
   154  func (r *hTTPChaosResolver) CreationTimestamp(ctx context.Context, obj *v1alpha1.HTTPChaos) (*time.Time, error) {
   155  	return &obj.CreationTimestamp.Time, nil
   156  }
   157  
   158  func (r *hTTPChaosResolver) DeletionTimestamp(ctx context.Context, obj *v1alpha1.HTTPChaos) (*time.Time, error) {
   159  	return &obj.DeletionTimestamp.Time, nil
   160  }
   161  
   162  func (r *hTTPChaosResolver) Labels(ctx context.Context, obj *v1alpha1.HTTPChaos) (map[string]interface{}, error) {
   163  	labels := make(map[string]interface{})
   164  	for k, v := range obj.Labels {
   165  		labels[k] = v
   166  	}
   167  	return labels, nil
   168  }
   169  
   170  func (r *hTTPChaosResolver) Annotations(ctx context.Context, obj *v1alpha1.HTTPChaos) (map[string]interface{}, error) {
   171  	annotations := make(map[string]interface{})
   172  	for k, v := range obj.Annotations {
   173  		annotations[k] = v
   174  	}
   175  	return annotations, nil
   176  }
   177  
   178  func (r *hTTPChaosResolver) Podhttp(ctx context.Context, obj *v1alpha1.HTTPChaos) ([]*v1alpha1.PodHttpChaos, error) {
   179  	podhttps := make([]*v1alpha1.PodHttpChaos, 0, len(obj.Status.Instances))
   180  	for id := range obj.Status.Instances {
   181  		podhttp := new(v1alpha1.PodHttpChaos)
   182  		if err := r.Client.Get(ctx, parseNamespacedName(id), podhttp); err != nil {
   183  			return nil, err
   184  		}
   185  		podhttps = append(podhttps, podhttp)
   186  	}
   187  	return podhttps, nil
   188  }
   189  
   190  func (r *hTTPChaosSpecResolver) Mode(ctx context.Context, obj *v1alpha1.HTTPChaosSpec) (string, error) {
   191  	return string(obj.Mode), nil
   192  }
   193  
   194  func (r *hTTPChaosSpecResolver) Target(ctx context.Context, obj *v1alpha1.HTTPChaosSpec) (string, error) {
   195  	return string(obj.Target), nil
   196  }
   197  
   198  func (r *hTTPChaosSpecResolver) RequestHeaders(ctx context.Context, obj *v1alpha1.HTTPChaosSpec) (map[string]interface{}, error) {
   199  	headers := make(map[string]interface{})
   200  	for k, v := range obj.RequestHeaders {
   201  		headers[k] = v
   202  	}
   203  	return headers, nil
   204  }
   205  
   206  func (r *hTTPChaosSpecResolver) ResponseHeaders(ctx context.Context, obj *v1alpha1.HTTPChaosSpec) (map[string]interface{}, error) {
   207  	headers := make(map[string]interface{})
   208  	for k, v := range obj.ResponseHeaders {
   209  		headers[k] = v
   210  	}
   211  	return headers, nil
   212  }
   213  
   214  func (r *hTTPChaosStatusResolver) Instances(ctx context.Context, obj *v1alpha1.HTTPChaosStatus) (map[string]interface{}, error) {
   215  	instances := make(map[string]interface{})
   216  	for k, v := range obj.Instances {
   217  		instances[k] = v
   218  	}
   219  	return instances, nil
   220  }
   221  
   222  func (r *iOChaosResolver) UID(ctx context.Context, obj *v1alpha1.IOChaos) (string, error) {
   223  	return string(obj.UID), nil
   224  }
   225  
   226  func (r *iOChaosResolver) CreationTimestamp(ctx context.Context, obj *v1alpha1.IOChaos) (*time.Time, error) {
   227  	return &obj.CreationTimestamp.Time, nil
   228  }
   229  
   230  func (r *iOChaosResolver) DeletionTimestamp(ctx context.Context, obj *v1alpha1.IOChaos) (*time.Time, error) {
   231  	return &obj.DeletionTimestamp.Time, nil
   232  }
   233  
   234  func (r *iOChaosResolver) Labels(ctx context.Context, obj *v1alpha1.IOChaos) (map[string]interface{}, error) {
   235  	labels := make(map[string]interface{})
   236  	for k, v := range obj.Labels {
   237  		labels[k] = v
   238  	}
   239  	return labels, nil
   240  }
   241  
   242  func (r *iOChaosResolver) Annotations(ctx context.Context, obj *v1alpha1.IOChaos) (map[string]interface{}, error) {
   243  	annotations := make(map[string]interface{})
   244  	for k, v := range obj.Annotations {
   245  		annotations[k] = v
   246  	}
   247  	return annotations, nil
   248  }
   249  
   250  func (r *iOChaosResolver) Podios(ctx context.Context, obj *v1alpha1.IOChaos) ([]*v1alpha1.PodIOChaos, error) {
   251  	podios := make([]*v1alpha1.PodIOChaos, 0, len(obj.Status.Instances))
   252  	for id := range obj.Status.Instances {
   253  		podio := new(v1alpha1.PodIOChaos)
   254  		if err := r.Client.Get(ctx, parseNamespacedName(id), podio); err != nil {
   255  			return nil, err
   256  		}
   257  		podios = append(podios, podio)
   258  	}
   259  	return podios, nil
   260  }
   261  
   262  func (r *iOChaosActionResolver) Type(ctx context.Context, obj *v1alpha1.IOChaosAction) (string, error) {
   263  	return string(obj.Type), nil
   264  }
   265  
   266  func (r *iOChaosActionResolver) Methods(ctx context.Context, obj *v1alpha1.IOChaosAction) ([]string, error) {
   267  	methods := make([]string, 0, len(obj.Methods))
   268  	for k, v := range obj.Methods {
   269  		methods[k] = string(v)
   270  	}
   271  	return methods, nil
   272  }
   273  
   274  func (r *iOChaosActionResolver) Ino(ctx context.Context, obj *v1alpha1.IOChaosAction) (*int64, error) {
   275  	if obj.AttrOverrideSpec == nil || obj.Ino == nil {
   276  		return nil, nil
   277  	}
   278  	ino := (int64)(*obj.Ino)
   279  	return &ino, nil
   280  }
   281  
   282  func (r *iOChaosActionResolver) Size(ctx context.Context, obj *v1alpha1.IOChaosAction) (*int64, error) {
   283  	if obj.AttrOverrideSpec == nil || obj.Size == nil {
   284  		return nil, nil
   285  	}
   286  	size := (int64)(*obj.Size)
   287  	return &size, nil
   288  }
   289  
   290  func (r *iOChaosActionResolver) Blocks(ctx context.Context, obj *v1alpha1.IOChaosAction) (*int64, error) {
   291  	if obj.AttrOverrideSpec == nil || obj.Blocks == nil {
   292  		return nil, nil
   293  	}
   294  	blocks := (int64)(*obj.Blocks)
   295  	return &blocks, nil
   296  }
   297  
   298  func (r *iOChaosActionResolver) Atime(ctx context.Context, obj *v1alpha1.IOChaosAction) (*v1alpha1.Timespec, error) {
   299  	if obj.AttrOverrideSpec == nil {
   300  		return nil, nil
   301  	}
   302  	return obj.Atime, nil
   303  }
   304  
   305  func (r *iOChaosActionResolver) Mtime(ctx context.Context, obj *v1alpha1.IOChaosAction) (*v1alpha1.Timespec, error) {
   306  	if obj.AttrOverrideSpec == nil {
   307  		return nil, nil
   308  	}
   309  	return obj.Mtime, nil
   310  }
   311  
   312  func (r *iOChaosActionResolver) Ctime(ctx context.Context, obj *v1alpha1.IOChaosAction) (*v1alpha1.Timespec, error) {
   313  	if obj.AttrOverrideSpec == nil {
   314  		return nil, nil
   315  	}
   316  	return obj.Ctime, nil
   317  }
   318  
   319  func (r *iOChaosActionResolver) Kind(ctx context.Context, obj *v1alpha1.IOChaosAction) (*string, error) {
   320  	if obj.AttrOverrideSpec == nil || obj.Kind == nil {
   321  		return nil, nil
   322  	}
   323  	kind := (string)(*obj.Kind)
   324  	return &kind, nil
   325  }
   326  
   327  func (r *iOChaosActionResolver) Perm(ctx context.Context, obj *v1alpha1.IOChaosAction) (*int, error) {
   328  	if obj.AttrOverrideSpec == nil || obj.Perm == nil {
   329  		return nil, nil
   330  	}
   331  	perm := (int)(*obj.Perm)
   332  	return &perm, nil
   333  }
   334  
   335  func (r *iOChaosActionResolver) Nlink(ctx context.Context, obj *v1alpha1.IOChaosAction) (*int64, error) {
   336  	if obj.AttrOverrideSpec == nil || obj.Nlink == nil {
   337  		return nil, nil
   338  	}
   339  	nlink := (int64)(*obj.Nlink)
   340  	return &nlink, nil
   341  }
   342  
   343  func (r *iOChaosActionResolver) UID(ctx context.Context, obj *v1alpha1.IOChaosAction) (*int64, error) {
   344  	if obj.AttrOverrideSpec == nil || obj.UID == nil {
   345  		return nil, nil
   346  	}
   347  	uid := (int64)(*obj.UID)
   348  	return &uid, nil
   349  }
   350  
   351  func (r *iOChaosActionResolver) Gid(ctx context.Context, obj *v1alpha1.IOChaosAction) (*int64, error) {
   352  	if obj.AttrOverrideSpec == nil || obj.GID == nil {
   353  		return nil, nil
   354  	}
   355  	gid := (int64)(*obj.GID)
   356  	return &gid, nil
   357  }
   358  
   359  func (r *iOChaosActionResolver) Rdev(ctx context.Context, obj *v1alpha1.IOChaosAction) (*int64, error) {
   360  	if obj.AttrOverrideSpec == nil || obj.Rdev == nil {
   361  		return nil, nil
   362  	}
   363  	rdev := (int64)(*obj.Rdev)
   364  	return &rdev, nil
   365  }
   366  
   367  func (r *iOChaosActionResolver) Filling(ctx context.Context, obj *v1alpha1.IOChaosAction) (*string, error) {
   368  	if obj.MistakeSpec == nil {
   369  		return nil, nil
   370  	}
   371  	filling := string(obj.Filling)
   372  	return &filling, nil
   373  }
   374  
   375  func (r *iOChaosActionResolver) MaxOccurrences(ctx context.Context, obj *v1alpha1.IOChaosAction) (*int64, error) {
   376  	if obj.MistakeSpec == nil {
   377  		return nil, nil
   378  	}
   379  	return &obj.MaxOccurrences, nil
   380  }
   381  
   382  func (r *iOChaosActionResolver) MaxLength(ctx context.Context, obj *v1alpha1.IOChaosAction) (*int64, error) {
   383  	if obj.MistakeSpec == nil {
   384  		return nil, nil
   385  	}
   386  	return &obj.MaxLength, nil
   387  }
   388  
   389  func (r *iOChaosSpecResolver) Mode(ctx context.Context, obj *v1alpha1.IOChaosSpec) (string, error) {
   390  	return string(obj.Mode), nil
   391  }
   392  
   393  func (r *iOChaosSpecResolver) Action(ctx context.Context, obj *v1alpha1.IOChaosSpec) (string, error) {
   394  	return string(obj.Action), nil
   395  }
   396  
   397  func (r *iOChaosSpecResolver) Errno(ctx context.Context, obj *v1alpha1.IOChaosSpec) (*int, error) {
   398  	errno := int(obj.Errno)
   399  	return &errno, nil
   400  }
   401  
   402  func (r *iOChaosSpecResolver) Methods(ctx context.Context, obj *v1alpha1.IOChaosSpec) ([]string, error) {
   403  	methods := make([]string, 0, len(obj.Methods))
   404  	for _, method := range obj.Methods {
   405  		methods = append(methods, string(method))
   406  	}
   407  	return methods, nil
   408  }
   409  
   410  func (r *iOChaosStatusResolver) Instances(ctx context.Context, obj *v1alpha1.IOChaosStatus) (map[string]interface{}, error) {
   411  	instances := make(map[string]interface{})
   412  	for k, v := range obj.Instances {
   413  		instances[k] = v
   414  	}
   415  	return instances, nil
   416  }
   417  
   418  func (r *ioFaultResolver) Errno(ctx context.Context, obj *v1alpha1.IoFault) (int, error) {
   419  	return int(obj.Errno), nil
   420  }
   421  
   422  func (r *loggerResolver) Component(ctx context.Context, ns string, component model.Component) (<-chan string, error) {
   423  	var list v1.PodList
   424  	if err := r.Client.List(ctx, &list, client.MatchingLabels(componentLabels(component)), client.InNamespace(ns)); err != nil {
   425  		return nil, err
   426  	}
   427  
   428  	if len(list.Items) == 0 {
   429  		return nil, fmt.Errorf("instance of %s not found", component)
   430  	}
   431  
   432  	return r.Pod(ctx, list.Items[0].Namespace, list.Items[0].Name)
   433  }
   434  
   435  func (r *loggerResolver) Pod(ctx context.Context, ns string, name string) (<-chan string, error) {
   436  	logs, err := r.Clientset.CoreV1().Pods(ns).GetLogs(name, &v1.PodLogOptions{Follow: true}).Stream(ctx)
   437  	if err != nil {
   438  		return nil, err
   439  	}
   440  	logChan := make(chan string)
   441  	go func() {
   442  		defer logs.Close()
   443  		reader := bufio.NewReader(logs)
   444  		for {
   445  			line, err := reader.ReadString('\n')
   446  			if err != nil {
   447  				r.Log.Error(err, fmt.Sprintf("fail to read log of pod(%s/%s)", ns, name))
   448  				break
   449  			}
   450  			select {
   451  			case logChan <- string(line):
   452  				continue
   453  			case <-time.NewTimer(time.Minute).C:
   454  				r.Log.Info(fmt.Sprintf("client has not read log of pod(%s/%s) for 1m, close channel", ns, name))
   455  				return
   456  			}
   457  		}
   458  	}()
   459  	return logChan, nil
   460  }
   461  
   462  func (r *mistakeSpecResolver) Filling(ctx context.Context, obj *v1alpha1.MistakeSpec) (*string, error) {
   463  	filling := string(obj.Filling)
   464  	return &filling, nil
   465  }
   466  
   467  func (r *mutablePodResolver) KillProcesses(ctx context.Context, obj *model.MutablePod, pids []string) ([]*model.KillProcessResult, error) {
   468  	return r.Resolver.killProcess(ctx, obj.Pod, pids)
   469  }
   470  
   471  func (r *mutablePodResolver) CleanTcs(ctx context.Context, obj *model.MutablePod, devices []string) ([]string, error) {
   472  	return r.Resolver.cleanTcs(ctx, obj.Pod, devices)
   473  }
   474  
   475  func (r *mutablePodResolver) CleanIptables(ctx context.Context, obj *model.MutablePod, chains []string) ([]string, error) {
   476  	return r.Resolver.cleanIptables(ctx, obj.Pod, chains)
   477  }
   478  
   479  func (r *mutationResolver) Pod(ctx context.Context, ns string, name string) (*model.MutablePod, error) {
   480  	key := types.NamespacedName{Namespace: ns, Name: name}
   481  	pod := new(v1.Pod)
   482  	if err := r.Client.Get(ctx, key, pod); err != nil {
   483  		return nil, err
   484  	}
   485  	return &model.MutablePod{Pod: pod}, nil
   486  }
   487  
   488  func (r *namespaceResolver) Component(ctx context.Context, obj *model.Namespace, component model.Component) ([]*v1.Pod, error) {
   489  	var list v1.PodList
   490  	var pods []*v1.Pod
   491  	if err := r.Client.List(ctx, &list, client.MatchingLabels(componentLabels(component)), client.InNamespace(obj.Ns)); err != nil {
   492  		return nil, err
   493  	}
   494  	for i := range list.Items {
   495  		pods = append(pods, &list.Items[i])
   496  	}
   497  	return pods, nil
   498  }
   499  
   500  func (r *namespaceResolver) Pod(ctx context.Context, obj *model.Namespace, name *string) ([]*v1.Pod, error) {
   501  	if name == nil {
   502  		var podList v1.PodList
   503  		var pods []*v1.Pod
   504  		if err := r.Client.List(ctx, &podList, &client.ListOptions{Namespace: obj.Ns}); err != nil {
   505  			return nil, err
   506  		}
   507  
   508  		for i := range podList.Items {
   509  			pods = append(pods, &podList.Items[i])
   510  		}
   511  
   512  		return pods, nil
   513  	}
   514  
   515  	key := types.NamespacedName{Namespace: obj.Ns, Name: *name}
   516  	pod := new(v1.Pod)
   517  	if err := r.Client.Get(ctx, key, pod); err != nil {
   518  		return nil, err
   519  	}
   520  	return []*v1.Pod{pod}, nil
   521  }
   522  
   523  func (r *namespaceResolver) Stresschaos(ctx context.Context, obj *model.Namespace, name *string) ([]*v1alpha1.StressChaos, error) {
   524  	if name == nil {
   525  		var stressList v1alpha1.StressChaosList
   526  		var stresses []*v1alpha1.StressChaos
   527  		if err := r.Client.List(ctx, &stressList, &client.ListOptions{Namespace: obj.Ns}); err != nil {
   528  			return nil, err
   529  		}
   530  
   531  		for i := range stressList.Items {
   532  			stresses = append(stresses, &stressList.Items[i])
   533  		}
   534  
   535  		return stresses, nil
   536  	}
   537  
   538  	key := types.NamespacedName{Namespace: obj.Ns, Name: *name}
   539  	stress := new(v1alpha1.StressChaos)
   540  	if err := r.Client.Get(ctx, key, stress); err != nil {
   541  		return nil, err
   542  	}
   543  	return []*v1alpha1.StressChaos{stress}, nil
   544  }
   545  
   546  func (r *namespaceResolver) Iochaos(ctx context.Context, obj *model.Namespace, name *string) ([]*v1alpha1.IOChaos, error) {
   547  	if name == nil {
   548  		var ioList v1alpha1.IOChaosList
   549  		var ios []*v1alpha1.IOChaos
   550  		if err := r.Client.List(ctx, &ioList, &client.ListOptions{Namespace: obj.Ns}); err != nil {
   551  			return nil, err
   552  		}
   553  
   554  		for i := range ioList.Items {
   555  			ios = append(ios, &ioList.Items[i])
   556  		}
   557  
   558  		return ios, nil
   559  	}
   560  
   561  	key := types.NamespacedName{Namespace: obj.Ns, Name: *name}
   562  	io := new(v1alpha1.IOChaos)
   563  	if err := r.Client.Get(ctx, key, io); err != nil {
   564  		return nil, err
   565  	}
   566  	return []*v1alpha1.IOChaos{io}, nil
   567  }
   568  
   569  func (r *namespaceResolver) Podiochaos(ctx context.Context, obj *model.Namespace, name *string) ([]*v1alpha1.PodIOChaos, error) {
   570  	if name == nil {
   571  		var ioList v1alpha1.PodIOChaosList
   572  		var ios []*v1alpha1.PodIOChaos
   573  		if err := r.Client.List(ctx, &ioList, &client.ListOptions{Namespace: obj.Ns}); err != nil {
   574  			return nil, err
   575  		}
   576  
   577  		for i := range ioList.Items {
   578  			ios = append(ios, &ioList.Items[i])
   579  		}
   580  
   581  		return ios, nil
   582  	}
   583  
   584  	key := types.NamespacedName{Namespace: obj.Ns, Name: *name}
   585  	io := new(v1alpha1.PodIOChaos)
   586  	if err := r.Client.Get(ctx, key, io); err != nil {
   587  		return nil, err
   588  	}
   589  
   590  	return []*v1alpha1.PodIOChaos{io}, nil
   591  }
   592  
   593  func (r *namespaceResolver) Httpchaos(ctx context.Context, obj *model.Namespace, name *string) ([]*v1alpha1.HTTPChaos, error) {
   594  	if name == nil {
   595  		var httpList v1alpha1.HTTPChaosList
   596  		var https []*v1alpha1.HTTPChaos
   597  		if err := r.Client.List(ctx, &httpList, &client.ListOptions{Namespace: obj.Ns}); err != nil {
   598  			return nil, err
   599  		}
   600  
   601  		for i := range httpList.Items {
   602  			https = append(https, &httpList.Items[i])
   603  		}
   604  
   605  		return https, nil
   606  	}
   607  
   608  	key := types.NamespacedName{Namespace: obj.Ns, Name: *name}
   609  	http := new(v1alpha1.HTTPChaos)
   610  	if err := r.Client.Get(ctx, key, http); err != nil {
   611  		return nil, err
   612  	}
   613  	return []*v1alpha1.HTTPChaos{http}, nil
   614  }
   615  
   616  func (r *namespaceResolver) Podhttpchaos(ctx context.Context, obj *model.Namespace, name *string) ([]*v1alpha1.PodHttpChaos, error) {
   617  	if name == nil {
   618  		var httpList v1alpha1.PodHttpChaosList
   619  		var https []*v1alpha1.PodHttpChaos
   620  		if err := r.Client.List(ctx, &httpList, &client.ListOptions{Namespace: obj.Ns}); err != nil {
   621  			return nil, err
   622  		}
   623  
   624  		for i := range httpList.Items {
   625  			https = append(https, &httpList.Items[i])
   626  		}
   627  
   628  		return https, nil
   629  	}
   630  
   631  	key := types.NamespacedName{Namespace: obj.Ns, Name: *name}
   632  	http := new(v1alpha1.PodHttpChaos)
   633  	if err := r.Client.Get(ctx, key, http); err != nil {
   634  		return nil, err
   635  	}
   636  	return []*v1alpha1.PodHttpChaos{http}, nil
   637  }
   638  
   639  func (r *namespaceResolver) Networkchaos(ctx context.Context, obj *model.Namespace, name *string) ([]*v1alpha1.NetworkChaos, error) {
   640  	if name == nil {
   641  		var networkList v1alpha1.NetworkChaosList
   642  		var networks []*v1alpha1.NetworkChaos
   643  		if err := r.Client.List(ctx, &networkList, &client.ListOptions{Namespace: obj.Ns}); err != nil {
   644  			return nil, err
   645  		}
   646  
   647  		for i := range networkList.Items {
   648  			networks = append(networks, &networkList.Items[i])
   649  		}
   650  
   651  		return networks, nil
   652  	}
   653  
   654  	key := types.NamespacedName{Namespace: obj.Ns, Name: *name}
   655  	network := new(v1alpha1.NetworkChaos)
   656  	if err := r.Client.Get(ctx, key, network); err != nil {
   657  		return nil, err
   658  	}
   659  	return []*v1alpha1.NetworkChaos{network}, nil
   660  }
   661  
   662  func (r *namespaceResolver) Podnetworkchaos(ctx context.Context, obj *model.Namespace, name *string) ([]*v1alpha1.PodNetworkChaos, error) {
   663  	if name == nil {
   664  		var networkList v1alpha1.PodNetworkChaosList
   665  		var networks []*v1alpha1.PodNetworkChaos
   666  		if err := r.Client.List(ctx, &networkList, &client.ListOptions{Namespace: obj.Ns}); err != nil {
   667  			return nil, err
   668  		}
   669  
   670  		for i := range networkList.Items {
   671  			networks = append(networks, &networkList.Items[i])
   672  		}
   673  
   674  		return networks, nil
   675  	}
   676  
   677  	key := types.NamespacedName{Namespace: obj.Ns, Name: *name}
   678  	network := new(v1alpha1.PodNetworkChaos)
   679  	if err := r.Client.Get(ctx, key, network); err != nil {
   680  		return nil, err
   681  	}
   682  	return []*v1alpha1.PodNetworkChaos{network}, nil
   683  }
   684  
   685  func (r *networkChaosResolver) UID(ctx context.Context, obj *v1alpha1.NetworkChaos) (string, error) {
   686  	return string(obj.UID), nil
   687  }
   688  
   689  func (r *networkChaosResolver) CreationTimestamp(ctx context.Context, obj *v1alpha1.NetworkChaos) (*time.Time, error) {
   690  	return &obj.CreationTimestamp.Time, nil
   691  }
   692  
   693  func (r *networkChaosResolver) DeletionTimestamp(ctx context.Context, obj *v1alpha1.NetworkChaos) (*time.Time, error) {
   694  	return &obj.DeletionTimestamp.Time, nil
   695  }
   696  
   697  func (r *networkChaosResolver) Labels(ctx context.Context, obj *v1alpha1.NetworkChaos) (map[string]interface{}, error) {
   698  	labels := make(map[string]interface{})
   699  	for k, v := range obj.Labels {
   700  		labels[k] = v
   701  	}
   702  	return labels, nil
   703  }
   704  
   705  func (r *networkChaosResolver) Annotations(ctx context.Context, obj *v1alpha1.NetworkChaos) (map[string]interface{}, error) {
   706  	annotations := make(map[string]interface{})
   707  	for k, v := range obj.Annotations {
   708  		annotations[k] = v
   709  	}
   710  	return annotations, nil
   711  }
   712  
   713  func (r *networkChaosResolver) Podnetwork(ctx context.Context, obj *v1alpha1.NetworkChaos) ([]*v1alpha1.PodNetworkChaos, error) {
   714  	podnetworks := make([]*v1alpha1.PodNetworkChaos, 0, len(obj.Status.Instances))
   715  	for id := range obj.Status.Instances {
   716  		podnetwork := new(v1alpha1.PodNetworkChaos)
   717  		if err := r.Client.Get(ctx, parseNamespacedName(id), podnetwork); err != nil {
   718  			return nil, err
   719  		}
   720  		podnetworks = append(podnetworks, podnetwork)
   721  	}
   722  	return podnetworks, nil
   723  }
   724  
   725  func (r *ownerReferenceResolver) UID(ctx context.Context, obj *v11.OwnerReference) (string, error) {
   726  	return string(obj.UID), nil
   727  }
   728  
   729  func (r *podResolver) UID(ctx context.Context, obj *v1.Pod) (string, error) {
   730  	return string(obj.UID), nil
   731  }
   732  
   733  func (r *podResolver) CreationTimestamp(ctx context.Context, obj *v1.Pod) (*time.Time, error) {
   734  	return &obj.CreationTimestamp.Time, nil
   735  }
   736  
   737  func (r *podResolver) DeletionTimestamp(ctx context.Context, obj *v1.Pod) (*time.Time, error) {
   738  	return &obj.DeletionTimestamp.Time, nil
   739  }
   740  
   741  func (r *podResolver) Labels(ctx context.Context, obj *v1.Pod) (map[string]interface{}, error) {
   742  	labels := make(map[string]interface{})
   743  	for k, v := range obj.Labels {
   744  		labels[k] = v
   745  	}
   746  	return labels, nil
   747  }
   748  
   749  func (r *podResolver) Annotations(ctx context.Context, obj *v1.Pod) (map[string]interface{}, error) {
   750  	annotations := make(map[string]interface{})
   751  	for k, v := range obj.Annotations {
   752  		annotations[k] = v
   753  	}
   754  	return annotations, nil
   755  }
   756  
   757  func (r *podResolver) Logs(ctx context.Context, obj *v1.Pod) (string, error) {
   758  	logs, err := r.Clientset.CoreV1().Pods(obj.Namespace).GetLogs(obj.Name, &v1.PodLogOptions{}).Stream(ctx)
   759  	if err != nil {
   760  		return "", err
   761  	}
   762  	defer logs.Close()
   763  	data, err := io.ReadAll(logs)
   764  	if err != nil {
   765  		return "", err
   766  	}
   767  	return string(data), nil
   768  }
   769  
   770  func (r *podResolver) Daemon(ctx context.Context, obj *v1.Pod) (*v1.Pod, error) {
   771  	daemons, err := getDaemonMap(ctx, r.Client)
   772  	if err != nil {
   773  		return nil, err
   774  	}
   775  
   776  	daemon, exist := daemons[obj.Spec.NodeName]
   777  	if !exist {
   778  		return nil, fmt.Errorf("daemon of pod(%s/%s) not found", obj.Namespace, obj.Name)
   779  	}
   780  	return &daemon, nil
   781  }
   782  
   783  func (r *podResolver) Processes(ctx context.Context, obj *v1.Pod) ([]*model.Process, error) {
   784  	return r.GetPidFromPS(ctx, obj)
   785  }
   786  
   787  func (r *podResolver) Mounts(ctx context.Context, obj *v1.Pod) ([]string, error) {
   788  	return r.GetMounts(ctx, obj)
   789  }
   790  
   791  func (r *podResolver) Ipset(ctx context.Context, obj *v1.Pod) (string, error) {
   792  	return r.GetIpset(ctx, obj)
   793  }
   794  
   795  func (r *podResolver) TcQdisc(ctx context.Context, obj *v1.Pod) ([]string, error) {
   796  	return r.GetTcQdisc(ctx, obj)
   797  }
   798  
   799  func (r *podResolver) Iptables(ctx context.Context, obj *v1.Pod) ([]string, error) {
   800  	return r.GetIptables(ctx, obj)
   801  }
   802  
   803  func (r *podConditionResolver) Type(ctx context.Context, obj *v1.PodCondition) (string, error) {
   804  	return string(obj.Type), nil
   805  }
   806  
   807  func (r *podConditionResolver) Status(ctx context.Context, obj *v1.PodCondition) (string, error) {
   808  	return string(obj.Status), nil
   809  }
   810  
   811  func (r *podConditionResolver) LastProbeTime(ctx context.Context, obj *v1.PodCondition) (*time.Time, error) {
   812  	return &obj.LastProbeTime.Time, nil
   813  }
   814  
   815  func (r *podConditionResolver) LastTransitionTime(ctx context.Context, obj *v1.PodCondition) (*time.Time, error) {
   816  	return &obj.LastTransitionTime.Time, nil
   817  }
   818  
   819  func (r *podHTTPChaosResolver) UID(ctx context.Context, obj *v1alpha1.PodHttpChaos) (string, error) {
   820  	return string(obj.UID), nil
   821  }
   822  
   823  func (r *podHTTPChaosResolver) CreationTimestamp(ctx context.Context, obj *v1alpha1.PodHttpChaos) (*time.Time, error) {
   824  	return &obj.CreationTimestamp.Time, nil
   825  }
   826  
   827  func (r *podHTTPChaosResolver) DeletionTimestamp(ctx context.Context, obj *v1alpha1.PodHttpChaos) (*time.Time, error) {
   828  	return &obj.DeletionTimestamp.Time, nil
   829  }
   830  
   831  func (r *podHTTPChaosResolver) Labels(ctx context.Context, obj *v1alpha1.PodHttpChaos) (map[string]interface{}, error) {
   832  	labels := make(map[string]interface{})
   833  	for k, v := range obj.Labels {
   834  		labels[k] = v
   835  	}
   836  	return labels, nil
   837  }
   838  
   839  func (r *podHTTPChaosResolver) Annotations(ctx context.Context, obj *v1alpha1.PodHttpChaos) (map[string]interface{}, error) {
   840  	annotations := make(map[string]interface{})
   841  	for k, v := range obj.Annotations {
   842  		annotations[k] = v
   843  	}
   844  	return annotations, nil
   845  }
   846  
   847  func (r *podHTTPChaosResolver) Pod(ctx context.Context, obj *v1alpha1.PodHttpChaos) (*v1.Pod, error) {
   848  	pod := new(v1.Pod)
   849  	if err := r.Client.Get(ctx, types.NamespacedName{Namespace: obj.Namespace, Name: obj.Name}, pod); err != nil {
   850  		return nil, err
   851  	}
   852  	return pod, nil
   853  }
   854  
   855  func (r *podHttpChaosReplaceActionsResolver) Body(ctx context.Context, obj *v1alpha1.PodHttpChaosReplaceActions) (*string, error) {
   856  	data, err := json.Marshal(obj.Body)
   857  	if err != nil {
   858  		return nil, err
   859  	}
   860  
   861  	body := string(data)
   862  	return &body, nil
   863  }
   864  
   865  func (r *podHttpChaosReplaceActionsResolver) Queries(ctx context.Context, obj *v1alpha1.PodHttpChaosReplaceActions) (map[string]interface{}, error) {
   866  	queries := make(map[string]interface{})
   867  	for k, v := range obj.Queries {
   868  		queries[k] = v
   869  	}
   870  	return queries, nil
   871  }
   872  
   873  func (r *podHttpChaosReplaceActionsResolver) Headers(ctx context.Context, obj *v1alpha1.PodHttpChaosReplaceActions) (map[string]interface{}, error) {
   874  	headers := make(map[string]interface{})
   875  	for k, v := range obj.Headers {
   876  		headers[k] = v
   877  	}
   878  	return headers, nil
   879  }
   880  
   881  func (r *podHttpChaosRuleResolver) Target(ctx context.Context, obj *v1alpha1.PodHttpChaosRule) (string, error) {
   882  	return string(obj.Target), nil
   883  }
   884  
   885  func (r *podHttpChaosSelectorResolver) RequestHeaders(ctx context.Context, obj *v1alpha1.PodHttpChaosSelector) (map[string]interface{}, error) {
   886  	headers := make(map[string]interface{})
   887  	for k, v := range obj.RequestHeaders {
   888  		headers[k] = v
   889  	}
   890  	return headers, nil
   891  }
   892  
   893  func (r *podHttpChaosSelectorResolver) ResponseHeaders(ctx context.Context, obj *v1alpha1.PodHttpChaosSelector) (map[string]interface{}, error) {
   894  	headers := make(map[string]interface{})
   895  	for k, v := range obj.ResponseHeaders {
   896  		headers[k] = v
   897  	}
   898  	return headers, nil
   899  }
   900  
   901  func (r *podIOChaosResolver) UID(ctx context.Context, obj *v1alpha1.PodIOChaos) (string, error) {
   902  	return string(obj.UID), nil
   903  }
   904  
   905  func (r *podIOChaosResolver) CreationTimestamp(ctx context.Context, obj *v1alpha1.PodIOChaos) (*time.Time, error) {
   906  	return &obj.CreationTimestamp.Time, nil
   907  }
   908  
   909  func (r *podIOChaosResolver) DeletionTimestamp(ctx context.Context, obj *v1alpha1.PodIOChaos) (*time.Time, error) {
   910  	return &obj.DeletionTimestamp.Time, nil
   911  }
   912  
   913  func (r *podIOChaosResolver) Labels(ctx context.Context, obj *v1alpha1.PodIOChaos) (map[string]interface{}, error) {
   914  	labels := make(map[string]interface{})
   915  	for k, v := range obj.Labels {
   916  		labels[k] = v
   917  	}
   918  	return labels, nil
   919  }
   920  
   921  func (r *podIOChaosResolver) Annotations(ctx context.Context, obj *v1alpha1.PodIOChaos) (map[string]interface{}, error) {
   922  	annotations := make(map[string]interface{})
   923  	for k, v := range obj.Annotations {
   924  		annotations[k] = v
   925  	}
   926  	return annotations, nil
   927  }
   928  
   929  func (r *podIOChaosResolver) Pod(ctx context.Context, obj *v1alpha1.PodIOChaos) (*v1.Pod, error) {
   930  	pod := new(v1.Pod)
   931  	key := types.NamespacedName{Namespace: obj.Namespace, Name: obj.Name}
   932  	if err := r.Client.Get(ctx, key, pod); err != nil {
   933  		return nil, err
   934  	}
   935  	return pod, nil
   936  }
   937  
   938  func (r *podIOChaosResolver) Ios(ctx context.Context, obj *v1alpha1.PodIOChaos) ([]*v1alpha1.IOChaos, error) {
   939  	ioNames := make(map[string]bool)
   940  	for _, action := range obj.Spec.Actions {
   941  		ioNames[action.Source] = true
   942  	}
   943  
   944  	ios := make([]*v1alpha1.IOChaos, 0, len(ioNames))
   945  	for name := range ioNames {
   946  		namespaced := parseNamespacedName(name)
   947  		io := new(v1alpha1.IOChaos)
   948  		if err := r.Client.Get(ctx, namespaced, io); err != nil {
   949  			return nil, err
   950  		}
   951  		ios = append(ios, io)
   952  	}
   953  	return ios, nil
   954  }
   955  
   956  func (r *podNetworkChaosResolver) UID(ctx context.Context, obj *v1alpha1.PodNetworkChaos) (string, error) {
   957  	return string(obj.UID), nil
   958  }
   959  
   960  func (r *podNetworkChaosResolver) CreationTimestamp(ctx context.Context, obj *v1alpha1.PodNetworkChaos) (*time.Time, error) {
   961  	return &obj.CreationTimestamp.Time, nil
   962  }
   963  
   964  func (r *podNetworkChaosResolver) DeletionTimestamp(ctx context.Context, obj *v1alpha1.PodNetworkChaos) (*time.Time, error) {
   965  	return &obj.DeletionTimestamp.Time, nil
   966  }
   967  
   968  func (r *podNetworkChaosResolver) Labels(ctx context.Context, obj *v1alpha1.PodNetworkChaos) (map[string]interface{}, error) {
   969  	labels := make(map[string]interface{})
   970  	for k, v := range obj.Labels {
   971  		labels[k] = v
   972  	}
   973  	return labels, nil
   974  }
   975  
   976  func (r *podNetworkChaosResolver) Annotations(ctx context.Context, obj *v1alpha1.PodNetworkChaos) (map[string]interface{}, error) {
   977  	annotations := make(map[string]interface{})
   978  	for k, v := range obj.Annotations {
   979  		annotations[k] = v
   980  	}
   981  	return annotations, nil
   982  }
   983  
   984  func (r *podNetworkChaosResolver) Pod(ctx context.Context, obj *v1alpha1.PodNetworkChaos) (*v1.Pod, error) {
   985  	pod := new(v1.Pod)
   986  	if err := r.Client.Get(ctx, types.NamespacedName{Namespace: obj.Namespace, Name: obj.Name}, pod); err != nil {
   987  		return nil, err
   988  	}
   989  	return pod, nil
   990  }
   991  
   992  func (r *podSelectorSpecResolver) Pods(ctx context.Context, obj *v1alpha1.PodSelectorSpec) (map[string]interface{}, error) {
   993  	pods := make(map[string]interface{})
   994  	for k, v := range obj.Pods {
   995  		pods[k] = v
   996  	}
   997  	return pods, nil
   998  }
   999  
  1000  func (r *podSelectorSpecResolver) NodeSelectors(ctx context.Context, obj *v1alpha1.PodSelectorSpec) (map[string]interface{}, error) {
  1001  	selectors := make(map[string]interface{})
  1002  	for k, v := range obj.NodeSelectors {
  1003  		selectors[k] = v
  1004  	}
  1005  	return selectors, nil
  1006  }
  1007  
  1008  func (r *podSelectorSpecResolver) FieldSelectors(ctx context.Context, obj *v1alpha1.PodSelectorSpec) (map[string]interface{}, error) {
  1009  	selectors := make(map[string]interface{})
  1010  	for k, v := range obj.FieldSelectors {
  1011  		selectors[k] = v
  1012  	}
  1013  	return selectors, nil
  1014  }
  1015  
  1016  func (r *podSelectorSpecResolver) LabelSelectors(ctx context.Context, obj *v1alpha1.PodSelectorSpec) (map[string]interface{}, error) {
  1017  	selectors := make(map[string]interface{})
  1018  	for k, v := range obj.LabelSelectors {
  1019  		selectors[k] = v
  1020  	}
  1021  	return selectors, nil
  1022  }
  1023  
  1024  func (r *podSelectorSpecResolver) AnnotationSelectors(ctx context.Context, obj *v1alpha1.PodSelectorSpec) (map[string]interface{}, error) {
  1025  	selectors := make(map[string]interface{})
  1026  	for k, v := range obj.AnnotationSelectors {
  1027  		selectors[k] = v
  1028  	}
  1029  	return selectors, nil
  1030  }
  1031  
  1032  func (r *podStatusResolver) Phase(ctx context.Context, obj *v1.PodStatus) (string, error) {
  1033  	return string(obj.Phase), nil
  1034  }
  1035  
  1036  func (r *podStatusResolver) StartTime(ctx context.Context, obj *v1.PodStatus) (*time.Time, error) {
  1037  	return &obj.StartTime.Time, nil
  1038  }
  1039  
  1040  func (r *podStatusResolver) QosClass(ctx context.Context, obj *v1.PodStatus) (string, error) {
  1041  	return string(obj.QOSClass), nil
  1042  }
  1043  
  1044  func (r *podStressChaosResolver) Cgroups(ctx context.Context, obj *model.PodStressChaos) (*model.Cgroups, error) {
  1045  	return r.GetCgroups(ctx, obj)
  1046  }
  1047  
  1048  func (r *podStressChaosResolver) ProcessStress(ctx context.Context, obj *model.PodStressChaos) ([]*model.ProcessStress, error) {
  1049  	processes, err := r.Pod().Processes(ctx, obj.Pod)
  1050  	if err != nil {
  1051  		return nil, err
  1052  	}
  1053  
  1054  	var processStress []*model.ProcessStress
  1055  	for _, process := range processes {
  1056  		cgroup, err := r.GetCgroup(ctx, obj.Pod, process.Pid)
  1057  		if err != nil {
  1058  			r.Log.Error(err, "get cgroup for process", "pid", process.Pid)
  1059  			// ignore this process
  1060  			continue
  1061  		}
  1062  
  1063  		processStress = append(processStress, &model.ProcessStress{
  1064  			Process: process,
  1065  			Cgroup:  cgroup,
  1066  		})
  1067  	}
  1068  	return processStress, nil
  1069  }
  1070  
  1071  func (r *processResolver) Fds(ctx context.Context, obj *model.Process) ([]*model.Fd, error) {
  1072  	return r.GetFdsOfProcess(ctx, obj), nil
  1073  }
  1074  
  1075  func (r *queryResolver) Namespace(ctx context.Context, ns *string) ([]*model.Namespace, error) {
  1076  	if ns == nil {
  1077  		var nsList v1.NamespaceList
  1078  		var namespaces []*model.Namespace
  1079  		if err := r.Client.List(ctx, &nsList); err != nil {
  1080  			return nil, err
  1081  		}
  1082  
  1083  		for _, ns := range nsList.Items {
  1084  			namespaces = append(namespaces, &model.Namespace{Ns: ns.Name})
  1085  		}
  1086  
  1087  		return namespaces, nil
  1088  	}
  1089  	return []*model.Namespace{{Ns: *ns}}, nil
  1090  }
  1091  
  1092  func (r *queryResolver) Pods(ctx context.Context, selector model.PodSelectorInput) ([]*v1.Pod, error) {
  1093  	spec := v1alpha1.PodSelectorSpec{
  1094  		Pods:              map[string][]string{},
  1095  		NodeSelectors:     map[string]string{},
  1096  		Nodes:             selector.Nodes,
  1097  		PodPhaseSelectors: selector.PodPhaseSelectors,
  1098  		GenericSelectorSpec: v1alpha1.GenericSelectorSpec{
  1099  			Namespaces:          selector.Namespaces,
  1100  			FieldSelectors:      map[string]string{},
  1101  			LabelSelectors:      map[string]string{},
  1102  			AnnotationSelectors: map[string]string{},
  1103  		},
  1104  	}
  1105  
  1106  	for ns, p := range selector.Pods {
  1107  		if pod, ok := p.(string); ok {
  1108  			spec.Pods[ns] = []string{pod}
  1109  		}
  1110  
  1111  		if pods, ok := p.([]string); ok {
  1112  			spec.Pods[ns] = pods
  1113  		}
  1114  	}
  1115  
  1116  	for k, s := range selector.NodeSelectors {
  1117  		if selector, ok := s.(string); ok {
  1118  			spec.NodeSelectors[k] = selector
  1119  		}
  1120  	}
  1121  
  1122  	for k, s := range selector.FieldSelectors {
  1123  		if selector, ok := s.(string); ok {
  1124  			spec.FieldSelectors[k] = selector
  1125  		}
  1126  	}
  1127  
  1128  	for k, s := range selector.LabelSelectors {
  1129  		if selector, ok := s.(string); ok {
  1130  			spec.LabelSelectors[k] = selector
  1131  		}
  1132  	}
  1133  
  1134  	for k, s := range selector.AnnotationSelectors {
  1135  		if selector, ok := s.(string); ok {
  1136  			spec.AnnotationSelectors[k] = selector
  1137  		}
  1138  	}
  1139  
  1140  	selectImpl := podSelector.New(podSelector.Params{
  1141  		Client: r.Client,
  1142  		Reader: r.Client,
  1143  	})
  1144  	pods, err := selectImpl.Select(ctx, &v1alpha1.PodSelector{Selector: spec, Mode: v1alpha1.AllMode})
  1145  	if err != nil {
  1146  		if errors.Is(err, podSelector.ErrNoPodSelected) {
  1147  			return nil, nil
  1148  		}
  1149  		return nil, err
  1150  	}
  1151  	var list []*v1.Pod
  1152  	for _, pod := range pods {
  1153  		p := pod
  1154  		list = append(list, &p.Pod)
  1155  	}
  1156  	return list, nil
  1157  }
  1158  
  1159  func (r *rawIPSetResolver) IPSetType(ctx context.Context, obj *v1alpha1.RawIPSet) (string, error) {
  1160  	return string(obj.IPSetType), nil
  1161  }
  1162  
  1163  func (r *rawIptablesResolver) Direction(ctx context.Context, obj *v1alpha1.RawIptables) (string, error) {
  1164  	return string(obj.Direction), nil
  1165  }
  1166  
  1167  func (r *rawTrafficControlResolver) Type(ctx context.Context, obj *v1alpha1.RawTrafficControl) (string, error) {
  1168  	return string(obj.Type), nil
  1169  }
  1170  
  1171  func (r *recordResolver) Phase(ctx context.Context, obj *v1alpha1.Record) (string, error) {
  1172  	return string(obj.Phase), nil
  1173  }
  1174  
  1175  func (r *stressChaosResolver) UID(ctx context.Context, obj *v1alpha1.StressChaos) (string, error) {
  1176  	return string(obj.UID), nil
  1177  }
  1178  
  1179  func (r *stressChaosResolver) CreationTimestamp(ctx context.Context, obj *v1alpha1.StressChaos) (*time.Time, error) {
  1180  	return &obj.CreationTimestamp.Time, nil
  1181  }
  1182  
  1183  func (r *stressChaosResolver) DeletionTimestamp(ctx context.Context, obj *v1alpha1.StressChaos) (*time.Time, error) {
  1184  	return &obj.DeletionTimestamp.Time, nil
  1185  }
  1186  
  1187  func (r *stressChaosResolver) Labels(ctx context.Context, obj *v1alpha1.StressChaos) (map[string]interface{}, error) {
  1188  	labels := make(map[string]interface{})
  1189  	for k, v := range obj.Labels {
  1190  		labels[k] = v
  1191  	}
  1192  	return labels, nil
  1193  }
  1194  
  1195  func (r *stressChaosResolver) Annotations(ctx context.Context, obj *v1alpha1.StressChaos) (map[string]interface{}, error) {
  1196  	annotations := make(map[string]interface{})
  1197  	for k, v := range obj.Annotations {
  1198  		annotations[k] = v
  1199  	}
  1200  	return annotations, nil
  1201  }
  1202  
  1203  func (r *stressChaosResolver) Podstress(ctx context.Context, obj *v1alpha1.StressChaos) ([]*model.PodStressChaos, error) {
  1204  	pods, _, err := GetPods(ctx, obj.Status.ChaosStatus, obj.Spec.Selector, r.Client)
  1205  	if err != nil {
  1206  		return nil, err
  1207  	}
  1208  
  1209  	var podStress []*model.PodStressChaos
  1210  	for _, pod := range pods {
  1211  		p := pod
  1212  		podStress = append(podStress, &model.PodStressChaos{
  1213  			StressChaos: obj,
  1214  			Pod:         &p,
  1215  		})
  1216  	}
  1217  	return podStress, nil
  1218  }
  1219  
  1220  func (r *stressChaosSpecResolver) Mode(ctx context.Context, obj *v1alpha1.StressChaosSpec) (string, error) {
  1221  	return string(obj.Mode), nil
  1222  }
  1223  
  1224  func (r *stressChaosStatusResolver) Instances(ctx context.Context, obj *v1alpha1.StressChaosStatus) (map[string]interface{}, error) {
  1225  	instances := make(map[string]interface{})
  1226  	for k, v := range obj.Instances {
  1227  		instances[k] = v
  1228  	}
  1229  	return instances, nil
  1230  }
  1231  
  1232  // AttrOverrideSpec returns generated.AttrOverrideSpecResolver implementation.
  1233  func (r *Resolver) AttrOverrideSpec() generated.AttrOverrideSpecResolver {
  1234  	return &attrOverrideSpecResolver{r}
  1235  }
  1236  
  1237  // BandwidthSpec returns generated.BandwidthSpecResolver implementation.
  1238  func (r *Resolver) BandwidthSpec() generated.BandwidthSpecResolver { return &bandwidthSpecResolver{r} }
  1239  
  1240  // ChaosCondition returns generated.ChaosConditionResolver implementation.
  1241  func (r *Resolver) ChaosCondition() generated.ChaosConditionResolver {
  1242  	return &chaosConditionResolver{r}
  1243  }
  1244  
  1245  // CidrAndPort returns generated.CidrAndPortResolver implementation.
  1246  func (r *Resolver) CidrAndPort() generated.CidrAndPortResolver { return &cidrAndPortResolver{r} }
  1247  
  1248  // ContainerStateRunning returns generated.ContainerStateRunningResolver implementation.
  1249  func (r *Resolver) ContainerStateRunning() generated.ContainerStateRunningResolver {
  1250  	return &containerStateRunningResolver{r}
  1251  }
  1252  
  1253  // ContainerStateTerminated returns generated.ContainerStateTerminatedResolver implementation.
  1254  func (r *Resolver) ContainerStateTerminated() generated.ContainerStateTerminatedResolver {
  1255  	return &containerStateTerminatedResolver{r}
  1256  }
  1257  
  1258  // ExperimentStatus returns generated.ExperimentStatusResolver implementation.
  1259  func (r *Resolver) ExperimentStatus() generated.ExperimentStatusResolver {
  1260  	return &experimentStatusResolver{r}
  1261  }
  1262  
  1263  // HTTPChaos returns generated.HTTPChaosResolver implementation.
  1264  func (r *Resolver) HTTPChaos() generated.HTTPChaosResolver { return &hTTPChaosResolver{r} }
  1265  
  1266  // HTTPChaosSpec returns generated.HTTPChaosSpecResolver implementation.
  1267  func (r *Resolver) HTTPChaosSpec() generated.HTTPChaosSpecResolver { return &hTTPChaosSpecResolver{r} }
  1268  
  1269  // HTTPChaosStatus returns generated.HTTPChaosStatusResolver implementation.
  1270  func (r *Resolver) HTTPChaosStatus() generated.HTTPChaosStatusResolver {
  1271  	return &hTTPChaosStatusResolver{r}
  1272  }
  1273  
  1274  // IOChaos returns generated.IOChaosResolver implementation.
  1275  func (r *Resolver) IOChaos() generated.IOChaosResolver { return &iOChaosResolver{r} }
  1276  
  1277  // IOChaosAction returns generated.IOChaosActionResolver implementation.
  1278  func (r *Resolver) IOChaosAction() generated.IOChaosActionResolver { return &iOChaosActionResolver{r} }
  1279  
  1280  // IOChaosSpec returns generated.IOChaosSpecResolver implementation.
  1281  func (r *Resolver) IOChaosSpec() generated.IOChaosSpecResolver { return &iOChaosSpecResolver{r} }
  1282  
  1283  // IOChaosStatus returns generated.IOChaosStatusResolver implementation.
  1284  func (r *Resolver) IOChaosStatus() generated.IOChaosStatusResolver { return &iOChaosStatusResolver{r} }
  1285  
  1286  // IoFault returns generated.IoFaultResolver implementation.
  1287  func (r *Resolver) IoFault() generated.IoFaultResolver { return &ioFaultResolver{r} }
  1288  
  1289  // Logger returns generated.LoggerResolver implementation.
  1290  func (r *Resolver) Logger() generated.LoggerResolver { return &loggerResolver{r} }
  1291  
  1292  // MistakeSpec returns generated.MistakeSpecResolver implementation.
  1293  func (r *Resolver) MistakeSpec() generated.MistakeSpecResolver { return &mistakeSpecResolver{r} }
  1294  
  1295  // MutablePod returns generated.MutablePodResolver implementation.
  1296  func (r *Resolver) MutablePod() generated.MutablePodResolver { return &mutablePodResolver{r} }
  1297  
  1298  // Mutation returns generated.MutationResolver implementation.
  1299  func (r *Resolver) Mutation() generated.MutationResolver { return &mutationResolver{r} }
  1300  
  1301  // Namespace returns generated.NamespaceResolver implementation.
  1302  func (r *Resolver) Namespace() generated.NamespaceResolver { return &namespaceResolver{r} }
  1303  
  1304  // NetworkChaos returns generated.NetworkChaosResolver implementation.
  1305  func (r *Resolver) NetworkChaos() generated.NetworkChaosResolver { return &networkChaosResolver{r} }
  1306  
  1307  // OwnerReference returns generated.OwnerReferenceResolver implementation.
  1308  func (r *Resolver) OwnerReference() generated.OwnerReferenceResolver {
  1309  	return &ownerReferenceResolver{r}
  1310  }
  1311  
  1312  // Pod returns generated.PodResolver implementation.
  1313  func (r *Resolver) Pod() generated.PodResolver { return &podResolver{r} }
  1314  
  1315  // PodCondition returns generated.PodConditionResolver implementation.
  1316  func (r *Resolver) PodCondition() generated.PodConditionResolver { return &podConditionResolver{r} }
  1317  
  1318  // PodHTTPChaos returns generated.PodHTTPChaosResolver implementation.
  1319  func (r *Resolver) PodHTTPChaos() generated.PodHTTPChaosResolver { return &podHTTPChaosResolver{r} }
  1320  
  1321  // PodHttpChaosReplaceActions returns generated.PodHttpChaosReplaceActionsResolver implementation.
  1322  func (r *Resolver) PodHttpChaosReplaceActions() generated.PodHttpChaosReplaceActionsResolver {
  1323  	return &podHttpChaosReplaceActionsResolver{r}
  1324  }
  1325  
  1326  // PodHttpChaosRule returns generated.PodHttpChaosRuleResolver implementation.
  1327  func (r *Resolver) PodHttpChaosRule() generated.PodHttpChaosRuleResolver {
  1328  	return &podHttpChaosRuleResolver{r}
  1329  }
  1330  
  1331  // PodHttpChaosSelector returns generated.PodHttpChaosSelectorResolver implementation.
  1332  func (r *Resolver) PodHttpChaosSelector() generated.PodHttpChaosSelectorResolver {
  1333  	return &podHttpChaosSelectorResolver{r}
  1334  }
  1335  
  1336  // PodIOChaos returns generated.PodIOChaosResolver implementation.
  1337  func (r *Resolver) PodIOChaos() generated.PodIOChaosResolver { return &podIOChaosResolver{r} }
  1338  
  1339  // PodNetworkChaos returns generated.PodNetworkChaosResolver implementation.
  1340  func (r *Resolver) PodNetworkChaos() generated.PodNetworkChaosResolver {
  1341  	return &podNetworkChaosResolver{r}
  1342  }
  1343  
  1344  // PodSelectorSpec returns generated.PodSelectorSpecResolver implementation.
  1345  func (r *Resolver) PodSelectorSpec() generated.PodSelectorSpecResolver {
  1346  	return &podSelectorSpecResolver{r}
  1347  }
  1348  
  1349  // PodStatus returns generated.PodStatusResolver implementation.
  1350  func (r *Resolver) PodStatus() generated.PodStatusResolver { return &podStatusResolver{r} }
  1351  
  1352  // PodStressChaos returns generated.PodStressChaosResolver implementation.
  1353  func (r *Resolver) PodStressChaos() generated.PodStressChaosResolver {
  1354  	return &podStressChaosResolver{r}
  1355  }
  1356  
  1357  // Process returns generated.ProcessResolver implementation.
  1358  func (r *Resolver) Process() generated.ProcessResolver { return &processResolver{r} }
  1359  
  1360  // Query returns generated.QueryResolver implementation.
  1361  func (r *Resolver) Query() generated.QueryResolver { return &queryResolver{r} }
  1362  
  1363  // RawIPSet returns generated.RawIPSetResolver implementation.
  1364  func (r *Resolver) RawIPSet() generated.RawIPSetResolver { return &rawIPSetResolver{r} }
  1365  
  1366  // RawIptables returns generated.RawIptablesResolver implementation.
  1367  func (r *Resolver) RawIptables() generated.RawIptablesResolver { return &rawIptablesResolver{r} }
  1368  
  1369  // RawTrafficControl returns generated.RawTrafficControlResolver implementation.
  1370  func (r *Resolver) RawTrafficControl() generated.RawTrafficControlResolver {
  1371  	return &rawTrafficControlResolver{r}
  1372  }
  1373  
  1374  // Record returns generated.RecordResolver implementation.
  1375  func (r *Resolver) Record() generated.RecordResolver { return &recordResolver{r} }
  1376  
  1377  // StressChaos returns generated.StressChaosResolver implementation.
  1378  func (r *Resolver) StressChaos() generated.StressChaosResolver { return &stressChaosResolver{r} }
  1379  
  1380  // StressChaosSpec returns generated.StressChaosSpecResolver implementation.
  1381  func (r *Resolver) StressChaosSpec() generated.StressChaosSpecResolver {
  1382  	return &stressChaosSpecResolver{r}
  1383  }
  1384  
  1385  // StressChaosStatus returns generated.StressChaosStatusResolver implementation.
  1386  func (r *Resolver) StressChaosStatus() generated.StressChaosStatusResolver {
  1387  	return &stressChaosStatusResolver{r}
  1388  }
  1389  
  1390  type attrOverrideSpecResolver struct{ *Resolver }
  1391  type bandwidthSpecResolver struct{ *Resolver }
  1392  type chaosConditionResolver struct{ *Resolver }
  1393  type cidrAndPortResolver struct{ *Resolver }
  1394  type containerStateRunningResolver struct{ *Resolver }
  1395  type containerStateTerminatedResolver struct{ *Resolver }
  1396  type experimentStatusResolver struct{ *Resolver }
  1397  type hTTPChaosResolver struct{ *Resolver }
  1398  type hTTPChaosSpecResolver struct{ *Resolver }
  1399  type hTTPChaosStatusResolver struct{ *Resolver }
  1400  type iOChaosResolver struct{ *Resolver }
  1401  type iOChaosActionResolver struct{ *Resolver }
  1402  type iOChaosSpecResolver struct{ *Resolver }
  1403  type iOChaosStatusResolver struct{ *Resolver }
  1404  type ioFaultResolver struct{ *Resolver }
  1405  type loggerResolver struct{ *Resolver }
  1406  type mistakeSpecResolver struct{ *Resolver }
  1407  type mutablePodResolver struct{ *Resolver }
  1408  type mutationResolver struct{ *Resolver }
  1409  type namespaceResolver struct{ *Resolver }
  1410  type networkChaosResolver struct{ *Resolver }
  1411  type ownerReferenceResolver struct{ *Resolver }
  1412  type podResolver struct{ *Resolver }
  1413  type podConditionResolver struct{ *Resolver }
  1414  type podHTTPChaosResolver struct{ *Resolver }
  1415  type podHttpChaosReplaceActionsResolver struct{ *Resolver }
  1416  type podHttpChaosRuleResolver struct{ *Resolver }
  1417  type podHttpChaosSelectorResolver struct{ *Resolver }
  1418  type podIOChaosResolver struct{ *Resolver }
  1419  type podNetworkChaosResolver struct{ *Resolver }
  1420  type podSelectorSpecResolver struct{ *Resolver }
  1421  type podStatusResolver struct{ *Resolver }
  1422  type podStressChaosResolver struct{ *Resolver }
  1423  type processResolver struct{ *Resolver }
  1424  type queryResolver struct{ *Resolver }
  1425  type rawIPSetResolver struct{ *Resolver }
  1426  type rawIptablesResolver struct{ *Resolver }
  1427  type rawTrafficControlResolver struct{ *Resolver }
  1428  type recordResolver struct{ *Resolver }
  1429  type stressChaosResolver struct{ *Resolver }
  1430  type stressChaosSpecResolver struct{ *Resolver }
  1431  type stressChaosStatusResolver struct{ *Resolver }
  1432