legion-crypt 1.5.38 → 1.6.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 (45) hide show
  1. checksums.yaml +4 -4
  2. data/.github/workflows/ci.yml +30 -3
  3. data/.rspec +2 -0
  4. data/AGENTS.md +2 -0
  5. data/CHANGELOG.md +99 -0
  6. data/CLAUDE.md +65 -192
  7. data/CODEOWNERS +4 -4
  8. data/Gemfile +4 -1
  9. data/README.md +60 -16
  10. data/legion-crypt.gemspec +1 -0
  11. data/lib/legion/crypt/cert_rotation.rb +7 -21
  12. data/lib/legion/crypt/cluster_secret.rb +3 -14
  13. data/lib/legion/crypt/ed25519.rb +2 -10
  14. data/lib/legion/crypt/erasure.rb +3 -13
  15. data/lib/legion/crypt/jwks_client.rb +4 -4
  16. data/lib/legion/crypt/lease_manager.rb +5 -831
  17. data/lib/legion/crypt/mtls.rb +8 -46
  18. data/lib/legion/crypt/partition_keys.rb +2 -6
  19. data/lib/legion/crypt/settings.rb +31 -21
  20. data/lib/legion/crypt/spiffe/svid_rotation.rb +6 -9
  21. data/lib/legion/crypt/spiffe.rb +14 -39
  22. data/lib/legion/crypt/vault/auth/jwt.rb +28 -0
  23. data/lib/legion/crypt/vault/auth/kerberos.rb +60 -0
  24. data/lib/legion/crypt/vault/auth/ldap.rb +29 -0
  25. data/lib/legion/crypt/vault/auth.rb +50 -0
  26. data/lib/legion/crypt/vault/client.rb +362 -0
  27. data/lib/legion/crypt/vault/cluster.rb +262 -0
  28. data/lib/legion/crypt/vault/entity.rb +79 -0
  29. data/lib/legion/crypt/vault/leases.rb +871 -0
  30. data/lib/legion/crypt/vault/operation.rb +29 -0
  31. data/lib/legion/crypt/vault/session.rb +405 -0
  32. data/lib/legion/crypt/vault.rb +21 -31
  33. data/lib/legion/crypt/version.rb +1 -1
  34. data/lib/legion/crypt.rb +152 -177
  35. metadata +27 -11
  36. data/lib/legion/crypt/kerberos_auth.rb +0 -119
  37. data/lib/legion/crypt/ldap_auth.rb +0 -48
  38. data/lib/legion/crypt/token_renewer.rb +0 -318
  39. data/lib/legion/crypt/vault_client.rb +0 -355
  40. data/lib/legion/crypt/vault_cluster.rb +0 -331
  41. data/lib/legion/crypt/vault_entity.rb +0 -78
  42. data/lib/legion/crypt/vault_jwt_auth.rb +0 -97
  43. data/lib/legion/crypt/vault_kerberos_auth.rb +0 -51
  44. data/lib/legion/crypt/vault_operation.rb +0 -27
  45. /data/lib/legion/crypt/{vault_renewer.rb → vault/renewer.rb} +0 -0
