kruby-controller 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (39) hide show
  1. checksums.yaml +7 -0
  2. data/LICENSE +201 -0
  3. data/README.md +117 -0
  4. data/Rakefile +8 -0
  5. data/exe/kruby-controller +32 -0
  6. data/lib/kruby-controller.rb +8 -0
  7. data/lib/kruby_controller/builder/controller_builder.rb +52 -0
  8. data/lib/kruby_controller/cache/cache.rb +100 -0
  9. data/lib/kruby_controller/cache/deep_copy.rb +32 -0
  10. data/lib/kruby_controller/cache/delta.rb +12 -0
  11. data/lib/kruby_controller/cache/informer.rb +453 -0
  12. data/lib/kruby_controller/cache/request_error.rb +55 -0
  13. data/lib/kruby_controller/cache/store.rb +92 -0
  14. data/lib/kruby_controller/cache/watch_stream.rb +144 -0
  15. data/lib/kruby_controller/cli/create_api_command.rb +335 -0
  16. data/lib/kruby_controller/cli/flag_parser.rb +85 -0
  17. data/lib/kruby_controller/cli/init_command.rb +383 -0
  18. data/lib/kruby_controller/controller.rb +200 -0
  19. data/lib/kruby_controller/crd.rb +141 -0
  20. data/lib/kruby_controller/election/leader_elector.rb +212 -0
  21. data/lib/kruby_controller/finalizer/finalizer_manager.rb +31 -0
  22. data/lib/kruby_controller/generator/crd_generator.rb +109 -0
  23. data/lib/kruby_controller/gvk.rb +59 -0
  24. data/lib/kruby_controller/handler/enqueued_object.rb +18 -0
  25. data/lib/kruby_controller/handler/enqueued_owner.rb +51 -0
  26. data/lib/kruby_controller/handler/predicated.rb +21 -0
  27. data/lib/kruby_controller/kubernetes_object_client.rb +77 -0
  28. data/lib/kruby_controller/logger.rb +11 -0
  29. data/lib/kruby_controller/manager.rb +291 -0
  30. data/lib/kruby_controller/owner/owner_reference.rb +23 -0
  31. data/lib/kruby_controller/queue/rate_limiter.rb +51 -0
  32. data/lib/kruby_controller/queue/work_queue.rb +375 -0
  33. data/lib/kruby_controller/reconciler.rb +18 -0
  34. data/lib/kruby_controller/request.rb +59 -0
  35. data/lib/kruby_controller/result.rb +50 -0
  36. data/lib/kruby_controller/status/status_updater.rb +29 -0
  37. data/lib/kruby_controller/version.rb +5 -0
  38. data/lib/kruby_controller.rb +87 -0
  39. metadata +138 -0
