kuby-redis 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a76527037e4b0dc6d60be52d6ae1b9c93bf3bd41d3188b562f8140a4d45dc007
-  data.tar.gz: a98a3e23693aa65f9e8964d37754c5c4e0612c6250b5b2d9a4047f99ab3f1fa7
+  metadata.gz: 69bffb46215d12382fd38781fd0b53d6ec8c73db4e8e94902fc46d844d72dc7f
+  data.tar.gz: 322bcccaec7830bbddaa8ce829f64682c83ec16ebc2b0db5898f8dcd630cb732
 SHA512:
-  metadata.gz: e288064f9f39ff7c223e34c0e9f75dd5e3e0b94c4a6983b849fc78469ceeb2ed2577594695eba5dca8d4019e5cac4ea26b49ebc59ba3c782d1cada87f335f9d7
-  data.tar.gz: 7c68f5b0bea7c5aa285e3164562f5ea514577c0b608a346cb74f8c976a15360d22495c5013108a886f935bb2592a7f20910c6f82817ccc05d8221cb4285db431
+  metadata.gz: e4857e14a64a878411e27f72d268303e38282e31a71bfe221362f96db9f75c5b7a85eb43e8088690b09aee09237955b0f477b7c28dc2fb533ed23644f723b656
+  data.tar.gz: 37ea5f91b73bd1ce226e78508141e6c097eaf7dc317d21e1c1db340f2169846f37df0ed1cfa5236bef9afaf10248d6c8dab5bc7cfac690efd4c3fc97b67a9b42

data/CHANGELOG.md

@@ -1,2 +1,6 @@
+## 0.2.0
+* Use the Spotahome Redis operator instead of KubeDB.
+* Generate DSL files by making an API request to a Kind cluster.
+
 ## 0.1.0
 * Birthday!

data/Gemfile

@@ -3,9 +3,12 @@ source 'https://rubygems.org'
 gemspec
 
 gem 'kuby-core', path: '../kuby-core'
-gem 'kube-dsl', path: '../kube-dsl'
 
 group :development, :test do
+  gem 'sorbet'
+  gem 'sorbet-runtime'
+  gem 'tapioca', '~> 0.7'
+  gem 'parlour', github: 'camertron/parlour', branch: 'initialize_void'
   gem 'pry-byebug'
   gem 'rake'
 end

data/README.md