@@ -0,0 +1,29 @@
1
+ # frozen_string_literal: true
2
+
3
+ require 'timeout'
4
+ require 'legion/crypt/settings'
5
+
6
+ module Legion
7
+ module Crypt
8
+ module Vault
9
+ module Operation
10
+ DEFAULT_TIMEOUT = 5
11
+ SHUTDOWN_TIMEOUT = 10
12
+
13
+ def self.with_timeout(deadline: nil, **)
14
+ timeout = Legion::Settings[:crypt][:vault][:operation_timeout]
15
+ raise ArgumentError, 'Vault operation_timeout must be a finite positive number' unless timeout.is_a?(Numeric) && timeout.finite? && timeout.positive?
16
+
17
+ if deadline
18
+ remaining = deadline - ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
19
+ raise Timeout::Error, 'Vault operation deadline expired' unless remaining.positive?
20
+
21
+ timeout = [timeout, remaining].min
22
+ end
23
+ operation_deadline = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + timeout
24
+ Timeout.timeout(timeout) { yield(operation_deadline) }
25
+ end
26
+ end
27
+ end
28
+ end
29
+ end
@@ -0,0 +1,405 @@
1
+ # frozen_string_literal: true
2
+
3
+ require 'time'
4
+ require 'faraday'
5
+ require 'legion/logging/helper'
6
+ require 'legion/crypt/vault/client'
7
+ require 'legion/crypt/vault/auth'
8
+ require 'legion/crypt/vault/leases'
9
+ require 'legion/crypt/vault/operation'
10
+
11
+ module Legion
12
+ module Crypt
13
+ module Vault
14
+ # Owns one cluster's token + leases lifecycle. Holds the current grant (the login auth
15
+ # response — the source of truth for the token's identity and lifetime) directly, so renewal
16
+ # and revocation work for both minted (auth-method) and adopted (static/config) tokens.
17
+ # Network I/O runs outside @state_mutex; only state transitions hold it briefly, so a
18
+ # concurrent request_stop is never blocked behind a network call. One instance per cluster.
19
+ class Session
20
+ include Legion::Logging::Helper
21
+
22
+ RENEWAL_RATIO = 0.75
23
+ INITIAL_BACKOFF = 30
24
+ MAX_BACKOFF = 600
25
+ MINIMUM_WAIT = 0.01
26
+ RENEWAL_CHECK_INTERVAL = 5
27
+ RETRYABLE_CODES = [408, 429].freeze
28
+ STANDBY_CODES = [429, 472, 473].freeze # standby, DR secondary, performance standby
29
+ FAILURES = [IOError, SystemCallError, Timeout::Error, Faraday::Error,
30
+ Legion::Crypt::Vault::HTTPError].freeze
31
+
32
+ attr_reader :cluster_name, :client
33
+
34
+ def initialize(cluster_name:, client:, leases: nil, lease_defs: nil, **)
35
+ @cluster_name = cluster_name
36
+ @client = client
37
+ @leases = leases
38
+ @lease_defs = lease_defs
39
+ @auth = nil
40
+ @auth_method = nil
41
+ @grant = nil
42
+ @current_token = nil
43
+ @lease_duration = 0
44
+ @renewable = false
45
+ @expires_at = nil
46
+ @rejected = false
47
+ @disconnected = false
48
+ @backoff = INITIAL_BACKOFF
49
+ @minted = false
50
+ @stop = false
51
+ @started = false
52
+ @thread = nil
53
+ @state_mutex = Mutex.new
54
+ @wake = ConditionVariable.new
55
+ end
56
+
57
+ # Kerberos and static-token clusters authenticate at start; LDAP/JWT wait for an explicit login.
58
+ def start(**)
59
+ return false unless begin_lifecycle
60
+
61
+ @auth_method = cluster_config[:auth_method]&.to_s
62
+ authenticate if @auth_method == 'kerberos'
63
+ adopt_config_token if @auth_method.nil? || @auth_method.empty?
64
+ start_maintenance
65
+ true
66
+ rescue Legion::Crypt::Vault::Auth::AuthError, *FAILURES => e
67
+ handle_exception(e, level: :error, operation: 'crypt.vault_session.start', cluster_name: @cluster_name)
68
+ false
69
+ end
70
+
71
+ # Explicit LDAP/JWT login. Returns the grant Hash (the pre-refactor ldap_login contract);
72
+ # a failed login raises to the caller, which owns reporting it.
73
+ def login(**creds)
74
+ return nil if stopped?
75
+
76
+ grant = auth.authenticate(client: @client, **creds)
77
+ commit_grant(grant: grant, minted: true)
78
+ start_maintenance
79
+ grant_hash
80
+ end
81
+
82
+ # Stops the maintenance thread, shuts down the leases, and then revokes a MINTED (auth-method)
83
+ # token. An adopted static/config token is never revoked — it belongs to the operator.
84
+ # Returns whether the leases and the token were actually cleaned up in Vault.
85
+ def stop(deadline:, **)
86
+ request_stop
87
+ thread = @state_mutex.synchronize { @thread }
88
+ if thread && thread != Thread.current
89
+ remaining = deadline - ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
90
+ thread.join(remaining) if remaining.positive?
91
+ end
92
+ leases_released = @leases.nil? || @leases.shutdown(deadline: deadline)
93
+ token_released = !@state_mutex.synchronize { @minted && revocable_locked? } || revoke_token
94
+ if leases_released && token_released
95
+ log.info "Vault session stopped cluster=#{label}"
96
+ else
97
+ log.error "Vault session stopped with incomplete cleanup cluster=#{label} leases=#{leases_released} token=#{token_released}"
98
+ end
99
+ leases_released && token_released
100
+ end
101
+
102
+ # Signals the maintenance thread to stop. Public so Legion::Crypt.shutdown can request an
103
+ # early stop without racing the lifecycle lock across a network call.
104
+ def request_stop
105
+ @state_mutex.synchronize do
106
+ @stop = true
107
+ @wake.broadcast
108
+ end
109
+ @leases&.request_stop
110
+ nil
111
+ end
112
+
113
+ def running?
114
+ @state_mutex.synchronize { @thread&.alive? == true }
115
+ end
116
+
117
+ def revocable?
118
+ @state_mutex.synchronize { revocable_locked? }
119
+ end
120
+
121
+ def principal
122
+ @state_mutex.synchronize { @grant&.metadata&.dig(:username) }
123
+ end
124
+
125
+ # Called (as a 0-arg callable or with a block) to test/drive work while this session is the
126
+ # live grant owner. Used by Vault::Leases#reissue_all during the handoff.
127
+ def grant_active
128
+ @state_mutex.synchronize do
129
+ next false if @stop || !@started || crypt_stopping?
130
+
131
+ yield if block_given?
132
+ true
133
+ end
134
+ end
135
+
136
+ private
137
+
138
+ def label
139
+ @cluster_name || 'default'
140
+ end
141
+
142
+ def crypt_stopping?
143
+ Legion::Crypt.respond_to?(:stopping) && Legion::Crypt.stopping
144
+ end
145
+
146
+ def cluster_config
147
+ vault = Legion::Settings[:crypt][:vault]
148
+ @cluster_name ? vault[:clusters].fetch(@cluster_name) : vault
149
+ end
150
+
151
+ def auth
152
+ @auth ||= case cluster_config[:auth_method]&.to_s
153
+ when 'kerberos' then Legion::Crypt::Vault::Auth::Kerberos.new(cluster_name: @cluster_name)
154
+ when 'ldap' then Legion::Crypt::Vault::Auth::LDAP.new(cluster_name: @cluster_name)
155
+ when 'jwt' then Legion::Crypt::Vault::Auth::JWT.new(cluster_name: @cluster_name)
156
+ else
157
+ raise ArgumentError, "unsupported Vault auth_method: #{cluster_config[:auth_method].inspect}"
158
+ end
159
+ end
160
+
161
+ def stopped?
162
+ @state_mutex.synchronize { @stop }
163
+ end
164
+
165
+ def begin_lifecycle
166
+ @state_mutex.synchronize do
167
+ return false if @stop || @started
168
+
169
+ @started = true
170
+ true
171
+ end
172
+ end
173
+
174
+ def revocable_locked?
175
+ !@rejected && (@expires_at.nil? || @expires_at > Time.now)
176
+ end
177
+
178
+ # Network auth runs outside the mutex; the grant commit is a brief mutex hold.
179
+ def authenticate
180
+ grant = auth.authenticate(client: @client)
181
+ commit_grant(grant: grant, minted: true)
182
+ end
183
+
184
+ # Adopts a pre-configured (static) token once Vault answers a health check. It is non-minted,
185
+ # so it is never revoked on stop, and it is renewed only if its configuration says renewable.
186
+ def adopt_config_token
187
+ token = cluster_config[:token]
188
+ return if token.nil?
189
+
190
+ @auth_method = 'token'
191
+ return Legion::Crypt.disconnect_vault_grant(cluster_name: @cluster_name, token: token, relogin_required: false) unless cluster_healthy?
192
+
193
+ grant = Legion::Crypt::Vault::Client::Auth.new(data: { client_token: token,
194
+ lease_duration: cluster_config[:lease_duration],
195
+ renewable: cluster_config[:renewable] })
196
+ commit_grant(grant: grant, minted: false)
197
+ end
198
+
199
+ # Brief mutex hold: installs the grant as current and publishes it to the cluster config.
200
+ # previous_token guards against a concurrent token change; nil bypasses it (a first auth or a
201
+ # rollback restore). Returns the current token, or nil when the session is stopping.
202
+ def commit_grant(grant:, minted:, previous_token: nil, issued_at: Time.now)
203
+ @state_mutex.synchronize do
204
+ return if @stop
205
+
206
+ @grant = grant
207
+ @minted = minted
208
+ @disconnected = false
209
+ @rejected = false
210
+ @backoff = INITIAL_BACKOFF
211
+ @current_token = grant.client_token
212
+ @lease_duration = grant.lease_duration.to_f
213
+ @renewable = grant.renewable?
214
+ @expires_at = Legion::Crypt.publish_vault_grant(cluster_name: @cluster_name, client: @client, grant: grant_hash,
215
+ auth_method: @auth_method, issued_at: issued_at,
216
+ current_token: previous_token)
217
+ @current_token
218
+ end
219
+ end
220
+
221
+ def grant_hash
222
+ g = @grant
223
+ { token: g.client_token, lease_duration: g.lease_duration, renewable: g.renewable?,
224
+ policies: g.policies, metadata: g.metadata }
225
+ end
226
+
227
+ def cluster_healthy?
228
+ Legion::Crypt::Vault::Operation.with_timeout { @client.sys.health_status.initialized? }
229
+ rescue Legion::Crypt::Vault::HTTPError => e
230
+ return true if STANDBY_CODES.include?(e.code)
231
+
232
+ handle_exception(e, level: :error, operation: 'crypt.vault_session.health', cluster_name: @cluster_name)
233
+ false
234
+ end
235
+
236
+ def start_maintenance
237
+ return if stopped? || @state_mutex.synchronize { @current_token.nil? }
238
+
239
+ if @leases
240
+ @leases.start(definitions: @lease_defs, client: @client)
241
+ @leases.start_renewal_thread
242
+ end
243
+ @state_mutex.synchronize do
244
+ return if @stop || @thread&.alive?
245
+
246
+ @thread = Thread.new { maintenance_loop }
247
+ @thread.name = "vault-session-#{label}"
248
+ end
249
+ end
250
+
251
+ def maintenance_loop
252
+ return unless @state_mutex.synchronize { @expires_at }
253
+
254
+ wait(renewal_delay)
255
+ while grant_active
256
+ case maintain_token
257
+ when :renewed
258
+ @state_mutex.synchronize { @backoff = INITIAL_BACKOFF }
259
+ wait(renewal_delay)
260
+ when :pending
261
+ wait(renewal_delay)
262
+ when :failed
263
+ wait(retry_delay)
264
+ else
265
+ break
266
+ end
267
+ end
268
+ end
269
+
270
+ # Renewal is attempted only when Vault's last auth response said the token is renewable.
271
+ # A token that cannot be renewed is replaced by re-authentication (Kerberos) ahead of its
272
+ # expiry, or left to expire and disconnect (LDAP/JWT/static).
273
+ def maintain_token
274
+ expired, renewable = @state_mutex.synchronize do
275
+ return :finished if @expires_at.nil?
276
+
277
+ [@expires_at <= Time.now, @renewable]
278
+ end
279
+ if renewable && !expired
280
+ outcome = renew_token
281
+ return outcome unless outcome == :rejected
282
+ elsif !expired && !reauthable?
283
+ return :pending
284
+ end
285
+ return handoff if reauthable?
286
+
287
+ disconnect_token(reason: 'expired')
288
+ :finished
289
+ end
290
+
291
+ def reauthable?
292
+ @auth&.can_reauth? == true
293
+ end
294
+
295
+ # Renewal uses the client directly so it works for both minted and adopted (static) tokens.
296
+ def renew_token
297
+ deadline, minted, previous_token = @state_mutex.synchronize do
298
+ remaining = @expires_at ? @expires_at - Time.now : 0
299
+ [::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + [remaining, 0].max, @minted, @current_token]
300
+ end
301
+ renewed = Legion::Crypt::Vault::Operation.with_timeout(deadline: deadline) { @client.auth_token.renew_self }&.auth
302
+ raise Legion::Crypt::Vault::Auth::AuthError, 'Vault token renewal returned no auth data' if renewed.nil?
303
+
304
+ commit_grant(grant: renewed, minted: minted, previous_token: previous_token)
305
+ log.info "Vault token renewed cluster=#{label} ttl=#{@state_mutex.synchronize { @lease_duration }}s"
306
+ :renewed
307
+ rescue Legion::Crypt::Vault::GrantRejectedError => e
308
+ handle_exception(e, level: :error, operation: 'crypt.vault_session.renew', cluster_name: @cluster_name)
309
+ :finished
310
+ rescue *FAILURES, Legion::Crypt::Vault::Auth::AuthError => e
311
+ handle_exception(e, level: :error, operation: 'crypt.vault_session.renew', cluster_name: @cluster_name)
312
+ rejected = e.is_a?(Legion::Crypt::Vault::HTTPClientError) && !RETRYABLE_CODES.include?(e.code)
313
+ @state_mutex.synchronize { @rejected = true } if rejected
314
+ rejected ? :rejected : :failed
315
+ end
316
+
317
+ # The atomic re-auth handoff: re-auth, publish the candidate grant, reissue the leases under
318
+ # it, then commit (commit the expiry, revoke the old token) or roll back (revoke the
319
+ # candidate, restore the prior grant and its expiry).
320
+ def handoff
321
+ old_grant, old_expires, old_minted = @state_mutex.synchronize { [@grant, @expires_at, @minted] }
322
+ candidate = @auth.reauth(client: @client)
323
+ committed = grant_active && commit_grant(grant: candidate, minted: true, previous_token: old_grant.client_token)
324
+ recovered = committed && (@leases.nil? || @leases.reissue_all(client: @client, active: method(:grant_active)))
325
+ if recovered && grant_active
326
+ revoke_token(token: old_grant.client_token)
327
+ log.info "Vault token re-authenticated cluster=#{label} ttl=#{candidate.lease_duration}s"
328
+ return :renewed
329
+ end
330
+ revoke_token(token: candidate.client_token)
331
+ return :finished unless committed
332
+
333
+ commit_grant(grant: old_grant, minted: old_minted, issued_at: old_expires - old_grant.lease_duration.to_f)
334
+ log.error "Vault token re-auth incomplete cluster=#{label}; previous token retained"
335
+ :failed
336
+ rescue Legion::Crypt::Vault::GrantRejectedError => e
337
+ handle_exception(e, level: :error, operation: 'crypt.vault_session.handoff', cluster_name: @cluster_name)
338
+ :finished
339
+ rescue *FAILURES, Legion::Crypt::Vault::Auth::AuthError => e
340
+ handle_exception(e, level: :error, operation: 'crypt.vault_session.handoff', cluster_name: @cluster_name)
341
+ :failed
342
+ end
343
+
344
+ def disconnect_token(reason:)
345
+ @state_mutex.synchronize do
346
+ return if @disconnected
347
+
348
+ @disconnected = true
349
+ Legion::Crypt.disconnect_vault_grant(cluster_name: @cluster_name, token: @current_token,
350
+ relogin_required: !reauthable?)
351
+ log.error "Vault token #{reason} cluster=#{label}; #{reauthable? ? 're-authentication pending' : 'login required'}"
352
+ end
353
+ end
354
+
355
+ # Returns whether the token is gone from Vault; a failed revocation is reported, not hidden.
356
+ def revoke_token(token: @state_mutex.synchronize { @current_token })
357
+ return true if token.nil?
358
+
359
+ Legion::Crypt.revoke_vault_token(client: @client, token: token)
360
+ true
361
+ rescue *FAILURES => e
362
+ handle_exception(e, level: :error, operation: 'crypt.vault_session.revoke', cluster_name: @cluster_name,
363
+ outcome: 'incomplete')
364
+ false
365
+ end
366
+
367
+ def renewal_delay
368
+ @state_mutex.synchronize do
369
+ return RENEWAL_CHECK_INTERVAL if @expires_at.nil?
370
+
371
+ remaining = @expires_at - Time.now
372
+ delay = @renewable || reauthable? ? remaining - (@lease_duration * (1 - RENEWAL_RATIO)) : remaining
373
+ [delay, MINIMUM_WAIT].max
374
+ end
375
+ end
376
+
377
+ def retry_delay
378
+ @state_mutex.synchronize do
379
+ delay = @backoff
380
+ @backoff = [@backoff * 2, MAX_BACKOFF].min
381
+
382
+ remaining = @expires_at ? @expires_at - Time.now : 0
383
+ return delay if remaining <= 0
384
+
385
+ floor = remaining / 2
386
+ floor = MINIMUM_WAIT if floor < MINIMUM_WAIT
387
+ [delay, floor].min
388
+ end
389
+ end
390
+
391
+ def wait(seconds)
392
+ deadline = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + seconds
393
+ @state_mutex.synchronize do
394
+ until @stop
395
+ remaining = deadline - ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
396
+ break unless remaining.positive?
397
+
398
+ @wake.wait(@state_mutex, remaining)
399
+ end
400
+ end
401
+ end
402
+ end
403
+ end
404
+ end
405
+ end
@@ -1,8 +1,11 @@
1
1
  # frozen_string_literal: true
