knife-rackspace 0.11.0 → 0.11.1

Sign up to get free protection for your applications and to get access to all the features.
checksums.yaml CHANGED
@@ -1,15 +1,15 @@
1
1
  ---
2
2
  !binary "U0hBMQ==":
3
3
  metadata.gz: !binary |-
4
- M2NhZmI1NDM4OWUxODEwODI1ZGVmNWQ2YzgxZjBjNmJiYjMzOGVkYQ==
4
+ ODQzY2Q3NmUyODY1YmQ0OTUyN2Q5NjI1N2I3MTBmMDYxOGVkY2Y5MQ==
5
5
  data.tar.gz: !binary |-
6
- OTY4MTM0MTMzNzY5M2U4NWUwMmMxNmFhZWEyNjQ3YjQzYTdkNWMwZA==
6
+ MjY0YmQ3N2VhYTA4MjZiNmI1ZDAyZDJjMzMwMzQyYzI3ODdkZDcyOQ==
7
7
  SHA512:
8
8
  metadata.gz: !binary |-
9
- NTdjN2ZlMzBiNjUwZDZjODQ0M2U1YmQyODkwMTA0MGMyMTIxYjZmYTNhODQ5
10
- MGExY2U5NmEzMzc5MTUxMWE4YzkwZDBiMGJmNzMxZTAyODc2MzZmMjdiMjg1
11
- NzVlMWU0NWZlYjY1Yzc5MDU2OWE4MjI4NGUxMjM4N2I5MGFjZjQ=
9
+ YTJlMjM3ZThmZWJhYjQ3NTlkYjYzZGJjZjQ2YTQ4ZmQ2ZTMyYjZhMTU4N2Ux
10
+ NmZmOTIxMjhkYzNjYjM2ZDJmZjZjZGYyY2M2NTk4NDliM2QxMTY2ODRiYTQ1
11
+ YTExNmFhNGI5NzI2NTQ2NDhlMThlNjgxMWIzYTdlNTIzMGRmMDY=
12
12
  data.tar.gz: !binary |-
13
- YTVkNjkwMjM4MDM0YTZhZDdjNmEzZDhlYzY2OTk4NTA3MTdmODE2YjgyNzRj
14
- MzJjODA0MjY1MmFhNjY5NzFmMWFhMzY4YjhlZjQ4OTA1MTkwNGRlMjBiZTc4
15
- Mzk4MjE1OGU3ODkyOTM3NDJmMWQ1ZDcxYWQ5MGY4YjI4ZTdjN2E=
13
+ NGJiY2NiOTNiN2QzOGUxNmRkN2RlYjA0MTVmZGJmOWQ2NzA1ODBmZTEwNWI2
14
+ NDliY2I2ODRlMGE5NWM3OGFlZGY4ZDZjZjNhOWNiMjdmMDMyNDI3ZTRmZjhk
15
+ NWYzMDMyNDYwZDc1MWFiMDkwMjI2ZjgyMjJlNTczMDJkMDVmYzI=
data/.travis.yml CHANGED
@@ -1,3 +1,4 @@
1
+ sudo: false
1
2
  language: ruby
2
3
  rvm:
3
4
  - 2.2
@@ -8,7 +8,7 @@ Gem::Specification.new do |s|
8
8
  s.has_rdoc = true
9
9
  s.authors = ["Adam Jacob","Seth Chisamore", "Matt Ray","Rackspace Developers","JJ Asghar"]
10
10
  s.email = ["adam@chef.io","schisamo@chef.io", "matt@chef.io","jj@chef.io"]
11
- s.homepage = "https://docs.chef.io/plugin_knife_rackspace.html"
11
+ s.homepage = "https://github.com/chef/knife-rackspace"
12
12
  s.summary = "Rackspace Support for Chef's Knife Command"
13
13
  s.description = s.summary
14
14
  s.extra_rdoc_files = ["README.rdoc", "LICENSE" ]
