vagrant 0.4.1 → 0.4.2

Sign up to get free protection for your applications and to get access to all the features.
@@ -76,7 +76,7 @@ module Vagrant
76
76
  #
77
77
  # @return [String]
78
78
  def full_template_path
79
- File.join(PROJECT_ROOT, 'templates', "#{template}.erb")
79
+ File.join(PROJECT_ROOT, 'templates', "#{template}.erb").squeeze("/")
80
80
  end
81
81
  end
82
82
  end
@@ -70,6 +70,12 @@
70
70
  A box with the name '<%= box_name %>' already exists, please use another name or use `vagrant box remove <%= box_name %>`
71
71
  :box_download_unknown_type: |-
72
72
  Unknown URI type for box download.
73
+ :box_file_exists: |-
74
+ The specified output file for packaging already exists. Please move
75
+ the file or modify the output filename parameter then try to package
76
+ again.
77
+
78
+ Specified output file: <%= output_file %>
73
79
  :box_remove_doesnt_exist: |-
74
80
  The box you're attempting to remove does not exist!
75
81
  :box_specified_doesnt_exist: |-
@@ -136,6 +142,11 @@
136
142
  If the name specification is removed, Vagrant will create a new
137
143
  host only network for you. Alternatively, please create the
138
144
  specified network manually.
145
+ :network_collides: |-
146
+ The specified host network collides with a non-hostonly network!
147
+ This will cause your specified IP to be inaccessible. Please change
148
+ the IP or name of your host only network to not match that of
149
+ a bridged or non-hostonly network.
139
150
  :package_include_file_doesnt_exist: |-
140
151
  File specified to include: '<%= filename %>' does not exist!
141
152
  :package_multivm: |-
@@ -212,6 +223,11 @@
212
223
  :system_unspecified: |-
213
224
  A VM system type must be specified! This is done via the `config.vm.system`
214
225
  configuration value. Please read the documentation online for more information.
226
+ :unison_not_found: |-
227
+ The `unison` binary was not found on the guest machine. This is required
228
+ for folder syncing via unison. Please install unison on your system to
229
+ use folder syncing. You may also disable folder syncing, install unison,
230
+ re-enable syncing, then call a `vagrant reload` to enable syncing.
215
231
  :unknown_vm: |-
216
232
  The specified VM could not be found: <%= vm %>
217
233
  :virtualbox_import_failure: |-
@@ -219,7 +235,7 @@
219
235
  manually for more verbose error output.
220
236
  :virtualbox_invalid_version: |-
221
237
  Vagrant has detected that you have VirtualBox version <%= version %> installed!
222
- Vagrant requires that you use at least VirtualBox version 3.1. Please install
238
+ Vagrant requires that you use at least VirtualBox version 3.2. Please install
223
239
  a more recent version of VirtualBox to continue.
224
240
  :virtualbox_not_detected: |-
225
241
  Vagrant could not detect VirtualBox! Make sure VirtualBox is properly installed.
