module CORL::Vagrant::Config

Public Class Methods

check_numeric(string) click to toggle source
    # File lib/core/vagrant/config.rb
540 def self.check_numeric(string)
541   return true if string =~ /^\d+$/
542   begin
543     Float(string)
544     return true
545   rescue
546     return false
547   end
548 end
configure_provider_overrides(provider, machine, config, data, already_processed, parents = [], indent = '') click to toggle source
    # File lib/core/vagrant/config.rb
442 def self.configure_provider_overrides(provider, machine, config, data, already_processed, parents = [], indent = '')
443   data.each do |name, info|
444     label = (parents.empty? ? name : "#{parents.join('.')}.#{name}")
445 
446     if info.is_a?(Hash)
447       configure_provider_overrides(provider, machine.send(name), config.send(name), info, already_processed, [ parents, name].flatten, indent)
448     else
449       if machine.respond_to?("#{name}=")
450         render("#{indent}override.#{label} = %property", { :property => info }) unless already_processed
451         config.send("#{name}=", info)
452       else
453         params = parse_params(info)
454         render("#{indent}override.#{label} %params", { :params => params }) unless already_processed
455         config.send(name, params)
456       end
457     end
458   end
459 end
configure_provisioner(network, node, machine, &code) click to toggle source
    # File lib/core/vagrant/config.rb
425 def self.configure_provisioner(network, node, machine, &code)
426   success = true
427 
428   unless node[:docker_host]
429     # CORL provisioning
430     machine.vm.provision :corl do |provisioner|
431       provisioner.network = network
432       provisioner.node    = node
433 
434       code.call(node, machine, provisioner) if code
435     end
436   end
437   success
438 end
configure_shares(node, provider, machine, already_processed, indent = '') click to toggle source
    # File lib/core/vagrant/config.rb