2
2
 
3
3
  require 'legion/logging/helper'
4
- require 'legion/crypt/vault_operation'
5
- require 'legion/crypt/vault_client'
4
+ require 'legion/crypt/vault/operation'
5
+ require 'legion/crypt/vault/client'
6
+ require 'legion/crypt/vault/auth'
7
+ require 'legion/crypt/vault/leases'
8
+ require 'legion/crypt/vault/session'
6
9
 
7
10
  module Legion
8
11
  module Crypt
@@ -11,15 +14,10 @@ module Legion
11
14
 
12
15
  attr_accessor :sessions
13
16
 
14
- def settings
15
- Legion::Settings[:crypt][:vault]
16
- end
17
-
18
17
  def connect_vault
19
18
  return unless start_session_tracking
20
19
 
21
20
  configuration = Legion::Settings[:crypt][:vault]
22
- configuration[:token] = ENV['VAULT_DEV_ROOT_TOKEN_ID'] if ENV.key? 'VAULT_DEV_ROOT_TOKEN_ID'
23
21
  return nil if configuration[:token].nil?
24
22
 
25
23
  client = vault_client
@@ -118,8 +116,9 @@ module Legion
118
116
  end
119
117
  end
120
118
 
121
- def close_sessions(deadline: nil)
122
- deadline ||= ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + VaultOperation::SHUTDOWN_TIMEOUT
119
+ # Revokes every tracked session until the deadline or a token rejection; returns whether all were revoked.
120
+ def close_sessions(deadline: nil, denied_clients: {}.compare_by_identity, **)
121
+ deadline ||= ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + Legion::Crypt::Vault::Operation::SHUTDOWN_TIMEOUT
123
122
  pending = session_mutex.synchronize do