@@ -17,11 +17,10 @@ Gem::Specification.new do |s|
17
17
  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
18
18
  s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
19
19
  s.add_dependency "knife-windows"
20
- s.add_dependency "fog", '>= 1.24'
21
- s.add_dependency "chef", ">= 0.10.10"
20
+ s.add_dependency "fog", '>= 1.35'
21
+ s.add_dependency "chef", ">= 11.0.0"
22
22
  s.require_paths = ["lib"]
23
23
 
24
- s.add_development_dependency "knife-dsl"
25
24
  s.add_development_dependency "rspec"
26
25
  s.add_development_dependency "vcr"
27
26
  s.add_development_dependency "ansi"
@@ -77,14 +77,17 @@ class Chef
77
77
  def connection
78
78
  Chef::Log.debug("version #{Chef::Config[:knife][:rackspace_version]} (config)")
79
79
  Chef::Log.debug("version #{config[:rackspace_version]} (cli)")
80
- Chef::Log.debug("rackspace_api_key #{Chef::Config[:knife][:rackspace_api_key]}")
81
- Chef::Log.debug("rackspace_username #{Chef::Config[:knife][:rackspace_username]}")
82
- Chef::Log.debug("rackspace_api_username #{Chef::Config[:knife][:rackspace_api_username]}")
83
- Chef::Log.debug("rackspace_auth_url #{Chef::Config[:knife][:rackspace_auth_url]}")
84
- Chef::Log.debug("rackspace_auth_url #{config[:rackspace_api_auth_url]}")
80
+ Chef::Log.debug("rackspace_api_key #{Chef::Config[:knife][:rackspace_api_key]} (config)")
81
+ Chef::Log.debug("rackspace_api_key #{config[:rackspace_api_key]} (cli)")
82
+ Chef::Log.debug("rackspace_username #{Chef::Config[:knife][:rackspace_username]} (config)")
83
+ Chef::Log.debug("rackspace_username #{config[:rackspace_username]} (cli)")
84
+ Chef::Log.debug("rackspace_api_username #{Chef::Config[:knife][:rackspace_api_username]} (config)")
85
+ Chef::Log.debug("rackspace_api_username #{config[:rackspace_api_username]} (cli)")
86
+ Chef::Log.debug("rackspace_auth_url #{Chef::Config[:knife][:rackspace_auth_url]} (config)")
87
+ Chef::Log.debug("rackspace_auth_url #{config[:rackspace_api_auth_url]} (cli)")
85
88
  Chef::Log.debug("rackspace_auth_url #{auth_endpoint} (using)")
86
- Chef::Log.debug("rackspace_region #{Chef::Config[:knife][:rackspace_region]}")
87
- Chef::Log.debug("rackspace_region #{config[:rackspace_region]}")
89
+ Chef::Log.debug("rackspace_region #{Chef::Config[:knife][:rackspace_region]} (config)")
90
+ Chef::Log.debug("rackspace_region #{config[:rackspace_region]} (cli)")
88
91
 
89
92
  if version_one?
90
93
  Chef::Log.debug("rackspace v1")
@@ -105,7 +108,7 @@ class Chef
105
108
  end
106
109
 
107
110
  def region_warning_for_v1
108
- if Chef::Config[:knife][:rackspace_region] || config[:rackspace_region]
111
+ if locate_config_value(:rackspace_region)
109
112
  Chef::Log.warn("Ignoring the rackspace_region parameter as it is only supported for Next Gen Cloud Servers (v2)")
110
113
  end
111
114
  end
@@ -116,10 +119,21 @@ class Chef
116
119
  exit 1
117
120
  end
118
121
 
