Documentation

Overview

    Package v1 contains API Schema definitions for the jaegertracing v1 API group +k8s:deepcopy-gen=package,register +groupName=jaegertracing.io

    Package v1 contains API Schema definitions for the jaegertracing v1 API group +k8s:deepcopy-gen=package,register +groupName=jaegertracing.io

    Index

    Constants

    View Source
    const (
    	// LabelOperatedBy is used as the key to the label indicating which operator is managing the instance
    	LabelOperatedBy string = "jaegertracing.io/operated-by"
    
    	// ConfigIdentity is the key to the configuration map related to the operator's identity
    	ConfigIdentity string = "identity"
    
    	// ConfigWatchNamespace is the key to the configuration map related to the namespace the operator should watch
    	ConfigWatchNamespace string = "watch-namespace"
    
    	// ConfigEnableNamespaceController is the key to the configuration map related to the boolean, determining whether the namespace controller is enabled
    	ConfigEnableNamespaceController string = "enable-namespace-controller"
    
    	// ConfigOperatorScope is the configuration key holding the scope of the operator
    	ConfigOperatorScope string = "operator-scope"
    
    	// WatchAllNamespaces is the value that the ConfigWatchNamespace holds to represent "all namespaces".
    	WatchAllNamespaces string = ""
    
    	// OperatorScopeCluster signals that the operator's instance is installed cluster-wide
    	OperatorScopeCluster string = "cluster"
    
    	// OperatorScopeNamespace signals that the operator's instance is working on a single namespace
    	OperatorScopeNamespace string = "namespace"
    
    	// BootstrapTracer is the OpenTelemetry tracer name for the bootstrap procedure
    	BootstrapTracer string = "operator/bootstrap"
    
    	// ReconciliationTracer is the OpenTelemetry tracer name for the reconciliation loops
    	ReconciliationTracer string = "operator/reconciliation"
    )
    View Source
    const (
    	// FlagPlatformKubernetes represents the value for the 'platform' flag for Kubernetes
    	// +k8s:openapi-gen=true
    	FlagPlatformKubernetes = "kubernetes"
    
    	// FlagPlatformOpenShift represents the value for the 'platform' flag for OpenShift
    	// +k8s:openapi-gen=true
    	FlagPlatformOpenShift = "openshift"
    
    	// FlagPlatformAutoDetect represents the "auto-detect" value for the platform flag
    	// +k8s:openapi-gen=true
    	FlagPlatformAutoDetect = "auto-detect"
    
    	// FlagProvisionElasticsearchAuto represents the 'auto' value for the 'es-provision' flag
    	// +k8s:openapi-gen=true
    	FlagProvisionElasticsearchAuto = "auto"
    
    	// FlagProvisionElasticsearchYes represents the value 'yes' for the 'es-provision' flag
    	// +k8s:openapi-gen=true
    	FlagProvisionElasticsearchYes = "yes"
    
    	// FlagProvisionElasticsearchNo represents the value 'no' for the 'es-provision' flag
    	// +k8s:openapi-gen=true
    	FlagProvisionElasticsearchNo = "no"
    
    	// FlagProvisionKafkaAuto represents the 'auto' value for the 'kafka-provision' flag
    	// +k8s:openapi-gen=true
    	FlagProvisionKafkaAuto = "auto"
    
    	// FlagProvisionKafkaYes represents the value 'yes' for the 'kafka-provision' flag
    	// +k8s:openapi-gen=true
    	FlagProvisionKafkaYes = "yes"
    
    	// FlagProvisionKafkaNo represents the value 'no' for the 'kafka-provision' flag
    	// +k8s:openapi-gen=true
    	FlagProvisionKafkaNo = "no"
    
    	// IngressSecurityNone disables any form of security for ingress objects (default)
    	// +k8s:openapi-gen=true
    	IngressSecurityNone IngressSecurityType = ""
    
    	// IngressSecurityNoneExplicit used when the user specifically set it to 'none'
    	// +k8s:openapi-gen=true
    	IngressSecurityNoneExplicit IngressSecurityType = "none"
    
    	// IngressSecurityOAuthProxy represents an OAuth Proxy as security type
    	// +k8s:openapi-gen=true
    	IngressSecurityOAuthProxy IngressSecurityType = "oauth-proxy"
    
    	// AnnotationProvisionedKafkaKey is a label to be added to Kafkas that have been provisioned by Jaeger
    	// +k8s:openapi-gen=true
    	AnnotationProvisionedKafkaKey string = "jaegertracing.io/kafka-provisioned"
    
    	// AnnotationProvisionedKafkaValue is a label to be added to Kafkas that have been provisioned by Jaeger
    	// +k8s:openapi-gen=true
    	AnnotationProvisionedKafkaValue string = "true"
    
    	// JaegerPhaseFailed indicates that the Jaeger instance failed to be provisioned
    	// +k8s:openapi-gen=true
    	JaegerPhaseFailed JaegerPhase = "Failed"
    
    	// JaegerPhaseRunning indicates that the Jaeger instance is ready and running
    	// +k8s:openapi-gen=true
    	JaegerPhaseRunning JaegerPhase = "Running"
    
    	// JaegerMemoryStorage indicates that the Jaeger storage type is memory. This is the default storage type.
    	// +k8s:openapi-gen=true
    	JaegerMemoryStorage JaegerStorageType = "memory"
    
    	// JaegerCassandraStorage indicates that the Jaeger storage type is cassandra
    	// +k8s:openapi-gen=true
    	JaegerCassandraStorage JaegerStorageType = "cassandra"
    
    	// JaegerESStorage indicates that the Jaeger storage type is elasticsearch
    	// +k8s:openapi-gen=true
    	JaegerESStorage JaegerStorageType = "elasticsearch"
    
    	// JaegerKafkaStorage indicates that the Jaeger storage type is kafka
    	// +k8s:openapi-gen=true
    	JaegerKafkaStorage JaegerStorageType = "kafka"
    
    	// JaegerBadgerStorage indicates that the Jaeger storage type is badger
    	// +k8s:openapi-gen=true
    	JaegerBadgerStorage JaegerStorageType = "badger"
    )

    Variables

    View Source
    var (
    	// SchemeGroupVersion is group version used to register these objects
    	SchemeGroupVersion = schema.GroupVersion{Group: "jaegertracing.io", Version: "v1"}
    
    	// SchemeBuilder is used to add go types to the GroupVersionKind scheme
    	SchemeBuilder = &scheme.Builder{GroupVersion: SchemeGroupVersion}
    )

    Functions

    func RegisterDefaults

    func RegisterDefaults(scheme *runtime.Scheme) error

      RegisterDefaults adds defaulters functions to the given scheme. Public to allow building arbitrary schemes. All generated defaulters are covering - they call all nested defaulters.

      Types

      type AutoScaleSpec

      type AutoScaleSpec struct {
      	// Autoscale turns on/off the autoscale feature. By default, it's enabled if the Replicas field is not set.
      	// +optional
      	Autoscale *bool `json:"autoscale,omitempty"`
      	// MinReplicas sets a lower bound to the autoscaling feature.
      	// +optional
      	MinReplicas *int32 `json:"minReplicas,omitempty"`
      
      	// MaxReplicas sets an upper bound to the autoscaling feature. When autoscaling is enabled and no value is provided, a default value is used.
      	// +optional
      	MaxReplicas *int32 `json:"maxReplicas,omitempty"`
      }

        AutoScaleSpec defines the common elements used for create HPAs +k8s:openapi-gen=true

        func (*AutoScaleSpec) DeepCopy

        func (in *AutoScaleSpec) DeepCopy() *AutoScaleSpec

          DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AutoScaleSpec.

          func (*AutoScaleSpec) DeepCopyInto

          func (in *AutoScaleSpec) DeepCopyInto(out *AutoScaleSpec)

            DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

            type DeploymentStrategy

            type DeploymentStrategy string

              DeploymentStrategy represents the possible values for deployment strategies +k8s:openapi-gen=true

              const (
              	// DeploymentStrategyDeprecatedAllInOne represents the (deprecated) 'all-in-one' deployment strategy
              	// +k8s:openapi-gen=true
              	DeploymentStrategyDeprecatedAllInOne DeploymentStrategy = "all-in-one"
              
              	// DeploymentStrategyAllInOne represents the 'allInOne' deployment strategy (default)
              	// +k8s:openapi-gen=true
              	DeploymentStrategyAllInOne DeploymentStrategy = "allinone"
              
              	// DeploymentStrategyStreaming represents the 'streaming' deployment strategy
              	// +k8s:openapi-gen=true
              	DeploymentStrategyStreaming DeploymentStrategy = "streaming"
              
              	// DeploymentStrategyProduction represents the 'production' deployment strategy
              	// +k8s:openapi-gen=true
              	DeploymentStrategyProduction DeploymentStrategy = "production"
              )

              func (*DeploymentStrategy) UnmarshalText

              func (ds *DeploymentStrategy) UnmarshalText(text []byte) error

                UnmarshalText implements encoding.TextUnmarshaler to ensure that JSON values in the strategy field of JSON jaeger specs are interpreted in a case-insensitive manner

                type ElasticsearchSpec

                type ElasticsearchSpec struct {
                	// +optional
                	Image string `json:"image,omitempty"`
                
                	// +optional
                	Resources *v1.ResourceRequirements `json:"resources,omitempty"`
                
                	// +optional
                	NodeCount int32 `json:"nodeCount,omitempty"`
                
                	// +optional
                	NodeSelector map[string]string `json:"nodeSelector,omitempty"`
                
                	// +optional
                	Storage esv1.ElasticsearchStorageSpec `json:"storage,omitempty"`
                
                	// +optional
                	RedundancyPolicy esv1.RedundancyPolicyType `json:"redundancyPolicy,omitempty"`
                
                	// +optional
                	// +listType=atomic
                	Tolerations []v1.Toleration `json:"tolerations,omitempty"`
                }

                  ElasticsearchSpec represents the ES configuration options that we pass down to the Elasticsearch operator +k8s:openapi-gen=true

                  func (*ElasticsearchSpec) DeepCopy

                  func (in *ElasticsearchSpec) DeepCopy() *ElasticsearchSpec

                    DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ElasticsearchSpec.

                    func (*ElasticsearchSpec) DeepCopyInto

                    func (in *ElasticsearchSpec) DeepCopyInto(out *ElasticsearchSpec)

                      DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                      type FreeForm

                      type FreeForm struct {
                      	// contains filtered or unexported fields
                      }

                        FreeForm defines a common options parameter that maintains the hierarchical structure of the data, unlike Options which flattens the hierarchy into a key/value map where the hierarchy is converted to '.' separated items in the key.

                        func NewFreeForm

                        func NewFreeForm(o map[string]interface{}) FreeForm

                          NewFreeForm build a new FreeForm object based on the given map

                          func (*FreeForm) DeepCopy

                          func (in *FreeForm) DeepCopy() *FreeForm

                            DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new FreeForm.

                            func (*FreeForm) DeepCopyInto

                            func (in *FreeForm) DeepCopyInto(out *FreeForm)

                              DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                              func (FreeForm) GetMap

                              func (o FreeForm) GetMap() (map[string]interface{}, error)

                                GetMap returns a map created from json

                                func (FreeForm) IsEmpty

                                func (o FreeForm) IsEmpty() bool

                                  IsEmpty determines if the freeform options are empty

                                  func (FreeForm) MarshalJSON

                                  func (o FreeForm) MarshalJSON() ([]byte, error)

                                    MarshalJSON specifies how to convert this object into JSON

                                    func (*FreeForm) UnmarshalJSON

                                    func (o *FreeForm) UnmarshalJSON(b []byte) error

                                      UnmarshalJSON implements an alternative parser for this field

                                      type IngressSecurityType

                                      type IngressSecurityType string

                                        IngressSecurityType represents the possible values for the security type +k8s:openapi-gen=true

                                        type Jaeger

                                        type Jaeger struct {
                                        	metav1.TypeMeta `json:",inline"`
                                        
                                        	// +optional
                                        	metav1.ObjectMeta `json:"metadata,omitempty"`
                                        
                                        	// +optional
                                        	Spec JaegerSpec `json:"spec,omitempty"`
                                        
                                        	// +optional
                                        	Status JaegerStatus `json:"status,omitempty"`
                                        }

                                          Jaeger is the Schema for the jaegers API +k8s:openapi-gen=true +operator-sdk:gen-csv:customresourcedefinitions.displayName="Jaeger" +kubebuilder:subresource:status +kubebuilder:printcolumn:name="Status",type="string",JSONPath=".status.phase",description="Jaeger instance's status" +kubebuilder:printcolumn:name="Version",type="string",JSONPath=".status.version",description="Jaeger Version" +kubebuilder:printcolumn:name="Strategy",type="string",JSONPath=".spec.strategy",description="Jaeger deployment strategy" +kubebuilder:printcolumn:name="Storage",type="string",JSONPath=".spec.storage.type",description="Jaeger storage type" +kubebuilder:printcolumn:name="Age",type="date",JSONPath=".metadata.creationTimestamp"

                                          func NewJaeger

                                          func NewJaeger(nsn types.NamespacedName) *Jaeger

                                            NewJaeger returns a new Jaeger instance with the given name

                                            func (*Jaeger) DeepCopy

                                            func (in *Jaeger) DeepCopy() *Jaeger

                                              DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Jaeger.

                                              func (*Jaeger) DeepCopyInto

                                              func (in *Jaeger) DeepCopyInto(out *Jaeger)

                                                DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                func (*Jaeger) DeepCopyObject

                                                func (in *Jaeger) DeepCopyObject() runtime.Object

                                                  DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

                                                  func (*Jaeger) Logger

                                                  func (j *Jaeger) Logger() *log.Entry

                                                    Logger returns a logger filled with context-related fields, such as Name and Namespace

                                                    type JaegerAgentSpec

                                                    type JaegerAgentSpec struct {
                                                    	// Strategy can be either 'DaemonSet' or 'Sidecar' (default)
                                                    	// +optional
                                                    	Strategy string `json:"strategy,omitempty"`
                                                    
                                                    	// +optional
                                                    	Image string `json:"image,omitempty"`
                                                    
                                                    	// +optional
                                                    	// +listType=atomic
                                                    	ImagePullSecrets []v1.LocalObjectReference `json:"imagePullSecrets,omitempty"`
                                                    
                                                    	// +optional
                                                    	Options Options `json:"options,omitempty"`
                                                    
                                                    	// +optional
                                                    	JaegerCommonSpec `json:",inline,omitempty"`
                                                    
                                                    	// +optional
                                                    	Config FreeForm `json:"config,omitempty"`
                                                    
                                                    	// +optional
                                                    	SidecarSecurityContext *v1.SecurityContext `json:"sidecarSecurityContext,omitempty"`
                                                    
                                                    	// +optional
                                                    	HostNetwork *bool `json:"hostNetwork,omitempty"`
                                                    
                                                    	// +optional
                                                    	PriorityClassName string `json:"priorityClassName,omitempty"`
                                                    }

                                                      JaegerAgentSpec defines the options to be used when deploying the agent +k8s:openapi-gen=true

                                                      func (*JaegerAgentSpec) DeepCopy

                                                      func (in *JaegerAgentSpec) DeepCopy() *JaegerAgentSpec

                                                        DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerAgentSpec.

                                                        func (*JaegerAgentSpec) DeepCopyInto

                                                        func (in *JaegerAgentSpec) DeepCopyInto(out *JaegerAgentSpec)

                                                          DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                          type JaegerAllInOneSpec

                                                          type JaegerAllInOneSpec struct {
                                                          	// +optional
                                                          	Image string `json:"image,omitempty"`
                                                          
                                                          	// +optional
                                                          	Options Options `json:"options,omitempty"`
                                                          
                                                          	// +optional
                                                          	Config FreeForm `json:"config,omitempty"`
                                                          
                                                          	// +optional
                                                          	JaegerCommonSpec `json:",inline,omitempty"`
                                                          
                                                          	// +optional
                                                          	// TracingEnabled if set to false adds the JAEGER_DISABLED environment flag and removes the injected
                                                          	// agent container from the query component to disable tracing requests to the query service.
                                                          	// The default, if ommited, is true
                                                          	TracingEnabled *bool `json:"tracingEnabled,omitempty"`
                                                          }

                                                            JaegerAllInOneSpec defines the options to be used when deploying the query +k8s:openapi-gen=true

                                                            func (*JaegerAllInOneSpec) DeepCopy

                                                            func (in *JaegerAllInOneSpec) DeepCopy() *JaegerAllInOneSpec

                                                              DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerAllInOneSpec.

                                                              func (*JaegerAllInOneSpec) DeepCopyInto

                                                              func (in *JaegerAllInOneSpec) DeepCopyInto(out *JaegerAllInOneSpec)

                                                                DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                type JaegerCassandraCreateSchemaSpec

                                                                type JaegerCassandraCreateSchemaSpec struct {
                                                                	// +optional
                                                                	Enabled *bool `json:"enabled,omitempty"`
                                                                
                                                                	// Image specifies the container image to use to create the cassandra schema.
                                                                	// The Image is used by a Kubernetes Job, defaults to the image provided through the cli flag "jaeger-cassandra-schema-image" (default: jaegertracing/jaeger-cassandra-schema).
                                                                	// See here for the jaeger-provided image: https://github.com/jaegertracing/jaeger/tree/master/plugin/storage/cassandra
                                                                	// +optional
                                                                	Image string `json:"image,omitempty"`
                                                                
                                                                	// Datacenter is a collection of racks in the cassandra topology.
                                                                	// defaults to "test"
                                                                	// +optional
                                                                	Datacenter string `json:"datacenter,omitempty"`
                                                                
                                                                	// Mode controls the replication factor of your cassandra schema.
                                                                	// Set it to "prod" (which is the default) to use the NetworkTopologyStrategy with a replication factor of 2, effectively meaning
                                                                	// that at least 3 nodes are required in the cassandra cluster.
                                                                	// When set to "test" the schema uses the SimpleStrategy with a replication factor of 1. You never want to do this in a production setup.
                                                                	// +optional
                                                                	Mode string `json:"mode,omitempty"`
                                                                
                                                                	// TraceTTL sets the TTL for your trace data
                                                                	// +optional
                                                                	TraceTTL string `json:"traceTTL,omitempty"`
                                                                
                                                                	// Timeout controls the Job deadline, it defaults to 1 day.
                                                                	// specify it with a value which can be parsed by time.ParseDuration, e.g. 24h or 120m.
                                                                	// If the job does not succeed within that duration it transitions into a permanent error state.
                                                                	// See https://github.com/jaegertracing/jaeger-kubernetes/issues/32 and
                                                                	// https://github.com/jaegertracing/jaeger-kubernetes/pull/125
                                                                	// +optional
                                                                	Timeout string `json:"timeout,omitempty"`
                                                                
                                                                	// +optional
                                                                	TTLSecondsAfterFinished *int32 `json:"ttlSecondsAfterFinished,omitempty"`
                                                                }

                                                                  JaegerCassandraCreateSchemaSpec holds the options related to the create-schema batch job +k8s:openapi-gen=true

                                                                  func (*JaegerCassandraCreateSchemaSpec) DeepCopy

                                                                    DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerCassandraCreateSchemaSpec.

                                                                    func (*JaegerCassandraCreateSchemaSpec) DeepCopyInto

                                                                      DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                      type JaegerCollectorSpec

                                                                      type JaegerCollectorSpec struct {
                                                                      
                                                                      	// +optional
                                                                      	AutoScaleSpec `json:",inline,omitempty"`
                                                                      
                                                                      	// Replicas represents the number of replicas to create for this service.
                                                                      	// +optional
                                                                      	Replicas *int32 `json:"replicas,omitempty"`
                                                                      
                                                                      	// +optional
                                                                      	Image string `json:"image,omitempty"`
                                                                      
                                                                      	// +optional
                                                                      	Options Options `json:"options,omitempty"`
                                                                      
                                                                      	// +optional
                                                                      	JaegerCommonSpec `json:",inline,omitempty"`
                                                                      
                                                                      	// +optional
                                                                      	Config FreeForm `json:"config,omitempty"`
                                                                      
                                                                      	// +optional
                                                                      	// ServiceType represents the type of Service to create.
                                                                      	// Valid values include: ClusterIP, NodePort, LoadBalancer, and ExternalName.
                                                                      	// The default, if omitted, is ClusterIP.
                                                                      	// See https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types
                                                                      	ServiceType v1.ServiceType `json:"serviceType,omitempty"`
                                                                      
                                                                      	// +optional
                                                                      	PriorityClassName string `json:"priorityClassName,omitempty"`
                                                                      }

                                                                        JaegerCollectorSpec defines the options to be used when deploying the collector +k8s:openapi-gen=true

                                                                        func (*JaegerCollectorSpec) DeepCopy

                                                                        func (in *JaegerCollectorSpec) DeepCopy() *JaegerCollectorSpec

                                                                          DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerCollectorSpec.

                                                                          func (*JaegerCollectorSpec) DeepCopyInto

                                                                          func (in *JaegerCollectorSpec) DeepCopyInto(out *JaegerCollectorSpec)

                                                                            DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                            type JaegerCommonSpec

                                                                            type JaegerCommonSpec struct {
                                                                            	// +optional
                                                                            	// +listType=atomic
                                                                            	Volumes []v1.Volume `json:"volumes,omitempty"`
                                                                            
                                                                            	// +optional
                                                                            	// +listType=atomic
                                                                            	VolumeMounts []v1.VolumeMount `json:"volumeMounts,omitempty"`
                                                                            
                                                                            	// +nullable
                                                                            	// +optional
                                                                            	Annotations map[string]string `json:"annotations,omitempty"`
                                                                            
                                                                            	// +optional
                                                                            	Labels map[string]string `json:"labels,omitempty"`
                                                                            
                                                                            	// +nullable
                                                                            	// +optional
                                                                            	Resources v1.ResourceRequirements `json:"resources,omitempty"`
                                                                            
                                                                            	// +optional
                                                                            	Affinity *v1.Affinity `json:"affinity,omitempty"`
                                                                            
                                                                            	// +optional
                                                                            	// +listType=atomic
                                                                            	Tolerations []v1.Toleration `json:"tolerations,omitempty"`
                                                                            
                                                                            	// +optional
                                                                            	SecurityContext *v1.PodSecurityContext `json:"securityContext,omitempty"`
                                                                            
                                                                            	// +optional
                                                                            	ServiceAccount string `json:"serviceAccount,omitempty"`
                                                                            }

                                                                              JaegerCommonSpec defines the common elements used in multiple other spec structs +k8s:openapi-gen=true

                                                                              func (*JaegerCommonSpec) DeepCopy

                                                                              func (in *JaegerCommonSpec) DeepCopy() *JaegerCommonSpec

                                                                                DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerCommonSpec.

                                                                                func (*JaegerCommonSpec) DeepCopyInto

                                                                                func (in *JaegerCommonSpec) DeepCopyInto(out *JaegerCommonSpec)

                                                                                  DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                  type JaegerDependenciesSpec

                                                                                  type JaegerDependenciesSpec struct {
                                                                                  	// +optional
                                                                                  	Enabled *bool `json:"enabled,omitempty"`
                                                                                  
                                                                                  	// +optional
                                                                                  	SparkMaster string `json:"sparkMaster,omitempty"`
                                                                                  
                                                                                  	// +optional
                                                                                  	Schedule string `json:"schedule,omitempty"`
                                                                                  
                                                                                  	// +optional
                                                                                  	SuccessfulJobsHistoryLimit *int32 `json:"successfulJobsHistoryLimit,omitempty"`
                                                                                  
                                                                                  	// +optional
                                                                                  	Image string `json:"image,omitempty"`
                                                                                  
                                                                                  	// +optional
                                                                                  	JavaOpts string `json:"javaOpts,omitempty"`
                                                                                  
                                                                                  	// +optional
                                                                                  	CassandraClientAuthEnabled bool `json:"cassandraClientAuthEnabled,omitempty"`
                                                                                  
                                                                                  	// +optional
                                                                                  	ElasticsearchClientNodeOnly *bool `json:"elasticsearchClientNodeOnly,omitempty"`
                                                                                  
                                                                                  	// +optional
                                                                                  	ElasticsearchNodesWanOnly *bool `json:"elasticsearchNodesWanOnly,omitempty"`
                                                                                  
                                                                                  	// +optional
                                                                                  	TTLSecondsAfterFinished *int32 `json:"ttlSecondsAfterFinished,omitempty"`
                                                                                  
                                                                                  	// +optional
                                                                                  	JaegerCommonSpec `json:",inline,omitempty"`
                                                                                  }

                                                                                    JaegerDependenciesSpec defined options for running spark-dependencies. +k8s:openapi-gen=true

                                                                                    func (*JaegerDependenciesSpec) DeepCopy

                                                                                      DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerDependenciesSpec.

                                                                                      func (*JaegerDependenciesSpec) DeepCopyInto

                                                                                      func (in *JaegerDependenciesSpec) DeepCopyInto(out *JaegerDependenciesSpec)

                                                                                        DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                        type JaegerEsIndexCleanerSpec

                                                                                        type JaegerEsIndexCleanerSpec struct {
                                                                                        	// +optional
                                                                                        	Enabled *bool `json:"enabled,omitempty"`
                                                                                        
                                                                                        	// +optional
                                                                                        	NumberOfDays *int `json:"numberOfDays,omitempty"`
                                                                                        
                                                                                        	// +optional
                                                                                        	Schedule string `json:"schedule,omitempty"`
                                                                                        
                                                                                        	// +optional
                                                                                        	SuccessfulJobsHistoryLimit *int32 `json:"successfulJobsHistoryLimit,omitempty"`
                                                                                        
                                                                                        	// +optional
                                                                                        	Image string `json:"image,omitempty"`
                                                                                        
                                                                                        	// +optional
                                                                                        	TTLSecondsAfterFinished *int32 `json:"ttlSecondsAfterFinished,omitempty"`
                                                                                        
                                                                                        	// +optional
                                                                                        	JaegerCommonSpec `json:",inline,omitempty"`
                                                                                        }

                                                                                          JaegerEsIndexCleanerSpec holds the options related to es-index-cleaner +k8s:openapi-gen=true

                                                                                          func (*JaegerEsIndexCleanerSpec) DeepCopy

                                                                                            DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerEsIndexCleanerSpec.

                                                                                            func (*JaegerEsIndexCleanerSpec) DeepCopyInto

                                                                                            func (in *JaegerEsIndexCleanerSpec) DeepCopyInto(out *JaegerEsIndexCleanerSpec)

                                                                                              DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                              type JaegerEsRolloverSpec

                                                                                              type JaegerEsRolloverSpec struct {
                                                                                              	// +optional
                                                                                              	Image string `json:"image,omitempty"`
                                                                                              
                                                                                              	// +optional
                                                                                              	Schedule string `json:"schedule,omitempty"`
                                                                                              
                                                                                              	// +optional
                                                                                              	SuccessfulJobsHistoryLimit *int32 `json:"successfulJobsHistoryLimit,omitempty"`
                                                                                              
                                                                                              	// +optional
                                                                                              	Conditions string `json:"conditions,omitempty"`
                                                                                              
                                                                                              	// +optional
                                                                                              	TTLSecondsAfterFinished *int32 `json:"ttlSecondsAfterFinished,omitempty"`
                                                                                              
                                                                                              	// we parse it with time.ParseDuration
                                                                                              	// +optional
                                                                                              	ReadTTL string `json:"readTTL,omitempty"`
                                                                                              
                                                                                              	// +optional
                                                                                              	JaegerCommonSpec `json:",inline,omitempty"`
                                                                                              }

                                                                                                JaegerEsRolloverSpec holds the options related to es-rollover

                                                                                                func (*JaegerEsRolloverSpec) DeepCopy

                                                                                                  DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerEsRolloverSpec.

                                                                                                  func (*JaegerEsRolloverSpec) DeepCopyInto

                                                                                                  func (in *JaegerEsRolloverSpec) DeepCopyInto(out *JaegerEsRolloverSpec)

                                                                                                    DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                                    type JaegerIngesterSpec

                                                                                                    type JaegerIngesterSpec struct {
                                                                                                    	// +optional
                                                                                                    	AutoScaleSpec `json:",inline,omitempty"`
                                                                                                    
                                                                                                    	// Replicas represents the number of replicas to create for this service.
                                                                                                    	// +optional
                                                                                                    	Replicas *int32 `json:"replicas,omitempty"`
                                                                                                    
                                                                                                    	// +optional
                                                                                                    	Image string `json:"image,omitempty"`
                                                                                                    
                                                                                                    	// +optional
                                                                                                    	Options Options `json:"options,omitempty"`
                                                                                                    
                                                                                                    	// +optional
                                                                                                    	JaegerCommonSpec `json:",inline,omitempty"`
                                                                                                    
                                                                                                    	// +optional
                                                                                                    	Config FreeForm `json:"config,omitempty"`
                                                                                                    }

                                                                                                      JaegerIngesterSpec defines the options to be used when deploying the ingester +k8s:openapi-gen=true

                                                                                                      func (*JaegerIngesterSpec) DeepCopy

                                                                                                      func (in *JaegerIngesterSpec) DeepCopy() *JaegerIngesterSpec

                                                                                                        DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerIngesterSpec.

                                                                                                        func (*JaegerIngesterSpec) DeepCopyInto

                                                                                                        func (in *JaegerIngesterSpec) DeepCopyInto(out *JaegerIngesterSpec)

                                                                                                          DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                                          type JaegerIngressOpenShiftSpec

                                                                                                          type JaegerIngressOpenShiftSpec struct {
                                                                                                          	// +optional
                                                                                                          	SAR string `json:"sar,omitempty"`
                                                                                                          
                                                                                                          	// +optional
                                                                                                          	DelegateUrls string `json:"delegateUrls,omitempty"`
                                                                                                          
                                                                                                          	// +optional
                                                                                                          	HtpasswdFile string `json:"htpasswdFile,omitempty"`
                                                                                                          
                                                                                                          	// SkipLogout tells the operator to not automatically add a "Log Out" menu option to the custom Jaeger configuration
                                                                                                          	// +optional
                                                                                                          	SkipLogout *bool `json:"skipLogout,omitempty"`
                                                                                                          }

                                                                                                            JaegerIngressOpenShiftSpec defines the OpenShift-specific options in the context of ingress connections, such as options for the OAuth Proxy +k8s:openapi-gen=true

                                                                                                            func (*JaegerIngressOpenShiftSpec) DeepCopy

                                                                                                              DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerIngressOpenShiftSpec.

                                                                                                              func (*JaegerIngressOpenShiftSpec) DeepCopyInto

                                                                                                                DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                                                type JaegerIngressSpec

                                                                                                                type JaegerIngressSpec struct {
                                                                                                                	// +optional
                                                                                                                	Enabled *bool `json:"enabled,omitempty"`
                                                                                                                
                                                                                                                	// +optional
                                                                                                                	Security IngressSecurityType `json:"security,omitempty"`
                                                                                                                
                                                                                                                	// +optional
                                                                                                                	Openshift JaegerIngressOpenShiftSpec `json:"openshift,omitempty"`
                                                                                                                
                                                                                                                	// +optional
                                                                                                                	// +listType=atomic
                                                                                                                	Hosts []string `json:"hosts,omitempty"`
                                                                                                                
                                                                                                                	// +optional
                                                                                                                	// +listType=atomic
                                                                                                                	TLS []JaegerIngressTLSSpec `json:"tls,omitempty"`
                                                                                                                
                                                                                                                	// Deprecated in favor of the TLS property
                                                                                                                	// +optional
                                                                                                                	SecretName string `json:"secretName,omitempty"`
                                                                                                                
                                                                                                                	// +optional
                                                                                                                	JaegerCommonSpec `json:",inline,omitempty"`
                                                                                                                
                                                                                                                	// +optional
                                                                                                                	Options Options `json:"options,omitempty"`
                                                                                                                }

                                                                                                                  JaegerIngressSpec defines the options to be used when deploying the query ingress +k8s:openapi-gen=true

                                                                                                                  func (*JaegerIngressSpec) DeepCopy

                                                                                                                  func (in *JaegerIngressSpec) DeepCopy() *JaegerIngressSpec

                                                                                                                    DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerIngressSpec.

                                                                                                                    func (*JaegerIngressSpec) DeepCopyInto

                                                                                                                    func (in *JaegerIngressSpec) DeepCopyInto(out *JaegerIngressSpec)

                                                                                                                      DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                                                      type JaegerIngressTLSSpec

                                                                                                                      type JaegerIngressTLSSpec struct {
                                                                                                                      	// +optional
                                                                                                                      	// +listType=atomic
                                                                                                                      	Hosts []string `json:"hosts,omitempty"`
                                                                                                                      
                                                                                                                      	// +optional
                                                                                                                      	SecretName string `json:"secretName,omitempty"`
                                                                                                                      }

                                                                                                                        JaegerIngressTLSSpec defines the TLS configuration to be used when deploying the query ingress +k8s:openapi-gen=true

                                                                                                                        func (*JaegerIngressTLSSpec) DeepCopy

                                                                                                                          DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerIngressTLSSpec.

                                                                                                                          func (*JaegerIngressTLSSpec) DeepCopyInto

                                                                                                                          func (in *JaegerIngressTLSSpec) DeepCopyInto(out *JaegerIngressTLSSpec)

                                                                                                                            DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                                                            type JaegerList

                                                                                                                            type JaegerList struct {
                                                                                                                            	metav1.TypeMeta `json:",inline"`
                                                                                                                            	metav1.ListMeta `json:"metadata,omitempty"`
                                                                                                                            	Items           []Jaeger `json:"items"`
                                                                                                                            }

                                                                                                                              JaegerList contains a list of Jaeger

                                                                                                                              func (*JaegerList) DeepCopy

                                                                                                                              func (in *JaegerList) DeepCopy() *JaegerList

                                                                                                                                DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerList.

                                                                                                                                func (*JaegerList) DeepCopyInto

                                                                                                                                func (in *JaegerList) DeepCopyInto(out *JaegerList)

                                                                                                                                  DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                                                                  func (*JaegerList) DeepCopyObject

                                                                                                                                  func (in *JaegerList) DeepCopyObject() runtime.Object

                                                                                                                                    DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

                                                                                                                                    type JaegerPhase

                                                                                                                                    type JaegerPhase string

                                                                                                                                      JaegerPhase represents the current phase of Jaeger instances +k8s:openapi-gen=true

                                                                                                                                      type JaegerQuerySpec

                                                                                                                                      type JaegerQuerySpec struct {
                                                                                                                                      	// Replicas represents the number of replicas to create for this service.
                                                                                                                                      	// +optional
                                                                                                                                      	Replicas *int32 `json:"replicas,omitempty"`
                                                                                                                                      
                                                                                                                                      	// +optional
                                                                                                                                      	Image string `json:"image,omitempty"`
                                                                                                                                      
                                                                                                                                      	// +optional
                                                                                                                                      	Options Options `json:"options,omitempty"`
                                                                                                                                      
                                                                                                                                      	// +optional
                                                                                                                                      	JaegerCommonSpec `json:",inline,omitempty"`
                                                                                                                                      
                                                                                                                                      	// +optional
                                                                                                                                      	// ServiceType represents the type of Service to create.
                                                                                                                                      	// Valid values include: ClusterIP, NodePort, LoadBalancer, and ExternalName.
                                                                                                                                      	// The default, if omitted, is ClusterIP.
                                                                                                                                      	// See https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types
                                                                                                                                      	ServiceType v1.ServiceType `json:"serviceType,omitempty"`
                                                                                                                                      
                                                                                                                                      	// +optional
                                                                                                                                      	// TracingEnabled if set to false adds the JAEGER_DISABLED environment flag and removes the injected
                                                                                                                                      	// agent container from the query component to disable tracing requests to the query service.
                                                                                                                                      	// The default, if ommited, is true
                                                                                                                                      	TracingEnabled *bool `json:"tracingEnabled,omitempty"`
                                                                                                                                      
                                                                                                                                      	// +optional
                                                                                                                                      	PriorityClassName string `json:"priorityClassName,omitempty"`
                                                                                                                                      }

                                                                                                                                        JaegerQuerySpec defines the options to be used when deploying the query +k8s:openapi-gen=true

                                                                                                                                        func (*JaegerQuerySpec) DeepCopy

                                                                                                                                        func (in *JaegerQuerySpec) DeepCopy() *JaegerQuerySpec

                                                                                                                                          DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerQuerySpec.

                                                                                                                                          func (*JaegerQuerySpec) DeepCopyInto

                                                                                                                                          func (in *JaegerQuerySpec) DeepCopyInto(out *JaegerQuerySpec)

                                                                                                                                            DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                                                                            type JaegerSamplingSpec

                                                                                                                                            type JaegerSamplingSpec struct {
                                                                                                                                            	// +optional
                                                                                                                                            	Options FreeForm `json:"options,omitempty"`
                                                                                                                                            }

                                                                                                                                              JaegerSamplingSpec defines the options to be used to configure the UI +k8s:openapi-gen=true

                                                                                                                                              func (*JaegerSamplingSpec) DeepCopy

                                                                                                                                              func (in *JaegerSamplingSpec) DeepCopy() *JaegerSamplingSpec

                                                                                                                                                DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerSamplingSpec.

                                                                                                                                                func (*JaegerSamplingSpec) DeepCopyInto

                                                                                                                                                func (in *JaegerSamplingSpec) DeepCopyInto(out *JaegerSamplingSpec)

                                                                                                                                                  DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                                                                                  type JaegerSpec

                                                                                                                                                  type JaegerSpec struct {
                                                                                                                                                  	// +optional
                                                                                                                                                  	Strategy DeploymentStrategy `json:"strategy,omitempty"`
                                                                                                                                                  
                                                                                                                                                  	// +optional
                                                                                                                                                  	AllInOne JaegerAllInOneSpec `json:"allInOne,omitempty"`
                                                                                                                                                  
                                                                                                                                                  	// +optional
                                                                                                                                                  	Query JaegerQuerySpec `json:"query,omitempty"`
                                                                                                                                                  
                                                                                                                                                  	// +optional
                                                                                                                                                  	Collector JaegerCollectorSpec `json:"collector,omitempty"`
                                                                                                                                                  
                                                                                                                                                  	// +optional
                                                                                                                                                  	Ingester JaegerIngesterSpec `json:"ingester,omitempty"`
                                                                                                                                                  
                                                                                                                                                  	// +optional
                                                                                                                                                  	// +nullable
                                                                                                                                                  	Agent JaegerAgentSpec `json:"agent,omitempty"`
                                                                                                                                                  
                                                                                                                                                  	// +optional
                                                                                                                                                  	UI JaegerUISpec `json:"ui,omitempty"`
                                                                                                                                                  
                                                                                                                                                  	// +optional
                                                                                                                                                  	Sampling JaegerSamplingSpec `json:"sampling,omitempty"`
                                                                                                                                                  
                                                                                                                                                  	// +optional
                                                                                                                                                  	Storage JaegerStorageSpec `json:"storage,omitempty"`
                                                                                                                                                  
                                                                                                                                                  	// +optional
                                                                                                                                                  	Ingress JaegerIngressSpec `json:"ingress,omitempty"`
                                                                                                                                                  
                                                                                                                                                  	// +optional
                                                                                                                                                  	JaegerCommonSpec `json:",inline,omitempty"`
                                                                                                                                                  }

                                                                                                                                                    JaegerSpec defines the desired state of Jaeger +k8s:openapi-gen=true

                                                                                                                                                    func (*JaegerSpec) DeepCopy

                                                                                                                                                    func (in *JaegerSpec) DeepCopy() *JaegerSpec

                                                                                                                                                      DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerSpec.

                                                                                                                                                      func (*JaegerSpec) DeepCopyInto

                                                                                                                                                      func (in *JaegerSpec) DeepCopyInto(out *JaegerSpec)

                                                                                                                                                        DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                                                                                        type JaegerStatus

                                                                                                                                                        type JaegerStatus struct {
                                                                                                                                                        	Version string      `json:"version"`
                                                                                                                                                        	Phase   JaegerPhase `json:"phase"`
                                                                                                                                                        }

                                                                                                                                                          JaegerStatus defines the observed state of Jaeger +k8s:openapi-gen=true

                                                                                                                                                          func (*JaegerStatus) DeepCopy

                                                                                                                                                          func (in *JaegerStatus) DeepCopy() *JaegerStatus

                                                                                                                                                            DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerStatus.

                                                                                                                                                            func (*JaegerStatus) DeepCopyInto

                                                                                                                                                            func (in *JaegerStatus) DeepCopyInto(out *JaegerStatus)

                                                                                                                                                              DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                                                                                              type JaegerStorageSpec

                                                                                                                                                              type JaegerStorageSpec struct {
                                                                                                                                                              	// +optional
                                                                                                                                                              	Type JaegerStorageType `json:"type,omitempty"`
                                                                                                                                                              
                                                                                                                                                              	// +optional
                                                                                                                                                              	SecretName string `json:"secretName,omitempty"`
                                                                                                                                                              
                                                                                                                                                              	// +optional
                                                                                                                                                              	Options Options `json:"options,omitempty"`
                                                                                                                                                              
                                                                                                                                                              	// +optional
                                                                                                                                                              	CassandraCreateSchema JaegerCassandraCreateSchemaSpec `json:"cassandraCreateSchema,omitempty"`
                                                                                                                                                              
                                                                                                                                                              	// +optional
                                                                                                                                                              	Dependencies JaegerDependenciesSpec `json:"dependencies,omitempty"`
                                                                                                                                                              
                                                                                                                                                              	// +optional
                                                                                                                                                              	EsIndexCleaner JaegerEsIndexCleanerSpec `json:"esIndexCleaner,omitempty"`
                                                                                                                                                              
                                                                                                                                                              	// +optional
                                                                                                                                                              	EsRollover JaegerEsRolloverSpec `json:"esRollover,omitempty"`
                                                                                                                                                              
                                                                                                                                                              	// +optional
                                                                                                                                                              	Elasticsearch ElasticsearchSpec `json:"elasticsearch,omitempty"`
                                                                                                                                                              }

                                                                                                                                                                JaegerStorageSpec defines the common storage options to be used for the query and collector +k8s:openapi-gen=true

                                                                                                                                                                func (*JaegerStorageSpec) DeepCopy

                                                                                                                                                                func (in *JaegerStorageSpec) DeepCopy() *JaegerStorageSpec

                                                                                                                                                                  DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerStorageSpec.

                                                                                                                                                                  func (*JaegerStorageSpec) DeepCopyInto

                                                                                                                                                                  func (in *JaegerStorageSpec) DeepCopyInto(out *JaegerStorageSpec)

                                                                                                                                                                    DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                                                                                                    type JaegerStorageType

                                                                                                                                                                    type JaegerStorageType string

                                                                                                                                                                      JaegerStorageType represents the Jaeger storage type +k8s:openapi-gen=true

                                                                                                                                                                      func ValidStorageTypes

                                                                                                                                                                      func ValidStorageTypes() []JaegerStorageType

                                                                                                                                                                        ValidStorageTypes returns the list of valid storage types

                                                                                                                                                                        func (JaegerStorageType) OptionsPrefix

                                                                                                                                                                        func (storageType JaegerStorageType) OptionsPrefix() string

                                                                                                                                                                          OptionsPrefix returns the options prefix associated with the storage type

                                                                                                                                                                          type JaegerUISpec

                                                                                                                                                                          type JaegerUISpec struct {
                                                                                                                                                                          	// +optional
                                                                                                                                                                          	Options FreeForm `json:"options,omitempty"`
                                                                                                                                                                          }

                                                                                                                                                                            JaegerUISpec defines the options to be used to configure the UI +k8s:openapi-gen=true

                                                                                                                                                                            func (*JaegerUISpec) DeepCopy

                                                                                                                                                                            func (in *JaegerUISpec) DeepCopy() *JaegerUISpec

                                                                                                                                                                              DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new JaegerUISpec.

                                                                                                                                                                              func (*JaegerUISpec) DeepCopyInto

                                                                                                                                                                              func (in *JaegerUISpec) DeepCopyInto(out *JaegerUISpec)

                                                                                                                                                                                DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                                                                                                                type Options

                                                                                                                                                                                type Options struct {
                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                }

                                                                                                                                                                                  Options defines a common options parameter to the different structs

                                                                                                                                                                                  func NewOptions

                                                                                                                                                                                  func NewOptions(o map[string]interface{}) Options

                                                                                                                                                                                    NewOptions build a new Options object based on the given map

                                                                                                                                                                                    func (*Options) DeepCopy

                                                                                                                                                                                    func (in *Options) DeepCopy() *Options

                                                                                                                                                                                      DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Options.

                                                                                                                                                                                      func (*Options) DeepCopyInto

                                                                                                                                                                                      func (in *Options) DeepCopyInto(out *Options)

                                                                                                                                                                                        DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

                                                                                                                                                                                        func (*Options) Filter

                                                                                                                                                                                        func (o *Options) Filter(prefix string) Options

                                                                                                                                                                                          Filter creates a new Options object with just the elements identified by the supplied prefix

                                                                                                                                                                                          func (*Options) GenericMap

                                                                                                                                                                                          func (o *Options) GenericMap() map[string]interface{}

                                                                                                                                                                                            GenericMap returns the map representing the option entries as interface{}, suitable for usage with NewOptions()

                                                                                                                                                                                            func (*Options) Map

                                                                                                                                                                                            func (o *Options) Map() map[string]string

                                                                                                                                                                                              Map returns a map representing the option entries. Items are flattened, with dots as separators. For instance an option "cassandra" with a nested "servers" object becomes an entry with the key "cassandra.servers"

                                                                                                                                                                                              func (Options) MarshalJSON

                                                                                                                                                                                              func (o Options) MarshalJSON() ([]byte, error)

                                                                                                                                                                                                MarshalJSON specifies how to convert this object into JSON

                                                                                                                                                                                                func (*Options) ToArgs

                                                                                                                                                                                                func (o *Options) ToArgs() []string

                                                                                                                                                                                                  ToArgs converts the options to a value suitable for the Container.Args field

                                                                                                                                                                                                  func (*Options) UnmarshalJSON

                                                                                                                                                                                                  func (o *Options) UnmarshalJSON(b []byte) error

                                                                                                                                                                                                    UnmarshalJSON implements an alternative parser for this field