001    /*
002     * Copyright (C) 2003-2009 eXo Platform SAS.
003     *
004     * This is free software; you can redistribute it and/or modify it
005     * under the terms of the GNU Lesser General Public License as
006     * published by the Free Software Foundation; either version 2.1 of
007     * the License, or (at your option) any later version.
008     *
009     * This software is distributed in the hope that it will be useful,
010     * but WITHOUT ANY WARRANTY; without even the implied warranty of
011     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
012     * Lesser General Public License for more details.
013     *
014     * You should have received a copy of the GNU Lesser General Public
015     * License along with this software; if not, write to the Free
016     * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
017     * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
018     */
019    
020    package org.crsh.shell;
021    
022    import org.crsh.command.ScriptException;
023    
024    import java.util.Collections;
025    
026    /**
027     * The response of a shell invocation.
028     *
029     * @author <a href="mailto:julien.viet@exoplatform.com">Julien Viet</a>
030     * @version $Revision$
031     */
032    public abstract class ShellResponse {
033    
034      public static UnknownCommand unknownCommand(String name) {
035        return new UnknownCommand(name);
036      }
037    
038      public static NoCommand noCommand() {
039        return NoCommand.INSTANCE;
040      }
041    
042      public static Ok ok(Iterable<?> produced) {
043        return new Ok(produced);
044      }
045    
046      public static Ok ok() {
047        return new Ok();
048      }
049    
050      public static Display display(String text) {
051        return new Display(text);
052      }
053    
054      public static Display display(Iterable<?> produced, String text) {
055        return new Display(produced, text);
056      }
057    
058      public static Error evalError(String msg, Throwable throwable) {
059        return new Error(ErrorType.EVALUATION, msg, throwable);
060      }
061    
062      public static Error evalError(String msg) {
063        return new Error(ErrorType.EVALUATION, msg);
064      }
065    
066      public static Error internalError(String msg, Throwable throwable) {
067        return new Error(ErrorType.INTERNAL, msg, throwable);
068      }
069    
070      public static Error internalError(String msg) {
071        return new Error(ErrorType.INTERNAL, msg);
072      }
073    
074      public static Error error(ErrorType type, String msg, Throwable throwable) {
075        return new Error(type, msg, throwable);
076      }
077    
078      public static Error error(ErrorType type, String msg) {
079        return new Error(type, msg);
080      }
081    
082      public static Cancelled cancelled() {
083        return Cancelled.INSTANCE;
084      }
085    
086      public static Close close() {
087        return Close.INSTANCE;
088      }
089    
090      public abstract String getText();
091    
092      public static class UnknownCommand extends ShellResponse {
093    
094        /** . */
095        private final String name;
096    
097        private UnknownCommand(String name) {
098          this.name = name;
099        }
100    
101        public String getName() {
102          return name;
103        }
104    
105        @Override
106        public String getText() {
107          return name + ": command not found";
108        }
109    
110        @Override
111        public String toString() {
112          return "UnknownCommand[" + name + "]";
113        }
114      }
115    
116      public static class NoCommand extends ShellResponse {
117    
118        /** . */
119        private static final NoCommand INSTANCE = new NoCommand();
120    
121        private NoCommand() {
122        }
123    
124        @Override
125        public String getText() {
126          return "Please type something";
127        }
128      }
129    
130      public static class Close extends ShellResponse {
131    
132        /** . */
133        private static final Close INSTANCE = new Close();
134    
135        private Close() {
136        }
137    
138        @Override
139        public String getText() {
140          return "Have a good day!\r\n";
141        }
142      }
143    
144      /**
145       * Command execution is terminated.
146       */
147      public static class Ok extends ShellResponse {
148    
149        /** . */
150        private final Iterable<?> produced;
151    
152        private Ok() {
153          this(Collections.<Object>emptyList());
154        }
155    
156        private Ok(Iterable<?> produced) {
157          this.produced = produced;
158        }
159    
160        public Iterable<?> getProduced() {
161          return produced;
162        }
163    
164        @Override
165        public String getText() {
166          return "";
167        }
168      }
169    
170      public static class Display extends Ok {
171    
172        /** . */
173        private final String text;
174    
175        private Display(String text) {
176          this.text = text;
177        }
178    
179        private Display(Iterable<?> produced, String text) {
180          super(produced);
181    
182          //
183          this.text = text;
184        }
185    
186        @Override
187        public boolean equals(Object obj) {
188          if (obj == this) {
189            return true;
190          }
191          if (obj instanceof Display) {
192            Display that = (Display)obj;
193            return text.equals(that.text);
194          }
195          return false;
196        }
197    
198        @Override
199        public String getText() {
200          return text;
201        }
202      }
203    
204      public static class Cancelled extends ShellResponse {
205    
206        /** . */
207        private static final Cancelled INSTANCE = new Cancelled();
208    
209        private Cancelled() {
210        }
211    
212        @Override
213        public String getText() {
214          return "cancelled" ;
215        }
216      }
217    
218      public static class Error extends ShellResponse {
219    
220        /** . */
221        private final ErrorType type;
222    
223        /** . */
224        private final Throwable throwable;
225    
226        /** . */
227        private final String msg;
228    
229        private Error(ErrorType type, String msg) {
230          this.type = type;
231          this.msg = msg;
232          this.throwable = null;
233        }
234    
235        private Error(ErrorType type, String msg, Throwable throwable) {
236          this.type = type;
237          this.msg = msg;
238          this.throwable = throwable;
239        }
240    
241        public ErrorType getType() {
242          return type;
243        }
244    
245        public Throwable getThrowable() {
246          return throwable;
247        }
248    
249        @Override
250        public String getText() {
251          return msg;
252        }
253    
254        public String toString() {
255          return "ShellResponse.Error[type=" + type + ",msg=" + msg + "]";
256        }
257      }
258    }