122
+ username = locate_config_value(:rackspace_username) || locate_config_value(:rackspace_api_username)
123
+ unless username
124
+ ui.error "Please specify an api username via the command line using the --rackspace-username switch or add a knife[:rackspace_username] = USERNAME to your knife file."
125
+ exit 1
126
+ end
127
+
128
+ unless locate_config_value(:rackspace_api_key)
129
+ ui.error "Please specify an api key via the command line using the --rackspace-api-key switch or add a knife[:rackspace_api_key] = USERNAME to your knife file."
130
+ exit 1
131
+ end
132
+
119
133
  hash = options.merge({
120
134
  :provider => 'Rackspace',
121
- :rackspace_api_key => Chef::Config[:knife][:rackspace_api_key],
122
- :rackspace_username => (Chef::Config[:knife][:rackspace_username] || Chef::Config[:knife][:rackspace_api_username]),
135
+ :rackspace_api_key => locate_config_value(:rackspace_api_key),
136
+ :rackspace_username => username,
123
137
  :rackspace_auth_url => auth_endpoint,
124
138
  :rackspace_region => locate_config_value(:rackspace_region)
125
139
  })
@@ -54,6 +54,12 @@ class Chef
54
54
  :description => "The image of the server",
55
55
  :proc => Proc.new { |i| Chef::Config[:knife][:image] = i.to_s }
56
56
 
57
+ option :boot_volume_size,
58
+ :long => "--boot-volume-size GB",
59
+ :description => "The size of the CBS to use as the server's boot device",
60
+ :proc => Proc.new { |i| Chef::Config[:knife][:boot_volume_size] = i.to_s },
61
+ :default => 100
62
+
57
63
  option :boot_volume_id,
58
64
  :short => "-B BOOT_VOLUME_ID",
59
65
  :long => "--boot-volume-id UUID",
@@ -106,7 +112,8 @@ class Chef
106
112
 
107
113
  option :prerelease,
108
114
  :long => "--prerelease",
109
- :description => "Install the pre-release chef gems"
115
+ :description => "Install the pre-release chef gems",
116
+ :default => false
110
117
 
111
118
  option :bootstrap_version,
112
119
  :long => "--bootstrap-version VERSION",
@@ -143,8 +150,8 @@ class Chef
143
150
  :short => "-M JSON",
144
151
  :long => "--rackspace-metadata JSON",
145
152
  :description => "JSON string version of metadata hash to be supplied with the server create call",
146
- :proc => Proc.new { |m| Chef::Config[:knife][:rackspace_metadata] = JSON.parse(m) },
147
- :default => ""
153
+ :proc => lambda { |m| JSON.parse(m) },
154
+ :default => {}
148
155
 
149
156
  option :rackconnect_wait,
150
157
  :long => "--rackconnect-wait",
@@ -232,9 +239,8 @@ class Chef
232
239
 
233
240
  option :rackspace_disk_config,
234
241
  :long => "--rackspace-disk-config DISKCONFIG",
235
- :description => "Specify if want to manage your own disk partitioning scheme (AUTO or MANUAL), default is AUTO",
236
- :proc => Proc.new { |k| Chef::Config[:knife][:rackspace_disk_config] = k },
237
- :default => "AUTO"
242
+ :description => "Specify if want to manage your own disk partitioning scheme (AUTO or MANUAL)",
243
+ :proc => Proc.new { |k| Chef::Config[:knife][:rackspace_disk_config] = k }
238
244
 
239
245
  option :rackspace_config_drive,
240
246
  :long => "--rackspace_config_drive CONFIGDRIVE",
@@ -286,9 +292,9 @@ class Chef
286
292
  end
287
293
 
288
294
  def tcp_test_ssh(server, bootstrap_ip)
289
- return true unless config[:tcp_test_ssh] != nil
295
+ return true unless locate_config_value(:tcp_test_ssh) != nil
290
296
 
291
- limit = Chef::Config[:knife][:retry_ssh_limit].to_i
297
+ limit = locate_config_value(:retry_ssh_limit).to_i
292
298
  count = 0
293
299
 
294
300
  begin
