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() {}
 126         public void run() throws BkellException {
 127
 128
 129                 while(expVisitor.isActive()) {
 130
 131                         logger.debug("bkell > ");
 132                         try {
 133
 134                                 //** parse the syntax and provide the MODEL
 135                                 Parser parser = new Parser(new Lexer(pbreader) {
 136
 137                                         Logger logger = Logger.getLogger(Lexer.class);
 138                                         protected void filter() {
 139                                 logger.debug(token.getClass() + ", state : " + state.id() + ", text : [" + token.getText() + "]");
 140                             }
 141                         });
 142
 143                                 logger.debug("bkell > 1");
 144
 145                                 // parse the input
 146                                 Start tree = parser.parse();
 147
 148                                 logger.debug("bkell > 2");
 149
 150                                 // apply the Visitor
 151                                 tree.apply(expVisitor);
 152
 153                                 logger.debug("bkell > 3");
 154
 155                                 synchronized(this) { this.notify(); //** if any thread is waiting on this thread's monitor, wake them up
 156                                 }
 157
 158                         logger.debug("bkell > 4");
 159
 160                         }
 161                         catch(java.io.IOException e) {
 162
 163                                 logger.error(e.getMessage(), e);
 164                                 BkellException bke = com.interrupt.bookkeeping.util.Util.generateBkellException(e);
 165                                 logger.error(bke.getLogMessages().toXML(false));
 166
 167                                 this.setBkellException(bke);
 168                                 this.fillInPreviousCommandResult(bke.getLogMessages());
 169
 170                                 synchronized(this) { this.notify(); //** if any thread is waiting on this thread's monitor, wake them up
 171                                 }
 172                         }
 173                         catch(LexerException e) {
 174
 175                                 logger.error(e.getMessage(), e);
 176                                 BkellException bke = com.interrupt.bookkeeping.util.Util.generateBkellException(e);
 177                                 logger.error(bke.getLogMessages().toXML(false));
 178
 179                                 this.setBkellException(bke);
 180                                 this.fillInPreviousCommandResult(bke.getLogMessages());
 181
 182                                 synchronized(this) { this.notify(); //** if any thread is waiting on this thread's monitor, wake them up
 183                                 }
 184                         }
 185                         catch(ParserException e) {
 186
 187                                 logger.error(e.getMessage(), e);
 188                                 BkellException bke = com.interrupt.bookkeeping.util.Util.generateBkellException(e);
 189                                 logger.error(bke.getLogMessages().toXML(false));
 190
 191                                 this.setBkellException(bke);
 192                                 this.fillInPreviousCommandResult(bke.getLogMessages());
 193
 194                                 synchronized(this) { this.notify(); //** if any thread is waiting on this thread's monitor, wake them up
 195                                 }
 196                         }
 197                         catch(AuthorisationException e) {
 198
 199                                 logger.error(e.getMessage(), e);
 200                                 BkellException bke = com.interrupt.bookkeeping.util.Util.generateBkellException(e);
 201                                 logger.error(bke.getLogMessages().toXML(false));
 202
 203                                 this.setBkellException(bke);
 204                                 this.fillInPreviousCommandResult(bke.getLogMessages());
 205
 206                                 synchronized(this) { this.notify(); //** if any thread is waiting on this thread's monitor, wake them up
 207                                 }
 208                         }
 209                         catch(BkellException e) {
 210
 211                                 System.out.println("Here... ["+ e.getLogMessages().toXML(false) +"]");
 212
 213                                 this.setBkellException(e);
 214                                 this.fillInPreviousCommandResult(e.getLogMessages());
 215
 216                                 synchronized(this) { this.notify(); //** if any thread is waiting on this thread's monitor, wake them up
 217                                 }
 218                         }
 219                         catch(Exception e) {
 220
 221                                 logger.error(e.getMessage(), e);
 222                                 BkellException bke = com.interrupt.bookkeeping.util.Util.generateBkellException(e);
 223                                 logger.error(bke.getLogMessages().toXML(false));
 224
 225                                 this.setBkellException(bke);
 226                                 this.fillInPreviousCommandResult(bke.getLogMessages());
 227
 228                                 synchronized(this) { this.notify(); //** if any thread is waiting on this thread's monitor, wake them up
 229                                 }
 230                         }
 231                         catch(Throwable e) {
 232
 233                                 logger.error(e.getMessage(), e);
 234                                 BkellException bke = com.interrupt.bookkeeping.util.Util.generateBkellException(e);
 235                                 logger.error(bke.getLogMessages().toXML(false));
 236
 237                                 this.setBkellException(bke);
 238                                 this.fillInPreviousCommandResult(bke.getLogMessages());
 239
 240                                 synchronized(this) { this.notify(); //** if any thread is waiting on this thread's monitor, wake them up
 241                                 }
 242                         }
 243
 244                 }
 245
 246         }
 247
 248
 249         private void fillInPreviousCommandResult(IBob bob) {
 250
 251                 AXmlCommandInputRef replacorReference = new AXmlCommandInputRef();
 252         replacorReference.setReference(bob);
 253         this.expVisitor.setPreviousCommandResult(replacorReference);
 254         }
 255
 256         public static void main(String args[]) {
 257
 258
 259                 Logger logger = Logger.getLogger(Bkell.class);
 260                 logger.debug("bkell >");
 261
 262                 System.getProperties().setProperty(com.interrupt.bob.util.Util.DEF, BookkeepingSystemProperties.instance().getProperty("bob.def"));
 263                 System.getProperties().setProperty(com.interrupt.bob.util.Util.BASE, ".");
 264                 System.getProperties().setProperty(com.interrupt.bob.util.Util.END, ".xml");
 265
 266                 ISystem system =
 267                         (ISystem)Bob.loadS(
 268                                 Bkell.class.getResourceAsStream("/bookkeeping.system.xml"),
 269                                         BookkeepingSystemProperties.instance().getProperty("bob.def") );
 270
 271                 //logger.debug("Loaded Bookkkeeping system > "+ system.toXML(false));
 272
 273                 Bkell bkell = null;
 274                 try {
 275                         bkell = (Bkell)((com.interrupt.bookkeeping.System)system).findBkellById("bkell.main");
 276                 }
 277                 catch(Exception e) {
 278                         e.printStackTrace();
 279                 }
 280                 bkell.initialise();
 281
 282
 283                 //**
 284                 BkellUncaughtExceptionHandler ehandler = new BkellUncaughtExceptionHandler();
 285                 Thread bkellThread = new Thread(bkell);
 286                 bkellThread.setDefaultUncaughtExceptionHandler(ehandler);
 287                 try {
 288
 289                         bkellThread.start();
 290
 291                         // 'join()' is a block method for the thread
 292                         bkellThread.join();
 293                 }
 294                 catch(BkellException e) {
 295
 296                         ILogs logs = e.getLogMessages();
 297                         logger.error(logs.toXML(false));
 298
 299                         e.printStackTrace();
 300                 }
 301                 catch(InterruptedException e) {
 302                         e.printStackTrace();
 303                 }
 304                 System.exit(0);
 305
 306         }
 307
 308
 309 }
 310
 311
 312