@bluedynamics/cdk8s-plone 0.1.26 → 0.1.28

package/lib/vinylcache.d.ts

@@ -1,5 +1,67 @@
 import { Construct } from 'constructs';
 import { Plone } from './plone';
+/**
+ * Health probe configuration for a VinylCache backend.
+ */
+export interface VinylCacheBackendProbe {
+    /**
+     * URL to probe.
+     * @default '/'
+     */
+    readonly url?: string;
+    /**
+     * How often to probe the backend.
+     * @default '5s'
+     */
+    readonly interval?: string;
+    /**
+     * Maximum time to wait for a probe response.
+     * @default '2s'
+     */
+    readonly timeout?: string;
+    /**
+     * Number of most recent probes to consider.
+     * @default 10
+     */
+    readonly window?: number;
+    /**
+     * Minimum successful probes within window for healthy status.
+     * @default 8
+     */
+    readonly threshold?: number;
+    /**
+     * Expected HTTP response status code.
+     * @default 200
+     */
+    readonly expectedResponse?: number;
+}
+/**
+ * An additional backend for the VinylCache.
+ */
+export interface VinylCacheBackend {
+    /**
+     * VCL identifier for this backend. Must match ^[a-zA-Z][a-zA-Z0-9_]*$.
+     */
+    readonly name: string;
+    /**
+     * Kubernetes Service name to use as backend.
+     */
+    readonly serviceName: string;
+    /**
+     * Port to use for this backend.
+     */
+    readonly port: number;
+    /**
+     * Health probe configuration.
+     * @default - no probe
+     */
+    readonly probe?: VinylCacheBackendProbe;
+    /**
+     * Relative weight for the director. 0 means standby.
+     * @default - operator default
+     */
+    readonly weight?: number;
+}
 /**
  * A Kubernetes toleration for the Varnish pods.
  */
