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 



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

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

#apply_template(data) ⇒ Object

apply



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

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 



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

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 



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

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 



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

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 



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

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) 


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

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 



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

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 



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

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 



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

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 



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

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



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

def fetch_gvcs
  api.gvc_list(org: org)
end

#fetch_identity(identity, a_gvc = gvc) ⇒ Object

identities



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

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

#fetch_image_details(image) ⇒ Object 



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

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

#fetch_policy(policy) ⇒ Object

policies



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

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

#fetch_secret(secret) ⇒ Object

secrets



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

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

#fetch_volumesets(a_gvc = gvc) ⇒ Object

volumeset



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

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

#fetch_workload(workload) ⇒ Object 



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

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

#fetch_workload!(workload) ⇒ Object 



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

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 



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



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

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

#fetch_workloads_by_org(a_org = org) ⇒ Object 



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

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

#find_domain_for(workloads) ⇒ Object 



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

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



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

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 



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

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

#gvc_query(app_name = config.app) ⇒ Object 



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

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 



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

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 



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

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

#image_login(org_name = config.org) ⇒ Object 



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

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

#image_pull(image) ⇒ Object 



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

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

#image_push(image) ⇒ Object 



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

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

#image_tag(old_tag, new_tag) ⇒ Object 



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

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 



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

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



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

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



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
468
 
# File 'lib/core/controlplane.rb', line 437

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 



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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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

#workload_suspended?(workload) ⇒ Boolean

Returns:

  • (Boolean) 


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

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