/// The MIR of the program.

pub mir: HashMap<MirNodeId, MirNode>,

/// Program schema.

pub program_schema: ProgramSchema,

/// Global controller configuration.

#[serde(flatten)]

#[schema(inline)]

pub global: RuntimeConfig,

/// Configuration for multihost pipelines.

///

/// The presence of this field indicates that the pipeline is running in

/// multihost mode. In the pod with ordinal 0, this triggers starting the

/// coordinator process. In all pods, this tells the pipeline process to

/// await a connection from the coordinator instead of initializing the

/// pipeline immediately.

pub multihost: Option<MultihostConfig>,

/// Unique system-generated name of the pipeline (format: `pipeline-<uuid>`).

/// It is unique across all tenants and cannot be changed.

///

/// The `<uuid>` is also used in the naming of various resources that back the pipeline,

/// and as such this name is useful to find/identify corresponding resources.

pub name: Option<String>,

/// Name given by the tenant to the pipeline. It is only unique within the same tenant, and can

/// be changed by the tenant when the pipeline is stopped.

///

/// Given a specific tenant, it can be used to find/identify a specific pipeline of theirs.

pub given_name: Option<String>,

/// Configuration for persistent storage

///

/// If `global.storage` is `Some(_)`, this field must be set to some

/// [`StorageConfig`]. If `global.storage` is `None``, the pipeline ignores

/// this field.

#[serde(default)]

pub storage_config: Option<StorageConfig>,

/// Directory containing values of secrets.

///

/// If this is not set, a default directory is used.

pub secrets_dir: Option<String>,

/// Input endpoint configuration.

#[serde(default)]

pub inputs: BTreeMap<Cow<'static, str>, InputEndpointConfig>,

/// Output endpoint configuration.

#[serde(default)]

pub outputs: BTreeMap<Cow<'static, str>, OutputEndpointConfig>,

/// Program information.

#[serde(default)]

pub program_ir: Option<ProgramIr>,

pub fn max_parallel_connector_init(&self) -> u64 {

max(

self.global

.max_parallel_connector_init

.unwrap_or(DEFAULT_MAX_PARALLEL_CONNECTOR_INIT),

1,

)

}

pub fn with_storage(self, storage: Option<(StorageConfig, StorageOptions)>) -> Self {

let (storage_config, storage_options) = storage.unzip();

Self {

global: RuntimeConfig {

storage: storage_options,

..self.global

},

storage_config,

..self

}

}

pub fn storage(&self) -> Option<(&StorageConfig, &StorageOptions)> {

let storage_options = self.global.storage.as_ref();

let storage_config = self.storage_config.as_ref();

storage_config.zip(storage_options)

}

/// Returns `self.secrets_dir`, or the default secrets directory if it isn't

/// set.

pub fn secrets_dir(&self) -> &Path {

match &self.secrets_dir {

Some(dir) => Path::new(dir.as_str()),

None => default_secrets_directory(),

}

}

/// Abbreviated config that can be printed in the log on pipeline startup.

pub fn display_summary(&self) -> String {

// TODO: we may want to further abbreviate connector config.

let summary = serde_json::json!({

"name": self.name,

"given_name": self.given_name,

"global": self.global,

"storage_config": self.storage_config,

"secrets_dir": self.secrets_dir,

"inputs": self.inputs,

"outputs": self.outputs

});

serde_json::to_string_pretty(&summary).unwrap_or_else(|_| "{}".to_string())

}

/// Input endpoint configuration.

pub inputs: BTreeMap<Cow<'static, str>, InputEndpointConfig>,

/// Output endpoint configuration.

#[serde(default)]

pub outputs: BTreeMap<Cow<'static, str>, OutputEndpointConfig>,

/// Program information.

#[serde(default)]

pub program_ir: Option<ProgramIr>,

/// Number of hosts to launch.

///

/// For the configuration to be truly multihost, this should be at least 2.

/// A value of 1 still runs the multihost coordinator but it only

/// coordinates a single host.

pub hosts: usize,

fn default() -> Self {

Self { hosts: 1 }

}

/// A directory to keep pipeline state, as a path on the filesystem of the

/// machine or container where the pipeline will run.

///

/// When storage is enabled, this directory stores the data for

/// [StorageBackendConfig::Default].

///

/// When fault tolerance is enabled, this directory stores checkpoints and

/// the log.

pub path: String,

/// How to cache access to storage in this pipeline.

#[serde(default)]

