001: /*
002: * IzPack - Copyright 2001-2008 Julien Ponge, All Rights Reserved.
003: *
004: * http://izpack.org/
005: * http://izpack.codehaus.org/
006: *
007: * Copyright 2003 Tino Schwarze
008: *
009: * Licensed under the Apache License, Version 2.0 (the "License");
010: * you may not use this file except in compliance with the License.
011: * You may obtain a copy of the License at
012: *
013: * http://www.apache.org/licenses/LICENSE-2.0
014: *
015: * Unless required by applicable law or agreed to in writing, software
016: * distributed under the License is distributed on an "AS IS" BASIS,
017: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
018: * See the License for the specific language governing permissions and
019: * limitations under the License.
020: */
021:
022: package com.izforge.izpack.installer;
023:
024: import java.io.PrintWriter;
025: import java.io.StringWriter;
026: import java.util.Iterator;
027: import java.util.List;
028:
029: /**
030: * This class describes the result of the compilation.
031: *
032: * This class is here because error handling is not straight-forward with regard to compilation.
033: *
034: * The error condition consists of an error message, the full command line which failed to execute
035: * plus it's stdout and stderr. The reason for this class to exist is that there are three possible
036: * reactions to the error (chosen by the user).
037: * <ol>
038: * <li>abort</li>
039: * <li>ignore (continue anyway)</li>
040: * <li>reconfigure</li>
041: * </ol>
042: *
043: * @author Tino Schwarze
044: */
045: public class CompileResult {
046:
047: // -------- public constants ---------------
048: // arbitrary values
049: public final static int SUCCESS = 42;
050:
051: public final static int FAILED = 23;
052:
053: public final static int ACTION_ABORT = 27;
054:
055: public final static int ACTION_CONTINUE = 39;
056:
057: public final static int ACTION_RECONFIGURE = 31;
058:
059: // -------- private variables ---------------
060: // we're optimistic...
061: private int status = SUCCESS;
062:
063: // here we're pessimistic
064: private int action = ACTION_ABORT;
065:
066: /** the error message */
067: private String message = null;
068:
069: /** the command line */
070: private List<String> cmdline = null;
071:
072: /** the stdout of the command */
073: private String stdout = null;
074:
075: /** the stderr of the command */
076: private String stderr = null;
077:
078: /** constructor, create a new successful result */
079: public CompileResult() {
080: this .status = SUCCESS;
081: this .action = ACTION_CONTINUE;
082: }
083:
084: /**
085: * Creates a result because of exception.
086: *
087: * @param anException The exception.
088: */
089: public CompileResult(Exception anException) {
090: StringWriter writer = new StringWriter();
091: anException.printStackTrace(new PrintWriter(writer));
092: this .message = writer.toString();
093: this .action = ACTION_ABORT;
094: this .status = FAILED;
095: }
096:
097: /**
098: * creates a new CompileResult with status FAILED
099: *
100: * @param message description of the exception
101: * @param cmdline full command line of failed command
102: * @param stdout standard output of failed command
103: * @param stderr standard error of failed command
104: */
105: public CompileResult(String message, List<String> cmdline,
106: String stdout, String stderr) {
107: this .message = message;
108: this .status = FAILED;
109: this .cmdline = cmdline;
110: this .stdout = stdout;
111: this .stderr = stderr;
112: }
113:
114: public void setStatus(int status) {
115: if ((status == SUCCESS) || (status == FAILED)) {
116: this .status = status;
117: }
118: }
119:
120: public int getStatus() {
121: return this .status;
122: }
123:
124: public void setAction(int action) {
125: if ((action == ACTION_ABORT) || (action == ACTION_CONTINUE)
126: || (action == ACTION_RECONFIGURE)) {
127: this .action = action;
128: }
129:
130: }
131:
132: public int getAction() {
133: return this .action;
134: }
135:
136: /** check for success (convenience function) */
137: public boolean isSuccess() {
138: return (this .status == SUCCESS);
139: }
140:
141: /** check whether to abort (convenience function) */
142: public boolean isAbort() {
143: return ((this .status == FAILED) && (this .action == ACTION_ABORT));
144: }
145:
146: /**
147: * check whether to continue (convenience function)
148: *
149: * @return true if status is SUCCESS or action is CONTINUE
150: */
151: public boolean isContinue() {
152: return ((this .status == SUCCESS) || (this .action == ACTION_CONTINUE));
153: }
154:
155: /** check whether to reconfigure (convenience function) */
156: public boolean isReconfigure() {
157: return ((this .status == FAILED) && (this .action == ACTION_RECONFIGURE));
158: }
159:
160: /**
161: * return error message
162: *
163: * @return the error message describing the action that failed (might be null)
164: */
165: public String getMessage() {
166: return this .message;
167: }
168:
169: /**
170: * get command line of failed command as a string
171: *
172: * @return command line of failed command
173: */
174: public String getCmdline() {
175: StringBuffer sb = new StringBuffer();
176: for (String aCmdline : this .cmdline) {
177: if (sb.length() > 0) {
178: sb.append(' ');
179: }
180: sb.append(aCmdline);
181: }
182: return sb.toString();
183: }
184:
185: public String getStdout() {
186: return this .stdout;
187: }
188:
189: public String getStderr() {
190: return this.stderr;
191: }
192:
193: }
|