@@ -301,7 +307,7 @@ class Chef
301
307
 
302
308
  if count <= limit
303
309
  print '.'
304
- sleep config[:retry_ssh_every].to_i
310
+ sleep locate_config_value(:retry_ssh_every).to_i
305
311
  tcp_test_ssh(server, bootstrap_ip)
306
312
  else
307
313
  ui.error "Unable to SSH into #{bootstrap_ip}"
@@ -372,18 +378,18 @@ class Chef
372
378
  $stdout.sync = true
373
379
 
374
380
  server_create_options = {
375
- :metadata => Chef::Config[:knife][:rackspace_metadata],
376
- :disk_config => Chef::Config[:knife][:rackspace_disk_config],
381
+ :metadata => locate_config_value(:rackspace_metadata),
382
+ :disk_config => locate_config_value(:rackspace_disk_config),
377
383
  :user_data => user_data,
378
384
  :config_drive => locate_config_value(:rackspace_config_drive) || false,
379
385
  :personality => files,
380
- :key_name => Chef::Config[:knife][:rackspace_ssh_keypair],
386
+ :key_name => locate_config_value(:rackspace_ssh_keypair),
381
387
  :name => get_node_name(config[:chef_node_name] || config[:server_name]),
382
- :networks => get_networks(Chef::Config[:knife][:rackspace_networks], Chef::Config[:knife][:rackconnect_v3_network_id]),
388
+ :networks => get_networks(locate_config_value(:rackspace_networks), locate_config_value(:rackconnect_v3_network_id)),
383
389
  }
384
390
 
385
391
  # Maybe deprecate this option at some point
386
- config[:bootstrap_network] = 'private' if config[:private_network]
392
+ config[:bootstrap_network] = 'private' if locate_config_value(:private_network)
387
393
 
388
394
  flavor_id = locate_config_value(:flavor)
389
395
  flavor = connection.flavors.get(flavor_id)
@@ -401,15 +407,16 @@ class Chef
401
407
  # swap out the image_id argument with the boot_image_id argument.
402
408
  if flavor.disk == 0
403
409
  server_create_options[:image_id] = ''
404
- server_create_options[:boot_volume_id] = Chef::Config[:knife][:boot_volume_id]
405
- server_create_options[:boot_image_id] = Chef::Config[:knife][:image]
410
+ server_create_options[:boot_volume_id] = locate_config_value(:boot_volume_id)
411
+ server_create_options[:boot_image_id] = locate_config_value(:image)
412
+ server_create_options[:boot_volume_size] = locate_config_value(:boot_volume_size)
406
413
 
407
414
  if server_create_options[:boot_image_id] && server_create_options[:boot_volume_id]
408
- ui.error('Please specify exactly one of --boot-volume-id (-B) and --image (-I)')
415
+ ui.error('Please specify either --boot-volume-id (-B) or --image (-I)')
409
416
  exit 1
410
417
  end
411
418
  else
412
- server_create_options[:image_id] = Chef::Config[:knife][:image]
419
+ server_create_options[:image_id] = locate_config_value(:image)
413
420
 
414
421
  if !server_create_options[:image_id]
415
422
  ui.error('Please specify an Image ID for the server with --image (-I)')
@@ -429,8 +436,8 @@ class Chef
429
436
  server.save(:networks => server_create_options[:networks])
430
437
  end
431
438
 
432
- rackconnect_wait = Chef::Config[:knife][:rackconnect_wait] || config[:rackconnect_wait]
433
- rackspace_servicelevel_wait = Chef::Config[:knife][:rackspace_servicelevel_wait] || config[:rackspace_servicelevel_wait]
439
+ rackconnect_wait = locate_config_value(:rackconnect_wait)
440
+ rackspace_servicelevel_wait = locate_config_value(:rackspace_servicelevel_wait)
434
441
 
435
442
  msg_pair("Instance ID", server.id)
