src/uk/ac/vamsas/test/ExampleApplication.java

   1 /**
   2  * Created on 14-Sep-2005
   3  *
   4  * TODO To change the template for this generated file go to
   5  * Window - Preferences - Java - Code Style - Code Templates
   6  */
   7 package uk.ac.vamsas.test;
   8
   9 import uk.ac.vamsas.client.*;
  10 import uk.ac.vamsas.client.picking.IMessageHandler;
  11 import uk.ac.vamsas.client.picking.IPickManager;
  12 import uk.ac.vamsas.client.picking.Message;
  13 import uk.ac.vamsas.objects.core.VAMSAS;
  14 import uk.ac.vamsas.test.objects.Core;
  15
  16 import java.awt.Event;
  17 import java.beans.PropertyChangeEvent;
  18 import java.beans.PropertyChangeListener;
  19 import java.io.IOException;
  20 import java.util.Vector;
  21
  22 /**
  23  * Toy vamsas command line client application demonstrating the API. TODO: test
  24  * appData get/set methods TODO: verify and test pickManager and interaction
  25  * between it and other session events TODO: add more session interaction events
  26  * (currently: modifies document on start up, then modifies every 2 updates
  27  * before finalizing after 5 updates.
  28  *
  29  * @author jimp
  30  */
  31
  32 public class ExampleApplication
  33 {
  34         private static ClientHandle app;
  35
  36         private static UserHandle user; // TODO: make this something defined by the
  37                                                                         // api
  38
  39         private static IClientFactory clientfactory;
  40
  41         private static IClient vorbaclient;
  42
  43         private static byte[] mydata;
  44
  45         private static Vector vamsasObjects;
  46
  47         private static boolean isUpdated = false;
  48
  49         private static boolean isShuttingdown = false;
  50
  51         private static boolean isFinalizing = false;
  52
  53         private static void processVamsasDocument(IClientDocument doc)
  54         {
  55                 doc.addVamsasRoot(Core.getDemoVamsas());
  56                 vorbaclient.updateDocument(doc);
  57                 // merge vamsasObjects with vamsas objects in document
  58                 // get this apps 'mydata' if it hasn't got it already.
  59                 // .. access this application's 'public' mydata' if there is any.
  60         }
  61
  62         private static void addHandlers(IClient avorbaclient)
  63         {
  64                 // make a non-volatile reference to the client instance.
  65                 final IClient vorbaclient = avorbaclient;
  66                 // register update handler
  67                 vorbaclient.addDocumentUpdateHandler(new PropertyChangeListener() {
  68                         public void propertyChange(PropertyChangeEvent evt)
  69                         {
  70                                 System.out.println("Vamsas document update for "
  71                                                 + evt.getPropertyName() + ": " + evt.getOldValue()
  72                                                 + " to " + evt.getNewValue());
  73                                 // merge new data into ours.
  74                                 // example - output doc
  75                                 try
  76                                 {
  77                                         IClientDocument cdoc = vorbaclient.getClientDocument();
  78                                         uk.ac.vamsas.test.simpleclient.ArchiveReports.rootReport(
  79                                                         cdoc.getVamsasRoots(), true, System.out);
  80                                         vorbaclient.updateDocument(cdoc);
  81                                 }
  82                                 catch (Exception e)
  83                                 {
  84                                         System.err
  85                                                         .println("Exception whilst dumping document tree after an update.");
  86                                         e.printStackTrace(System.err);
  87                                 }
  88                                 isUpdated = true; // tell main thread to reflect change...
  89                         }
  90                 });
  91                 // register close handler
  92                 vorbaclient.addVorbaEventHandler(Events.DOCUMENT_REQUESTTOCLOSE,
  93                                 new PropertyChangeListener() {
  94                                         public void propertyChange(PropertyChangeEvent evt)
  95                                         {
  96                                                 System.out
  97                                                                 .println("Received request to close vamsas document.");
  98                                                 // ask user for a filename to save it to.
  99                                                 // Then pass it to the vorba object...
 100                                                 vorbaclient.storeDocument(new java.io.File(
 101                                                                 "UserLocation"));
 102                                         }
 103                                 });
 104
 105                 // register some more handlers to monitor the session :
 106
 107                 vorbaclient.addVorbaEventHandler(Events.CLIENT_CREATION,
 108                                 new PropertyChangeListener() {
 109                                         public void propertyChange(PropertyChangeEvent evt)
 110                                         {
 111                                                 System.out.println("New Vamsas client for "
 112                                                                 + evt.getPropertyName() + ": "
 113                                                                 + evt.getOldValue() + " to "
 114                                                                 + evt.getNewValue());
 115                                                 // tell app add new client to its list of clients.
 116                                         }
 117                                 });
 118                 vorbaclient.addVorbaEventHandler(Events.CLIENT_FINALIZATION,
 119                                 new PropertyChangeListener() {
 120                                         public void propertyChange(PropertyChangeEvent evt)
 121                                         {
 122                                                 System.out.println("Vamsas client finalizing for "
 123                                                                 + evt.getPropertyName() + ": "
 124                                                                 + evt.getOldValue() + " to "
 125                                                                 + evt.getNewValue());
 126                                                 // tell app to update its list of clients to communicate
 127                                                 // with.
 128                                         }
 129                                 });
 130                 vorbaclient.addVorbaEventHandler(Events.SESSION_SHUTDOWN,
 131                                 new PropertyChangeListener() {
 132                                         public void propertyChange(PropertyChangeEvent evt)
 133                                         {
 134                                                 System.out.println("Session " + evt.getPropertyName()
 135                                                                 + " is shutting down.");
 136                                                 // tell app to finalize its session data before
 137                                                 // shutdown.
 138                                         }
 139                                 });
 140                 vorbaclient.addVorbaEventHandler(Events.DOCUMENT_FINALIZEAPPDATA,
 141                                 new PropertyChangeListener() {
 142                                         public void propertyChange(PropertyChangeEvent evt)
 143                                         {
 144                                                 System.out
 145                                                                 .println("Application received a DOCUMENT_FINALIZEAPPDATA event.");
 146                                                 // tell app to finalize its session data prior to the
 147                                                 // storage of the current session as an archive.
 148                                         }
 149                                 });
 150
 151         }
 152
 153         public static String Usage = "ExampleApplication [session urn] watch/n( future usage is :/n <vamsasFileDirectory> <vamsasSessionURN> <action> [+<arguments>]\n"
 154                         + "<action> is one of :\n\tsave,update,close,watch";
 155
 156         static String sess = null;
 157
 158         private static boolean parseArgs(String args[])
 159         {
 160                 if (args.length == 0)
 161                 {
 162                         return false;
 163                 }
 164                 if (!args[0].toLowerCase().equals("watch"))
 165                 {
 166                         sess = args[0];
 167                 }
 168                 return true;
 169         }
 170
 171         public static void main(String[] args)
 172         {
 173                 class ExamplePicker extends Thread
 174                 {
 175                         String me = null;
 176
 177                         public IPickManager pm = null;
 178
 179                         ExamplePicker(String me, IPickManager pm)
 180                         {
 181                                 this.me = me;
 182                                 this.pm = pm;
 183                         }
 184
 185                         public void run()
 186                         {
 187                                 int mcount = 1;
 188                                 while (pm != null)
 189                                 {
 190                                         try { Thread.sleep(1000 + (long) Math.random() * 10000); }
 191                                         catch (Exception e) {}
 192
 193                                         if (pm != null)
 194                                         {
 195                                                 pm.sendMessage(new uk.ac.vamsas.client.picking.CustomMessage("Message " + mcount++ + " from " + me));
 196                                         }
 197                                 }
 198                         }
 199
 200                 }
 201
 202                 if (!parseArgs(args))
 203                 {
 204                         System.err.print(Usage);
 205                 }
 206                 // get IClientFactory
 207                 try
 208                 {
 209                         clientfactory = new uk.ac.vamsas.client.simpleclient.SimpleClientFactory();
 210                 }
 211                 catch (IOException e)
 212                 {
 213                         System.err.println(e + "\n" + Usage);
 214                         System.exit(1);
 215                 }
 216
 217                 // get an Iclient with session data
 218                 app = new ClientHandle("uk.ac.vamsas.test.ExampleApplication", "0.1");
 219                 user = new UserHandle("arnolduser", "deathsdoor");
 220                 try
 221                 {
 222                         vorbaclient = clientfactory.getIClient(app, user);
 223                 }
 224                 catch (NoDefaultSessionException e)
 225                 {
 226                         System.err
 227                                         .println("There appear to be several sessions to choose from :");
 228                         String[] sessions = clientfactory.getCurrentSessions();
 229                         for (int s = 0; s < sessions.length; s++)
 230                                 System.err.println(sessions[s]);
 231                         System.exit(2);
 232                 }
 233                 addHandlers(vorbaclient);
 234                 try
 235                 {
 236                         vorbaclient.joinSession();
 237                 }
 238                 catch (Exception se)
 239                 {
 240                         se.printStackTrace();
 241                         System.err.println(se + " when joining session.\n" + Usage);
 242                         System.exit(1);
 243                 }
 244                 // register an update listener and a close listener.
 245                 // get document data
 246                 try
 247                 {
 248                         IClientDocument cdoc = vorbaclient.getClientDocument();
 249                         processVamsasDocument(cdoc);
 250                 }
 251                 catch (Exception e)
 252                 {
 253                         System.err
 254                                         .println("Unexpected exception when retrieving the client document for the first time!");
 255                         e.printStackTrace(System.err);
 256                         System.exit(1);
 257                 }
 258                 int update = 0;
 259                 ExamplePicker picker = new ExamplePicker(vorbaclient.getClientHandle()
 260                                 .getClientUrn(), vorbaclient.getPickManager());
 261
 262                 picker.start();
 263                 picker.pm.registerMessageHandler(new IMessageHandler() {
 264
 265                         public void handleMessage(Message message)
 266                         {
 267                                 System.out
 268                                                 .println("Received |" + message.getRawMessage() + "|");
 269                         }
 270
 271                 });
 272                 while (!isShuttingdown && update < 5)
 273                 {
 274                         // do something with data
 275                         // , update document, or something.
 276                         // ..
 277                         if (isUpdated)
 278                         {
 279                                 System.out.println("Update handler called " + (++update)
 280                                                 + " times");
 281                                 System.out
 282                                                 .println("******************************************");
 283                                 isUpdated = false; // TODO: saner update det method.
 284                                 if (update % 2 == 1)
 285                                 {
 286                                         try
 287                                         {
 288                                                 IClientDocument cdoc = vorbaclient.getClientDocument();
 289                                                 processVamsasDocument(cdoc);
 290                                         }
 291                                         catch (Exception e)
 292                                         {
 293                                                 System.err
 294                                                                 .println("Error when updating document after an even numbered update.");
 295                                                 e.printStackTrace(System.err);
 296                                         }
 297                                 }
 298                         }
 299
 300                         try     { Thread.sleep(15); }
 301                         catch (Exception e) {}
 302
 303                 }
 304                 System.out.println("Shutting down picker.");
 305                 picker.pm = null;
 306                 while (picker.isAlive())
 307                 {
 308                         System.out.println("Waiting for picker to die...");
 309                         try
 310                         {
 311                                 Thread.sleep(1000);
 312                         }
 313                         catch (Exception e)
 314                         {
 315                         }
 316                         ;
 317                 }
 318
 319                 System.out.println("Finalizing.");
 320                 // call finalizeClient
 321                 vorbaclient.finalizeClient();
 322                 // { meanwhile, eventHandlers are called to do any saves if need be }
 323                 // and all registered listeners will be deregistered to avoid deadlock.
 324
 325                 // finish
 326         }
 327
 328 }