pub cache: StorageCacheConfig,

pub fn path(&self) -> &Path {

Path::new(&self.path)

}

/// Use the operating system's page cache as the primary storage cache.

///

/// This is the default because it currently performs better than

/// `FelderaCache`.

#[default]

PageCache,

/// Use Feldera's internal cache implementation.

///

/// This is under development. It will become the default when its

/// performance exceeds that of `PageCache`.

FelderaCache,

#[cfg(unix)]

pub fn to_custom_open_flags(&self) -> i32 {

match self {

StorageCacheConfig::PageCache => (),

StorageCacheConfig::FelderaCache => {

#[cfg(target_os = "linux")]

return libc::O_DIRECT;

}

}

0

}

/// How to connect to the underlying storage.

pub backend: StorageBackendConfig,

/// For a batch of data maintained as part of a persistent index during a

/// pipeline run, the minimum estimated number of bytes to write it to

/// storage.

///

/// This is provided for debugging and fine-tuning and should ordinarily be

/// left unset.

///

/// A value of 0 will write even empty batches to storage, and nonzero

/// values provide a threshold. `usize::MAX` would effectively disable

/// storage for such batches. The default is 10,048,576 (10 MiB).

pub min_storage_bytes: Option<usize>,

/// For a batch of data passed through the pipeline during a single step,

/// the minimum estimated number of bytes to write it to storage.

///

/// This is provided for debugging and fine-tuning and should ordinarily be

/// left unset. A value of 0 will write even empty batches to storage, and

/// nonzero values provide a threshold. `usize::MAX`, the default,

/// effectively disables storage for such batches. If it is set to another

/// value, it should ordinarily be greater than or equal to

/// `min_storage_bytes`.

pub min_step_storage_bytes: Option<usize>,

/// The form of compression to use in data batches.

///

/// Compression has a CPU cost but it can take better advantage of limited

/// NVMe and network bandwidth, which means that it can increase overall

/// performance.

pub compression: StorageCompression,

/// The maximum size of the in-memory storage cache, in MiB.

///

/// If set, the specified cache size is spread across all the foreground and

/// background threads. If unset, each foreground or background thread cache

/// is limited to 256 MiB.

pub cache_mib: Option<usize>,

/// Use the default storage configuration.

///

/// This currently uses the local file system.

#[default]

Default,

/// Use the local file system.

///

/// This uses ordinary system file operations.

File(Box<FileBackendConfig>),

/// Object storage.

Object(ObjectStorageConfig),

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

match self {

StorageBackendConfig::Default => write!(f, "default"),

StorageBackendConfig::File(_) => write!(f, "file"),

StorageBackendConfig::Object(_) => write!(f, "object"),

}

}

/// Use Feldera's default compression algorithm.

///

/// The default may change as Feldera's performance is tuned and new

/// algorithms are introduced.

#[default]

Default,

/// Do not compress.

None,

/// Use [Snappy](https://en.wikipedia.org/wiki/Snappy_(compression)) compression.

Snappy,

fn schema() -> (

&'static str,

utoipa::openapi::RefOr<utoipa::openapi::schema::Schema>,

) {

(

"StartFromCheckpoint",

utoipa::openapi::RefOr::T(Schema::OneOf(

OneOfBuilder::new()

.item(

ObjectBuilder::new()

.schema_type(SchemaType::String)

.enum_values(Some(["latest"].into_iter()))

.build(),

)

.item(

ObjectBuilder::new()

.schema_type(SchemaType::String)

.format(Some(utoipa::openapi::SchemaFormat::KnownFormat(

utoipa::openapi::KnownFormat::Uuid,

)))

.build(),

)

.nullable(true)

.build(),

)),

)

}

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where

D: Deserializer<'de>,

{

struct StartFromCheckpointVisitor;

impl<'de> Visitor<'de> for StartFromCheckpointVisitor {

type Value = StartFromCheckpoint;

fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {

formatter.write_str("a UUID string or the string \"latest\"")

}

fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>

where

E: de::Error,

{

if value == "latest" {

Ok(StartFromCheckpoint::Latest)

} else {

uuid::Uuid::parse_str(value)

.map(StartFromCheckpoint::Uuid)

.map_err(|_| E::invalid_value(serde::de::Unexpected::Str(value), &self))

}

}

}

deserializer.deserialize_str(StartFromCheckpointVisitor)

}

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where

S: serde::Serializer,