124
123
  @sessions_stopped = true
125
124
  @session_generation = (@session_generation || 0) + 1
@@ -127,17 +126,24 @@ module Legion
127
126
  @sessions = []
128
127
  detached
129
128
  end
129
+ return true if pending.empty?
130
+
130
131
  log.info 'Closing all Legion::Crypt vault sessions'
131
- closed = []
132
+ client = vault_client
133
+ closed = 0
132
134
  pending.each do |session|
133
- break if ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) >= deadline
135
+ break if ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) >= deadline || denied_clients.key?(client)
134
136
 
135
- VaultOperation.with_timeout(deadline: deadline) { close_session(session: session) }
136
- closed << session
137
+ Legion::Crypt::Vault::Operation.with_timeout(deadline: deadline) { close_session(session: session) }
138
+ closed += 1
137
139
  rescue StandardError => e
140
+ denied_clients[client] = true if e.is_a?(Legion::Crypt::Vault::HTTPClientError) && e.code == 403
138
141
  handle_exception(e, level: :error, operation: 'crypt.vault.close_session')
139
142
  end
140
- closed
143
+ return true if closed == pending.size
144
+
145
+ log.error "Vault session cleanup incomplete: #{pending.size - closed} of #{pending.size} session(s) not revoked"
146
+ false
141
147
  end