@@ -0,0 +1 @@
1
+ * * * * * <%= script %> '<%= from %>' '<%= to %>' '<%= options %>' >> <%= log_file %> 2>&1
@@ -0,0 +1,71 @@
1
+ #!/bin/bash
2
+ #------------------------------------------------------------
3
+ # Author : John Bender and Mitchell Hashimoto
4
+ # Description : Runs the `unison` folder synchronization
5
+ # utility for shared folders.
6
+ #------------------------------------------------------------
7
+
8
+ #------------------------------------------------------------
9
+ # Argument verification
10
+ #------------------------------------------------------------
11
+ if [ $# -ne 3 ]; then
12
+ echo "Usage: `basename $0` from_folder to_folder options"
13
+ exit 1
14
+ fi
15
+
16
+ # Sanitization function which turns any non-alphanumeric char
17
+ # into a dash '-' and returns it by echoing the result.
18
+ function sanitize() {
19
+ local DATA=$1
20
+ DATA=${DATA//[^a-zA-Z0-9_-]/-}
21
+ echo ${DATA}
22
+ }
23
+
24
+ #------------------------------------------------------------
25
+ # "Configuration"
26
+ #------------------------------------------------------------
27
+ # TODO Change lockfile to depend on the from/to folder to
28
+ # allow multiple syncs of diff folders to happen at once.
29
+ FROM=$1
30
+ TO=$2
31
+ OPTIONS=$3
32
+ LOCK_FILE=`basename $0`-$(sanitize ${TO}).lck
33
+
34
+ #------------------------------------------------------------
35
+ # Am I Running?
36
+ #------------------------------------------------------------
37
+ if [ -f "${LOCK_FILE}" ]; then
38
+ # The file exists, verify its running and if so exit.
39
+ OUR_PID=`head -n 1 "${LOCK_FILE}"`
40
+ TEST_RUNNING=`ps -p ${OUR_PID} | grep ${OUR_PID}`
41
+
42
+ if [ "${TEST_RUNNING}" ]; then
43
+ # The process is running, echo and exit.
44
+ echo "Unison sync already running. [PID: ${OUR_PID}]"
45
+ exit 0
46
+ fi
47
+ fi
48
+
49
+ # We're not running if we reached this point, so lock
50
+ # it up.
51
+ echo $$ > "${LOCK_FILE}"
52
+
53
+ #------------------------------------------------------------
54
+ # The Meat
55
+ #------------------------------------------------------------
56
+ echo "Beginning Sync:"
57
+ echo " -- From: ${FROM}"
58
+ echo " -- To: ${TO}"
59
+ echo " -- Options: ${OPTIONS}"
60
+ while [ 1 ]; do
61
+ echo "Syncing: $(date)"
62
+ # TODO check result and output log data... somewhere!
63
+ sudo unison ${FROM} ${TO} ${OPTIONS}
64
+ sleep 1
65
+ done
66
+
67
+ #------------------------------------------------------------
68
+ # Cleanup and Exit
69
+ #------------------------------------------------------------
70
+ rm -f "${LOCK_FILE}"
71
+ exit 0
@@ -23,6 +23,7 @@ class Test::Unit::TestCase
23
23
  Vagrant::Config.reset!(environment)
24
24
 
25
25
  Vagrant::Config.run do |config|
26
+ config.vagrant.home = '~/.home'
26
27
  config.vagrant.dotfile_name = ".vagrant"
27
28
  config.vagrant.log_output = nil
28
29
 
@@ -42,13 +43,15 @@ class Test::Unit::TestCase
42
43
  config.vm.shared_folder_uid = nil
43
44
  config.vm.shared_folder_gid = nil
44
45
  config.vm.system = :linux
45
- config.vm.sync_script = "/foo"
46
- config.vm.sync_crontab_entry_file = "/tmp/foo"
47
46
  config.vm.share_folder("v-root", "/vagrant", ".")
48
47
 
49
48
  config.package.name = 'vagrant'
50
49
  config.package.extension = '.box'
51
50
 
51
+ # Unison
52
+ config.unison.folder_suffix = ".sync"
53
+ config.unison.log_file = "foo-%s"
54
+
52
55
  # Chef
53
56
  config.chef.chef_server_url = "http://localhost:4000"
54
57
  config.chef.validation_key_path = "validation.pem"
@@ -60,8 +63,6 @@ class Test::Unit::TestCase
60
63
  config.chef.json = {
61
64
  :recipes => ["vagrant_main"]
62
65
  }
63
-
64
- config.vagrant.home = '~/.home'
65
66
  end
66
67
 
67
68
  if block_given?
@@ -103,9 +103,10 @@ class ForwardPortsActionTest < Test::Unit::TestCase
103
103
  forwarded_ports = mock("forwarded_ports")
104
104
  network_adapter = mock("network_adapter")
105
105
 
106
- @vm.expects(:network_adapters).returns([network_adapter])
106
+ @vm.stubs(:network_adapters).returns([network_adapter])
107
107
  network_adapter.expects(:attachment_type).returns(:nat)
108
108
 
109
+ @action.expects(:forward_port).once
109
110
  @vm.expects(:save).once
110
111
  @runner.expects(:reload!).once
111
112
  @action.forward_ports
@@ -182,13 +183,6 @@ class ForwardPortsActionTest < Test::Unit::TestCase
182
183
  @action.used_ports
183
184
  end
184
185
 
185
- should "return the forwarded ports for VB 3.1.x" do
186
- VirtualBox.stubs(:version).returns("3.1.4")
187
- fps = [mock_fp(2222), mock_fp(80)]
188
- @vms << mock_vm(:forwarded_ports => fps)
189
- assert_equal %W[2222 80], @action.used_ports
190
- end
191
-
192
186
  should "return the forwarded ports for VB 3.2.x" do
193
187
  VirtualBox.stubs(:version).returns("3.2.4")
194
188
  fps = [mock_fp(2222), mock_fp(80)]
@@ -208,92 +202,52 @@ class ForwardPortsActionTest < Test::Unit::TestCase
208
202
  fp
209
203
  end
210
204
 
211
- context "in VB 3.1.x" do
212
- setup do
213
- VirtualBox.stubs(:version).returns("3.1.4")
214
- @fps = []
215
- @vm.stubs(:forwarded_ports).returns(@fps)
216
- end
217
-
218
- should "destroy each forwarded port" do
219
- @fps << mock_fp
220
- @fps << mock_fp
221
- @action.clear_ports
222
- end
205
+ setup do
206
+ VirtualBox.stubs(:version).returns("3.2.8")
207
+ @adapters = []
208
+ @vm.stubs(:network_adapters).returns(@adapters)
223
209
  end
224
210
 
225
- context "in VB 3.2.x" do
226
- setup do
227
- VirtualBox.stubs(:version).returns("3.2.8")
228
- @adapters = []
229
- @vm.stubs(:network_adapters).returns(@adapters)
230
- end
231
-
232
- def mock_adapter
233
- na = mock("adapter")
234
- engine = mock("engine")
235
- engine.stubs(:forwarded_ports).returns([mock_fp])
236
- na.stubs(:nat_driver).returns(engine)
237
- na
238
- end
211
+ def mock_adapter
212
+ na = mock("adapter")
213
+ engine = mock("engine")
214
+ engine.stubs(:forwarded_ports).returns([mock_fp])
215
+ na.stubs(:nat_driver).returns(engine)
216
+ na
217
+ end
239
218
 
240
- should "destroy each forwarded port" do
241
- @adapters << mock_adapter
242
- @adapters << mock_adapter
243
- @action.clear_ports
244
- end
219
+ should "destroy each forwarded port" do
220
+ @adapters << mock_adapter
221
+ @adapters << mock_adapter
222
+ @action.clear_ports
245
223
  end
246
224
  end
247
225
 
248
- context "forwarding ports" do
249
- context "in VB 3.1.x" do
250
- setup do
251
- VirtualBox.stubs(:version).returns("3.1.4")
252
- end
253
-
254
- should "forward ports" do
255
- forwarded_ports = mock("forwarded_ports")
256
- @vm.expects(:forwarded_ports).returns(forwarded_ports)
257
- @runner.env.config.vm.forwarded_ports.each do |name, opts|
258
- forwarded_ports.expects(:<<).with do |port|
259
- assert_equal name, port.name
260
- assert_equal opts[:hostport], port.hostport
261
- assert_equal opts[:guestport], port.guestport
262
- assert_equal opts[:adapter], port.instance
263
- true
264
- end
265
-
266
- @action.forward_port(name, opts)
267
- end
226
+ context "forwarding ports implementation" do
227
+ setup do
228
+ VirtualBox.stubs(:version).returns("3.2.8")
229
+ end
230
+
231
+ should "forward ports" do
232
+ name, opts = @runner.env.config.vm.forwarded_ports.first
233
+
234
+ adapters = []
235
+ adapter = mock("adapter")
236
+ engine = mock("engine")
237
+ fps = mock("forwarded ports")
238
+ adapter.stubs(:nat_driver).returns(engine)
239
+ engine.stubs(:forwarded_ports).returns(fps)
240
+ fps.expects(:<<).with do |port|
241
+ assert_equal name, port.name
242
+ assert_equal opts[:hostport], port.hostport
243
+ assert_equal opts[:guestport], port.guestport
244
+ true
268
245
  end
269
- end
270
246
 
271
- context "in VB 3.2.x" do
272
- setup do
273
- VirtualBox.stubs(:version).returns("3.2.8")
274
- end
247
+ adapters[opts[:adapter]] = adapter
248
+ @vm.stubs(:network_adapters).returns(adapters)
275
249
 
276
- should "forward ports" do
277
- name, opts = @runner.env.config.vm.forwarded_ports.first
278
-
279
- adapters = []
280
- adapter = mock("adapter")
281
- engine = mock("engine")
282
- fps = mock("forwarded ports")
283
- adapter.stubs(:nat_driver).returns(engine)
284
- engine.stubs(:forwarded_ports).returns(fps)
285
- fps.expects(:<<).with do |port|
286
- assert_equal name, port.name
287
- assert_equal opts[:hostport], port.hostport
288
- assert_equal opts[:guestport], port.guestport
289
- true
290
- end
291
-
292
- adapters[opts[:adapter]] = adapter
293
- @vm.stubs(:network_adapters).returns(adapters)
294
-
295
- @action.forward_port(name, opts)
296
- end
250
+ @action.forward_port(name, opts)
297
251
  end
298
252
  end
299
253
  end
@@ -4,6 +4,36 @@ class NetworkTest < Test::Unit::TestCase
4
4
  setup do
5
5
  @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Network)
6
6
  @runner.stubs(:system).returns(linux_system(@vm))
7
+
8
+ @interfaces = []
9
+ VirtualBox::Global.global.host.stubs(:network_interfaces).returns(@interfaces)
10
+ end
11
+
12
+ def mock_interface(options=nil)
13
+ options = {
14
+ :interface_type => :host_only,
15
+ :name => "foo"
16
+ }.merge(options || {})
17
+
18
+ interface = mock("interface")
19
+ options.each do |k,v|
20
+ interface.stubs(k).returns(v)
21
+ end
22
+
23
+ @interfaces << interface
24
+ interface
25
+ end
26
+
27
+ context "preparing" do
28
+ should "verify no bridge collisions for each network enabled" do
29
+ @runner.env.config.vm.network("foo")
30
+ @action.expects(:verify_no_bridge_collision).once.with() do |options|
31
+ assert_equal "foo", options[:ip]
32
+ true
33
+ end
34
+
35
+ @action.prepare
36
+ end
7
37
  end
8
38
 
9
39
  context "before destroy" do
@@ -112,11 +142,30 @@ class NetworkTest < Test::Unit::TestCase
112
142
  end
113
143
  end
114
144
 
115
- context "network name" do
145
+ context "verify no bridge collision" do
116
146
  setup do
117
- @interfaces = []
118
- VirtualBox::Global.global.host.stubs(:network_interfaces).returns(@interfaces)
147
+ @action.stubs(:matching_network?).returns(false)
148
+ @options = { :ip => :foo, :netmask => :bar, :name => nil }
149
+ end
119
150
 
151
+ should "do nothing if everything is okay" do
152
+ mock_interface
153
+
154
+ assert_nothing_raised { @action.verify_no_bridge_collision(@options) }
155
+ end
156
+
157
+ should "raise an exception if a collision is found" do
158
+ mock_interface(:interface_type => :bridged)
159
+ @action.stubs(:matching_network?).returns(true)
160
+
161
+ assert_raises(Vagrant::Actions::ActionException) {
162
+ @action.verify_no_bridge_collision(@options)
163
+ }
164
+ end
165
+ end
166
+
167
+ context "network name" do
168
+ setup do
120
169
  @action.stubs(:matching_network?).returns(false)
121
170
 
122
171
  @options = { :ip => :foo, :netmask => :bar, :name => nil }
@@ -124,21 +173,26 @@ class NetworkTest < Test::Unit::TestCase
124
173
 
125
174
  should "return the network which matches" do
126
175
  result = mock("result")
127
- interface = mock("interface")
128
- interface.stubs(:name).returns(result)
129
- @interfaces << interface
176
+ interface = mock_interface(:name => result)
130
177
 
131
178
  @action.expects(:matching_network?).with(interface, @options).returns(true)
132
179
  assert_equal result, @action.network_name(@options)
133
180
  end
134
181
 
135
- should "return the network which matches the name if given" do
182
+ should "ignore non-host only interfaces" do
136
183
  @options[:name] = "foo"
184
+ mock_interface(:name => @options[:name],
185
+ :interface_type => :bridged)
137
186
 
138
- interface = mock("interface")
139
- interface.stubs(:name).returns(@options[:name])
140
- @interfaces << interface
187
+ assert_raises(Vagrant::Actions::ActionException) {
188
+ @action.network_name(@options)
189
+ }
190
+ end
191
+
192
+ should "return the network which matches the name if given" do
193
+ @options[:name] = "foo"
141
194
 
195
+ interface = mock_interface(:name => @options[:name])
142
196
  assert_equal @options[:name], @action.network_name(@options)
143
197
  end
144
198
 
@@ -154,12 +208,12 @@ class NetworkTest < Test::Unit::TestCase
154
208
 
155
209
  should "create a network for the IP and netmask" do
156
210
  result = mock("result")
157
- interface = mock("interface")
158
211
  network_ip = :foo
212
+
213
+ interface = mock_interface(:name => result)
214
+ interface.expects(:enable_static).with(network_ip, @options[:netmask])
159
215
  @interfaces.expects(:create).returns(interface)
160
216
  @action.expects(:network_ip).with(@options[:ip], @options[:netmask]).once.returns(network_ip)
161
- interface.expects(:enable_static).with(network_ip, @options[:netmask])
162
- interface.expects(:name).returns(result)
163
217
 
164
218
  assert_equal result, @action.network_name(@options)
165
219
  end
@@ -226,6 +226,11 @@ class PackageActionTest < Test::Unit::TestCase
226
226
  @action.prepare
227
227
  end
228
228
 
229
+ should "raise an exception if the output file already exists" do
230
+ File.expects(:exist?).with(@action.tar_path).returns(false)
231
+ assert_raises(Vagrant::Actions::ActionException) { @action.prepare }
232
+ end
233
+
229
234
  should "raise an exception when an include file does not exist" do
230
235
  File.expects(:exists?).once.returns(false)
231
236
  assert_raises(Vagrant::Actions::ActionException) { @action.prepare }