{

match self {

StartFromCheckpoint::Latest => serializer.serialize_str("latest"),

StartFromCheckpoint::Uuid(uuid) => serializer.serialize_str(&uuid.to_string()),

}

}

/// The endpoint URL for the storage service.

///

/// This is typically required for custom or local S3-compatible storage providers like MinIO.

/// Example: `http://localhost:9000`

///

/// Relevant rclone config key: [`endpoint`](https://rclone.org/s3/#s3-endpoint)

pub endpoint: Option<String>,

/// The name of the storage bucket.

///

/// This may include a path to a folder inside the bucket (e.g., `my-bucket/data`).

pub bucket: String,

/// The region that this bucket is in.

///

/// Leave empty for Minio or the default region (`us-east-1` for AWS).

pub region: Option<String>,

/// The name of the cloud storage provider (e.g., `"AWS"`, `"Minio"`).

///

/// Used for provider-specific behavior in rclone.

/// If omitted, defaults to `"Other"`.

///

/// See [rclone S3 provider documentation](https://rclone.org/s3/#s3-provider)

pub provider: Option<String>,

/// The access key used to authenticate with the storage provider.

///

/// If not provided, rclone will fall back to environment-based credentials, such as

/// `RCLONE_S3_ACCESS_KEY_ID`. In Kubernetes environments using IRSA (IAM Roles for Service Accounts),

/// this can be left empty to allow automatic authentication via the pod's service account.

pub access_key: Option<String>,

/// The secret key used together with the access key for authentication.

///

/// If not provided, rclone will fall back to environment-based credentials, such as

/// `RCLONE_S3_SECRET_ACCESS_KEY`. In Kubernetes environments using IRSA (IAM Roles for Service Accounts),

/// this can be left empty to allow automatic authentication via the pod's service account.

pub secret_key: Option<String>,

/// When set, the pipeline will try fetch the specified checkpoint from the

/// object store.

///

/// If `fail_if_no_checkpoint` is `true`, the pipeline will fail to initialize.

pub start_from_checkpoint: Option<StartFromCheckpoint>,

/// When true, the pipeline will fail to initialize if fetching the

/// specified checkpoint fails (missing, download error).

/// When false, the pipeline will start from scratch instead.

///

/// False by default.

#[schema(default = std::primitive::bool::default)]

#[serde(default)]

pub fail_if_no_checkpoint: bool,

/// The number of file transfers to run in parallel.

/// Default: 20

pub transfers: Option<u8>,

/// The number of checkers to run in parallel.

/// Default: 20

pub checkers: Option<u8>,

/// Set to skip post copy check of checksums, and only check the file sizes.

/// This can significantly improve the throughput.

/// Defualt: false

pub ignore_checksum: Option<bool>,

/// Number of streams to use for multi-thread downloads.

/// Default: 10

pub multi_thread_streams: Option<u8>,

/// Use multi-thread download for files above this size.

/// Format: `[size][Suffix]` (Example: 1G, 500M)

/// Supported suffixes: k|M|G|T

/// Default: 100M

pub multi_thread_cutoff: Option<String>,

/// The number of chunks of the same file that are uploaded for multipart uploads.

/// Default: 10

pub upload_concurrency: Option<u8>,

/// When `true`, the pipeline starts in **standby** mode; processing doesn't

/// start until activation (`POST /activate`).

/// If this pipeline was previously activated and the storage has not been

/// cleared, the pipeline will auto activate, no newer checkpoints will be

/// fetched.

///

/// Standby behavior depends on `start_from_checkpoint`:

/// - If `latest`, pipeline continuously fetches the latest available

/// checkpoint until activated.

/// - If checkpoint UUID, pipeline fetches this checkpoint once and waits

/// in standby until activated.

///

/// Default: `false`

#[schema(default = std::primitive::bool::default)]

#[serde(default)]

pub standby: bool,

/// The interval (in seconds) between each attempt to fetch the latest

/// checkpoint from object store while in standby mode.

///

/// Applies only when `start_from_checkpoint` is set to `latest`.

///

/// Default: 10 seconds

#[schema(default = default_pull_interval)]

#[serde(default = "default_pull_interval")]

pub pull_interval: u64,

/// The interval (in seconds) between each push of checkpoints to object store.

///

/// Default: disabled (no periodic push).

#[serde(default)]

pub push_interval: Option<u64>,

/// Extra flags to pass to `rclone`.

///

/// WARNING: Supplying incorrect or conflicting flags can break `rclone`.