@@ -1,14 +1,22 @@
+**NOTE**: The documentation below refers to an unreleased version of kuby-redis. Please [click here](https://github.com/getkuby/kuby-redis/blob/v0.1.0/README.md) for the documentation for the currently released version.
+
 ## kuby-redis
 
-Redis plugin for [Kuby](https://github.com/getkuby/kuby-core).
+Redis plugin for [Kuby](https://github.com/getkuby/kuby-core). If you're looking for an easy way to add Sidekiq to your app, check out [kuby-sidekiq](https://github.com/getkuby/kuby-sidekiq).
 
 ## Intro
 
-The redis plugin provides the ability to stand up arbitrary redis instances. Behind the scenes it uses the excellent [kubedb](https://kubedb.com/) Kubernetes operator.
+The redis plugin provides the ability to stand up arbitrary redis instances. Behind the scenes it uses the excellent [Spotahome Redis operator](https://github.com/spotahome/redis-operator).
 
 ## Configuration
 
-Add the kuby-redis gem to your Gemfile, then add a redis instance like this:
+Add the kuby-redis gem to your Gemfile and run the setup command, eg:
+
+```bash
+bundle exec kuby -e production setup
+```
+
+Add a Redis instance like this:
 
 ```ruby
 require 'kuby/redis'
@@ -24,13 +32,20 @@ Kuby.define(:production) do
 end
 ```
 
-The kuby-redis plugin allows a number of additional configuration options too:
+The kuby-redis plugin supports a number of additional configuration options:
 
+* `cpu_request`, (default: `'100m'`). The number of CPU units to request from Kubernetes. 1 CPU core = 1000 units.
+* `memory_request`, (default: `'100Mi'`). The amount of memory to request from Kubernetes.
+* `cpu_limit`, (default: `'400m'`). A limit on the number of CPU units the Redis instance may consume. 1 CPU core = 1000 units.
+* `memory_limit`, (default: `'500Mi'`). A limit on the amount of memory the Redis instance may consume.
+* `sentinel_replicas` (default: `1`). The number of [Redis sentinels](https://redis.io/docs/manual/sentinel/) to run.
+* `redis_replicas` (default: `1`). The number of replicated Redis servers to run. For a highly-available configuration, set this option to a value >= 3.
+* `storage_access_modes`, (default: `['ReadWriteOnce']`). An array of Kubernetes [storage access modes](https://kubernetes.io/docs/concepts/storage/persistent-volumes/#access-modes) for the persistent volume that the Redis instance will use to persist data.
+* `storage`, (default: `'1Gi'`). The amount of persistent storage to request. Note that this is not a Redis memory limit, but rather a request for an amount of persistent (i.e. disk-based) storage Redis will write to. Persistent storage is necessary to prevent data loss if/when an individual Redis instance fails.
 
-value_field :storage_type, default: 'Durable'
-value_field :storage, default: '1Gi'
-value_field :access_modes, default: ['ReadWriteOnce']
+**NOTE**: All memory amounts must be strings parseable by Go's [go-units module](https://pkg.go.dev/github.com/docker/go-units#example-FromHumanSize). Valid examples include '100Mi' (100 megabytes) and '2Gi' (2 gigabytes).
 
+Example:
 
 ```ruby
 Kuby.define(:production) do
@@ -38,15 +53,12 @@ Kuby.define(:production) do
 
     add_plugin(:redis) do
       instance(:my_rails_cache) do
-        # set the version of redis you want to use
-        version '5.0.3-v1'  # this is the default version
-
-        # set the port redis listens on and that you'll
-        # use to connect to the instance
-        port 6379  # this is the default port
+        # Launch three redis replicas (this is the recommended configuration
+        # for high availability).
+        redis_replicas 3
 
-        # the amount of durable storage to allocate
-        storage '1Gi'
+        # The amount of persistent storage to request.
+        storage '5Gi'
       end
     end
 
@@ -54,47 +66,40 @@ Kuby.define(:production) do
 end
 ```
 
-Get a list of the redis versions your cluster supports by running:
-
-```bash
-bundle exec kuby -e production kubectl -- get redisversions
-```
-
 ## Usage
 
-Redis instances defined in your Kuby config respond to `#hostname`, `#port`, and `#url` methods to help point at them in your Rails configuration. The `#url` method returns a complete URL to the redis instance, including the host and port.
+Redis instances defined in your Kuby config respond to the `#service_name`, `#service_port`, and `#connection_params` methods to facilitate connecting to them from your Rails app. One caveat is that clients must be [sentinel-aware](https://redis.io/docs/reference/sentinel-clients/), but for the most part users won't have to worry about this since the redis-rb gem [supports sentinel configurations](https://github.com/redis/redis-rb#sentinel-support).
 
 ### Rails Cache
 
 In your Rails config (eg. config/environments/production.rb), point your cache store at your redis instance like so:
 
-
 ```ruby
+# make sure Kuby config is loaded
 Kuby.load!
 
-url = Kuby.environment.kubernetes
+redis_instance = Kuby.environment.kubernetes
   .plugin(:redis)
   .instance(:my_rails_cache)
-  .url
 
-config.cache_store = :redis_cache_store, { url: url }
+config.cache_store = :redis_cache_store, redis_instance.connection_params
 ```
 
 ### Redis Gem
 
-You can also use a redis client like the [Redis gem](https://github.com/redis/redis-rb) directly:
+You can also use the [redis-rb gem](https://github.com/redis/redis-rb) directly:
 
 ```ruby
+# make sure Kuby config is loaded
+Kuby.load!
+
 require 'redis'
 
-url = Kuby.environment.kubernetes
+redis_instance = Kuby.environment.kubernetes
   .plugin(:redis)
   .instance(:my_rails_cache)
-  .url
 
-redis = Redis.new(url: url)
-redis.set('abc', 123)
-value = redis.get('abc')
+redis = Redis.new(**redis_instance.connection_params)
 ```
 
 ## License

data/Rakefile

@@ -2,6 +2,8 @@ require 'bundler'
 require 'rspec/core/rake_task'
 require 'rubygems/package_task'
 
+require 'pry-byebug'
+require 'sorbet-runtime'
 require 'kuby/redis'
 
 Bundler::GemHelper.install_tasks
@@ -12,3 +14,159 @@ desc 'Run specs'
 RSpec::Core::RakeTask.new do |t|
   t.pattern = './spec/**/*_spec.rb'
 end
+
+task generate: [:schemagen, :codegen]
+
+task :schemagen do
+  require 'base64'
+  require 'json'
+  require 'kind-rb'
+  require 'net/http'
+  require 'uri'
+  require 'yaml'
+  require 'helm-cli'
+
+  # delete first just in case
+  system("#{KindRb.executable} delete cluster --name kuby-redis")
+  system("#{KindRb.executable} create cluster --name kuby-redis")
+
+  kubeconfig = `#{KindRb.executable} get kubeconfig --name kuby-redis`
+  File.write('.kubeconfig', kubeconfig)
+
+  helm = HelmCLI.new('.kubeconfig')
+  helm.add_repo('redis-operator', 'https://spotahome.github.io/redis-operator')
+  helm.update_repos
+
+  unless helm.release_exists?('redis-operator')
+    helm.install_chart('redis-operator/redis-operator', release: 'redis-operator', version: '3.1.4')
+  end
+
+  cluster_name = 'kind-kuby-redis'
+  kubeconfig = YAML.load(kubeconfig)
+  cluster = kubeconfig['clusters'].find { |cluster| cluster['name'] == cluster_name }
+  ca_cert_data = Base64.decode64(cluster.dig(*%w(cluster certificate-authority-data)))
+
+  cert_store = OpenSSL::X509::Store.new
+  cert_store.add_cert(OpenSSL::X509::Certificate.new(ca_cert_data))
+  server = URI.parse(cluster.dig(*%w(cluster server)))
+
+  http = Net::HTTP.new(server.host, server.port).tap do |http|
+    http.use_ssl = true
+    http.cert_store = cert_store
+    http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+  end
+
+  token = nil
+  STDOUT.write("Getting API token from cluster...")
+
+  loop do
+    secrets = JSON.parse(`kubectl --context #{cluster_name} get secrets -o json`)
+    secret = secrets['items'].find do |secret|
+      secret.dig(*%w(metadata annotations kubernetes.io/service-account.name)) == 'default'
+    end
+
+    if secret
+      token = Base64.decode64(secret.dig(*%w(data token)))
+      puts ' done'
+      break
+    else
+      STDOUT.write('.')
+      sleep 1
+    end
+  end
+
+  get = Net::HTTP::Get.new('/openapi/v2')
+  get['Authorization'] = "Bearer #{token}"
+
+  crds = []
+  schema = nil
+  STDOUT.write("Requesting OpenAPI v2 schema from cluster...")
+
+  loop do
+    response = http.request(get)
+    schema = JSON.parse(response.body)
+
+    crds = schema['definitions'].each_with_object({}) do |(id, data), memo|
+      memo[id] = data if id.start_with?('com.spotahome')
+    end
+
+    if crds.empty?
+      STDOUT.write('.')
+      sleep 1
+    else
+      puts ' done'
+      break
+    end
+  end
+
+  FileUtils.rm_rf('vendor')
+  FileUtils.mkdir('vendor')
+
+  schema = schema.merge('definitions' => crds)
+  File.write(File.join('vendor', 'open_api.json'), schema.to_json)
+
+  puts 'Pulling openapi2jsonschema Docker image'
+  system('docker pull garethr/openapi2jsonschema')
+
+  puts 'Converting OpenAPI format to JSON schema format'
+  system(<<~END)
+    docker run --rm \
+      -v #{File.expand_path('vendor')}:/usr/local/scratch \
+      garethr/openapi2jsonschema \
+      --kubernetes --output /usr/local/scratch/json_schema /usr/local/scratch/open_api.json
+  END
+
+  puts "Cleaning up"
+  system("#{KindRb.executable} delete cluster --name kuby-redis")
+  File.unlink('.kubeconfig')
+end
+
+task :codegen do
+  require 'dry/inflector'
+  require 'fileutils'
+
+  # delete anything that should be re-generated
+  FileUtils.rm_rf('./lib/kuby/redis/dsl.rb')
+  FileUtils.rm_rf('./lib/kuby/redis/dsl')
+  FileUtils.rm_rf('./lib/kuby/redis/entrypoint.rb')
+  FileUtils.rm_rf('./sorbet/rbi/kuby/redis')
+  FileUtils.mkdir_p('./lib/kuby/redis/dsl')
+
+  local_json_schema_path = 'vendor/json_schema'
+
+  generator = KubeDSL::Generator.new(
+    schema_dir: local_json_schema_path,
+    output_dir: File.join('lib'),
+    autoload_prefix: File.join('kuby', 'redis', 'dsl'),
+    dsl_namespace: ['Kuby', 'Redis', 'DSL'],
+    entrypoint_namespace: ['Kuby', 'Redis'],
+    inflector: Dry::Inflector.new do |inflections|
+      inflections.acronym('DSL')
+    end
+  )
+
+  generator.builder.register_resolver('io.k8s') do |ref_str, builder|
+    external_ref = ::KubeDSL::ExternalRef.new(
+      ref_str,
+      ['KubeDSL', 'DSL'],
+      builder.inflector,
+      builder.schema_dir,
+      builder.autoload_prefix,
+      builder.serialize_handlers
+    )
+
+    ns = external_ref.ruby_namespace + [external_ref.kind]
+    exists = ns.inject(Object) { |mod, n| mod.const_get(n, false) } rescue false
+    exists ? external_ref : builder.parse_ref(ref_str)
+  end
+
+  generator.generate_resource_files
+  generator.generate_autoload_files
+  generator.generate_entrypoint_file do |resource, ns|
+    # only generate entrypoint methods for resources defined at the top-level, i.e.
+    # not resources defined inside other resources
+    !resource.ref.inline?
+  end
+
+  FileUtils.rm_rf(File.join('lib', 'kuby.rb'))
+end

data/kuby-redis.gemspec

@@ -12,8 +12,9 @@ Gem::Specification.new do |s|
 
   s.platform = Gem::Platform::RUBY
 
-  s.add_dependency 'kuby-kube-db', '~> 0.4'
-  s.add_dependency 'kube-dsl', '~> 0.4'
+  s.add_dependency 'kuby-core', '>= 0.16.0', '< 1.0'
+  s.add_dependency 'kube-dsl', '~> 0.7'
+  s.add_dependency 'helm-cli', '~> 0.3'
 
   s.require_path = 'lib'
   s.files = Dir['{lib,spec}/**/*', 'Gemfile', 'LICENSE', 'CHANGELOG.md', 'README.md', 'Rakefile', 'kuby-redis.gemspec']

data/lib/kuby/redis/dsl/databases/v1/redis_failover.rb

@@ -0,0 +1,34 @@
+# typed: true
+
+module Kuby
+  module Redis
+    module DSL
+      module Databases
+        module V1
+          class RedisFailover < ::KubeDSL::DSLObject
+            object_field(:spec) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpec.new }
+            value_field :api_version
+            object_field(:metadata) { KubeDSL::DSL::Meta::V1::ObjectMeta.new }
+
+            validates :spec, object: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpec }
+            validates :api_version, field: { format: :string }, presence: false
+            validates :metadata, object: { kind_of: KubeDSL::DSL::Meta::V1::ObjectMeta }
+
+            def serialize
+              {}.tap do |result|
+                result[:kind] = "RedisFailover"
+                result[:spec] = spec.serialize
+                result[:apiVersion] = api_version
+                result[:metadata] = metadata.serialize
+              end
+            end
+
+            def kind_sym
+              :redis_failover
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/redis/dsl/databases/v1/redis_failover_list.rb

@@ -0,0 +1,34 @@
+# typed: true
+
+module Kuby
+  module Redis
+    module DSL
+      module Databases
+        module V1
+          class RedisFailoverList < ::KubeDSL::DSLObject
+            array_field(:item) { Kuby::Redis::DSL::Databases::V1::RedisFailover.new }
+            value_field :api_version
+            object_field(:metadata) { KubeDSL::DSL::Meta::V1::ListMeta.new }
+
+            validates :items, array: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailover }, presence: false
+            validates :api_version, field: { format: :string }, presence: false
+            validates :metadata, object: { kind_of: KubeDSL::DSL::Meta::V1::ListMeta }
+
+            def serialize
+              {}.tap do |result|
+                result[:items] = items.map(&:serialize)
+                result[:kind] = "RedisFailoverList"
+                result[:apiVersion] = api_version
+                result[:metadata] = metadata.serialize
+              end
+            end
+
+            def kind_sym
+              :redis_failover_list
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/redis/dsl/databases/v1/redis_failover_spec.rb

@@ -0,0 +1,39 @@
+# typed: true
+
+module Kuby
+  module Redis
+    module DSL
+      module Databases
+        module V1
+          class RedisFailoverSpec < ::KubeDSL::DSLObject
+            object_field(:sentinel) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecSentinel.new }
+            object_field(:bootstrap_node) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecBootstrapNode.new }
+            object_field(:redis) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedis.new }
+            object_field(:auth) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecAuth.new }
+            value_field :label_whitelist
+
+            validates :sentinel, object: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecSentinel }
+            validates :bootstrap_node, object: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecBootstrapNode }
+            validates :redis, object: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedis }
+            validates :auth, object: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecAuth }
+            validates :label_whitelist, field: { format: :string }, presence: false
+
+            def serialize
+              {}.tap do |result|
+                result[:sentinel] = sentinel.serialize
+                result[:bootstrapNode] = bootstrap_node.serialize
+                result[:redis] = redis.serialize
+                result[:auth] = auth.serialize
+                result[:labelWhitelist] = label_whitelist
+              end
+            end
+
+            def kind_sym
+              :redis_failover_spec
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/redis/dsl/databases/v1/redis_failover_spec_auth.rb

