java/src/IceGridGUI/LiveDeployment/ShowLogDialog.java

   1 // **********************************************************************
   2 //
   3 // Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved.
   4 //
   5 // This copy of Ice is licensed to you under the terms described in the
   6 // ICE_LICENSE file included in this distribution.
   7 //
   8 // **********************************************************************
   9
  10 package IceGridGUI.LiveDeployment;
  11
  12 import java.awt.Cursor;
  13 import java.awt.BorderLayout;
  14 import java.awt.Container;
  15 import java.awt.Dimension;
  16 import java.awt.Frame;
  17
  18 import java.awt.event.ActionEvent;
  19 import java.awt.event.ActionListener;
  20 import java.awt.event.KeyEvent;
  21
  22 import javax.swing.AbstractAction;
  23 import javax.swing.Action;
  24 import javax.swing.ButtonGroup;
  25 import javax.swing.JComponent;
  26 import javax.swing.JDialog;
  27 import javax.swing.JFileChooser;
  28 import javax.swing.JMenu;
  29 import javax.swing.JMenuBar;
  30 import javax.swing.JOptionPane;
  31 import javax.swing.JPanel;
  32 import javax.swing.JRadioButtonMenuItem;
  33 import javax.swing.JScrollPane;
  34 import javax.swing.JTextArea;
  35 import javax.swing.JToggleButton;
  36 import javax.swing.JToolBar;
  37 import javax.swing.KeyStroke;
  38 import javax.swing.SwingUtilities;
  39
  40 import com.jgoodies.looks.BorderStyle;
  41 import com.jgoodies.looks.HeaderStyle;
  42 import com.jgoodies.looks.Options;
  43 import com.jgoodies.looks.plastic.PlasticLookAndFeel;
  44
  45 import IceGrid.*;
  46 import IceGridGUI.*;
  47
  48 class ShowLogDialog extends JDialog
  49 {
  50     static interface FileIteratorFactory
  51     {
  52         FileIteratorPrx open(int count)
  53             throws Ice.UserException;
  54
  55         String getTitle();
  56
  57         String getDefaultFilename();
  58     }
  59
  60     private class FIFOTextArea extends JTextArea
  61     {
  62         FIFOTextArea(int rows, int colums)
  63         {
  64             super(rows, colums);
  65             setEditable(false);
  66             setLineWrap(true);
  67         }
  68
  69         public void appendLines(final String[] lines, final int maxLines, final int maxSize)
  70         {
  71             SwingUtilities.invokeLater(new Runnable()
  72                 {
  73                     public void run()
  74                     {
  75                         for(int i = 0; i < lines.length; ++i)
  76                         {
  77                             //
  78                             // The last line is always incomplete
  79                             //
  80                             if(i + 1 != lines.length)
  81                             {
  82                                 append(lines[i] + "\n");
  83                             }
  84                             else
  85                             {
  86                                 append(lines[i]);
  87                             }
  88                             removeLines(maxLines, maxSize);
  89                         }
  90                     }
  91                 });
  92         }
  93
  94         public void removeLines(int maxLines, int maxSize)
  95         {
  96             javax.swing.text.Document doc = getDocument();
  97             javax.swing.text.Element rootElt = doc.getDefaultRootElement();
  98
  99             //
 100             // We keep at least one line, no matter its length
 101             //
 102             int lineCount = getLineCount();
 103             while(lineCount > 1 && (doc.getLength() > maxSize || (lineCount > maxLines)))
 104             {
 105                 javax.swing.text.Element firstLine = rootElt.getElement(0);
 106                 try
 107                 {
 108                     doc.remove(0, firstLine.getEndOffset());
 109                 }
 110                 catch(javax.swing.text.BadLocationException ble)
 111                 {
 112                     assert false;
 113                 }
 114                 lineCount--;
 115             }
 116             setCaretPosition(doc.getLength());
 117         }
 118     }
 119
 120     private class ReaderThread extends Thread
 121     {
 122         ReaderThread()
 123         {
 124             _threadMaxLines = _maxLines;
 125             _threadMaxSize = _maxSize;
 126             _threadInitialLines = _initialLines;
 127             _threadMaxReadSize = _maxReadSize;
 128             _threadPeriod = _period;
 129
 130             _playButton.setSelected(true);
 131             _playItem.setSelected(true);
 132             _pause.setEnabled(true);
 133         }
 134
 135         private void openError(final String message)
 136         {
 137             SwingUtilities.invokeLater(
 138                 new Runnable()
 139                 {
 140                     public void run()
 141                     {
 142                         if(_textArea.getText() == null || _textArea.getText().length() == 0)
 143                         {
 144                             close(true);
 145                         }
 146                         else
 147                         {
 148                             stopReading();
 149                         }
 150
 151                         JOptionPane.showMessageDialog(
 152                             ShowLogDialog.this,
 153                             message,
 154                             _factory.getTitle() + ": cannot open file",
 155                             JOptionPane.ERROR_MESSAGE);
 156                     }
 157                 });
 158         }
 159
 160         public void run()
 161         {
 162             //
 163             // Open file
 164             //
 165             int initialLines;
 166
 167             synchronized(this)
 168             {
 169                 initialLines = _threadInitialLines;
 170             }
 171
 172             try
 173             {
 174                 _p = _factory.open(initialLines);
 175             }
 176             catch(Ice.UserException e)
 177             {
 178                 openError(e.toString());
 179                 return;
 180             }
 181             catch(Ice.LocalException e)
 182             {
 183                 openError(e.toString());
 184                 return;
 185             }
 186
 187             SwingUtilities.invokeLater(
 188                 new Runnable()
 189                 {
 190                     public void run()
 191                     {
 192                         if(isVisible())
 193                         {
 194                             _textArea.setText(null);
 195                         }
 196                         else
 197                         {
 198                             setVisible(true);
 199                         }
 200                     }
 201                 });
 202
 203             boolean firstRun = true;
 204             for(;;)
 205             {
 206                 synchronized(this)
 207                 {
 208                     if(!_done)
 209                     {
 210                         if(_paused)
 211                         {
 212                             while(_paused && !_done)
 213                             {
 214                                 try
 215                                 {
 216                                     wait();
 217                                 }
 218                                 catch(InterruptedException e)
 219                                 {
 220                                 }
 221                             }
 222                         }
 223                         else if(!firstRun)
 224                         {
 225                             try
 226                             {
 227                                 wait(_threadPeriod);
 228                             }
 229                             catch(InterruptedException e)
 230                             {
 231                             }
 232                         }
 233                         else
 234                         {
 235                             firstRun = false;
 236                         }
 237                     }
 238
 239                     if(_done)
 240                     {
 241                         cleanupIterator();
 242                         return;
 243                     }
 244                 }
 245
 246                 boolean eofEncountered = false;
 247
 248                 while(!eofEncountered)
 249                 {
 250                     int maxLines;
 251                     int maxSize;
 252                     int maxReadSize;
 253
 254                     synchronized(this)
 255                     {
 256                         if(_done || _paused)
 257                         {
 258                             break; // while(!eofEncountered)
 259                         }
 260
 261                         maxLines = _threadMaxLines;
 262                         maxSize = _threadMaxSize;
 263                         maxReadSize = _threadMaxReadSize;
 264                     }
 265
 266                     Ice.StringSeqHolder linesHolder = new Ice.StringSeqHolder();
 267
 268                     try
 269                     {
 270                         eofEncountered = _p.read(maxReadSize, linesHolder);
 271                     }
 272                     catch(IceGrid.FileNotAvailableException e)
 273                     {
 274                         _textArea.appendLines(new String[]
 275                             {
 276                                 "---------------------------",
 277                                 "IceGridAdmin caught: " + e.toString(),
 278                                 "---------------------------"
 279                             }, maxLines, maxSize);
 280                         SwingUtilities.invokeLater(
 281                             new Runnable()
 282                             {
 283                                 public void run()
 284                                 {
 285                                     stopReading();
 286                                 }
 287                             });
 288                         cleanupIterator();
 289                         return;
 290                     }
 291                     catch(Ice.LocalException e)
 292                     {
 293                         _textArea.appendLines(new String[]
 294                             {
 295                                 "---------------------------",
 296                                 "IceGridAdmin caught: " + e.toString(),
 297                                 "---------------------------"
 298                             }, maxLines, maxSize);
 299                         SwingUtilities.invokeLater(
 300                             new Runnable()
 301                             {
 302                                 public void run()
 303                                 {
 304                                     stopReading();
 305                                 }
 306                             });
 307                         return;
 308                     }
 309
 310                     _textArea.appendLines(linesHolder.value, maxLines, maxSize);
 311                 }
 312             }
 313         }
 314
 315         private void cleanupIterator()
 316         {
 317             try
 318             {
 319                 _p.destroy();
 320             }
 321             catch(Ice.LocalException e)
 322             {
 323                 // Ignored, maybe should log warning
 324             }
 325         }
 326
 327         synchronized void pause()
 328         {
 329             if(!_paused)
 330             {
 331                 _paused = true;
 332                 notify();
 333             }
 334         }
 335
 336         synchronized void terminate()
 337         {
 338             if(!_done)
 339             {
 340                 _done = true;
 341                 notify();
 342             }
 343         }
 344
 345         synchronized void play()
 346         {
 347             if(_paused)
 348             {
 349                 _paused = false;
 350                 notify();
 351             }
 352         }
 353
 354         synchronized void setPrefs()
 355         {
 356             _threadMaxLines = _maxLines;
 357             _threadMaxSize = _maxSize;
 358             _threadInitialLines = _initialLines;
 359             _threadMaxReadSize = _maxReadSize;
 360             _threadPeriod = _period;
 361         }
 362
 363         private  FileIteratorPrx _p;
 364         private boolean _done = false;
 365         private boolean _paused = false;
 366
 367         private int _threadMaxLines;
 368         private int _threadMaxSize;
 369         private int _threadInitialLines;
 370         private int _threadMaxReadSize;
 371         private int _threadPeriod;
 372     }
 373
 374     private class MenuBar extends JMenuBar
 375     {
 376         private MenuBar()
 377         {
 378             putClientProperty(Options.HEADER_STYLE_KEY, HeaderStyle.BOTH);
 379             putClientProperty(PlasticLookAndFeel.BORDER_STYLE_KEY, BorderStyle.SEPARATOR);
 380
 381             final int MENU_MASK = java.awt.Toolkit.getDefaultToolkit().getMenuShortcutKeyMask();
 382
 383             //
 384             // File menu
 385             //
 386             JMenu fileMenu = new JMenu("File");
 387             fileMenu.setMnemonic(java.awt.event.KeyEvent.VK_F);
 388             add(fileMenu);
 389
 390             ButtonGroup bg = new ButtonGroup();
 391
 392             _pauseItem = new JRadioButtonMenuItem(_pause);
 393             fileMenu.add(_pauseItem);
 394             bg.add(_pauseItem);
 395             _playItem = new JRadioButtonMenuItem(_play);
 396             fileMenu.add(_playItem);
 397             bg.add(_playItem);
 398             _stopItem = new JRadioButtonMenuItem(_stop);
 399             fileMenu.add(_stopItem);
 400             bg.add(_stopItem);
 401             fileMenu.addSeparator();
 402
 403             Action save = new AbstractAction("Save As...")
 404                 {
 405                     public void actionPerformed(ActionEvent e)
 406                     {
 407                         JFileChooser fileChooser = _root.getCoordinator().getSaveLogChooser();
 408
 409                         fileChooser.setSelectedFile(new java.io.File(fileChooser.getCurrentDirectory(),
 410                                                                      _factory.getDefaultFilename()));
 411
 412                         java.io.File file = null;
 413
 414                         while(file == null)
 415                         {
 416                             int result = fileChooser.showSaveDialog(ShowLogDialog.this);
 417                             if(result == JFileChooser.APPROVE_OPTION)
 418                             {
 419                                 file = fileChooser.getSelectedFile();
 420
 421                                 if(file != null)
 422                                 {
 423                                     if(!file.exists() && file.getName().indexOf('.') == -1)
 424                                     {
 425                                         file = new java.io.File(file.getAbsolutePath() + ".log");
 426                                     }
 427
 428                                     java.io.OutputStreamWriter os = null;
 429
 430                                     try
 431                                     {
 432                                         os = new java.io.OutputStreamWriter(new java.io.FileOutputStream(file));
 433                                         String txt = _textArea.getText();
 434                                         if(txt == null)
 435                                         {
 436                                             txt = "";
 437                                         }
 438                                         os.write(txt, 0, txt.length());
 439                                     }
 440                                     catch(java.io.IOException io)
 441                                     {
 442                                         JOptionPane.showMessageDialog(
 443                                             ShowLogDialog.this,
 444                                             io.toString(),
 445                                             "Cannot write file",
 446                                             JOptionPane.ERROR_MESSAGE);
 447                                     }
 448                                     finally
 449                                     {
 450                                         if(os != null)
 451                                         {
 452                                             try
 453                                             {
 454                                                 os.close();
 455                                             }
 456                                             catch(java.io.IOException io)
 457                                             {
 458                                             }
 459                                         }
 460                                     }
 461                                 }
 462                             }
 463                             else
 464                             {
 465                                 break; // while
 466                             }
 467                         }
 468                     }
 469                 };
 470             save.putValue(Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_S, MENU_MASK));
 471             save.putValue(Action.SHORT_DESCRIPTION, "Save As...");
 472             fileMenu.add(save);
 473             fileMenu.addSeparator();
 474
 475             fileMenu.add(new AbstractAction("Close")
 476                 {
 477                     public void actionPerformed(ActionEvent e)
 478                     {
 479                         close(true);
 480                     }
 481                 });
 482             JMenu editMenu = new JMenu("Edit");
 483             editMenu.setMnemonic(java.awt.event.KeyEvent.VK_E);
 484             add(editMenu);
 485
 486             Action copy = new AbstractAction("Copy")
 487                 {
 488                     public void actionPerformed(ActionEvent e)
 489                     {
 490                         _textArea.copy();
 491                     }
 492
 493                 };
 494             copy.putValue(Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_C, MENU_MASK));
 495             copy.putValue(Action.SHORT_DESCRIPTION, "Copy");
 496             editMenu.add(copy);
 497
 498             editMenu.addSeparator();
 499             Action selectAll = new AbstractAction("Select All")
 500                 {
 501                     public void actionPerformed(ActionEvent e)
 502                     {
 503                         _textArea.grabFocus();
 504                         _textArea.selectAll();
 505                     }
 506                 };
 507             selectAll.putValue(Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke(KeyEvent.VK_A, MENU_MASK));
 508             selectAll.putValue(Action.SHORT_DESCRIPTION, "Select All");
 509
 510             editMenu.add(selectAll);
 511             editMenu.addSeparator();
 512             editMenu.add(new AbstractAction("Preferences...")
 513                 {
 514                     public void actionPerformed(ActionEvent e)
 515                     {
 516                         new ShowLogPrefsDialog(ShowLogDialog.this);
 517                     }
 518                 });
 519         }
 520     }
 521
 522     private class ToolBar extends JToolBar
 523     {
 524         private ToolBar()
 525         {
 526             putClientProperty(Options.HEADER_STYLE_KEY, HeaderStyle.BOTH);
 527             putClientProperty(PlasticLookAndFeel.BORDER_STYLE_KEY, BorderStyle.SEPARATOR);
 528             setFloatable(false);
 529             putClientProperty("JToolBar.isRollover", Boolean.TRUE);
 530
 531             _pauseButton = new JToggleButton(_pause);
 532             _pauseButton.setText(null);
 533             _pauseButton.setIcon(Utils.getIcon("/icons/16x16/pause.png"));
 534             add(_pauseButton);
 535             _playButton = new JToggleButton(_play);
 536             _playButton.setText(null);
 537             _playButton.setIcon(Utils.getIcon("/icons/16x16/start.png"));
 538             add(_playButton);
 539             _stopButton = new JToggleButton(_stop);
 540             _stopButton.setText(null);
 541             _stopButton.setIcon(Utils.getIcon("/icons/16x16/stop.png"));
 542             add(_stopButton);
 543
 544             ButtonGroup bg = new ButtonGroup();
 545             bg.add(_pauseButton);
 546             bg.add(_playButton);
 547             bg.add(_stopButton);
 548         }
 549     }
 550
 551     ShowLogDialog(Root root, FileIteratorFactory factory, int maxLines, int maxSize, int initialLines, int maxReadSize,
 552                   int period)
 553     {
 554         super(root.getCoordinator().getMainFrame(), factory.getTitle() + " - IceGrid Admin", false);
 555
 556         _maxLines = maxLines;
 557         _maxSize = maxSize;
 558         _initialLines = initialLines;
 559         _maxReadSize = maxReadSize;
 560         _period = period;
 561         _factory = factory;
 562         _root = root;
 563
 564         setDefaultCloseOperation(JDialog.DO_NOTHING_ON_CLOSE);
 565         addWindowListener(new java.awt.event.WindowAdapter()
 566             {
 567                 public void windowClosing(java.awt.event.WindowEvent e)
 568                 {
 569                     close(true);
 570                 }
 571             });
 572
 573         _pause = new AbstractAction("Pause")
 574             {
 575                 public void actionPerformed(ActionEvent e)
 576                 {
 577                     pause();
 578                 }
 579             };
 580
 581         _play = new AbstractAction("Play")
 582             {
 583                 public void actionPerformed(ActionEvent e)
 584                 {
 585                     play();
 586                 }
 587             };
 588
 589         _stop = new AbstractAction("Stop")
 590             {
 591                 public void actionPerformed(ActionEvent e)
 592                 {
 593                     stopReading();
 594                 }
 595             };
 596
 597         setJMenuBar(new MenuBar());
 598         getContentPane().add(new ToolBar(), BorderLayout.PAGE_START);
 599
 600         JScrollPane scrollPane = new JScrollPane(_textArea,
 601                                                  JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,
 602                                                  JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
 603
 604         getContentPane().add(scrollPane);
 605
 606         pack();
 607         setResizable(true);
 608
 609         setLocationRelativeTo(root.getCoordinator().getMainFrame());
 610         play();
 611     }
 612
 613     void pause()
 614     {
 615         _thread.pause();
 616         _pauseItem.setSelected(true);
 617         _pauseButton.setSelected(true);
 618     }
 619
 620     void stopReading()
 621     {
 622         if(_thread != null)
 623         {
 624             _thread.terminate();
 625
 626             try
 627             {
 628                 _thread.join();
 629             }
 630             catch(InterruptedException e)
 631             {
 632             }
 633
 634             _thread = null;
 635             _stopItem.setSelected(true);
 636             _stopButton.setSelected(true);
 637             _pause.setEnabled(false);
 638         }
 639     }
 640
 641     void play()
 642     {
 643         if(_thread != null)
 644         {
 645             _thread.play();
 646             _playItem.setSelected(true);
 647             _playButton.setSelected(true);
 648             _pause.setEnabled(true);
 649         }
 650         else
 651         {
 652             _thread = new ReaderThread();
 653             _thread.start();
 654         }
 655     }
 656
 657     int getMaxLines()
 658     {
 659         return _maxLines;
 660     }
 661
 662     int getMaxSize()
 663     {
 664         return _maxSize;
 665     }
 666
 667     int getInitialLines()
 668     {
 669         return _initialLines;
 670     }
 671
 672     int getMaxReadSize()
 673     {
 674         return _maxReadSize;
 675     }
 676
 677     int getPeriod()
 678     {
 679         return _period;
 680     }
 681
 682     void setPrefs(int maxLines, int maxSize, int initialLines, int maxReadSize, int period)
 683     {
 684         if(maxLines < 50)
 685         {
 686             maxLines = 50;
 687         }
 688         _maxLines = maxLines;
 689
 690         if(maxSize < 1000)
 691         {
 692             maxSize = 1000;
 693         }
 694         _maxSize = maxSize;
 695
 696         _initialLines = initialLines;
 697
 698         if(maxReadSize < 100)
 699         {
 700             maxReadSize = 100;
 701         }
 702         else if(maxReadSize + 512 > _root.getMessageSizeMax())
 703         {
 704             maxReadSize =  _root.getMessageSizeMax() - 512;
 705         }
 706         _maxReadSize = maxReadSize;
 707
 708         if(period < 200)
 709         {
 710             period = 200;
 711         }
 712         else if(period > 5000)
 713         {
 714             period = 5000;
 715         }
 716         _period = period;
 717
 718         if(_thread != null)
 719         {
 720             _thread.setPrefs();
 721         }
 722
 723         _root.setLogPrefs(_maxLines, _maxSize, _initialLines, _maxReadSize, _period);
 724     }
 725
 726     void close(boolean notifyRoot)
 727     {
 728         stopReading();
 729
 730         if(notifyRoot)
 731         {
 732             _root.removeShowLogDialog(_factory.getTitle());
 733         }
 734         dispose();
 735     }
 736
 737     private final Root _root;
 738     private final FileIteratorFactory _factory;
 739
 740     private int _maxLines;
 741     private int _maxSize;
 742     private int _initialLines;
 743     private int _maxReadSize;
 744     private int _period;
 745
 746     private Action _play;
 747     private Action _pause;
 748     private Action _stop;
 749
 750     private JRadioButtonMenuItem _playItem;
 751     private JRadioButtonMenuItem _pauseItem;
 752     private JRadioButtonMenuItem _stopItem;
 753
 754     private JToggleButton _playButton;
 755     private JToggleButton _pauseButton;
 756     private JToggleButton _stopButton;
 757
 758     private FIFOTextArea _textArea = new FIFOTextArea(20, 45);
 759     private ReaderThread _thread;
 760 }