436
443
  msg_pair("Host ID", server.host_id)
@@ -440,11 +447,11 @@ class Chef
440
447
  msg_pair("Boot Image ID", server.boot_image_id) if server.boot_image_id
441
448
  msg_pair("Metadata", server.metadata.all)
442
449
  msg_pair("ConfigDrive", server.config_drive)
443
- msg_pair("UserData", Chef::Config[:knife][:rackspace_user_data])
450
+ msg_pair("UserData", locate_config_value(:rackspace_user_data))
444
451
  msg_pair("RackConnect Wait", rackconnect_wait ? 'yes' : 'no')
445
- msg_pair("RackConnect V3", Chef::Config[:knife][:rackconnect_v3_network_id] ? 'yes' : 'no')
452
+ msg_pair("RackConnect V3", locate_config_value(:rackconnect_v3_network_id) ? 'yes' : 'no')
446
453
  msg_pair("ServiceLevel Wait", rackspace_servicelevel_wait ? 'yes' : 'no')
447
- msg_pair("SSH Key", Chef::Config[:knife][:rackspace_ssh_keypair])
454
+ msg_pair("SSH Key", locate_config_value(:rackspace_ssh_keypair))
448
455
 
449
456
  # wait for it to be ready to do stuff
450
457
  begin
@@ -480,7 +487,7 @@ class Chef
480
487
 
481
488
  puts("\n")
482
489
 
483
- if Chef::Config[:knife][:rackconnect_v3_network_id]
490
+ if locate_config_value(:rackconnect_v3_network_id)
484
491
  print "\n#{ui.color("Setting up RackconnectV3 network and IPs", :magenta)}"
485
492
  setup_rackconnect_network!(server)
486
493
  while server.ipv4_address == ""
@@ -489,8 +496,8 @@ class Chef
489
496
  end
490
497
  end
491
498
 
492
- if server_create_options[:networks] && Chef::Config[:knife][:rackspace_networks]
493
- msg_pair("Networks", Chef::Config[:knife][:rackspace_networks].sort.join(', '))
499
+ if server_create_options[:networks] && locate_config_value(:rackspace_networks)
500
+ msg_pair("Networks", locate_config_value(:rackspace_networks).sort.join(', '))
494
501
  end
495
502
 
496
503
  msg_pair("Public DNS Name", public_dns_name(server))
@@ -499,7 +506,7 @@ class Chef
499
506
  msg_pair("Password", server.password)
500
507
  msg_pair("Metadata", server.metadata.all)
501
508
 
502
- bootstrap_ip_address = ip_address(server, config[:bootstrap_network])
509
+ bootstrap_ip_address = ip_address(server, locate_config_value(:bootstrap_network))
503
510
 
504
511
  Chef::Log.debug("Bootstrap IP Address #{bootstrap_ip_address}")
505
512
  if bootstrap_ip_address.nil?
@@ -554,7 +561,7 @@ class Chef
554
561
  end
555
562
 
556
563
  def user_data
557
- file = Chef::Config[:knife][:rackspace_user_data]
564
+ file = locate_config_value(:rackspace_user_data)
558
565
  return unless file
559
566
 
560
567
  begin
@@ -570,16 +577,16 @@ class Chef
570
577
  def bootstrap_for_node(server, bootstrap_ip_address)
571
578
  bootstrap = Chef::Knife::Bootstrap.new
572
579
  bootstrap.name_args = [bootstrap_ip_address]
573
- bootstrap.config[:ssh_user] = config[:ssh_user] || "root"
580
+ bootstrap.config[:ssh_user] = locate_config_value(:ssh_user) || "root"
574
581
  bootstrap.config[:ssh_password] = server.password
