Class: Controlplane

Inherits:
Object
  • Object
show all
Defined in:
lib/core/controlplane.rb

Overview

rubocop:disable Metrics/ClassLength

Constant Summary collapse

NO_IMAGE_AVAILABLE = 
"NO_IMAGE_AVAILABLE"

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(config) ⇒ Controlplane

Returns a new instance of Controlplane.



8
9
10
11
12
13
14
15
 
# File 'lib/core/controlplane.rb', line 8

def initialize(config)
  @config = config
  @api = ControlplaneApi.new
  @gvc = config.app
  @org = config.org

  ensure_org_exists! if org
end

Instance Attribute Details

#api ⇒ Object (readonly)

Returns the value of attribute api.



4
5
6
 
# File 'lib/core/controlplane.rb', line 4

def api
  @api
end

#config ⇒ Object (readonly)

Returns the value of attribute config.



4
5
6
 
# File 'lib/core/controlplane.rb', line 4

def config
  @config
end

#gvc ⇒ Object (readonly)

Returns the value of attribute gvc.



4
5
6
 
# File 'lib/core/controlplane.rb', line 4

def gvc
  @gvc
end

#org ⇒ Object (readonly)

Returns the value of attribute org.



4
5
6
 
# File 'lib/core/controlplane.rb', line 4

def org
  @org
end

Instance Method Details

#apply_hash(data) ⇒ Object 



428
429
430
 
# File 'lib/core/controlplane.rb', line 428

def apply_hash(data)
  apply_template(data.to_yaml)
end

#apply_template(data) ⇒ Object

apply



403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
 
# File 'lib/core/controlplane.rb', line 403

def apply_template(data) # rubocop:disable Metrics/MethodLength
  Tempfile.create do |f|
    f.write(data)
    f.rewind
    cmd = "cpln apply #{gvc_org} --file #{f.path}"
    if Shell.tmp_stderr
      cmd += " 2> #{Shell.tmp_stderr.path}" if Shell.should_hide_output?

      Shell.debug("CMD", cmd)

      result = Shell.cmd(cmd)
      parse_apply_result(result[:output]) if result[:success]
    else
      Shell.debug("CMD", cmd)

      result = Shell.cmd(cmd)
      if result[:success]
        parse_apply_result(result[:output])
      else
        Shell.abort("Command exited with non-zero status.")
      end
    end
  end
end

#bind_identity_to_policy(identity_link, policy) ⇒ Object 



392
393
394
395
 
# File 'lib/core/controlplane.rb', line 392

def bind_identity_to_policy(identity_link, policy)
  cmd = "cpln policy add-binding #{policy} --org #{org} --identity #{identity_link} --permission reveal"
  perform!(cmd)
end

#cron_workload_deployed_version(workload) ⇒ Object 



297
298
299
300
301
302
303
304
305
 
# File 'lib/core/controlplane.rb', line 297

def cron_workload_deployed_version(workload)
  current_deployment = fetch_workload_deployments(workload)&.dig("items")&.first
  return nil unless current_deployment

  ready = current_deployment.dig("status", "ready")
  last_processed_version = current_deployment.dig("status", "lastProcessedVersion")

  ready ? last_processed_version : nil
end

#delete_volumeset(volumeset, a_gvc = gvc) ⇒ Object 



313
314
315
 
# File 'lib/core/controlplane.rb', line 313

def delete_volumeset(volumeset, a_gvc = gvc)
  api.delete_volumeset(org: org, gvc: a_gvc, volumeset: volumeset)
end

#delete_workload(workload, a_gvc = gvc) ⇒ Object 



264
265
266
 
# File 'lib/core/controlplane.rb', line 264

def delete_workload(workload, a_gvc = gvc)
  api.delete_workload(org: org, gvc: a_gvc, workload: workload)
end

#domain_workload_matches?(data, workload) ⇒ Boolean

Returns:

  • (Boolean) 


347
348
349
350
 
# File 'lib/core/controlplane.rb', line 347

