Class: Bosh::Cli::Client::Director

Inherits:
Object
  • Object
show all
Defined in:
lib/cli/client/director.rb

Constant Summary collapse

DIRECTOR_HTTP_ERROR_CODES = 
[400, 401, 403, 404, 500]
API_TIMEOUT = 
86400 * 3
CONNECT_TIMEOUT = 
30

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(director_uri, credentials = nil, options = {}) ⇒ Director

Options can include:

  • :no_track => true - do not use TaskTracker for long-running

    +request_and_track+ calls



26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/cli/client/director.rb', line 26

def initialize(director_uri, credentials = nil, options = {})
  if director_uri.nil? || director_uri =~ /^\s*$/
    raise DirectorMissing, 'no director URI given'
  end

  @director_uri        = URI.parse(director_uri)
  @director_host       = @director_uri.host
  @scheme              = @director_uri.scheme
  @port                = @director_uri.port
  @credentials         = credentials
  @track_tasks         = !options.delete(:no_track)
  @num_retries         = options.fetch(:num_retries, 5)
  @retry_wait_interval = options.fetch(:retry_wait_interval, 5)
  @ca_cert             = options[:ca_cert]
end

Instance Attribute Details

#director_uri ⇒ Object (readonly)

Returns the value of attribute director_uri.



21
22
23
 
# File 'lib/cli/client/director.rb', line 21

def director_uri
  @director_uri
end

Instance Method Details

#apply_resolutions(deployment_name, resolutions, options = {}) ⇒ Object 



521
522
523
524
525
526
527
528
529
 
# File 'lib/cli/client/director.rb', line 521

def apply_resolutions(deployment_name, resolutions, options = {})
  options = options.dup

  url                    = "/deployments/#{deployment_name}/problems"
  options[:content_type] = 'application/json'
  options[:payload]      = JSON.generate('resolutions' => resolutions)

  request_and_track(:put, url, options)
end

#attach_disk(deployment_name, job_name, instance_id, disk_cid) ⇒ Object 



206
207
208
 
# File 'lib/cli/client/director.rb', line 206

def attach_disk(deployment_name, job_name, instance_id, disk_cid)
  request_and_track(:put, "/disks/#{disk_cid}/attachments?deployment=#{deployment_name}&job=#{job_name}&instance_id=#{instance_id}")
end

#authenticated? ⇒ Boolean

Returns:

  • (Boolean) 


67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/cli/client/director.rb', line 67

def authenticated?
  # getting status verifies credentials
  # if credentials are wrong it will raise DirectorError
  status = get_status
  # Backward compatibility: older directors return 200
  # only for logged in users
  return true if !status.has_key?('version')
  !status['user'].nil?
rescue DirectorError
  false
end

#cancel_task(task_id) ⇒ Object

Raises:



590
591
592
593
594
595
 
# File 'lib/cli/client/director.rb', line 590

def cancel_task(task_id)
  response_code, body = delete("/task/#{task_id}")
  raise AuthError if response_code == 401
  raise MissingTask, "No task##{task_id} found" if response_code == 404
  [body, response_code]
end

#change_instance_ignore_state(deployment_name, instance_group_name, id, ignore_state) ⇒ Object 



390
391
392
393
394
 
# File 'lib/cli/client/director.rb', line 390

def change_instance_ignore_state(deployment_name, instance_group_name, id, ignore_state)
  url     = "/deployments/#{deployment_name}/instance_groups/#{instance_group_name}/#{id}/ignore"
  payload = JSON.generate('ignore' => ignore_state)
  put(url, 'application/json', payload)
end

#change_job_state(deployment_name, manifest_yaml, job, index_or_id, new_state, options = {}) ⇒ Object 



357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
 
# File 'lib/cli/client/director.rb', line 357

def change_job_state(deployment_name, manifest_yaml,
  job, index_or_id, new_state, options = {})
  options = options.dup

  skip_drain = !!options.delete(:skip_drain)
  canaries = options.delete(:canaries)
  max_in_flight = options.delete(:max_in_flight)

  url = "/deployments/#{deployment_name}/jobs/#{job}"
  url += "/#{index_or_id}" if index_or_id
  url += "?state=#{new_state}"
  url += "&skip_drain=true" if skip_drain
  url += "&max_in_flight=#{max_in_flight}" if max_in_flight
  url += "&canaries=#{canaries}" if canaries

  options[:payload]      = manifest_yaml
  options[:content_type] = 'text/yaml'

  request_and_track(:put, url, options)
end

#change_vm_resurrection(deployment_name, job_name, index, value) ⇒ Object 



378
379
380
381
382
 
# File 'lib/cli/client/director.rb', line 378

def change_vm_resurrection(deployment_name, job_name, index, value)
  url     = "/deployments/#{deployment_name}/jobs/#{job_name}/#{index}/resurrection"
  payload = JSON.generate('resurrection_paused' => value)
  put(url, 'application/json', payload)
end

#change_vm_resurrection_for_all(value) ⇒ Object 



384
385
386
387
388
 
# File 'lib/cli/client/director.rb', line 384

def change_vm_resurrection_for_all(value)
  url     = "/resurrection"
  payload = JSON.generate('resurrection_paused' => value)
  put(url, 'application/json', payload)
end

#check_director_restart(poll_interval, timeout) ⇒ Object 



610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
 
# File 'lib/cli/client/director.rb', line 610

def check_director_restart(poll_interval, timeout)
  current_time = start_time = Time.now()

  #step 1, wait until director is stopped
  while current_time.to_i - start_time.to_i <= timeout do
    status, body = get_json_with_status('/info')
    break if status != 200

    sleep(poll_interval)
    current_time = Time.now()
  end

  #step 2, wait until director is started
  while current_time.to_i - start_time.to_i <= timeout do
    status, body = get_json_with_status('/info')
    return true if status == 200

    sleep(poll_interval)
    current_time = Time.now()
  end

  return false
end

#cleanup(config = {}) ⇒ Object 



722
723
724
725
726
727
 
# File 'lib/cli/client/director.rb', line 722

def cleanup(config = {})
  options = {}
  options[:payload] = JSON.generate('config' => config)
  options[:content_type] = 'application/json'
  request_and_track(:post, '/cleanup', options)
end

#cleanup_ssh(deployment_name, job, user_regex, id, options = {}) ⇒ Object 



334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
 
# File 'lib/cli/client/director.rb', line 334

def cleanup_ssh(deployment_name, job, user_regex, id, options = {})
  options = options.dup

  url = "/deployments/#{deployment_name}/ssh"

  payload = {
    'command'         => 'cleanup',
    'deployment_name' => deployment_name,
    'target'          => {
      'job'     => job,
      'indexes' => (id || []).compact,
      'ids' => (id || []).compact,
    },
    'params'          => { 'user_regex' => user_regex }
  }

  options[:payload]      = JSON.generate(payload)
  options[:content_type] = 'application/json'
  options[:task_success_state] = :queued

  request_and_track(:post, url, options)
end

#create_backup ⇒ Object 



597
598
599
 
# File 'lib/cli/client/director.rb', line 597

def create_backup
  request_and_track(:post, '/backups', {})
end

#create_property(deployment_name, property_name, value) ⇒ Object 



445
446
447
448
449
 
# File 'lib/cli/client/director.rb', line 445

def create_property(deployment_name, property_name, value)
  url     = "/deployments/#{deployment_name}/properties"
  payload = JSON.generate('name' => property_name, 'value' => value)
  post(url, 'application/json', payload)
end

#create_user(username, password) ⇒ Object 



79
80
81
82
83
 
# File 'lib/cli/client/director.rb', line 79

def create_user(username, password)
  payload          = JSON.generate('username' => username, 'password' => password)
  response_code, _ = post('/users', 'application/json', payload)
  response_code == 204
end

#delete(uri, content_type = nil, payload = nil, headers = {}, options = {}) ⇒ Object 



741
742
743
 
# File 'lib/cli/client/director.rb', line 741

def delete(uri, content_type = nil, payload = nil, headers = {}, options = {})
  request(:delete, uri, content_type, payload, headers, options)
end

#delete_all_snapshots(deployment_name, options = {}) ⇒ Object 



493
494
495
496
497
498
499
 
# File 'lib/cli/client/director.rb', line 493

def delete_all_snapshots(deployment_name, options = {})
  options = options.dup

  url = "/deployments/#{deployment_name}/snapshots"

  request_and_track(:delete, url, options)
end

#delete_deployment(name, options = {}) ⇒ Object 



247
248
249
250
251
252
253
254
255
256
257
 
# File 'lib/cli/client/director.rb', line 247

def delete_deployment(name, options = {})
  options = options.dup
  force   = options.delete(:force)

  url = "/deployments/#{name}"

  extras = []
  extras << ['force', 'true'] if force

  request_and_track(:delete, add_query_string(url, extras), options)
end

#delete_orphan_disk_by_disk_cid(orphan_disk_cid) ⇒ Object 



210
211
212
 
# File 'lib/cli/client/director.rb', line 210

def delete_orphan_disk_by_disk_cid(orphan_disk_cid)
  request_and_track(:delete, "/disks/#{orphan_disk_cid}")
end

#delete_property(deployment_name, property_name) ⇒ Object 



457
458
459
460
 
# File 'lib/cli/client/director.rb', line 457

def delete_property(deployment_name, property_name)
  url = "/deployments/#{deployment_name}/properties/#{property_name}"
  delete(url, 'application/json')
end

#delete_release(name, options = {}) ⇒ Object 



259
260
261
262
263
264
265
266
267
268
269
270
271
 
# File 'lib/cli/client/director.rb', line 259

def delete_release(name, options = {})
  options = options.dup
  force   = options.delete(:force)
  version = options.delete(:version)

  url = "/releases/#{name}"

  extras = []
  extras << ['force', 'true'] if force
  extras << ['version', version] if version

  request_and_track(:delete, add_query_string(url, extras), options)
end

#delete_snapshot(deployment_name, snapshot_cid, options = {}) ⇒ Object 



501
502
503
504
505
506
507
 
# File 'lib/cli/client/director.rb', line 501

def delete_snapshot(deployment_name, snapshot_cid, options = {})
  options = options.dup

  url = "/deployments/#{deployment_name}/snapshots/#{snapshot_cid}"

  request_and_track(:delete, url, options)
end

#delete_stemcell(name, version, options = {}) ⇒ Object 



235
236
237
238
239
240
241
242
243
244
245
 
# File 'lib/cli/client/director.rb', line 235

def delete_stemcell(name, version, options = {})
  options = options.dup
  force   = options.delete(:force)

  url = "/stemcells/#{name}/#{version}"

  extras = []
  extras << ['force', 'true'] if force

  request_and_track(:delete, add_query_string(url, extras), options)
end

#delete_user(username) ⇒ Object 



85
86
87
88
 
# File 'lib/cli/client/director.rb', line 85

def delete_user(username)
  response_code, _ = delete("/users/#{username}")
  response_code == 204
end

#delete_vm_by_cid(vm_cid) ⇒ Object 



273
274
275
 
# File 'lib/cli/client/director.rb', line 273

def delete_vm_by_cid(vm_cid)
  request_and_track(:delete, "/vms/#{vm_cid}")
end

#deploy(manifest_yaml, options = {}) ⇒ Object 



277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
 
# File 'lib/cli/client/director.rb', line 277

def deploy(manifest_yaml, options = {})
  options = options.dup

  recreate               = options.delete(:recreate)
  skip_drain             = options.delete(:skip_drain)
  context                = options.delete(:context)
  options[:content_type] = 'text/yaml'
  options[:payload]      = manifest_yaml

  url = '/deployments'

  extras = []
  extras << ['recreate', 'true'] if recreate
  extras << ['context', JSON.dump(context)] if context
  extras << ['skip_drain', skip_drain] if skip_drain

  request_and_track(:post, add_query_string(url, extras), options)
end

#diff_deployment(name, manifest_yaml, redact_diff = true) ⇒ Object 



296
297
298
299
300
301
302
303
304
305
 
# File 'lib/cli/client/director.rb', line 296

def diff_deployment(name, manifest_yaml, redact_diff = true)
  redact_param = redact_diff ? '' : '?redact=false'
  uri = "/deployments/#{name}/diff#{redact_param}"
  status, body = post(uri, 'text/yaml', manifest_yaml)
  if status == 200
    JSON.parse(body)
  else
    err(parse_error_message(status, body))
  end
end

#download_resource(id) ⇒ Object 



433
434
435
436
437
438
439
440
441
442
443
 
# File 'lib/cli/client/director.rb', line 433

def download_resource(id)
  status, tmp_file, _ = get("/resources/#{id}",
                            nil, nil, {}, :file => true)

  if status == 200
    tmp_file
  else
    raise DirectorError,
          "Cannot download resource '#{id}': HTTP status #{status}"
  end
end

#exists? ⇒ Boolean

Returns:

  • (Boolean) 


46
47
48
49
50
51
52
53
 
# File 'lib/cli/client/director.rb', line 46

def exists?
  get_status
  true
rescue AuthError
  true # For compatibility with directors that return 401 for /info
rescue DirectorError
  false
end

#fetch_backup ⇒ Object 



601
602
603
604
 
# File 'lib/cli/client/director.rb', line 601

def fetch_backup
  _, path, _ = get('/backups', nil, nil, {}, :file => true)
  path
end

#fetch_logs(deployment_name, job_name, index, log_type, filters = nil, options = {}) ⇒ Object 



396
397
398
399
400
401
402
403
404
405
406
407
 
# File 'lib/cli/client/director.rb', line 396

def fetch_logs(deployment_name, job_name, index, log_type,
  filters = nil, options = {})
  options = options.dup

  url = "/deployments/#{deployment_name}/jobs/#{job_name}"
  url += "/#{index}/logs?type=#{log_type}&filters=#{filters}"

  status, task_id = request_and_track(:get, url, options)

  return nil if status != :done
  get_task_result(task_id)
end

#fetch_vm_state(deployment_name, options = {}, full = true) ⇒ Object 



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/cli/client/director.rb', line 409

def fetch_vm_state(deployment_name, options = {}, full = true)
  options = options.dup

  url = "/deployments/#{deployment_name}/vms"

  if full
    status, task_id = request_and_track(:get, "#{url}?format=full", options)

    raise DirectorError, 'Failed to fetch VMs information from director' if status != :done

    output = get_task_result_log(task_id)
  else
    status, output, _ = get(url, nil, nil, {}, options)

    raise DirectorError, 'Failed to fetch VMs information from director' if status != 200
  end

  output = output.to_s.split("\n").map do |vm_state|
    JSON.parse(vm_state)
  end

  output.flatten
end

#get(uri, content_type = nil, payload = nil, headers = {}, options = {}) ⇒ Object 



737
738
739
 
# File 'lib/cli/client/director.rb', line 737

def get(uri, content_type = nil, payload = nil, headers = {}, options = {})
  request(:get, uri, content_type, payload, headers, options)
end

#get_cloud_config ⇒ Object 



690
691
692
693
694
695
696
697
698
699
 
# File 'lib/cli/client/director.rb', line 690

def get_cloud_config
  _, cloud_configs = get_json_with_status('/cloud_configs?limit=1')
  latest = cloud_configs.first

  if !latest.nil?
    Bosh::Cli::CloudConfig.new(
      properties: latest["properties"],
      created_at: latest["created_at"])
  end
end

#get_current_time ⇒ Object 



531
532
533
534
 
# File 'lib/cli/client/director.rb', line 531

def get_current_time
  _, _, headers = get('/info')
  Time.parse(headers[:date]) rescue nil
end

#get_deployment(name) ⇒ Object 



196
197
198
199
 
# File 'lib/cli/client/director.rb', line 196

def get_deployment(name)
  _, body = get_json_with_status("/deployments/#{name}")
  body
end

#get_property(deployment_name, property_name) ⇒ Object 



462
463
464
465
 
# File 'lib/cli/client/director.rb', line 462

def get_property(deployment_name, property_name)
  url = "/deployments/#{deployment_name}/properties/#{property_name}"
  get_json_with_status(url)
end

#get_release(name) ⇒ Object 



161
162
163
 
# File 'lib/cli/client/director.rb', line 161

def get_release(name)
  get_json("/releases/#{name}")
end

#get_runtime_config ⇒ Object 



706
707
708
709
710
711
712
713
714
715
 
# File 'lib/cli/client/director.rb', line 706

def get_runtime_config
  _, runtime_configs = get_json_with_status('/runtime_configs?limit=1')
  latest = runtime_configs.first

  if !latest.nil?
    Bosh::Cli::RuntimeConfig.new(
        properties: latest["properties"],
        created_at: latest["created_at"])
  end
end

#get_status ⇒ Object 



111
112
113
 
# File 'lib/cli/client/director.rb', line 111

def get_status
  get_json('/info')
end

#get_task(task_id) ⇒ Object 



542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
 
# File 'lib/cli/client/director.rb', line 542

def get_task(task_id)
  response_code, body = get("/tasks/#{task_id}")
  raise AuthError if response_code == 401
  raise MissingTask, "Task #{task_id} not found" if response_code == 404

  if response_code != 200
    raise TaskTrackError, "Got HTTP #{response_code} " +
      'while tracking task state'
  end

  JSON.parse(body)
rescue JSON::ParserError
  raise TaskTrackError, 'Cannot parse task JSON, ' +
    'incompatible director version'
end

#get_task_output(task_id, offset, log_type = nil) ⇒ Object 



571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
 
# File 'lib/cli/client/director.rb', line 571

def get_task_output(task_id, offset, log_type = nil)
  uri = "/tasks/#{task_id}/output"
  uri += "?type=#{log_type}" if log_type

  headers                      = { 'Range' => "bytes=#{offset}-" }
  response_code, body, headers = get(uri, nil, nil, headers)

  if response_code == 206 &&
    headers[:content_range].to_s =~ /bytes \d+-(\d+)\/\d+/
    new_offset = $1.to_i + 1
  else
    new_offset = nil
    # Delete the "Byte range unsatisfiable" message
    body = nil if response_code == 416
  end

  [body, new_offset]
end

#get_task_result(task_id) ⇒ Object 



562
563
564
 
# File 'lib/cli/client/director.rb', line 562

def get_task_result(task_id)
  get_task(task_id)['result']
end

#get_task_result_log(task_id) ⇒ Object 



566
567
568
569
 
# File 'lib/cli/client/director.rb', line 566

def get_task_result_log(task_id)
  log, _ = get_task_output(task_id, 0, 'result')
  log
end

#get_task_state(task_id) ⇒ Object 



558
559
560
 
# File 'lib/cli/client/director.rb', line 558

def get_task_state(task_id)
  get_task(task_id)['state']
end

#get_time_difference ⇒ Object 



536
537
538
539
540
 
# File 'lib/cli/client/director.rb', line 536

def get_time_difference
  # This includes the round-trip to director
  ctime = get_current_time
  ctime ? Time.now - ctime : 0
end

#get_version ⇒ Object 



107
108
109
 
# File 'lib/cli/client/director.rb', line 107

def get_version
  get_status['version']
end

#inspect_release(name, version) ⇒ Object 



165
166
167
168
169
170
171
172
 
# File 'lib/cli/client/director.rb', line 165

def inspect_release(name, version)
  url = "/releases/#{name}"

  extras = []
  extras << ['version', version]

  get_json(add_query_string(url, extras))
end

#list_deployments ⇒ Object 



123
124
125
 
# File 'lib/cli/client/director.rb', line 123

def list_deployments
  get_json('/deployments')
end

#list_errands(deployment_name) ⇒ Object 



141
142
143
 
# File 'lib/cli/client/director.rb', line 141

def list_errands(deployment_name)
  get_json("/deployments/#{deployment_name}/errands")
end

#list_events(options = {}) ⇒ Object 



127
128
129
130
131
132
133
134
135
136
137
138
139
 
# File 'lib/cli/client/director.rb', line 127

def list_events(options={})
  query_string = "/events"
  delimeter = "?"
  options[:before_time] = URI.encode(options.delete(:before)) if options[:before]
  options[:after_time] = URI.encode(options.delete(:after)) if options[:after]
  [:before_id, :deployment, :instance, :task, :before_time, :after_time].each do |param|
    if options[param]
      query_string += "#{delimeter}#{ param.to_s}=#{options[param]}"
      delimeter = "&"
    end
  end
  get_json(query_string)
end

#list_locks ⇒ Object 



634
635
636
 
# File 'lib/cli/client/director.rb', line 634

def list_locks
  get_json('/locks')
end

#list_orphan_disks ⇒ Object 



214
215
216
217
 
# File 'lib/cli/client/director.rb', line 214

def list_orphan_disks
  _, body = get_json_with_status('/disks')
  body
end

#list_problems(deployment_name) ⇒ Object 



516
517
518
519
 
# File 'lib/cli/client/director.rb', line 516

def list_problems(deployment_name)
  url = "/deployments/#{deployment_name}/problems"
  get_json(url)
end

#list_properties(deployment_name) ⇒ Object 



467
468
469
470
 
# File 'lib/cli/client/director.rb', line 467

def list_properties(deployment_name)
  url = "/deployments/#{deployment_name}/properties"
  get_json(url)
end

#list_recent_tasks(count = 30, verbose = 1, deployment_name = nil) ⇒ Object 



153
154
155
156
157
158
159
 
# File 'lib/cli/client/director.rb', line 153

def list_recent_tasks(count = 30, verbose = 1, deployment_name = nil)
  if deployment_name
    get_json("/tasks?limit=#{count}&verbose=#{verbose}&deployment=#{deployment_name}")
  else
    get_json("/tasks?limit=#{count}&verbose=#{verbose}")
  end
end

#list_releases ⇒ Object 



119
120
121
 
# File 'lib/cli/client/director.rb', line 119

def list_releases
  get_json('/releases')
end

#list_running_tasks(verbose = 1, deployment_name = nil) ⇒ Object 



145
146
147
148
149
150
151
 
# File 'lib/cli/client/director.rb', line 145

def list_running_tasks(verbose = 1, deployment_name = nil)
  if deployment_name
    get_json("/tasks?state=processing,cancelling,queued&verbose=#{verbose}&deployment=#{deployment_name}")
  else
    get_json("/tasks?state=processing,cancelling,queued&verbose=#{verbose}")
  end
end

#list_snapshots(deployment_name, job = nil, index = nil) ⇒ Object 



484
485
486
487
488
489
490
491
 
# File 'lib/cli/client/director.rb', line 484

def list_snapshots(deployment_name, job = nil, index = nil)
  if job && index
    url = "/deployments/#{deployment_name}/jobs/#{job}/#{index}/snapshots"
  else
    url = "/deployments/#{deployment_name}/snapshots"
  end
  get_json(url)
end

#list_stemcells ⇒ Object 



115
116
117
 
# File 'lib/cli/client/director.rb', line 115

def list_stemcells
  get_json('/stemcells')
end

#list_vms(name) ⇒ Object 



201
202
203
204
 
# File 'lib/cli/client/director.rb', line 201

def list_vms(name)
  _, body = get_json_with_status("/deployments/#{name}/vms")
  body
end

#login(username, password) ⇒ Object 



62
63
64
65
 
# File 'lib/cli/client/director.rb', line 62

def (username, password)
  @credentials = BasicCredentials.new(username, password)
  authenticated?
end

#match_compiled_packages(manifest_yaml) ⇒ Object 



185
186
187
188
189
190
191
192
193
194
 
# File 'lib/cli/client/director.rb', line 185