/// Use with caution.

///

/// Refer to the docs to see the supported flags:

/// - [Global flags](https://rclone.org/flags/)

/// - [S3 specific flags](https://rclone.org/s3/)

pub flags: Option<Vec<String>>,

/// The minimum number of checkpoints to retain in object store.

/// No checkpoints will be deleted if the total count is below this threshold.

///

/// Default: 10

#[schema(default = default_retention_min_count)]

#[serde(default = "default_retention_min_count")]

pub retention_min_count: u32,

/// The minimum age (in days) a checkpoint must reach before it becomes

/// eligible for deletion. All younger checkpoints will be preserved.

///

/// Default: 30

#[schema(default = default_retention_min_age)]

#[serde(default = "default_retention_min_age")]

pub retention_min_age: u32,

/// A read-only bucket used as a fallback checkpoint source.

///

/// When the pipeline has no local checkpoint and `bucket` contains no

/// checkpoint either, it will attempt to fetch the checkpoint from this

/// location instead. All connection settings (`endpoint`, `region`,

/// `provider`, `access_key`, `secret_key`) are shared with `bucket`.

///

/// The pipeline **never writes** to `read_bucket`.

///

/// Must point to a different location than `bucket`.

#[serde(default)]

pub read_bucket: Option<String>,

pub fn validate(&self) -> Result<(), String> {

if self.standby && self.start_from_checkpoint.is_none() {

return Err(r#"invalid sync config: `standby` set to `true` but `start_from_checkpoint` not set.

}

if let Some(ref rb) = self.read_bucket

&& rb == &self.bucket

{

return Err(

"invalid sync config: `read_bucket` and `bucket` must point to different locations"

.to_owned(),

);

}

Ok(())

}

/// Name of the ConfigMap containing the pipeline template.

pub name: String,

/// Key in the ConfigMap containing the pipeline template.

///

/// If not set, defaults to `pipelineTemplate`.

#[schema(default = default_pipeline_template_key)]

#[serde(default = "default_pipeline_template_key")]

pub key: String,

/// URL.

///

/// The following URL schemes are supported:

///

/// * S3:

/// - `s3://<bucket>/<path>`

/// - `s3a://<bucket>/<path>`

/// - `https://s3.<region>.amazonaws.com/<bucket>`

/// - `https://<bucket>.s3.<region>.amazonaws.com`

/// - `https://ACCOUNT_ID.r2.cloudflarestorage.com/bucket`

/// * Google Cloud Storage:

/// - `gs://<bucket>/<path>`

/// * Microsoft Azure Blob Storage:

/// - `abfs[s]://<container>/<path>` (according to [fsspec](https://github.com/fsspec/adlfs))

/// - `abfs[s]://<file_system>@<account_name>.dfs.core.windows.net/<path>`

/// - `abfs[s]://<file_system>@<account_name>.dfs.fabric.microsoft.com/<path>`

/// - `az://<container>/<path>` (according to [fsspec](https://github.com/fsspec/adlfs))

/// - `adl://<container>/<path>` (according to [fsspec](https://github.com/fsspec/adlfs))

/// - `azure://<container>/<path>` (custom)

/// - `https://<account>.dfs.core.windows.net`

/// - `https://<account>.blob.core.windows.net`

/// - `https://<account>.blob.core.windows.net/<container>`

/// - `https://<account>.dfs.fabric.microsoft.com`

/// - `https://<account>.dfs.fabric.microsoft.com/<container>`

/// - `https://<account>.blob.fabric.microsoft.com`

/// - `https://<account>.blob.fabric.microsoft.com/<container>`

///

/// Settings derived from the URL will override other settings.

pub url: String,

/// Additional options as key-value pairs.

///

/// The following keys are supported:

///

/// * S3:

/// - `access_key_id`: AWS Access Key.

/// - `secret_access_key`: AWS Secret Access Key.

/// - `region`: Region.

/// - `default_region`: Default region.

/// - `endpoint`: Custom endpoint for communicating with S3,

/// e.g. `https://localhost:4566` for testing against a localstack

/// instance.

/// - `token`: Token to use for requests (passed to underlying provider).

/// - [Other keys](https://docs.rs/object_store/latest/object_store/aws/enum.AmazonS3ConfigKey.html#variants).

/// * Google Cloud Storage:

/// - `service_account`: Path to the service account file.

/// - `service_account_key`: The serialized service account key.

/// - `google_application_credentials`: Application credentials path.

/// - [Other keys](https://docs.rs/object_store/latest/object_store/gcp/enum.GoogleConfigKey.html).

/// * Microsoft Azure Blob Storage:

/// - `access_key`: Azure Access Key.

/// - `container_name`: Azure Container Name.

/// - `account`: Azure Account.

/// - `bearer_token_authorization`: Static bearer token for authorizing requests.

/// - `client_id`: Client ID for use in client secret or Kubernetes federated credential flow.

/// - `client_secret`: Client secret for use in client secret flow.

/// - `tenant_id`: Tenant ID for use in client secret or Kubernetes federated credential flow.

/// - `endpoint`: Override the endpoint for communicating with blob storage.

/// - [Other keys](https://docs.rs/object_store/latest/object_store/azure/enum.AzureConfigKey.html#variants).

///

/// Options set through the URL take precedence over those set with these

/// options.

#[serde(flatten)]

pub other_options: BTreeMap<String, String>,

/// Whether to use background threads for file I/O.

///

/// Background threads should improve performance, but they can reduce

/// performance if too few cores are available. This is provided for

/// debugging and fine-tuning and should ordinarily be left unset.

pub async_threads: Option<bool>,

/// Per-I/O operation sleep duration, in milliseconds.

///

/// This is for simulating slow storage devices. Do not use this in

/// production.

pub ioop_delay: Option<u64>,

/// Configuration to synchronize checkpoints to object store.

pub sync: Option<SyncConfig>,

/// Number of DBSP worker threads.

///

/// Each DBSP "foreground" worker thread is paired with a "background"

/// thread for LSM merging, making the total number of threads twice the

/// specified number.

///

/// The typical sweet spot for the number of workers is between 4 and 16.

/// Each worker increases overall memory consumption for data structures

/// used during a step.

pub workers: u16,

/// Number of DBSP hosts.

///

/// The worker threads are evenly divided among the hosts. For single-host

/// deployments, this should be 1 (the default).

///

/// Multihost pipelines are an enterprise-only preview feature.

pub hosts: usize,

/// Storage configuration.

///

/// - If this is `None`, the default, the pipeline's state is kept in

/// in-memory data-structures. This is useful if the pipeline's state

/// will fit in memory and if the pipeline is ephemeral and does not need

/// to be recovered after a restart. The pipeline will most likely run

/// faster since it does not need to access storage.

///

/// - If set, the pipeline's state is kept on storage. This allows the

/// pipeline to work with state that will not fit into memory. It also

/// allows the state to be checkpointed and recovered across restarts.

#[serde(deserialize_with = "deserialize_storage_options")]

pub storage: Option<StorageOptions>,

/// Fault tolerance configuration.

#[serde(deserialize_with = "deserialize_fault_tolerance")]

pub fault_tolerance: FtConfig,

/// Enable CPU profiler.

///

/// The default value is `true`.

pub cpu_profiler: bool,

/// Enable pipeline tracing.

pub tracing: bool,

/// Jaeger tracing endpoint to send tracing information to.

pub tracing_endpoint_jaeger: String,

/// Minimal input batch size.

///

/// The controller delays pushing input records to the circuit until at

/// least `min_batch_size_records` records have been received (total

/// across all endpoints) or `max_buffering_delay_usecs` microseconds

/// have passed since at least one input records has been buffered.

/// Defaults to 0.

pub min_batch_size_records: u64,

/// Maximal delay in microseconds to wait for `min_batch_size_records` to

/// get buffered by the controller, defaults to 0.

pub max_buffering_delay_usecs: u64,

/// Resource reservations and limits. This is enforced

/// only in Feldera Cloud.

pub resources: ResourceConfig,

/// Real-time clock resolution in microseconds.

///

/// This parameter controls the execution of queries that use the `NOW()` function. The output of such

/// queries depends on the real-time clock and can change over time without any external

/// inputs. If the query uses `NOW()`, the pipeline will update the clock value and trigger incremental

/// recomputation at most each `clock_resolution_usecs` microseconds. If the query does not use

/// `NOW()`, then clock value updates are suppressed and the pipeline ignores this setting.

///

/// It is set to 1 second (1,000,000 microseconds) by default.

pub clock_resolution_usecs: Option<u64>,

/// Optionally, a list of CPU numbers for CPUs to which the pipeline may pin

/// its worker threads. Specify at least twice as many CPU numbers as

/// workers. CPUs are generally numbered starting from 0. The pipeline

/// might not be able to honor CPU pinning requests.

///

/// CPU pinning can make pipelines run faster and perform more consistently,

/// as long as different pipelines running on the same machine are pinned to

/// different CPUs.

pub pin_cpus: Vec<usize>,

/// Timeout in seconds for the `Provisioning` phase of the pipeline.

/// Setting this value will override the default of the runner.

pub provisioning_timeout_secs: Option<u64>,

/// The maximum number of connectors initialized in parallel during pipeline

/// startup.

///

/// At startup, the pipeline must initialize all of its input and output connectors.

/// Depending on the number and types of connectors, this can take a long time.

/// To accelerate the process, multiple connectors are initialized concurrently.

/// This option controls the maximum number of connectors that can be initialized

/// in parallel.

///

/// The default is 10.

pub max_parallel_connector_init: Option<u64>,

/// Specification of additional (sidecar) containers.

pub init_containers: Option<serde_json::Value>,

/// Deprecated: setting this true or false does not have an effect anymore.

pub checkpoint_during_suspend: bool,

/// Sets the number of available runtime threads for the http server.

///

/// In most cases, this does not need to be set explicitly and

/// the default is sufficient. Can be increased in case the

/// pipeline HTTP API operations are a bottleneck.

///

/// If not specified, the default is set to `workers`.

pub http_workers: Option<u64>,

/// Sets the number of available runtime threads for async IO tasks.

///

/// This affects some networking and file I/O operations

/// especially adapters and ad-hoc queries.

///

/// In most cases, this does not need to be set explicitly and

/// the default is sufficient. Can be increased in case

/// ingress, egress or ad-hoc queries are a bottleneck.

///

/// If not specified, the default is set to `workers`.

pub io_workers: Option<u64>,

/// Environment variables for the pipeline process.

///

/// These are key-value pairs injected into the pipeline process environment.

/// Some variable names are reserved by the platform and cannot be overridden

/// (for example `RUST_LOG`, and variables in the `FELDERA_`,

/// `KUBERNETES_`, and `TOKIO_` namespaces).

#[serde(default)]

pub env: BTreeMap<String, String>,

/// Optional settings for tweaking Feldera internals.

///

/// The available key-value pairs change from one version of Feldera to

/// another, so users should not depend on particular settings being

/// available, or on their behavior.

pub dev_tweaks: BTreeMap<String, serde_json::Value>,

/// Log filtering directives.

///

/// If set to a valid [tracing-subscriber] filter, this controls the log

/// messages emitted by the pipeline process. Otherwise, or if the filter

/// has invalid syntax, messages at "info" severity and higher are written

/// to the log and all others are discarded.

///

/// [tracing-subscriber]: https://docs.rs/tracing-subscriber/latest/tracing_subscriber/filter/struct.EnvFilter.html#directives

pub logging: Option<String>,

/// ConfigMap containing a custom pipeline template (Enterprise only).

///

/// This feature is only available in Feldera Enterprise. If set, the Kubernetes runner

/// will read the template from the specified ConfigMap and use it instead of the default

/// StatefulSet template for the configured pipeline.

///

/// check [`PipelineTemplateConfig`] documentation for details.

pub pipeline_template_configmap: Option<PipelineTemplateConfig>,

D: Deserializer<'de>,

struct BoolOrStruct;

impl<'de> Visitor<'de> for BoolOrStruct {

type Value = Option<StorageOptions>;

fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {

formatter.write_str("boolean or StorageOptions")

}

fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>

where

E: de::Error,

{

match v {

false => Ok(None),

true => Ok(Some(StorageOptions::default())),

}

}

fn visit_unit<E>(self) -> Result<Self::Value, E>

where

E: de::Error,

{

Ok(None)

}

fn visit_none<E>(self) -> Result<Self::Value, E>

where

E: de::Error,

{

Ok(None)

}

fn visit_map<M>(self, map: M) -> Result<Option<StorageOptions>, M::Error>

where

M: MapAccess<'de>,

{

Deserialize::deserialize(de::value::MapAccessDeserializer::new(map)).map(Some)

}

}

deserializer.deserialize_any(BoolOrStruct)

D: Deserializer<'de>,

struct StringOrStruct;

impl<'de> Visitor<'de> for StringOrStruct {

type Value = FtConfig;

fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {

formatter.write_str("none or FtConfig or 'initial_state' or 'latest_checkpoint'")

}