@@ -0,0 +1,27 @@
+# typed: true
+
+module Kuby
+  module Redis
+    module DSL
+      module Databases
+        module V1
+          class RedisFailoverSpecAuth < ::KubeDSL::DSLObject
+            value_field :secret_path
+
+            validates :secret_path, field: { format: :string }, presence: false
+
+            def serialize
+              {}.tap do |result|
+                result[:secretPath] = secret_path
+              end
+            end
+
+            def kind_sym
+              :redis_failover_spec_auth
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/redis/dsl/databases/v1/redis_failover_spec_bootstrap_node.rb

@@ -0,0 +1,33 @@
+# typed: true
+
+module Kuby
+  module Redis
+    module DSL
+      module Databases
+        module V1
+          class RedisFailoverSpecBootstrapNode < ::KubeDSL::DSLObject
+            value_field :host
+            value_field :allow_sentinels
+            value_field :port
+
+            validates :host, field: { format: :string }, presence: false
+            validates :allow_sentinels, field: { format: :boolean }, presence: true
+            validates :port, field: { format: :string }, presence: false
+
+            def serialize
+              {}.tap do |result|
+                result[:host] = host
+                result[:allowSentinels] = allow_sentinels
+                result[:port] = port
+              end
+            end
+
+            def kind_sym
+              :redis_failover_spec_bootstrap_node
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/redis/dsl/databases/v1/redis_failover_spec_redis.rb

