From 2d1c116c5fb113cce57f89abb5cc00e663945a83 Mon Sep 17 00:00:00 2001 From: Michael Golubev Date: Mon, 3 Sep 2012 23:10:29 +0200 Subject: [PATCH] IDEA-90367 - CloudBees support - unify log consoles --- .../diagnostic/logging/LogConsoleManager.java | 5 +- .../logging/LogConsoleManagerBase.java | 166 ++++++++++++++++++ .../execution/runners/RunContentBuilder.java | 87 ++------- .../impl/ui/DebuggerSessionTabBase.java | 137 +++------------ 4 files changed, 206 insertions(+), 189 deletions(-) create mode 100644 platform/lang-impl/src/com/intellij/diagnostic/logging/LogConsoleManagerBase.java diff --git a/platform/lang-impl/src/com/intellij/diagnostic/logging/LogConsoleManager.java b/platform/lang-impl/src/com/intellij/diagnostic/logging/LogConsoleManager.java index a23274d6557f..08407236006d 100644 --- a/platform/lang-impl/src/com/intellij/diagnostic/logging/LogConsoleManager.java +++ b/platform/lang-impl/src/com/intellij/diagnostic/logging/LogConsoleManager.java @@ -21,11 +21,14 @@ import org.jetbrains.annotations.NotNull; import java.nio.charset.Charset; +import java.io.Reader; + /** * User: anna * Date: 01-Feb-2006 */ public interface LogConsoleManager extends AdditionalTabComponentManager { void addLogConsole(final String name, final String path, @NotNull Charset charset, final long skippedContent); - void removeLogConsole(final String path); + void addLogConsole(final String name, Reader reader, final String id); + void removeLogConsole(final String pathOrId); } diff --git a/platform/lang-impl/src/com/intellij/diagnostic/logging/LogConsoleManagerBase.java b/platform/lang-impl/src/com/intellij/diagnostic/logging/LogConsoleManagerBase.java new file mode 100644 index 000000000000..28778252a7a6 --- /dev/null +++ b/platform/lang-impl/src/com/intellij/diagnostic/logging/LogConsoleManagerBase.java @@ -0,0 +1,166 @@ +/* + * Copyright 2000-2012 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.intellij.diagnostic.logging; + +import com.intellij.execution.configurations.RunConfigurationBase; +import com.intellij.execution.process.ProcessHandler; +import com.intellij.execution.runners.ExecutionEnvironment; +import com.intellij.execution.ui.RunnerLayoutUi; +import com.intellij.openapi.Disposable; +import com.intellij.openapi.project.Project; +import com.intellij.openapi.ui.ComponentWithActions; +import com.intellij.openapi.util.Disposer; +import com.intellij.ui.content.Content; +import com.intellij.ui.content.ContentManagerAdapter; +import com.intellij.ui.content.ContentManagerEvent; +import com.intellij.util.ArrayUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import javax.swing.*; +import java.io.File; +import java.io.Reader; +import java.nio.charset.Charset; +import java.util.HashMap; +import java.util.Map; + +/** + * Created by IntelliJ IDEA. + * User: michael.golubev + */ +public abstract class LogConsoleManagerBase implements LogConsoleManager, Disposable { + + private final Project myProject; + + private final Map myAdditionalContent = new HashMap(); + + private ExecutionEnvironment myEnvironment; + + protected LogConsoleManagerBase(@NotNull Project project) { + myProject = project; + } + + protected final Project getProject() { + return myProject; + } + + public void setEnvironment(@NotNull final ExecutionEnvironment env) { + myEnvironment = env; + } + + protected final ExecutionEnvironment getEnvironment() { + return myEnvironment; + } + + @Override + public void addLogConsole(final String name, final String path, @NotNull Charset charset, final long skippedContent) { + addLogConsole(name, path, charset, skippedContent, getDefaultIcon()); + } + + public void addLogConsole(final String name, final String path, @NotNull Charset charset, final long skippedContent, Icon icon) { + doAddLogConsole(new LogConsoleImpl(myProject, new File(path), charset, skippedContent, name, false) { + + @Override + public boolean isActive() { + return isConsoleActive(path); + } + }, path, icon); + } + + @Override + public void addLogConsole(String name, Reader reader, final String id) { + addLogConsole(name, reader, id, getDefaultIcon()); + } + + public void addLogConsole(String name, Reader reader, final String id, Icon icon) { + doAddLogConsole(new LogConsoleBase(myProject, + reader, + name, + false, + new DefaultLogFilterModel(myProject)) { + + @Override + public boolean isActive() { + return isConsoleActive(id); + } + }, id, icon); + } + + private void doAddLogConsole(final LogConsoleBase log, + final String id, + Icon icon) { + if (myEnvironment != null && myEnvironment.getRunProfile() instanceof RunConfigurationBase) { + ((RunConfigurationBase)myEnvironment.getRunProfile()).customizeLogConsole(log); + } + log.attachStopLogConsoleTrackingListener(getProcessHandler()); + addAdditionalTabComponent(log, id, icon); + + getUi().addListener(new ContentManagerAdapter() { + public void selectionChanged(final ContentManagerEvent event) { + log.activate(); + } + }, log); + } + + private boolean isConsoleActive(String id) { + final Content content = getUi().findContent(id); + return content != null && content.isSelected(); + } + + public void removeLogConsole(final String path) { + final Content content = getUi().findContent(path); + if (content != null) { + final LogConsoleBase log = (LogConsoleBase)content.getComponent(); + removeAdditionalTabComponent(log); + } + } + + public void addAdditionalTabComponent(final AdditionalTabComponent tabComponent, final String id) { + addAdditionalTabComponent(tabComponent, id, getDefaultIcon()); + } + + public Content addAdditionalTabComponent(final AdditionalTabComponent tabComponent, String id, Icon icon) { + final Content logContent = createLogContent(tabComponent, id, icon); + myAdditionalContent.put(tabComponent, logContent); + getUi().addContent(logContent); + return logContent; + } + + protected Content createLogContent(AdditionalTabComponent tabComponent, String id, Icon icon) { + return getUi().createContent(id, (ComponentWithActions)tabComponent, tabComponent.getTabTitle(), icon, + tabComponent.getPreferredFocusableComponent()); + } + + public void removeAdditionalTabComponent(AdditionalTabComponent component) { + Disposer.dispose(component); + final Content content = myAdditionalContent.remove(component); + if (!getUi().isDisposed()) { + getUi().removeContent(content, true); + } + } + + public void dispose() { + for (AdditionalTabComponent component : ArrayUtil.toObjectArray(myAdditionalContent.keySet(), AdditionalTabComponent.class)) { + removeAdditionalTabComponent(component); + } + } + + protected abstract Icon getDefaultIcon(); + + protected abstract RunnerLayoutUi getUi(); + + public abstract ProcessHandler getProcessHandler(); +} diff --git a/platform/lang-impl/src/com/intellij/execution/runners/RunContentBuilder.java b/platform/lang-impl/src/com/intellij/execution/runners/RunContentBuilder.java index 7afa74bfce04..3fb5c5241191 100644 --- a/platform/lang-impl/src/com/intellij/execution/runners/RunContentBuilder.java +++ b/platform/lang-impl/src/com/intellij/execution/runners/RunContentBuilder.java @@ -27,7 +27,6 @@ import com.intellij.execution.ui.actions.CloseAction; import com.intellij.execution.ui.layout.PlaceInGrid; import com.intellij.icons.AllIcons; import com.intellij.ide.actions.ContextHelpAction; -import com.intellij.openapi.CompositeDisposable; import com.intellij.openapi.Disposable; import com.intellij.openapi.actionSystem.*; import com.intellij.openapi.application.ApplicationManager; @@ -44,7 +43,6 @@ import org.jetbrains.annotations.NotNull; import javax.swing.*; import javax.swing.event.ChangeEvent; import java.io.File; -import java.nio.charset.Charset; import java.util.ArrayList; import java.util.HashMap; import java.util.Map; @@ -52,12 +50,10 @@ import java.util.Map; /** * @author dyoma */ -public class RunContentBuilder implements LogConsoleManager, Disposable { +public class RunContentBuilder extends LogConsoleManagerBase { @NonNls private static final String JAVA_RUNNER = "JavaRunner"; - + private final ProgramRunner myRunner; - private final Project myProject; - private final CompositeDisposable myDisposeables = new CompositeDisposable(); private final ArrayList myRunnerActions = new ArrayList(); private final Icon myRerunIcon = AllIcons.Actions.RefreshUsages; private final boolean myReuseProhibited = false; @@ -66,12 +62,10 @@ public class RunContentBuilder implements LogConsoleManager, Disposable { private final LogFilesManager myManager; private RunnerLayoutUi myUi; - private final Map myAdditionalContent = new HashMap(); private final Executor myExecutor; - private ExecutionEnvironment myEnvironment; public RunContentBuilder(final Project project, final ProgramRunner runner, Executor executor) { - myProject = project; + super(project); myRunner = runner; myExecutor = executor; myManager = new LogFilesManager(project, this, this); @@ -86,7 +80,7 @@ public class RunContentBuilder implements LogConsoleManager, Disposable { } public void setEnvironment(@NotNull final ExecutionEnvironment env) { - myEnvironment = env; + super.setEnvironment(env); final RunProfile profile = env.getRunProfile(); if (profile instanceof RunConfigurationBase) { myManager.registerFileMatcher((RunConfigurationBase)profile); @@ -97,21 +91,17 @@ public class RunContentBuilder implements LogConsoleManager, Disposable { myRunnerActions.add(action); } - @Override - public void dispose() { - Disposer.dispose(myDisposeables); - } - private RunContentDescriptor createDescriptor() { if (myExecutionResult == null) { throw new IllegalStateException("Missing ExecutionResult"); } - if (myEnvironment == null) { + ExecutionEnvironment environment = getEnvironment(); + if (environment == null) { throw new IllegalStateException("Missing ExecutionEnvironment"); } - final RunProfile profile = myEnvironment.getRunProfile(); + final RunProfile profile = environment.getRunProfile(); final ExecutionConsole console = myExecutionResult.getExecutionConsole(); String runnerType = JAVA_RUNNER; @@ -121,7 +111,7 @@ public class RunContentBuilder implements LogConsoleManager, Disposable { runnerType = JAVA_RUNNER + "." + id; } } - myUi = RunnerLayoutUi.Factory.getInstance(myProject).create(runnerType, myExecutor.getId(), profile.getName(), this); + myUi = RunnerLayoutUi.Factory.getInstance(getProject()).create(runnerType, myExecutor.getId(), profile.getName(), this); myUi.getOptions().setMoveToGridActionEnabled(false).setMinimizeActionEnabled(false); if (ApplicationManager.getApplication().isUnitTestMode()) { @@ -168,42 +158,10 @@ public class RunContentBuilder implements LogConsoleManager, Disposable { consoleContent.setActions(consoleActions, ActionPlaces.UNKNOWN, console.getComponent()); } - @Override - public void addLogConsole(final String name, final String path, @NotNull Charset charset, final long skippedContent) { - final LogConsoleImpl log = new LogConsoleImpl(myProject, new File(path), charset, skippedContent, name, false){ - @Override - public boolean isActive() { - final Content content = myUi.findContent(path); - return content != null && content.isSelected(); - } - }; - if (myEnvironment.getRunProfile() instanceof RunConfigurationBase) { - ((RunConfigurationBase) myEnvironment.getRunProfile()).customizeLogConsole(log); - } - log.attachStopLogConsoleTrackingListener(myExecutionResult.getProcessHandler()); - addAdditionalTabComponent(log, path); - - myUi.addListener(new ContentManagerAdapter() { - @Override - public void selectionChanged(final ContentManagerEvent event) { - log.stateChanged(new ChangeEvent(myUi)); - } - }, log); - } - - @Override - public void removeLogConsole(final String path) { - final Content content = myUi.findContent(path); - if (content != null) { - final LogConsoleImpl log = (LogConsoleImpl)content.getComponent(); - removeAdditionalTabComponent(log); - } - } - private ActionGroup createActionToolbar(final RunContentDescriptor contentDescriptor, final JComponent component) { final DefaultActionGroup actionGroup = new DefaultActionGroup(); - final RestartAction restartAction = new RestartAction(myExecutor, myRunner, getProcessHandler(), myRerunIcon, contentDescriptor, myEnvironment); + final RestartAction restartAction = new RestartAction(myExecutor, myRunner, getProcessHandler(), myRerunIcon, contentDescriptor, getEnvironment()); restartAction.registerShortcut(component); actionGroup.add(restartAction); contentDescriptor.setRestarter(new Runnable() { @@ -244,7 +202,7 @@ public class RunContentBuilder implements LogConsoleManager, Disposable { actionGroup.add(myUi.getOptions().getLayoutActions()); actionGroup.addSeparator(); actionGroup.add(PinToolwindowTabAction.getPinAction()); - actionGroup.add(new CloseAction(myExecutor, contentDescriptor, myProject)); + actionGroup.add(new CloseAction(myExecutor, contentDescriptor, getProject())); actionGroup.add(new ContextHelpAction(myExecutor.getHelpId())); return actionGroup; } @@ -263,30 +221,13 @@ public class RunContentBuilder implements LogConsoleManager, Disposable { } @Override - public void addAdditionalTabComponent(final AdditionalTabComponent tabComponent, final String id) { - final Content content = myUi.createContent(id, (ComponentWithActions)tabComponent, tabComponent.getTabTitle(), - AllIcons.Debugger.Console, tabComponent.getPreferredFocusableComponent()); - - - - myUi.addContent(content); - myAdditionalContent.put(tabComponent, content); - - myDisposeables.add(new Disposable(){ - @Override - public void dispose() { - if (!myUi.isDisposed()) { - removeAdditionalTabComponent(tabComponent); - } - } - }); + protected RunnerLayoutUi getUi() { + return myUi; } @Override - public void removeAdditionalTabComponent(AdditionalTabComponent component) { - Disposer.dispose(component); - final Content content = myAdditionalContent.remove(component); - myUi.removeContent(content, true); + protected Icon getDefaultIcon() { + return AllIcons.Debugger.Console; } private static class MyRunContentDescriptor extends RunContentDescriptor { diff --git a/platform/xdebugger-impl/src/com/intellij/xdebugger/impl/ui/DebuggerSessionTabBase.java b/platform/xdebugger-impl/src/com/intellij/xdebugger/impl/ui/DebuggerSessionTabBase.java index 107025110ea8..f398087e8e1a 100644 --- a/platform/xdebugger-impl/src/com/intellij/xdebugger/impl/ui/DebuggerSessionTabBase.java +++ b/platform/xdebugger-impl/src/com/intellij/xdebugger/impl/ui/DebuggerSessionTabBase.java @@ -48,7 +48,7 @@ import org.jetbrains.annotations.Nullable; import javax.swing.*; import java.io.File; -import java.nio.charset.Charset; +import java.io.Reader; import java.util.Collection; import java.util.HashMap; import java.util.Map; @@ -56,24 +56,17 @@ import java.util.Map; /** * @author nik */ -public abstract class DebuggerSessionTabBase implements DebuggerLogConsoleManager, Disposable { - @NotNull private final Project myProject; +public abstract class DebuggerSessionTabBase extends LogConsoleManagerBase implements DebuggerLogConsoleManager { @NotNull private final LogFilesManager myManager; @NotNull final String mySessionName; @NotNull protected final RunnerLayoutUi myUi; - @NotNull private final Map myAdditionalContent = new HashMap(); - @NotNull private final Map myContentListeners = - new HashMap(); - - protected ExecutionEnvironment myEnvironment; - protected ExecutionConsole myConsole; protected RunContentDescriptor myRunContentDescriptor; public DebuggerSessionTabBase(Project project, @NotNull String runnerId, @NotNull final String sessionName) { - myProject = project; + super(project); myManager = new LogFilesManager(project, this, this); mySessionName = sessionName; @@ -89,6 +82,24 @@ public abstract class DebuggerSessionTabBase implements DebuggerLogConsoleManage public abstract RunContentDescriptor getRunContentDescriptor(); + @Override + public ProcessHandler getProcessHandler() { + return getRunContentDescriptor().getProcessHandler(); + } + + @Override + protected Content createLogContent(AdditionalTabComponent tabComponent, String id, Icon icon) { + Content result = super.createLogContent(tabComponent, id, icon); + result.setCloseable(false); + result.setDescription(tabComponent.getTooltip()); + return result; + } + + @Override + protected Icon getDefaultIcon() { + return AllIcons.FileTypes.Text; + } + @NotNull public RunnerLayoutUi getUi() { return myUi; @@ -111,42 +122,6 @@ public abstract class DebuggerSessionTabBase implements DebuggerLogConsoleManage return myManager; } - // TODO[oleg]: talk to nick - public void setEnvironment(@NotNull final ExecutionEnvironment env) { - myEnvironment = env; - } - - public void addLogConsole(final String name, final String path, @NotNull final Charset charset, final long skippedContent, Icon icon) { - final Ref content = new Ref(); - addLogConsole(new LogConsoleImpl(myProject, new File(path), charset, skippedContent, name, false) { - public boolean isActive() { - final Content logContent = content.get(); - return logContent != null && logContent.isSelected(); - } - }, icon, content); - } - - private void addLogConsole(final LogConsoleBase logConsole, Icon icon, Ref content) { - logConsole.attachStopLogConsoleTrackingListener(getRunContentDescriptor().getProcessHandler()); - // Attach custom log handlers - if (myEnvironment != null && myEnvironment.getRunProfile() instanceof RunConfigurationBase) { - ((RunConfigurationBase)myEnvironment.getRunProfile()).customizeLogConsole(logConsole); - } - - content.set(addLogComponent(logConsole, icon)); - final ContentManagerAdapter l = new ContentManagerAdapter() { - public void selectionChanged(final ContentManagerEvent event) { - logConsole.activate(); - } - }; - myContentListeners.put(logConsole, l); - getUi().addListener(l, this); - } - - public void addLogConsole(String name, String path, @NotNull Charset charset, long skippedContent) { - addLogConsole(name, path, charset, skippedContent, AllIcons.FileTypes.Text); - } - protected void attachNotificationTo(final Content content) { if (myConsole instanceof ObservableConsoleView) { ObservableConsoleView observable = (ObservableConsoleView)myConsole; @@ -160,67 +135,6 @@ public abstract class DebuggerSessionTabBase implements DebuggerLogConsoleManage } } - @Nullable - public static String getLogContentId(@NotNull String tabTitle) { - return "Log-" + tabTitle; - } - - public void removeLogConsole(final String path) { - LogConsoleImpl componentToRemove = null; - for (AdditionalTabComponent tabComponent : myAdditionalContent.keySet()) { - if (tabComponent instanceof LogConsoleImpl) { - final LogConsoleImpl console = (LogConsoleImpl)tabComponent; - if (Comparing.strEqual(console.getPath(), path)) { - componentToRemove = console; - break; - } - } - } - if (componentToRemove != null) { - getUi().removeListener(myContentListeners.remove(componentToRemove)); - removeAdditionalTabComponent(componentToRemove); - } - } - - public void addAdditionalTabComponent(AdditionalTabComponent tabComponent, String id, Icon icon) { - addLogComponent(tabComponent, id, icon); - } - - public void addAdditionalTabComponent(final AdditionalTabComponent tabComponent, final String id) { - addLogComponent(tabComponent, id); - } - - private void addLogComponent(AdditionalTabComponent component, String id) { - addLogComponent(component, id, AllIcons.FileTypes.Text); - } - - private Content addLogComponent(AdditionalTabComponent tabComponent, Icon icon) { - @NonNls final String id = getLogContentId(tabComponent.getTabTitle()); - return addLogComponent(tabComponent, id, icon); - } - - private Content addLogComponent(final AdditionalTabComponent tabComponent, String id, Icon icon) { - final Content logContent = getUi().createContent(id, (ComponentWithActions)tabComponent, tabComponent.getTabTitle(), icon, - tabComponent.getPreferredFocusableComponent()); - logContent.setCloseable(false); - logContent.setDescription(tabComponent.getTooltip()); - myAdditionalContent.put(tabComponent, logContent); - getUi().addContent(logContent); - Disposer.register(this, new Disposable() { - public void dispose() { - removeAdditionalTabComponent(tabComponent); - } - }); - - return logContent; - } - - public void removeAdditionalTabComponent(AdditionalTabComponent component) { - Disposer.dispose(component); - final Content content = myAdditionalContent.remove(component); - getUi().removeContent(content, true); - } - public void toFront() { if (!ApplicationManager.getApplication().isUnitTestMode()) { ExecutionManager.getInstance(getProject()).getContentManager().toFrontRunContent(DefaultDebugExecutor.getDebugExecutorInstance(), myRunContentDescriptor); @@ -230,17 +144,10 @@ public abstract class DebuggerSessionTabBase implements DebuggerLogConsoleManage boolean focusWnd = Registry.is("debugger.mayBringFrameToFrontOnBreakpoint"); ProjectUtil.focusProjectWindow(getProject(), focusWnd); if (!focusWnd) { - AppIcon.getInstance().requestAttention(myProject, true); + AppIcon.getInstance().requestAttention(getProject(), true); } } }); } } - - protected Project getProject() { - return myProject; - } - - public void dispose() { - } }