View Javadoc

1   /**
2    * Copyright 2010-2012 The Kuali Foundation
3    *
4    * Licensed under the Educational Community License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    * http://www.opensource.org/licenses/ecl2.php
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  package org.kuali.common.util;
17  
18  import java.io.File;
19  import java.io.IOException;
20  import java.util.ArrayList;
21  import java.util.Arrays;
22  import java.util.Collections;
23  import java.util.List;
24  
25  import org.apache.commons.io.FileUtils;
26  import org.apache.commons.lang3.StringUtils;
27  import org.codehaus.plexus.util.cli.CommandLineException;
28  import org.codehaus.plexus.util.cli.CommandLineUtils;
29  import org.codehaus.plexus.util.cli.Commandline;
30  import org.codehaus.plexus.util.cli.StreamConsumer;
31  import org.slf4j.Logger;
32  import org.slf4j.LoggerFactory;
33  import org.springframework.util.Assert;
34  
35  /**
36   * Execute Unix utilities using java.
37   */
38  public class UnixUtils {
39  
40  	private static final Logger logger = LoggerFactory.getLogger(UnixUtils.class);
41  
42  	private static final String SCP = "scp";
43  	private static final String SSH = "ssh";
44  	private static final String SU = "su";
45  	private static final String MKDIR = "mkdir";
46  	private static final String RM = "rm";
47  	private static final String CHOWN = "chown";
48  	private static final String CHMOD = "chmod";
49  	private static final String RSYNC = "rsync";
50  	private static final String FORWARD_SLASH = "/";
51  	public static final int SUCCESS = 0;
52  
53  	/**
54  	 * <pre>
55  	 *  rsync source destination
56  	 * </pre>
57  	 *
58  	 * Where <code>source</code> and <code>destination</code> are both directories on the local file system. <code>source</code> must
59  	 * already exist. <code>destination</code> will be created if it does not exist.
60  	 */
61  	public static final int rsyncdirs(File source, File destination) {
62  		String sourcePath = validateRsyncSourceDir(source);
63  		String destinationPath = validateRsyncDestinationDir(destination);
64  
65  		// Make sure source is a different directory than destination
66  		boolean different = !source.equals(destination);
67  		Assert.isTrue(different);
68  
69  		return rsyncdirs(null, sourcePath, destinationPath);
70  	}
71  
72  	/**
73  	 * <pre>
74  	 *  rsync source [user@]hostname:destination
75  	 * </pre>
76  	 *
77  	 * Where <code>source</code> is a directory on the local file system. <code>source</code> must already exist.
78  	 */
79  	public static final int rsyncdirs(File source, String destination) {
80  		String sourcePath = validateRsyncSourceDir(source);
81  		return rsyncdirs(null, sourcePath, destination);
82  	}
83  
84  	/**
85  	 * <pre>
86  	 *  rsync [user@]hostname:source destination
87  	 * </pre>
88  	 *
89  	 * Where <code>destination</code> is a directory on the local file system. <code>destination</code> will be created if it does not exist
90  	 */
91  	public static final int rsyncdirs(String source, File destination) {
92  		String destinationPath = validateRsyncDestinationDir(destination);
93  		return rsyncdirs(null, source, destinationPath);
94  	}
95  
96  	/**
97  	 * <pre>
98  	 *  rsync [options] source destination
99  	 * </pre>
100 	 *
101 	 * Where <code>source</code> and <code>destination</code> are both directories on the local file system. <code>source</code> must
102 	 * already exist. <code>destination</code> will be created if it does not exist.
103 	 */
104 	public static final int rsyncdirs(List<String> options, File source, File destination) {
105 		String sourcePath = validateRsyncSourceDir(source);
106 		String destinationPath = validateRsyncDestinationDir(destination);
107 		return rsyncdirs(options, sourcePath, destinationPath);
108 	}
109 
110 	/**
111 	 * <pre>
112 	 *  rsync [options] source [user@]hostname:destination
113 	 * </pre>
114 	 *
115 	 * Where <code>source</code> is a directory on the local file system. <code>source</code> must already exist.
116 	 */
117 	public static final int rsync(List<String> options, File source, String destination) {
118 		String sourcePath = validateRsyncSourceDir(source);
119 		return rsyncdirs(options, sourcePath, destination);
120 	}
121 
122 	/**
123 	 * <pre>
124 	 *  rsync [options] [user@]hostname:source destination
125 	 * </pre>
126 	 *
127 	 * Where <code>destination</code> is a directory on the local file system. <code>destination</code> will be created if it does not exist
128 	 */
129 	public static final int rsyncdirs(List<String> options, String source, File destination) {
130 		String destinationPath = validateRsyncDestinationDir(destination);
131 		return rsyncdirs(options, source, destinationPath);
132 	}
133 
134 	/**
135 	 * <pre>
136 	 *  rsync [options] source destination
137 	 *  rsync [options] source [user@]hostname:destination
138 	 *  rsync [options] [user@]hostname:source destination
139 	 * </pre>
140 	 *
141 	 * Always add a trailing slash to source when sync'ing directories.<br>
142 	 * This forces rsync to behave like <code>cp</code>
143 	 *
144 	 * <pre>
145 	 * cp -R /tmp/foo/bar  /tmp/xyz  -  creates files in /tmp/xyz
146 	 * rsync /tmp/foo/bar/ /tmp/xyz  -  creates files in /tmp/xyz
147 	 *
148 	 * rsync /tmp/foo/bar  /tmp/xyz  -  creates files in /tmp/xyz/bar
149 	 * </pre>
150 	 */
151 	public static final int rsyncdirs(List<String> options, String source, String destination) {
152 		List<String> rsyncDirOptions = getRsyncDirOptions(options);
153 		// Make sure source always has a trailing slash
154 		String trailingSlashSource = StringUtils.endsWith(source, FORWARD_SLASH) ? source : source + FORWARD_SLASH;
155 		return rsync(rsyncDirOptions, trailingSlashSource, destination);
156 	}
157 
158 	/**
159 	 * <pre>
160 	 *  rsync [options] source destination
161 	 *  rsync [options] source [user@]hostname:destination
162 	 *  rsync [options] [user@]hostname:source destination
163 	 * </pre>
164 	 */
165 	public static final int rsyncdirs(String source, String destination) {
166 		return rsyncdirs(null, source, destination);
167 	}
168 
169 	/**
170 	 * <pre>
171 	 *  rsync source destination
172 	 *  rsync source [user@]hostname:destination
173 	 *  rsync [user@]hostname:source destination
174 	 * </pre>
175 	 */
176 	public static final int rsync(String source, String destination) {
177 		return rsync(null, source, destination);
178 	}
179 
180 	/**
181 	 * <pre>
182 	 *  rsync [options] source destination
183 	 *  rsync [options] source [user@]hostname:destination
184 	 *  rsync [options] [user@]hostname:source destination
185 	 * </pre>
186 	 */
187 	public static final int rsync(List<String> options, String source, String destination) {
188 		Assert.notNull(source);
189 		Assert.notNull(destination);
190 		List<String> arguments = new ArrayList<String>();
191 		arguments.addAll(CollectionUtils.toEmpty(options));
192 		arguments.add(source);
193 		arguments.add(destination);
194 		Commandline cl = new Commandline();
195 		cl.setExecutable(RSYNC);
196 		cl.addArguments(CollectionUtils.toStringArray(arguments));
197 		return execute(cl);
198 	}
199 
200 	/**
201 	 * <pre>
202 	 * ssh [args] [user@]hostname chown [chownargs] owner:group file
203 	 * </pre>
204 	 */
205 	public static final int sshchown(List<String> args, String user, String hostname, List<String> chownargs, String owner, String group, String file) {
206 		Assert.notNull(owner);
207 		Assert.notNull(group);
208 		Assert.notNull(file);
209 		String command = getChownCommand(chownargs, owner, group, file);
210 		return ssh(args, user, hostname, command);
211 	}
212 
213 	/**
214 	 * <pre>
215 	 * ssh hostname chown -R owner:group file
216 	 * </pre>
217 	 */
218 	public static final int sshchownrecursive(String hostname, String owner, String group, String file) {
219 		return sshchownrecursive(null, null, hostname, owner, group, file);
220 	}
221 
222 	/**
223 	 * <pre>
224 	 * ssh [user@]hostname chown -R owner:group file
225 	 * </pre>
226 	 */
227 	public static final int sshchownrecursive(String user, String hostname, String owner, String group, String file) {
228 		return sshchownrecursive(null, user, hostname, owner, group, file);
229 	}
230 
231 	/**
232 	 * <pre>
233 	 * ssh [args] hostname chown -R owner:group file
234 	 * </pre>
235 	 */
236 	public static final int sshchownrecursive(List<String> args, String hostname, String owner, String group, String file) {
237 		return sshchownrecursive(args, null, hostname, owner, group, file);
238 	}
239 
240 	/**
241 	 * <pre>
242 	 * ssh [args] [user@]hostname chown -R owner:group file
243 	 * </pre>
244 	 */
245 	public static final int sshchownrecursive(List<String> args, String user, String hostname, String owner, String group, String file) {
246 		return sshchown(args, user, hostname, Arrays.asList("-R"), owner, group, file);
247 	}
248 
249 	/**
250 	 * <pre>
251 	 * ssh [args] hostname chown owner:group file
252 	 * </pre>
253 	 */
254 	public static final int sshchown(List<String> args, String hostname, String owner, String group, String file) {
255 		return sshchown(args, null, hostname, null, owner, group, file);
256 	}
257 
258 	/**
259 	 * <pre>
260 	 * ssh [args] [user@]hostname chown owner:group file
261 	 * </pre>
262 	 */
263 	public static final int sshchown(List<String> args, String user, String hostname, String owner, String group, String file) {
264 		return sshchown(args, user, hostname, null, owner, group, file);
265 	}
266 
267 	/**
268 	 * <pre>
269 	 * ssh [user@]hostname chown owner:group file
270 	 * </pre>
271 	 */
272 	public static final int sshchown(String user, String hostname, String owner, String group, String file) {
273 		return sshchown(null, user, hostname, null, owner, group, file);
274 	}
275 
276 	/**
277 	 * <pre>
278 	 * ssh hostname chown owner:group file
279 	 * </pre>
280 	 */
281 	public static final int sshchown(String hostname, String owner, String group, String file) {
282 		return sshchown(null, null, hostname, owner, group, file);
283 	}
284 
285 	/**
286 	 * <pre>
287 	 * ssh hostname rm -rf file
288 	 * </pre>
289 	 */
290 	public static final int sshrm(String hostname, String file) {
291 		return sshrm(null, null, hostname, file);
292 	}
293 
294 	/**
295 	 * <pre>
296 	 * ssh [user@]hostname rm -rf file
297 	 * </pre>
298 	 */
299 	public static final int sshrm(String user, String hostname, String file) {
300 		return sshrm(null, user, hostname, file);
301 	}
302 
303 	/**
304 	 * <pre>
305 	 * ssh [args] hostname rm -rf file
306 	 * </pre>
307 	 */
308 	public static final int sshrm(List<String> args, String hostname, String file) {
309 		return sshrm(args, null, hostname, file);
310 	}
311 
312 	/**
313 	 * <pre>
314 	 * ssh [args] [user@]hostname rm -rf file
315 	 * </pre>
316 	 */
317 	public static final int sshrm(List<String> args, String user, String hostname, String file) {
318 		Assert.notNull(file);
319 		return sshrm(args, user, hostname, Collections.singletonList(file));
320 	}
321 
322 	/**
323 	 * <pre>
324 	 * ssh hostname rm -rf file ...
325 	 * </pre>
326 	 */
327 	public static final int sshrm(String hostname, List<String> files) {
328 		return sshrm(null, null, hostname, files);
329 	}
330 
331 	/**
332 	 * <pre>
333 	 * ssh [user@]hostname rm -rf file ...
334 	 * </pre>
335 	 */
336 	public static final int sshrm(String user, String hostname, List<String> files) {
337 		return sshrm(null, user, hostname, files);
338 	}
339 
340 	/**
341 	 * <pre>
342 	 * ssh [args] hostname rm -rf file ...
343 	 * </pre>
344 	 */
345 	public static final int sshrm(List<String> args, String hostname, List<String> files) {
346 		return sshrm(args, null, hostname, files);
347 	}
348 
349 	/**
350 	 * <pre>
351 	 * ssh [args] [user@]hostname rm -rf file ...
352 	 * </pre>
353 	 */
354 	public static final int sshrm(List<String> args, String user, String hostname, List<String> files) {
355 		return sshrm(args, user, hostname, Arrays.asList("-rf"), files);
356 	}
357 
358 	/**
359 	 * <pre>
360 	 * ssh [args] [user@]hostname rm [rmargs] file ...
361 	 * </pre>
362 	 */
363 	public static final int sshrm(List<String> args, String user, String hostname, List<String> rmargs, List<String> files) {
364 		Assert.notNull(files);
365 		Assert.isTrue(files.size() > 0);
366 		String command = getRmCommand(rmargs, files);
367 		return ssh(args, user, hostname, command);
368 	}
369 
370 	public static final String getRmCommand(List<String> args, List<String> files) {
371 		Assert.notNull(files);
372 		StringBuilder sb = new StringBuilder();
373 		sb.append(RM);
374 		String arguments = getSpaceSeparatedStrings(args);
375 		if (arguments != null) {
376 			sb.append(" ");
377 			sb.append(arguments);
378 		}
379 		sb.append(" ");
380 		sb.append(getSpaceSeparatedStrings(files));
381 		return sb.toString();
382 	}
383 
384 	/**
385 	 * <pre>
386 	 * ssh [args] [user@]hostname chmod mode file
387 	 * </pre>
388 	 */
389 	public static final int sshchmod(List<String> args, String user, String hostname, String mode, String file) {
390 		Assert.notNull(mode);
391 		Assert.notNull(file);
392 		return ssh(args, user, hostname, CHMOD + " " + mode + " " + file);
393 	}
394 
395 	/**
396 	 * <pre>
397 	 * ssh [user@]hostname chmod mode file
398 	 * </pre>
399 	 */
400 	public static final int sshchmod(String user, String hostname, String mode, String file) {
401 		return sshchmod(null, user, hostname, mode, file);
402 	}
403 
404 	/**
405 	 * <pre>
406 	 * ssh [user@]hostname mkdir -p directory
407 	 * </pre>
408 	 */
409 	public static final int sshmkdir(String user, String hostname, String directory) {
410 		return sshmkdir(null, user, hostname, directory);
411 	}
412 
413 	/**
414 	 * <pre>
415 	 * ssh [args] [user@]hostname mkdir -p directory
416 	 * </pre>
417 	 */
418 	public static final int sshmkdir(List<String> args, String user, String hostname, String directory) {
419 		Assert.notNull(directory);
420 		return ssh(args, user, hostname, MKDIR + " -p " + directory);
421 	}
422 
423 	/**
424 	 * <pre>
425 	 * ssh hostname mkdir -p directory
426 	 * </pre>
427 	 */
428 	public static final int sshmkdir(String hostname, String directory) {
429 		return sshmkdir(null, null, hostname, directory);
430 	}
431 
432 	/**
433 	 * <pre>
434 	 * ssh [args] hostname mkdir -p directory
435 	 * </pre>
436 	 */
437 	public static final int sshmkdir(List<String> args, String hostname, String directory) {
438 		return sshmkdir(args, null, hostname, directory);
439 	}
440 
441 	/**
442 	 * <pre>
443 	 * ssh hostname su - login command
444 	 * </pre>
445 	 */
446 	public static final int sshsu(String hostname, String login, String command) {
447 		return sshsu(null, null, hostname, login, command);
448 	}
449 
450 	/**
451 	 * <pre>
452 	 * ssh [args] hostname su - login command
453 	 * </pre>
454 	 */
455 	public static final int sshsu(List<String> args, String hostname, String login, String command) {
456 		return sshsu(args, null, hostname, login, command);
457 	}
458 
459 	/**
460 	 * <pre>
461 	 * ssh [user@]hostname su - login command
462 	 * </pre>
463 	 */
464 	public static final int sshsu(String user, String hostname, String login, String command) {
465 		return sshsu(null, user, hostname, login, command);
466 	}
467 
468 	/**
469 	 * <pre>
470 	 * ssh [args] [user@]hostname su - login command
471 	 * </pre>
472 	 */
473 	public static final int sshsu(List<String> args, String user, String hostname, String login, String command) {
474 		Assert.notNull(login);
475 		Assert.notNull(command);
476 		return ssh(user, hostname, SU + " - " + login + " " + command);
477 	}
478 
479 	/**
480 	 * <pre>
481 	 * ssh hostname command
482 	 * </pre>
483 	 */
484 	public static final int ssh(String hostname, String command) {
485 		return ssh(null, null, hostname, command);
486 	}
487 
488 	/**
489 	 * <pre>
490 	 * ssh [user@]hostname command
491 	 * </pre>
492 	 */
493 	public static final int ssh(String user, String hostname, String command) {
494 		return ssh(null, user, hostname, command);
495 	}
496 
497 	/**
498 	 * <pre>
499 	 * ssh [args] hostname command
500 	 * </pre>
501 	 */
502 	public static final int ssh(List<String> args, String hostname, String command) {
503 		return ssh(args, null, hostname, command);
504 	}
505 
506 	/**
507 	 * <pre>
508 	 * ssh [args] [user@]hostname command
509 	 * </pre>
510 	 */
511 	public static final int ssh(List<String> args, String user, String hostname, String command) {
512 		Assert.notNull(hostname);
513 		Assert.notNull(command);
514 		List<String> arguments = new ArrayList<String>();
515 		arguments.addAll(CollectionUtils.toEmpty(args));
516 		if (!StringUtils.isBlank(user)) {
517 			arguments.add(user + "@" + hostname);
518 		} else {
519 			arguments.add(hostname);
520 		}
521 		arguments.add(command);
522 		Commandline cl = new Commandline();
523 		cl.setExecutable(SSH);
524 		cl.addArguments(CollectionUtils.toStringArray(arguments));
525 		return execute(cl);
526 	}
527 
528 	/**
529 	 * <pre>
530 	 * scp source destination
531 	 * </pre>
532 	 *
533 	 * Where both <code>source</code> and <code>destination</code> are in the format
534 	 *
535 	 * <pre>
536 	 * [[user@]host:]file
537 	 * </pre>
538 	 */
539 	public static final int scp(String source, String destination) {
540 		return scp(null, source, destination);
541 	}
542 
543 	/**
544 	 * <pre>
545 	 * scp [args] source destination
546 	 * </pre>
547 	 *
548 	 * Where both <code>source</code> and <code>destination</code> are in the format
549 	 *
550 	 * <pre>
551 	 * [[user@]host:]file
552 	 * </pre>
553 	 */
554 	public static final int scp(List<String> args, String source, String destination) {
555 		Assert.notNull(source);
556 		Assert.notNull(destination);
557 		List<String> arguments = new ArrayList<String>();
558 		arguments.addAll(CollectionUtils.toEmpty(args));
559 		arguments.add(source);
560 		arguments.add(destination);
561 		Commandline cl = new Commandline();
562 		cl.setExecutable(SCP);
563 		cl.addArguments(CollectionUtils.toStringArray(arguments));
564 		return execute(cl);
565 	}
566 
567 	/**
568 	 * <pre>
569 	 * scp [args] source destination
570 	 * </pre>
571 	 *
572 	 * Where <code>source</code> is a file on the local file system and <code>destination</code> is in the format
573 	 *
574 	 * <pre>
575 	 * [[user@]host:]file
576 	 * </pre>
577 	 */
578 	public static final int scp(List<String> args, File source, String destination) {
579 		Assert.notNull(source);
580 		String sourcePath = LocationUtils.getCanonicalPath(source);
581 		if (!source.exists()) {
582 			throw new IllegalArgumentException(sourcePath + " does not exist");
583 		}
584 		return scp(args, sourcePath, destination);
585 	}
586 
587 	/**
588 	 * <pre>
589 	 * scp [args] source destination
590 	 * </pre>
591 	 *
592 	 * Where <code>destination</code> is a file on the local file system and <code>source</code> is in the format
593 	 *
594 	 * <pre>
595 	 * [[user@]host:]file
596 	 * </pre>
597 	 */
598 	public static final int scp(List<String> args, String source, File destination) {
599 		try {
600 			FileUtils.touch(destination);
601 		} catch (IOException e) {
602 			throw new IllegalStateException("Unexpected IO error", e);
603 		}
604 		String localPath = LocationUtils.getCanonicalPath(destination);
605 		return scp(args, source, localPath);
606 	}
607 
608 	/**
609 	 * <pre>
610 	 * scp source destination
611 	 * </pre>
612 	 *
613 	 * Where <code>source</code> is a file on the local file system and <code>destination</code> is in the format
614 	 *
615 	 * <pre>
616 	 * [[user@]host:]file
617 	 * </pre>
618 	 */
619 	public static final int scp(File source, String destination) {
620 		return scp(null, source, destination);
621 	}
622 
623 	/**
624 	 * <pre>
625 	 * scp source destination
626 	 * </pre>
627 	 *
628 	 * Where <code>destination</code> is a file on the local file system and <code>source</code> is in the format
629 	 *
630 	 * <pre>
631 	 * [[user@]host:]file
632 	 * </pre>
633 	 */
634 	public static final int scp(String source, File destination) {
635 		return scp(null, source, destination);
636 	}
637 
638 	public static final void validate(int exitValue, String message, Mode mode) {
639 		if (exitValue != UnixUtils.SUCCESS) {
640 			ModeUtils.validate(mode, message + " Exit value=[" + exitValue + "]");
641 		}
642 	}
643 
644 	public static final void validate(int exitValue, String message) {
645 		validate(exitValue, message, Mode.ERROR);
646 	}
647 
648 	public static final int execute(Commandline cl) {
649 		try {
650 			StreamConsumer stdout = new LoggingStreamConsumer(logger, LoggerLevel.INFO);
651 			StreamConsumer stderr = new LoggingStreamConsumer(logger, LoggerLevel.WARN);
652 			logger.info(cl.toString());
653 			return CommandLineUtils.executeCommandLine(cl, stdout, stderr);
654 		} catch (CommandLineException e) {
655 			throw new IllegalStateException(e);
656 		}
657 	}
658 
659 	protected static final String getChownCommand(List<String> args, String owner, String group, String file) {
660 		StringBuilder sb = new StringBuilder();
661 		sb.append(CHOWN);
662 		String arguments = getSpaceSeparatedStrings(args);
663 		if (arguments != null) {
664 			sb.append(" ");
665 			sb.append(arguments);
666 		}
667 		sb.append(" ");
668 		sb.append(owner + ":" + group);
669 		sb.append(" ");
670 		sb.append(file);
671 		return sb.toString();
672 	}
673 
674 	public static final String getLocation(String user, String hostname, String filename) {
675 		Assert.notNull(user);
676 		Assert.notNull(filename);
677 		StringBuilder sb = new StringBuilder();
678 		if (!StringUtils.isBlank(user)) {
679 			sb.append(user + "@");
680 		}
681 		sb.append(hostname);
682 		sb.append(":");
683 		sb.append(filename);
684 		return sb.toString();
685 	}
686 
687 	public static final String getSpaceSeparatedStrings(List<String> strings) {
688 		if (CollectionUtils.isEmpty(strings)) {
689 			return null;
690 		}
691 		StringBuilder sb = new StringBuilder();
692 		for (int i = 0; i < strings.size(); i++) {
693 			if (i != 0) {
694 				sb.append(" ");
695 			}
696 			sb.append(strings.get(i));
697 		}
698 		return sb.toString();
699 	}
700 
701 	protected static final String validateRsyncSourceDir(File dir) {
702 		String path = LocationUtils.getCanonicalPath(dir);
703 		if (!dir.exists()) {
704 			throw new IllegalArgumentException(path + " does not exist");
705 		}
706 		if (!dir.isDirectory()) {
707 			throw new IllegalArgumentException(path + " is not a directory");
708 		}
709 		if (!StringUtils.endsWith(path, FORWARD_SLASH)) {
710 			return path + FORWARD_SLASH;
711 		} else {
712 			return path;
713 		}
714 	}
715 
716 	protected static final String validateRsyncDestinationDir(File dir) {
717 		try {
718 			FileUtils.forceMkdir(dir);
719 			return dir.getCanonicalPath();
720 		} catch (IOException e) {
721 			throw new IllegalArgumentException("Unexpected IO error", e);
722 		}
723 	}
724 
725 	/**
726 	 * Return a list containing the options <code>--recursive</code>, <code>--archive</code>, and <code>--delete</code> as the first 3
727 	 * elements, with additional options coming after.
728 	 */
729 	protected static final List<String> getRsyncDirOptions(List<String> options) {
730 		List<String> rsyncDirOptions = new ArrayList<String>();
731 		rsyncDirOptions.add("--recursive");
732 		rsyncDirOptions.add("--archive");
733 		rsyncDirOptions.add("--delete");
734 		for (String option : CollectionUtils.toEmpty(options)) {
735 			if (!rsyncDirOptions.contains(option)) {
736 				rsyncDirOptions.add(option);
737 			}
738 		}
739 		return rsyncDirOptions;
740 	}
741 
742 }