@@ -0,0 +1,90 @@
+# typed: true
+
+module Kuby
+  module Redis
+    module DSL
+      module Databases
+        module V1
+          class RedisFailoverSpecRedis < ::KubeDSL::DSLObject
+            value_field :dns_policy
+            key_value_field(:pod_annotations, format: :string)
+            value_field :image
+            value_field :host_network
+            object_field(:exporter) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisExporter.new }
+            key_value_field(:node_selector, format: :string)
+            value_field :priority_class_name
+            object_field(:security_context) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisSecurityContext.new }
+            object_field(:storage) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisStorage.new }
+            array_field(:custom_command_rename) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisCustomCommandRenames.new }
+            value_field :custom_config
+            object_field(:affinity) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisAffinity.new }
+            array_field(:toleration) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisTolerations.new }
+            object_field(:resources) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisResources.new }
+            value_field :shutdown_config_map
+            value_field :termination_grace_period
+            value_field :service_account_name
+            value_field :replicas
+            key_value_field(:service_annotations, format: :string)
+            value_field :command
+            value_field :image_pull_policy
+            array_field(:image_pull_secret) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisImagePullSecrets.new }
+
+            validates :dns_policy, field: { format: :string }, presence: false
+            validates :pod_annotations, kv: { value_format: :string }, presence: true
+            validates :image, field: { format: :string }, presence: false
+            validates :host_network, field: { format: :boolean }, presence: true
+            validates :exporter, object: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisExporter }
+            validates :node_selector, kv: { value_format: :string }, presence: true
+            validates :priority_class_name, field: { format: :string }, presence: false
+            validates :security_context, object: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisSecurityContext }
+            validates :storage, object: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisStorage }
+            validates :custom_command_renames, array: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisCustomCommandRenames }, presence: false
+            validates :custom_config, field: { format: :string }, presence: false
+            validates :affinity, object: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisAffinity }
+            validates :tolerations, array: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisTolerations }, presence: false
+            validates :resources, object: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisResources }
+            validates :shutdown_config_map, field: { format: :string }, presence: false
+            validates :termination_grace_period, field: { format: :integer }, presence: true
+            validates :service_account_name, field: { format: :string }, presence: false
+            validates :replicas, field: { format: :integer }, presence: true
+            validates :service_annotations, kv: { value_format: :string }, presence: true
+            validates :command, field: { format: :string }, presence: false
+            validates :image_pull_policy, field: { format: :string }, presence: false
+            validates :image_pull_secrets, array: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisImagePullSecrets }, presence: false
+
+            def serialize
+              {}.tap do |result|
+                result[:dnsPolicy] = dns_policy
+                result[:podAnnotations] = pod_annotations.serialize
+                result[:image] = image
+                result[:hostNetwork] = host_network
+                result[:exporter] = exporter.serialize
+                result[:nodeSelector] = node_selector.serialize
+                result[:priorityClassName] = priority_class_name
+                result[:securityContext] = security_context.serialize
+                result[:storage] = storage.serialize
+                result[:customCommandRenames] = custom_command_renames.map(&:serialize)
+                result[:customConfig] = custom_config
+                result[:affinity] = affinity.serialize
+                result[:tolerations] = tolerations.map(&:serialize)
+                result[:resources] = resources.serialize
+                result[:shutdownConfigMap] = shutdown_config_map
+                result[:terminationGracePeriod] = termination_grace_period
+                result[:serviceAccountName] = service_account_name
+                result[:replicas] = replicas
+                result[:serviceAnnotations] = service_annotations.serialize
+                result[:command] = command
+                result[:imagePullPolicy] = image_pull_policy
+                result[:imagePullSecrets] = image_pull_secrets.map(&:serialize)
+              end
+            end
+
+            def kind_sym
+              :redis_failover_spec_redis
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/redis/dsl/databases/v1/redis_failover_spec_redis_affinity.rb