@@ -38,6 +100,12 @@ export interface PloneVinylCacheOptions {
      * Backends are auto-configured from the Plone services.
      */
     readonly plone: Plone;
+    /**
+     * Additional backends to add after the auto-generated Plone backends.
+     * Uses the same backend type structure as the VinylCache CRD.
+     * @default - no extra backends
+     */
+    readonly extraBackends?: VinylCacheBackend[];
     /**
      * Number of Varnish pod replicas.
      * @default 2
@@ -100,6 +168,74 @@ export interface PloneVinylCacheOptions {
      * @default - no tolerations
      */
     readonly tolerations?: VinylCacheToleration[];
+    /**
+     * Node selector labels for the Varnish pods.
+     * Constrains pods to nodes matching all specified labels.
+     * @default - no node selector
+     */
+    readonly nodeSelector?: {
+        [key: string]: string;
+    };
+    /**
+     * Custom VCL snippet for vcl_deliver subroutine.
+     * @default - no snippet
+     */
+    readonly vclDeliverSnippet?: string;
+    /**
+     * Custom VCL snippet for vcl_hit subroutine.
+     * @default - no snippet
+     */
+    readonly vclHitSnippet?: string;
+    /**
+     * Custom VCL snippet for vcl_miss subroutine.
+     * @default - no snippet
+     */
+    readonly vclMissSnippet?: string;
+    /**
+     * Custom VCL snippet for vcl_pass subroutine.
+     * @default - no snippet
+     */
+    readonly vclPassSnippet?: string;
+    /**
+     * Custom VCL snippet for vcl_pipe subroutine.
+     * @default - no snippet
+     */
+    readonly vclPipeSnippet?: string;
+    /**
+     * Custom VCL snippet for vcl_synth subroutine.
+     * @default - no snippet
+     */
+    readonly vclSynthSnippet?: string;
+    /**
+     * Custom VCL snippet for vcl_purge subroutine.
+     * @default - no snippet
+     */
+    readonly vclPurgeSnippet?: string;
+    /**
+     * Custom VCL snippet for vcl_hash subroutine.
+     * @default - no snippet
+     */
+    readonly vclHashSnippet?: string;
+    /**
+     * Custom VCL snippet for vcl_init subroutine.
+     * @default - no snippet
+     */
+    readonly vclInitSnippet?: string;
+    /**
+     * Custom VCL snippet for vcl_fini subroutine.
+     * @default - no snippet
+     */
+    readonly vclFiniSnippet?: string;
+    /**
+     * Custom VCL snippet for vcl_backend_fetch subroutine.
+     * @default - no snippet
+     */
+    readonly vclBackendFetchSnippet?: string;
+    /**
+     * Custom VCL snippet for vcl_backend_error subroutine.
+     * @default - no snippet
+     */
+    readonly vclBackendErrorSnippet?: string;
 }
 /**
  * PloneVinylCache construct for deploying Varnish Cache via cloud-vinyl operator.

package/lib/vinylcache.js

@@ -81,6 +81,22 @@ class PloneVinylCache extends constructs_1.Construct {
                 },
             });
         }
+        if (options.extraBackends) {
+            for (const eb of options.extraBackends) {
+                backends.push({
+                    name: eb.name,
+                    serviceRef: { name: eb.serviceName },
+                    port: eb.port,
+                    probe: eb.probe ? {
+                        url: eb.probe.url ?? '/',
+                        interval: eb.probe.interval ?? '5s',
+                        timeout: eb.probe.timeout ?? '2s',
+                        window: eb.probe.window ?? 10,
+                        threshold: eb.probe.threshold ?? 8,
+                    } : undefined,
+                });
+            }
+        }
         const vinylCache = new vinyl_bluedynamics_eu_1.VinylCache(this, 'vinylcache', {
             spec: {
                 replicas,
@@ -91,6 +107,18 @@ class PloneVinylCache extends constructs_1.Construct {
                     snippets: {
                         vclRecv: vclRecv,
                         vclBackendResponse: vclBackendResponse,
+                        vclDeliver: options.vclDeliverSnippet,
+                        vclHit: options.vclHitSnippet,
+                        vclMiss: options.vclMissSnippet,
+                        vclPass: options.vclPassSnippet,
+                        vclPipe: options.vclPipeSnippet,
+                        vclSynth: options.vclSynthSnippet,
+                        vclPurge: options.vclPurgeSnippet,
+                        vclHash: options.vclHashSnippet,
+                        vclInit: options.vclInitSnippet,
+                        vclFini: options.vclFiniSnippet,
+                        vclBackendFetch: options.vclBackendFetchSnippet,
+                        vclBackendError: options.vclBackendErrorSnippet,
                     },
                 },
                 resources: {
@@ -112,13 +140,14 @@ class PloneVinylCache extends constructs_1.Construct {
                     enabled: true,
                     serviceMonitor: { enabled: true },
                 } : undefined,
-                pod: (options.tolerations && options.tolerations.length > 0) ? {
-                    tolerations: options.tolerations.map(t => ({
+                pod: (options.tolerations?.length || options.nodeSelector) ? {
+                    tolerations: options.tolerations?.map(t => ({
                         key: t.key,
                         operator: t.operator,
                         value: t.value,
                         effect: t.effect,
                     })),
+                    nodeSelector: options.nodeSelector,
                 } : undefined,
             },
         });
@@ -128,5 +157,5 @@ class PloneVinylCache extends constructs_1.Construct {
 }
 exports.PloneVinylCache = PloneVinylCache;
 _a = JSII_RTTI_SYMBOL_1;
-PloneVinylCache[_a] = { fqn: "@bluedynamics/cdk8s-plone.PloneVinylCache", version: "0.1.26" };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vinylcache.js","sourceRoot":"","sources":["../src/vinylcache.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport { Names } from 'cdk8s';\nimport { Construct } from 'constructs';\nimport {\n  VinylCache,\n  VinylCacheSpecDirectorType,\n  VinylCacheSpecResourcesLimits,\n  VinylCacheSpecResourcesRequests,\n} from './imports/vinyl.bluedynamics.eu';\nimport { Plone } from './plone';\n\n/**\n * A Kubernetes toleration for the Varnish pods.\n */\nexport interface VinylCacheToleration {\n  /**\n   * The taint key to tolerate.\n   */\n  readonly key: string;\n\n  /**\n   * The operator (Equal or Exists).\n   * @default 'Equal'\n   */\n  readonly operator?: string;\n\n  /**\n   * The taint value to match (when operator is Equal).\n   * @default - no value\n   */\n  readonly value?: string;\n\n  /**\n   * The taint effect to tolerate (NoSchedule, PreferNoSchedule, NoExecute).\n   * @default - tolerate all effects\n   */\n  readonly effect?: string;\n}\n\n/**\n * Configuration options for PloneVinylCache (cloud-vinyl operator).\n *\n * Creates a VinylCache custom resource that the cloud-vinyl operator\n * reconciles into a Varnish Cache cluster with agent-based VCL delivery.\n *\n * Requires the cloud-vinyl operator to be installed in the cluster.\n */\nexport interface PloneVinylCacheOptions {\n  /**\n   * The Plone construct to attach the cache to.\n   * Backends are auto-configured from the Plone services.\n   */\n  readonly plone: Plone;\n\n  /**\n   * Number of Varnish pod replicas.\n   * @default 2\n   */\n  readonly replicas?: number;\n\n  /**\n   * CPU request for Varnish pods.\n   * @default '100m'\n   */\n  readonly requestCpu?: string;\n\n  /**\n   * Memory request for Varnish pods.\n   * @default '256Mi'\n   */\n  readonly requestMemory?: string;\n\n  /**\n   * CPU limit for Varnish pods.\n   * @default '500m'\n   */\n  readonly limitCpu?: string;\n\n  /**\n   * Memory limit for Varnish pods.\n   * @default '512Mi'\n   */\n  readonly limitMemory?: string;\n\n  /**\n   * Director type for load distribution.\n   * @default 'shard'\n   */\n  readonly director?: string;\n\n  /**\n   * Custom VCL snippet for vcl_recv subroutine.\n   * Replaces the default Plone recv snippet.\n   * @default - uses built-in plone-vinyl-recv.vcl\n   */\n  readonly vclRecvSnippet?: string;\n\n  /**\n   * Custom VCL snippet for vcl_backend_response subroutine.\n   * Replaces the default Plone backend_response snippet.\n   * @default - uses built-in plone-vinyl-backend-response.vcl\n   */\n  readonly vclBackendResponseSnippet?: string;\n\n  /**\n   * Enable cache invalidation (PURGE, BAN, xkey).\n   * @default true\n   */\n  readonly invalidation?: boolean;\n\n  /**\n   * Enable Prometheus monitoring (metrics + ServiceMonitor).\n   * @default false\n   */\n  readonly monitoring?: boolean;\n\n  /**\n   * Container image for the Varnish pods.\n   * @default 'varnish:7.6'\n   */\n  readonly image?: string;\n\n  /**\n   * Tolerations for the Varnish pods.\n   * @default - no tolerations\n   */\n  readonly tolerations?: VinylCacheToleration[];\n}\n\n/**\n * PloneVinylCache construct for deploying Varnish Cache via cloud-vinyl operator.\n *\n * Creates a VinylCache custom resource with Plone backend/frontend services\n * auto-configured as backends. The cloud-vinyl operator manages the full\n * Varnish lifecycle including VCL generation, agent delivery, and monitoring.\n *\n * Requires the cloud-vinyl operator to be installed in the cluster.\n *\n * @example\n * const plone = new Plone(chart, 'plone');\n * const cache = new PloneVinylCache(chart, 'cache', {\n *   plone: plone,\n *   replicas: 2,\n * });\n * // Use cache.vinylCacheServiceName for IngressRoute\n */\nexport class PloneVinylCache extends Construct {\n  /**\n   * Name of the VinylCache service created by the operator.\n   * Use this to reference the cache service from ingress or other constructs.\n   */\n  public readonly vinylCacheServiceName: string;\n\n  constructor(scope: Construct, id: string, options: PloneVinylCacheOptions) {\n    super(scope, id);\n\n    const replicas = options.replicas ?? 2;\n    const invalidation = options.invalidation ?? true;\n    const monitoring = options.monitoring ?? false;\n\n    // Resolve director type enum\n    const directorStr = options.director ?? 'shard';\n    let directorType: VinylCacheSpecDirectorType;\n    switch (directorStr) {\n      case 'round_robin':\n        directorType = VinylCacheSpecDirectorType.ROUND_UNDERSCORE_ROBIN;\n        break;\n      case 'random':\n        directorType = VinylCacheSpecDirectorType.RANDOM;\n        break;\n      case 'hash':\n        directorType = VinylCacheSpecDirectorType.HASH;\n        break;\n      default:\n        directorType = VinylCacheSpecDirectorType.SHARD;\n    }\n\n    // Load default VCL snippets\n    const vclRecv = options.vclRecvSnippet ??\n      fs.readFileSync(path.join(__dirname, 'config', 'plone-vinyl-recv.vcl'), 'utf8');\n    const vclBackendResponse = options.vclBackendResponseSnippet ??\n      fs.readFileSync(path.join(__dirname, 'config', 'plone-vinyl-backend-response.vcl'), 'utf8');\n\n    // Build backends from Plone services\n    const backends = [\n      {\n        name: 'plone_backend',\n        serviceRef: { name: options.plone.backendServiceName },\n        port: 8080,\n        probe: {\n          url: '/ok',\n          interval: '5s',\n          timeout: '2s',\n          window: 10,\n          threshold: 8,\n        },\n      },\n    ];\n\n    if (options.plone.frontendServiceName) {\n      backends.push({\n        name: 'plone_frontend',\n        serviceRef: { name: options.plone.frontendServiceName },\n        port: 3000,\n        probe: {\n          url: '/',\n          interval: '5s',\n          timeout: '2s',\n          window: 10,\n          threshold: 8,\n        },\n      });\n    }\n\n    const vinylCache = new VinylCache(this, 'vinylcache', {\n      spec: {\n        replicas,\n        image: options.image ?? 'varnish:7.6',\n        backends,\n        director: { type: directorType },\n        vcl: {\n          snippets: {\n            vclRecv: vclRecv,\n            vclBackendResponse: vclBackendResponse,\n          },\n        },\n        resources: {\n          requests: {\n            cpu: VinylCacheSpecResourcesRequests.fromString(options.requestCpu ?? '100m'),\n            memory: VinylCacheSpecResourcesRequests.fromString(options.requestMemory ?? '256Mi'),\n          },\n          limits: {\n            cpu: VinylCacheSpecResourcesLimits.fromString(options.limitCpu ?? '500m'),\n            memory: VinylCacheSpecResourcesLimits.fromString(options.limitMemory ?? '512Mi'),\n          },\n        },\n        invalidation: invalidation ? {\n          purge: { enabled: true },\n          ban: { enabled: true },\n          xkey: { enabled: true },\n        } : undefined,\n        monitoring: monitoring ? {\n          enabled: true,\n          serviceMonitor: { enabled: true },\n        } : undefined,\n        pod: (options.tolerations && options.tolerations.length > 0) ? {\n          tolerations: options.tolerations.map(t => ({\n            key: t.key,\n            operator: t.operator,\n            value: t.value,\n            effect: t.effect,\n          })),\n        } : undefined,\n      },\n    });\n\n    // The operator creates a service with the same name as the VinylCache resource\n    this.vinylCacheServiceName = Names.toLabelValue(vinylCache);\n  }\n}\n"]}
+PloneVinylCache[_a] = { fqn: "@bluedynamics/cdk8s-plone.PloneVinylCache", version: "0.1.28" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vinylcache.js","sourceRoot":"","sources":["../src/vinylcache.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport { Names } from 'cdk8s';\nimport { Construct } from 'constructs';\nimport {\n  VinylCache,\n  VinylCacheSpecDirectorType,\n  VinylCacheSpecResourcesLimits,\n  VinylCacheSpecResourcesRequests,\n} from './imports/vinyl.bluedynamics.eu';\nimport { Plone } from './plone';\n\n/**\n * Health probe configuration for a VinylCache backend.\n */\nexport interface VinylCacheBackendProbe {\n  /**\n   * URL to probe.\n   * @default '/'\n   */\n  readonly url?: string;\n\n  /**\n   * How often to probe the backend.\n   * @default '5s'\n   */\n  readonly interval?: string;\n\n  /**\n   * Maximum time to wait for a probe response.\n   * @default '2s'\n   */\n  readonly timeout?: string;\n\n  /**\n   * Number of most recent probes to consider.\n   * @default 10\n   */\n  readonly window?: number;\n\n  /**\n   * Minimum successful probes within window for healthy status.\n   * @default 8\n   */\n  readonly threshold?: number;\n\n  /**\n   * Expected HTTP response status code.\n   * @default 200\n   */\n  readonly expectedResponse?: number;\n}\n\n/**\n * An additional backend for the VinylCache.\n */\nexport interface VinylCacheBackend {\n  /**\n   * VCL identifier for this backend. Must match ^[a-zA-Z][a-zA-Z0-9_]*$.\n   */\n  readonly name: string;\n\n  /**\n   * Kubernetes Service name to use as backend.\n   */\n  readonly serviceName: string;\n\n  /**\n   * Port to use for this backend.\n   */\n  readonly port: number;\n\n  /**\n   * Health probe configuration.\n   * @default - no probe\n   */\n  readonly probe?: VinylCacheBackendProbe;\n\n  /**\n   * Relative weight for the director. 0 means standby.\n   * @default - operator default\n   */\n  readonly weight?: number;\n}\n\n/**\n * A Kubernetes toleration for the Varnish pods.\n */\nexport interface VinylCacheToleration {\n  /**\n   * The taint key to tolerate.\n   */\n  readonly key: string;\n\n  /**\n   * The operator (Equal or Exists).\n   * @default 'Equal'\n   */\n  readonly operator?: string;\n\n  /**\n   * The taint value to match (when operator is Equal).\n   * @default - no value\n   */\n  readonly value?: string;\n\n  /**\n   * The taint effect to tolerate (NoSchedule, PreferNoSchedule, NoExecute).\n   * @default - tolerate all effects\n   */\n  readonly effect?: string;\n}\n\n/**\n * Configuration options for PloneVinylCache (cloud-vinyl operator).\n *\n * Creates a VinylCache custom resource that the cloud-vinyl operator\n * reconciles into a Varnish Cache cluster with agent-based VCL delivery.\n *\n * Requires the cloud-vinyl operator to be installed in the cluster.\n */\nexport interface PloneVinylCacheOptions {\n  /**\n   * The Plone construct to attach the cache to.\n   * Backends are auto-configured from the Plone services.\n   */\n  readonly plone: Plone;\n\n  /**\n   * Additional backends to add after the auto-generated Plone backends.\n   * Uses the same backend type structure as the VinylCache CRD.\n   * @default - no extra backends\n   */\n  readonly extraBackends?: VinylCacheBackend[];\n\n  /**\n   * Number of Varnish pod replicas.\n   * @default 2\n   */\n  readonly replicas?: number;\n\n  /**\n   * CPU request for Varnish pods.\n   * @default '100m'\n   */\n  readonly requestCpu?: string;\n\n  /**\n   * Memory request for Varnish pods.\n   * @default '256Mi'\n   */\n  readonly requestMemory?: string;\n\n  /**\n   * CPU limit for Varnish pods.\n   * @default '500m'\n   */\n  readonly limitCpu?: string;\n\n  /**\n   * Memory limit for Varnish pods.\n   * @default '512Mi'\n   */\n  readonly limitMemory?: string;\n\n  /**\n   * Director type for load distribution.\n   * @default 'shard'\n   */\n  readonly director?: string;\n\n  /**\n   * Custom VCL snippet for vcl_recv subroutine.\n   * Replaces the default Plone recv snippet.\n   * @default - uses built-in plone-vinyl-recv.vcl\n   */\n  readonly vclRecvSnippet?: string;\n\n  /**\n   * Custom VCL snippet for vcl_backend_response subroutine.\n   * Replaces the default Plone backend_response snippet.\n   * @default - uses built-in plone-vinyl-backend-response.vcl\n   */\n  readonly vclBackendResponseSnippet?: string;\n\n  /**\n   * Enable cache invalidation (PURGE, BAN, xkey).\n   * @default true\n   */\n  readonly invalidation?: boolean;\n\n  /**\n   * Enable Prometheus monitoring (metrics + ServiceMonitor).\n   * @default false\n   */\n  readonly monitoring?: boolean;\n\n  /**\n   * Container image for the Varnish pods.\n   * @default 'varnish:7.6'\n   */\n  readonly image?: string;\n\n  /**\n   * Tolerations for the Varnish pods.\n   * @default - no tolerations\n   */\n  readonly tolerations?: VinylCacheToleration[];\n\n  /**\n   * Node selector labels for the Varnish pods.\n   * Constrains pods to nodes matching all specified labels.\n   * @default - no node selector\n   */\n  readonly nodeSelector?: { [key: string]: string };\n\n  /**\n   * Custom VCL snippet for vcl_deliver subroutine.\n   * @default - no snippet\n   */\n  readonly vclDeliverSnippet?: string;\n\n  /**\n   * Custom VCL snippet for vcl_hit subroutine.\n   * @default - no snippet\n   */\n  readonly vclHitSnippet?: string;\n\n  /**\n   * Custom VCL snippet for vcl_miss subroutine.\n   * @default - no snippet\n   */\n  readonly vclMissSnippet?: string;\n\n  /**\n   * Custom VCL snippet for vcl_pass subroutine.\n   * @default - no snippet\n   */\n  readonly vclPassSnippet?: string;\n\n  /**\n   * Custom VCL snippet for vcl_pipe subroutine.\n   * @default - no snippet\n   */\n  readonly vclPipeSnippet?: string;\n\n  /**\n   * Custom VCL snippet for vcl_synth subroutine.\n   * @default - no snippet\n   */\n  readonly vclSynthSnippet?: string;\n\n  /**\n   * Custom VCL snippet for vcl_purge subroutine.\n   * @default - no snippet\n   */\n  readonly vclPurgeSnippet?: string;\n\n  /**\n   * Custom VCL snippet for vcl_hash subroutine.\n   * @default - no snippet\n   */\n  readonly vclHashSnippet?: string;\n\n  /**\n   * Custom VCL snippet for vcl_init subroutine.\n   * @default - no snippet\n   */\n  readonly vclInitSnippet?: string;\n\n  /**\n   * Custom VCL snippet for vcl_fini subroutine.\n   * @default - no snippet\n   */\n  readonly vclFiniSnippet?: string;\n\n  /**\n   * Custom VCL snippet for vcl_backend_fetch subroutine.\n   * @default - no snippet\n   */\n  readonly vclBackendFetchSnippet?: string;\n\n  /**\n   * Custom VCL snippet for vcl_backend_error subroutine.\n   * @default - no snippet\n   */\n  readonly vclBackendErrorSnippet?: string;\n}\n\n/**\n * PloneVinylCache construct for deploying Varnish Cache via cloud-vinyl operator.\n *\n * Creates a VinylCache custom resource with Plone backend/frontend services\n * auto-configured as backends. The cloud-vinyl operator manages the full\n * Varnish lifecycle including VCL generation, agent delivery, and monitoring.\n *\n * Requires the cloud-vinyl operator to be installed in the cluster.\n *\n * @example\n * const plone = new Plone(chart, 'plone');\n * const cache = new PloneVinylCache(chart, 'cache', {\n *   plone: plone,\n *   replicas: 2,\n * });\n * // Use cache.vinylCacheServiceName for IngressRoute\n */\nexport class PloneVinylCache extends Construct {\n  /**\n   * Name of the VinylCache service created by the operator.\n   * Use this to reference the cache service from ingress or other constructs.\n   */\n  public readonly vinylCacheServiceName: string;\n\n  constructor(scope: Construct, id: string, options: PloneVinylCacheOptions) {\n    super(scope, id);\n\n    const replicas = options.replicas ?? 2;\n    const invalidation = options.invalidation ?? true;\n    const monitoring = options.monitoring ?? false;\n\n    // Resolve director type enum\n    const directorStr = options.director ?? 'shard';\n    let directorType: VinylCacheSpecDirectorType;\n    switch (directorStr) {\n      case 'round_robin':\n        directorType = VinylCacheSpecDirectorType.ROUND_UNDERSCORE_ROBIN;\n        break;\n      case 'random':\n        directorType = VinylCacheSpecDirectorType.RANDOM;\n        break;\n      case 'hash':\n        directorType = VinylCacheSpecDirectorType.HASH;\n        break;\n      default:\n        directorType = VinylCacheSpecDirectorType.SHARD;\n    }\n\n    // Load default VCL snippets\n    const vclRecv = options.vclRecvSnippet ??\n      fs.readFileSync(path.join(__dirname, 'config', 'plone-vinyl-recv.vcl'), 'utf8');\n    const vclBackendResponse = options.vclBackendResponseSnippet ??\n      fs.readFileSync(path.join(__dirname, 'config', 'plone-vinyl-backend-response.vcl'), 'utf8');\n\n    // Build backends from Plone services\n    const backends: Array<{\n      name: string;\n      serviceRef: { name: string };\n      port: number;\n      probe?: {\n        url: string;\n        interval: string;\n        timeout: string;\n        window: number;\n        threshold: number;\n      };\n      weight?: number;\n    }> = [\n      {\n        name: 'plone_backend',\n        serviceRef: { name: options.plone.backendServiceName },\n        port: 8080,\n        probe: {\n          url: '/ok',\n          interval: '5s',\n          timeout: '2s',\n          window: 10,\n          threshold: 8,\n        },\n      },\n    ];\n\n    if (options.plone.frontendServiceName) {\n      backends.push({\n        name: 'plone_frontend',\n        serviceRef: { name: options.plone.frontendServiceName },\n        port: 3000,\n        probe: {\n          url: '/',\n          interval: '5s',\n          timeout: '2s',\n          window: 10,\n          threshold: 8,\n        },\n      });\n    }\n\n    if (options.extraBackends) {\n      for (const eb of options.extraBackends) {\n        backends.push({\n          name: eb.name,\n          serviceRef: { name: eb.serviceName },\n          port: eb.port,\n          probe: eb.probe ? {\n            url: eb.probe.url ?? '/',\n            interval: eb.probe.interval ?? '5s',\n            timeout: eb.probe.timeout ?? '2s',\n            window: eb.probe.window ?? 10,\n            threshold: eb.probe.threshold ?? 8,\n          } : undefined,\n        });\n      }\n    }\n\n    const vinylCache = new VinylCache(this, 'vinylcache', {\n      spec: {\n        replicas,\n        image: options.image ?? 'varnish:7.6',\n        backends,\n        director: { type: directorType },\n        vcl: {\n          snippets: {\n            vclRecv: vclRecv,\n            vclBackendResponse: vclBackendResponse,\n            vclDeliver: options.vclDeliverSnippet,\n            vclHit: options.vclHitSnippet,\n            vclMiss: options.vclMissSnippet,\n            vclPass: options.vclPassSnippet,\n            vclPipe: options.vclPipeSnippet,\n            vclSynth: options.vclSynthSnippet,\n            vclPurge: options.vclPurgeSnippet,\n            vclHash: options.vclHashSnippet,\n            vclInit: options.vclInitSnippet,\n            vclFini: options.vclFiniSnippet,\n            vclBackendFetch: options.vclBackendFetchSnippet,\n            vclBackendError: options.vclBackendErrorSnippet,\n          },\n        },\n        resources: {\n          requests: {\n            cpu: VinylCacheSpecResourcesRequests.fromString(options.requestCpu ?? '100m'),\n            memory: VinylCacheSpecResourcesRequests.fromString(options.requestMemory ?? '256Mi'),\n          },\n          limits: {\n            cpu: VinylCacheSpecResourcesLimits.fromString(options.limitCpu ?? '500m'),\n            memory: VinylCacheSpecResourcesLimits.fromString(options.limitMemory ?? '512Mi'),\n          },\n        },\n        invalidation: invalidation ? {\n          purge: { enabled: true },\n          ban: { enabled: true },\n          xkey: { enabled: true },\n        } : undefined,\n        monitoring: monitoring ? {\n          enabled: true,\n          serviceMonitor: { enabled: true },\n        } : undefined,\n        pod: (options.tolerations?.length || options.nodeSelector) ? {\n          tolerations: options.tolerations?.map(t => ({\n            key: t.key,\n            operator: t.operator,\n            value: t.value,\n            effect: t.effect,\n          })),\n          nodeSelector: options.nodeSelector,\n        } : undefined,\n      },\n    });\n\n    // The operator creates a service with the same name as the VinylCache resource\n    this.vinylCacheServiceName = Names.toLabelValue(vinylCache);\n  }\n}\n"]}

package/package.json

@@ -77,7 +77,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.26",
+  "version": "0.1.28",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [