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.
- checksums.yaml +7 -0
- data/LICENSE +201 -0
- data/README.md +117 -0
- data/Rakefile +8 -0
- data/exe/kruby-controller +32 -0
- data/lib/kruby-controller.rb +8 -0
- data/lib/kruby_controller/builder/controller_builder.rb +52 -0
- data/lib/kruby_controller/cache/cache.rb +100 -0
- data/lib/kruby_controller/cache/deep_copy.rb +32 -0
- data/lib/kruby_controller/cache/delta.rb +12 -0
- data/lib/kruby_controller/cache/informer.rb +453 -0
- data/lib/kruby_controller/cache/request_error.rb +55 -0
- data/lib/kruby_controller/cache/store.rb +92 -0
- data/lib/kruby_controller/cache/watch_stream.rb +144 -0
- data/lib/kruby_controller/cli/create_api_command.rb +335 -0
- data/lib/kruby_controller/cli/flag_parser.rb +85 -0
- data/lib/kruby_controller/cli/init_command.rb +383 -0
- data/lib/kruby_controller/controller.rb +200 -0
- data/lib/kruby_controller/crd.rb +141 -0
- data/lib/kruby_controller/election/leader_elector.rb +212 -0
- data/lib/kruby_controller/finalizer/finalizer_manager.rb +31 -0
- data/lib/kruby_controller/generator/crd_generator.rb +109 -0
- data/lib/kruby_controller/gvk.rb +59 -0
- data/lib/kruby_controller/handler/enqueued_object.rb +18 -0
- data/lib/kruby_controller/handler/enqueued_owner.rb +51 -0
- data/lib/kruby_controller/handler/predicated.rb +21 -0
- data/lib/kruby_controller/kubernetes_object_client.rb +77 -0
- data/lib/kruby_controller/logger.rb +11 -0
- data/lib/kruby_controller/manager.rb +291 -0
- data/lib/kruby_controller/owner/owner_reference.rb +23 -0
- data/lib/kruby_controller/queue/rate_limiter.rb +51 -0
- data/lib/kruby_controller/queue/work_queue.rb +375 -0
- data/lib/kruby_controller/reconciler.rb +18 -0
- data/lib/kruby_controller/request.rb +59 -0
- data/lib/kruby_controller/result.rb +50 -0
- data/lib/kruby_controller/status/status_updater.rb +29 -0
- data/lib/kruby_controller/version.rb +5 -0
- data/lib/kruby_controller.rb +87 -0
- 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,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
|