platform/lang-impl/src/com/intellij/diagnostic/logging/LogConsoleImpl.java

   1 package com.intellij.diagnostic.logging;
   2
   3 import com.intellij.diagnostic.DiagnosticBundle;
   4 import com.intellij.execution.filters.TextConsoleBuilder;
   5 import com.intellij.execution.filters.TextConsoleBuilderFactory;
   6 import com.intellij.execution.process.ProcessAdapter;
   7 import com.intellij.execution.process.ProcessEvent;
   8 import com.intellij.execution.process.ProcessHandler;
   9 import com.intellij.execution.process.ProcessOutputTypes;
  10 import com.intellij.execution.ui.ConsoleView;
  11 import com.intellij.execution.ui.ConsoleViewContentType;
  12 import com.intellij.openapi.actionSystem.*;
  13 import com.intellij.openapi.application.ApplicationManager;
  14 import com.intellij.openapi.diagnostic.Logger;
  15 import com.intellij.openapi.editor.Document;
  16 import com.intellij.openapi.editor.Editor;
  17 import com.intellij.openapi.project.Project;
  18 import com.intellij.openapi.util.Comparing;
  19 import com.intellij.openapi.util.Condition;
  20 import com.intellij.openapi.util.Disposer;
  21 import com.intellij.openapi.util.io.FileUtil;
  22 import org.jetbrains.annotations.NotNull;
  23 import org.jetbrains.annotations.Nullable;
  24
  25 import javax.swing.*;
  26 import javax.swing.event.ChangeEvent;
  27 import javax.swing.event.ChangeListener;
  28 import java.awt.*;
  29 import java.awt.event.ActionListener;
  30 import java.awt.event.ActionEvent;
  31 import java.io.*;
  32 import java.util.ArrayList;
  33 import java.util.List;
  34
  35 /**
  36  * User: anna
  37  * Date: Apr 19, 2005
  38  */
  39 public abstract class LogConsoleImpl extends AdditionalTabComponent
  40   implements LogConsole, ChangeListener, LogConsolePreferences.FilterListener {
  41   private ConsoleView myConsole;
  42   private final LightProcessHandler myProcessHandler = new LightProcessHandler();
  43   private ReaderThread myReaderThread;
  44   private final long mySkippedContents;
  45
  46   private StringBuffer myOriginalDocument = null;
  47
  48   private String myPrevType = null;
  49   private String myLineUnderSelection = null;
  50   private int myLineOffset = -1;
  51
  52   /*private FilterComponent myFilter = new FilterComponent("LOG_FILTER_HISTORY", 5) {
  53     public void filter() {
  54       getPreferences().updateCustomFilter(getFilter());
  55     }
  56   };*/
  57
  58   private LogContentPreprocessor myContentPreprocessor;
  59   private boolean myShowStandardFilters = true;
  60
  61   private String myTitle = null;
  62   private final Project myProject;
  63   private final String myPath;
  64   private boolean myWasInitialized;
  65   private final JPanel myTopComponent = new JPanel(new BorderLayout());
  66   private ActionGroup myActions;
  67   private final boolean myBuildInActions;
  68
  69   public LogConsoleImpl(Project project, File file, long skippedContents, String title, final boolean buildInActions) {
  70     super(new BorderLayout());
  71     mySkippedContents = skippedContents;
  72     myTitle = title;
  73     myProject = project;
  74     myPath = file.getAbsolutePath();
  75     myBuildInActions = buildInActions;
  76     myReaderThread = new ReaderThread(file);
  77     TextConsoleBuilder builder = TextConsoleBuilderFactory.getInstance().createBuilder(project);
  78     myConsole = builder.getConsole();
  79     myConsole.attachToProcess(myProcessHandler);
  80     getPreferences().addFilterListener(this);
  81   }
  82
  83   public LogContentPreprocessor getContentPreprocessor() {
  84     return myContentPreprocessor;
  85   }
  86
  87   public void setContentPreprocessor(final LogContentPreprocessor contentPreprocessor) {
  88     myContentPreprocessor = contentPreprocessor;
  89   }
  90
  91   public boolean isShowStandardFilters() {
  92     return myShowStandardFilters;
  93   }
  94
  95   public void setShowStandardFilters(final boolean showStandardFilters) {
  96     myShowStandardFilters = showStandardFilters;
  97   }
  98
  99   @SuppressWarnings({"NonStaticInitializer"})
 100   private JComponent createToolbar() {
 101
 102     /*myFilter.reset();
 103     myFilter.setSelectedItem(registrar.CUSTOM_FILTER != null ? registrar.CUSTOM_FILTER : "");
 104     new AnAction() {
 105       {
 106         registerCustomShortcutSet(new CustomShortcutSet(KeyStroke.getKeyStroke(KeyEvent.VK_TAB, KeyEvent.SHIFT_DOWN_MASK)),
 107                                   LogConsoleImpl.this);
 108       }
 109
 110       public void actionPerformed(final AnActionEvent e) {
 111         myFilter.requestFocusInWindow();
 112       }
 113     };*/
 114
 115     if (myBuildInActions) {
 116       final JComponent tbComp =
 117         ActionManager.getInstance().createActionToolbar(ActionPlaces.UNKNOWN, getOrCreateActions(), true).getComponent();
 118       myTopComponent.add(tbComp, BorderLayout.CENTER);
 119       //myTopComponent.add(myFilter, BorderLayout.EAST);
 120     }
 121
 122
 123     return myTopComponent;
 124   }
 125
 126   public ActionGroup getOrCreateActions() {
 127     if (myActions != null) return myActions;
 128     DefaultActionGroup group = new DefaultActionGroup();
 129
 130     final AnAction[] actions = myConsole.createConsoleActions();
 131     for (AnAction action : actions) {
 132       group.add(action);
 133     }
 134
 135     group.addSeparator();
 136
 137     /*for (final LogFilter filter : filters) {
 138       group.add(new ToggleAction(filter.getName(), filter.getName(), filter.getIcon()) {
 139         public boolean isSelected(AnActionEvent e) {
 140           return prefs.isFilterSelected(filter);
 141         }
 142
 143         public void setSelected(AnActionEvent e, boolean state) {
 144           prefs.setFilterSelected(filter, state);
 145         }
 146       });
 147     }*/
 148
 149     myActions = group;
 150
 151     return myActions;
 152   }
 153
 154
 155   public void onFilterStateChange(final LogFilter filter) {
 156     filterConsoleOutput(new Condition<String>() {
 157       public boolean value(final String line) {
 158         return filter.isAcceptable(line);
 159       }
 160     });
 161   }
 162
 163   public void onTextFilterChange() {
 164     filterConsoleOutput(new Condition<String>() {
 165       public boolean value(final String line) {
 166         return getPreferences().isApplicable(line, myPrevType);
 167       }
 168     });
 169   }
 170
 171   @NotNull
 172   public JComponent getComponent() {
 173     if (!myWasInitialized) {
 174       myWasInitialized = true;
 175       add(myConsole.getComponent(), BorderLayout.CENTER);
 176       add(createToolbar(), BorderLayout.NORTH);
 177     }
 178     return this;
 179   }
 180
 181   public abstract boolean isActive();
 182
 183   public void activate() {
 184     if (myReaderThread == null) return;
 185     if (isActive() && !myReaderThread.myRunning) {
 186       //myFilter.setSelectedItem(getPreferences().CUSTOM_FILTER);
 187       myReaderThread.startRunning();
 188       ApplicationManager.getApplication().executeOnPooledThread(myReaderThread);
 189     }
 190     else if (!isActive() && myReaderThread.myRunning) {
 191       myReaderThread.stopRunning();
 192     }
 193   }
 194
 195   public void stateChanged(final ChangeEvent e) {
 196     activate();
 197   }
 198
 199   public String getTabTitle() {
 200     return myTitle;
 201   }
 202
 203   @Nullable
 204   public String getTooltip() {
 205     return myPath;
 206   }
 207
 208   public String getPath() {
 209     return myPath;
 210   }
 211
 212   public void dispose() {
 213     getPreferences().removeFilterListener(this);
 214     if (myReaderThread != null && myReaderThread.myFileStream != null) {
 215       myReaderThread.stopRunning();
 216       try {
 217         myReaderThread.myFileStream.close();
 218       }
 219       catch (IOException e) {
 220         LOG.warn(e);
 221       }
 222       myReaderThread.myFileStream = null;
 223       myReaderThread = null;
 224     }
 225     if (myConsole != null) {
 226       Disposer.dispose(myConsole);
 227       myConsole = null;
 228     }
 229     /*if (myFilter != null) {
 230       myFilter.dispose();
 231       myFilter = null;
 232     }*/
 233     myOriginalDocument = null;
 234   }
 235
 236   private void stopRunning() {
 237     if (myReaderThread != null && !isActive()) {
 238       myReaderThread.stopRunning();
 239     }
 240   }
 241
 242   private void addMessage(final String text) {
 243     if (text == null) return;
 244     if (myContentPreprocessor != null) {
 245       final List<LogFragment> fragments = myContentPreprocessor.parseLogLine(text + "\n");
 246       myOriginalDocument = getOriginalDocument();
 247       for (LogFragment fragment : fragments) {
 248         myProcessHandler.notifyTextAvailable(fragment.getText(), fragment.getOutputType());
 249         if (myOriginalDocument != null) {
 250           myOriginalDocument.append(fragment.getText());
 251         }
 252       }
 253     }
 254     else {
 255       final String key = LogConsolePreferences.getType(text);
 256       if (getPreferences().isApplicable(text, myPrevType)) {
 257         myProcessHandler.notifyTextAvailable(text + "\n", key != null
 258                                                           ? LogConsolePreferences.getProcessOutputTypes(key)
 259                                                           : (myPrevType == LogConsolePreferences.ERROR
 260                                                              ? ProcessOutputTypes.STDERR
 261                                                              : ProcessOutputTypes.STDOUT));
 262       }
 263       if (key != null) {
 264         myPrevType = key;
 265       }
 266       myOriginalDocument = getOriginalDocument();
 267       if (myOriginalDocument != null) {
 268         myOriginalDocument.append(text).append("\n");
 269       }
 270     }
 271   }
 272
 273   private LogConsolePreferences getPreferences() {
 274     return LogConsolePreferences.getInstance(myProject);
 275   }
 276
 277   public void attachStopLogConsoleTrackingListener(final ProcessHandler process) {
 278     if (process != null) {
 279       final ProcessAdapter stopListener = new ProcessAdapter() {
 280         public void processTerminated(final ProcessEvent event) {
 281           process.removeProcessListener(this);
 282           stopRunning();
 283         }
 284       };
 285       process.addProcessListener(stopListener);
 286     }
 287   }
 288
 289   private StringBuffer getOriginalDocument() {
 290     if (myOriginalDocument == null) {
 291       final Editor editor = getEditor();
 292       if (editor != null) {
 293         myOriginalDocument = new StringBuffer(editor.getDocument().getText());
 294       }
 295     }
 296     return myOriginalDocument;
 297   }
 298
 299   @Nullable
 300   private Editor getEditor() {
 301     return myConsole != null ? (Editor)((DataProvider)myConsole).getData(DataConstants.EDITOR) : null;
 302   }
 303
 304   private void filterConsoleOutput(Condition<String> isApplicable) {
 305     myOriginalDocument = getOriginalDocument();
 306     if (myOriginalDocument != null) {
 307       final Editor editor = getEditor();
 308       LOG.assertTrue(editor != null);
 309       final Document document = editor.getDocument();
 310       final int caretOffset = editor.getCaretModel().getOffset();
 311       if (caretOffset > -1) {
 312         int line = document.getLineNumber(caretOffset);
 313         if (line > -1 && line < document.getLineCount()) {
 314           final int startOffset = document.getLineStartOffset(line);
 315           myLineUnderSelection = document.getText().substring(startOffset, document.getLineEndOffset(line));
 316           myLineOffset = caretOffset - startOffset;
 317         }
 318       }
 319       myConsole.clear();
 320       final String[] lines = myOriginalDocument.toString().split("\n");
 321       int offset = 0;
 322       boolean caretPositioned = false;
 323       for (String line : lines) {
 324         final String contentType = LogConsolePreferences.getType(line);
 325         if (isApplicable.value(line)) {
 326           myConsole.print(line + "\n", contentType != null
 327                                        ? LogConsolePreferences.getContentType(contentType)
 328                                        : (myPrevType == LogConsolePreferences.ERROR
 329                                           ? ConsoleViewContentType.ERROR_OUTPUT
 330                                           : ConsoleViewContentType.NORMAL_OUTPUT));
 331           if (!caretPositioned) {
 332             if (Comparing.strEqual(myLineUnderSelection, line)) {
 333               caretPositioned = true;
 334               offset += myLineOffset != -1 ? myLineOffset : 0;
 335             }
 336             else {
 337               offset += line.length() + 1;
 338             }
 339           }
 340         }
 341         if (contentType != null) {
 342           myPrevType = contentType;
 343         }
 344       }
 345       myConsole.scrollTo(offset);
 346     }
 347   }
 348
 349   private static class LightProcessHandler extends ProcessHandler {
 350     protected void destroyProcessImpl() {
 351       throw new UnsupportedOperationException();
 352     }
 353
 354     protected void detachProcessImpl() {
 355       throw new UnsupportedOperationException();
 356     }
 357
 358     public boolean detachIsDefault() {
 359       return false;
 360     }
 361
 362     @Nullable
 363     public OutputStream getProcessInput() {
 364       return null;
 365     }
 366   }
 367
 368   private static final Logger LOG = Logger.getInstance("com.intellij.diagnostic.logging.LogConsoleImpl");
 369
 370   private class ReaderThread implements Runnable {
 371     private BufferedReader myFileStream;
 372     private boolean myRunning = false;
 373
 374     @SuppressWarnings({"IOResourceOpenedButNotSafelyClosed"})
 375     public ReaderThread(File file) {
 376       try {
 377         try {
 378           final FileInputStream inputStream = new FileInputStream(file);
 379           myFileStream = new BufferedReader(new InputStreamReader(inputStream));
 380           if (file.length() >= mySkippedContents) { //do not skip forward
 381             inputStream.skip(mySkippedContents);
 382           }
 383         }
 384         catch (FileNotFoundException e) {
 385           if (!FileUtil.createIfDoesntExist(file)) return;
 386           myFileStream = new BufferedReader(new FileReader(file));
 387         }
 388       }
 389       catch (Throwable e) {
 390         myFileStream = null;
 391       }
 392     }
 393
 394     public void run() {
 395       if (myFileStream == null) return;
 396       while (myRunning) {
 397         try {
 398           int i = 0;
 399           while (i++ < 100) {
 400             if (myRunning && myFileStream != null && myFileStream.ready()) {
 401               addMessage(myFileStream.readLine());
 402             }
 403             else {
 404               break;
 405             }
 406           }
 407           synchronized (this) {
 408             wait(100);
 409           }
 410         }
 411         catch (IOException e) {
 412           LOG.error(e);
 413         }
 414         catch (InterruptedException e) {
 415           Disposer.dispose(LogConsoleImpl.this);
 416         }
 417       }
 418     }
 419
 420     public void startRunning() {
 421       myRunning = true;
 422     }
 423
 424     public void stopRunning() {
 425       myRunning = false;
 426       synchronized (this) {
 427         notifyAll();
 428       }
 429     }
 430   }
 431
 432   public ActionGroup getToolbarActions() {
 433     return getOrCreateActions();
 434   }
 435
 436   public String getToolbarPlace() {
 437     return ActionPlaces.UNKNOWN;
 438   }
 439
 440   public JComponent getToolbarContextComponent() {
 441     return myConsole.getComponent();
 442   }
 443
 444   public JComponent getPreferredFocusableComponent() {
 445     return myConsole.getPreferredFocusableComponent();
 446   }
 447
 448   private List<LogFilter> getLogFilters(final LogConsolePreferences prefs) {
 449     abstract class MyFilter extends StandartLogFilter {
 450       protected MyFilter(String name) {
 451         super(name);
 452       }
 453
 454       public boolean isAcceptable(String line) {
 455         return prefs.isApplicable(line, myPrevType);
 456       }
 457     }
 458     final ArrayList<LogFilter> filters = new ArrayList<LogFilter>();
 459     if (myShowStandardFilters) {
 460       filters.add(new MyFilter(DiagnosticBundle.message("log.console.filter.show.all")) {
 461         @Override
 462         public void selectFilter(LogConsolePreferences prefs) {
 463           prefs.FILTER_ERRORS = false;
 464           prefs.FILTER_INFO = false;
 465           prefs.FILTER_WARNINGS = false;
 466         }
 467
 468         @Override
 469         public boolean isSelected(LogConsolePreferences prefs) {
 470           return !prefs.FILTER_ERRORS && !prefs.FILTER_INFO && !prefs.FILTER_WARNINGS;
 471         }
 472       });
 473       filters.add(new MyFilter(DiagnosticBundle.message("log.console.filter.show.errors.and.warnings")) {
 474         @Override
 475         public void selectFilter(LogConsolePreferences prefs) {
 476           prefs.FILTER_ERRORS = false;
 477           prefs.FILTER_INFO = true;
 478           prefs.FILTER_WARNINGS = false;
 479         }
 480
 481         @Override
 482         public boolean isSelected(LogConsolePreferences prefs) {
 483           return !prefs.FILTER_ERRORS && prefs.FILTER_INFO && !prefs.FILTER_WARNINGS;
 484         }
 485       });
 486       filters.add(new MyFilter(DiagnosticBundle.message("log.console.filter.show.errors")) {
 487         @Override
 488         public void selectFilter(LogConsolePreferences prefs) {
 489           prefs.FILTER_ERRORS = false;
 490           prefs.FILTER_INFO = true;
 491           prefs.FILTER_WARNINGS = true;
 492         }
 493
 494         @Override
 495         public boolean isSelected(LogConsolePreferences prefs) {
 496           return !prefs.FILTER_ERRORS && prefs.FILTER_INFO && prefs.FILTER_WARNINGS;
 497         }
 498       });
 499     }
 500     filters.addAll(prefs.getRegisteredLogFilters());
 501     return filters;
 502   }
 503
 504   public JComponent getSearchComponent() {
 505     final LogConsolePreferences prefs = getPreferences();
 506     List<LogFilter> filters = getLogFilters(prefs);
 507     final JComboBox combo = new JComboBox(filters.toArray(new LogFilter[filters.size()]));
 508     for (LogFilter filter : filters) {
 509       if (prefs.isFilterSelected(filter)) {
 510         combo.setSelectedItem(filter);
 511         break;
 512       }
 513     }
 514     combo.addActionListener(new ActionListener() {
 515       public void actionPerformed(ActionEvent e) {
 516         LogFilter filter = (LogFilter)combo.getSelectedItem();
 517         prefs.selectOnlyFilter(filter);
 518       }
 519     });
 520     return combo;
 521   }
 522
 523   public boolean isContentBuiltIn() {
 524     return myBuildInActions;
 525   }
 526 }