575
- bootstrap.config[:ssh_port] = config[:ssh_port] || Chef::Config[:knife][:ssh_port]
576
- bootstrap.config[:identity_file] = config[:identity_file]
577
- bootstrap.config[:host_key_verify] = config[:host_key_verify]
578
- bootstrap.config[:bootstrap_vault_file] = config[:bootstrap_vault_file] if config[:bootstrap_vault_file]
579
- bootstrap.config[:bootstrap_vault_json] = config[:bootstrap_vault_json] if config[:bootstrap_vault_json]
580
- bootstrap.config[:bootstrap_vault_item] = config[:bootstrap_vault_item] if config[:bootstrap_vault_item]
582
+ bootstrap.config[:ssh_port] = locate_config_value(:ssh_port)
583
+ bootstrap.config[:identity_file] = locate_config_value(:identity_file)
584
+ bootstrap.config[:host_key_verify] = locate_config_value(:host_key_verify)
585
+ bootstrap.config[:bootstrap_vault_file] = locate_config_value(:bootstrap_vault_file) if locate_config_value(:bootstrap_vault_file)
586
+ bootstrap.config[:bootstrap_vault_json] = locate_config_value(:bootstrap_vault_json) if locate_config_value(:bootstrap_vault_json)
587
+ bootstrap.config[:bootstrap_vault_item] = locate_config_value(:bootstrap_vault_item) if locate_config_value(:bootstrap_vault_item)
581
588
  # bootstrap will run as root...sudo (by default) also messes up Ohai on CentOS boxes
582
- bootstrap.config[:use_sudo] = true unless config[:ssh_user] == 'root'
589
+ bootstrap.config[:use_sudo] = true unless locate_config_value(:ssh_user) == 'root'
583
590
  bootstrap.config[:distro] = locate_config_value(:distro) || 'chef-full'
584
591
  bootstrap_common_params(bootstrap, server)
585
592
  end
@@ -592,13 +599,14 @@ class Chef
592
599
  else
593
600
  bootstrap.config[:chef_node_name] = config[:chef_node_name] || server.name
594
601
  end
595
- bootstrap.config[:prerelease] = config[:prerelease]
602
+ bootstrap.config[:prerelease] = locate_config_value(:prerelease)
596
603
  bootstrap.config[:bootstrap_version] = locate_config_value(:bootstrap_version)
597
604
  bootstrap.config[:template_file] = locate_config_value(:template_file)
598
- bootstrap.config[:first_boot_attributes] = config[:first_boot_attributes]
605
+ bootstrap.config[:first_boot_attributes] = locate_config_value(:first_boot_attributes)
599
606
  bootstrap.config[:bootstrap_proxy] = locate_config_value(:bootstrap_proxy)
600
- bootstrap.config[:encrypted_data_bag_secret] = config[:encrypted_data_bag_secret]
601
- bootstrap.config[:encrypted_data_bag_secret_file] = config[:encrypted_data_bag_secret_file]
607
+ # TODO: Remove dead code. There's no command line parameter for these two.
608
+ # bootstrap.config[:encrypted_data_bag_secret] = config[:encrypted_data_bag_secret]
609
+ # bootstrap.config[:encrypted_data_bag_secret_file] = config[:encrypted_data_bag_secret_file]
602
610
  bootstrap.config[:secret] = locate_config_value(:secret)
603
611
  bootstrap.config[:secret_file] = locate_config_value(:secret_file) || ""
604
612
 
@@ -629,16 +637,16 @@ class Chef
629
637
  def get_networks(names, rackconnect3=false)
630
638
  names = Array(names)
631
639
 
