| /** |
| * Generated by karavan build tools - do NOT edit this file! |
| */ |
| import {CamelElement} from "./IntegrationDefinition"; |
| |
| export class TraitPropertyMeta { |
| name: string |
| type: string |
| description: string |
| |
| constructor(name: string, type: string, description: string) { |
| this.name = name; |
| this.type = type; |
| this.description = description; |
| } |
| } |
| |
| export class TraitMeta { |
| name: string |
| platform: boolean |
| profiles: string |
| description: string |
| properties: TraitPropertyMeta[] |
| |
| |
| constructor(name: string, platform:boolean, profiles: string, description: string, properties: TraitPropertyMeta[]) { |
| this.name = name; |
| this.platform = platform; |
| this.profiles = profiles; |
| this.description = description; |
| this.properties = properties; |
| } |
| } |
| |
| export class Trait extends CamelElement { |
| affinity?: AffinityTrait; |
| builder?: BuilderTrait; |
| camel?: CamelTrait; |
| container?: ContainerTrait; |
| cron?: CronTrait; |
| dependencies?: DependenciesTrait; |
| deployer?: DeployerTrait; |
| deployment?: DeploymentTrait; |
| environment?: EnvironmentTrait; |
| errorHandler?: ErrorHandlerTrait; |
| gc?: GcTrait; |
| health?: HealthTrait; |
| ingress?: IngressTrait; |
| istio?: IstioTrait; |
| jolokia?: JolokiaTrait; |
| jvm?: JvmTrait; |
| kamelets?: KameletsTrait; |
| keda?: KedaTrait; |
| knativeService?: KnativeServiceTrait; |
| knative?: KnativeTrait; |
| logging?: LoggingTrait; |
| master?: MasterTrait; |
| mount?: MountTrait; |
| openapi?: OpenapiTrait; |
| owner?: OwnerTrait; |
| pdb?: PdbTrait; |
| platform?: PlatformTrait; |
| pod?: PodTrait; |
| prometheus?: PrometheusTrait; |
| pullSecret?: PullSecretTrait; |
| quarkus?: QuarkusTrait; |
| route?: RouteTrait; |
| serviceBinding?: ServiceBindingTrait; |
| service?: ServiceTrait; |
| threeScale?: ThreeScaleTrait; |
| toleration?: TolerationTrait; |
| tracing?: TracingTrait; |
| public constructor(init?: Partial<Trait>) { |
| super('Trait') |
| Object.assign(this, init) |
| } |
| } |
| export class AffinityTrait extends CamelElement { |
| enabled?: boolean; |
| podAffinity?: boolean; |
| podAntiAffinity?: boolean; |
| nodeAffinityLabels?: string[]; |
| podAffinityLabels?: string[]; |
| podAntiAffinityLabels?: string[]; |
| public constructor(init?: Partial<AffinityTrait>) { |
| super('AffinityTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class BuilderTrait extends CamelElement { |
| enabled?: boolean; |
| verbose?: boolean; |
| properties?: string[]; |
| public constructor(init?: Partial<BuilderTrait>) { |
| super('BuilderTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class CamelTrait extends CamelElement { |
| enabled?: boolean; |
| runtimeVersion?: string; |
| properties?: string[]; |
| public constructor(init?: Partial<CamelTrait>) { |
| super('CamelTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class ContainerTrait extends CamelElement { |
| enabled?: boolean; |
| auto?: boolean; |
| requestCpu?: string; |
| requestMemory?: string; |
| limitCpu?: string; |
| limitMemory?: string; |
| expose?: boolean; |
| port?: string; |
| portName?: string; |
| servicePort?: string; |
| servicePortName?: string; |
| name?: string; |
| image?: string; |
| imagePullPolicy?: string; |
| probesEnabled?: boolean; |
| livenessScheme?: string; |
| livenessInitialDelay?: number; |
| livenessTimeout?: number; |
| livenessPeriod?: number; |
| livenessSuccessThreshold?: number; |
| livenessFailureThreshold?: number; |
| readinessScheme?: string; |
| readinessInitialDelay?: number; |
| readinessTimeout?: number; |
| readinessPeriod?: number; |
| readinessSuccessThreshold?: number; |
| readinessFailureThreshold?: number; |
| public constructor(init?: Partial<ContainerTrait>) { |
| super('ContainerTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class CronTrait extends CamelElement { |
| enabled?: boolean; |
| schedule?: string; |
| components?: string; |
| fallback?: boolean; |
| concurrencyPolicy?: string; |
| auto?: boolean; |
| startingDeadlineSeconds?: number; |
| activeDeadlineSeconds?: number; |
| backoffLimit?: number; |
| public constructor(init?: Partial<CronTrait>) { |
| super('CronTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class DependenciesTrait extends CamelElement { |
| public constructor(init?: Partial<DependenciesTrait>) { |
| super('DependenciesTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class DeployerTrait extends CamelElement { |
| enabled?: boolean; |
| kind?: string; |
| public constructor(init?: Partial<DeployerTrait>) { |
| super('DeployerTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class DeploymentTrait extends CamelElement { |
| enabled?: boolean; |
| progressDeadlineSeconds?: number; |
| public constructor(init?: Partial<DeploymentTrait>) { |
| super('DeploymentTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class EnvironmentTrait extends CamelElement { |
| enabled?: boolean; |
| containerMeta?: boolean; |
| httpProxy?: boolean; |
| vars?: string[]; |
| public constructor(init?: Partial<EnvironmentTrait>) { |
| super('EnvironmentTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class ErrorHandlerTrait extends CamelElement { |
| enabled?: boolean; |
| ref?: string; |
| public constructor(init?: Partial<ErrorHandlerTrait>) { |
| super('ErrorHandlerTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class GcTrait extends CamelElement { |
| enabled?: boolean; |
| discoveryCache?: string; |
| public constructor(init?: Partial<GcTrait>) { |
| super('GcTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class HealthTrait extends CamelElement { |
| enabled?: boolean; |
| livenessProbeEnabled?: boolean; |
| livenessScheme?: string; |
| livenessInitialDelay?: number; |
| livenessTimeout?: number; |
| livenessPeriod?: number; |
| livenessSuccessThreshold?: number; |
| livenessFailureThreshold?: number; |
| readinessProbeEnabled?: boolean; |
| readinessScheme?: string; |
| readinessInitialDelay?: number; |
| readinessTimeout?: number; |
| readinessPeriod?: number; |
| readinessSuccessThreshold?: number; |
| readinessFailureThreshold?: number; |
| public constructor(init?: Partial<HealthTrait>) { |
| super('HealthTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class IngressTrait extends CamelElement { |
| enabled?: boolean; |
| host?: string; |
| auto?: boolean; |
| public constructor(init?: Partial<IngressTrait>) { |
| super('IngressTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class IstioTrait extends CamelElement { |
| enabled?: boolean; |
| allow?: string; |
| inject?: boolean; |
| public constructor(init?: Partial<IstioTrait>) { |
| super('IstioTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class JolokiaTrait extends CamelElement { |
| enabled?: boolean; |
| caCert?: string; |
| clientPrincipal?: string[]; |
| discoveryEnabled?: boolean; |
| extendedClientCheck?: boolean; |
| host?: string; |
| password?: string; |
| port?: string; |
| protocol?: string; |
| user?: string; |
| useSslClientAuthentication?: boolean; |
| options?: string[]; |
| public constructor(init?: Partial<JolokiaTrait>) { |
| super('JolokiaTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class JvmTrait extends CamelElement { |
| enabled?: boolean; |
| debug?: boolean; |
| debugSuspend?: boolean; |
| printCommand?: boolean; |
| debugAddress?: string; |
| options?: string[]; |
| classpath?: string; |
| public constructor(init?: Partial<JvmTrait>) { |
| super('JvmTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class KameletsTrait extends CamelElement { |
| enabled?: boolean; |
| auto?: boolean; |
| list?: string; |
| public constructor(init?: Partial<KameletsTrait>) { |
| super('KameletsTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class KedaTrait extends CamelElement { |
| enabled?: boolean; |
| auto?: boolean; |
| hackControllerReplicas?: boolean; |
| pollingInterval?: number; |
| cooldownPeriod?: number; |
| idleReplicaCount?: number; |
| minReplicaCount?: number; |
| maxReplicaCount?: number; |
| triggers?: string; |
| public constructor(init?: Partial<KedaTrait>) { |
| super('KedaTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class KnativeServiceTrait extends CamelElement { |
| enabled?: boolean; |
| autoscalingClass?: string; |
| autoscalingMetric?: string; |
| autoscalingTarget?: string; |
| minScale?: string; |
| maxScale?: string; |
| rolloutDuration?: string; |
| auto?: boolean; |
| public constructor(init?: Partial<KnativeServiceTrait>) { |
| super('KnativeServiceTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class KnativeTrait extends CamelElement { |
| enabled?: boolean; |
| configuration?: string; |
| channelSources?: string[]; |
| channelSinks?: string[]; |
| endpointSources?: string[]; |
| endpointSinks?: string[]; |
| eventSources?: string[]; |
| eventSinks?: string[]; |
| filterSourceChannels?: boolean; |
| sinkBinding?: boolean; |
| auto?: boolean; |
| public constructor(init?: Partial<KnativeTrait>) { |
| super('KnativeTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class LoggingTrait extends CamelElement { |
| enabled?: boolean; |
| color?: boolean; |
| format?: string; |
| level?: string; |
| json?: boolean; |
| jsonPrettyPrint?: boolean; |
| public constructor(init?: Partial<LoggingTrait>) { |
| super('LoggingTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class MasterTrait extends CamelElement { |
| enabled?: boolean; |
| auto?: boolean; |
| includeDelegateDependencies?: boolean; |
| resourceName?: string; |
| resourceType?: string; |
| labelKey?: string; |
| labelValue?: string; |
| public constructor(init?: Partial<MasterTrait>) { |
| super('MasterTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class MountTrait extends CamelElement { |
| enabled?: boolean; |
| configs?: string[]; |
| resources?: string[]; |
| volumes?: string[]; |
| public constructor(init?: Partial<MountTrait>) { |
| super('MountTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class OpenapiTrait extends CamelElement { |
| enabled?: boolean; |
| configmaps?: string[]; |
| public constructor(init?: Partial<OpenapiTrait>) { |
| super('OpenapiTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class OwnerTrait extends CamelElement { |
| enabled?: boolean; |
| targetAnnotations?: string[]; |
| targetLabels?: string[]; |
| public constructor(init?: Partial<OwnerTrait>) { |
| super('OwnerTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class PdbTrait extends CamelElement { |
| enabled?: boolean; |
| minAvailable?: string; |
| maxUnavailable?: string; |
| public constructor(init?: Partial<PdbTrait>) { |
| super('PdbTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class PlatformTrait extends CamelElement { |
| enabled?: boolean; |
| createDefault?: boolean; |
| global?: boolean; |
| auto?: boolean; |
| public constructor(init?: Partial<PlatformTrait>) { |
| super('PlatformTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class PodTrait extends CamelElement { |
| public constructor(init?: Partial<PodTrait>) { |
| super('PodTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class PrometheusTrait extends CamelElement { |
| enabled?: boolean; |
| podMonitor?: boolean; |
| podMonitorLabels?: string[]; |
| public constructor(init?: Partial<PrometheusTrait>) { |
| super('PrometheusTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class PullSecretTrait extends CamelElement { |
| enabled?: boolean; |
| secretName?: string; |
| imagePullerDelegation?: boolean; |
| auto?: boolean; |
| public constructor(init?: Partial<PullSecretTrait>) { |
| super('PullSecretTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class QuarkusTrait extends CamelElement { |
| enabled?: boolean; |
| packageType?: string; |
| public constructor(init?: Partial<QuarkusTrait>) { |
| super('QuarkusTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class RouteTrait extends CamelElement { |
| enabled?: boolean; |
| host?: string; |
| tlsTermination?: string; |
| tlsCertificate?: string; |
| tlsCertificateSecret?: string; |
| tlsKey?: string; |
| tlsKeySecret?: string; |
| tlsCaCertificate?: string; |
| tlsCaCertificateSecret?: string; |
| tlsDestinationCaCertificate?: string; |
| tlsDestinationCaCertificateSecret?: string; |
| tlsInsecureEdgeTerminationPolicy?: string; |
| public constructor(init?: Partial<RouteTrait>) { |
| super('RouteTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class ServiceBindingTrait extends CamelElement { |
| enabled?: boolean; |
| services?: string[]; |
| public constructor(init?: Partial<ServiceBindingTrait>) { |
| super('ServiceBindingTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class ServiceTrait extends CamelElement { |
| enabled?: boolean; |
| auto?: boolean; |
| nodePort?: boolean; |
| public constructor(init?: Partial<ServiceTrait>) { |
| super('ServiceTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class ThreeScaleTrait extends CamelElement { |
| enabled?: boolean; |
| auto?: boolean; |
| scheme?: string; |
| path?: string; |
| port?: string; |
| descriptionPath?: string; |
| public constructor(init?: Partial<ThreeScaleTrait>) { |
| super('ThreeScaleTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class TolerationTrait extends CamelElement { |
| enabled?: boolean; |
| taints?: string[]; |
| public constructor(init?: Partial<TolerationTrait>) { |
| super('TolerationTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class TracingTrait extends CamelElement { |
| enabled?: boolean; |
| auto?: boolean; |
| serviceName?: string; |
| endpoint?: string; |
| samplerType?: string; |
| samplerParam?: string; |
| public constructor(init?: Partial<TracingTrait>) { |
| super('TracingTrait') |
| Object.assign(this, init) |
| } |
| } |
| |
| export class TraitApi { |
| |
| static traitsFromYaml(yaml: any) { |
| const traits: Trait = new Trait(); |
| Object.keys(yaml).forEach(key => { |
| if (key === 'affinity') traits.affinity = new AffinityTrait(yaml.affinity.configuration); |
| if (key === 'builder') traits.builder = new BuilderTrait(yaml.builder.configuration); |
| if (key === 'camel') traits.camel = new CamelTrait(yaml.camel.configuration); |
| if (key === 'container') traits.container = new ContainerTrait(yaml.container.configuration); |
| if (key === 'cron') traits.cron = new CronTrait(yaml.cron.configuration); |
| if (key === 'dependencies') traits.dependencies = new DependenciesTrait(yaml.dependencies.configuration); |
| if (key === 'deployer') traits.deployer = new DeployerTrait(yaml.deployer.configuration); |
| if (key === 'deployment') traits.deployment = new DeploymentTrait(yaml.deployment.configuration); |
| if (key === 'environment') traits.environment = new EnvironmentTrait(yaml.environment.configuration); |
| if (key === 'errorHandler') traits.errorHandler = new ErrorHandlerTrait(yaml.errorHandler.configuration); |
| if (key === 'gc') traits.gc = new GcTrait(yaml.gc.configuration); |
| if (key === 'health') traits.health = new HealthTrait(yaml.health.configuration); |
| if (key === 'ingress') traits.ingress = new IngressTrait(yaml.ingress.configuration); |
| if (key === 'istio') traits.istio = new IstioTrait(yaml.istio.configuration); |
| if (key === 'jolokia') traits.jolokia = new JolokiaTrait(yaml.jolokia.configuration); |
| if (key === 'jvm') traits.jvm = new JvmTrait(yaml.jvm.configuration); |
| if (key === 'kamelets') traits.kamelets = new KameletsTrait(yaml.kamelets.configuration); |
| if (key === 'keda') traits.keda = new KedaTrait(yaml.keda.configuration); |
| if (key === 'knativeService') traits.knativeService = new KnativeServiceTrait(yaml.knativeService.configuration); |
| if (key === 'knative') traits.knative = new KnativeTrait(yaml.knative.configuration); |
| if (key === 'logging') traits.logging = new LoggingTrait(yaml.logging.configuration); |
| if (key === 'master') traits.master = new MasterTrait(yaml.master.configuration); |
| if (key === 'mount') traits.mount = new MountTrait(yaml.mount.configuration); |
| if (key === 'openapi') traits.openapi = new OpenapiTrait(yaml.openapi.configuration); |
| if (key === 'owner') traits.owner = new OwnerTrait(yaml.owner.configuration); |
| if (key === 'pdb') traits.pdb = new PdbTrait(yaml.pdb.configuration); |
| if (key === 'platform') traits.platform = new PlatformTrait(yaml.platform.configuration); |
| if (key === 'pod') traits.pod = new PodTrait(yaml.pod.configuration); |
| if (key === 'prometheus') traits.prometheus = new PrometheusTrait(yaml.prometheus.configuration); |
| if (key === 'pullSecret') traits.pullSecret = new PullSecretTrait(yaml.pullSecret.configuration); |
| if (key === 'quarkus') traits.quarkus = new QuarkusTrait(yaml.quarkus.configuration); |
| if (key === 'route') traits.route = new RouteTrait(yaml.route.configuration); |
| if (key === 'serviceBinding') traits.serviceBinding = new ServiceBindingTrait(yaml.serviceBinding.configuration); |
| if (key === 'service') traits.service = new ServiceTrait(yaml.service.configuration); |
| if (key === '3scale') traits.threeScale = new ThreeScaleTrait(yaml["3scale"].configuration); |
| if (key === 'toleration') traits.toleration = new TolerationTrait(yaml.toleration.configuration); |
| if (key === 'tracing') traits.tracing = new TracingTrait(yaml.tracing.configuration); |
| }); |
| return traits; |
| } |
| |
| static cloneTrait(t: Trait) { |
| const clone = JSON.parse(JSON.stringify(t)); |
| const traits: Trait = new Trait(); |
| Object.keys(clone).forEach(key => { if (key === 'affinity') traits.affinity = new AffinityTrait(clone.affinity); |
| if (key === 'builder') traits.builder = new BuilderTrait(clone.builder); |
| if (key === 'camel') traits.camel = new CamelTrait(clone.camel); |
| if (key === 'container') traits.container = new ContainerTrait(clone.container); |
| if (key === 'cron') traits.cron = new CronTrait(clone.cron); |
| if (key === 'dependencies') traits.dependencies = new DependenciesTrait(clone.dependencies); |
| if (key === 'deployer') traits.deployer = new DeployerTrait(clone.deployer); |
| if (key === 'deployment') traits.deployment = new DeploymentTrait(clone.deployment); |
| if (key === 'environment') traits.environment = new EnvironmentTrait(clone.environment); |
| if (key === 'errorHandler') traits.errorHandler = new ErrorHandlerTrait(clone.errorHandler); |
| if (key === 'gc') traits.gc = new GcTrait(clone.gc); |
| if (key === 'health') traits.health = new HealthTrait(clone.health); |
| if (key === 'ingress') traits.ingress = new IngressTrait(clone.ingress); |
| if (key === 'istio') traits.istio = new IstioTrait(clone.istio); |
| if (key === 'jolokia') traits.jolokia = new JolokiaTrait(clone.jolokia); |
| if (key === 'jvm') traits.jvm = new JvmTrait(clone.jvm); |
| if (key === 'kamelets') traits.kamelets = new KameletsTrait(clone.kamelets); |
| if (key === 'keda') traits.keda = new KedaTrait(clone.keda); |
| if (key === 'knativeService') traits.knativeService = new KnativeServiceTrait(clone.knativeService); |
| if (key === 'knative') traits.knative = new KnativeTrait(clone.knative); |
| if (key === 'logging') traits.logging = new LoggingTrait(clone.logging); |
| if (key === 'master') traits.master = new MasterTrait(clone.master); |
| if (key === 'mount') traits.mount = new MountTrait(clone.mount); |
| if (key === 'openapi') traits.openapi = new OpenapiTrait(clone.openapi); |
| if (key === 'owner') traits.owner = new OwnerTrait(clone.owner); |
| if (key === 'pdb') traits.pdb = new PdbTrait(clone.pdb); |
| if (key === 'platform') traits.platform = new PlatformTrait(clone.platform); |
| if (key === 'pod') traits.pod = new PodTrait(clone.pod); |
| if (key === 'prometheus') traits.prometheus = new PrometheusTrait(clone.prometheus); |
| if (key === 'pullSecret') traits.pullSecret = new PullSecretTrait(clone.pullSecret); |
| if (key === 'quarkus') traits.quarkus = new QuarkusTrait(clone.quarkus); |
| if (key === 'route') traits.route = new RouteTrait(clone.route); |
| if (key === 'serviceBinding') traits.serviceBinding = new ServiceBindingTrait(clone.serviceBinding); |
| if (key === 'service') traits.service = new ServiceTrait(clone.service); |
| if (key === 'threeScale') traits.threeScale = new ThreeScaleTrait(clone.threeScale); |
| if (key === 'toleration') traits.toleration = new TolerationTrait(clone.toleration); |
| if (key === 'tracing') traits.tracing = new TracingTrait(clone.tracing); |
| }); |
| return traits; |
| } |
| } |
| |
| export const CamelTraitMetadata: TraitMeta[] = [ new TraitMeta("affinity", false, "Kubernetes, Knative, OpenShift", "Allows constraining which nodes the integration pod(s) are eligible to be scheduled on, based on labels on the node, or with inter-pod affinity and anti-affinity, based on labels on pods that are already running on the nodes. It's disabled by default.", [ |
| ]), |
| new TraitMeta("builder", false, "Kubernetes, Knative, OpenShift", "The builder trait is internally used to determine the best strategy to build and configure IntegrationKits.", [ |
| ]), |
| new TraitMeta("camel", false, "Kubernetes, Knative, OpenShift", "The Camel trait can be used to configure versions of Apache Camel K runtime and related libraries, it cannot be disabled.", [ |
| ]), |
| new TraitMeta("container", false, "Kubernetes, Knative, OpenShift", "The Container trait can be used to configure properties of the container where the integration will run. It also provides configuration for Services associated to the container.", [ |
| ]), |
| new TraitMeta("cron", false, "Kubernetes, Knative, OpenShift", "The Cron trait can be used to customize the behaviour of periodic timer/cron based integrations. While normally an integration requires a pod to be always up and running, some periodic tasks, such as batch jobs, require to be activated at specific hours of the day or with a periodic delay of minutes. For such tasks, the cron trait can materialize the integration as a Kubernetes CronJob instead of a standard deployment, in order to save resources when the integration does not need to be executed. Integrations that start from the following components are evaluated by the cron trait: `timer`, `cron`, `quartz`. The rules for using a Kubernetes CronJob are the following: - `timer`: when periods can be written as cron expressions. E.g. `timer:tick?period=60000`. - `cron`, `quartz`: when the cron expression does not contain seconds (or the \"seconds\" part is set to 0). E.g. `cron:tab?schedule=0/2${plus}*{plus}*{plus}*{plus}?` or `quartz:trigger?cron=0{plus}0/2{plus}*{plus}*{plus}*{plus}?`.", [ |
| ]), |
| new TraitMeta("dependencies", false, "Kubernetes, Knative, OpenShift", "The Dependencies trait is internally used to automatically add runtime dependencies based on the integration that the user wants to run.", [ |
| ]), |
| new TraitMeta("deployer", false, "Kubernetes, Knative, OpenShift", "The deployer trait is responsible for deploying the resources owned by the integration, and can be used to explicitly select the underlying controller that will manage the integration pods.", [ |
| ]), |
| new TraitMeta("deployment", false, "Kubernetes, Knative, OpenShift", "The Deployment trait is responsible for generating the Kubernetes deployment that will make sure the integration will run in the cluster.", [ |
| ]), |
| new TraitMeta("environment", false, "Kubernetes, Knative, OpenShift", "The environment trait is used internally to inject standard environment variables in the integration container, such as `NAMESPACE`, `POD_NAME` and others.", [ |
| ]), |
| new TraitMeta("error-handler", false, "Kubernetes, Knative, OpenShift", "The error-handler is a platform trait used to inject Error Handler source into the integration runtime.", [ |
| ]), |
| new TraitMeta("gc", false, "Kubernetes, Knative, OpenShift", "The GC Trait garbage-collects all resources that are no longer necessary upon integration updates.", [ |
| ]), |
| new TraitMeta("health", false, "Kubernetes, Knative, OpenShift", "The health trait is responsible for configuring the health probes on the integration container. It's disabled by default.", [ |
| ]), |
| new TraitMeta("ingress", false, "Kubernetes", "The Ingress trait can be used to expose the service associated with the integration to the outside world with a Kubernetes Ingress. It's enabled by default whenever a Service is added to the integration (through the `service` trait).", [ |
| ]), |
| new TraitMeta("istio", false, "Kubernetes, Knative, OpenShift", "The Istio trait allows configuring properties related to the Istio service mesh, such as sidecar injection and outbound IP ranges.", [ |
| ]), |
| new TraitMeta("jolokia", false, "Kubernetes, Knative, OpenShift", "The Jolokia trait activates and configures the Jolokia Java agent. See https://jolokia.org/reference/html/agents.html", [ |
| ]), |
| new TraitMeta("jvm", false, "Kubernetes, Knative, OpenShift", "The JVM trait is used to configure the JVM that runs the integration.", [ |
| ]), |
| new TraitMeta("kamelets", false, "Kubernetes, Knative, OpenShift", "The kamelets trait is a platform trait used to inject Kamelets into the integration runtime.", [ |
| ]), |
| new TraitMeta("keda", false, "Kubernetes, Knative, OpenShift", "The KEDA trait can be used for automatic integration with KEDA autoscalers. The trait can be either manually configured using the `triggers` option or automatically configured via markers in the Kamelets. For information on how to use KEDA enabled Kamelets with the KEDA trait, refer to xref:ROOT:kamelets/kamelets-user.adoc#kamelet-keda-user[the KEDA section in the Kamelets user guide]. If you want to create Kamelets that contain KEDA metadata, refer to xref:ROOT:kamelets/kamelets-dev.adoc#kamelet-keda-dev[the KEDA section in the Kamelets development guide]. The KEDA trait is disabled by default.", [ |
| ]), |
| new TraitMeta("knative-service", false, "Knative", "The Knative Service trait allows configuring options when running the Integration as a Knative service, instead of a standard Kubernetes Deployment. Running an Integration as a Knative Service enables auto-scaling (and scaling-to-zero), but those features are only relevant when the Camel route(s) use(s) an HTTP endpoint consumer.", [ |
| ]), |
| new TraitMeta("knative", false, "Knative", "The Knative trait automatically discovers addresses of Knative resources and inject them into the running integration. The full Knative configuration is injected in the CAMEL_KNATIVE_CONFIGURATION in JSON format. The Camel Knative component will then use the full configuration to configure the routes. The trait is enabled by default when the Knative profile is active.", [ |
| ]), |
| new TraitMeta("logging", false, "Kubernetes, Knative, OpenShift", "The Logging trait is used to configure Integration runtime logging options (such as color and format). The logging backend is provided by Quarkus, whose configuration is documented at https://quarkus.io/guides/logging.", [ |
| ]), |
| new TraitMeta("master", false, "Kubernetes, Knative, OpenShift", "The Master trait allows to configure the integration to automatically leverage Kubernetes resources for doing leader election and starting *master* routes only on certain instances. It's activated automatically when using the master endpoint in a route, e.g. `from(\"master:lockname:telegram:bots\")...`. NOTE: this trait adds special permissions to the integration service account in order to read/write configmaps and read pods. It's recommended to use a different service account than \"default\" when running the integration.", [ |
| ]), |
| new TraitMeta("mount", false, "Kubernetes, Knative, OpenShift", "The Mount trait can be used to configure volumes mounted on the Integration Pods.", [ |
| ]), |
| new TraitMeta("openapi", false, "Kubernetes, Knative, OpenShift", "The OpenAPI DSL trait is internally used to allow creating integrations from a OpenAPI specs.", [ |
| ]), |
| new TraitMeta("owner", false, "Kubernetes, Knative, OpenShift", "The Owner trait ensures that all created resources belong to the integration being created and transfers annotations and labels on the integration onto these owned resources.", [ |
| ]), |
| new TraitMeta("pdb", false, "Kubernetes, Knative, OpenShift", "The PDB trait allows to configure the PodDisruptionBudget resource for the Integration pods.", [ |
| ]), |
| new TraitMeta("platform", false, "Kubernetes, Knative, OpenShift", "The platform trait is a base trait that is used to assign an integration platform to an integration. In case the platform is missing, the trait is allowed to create a default platform. This feature is especially useful in contexts where there's no need to provide a custom configuration for the platform (e.g. on OpenShift the default settings work, since there's an embedded container image registry).", [ |
| ]), |
| new TraitMeta("pod", false, "Kubernetes, Knative, OpenShift", "The pod trait allows the customization of the Integration pods. It applies the `PodSpecTemplate` struct contained in the Integration `.spec.podTemplate` field, into the Integration deployment Pods template, using strategic merge patch. This can be used to customize the container where Camel routes execute, by using the `integration` container name.", [ |
| ]), |
| new TraitMeta("prometheus", false, "Kubernetes, Knative, OpenShift", "The Prometheus trait configures a Prometheus-compatible endpoint. It also creates a `PodMonitor` resource, so that the endpoint can be scraped automatically, when using the Prometheus operator. The metrics are exposed using MicroProfile Metrics. WARNING: The creation of the `PodMonitor` resource requires the https://github.com/coreos/prometheus-operator[Prometheus Operator] custom resource definition to be installed. You can set `pod-monitor` to `false` for the Prometheus trait to work without the Prometheus Operator. The Prometheus trait is disabled by default.", [ |
| ]), |
| new TraitMeta("pull-secret", false, "Kubernetes, Knative, OpenShift", "The Pull Secret trait sets a pull secret on the pod, to allow Kubernetes to retrieve the container image from an external registry. The pull secret can be specified manually or, in case you've configured authentication for an external container registry on the `IntegrationPlatform`, the same secret is used to pull images. It's enabled by default whenever you configure authentication for an external container registry, so it assumes that external registries are private. If your registry does not need authentication for pulling images, you can disable this trait.", [ |
| ]), |
| new TraitMeta("quarkus", false, "Kubernetes, Knative, OpenShift", "The Quarkus trait configures the Quarkus runtime. It's enabled by default. NOTE: Compiling to a native executable, i.e. when using `package-type=native`, is only supported for kamelets, as well as YAML and XML integrations. It also requires at least 4GiB of memory, so the Pod running the native build, that is either the operator Pod, or the build Pod (depending on the build strategy configured for the platform), must have enough memory available.", [ |
| ]), |
| new TraitMeta("route", false, "OpenShift", "The Route trait can be used to configure the creation of OpenShift routes for the integration. The certificate and key contents may be sourced either from the local filesystem or in a Openshift `secret` object. The user may use the parameters ending in `-secret` (example: `tls-certificate-secret`) to reference a certificate stored in a `secret`. Parameters ending in `-secret` have higher priorities and in case the same route parameter is set, for example: `tls-key-secret` and `tls-key`, then `tls-key-secret` is used. The recommended approach to set the key and certificates is to use `secrets` to store their contents and use the following parameters to reference them: `tls-certificate-secret`, `tls-key-secret`, `tls-ca-certificate-secret`, `tls-destination-ca-certificate-secret` See the examples section at the end of this page to see the setup options.", [ |
| ]), |
| new TraitMeta("service-binding", false, "Kubernetes, Knative, OpenShift", "The Service Binding trait allows users to connect to Services in Kubernetes: https://github.com/k8s-service-bindings/spec#service-binding As the specification is still evolving this is subject to change", [ |
| ]), |
| new TraitMeta("service", false, "Kubernetes, OpenShift", "The Service trait exposes the integration with a Service resource so that it can be accessed by other applications (or integrations) in the same namespace. It's enabled by default if the integration depends on a Camel component that can expose a HTTP endpoint.", [ |
| ]), |
| new TraitMeta("3scale", false, "Kubernetes, Knative, OpenShift", "The 3scale trait can be used to automatically create annotations that allow 3scale to discover the generated service and make it available for API management. The 3scale trait is disabled by default.", [ |
| ]), |
| new TraitMeta("toleration", false, "Kubernetes, Knative, OpenShift", "This trait sets Tolerations over Integration pods. Tolerations allow (but do not require) the pods to schedule onto nodes with matching taints. See https://kubernetes.io/docs/concepts/scheduling-eviction/taint-and-toleration/ for more details. The toleration should be expressed in a similar manner that of taints, i.e., `Key[=Value]:Effect[:Seconds]`, where values in square brackets are optional. For examples: - `node-role.kubernetes.io/master:NoSchedule` - `node.kubernetes.io/network-unavailable:NoExecute:3000` - `disktype=ssd:PreferNoSchedule` It's disabled by default.", [ |
| ]), |
| new TraitMeta("tracing", false, "Kubernetes, Knative, OpenShift", "The Tracing trait can be used to automatically publish tracing information to an OpenTracing compatible collector. The trait is able to automatically discover the tracing endpoint available in the namespace (supports **Jaeger**). The Tracing trait is disabled by default.", [ |
| ]), |
| ] |
| |