@@ -0,0 +1,33 @@
+# typed: true
+
+module Kuby
+  module Redis
+    module DSL
+      module Databases
+        module V1
+          class RedisFailoverSpecRedisAffinity < ::KubeDSL::DSLObject
+            object_field(:pod_affinity) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisAffinityPodAffinity.new }
+            object_field(:node_affinity) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisAffinityNodeAffinity.new }
+            object_field(:pod_anti_affinity) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisAffinityPodAntiAffinity.new }
+
+            validates :pod_affinity, object: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisAffinityPodAffinity }
+            validates :node_affinity, object: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisAffinityNodeAffinity }
+            validates :pod_anti_affinity, object: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisAffinityPodAntiAffinity }
+
+            def serialize
+              {}.tap do |result|
+                result[:podAffinity] = pod_affinity.serialize
+                result[:nodeAffinity] = node_affinity.serialize
+                result[:podAntiAffinity] = pod_anti_affinity.serialize
+              end
+            end
+
+            def kind_sym
+              :redis_failover_spec_redis_affinity
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/redis/dsl/databases/v1/redis_failover_spec_redis_affinity_node_affinity.rb

@@ -0,0 +1,30 @@
+# typed: true
+
+module Kuby
+  module Redis
+    module DSL
+      module Databases
+        module V1
+          class RedisFailoverSpecRedisAffinityNodeAffinity < ::KubeDSL::DSLObject
+            object_field(:required_during_scheduling_ignored_during_execution) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecution.new }
+            array_field(:preferred_during_scheduling_ignored_during_execution) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecution.new }
+
+            validates :required_during_scheduling_ignored_during_execution, object: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecution }
+            validates :preferred_during_scheduling_ignored_during_executions, array: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecution }, presence: false
+
+            def serialize
+              {}.tap do |result|
+                result[:requiredDuringSchedulingIgnoredDuringExecution] = required_during_scheduling_ignored_during_execution.serialize
+                result[:preferredDuringSchedulingIgnoredDuringExecution] = preferred_during_scheduling_ignored_during_executions.map(&:serialize)
+              end
+            end
+
+            def kind_sym
+              :redis_failover_spec_redis_affinity_node_affinity
+            end
+          end
+        end
+      end
+    end
+  end
+end