kube_cluster 1.4.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 161e8e4b158fcb49cbab16469213bb0a49fab8ff7d1669a1c974fa79b60e4d77
-  data.tar.gz: 87da0f1d7a75f18803146f1dc23bbe23bf5c188a3106751ef1ff95edfe38c9a5
+  metadata.gz: c8a1a110a7fc51055c3b0b6c7bed9c90ef99a7f5d3270aada0f9b89b7fba5eb0
+  data.tar.gz: 07a7eb71bc8a0d9e9197fb24a76729764de4e237c68110fc1a486d0df38eec74
 SHA512:
-  metadata.gz: d41568ed4346c1429eda172bb4021c38e72a1e4cb7994c8060991df077b6fb7eebc4a9f9c58689cf0839c97ad682d546aff7ab9360c57f8c14845d8626b07252
-  data.tar.gz: 85f8c1da91dcacfedf71b19736edef620113d71d211c51aa0f303cef72d63d2110cd8a4d9adab7f2fc2ee99f2fbec55837141c49f904587fbbd07d90e101325c
+  metadata.gz: 8bc59ca6435b4f4b9096bb7925605211289ee6a337015fc3eba64d747d673adce333a391585b5235c961f5a681f23474588d8391d88c12e51af5c5d5026fed06
+  data.tar.gz: 73c07cf7c0c85c0f998dc2b406da0d385502d24e414194eeb5f2e2dfbecbef3bedcef8401678e73a0b53665bc1d62465a6cd9ef77b962e07c761ecdca09b8620

data/CHANGELOG.md

@@ -5,6 +5,25 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.6.0] - 2026-08-03
+
+### Added
+- `Standard::JuiceFS::Sync` — a wrapper for the juicefs-operator's `Sync` CRD
+  (pinned to `juicefs.io/v1`). `from`/`to` are the CRD's sink hashes, passed
+  through as-is. Documents two operator behaviours worth knowing before use: the
+  unquoted metadata-URL export that breaks `juicefsCE` sinks whose metaurl
+  contains `&`, and the `ttlSecondsAfterFinished` deletion that makes a
+  reconciler-managed Sync re-run forever.
+- `Standard::JuiceFS::PersistentVolume` — a statically-provisioned JuiceFS PV,
+  the only way to give a volume an exact, readable directory name (`subPath`)
+  rather than the `pvc-<uuid>` a StorageClass would assign.
+- `PersistentVolume` pinned to `v1/PersistentVolume` in the resolve table.
+
+### Changed
+- Requires kube_schema `~> 1.10.0`, which ships the `juicefs.io/v1` schemas.
+  These wrappers previously needed a local CRD-registration shim that downloaded
+  `dist/crd.yaml` at load time; that is no longer necessary.
+
 ## [1.4.0] - 2026-07-13
 
 ### Added

data/Gemfile.lock

@@ -1,10 +1,10 @@
 PATH
   remote: .
   specs:
-    kube_cluster (1.4.0)
+    kube_cluster (1.6.0)
       activesupport (~> 8.0)
       kube_kubectl (~> 2.0)
-      kube_schema (~> 1.9.2)
+      kube_schema (~> 1.10.0)
 
 GEM
   remote: https://rubygems.org/
@@ -132,7 +132,7 @@ GEM
       rubyshell (~> 1.5)
       shellwords (~> 0.2.2)
       string_builder (~> 1.2.2)
-    kube_schema (1.9.2)
+    kube_schema (1.10.0)
       json_schemer (~> 2.5.0)
       rubyshell (~> 1.5.0)
     lefthook (2.1.10)

data/kube_cluster.gemspec

@@ -32,7 +32,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "scampi", "~> 1.0"
   spec.add_development_dependency "lefthook", "~> 2.1"
 
-  spec.add_dependency "kube_schema", "~> 1.9.2"
+  spec.add_dependency "kube_schema", "~> 1.10.0"
   spec.add_dependency "kube_kubectl", "~> 2.0"
   spec.add_dependency "activesupport", "~> 8.0"
 end