142
148
 
143
149
  def shutdown_renewer
@@ -169,13 +175,11 @@ module Legion
169
175
  [@session_generation, (@sessions || []).dup]
170
176
  end
171
177
  log.debug 'Vault renewal cycle start'
172
- return renew_cluster_tokens(generation: generation) if respond_to?(:connected_clusters) && connected_clusters.any?
173
-
174
178
  renewed = []
175
179
  pending.each do |session|
176
180
  break unless session_maintenance_active?(generation: generation)
177
181
 
178
- VaultOperation.with_timeout { renew_session(session: session) }
182
+ Legion::Crypt::Vault::Operation.with_timeout { renew_session(session: session) }
179
183
  renewed << session
180
184
  rescue StandardError => e
181
185
  handle_exception(e, level: :error, operation: 'crypt.vault.renew_session')
@@ -187,20 +191,6 @@ module Legion
187
191
  raise
188
192
  end
189
193
 
190
- def renew_cluster_tokens(generation: session_mutex.synchronize { @session_generation })
191
- renewed = []
192
- connected_clusters.each_key do |name|
193
- break unless session_maintenance_active?(generation: generation)
194
-
195
- VaultOperation.with_timeout { vault_client(name).auth_token.renew_self }
196
- renewed << name
197
- log.info "Vault token renewed for cluster #{name}"
198
- rescue StandardError => e
199
- log_vault_error(name, e)
200
- end
201
- renewed
202
- end
203
-
204
194
  def vault_exists?(name)
205
195
  vault_client.sys.mounts.key?(name.to_sym)
206
196
  end
@@ -2,6 +2,6 @@
2
2
 
3
3
  module Legion
4
4
  module Crypt
5
- VERSION = '1.5.38'
5
+ VERSION = '1.6.0'
6
6
  end
7
7
  end