src/com/interrupt/bookkeeping/cc/bkell/Bkell.java

   1 package com.interrupt.bookkeeping.cc.bkell;
   2
   3
   4 import java.io.IOException;
   5 import java.io.InputStream;
   6 import java.io.InputStreamReader;
   7 import java.io.PipedInputStream;
   8 import java.io.PipedOutputStream;
   9 import java.io.PushbackReader;
  10 import java.io.Reader;
  11 import java.io.Serializable;
  12 import java.lang.Thread.UncaughtExceptionHandler;
  13 import java.lang.reflect.InvocationTargetException;
  14
  15 import org.apache.log4j.Logger;
  16 import com.interrupt.bob.base.IBob;
  17 import com.interrupt.bob.base.IVisitor;
  18
  19 import com.interrupt.bob.base.Bob;
  20 import com.interrupt.bookkeeping.ISystem;
  21 import com.interrupt.bookkeeping.cc.ExpressionVisitor;
  22 import com.interrupt.bookkeeping.cc.bkell.aauth.Aauthentication;
  23 import com.interrupt.bookkeeping.cc.lexer.Lexer;
  24 import com.interrupt.bookkeeping.cc.lexer.LexerException;
  25 import com.interrupt.bookkeeping.cc.node.AXmlCommandInputRef;
  26 import com.interrupt.bookkeeping.cc.node.Start;
  27 import com.interrupt.bookkeeping.cc.parser.Parser;
  28 import com.interrupt.bookkeeping.cc.parser.ParserException;
  29 import com.interrupt.bookkeeping.exception.AuthorisationException;
  30 import com.interrupt.bookkeeping.exception.BkellException;
  31 import com.interrupt.bookkeeping.exception.BkellUncaughtExceptionHandler;
  32 import com.interrupt.bookkeeping.system.BookkeepingSystem;
  33 import com.interrupt.bookkeeping.system.BookkeepingSystemProperties;
  34 import com.interrupt.bookkeeping.users.IUserSession;
  35 import com.interrupt.logs.GLog;
  36 import com.interrupt.logs.GLogMessage;
  37 import com.interrupt.logs.GLogMessages;
  38 import com.interrupt.logs.GLogs;
  39 import com.interrupt.logs.ILog;
  40 import com.interrupt.logs.ILogMessage;
  41 import com.interrupt.logs.ILogMessages;
  42 import com.interrupt.logs.ILogs;
  43 import com.interrupt.spittoon.Spittoon;
  44
  45 public class Bkell extends GBkell implements Runnable, Serializable {
  46
  47
  48     public static final String BKELL_NAME = "bookkeeping.shell";
  49     private Logger logger = Logger.getLogger(Bkell.class);
  50         private transient InputStream inputStream = null;
  51         private BkellException bkellException = null;
  52
  53         private ExpressionVisitor expVisitor = null;
  54         private PushbackReader pbreader = null;
  55
  56         public Bkell() {
  57
  58                 inputStream = System.in;
  59                 pbreader = new PushbackReader( new InputStreamReader(inputStream), 1024 );
  60         }
  61
  62
  63         public BkellException getBkellException() { return bkellException; }
  64         public void setBkellException(BkellException bkellException) { this.bkellException = bkellException; }
  65
  66
  67         // inputStream
  68         public InputStream getInputStream() {
  69                 return inputStream;
  70         }
  71         public void setInputStream(InputStream inputStream) {
  72                 this.inputStream = inputStream;
  73                 pbreader = new PushbackReader( new InputStreamReader(this.inputStream), 1024 );
  74         }
  75
  76         // pushbackReader
  77         public void updatePushbackReader(Reader reader) {
  78             pbreader = new PushbackReader( reader, 1024 );
  79         }
  80
  81         public synchronized void connectPipe(PipedOutputStream postream) throws IOException {
  82                 ((PipedInputStream)inputStream).connect(postream);
  83         }
  84
  85         // expression visitor
  86         public ExpressionVisitor getExpVisitor() {
  87         return expVisitor;
  88     }
  89     public void setExpVisitor(ExpressionVisitor expVisitor) {
  90         this.expVisitor = expVisitor;
  91         this.expVisitor.setBkellEnv(this);
  92     }
  93
  94
  95     public IUserSession getUserSession() {
  96         return this.getExpVisitor().getUserSession();
  97     }
  98     public void setUserSession(IUserSession userSession) {
  99         this.getExpVisitor().setUserSession(userSession);
 100     }
 101
 102
 103     // previousCommandResult
 104         public IBob getPreviousCommandResult() {
 105                 return this.expVisitor.getPreviousCommandResult().getReference();
 106         }
 107
 108
 109         public void initialise() {
 110
 111                 logger.debug("Bkell.initialise() CALLED");
 112                 com.interrupt.spittoon.Spittoon spittoon = new com.interrupt.spittoon.Spittoon();
 113                 spittoon.initialise();
 114
 115         com.interrupt.bookkeeping.System system = (com.interrupt.bookkeeping.System)spittoon.
 116                         retrieve(spittoon.getAauthDbUrl(),
 117                                 "/system[ @id='main.system' ]", true);
 118
 119         Aauthentication aauthentication = system.getAauthentication();
 120         expVisitor = new ExpressionVisitor(spittoon);
 121         expVisitor.setAauthentication(aauthentication);
 122         expVisitor.setBkellEnv(this);
 123
 124         }
 125         public void shutdown() throws IOException {
 126
 127                 ((PipedInputStream)inputStream).close();
 128                 this.getExpVisitor().setActive(false);
 129
 130         }
 131
 132         public void run() throws BkellException {
 133
 134
 135                 while(expVisitor.isActive()) {
 136
 137                         logger.debug("bkell > ");
 138                         try {
 139
 140                                 //** parse the syntax and provide the MODEL
 141                                 Parser parser = new Parser(new Lexer(pbreader) {
 142
 143                                         Logger logger = Logger.getLogger(Lexer.class);
 144                                         protected void filter() {
 145                                 logger.debug(token.getClass() + ", state : " + state.id() + ", text : [" + token.getText() + "]");
 146                             }
 147                         });
 148
 149                                 logger.debug("bkell > 1");
 150
 151                                 // parse the input
 152                                 Start tree = parser.parse();
 153
 154                                 logger.debug("bkell > 2");
 155
 156                                 // apply the Visitor
 157                                 tree.apply(expVisitor);
 158
 159                                 logger.debug("bkell > 3");
 160
 161                                 synchronized(this) { this.notify(); //** if any thread is waiting on this thread's monitor, wake them up
 162                                 }
 163
 164                         logger.debug("bkell > 4 > expVisitor.isActive ["+ expVisitor.isActive() +"]");
 165
 166                         }
 167                         catch(java.io.IOException e) {
 168
 169                                 logger.error(e.getMessage(), e);
 170                                 BkellException bke = com.interrupt.bookkeeping.util.Util.generateBkellException(e);
 171                                 logger.error(bke.getLogMessages().toXML(false));
 172
 173                                 this.setBkellException(bke);
 174                                 this.fillInPreviousCommandResult(bke.getLogMessages());
 175
 176                                 synchronized(this) { this.notify(); //** if any thread is waiting on this thread's monitor, wake them up
 177                                 }
 178                         }
 179                         catch(LexerException e) {
 180
 181                                 logger.error(e.getMessage(), e);
 182                                 BkellException bke = com.interrupt.bookkeeping.util.Util.generateBkellException(e);
 183                                 logger.error(bke.getLogMessages().toXML(false));
 184
 185                                 this.setBkellException(bke);
 186                                 this.fillInPreviousCommandResult(bke.getLogMessages());
 187
 188                                 synchronized(this) { this.notify(); //** if any thread is waiting on this thread's monitor, wake them up
 189                                 }
 190                         }
 191                         catch(ParserException e) {
 192
 193                                 logger.error(e.getMessage(), e);
 194                                 BkellException bke = com.interrupt.bookkeeping.util.Util.generateBkellException(e);
 195                                 logger.error(bke.getLogMessages().toXML(false));
 196
 197                                 this.setBkellException(bke);
 198                                 this.fillInPreviousCommandResult(bke.getLogMessages());
 199
 200                                 synchronized(this) { this.notify(); //** if any thread is waiting on this thread's monitor, wake them up
 201                                 }
 202                         }
 203                         catch(AuthorisationException e) {
 204
 205                                 logger.error(e.getMessage(), e);
 206                                 BkellException bke = com.interrupt.bookkeeping.util.Util.generateBkellException(e);
 207                                 logger.error(bke.getLogMessages().toXML(false));
 208
 209                                 this.setBkellException(bke);
 210                                 this.fillInPreviousCommandResult(bke.getLogMessages());
 211
 212                                 synchronized(this) { this.notify(); //** if any thread is waiting on this thread's monitor, wake them up
 213                                 }
 214                         }
 215                         catch(BkellException e) {
 216
 217                                 System.out.println("Here... ["+ e.getLogMessages().toXML(false) +"]");
 218
 219                                 this.setBkellException(e);
 220                                 this.fillInPreviousCommandResult(e.getLogMessages());
 221
 222                                 synchronized(this) { this.notify(); //** if any thread is waiting on this thread's monitor, wake them up
 223                                 }
 224                         }
 225                         catch(Exception e) {
 226
 227                                 logger.error(e.getMessage(), e);
 228                                 BkellException bke = com.interrupt.bookkeeping.util.Util.generateBkellException(e);
 229                                 logger.error(bke.getLogMessages().toXML(false));
 230
 231                                 this.setBkellException(bke);
 232                                 this.fillInPreviousCommandResult(bke.getLogMessages());
 233
 234                                 synchronized(this) { this.notify(); //** if any thread is waiting on this thread's monitor, wake them up
 235                                 }
 236                         }
 237                         catch(Throwable e) {
 238
 239                                 logger.error(e.getMessage(), e);
 240                                 BkellException bke = com.interrupt.bookkeeping.util.Util.generateBkellException(e);
 241                                 logger.error(bke.getLogMessages().toXML(false));
 242
 243                                 this.setBkellException(bke);
 244                                 this.fillInPreviousCommandResult(bke.getLogMessages());
 245
 246                                 synchronized(this) { this.notify(); //** if any thread is waiting on this thread's monitor, wake them up
 247                                 }
 248                         }
 249
 250                 }
 251
 252                 logger.debug("bkell no longer active. EXITing");
 253                 this.notify();
 254
 255         }
 256
 257
 258         private void fillInPreviousCommandResult(IBob bob) {
 259
 260                 AXmlCommandInputRef replacorReference = new AXmlCommandInputRef();
 261         replacorReference.setReference(bob);
 262         this.expVisitor.setPreviousCommandResult(replacorReference);
 263         }
 264
 265         public static void main(String args[]) {
 266
 267
 268                 Logger logger = Logger.getLogger(Bkell.class);
 269                 logger.debug("bkell >");
 270
 271                 System.getProperties().setProperty(com.interrupt.bob.util.Util.DEF, BookkeepingSystemProperties.instance().getProperty("bob.def"));
 272                 System.getProperties().setProperty(com.interrupt.bob.util.Util.BASE, ".");
 273                 System.getProperties().setProperty(com.interrupt.bob.util.Util.END, ".xml");
 274
 275                 ISystem system =
 276                         (ISystem)Bob.loadS(
 277                                 Bkell.class.getResourceAsStream("/bookkeeping.system.xml"),
 278                                         BookkeepingSystemProperties.instance().getProperty("bob.def") );
 279
 280                 //logger.debug("Loaded Bookkkeeping system > "+ system.toXML(false));
 281
 282                 Bkell bkell = null;
 283                 try {
 284                         bkell = (Bkell)((com.interrupt.bookkeeping.System)system).findBkellById("bkell.main");
 285                 }
 286                 catch(Exception e) {
 287                         e.printStackTrace();
 288                 }
 289                 bkell.initialise();
 290
 291
 292                 //**
 293                 BkellUncaughtExceptionHandler ehandler = new BkellUncaughtExceptionHandler();
 294                 Thread bkellThread = new Thread(bkell);
 295                 bkellThread.setDefaultUncaughtExceptionHandler(ehandler);
 296                 try {
 297
 298                         bkellThread.start();
 299
 300                         // 'join()' is a block method for the thread
 301                         bkellThread.join();
 302                 }
 303                 catch(BkellException e) {
 304
 305                         ILogs logs = e.getLogMessages();
 306                         logger.error(logs.toXML(false));
 307
 308                         e.printStackTrace();
 309                 }
 310                 catch(InterruptedException e) {
 311                         e.printStackTrace();
 312                 }
 313                 System.exit(0);
 314
 315         }
 316
 317
 318 }
 319
 320
 321