371 def self.configure_shares(node, provider, machine, already_processed, indent = '')
372   use_nfs          = provider.to_sym != :docker
373   bindfs_installed = Gems.exist?('vagrant-bindfs')
374   success          = true
375 
376   if use_nfs && bindfs_installed
377     machine.vm.synced_folder ".", "/vagrant", disabled: true
378 
379     unless ENV['CORL_NO_NETWORK_SHARE']
380       machine.vm.synced_folder ".", "/tmp/vagrant", :type => "nfs"
381       machine.bindfs.bind_folder "/tmp/vagrant", "/vagrant"
382     end
383   end
384 
385   render("\n") unless already_processed
386 
387   Util::Data.hash(node.shares).each do |name, options|
388     config = CORL::Config.ensure(options)
389 
390     if config[:type].to_sym == :nfs && ! use_nfs
391       config.delete(:type)
392     end
393 
394     share_type = config.get(:type, nil)
395     local_dir  = config.delete(:local, '')
396     remote_dir = config.delete(:remote, '')
397 
398     config.init(:create, true)
399 
400     unless local_dir.empty? || remote_dir.empty?
401       bindfs_options = config.delete(:bindfs, {})
402       share_options  = {}
403 
404       config.keys.each do |key|
405         share_options[key] = Util::Data.value(config[key])
406       end
407 
408       if share_type && share_type.to_sym == :nfs && bindfs_installed
409         final_dir  = remote_dir
410         remote_dir = [ '/tmp', remote_dir.sub(/^\//, '') ].join('/')
411 
412         render("#{indent}override.bindfs.bind_folder '#{remote_dir}', '#{final_dir}', %params", { :params => bindfs_options }) unless already_processed
413         machine.bindfs.bind_folder remote_dir, final_dir, bindfs_options
414       end
415 
416       render("#{indent}override.vm.synced_folder '#{local_dir}', '#{remote_dir}', %params", { :params => share_options }) unless already_processed
417       machine.vm.synced_folder local_dir, remote_dir, share_options
418     end
419   end
420   success
421 end
configure_ssh(node, machine) click to toggle source
    # File lib/core/vagrant/config.rb
131 def self.configure_ssh(node, machine)
132   success = true
133 
134   render("  node.ssh.username = %property", { :property => node.user })
135   machine.ssh.username = node.user
136 
137   render("  node.ssh.guest_port = %property", { :property => node.ssh_port })
138   machine.ssh.guest_port = node.ssh_port
139 
140   if node.cache_setting(:use_private_key, false)
141     key_dir     = node.network.key_cache_directory
142     key_name    = node.plugin_name
143 
144     ssh_config  = ::CORL::Config.new({
145       :keypair  => node.keypair,
146       :key_dir  => key_dir,
147       :key_name => key_name
148     })
149 
150     if keypair = Util::SSH.unlock_private_key(node.private_key, ssh_config)
151       if keypair.is_a?(String)
152         render("  node.ssh.private_key_path = %property", { :property => keypair })
153         machine.ssh.private_key_path = keypair
154       else
155         private_key_file = keypair.private_key_file(key_dir, key_name)
156         node.keypair     = keypair
157         render("  node.ssh.private_key_path = %property", { :property => private_key_file })
158         machine.ssh.private_key_path = private_key_file
159       end
160     end
161     unless keypair && File.exists?(machine.ssh.private_key_path)
162       render("  node.ssh.private_key_path = %property", { :property => node.private_key })
163       machine.ssh.private_key_path = node.private_key
164     end
165   end
166 
167   render("\n")
168 
169   Util::Data.hash(node.ssh).each do |name, data|
170     if machine.ssh.respond_to?("#{name}=")
171       data = Util::Data.value(data)
172       render("  node.ssh.#{name} = %property", { :property => data })
173       machine.ssh.send("#{name}=", data)
174     else
175       params = parse_params(data)
176       render("  node.ssh.#{name} %params", { :params => params })
177       machine.ssh.send(name, params)
178     end
179   end
180   success
181 end
configure_vagrant(network, vagrant) click to toggle source
    # File lib/core/vagrant/config.rb
113 def self.configure_vagrant(network, vagrant)
114   success = true
115   Util::Data.hash(network.settings(:vagrant_config)).each do |name, data|
116     if vagrant.respond_to?("#{name}=")
117       data = Util::Data.value(data)
118       render("config.vagrant.#{name} = %property", { :property => data })
119       vagrant.send("#{name}=", data)
120     else
121       params = parse_params(data)
122       render("config.vagrant.#{name} %params", { :params => params })
123       vagrant.send(name, params)
124     end
125   end
126   success
127 end
configure_vm(node, machine) click to toggle source
    # File lib/core/vagrant/config.rb
185 def self.configure_vm(node, machine)
186   vm_config = Util::Data.hash(Util::Data.clone(node.vm))
187   success   = true
188 
189   render("  node.vm.hostname = %property", { :property => node.hostname })
190   machine.vm.hostname = node.hostname
191 
192   box      = node.cache_setting(:box)
193   box_url  = node.cache_setting(:box_url)
194   box_file = nil
195 
196   if box_url
197     box_file = box_url.gsub(/^file\:\/\//, '')
198     unless File.exists?(box_file)
199       box_url = nil
200       node.clear_cache
201     end
202   end
203 
204   if vm_config.has_key?(:private_network)
205     network_options = Util::Data.hash(vm_config[:private_network])
206 
207     if node[:public_ip]
208       network_options[:ip] = node[:public_ip]
209     end
210     render("  node.vm.network :private_network, %params", { :params => network_options })
211     machine.vm.network :private_network, network_options
212     vm_config.delete(:private_network)
213     render("\n")
214 
215   elsif vm_config.has_key?(:public_network)
216     network_options = Util::Data.hash(vm_config[:public_network])
217 
218     render("  node.vm.network :public_network, %params", { :params => network_options })
219     machine.vm.network :public_network, network_options
220     vm_config.delete(:public_network)
221     render("\n")
222   end
223 
224   if vm_config.has_key?(:provision)
225     Util::Data.array(vm_config[:provision]).each do |provisioner|
226       if provisioner.is_a?(String)
227         render("  node.vm.provision :#{provisioner}")
228         machine.vm.provision provisioner
229       else
230         provision_options = Util::Data.symbol_map(provisioner)
231         provision_type    = provision_options.delete(:type)
232 
233         if provision_type
234           render("  node.vm.provision :#{provision_type}, %params", { :params => provision_options })
235           machine.vm.provision provision_type, provision_options
236         end
237       end
238     end
239     vm_config.delete(:provision)
240   end
241 
242   vm_config.each do |name, data|
243     case name.to_sym
244     # Network interfaces
245     when :forwarded_ports
246       data.each do |forward_name, info|
247         forward_config = CORL::Config.new({ :auto_correct => true }).import(info)
248 
249         forward_config.keys do |key|
250           forward_config[key] = Util::Data.value(forward_config[key])
251         end
252         forward_options = forward_config.export
253         render("  node.vm.network :forwarded_port, %params", { :params => forward_options })
254         machine.vm.network :forwarded_port, forward_options
255       end
256       render("\n")
257     when :usable_port_range
258       low, high = data.to_s.split(/\s*--?\s*/)
259       render("  node.vm.usable_port_range = #{low}..#{high}")
260       machine.vm.usable_port_range = Range.new(low, high)
261 
262     # Provider specific settings
263     when :providers
264       data.each do |provider, info|
265         provider          = provider.to_sym
266         info              = Util::Data.symbol_map(info)
267         already_processed = {}
268 
269         machine.vm.provider provider do |interface, override|
270           render("  node.vm.provider '#{provider}' do |provider, override|  # for #{node.hostname}") unless already_processed[provider]
271 
272           if info.has_key?(:private_network)
273             network_options = info[:private_network].is_a?(Hash) ? info[:private_network] : { :ip => info[:private_network] }
274 
275             render("    node.vm.network :private_network, %params", { :params => network_options }) unless already_processed[provider]
276             machine.vm.network :private_network, network_options
277             info.delete(:private_network)
278 
279           elsif info.has_key?(:public_network)
280             network_options = info[:public_network].is_a?(Hash) ? info[:public_network] : { :ip => info[:public_network] }
281 
282             render("    node.vm.network :public_network, %params", { :params => network_options })
283             machine.vm.network :public_network, network_options
284             info.delete(:public_network)
285           end
286 
287           if info.has_key?(:override) && info[:override].has_key?(:provision)
288             Util::Data.array(info[:override][:provision]).each do |provisioner|
289               if provisioner.is_a?(String)
290                 render("    override.vm.provision :#{provisioner}")
291                 override.vm.provision provisioner
292               else
293                 provision_options = Util::Data.symbol_map(provisioner)
294                 provision_type    = provision_options.delete(:type)
295 
296                 if provision_type
297                   render("    override.vm.provision :#{provision_type}, %params", { :params => provision_options })
298                   override.vm.provision provision_type, provision_options
299                 end
300               end
301             end
302             info[:override].delete(:provision)
303           end
304 
305           info.each do |property, item|
306             if property.to_sym == :override
307               configure_provider_overrides(provider, machine, override, item, already_processed[provider], [], '    ')
308             else
309               if interface.respond_to?("#{property}=")
310                 render("    provider.#{property} = %property", { :property => item }) unless already_processed[provider]
311                 interface.send("#{property}=", item)
312               else
313                 params = parse_params(item)
314                 render("    provider.#{property} %params", { :params => params }) unless already_processed[provider]
315                 interface.send(property, params)
316               end
317             end
318           end
319 
320           if box || box_url
321             if provider != :docker
322               if box && box_url
323                 render("    override.vm.box = %property", { :property => box }) unless already_processed[provider]
324                 override.vm.box = box
325 
326                 render("    override.vm.box_url = %property", { :property => box_url }) unless already_processed[provider]
327                 override.vm.box_url = box_url
328               end
329             else
330               if box_file
331                 render("    provider.build_dir = %property", { :property => box_file }) unless already_processed[provider]
332                 interface.build_dir = box_file
333               else
334                 render("    provider.image = %property", { :property => box }) unless already_processed[provider]
335                 interface.image = box
336               end
337             end
338             render("\n")
339           end
340 
341           # Server shares
342           unless configure_shares(node, provider, override, already_processed[provider], '    ')
343             raise "Configuration of Vagrant shares failed: #{node_name}"
344           end
345 
346           unless already_processed[provider]
347             render("  end")
348             render("\n")
349           end
350           already_processed[provider] = 1
351         end
352       end
353     # All other basic VM settings...
354     else
355       if machine.vm.respond_to?("#{name}=")
356         render("  node.vm.#{name} = %property", { :property => data })
357         machine.vm.send("#{name}=", data)
358       else
359         params = parse_params(data)
360         render("  node.vm.#{name} %params", { :params => params })
361         machine.vm.send(name, params)
362       end
363     end
364     render("\n")
365   end
366   success
367 end
load_network(directory) click to toggle source
    # File lib/core/vagrant/config.rb
106 def self.load_network(directory)
107   # Load network if it exists
108   @@network = CORL.network(directory, CORL.config(:vagrant_network, { :directory => directory }))
109 end
logger() click to toggle source
   # File lib/core/vagrant/config.rb
42 def self.logger
43   @@logger
44 end
network() click to toggle source
   # File lib/core/vagrant/config.rb
55 def self.network
56   @@network
57 end
network=(network) click to toggle source
   # File lib/core/vagrant/config.rb
51 def self.network=network
52   @@network = network
53 end
parse_params(data) click to toggle source
    # File lib/core/vagrant/config.rb
463 def self.parse_params(data)
464   params = data
465   if data.is_a?(Hash)
466     params = []
467     data.each do |key, item|
468       unless Util::Data.undef?(item)
469         params << ( key.match(/^\:/) ? key.gsub(/^\:/, '').to_sym : key.to_s )
470         unless Util::Data.empty?(item)
471           value = item
472           value = ((item.is_a?(String) && item.match(/^\:/)) ? item.gsub(/^\:/, '').to_sym : item)
473           params << Util::Data.value(value)
474         end
475       end
476     end
477   end
478   params
479 end
register(directory, config, &code) click to toggle source

Gateway CORL configurator for Vagrant.

    # File lib/core/vagrant/config.rb
 67 def self.register(directory, config, &code)
 68   ::Vagrant.require_version ">= 1.5.0"
 69 
 70   config_network = network
 71   config_network = load_network(directory) unless config_network
 72 
 73   if config_network
 74     # Vagrant settings
 75     unless configure_vagrant(config_network, config.vagrant)
 76       raise "Configuration of Vagrant general settings failed"
 77     end
 78 
 79     config_network.nodes(:vagrant, true).each do |node_name, node|
 80       config.vm.define node.id.to_sym do |machine|
 81         render("\n")
 82         render("config.vm.define '#{node.id}' do |node|")
 83 
 84         # SSH settings
 85         unless configure_ssh(node, machine)
 86           raise "Configuration of Vagrant VM SSH settings failed"
 87         end
 88 
 89         # VM settings
 90         unless configure_vm(node, machine)
 91           raise "Configuration of Vagrant VM failed: #{node_name}"
 92         end
 93 
 94         # Provisioner configuration
 95         unless configure_provisioner(network, node, machine, &code)
 96           raise "Configuration of Vagrant provisioner failed: #{node_name}"
 97         end
 98       end
 99     end
100   end
101   @@rerender = true
102 end
render(statement, inputs = {}) click to toggle source
    # File lib/core/vagrant/config.rb
483 def self.render(statement, inputs = {})
484   return unless [ :debug, :info, :warn, :error ].include?(Nucleon.log_level)
485 
486   if statement =~ /^\s+$/
487     puts statement
488   else
489     Util::Data.clone(inputs).each do |name, data|
490       rendered_data = render_value(data)
491 
492       if rendered_data.empty?
493         statement.gsub!(/,\s*$/, '')
494       end
495       statement.gsub!("\%#{name}", rendered_data)
496     end
497     Core.ui_group('') do |ui|
498       ui.success(statement, { :prefix => false })
499     end
500   end
501 end
render_value(data) click to toggle source
    # File lib/core/vagrant/config.rb
505 def self.render_value(data)
506   rendered_value = ''
507 
508   case data
509   when Hash
510     keypairs = []
511     data.each do |name, value|
512       keypairs << "#{name}: " + render_value(value)
513     end
514     rendered_value = keypairs.join(', ')
515   when Array
516     unless data.empty?
517       data.collect! {|value| render_value(value) }
518       rendered_value = '[' + data.join(', ') + ']'
519     end
520   when String
521     if check_numeric(data) || data[0] == ':'
522       rendered_value = data.to_s
523     else
524       if data =~ /\'/
525         rendered_value = "\"#{data}\""
526       else
527         rendered_value = "'#{data}'"
528       end
529     end
530   when Symbol
531     rendered_value = ":#{data}"
532   else
533     rendered_value = data.to_s
534   end
535   rendered_value
536 end