def match_compiled_packages(manifest_yaml)
  url          = '/packages/matches_compiled'
  status, body = post(url, 'text/yaml', manifest_yaml)

  if status == 200
    JSON.parse(body)
  else
    err(parse_error_message(status, body))
  end
end

#match_packages(manifest_yaml) ⇒ Object 



174
175
176
177
178
179
180
181
182
183
 
# File 'lib/cli/client/director.rb', line 174

def match_packages(manifest_yaml)
  url          = '/packages/matches'
  status, body = post(url, 'text/yaml', manifest_yaml)

  if status == 200
    JSON.parse(body)
  else
    err(parse_error_message(status, body))
  end
end

#perform_cloud_scan(deployment_name, options = {}) ⇒ Object 



509
510
511
512
513
514
 
# File 'lib/cli/client/director.rb', line 509

def perform_cloud_scan(deployment_name, options = {})
  options = options.dup
  url     = "/deployments/#{deployment_name}/scans"

  request_and_track(:post, url, options)
end

#post(uri, content_type = nil, payload = nil, headers = {}, options = {}) ⇒ Object 



729
730
731
 
# File 'lib/cli/client/director.rb', line 729

def post(uri, content_type = nil, payload = nil, headers = {}, options = {})
  request(:post, uri, content_type, payload, headers, options)
end

#put(uri, content_type = nil, payload = nil, headers = {}, options = {}) ⇒ Object 



733
734
735
 
# File 'lib/cli/client/director.rb', line 733

def put(uri, content_type = nil, payload = nil, headers = {}, options = {})
  request(:put, uri, content_type, payload, headers, options)
end

#request_and_track(method, uri, options = {}) ⇒ Object

Perform director HTTP request and track director task (if request started one).

Parameters:

  • method (Symbol) —

    HTTP method

  • uri (String) —

    URI

  • options (Hash) (defaults to: {}) —

    Request and tracking options



644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
 
# File 'lib/cli/client/director.rb', line 644

def request_and_track(method, uri, options = {})
  options = options.dup

  content_type = options.delete(:content_type)
  payload      = options.delete(:payload)
  track_opts   = options

  http_status, _, headers = request(method, uri, content_type, payload)
  location                = headers[:location]
  redirected              = [302, 303].include? http_status
  task_id                 = nil

  if redirected
    if location =~ /\/tasks\/(\d+)\/?$/ # Looks like we received task URI
      task_id = $1
      if @track_tasks
        tracker = Bosh::Cli::TaskTracking::TaskTracker.new(self, task_id, track_opts)
        status  = tracker.track
      else
        status = :running
      end
    else
      status = :non_trackable
    end
  else
    status = :failed
  end

  [status, task_id]
end

#restore_db(filename) ⇒ Object 



606
607
608
 
# File 'lib/cli/client/director.rb', line 606

def restore_db(filename)
  upload_without_track('/restore', filename, { content_type: 'application/x-compressed' })
end

#setup_ssh(deployment_name, job, id, user, public_key, password, options = {}) ⇒ Object 



307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
 
# File 'lib/cli/client/director.rb', line 307

def setup_ssh(deployment_name, job, id, user,
  public_key, password, options = {})
  options = options.dup

  url = "/deployments/#{deployment_name}/ssh"

  payload = {
    'command'         => 'setup',
    'deployment_name' => deployment_name,
    'target'          => {
      'job'     => job,
      'indexes' => [id].compact, # for backwards compatibility with old director
      'ids' => [id].compact,
    },
    'params'          => {
      'user'       => user,
      'public_key' => public_key,
      'password'   => password
    }
  }

  options[:payload]      = JSON.generate(payload)
  options[:content_type] = 'application/json'

  request_and_track(:post, url, options)
end

#take_snapshot(deployment_name, job = nil, index = nil, options = {}) ⇒ Object 



472
473
474
475
476
477
478
479
480
481
482
 
# File 'lib/cli/client/director.rb', line 472