def domain_workload_matches?(data, workload)
  route = find_domain_route(data)
  route["workloadLink"].match?(%r{/org/#{org}/gvc/#{gvc}/workload/#{workload}})
end

#extract_image_commit(image_name) ⇒ Object 



83
84
85
 
# File 'lib/core/controlplane.rb', line 83

def extract_image_commit(image_name)
  image_name.match(/_(\h+)$/)&.captures&.first
end

#extract_image_number(image_name) ⇒ Object 



77
78
79
80
81
 
# File 'lib/core/controlplane.rb', line 77

def extract_image_number(image_name)
  return 0 if image_name.end_with?(NO_IMAGE_AVAILABLE)

  image_name.match(/:(\d+)/)&.captures&.first.to_i
end

#fetch_cron_workload(workload, location:) ⇒ Object 



292
293
294
295
 
# File 'lib/core/controlplane.rb', line 292

def fetch_cron_workload(workload, location:)
  cmd = "cpln workload cron get #{workload} #{gvc_org} --location #{location} -o yaml"
  perform_yaml(cmd)
end

#fetch_domain(domain) ⇒ Object 



339
340
341
342
343
344
345
 
# File 'lib/core/controlplane.rb', line 339

def fetch_domain(domain)
  domain_data = api.fetch_domain(org: org, domain: domain)
  route = find_domain_route(domain_data)
  return nil if route.nil?

  domain_data
end

#fetch_gvc(a_gvc = gvc, a_org = org) ⇒ Object 



151
152
153
 
# File 'lib/core/controlplane.rb', line 151

def fetch_gvc(a_gvc = gvc, a_org = org)
  api.gvc_get(gvc: a_gvc, org: a_org)
end

#fetch_gvc!(a_gvc = gvc) ⇒ Object 



155
156
157
158
159
160
 
# File 'lib/core/controlplane.rb', line 155

def fetch_gvc!(a_gvc = gvc)
  gvc_data = fetch_gvc(a_gvc)
  return gvc_data if gvc_data

  raise "Can't find app '#{gvc}', please create it with 'cpl setup-app -a #{config.app}'."
end

#fetch_gvcs ⇒ Object

gvc



138
139
140
 
# File 'lib/core/controlplane.rb', line 138

def fetch_gvcs
  api.gvc_list(org: org)
end

#fetch_identity(identity, a_gvc = gvc) ⇒ Object

identities



382
383
384
 
# File 'lib/core/controlplane.rb', line 382

def fetch_identity(identity, a_gvc = gvc)
  api.fetch_identity(org: org, gvc: a_gvc, identity: identity)
end

#fetch_image_details(image) ⇒ Object 



108
109
110
 
# File 'lib/core/controlplane.rb', line 108

def fetch_image_details(image)
  api.fetch_image_details(org: org, image: image)
end

#fetch_policy(policy) ⇒ Object

policies



388
389
390
 
# File 'lib/core/controlplane.rb', line 388

def fetch_policy(policy)
  api.fetch_policy(org: org, policy: policy)
end

#fetch_secret(secret) ⇒ Object

secrets



376
377
378
 
# File 'lib/core/controlplane.rb', line 376

def fetch_secret(secret)
  api.fetch_secret(org: org, secret: secret)
end

#fetch_volumesets(a_gvc = gvc) ⇒ Object

volumeset



309
310
311
 
# File 'lib/core/controlplane.rb', line 309

def fetch_volumesets(a_gvc = gvc)
  api.list_volumesets(org: org, gvc: a_gvc)
end

#fetch_workload(workload) ⇒ Object 



176
177
178
 
# File 'lib/core/controlplane.rb', line 176

def fetch_workload(workload)
  api.workload_get(workload: workload, gvc: gvc, org: org)
end

#fetch_workload!(workload) ⇒ Object 



180
181
182
183
184
185
 
# File 'lib/core/controlplane.rb', line 180

def fetch_workload!(workload)
  workload_data = fetch_workload(workload)
  return workload_data if workload_data

  raise "Can't find workload '#{workload}', please create it with 'cpl apply-template #{workload} -a #{config.app}'."
end

#fetch_workload_deployments(workload) ⇒ Object 



205
206
207
 
# File 'lib/core/controlplane.rb', line 205

def fetch_workload_deployments(workload)
  api.workload_deployments(workload: workload, gvc: gvc, org: org)
end

#fetch_workload_replicas(workload, location:) ⇒ Object 



195
196
197
198
 
# File 'lib/core/controlplane.rb', line 195

def fetch_workload_replicas(workload, location:)
  cmd = "cpln workload replica get #{workload} #{gvc_org} --location #{location} -o yaml"
  perform_yaml(cmd)
end

#fetch_workloads(a_gvc = gvc) ⇒ Object

workload



168
169
170
 
# File 'lib/core/controlplane.rb', line 168

def fetch_workloads(a_gvc = gvc)
  api.workload_list(gvc: a_gvc, org: org)
end

#fetch_workloads_by_org(a_org = org) ⇒ Object 



172
173
174
 
# File 'lib/core/controlplane.rb', line 172

def fetch_workloads_by_org(a_org = org)
  api.workload_list_by_org(org: a_org)
end

#find_domain_for(workloads) ⇒ Object 



329
330
331
332
333
334
335
336
337
 
# File 'lib/core/controlplane.rb', line 329

def find_domain_for(workloads)
  domains = api.list_domains(org: org)["items"]
  domains.find do |domain_data|
    route = find_domain_route(domain_data)
    next false if route.nil?

    workloads.any? { |workload| route["workloadLink"].match?(%r{/org/#{org}/gvc/#{gvc}/workload/#{workload}}) }
  end
end

#find_domain_route(data) ⇒ Object

domain



319
320
321
322
323
324
325
326
327
 
# File 'lib/core/controlplane.rb', line 319

def find_domain_route(data)
  port = data["spec"]["ports"].find { |current_port| current_port["number"] == 80 || current_port["number"] == 443 }
  return nil if port.nil? || port["routes"].nil?

  route = port["routes"].find { |current_route| current_route["prefix"] == "/" }
  return nil if route.nil?

  route
end

#gvc_delete(a_gvc = gvc) ⇒ Object 



162
163
164
 
# File 'lib/core/controlplane.rb', line 162

def gvc_delete(a_gvc = gvc)
  api.gvc_delete(gvc: a_gvc, org: org)
end

#gvc_query(app_name = config.app) ⇒ Object 



142
143
144
145
146
147
148
149
 
# File 'lib/core/controlplane.rb', line 142

def gvc_query(app_name = config.app)
  # When `match_if_app_name_starts_with` is `true`, we query for any gvc containing the name,
  # otherwise we query for a gvc with the exact name.
  op = config.should_app_start_with?(app_name) ? "~" : "="

  cmd = "cpln gvc query --org #{org} -o yaml --prop name#{op}#{app_name}"
  perform_yaml!(cmd)
end

#image_build(image, dockerfile:, docker_args: [], build_args: [], push: true) ⇒ Object 



94
95
96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/core/controlplane.rb', line 94

def image_build(image, dockerfile:, docker_args: [], build_args: [], push: true)
  # https://docs.controlplane.com/guides/push-image#step-2
  # Might need to use `docker buildx build` if compatiblitity issues arise
  cmd = "docker build --platform=linux/amd64 -t #{image} -f #{dockerfile}"
  cmd += " --progress=plain" if ControlplaneApiDirect.trace

  cmd += " #{docker_args.join(' ')}" if docker_args.any?
  build_args.each { |build_arg| cmd += " --build-arg #{build_arg}" }
  cmd += " #{config.app_dir}"
  perform!(cmd)

  image_push(image) if push
end

#image_delete(image) ⇒ Object 



112
113
114
 
# File 'lib/core/controlplane.rb', line 112

def image_delete(image)
  api.image_delete(org: org, image: image)
end

#image_login(org_name = config.org) ⇒ Object 



116
117
118
119
 
# File 'lib/core/controlplane.rb', line 116

def (org_name = config.org)
  cmd = "cpln image docker-login --org #{org_name}"
  perform!(cmd, output_mode: :none)
end

#image_pull(image) ⇒ Object 



121
122
123
124
 
# File 'lib/core/controlplane.rb', line 121

def image_pull(image)
  cmd = "docker pull #{image}"
  perform!(cmd, output_mode: :none)
end

#image_push(image) ⇒ Object 



131
132
133
134
 
# File 'lib/core/controlplane.rb', line 131

def image_push(image)
  cmd = "docker push #{image}"
  perform!(cmd)
end

#image_tag(old_tag, new_tag) ⇒ Object 



126
127
128
129
 
# File 'lib/core/controlplane.rb', line 126

def image_tag(old_tag, new_tag)
  cmd = "docker tag #{old_tag} #{new_tag}"
  perform!(cmd)
end

#latest_image(a_gvc = gvc, a_org = org, refresh: false) ⇒ Object

image



42
43
44
45
46
47
48
49
50
 
# File 'lib/core/controlplane.rb', line 42

def latest_image(a_gvc = gvc, a_org = org, refresh: false)
  @latest_image ||= {}
  @latest_image[a_gvc] = nil if refresh
  @latest_image[a_gvc] ||=
    begin
      items = query_images(a_gvc, a_org)["items"]
      latest_image_from(items, app_name: a_gvc)
    end
end

#latest_image_from(items, app_name: gvc, name_only: true) ⇒ Object 



65
66
67
68
69
70
71
72
73
74
75
 
# File 'lib/core/controlplane.rb', line 65

def latest_image_from(items, app_name: gvc, name_only: true)
  matching_items = items.select { |item| item["name"].start_with?("#{app_name}:") }

  # Or special string to indicate no image available
  if matching_items.empty?
    name_only ? "#{app_name}:#{NO_IMAGE_AVAILABLE}" : nil
  else
    latest_item = matching_items.max_by { |item| extract_image_number(item["name"]) }
    name_only ? latest_item["name"] : latest_item
  end
end

#latest_image_next(a_gvc = gvc, a_org = org, commit: nil) ⇒ Object 



52
53
54
55
56
57
58
59
60
61
62
63
 
# File 'lib/core/controlplane.rb', line 52

def latest_image_next(a_gvc = gvc, a_org = org, commit: nil)
  commit ||= config.options[:commit]

  @latest_image_next ||= {}
  @latest_image_next[a_gvc] ||= begin
    latest_image_name = latest_image(a_gvc, a_org)
    image = latest_image_name.split(":").first
    image += ":#{extract_image_number(latest_image_name) + 1}"
    image += "_#{commit}" if commit
    image
  end
end

#log_get(workload:, from:, to:, replica: nil) ⇒ Object 



370
371
372
 
# File 'lib/core/controlplane.rb', line 370

def log_get(workload:, from:, to:, replica: nil)
  api.log_get(org: org, gvc: gvc, workload: workload, replica: replica, from: from, to: to)
end

#logs(workload:, limit:, since:, replica: nil) ⇒ Object

logs



361
362
363
364
365
366
367
368
 
# File 'lib/core/controlplane.rb', line 361

def logs(workload:, limit:, since:, replica: nil)
  query_parts = ["gvc=\"#{gvc}\"", "workload=\"#{workload}\""]
  query_parts.push("replica=\"#{replica}\"") if replica
  query = "{#{query_parts.join(',')}}"

  cmd = "cpln logs '#{query}' --org #{org} -t -o raw --limit #{limit} --since #{since}"
  perform!(cmd, output_mode: :all)
end

#parse_apply_result(result) ⇒ Object

rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity



432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
 
# File 'lib/core/controlplane.rb', line 432

def parse_apply_result(result) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
  items = []

  lines = result.split("\n")
  lines.each do |line|
    # The line can be in one of these formats:
    # - "Created /org/shakacode-open-source-examples/gvc/my-app-staging"
    # - "Created /org/shakacode-open-source-examples/gvc/my-app-staging/workload/redis"
    # - "Updated gvc 'tutorial-app-test-1'"
    # - "Updated workload 'redis'"
    if line.start_with?("Created")
      matches = line.match(%r{Created\s/org/[^/]+/gvc/([^/]+)($|(/([^/]+)/([^/]+)$))})&.captures
      next unless matches

      app, _, __, kind, name = matches
      if kind
        items.push({ kind: kind, name: name })
      else
        items.push({ kind: "app", name: app })
      end
    else
      matches = line.match(/Updated\s([^\s]+)\s'([^\s]+)'$/)&.captures
      next unless matches

      kind, name = matches
      kind = "app" if kind == "gvc"
      items.push({ kind: kind, name: name })
    end
  end

  items
end

#profile_create(profile, token) ⇒ Object 



29
30
31
32
33
 
# File 'lib/core/controlplane.rb', line 29

def profile_create(profile, token)
  sensitive_data_pattern = /(?<=--token )(\S+)/
  cmd = "cpln profile create #{profile} --token #{token}"
  perform!(cmd, sensitive_data_pattern: sensitive_data_pattern)
end

#profile_delete(profile) ⇒ Object 



35
36
37
38
 
# File 'lib/core/controlplane.rb', line 35

def profile_delete(profile)
  cmd = "cpln profile delete #{profile}"
  perform!(cmd)
end

#profile_exists?(profile) ⇒ Boolean

Returns:

  • (Boolean) 


24
25
26
27
 
# File 'lib/core/controlplane.rb', line 24

def profile_exists?(profile)
  cmd = "cpln profile get #{profile} -o yaml"
  perform_yaml!(cmd).length.positive?
end

#profile_switch(profile) ⇒ Object

profile



19
20
21
22
 
# File 'lib/core/controlplane.rb', line 19

def profile_switch(profile)
  ENV["CPLN_PROFILE"] = profile
  ControlplaneApiDirect.reset_api_token
end

#query_images(a_gvc = gvc, a_org = org, partial_gvc_match: nil) ⇒ Object 



87
88
89
90
91
92
 
# File 'lib/core/controlplane.rb', line 87

def query_images(a_gvc = gvc, a_org = org, partial_gvc_match: nil)
  partial_gvc_match = config.should_app_start_with?(a_gvc) if partial_gvc_match.nil?
  gvc_op = partial_gvc_match ? "~" : "="

  api.query_images(org: a_org, gvc: a_gvc, gvc_op_type: gvc_op)
end

#query_workloads(workload, a_gvc = gvc, a_org = org, partial_workload_match: false, partial_gvc_match: nil) ⇒ Object 



187
188
189
190
191
192
193
 
# File 'lib/core/controlplane.rb', line 187

def query_workloads(workload, a_gvc = gvc, a_org = org, partial_workload_match: false, partial_gvc_match: nil)
  partial_gvc_match = config.should_app_start_with?(a_gvc) if partial_gvc_match.nil?
  gvc_op = partial_gvc_match ? "~" : "="
  workload_op = partial_workload_match ? "~" : "="

  api.query_workloads(org: a_org, gvc: a_gvc, workload: workload, gvc_op_type: gvc_op, workload_op_type: workload_op)
end

#set_domain_workload(data, workload) ⇒ Object 



352
353
354
355
356
357
 
# File 'lib/core/controlplane.rb', line 352

def set_domain_workload(data, workload)
  route = find_domain_route(data)
  route["workloadLink"] = "/org/#{org}/gvc/#{gvc}/workload/#{workload}"

  api.update_domain(org: org, domain: data["name"], data: data)
end

#set_workload_env_var(workload, container:, name:, value:) ⇒ Object 



237
238
239
240
241
242
243
244
245
246
247
248
249
250
 
# File 'lib/core/controlplane.rb', line 237

def set_workload_env_var(workload, container:, name:, value:)
  data = fetch_workload!(workload)
  data["spec"]["containers"].each do |container_data|
    next unless container_data["name"] == container

    container_data["env"].each do |env_data|
      next unless env_data["name"] == name

      env_data["value"] = value
    end
  end

  api.update_workload(org: org, gvc: gvc, workload: workload, data: data)
end

#set_workload_suspend(workload, value) ⇒ Object 



252
253
254
255
256
257
 
# File 'lib/core/controlplane.rb', line 252

def set_workload_suspend(workload, value)
  data = fetch_workload!(workload)
  data["spec"]["defaultOptions"]["suspend"] = value

  api.update_workload(org: org, gvc: gvc, workload: workload, data: data)
end

#start_cron_workload(workload, job_start_yaml, location:) ⇒ Object 



282
283
284
285
286
287
288
289
290
 
# File 'lib/core/controlplane.rb', line 282

def start_cron_workload(workload, job_start_yaml, location:)
  Tempfile.create do |f|
    f.write(job_start_yaml)
    f.rewind

    cmd = "cpln workload cron start #{workload} #{gvc_org} --file #{f.path} --location #{location} -o yaml"
    perform_yaml(cmd)
  end
end

#stop_workload_replica(workload, replica, location:) ⇒ Object 



200
201
202
203
 
# File 'lib/core/controlplane.rb', line 200

def stop_workload_replica(workload, replica, location:)
  cmd = "cpln workload replica stop #{workload} #{gvc_org} --replica-name #{replica} --location #{location}"
  perform(cmd, output_mode: :none)
end

#unbind_identity_from_policy(identity_link, policy) ⇒ Object 



397
398
399
400
 
# File 'lib/core/controlplane.rb', line 397

def unbind_identity_from_policy(identity_link, policy)
  cmd = "cpln policy remove-binding #{policy} --org #{org} --identity #{identity_link} --permission reveal"
  perform!(cmd)
end

#workload_connect(workload, location:, container: nil, shell: nil) ⇒ Object 



268
269
270
271
272
273
 
# File 'lib/core/controlplane.rb', line 268

def workload_connect(workload, location:, container: nil, shell: nil)
  cmd = "cpln workload connect #{workload} #{gvc_org} --location #{location}"
  cmd += " --container #{container}" if container
  cmd += " --shell #{shell}" if shell
  perform!(cmd, output_mode: :all)
end

#workload_deployment_version_ready?(version, next_version) ⇒ Boolean

Returns:

  • (Boolean) 


209
210
211
212
213
214
215
 
# File 'lib/core/controlplane.rb', line 209

def workload_deployment_version_ready?(version, next_version)
  return false unless version["workload"] == next_version

  version["containers"]&.all? do |_, container|
    container.dig("resources", "replicas") == container.dig("resources", "replicasReady")
  end
end

#workload_deployments_ready?(workload, location:, expected_status:) ⇒ Boolean

Returns:

  • (Boolean) 


217
218
219
220
221
222
223
224
225
226
227
228
229
 
# File 'lib/core/controlplane.rb', line 217

def workload_deployments_ready?(workload, location:, expected_status:)
  deployed_replicas = fetch_workload_replicas(workload, location: location)["items"].length
  return deployed_replicas.zero? if expected_status == false

  deployments = fetch_workload_deployments(workload)["items"]
  deployments.all? do |deployment|
    next_version = deployment.dig("status", "expectedDeploymentVersion")

    deployment.dig("status", "versions")&.all? do |version|
      workload_deployment_version_ready?(version, next_version)
    end
  end
end

#workload_exec(workload, replica, location:, container: nil, command: nil) ⇒ Object 



275
276
277
278
279
280
 
# File 'lib/core/controlplane.rb', line 275

def workload_exec(workload, replica, location:, container: nil, command: nil)
  cmd = "cpln workload exec #{workload} #{gvc_org} --replica #{replica} --location #{location}"
  cmd += " --container #{container}" if container
  cmd += " -- #{command}"
  perform!(cmd, output_mode: :all)
end

#workload_force_redeployment(workload) ⇒ Object 



259
260
261
262
 
# File 'lib/core/controlplane.rb', line 259

def workload_force_redeployment(workload)
  cmd = "cpln workload force-redeployment #{workload} #{gvc_org}"
  perform!(cmd)
end

#workload_set_image_ref(workload, container:, image:) ⇒ Object 



231
232
233
234
235
 
# File 'lib/core/controlplane.rb', line 231

def workload_set_image_ref(workload, container:, image:)
  cmd = "cpln workload update #{workload} #{gvc_org}"
  cmd += " --set spec.containers.#{container}.image=/org/#{config.org}/image/#{image}"
  perform!(cmd)
end