632
- if(Chef::Config[:knife][:rackspace_version] == 'v2')
633
- if rackconnect3
634
- nets = [Chef::Config[:knife][:rackconnect_v3_network_id]]
635
- elsif config[:default_networks]
636
- nets = [
640
+ if(locate_config_value(:rackspace_version) == 'v2')
641
+ nets = if rackconnect3
642
+ [locate_config_value(:rackconnect_v3_network_id)]
643
+ elsif locate_config_value(:default_networks)
644
+ [
637
645
  '00000000-0000-0000-0000-000000000000',
638
646
  '11111111-1111-1111-1111-111111111111'
639
647
  ]
640
648
  else
641
- nets = []
649
+ []
642
650
  end
643
651
 
644
652
  available_networks = connection.networks.all
@@ -67,6 +67,7 @@ class Chef
67
67
  msg_pair("Name", server.name)
68
68
  msg_pair("Flavor", server.flavor.name)
69
69
  msg_pair("Image", server.image.name) if server.image
70
+ msg_pair("Boot Image ID", server.boot_image_id) if server.boot_image_id
70
71
  msg_pair("Public IP Address", ip_address(server, 'public'))
71
72
  msg_pair("Private IP Address", ip_address(server, 'private'))
72
73
 
@@ -1,6 +1,6 @@
1
1
  module Knife
2
2
  module Rackspace
3
- VERSION = '0.11.0'
3
+ VERSION = '0.11.1'
4
4
  MAJOR, MINOR, TINY = VERSION.split('.')
5
5
  end
6
6
  end
metadata CHANGED
@@ -1,7 +1,7 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: knife-rackspace
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.11.0
4
+ version: 0.11.1
5
5
  platform: ruby
6
6
  authors:
7
7
  - Adam Jacob
@@ -12,7 +12,7 @@ authors:
12
12
  autorequire:
13
13
  bindir: bin
14
14
  cert_chain: []
15
- date: 2015-09-08 00:00:00.000000000 Z
15
+ date: 2016-05-03 00:00:00.000000000 Z
16
16
  dependencies:
17
17
  - !ruby/object:Gem::Dependency
18
18
  name: knife-windows
@@ -34,42 +34,28 @@ dependencies:
34
34
  requirements:
35
35
  - - ! '>='
36
36
  - !ruby/object:Gem::Version
37
- version: '1.24'
37
+ version: '1.35'
38
38
  type: :runtime
39
39
  prerelease: false
40
40
  version_requirements: !ruby/object:Gem::Requirement
41
41
  requirements:
42
42
  - - ! '>='
43
43
  - !ruby/object:Gem::Version
44
- version: '1.24'
44
+ version: '1.35'
45
45
  - !ruby/object:Gem::Dependency
46
46
  name: chef
47
47
  requirement: !ruby/object:Gem::Requirement
48
48
  requirements:
49
49
  - - ! '>='
50
50
  - !ruby/object:Gem::Version
51
- version: 0.10.10
51
+ version: 11.0.0
52
52
  type: :runtime
53
53
  prerelease: false
54
54
  version_requirements: !ruby/object:Gem::Requirement
55
55
  requirements:
56
56
  - - ! '>='
57
57
  - !ruby/object:Gem::Version
58
- version: 0.10.10
59
- - !ruby/object:Gem::Dependency
60
- name: knife-dsl
61
- requirement: !ruby/object:Gem::Requirement
62
- requirements:
63
- - - ! '>='
64
- - !ruby/object:Gem::Version
65
- version: '0'
66
- type: :development
67
- prerelease: false
68
- version_requirements: !ruby/object:Gem::Requirement
69
- requirements:
70
- - - ! '>='
71
- - !ruby/object:Gem::Version
72
- version: '0'
58
+ version: 11.0.0
73
59
  - !ruby/object:Gem::Dependency
74
60
  name: rspec
75
61
  requirement: !ruby/object:Gem::Requirement
@@ -165,7 +151,7 @@ files:
165
151
  - spec/integration_spec_helper.rb
166
152
  - spec/spec_helper.rb
167
153
  - spec/unit/rackspace_base_spec.rb
168
- homepage: https://docs.chef.io/plugin_knife_rackspace.html
154
+ homepage: https://github.com/chef/knife-rackspace
169
155
  licenses: []
170
156
  metadata: {}
171
157
  post_install_message: