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 



432
433
434
 
# File 'lib/core/controlplane.rb', line 432

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

#apply_template(data) ⇒ Object

apply



407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
 
# File 'lib/core/controlplane.rb', line 407

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 



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

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 



301
302
303
304
305
306
307
308
309
 
# File 'lib/core/controlplane.rb', line 301

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 



317
318
319
 
# File 'lib/core/controlplane.rb', line 317

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 



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

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) 


351
352
353
354
 
# File 'lib/core/controlplane.rb', line 351

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 



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

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

#extract_image_number(image_name) ⇒ Object 



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

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 



296
297
298
299
 
# File 'lib/core/controlplane.rb', line 296

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 



343
344
345
346
347
348
349
 
# File 'lib/core/controlplane.rb', line 343

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 



149
150
151
 
# File 'lib/core/controlplane.rb', line 149

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 



153
154
155
156
157
158
 
# File 'lib/core/controlplane.rb', line 153

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 'cpflow setup-app -a #{config.app}'."
end

#fetch_gvcs ⇒ Object

gvc



136
137
138
 
# File 'lib/core/controlplane.rb', line 136

def fetch_gvcs
  api.gvc_list(org: org)
end

#fetch_identity(identity, a_gvc = gvc) ⇒ Object

identities



386
387
388
 
# File 'lib/core/controlplane.rb', line 386

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

#fetch_image_details(image) ⇒ Object 



106
107
108
 
# File 'lib/core/controlplane.rb', line 106

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

#fetch_policy(policy) ⇒ Object

policies



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

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

#fetch_secret(secret) ⇒ Object

secrets



380
381
382
 
# File 'lib/core/controlplane.rb', line 380

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

#fetch_volumesets(a_gvc = gvc) ⇒ Object

volumeset



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

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

#fetch_workload(workload) ⇒ Object 



174
175
176
 
# File 'lib/core/controlplane.rb', line 174

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

#fetch_workload!(workload) ⇒ Object 



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

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 'cpflow apply-template #{workload} -a #{config.app}'."
end

#fetch_workload_deployments(workload) ⇒ Object 



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

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

#fetch_workload_replicas(workload, location:) ⇒ Object 



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

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



166
167
168
 
# File 'lib/core/controlplane.rb', line 166

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

#fetch_workloads_by_org(a_org = org) ⇒ Object 



170
171
172
 
# File 'lib/core/controlplane.rb', line 170

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

#find_domain_for(workloads) ⇒ Object 



333
334
335
336
337
338
339
340
341
 
# File 'lib/core/controlplane.rb', line 333

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



323
324
325
326
327
328
329
330
331
 
# File 'lib/core/controlplane.rb', line 323

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 



160
161
162
 
# File 'lib/core/controlplane.rb', line 160

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

#gvc_query(app_name = config.app) ⇒ Object 



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

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_context:, docker_args: [], build_args: []) ⇒ Object 



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

def image_build(image, dockerfile:, docker_context:, docker_args: [], build_args: [])
  # 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 += " #{docker_context}"

  perform!(cmd)
end

#image_delete(image) ⇒ Object 



110
111
112
 
# File 'lib/core/controlplane.rb', line 110

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

#image_login(org_name = config.org) ⇒ Object 



114
115
116
117
 
# File 'lib/core/controlplane.rb', line 114

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

#image_pull(image) ⇒ Object 



119
120
121
122
 
# File 'lib/core/controlplane.rb', line 119

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

#image_push(image) ⇒ Object 



129
130
131
132
 
# File 'lib/core/controlplane.rb', line 129

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

#image_tag(old_tag, new_tag) ⇒ Object 



124
125
126
127
 
# File 'lib/core/controlplane.rb', line 124

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) ⇒ Object

image



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

def latest_image(a_gvc = gvc, a_org = org)
  @latest_image ||= {}
  @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 



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

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| DateTime.parse(item["created"]) }
    name_only ? latest_item["name"] : latest_item
  end
end

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



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

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 



374
375
376
 
# File 'lib/core/controlplane.rb', line 374

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



365
366
367
368
369
370
371
372
 
# File 'lib/core/controlplane.rb', line 365

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



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
464
465
466
467
 
# File 'lib/core/controlplane.rb', line 436

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 



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

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 



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

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 



356
357
358
359
360
361
 
# File 'lib/core/controlplane.rb', line 356

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 



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

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 



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

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 



286
287
288
289
290
291
292
293
294
 
# File 'lib/core/controlplane.rb', line 286

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 



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

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 



401
402
403
404
 
# File 'lib/core/controlplane.rb', line 401

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 



272
273
274
275
276
277
 
# File 'lib/core/controlplane.rb', line 272

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) 


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

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) 


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

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 



279
280
281
282
283
284
 
# File 'lib/core/controlplane.rb', line 279

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

#workload_force_redeployment(workload) ⇒ Object 



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

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

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



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

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

#workload_suspended?(workload) ⇒ Boolean

Returns:

  • (Boolean) 


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

def workload_suspended?(workload)
  details = fetch_workload!(workload)
  details["spec"]["defaultOptions"]["suspend"]
end