def take_snapshot(deployment_name, job = nil, index = nil, options = {})
  options = options.dup

  if job && index
    url = "/deployments/#{deployment_name}/jobs/#{job}/#{index}/snapshots"
  else
    url = "/deployments/#{deployment_name}/snapshots"
  end

  request_and_track(:post, url, options)
end

#update_cloud_config(cloud_config_yaml) ⇒ Object 



701
702
703
704
 
# File 'lib/cli/client/director.rb', line 701

def update_cloud_config(cloud_config_yaml)
  status, _ = post('/cloud_configs', 'text/yaml', cloud_config_yaml)
  status == 201
end

#update_property(deployment_name, property_name, value) ⇒ Object 



451
452
453
454
455
 
# File 'lib/cli/client/director.rb', line 451

def update_property(deployment_name, property_name, value)
  url     = "/deployments/#{deployment_name}/properties/#{property_name}"
  payload = JSON.generate('value' => value)
  put(url, 'application/json', payload)
end

#update_runtime_config(runtime_config_yaml) ⇒ Object 



717
718
719
720
 
# File 'lib/cli/client/director.rb', line 717

def update_runtime_config(runtime_config_yaml)
  status, _ = post('/runtime_configs', 'text/yaml', runtime_config_yaml)
  status == 201
end

#upload_and_track(method, uri, filename, options = {}) ⇒ Object 



675
676
677
678
679
680
 
# File 'lib/cli/client/director.rb', line 675

def upload_and_track(method, uri, filename, options = {})
  file = FileWithProgressBar.open(filename, 'r')
  request_and_track(method, uri, options.merge(:payload => file))
ensure
  file.stop_progress_bar if file
end

#upload_release(filename, options = {}) ⇒ Object 



219
220
221
222
223
224
 
# File 'lib/cli/client/director.rb', line 219

def upload_release(filename, options = {})
  options                = options.dup
  options[:content_type] = 'application/x-compressed'

  upload_and_track(:post, releases_path(options), filename, options)
end

#upload_remote_release(release_location, options = {}) ⇒ Object 



226
227
228
229
230
231
232
233
 
# File 'lib/cli/client/director.rb', line 226

def upload_remote_release(release_location, options = {})
  options                = options.dup
  payload                = { 'location' => release_location }
  options[:payload]      = JSON.generate(payload)
  options[:content_type] = 'application/json'

  request_and_track(:post, releases_path(options), options)
end

#upload_remote_stemcell(stemcell_location, options = {}) ⇒ Object 



97
98
99
100
101
102
103
104
105
 
# File 'lib/cli/client/director.rb', line 97

def upload_remote_stemcell(stemcell_location, options = {})
  options                = options.dup
  payload                = { 'location' => stemcell_location }
  payload[:sha1]         = options[:sha1] if options[:sha1]
  options[:payload]      = JSON.generate(payload)
  options[:content_type] = 'application/json'

  request_and_track(:post, stemcells_path(options), options)
end

#upload_stemcell(filename, options = {}) ⇒ Object 



90
91
92
93
94
95
 
# File 'lib/cli/client/director.rb', line 90

def upload_stemcell(filename, options = {})
  options                = options.dup
  options[:content_type] = 'application/x-compressed'

  upload_and_track(:post, stemcells_path(options), filename, options)
end

#upload_without_track(uri, filename, options = {}) ⇒ Object 



682
683
684
685
686
687
688
 
# File 'lib/cli/client/director.rb', line 682

def upload_without_track(uri, filename, options = {})
  file = FileWithProgressBar.open(filename, 'r')
  status, _ = post(uri, options[:content_type], file, {}, options)
  status
ensure
  file.stop_progress_bar if file
end

#uuid ⇒ Object 



42
43
44
 
# File 'lib/cli/client/director.rb', line 42

def uuid
  @uuid ||= get_status['uuid']
end

#wait_until_ready ⇒ Object 



55
56
57
58
59
60
 
# File 'lib/cli/client/director.rb', line 55

def wait_until_ready
  num_retries.times do
    return if exists?
    sleep retry_wait_interval
  end
end