1 /*

     2  * CDDL HEADER START

     3  *

     4  * The contents of this file are subject to the terms of the

     5  * Common Development and Distribution License (the "License").

     6  * You may not use this file except in compliance with the License.

     7  *

     8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

     9  * or http://www.opensolaris.org/os/licensing.

    10  * See the License for the specific language governing permissions

    11  * and limitations under the License.

    12  *

    13  * When distributing Covered Code, include this CDDL HEADER in each

    14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

    15  * If applicable, add the following below this CDDL HEADER, with the

    16  * fields enclosed by brackets "[]" replaced with your own identifying

    17  * information: Portions Copyright [yyyy] [name of copyright owner]

    18  *

    19  * CDDL HEADER END

    20  */

    21 

    22 /*

    23  * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.

    24  */

    25 

    26 package com.oracle.solaris.vp.util.misc;

    27 

    28 import java.io.*;

    29 import com.oracle.solaris.vp.util.misc.exception.CommandFailedException;

    30 

    31 public class ProcessUtil {

    32     //

    33     // Static methods

    34     //

    35 

    36     /**

    37      * Runs the given command and waits for it to complete.

    38      *

    39      * @param	    command

    40      *		    the command array

    41      *

    42      * @return	    the result of the command

    43      *

    44      * @exception   IOException

    45      *		    if an I/O error occurs

    46      *

    47      * @exception   InterruptedException

    48      *		    if the current thread is interrupted while

    49      *		    waiting for the process to finish

    50      */

    51     public static ProcessResult exec(String... command) throws IOException,

    52 	InterruptedException {

    53 

    54 	Process p = Runtime.getRuntime().exec(command);

    55 	p.waitFor();

    56 

    57 	int exitValue = p.exitValue();

    58 	byte[] stdout = getBytes(p.getInputStream());

    59 	byte[] stderr = getBytes(p.getErrorStream());

    60 

    61 	return new ProcessResult(command, exitValue, stdout, stderr);

    62     }

    63 

    64     /**

    65      * Runs the given command and waits for it to complete.

    66      *

    67      * @param	    expExitValue

    68      *		    the expected exit value of the command

    69      *

    70      * @param	    command

    71      *		    the command array

    72      *

    73      * @return	    the result of the command

    74      *

    75      * @exception   IOException

    76      *		    if an I/O error occurs

    77      *

    78      * @exception   InterruptedException

    79      *		    if the current thread is interrupted while

    80      *		    waiting for the process to finish

    81      *

    82      * @exception   CommandFailedException

    83      *		    if the command exits with a result other than {@code

    84      *		    expExitValue}

    85      */

    86     public static ProcessResult exec(int expExitValue, String... command)

    87 	throws IOException, InterruptedException, CommandFailedException {

    88 

    89 	ProcessResult result = exec(command);

    90 	if (result.getExitValue() != expExitValue) {

    91 	    throw new CommandFailedException(result);

    92 	}

    93 

    94 	return result;

    95     }

    96 

    97     //

    98     // Private static methods

    99     //

   100 

   101     private static byte[] getBytes(InputStream in) {

   102 	ByteArrayOutputStream out = new ByteArrayOutputStream();

   103 	byte[] b = new byte[1024];

   104 	int n;

   105 	try {

   106 	    while ((n = in.read(b)) != -1) {

   107 		out.write(b, 0, n);

   108 	    }

   109 	} catch (IOException unlikely) {

   110 	}

   111 	return out.toByteArray();

   112     }

   113 }