data/lib/kube/cluster/standard/juice_fs/persistent_volume.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+#
+# A statically-provisioned JuiceFS PersistentVolume.
+#
+# Dynamic provisioning (a `juicefs-sc` StorageClass) names each volume's
+# directory `pvc-<uuid>` at the root of the filesystem. Static provisioning lets
+# the directory be named explicitly via the `subPath` volume attribute — the
+# only way to get an exact, readable folder name.
+#
+# `secret`/`secret_namespace` point at the JuiceFS "volume credentials" Secret
+# (name / metaurl / storage / bucket / keys / encrypt_rsa_key). PersistentVolume
+# is cluster-scoped and nodePublishSecretRef carries its own namespace, so the
+# PV, its PVC, and that Secret may all live in different namespaces. The mount
+# pod always runs in the CSI driver's namespace regardless.
+#
+# `storage` is a label only — JuiceFS enforces no quota through this field.
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module JuiceFS
+        class PersistentVolume < Kube::Cluster["PersistentVolume"]
+          def initialize(name:, storage:, sub_path:, secret:, secret_namespace:,
+                         access_modes: ["ReadWriteMany"], reclaim_policy: "Retain", &block)
+            super() {
+              metadata.name = name
+
+              spec.capacity                      = { storage: storage }
+              spec.accessModes                   = access_modes
+              spec.persistentVolumeReclaimPolicy = reclaim_policy
+              # Empty (not absent) so no StorageClass can claim this PV and the
+              # matching PVC binds by volumeName alone.
+              spec.storageClassName              = ""
+              spec.csi = {
+                driver:               "csi.juicefs.com",
+                volumeHandle:         name,
+                fsType:               "juicefs",
+                nodePublishSecretRef: { name: secret, namespace: secret_namespace },
+                volumeAttributes:     { subPath: sub_path },
+              }
+
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "JuiceFS::PersistentVolume" do
+  pv = Kube::Cluster::Standard::JuiceFS::PersistentVolume
+
+  volume = pv.new(
+    name:             "media",
+    storage:          "1Ti",
+    sub_path:         "media",
+    secret:           "juicefs-secret",
+    secret_namespace: "kube-system",
+  )
+
+  it "mounts the named subPath through the JuiceFS CSI driver" do
+    yaml = volume.to_yaml
+
+    yaml.include?("driver: csi.juicefs.com").should == true
+    yaml.include?("subPath: media").should       == true
+  end
+
+  it "defaults to a retained, ReadWriteMany volume with no StorageClass" do
+    yaml = volume.to_yaml
+
+    yaml.include?("persistentVolumeReclaimPolicy: Retain").should == true
+    yaml.include?("ReadWriteMany").should                        == true
+    yaml.include?("storageClassName: ''").should                 == true
+  end
+end

data/lib/kube/cluster/standard/juice_fs/sync.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+#
+# juicefs.io/v1 Sync — a one-shot `juicefs sync` job run by the juicefs-operator
+# (https://juicefs.com/docs/csi/guide/juicefs-operator/).
+#
+# The operator builds a manager pod (plus `replicas - 1` worker pods) from
+# `image`, parses each sink into a URI, and runs
+# `juicefs sync [--<options>] <from> <to>`.
+#
+# `from`/`to` are the CRD's sink hashes and are passed through as-is — they are
+# the meaningful configuration, so wrapping them in a mini-DSL would only hide
+# the CRD. Exactly one of these keys per sink:
+#
+#   external:  { uri:, accessKey:, secretKey:, extraVolumes: }  any object store,
+#              a `file://` path, or a mounted PVC/hostPath
+#   juicefs:   { volumeName:, token:, ... }                     enterprise edition
+#   juicefsCE: { metaURL:, metaPassWord:, path: }               community edition
+#
+# NOTE ON juicefsCE: the operator emits its metadata-URL export UNQUOTED
+# (pkg/utils/sync.go, `export %s=%s`). A metaurl containing a literal `&` (e.g.
+# `?sslmode=require&search_path=juicefs`) is split by the pod's `sh -c`
+# entrypoint — the export runs in a background subshell and the variable is
+# empty in the shell that runs the sync. Use an `external` sink with a `pvc`
+# extraVolume instead, and let the CSI mount pod do the JuiceFS work.
+#
+# NOTE ON ttlSecondsAfterFinished: DO NOT SET IT when the Sync is managed by a
+# reconciler such as Flux or Argo CD. The controller DELETES the Sync object
+# when the TTL expires (internal/controller/sync_controller.go); the reconciler
+# then sees drift, recreates it, and the sync runs again — forever. Without a
+# TTL the object simply stays `Completed`. To re-run, delete the object by hand
+# or switch to a CronSync.
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module JuiceFS
+        class Sync < Kube::Cluster["juicefs.io/v1/Sync"]
+          def initialize(name:, image:, from:, to:, replicas: 1, options: [], &block)
+            super() {
+              metadata.name = name
+              spec.image    = image
+              spec.replicas = replicas
+              spec.options  = options if options.any?
+              spec.from     = from
+              spec.to       = to
+
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "JuiceFS::Sync" do
+  sync = Kube::Cluster::Standard::JuiceFS::Sync
+
+  it "emits the juicefs.io/v1 apiVersion" do
+    sync
+      .new(
+        name:  "media-backup",
+        image: "juicedata/mount:latest",
+        from:  { external: { uri: "file:///mnt/media/" } },
+        to:    { external: { uri: "s3://backup.example.com/media/" } },
+      )
+      .to_yaml
+      .include?("apiVersion: juicefs.io/v1")
+      .should == true
+  end
+
+  it "omits options when none are given" do
+    sync
+      .new(
+        name:  "plain",
+        image: "juicedata/mount:latest",
+        from:  { external: { uri: "file:///a/" } },
+        to:    { external: { uri: "file:///b/" } },
+      )
+      .to_yaml
+      .include?("options:")
+      .should == false
+  end
+
+  it "carries options and replicas through" do
+    yaml = sync.new(
+      name:     "parallel",
+      image:    "juicedata/mount:latest",
+      from:     { external: { uri: "file:///a/" } },
+      to:       { external: { uri: "file:///b/" } },
+      replicas: 3,
+      options:  ["--update"],
+    ).to_yaml
+
+    yaml.include?("replicas: 3").should == true
+    yaml.include?("--update").should  == true
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vl_cluster.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # HA/clustered VictoriaLogs: vlstorage + vlselect + vlinsert components
+        # (the horizontally-scalable alternative to VLSingle). Retention lives on
+        # the vlstorage component, so configure the components in the block.
+        class VLCluster < Kube::Cluster["VLCluster"]
+          def initialize(name:, &block)
+            super() {
+              metadata.name = name
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VLCluster" do
+  it "initializes without error" do
+    Kube::Cluster::Standard::VictoriaMetrics::VLCluster
+      .new(name: "vlcluster")
+      .to_yaml
+      .is_a?(String)
+      .should == true
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vlogs.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # Legacy VictoriaLogs kind (operator.victoriametrics.com/v1beta1). New
+        # deployments should prefer VLSingle (v1); this wrapper exists for
+        # completeness / migrating existing objects. Spec is configured in block.
+        class VLogs < Kube::Cluster["VLogs"]
+          def initialize(name:, &block)
+            super() {
+              metadata.name = name
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VLogs" do
+  it "initializes without error" do
+    Kube::Cluster::Standard::VictoriaMetrics::VLogs
+      .new(name: "vlogs")
+      .to_yaml
+      .is_a?(String)
+      .should == true
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vm_alertmanager.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # Managed Alertmanager instance. Notification routing/receivers can be
+        # supplied inline via spec.configRawYaml or selected from
+        # VMAlertmanagerConfig objects; configure that in the block.
+        class VMAlertmanager < Kube::Cluster["VMAlertmanager"]
+          def initialize(name:, replica_count: 1, &block)
+            super() {
+              metadata.name     = name
+              spec.replicaCount = replica_count
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VMAlertmanager" do
+  it "initializes without error" do
+    Kube::Cluster::Standard::VictoriaMetrics::VMAlertmanager
+      .new(name: "vmalertmanager")
+      .to_yaml
+      .is_a?(String)
+      .should == true
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vm_alertmanager_config.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # Alertmanager routing tree and receivers, selected by a VMAlertmanager.
+        # Define spec.route and spec.receivers in the block.
+        class VMAlertmanagerConfig < Kube::Cluster["VMAlertmanagerConfig"]
+          def initialize(name:, &block)
+            super() {
+              metadata.name = name
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VMAlertmanagerConfig" do
+  it "initializes without error" do
+    Kube::Cluster::Standard::VictoriaMetrics::VMAlertmanagerConfig
+      .new(name: "vmalertmanagerconfig")
+      .to_yaml
+      .is_a?(String)
+      .should == true
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vm_anomaly.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # VictoriaMetrics Anomaly Detection service (vmanomaly). Reads metrics,
+        # fits models, and writes anomaly scores back. Provide the model/reader/
+        # writer configuration via spec.configRawYaml in the block.
+        class VMAnomaly < Kube::Cluster["VMAnomaly"]
+          def initialize(name:, &block)
+            super() {
+              metadata.name = name
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VMAnomaly" do
+  it "initializes without error" do
+    Kube::Cluster::Standard::VictoriaMetrics::VMAnomaly
+      .new(name: "vmanomaly")
+      .to_yaml
+      .is_a?(String)
+      .should == true
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vm_anomaly_config.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # Reusable configuration object referenced by a VMAnomaly instance.
+        # Define the models/schedulers in the block.
+        class VMAnomalyConfig < Kube::Cluster["VMAnomalyConfig"]
+          def initialize(name:, &block)
+            super() {
+              metadata.name = name
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VMAnomalyConfig" do
+  it "initializes without error" do
+    Kube::Cluster::Standard::VictoriaMetrics::VMAnomalyConfig
+      .new(name: "vmanomalyconfig") { spec.schedulers = {} }
+      .to_yaml
+      .is_a?(String)
+      .should == true
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vm_auth.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # Auth proxy / router that sits in front of VictoriaMetrics components and
+        # dispatches requests according to the VMUser objects it selects. Configure
+        # user selection and unauthorized-access rules in the block.
+        class VMAuth < Kube::Cluster["VMAuth"]
+          def initialize(name:, &block)
+            super() {
+              metadata.name = name
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VMAuth" do
+  it "initializes without error" do
+    Kube::Cluster::Standard::VictoriaMetrics::VMAuth
+      .new(name: "vmauth")
+      .to_yaml
+      .is_a?(String)
+      .should == true
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vm_cluster.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # HA/clustered VictoriaMetrics: vmstorage + vmselect + vminsert
+        # components (the horizontally-scalable alternative to VMSingle).
+        # Configure the three components in the block.
+        class VMCluster < Kube::Cluster["VMCluster"]
+          def initialize(name:, retention_period: "30d", &block)
+            super() {
+              metadata.name        = name
+              spec.retentionPeriod = retention_period
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VMCluster" do
+  it "initializes without error" do
+    Kube::Cluster::Standard::VictoriaMetrics::VMCluster
+      .new(name: "vmcluster")
+      .to_yaml
+      .is_a?(String)
+      .should == true
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vm_distributed.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # Multi-zone/distributed VictoriaMetrics topology. The full shape (zones,
+        # common settings) is configured in the block.
+        class VMDistributed < Kube::Cluster["VMDistributed"]
+          def initialize(name:, &block)
+            super() {
+              metadata.name = name
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VMDistributed" do
+  it "initializes without error" do
+    Kube::Cluster::Standard::VictoriaMetrics::VMDistributed
+      .new(name: "vmdistributed") { spec.retain = true }
+      .to_yaml
+      .is_a?(String)
+      .should == true
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vm_pod_scrape.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # Declares how to scrape the pods selected by the app.kubernetes.io/name
+        # label (the pod-selector analogue of VMServiceScrape), relabelling the
+        # metrics onto a job.
+        class VMPodScrape < Kube::Cluster["VMPodScrape"]
+          def initialize(name:, job:, match_name:, port:, &block)
+            super() {
+              metadata.name           = name
+              spec.selector           = { matchLabels: { "app.kubernetes.io/name" => match_name } }
+              spec.podMetricsEndpoints = [{ port: port, relabelConfigs: [{ targetLabel: "job", replacement: job }] }]
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VMPodScrape" do
+  it "initializes without error" do
+    Kube::Cluster::Standard::VictoriaMetrics::VMPodScrape
+      .new(name: "opencost", job: "opencost", match_name: "opencost", port: "http")
+      .to_yaml
+      .is_a?(String)
+      .should == true
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vm_probe.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # Blackbox/probe scraping: points a prober (e.g. blackbox_exporter) at a
+        # set of targets. Pass the prober URL here and the targets/module in the
+        # block via spec.targets and spec.module.
+        class VMProbe < Kube::Cluster["VMProbe"]
+          def initialize(name:, prober_url:, &block)
+            super() {
+              metadata.name    = name
+              spec.vmProberSpec = { url: prober_url }
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VMProbe" do
+  it "initializes without error" do
+    Kube::Cluster::Standard::VictoriaMetrics::VMProbe
+      .new(name: "blackbox", prober_url: "http://blackbox-exporter.metrics.svc:9115")
+      .to_yaml
+      .is_a?(String)
+      .should == true
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vm_scrape_config.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # Generic scrape configuration supporting the full range of service-
+        # discovery mechanisms (static, kubernetes, http, ec2, consul, …). Declare
+        # the discovery configs and relabelling in the block.
+        class VMScrapeConfig < Kube::Cluster["VMScrapeConfig"]
+          def initialize(name:, &block)
+            super() {
+              metadata.name = name
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VMScrapeConfig" do
+  it "initializes without error" do
+    Kube::Cluster::Standard::VictoriaMetrics::VMScrapeConfig
+      .new(name: "vmscrapeconfig")
+      .to_yaml
+      .is_a?(String)
+      .should == true
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vm_static_scrape.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # Scrapes a fixed set of static targets (host:port) under a named job —
+        # for endpoints that have no Service/Pod to select. Extra per-endpoint
+        # settings (path, scheme, labels) can be added in the block.
+        class VMStaticScrape < Kube::Cluster["VMStaticScrape"]
+          def initialize(name:, job:, targets:, &block)
+            super() {
+              metadata.name       = name
+              spec.jobName        = job
+              spec.targetEndpoints = [{ targets: Array(targets) }]
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VMStaticScrape" do
+  it "initializes without error" do
+    Kube::Cluster::Standard::VictoriaMetrics::VMStaticScrape
+      .new(name: "external", job: "external", targets: ["10.0.0.1:9100"])
+      .to_yaml
+      .is_a?(String)
+      .should == true
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vm_user.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # A user/route definition consumed by VMAuth: maps credentials to a set of
+        # upstream target refs. Pass the routing in the block via spec.targetRefs.
+        class VMUser < Kube::Cluster["VMUser"]
+          def initialize(name:, username: nil, &block)
+            super() {
+              metadata.name = name
+              spec.username = username if username
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VMUser" do
+  it "initializes without error" do
+    Kube::Cluster::Standard::VictoriaMetrics::VMUser
+      .new(name: "vmuser", username: "reader") {
+        spec.targetRefs = [{ crd: { kind: "VMSingle", name: "vmsingle", namespace: "metrics" }, paths: ["/"] }]
+      }
+      .to_yaml
+      .is_a?(String)
+      .should == true
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vt_cluster.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # HA/clustered VictoriaTraces: storage + select + insert components
+        # (the horizontally-scalable alternative to VTSingle). Retention lives on
+        # the storage component, so configure the components in the block.
+        class VTCluster < Kube::Cluster["VTCluster"]
+          def initialize(name:, &block)
+            super() {
+              metadata.name = name
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VTCluster" do
+  it "initializes without error" do
+    Kube::Cluster::Standard::VictoriaMetrics::VTCluster
+      .new(name: "vtcluster")
+      .to_yaml
+      .is_a?(String)
+      .should == true
+  end
+end

data/lib/kube/cluster/standard/victoria_metrics/vt_single.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "kube/cluster"
+
+module Kube
+  module Cluster
+    module Standard
+      module VictoriaMetrics
+        # Single-node VictoriaTraces store.
+        class VTSingle < Kube::Cluster["VTSingle"]
+          def initialize(name:, retention_period: "30d", &block)
+            super() {
+              metadata.name        = name
+              spec.retentionPeriod = retention_period
+              instance_exec(&block) if block
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "VictoriaMetrics::VTSingle" do
+  it "initializes without error" do
+    Kube::Cluster::Standard::VictoriaMetrics::VTSingle
+      .new(name: "vtsingle")
+      .to_yaml
+      .is_a?(String)
+      .should == true
+  end
+end

data/lib/kube/cluster/version.rb

@@ -2,6 +2,6 @@
 
 module Kube
   module Cluster
-    VERSION = "1.4.0"
+    VERSION = "1.6.0"
   end
 end

data/lib/kube/cluster.rb

@@ -92,6 +92,7 @@ require "kube/cluster/resource/persistence"
 Kube::Cluster.config do
   # Built-in Kubernetes kinds.
   resolve "ConfigMap",                to: "v1/ConfigMap"
+  resolve "PersistentVolume",         to: "v1/PersistentVolume"
   resolve "PersistentVolumeClaim",    to: "v1/PersistentVolumeClaim"
   resolve "Secret",                   to: "v1/Secret"
   resolve "Service",                  to: "v1/Service"
@@ -126,13 +127,29 @@ Kube::Cluster.config do
 
   # VictoriaMetrics operator.
   resolve "VLAgent",                  to: "operator.victoriametrics.com/v1/VLAgent"
+  resolve "VLCluster",                to: "operator.victoriametrics.com/v1/VLCluster"
+  resolve "VLogs",                    to: "operator.victoriametrics.com/v1beta1/VLogs"
   resolve "VLSingle",                 to: "operator.victoriametrics.com/v1/VLSingle"
   resolve "VMAgent",                  to: "operator.victoriametrics.com/v1beta1/VMAgent"
   resolve "VMAlert",                  to: "operator.victoriametrics.com/v1beta1/VMAlert"
+  resolve "VMAlertmanager",           to: "operator.victoriametrics.com/v1beta1/VMAlertmanager"
+  resolve "VMAlertmanagerConfig",     to: "operator.victoriametrics.com/v1beta1/VMAlertmanagerConfig"
+  resolve "VMAnomaly",                to: "operator.victoriametrics.com/v1/VMAnomaly"
+  resolve "VMAnomalyConfig",          to: "operator.victoriametrics.com/v1/VMAnomalyConfig"
+  resolve "VMAuth",                   to: "operator.victoriametrics.com/v1beta1/VMAuth"
+  resolve "VMCluster",                to: "operator.victoriametrics.com/v1beta1/VMCluster"
+  resolve "VMDistributed",            to: "operator.victoriametrics.com/v1alpha1/VMDistributed"
   resolve "VMNodeScrape",             to: "operator.victoriametrics.com/v1beta1/VMNodeScrape"
+  resolve "VMPodScrape",              to: "operator.victoriametrics.com/v1beta1/VMPodScrape"
+  resolve "VMProbe",                  to: "operator.victoriametrics.com/v1beta1/VMProbe"
   resolve "VMRule",                   to: "operator.victoriametrics.com/v1beta1/VMRule"
+  resolve "VMScrapeConfig",           to: "operator.victoriametrics.com/v1beta1/VMScrapeConfig"
   resolve "VMServiceScrape",          to: "operator.victoriametrics.com/v1beta1/VMServiceScrape"
   resolve "VMSingle",                 to: "operator.victoriametrics.com/v1beta1/VMSingle"
+  resolve "VMStaticScrape",           to: "operator.victoriametrics.com/v1beta1/VMStaticScrape"
+  resolve "VMUser",                   to: "operator.victoriametrics.com/v1beta1/VMUser"
+  resolve "VTCluster",                to: "operator.victoriametrics.com/v1/VTCluster"
+  resolve "VTSingle",                 to: "operator.victoriametrics.com/v1/VTSingle"
 
   # Gateway API — pin to the stable v1 group/version.
   resolve "GatewayClass",             to: "gateway.networking.k8s.io/v1/GatewayClass"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kube_cluster
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.6.0
 platform: ruby
 authors:
 - Nathan K
@@ -57,14 +57,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.9.2
+        version: 1.10.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.9.2
+        version: 1.10.0
 - !ruby/object:Gem::Dependency
   name: kube_kubectl
   requirement: !ruby/object:Gem::Requirement
@@ -231,6 +231,8 @@ files:
 - lib/kube/cluster/standard/gateway_api/http_route.rb
 - lib/kube/cluster/standard/job.rb
 - lib/kube/cluster/standard/job_with_service_account.rb
+- lib/kube/cluster/standard/juice_fs/persistent_volume.rb
+- lib/kube/cluster/standard/juice_fs/sync.rb
 - lib/kube/cluster/standard/kube_virt/virtual_machine.rb
 - lib/kube/cluster/standard/meta_controller/composite_controller.rb
 - lib/kube/cluster/standard/meta_controller/decorator_controller.rb
@@ -244,13 +246,29 @@ files:
 - lib/kube/cluster/standard/service_account.rb
 - lib/kube/cluster/standard/service_account_with_role.rb
 - lib/kube/cluster/standard/victoria_metrics/vl_agent.rb
+- lib/kube/cluster/standard/victoria_metrics/vl_cluster.rb
 - lib/kube/cluster/standard/victoria_metrics/vl_single.rb
+- lib/kube/cluster/standard/victoria_metrics/vlogs.rb
 - lib/kube/cluster/standard/victoria_metrics/vm_agent.rb
 - lib/kube/cluster/standard/victoria_metrics/vm_alert.rb
+- lib/kube/cluster/standard/victoria_metrics/vm_alertmanager.rb
+- lib/kube/cluster/standard/victoria_metrics/vm_alertmanager_config.rb
+- lib/kube/cluster/standard/victoria_metrics/vm_anomaly.rb
+- lib/kube/cluster/standard/victoria_metrics/vm_anomaly_config.rb
+- lib/kube/cluster/standard/victoria_metrics/vm_auth.rb
+- lib/kube/cluster/standard/victoria_metrics/vm_cluster.rb
+- lib/kube/cluster/standard/victoria_metrics/vm_distributed.rb
 - lib/kube/cluster/standard/victoria_metrics/vm_node_scrape.rb
+- lib/kube/cluster/standard/victoria_metrics/vm_pod_scrape.rb
+- lib/kube/cluster/standard/victoria_metrics/vm_probe.rb
 - lib/kube/cluster/standard/victoria_metrics/vm_rule.rb
+- lib/kube/cluster/standard/victoria_metrics/vm_scrape_config.rb
 - lib/kube/cluster/standard/victoria_metrics/vm_service_scrape.rb
 - lib/kube/cluster/standard/victoria_metrics/vm_single.rb
+- lib/kube/cluster/standard/victoria_metrics/vm_static_scrape.rb
+- lib/kube/cluster/standard/victoria_metrics/vm_user.rb
+- lib/kube/cluster/standard/victoria_metrics/vt_cluster.rb
+- lib/kube/cluster/standard/victoria_metrics/vt_single.rb
 - lib/kube/cluster/standard/volume_processing.rb
 - lib/kube/cluster/version.rb
 - lib/kube/cluster/version.rb.erb