From 348e9a3aeac9ed02e930981065cf0cadad5ce227 Mon Sep 17 00:00:00 2001 From: KubeKyrie Date: Fri, 24 Nov 2023 18:53:03 +0800 Subject: [PATCH] add OTEL trace for clusterpedia-apiserver --- cmd/apiserver/app/apiserver.go | 17 + go.mod | 8 +- pkg/constants/constants.go | 5 + pkg/utils/trace/trace.go | 38 + vendor/github.com/clusterpedia-io/api | 1 - .../api/cluster/v1alpha2/doc.go | 6 + .../api/cluster/v1alpha2/register.go | 51 + .../api/cluster/v1alpha2/types.go | 249 +++ .../cluster/v1alpha2/zz_generated.deepcopy.go | 322 ++++ .../clusterpedia-io/api/clusterpedia/doc.go | 4 + .../api/clusterpedia/fields/lexer.go | 150 ++ .../api/clusterpedia/fields/parser.go | 270 +++ .../api/clusterpedia/fields/selector.go | 363 ++++ .../api/clusterpedia/install/install.go | 14 + .../api/clusterpedia/register.go | 29 + .../api/clusterpedia/scheme/register.go | 17 + .../clusterpedia-io/api/clusterpedia/types.go | 111 ++ .../api/clusterpedia/v1beta1/conversion.go | 376 ++++ .../api/clusterpedia/v1beta1/doc.go | 8 + .../api/clusterpedia/v1beta1/register.go | 56 + .../api/clusterpedia/v1beta1/types.go | 110 ++ .../v1beta1/zz_generated.conversion.go | 338 ++++ .../v1beta1/zz_generated.deepcopy.go | 179 ++ .../api/clusterpedia/zz_generated.deepcopy.go | 207 +++ .../api/policy/v1alpha1/doc.go | 6 + .../api/policy/v1alpha1/register.go | 51 + .../api/policy/v1alpha1/types.go | 347 ++++ .../policy/v1alpha1/zz_generated.deepcopy.go | 340 ++++ .../otel/semconv/v1.7.0/doc.go | 20 + .../otel/semconv/v1.7.0/exception.go | 20 + .../otel/semconv/v1.7.0/http.go | 114 ++ .../otel/semconv/v1.7.0/resource.go | 946 ++++++++++ .../otel/semconv/v1.7.0/schema.go | 20 + .../otel/semconv/v1.7.0/trace.go | 1558 +++++++++++++++++ vendor/modules.txt | 1 + 35 files changed, 6347 insertions(+), 5 deletions(-) create mode 100644 pkg/constants/constants.go create mode 100644 pkg/utils/trace/trace.go delete mode 120000 vendor/github.com/clusterpedia-io/api create mode 100644 vendor/github.com/clusterpedia-io/api/cluster/v1alpha2/doc.go create mode 100644 vendor/github.com/clusterpedia-io/api/cluster/v1alpha2/register.go create mode 100644 vendor/github.com/clusterpedia-io/api/cluster/v1alpha2/types.go create mode 100644 vendor/github.com/clusterpedia-io/api/cluster/v1alpha2/zz_generated.deepcopy.go create mode 100644 vendor/github.com/clusterpedia-io/api/clusterpedia/doc.go create mode 100644 vendor/github.com/clusterpedia-io/api/clusterpedia/fields/lexer.go create mode 100644 vendor/github.com/clusterpedia-io/api/clusterpedia/fields/parser.go create mode 100644 vendor/github.com/clusterpedia-io/api/clusterpedia/fields/selector.go create mode 100644 vendor/github.com/clusterpedia-io/api/clusterpedia/install/install.go create mode 100644 vendor/github.com/clusterpedia-io/api/clusterpedia/register.go create mode 100644 vendor/github.com/clusterpedia-io/api/clusterpedia/scheme/register.go create mode 100644 vendor/github.com/clusterpedia-io/api/clusterpedia/types.go create mode 100644 vendor/github.com/clusterpedia-io/api/clusterpedia/v1beta1/conversion.go create mode 100644 vendor/github.com/clusterpedia-io/api/clusterpedia/v1beta1/doc.go create mode 100644 vendor/github.com/clusterpedia-io/api/clusterpedia/v1beta1/register.go create mode 100644 vendor/github.com/clusterpedia-io/api/clusterpedia/v1beta1/types.go create mode 100644 vendor/github.com/clusterpedia-io/api/clusterpedia/v1beta1/zz_generated.conversion.go create mode 100644 vendor/github.com/clusterpedia-io/api/clusterpedia/v1beta1/zz_generated.deepcopy.go create mode 100644 vendor/github.com/clusterpedia-io/api/clusterpedia/zz_generated.deepcopy.go create mode 100644 vendor/github.com/clusterpedia-io/api/policy/v1alpha1/doc.go create mode 100644 vendor/github.com/clusterpedia-io/api/policy/v1alpha1/register.go create mode 100644 vendor/github.com/clusterpedia-io/api/policy/v1alpha1/types.go create mode 100644 vendor/github.com/clusterpedia-io/api/policy/v1alpha1/zz_generated.deepcopy.go create mode 100644 vendor/go.opentelemetry.io/otel/semconv/v1.7.0/doc.go create mode 100644 vendor/go.opentelemetry.io/otel/semconv/v1.7.0/exception.go create mode 100644 vendor/go.opentelemetry.io/otel/semconv/v1.7.0/http.go create mode 100644 vendor/go.opentelemetry.io/otel/semconv/v1.7.0/resource.go create mode 100644 vendor/go.opentelemetry.io/otel/semconv/v1.7.0/schema.go create mode 100644 vendor/go.opentelemetry.io/otel/semconv/v1.7.0/trace.go diff --git a/cmd/apiserver/app/apiserver.go b/cmd/apiserver/app/apiserver.go index 332b9f6b4..ce1fd1366 100644 --- a/cmd/apiserver/app/apiserver.go +++ b/cmd/apiserver/app/apiserver.go @@ -14,9 +14,12 @@ import ( "k8s.io/component-base/logs" logsapi "k8s.io/component-base/logs/api/v1" "k8s.io/component-base/term" + "k8s.io/klog/v2" "github.com/clusterpedia-io/clusterpedia/cmd/apiserver/app/options" + "github.com/clusterpedia-io/clusterpedia/pkg/constants" "github.com/clusterpedia-io/clusterpedia/pkg/storage" + "github.com/clusterpedia-io/clusterpedia/pkg/utils/trace" "github.com/clusterpedia-io/clusterpedia/pkg/version/verflag" ) @@ -45,6 +48,20 @@ func NewClusterPediaServerCommand(ctx context.Context) *cobra.Command { return err } + if _, exist := os.LookupEnv(constants.OtelAgentAddrENV); exist { + closeTracer, err := trace.InitTracer(ctx) + if err != nil { + klog.Fatalf("failed to initialize tracing: %v", err) + } + defer func() { + err := closeTracer(ctx) + if err != nil { + klog.ErrorS(err, "failed to stop exporter: %v", err) + return + } + }() + } + if err := server.Run(ctx); err != nil { return err } diff --git a/go.mod b/go.mod index 0874997d7..8b6e1005f 100644 --- a/go.mod +++ b/go.mod @@ -17,7 +17,11 @@ require ( github.com/spf13/cobra v1.7.0 github.com/spf13/pflag v1.0.5 github.com/stretchr/testify v1.8.3 + go.opentelemetry.io/otel v1.10.0 + go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.10.0 + go.opentelemetry.io/otel/sdk v1.10.0 go.uber.org/atomic v1.10.0 + google.golang.org/grpc v1.54.0 gopkg.in/natefinch/lumberjack.v2 v2.2.1 gorm.io/datatypes v1.0.7 gorm.io/driver/mysql v1.4.4 @@ -124,12 +128,9 @@ require ( go.etcd.io/etcd/client/v3 v3.5.9 // indirect go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.35.0 // indirect go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.35.1 // indirect - go.opentelemetry.io/otel v1.10.0 // indirect go.opentelemetry.io/otel/exporters/otlp/internal/retry v1.10.0 // indirect go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.10.0 // indirect - go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.10.0 // indirect go.opentelemetry.io/otel/metric v0.31.0 // indirect - go.opentelemetry.io/otel/sdk v1.10.0 // indirect go.opentelemetry.io/otel/trace v1.10.0 // indirect go.opentelemetry.io/proto/otlp v0.19.0 // indirect go.uber.org/multierr v1.11.0 // indirect @@ -149,7 +150,6 @@ require ( google.golang.org/genproto v0.0.0-20230526161137-0005af68ea54 // indirect google.golang.org/genproto/googleapis/api v0.0.0-20230525234035-dd9d682886f9 // indirect google.golang.org/genproto/googleapis/rpc v0.0.0-20230525234030-28d5490b6b19 // indirect - google.golang.org/grpc v1.54.0 // indirect google.golang.org/protobuf v1.30.0 // indirect gopkg.in/inf.v0 v0.9.1 // indirect gopkg.in/yaml.v2 v2.4.0 // indirect diff --git a/pkg/constants/constants.go b/pkg/constants/constants.go new file mode 100644 index 000000000..52b930fba --- /dev/null +++ b/pkg/constants/constants.go @@ -0,0 +1,5 @@ +package constants + +const ( + OtelAgentAddrENV = "OTEL_EXPORTER_OTLP_ENDPOINT" +) diff --git a/pkg/utils/trace/trace.go b/pkg/utils/trace/trace.go new file mode 100644 index 000000000..db274137a --- /dev/null +++ b/pkg/utils/trace/trace.go @@ -0,0 +1,38 @@ +package trace + +import ( + "context" + + "go.opentelemetry.io/otel" + "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc" + "go.opentelemetry.io/otel/propagation" + "go.opentelemetry.io/otel/sdk/resource" + sdktrace "go.opentelemetry.io/otel/sdk/trace" + semconv "go.opentelemetry.io/otel/semconv/v1.7.0" + "google.golang.org/grpc" + "k8s.io/klog/v2" +) + +// InitTracer initializes the trace provider and the otel grpc exporter. +func InitTracer(ctx context.Context) (func(ctx context.Context) error, error) { + traceExporter, err := otlptracegrpc.New(ctx, otlptracegrpc.WithInsecure(), otlptracegrpc.WithDialOption(grpc.WithBlock())) + if err != nil { + return nil, err + } + + tracerProvider := sdktrace.NewTracerProvider( + sdktrace.WithBatcher(traceExporter), + sdktrace.WithSampler(sdktrace.AlwaysSample()), + sdktrace.WithResource(resource.NewWithAttributes(semconv.SchemaURL))) + + otel.SetTracerProvider(tracerProvider) + otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(propagation.TraceContext{}, propagation.Baggage{})) + + return func(ctx context.Context) error { + if err := traceExporter.Shutdown(ctx); err != nil { + klog.V(2).ErrorS(err, "failed to stop exporter") + return err + } + return nil + }, nil +} diff --git a/vendor/github.com/clusterpedia-io/api b/vendor/github.com/clusterpedia-io/api deleted file mode 120000 index 7c9f729c5..000000000 --- a/vendor/github.com/clusterpedia-io/api +++ /dev/null @@ -1 +0,0 @@ -../../../staging/src/github.com/clusterpedia-io/api/ \ No newline at end of file diff --git a/vendor/github.com/clusterpedia-io/api/cluster/v1alpha2/doc.go b/vendor/github.com/clusterpedia-io/api/cluster/v1alpha2/doc.go new file mode 100644 index 000000000..e8b67bb3d --- /dev/null +++ b/vendor/github.com/clusterpedia-io/api/cluster/v1alpha2/doc.go @@ -0,0 +1,6 @@ +// +k8s:deepcopy-gen=package +// +k8s:openapi-gen=true +// +groupName=cluster.clusterpedia.io + +// Package v1alpha2 is the v1alpha2 version of the API +package v1alpha2 diff --git a/vendor/github.com/clusterpedia-io/api/cluster/v1alpha2/register.go b/vendor/github.com/clusterpedia-io/api/cluster/v1alpha2/register.go new file mode 100644 index 000000000..c5498b7d2 --- /dev/null +++ b/vendor/github.com/clusterpedia-io/api/cluster/v1alpha2/register.go @@ -0,0 +1,51 @@ +package v1alpha2 + +import ( + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" +) + +// GroupName specifies the group name used to register the objects. +const GroupName = "cluster.clusterpedia.io" + +// GroupVersion specifies the group and the version used to register the objects. +var GroupVersion = v1.GroupVersion{Group: GroupName, Version: "v1alpha2"} + +// SchemeGroupVersion is group version used to register these objects +// Deprecated: use GroupVersion instead. +var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1alpha2"} + +// Resource takes an unqualified resource and returns a Group qualified GroupResource +func Resource(resource string) schema.GroupResource { + return SchemeGroupVersion.WithResource(resource).GroupResource() +} + +var ( + // localSchemeBuilder and AddToScheme will stay in k8s.io/kubernetes. + SchemeBuilder runtime.SchemeBuilder + localSchemeBuilder = &SchemeBuilder + // Depreciated: use Install instead + AddToScheme = localSchemeBuilder.AddToScheme + Install = localSchemeBuilder.AddToScheme +) + +func init() { + // We only register manually written functions here. The registration of the + // generated functions takes place in the generated files. The separation + // makes the code compile even when the generated files are missing. + localSchemeBuilder.Register(addKnownTypes) +} + +// Adds the list of known types to Scheme. +func addKnownTypes(scheme *runtime.Scheme) error { + scheme.AddKnownTypes(SchemeGroupVersion, + &PediaCluster{}, + &PediaClusterList{}, + &ClusterSyncResources{}, + &ClusterSyncResourcesList{}, + ) + // AddToGroupVersion allows the serialization of client types like ListOptions. + v1.AddToGroupVersion(scheme, SchemeGroupVersion) + return nil +} diff --git a/vendor/github.com/clusterpedia-io/api/cluster/v1alpha2/types.go b/vendor/github.com/clusterpedia-io/api/cluster/v1alpha2/types.go new file mode 100644 index 000000000..fe386dedf --- /dev/null +++ b/vendor/github.com/clusterpedia-io/api/cluster/v1alpha2/types.go @@ -0,0 +1,249 @@ +package v1alpha2 + +import ( + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime/schema" +) + +const ( + ValidatedCondition = "Validated" + SynchroRunningCondition = "SynchroRunning" + ClusterHealthyCondition = "ClusterHealthy" + ReadyCondition = "Ready" + + // deprecated + ClusterSynchroInitializedCondition = "ClusterSynchroInitialized" +) + +const ( + InvalidConfigReason = "InvalidConfig" + InvalidSyncResourcesReason = "InvalidSyncResources" + ValidatedReason = "Validated" + + SynchroWaitInitReason = "WaitInit" + SynchroInitialFailedReason = "InitialFailed" + SynchroPendingReason = "Pending" + SynchroRunningReason = "Running" + SynchroShutdownReason = "Shutdown" + + ClusterMonitorStopReason = "MonitorStop" + ClusterHealthyReason = "Healthy" + ClusterUnhealthyReason = "Unhealthy" + ClusterNotReachableReason = "NotReachable" + + ReadyReason = "Ready" + NotReadyReason = "NotReady" +) + +const ( + ResourceSyncStatusPending = "Pending" + ResourceSyncStatusSyncing = "Syncing" + ResourceSyncStatusStop = "Stop" + ResourceSyncStatusUnknown = "Unknown" + ResourceSyncStatusError = "Error" +) + +// +genclient +// +genclient:nonNamespaced +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +// +k8s:openapi-gen=true +// +kubebuilder:subresource:status +// +kubebuilder:resource:scope="Cluster" +// +kubebuilder:printcolumn:name="Ready",type=string,JSONPath=".status.conditions[?(@.type == 'Ready')].status" +// +kubebuilder:printcolumn:name="Version",type=string,JSONPath=".status.version" +// +kubebuilder:printcolumn:name="APIServer",type=string,JSONPath=".status.apiserver" +// +kubebuilder:printcolumn:name="Validated",type=string,JSONPath=".status.conditions[?(@.type == 'Validated')].reason",priority=10 +// +kubebuilder:printcolumn:name="SynchroRunning",type=string,JSONPath=".status.conditions[?(@.type == 'SynchroRunning')].reason",priority=10 +// +kubebuilder:printcolumn:name="ClusterHealthy",type=string,JSONPath=".status.conditions[?(@.type == 'ClusterHealthy')].reason",priority=10 +type PediaCluster struct { + metav1.TypeMeta `json:",inline"` + metav1.ObjectMeta `json:"metadata,omitempty"` + + // +optional + Spec ClusterSpec `json:"spec,omitempty"` + + // +optional + Status ClusterStatus `json:"status,omitempty"` +} + +type ClusterSpec struct { + // +optional + Kubeconfig []byte `json:"kubeconfig,omitempty"` + + // +optional + APIServer string `json:"apiserver,omitempty"` + + // +optional + TokenData []byte `json:"tokenData,omitempty"` + + // +optional + CAData []byte `json:"caData,omitempty"` + + // +optional + CertData []byte `json:"certData,omitempty"` + + // +optional + KeyData []byte `json:"keyData,omitempty"` + + // +required + SyncResources []ClusterGroupResources `json:"syncResources"` + + // +optional + SyncAllCustomResources bool `json:"syncAllCustomResources,omitempty"` + + // +optional + SyncResourcesRefName string `json:"syncResourcesRefName,omitempty"` +} + +type ClusterGroupResources struct { + Group string `json:"group"` + + // +optional + Versions []string `json:"versions,omitempty"` + + // +required + // +kubebuilder:validation:Required + // +kubebuilder:validation:MinItems=1 + Resources []string `json:"resources"` +} + +type ClusterStatus struct { + // +optional + APIServer string `json:"apiserver,omitempty"` + + // +optional + Version string `json:"version,omitempty"` + + // +optional + Conditions []metav1.Condition `json:"conditions,omitempty"` + + // +optional + SyncResources []ClusterGroupResourcesStatus `json:"syncResources,omitempty"` +} + +type ClusterGroupResourcesStatus struct { + // +required + // +kubebuilder:validation:Required + Group string `json:"group"` + + // +required + // +kubebuilder:validation:Required + Resources []ClusterResourceStatus `json:"resources"` +} + +type ClusterResourceStatus struct { + // +required + // +kubebuilder:validation:Required + Name string `json:"name"` + + // +required + // +kubebuilder:validation:Required + Kind string `json:"kind"` + + // +required + // +kubebuilder:validation:Required + Namespaced bool `json:"namespaced"` + + // +required + // +kubebuilder:validation:Required + SyncConditions []ClusterResourceSyncCondition `json:"syncConditions"` +} + +type ClusterResourceSyncCondition struct { + // +required + // +kubebuilder:validation:Required + Version string `json:"version"` + + // optional + SyncVersion string `json:"syncVersion,omitempty"` + + // optional + SyncResource string `json:"syncResource,omitempty"` + + // optional + StorageVersion string `json:"storageVersion,omitempty"` + + // optional + StorageResource string `json:"storageResource,omitempty"` + + // +required + // +kubebuilder:validation:Required + Status string `json:"status"` + + // optional + Reason string `json:"reason,omitempty"` + + // optional + Message string `json:"message,omitempty"` + + // +required + // +kubebuilder:validation:Required + // +kubebuilder:validation:Type=string + // +kubebuilder:validation:Format=date-time + LastTransitionTime metav1.Time `json:"lastTransitionTime"` +} + +func (cond ClusterResourceSyncCondition) SyncGVR(resource schema.GroupResource) schema.GroupVersionResource { + if cond.Version == "" || cond.SyncVersion == "" { + return schema.GroupVersionResource{} + } + + if cond.SyncResource != "" { + resource = schema.ParseGroupResource(cond.SyncResource) + } + if cond.SyncVersion != "" { + return resource.WithVersion(cond.StorageVersion) + } + return resource.WithVersion(cond.Version) +} + +func (cond ClusterResourceSyncCondition) StorageGVR(resource schema.GroupResource) schema.GroupVersionResource { + if cond.Version == "" || cond.StorageVersion == "" { + return schema.GroupVersionResource{} + } + + if cond.StorageResource != "" { + return schema.ParseGroupResource(cond.StorageResource).WithVersion(cond.StorageVersion) + } + return resource.WithVersion(cond.StorageVersion) +} + +// +kubebuilder:object:root=true +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +type PediaClusterList struct { + metav1.TypeMeta `json:",inline"` + + // +optional + metav1.ListMeta `json:"metadata,omitempty"` + + Items []PediaCluster `json:"items"` +} + +// +genclient +// +genclient:nonNamespaced +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +// +kubebuilder:resource:scope="Cluster" +type ClusterSyncResources struct { + metav1.TypeMeta `json:",inline"` + metav1.ObjectMeta `json:"metadata,omitempty"` + + // +optional + Spec ClusterSyncResourcesSpec `json:"spec,omitempty"` +} + +type ClusterSyncResourcesSpec struct { + // +required + SyncResources []ClusterGroupResources `json:"syncResources"` +} + +// +kubebuilder:object:root=true +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +type ClusterSyncResourcesList struct { + metav1.TypeMeta `json:",inline"` + + // +optional + metav1.ListMeta `json:"metadata,omitempty"` + + Items []ClusterSyncResources `json:"items"` +} diff --git a/vendor/github.com/clusterpedia-io/api/cluster/v1alpha2/zz_generated.deepcopy.go b/vendor/github.com/clusterpedia-io/api/cluster/v1alpha2/zz_generated.deepcopy.go new file mode 100644 index 000000000..b2183dbca --- /dev/null +++ b/vendor/github.com/clusterpedia-io/api/cluster/v1alpha2/zz_generated.deepcopy.go @@ -0,0 +1,322 @@ +//go:build !ignore_autogenerated +// +build !ignore_autogenerated + +// Code generated by deepcopy-gen. DO NOT EDIT. + +package v1alpha2 + +import ( + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" +) + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ClusterGroupResources) DeepCopyInto(out *ClusterGroupResources) { + *out = *in + if in.Versions != nil { + in, out := &in.Versions, &out.Versions + *out = make([]string, len(*in)) + copy(*out, *in) + } + if in.Resources != nil { + in, out := &in.Resources, &out.Resources + *out = make([]string, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterGroupResources. +func (in *ClusterGroupResources) DeepCopy() *ClusterGroupResources { + if in == nil { + return nil + } + out := new(ClusterGroupResources) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ClusterGroupResourcesStatus) DeepCopyInto(out *ClusterGroupResourcesStatus) { + *out = *in + if in.Resources != nil { + in, out := &in.Resources, &out.Resources + *out = make([]ClusterResourceStatus, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterGroupResourcesStatus. +func (in *ClusterGroupResourcesStatus) DeepCopy() *ClusterGroupResourcesStatus { + if in == nil { + return nil + } + out := new(ClusterGroupResourcesStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ClusterResourceStatus) DeepCopyInto(out *ClusterResourceStatus) { + *out = *in + if in.SyncConditions != nil { + in, out := &in.SyncConditions, &out.SyncConditions + *out = make([]ClusterResourceSyncCondition, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterResourceStatus. +func (in *ClusterResourceStatus) DeepCopy() *ClusterResourceStatus { + if in == nil { + return nil + } + out := new(ClusterResourceStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ClusterResourceSyncCondition) DeepCopyInto(out *ClusterResourceSyncCondition) { + *out = *in + in.LastTransitionTime.DeepCopyInto(&out.LastTransitionTime) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterResourceSyncCondition. +func (in *ClusterResourceSyncCondition) DeepCopy() *ClusterResourceSyncCondition { + if in == nil { + return nil + } + out := new(ClusterResourceSyncCondition) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ClusterSpec) DeepCopyInto(out *ClusterSpec) { + *out = *in + if in.Kubeconfig != nil { + in, out := &in.Kubeconfig, &out.Kubeconfig + *out = make([]byte, len(*in)) + copy(*out, *in) + } + if in.TokenData != nil { + in, out := &in.TokenData, &out.TokenData + *out = make([]byte, len(*in)) + copy(*out, *in) + } + if in.CAData != nil { + in, out := &in.CAData, &out.CAData + *out = make([]byte, len(*in)) + copy(*out, *in) + } + if in.CertData != nil { + in, out := &in.CertData, &out.CertData + *out = make([]byte, len(*in)) + copy(*out, *in) + } + if in.KeyData != nil { + in, out := &in.KeyData, &out.KeyData + *out = make([]byte, len(*in)) + copy(*out, *in) + } + if in.SyncResources != nil { + in, out := &in.SyncResources, &out.SyncResources + *out = make([]ClusterGroupResources, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterSpec. +func (in *ClusterSpec) DeepCopy() *ClusterSpec { + if in == nil { + return nil + } + out := new(ClusterSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ClusterStatus) DeepCopyInto(out *ClusterStatus) { + *out = *in + if in.Conditions != nil { + in, out := &in.Conditions, &out.Conditions + *out = make([]v1.Condition, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.SyncResources != nil { + in, out := &in.SyncResources, &out.SyncResources + *out = make([]ClusterGroupResourcesStatus, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterStatus. +func (in *ClusterStatus) DeepCopy() *ClusterStatus { + if in == nil { + return nil + } + out := new(ClusterStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ClusterSyncResources) DeepCopyInto(out *ClusterSyncResources) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterSyncResources. +func (in *ClusterSyncResources) DeepCopy() *ClusterSyncResources { + if in == nil { + return nil + } + out := new(ClusterSyncResources) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *ClusterSyncResources) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ClusterSyncResourcesList) DeepCopyInto(out *ClusterSyncResourcesList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]ClusterSyncResources, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterSyncResourcesList. +func (in *ClusterSyncResourcesList) DeepCopy() *ClusterSyncResourcesList { + if in == nil { + return nil + } + out := new(ClusterSyncResourcesList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *ClusterSyncResourcesList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ClusterSyncResourcesSpec) DeepCopyInto(out *ClusterSyncResourcesSpec) { + *out = *in + if in.SyncResources != nil { + in, out := &in.SyncResources, &out.SyncResources + *out = make([]ClusterGroupResources, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterSyncResourcesSpec. +func (in *ClusterSyncResourcesSpec) DeepCopy() *ClusterSyncResourcesSpec { + if in == nil { + return nil + } + out := new(ClusterSyncResourcesSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *PediaCluster) DeepCopyInto(out *PediaCluster) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) + in.Status.DeepCopyInto(&out.Status) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PediaCluster. +func (in *PediaCluster) DeepCopy() *PediaCluster { + if in == nil { + return nil + } + out := new(PediaCluster) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *PediaCluster) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *PediaClusterList) DeepCopyInto(out *PediaClusterList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]PediaCluster, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PediaClusterList. +func (in *PediaClusterList) DeepCopy() *PediaClusterList { + if in == nil { + return nil + } + out := new(PediaClusterList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *PediaClusterList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} diff --git a/vendor/github.com/clusterpedia-io/api/clusterpedia/doc.go b/vendor/github.com/clusterpedia-io/api/clusterpedia/doc.go new file mode 100644 index 000000000..eb37a35a2 --- /dev/null +++ b/vendor/github.com/clusterpedia-io/api/clusterpedia/doc.go @@ -0,0 +1,4 @@ +// +k8s:deepcopy-gen=package +// +k8s:openapi-gen=true +// +groupName=clusterpedia.io +package clusterpedia diff --git a/vendor/github.com/clusterpedia-io/api/clusterpedia/fields/lexer.go b/vendor/github.com/clusterpedia-io/api/clusterpedia/fields/lexer.go new file mode 100644 index 000000000..ae85694ca --- /dev/null +++ b/vendor/github.com/clusterpedia-io/api/clusterpedia/fields/lexer.go @@ -0,0 +1,150 @@ +/* + Copy from + https://github.com/kubernetes/kubernetes/blob/f5be5052e3d0808abb904aebd3218fe4a5c2dd82/staging/src/k8s.io/apimachinery/pkg/labels/selector.go#L452-L588 +*/ + +package fields + +import ( + "fmt" + + "k8s.io/apimachinery/pkg/labels" +) + +// string2token contains the mapping between lexer Token and token literal +// (except IdentifierToken, EndOfStringToken and ErrorToken since it makes no sense) +var string2token = map[string]labels.Token{ + ")": labels.ClosedParToken, + ",": labels.CommaToken, + "!": labels.DoesNotExistToken, + "==": labels.DoubleEqualsToken, + "=": labels.EqualsToken, + ">": labels.GreaterThanToken, + "in": labels.InToken, + "<": labels.LessThanToken, + "!=": labels.NotEqualsToken, + "notin": labels.NotInToken, + "(": labels.OpenParToken, +} + +// ScannedItem contains the Token and the literal produced by the lexer. +type ScannedItem struct { + tok labels.Token + literal string +} + +// isWhitespace returns true if the rune is a space, tab, or newline. +func isWhitespace(ch byte) bool { + return ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n' +} + +// isSpecialSymbol detects if the character ch can be an operator +func isSpecialSymbol(ch byte) bool { + switch ch { + case '=', '!', '(', ')', ',', '>', '<': + return true + } + return false +} + +// Lexer represents the Lexer struct for label selector. +// It contains necessary informationt to tokenize the input string +type Lexer struct { + // s stores the string to be tokenized + s string + // pos is the position currently tokenized + pos int +} + +// read returns the character currently lexed +// increment the position and check the buffer overflow +func (l *Lexer) read() (b byte) { + b = 0 + if l.pos < len(l.s) { + b = l.s[l.pos] + l.pos++ + } + return b +} + +// unread 'undoes' the last read character +func (l *Lexer) unread() { + l.pos-- +} + +// scanIDOrKeyword scans string to recognize literal token (for example 'in') or an identifier. +func (l *Lexer) scanIDOrKeyword() (tok labels.Token, lit string) { + var buffer []byte +IdentifierLoop: + for { + switch ch := l.read(); { + case ch == 0: + break IdentifierLoop + case isSpecialSymbol(ch) || isWhitespace(ch): + l.unread() + break IdentifierLoop + default: + buffer = append(buffer, ch) + } + } + s := string(buffer) + if val, ok := string2token[s]; ok { // is a literal token? + return val, s + } + return labels.IdentifierToken, s // otherwise is an identifier +} + +// scanSpecialSymbol scans string starting with special symbol. +// special symbol identify non literal operators. "!=", "==", "=" +func (l *Lexer) scanSpecialSymbol() (labels.Token, string) { + lastScannedItem := ScannedItem{} + var buffer []byte +SpecialSymbolLoop: + for { + switch ch := l.read(); { + case ch == 0: + break SpecialSymbolLoop + case isSpecialSymbol(ch): + buffer = append(buffer, ch) + if token, ok := string2token[string(buffer)]; ok { + lastScannedItem = ScannedItem{tok: token, literal: string(buffer)} + } else if lastScannedItem.tok != 0 { + l.unread() + break SpecialSymbolLoop + } + default: + l.unread() + break SpecialSymbolLoop + } + } + if lastScannedItem.tok == 0 { + return labels.ErrorToken, fmt.Sprintf("error expected: keyword found '%s'", buffer) + } + return lastScannedItem.tok, lastScannedItem.literal +} + +// skipWhiteSpaces consumes all blank characters +// returning the first non blank character +func (l *Lexer) skipWhiteSpaces(ch byte) byte { + for { + if !isWhitespace(ch) { + return ch + } + ch = l.read() + } +} + +// Lex returns a pair of Token and the literal +// literal is meaningfull only for IdentifierToken token +func (l *Lexer) Lex() (tok labels.Token, lit string) { + switch ch := l.skipWhiteSpaces(l.read()); { + case ch == 0: + return labels.EndOfStringToken, "" + case isSpecialSymbol(ch): + l.unread() + return l.scanSpecialSymbol() + default: + l.unread() + return l.scanIDOrKeyword() + } +} diff --git a/vendor/github.com/clusterpedia-io/api/clusterpedia/fields/parser.go b/vendor/github.com/clusterpedia-io/api/clusterpedia/fields/parser.go new file mode 100644 index 000000000..9a4ca004e --- /dev/null +++ b/vendor/github.com/clusterpedia-io/api/clusterpedia/fields/parser.go @@ -0,0 +1,270 @@ +/* + Reference from + https://github.com/kubernetes/kubernetes/blob/f5be5052e3d0808abb904aebd3218fe4a5c2dd82/staging/src/k8s.io/apimachinery/pkg/labels/selector.go#L590 + +*/ + +package fields + +import ( + "fmt" + "sort" + "strings" + + "k8s.io/apimachinery/pkg/labels" + "k8s.io/apimachinery/pkg/selection" + "k8s.io/apimachinery/pkg/util/sets" +) + +var ( + unaryOperators = []string{ + string(selection.Exists), string(selection.DoesNotExist), + } + binaryOperators = []string{ + string(selection.In), string(selection.NotIn), + string(selection.Equals), string(selection.DoubleEquals), string(selection.NotEquals), + string(selection.GreaterThan), string(selection.LessThan), + } + validRequirementOperators = append(binaryOperators, unaryOperators...) +) + +type Parser struct { + l *Lexer + scannedItems []ScannedItem + position int +} + +// ParserContext represents context during parsing: +// some literal for example 'in' and 'notin' can be +// recognized as operator for example 'x in (a)' but +// it can be recognized as value for example 'value in (in)' +type ParserContext int + +const ( + // KeyAndOperator represents key and operator + KeyAndOperator ParserContext = iota + // Values represents values + Values +) + +func (p *Parser) lookahead(context ParserContext) (labels.Token, string) { + tok, lit := p.scannedItems[p.position].tok, p.scannedItems[p.position].literal + if context == Values { + switch tok { + case labels.InToken, labels.NotInToken: + tok = labels.IdentifierToken + } + } + return tok, lit +} + +func (p *Parser) consume(context ParserContext) (labels.Token, string) { + p.position++ + tok, lit := p.scannedItems[p.position-1].tok, p.scannedItems[p.position-1].literal + if context == Values { + switch tok { + case labels.InToken, labels.NotInToken: + tok = labels.IdentifierToken + } + } + return tok, lit +} + +func (p *Parser) scan() { + for { + token, literal := p.l.Lex() + p.scannedItems = append(p.scannedItems, ScannedItem{token, literal}) + if token == labels.EndOfStringToken { + break + } + } +} + +func (p *Parser) parse() ([]Requirement, error) { + p.scan() + + var requirements []Requirement + for { + tok, lit := p.lookahead(Values) + switch tok { + case labels.IdentifierToken, labels.DoesNotExistToken: + r, err := p.parseRequirement() + if err != nil { + return nil, fmt.Errorf("unable to parse requirement: %v", err) + } + requirements = append(requirements, *r) + t, l := p.consume(Values) + switch t { + case labels.EndOfStringToken: + return requirements, nil + case labels.CommaToken: + t2, l2 := p.lookahead(Values) + if t2 != labels.IdentifierToken && t2 != labels.DoesNotExistToken { + return nil, fmt.Errorf("found %q, expected: identifier after ','", l2) + } + default: + return nil, fmt.Errorf("found %q, expected: ',' or 'end of string'", l) + } + case labels.EndOfStringToken: + return requirements, nil + default: + return nil, fmt.Errorf("found %q, expected: !, identifier, or ''end of string", lit) + } + } +} + +func (p *Parser) parseRequirement() (*Requirement, error) { + key, operator, err := p.parseKeyAndInferOperator() + if err != nil { + return nil, err + } + if operator == selection.Exists || operator == selection.DoesNotExist { + return NewRequirement(key, operator, []string{}) + } + + operator, err = p.parseOperator() + if err != nil { + return nil, err + } + + var values sets.String + switch operator { + case selection.In, selection.NotIn: + values, err = p.parseValues() + case selection.Equals, selection.DoubleEquals, selection.NotEquals, selection.GreaterThan, selection.LessThan: + values, err = p.parseExactValue() + } + if err != nil { + return nil, err + } + return NewRequirement(key, operator, values.List()) +} + +func (p *Parser) parseKeyAndInferOperator() (string, selection.Operator, error) { + var operator selection.Operator + tok, literal := p.consume(Values) + if tok == labels.DoesNotExistToken { + operator = selection.DoesNotExist + tok, literal = p.consume(Values) + } + if tok != labels.IdentifierToken { + return "", "", fmt.Errorf("found %q, expected: identifier", literal) + } + + if t, _ := p.lookahead(Values); t == labels.EndOfStringToken || t == labels.CommaToken { + if operator != selection.DoesNotExist { + operator = selection.Exists + } + } + return literal, operator, nil +} + +func (p *Parser) parseOperator() (op selection.Operator, err error) { + tok, lit := p.consume(KeyAndOperator) + switch tok { + // DoesNotExistToken shouldn't be here because it's a unary operator, not a binary operator + case labels.InToken: + op = selection.In + case labels.EqualsToken: + op = selection.Equals + case labels.DoubleEqualsToken: + op = selection.DoubleEquals + case labels.GreaterThanToken: + op = selection.GreaterThan + case labels.LessThanToken: + op = selection.LessThan + case labels.NotInToken: + op = selection.NotIn + case labels.NotEqualsToken: + op = selection.NotEquals + default: + return "", fmt.Errorf("found '%s', expected: %v", lit, strings.Join(binaryOperators, ", ")) + } + return op, nil +} + +func (p *Parser) parseValues() (sets.String, error) { + tok, lit := p.consume(Values) + if tok != labels.OpenParToken { + return nil, fmt.Errorf("found %q, expcted:'('", lit) + } + + tok, lit = p.lookahead(Values) + switch tok { + case labels.IdentifierToken, labels.CommaToken: + s, err := p.parseIdentifiersList() + if err != nil { + return s, err + } + if tok, _ = p.consume(Values); tok != labels.ClosedParToken { + return nil, fmt.Errorf("found '%s', expectedd: ')'", lit) + } + return s, nil + case labels.ClosedParToken: + p.consume(Values) + return sets.NewString(""), nil + default: + return nil, fmt.Errorf("found %q, expected: ',', ')' or identifier", lit) + } +} + +func (p *Parser) parseIdentifiersList() (sets.String, error) { + s := sets.NewString() + for { + tok, lit := p.consume(Values) + switch tok { + case labels.IdentifierToken: + s.Insert(lit) + tok2, lit2 := p.lookahead(Values) + switch tok2 { + case labels.CommaToken: + continue + case labels.ClosedParToken: + return s, nil + default: + return nil, fmt.Errorf("found %q, expected: ',' or ')'", lit2) + } + case labels.CommaToken: + if s.Len() == 0 { + s.Insert("") // to handle '(,' + } + tok2, _ := p.lookahead(Values) + if tok2 == labels.ClosedParToken { + s.Insert("") // to handle ',)' Double "" removed by StringSet + return s, nil + } + if tok2 == labels.CommaToken { + p.consume(Values) + s.Insert("") // to handle ,, Double "" removed by StringSet + } + default: + return s, fmt.Errorf("found %q, expected: ',',or identifier", lit) + } + } +} + +func (p *Parser) parseExactValue() (sets.String, error) { + s := sets.NewString() + tok, _ := p.lookahead(Values) + if tok == labels.EndOfStringToken || tok == labels.CommaToken { + s.Insert("") + return s, nil + } + tok, lit := p.consume(Values) + if tok != labels.IdentifierToken { + return nil, fmt.Errorf("found %q, expected: identifier", lit) + } + s.Insert(lit) + return s, nil +} + +// safeSort sorts input strings without modification +func safeSort(in []string) []string { + if sort.StringsAreSorted(in) { + return in + } + out := make([]string, len(in)) + copy(out, in) + sort.Strings(out) + return out +} diff --git a/vendor/github.com/clusterpedia-io/api/clusterpedia/fields/selector.go b/vendor/github.com/clusterpedia-io/api/clusterpedia/fields/selector.go new file mode 100644 index 000000000..eb0f1917d --- /dev/null +++ b/vendor/github.com/clusterpedia-io/api/clusterpedia/fields/selector.go @@ -0,0 +1,363 @@ +package fields + +import ( + "errors" + "fmt" + "sort" + "strconv" + "strings" + + "k8s.io/apimachinery/pkg/selection" + "k8s.io/apimachinery/pkg/util/sets" + "k8s.io/apimachinery/pkg/util/validation" + "k8s.io/apimachinery/pkg/util/validation/field" +) + +type Requirements []Requirement + +// Selector represents a label selector +type Selector interface { + Empty() bool + + String() string + + // Add adds requirements to the Selector + Add(r ...Requirement) Selector + + Requirements() (requirements Requirements, selectable bool) + + // Make a deep copy of the selector. + DeepCopySelector() Selector +} + +type internalSelector []Requirement + +func (s internalSelector) Empty() bool { return len(s) == 0 } + +func (s internalSelector) Requirements() (Requirements, bool) { return Requirements(s), true } + +func (s internalSelector) DeepCopy() internalSelector { + if s == nil { + return nil + } + + // The `field.Path` struct is included in the `Field`, + // so DeepCopy becomes more complicated, and using `Parse` + // simplifies the logic. + result, _ := Parse(s.String()) + return result.(internalSelector) +} + +func (s internalSelector) DeepCopySelector() Selector { + return s.DeepCopy() +} + +func (s internalSelector) Add(reqs ...Requirement) Selector { + ret := make(internalSelector, 0, len(s)+len(reqs)) + ret = append(ret, s...) + ret = append(ret, reqs...) + sort.Sort(ByKey(ret)) + return ret +} + +func (s internalSelector) String() string { + var reqs []string + for ix := range s { + reqs = append(reqs, s[ix].String()) + } + return strings.Join(reqs, ",") +} + +// ByKey sorts requirements by key to obtain deterministic parser +type ByKey []Requirement + +func (rs ByKey) Len() int { return len(rs) } + +func (rs ByKey) Swap(i, j int) { rs[i], rs[j] = rs[j], rs[i] } + +func (rs ByKey) Less(i, j int) bool { return rs[i].key < rs[j].key } + +type Requirement struct { + key string + + fields []Field + operator selection.Operator + strValues []string +} + +func NewRequirement(key string, op selection.Operator, vals []string) (*Requirement, error) { + fields, err := parseFields(key, nil) + if err != nil { + return nil, err + } + if len(fields) == 0 { + return nil, errors.New("fields is empty") + } + + var allErrs field.ErrorList + for _, field := range fields { + if err := field.Validate(); err != nil { + allErrs = append(allErrs, err) + } + } + + lastField := fields[len(fields)-1] + path := lastField.Path() + if lastField.IsList() { + allErrs = append(allErrs, field.Invalid(path, lastField.Name(), "last field could not be list")) + } + + valuePath := path.Child("values") + switch op { + case selection.In, selection.NotIn: + if len(vals) == 0 { + allErrs = append(allErrs, field.Invalid(valuePath, vals, "for 'in', 'notin' operators, values set can't be empty")) + } + case selection.Equals, selection.DoubleEquals, selection.NotEquals: + if len(vals) != 1 { + allErrs = append(allErrs, field.Invalid(valuePath, vals, "exact-match compatibility requires one single value")) + } + case selection.Exists, selection.DoesNotExist: + if len(vals) != 0 { + allErrs = append(allErrs, field.Invalid(valuePath, vals, "values set must be empty for exists and does not exist")) + } + case selection.GreaterThan, selection.LessThan: + if len(vals) != 1 { + allErrs = append(allErrs, field.Invalid(valuePath, vals, "for 'Gt', 'Lt' operators, exactly one value is required")) + } + for i := range vals { + if _, err := strconv.ParseInt(vals[i], 10, 64); err != nil { + allErrs = append(allErrs, field.Invalid(valuePath.Index(i), vals[i], "for 'Gt', 'Lt' operators, the value must be an integer")) + } + } + default: + allErrs = append(allErrs, field.NotSupported(path.Child("operator"), op, validRequirementOperators)) + } + + // values not validate + + return &Requirement{key: key, fields: fields, operator: op, strValues: vals}, allErrs.ToAggregate() +} + +func (r *Requirement) Fields() []Field { + fields := make([]Field, len(r.fields)) + copy(fields, r.fields) + return fields +} + +func (r *Requirement) Operator() selection.Operator { + return r.operator +} + +func (r *Requirement) Values() sets.String { + ret := sets.String{} + for i := range r.strValues { + ret.Insert(r.strValues[i]) + } + return ret +} + +func (r *Requirement) String() string { + var sb strings.Builder + sb.Grow( + // length of r.key + len(r.key) + + // length of 'r.operator' + 2 spaces for the worst case ('in' and 'notin') + len(r.operator) + 2 + + // length of 'r.strValues' slice times. Heuristically 5 chars per word + +5*len(r.strValues)) + if r.operator == selection.DoesNotExist { + sb.WriteString("!") + } + sb.WriteString(r.key) + + switch r.operator { + case selection.Equals: + sb.WriteString("=") + case selection.DoubleEquals: + sb.WriteString("==") + case selection.NotEquals: + sb.WriteString("!=") + case selection.In: + sb.WriteString(" in ") + case selection.NotIn: + sb.WriteString(" notin ") + case selection.GreaterThan: + sb.WriteString(">") + case selection.LessThan: + sb.WriteString("<") + case selection.Exists, selection.DoesNotExist: + return sb.String() + } + + switch r.operator { + case selection.In, selection.NotIn: + sb.WriteString("(") + } + if len(r.strValues) == 1 { + sb.WriteString(r.strValues[0]) + } else { // only > 1 since == 0 prohibited by NewRequirement + // normalizes value order on output, without mutating the in-memory selector representation + // also avoids normalization when it is not required, and ensures we do not mutate shared data + sb.WriteString(strings.Join(safeSort(r.strValues), ",")) + } + + switch r.operator { + case selection.In, selection.NotIn: + sb.WriteString(")") + } + return sb.String() +} + +type Field struct { + path *field.Path + + name string + isList bool + index int +} + +func NewField(parentPath *field.Path, name string) Field { + var path *field.Path + if parentPath == nil { + path = field.NewPath(name) + } else { + path = parentPath.Child(name) + } + + return Field{path: path, name: name} +} + +func (f *Field) setListIndex(index int) { + f.path = f.path.Index(index) + f.isList = true + f.index = index +} + +func (f *Field) Name() string { + return f.name +} + +func (f *Field) IsList() bool { + return f.isList +} + +func (f *Field) GetListIndex() (int, bool) { + return f.index, f.isList +} + +func (f *Field) Path() *field.Path { + return f.path +} + +func (f *Field) Validate() *field.Error { + if errs := validation.IsQualifiedName(f.name); len(errs) != 0 { + return field.Invalid(f.path, f.name, strings.Join(errs, "; ")) + } + return nil +} + +func parseFields(key string, fields []Field) ([]Field, error) { + if len(key) == 0 { + return fields, nil + } + + if key[0] == '.' { + if len(key) == 1 { + return nil, errors.New("empty field after '.'") + } + + key = key[1:] + } + + var parentPath *field.Path + if len(fields) != 0 { + parentPath = fields[len(fields)-1].Path() + } + + if key[0] == '[' { + rightIndex := strings.IndexByte(key, ']') + switch { + case rightIndex == -1: + return nil, errors.New("not found ']'") + + // handle 'field[]' + case rightIndex == 1: + if len(fields) == 0 { + return nil, errors.New("empty [], not found list field") + } + fields[len(fields)-1].isList = true + + // handle `lastfield['field']` + case key[1] == '\'' || key[1] == '"': + inSquKey := key[1:rightIndex] + + wrap, inSquKey := inSquKey[0], inSquKey[1:] + rightSquIndex := strings.IndexByte(inSquKey, wrap) + switch rightSquIndex { + case -1: + return nil, fmt.Errorf("not found right '%c'", wrap) + case 1: + return nil, fmt.Errorf("empty field %c%c", wrap, wrap) + case len(inSquKey) - 1: + fields = append(fields, NewField(parentPath, inSquKey[0:rightSquIndex])) + default: + return nil, fmt.Errorf("invalid field ['%s]", inSquKey) + } + + // handle 'field[0]' + default: + if len(fields) == 0 { + return nil, errors.New("[], not found list field") + } + lastField := &fields[len(fields)-1] + + indexStr := key[1:rightIndex] + index, err := strconv.Atoi(indexStr) + if err != nil { + return nil, fmt.Errorf("%s[] list index invalid. if %s is a field, please use ['%s'] or .'%s'", lastField.Path(), indexStr, indexStr, indexStr) + } + + lastField.setListIndex(index) + } + return parseFields(key[rightIndex+1:], fields) + } + + if key[0] == '\'' || key[0] == '"' { + wrap := key[0] + if len(key) == 1 { + return nil, fmt.Errorf("not found right '%c'", wrap) + } + + key = key[1:] + rightIndex := strings.IndexByte(key, wrap) + if rightIndex == -1 { + return nil, fmt.Errorf("not found right '%c'", wrap) + } + if rightIndex == 1 { + return nil, fmt.Errorf("empty field %c%c", wrap, wrap) + } + + fields = append(fields, NewField(parentPath, key[0:rightIndex])) + return parseFields(key[rightIndex+1:], fields) + } + + rightIndex := strings.IndexAny(key, ".[") + if rightIndex == -1 { + fields = append(fields, NewField(parentPath, key)) + return fields, nil + } + + fields = append(fields, NewField(parentPath, key[:rightIndex])) + return parseFields(key[rightIndex:], fields) +} + +func Parse(selector string) (Selector, error) { + p := &Parser{l: &Lexer{s: selector, pos: 0}} + items, err := p.parse() + if err != nil { + return nil, err + } + sort.Sort(ByKey(items)) + return internalSelector(items), nil +} diff --git a/vendor/github.com/clusterpedia-io/api/clusterpedia/install/install.go b/vendor/github.com/clusterpedia-io/api/clusterpedia/install/install.go new file mode 100644 index 000000000..3984e87a1 --- /dev/null +++ b/vendor/github.com/clusterpedia-io/api/clusterpedia/install/install.go @@ -0,0 +1,14 @@ +package install + +import ( + internal "github.com/clusterpedia-io/api/clusterpedia" + "github.com/clusterpedia-io/api/clusterpedia/v1beta1" + "k8s.io/apimachinery/pkg/runtime" + utilruntime "k8s.io/apimachinery/pkg/util/runtime" +) + +func Install(scheme *runtime.Scheme) { + utilruntime.Must(internal.Install(scheme)) + utilruntime.Must(v1beta1.Install(scheme)) + utilruntime.Must(scheme.SetVersionPriority(v1beta1.SchemeGroupVersion)) +} diff --git a/vendor/github.com/clusterpedia-io/api/clusterpedia/register.go b/vendor/github.com/clusterpedia-io/api/clusterpedia/register.go new file mode 100644 index 000000000..13e793085 --- /dev/null +++ b/vendor/github.com/clusterpedia-io/api/clusterpedia/register.go @@ -0,0 +1,29 @@ +package clusterpedia + +import ( + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" +) + +const GroupName = "clusterpedia.io" + +var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal} + +var ( + SchemeBuilder runtime.SchemeBuilder + localSchemeBuilder = &SchemeBuilder + Install = localSchemeBuilder.AddToScheme +) + +func init() { + localSchemeBuilder.Register(addKnownTypes) +} + +func addKnownTypes(scheme *runtime.Scheme) error { + scheme.AddKnownTypes(SchemeGroupVersion, + &ListOptions{}, + &CollectionResource{}, + &CollectionResourceList{}, + ) + return nil +} diff --git a/vendor/github.com/clusterpedia-io/api/clusterpedia/scheme/register.go b/vendor/github.com/clusterpedia-io/api/clusterpedia/scheme/register.go new file mode 100644 index 000000000..10b8254cb --- /dev/null +++ b/vendor/github.com/clusterpedia-io/api/clusterpedia/scheme/register.go @@ -0,0 +1,17 @@ +package scheme + +import ( + "github.com/clusterpedia-io/api/clusterpedia/install" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/serializer" +) + +var scheme = runtime.NewScheme() + +var Codecs = serializer.NewCodecFactory(scheme) + +var ParameterCodec = runtime.NewParameterCodec(scheme) + +func init() { + install.Install(scheme) +} diff --git a/vendor/github.com/clusterpedia-io/api/clusterpedia/types.go b/vendor/github.com/clusterpedia-io/api/clusterpedia/types.go new file mode 100644 index 000000000..35ed197c6 --- /dev/null +++ b/vendor/github.com/clusterpedia-io/api/clusterpedia/types.go @@ -0,0 +1,111 @@ +package clusterpedia + +import ( + "net/url" + + metainternal "k8s.io/apimachinery/pkg/apis/meta/internalversion" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + + "github.com/clusterpedia-io/api/clusterpedia/fields" +) + +const ( + SearchLabelNames = "search.clusterpedia.io/names" + SearchLabelClusters = "search.clusterpedia.io/clusters" + SearchLabelNamespaces = "search.clusterpedia.io/namespaces" + SearchLabelOrderBy = "search.clusterpedia.io/orderby" + + SearchLabelOwnerUID = "search.clusterpedia.io/owner-uid" + SearchLabelOwnerName = "search.clusterpedia.io/owner-name" + SearchLabelOwnerGroupResource = "search.clusterpedia.io/owner-gr" + SearchLabelOwnerSeniority = "search.clusterpedia.io/owner-seniority" + + SearchLabelWithContinue = "search.clusterpedia.io/with-continue" + SearchLabelWithRemainingCount = "search.clusterpedia.io/with-remaining-count" + + SearchLabelLimit = "search.clusterpedia.io/limit" + SearchLabelOffset = "search.clusterpedia.io/offset" + + SearchLabelSince = "search.clusterpedia.io/since" + SearchLabelBefore = "search.clusterpedia.io/before" + + ShadowAnnotationClusterName = "shadow.clusterpedia.io/cluster-name" + ShadowAnnotationGroupVersionResource = "shadow.clusterpedia.io/gvr" +) + +type OrderBy struct { + Field string + Desc bool +} + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +// +k8s:openapi-gen=true +type ListOptions struct { + metainternal.ListOptions + + Names []string + ClusterNames []string + Namespaces []string + OrderBy []OrderBy + + OwnerName string + OwnerUID string + OwnerGroupResource schema.GroupResource + OwnerSeniority int + + Since *metav1.Time + Before *metav1.Time + + WithContinue *bool + WithRemainingCount *bool + + // +k8s:conversion-fn:drop + EnhancedFieldSelector fields.Selector + + // +k8s:conversion-fn:drop + ExtraLabelSelector labels.Selector + + // +k8s:conversion-fn:drop + URLQuery url.Values + + // RelatedResources []schema.GroupVersionKind + + OnlyMetadata bool +} + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +type CollectionResource struct { + metav1.TypeMeta + metav1.ObjectMeta + + ResourceTypes []CollectionResourceType + Items []runtime.Object + + Continue string + RemainingItemCount *int64 +} + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +type CollectionResourceList struct { + metav1.TypeMeta + metav1.ListMeta + + Items []CollectionResource +} + +type CollectionResourceType struct { + Group string + Version string + Kind string + Resource string +} + +func (t CollectionResourceType) GroupResource() schema.GroupResource { + return schema.GroupResource{ + Group: t.Group, + Resource: t.Resource, + } +} diff --git a/vendor/github.com/clusterpedia-io/api/clusterpedia/v1beta1/conversion.go b/vendor/github.com/clusterpedia-io/api/clusterpedia/v1beta1/conversion.go new file mode 100644 index 000000000..4d3f6d84a --- /dev/null +++ b/vendor/github.com/clusterpedia-io/api/clusterpedia/v1beta1/conversion.go @@ -0,0 +1,376 @@ +package v1beta1 + +import ( + "errors" + "fmt" + "net/url" + "strconv" + "strings" + "time" + + metainternal "k8s.io/apimachinery/pkg/apis/meta/internalversion" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/conversion" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + + "github.com/clusterpedia-io/api/clusterpedia" + "github.com/clusterpedia-io/api/clusterpedia/fields" +) + +func Convert_v1beta1_ListOptions_To_clusterpedia_ListOptions(in *ListOptions, out *clusterpedia.ListOptions, s conversion.Scope) error { + fieldSelector := in.FieldSelector + defer func() { + in.FieldSelector = fieldSelector + }() + + // skip convert fieldSelector + in.FieldSelector = "" + if err := metainternal.Convert_v1_ListOptions_To_internalversion_ListOptions(&in.ListOptions, &out.ListOptions, s); err != nil { + return err + } + + if err := convert_string_To_fields_Selector(&fieldSelector, &out.EnhancedFieldSelector, s); err != nil { + return err + } + + if err := convert_String_To_Slice_string(&in.Names, &out.Names, s); err != nil { + return err + } + if err := convert_String_To_Slice_string(&in.ClusterNames, &out.ClusterNames, s); err != nil { + return err + } + if err := convert_String_To_Slice_string(&in.Namespaces, &out.Namespaces, s); err != nil { + return err + } + + var orderbys []string + if err := convert_String_To_Slice_string(&in.OrderBy, &orderbys, s); err != nil { + return err + } + if err := convert_Slice_string_To_clusterpedia_Slice_orderby(&orderbys, &out.OrderBy, " ", s); err != nil { + return err + } + + out.OwnerUID = in.OwnerUID + out.OwnerName = in.OwnerName + if in.OwnerGroupResource != "" { + out.OwnerGroupResource = schema.ParseGroupResource(in.OwnerGroupResource) + } + out.OwnerSeniority = in.OwnerSeniority + + if err := convert_String_To_Pointer_metav1_Time(&in.Since, &out.Since, nil); err != nil { + return err + } + + if err := convert_String_To_Pointer_metav1_Time(&in.Before, &out.Before, nil); err != nil { + return err + } + + out.WithContinue = in.WithContinue + out.WithRemainingCount = in.WithRemainingCount + + if out.LabelSelector != nil { + var ( + labelRequest []labels.Requirement + extraLabelRequest []labels.Requirement + ) + + if requirements, selectable := out.LabelSelector.Requirements(); selectable { + for _, require := range requirements { + values := require.Values().UnsortedList() + switch require.Key() { + case clusterpedia.SearchLabelNames: + if len(out.Names) == 0 && len(values) != 0 { + out.Names = values + } + case clusterpedia.SearchLabelClusters: + if len(out.ClusterNames) == 0 && len(values) != 0 { + out.ClusterNames = values + } + case clusterpedia.SearchLabelNamespaces: + if len(out.Namespaces) == 0 && len(values) != 0 { + out.Namespaces = values + } + case clusterpedia.SearchLabelOwnerUID: + if out.OwnerUID == "" && len(values) == 1 { + out.OwnerUID = values[0] + } + case clusterpedia.SearchLabelOwnerName: + if out.OwnerName == "" && len(values) == 1 { + out.OwnerName = values[0] + } + case clusterpedia.SearchLabelOwnerGroupResource: + if out.OwnerGroupResource.Empty() && len(values) == 1 { + out.OwnerGroupResource = schema.ParseGroupResource(values[0]) + } + case clusterpedia.SearchLabelOwnerSeniority: + if out.OwnerSeniority == 0 && len(values) == 1 { + seniority, err := strconv.Atoi(values[0]) + if err != nil { + return fmt.Errorf("Invalid Query OwnerSeniority(%s): %w", values[0], err) + } + out.OwnerSeniority = seniority + } + case clusterpedia.SearchLabelSince: + if out.Since == nil && len(values) == 1 { + if err := convert_String_To_Pointer_metav1_Time(&values[0], &out.Since, nil); err != nil { + return fmt.Errorf("Invalid Query Since(%s): %w", values[0], err) + } + } + case clusterpedia.SearchLabelBefore: + if out.Before == nil && len(values) == 1 { + if err := convert_String_To_Pointer_metav1_Time(&values[0], &out.Before, nil); err != nil { + return fmt.Errorf("Invalid Query Before(%s): %w", values[0], err) + } + } + case clusterpedia.SearchLabelOrderBy: + if len(out.OrderBy) == 0 && len(values) != 0 { + if err := convert_Slice_string_To_clusterpedia_Slice_orderby(&values, &out.OrderBy, "_", s); err != nil { + return err + } + } + case clusterpedia.SearchLabelLimit: + if out.Limit == 0 && len(values) != 0 { + limit, err := strconv.ParseInt(values[0], 10, 64) + if err != nil { + return fmt.Errorf("Invalid Query Limit: %w", err) + } + out.Limit = limit + } + case clusterpedia.SearchLabelOffset: + if out.Continue == "" && len(values) != 0 { + out.Continue = values[0] + } + + if out.Continue != "" { + _, err := strconv.ParseInt(out.Continue, 10, 64) + if err != nil { + return fmt.Errorf("Invalid Query Offset(%s): %w", out.Continue, err) + } + } + case clusterpedia.SearchLabelWithContinue: + if in.WithContinue == nil && len(values) != 0 { + if err := runtime.Convert_Slice_string_To_Pointer_bool(&values, &out.WithContinue, s); err != nil { + return err + } + } + case clusterpedia.SearchLabelWithRemainingCount: + if in.WithRemainingCount == nil && len(values) != 0 { + if err := runtime.Convert_Slice_string_To_Pointer_bool(&values, &out.WithRemainingCount, s); err != nil { + return err + } + } + default: + if strings.Contains(require.Key(), "clusterpedia.io") { + extraLabelRequest = append(extraLabelRequest, require) + } else { + labelRequest = append(labelRequest, require) + } + } + } + } + + out.LabelSelector = nil + if len(labelRequest) != 0 { + out.LabelSelector = labels.NewSelector().Add(labelRequest...) + } + if len(extraLabelRequest) != 0 { + out.ExtraLabelSelector = labels.NewSelector().Add(extraLabelRequest...) + } + } + if out.Before.Before(out.Since) { + return fmt.Errorf("Invalid Query, Since is after Before") + } + if len(in.urlQuery) > 0 { + // Out URLQuery will not be modified, so deepcopy is not used here. + out.URLQuery = in.urlQuery + } + + out.OnlyMetadata = in.OnlyMetadata + return nil +} + +func Convert_clusterpedia_ListOptions_To_v1beta1_ListOptions(in *clusterpedia.ListOptions, out *ListOptions, s conversion.Scope) error { + if err := metainternal.Convert_internalversion_ListOptions_To_v1_ListOptions(&in.ListOptions, &out.ListOptions, s); err != nil { + return err + } + + if err := convert_fields_Selector_To_string(&in.EnhancedFieldSelector, &out.FieldSelector, s); err != nil { + return err + } + + labels := in.LabelSelector.DeepCopySelector() + requirements, _ := in.ExtraLabelSelector.Requirements() + labels.Add(requirements...) + if err := metav1.Convert_labels_Selector_To_string(&labels, &out.ListOptions.LabelSelector, s); err != nil { + return err + } + + out.OwnerUID = in.OwnerUID + out.OwnerName = in.OwnerName + out.OwnerGroupResource = in.OwnerGroupResource.String() + out.OwnerSeniority = in.OwnerSeniority + + if err := convert_Slice_string_To_String(&in.Names, &out.Names, s); err != nil { + return err + } + if err := convert_Slice_string_To_String(&in.ClusterNames, &out.ClusterNames, s); err != nil { + return err + } + if err := convert_Slice_string_To_String(&in.Namespaces, &out.Namespaces, s); err != nil { + return err + } + if err := convert_pedia_Slice_orderby_To_String(&in.OrderBy, &out.OrderBy, s); err != nil { + return err + } + + out.WithContinue = in.WithContinue + out.WithRemainingCount = in.WithRemainingCount + return nil +} + +func Convert_url_Values_To_v1beta1_ListOptions(in *url.Values, out *ListOptions, s conversion.Scope) error { + if err := metav1.Convert_url_Values_To_v1_ListOptions(in, &out.ListOptions, s); err != nil { + return err + } + // Save the native query parameters for use by listoptions. + out.urlQuery = *in + + return autoConvert_url_Values_To_v1beta1_ListOptions(in, out, s) +} + +func convert_String_To_Slice_string(in *string, out *[]string, scope conversion.Scope) error { + str := strings.TrimSpace(*in) + if str == "" { + *out = nil + return nil + } + + *out = strings.Split(str, ",") + return nil +} + +func convert_Slice_string_To_String(in *[]string, out *string, scope conversion.Scope) error { + if len(*in) == 0 { + *out = "" + return nil + } + *out = strings.Join(*in, ",") + return nil +} + +func convert_String_To_Pointer_metav1_Time(in *string, out **metav1.Time, scope conversion.Scope) error { + str := strings.TrimSpace(*in) + if len(str) == 0 { + return nil + } + + var err error + var t time.Time + switch { + case strings.Contains(str, "T"): + // If the query parameter contains "+", it will be parsed into " ". + // The query parameter need to be encoded. + t, err = time.Parse(time.RFC3339, *in) + case strings.Contains(str, " "): + t, err = time.Parse("2006-01-02 15:04:05", *in) + case strings.Contains(str, "-"): + t, err = time.Parse("2006-01-02", *in) + default: + var timestamp int64 + timestamp, err = strconv.ParseInt(*in, 10, 64) + if err != nil { + break + } + + switch len(str) { + case 10: + t = time.Unix(timestamp, 0) + case 13: + t = time.Unix(timestamp/1e3, (timestamp%1e3)*1e6) + default: + return errors.New("Invalid timestamp: only timestamps with string lengths of 10(as s) and 13(as ms) are supported") + } + } + if err != nil { + return fmt.Errorf("Invalid datetime: %s, a valid datetime format: RFC3339, Datetime(2006-01-02 15:04:05), Date(2006-01-02), Unix Timestamp", *in) + } + *out = &metav1.Time{Time: t} + return nil +} + +func convert_Slice_string_To_clusterpedia_Slice_orderby(in *[]string, out *[]clusterpedia.OrderBy, descSep string, s conversion.Scope) error { + if len(*in) == 0 { + return nil + } + + for _, o := range *in { + sli := strings.Split(strings.TrimSpace(o), descSep) + switch len(sli) { + case 0: + continue + case 1: + *out = append(*out, clusterpedia.OrderBy{Field: sli[0]}) + continue + default: + } + + var desc bool + if sli[len(sli)-1] == "desc" { + desc = true + sli = sli[:len(sli)-1] + } + + // if descSep is " ", `orderby` can only be 'field' or 'field desc' + // example invalid `orderby`: 'field1 field2', 'field1 field2 desc' + if descSep == " " && len(sli) > 1 { + return errors.New("Invalid Query OrderBy") + } + + field := strings.Join(sli, descSep) + *out = append(*out, clusterpedia.OrderBy{Field: field, Desc: desc}) + } + return nil +} + +func convert_pedia_Slice_orderby_To_String(in *[]clusterpedia.OrderBy, out *string, s conversion.Scope) error { + if len(*in) == 0 { + return nil + } + + sliOrderBy := make([]string, len(*in)) + for i, orderby := range *in { + str := orderby.Field + if orderby.Desc { + str += " desc" + } + sliOrderBy[i] = str + } + + if err := convert_Slice_string_To_String(&sliOrderBy, out, s); err != nil { + return err + } + return nil +} + +func convert_string_To_fields_Selector(in *string, out *fields.Selector, s conversion.Scope) error { + selector, err := fields.Parse(*in) + if err != nil { + return err + } + *out = selector + return nil +} + +func convert_fields_Selector_To_string(in *fields.Selector, out *string, s conversion.Scope) error { + if *in == nil { + return nil + } + *out = (*in).String() + return nil +} + +// nolint:unused +func compileErrorOnMissingConversion() {} diff --git a/vendor/github.com/clusterpedia-io/api/clusterpedia/v1beta1/doc.go b/vendor/github.com/clusterpedia-io/api/clusterpedia/v1beta1/doc.go new file mode 100644 index 000000000..27ed18eba --- /dev/null +++ b/vendor/github.com/clusterpedia-io/api/clusterpedia/v1beta1/doc.go @@ -0,0 +1,8 @@ +// +k8s:openapi-gen=true +// +k8s:deepcopy-gen=package +// +k8s:conversion-gen=github.com/clusterpedia-io/api/clusterpedia +// +k8s:defaulter-gen=TypeMeta +// +groupName=clusterpedia.io + +// Package v1beta1 is the v1beta1 version of the API +package v1beta1 diff --git a/vendor/github.com/clusterpedia-io/api/clusterpedia/v1beta1/register.go b/vendor/github.com/clusterpedia-io/api/clusterpedia/v1beta1/register.go new file mode 100644 index 000000000..a55ab7197 --- /dev/null +++ b/vendor/github.com/clusterpedia-io/api/clusterpedia/v1beta1/register.go @@ -0,0 +1,56 @@ +package v1beta1 + +import ( + internal "github.com/clusterpedia-io/api/clusterpedia" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" + utilruntime "k8s.io/apimachinery/pkg/util/runtime" +) + +var SchemeGroupVersion = schema.GroupVersion{Group: internal.GroupName, Version: "v1beta1"} + +var ( + SchemeBuilder runtime.SchemeBuilder + localSchemeBuilder = &SchemeBuilder + Install = localSchemeBuilder.AddToScheme +) + +func init() { + localSchemeBuilder.Register(addKnownTypes) +} + +func addKnownTypes(scheme *runtime.Scheme) error { + scheme.AddKnownTypes(SchemeGroupVersion, + &CollectionResource{}, + &CollectionResourceList{}, + &Resources{}, + &ListOptions{}, + + &metav1.GetOptions{}, + &metav1.DeleteOptions{}, + &metav1.CreateOptions{}, + &metav1.UpdateOptions{}, + &metav1.PatchOptions{}, + ) + + scheme.AddKnownTypeWithName(SchemeGroupVersion.WithKind(metav1.WatchEventKind), &metav1.WatchEvent{}) + scheme.AddKnownTypeWithName( + schema.GroupVersion{Group: SchemeGroupVersion.Group, Version: runtime.APIVersionInternal}.WithKind(metav1.WatchEventKind), + &metav1.InternalEvent{}, + ) + + scheme.AddUnversionedTypes(metav1.Unversioned, + &metav1.Status{}, + &metav1.APIVersions{}, + &metav1.APIGroupList{}, + &metav1.APIGroup{}, + &metav1.APIResourceList{}, + ) + + utilruntime.Must(metav1.RegisterConversions(scheme)) + utilruntime.Must(metav1.RegisterDefaults(scheme)) + + // metav1.AddToGroupVersion(scheme, SchemeGroupVersion) + return nil +} diff --git a/vendor/github.com/clusterpedia-io/api/clusterpedia/v1beta1/types.go b/vendor/github.com/clusterpedia-io/api/clusterpedia/v1beta1/types.go new file mode 100644 index 000000000..25a827d17 --- /dev/null +++ b/vendor/github.com/clusterpedia-io/api/clusterpedia/v1beta1/types.go @@ -0,0 +1,110 @@ +package v1beta1 + +import ( + "net/url" + + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" +) + +// +k8s:conversion-gen:explicit-from=net/url.Values +// +k8s:openapi-gen=true +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +type ListOptions struct { + metav1.ListOptions `json:",inline"` + + // +optional + Names string `json:"names,omitempty"` + + // +optional + ClusterNames string `json:"clusters,omitempty"` + + // +optional + Namespaces string `json:"namespaces,omitempty"` + + // +optional + OrderBy string `json:"orderby,omitempty"` + + // +optional + OwnerUID string `json:"ownerUID,omitempty"` + + // +optional + OwnerName string `json:"ownerName,omitempty"` + + // +optional + Since string `json:"since,omitempty"` + + // +optional + Before string `json:"before,omitempty"` + + // +optional + OwnerGroupResource string `json:"ownerGR,omitempty"` + + // +optional + OwnerSeniority int `json:"ownerSeniority,omitempty"` + + // +optional + WithContinue *bool `json:"withContinue,omitempty"` + + // +optional + WithRemainingCount *bool `json:"withRemainingCount,omitempty"` + + // +optional + OnlyMetadata bool `json:"onlyMetadata,omitempty"` + + urlQuery url.Values +} + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +type Resources struct { + metav1.TypeMeta `json:",inline"` +} + +// +genclient +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +// +k8s:openapi-gen=true + +type CollectionResource struct { + metav1.TypeMeta `json:",inline"` + + // +optional + metav1.ObjectMeta `json:"metadata,omitempty"` + + // +required + ResourceTypes []CollectionResourceType `json:"resourceTypes"` + + // +optional + Items []runtime.RawExtension `json:"items,omitempty"` + + // +optional + Continue string `json:"continue,omitempty"` + + // +optional + RemainingItemCount *int64 `json:"remainingItemCount,omitempty"` +} + +type CollectionResourceType struct { + Group string `json:"group"` + + Version string `json:"version"` + + // +optional + Kind string `json:"kind,omitempty"` + + Resource string `json:"resource"` +} + +// +kubebuilder:object:root=true +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +// +k8s:openapi-gen=true + +type CollectionResourceList struct { + metav1.TypeMeta `json:",inline"` + + // +optional + metav1.ListMeta `json:"metadata,omitempty"` + + Items []CollectionResource `json:"items"` +} diff --git a/vendor/github.com/clusterpedia-io/api/clusterpedia/v1beta1/zz_generated.conversion.go b/vendor/github.com/clusterpedia-io/api/clusterpedia/v1beta1/zz_generated.conversion.go new file mode 100644 index 000000000..e0c81f294 --- /dev/null +++ b/vendor/github.com/clusterpedia-io/api/clusterpedia/v1beta1/zz_generated.conversion.go @@ -0,0 +1,338 @@ +//go:build !ignore_autogenerated +// +build !ignore_autogenerated + +// Code generated by conversion-gen. DO NOT EDIT. + +package v1beta1 + +import ( + url "net/url" + unsafe "unsafe" + + clusterpedia "github.com/clusterpedia-io/api/clusterpedia" + conversion "k8s.io/apimachinery/pkg/conversion" + runtime "k8s.io/apimachinery/pkg/runtime" +) + +func init() { + localSchemeBuilder.Register(RegisterConversions) +} + +// RegisterConversions adds conversion functions to the given scheme. +// Public to allow building arbitrary schemes. +func RegisterConversions(s *runtime.Scheme) error { + if err := s.AddGeneratedConversionFunc((*CollectionResource)(nil), (*clusterpedia.CollectionResource)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1beta1_CollectionResource_To_clusterpedia_CollectionResource(a.(*CollectionResource), b.(*clusterpedia.CollectionResource), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*clusterpedia.CollectionResource)(nil), (*CollectionResource)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_clusterpedia_CollectionResource_To_v1beta1_CollectionResource(a.(*clusterpedia.CollectionResource), b.(*CollectionResource), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*CollectionResourceList)(nil), (*clusterpedia.CollectionResourceList)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1beta1_CollectionResourceList_To_clusterpedia_CollectionResourceList(a.(*CollectionResourceList), b.(*clusterpedia.CollectionResourceList), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*clusterpedia.CollectionResourceList)(nil), (*CollectionResourceList)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_clusterpedia_CollectionResourceList_To_v1beta1_CollectionResourceList(a.(*clusterpedia.CollectionResourceList), b.(*CollectionResourceList), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*CollectionResourceType)(nil), (*clusterpedia.CollectionResourceType)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1beta1_CollectionResourceType_To_clusterpedia_CollectionResourceType(a.(*CollectionResourceType), b.(*clusterpedia.CollectionResourceType), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*clusterpedia.CollectionResourceType)(nil), (*CollectionResourceType)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_clusterpedia_CollectionResourceType_To_v1beta1_CollectionResourceType(a.(*clusterpedia.CollectionResourceType), b.(*CollectionResourceType), scope) + }); err != nil { + return err + } + if err := s.AddGeneratedConversionFunc((*url.Values)(nil), (*ListOptions)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_url_Values_To_v1beta1_ListOptions(a.(*url.Values), b.(*ListOptions), scope) + }); err != nil { + return err + } + if err := s.AddConversionFunc((*clusterpedia.ListOptions)(nil), (*ListOptions)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_clusterpedia_ListOptions_To_v1beta1_ListOptions(a.(*clusterpedia.ListOptions), b.(*ListOptions), scope) + }); err != nil { + return err + } + if err := s.AddConversionFunc((*url.Values)(nil), (*ListOptions)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_url_Values_To_v1beta1_ListOptions(a.(*url.Values), b.(*ListOptions), scope) + }); err != nil { + return err + } + if err := s.AddConversionFunc((*ListOptions)(nil), (*clusterpedia.ListOptions)(nil), func(a, b interface{}, scope conversion.Scope) error { + return Convert_v1beta1_ListOptions_To_clusterpedia_ListOptions(a.(*ListOptions), b.(*clusterpedia.ListOptions), scope) + }); err != nil { + return err + } + return nil +} + +func autoConvert_v1beta1_CollectionResource_To_clusterpedia_CollectionResource(in *CollectionResource, out *clusterpedia.CollectionResource, s conversion.Scope) error { + out.ObjectMeta = in.ObjectMeta + out.ResourceTypes = *(*[]clusterpedia.CollectionResourceType)(unsafe.Pointer(&in.ResourceTypes)) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]runtime.Object, len(*in)) + for i := range *in { + if err := runtime.Convert_runtime_RawExtension_To_runtime_Object(&(*in)[i], &(*out)[i], s); err != nil { + return err + } + } + } else { + out.Items = nil + } + out.Continue = in.Continue + out.RemainingItemCount = (*int64)(unsafe.Pointer(in.RemainingItemCount)) + return nil +} + +// Convert_v1beta1_CollectionResource_To_clusterpedia_CollectionResource is an autogenerated conversion function. +func Convert_v1beta1_CollectionResource_To_clusterpedia_CollectionResource(in *CollectionResource, out *clusterpedia.CollectionResource, s conversion.Scope) error { + return autoConvert_v1beta1_CollectionResource_To_clusterpedia_CollectionResource(in, out, s) +} + +func autoConvert_clusterpedia_CollectionResource_To_v1beta1_CollectionResource(in *clusterpedia.CollectionResource, out *CollectionResource, s conversion.Scope) error { + out.ObjectMeta = in.ObjectMeta + out.ResourceTypes = *(*[]CollectionResourceType)(unsafe.Pointer(&in.ResourceTypes)) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]runtime.RawExtension, len(*in)) + for i := range *in { + if err := runtime.Convert_runtime_Object_To_runtime_RawExtension(&(*in)[i], &(*out)[i], s); err != nil { + return err + } + } + } else { + out.Items = nil + } + out.Continue = in.Continue + out.RemainingItemCount = (*int64)(unsafe.Pointer(in.RemainingItemCount)) + return nil +} + +// Convert_clusterpedia_CollectionResource_To_v1beta1_CollectionResource is an autogenerated conversion function. +func Convert_clusterpedia_CollectionResource_To_v1beta1_CollectionResource(in *clusterpedia.CollectionResource, out *CollectionResource, s conversion.Scope) error { + return autoConvert_clusterpedia_CollectionResource_To_v1beta1_CollectionResource(in, out, s) +} + +func autoConvert_v1beta1_CollectionResourceList_To_clusterpedia_CollectionResourceList(in *CollectionResourceList, out *clusterpedia.CollectionResourceList, s conversion.Scope) error { + out.ListMeta = in.ListMeta + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]clusterpedia.CollectionResource, len(*in)) + for i := range *in { + if err := Convert_v1beta1_CollectionResource_To_clusterpedia_CollectionResource(&(*in)[i], &(*out)[i], s); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +// Convert_v1beta1_CollectionResourceList_To_clusterpedia_CollectionResourceList is an autogenerated conversion function. +func Convert_v1beta1_CollectionResourceList_To_clusterpedia_CollectionResourceList(in *CollectionResourceList, out *clusterpedia.CollectionResourceList, s conversion.Scope) error { + return autoConvert_v1beta1_CollectionResourceList_To_clusterpedia_CollectionResourceList(in, out, s) +} + +func autoConvert_clusterpedia_CollectionResourceList_To_v1beta1_CollectionResourceList(in *clusterpedia.CollectionResourceList, out *CollectionResourceList, s conversion.Scope) error { + out.ListMeta = in.ListMeta + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]CollectionResource, len(*in)) + for i := range *in { + if err := Convert_clusterpedia_CollectionResource_To_v1beta1_CollectionResource(&(*in)[i], &(*out)[i], s); err != nil { + return err + } + } + } else { + out.Items = nil + } + return nil +} + +// Convert_clusterpedia_CollectionResourceList_To_v1beta1_CollectionResourceList is an autogenerated conversion function. +func Convert_clusterpedia_CollectionResourceList_To_v1beta1_CollectionResourceList(in *clusterpedia.CollectionResourceList, out *CollectionResourceList, s conversion.Scope) error { + return autoConvert_clusterpedia_CollectionResourceList_To_v1beta1_CollectionResourceList(in, out, s) +} + +func autoConvert_v1beta1_CollectionResourceType_To_clusterpedia_CollectionResourceType(in *CollectionResourceType, out *clusterpedia.CollectionResourceType, s conversion.Scope) error { + out.Group = in.Group + out.Version = in.Version + out.Kind = in.Kind + out.Resource = in.Resource + return nil +} + +// Convert_v1beta1_CollectionResourceType_To_clusterpedia_CollectionResourceType is an autogenerated conversion function. +func Convert_v1beta1_CollectionResourceType_To_clusterpedia_CollectionResourceType(in *CollectionResourceType, out *clusterpedia.CollectionResourceType, s conversion.Scope) error { + return autoConvert_v1beta1_CollectionResourceType_To_clusterpedia_CollectionResourceType(in, out, s) +} + +func autoConvert_clusterpedia_CollectionResourceType_To_v1beta1_CollectionResourceType(in *clusterpedia.CollectionResourceType, out *CollectionResourceType, s conversion.Scope) error { + out.Group = in.Group + out.Version = in.Version + out.Kind = in.Kind + out.Resource = in.Resource + return nil +} + +// Convert_clusterpedia_CollectionResourceType_To_v1beta1_CollectionResourceType is an autogenerated conversion function. +func Convert_clusterpedia_CollectionResourceType_To_v1beta1_CollectionResourceType(in *clusterpedia.CollectionResourceType, out *CollectionResourceType, s conversion.Scope) error { + return autoConvert_clusterpedia_CollectionResourceType_To_v1beta1_CollectionResourceType(in, out, s) +} + +func autoConvert_v1beta1_ListOptions_To_clusterpedia_ListOptions(in *ListOptions, out *clusterpedia.ListOptions, s conversion.Scope) error { + // FIXME: Provide conversion function to convert v1.ListOptions to internalversion.ListOptions + compileErrorOnMissingConversion() + // WARNING: in.Names requires manual conversion: inconvertible types (string vs []string) + // WARNING: in.ClusterNames requires manual conversion: inconvertible types (string vs []string) + // WARNING: in.Namespaces requires manual conversion: inconvertible types (string vs []string) + // WARNING: in.OrderBy requires manual conversion: inconvertible types (string vs []github.com/clusterpedia-io/api/clusterpedia.OrderBy) + out.OwnerUID = in.OwnerUID + out.OwnerName = in.OwnerName + // WARNING: in.Since requires manual conversion: inconvertible types (string vs *k8s.io/apimachinery/pkg/apis/meta/v1.Time) + // WARNING: in.Before requires manual conversion: inconvertible types (string vs *k8s.io/apimachinery/pkg/apis/meta/v1.Time) + // WARNING: in.OwnerGroupResource requires manual conversion: inconvertible types (string vs k8s.io/apimachinery/pkg/runtime/schema.GroupResource) + out.OwnerSeniority = in.OwnerSeniority + out.WithContinue = (*bool)(unsafe.Pointer(in.WithContinue)) + out.WithRemainingCount = (*bool)(unsafe.Pointer(in.WithRemainingCount)) + out.OnlyMetadata = in.OnlyMetadata + // WARNING: in.urlQuery requires manual conversion: does not exist in peer-type + return nil +} + +func autoConvert_clusterpedia_ListOptions_To_v1beta1_ListOptions(in *clusterpedia.ListOptions, out *ListOptions, s conversion.Scope) error { + // FIXME: Provide conversion function to convert internalversion.ListOptions to v1.ListOptions + compileErrorOnMissingConversion() + if err := runtime.Convert_Slice_string_To_string(&in.Names, &out.Names, s); err != nil { + return err + } + if err := runtime.Convert_Slice_string_To_string(&in.ClusterNames, &out.ClusterNames, s); err != nil { + return err + } + if err := runtime.Convert_Slice_string_To_string(&in.Namespaces, &out.Namespaces, s); err != nil { + return err + } + // WARNING: in.OrderBy requires manual conversion: inconvertible types ([]github.com/clusterpedia-io/api/clusterpedia.OrderBy vs string) + out.OwnerName = in.OwnerName + out.OwnerUID = in.OwnerUID + // WARNING: in.OwnerGroupResource requires manual conversion: inconvertible types (k8s.io/apimachinery/pkg/runtime/schema.GroupResource vs string) + out.OwnerSeniority = in.OwnerSeniority + // WARNING: in.Since requires manual conversion: inconvertible types (*k8s.io/apimachinery/pkg/apis/meta/v1.Time vs string) + // WARNING: in.Before requires manual conversion: inconvertible types (*k8s.io/apimachinery/pkg/apis/meta/v1.Time vs string) + out.WithContinue = (*bool)(unsafe.Pointer(in.WithContinue)) + out.WithRemainingCount = (*bool)(unsafe.Pointer(in.WithRemainingCount)) + // WARNING: in.EnhancedFieldSelector requires manual conversion: does not exist in peer-type + // WARNING: in.ExtraLabelSelector requires manual conversion: does not exist in peer-type + // WARNING: in.URLQuery requires manual conversion: does not exist in peer-type + out.OnlyMetadata = in.OnlyMetadata + return nil +} + +func autoConvert_url_Values_To_v1beta1_ListOptions(in *url.Values, out *ListOptions, s conversion.Scope) error { + // WARNING: Field ListOptions does not have json tag, skipping. + + if values, ok := map[string][]string(*in)["names"]; ok && len(values) > 0 { + if err := runtime.Convert_Slice_string_To_string(&values, &out.Names, s); err != nil { + return err + } + } else { + out.Names = "" + } + if values, ok := map[string][]string(*in)["clusters"]; ok && len(values) > 0 { + if err := runtime.Convert_Slice_string_To_string(&values, &out.ClusterNames, s); err != nil { + return err + } + } else { + out.ClusterNames = "" + } + if values, ok := map[string][]string(*in)["namespaces"]; ok && len(values) > 0 { + if err := runtime.Convert_Slice_string_To_string(&values, &out.Namespaces, s); err != nil { + return err + } + } else { + out.Namespaces = "" + } + if values, ok := map[string][]string(*in)["orderby"]; ok && len(values) > 0 { + if err := runtime.Convert_Slice_string_To_string(&values, &out.OrderBy, s); err != nil { + return err + } + } else { + out.OrderBy = "" + } + if values, ok := map[string][]string(*in)["ownerUID"]; ok && len(values) > 0 { + if err := runtime.Convert_Slice_string_To_string(&values, &out.OwnerUID, s); err != nil { + return err + } + } else { + out.OwnerUID = "" + } + if values, ok := map[string][]string(*in)["ownerName"]; ok && len(values) > 0 { + if err := runtime.Convert_Slice_string_To_string(&values, &out.OwnerName, s); err != nil { + return err + } + } else { + out.OwnerName = "" + } + if values, ok := map[string][]string(*in)["since"]; ok && len(values) > 0 { + if err := runtime.Convert_Slice_string_To_string(&values, &out.Since, s); err != nil { + return err + } + } else { + out.Since = "" + } + if values, ok := map[string][]string(*in)["before"]; ok && len(values) > 0 { + if err := runtime.Convert_Slice_string_To_string(&values, &out.Before, s); err != nil { + return err + } + } else { + out.Before = "" + } + if values, ok := map[string][]string(*in)["ownerGR"]; ok && len(values) > 0 { + if err := runtime.Convert_Slice_string_To_string(&values, &out.OwnerGroupResource, s); err != nil { + return err + } + } else { + out.OwnerGroupResource = "" + } + if values, ok := map[string][]string(*in)["ownerSeniority"]; ok && len(values) > 0 { + if err := runtime.Convert_Slice_string_To_int(&values, &out.OwnerSeniority, s); err != nil { + return err + } + } else { + out.OwnerSeniority = 0 + } + if values, ok := map[string][]string(*in)["withContinue"]; ok && len(values) > 0 { + if err := runtime.Convert_Slice_string_To_Pointer_bool(&values, &out.WithContinue, s); err != nil { + return err + } + } else { + out.WithContinue = nil + } + if values, ok := map[string][]string(*in)["withRemainingCount"]; ok && len(values) > 0 { + if err := runtime.Convert_Slice_string_To_Pointer_bool(&values, &out.WithRemainingCount, s); err != nil { + return err + } + } else { + out.WithRemainingCount = nil + } + if values, ok := map[string][]string(*in)["onlyMetadata"]; ok && len(values) > 0 { + if err := runtime.Convert_Slice_string_To_bool(&values, &out.OnlyMetadata, s); err != nil { + return err + } + } else { + out.OnlyMetadata = false + } + // WARNING: Field urlQuery does not have json tag, skipping. + + return nil +} diff --git a/vendor/github.com/clusterpedia-io/api/clusterpedia/v1beta1/zz_generated.deepcopy.go b/vendor/github.com/clusterpedia-io/api/clusterpedia/v1beta1/zz_generated.deepcopy.go new file mode 100644 index 000000000..710cd4bf2 --- /dev/null +++ b/vendor/github.com/clusterpedia-io/api/clusterpedia/v1beta1/zz_generated.deepcopy.go @@ -0,0 +1,179 @@ +//go:build !ignore_autogenerated +// +build !ignore_autogenerated + +// Code generated by deepcopy-gen. DO NOT EDIT. + +package v1beta1 + +import ( + url "net/url" + + runtime "k8s.io/apimachinery/pkg/runtime" +) + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *CollectionResource) DeepCopyInto(out *CollectionResource) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + if in.ResourceTypes != nil { + in, out := &in.ResourceTypes, &out.ResourceTypes + *out = make([]CollectionResourceType, len(*in)) + copy(*out, *in) + } + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]runtime.RawExtension, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.RemainingItemCount != nil { + in, out := &in.RemainingItemCount, &out.RemainingItemCount + *out = new(int64) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CollectionResource. +func (in *CollectionResource) DeepCopy() *CollectionResource { + if in == nil { + return nil + } + out := new(CollectionResource) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *CollectionResource) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *CollectionResourceList) DeepCopyInto(out *CollectionResourceList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]CollectionResource, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CollectionResourceList. +func (in *CollectionResourceList) DeepCopy() *CollectionResourceList { + if in == nil { + return nil + } + out := new(CollectionResourceList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *CollectionResourceList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *CollectionResourceType) DeepCopyInto(out *CollectionResourceType) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CollectionResourceType. +func (in *CollectionResourceType) DeepCopy() *CollectionResourceType { + if in == nil { + return nil + } + out := new(CollectionResourceType) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ListOptions) DeepCopyInto(out *ListOptions) { + *out = *in + in.ListOptions.DeepCopyInto(&out.ListOptions) + if in.WithContinue != nil { + in, out := &in.WithContinue, &out.WithContinue + *out = new(bool) + **out = **in + } + if in.WithRemainingCount != nil { + in, out := &in.WithRemainingCount, &out.WithRemainingCount + *out = new(bool) + **out = **in + } + if in.urlQuery != nil { + in, out := &in.urlQuery, &out.urlQuery + *out = make(url.Values, len(*in)) + for key, val := range *in { + var outVal []string + if val == nil { + (*out)[key] = nil + } else { + in, out := &val, &outVal + *out = make([]string, len(*in)) + copy(*out, *in) + } + (*out)[key] = outVal + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ListOptions. +func (in *ListOptions) DeepCopy() *ListOptions { + if in == nil { + return nil + } + out := new(ListOptions) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *ListOptions) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *Resources) DeepCopyInto(out *Resources) { + *out = *in + out.TypeMeta = in.TypeMeta + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Resources. +func (in *Resources) DeepCopy() *Resources { + if in == nil { + return nil + } + out := new(Resources) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *Resources) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} diff --git a/vendor/github.com/clusterpedia-io/api/clusterpedia/zz_generated.deepcopy.go b/vendor/github.com/clusterpedia-io/api/clusterpedia/zz_generated.deepcopy.go new file mode 100644 index 000000000..1e5aab42f --- /dev/null +++ b/vendor/github.com/clusterpedia-io/api/clusterpedia/zz_generated.deepcopy.go @@ -0,0 +1,207 @@ +//go:build !ignore_autogenerated +// +build !ignore_autogenerated + +// Code generated by deepcopy-gen. DO NOT EDIT. + +package clusterpedia + +import ( + url "net/url" + + runtime "k8s.io/apimachinery/pkg/runtime" +) + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *CollectionResource) DeepCopyInto(out *CollectionResource) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + if in.ResourceTypes != nil { + in, out := &in.ResourceTypes, &out.ResourceTypes + *out = make([]CollectionResourceType, len(*in)) + copy(*out, *in) + } + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]runtime.Object, len(*in)) + for i := range *in { + if (*in)[i] != nil { + (*out)[i] = (*in)[i].DeepCopyObject() + } + } + } + if in.RemainingItemCount != nil { + in, out := &in.RemainingItemCount, &out.RemainingItemCount + *out = new(int64) + **out = **in + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CollectionResource. +func (in *CollectionResource) DeepCopy() *CollectionResource { + if in == nil { + return nil + } + out := new(CollectionResource) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *CollectionResource) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *CollectionResourceList) DeepCopyInto(out *CollectionResourceList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]CollectionResource, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CollectionResourceList. +func (in *CollectionResourceList) DeepCopy() *CollectionResourceList { + if in == nil { + return nil + } + out := new(CollectionResourceList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *CollectionResourceList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *CollectionResourceType) DeepCopyInto(out *CollectionResourceType) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CollectionResourceType. +func (in *CollectionResourceType) DeepCopy() *CollectionResourceType { + if in == nil { + return nil + } + out := new(CollectionResourceType) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ListOptions) DeepCopyInto(out *ListOptions) { + *out = *in + in.ListOptions.DeepCopyInto(&out.ListOptions) + if in.Names != nil { + in, out := &in.Names, &out.Names + *out = make([]string, len(*in)) + copy(*out, *in) + } + if in.ClusterNames != nil { + in, out := &in.ClusterNames, &out.ClusterNames + *out = make([]string, len(*in)) + copy(*out, *in) + } + if in.Namespaces != nil { + in, out := &in.Namespaces, &out.Namespaces + *out = make([]string, len(*in)) + copy(*out, *in) + } + if in.OrderBy != nil { + in, out := &in.OrderBy, &out.OrderBy + *out = make([]OrderBy, len(*in)) + copy(*out, *in) + } + out.OwnerGroupResource = in.OwnerGroupResource + if in.Since != nil { + in, out := &in.Since, &out.Since + *out = (*in).DeepCopy() + } + if in.Before != nil { + in, out := &in.Before, &out.Before + *out = (*in).DeepCopy() + } + if in.WithContinue != nil { + in, out := &in.WithContinue, &out.WithContinue + *out = new(bool) + **out = **in + } + if in.WithRemainingCount != nil { + in, out := &in.WithRemainingCount, &out.WithRemainingCount + *out = new(bool) + **out = **in + } + if in.EnhancedFieldSelector != nil { + out.EnhancedFieldSelector = in.EnhancedFieldSelector.DeepCopySelector() + } + if in.ExtraLabelSelector != nil { + out.ExtraLabelSelector = in.ExtraLabelSelector.DeepCopySelector() + } + if in.URLQuery != nil { + in, out := &in.URLQuery, &out.URLQuery + *out = make(url.Values, len(*in)) + for key, val := range *in { + var outVal []string + if val == nil { + (*out)[key] = nil + } else { + in, out := &val, &outVal + *out = make([]string, len(*in)) + copy(*out, *in) + } + (*out)[key] = outVal + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ListOptions. +func (in *ListOptions) DeepCopy() *ListOptions { + if in == nil { + return nil + } + out := new(ListOptions) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *ListOptions) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *OrderBy) DeepCopyInto(out *OrderBy) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OrderBy. +func (in *OrderBy) DeepCopy() *OrderBy { + if in == nil { + return nil + } + out := new(OrderBy) + in.DeepCopyInto(out) + return out +} diff --git a/vendor/github.com/clusterpedia-io/api/policy/v1alpha1/doc.go b/vendor/github.com/clusterpedia-io/api/policy/v1alpha1/doc.go new file mode 100644 index 000000000..ebfdecfc8 --- /dev/null +++ b/vendor/github.com/clusterpedia-io/api/policy/v1alpha1/doc.go @@ -0,0 +1,6 @@ +// +k8s:deepcopy-gen=package +// +k8s:openapi-gen=true +// +groupName=policy.clusterpedia.io + +// Package v1alpha1 is the v1alpha1 version of the API +package v1alpha1 diff --git a/vendor/github.com/clusterpedia-io/api/policy/v1alpha1/register.go b/vendor/github.com/clusterpedia-io/api/policy/v1alpha1/register.go new file mode 100644 index 000000000..bd5a6bd85 --- /dev/null +++ b/vendor/github.com/clusterpedia-io/api/policy/v1alpha1/register.go @@ -0,0 +1,51 @@ +package v1alpha1 + +import ( + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" +) + +// GroupName specifies the group name used to register the objects. +const GroupName = "policy.clusterpedia.io" + +// GroupVersion specifies the group and the version used to register the objects. +var GroupVersion = v1.GroupVersion{Group: GroupName, Version: "v1alpha1"} + +// SchemeGroupVersion is group version used to register these objects +// Deprecated: use GroupVersion instead. +var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1alpha1"} + +// Resource takes an unqualified resource and returns a Group qualified GroupResource +func Resource(resource string) schema.GroupResource { + return SchemeGroupVersion.WithResource(resource).GroupResource() +} + +var ( + // localSchemeBuilder and AddToScheme will stay in k8s.io/kubernetes. + SchemeBuilder runtime.SchemeBuilder + localSchemeBuilder = &SchemeBuilder + // Depreciated: use Install instead + AddToScheme = localSchemeBuilder.AddToScheme + Install = localSchemeBuilder.AddToScheme +) + +func init() { + // We only register manually written functions here. The registration of the + // generated functions takes place in the generated files. The separation + // makes the code compile even when the generated files are missing. + localSchemeBuilder.Register(addKnownTypes) +} + +// Adds the list of known types to Scheme. +func addKnownTypes(scheme *runtime.Scheme) error { + scheme.AddKnownTypes(SchemeGroupVersion, + &ClusterImportPolicy{}, + &ClusterImportPolicyList{}, + &PediaClusterLifecycle{}, + &PediaClusterLifecycleList{}, + ) + // AddToGroupVersion allows the serialization of client types like ListOptions. + v1.AddToGroupVersion(scheme, SchemeGroupVersion) + return nil +} diff --git a/vendor/github.com/clusterpedia-io/api/policy/v1alpha1/types.go b/vendor/github.com/clusterpedia-io/api/policy/v1alpha1/types.go new file mode 100644 index 000000000..c23e99e41 --- /dev/null +++ b/vendor/github.com/clusterpedia-io/api/policy/v1alpha1/types.go @@ -0,0 +1,347 @@ +package v1alpha1 + +import ( + "bytes" + "errors" + "fmt" + "html/template" + "strings" + + "github.com/Masterminds/sprig/v3" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime/schema" +) + +const ( + PolicyValidatedCondition = "Validated" + PolicyReconcilingCondition = "Reconciling" + + LifecycleCreatedCondition = "Created" + LifecycleUpdatingCondition = "Updating" +) + +// +genclient +// +genclient:nonNamespaced +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +// +k8s:openapi-gen=true +// +kubebuilder:subresource:status +// +kubebuilder:resource:scope="Cluster" +// +kubebuilder:printcolumn:name="Validated",type=string,JSONPath=".status.conditions[?(@.type == 'Validated')].reason" +// +kubebuilder:printcolumn:name="Reconciling",type=string,JSONPath=".status.conditions[?(@.type == 'Reconciling')].reason" +type ClusterImportPolicy struct { + metav1.TypeMeta `json:",inline"` + metav1.ObjectMeta `json:"metadata,omitempty"` + + // +optional + Spec ClusterImportPolicySpec `json:"spec,omitempty"` + + // +optional + Status ClusterImportPolicyStatus `json:"status,omitmepty"` +} + +type ClusterImportPolicySpec struct { + // +required + // +kubebuilder:validation:Required + Source SourceType `json:"source"` + + // +optional + // +listType=map + // +listMapKey=key + References []IntendReferenceResourceTemplate `json:"references,omitempty"` + + // +required + // +kubebuilder:validation:Required + NameTemplate LifecycleNameTemplate `json:"nameTemplate"` + + Policy `json:",inline"` +} + +type LifecycleNameTemplate string + +func (t LifecycleNameTemplate) Template() (*template.Template, error) { + return newTemplate("lifecycle-name", string(t)) +} + +type ClusterImportPolicyStatus struct { + // +optional + Conditions []metav1.Condition `json:"conditions,omitempty"` +} + +// +genclient +// +genclient:nonNamespaced +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +// +k8s:openapi-gen=true +// +kubebuilder:subresource:status +// +kubebuilder:resource:scope="Cluster" +// +kubebuilder:printcolumn:name="Created",type=string,JSONPath=".status.conditions[?(@.type == 'Created')].reason" +// +kubebuilder:printcolumn:name="Updating",type=string,JSONPath=".status.conditions[?(@.type == 'Updating')].reason" +type PediaClusterLifecycle struct { + metav1.TypeMeta `json:",inline"` + metav1.ObjectMeta `json:"metadata,omitempty"` + + // +optional + Spec PediaClusterLifecycleSpec `json:"spec,omitempty"` + + // +optional + Status PediaClusterLifecycleStatus `json:"status,omitempty"` +} + +type PediaClusterLifecycleSpec struct { + // +required + // +kubebuilder:validation:Required + Source DependentResource `json:"source"` + + // +optional + // +listType=map + // +listMapKey=key + References []ReferenceResourceTemplate `json:"references,omitempty"` + + Policy `json:",inline"` +} + +type PediaClusterLifecycleStatus struct { + // +optional + Conditions []metav1.Condition `json:"conditions,omitempty"` + + // +optional + References []DependentResource `json:"references"` +} + +type Policy struct { + // +required + // +kubebuilder:validation:Required + Template string `json:"template"` + + // +required + // +kubebuilder:validation:Required + CreationCondition string `json:"creationCondition"` + + /* + // +required + // +kubebuilder:validation:Required + UpdateTemplate string `json:"updateTemplate,omitempty"` + + // +optional + DeletionCondition string `json:"deletionCondition,omitempty"` + */ +} + +func (policy Policy) Validate() (errs []error) { + if _, err := newTemplate("", policy.Template); err != nil { + errs = append(errs, err) + } + if _, err := newTemplate("", policy.CreationCondition); err != nil { + errs = append(errs, err) + } + + return errs +} + +func (policy Policy) CouldCreate(writer *bytes.Buffer, data interface{}) (bool, error) { + tmpl, err := newTemplate("creationcondition", policy.CreationCondition) + if err != nil { + return false, err + } + + writer.Reset() + if err := tmpl.Execute(writer, data); err != nil { + return false, err + } + return strings.TrimSpace(strings.ToLower(replaceNoValue(writer.String()))) == "true", nil +} + +func (policy Policy) ResolvePediaCluster(writer *bytes.Buffer, data interface{}) ([]byte, error) { + tmpl, err := newTemplate("pediacluster", policy.Template) + if err != nil { + return nil, err + } + + writer.Reset() + if err := tmpl.Execute(writer, data); err != nil { + return nil, err + } + return bytes.ReplaceAll(writer.Bytes(), []byte(""), []byte("")), nil +} + +type BaseReferenceResourceTemplate struct { + // +required + // +kubebuilder:validation:Required + Key string `json:"key"` + + // +required + // +kubebuilder:validation:Required + Group string `json:"group"` + + // +required + // +kubebuilder:validation:Required + Resource string `json:"resource"` + + // +optional + NamespaceTemplate string `json:"namespaceTemplate,omitempty"` + + // +required + // +kubebuilder:validation:Required + NameTemplate string `json:"nameTemplate"` +} + +func (ref BaseReferenceResourceTemplate) GroupResource() schema.GroupResource { + return schema.GroupResource{Group: ref.Group, Resource: ref.Resource} +} + +func (ref BaseReferenceResourceTemplate) ResolveNamespaceAndName(writer *bytes.Buffer, data interface{}) (namespace, name string, err error) { + if ref.NamespaceTemplate != "" { + tmpl, err := newTemplate("references", ref.NamespaceTemplate) + if err != nil { + return "", "", fmt.Errorf("namespace: %w", err) + } + writer.Reset() + if err := tmpl.Execute(writer, data); err != nil { + return "", "", fmt.Errorf("namespace: %w", err) + } + namespace = replaceNoValue(writer.String()) + } + + tmpl, err := newTemplate("references", ref.NameTemplate) + if err != nil { + return "", "", fmt.Errorf("name: %w", err) + } + writer.Reset() + if err := tmpl.Execute(writer, data); err != nil { + return "", "", fmt.Errorf("name: %w", err) + } + name = replaceNoValue(writer.String()) + return +} + +type IntendReferenceResourceTemplate struct { + BaseReferenceResourceTemplate `json:",inline"` + + // +optional + Versions []string `json:"versions,omitempty"` +} + +type ReferenceResourceTemplate struct { + BaseReferenceResourceTemplate `json:",inline"` + + // +required + // +kubebuilder:validation:Required + Version string `json:"version"` +} + +func (r ReferenceResourceTemplate) String() string { + strs := []string{r.Group, r.Version, r.Resource} + if r.NamespaceTemplate != "" { + strs = append(strs, r.NamespaceTemplate) + } + strs = append(strs, r.NameTemplate) + return strings.Join(strs, "/") +} + +func (r ReferenceResourceTemplate) GroupVersionResource() schema.GroupVersionResource { + return schema.GroupVersionResource{Group: r.Group, Version: r.Version, Resource: r.Resource} +} + +func (ref ReferenceResourceTemplate) Validate(errs []error) { + if ref.Key == "" { + errs = append(errs, errors.New("reference resource key is required")) + } + + if ref.NameTemplate == "" { + errs = append(errs, errors.New("reference resource name is required")) + } + return +} + +func (ref ReferenceResourceTemplate) Resolve(writer *bytes.Buffer, data interface{}) (DependentResource, error) { + namespace, name, err := ref.ResolveNamespaceAndName(writer, data) + if err != nil { + return DependentResource{}, err + } + return DependentResource{Group: ref.Group, Version: ref.Version, Resource: ref.Resource, + Namespace: namespace, Name: name}, nil +} + +type SourceType struct { + // +required + // +kubebuilder:validation:Required + Group string `json:"group"` + + // +optional + Versions []string `json:"versions,omitempty"` + + // +required + // +kubebuilder:validation:Required + Resource string `json:"resource"` + + // +optional + SelectorTemplate SelectorTemplate `json:"selectorTemplate,omitempty"` +} + +func (st SourceType) GroupResource() schema.GroupResource { + return schema.GroupResource{Group: st.Group, Resource: st.Resource} +} + +type SelectorTemplate string + +func (t SelectorTemplate) Template() (*template.Template, error) { + return newTemplate("select-source", string(t)) +} + +type DependentResource struct { + // +required + // +kubebuilder:validation:Required + Group string `json:"group"` + + // +required + // +kubebuilder:validation:Required + Version string `json:"version"` + + // +required + // +kubebuilder:validation:Required + Resource string `json:"resource"` + + // +optional + Namespace string `json:"namespace"` + + // +required + // +kubebuilder:validation:Required + Name string `json:"name"` +} + +func (r DependentResource) GroupVersionResource() schema.GroupVersionResource { + return schema.GroupVersionResource{Group: r.Group, Version: r.Version, Resource: r.Resource} +} + +// +kubebuilder:object:root=true +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +// +k8s:openapi-gen=true + +type ClusterImportPolicyList struct { + metav1.TypeMeta `json:",inline"` + + // +optional + metav1.ListMeta `json:"metadata,omitempty"` + + Items []ClusterImportPolicy `json:"items"` +} + +// +kubebuilder:object:root=true +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object +// +k8s:openapi-gen=true + +type PediaClusterLifecycleList struct { + metav1.TypeMeta `json:",inline"` + + // +optional + metav1.ListMeta `json:"metadata,omitempty"` + + Items []PediaClusterLifecycle `json:"items"` +} + +func newTemplate(name string, tmpltext string) (*template.Template, error) { + return template.New(name).Funcs(sprig.FuncMap()).Parse(tmpltext) +} + +func replaceNoValue(value string) string { + return strings.ReplaceAll(value, "", "") +} diff --git a/vendor/github.com/clusterpedia-io/api/policy/v1alpha1/zz_generated.deepcopy.go b/vendor/github.com/clusterpedia-io/api/policy/v1alpha1/zz_generated.deepcopy.go new file mode 100644 index 000000000..cf3c97873 --- /dev/null +++ b/vendor/github.com/clusterpedia-io/api/policy/v1alpha1/zz_generated.deepcopy.go @@ -0,0 +1,340 @@ +//go:build !ignore_autogenerated +// +build !ignore_autogenerated + +// Code generated by deepcopy-gen. DO NOT EDIT. + +package v1alpha1 + +import ( + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" +) + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *BaseReferenceResourceTemplate) DeepCopyInto(out *BaseReferenceResourceTemplate) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new BaseReferenceResourceTemplate. +func (in *BaseReferenceResourceTemplate) DeepCopy() *BaseReferenceResourceTemplate { + if in == nil { + return nil + } + out := new(BaseReferenceResourceTemplate) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ClusterImportPolicy) DeepCopyInto(out *ClusterImportPolicy) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) + in.Status.DeepCopyInto(&out.Status) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterImportPolicy. +func (in *ClusterImportPolicy) DeepCopy() *ClusterImportPolicy { + if in == nil { + return nil + } + out := new(ClusterImportPolicy) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *ClusterImportPolicy) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ClusterImportPolicyList) DeepCopyInto(out *ClusterImportPolicyList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]ClusterImportPolicy, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterImportPolicyList. +func (in *ClusterImportPolicyList) DeepCopy() *ClusterImportPolicyList { + if in == nil { + return nil + } + out := new(ClusterImportPolicyList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *ClusterImportPolicyList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ClusterImportPolicySpec) DeepCopyInto(out *ClusterImportPolicySpec) { + *out = *in + in.Source.DeepCopyInto(&out.Source) + if in.References != nil { + in, out := &in.References, &out.References + *out = make([]IntendReferenceResourceTemplate, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + out.Policy = in.Policy + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterImportPolicySpec. +func (in *ClusterImportPolicySpec) DeepCopy() *ClusterImportPolicySpec { + if in == nil { + return nil + } + out := new(ClusterImportPolicySpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ClusterImportPolicyStatus) DeepCopyInto(out *ClusterImportPolicyStatus) { + *out = *in + if in.Conditions != nil { + in, out := &in.Conditions, &out.Conditions + *out = make([]v1.Condition, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterImportPolicyStatus. +func (in *ClusterImportPolicyStatus) DeepCopy() *ClusterImportPolicyStatus { + if in == nil { + return nil + } + out := new(ClusterImportPolicyStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *DependentResource) DeepCopyInto(out *DependentResource) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new DependentResource. +func (in *DependentResource) DeepCopy() *DependentResource { + if in == nil { + return nil + } + out := new(DependentResource) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *IntendReferenceResourceTemplate) DeepCopyInto(out *IntendReferenceResourceTemplate) { + *out = *in + out.BaseReferenceResourceTemplate = in.BaseReferenceResourceTemplate + if in.Versions != nil { + in, out := &in.Versions, &out.Versions + *out = make([]string, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new IntendReferenceResourceTemplate. +func (in *IntendReferenceResourceTemplate) DeepCopy() *IntendReferenceResourceTemplate { + if in == nil { + return nil + } + out := new(IntendReferenceResourceTemplate) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *PediaClusterLifecycle) DeepCopyInto(out *PediaClusterLifecycle) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + in.Spec.DeepCopyInto(&out.Spec) + in.Status.DeepCopyInto(&out.Status) + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PediaClusterLifecycle. +func (in *PediaClusterLifecycle) DeepCopy() *PediaClusterLifecycle { + if in == nil { + return nil + } + out := new(PediaClusterLifecycle) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *PediaClusterLifecycle) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *PediaClusterLifecycleList) DeepCopyInto(out *PediaClusterLifecycleList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]PediaClusterLifecycle, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PediaClusterLifecycleList. +func (in *PediaClusterLifecycleList) DeepCopy() *PediaClusterLifecycleList { + if in == nil { + return nil + } + out := new(PediaClusterLifecycleList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *PediaClusterLifecycleList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *PediaClusterLifecycleSpec) DeepCopyInto(out *PediaClusterLifecycleSpec) { + *out = *in + out.Source = in.Source + if in.References != nil { + in, out := &in.References, &out.References + *out = make([]ReferenceResourceTemplate, len(*in)) + copy(*out, *in) + } + out.Policy = in.Policy + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PediaClusterLifecycleSpec. +func (in *PediaClusterLifecycleSpec) DeepCopy() *PediaClusterLifecycleSpec { + if in == nil { + return nil + } + out := new(PediaClusterLifecycleSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *PediaClusterLifecycleStatus) DeepCopyInto(out *PediaClusterLifecycleStatus) { + *out = *in + if in.Conditions != nil { + in, out := &in.Conditions, &out.Conditions + *out = make([]v1.Condition, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + if in.References != nil { + in, out := &in.References, &out.References + *out = make([]DependentResource, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PediaClusterLifecycleStatus. +func (in *PediaClusterLifecycleStatus) DeepCopy() *PediaClusterLifecycleStatus { + if in == nil { + return nil + } + out := new(PediaClusterLifecycleStatus) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *Policy) DeepCopyInto(out *Policy) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Policy. +func (in *Policy) DeepCopy() *Policy { + if in == nil { + return nil + } + out := new(Policy) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ReferenceResourceTemplate) DeepCopyInto(out *ReferenceResourceTemplate) { + *out = *in + out.BaseReferenceResourceTemplate = in.BaseReferenceResourceTemplate + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ReferenceResourceTemplate. +func (in *ReferenceResourceTemplate) DeepCopy() *ReferenceResourceTemplate { + if in == nil { + return nil + } + out := new(ReferenceResourceTemplate) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *SourceType) DeepCopyInto(out *SourceType) { + *out = *in + if in.Versions != nil { + in, out := &in.Versions, &out.Versions + *out = make([]string, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new SourceType. +func (in *SourceType) DeepCopy() *SourceType { + if in == nil { + return nil + } + out := new(SourceType) + in.DeepCopyInto(out) + return out +} diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.7.0/doc.go b/vendor/go.opentelemetry.io/otel/semconv/v1.7.0/doc.go new file mode 100644 index 000000000..ba878d1cf --- /dev/null +++ b/vendor/go.opentelemetry.io/otel/semconv/v1.7.0/doc.go @@ -0,0 +1,20 @@ +// Copyright The OpenTelemetry Authors +// +// Licensed 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 semconv implements OpenTelemetry semantic conventions. +// +// OpenTelemetry semantic conventions are agreed standardized naming +// patterns for OpenTelemetry things. This package represents the conventions +// as of the v1.7.0 version of the OpenTelemetry specification. +package semconv // import "go.opentelemetry.io/otel/semconv/v1.7.0" diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.7.0/exception.go b/vendor/go.opentelemetry.io/otel/semconv/v1.7.0/exception.go new file mode 100644 index 000000000..ea3706862 --- /dev/null +++ b/vendor/go.opentelemetry.io/otel/semconv/v1.7.0/exception.go @@ -0,0 +1,20 @@ +// Copyright The OpenTelemetry Authors +// +// Licensed 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 semconv // import "go.opentelemetry.io/otel/semconv/v1.7.0" + +const ( + // ExceptionEventName is the name of the Span event representing an exception. + ExceptionEventName = "exception" +) diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.7.0/http.go b/vendor/go.opentelemetry.io/otel/semconv/v1.7.0/http.go new file mode 100644 index 000000000..945c95a18 --- /dev/null +++ b/vendor/go.opentelemetry.io/otel/semconv/v1.7.0/http.go @@ -0,0 +1,114 @@ +// Copyright The OpenTelemetry Authors +// +// Licensed 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 semconv // import "go.opentelemetry.io/otel/semconv/v1.7.0" + +import ( + "net/http" + + "go.opentelemetry.io/otel/attribute" + "go.opentelemetry.io/otel/codes" + "go.opentelemetry.io/otel/semconv/internal" + "go.opentelemetry.io/otel/trace" +) + +// HTTP scheme attributes. +var ( + HTTPSchemeHTTP = HTTPSchemeKey.String("http") + HTTPSchemeHTTPS = HTTPSchemeKey.String("https") +) + +var sc = &internal.SemanticConventions{ + EnduserIDKey: EnduserIDKey, + HTTPClientIPKey: HTTPClientIPKey, + HTTPFlavorKey: HTTPFlavorKey, + HTTPHostKey: HTTPHostKey, + HTTPMethodKey: HTTPMethodKey, + HTTPRequestContentLengthKey: HTTPRequestContentLengthKey, + HTTPRouteKey: HTTPRouteKey, + HTTPSchemeHTTP: HTTPSchemeHTTP, + HTTPSchemeHTTPS: HTTPSchemeHTTPS, + HTTPServerNameKey: HTTPServerNameKey, + HTTPStatusCodeKey: HTTPStatusCodeKey, + HTTPTargetKey: HTTPTargetKey, + HTTPURLKey: HTTPURLKey, + HTTPUserAgentKey: HTTPUserAgentKey, + NetHostIPKey: NetHostIPKey, + NetHostNameKey: NetHostNameKey, + NetHostPortKey: NetHostPortKey, + NetPeerIPKey: NetPeerIPKey, + NetPeerNameKey: NetPeerNameKey, + NetPeerPortKey: NetPeerPortKey, + NetTransportIP: NetTransportIP, + NetTransportOther: NetTransportOther, + NetTransportTCP: NetTransportTCP, + NetTransportUDP: NetTransportUDP, + NetTransportUnix: NetTransportUnix, +} + +// NetAttributesFromHTTPRequest generates attributes of the net +// namespace as specified by the OpenTelemetry specification for a +// span. The network parameter is a string that net.Dial function +// from standard library can understand. +func NetAttributesFromHTTPRequest(network string, request *http.Request) []attribute.KeyValue { + return sc.NetAttributesFromHTTPRequest(network, request) +} + +// EndUserAttributesFromHTTPRequest generates attributes of the +// enduser namespace as specified by the OpenTelemetry specification +// for a span. +func EndUserAttributesFromHTTPRequest(request *http.Request) []attribute.KeyValue { + return sc.EndUserAttributesFromHTTPRequest(request) +} + +// HTTPClientAttributesFromHTTPRequest generates attributes of the +// http namespace as specified by the OpenTelemetry specification for +// a span on the client side. +func HTTPClientAttributesFromHTTPRequest(request *http.Request) []attribute.KeyValue { + return sc.HTTPClientAttributesFromHTTPRequest(request) +} + +// HTTPServerMetricAttributesFromHTTPRequest generates low-cardinality attributes +// to be used with server-side HTTP metrics. +func HTTPServerMetricAttributesFromHTTPRequest(serverName string, request *http.Request) []attribute.KeyValue { + return sc.HTTPServerMetricAttributesFromHTTPRequest(serverName, request) +} + +// HTTPServerAttributesFromHTTPRequest generates attributes of the +// http namespace as specified by the OpenTelemetry specification for +// a span on the server side. Currently, only basic authentication is +// supported. +func HTTPServerAttributesFromHTTPRequest(serverName, route string, request *http.Request) []attribute.KeyValue { + return sc.HTTPServerAttributesFromHTTPRequest(serverName, route, request) +} + +// HTTPAttributesFromHTTPStatusCode generates attributes of the http +// namespace as specified by the OpenTelemetry specification for a +// span. +func HTTPAttributesFromHTTPStatusCode(code int) []attribute.KeyValue { + return sc.HTTPAttributesFromHTTPStatusCode(code) +} + +// SpanStatusFromHTTPStatusCode generates a status code and a message +// as specified by the OpenTelemetry specification for a span. +func SpanStatusFromHTTPStatusCode(code int) (codes.Code, string) { + return internal.SpanStatusFromHTTPStatusCode(code) +} + +// SpanStatusFromHTTPStatusCodeAndSpanKind generates a status code and a message +// as specified by the OpenTelemetry specification for a span. +// Exclude 4xx for SERVER to set the appropriate status. +func SpanStatusFromHTTPStatusCodeAndSpanKind(code int, spanKind trace.SpanKind) (codes.Code, string) { + return internal.SpanStatusFromHTTPStatusCodeAndSpanKind(code, spanKind) +} diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.7.0/resource.go b/vendor/go.opentelemetry.io/otel/semconv/v1.7.0/resource.go new file mode 100644 index 000000000..aab6daf3c --- /dev/null +++ b/vendor/go.opentelemetry.io/otel/semconv/v1.7.0/resource.go @@ -0,0 +1,946 @@ +// Copyright The OpenTelemetry Authors +// +// Licensed 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. + +// Code generated from semantic convention specification. DO NOT EDIT. + +package semconv // import "go.opentelemetry.io/otel/semconv/v1.7.0" + +import "go.opentelemetry.io/otel/attribute" + +// A cloud environment (e.g. GCP, Azure, AWS) +const ( + // Name of the cloud provider. + // + // Type: Enum + // Required: No + // Stability: stable + CloudProviderKey = attribute.Key("cloud.provider") + // The cloud account ID the resource is assigned to. + // + // Type: string + // Required: No + // Stability: stable + // Examples: '111111111111', 'opentelemetry' + CloudAccountIDKey = attribute.Key("cloud.account.id") + // The geographical region the resource is running. Refer to your provider's docs + // to see the available regions, for example [Alibaba Cloud + // regions](https://www.alibabacloud.com/help/doc-detail/40654.htm), [AWS + // regions](https://aws.amazon.com/about-aws/global-infrastructure/regions_az/), + // [Azure regions](https://azure.microsoft.com/en-us/global- + // infrastructure/geographies/), or [Google Cloud + // regions](https://cloud.google.com/about/locations). + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'us-central1', 'us-east-1' + CloudRegionKey = attribute.Key("cloud.region") + // Cloud regions often have multiple, isolated locations known as zones to + // increase availability. Availability zone represents the zone where the resource + // is running. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'us-east-1c' + // Note: Availability zones are called "zones" on Alibaba Cloud and Google Cloud. + CloudAvailabilityZoneKey = attribute.Key("cloud.availability_zone") + // The cloud platform in use. + // + // Type: Enum + // Required: No + // Stability: stable + // Note: The prefix of the service SHOULD match the one specified in + // `cloud.provider`. + CloudPlatformKey = attribute.Key("cloud.platform") +) + +var ( + // Alibaba Cloud + CloudProviderAlibabaCloud = CloudProviderKey.String("alibaba_cloud") + // Amazon Web Services + CloudProviderAWS = CloudProviderKey.String("aws") + // Microsoft Azure + CloudProviderAzure = CloudProviderKey.String("azure") + // Google Cloud Platform + CloudProviderGCP = CloudProviderKey.String("gcp") +) + +var ( + // Alibaba Cloud Elastic Compute Service + CloudPlatformAlibabaCloudECS = CloudPlatformKey.String("alibaba_cloud_ecs") + // Alibaba Cloud Function Compute + CloudPlatformAlibabaCloudFc = CloudPlatformKey.String("alibaba_cloud_fc") + // AWS Elastic Compute Cloud + CloudPlatformAWSEC2 = CloudPlatformKey.String("aws_ec2") + // AWS Elastic Container Service + CloudPlatformAWSECS = CloudPlatformKey.String("aws_ecs") + // AWS Elastic Kubernetes Service + CloudPlatformAWSEKS = CloudPlatformKey.String("aws_eks") + // AWS Lambda + CloudPlatformAWSLambda = CloudPlatformKey.String("aws_lambda") + // AWS Elastic Beanstalk + CloudPlatformAWSElasticBeanstalk = CloudPlatformKey.String("aws_elastic_beanstalk") + // Azure Virtual Machines + CloudPlatformAzureVM = CloudPlatformKey.String("azure_vm") + // Azure Container Instances + CloudPlatformAzureContainerInstances = CloudPlatformKey.String("azure_container_instances") + // Azure Kubernetes Service + CloudPlatformAzureAKS = CloudPlatformKey.String("azure_aks") + // Azure Functions + CloudPlatformAzureFunctions = CloudPlatformKey.String("azure_functions") + // Azure App Service + CloudPlatformAzureAppService = CloudPlatformKey.String("azure_app_service") + // Google Cloud Compute Engine (GCE) + CloudPlatformGCPComputeEngine = CloudPlatformKey.String("gcp_compute_engine") + // Google Cloud Run + CloudPlatformGCPCloudRun = CloudPlatformKey.String("gcp_cloud_run") + // Google Cloud Kubernetes Engine (GKE) + CloudPlatformGCPKubernetesEngine = CloudPlatformKey.String("gcp_kubernetes_engine") + // Google Cloud Functions (GCF) + CloudPlatformGCPCloudFunctions = CloudPlatformKey.String("gcp_cloud_functions") + // Google Cloud App Engine (GAE) + CloudPlatformGCPAppEngine = CloudPlatformKey.String("gcp_app_engine") +) + +// Resources used by AWS Elastic Container Service (ECS). +const ( + // The Amazon Resource Name (ARN) of an [ECS container instance](https://docs.aws. + // amazon.com/AmazonECS/latest/developerguide/ECS_instances.html). + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'arn:aws:ecs:us- + // west-1:123456789123:container/32624152-9086-4f0e-acae-1a75b14fe4d9' + AWSECSContainerARNKey = attribute.Key("aws.ecs.container.arn") + // The ARN of an [ECS cluster](https://docs.aws.amazon.com/AmazonECS/latest/develo + // perguide/clusters.html). + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'arn:aws:ecs:us-west-2:123456789123:cluster/my-cluster' + AWSECSClusterARNKey = attribute.Key("aws.ecs.cluster.arn") + // The [launch type](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/l + // aunch_types.html) for an ECS task. + // + // Type: Enum + // Required: No + // Stability: stable + AWSECSLaunchtypeKey = attribute.Key("aws.ecs.launchtype") + // The ARN of an [ECS task definition](https://docs.aws.amazon.com/AmazonECS/lates + // t/developerguide/task_definitions.html). + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'arn:aws:ecs:us- + // west-1:123456789123:task/10838bed-421f-43ef-870a-f43feacbbb5b' + AWSECSTaskARNKey = attribute.Key("aws.ecs.task.arn") + // The task definition family this task definition is a member of. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'opentelemetry-family' + AWSECSTaskFamilyKey = attribute.Key("aws.ecs.task.family") + // The revision for this task definition. + // + // Type: string + // Required: No + // Stability: stable + // Examples: '8', '26' + AWSECSTaskRevisionKey = attribute.Key("aws.ecs.task.revision") +) + +var ( + // ec2 + AWSECSLaunchtypeEC2 = AWSECSLaunchtypeKey.String("ec2") + // fargate + AWSECSLaunchtypeFargate = AWSECSLaunchtypeKey.String("fargate") +) + +// Resources used by AWS Elastic Kubernetes Service (EKS). +const ( + // The ARN of an EKS cluster. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'arn:aws:ecs:us-west-2:123456789123:cluster/my-cluster' + AWSEKSClusterARNKey = attribute.Key("aws.eks.cluster.arn") +) + +// Resources specific to Amazon Web Services. +const ( + // The name(s) of the AWS log group(s) an application is writing to. + // + // Type: string[] + // Required: No + // Stability: stable + // Examples: '/aws/lambda/my-function', 'opentelemetry-service' + // Note: Multiple log groups must be supported for cases like multi-container + // applications, where a single application has sidecar containers, and each write + // to their own log group. + AWSLogGroupNamesKey = attribute.Key("aws.log.group.names") + // The Amazon Resource Name(s) (ARN) of the AWS log group(s). + // + // Type: string[] + // Required: No + // Stability: stable + // Examples: 'arn:aws:logs:us-west-1:123456789012:log-group:/aws/my/group:*' + // Note: See the [log group ARN format + // documentation](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/iam- + // access-control-overview-cwl.html#CWL_ARN_Format). + AWSLogGroupARNsKey = attribute.Key("aws.log.group.arns") + // The name(s) of the AWS log stream(s) an application is writing to. + // + // Type: string[] + // Required: No + // Stability: stable + // Examples: 'logs/main/10838bed-421f-43ef-870a-f43feacbbb5b' + AWSLogStreamNamesKey = attribute.Key("aws.log.stream.names") + // The ARN(s) of the AWS log stream(s). + // + // Type: string[] + // Required: No + // Stability: stable + // Examples: 'arn:aws:logs:us-west-1:123456789012:log-group:/aws/my/group:log- + // stream:logs/main/10838bed-421f-43ef-870a-f43feacbbb5b' + // Note: See the [log stream ARN format + // documentation](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/iam- + // access-control-overview-cwl.html#CWL_ARN_Format). One log group can contain + // several log streams, so these ARNs necessarily identify both a log group and a + // log stream. + AWSLogStreamARNsKey = attribute.Key("aws.log.stream.arns") +) + +// A container instance. +const ( + // Container name. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'opentelemetry-autoconf' + ContainerNameKey = attribute.Key("container.name") + // Container ID. Usually a UUID, as for example used to [identify Docker + // containers](https://docs.docker.com/engine/reference/run/#container- + // identification). The UUID might be abbreviated. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'a3bf90e006b2' + ContainerIDKey = attribute.Key("container.id") + // The container runtime managing this container. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'docker', 'containerd', 'rkt' + ContainerRuntimeKey = attribute.Key("container.runtime") + // Name of the image the container was built on. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'gcr.io/opentelemetry/operator' + ContainerImageNameKey = attribute.Key("container.image.name") + // Container image tag. + // + // Type: string + // Required: No + // Stability: stable + // Examples: '0.1' + ContainerImageTagKey = attribute.Key("container.image.tag") +) + +// The software deployment. +const ( + // Name of the [deployment + // environment](https://en.wikipedia.org/wiki/Deployment_environment) (aka + // deployment tier). + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'staging', 'production' + DeploymentEnvironmentKey = attribute.Key("deployment.environment") +) + +// The device on which the process represented by this resource is running. +const ( + // A unique identifier representing the device + // + // Type: string + // Required: No + // Stability: stable + // Examples: '2ab2916d-a51f-4ac8-80ee-45ac31a28092' + // Note: The device identifier MUST only be defined using the values outlined + // below. This value is not an advertising identifier and MUST NOT be used as + // such. On iOS (Swift or Objective-C), this value MUST be equal to the [vendor id + // entifier](https://developer.apple.com/documentation/uikit/uidevice/1620059-iden + // tifierforvendor). On Android (Java or Kotlin), this value MUST be equal to the + // Firebase Installation ID or a globally unique UUID which is persisted across + // sessions in your application. More information can be found + // [here](https://developer.android.com/training/articles/user-data-ids) on best + // practices and exact implementation details. Caution should be taken when + // storing personal data or anything which can identify a user. GDPR and data + // protection laws may apply, ensure you do your own due diligence. + DeviceIDKey = attribute.Key("device.id") + // The model identifier for the device + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'iPhone3,4', 'SM-G920F' + // Note: It's recommended this value represents a machine readable version of the + // model identifier rather than the market or consumer-friendly name of the + // device. + DeviceModelIdentifierKey = attribute.Key("device.model.identifier") + // The marketing name for the device model + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'iPhone 6s Plus', 'Samsung Galaxy S6' + // Note: It's recommended this value represents a human readable version of the + // device model rather than a machine readable alternative. + DeviceModelNameKey = attribute.Key("device.model.name") +) + +// A serverless instance. +const ( + // The name of the single function that this runtime instance executes. + // + // Type: string + // Required: Always + // Stability: stable + // Examples: 'my-function' + // Note: This is the name of the function as configured/deployed on the FaaS + // platform and is usually different from the name of the callback function (which + // may be stored in the + // [`code.namespace`/`code.function`](../../trace/semantic_conventions/span- + // general.md#source-code-attributes) span attributes). + FaaSNameKey = attribute.Key("faas.name") + // The unique ID of the single function that this runtime instance executes. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'arn:aws:lambda:us-west-2:123456789012:function:my-function' + // Note: Depending on the cloud provider, use: + + // * **AWS Lambda:** The function + // [ARN](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and- + // namespaces.html). + // Take care not to use the "invoked ARN" directly but replace any + // [alias suffix](https://docs.aws.amazon.com/lambda/latest/dg/configuration- + // aliases.html) with the resolved function version, as the same runtime instance + // may be invokable with multiple + // different aliases. + // * **GCP:** The [URI of the resource](https://cloud.google.com/iam/docs/full- + // resource-names) + // * **Azure:** The [Fully Qualified Resource ID](https://docs.microsoft.com/en- + // us/rest/api/resources/resources/get-by-id). + + // On some providers, it may not be possible to determine the full ID at startup, + // which is why this field cannot be made required. For example, on AWS the + // account ID + // part of the ARN is not available without calling another AWS API + // which may be deemed too slow for a short-running lambda function. + // As an alternative, consider setting `faas.id` as a span attribute instead. + FaaSIDKey = attribute.Key("faas.id") + // The immutable version of the function being executed. + // + // Type: string + // Required: No + // Stability: stable + // Examples: '26', 'pinkfroid-00002' + // Note: Depending on the cloud provider and platform, use: + + // * **AWS Lambda:** The [function + // version](https://docs.aws.amazon.com/lambda/latest/dg/configuration- + // versions.html) + // (an integer represented as a decimal string). + // * **Google Cloud Run:** The + // [revision](https://cloud.google.com/run/docs/managing/revisions) + // (i.e., the function name plus the revision suffix). + // * **Google Cloud Functions:** The value of the + // [`K_REVISION` environment + // variable](https://cloud.google.com/functions/docs/env- + // var#runtime_environment_variables_set_automatically). + // * **Azure Functions:** Not applicable. Do not set this attribute. + FaaSVersionKey = attribute.Key("faas.version") + // The execution environment ID as a string, that will be potentially reused for + // other invocations to the same function/function version. + // + // Type: string + // Required: No + // Stability: stable + // Examples: '2021/06/28/[$LATEST]2f399eb14537447da05ab2a2e39309de' + // Note: * **AWS Lambda:** Use the (full) log stream name. + FaaSInstanceKey = attribute.Key("faas.instance") + // The amount of memory available to the serverless function in MiB. + // + // Type: int + // Required: No + // Stability: stable + // Examples: 128 + // Note: It's recommended to set this attribute since e.g. too little memory can + // easily stop a Java AWS Lambda function from working correctly. On AWS Lambda, + // the environment variable `AWS_LAMBDA_FUNCTION_MEMORY_SIZE` provides this + // information. + FaaSMaxMemoryKey = attribute.Key("faas.max_memory") +) + +// A host is defined as a general computing instance. +const ( + // Unique host ID. For Cloud, this must be the instance_id assigned by the cloud + // provider. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'opentelemetry-test' + HostIDKey = attribute.Key("host.id") + // Name of the host. On Unix systems, it may contain what the hostname command + // returns, or the fully qualified hostname, or another name specified by the + // user. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'opentelemetry-test' + HostNameKey = attribute.Key("host.name") + // Type of host. For Cloud, this must be the machine type. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'n1-standard-1' + HostTypeKey = attribute.Key("host.type") + // The CPU architecture the host system is running on. + // + // Type: Enum + // Required: No + // Stability: stable + HostArchKey = attribute.Key("host.arch") + // Name of the VM image or OS install the host was instantiated from. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'infra-ami-eks-worker-node-7d4ec78312', 'CentOS-8-x86_64-1905' + HostImageNameKey = attribute.Key("host.image.name") + // VM image ID. For Cloud, this value is from the provider. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'ami-07b06b442921831e5' + HostImageIDKey = attribute.Key("host.image.id") + // The version string of the VM image as defined in [Version + // Attributes](README.md#version-attributes). + // + // Type: string + // Required: No + // Stability: stable + // Examples: '0.1' + HostImageVersionKey = attribute.Key("host.image.version") +) + +var ( + // AMD64 + HostArchAMD64 = HostArchKey.String("amd64") + // ARM32 + HostArchARM32 = HostArchKey.String("arm32") + // ARM64 + HostArchARM64 = HostArchKey.String("arm64") + // Itanium + HostArchIA64 = HostArchKey.String("ia64") + // 32-bit PowerPC + HostArchPPC32 = HostArchKey.String("ppc32") + // 64-bit PowerPC + HostArchPPC64 = HostArchKey.String("ppc64") + // 32-bit x86 + HostArchX86 = HostArchKey.String("x86") +) + +// A Kubernetes Cluster. +const ( + // The name of the cluster. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'opentelemetry-cluster' + K8SClusterNameKey = attribute.Key("k8s.cluster.name") +) + +// A Kubernetes Node object. +const ( + // The name of the Node. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'node-1' + K8SNodeNameKey = attribute.Key("k8s.node.name") + // The UID of the Node. + // + // Type: string + // Required: No + // Stability: stable + // Examples: '1eb3a0c6-0477-4080-a9cb-0cb7db65c6a2' + K8SNodeUIDKey = attribute.Key("k8s.node.uid") +) + +// A Kubernetes Namespace. +const ( + // The name of the namespace that the pod is running in. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'default' + K8SNamespaceNameKey = attribute.Key("k8s.namespace.name") +) + +// A Kubernetes Pod object. +const ( + // The UID of the Pod. + // + // Type: string + // Required: No + // Stability: stable + // Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff' + K8SPodUIDKey = attribute.Key("k8s.pod.uid") + // The name of the Pod. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'opentelemetry-pod-autoconf' + K8SPodNameKey = attribute.Key("k8s.pod.name") +) + +// A container in a [PodTemplate](https://kubernetes.io/docs/concepts/workloads/pods/#pod-templates). +const ( + // The name of the Container in a Pod template. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'redis' + K8SContainerNameKey = attribute.Key("k8s.container.name") +) + +// A Kubernetes ReplicaSet object. +const ( + // The UID of the ReplicaSet. + // + // Type: string + // Required: No + // Stability: stable + // Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff' + K8SReplicaSetUIDKey = attribute.Key("k8s.replicaset.uid") + // The name of the ReplicaSet. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'opentelemetry' + K8SReplicaSetNameKey = attribute.Key("k8s.replicaset.name") +) + +// A Kubernetes Deployment object. +const ( + // The UID of the Deployment. + // + // Type: string + // Required: No + // Stability: stable + // Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff' + K8SDeploymentUIDKey = attribute.Key("k8s.deployment.uid") + // The name of the Deployment. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'opentelemetry' + K8SDeploymentNameKey = attribute.Key("k8s.deployment.name") +) + +// A Kubernetes StatefulSet object. +const ( + // The UID of the StatefulSet. + // + // Type: string + // Required: No + // Stability: stable + // Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff' + K8SStatefulSetUIDKey = attribute.Key("k8s.statefulset.uid") + // The name of the StatefulSet. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'opentelemetry' + K8SStatefulSetNameKey = attribute.Key("k8s.statefulset.name") +) + +// A Kubernetes DaemonSet object. +const ( + // The UID of the DaemonSet. + // + // Type: string + // Required: No + // Stability: stable + // Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff' + K8SDaemonSetUIDKey = attribute.Key("k8s.daemonset.uid") + // The name of the DaemonSet. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'opentelemetry' + K8SDaemonSetNameKey = attribute.Key("k8s.daemonset.name") +) + +// A Kubernetes Job object. +const ( + // The UID of the Job. + // + // Type: string + // Required: No + // Stability: stable + // Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff' + K8SJobUIDKey = attribute.Key("k8s.job.uid") + // The name of the Job. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'opentelemetry' + K8SJobNameKey = attribute.Key("k8s.job.name") +) + +// A Kubernetes CronJob object. +const ( + // The UID of the CronJob. + // + // Type: string + // Required: No + // Stability: stable + // Examples: '275ecb36-5aa8-4c2a-9c47-d8bb681b9aff' + K8SCronJobUIDKey = attribute.Key("k8s.cronjob.uid") + // The name of the CronJob. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'opentelemetry' + K8SCronJobNameKey = attribute.Key("k8s.cronjob.name") +) + +// The operating system (OS) on which the process represented by this resource is running. +const ( + // The operating system type. + // + // Type: Enum + // Required: Always + // Stability: stable + OSTypeKey = attribute.Key("os.type") + // Human readable (not intended to be parsed) OS version information, like e.g. + // reported by `ver` or `lsb_release -a` commands. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'Microsoft Windows [Version 10.0.18363.778]', 'Ubuntu 18.04.1 LTS' + OSDescriptionKey = attribute.Key("os.description") + // Human readable operating system name. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'iOS', 'Android', 'Ubuntu' + OSNameKey = attribute.Key("os.name") + // The version string of the operating system as defined in [Version + // Attributes](../../resource/semantic_conventions/README.md#version-attributes). + // + // Type: string + // Required: No + // Stability: stable + // Examples: '14.2.1', '18.04.1' + OSVersionKey = attribute.Key("os.version") +) + +var ( + // Microsoft Windows + OSTypeWindows = OSTypeKey.String("windows") + // Linux + OSTypeLinux = OSTypeKey.String("linux") + // Apple Darwin + OSTypeDarwin = OSTypeKey.String("darwin") + // FreeBSD + OSTypeFreeBSD = OSTypeKey.String("freebsd") + // NetBSD + OSTypeNetBSD = OSTypeKey.String("netbsd") + // OpenBSD + OSTypeOpenBSD = OSTypeKey.String("openbsd") + // DragonFly BSD + OSTypeDragonflyBSD = OSTypeKey.String("dragonflybsd") + // HP-UX (Hewlett Packard Unix) + OSTypeHPUX = OSTypeKey.String("hpux") + // AIX (Advanced Interactive eXecutive) + OSTypeAIX = OSTypeKey.String("aix") + // Oracle Solaris + OSTypeSolaris = OSTypeKey.String("solaris") + // IBM z/OS + OSTypeZOS = OSTypeKey.String("z_os") +) + +// An operating system process. +const ( + // Process identifier (PID). + // + // Type: int + // Required: No + // Stability: stable + // Examples: 1234 + ProcessPIDKey = attribute.Key("process.pid") + // The name of the process executable. On Linux based systems, can be set to the + // `Name` in `proc/[pid]/status`. On Windows, can be set to the base name of + // `GetProcessImageFileNameW`. + // + // Type: string + // Required: See below + // Stability: stable + // Examples: 'otelcol' + ProcessExecutableNameKey = attribute.Key("process.executable.name") + // The full path to the process executable. On Linux based systems, can be set to + // the target of `proc/[pid]/exe`. On Windows, can be set to the result of + // `GetProcessImageFileNameW`. + // + // Type: string + // Required: See below + // Stability: stable + // Examples: '/usr/bin/cmd/otelcol' + ProcessExecutablePathKey = attribute.Key("process.executable.path") + // The command used to launch the process (i.e. the command name). On Linux based + // systems, can be set to the zeroth string in `proc/[pid]/cmdline`. On Windows, + // can be set to the first parameter extracted from `GetCommandLineW`. + // + // Type: string + // Required: See below + // Stability: stable + // Examples: 'cmd/otelcol' + ProcessCommandKey = attribute.Key("process.command") + // The full command used to launch the process as a single string representing the + // full command. On Windows, can be set to the result of `GetCommandLineW`. Do not + // set this if you have to assemble it just for monitoring; use + // `process.command_args` instead. + // + // Type: string + // Required: See below + // Stability: stable + // Examples: 'C:\\cmd\\otecol --config="my directory\\config.yaml"' + ProcessCommandLineKey = attribute.Key("process.command_line") + // All the command arguments (including the command/executable itself) as received + // by the process. On Linux-based systems (and some other Unixoid systems + // supporting procfs), can be set according to the list of null-delimited strings + // extracted from `proc/[pid]/cmdline`. For libc-based executables, this would be + // the full argv vector passed to `main`. + // + // Type: string[] + // Required: See below + // Stability: stable + // Examples: 'cmd/otecol', '--config=config.yaml' + ProcessCommandArgsKey = attribute.Key("process.command_args") + // The username of the user that owns the process. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'root' + ProcessOwnerKey = attribute.Key("process.owner") +) + +// The single (language) runtime instance which is monitored. +const ( + // The name of the runtime of this process. For compiled native binaries, this + // SHOULD be the name of the compiler. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'OpenJDK Runtime Environment' + ProcessRuntimeNameKey = attribute.Key("process.runtime.name") + // The version of the runtime of this process, as returned by the runtime without + // modification. + // + // Type: string + // Required: No + // Stability: stable + // Examples: '14.0.2' + ProcessRuntimeVersionKey = attribute.Key("process.runtime.version") + // An additional description about the runtime of the process, for example a + // specific vendor customization of the runtime environment. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'Eclipse OpenJ9 Eclipse OpenJ9 VM openj9-0.21.0' + ProcessRuntimeDescriptionKey = attribute.Key("process.runtime.description") +) + +// A service instance. +const ( + // Logical name of the service. + // + // Type: string + // Required: Always + // Stability: stable + // Examples: 'shoppingcart' + // Note: MUST be the same for all instances of horizontally scaled services. If + // the value was not specified, SDKs MUST fallback to `unknown_service:` + // concatenated with [`process.executable.name`](process.md#process), e.g. + // `unknown_service:bash`. If `process.executable.name` is not available, the + // value MUST be set to `unknown_service`. + ServiceNameKey = attribute.Key("service.name") + // A namespace for `service.name`. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'Shop' + // Note: A string value having a meaning that helps to distinguish a group of + // services, for example the team name that owns a group of services. + // `service.name` is expected to be unique within the same namespace. If + // `service.namespace` is not specified in the Resource then `service.name` is + // expected to be unique for all services that have no explicit namespace defined + // (so the empty/unspecified namespace is simply one more valid namespace). Zero- + // length namespace string is assumed equal to unspecified namespace. + ServiceNamespaceKey = attribute.Key("service.namespace") + // The string ID of the service instance. + // + // Type: string + // Required: No + // Stability: stable + // Examples: '627cc493-f310-47de-96bd-71410b7dec09' + // Note: MUST be unique for each instance of the same + // `service.namespace,service.name` pair (in other words + // `service.namespace,service.name,service.instance.id` triplet MUST be globally + // unique). The ID helps to distinguish instances of the same service that exist + // at the same time (e.g. instances of a horizontally scaled service). It is + // preferable for the ID to be persistent and stay the same for the lifetime of + // the service instance, however it is acceptable that the ID is ephemeral and + // changes during important lifetime events for the service (e.g. service + // restarts). If the service has no inherent unique ID that can be used as the + // value of this attribute it is recommended to generate a random Version 1 or + // Version 4 RFC 4122 UUID (services aiming for reproducible UUIDs may also use + // Version 5, see RFC 4122 for more recommendations). + ServiceInstanceIDKey = attribute.Key("service.instance.id") + // The version string of the service API or implementation. + // + // Type: string + // Required: No + // Stability: stable + // Examples: '2.0.0' + ServiceVersionKey = attribute.Key("service.version") +) + +// The telemetry SDK used to capture data recorded by the instrumentation libraries. +const ( + // The name of the telemetry SDK as defined above. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'opentelemetry' + TelemetrySDKNameKey = attribute.Key("telemetry.sdk.name") + // The language of the telemetry SDK. + // + // Type: Enum + // Required: No + // Stability: stable + TelemetrySDKLanguageKey = attribute.Key("telemetry.sdk.language") + // The version string of the telemetry SDK. + // + // Type: string + // Required: No + // Stability: stable + // Examples: '1.2.3' + TelemetrySDKVersionKey = attribute.Key("telemetry.sdk.version") + // The version string of the auto instrumentation agent, if used. + // + // Type: string + // Required: No + // Stability: stable + // Examples: '1.2.3' + TelemetryAutoVersionKey = attribute.Key("telemetry.auto.version") +) + +var ( + // cpp + TelemetrySDKLanguageCPP = TelemetrySDKLanguageKey.String("cpp") + // dotnet + TelemetrySDKLanguageDotnet = TelemetrySDKLanguageKey.String("dotnet") + // erlang + TelemetrySDKLanguageErlang = TelemetrySDKLanguageKey.String("erlang") + // go + TelemetrySDKLanguageGo = TelemetrySDKLanguageKey.String("go") + // java + TelemetrySDKLanguageJava = TelemetrySDKLanguageKey.String("java") + // nodejs + TelemetrySDKLanguageNodejs = TelemetrySDKLanguageKey.String("nodejs") + // php + TelemetrySDKLanguagePHP = TelemetrySDKLanguageKey.String("php") + // python + TelemetrySDKLanguagePython = TelemetrySDKLanguageKey.String("python") + // ruby + TelemetrySDKLanguageRuby = TelemetrySDKLanguageKey.String("ruby") + // webjs + TelemetrySDKLanguageWebjs = TelemetrySDKLanguageKey.String("webjs") +) + +// Resource describing the packaged software running the application code. Web engines are typically executed using process.runtime. +const ( + // The name of the web engine. + // + // Type: string + // Required: Always + // Stability: stable + // Examples: 'WildFly' + WebEngineNameKey = attribute.Key("webengine.name") + // The version of the web engine. + // + // Type: string + // Required: No + // Stability: stable + // Examples: '21.0.0' + WebEngineVersionKey = attribute.Key("webengine.version") + // Additional description of the web engine (e.g. detailed version and edition + // information). + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'WildFly Full 21.0.0.Final (WildFly Core 13.0.1.Final) - 2.2.2.Final' + WebEngineDescriptionKey = attribute.Key("webengine.description") +) diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.7.0/schema.go b/vendor/go.opentelemetry.io/otel/semconv/v1.7.0/schema.go new file mode 100644 index 000000000..64b6c46a5 --- /dev/null +++ b/vendor/go.opentelemetry.io/otel/semconv/v1.7.0/schema.go @@ -0,0 +1,20 @@ +// Copyright The OpenTelemetry Authors +// +// Licensed 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 semconv // import "go.opentelemetry.io/otel/semconv/v1.7.0" + +// SchemaURL is the schema URL that matches the version of the semantic conventions +// that this package defines. Semconv packages starting from v1.4.0 must declare +// non-empty schema URL in the form https://opentelemetry.io/schemas/ +const SchemaURL = "https://opentelemetry.io/schemas/1.7.0" diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.7.0/trace.go b/vendor/go.opentelemetry.io/otel/semconv/v1.7.0/trace.go new file mode 100644 index 000000000..9b75bd77a --- /dev/null +++ b/vendor/go.opentelemetry.io/otel/semconv/v1.7.0/trace.go @@ -0,0 +1,1558 @@ +// Copyright The OpenTelemetry Authors +// +// Licensed 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. + +// Code generated from semantic convention specification. DO NOT EDIT. + +package semconv // import "go.opentelemetry.io/otel/semconv/v1.7.0" + +import "go.opentelemetry.io/otel/attribute" + +// Span attributes used by AWS Lambda (in addition to general `faas` attributes). +const ( + // The full invoked ARN as provided on the `Context` passed to the function + // (`Lambda-Runtime-Invoked-Function-ARN` header on the `/runtime/invocation/next` + // applicable). + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'arn:aws:lambda:us-east-1:123456:function:myfunction:myalias' + // Note: This may be different from `faas.id` if an alias is involved. + AWSLambdaInvokedARNKey = attribute.Key("aws.lambda.invoked_arn") +) + +// This document defines the attributes used to perform database client calls. +const ( + // An identifier for the database management system (DBMS) product being used. See + // below for a list of well-known identifiers. + // + // Type: Enum + // Required: Always + // Stability: stable + DBSystemKey = attribute.Key("db.system") + // The connection string used to connect to the database. It is recommended to + // remove embedded credentials. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'Server=(localdb)\\v11.0;Integrated Security=true;' + DBConnectionStringKey = attribute.Key("db.connection_string") + // Username for accessing the database. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'readonly_user', 'reporting_user' + DBUserKey = attribute.Key("db.user") + // The fully-qualified class name of the [Java Database Connectivity + // (JDBC)](https://docs.oracle.com/javase/8/docs/technotes/guides/jdbc/) driver + // used to connect. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'org.postgresql.Driver', + // 'com.microsoft.sqlserver.jdbc.SQLServerDriver' + DBJDBCDriverClassnameKey = attribute.Key("db.jdbc.driver_classname") + // If no [tech-specific attribute](#call-level-attributes-for-specific- + // technologies) is defined, this attribute is used to report the name of the + // database being accessed. For commands that switch the database, this should be + // set to the target database (even if the command fails). + // + // Type: string + // Required: Required, if applicable and no more-specific attribute is defined. + // Stability: stable + // Examples: 'customers', 'main' + // Note: In some SQL databases, the database name to be used is called "schema + // name". + DBNameKey = attribute.Key("db.name") + // The database statement being executed. + // + // Type: string + // Required: Required if applicable and not explicitly disabled via + // instrumentation configuration. + // Stability: stable + // Examples: 'SELECT * FROM wuser_table', 'SET mykey "WuValue"' + // Note: The value may be sanitized to exclude sensitive information. + DBStatementKey = attribute.Key("db.statement") + // The name of the operation being executed, e.g. the [MongoDB command + // name](https://docs.mongodb.com/manual/reference/command/#database-operations) + // such as `findAndModify`, or the SQL keyword. + // + // Type: string + // Required: Required, if `db.statement` is not applicable. + // Stability: stable + // Examples: 'findAndModify', 'HMSET', 'SELECT' + // Note: When setting this to an SQL keyword, it is not recommended to attempt any + // client-side parsing of `db.statement` just to get this property, but it should + // be set if the operation name is provided by the library being instrumented. If + // the SQL statement has an ambiguous operation, or performs more than one + // operation, this value may be omitted. + DBOperationKey = attribute.Key("db.operation") +) + +var ( + // Some other SQL database. Fallback only. See notes + DBSystemOtherSQL = DBSystemKey.String("other_sql") + // Microsoft SQL Server + DBSystemMSSQL = DBSystemKey.String("mssql") + // MySQL + DBSystemMySQL = DBSystemKey.String("mysql") + // Oracle Database + DBSystemOracle = DBSystemKey.String("oracle") + // IBM DB2 + DBSystemDB2 = DBSystemKey.String("db2") + // PostgreSQL + DBSystemPostgreSQL = DBSystemKey.String("postgresql") + // Amazon Redshift + DBSystemRedshift = DBSystemKey.String("redshift") + // Apache Hive + DBSystemHive = DBSystemKey.String("hive") + // Cloudscape + DBSystemCloudscape = DBSystemKey.String("cloudscape") + // HyperSQL DataBase + DBSystemHSQLDB = DBSystemKey.String("hsqldb") + // Progress Database + DBSystemProgress = DBSystemKey.String("progress") + // SAP MaxDB + DBSystemMaxDB = DBSystemKey.String("maxdb") + // SAP HANA + DBSystemHanaDB = DBSystemKey.String("hanadb") + // Ingres + DBSystemIngres = DBSystemKey.String("ingres") + // FirstSQL + DBSystemFirstSQL = DBSystemKey.String("firstsql") + // EnterpriseDB + DBSystemEDB = DBSystemKey.String("edb") + // InterSystems Caché + DBSystemCache = DBSystemKey.String("cache") + // Adabas (Adaptable Database System) + DBSystemAdabas = DBSystemKey.String("adabas") + // Firebird + DBSystemFirebird = DBSystemKey.String("firebird") + // Apache Derby + DBSystemDerby = DBSystemKey.String("derby") + // FileMaker + DBSystemFilemaker = DBSystemKey.String("filemaker") + // Informix + DBSystemInformix = DBSystemKey.String("informix") + // InstantDB + DBSystemInstantDB = DBSystemKey.String("instantdb") + // InterBase + DBSystemInterbase = DBSystemKey.String("interbase") + // MariaDB + DBSystemMariaDB = DBSystemKey.String("mariadb") + // Netezza + DBSystemNetezza = DBSystemKey.String("netezza") + // Pervasive PSQL + DBSystemPervasive = DBSystemKey.String("pervasive") + // PointBase + DBSystemPointbase = DBSystemKey.String("pointbase") + // SQLite + DBSystemSqlite = DBSystemKey.String("sqlite") + // Sybase + DBSystemSybase = DBSystemKey.String("sybase") + // Teradata + DBSystemTeradata = DBSystemKey.String("teradata") + // Vertica + DBSystemVertica = DBSystemKey.String("vertica") + // H2 + DBSystemH2 = DBSystemKey.String("h2") + // ColdFusion IMQ + DBSystemColdfusion = DBSystemKey.String("coldfusion") + // Apache Cassandra + DBSystemCassandra = DBSystemKey.String("cassandra") + // Apache HBase + DBSystemHBase = DBSystemKey.String("hbase") + // MongoDB + DBSystemMongoDB = DBSystemKey.String("mongodb") + // Redis + DBSystemRedis = DBSystemKey.String("redis") + // Couchbase + DBSystemCouchbase = DBSystemKey.String("couchbase") + // CouchDB + DBSystemCouchDB = DBSystemKey.String("couchdb") + // Microsoft Azure Cosmos DB + DBSystemCosmosDB = DBSystemKey.String("cosmosdb") + // Amazon DynamoDB + DBSystemDynamoDB = DBSystemKey.String("dynamodb") + // Neo4j + DBSystemNeo4j = DBSystemKey.String("neo4j") + // Apache Geode + DBSystemGeode = DBSystemKey.String("geode") + // Elasticsearch + DBSystemElasticsearch = DBSystemKey.String("elasticsearch") + // Memcached + DBSystemMemcached = DBSystemKey.String("memcached") + // CockroachDB + DBSystemCockroachdb = DBSystemKey.String("cockroachdb") +) + +// Connection-level attributes for Microsoft SQL Server +const ( + // The Microsoft SQL Server [instance name](https://docs.microsoft.com/en- + // us/sql/connect/jdbc/building-the-connection-url?view=sql-server-ver15) + // connecting to. This name is used to determine the port of a named instance. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'MSSQLSERVER' + // Note: If setting a `db.mssql.instance_name`, `net.peer.port` is no longer + // required (but still recommended if non-standard). + DBMSSQLInstanceNameKey = attribute.Key("db.mssql.instance_name") +) + +// Call-level attributes for Cassandra +const ( + // The name of the keyspace being accessed. To be used instead of the generic + // `db.name` attribute. + // + // Type: string + // Required: Always + // Stability: stable + // Examples: 'mykeyspace' + DBCassandraKeyspaceKey = attribute.Key("db.cassandra.keyspace") + // The fetch size used for paging, i.e. how many rows will be returned at once. + // + // Type: int + // Required: No + // Stability: stable + // Examples: 5000 + DBCassandraPageSizeKey = attribute.Key("db.cassandra.page_size") + // The consistency level of the query. Based on consistency values from + // [CQL](https://docs.datastax.com/en/cassandra- + // oss/3.0/cassandra/dml/dmlConfigConsistency.html). + // + // Type: Enum + // Required: No + // Stability: stable + DBCassandraConsistencyLevelKey = attribute.Key("db.cassandra.consistency_level") + // The name of the primary table that the operation is acting upon, including the + // schema name (if applicable). + // + // Type: string + // Required: Recommended if available. + // Stability: stable + // Examples: 'mytable' + // Note: This mirrors the db.sql.table attribute but references cassandra rather + // than sql. It is not recommended to attempt any client-side parsing of + // `db.statement` just to get this property, but it should be set if it is + // provided by the library being instrumented. If the operation is acting upon an + // anonymous table, or more than one table, this value MUST NOT be set. + DBCassandraTableKey = attribute.Key("db.cassandra.table") + // Whether or not the query is idempotent. + // + // Type: boolean + // Required: No + // Stability: stable + DBCassandraIdempotenceKey = attribute.Key("db.cassandra.idempotence") + // The number of times a query was speculatively executed. Not set or `0` if the + // query was not executed speculatively. + // + // Type: int + // Required: No + // Stability: stable + // Examples: 0, 2 + DBCassandraSpeculativeExecutionCountKey = attribute.Key("db.cassandra.speculative_execution_count") + // The ID of the coordinating node for a query. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'be13faa2-8574-4d71-926d-27f16cf8a7af' + DBCassandraCoordinatorIDKey = attribute.Key("db.cassandra.coordinator.id") + // The data center of the coordinating node for a query. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'us-west-2' + DBCassandraCoordinatorDCKey = attribute.Key("db.cassandra.coordinator.dc") +) + +var ( + // all + DBCassandraConsistencyLevelAll = DBCassandraConsistencyLevelKey.String("all") + // each_quorum + DBCassandraConsistencyLevelEachQuorum = DBCassandraConsistencyLevelKey.String("each_quorum") + // quorum + DBCassandraConsistencyLevelQuorum = DBCassandraConsistencyLevelKey.String("quorum") + // local_quorum + DBCassandraConsistencyLevelLocalQuorum = DBCassandraConsistencyLevelKey.String("local_quorum") + // one + DBCassandraConsistencyLevelOne = DBCassandraConsistencyLevelKey.String("one") + // two + DBCassandraConsistencyLevelTwo = DBCassandraConsistencyLevelKey.String("two") + // three + DBCassandraConsistencyLevelThree = DBCassandraConsistencyLevelKey.String("three") + // local_one + DBCassandraConsistencyLevelLocalOne = DBCassandraConsistencyLevelKey.String("local_one") + // any + DBCassandraConsistencyLevelAny = DBCassandraConsistencyLevelKey.String("any") + // serial + DBCassandraConsistencyLevelSerial = DBCassandraConsistencyLevelKey.String("serial") + // local_serial + DBCassandraConsistencyLevelLocalSerial = DBCassandraConsistencyLevelKey.String("local_serial") +) + +// Call-level attributes for Apache HBase +const ( + // The [HBase namespace](https://hbase.apache.org/book.html#_namespace) being + // accessed. To be used instead of the generic `db.name` attribute. + // + // Type: string + // Required: Always + // Stability: stable + // Examples: 'default' + DBHBaseNamespaceKey = attribute.Key("db.hbase.namespace") +) + +// Call-level attributes for Redis +const ( + // The index of the database being accessed as used in the [`SELECT` + // command](https://redis.io/commands/select), provided as an integer. To be used + // instead of the generic `db.name` attribute. + // + // Type: int + // Required: Required, if other than the default database (`0`). + // Stability: stable + // Examples: 0, 1, 15 + DBRedisDBIndexKey = attribute.Key("db.redis.database_index") +) + +// Call-level attributes for MongoDB +const ( + // The collection being accessed within the database stated in `db.name`. + // + // Type: string + // Required: Always + // Stability: stable + // Examples: 'customers', 'products' + DBMongoDBCollectionKey = attribute.Key("db.mongodb.collection") +) + +// Call-level attrbiutes for SQL databases +const ( + // The name of the primary table that the operation is acting upon, including the + // schema name (if applicable). + // + // Type: string + // Required: Recommended if available. + // Stability: stable + // Examples: 'public.users', 'customers' + // Note: It is not recommended to attempt any client-side parsing of + // `db.statement` just to get this property, but it should be set if it is + // provided by the library being instrumented. If the operation is acting upon an + // anonymous table, or more than one table, this value MUST NOT be set. + DBSQLTableKey = attribute.Key("db.sql.table") +) + +// This document defines the attributes used to report a single exception associated with a span. +const ( + // The type of the exception (its fully-qualified class name, if applicable). The + // dynamic type of the exception should be preferred over the static type in + // languages that support it. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'java.net.ConnectException', 'OSError' + ExceptionTypeKey = attribute.Key("exception.type") + // The exception message. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'Division by zero', "Can't convert 'int' object to str implicitly" + ExceptionMessageKey = attribute.Key("exception.message") + // A stacktrace as a string in the natural representation for the language + // runtime. The representation is to be determined and documented by each language + // SIG. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'Exception in thread "main" java.lang.RuntimeException: Test + // exception\\n at ' + // 'com.example.GenerateTrace.methodB(GenerateTrace.java:13)\\n at ' + // 'com.example.GenerateTrace.methodA(GenerateTrace.java:9)\\n at ' + // 'com.example.GenerateTrace.main(GenerateTrace.java:5)' + ExceptionStacktraceKey = attribute.Key("exception.stacktrace") + // SHOULD be set to true if the exception event is recorded at a point where it is + // known that the exception is escaping the scope of the span. + // + // Type: boolean + // Required: No + // Stability: stable + // Note: An exception is considered to have escaped (or left) the scope of a span, + // if that span is ended while the exception is still logically "in flight". + // This may be actually "in flight" in some languages (e.g. if the exception + // is passed to a Context manager's `__exit__` method in Python) but will + // usually be caught at the point of recording the exception in most languages. + + // It is usually not possible to determine at the point where an exception is + // thrown + // whether it will escape the scope of a span. + // However, it is trivial to know that an exception + // will escape, if one checks for an active exception just before ending the span, + // as done in the [example above](#exception-end-example). + + // It follows that an exception may still escape the scope of the span + // even if the `exception.escaped` attribute was not set or set to false, + // since the event might have been recorded at a time where it was not + // clear whether the exception will escape. + ExceptionEscapedKey = attribute.Key("exception.escaped") +) + +// This semantic convention describes an instance of a function that runs without provisioning or managing of servers (also known as serverless functions or Function as a Service (FaaS)) with spans. +const ( + // Type of the trigger on which the function is executed. + // + // Type: Enum + // Required: On FaaS instances, faas.trigger MUST be set on incoming invocations. + // Clients invoking FaaS instances MUST set `faas.trigger` on outgoing + // invocations, if it is known to the client. This is, for example, not the case, + // when the transport layer is abstracted in a FaaS client framework without + // access to its configuration. + // Stability: stable + FaaSTriggerKey = attribute.Key("faas.trigger") + // The execution ID of the current function execution. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'af9d5aa4-a685-4c5f-a22b-444f80b3cc28' + FaaSExecutionKey = attribute.Key("faas.execution") +) + +var ( + // A response to some data source operation such as a database or filesystem read/write + FaaSTriggerDatasource = FaaSTriggerKey.String("datasource") + // To provide an answer to an inbound HTTP request + FaaSTriggerHTTP = FaaSTriggerKey.String("http") + // A function is set to be executed when messages are sent to a messaging system + FaaSTriggerPubsub = FaaSTriggerKey.String("pubsub") + // A function is scheduled to be executed regularly + FaaSTriggerTimer = FaaSTriggerKey.String("timer") + // If none of the others apply + FaaSTriggerOther = FaaSTriggerKey.String("other") +) + +// Semantic Convention for FaaS triggered as a response to some data source operation such as a database or filesystem read/write. +const ( + // The name of the source on which the triggering operation was performed. For + // example, in Cloud Storage or S3 corresponds to the bucket name, and in Cosmos + // DB to the database name. + // + // Type: string + // Required: Always + // Stability: stable + // Examples: 'myBucketName', 'myDBName' + FaaSDocumentCollectionKey = attribute.Key("faas.document.collection") + // Describes the type of the operation that was performed on the data. + // + // Type: Enum + // Required: Always + // Stability: stable + FaaSDocumentOperationKey = attribute.Key("faas.document.operation") + // A string containing the time when the data was accessed in the [ISO + // 8601](https://www.iso.org/iso-8601-date-and-time-format.html) format expressed + // in [UTC](https://www.w3.org/TR/NOTE-datetime). + // + // Type: string + // Required: Always + // Stability: stable + // Examples: '2020-01-23T13:47:06Z' + FaaSDocumentTimeKey = attribute.Key("faas.document.time") + // The document name/table subjected to the operation. For example, in Cloud + // Storage or S3 is the name of the file, and in Cosmos DB the table name. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'myFile.txt', 'myTableName' + FaaSDocumentNameKey = attribute.Key("faas.document.name") +) + +var ( + // When a new object is created + FaaSDocumentOperationInsert = FaaSDocumentOperationKey.String("insert") + // When an object is modified + FaaSDocumentOperationEdit = FaaSDocumentOperationKey.String("edit") + // When an object is deleted + FaaSDocumentOperationDelete = FaaSDocumentOperationKey.String("delete") +) + +// Semantic Convention for FaaS scheduled to be executed regularly. +const ( + // A string containing the function invocation time in the [ISO + // 8601](https://www.iso.org/iso-8601-date-and-time-format.html) format expressed + // in [UTC](https://www.w3.org/TR/NOTE-datetime). + // + // Type: string + // Required: Always + // Stability: stable + // Examples: '2020-01-23T13:47:06Z' + FaaSTimeKey = attribute.Key("faas.time") + // A string containing the schedule period as [Cron Expression](https://docs.oracl + // e.com/cd/E12058_01/doc/doc.1014/e12030/cron_expressions.htm). + // + // Type: string + // Required: No + // Stability: stable + // Examples: '0/5 * * * ? *' + FaaSCronKey = attribute.Key("faas.cron") +) + +// Contains additional attributes for incoming FaaS spans. +const ( + // A boolean that is true if the serverless function is executed for the first + // time (aka cold-start). + // + // Type: boolean + // Required: No + // Stability: stable + FaaSColdstartKey = attribute.Key("faas.coldstart") +) + +// Contains additional attributes for outgoing FaaS spans. +const ( + // The name of the invoked function. + // + // Type: string + // Required: Always + // Stability: stable + // Examples: 'my-function' + // Note: SHOULD be equal to the `faas.name` resource attribute of the invoked + // function. + FaaSInvokedNameKey = attribute.Key("faas.invoked_name") + // The cloud provider of the invoked function. + // + // Type: Enum + // Required: Always + // Stability: stable + // Note: SHOULD be equal to the `cloud.provider` resource attribute of the invoked + // function. + FaaSInvokedProviderKey = attribute.Key("faas.invoked_provider") + // The cloud region of the invoked function. + // + // Type: string + // Required: For some cloud providers, like AWS or GCP, the region in which a + // function is hosted is essential to uniquely identify the function and also part + // of its endpoint. Since it's part of the endpoint being called, the region is + // always known to clients. In these cases, `faas.invoked_region` MUST be set + // accordingly. If the region is unknown to the client or not required for + // identifying the invoked function, setting `faas.invoked_region` is optional. + // Stability: stable + // Examples: 'eu-central-1' + // Note: SHOULD be equal to the `cloud.region` resource attribute of the invoked + // function. + FaaSInvokedRegionKey = attribute.Key("faas.invoked_region") +) + +var ( + // Alibaba Cloud + FaaSInvokedProviderAlibabaCloud = FaaSInvokedProviderKey.String("alibaba_cloud") + // Amazon Web Services + FaaSInvokedProviderAWS = FaaSInvokedProviderKey.String("aws") + // Microsoft Azure + FaaSInvokedProviderAzure = FaaSInvokedProviderKey.String("azure") + // Google Cloud Platform + FaaSInvokedProviderGCP = FaaSInvokedProviderKey.String("gcp") +) + +// These attributes may be used for any network related operation. +const ( + // Transport protocol used. See note below. + // + // Type: Enum + // Required: No + // Stability: stable + NetTransportKey = attribute.Key("net.transport") + // Remote address of the peer (dotted decimal for IPv4 or + // [RFC5952](https://tools.ietf.org/html/rfc5952) for IPv6) + // + // Type: string + // Required: No + // Stability: stable + // Examples: '127.0.0.1' + NetPeerIPKey = attribute.Key("net.peer.ip") + // Remote port number. + // + // Type: int + // Required: No + // Stability: stable + // Examples: 80, 8080, 443 + NetPeerPortKey = attribute.Key("net.peer.port") + // Remote hostname or similar, see note below. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'example.com' + NetPeerNameKey = attribute.Key("net.peer.name") + // Like `net.peer.ip` but for the host IP. Useful in case of a multi-IP host. + // + // Type: string + // Required: No + // Stability: stable + // Examples: '192.168.0.1' + NetHostIPKey = attribute.Key("net.host.ip") + // Like `net.peer.port` but for the host port. + // + // Type: int + // Required: No + // Stability: stable + // Examples: 35555 + NetHostPortKey = attribute.Key("net.host.port") + // Local hostname or similar, see note below. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'localhost' + NetHostNameKey = attribute.Key("net.host.name") + // The internet connection type currently being used by the host. + // + // Type: Enum + // Required: No + // Stability: stable + // Examples: 'wifi' + NetHostConnectionTypeKey = attribute.Key("net.host.connection.type") + // This describes more details regarding the connection.type. It may be the type + // of cell technology connection, but it could be used for describing details + // about a wifi connection. + // + // Type: Enum + // Required: No + // Stability: stable + // Examples: 'LTE' + NetHostConnectionSubtypeKey = attribute.Key("net.host.connection.subtype") + // The name of the mobile carrier. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'sprint' + NetHostCarrierNameKey = attribute.Key("net.host.carrier.name") + // The mobile carrier country code. + // + // Type: string + // Required: No + // Stability: stable + // Examples: '310' + NetHostCarrierMccKey = attribute.Key("net.host.carrier.mcc") + // The mobile carrier network code. + // + // Type: string + // Required: No + // Stability: stable + // Examples: '001' + NetHostCarrierMncKey = attribute.Key("net.host.carrier.mnc") + // The ISO 3166-1 alpha-2 2-character country code associated with the mobile + // carrier network. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'DE' + NetHostCarrierIccKey = attribute.Key("net.host.carrier.icc") +) + +var ( + // ip_tcp + NetTransportTCP = NetTransportKey.String("ip_tcp") + // ip_udp + NetTransportUDP = NetTransportKey.String("ip_udp") + // Another IP-based protocol + NetTransportIP = NetTransportKey.String("ip") + // Unix Domain socket. See below + NetTransportUnix = NetTransportKey.String("unix") + // Named or anonymous pipe. See note below + NetTransportPipe = NetTransportKey.String("pipe") + // In-process communication + NetTransportInProc = NetTransportKey.String("inproc") + // Something else (non IP-based) + NetTransportOther = NetTransportKey.String("other") +) + +var ( + // wifi + NetHostConnectionTypeWifi = NetHostConnectionTypeKey.String("wifi") + // wired + NetHostConnectionTypeWired = NetHostConnectionTypeKey.String("wired") + // cell + NetHostConnectionTypeCell = NetHostConnectionTypeKey.String("cell") + // unavailable + NetHostConnectionTypeUnavailable = NetHostConnectionTypeKey.String("unavailable") + // unknown + NetHostConnectionTypeUnknown = NetHostConnectionTypeKey.String("unknown") +) + +var ( + // GPRS + NetHostConnectionSubtypeGprs = NetHostConnectionSubtypeKey.String("gprs") + // EDGE + NetHostConnectionSubtypeEdge = NetHostConnectionSubtypeKey.String("edge") + // UMTS + NetHostConnectionSubtypeUmts = NetHostConnectionSubtypeKey.String("umts") + // CDMA + NetHostConnectionSubtypeCdma = NetHostConnectionSubtypeKey.String("cdma") + // EVDO Rel. 0 + NetHostConnectionSubtypeEvdo0 = NetHostConnectionSubtypeKey.String("evdo_0") + // EVDO Rev. A + NetHostConnectionSubtypeEvdoA = NetHostConnectionSubtypeKey.String("evdo_a") + // CDMA2000 1XRTT + NetHostConnectionSubtypeCdma20001xrtt = NetHostConnectionSubtypeKey.String("cdma2000_1xrtt") + // HSDPA + NetHostConnectionSubtypeHsdpa = NetHostConnectionSubtypeKey.String("hsdpa") + // HSUPA + NetHostConnectionSubtypeHsupa = NetHostConnectionSubtypeKey.String("hsupa") + // HSPA + NetHostConnectionSubtypeHspa = NetHostConnectionSubtypeKey.String("hspa") + // IDEN + NetHostConnectionSubtypeIden = NetHostConnectionSubtypeKey.String("iden") + // EVDO Rev. B + NetHostConnectionSubtypeEvdoB = NetHostConnectionSubtypeKey.String("evdo_b") + // LTE + NetHostConnectionSubtypeLte = NetHostConnectionSubtypeKey.String("lte") + // EHRPD + NetHostConnectionSubtypeEhrpd = NetHostConnectionSubtypeKey.String("ehrpd") + // HSPAP + NetHostConnectionSubtypeHspap = NetHostConnectionSubtypeKey.String("hspap") + // GSM + NetHostConnectionSubtypeGsm = NetHostConnectionSubtypeKey.String("gsm") + // TD-SCDMA + NetHostConnectionSubtypeTdScdma = NetHostConnectionSubtypeKey.String("td_scdma") + // IWLAN + NetHostConnectionSubtypeIwlan = NetHostConnectionSubtypeKey.String("iwlan") + // 5G NR (New Radio) + NetHostConnectionSubtypeNr = NetHostConnectionSubtypeKey.String("nr") + // 5G NRNSA (New Radio Non-Standalone) + NetHostConnectionSubtypeNrnsa = NetHostConnectionSubtypeKey.String("nrnsa") + // LTE CA + NetHostConnectionSubtypeLteCa = NetHostConnectionSubtypeKey.String("lte_ca") +) + +// Operations that access some remote service. +const ( + // The [`service.name`](../../resource/semantic_conventions/README.md#service) of + // the remote service. SHOULD be equal to the actual `service.name` resource + // attribute of the remote service if any. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'AuthTokenCache' + PeerServiceKey = attribute.Key("peer.service") +) + +// These attributes may be used for any operation with an authenticated and/or authorized enduser. +const ( + // Username or client_id extracted from the access token or + // [Authorization](https://tools.ietf.org/html/rfc7235#section-4.2) header in the + // inbound request from outside the system. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'username' + EnduserIDKey = attribute.Key("enduser.id") + // Actual/assumed role the client is making the request under extracted from token + // or application security context. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'admin' + EnduserRoleKey = attribute.Key("enduser.role") + // Scopes or granted authorities the client currently possesses extracted from + // token or application security context. The value would come from the scope + // associated with an [OAuth 2.0 Access + // Token](https://tools.ietf.org/html/rfc6749#section-3.3) or an attribute value + // in a [SAML 2.0 Assertion](http://docs.oasis- + // open.org/security/saml/Post2.0/sstc-saml-tech-overview-2.0.html). + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'read:message, write:files' + EnduserScopeKey = attribute.Key("enduser.scope") +) + +// These attributes may be used for any operation to store information about a thread that started a span. +const ( + // Current "managed" thread ID (as opposed to OS thread ID). + // + // Type: int + // Required: No + // Stability: stable + // Examples: 42 + ThreadIDKey = attribute.Key("thread.id") + // Current thread name. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'main' + ThreadNameKey = attribute.Key("thread.name") +) + +// These attributes allow to report this unit of code and therefore to provide more context about the span. +const ( + // The method or function name, or equivalent (usually rightmost part of the code + // unit's name). + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'serveRequest' + CodeFunctionKey = attribute.Key("code.function") + // The "namespace" within which `code.function` is defined. Usually the qualified + // class or module name, such that `code.namespace` + some separator + + // `code.function` form a unique identifier for the code unit. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'com.example.MyHTTPService' + CodeNamespaceKey = attribute.Key("code.namespace") + // The source code file name that identifies the code unit as uniquely as possible + // (preferably an absolute file path). + // + // Type: string + // Required: No + // Stability: stable + // Examples: '/usr/local/MyApplication/content_root/app/index.php' + CodeFilepathKey = attribute.Key("code.filepath") + // The line number in `code.filepath` best representing the operation. It SHOULD + // point within the code unit named in `code.function`. + // + // Type: int + // Required: No + // Stability: stable + // Examples: 42 + CodeLineNumberKey = attribute.Key("code.lineno") +) + +// This document defines semantic conventions for HTTP client and server Spans. +const ( + // HTTP request method. + // + // Type: string + // Required: Always + // Stability: stable + // Examples: 'GET', 'POST', 'HEAD' + HTTPMethodKey = attribute.Key("http.method") + // Full HTTP request URL in the form `scheme://host[:port]/path?query[#fragment]`. + // Usually the fragment is not transmitted over HTTP, but if it is known, it + // should be included nevertheless. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'https://www.foo.bar/search?q=OpenTelemetry#SemConv' + // Note: `http.url` MUST NOT contain credentials passed via URL in form of + // `https://username:password@www.example.com/`. In such case the attribute's + // value should be `https://www.example.com/`. + HTTPURLKey = attribute.Key("http.url") + // The full request target as passed in a HTTP request line or equivalent. + // + // Type: string + // Required: No + // Stability: stable + // Examples: '/path/12314/?q=ddds#123' + HTTPTargetKey = attribute.Key("http.target") + // The value of the [HTTP host + // header](https://tools.ietf.org/html/rfc7230#section-5.4). An empty Host header + // should also be reported, see note. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'www.example.org' + // Note: When the header is present but empty the attribute SHOULD be set to the + // empty string. Note that this is a valid situation that is expected in certain + // cases, according the aforementioned [section of RFC + // 7230](https://tools.ietf.org/html/rfc7230#section-5.4). When the header is not + // set the attribute MUST NOT be set. + HTTPHostKey = attribute.Key("http.host") + // The URI scheme identifying the used protocol. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'http', 'https' + HTTPSchemeKey = attribute.Key("http.scheme") + // [HTTP response status code](https://tools.ietf.org/html/rfc7231#section-6). + // + // Type: int + // Required: If and only if one was received/sent. + // Stability: stable + // Examples: 200 + HTTPStatusCodeKey = attribute.Key("http.status_code") + // Kind of HTTP protocol used. + // + // Type: Enum + // Required: No + // Stability: stable + // Note: If `net.transport` is not specified, it can be assumed to be `IP.TCP` + // except if `http.flavor` is `QUIC`, in which case `IP.UDP` is assumed. + HTTPFlavorKey = attribute.Key("http.flavor") + // Value of the [HTTP User- + // Agent](https://tools.ietf.org/html/rfc7231#section-5.5.3) header sent by the + // client. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'CERN-LineMode/2.15 libwww/2.17b3' + HTTPUserAgentKey = attribute.Key("http.user_agent") + // The size of the request payload body in bytes. This is the number of bytes + // transferred excluding headers and is often, but not always, present as the + // [Content-Length](https://tools.ietf.org/html/rfc7230#section-3.3.2) header. For + // requests using transport encoding, this should be the compressed size. + // + // Type: int + // Required: No + // Stability: stable + // Examples: 3495 + HTTPRequestContentLengthKey = attribute.Key("http.request_content_length") + // The size of the uncompressed request payload body after transport decoding. Not + // set if transport encoding not used. + // + // Type: int + // Required: No + // Stability: stable + // Examples: 5493 + HTTPRequestContentLengthUncompressedKey = attribute.Key("http.request_content_length_uncompressed") + // The size of the response payload body in bytes. This is the number of bytes + // transferred excluding headers and is often, but not always, present as the + // [Content-Length](https://tools.ietf.org/html/rfc7230#section-3.3.2) header. For + // requests using transport encoding, this should be the compressed size. + // + // Type: int + // Required: No + // Stability: stable + // Examples: 3495 + HTTPResponseContentLengthKey = attribute.Key("http.response_content_length") + // The size of the uncompressed response payload body after transport decoding. + // Not set if transport encoding not used. + // + // Type: int + // Required: No + // Stability: stable + // Examples: 5493 + HTTPResponseContentLengthUncompressedKey = attribute.Key("http.response_content_length_uncompressed") +) + +var ( + // HTTP 1.0 + HTTPFlavorHTTP10 = HTTPFlavorKey.String("1.0") + // HTTP 1.1 + HTTPFlavorHTTP11 = HTTPFlavorKey.String("1.1") + // HTTP 2 + HTTPFlavorHTTP20 = HTTPFlavorKey.String("2.0") + // SPDY protocol + HTTPFlavorSPDY = HTTPFlavorKey.String("SPDY") + // QUIC protocol + HTTPFlavorQUIC = HTTPFlavorKey.String("QUIC") +) + +// Semantic Convention for HTTP Server +const ( + // The primary server name of the matched virtual host. This should be obtained + // via configuration. If no such configuration can be obtained, this attribute + // MUST NOT be set ( `net.host.name` should be used instead). + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'example.com' + // Note: `http.url` is usually not readily available on the server side but would + // have to be assembled in a cumbersome and sometimes lossy process from other + // information (see e.g. open-telemetry/opentelemetry-python/pull/148). It is thus + // preferred to supply the raw data that is available. + HTTPServerNameKey = attribute.Key("http.server_name") + // The matched route (path template). + // + // Type: string + // Required: No + // Stability: stable + // Examples: '/users/:userID?' + HTTPRouteKey = attribute.Key("http.route") + // The IP address of the original client behind all proxies, if known (e.g. from + // [X-Forwarded-For](https://developer.mozilla.org/en- + // US/docs/Web/HTTP/Headers/X-Forwarded-For)). + // + // Type: string + // Required: No + // Stability: stable + // Examples: '83.164.160.102' + // Note: This is not necessarily the same as `net.peer.ip`, which would + // identify the network-level peer, which may be a proxy. + + // This attribute should be set when a source of information different + // from the one used for `net.peer.ip`, is available even if that other + // source just confirms the same value as `net.peer.ip`. + // Rationale: For `net.peer.ip`, one typically does not know if it + // comes from a proxy, reverse proxy, or the actual client. Setting + // `http.client_ip` when it's the same as `net.peer.ip` means that + // one is at least somewhat confident that the address is not that of + // the closest proxy. + HTTPClientIPKey = attribute.Key("http.client_ip") +) + +// Attributes that exist for multiple DynamoDB request types. +const ( + // The keys in the `RequestItems` object field. + // + // Type: string[] + // Required: No + // Stability: stable + // Examples: 'Users', 'Cats' + AWSDynamoDBTableNamesKey = attribute.Key("aws.dynamodb.table_names") + // The JSON-serialized value of each item in the `ConsumedCapacity` response + // field. + // + // Type: string[] + // Required: No + // Stability: stable + // Examples: '{ "CapacityUnits": number, "GlobalSecondaryIndexes": { "string" : { + // "CapacityUnits": number, "ReadCapacityUnits": number, "WriteCapacityUnits": + // number } }, "LocalSecondaryIndexes": { "string" : { "CapacityUnits": number, + // "ReadCapacityUnits": number, "WriteCapacityUnits": number } }, + // "ReadCapacityUnits": number, "Table": { "CapacityUnits": number, + // "ReadCapacityUnits": number, "WriteCapacityUnits": number }, "TableName": + // "string", "WriteCapacityUnits": number }' + AWSDynamoDBConsumedCapacityKey = attribute.Key("aws.dynamodb.consumed_capacity") + // The JSON-serialized value of the `ItemCollectionMetrics` response field. + // + // Type: string + // Required: No + // Stability: stable + // Examples: '{ "string" : [ { "ItemCollectionKey": { "string" : { "B": blob, + // "BOOL": boolean, "BS": [ blob ], "L": [ "AttributeValue" ], "M": { "string" : + // "AttributeValue" }, "N": "string", "NS": [ "string" ], "NULL": boolean, "S": + // "string", "SS": [ "string" ] } }, "SizeEstimateRangeGB": [ number ] } ] }' + AWSDynamoDBItemCollectionMetricsKey = attribute.Key("aws.dynamodb.item_collection_metrics") + // The value of the `ProvisionedThroughput.ReadCapacityUnits` request parameter. + // + // Type: double + // Required: No + // Stability: stable + // Examples: 1.0, 2.0 + AWSDynamoDBProvisionedReadCapacityKey = attribute.Key("aws.dynamodb.provisioned_read_capacity") + // The value of the `ProvisionedThroughput.WriteCapacityUnits` request parameter. + // + // Type: double + // Required: No + // Stability: stable + // Examples: 1.0, 2.0 + AWSDynamoDBProvisionedWriteCapacityKey = attribute.Key("aws.dynamodb.provisioned_write_capacity") + // The value of the `ConsistentRead` request parameter. + // + // Type: boolean + // Required: No + // Stability: stable + AWSDynamoDBConsistentReadKey = attribute.Key("aws.dynamodb.consistent_read") + // The value of the `ProjectionExpression` request parameter. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'Title', 'Title, Price, Color', 'Title, Description, RelatedItems, + // ProductReviews' + AWSDynamoDBProjectionKey = attribute.Key("aws.dynamodb.projection") + // The value of the `Limit` request parameter. + // + // Type: int + // Required: No + // Stability: stable + // Examples: 10 + AWSDynamoDBLimitKey = attribute.Key("aws.dynamodb.limit") + // The value of the `AttributesToGet` request parameter. + // + // Type: string[] + // Required: No + // Stability: stable + // Examples: 'lives', 'id' + AWSDynamoDBAttributesToGetKey = attribute.Key("aws.dynamodb.attributes_to_get") + // The value of the `IndexName` request parameter. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'name_to_group' + AWSDynamoDBIndexNameKey = attribute.Key("aws.dynamodb.index_name") + // The value of the `Select` request parameter. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'ALL_ATTRIBUTES', 'COUNT' + AWSDynamoDBSelectKey = attribute.Key("aws.dynamodb.select") +) + +// DynamoDB.CreateTable +const ( + // The JSON-serialized value of each item of the `GlobalSecondaryIndexes` request + // field + // + // Type: string[] + // Required: No + // Stability: stable + // Examples: '{ "IndexName": "string", "KeySchema": [ { "AttributeName": "string", + // "KeyType": "string" } ], "Projection": { "NonKeyAttributes": [ "string" ], + // "ProjectionType": "string" }, "ProvisionedThroughput": { "ReadCapacityUnits": + // number, "WriteCapacityUnits": number } }' + AWSDynamoDBGlobalSecondaryIndexesKey = attribute.Key("aws.dynamodb.global_secondary_indexes") + // The JSON-serialized value of each item of the `LocalSecondaryIndexes` request + // field. + // + // Type: string[] + // Required: No + // Stability: stable + // Examples: '{ "IndexARN": "string", "IndexName": "string", "IndexSizeBytes": + // number, "ItemCount": number, "KeySchema": [ { "AttributeName": "string", + // "KeyType": "string" } ], "Projection": { "NonKeyAttributes": [ "string" ], + // "ProjectionType": "string" } }' + AWSDynamoDBLocalSecondaryIndexesKey = attribute.Key("aws.dynamodb.local_secondary_indexes") +) + +// DynamoDB.ListTables +const ( + // The value of the `ExclusiveStartTableName` request parameter. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'Users', 'CatsTable' + AWSDynamoDBExclusiveStartTableKey = attribute.Key("aws.dynamodb.exclusive_start_table") + // The the number of items in the `TableNames` response parameter. + // + // Type: int + // Required: No + // Stability: stable + // Examples: 20 + AWSDynamoDBTableCountKey = attribute.Key("aws.dynamodb.table_count") +) + +// DynamoDB.Query +const ( + // The value of the `ScanIndexForward` request parameter. + // + // Type: boolean + // Required: No + // Stability: stable + AWSDynamoDBScanForwardKey = attribute.Key("aws.dynamodb.scan_forward") +) + +// DynamoDB.Scan +const ( + // The value of the `Segment` request parameter. + // + // Type: int + // Required: No + // Stability: stable + // Examples: 10 + AWSDynamoDBSegmentKey = attribute.Key("aws.dynamodb.segment") + // The value of the `TotalSegments` request parameter. + // + // Type: int + // Required: No + // Stability: stable + // Examples: 100 + AWSDynamoDBTotalSegmentsKey = attribute.Key("aws.dynamodb.total_segments") + // The value of the `Count` response parameter. + // + // Type: int + // Required: No + // Stability: stable + // Examples: 10 + AWSDynamoDBCountKey = attribute.Key("aws.dynamodb.count") + // The value of the `ScannedCount` response parameter. + // + // Type: int + // Required: No + // Stability: stable + // Examples: 50 + AWSDynamoDBScannedCountKey = attribute.Key("aws.dynamodb.scanned_count") +) + +// DynamoDB.UpdateTable +const ( + // The JSON-serialized value of each item in the `AttributeDefinitions` request + // field. + // + // Type: string[] + // Required: No + // Stability: stable + // Examples: '{ "AttributeName": "string", "AttributeType": "string" }' + AWSDynamoDBAttributeDefinitionsKey = attribute.Key("aws.dynamodb.attribute_definitions") + // The JSON-serialized value of each item in the the `GlobalSecondaryIndexUpdates` + // request field. + // + // Type: string[] + // Required: No + // Stability: stable + // Examples: '{ "Create": { "IndexName": "string", "KeySchema": [ { + // "AttributeName": "string", "KeyType": "string" } ], "Projection": { + // "NonKeyAttributes": [ "string" ], "ProjectionType": "string" }, + // "ProvisionedThroughput": { "ReadCapacityUnits": number, "WriteCapacityUnits": + // number } }' + AWSDynamoDBGlobalSecondaryIndexUpdatesKey = attribute.Key("aws.dynamodb.global_secondary_index_updates") +) + +// This document defines the attributes used in messaging systems. +const ( + // A string identifying the messaging system. + // + // Type: string + // Required: Always + // Stability: stable + // Examples: 'kafka', 'rabbitmq', 'activemq', 'AmazonSQS' + MessagingSystemKey = attribute.Key("messaging.system") + // The message destination name. This might be equal to the span name but is + // required nevertheless. + // + // Type: string + // Required: Always + // Stability: stable + // Examples: 'MyQueue', 'MyTopic' + MessagingDestinationKey = attribute.Key("messaging.destination") + // The kind of message destination + // + // Type: Enum + // Required: Required only if the message destination is either a `queue` or + // `topic`. + // Stability: stable + MessagingDestinationKindKey = attribute.Key("messaging.destination_kind") + // A boolean that is true if the message destination is temporary. + // + // Type: boolean + // Required: If missing, it is assumed to be false. + // Stability: stable + MessagingTempDestinationKey = attribute.Key("messaging.temp_destination") + // The name of the transport protocol. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'AMQP', 'MQTT' + MessagingProtocolKey = attribute.Key("messaging.protocol") + // The version of the transport protocol. + // + // Type: string + // Required: No + // Stability: stable + // Examples: '0.9.1' + MessagingProtocolVersionKey = attribute.Key("messaging.protocol_version") + // Connection string. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'tibjmsnaming://localhost:7222', + // 'https://queue.amazonaws.com/80398EXAMPLE/MyQueue' + MessagingURLKey = attribute.Key("messaging.url") + // A value used by the messaging system as an identifier for the message, + // represented as a string. + // + // Type: string + // Required: No + // Stability: stable + // Examples: '452a7c7c7c7048c2f887f61572b18fc2' + MessagingMessageIDKey = attribute.Key("messaging.message_id") + // The [conversation ID](#conversations) identifying the conversation to which the + // message belongs, represented as a string. Sometimes called "Correlation ID". + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'MyConversationID' + MessagingConversationIDKey = attribute.Key("messaging.conversation_id") + // The (uncompressed) size of the message payload in bytes. Also use this + // attribute if it is unknown whether the compressed or uncompressed payload size + // is reported. + // + // Type: int + // Required: No + // Stability: stable + // Examples: 2738 + MessagingMessagePayloadSizeBytesKey = attribute.Key("messaging.message_payload_size_bytes") + // The compressed size of the message payload in bytes. + // + // Type: int + // Required: No + // Stability: stable + // Examples: 2048 + MessagingMessagePayloadCompressedSizeBytesKey = attribute.Key("messaging.message_payload_compressed_size_bytes") +) + +var ( + // A message sent to a queue + MessagingDestinationKindQueue = MessagingDestinationKindKey.String("queue") + // A message sent to a topic + MessagingDestinationKindTopic = MessagingDestinationKindKey.String("topic") +) + +// Semantic convention for a consumer of messages received from a messaging system +const ( + // A string identifying the kind of message consumption as defined in the + // [Operation names](#operation-names) section above. If the operation is "send", + // this attribute MUST NOT be set, since the operation can be inferred from the + // span kind in that case. + // + // Type: Enum + // Required: No + // Stability: stable + MessagingOperationKey = attribute.Key("messaging.operation") + // The identifier for the consumer receiving a message. For Kafka, set it to + // `{messaging.kafka.consumer_group} - {messaging.kafka.client_id}`, if both are + // present, or only `messaging.kafka.consumer_group`. For brokers, such as + // RabbitMQ and Artemis, set it to the `client_id` of the client consuming the + // message. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'mygroup - client-6' + MessagingConsumerIDKey = attribute.Key("messaging.consumer_id") +) + +var ( + // receive + MessagingOperationReceive = MessagingOperationKey.String("receive") + // process + MessagingOperationProcess = MessagingOperationKey.String("process") +) + +// Attributes for RabbitMQ +const ( + // RabbitMQ message routing key. + // + // Type: string + // Required: Unless it is empty. + // Stability: stable + // Examples: 'myKey' + MessagingRabbitmqRoutingKeyKey = attribute.Key("messaging.rabbitmq.routing_key") +) + +// Attributes for Apache Kafka +const ( + // Message keys in Kafka are used for grouping alike messages to ensure they're + // processed on the same partition. They differ from `messaging.message_id` in + // that they're not unique. If the key is `null`, the attribute MUST NOT be set. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'myKey' + // Note: If the key type is not string, it's string representation has to be + // supplied for the attribute. If the key has no unambiguous, canonical string + // form, don't include its value. + MessagingKafkaMessageKeyKey = attribute.Key("messaging.kafka.message_key") + // Name of the Kafka Consumer Group that is handling the message. Only applies to + // consumers, not producers. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'my-group' + MessagingKafkaConsumerGroupKey = attribute.Key("messaging.kafka.consumer_group") + // Client ID for the Consumer or Producer that is handling the message. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'client-5' + MessagingKafkaClientIDKey = attribute.Key("messaging.kafka.client_id") + // Partition the message is sent to. + // + // Type: int + // Required: No + // Stability: stable + // Examples: 2 + MessagingKafkaPartitionKey = attribute.Key("messaging.kafka.partition") + // A boolean that is true if the message is a tombstone. + // + // Type: boolean + // Required: If missing, it is assumed to be false. + // Stability: stable + MessagingKafkaTombstoneKey = attribute.Key("messaging.kafka.tombstone") +) + +// This document defines semantic conventions for remote procedure calls. +const ( + // A string identifying the remoting system. + // + // Type: string + // Required: Always + // Stability: stable + // Examples: 'grpc', 'java_rmi', 'wcf' + RPCSystemKey = attribute.Key("rpc.system") + // The full (logical) name of the service being called, including its package + // name, if applicable. + // + // Type: string + // Required: No, but recommended + // Stability: stable + // Examples: 'myservice.EchoService' + // Note: This is the logical name of the service from the RPC interface + // perspective, which can be different from the name of any implementing class. + // The `code.namespace` attribute may be used to store the latter (despite the + // attribute name, it may include a class name; e.g., class with method actually + // executing the call on the server side, RPC client stub class on the client + // side). + RPCServiceKey = attribute.Key("rpc.service") + // The name of the (logical) method being called, must be equal to the $method + // part in the span name. + // + // Type: string + // Required: No, but recommended + // Stability: stable + // Examples: 'exampleMethod' + // Note: This is the logical name of the method from the RPC interface + // perspective, which can be different from the name of any implementing + // method/function. The `code.function` attribute may be used to store the latter + // (e.g., method actually executing the call on the server side, RPC client stub + // method on the client side). + RPCMethodKey = attribute.Key("rpc.method") +) + +// Tech-specific attributes for gRPC. +const ( + // The [numeric status + // code](https://github.com/grpc/grpc/blob/v1.33.2/doc/statuscodes.md) of the gRPC + // request. + // + // Type: Enum + // Required: Always + // Stability: stable + RPCGRPCStatusCodeKey = attribute.Key("rpc.grpc.status_code") +) + +var ( + // OK + RPCGRPCStatusCodeOk = RPCGRPCStatusCodeKey.Int(0) + // CANCELLED + RPCGRPCStatusCodeCancelled = RPCGRPCStatusCodeKey.Int(1) + // UNKNOWN + RPCGRPCStatusCodeUnknown = RPCGRPCStatusCodeKey.Int(2) + // INVALID_ARGUMENT + RPCGRPCStatusCodeInvalidArgument = RPCGRPCStatusCodeKey.Int(3) + // DEADLINE_EXCEEDED + RPCGRPCStatusCodeDeadlineExceeded = RPCGRPCStatusCodeKey.Int(4) + // NOT_FOUND + RPCGRPCStatusCodeNotFound = RPCGRPCStatusCodeKey.Int(5) + // ALREADY_EXISTS + RPCGRPCStatusCodeAlreadyExists = RPCGRPCStatusCodeKey.Int(6) + // PERMISSION_DENIED + RPCGRPCStatusCodePermissionDenied = RPCGRPCStatusCodeKey.Int(7) + // RESOURCE_EXHAUSTED + RPCGRPCStatusCodeResourceExhausted = RPCGRPCStatusCodeKey.Int(8) + // FAILED_PRECONDITION + RPCGRPCStatusCodeFailedPrecondition = RPCGRPCStatusCodeKey.Int(9) + // ABORTED + RPCGRPCStatusCodeAborted = RPCGRPCStatusCodeKey.Int(10) + // OUT_OF_RANGE + RPCGRPCStatusCodeOutOfRange = RPCGRPCStatusCodeKey.Int(11) + // UNIMPLEMENTED + RPCGRPCStatusCodeUnimplemented = RPCGRPCStatusCodeKey.Int(12) + // INTERNAL + RPCGRPCStatusCodeInternal = RPCGRPCStatusCodeKey.Int(13) + // UNAVAILABLE + RPCGRPCStatusCodeUnavailable = RPCGRPCStatusCodeKey.Int(14) + // DATA_LOSS + RPCGRPCStatusCodeDataLoss = RPCGRPCStatusCodeKey.Int(15) + // UNAUTHENTICATED + RPCGRPCStatusCodeUnauthenticated = RPCGRPCStatusCodeKey.Int(16) +) + +// Tech-specific attributes for [JSON RPC](https://www.jsonrpc.org/). +const ( + // Protocol version as in `jsonrpc` property of request/response. Since JSON-RPC + // 1.0 does not specify this, the value can be omitted. + // + // Type: string + // Required: If missing, it is assumed to be "1.0". + // Stability: stable + // Examples: '2.0', '1.0' + RPCJsonrpcVersionKey = attribute.Key("rpc.jsonrpc.version") + // `id` property of request or response. Since protocol allows id to be int, + // string, `null` or missing (for notifications), value is expected to be cast to + // string for simplicity. Use empty string in case of `null` value. Omit entirely + // if this is a notification. + // + // Type: string + // Required: No + // Stability: stable + // Examples: '10', 'request-7', '' + RPCJsonrpcRequestIDKey = attribute.Key("rpc.jsonrpc.request_id") + // `error.code` property of response if it is an error response. + // + // Type: int + // Required: If missing, response is assumed to be successful. + // Stability: stable + // Examples: -32700, 100 + RPCJsonrpcErrorCodeKey = attribute.Key("rpc.jsonrpc.error_code") + // `error.message` property of response if it is an error response. + // + // Type: string + // Required: No + // Stability: stable + // Examples: 'Parse error', 'User already exists' + RPCJsonrpcErrorMessageKey = attribute.Key("rpc.jsonrpc.error_message") +) + +// RPC received/sent message. +const ( + // Whether this is a received or sent message. + // + // Type: Enum + // Required: No + // Stability: stable + MessageTypeKey = attribute.Key("message.type") + // MUST be calculated as two different counters starting from `1` one for sent + // messages and one for received message. + // + // Type: int + // Required: No + // Stability: stable + // Note: This way we guarantee that the values will be consistent between + // different implementations. + MessageIDKey = attribute.Key("message.id") + // Compressed size of the message in bytes. + // + // Type: int + // Required: No + // Stability: stable + MessageCompressedSizeKey = attribute.Key("message.compressed_size") + // Uncompressed size of the message in bytes. + // + // Type: int + // Required: No + // Stability: stable + MessageUncompressedSizeKey = attribute.Key("message.uncompressed_size") +) + +var ( + // sent + MessageTypeSent = MessageTypeKey.String("SENT") + // received + MessageTypeReceived = MessageTypeKey.String("RECEIVED") +) diff --git a/vendor/modules.txt b/vendor/modules.txt index 603b4b4ef..ad0327bef 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -384,6 +384,7 @@ go.opentelemetry.io/otel/internal/global go.opentelemetry.io/otel/propagation go.opentelemetry.io/otel/semconv/internal go.opentelemetry.io/otel/semconv/v1.12.0 +go.opentelemetry.io/otel/semconv/v1.7.0 # go.opentelemetry.io/otel/exporters/otlp/internal/retry v1.10.0 ## explicit; go 1.17 go.opentelemetry.io/otel/exporters/otlp/internal/retry