@@ -0,0 +1,375 @@
1
+ # frozen_string_literal: true
2
+
3
+ module KrubyController
4
+ module Queue
5
+ # Deduplicating work queue with an in-flight dirty flag
6
+ # (controller-runtime semantics).
7
+ #
8
+ # All state access is guarded by a single mutex (a condition variable
9
+ # provides the blocking `get`), so the dequeue and the pending ->
10
+ # in-flight transition happen atomically: there is no window in which a
11
+ # key is visible as neither pending nor in flight and an informer event
12
+ # can be silently deduped against a stale state.
13
+ #
14
+ # A key is "present" while it is pending (`@pending_keys`) or in flight
15
+ # (`@in_flight`). `add` is a no-op for a key that is already present,
16
+ # except when the key is in flight: then it is recorded in `@dirty`
17
+ # instead of enqueued. When the worker calls `done`, a dirty key is
18
+ # re-queued so the reconciler runs once more for the latest state.
19
+ # Without this, an event for a key that is currently being reconciled
20
+ # would be dropped and never re-triggered.
21
+ #
22
+ # Completions are matched by request-object identity, not by key: a
23
+ # requeued copy is a fresh `Request` object, so a delayed or duplicate
24
+ # `done` for an older copy can never clear the in-flight entry of the
25
+ # newer copy (per-dequeue identity, equivalent to a generation token).
26
+ #
27
+ # Delayed retries (from `add_after` / `add_rate_limited`) are managed by
28
+ # ONE shared scheduler thread per queue instead of one sleeping thread
29
+ # per retry (which scaled linearly with the failure volume). Ordering
30
+ # and priority rules:
31
+ #
32
+ # * Registration collapses duplicates: at most ONE pending delayed entry
33
+ # per key exists, always the one with the earliest deadline. A
34
+ # later-registered deadline for a key that already has a pending entry
35
+ # is superseded and never produces a second copy; an
36
+ # earlier-registered deadline replaces the pending one (the sooner
37
+ # fire reconciles with the latest state either way).
38
+ # * An immediate `add` for a key with a pending delayed entry wins: the
39
+ # key becomes pending/in flight right away and the delayed fire is
40
+ # deduped when it fires. A delayed entry never preempts in-flight work.
41
+ # * A delayed fire while its key is pending is a dedupe no-op; while its
42
+ # key is in flight it records the dirty flag (exactly like an informer
43
+ # event), so the completion re-queues the key once; while the key is
44
+ # free (the earlier attempt already completed) it enqueues exactly
45
+ # once — a fresh, legitimate retry.
46
+ #
47
+ # Lifecycle is serialized against the queue mutex. Registration checks
48
+ # `@closed` and the retry lifecycle in the SAME critical section that
49
+ # inserts the entry and starts the scheduler, so a shutdown cannot slip
50
+ # between the check and the insertion and no scheduler can ever be
51
+ # started for a closed queue. shutdown and reset retire the current
52
+ # scheduler thread (per-scheduler stop flag, captured under the lock)
53
+ # and join it outside the lock, so a scheduler restarted by a reset in
54
+ # that window is never joined by the retiring shutdown.
55
+ class WorkQueue
56
+ SENTINEL = Object.new.freeze
57
+
58
+ # A delayed enqueue promise. Fires at +due_at+ (monotonic clock) and
59
+ # enqueues only if the queue is still open and the retry lifecycle
60
+ # (seq) that scheduled it is still current.
61
+ DelayEntry = Struct.new(:due_at, :seq, :request)
62
+
63
+ # One scheduler thread with its own stop flag. The flag is per handle
64
+ # so a scheduler started after a shutdown begins can never prevent the
65
+ # retired one from observing its stop (and vice versa).
66
+ SchedulerHandle = Struct.new(:thread, :stop_requested)
67
+
68
+ def initialize(rate_limiter: nil)
69
+ @rate_limiter = rate_limiter
70
+ # Thread::Queue gives us O(1) FIFO push/pop. Its operations are
71
+ # performed while @mutex is held so that popping an item and moving
72
+ # its key from pending to in flight remain one atomic transition.
73
+ @queue = ::Queue.new
74
+ @pending_keys = Set.new
75
+ @in_flight = {}
76
+ @dirty = Set.new
77
+ @mutex = Mutex.new
78
+ @cond = ConditionVariable.new
79
+ @closed = false
80
+ # Lifecycle counter for delayed retries. Bumped on every #reset so a
81
+ # retry scheduled in a previous lifecycle is discarded when it fires
82
+ # (Controller#start reopens the same queue via #reset).
83
+ @retry_seq = 0
84
+ # Deadline-sorted pending delayed entries (one per key, earliest
85
+ # deadline wins); the shared scheduler thread fires them
86
+ # oldest-deadline-first. @delayed_by_key gives O(1) duplicate lookup.
87
+ @delayed = []
88
+ @delayed_by_key = {}
89
+ @scheduler = nil
90
+ @scheduler_cond = ConditionVariable.new
91
+ end
92
+
93
+ def add(request)
94
+ @mutex.synchronize do
95
+ return if @closed
96
+
97
+ do_add(request)
98
+ end
99
+ end
100
+
101
+ # Schedules +request+ to be enqueued after +seconds+. The retry is owned
102
+ # by the shared scheduler: it is rejected while the queue is closed and
103
+ # is discarded (not enqueued) if the queue is shut down or reset before
104
+ # the deadline fires, so a retry from a previous lifecycle can never
105
+ # inject stale work after Controller#start reopens the queue. A second
106
+ # registration for a key that already has a pending entry is superseded
107
+ # (the earliest deadline wins) and returns false.
108
+ # Returns false when the queue is closed or nothing was scheduled; true
109
+ # otherwise.
110
+ def add_after(request, seconds)
111
+ @mutex.synchronize do
112
+ return false if @closed
113
+
114
+ entry = DelayEntry.new(monotonic_time + seconds, @retry_seq, request)
115
+ schedule_locked(entry)
116
+ end
117
+ end
118
+
119
+ # Re-queues +request+ after a delay decided by the rate limiter
120
+ # (controller-runtime's AddRateLimited). Requires a queue built with a
121
+ # rate_limiter. Does nothing (and records no backoff) when the queue is
122
+ # already closed.
123
+ def add_rate_limited(request)
124
+ raise ArgumentError, "WorkQueue#add_rate_limited requires a rate_limiter" unless @rate_limiter
125
+
126
+ @mutex.synchronize do
127
+ return false if @closed
128
+
129
+ delay = @rate_limiter.backoff(request.namespaced_name.to_s)
130
+ entry = DelayEntry.new(monotonic_time + delay, @retry_seq, request)
131
+ schedule_locked(entry)
132
+ end
133
+ end
134
+
135
+ # Shared enqueue logic; the caller must hold @mutex.
136
+ def do_add(request)
137
+ key = request.namespaced_name.to_s
138
+ if @in_flight.key?(key)
139
+ @dirty.add(key)
140
+ elsif !@pending_keys.include?(key)
141
+ @pending_keys.add(key)
142
+ @queue << request
143
+ end
144
+ @cond.signal
145
+ end
146
+
147
+ # Clears the rate limiter state for +request+'s key (controller-runtime's
148
+ # Forget); a no-op when the queue has no rate limiter.
149
+ def forget(request)
150
+ @rate_limiter&.forget(request.namespaced_name.to_s)
151
+ end
152
+
153
+ # Blocks until an item is available, atomically dequeueing it and
154
+ # moving its key from pending to in flight.
155
+ def get
156
+ @mutex.synchronize do
157
+ loop do
158
+ if @queue.empty?
159
+ return SENTINEL if @closed
160
+
161
+ @cond.wait(@mutex)
162
+ next
163
+ end
164
+
165
+ item = @queue.pop(true)
166
+ return item if item.equal?(SENTINEL)
167
+
168
+ key = item.namespaced_name.to_s
169
+ @pending_keys.delete(key)
170
+ @in_flight[key] = item
171
+ return item
172
+ end
173
+ end
174
+ end
175
+
176
+ # Marks a request as completed. Only the request object that is
177
+ # currently in flight for its key is considered; any other completion
178
+ # (a duplicate, or a stale one for an older copy) is ignored. An in
179
+ # flight, dirty key is re-queued with a fresh `Request` so the
180
+ # reconciler runs once more for the latest state.
181
+ def done(request)
182
+ return if request.equal?(SENTINEL)
183
+
184
+ @mutex.synchronize do
185
+ key = request.namespaced_name.to_s
186
+ current = @in_flight[key]
187
+ return unless current.equal?(request)
188
+
189
+ @in_flight.delete(key)
190
+ if @dirty.include?(key)
191
+ @dirty.delete(key)
192
+ namespace, name = key.split("/", 2)
193
+ @pending_keys.add(key)
194
+ @queue << Request.new(namespace: namespace.to_s, name: (name || "").to_s)
195
+ @cond.signal
196
+ end
197
+ end
198
+ end
199
+
200
+ def len
201
+ @mutex.synchronize { @queue.length }
202
+ end
203
+
204
+ def shutdown(num_workers = 1)
205
+ handle = nil
206
+ @mutex.synchronize do
207
+ return if @closed
208
+
209
+ @closed = true
210
+ # No delayed retry survives a shutdown: purge the entries and
211
+ # retire the shared scheduler thread. The handle (with its own
212
+ # stop flag) is captured under this lock, so a scheduler started
213
+ # by a registration that ran in this same lock is part of THIS
214
+ # retirement, and a scheduler started after the lock is released
215
+ # belongs to a later lifecycle and is never joined by this call.
216
+ @delayed.clear
217
+ @delayed_by_key.clear
218
+ handle = stop_current_scheduler
219
+ # Unblock any workers blocked in get
220
+ num_workers.times { @queue << SENTINEL }
221
+ @cond.broadcast
222
+ end
223
+ handle&.thread&.join
224
+ end
225
+
226
+ def shutdown?
227
+ @mutex.synchronize { @closed }
228
+ end
229
+
230
+ # Reopens the queue after shutdown, keeping any real pending requests
231
+ # and discarding leftover shutdown sentinels. The previous lifecycle's
232
+ # scheduler thread is retired (stopped and joined outside the lock);
233
+ # the next delayed retry lazily starts a fresh scheduler.
234
+ def reset
235
+ handle = nil
236
+ @mutex.synchronize do
237
+ pending = []
238
+ loop do
239
+ item = @queue.pop(true)
240
+ pending << item unless item.equal?(SENTINEL)
241
+ rescue ThreadError
242
+ break
243
+ end
244
+
245
+ @queue = ::Queue.new
246
+ pending.each { |item| @queue << item }
247
+ @pending_keys = Set.new(pending.map { |item| item.namespaced_name.to_s })
248
+ @in_flight = {}
249
+ @dirty = Set.new
250
+ @closed = false
251
+ # Invalidate any delayed retries scheduled in the previous lifecycle
252
+ # and drop their entries outright: every entry holds the previous
253
+ # seq, so purging is both correct and bounded. The old scheduler has
254
+ # nothing left to serve; retire it (joined below).
255
+ @retry_seq += 1
256
+ @delayed.clear
257
+ @delayed_by_key.clear
258
+ handle = stop_current_scheduler
259
+ @scheduler_cond.broadcast
260
+ @cond.broadcast
261
+ end
262
+ handle&.thread&.join
263
+ end
264
+
265
+ private
266
+
267
+ def monotonic_time
268
+ Process.clock_gettime(Process::CLOCK_MONOTONIC)
269
+ end
270
+
271
+ # Validates, dedupes, inserts and (lazily) starts the scheduler in ONE
272
+ # critical section: the caller holds @mutex, so a shutdown can never
273
+ # slip between the closed check and the insertion, and no scheduler is
274
+ # ever started for a closed queue.
275
+ def schedule_locked(entry)
276
+ return false if @closed
277
+ return false if entry.seq != @retry_seq
278
+
279
+ key = entry.request.namespaced_name.to_s
280
+ superseded = @delayed_by_key[key]
281
+ if superseded
282
+ # At most one pending delayed entry per key: the earliest deadline
283
+ # wins, so a later registration never produces a second copy.
284
+ return false if superseded.due_at <= entry.due_at
285
+
286
+ @delayed.delete(superseded)
287
+ @delayed_by_key.delete(key)
288
+ end
289
+
290
+ insert_deadline_sorted(entry)
291
+ @delayed_by_key[key] = entry
292
+ begin
293
+ start_scheduler unless @scheduler
294
+ rescue StandardError => e
295
+ # Startup failed: roll the queue back so a later registration can
296
+ # retry (an entry is never left silently unserved).
297
+ @delayed.delete(entry)
298
+ @delayed_by_key.delete(key)
299
+ if superseded
300
+ insert_deadline_sorted(superseded)
301
+ @delayed_by_key[key] = superseded
302
+ end
303
+ KrubyController.logger.warn("WorkQueue: delayed scheduler start failed: #{e.message}")
304
+ return false
305
+ end
306
+ # Wake the scheduler early only if the new entry is the earliest
307
+ # deadline; otherwise the current wait already governs.
308
+ @scheduler_cond.signal if @delayed.first.equal?(entry)
309
+ true
310
+ end
311
+
312
+ def insert_deadline_sorted(entry)
313
+ index = @delayed.bsearch_index { |e| e.due_at > entry.due_at } || @delayed.length
314
+ @delayed.insert(index, entry)
315
+ end
316
+
317
+ # Retires the current scheduler under the lock: sets ITS stop flag
318
+ # (per-scheduler state, so a fresh scheduler is unaffected) and hands
319
+ # the handle back for the caller to join outside the lock.
320
+ def stop_current_scheduler
321
+ handle = @scheduler
322
+ if handle
323
+ handle.stop_requested = true
324
+ @scheduler = nil
325
+ @scheduler_cond.broadcast
326
+ end
327
+ handle
328
+ end
329
+
330
+ def start_scheduler
331
+ handle = SchedulerHandle.new(nil, false)
332
+ handle.thread = Thread.new { scheduler_loop(handle) }
333
+ @scheduler = handle
334
+ end
335
+
336
+ def scheduler_loop(handle)
337
+ loop do
338
+ retire = false
339
+ @mutex.synchronize do
340
+ if handle.stop_requested
341
+ retire = true
342
+ elsif @delayed.empty?
343
+ @scheduler_cond.wait(@mutex)
344
+ else
345
+ now = monotonic_time
346
+ earliest = @delayed.first
347
+ if earliest.due_at > now
348
+ @scheduler_cond.wait(@mutex, earliest.due_at - now)
349
+ else
350
+ fire_due_entries(now)
351
+ end
352
+ end
353
+ end
354
+ return if retire
355
+ end
356
+ end
357
+
358
+ # Fires every entry whose deadline has passed, in deadline order. A
359
+ # fire is discarded when its retry lifecycle is stale (a queue reset
360
+ # happened in between) or the queue is closed. Otherwise it goes
361
+ # through the same do_add path as an immediate add, so dedupe, the
362
+ # in-flight dirty flag and the rate limiter all see one consistent
363
+ # state.
364
+ def fire_due_entries(now)
365
+ until @delayed.empty? || @delayed.first.due_at > now
366
+ entry = @delayed.shift
367
+ @delayed_by_key.delete(entry.request.namespaced_name.to_s)
368
+ next unless entry.seq == @retry_seq && !@closed
369
+
370
+ do_add(entry.request)
371
+ end
372
+ end
373
+ end
374
+ end
375
+ end
@@ -0,0 +1,18 @@
1
+ # frozen_string_literal: true
2
+
3
+ module KrubyController
4
+ class Reconciler
5
+ def reconcile(request)
6
+ raise NotImplementedError, "Subclass must implement reconcile(request)"
7
+ end
8
+
9
+ attr_writer :logger
10
+ def logger
11
+ @logger || KrubyController.logger
12
+ end
13
+
14
+ attr_accessor :cache
15
+ attr_accessor :api_client
16
+ attr_accessor :client
17
+ end
18
+ end
@@ -0,0 +1,59 @@
1
+ # frozen_string_literal: true
2
+
3
+ module KrubyController
4
+ class Request
5
+ attr_reader :namespace, :name
6
+
7
+ def initialize(namespace:, name:)
8
+ @namespace = namespace.to_s
9
+ @name = name.to_s
10
+ end
11
+
12
+ def namespaced_name
13
+ NamespacedName.new(@namespace, @name)
14
+ end
15
+
16
+ def ==(other)
17
+ return false unless other.is_a?(Request)
18
+
19
+ @namespace == other.namespace && @name == other.name
20
+ end
21
+ alias eql? ==
22
+
23
+ def hash
24
+ [@namespace, @name].hash
25
+ end
26
+
27
+ def inspect
28
+ "#<Request #{namespaced_name}>"
29
+ end
30
+
31
+ class NamespacedName
32
+ attr_reader :namespace, :name
33
+
34
+ def initialize(namespace, name)
35
+ @namespace = namespace
36
+ @name = name
37
+ end
38
+
39
+ def to_s
40
+ "#{@namespace}/#{@name}"
41
+ end
42
+
43
+ def hash
44
+ [@namespace, @name].hash
45
+ end
46
+
47
+ def ==(other)
48
+ return false unless other.is_a?(NamespacedName)
49
+
50
+ @namespace == other.namespace && @name == other.name
51
+ end
52
+ alias eql? ==
53
+
54
+ def inspect
55
+ "NamespacedName(#{self})"
56
+ end
57
+ end
58
+ end
59
+ end
@@ -0,0 +1,50 @@
1
+ # frozen_string_literal: true
2
+
3
+ module KrubyController
4
+ module Result
5
+ class Base
6
+ attr_reader :error
7
+ def initialize(error: nil)
8
+ @error = error
9
+ end
10
+ end
11
+
12
+ class Ok < Base
13
+ def self.ok(error: nil)
14
+ new(error:)
15
+ end
16
+ end
17
+
18
+ class RetryAfter < Base
19
+ attr_reader :after
20
+
21
+ def initialize(after:, error: nil)
22
+ raise ArgumentError, "after must be positive" unless after > 0
23
+ @after = after
24
+ super(error:)
25
+ end
26
+
27
+ def self.retry_after(seconds, error: nil)
28
+ new(after: seconds, error:)
29
+ end
30
+ end
31
+
32
+ class Requeue < Base
33
+ def self.requeue(error: nil)
34
+ new(error:)
35
+ end
36
+ end
37
+
38
+ def self.ok(error: nil)
39
+ Ok.ok(error:)
40
+ end
41
+
42
+ def self.retry_after(seconds, error: nil)
43
+ RetryAfter.retry_after(seconds, error:)
44
+ end
45
+
46
+ def self.requeue(error: nil)
47
+ Requeue.requeue(error:)
48
+ end
49
+ end
50
+ end
@@ -0,0 +1,29 @@
1
+ # frozen_string_literal: true
2
+
3
+ module KrubyController
4
+ module Status
5
+ class StatusUpdater
6
+ def initialize(client:, gvk:)
7
+ @client = client
8
+ @gvk = gvk
9
+ end
10
+
11
+ def update_status(obj, status_patch)
12
+ patched = deep_merge(obj, { "status" => status_patch })
13
+ @client.patch_status(patched)
14
+ end
15
+
16
+ def merge_status(obj, status_update)
17
+ current = obj.dig("status") || {}
18
+ merged = deep_merge(current, status_update)
19
+ update_status(obj, merged)
20
+ end
21
+
22
+ private
23
+
24
+ def deep_merge(h1, h2)
25
+ h1.merge(h2) { |_k, o, n| o.is_a?(Hash) && n.is_a?(Hash) ? deep_merge(o, n) : n }
26
+ end
27
+ end
28
+ end
29
+ end
@@ -0,0 +1,5 @@
1
+ # frozen_string_literal: true
2
+
3
+ module KrubyController
4
+ VERSION = "0.1.0"
5
+ end
@@ -0,0 +1,87 @@
1
+ # frozen_string_literal: true
2
+
3
+ require "kruby"
4
+ require "logger"
5
+
6
+ # KrubyController — Kubernetes Controller Framework for Ruby
7
+ #
8
+ # Provides controller-runtime equivalent functionality built on kruby:
9
+ # - Manager: orchestrates controllers, shared cache, leader election
10
+ # - Controller: reconcile loop with work queue
11
+ # - Reconciler: abstract class for user reconcile logic
12
+ # - SharedCache: informer-based local cache
13
+ # - Event Handler: watches → reconcile queue
14
+ # - Leader Election: Lease API based
15
+ # - CRD Generator: Ruby DSL → CRD YAML
16
+ # - CLI: scaffolding commands
17
+ #
18
+ # Example:
19
+ # class MyReconciler < KrubyController::Reconciler
20
+ # def reconcile(request)
21
+ # # your logic here
22
+ # KrubyController::Result.ok
23
+ # end
24
+ # end
25
+ #
26
+ # manager = KrubyController::Manager.new(kube_config: ENV["KUBECONFIG"])
27
+ # manager.add(MyReconciler, for: "MyResource")
28
+ # manager.start
29
+
30
+ module KrubyController
31
+ class Error < StandardError; end
32
+
33
+ # Core types
34
+ require_relative "kruby_controller/version"
35
+ require_relative "kruby_controller/logger"
36
+ require_relative "kruby_controller/gvk"
37
+ require_relative "kruby_controller/crd"
38
+ require_relative "kruby_controller/request"
39
+ require_relative "kruby_controller/result"
40
+ require_relative "kruby_controller/reconciler"
41
+
42
+ # Queue
43
+ require_relative "kruby_controller/queue/rate_limiter"
44
+ require_relative "kruby_controller/queue/work_queue"
45
+
46
+ # Cache
47
+ require_relative "kruby_controller/cache/delta"
48
+ require_relative "kruby_controller/cache/deep_copy"
49
+ require_relative "kruby_controller/cache/request_error"
50
+ require_relative "kruby_controller/cache/watch_stream"
51
+ require_relative "kruby_controller/cache/store"
52
+ require_relative "kruby_controller/cache/informer"
53
+ require_relative "kruby_controller/cache/cache"
54
+
55
+ # Handlers
56
+ require_relative "kruby_controller/handler/enqueued_object"
57
+ require_relative "kruby_controller/handler/enqueued_owner"
58
+ require_relative "kruby_controller/handler/predicated"
59
+
60
+ # Controller
61
+ require_relative "kruby_controller/controller"
62
+
63
+ # Leader Election
64
+ require_relative "kruby_controller/election/leader_elector"
65
+
66
+ # Manager
67
+ require_relative "kruby_controller/manager"
68
+
69
+ # Builders
70
+ require_relative "kruby_controller/builder/controller_builder"
71
+
72
+ # Helpers
73
+ require_relative "kruby_controller/kubernetes_object_client"
74
+ require_relative "kruby_controller/finalizer/finalizer_manager"
75
+ require_relative "kruby_controller/owner/owner_reference"
76
+ require_relative "kruby_controller/status/status_updater"
77
+
78
+ # CRD Generator
79
+ require_relative "kruby_controller/generator/crd_generator"
80
+
81
+ # CLI
82
+ require_relative "kruby_controller/cli/flag_parser"
83
+ require_relative "kruby_controller/cli/init_command"
84
+ require_relative "kruby_controller/cli/create_api_command"
85
+
86
+ private_constant :Error unless const_defined?(:Error, false)
87
+ end