| /*=============================================================================# |
| # Copyright (c) 2006, 2020 Stephan Wahlbrink and others. |
| # |
| # This program and the accompanying materials are made available under the |
| # terms of the Eclipse Public License 2.0 which is available at |
| # https://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0 |
| # which is available at https://www.apache.org/licenses/LICENSE-2.0. |
| # |
| # SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 |
| # |
| # Contributors: |
| # Stephan Wahlbrink <sw@wahlbrink.eu> - initial API and implementation |
| #=============================================================================*/ |
| |
| package org.eclipse.statet.nico.core.runtime; |
| |
| import java.io.File; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.eclipse.core.filesystem.IFileStore; |
| import org.eclipse.core.filesystem.URIUtil; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.core.variables.IDynamicVariable; |
| import org.eclipse.debug.core.DebugEvent; |
| import org.eclipse.debug.core.DebugPlugin; |
| |
| import org.eclipse.statet.jcommons.collections.CopyOnWriteIdentityListSet; |
| import org.eclipse.statet.jcommons.collections.ImCollections; |
| import org.eclipse.statet.jcommons.collections.ImList; |
| import org.eclipse.statet.jcommons.status.ErrorStatus; |
| import org.eclipse.statet.jcommons.status.ProgressMonitor; |
| import org.eclipse.statet.jcommons.status.StatusException; |
| import org.eclipse.statet.jcommons.ts.core.SystemRunnable; |
| import org.eclipse.statet.jcommons.ts.core.Tool; |
| import org.eclipse.statet.jcommons.ts.core.ToolService; |
| |
| import org.eclipse.statet.ecommons.io.FileUtil; |
| import org.eclipse.statet.ecommons.net.resourcemapping.core.ResourceMappingUtils; |
| import org.eclipse.statet.ecommons.runtime.core.util.PathUtils; |
| import org.eclipse.statet.ecommons.variables.core.DateVariable; |
| import org.eclipse.statet.ecommons.variables.core.DynamicVariable; |
| import org.eclipse.statet.ecommons.variables.core.TimeVariable; |
| |
| import org.eclipse.statet.internal.nico.core.NicoCorePlugin; |
| import org.eclipse.statet.nico.core.NicoCore; |
| import org.eclipse.statet.nico.core.NicoVariables; |
| import org.eclipse.statet.nico.core.runtime.ToolController.IToolStatusListener; |
| |
| |
| /** |
| * It belongs to a ToolProcess and has the same life cycle. |
| */ |
| public class ToolWorkspace { |
| |
| |
| public static interface Listener { |
| |
| public void propertyChanged(ToolWorkspace workspace, Map<String, Object> properties); |
| |
| } |
| |
| |
| private class ControllerListener implements IToolStatusListener { |
| |
| @Override |
| public void controllerStatusChanged(final ToolStatus oldStatus, final ToolStatus newStatus, final List<DebugEvent> eventCollection) { |
| if (newStatus == ToolStatus.TERMINATED) { |
| dispose(); |
| } |
| |
| // by definition in tool lifecycle thread |
| if (!newStatus.isRunning()) { |
| if (ToolWorkspace.this.currentPrompt == null || ToolWorkspace.this.currentPrompt == ToolWorkspace.this.publishedPrompt) { |
| return; |
| } |
| ToolWorkspace.this.publishedPrompt= ToolWorkspace.this.currentPrompt; |
| firePrompt(ToolWorkspace.this.currentPrompt, eventCollection); |
| return; |
| } |
| else { |
| ToolWorkspace.this.publishedPrompt= ToolWorkspace.this.defaultPrompt; |
| firePrompt(ToolWorkspace.this.defaultPrompt, eventCollection); |
| } |
| } |
| |
| } |
| |
| private class AutoUpdater implements SystemRunnable { |
| |
| |
| @Override |
| public String getTypeId() { |
| return "common/workspace/update.auto"; |
| } |
| |
| @Override |
| public String getLabel() { |
| return "Auto Update"; |
| } |
| |
| @Override |
| public boolean canRunIn(final Tool tool) { |
| return (tool == ToolWorkspace.this.process); |
| } |
| |
| @Override |
| public boolean changed(final int event, final Tool tool) { |
| switch (event) { |
| case REMOVING_FROM: |
| case MOVING_FROM: |
| return false; |
| } |
| return true; |
| } |
| |
| @Override |
| public void run(final ToolService service, final ProgressMonitor m) throws StatusException { |
| ToolWorkspace.this.isRefreshing= true; |
| try { |
| autoRefreshFromTool((ConsoleService) service, m); |
| } |
| finally { |
| ToolWorkspace.this.isRefreshing= false; |
| } |
| firePropertiesChanged(); |
| } |
| |
| } |
| |
| |
| public static final int DETAIL_PROMPT= 1; |
| public static final int DETAIL_LINE_SEPARTOR= 2; |
| |
| |
| private final ToolProcess process; |
| |
| private volatile String lineSeparator; |
| private volatile char fileSeparator; |
| |
| private volatile Prompt currentPrompt; |
| private volatile Prompt defaultPrompt; |
| private Prompt publishedPrompt; |
| |
| private IFileStore workspaceDir; |
| |
| private final String remoteHost; |
| private IPath remoteWorkspaceDirPath; |
| |
| private final Map<String, Object> properties= new HashMap<>(); |
| private final CopyOnWriteIdentityListSet<Listener> propertyListener= new CopyOnWriteIdentityListSet<>(); |
| |
| private boolean autoRefreshEnabled= true; |
| |
| private boolean isRefreshing; |
| |
| private final ImList<IDynamicVariable> stringVariables; |
| |
| private int changeFlags; |
| |
| |
| public ToolWorkspace(final ToolController controller, |
| Prompt prompt, final String lineSeparator, final char fileSeparator, |
| final String remoteHost) { |
| this.process= controller.getTool(); |
| if (prompt == null) { |
| prompt= Prompt.DEFAULT; |
| } |
| this.publishedPrompt= this.currentPrompt= this.defaultPrompt= prompt; |
| this.remoteHost= remoteHost; |
| controlSetLineSeparator(lineSeparator); |
| controlSetFileSeparator(fileSeparator); |
| |
| controller.addToolStatusListener(new ControllerListener()); |
| controller.getQueue().addOnIdle(new AutoUpdater(), 5000); |
| |
| this.stringVariables= ImCollections.<IDynamicVariable>newList( |
| new DateVariable(NicoVariables.SESSION_STARTUP_DATE_VARIABLE) { |
| @Override |
| protected long getTimestamp() { |
| return ToolWorkspace.this.process.getStartupTimestamp(); |
| } |
| }, |
| new TimeVariable(NicoVariables.SESSION_STARTUP_TIME_VARIABLE) { |
| @Override |
| protected long getTimestamp() { |
| return ToolWorkspace.this.process.getStartupTimestamp(); |
| } |
| }, |
| new DateVariable(NicoVariables.SESSION_CONNECTION_DATE_VARIABLE) { |
| @Override |
| protected long getTimestamp() { |
| return ToolWorkspace.this.process.getConnectionTimestamp(); |
| } |
| }, |
| new TimeVariable(NicoVariables.SESSION_CONNECTION_TIME_VARIABLE) { |
| @Override |
| protected long getTimestamp() { |
| return ToolWorkspace.this.process.getStartupTimestamp(); |
| } |
| }, |
| new DynamicVariable.LocationVariable(NicoVariables.SESSION_STARTUP_WD_VARIABLE) { |
| @Override |
| public String getValue(final String argument) throws CoreException { |
| return ToolWorkspace.this.process.getStartupWD(); |
| } |
| } ); |
| } |
| |
| |
| public ToolProcess getProcess() { |
| return this.process; |
| } |
| |
| public boolean isWindows() { |
| return (getFileSeparator() == '\\'); |
| } |
| |
| |
| public void setAutoRefresh(final boolean enable) { |
| synchronized (this.process.getQueue()) { |
| if (this.autoRefreshEnabled != enable) { |
| this.autoRefreshEnabled= enable; |
| final ToolStatus status= this.process.getToolStatus(); |
| if (status != ToolStatus.TERMINATED) { |
| if (enable && status.isWaiting()) { |
| this.process.getQueue().internal_resetOnIdle(); |
| this.process.getQueue().notifyAll(); |
| } |
| addPropertyChanged("AutoRefresh.enabled", enable); |
| firePropertiesChanged(); |
| } |
| } |
| } |
| } |
| |
| public boolean isAutoRefreshEnabled() { |
| return this.autoRefreshEnabled; |
| } |
| |
| |
| protected void autoRefreshFromTool(final ConsoleService service, |
| final ProgressMonitor m) throws StatusException { |
| if (this.autoRefreshEnabled) { |
| refreshFromTool(0, service, m); |
| } |
| } |
| |
| protected void refreshFromTool(final int options, final ConsoleService service, |
| final ProgressMonitor m) throws StatusException { |
| } |
| |
| |
| protected final int getChangeFlags() { |
| return this.changeFlags; |
| } |
| |
| protected void controlBriefChanged(final Object obj, final int flags) { |
| this.changeFlags|= flags; |
| } |
| |
| protected void clearBriefedChanges() { |
| this.changeFlags= 0; |
| } |
| |
| public final String getLineSeparator() { |
| return this.lineSeparator; |
| } |
| |
| public final char getFileSeparator() { |
| return this.fileSeparator; |
| } |
| |
| |
| public final Prompt getPrompt() { |
| return this.publishedPrompt; |
| } |
| |
| protected final Prompt getCurrentPrompt() { |
| return this.currentPrompt; |
| } |
| |
| public final Prompt getDefaultPrompt() { |
| return this.defaultPrompt; |
| } |
| |
| public final IFileStore getWorkspaceDir() { |
| return this.workspaceDir; |
| } |
| |
| public String getEncoding() { |
| return "UTF-8"; //$NON-NLS-1$ |
| } |
| |
| |
| public final boolean isRemote() { |
| return (this.remoteHost != null); |
| } |
| |
| public String getRemoteAddress() { |
| return this.remoteHost; |
| } |
| |
| public IPath getRemoteWorkspaceDirPath() { |
| return this.remoteWorkspaceDirPath; |
| } |
| |
| public IPath createToolPath(String toolPath) { |
| if (toolPath == null) { |
| return null; |
| } |
| if (isWindows() && File.separatorChar == '/') { |
| toolPath= toolPath.replace('\\', '/'); |
| } |
| return PathUtils.check(new Path(toolPath)); |
| } |
| |
| public IFileStore toFileStore(final IPath toolPath) throws CoreException { |
| if (this.remoteHost != null) { |
| return ResourceMappingUtils.getManager() |
| .mapRemoteResourceToFileStore(this.remoteHost, toolPath, |
| (this.remoteWorkspaceDirPath != null) ? this.remoteWorkspaceDirPath : null ); |
| } |
| return FileUtil.getFileStore(toolPath.toString(), this.workspaceDir); |
| } |
| |
| public IFileStore toFileStore(final String toolPath) throws CoreException { |
| if (this.remoteHost != null) { |
| return toFileStore(createToolPath(toolPath)); |
| } |
| return FileUtil.getFileStore(toolPath.toString(), this.workspaceDir); |
| } |
| |
| public String toToolPath(final IFileStore fileStore) throws StatusException { |
| if (this.remoteHost != null) { |
| final IPath path= ResourceMappingUtils.getManager() |
| .mapFileStoreToRemoteResource(this.remoteHost, fileStore); |
| if (path != null) { |
| return path.toString(); |
| } |
| throw new StatusException(new ErrorStatus(NicoCore.BUNDLE_ID, |
| "Resolving path for the remote system failed." )); |
| } |
| return URIUtil.toPath(fileStore.toURI()).toString(); |
| } |
| |
| |
| final void controlRefresh(final int options, final ConsoleService adapter, |
| final ProgressMonitor m) throws StatusException { |
| this.isRefreshing= true; |
| try { |
| refreshFromTool(options, adapter, m); |
| } |
| finally { |
| this.isRefreshing= false; |
| } |
| firePropertiesChanged(); |
| } |
| |
| |
| /** |
| * Use only in tool main thread. |
| * @param prompt the new prompt, null doesn't change anything |
| */ |
| final void controlSetCurrentPrompt(final Prompt prompt, final ToolStatus status) { |
| if (prompt == this.currentPrompt || prompt == null) { |
| return; |
| } |
| this.currentPrompt= prompt; |
| if (!status.isRunning()) { |
| this.publishedPrompt= prompt; |
| firePrompt(prompt, null); |
| } |
| } |
| |
| /** |
| * Use only in tool main thread. |
| * @param prompt the new prompt, null doesn't change anything |
| */ |
| final void controlSetDefaultPrompt(final Prompt prompt) { |
| if (prompt == this.defaultPrompt || prompt == null) { |
| return; |
| } |
| final Prompt oldDefault= this.defaultPrompt; |
| this.defaultPrompt= prompt; |
| if (oldDefault == this.currentPrompt) { |
| this.currentPrompt= prompt; |
| } |
| if (oldDefault == this.publishedPrompt) { |
| this.publishedPrompt= prompt; |
| firePrompt(prompt, null); |
| } |
| } |
| |
| /** |
| * Use only in tool main thread. |
| * |
| * The default separator is System.getProperty("line.separator") for local |
| * workspaces, and '\n' for remote workspaces. |
| * |
| * @param newSeparator the new line separator, null sets the default separator |
| */ |
| final void controlSetLineSeparator(final String newSeparator) { |
| final String oldSeparator= this.lineSeparator; |
| if (newSeparator != null) { |
| this.lineSeparator= newSeparator; |
| } |
| else { |
| this.lineSeparator= (this.remoteHost == null) ? System.getProperty("line.separator") : "\n"; //$NON-NLS-1$ |
| } |
| // if (!fLineSeparator.equals(oldSeparator)) { |
| // DebugEvent event= new DebugEvent(ToolWorkspace.this, DebugEvent.CHANGE, DETAIL_LINE_SEPARTOR); |
| // event.setData(fLineSeparator); |
| // fireEvent(event); |
| // } |
| } |
| |
| /** |
| * Use only in tool main thread. |
| * |
| * The default separator is System.getProperty("file.separator") for local |
| * workspaces, and '/' for remote workspaces. |
| * |
| * @param newSeparator the new file separator, null sets the default separator |
| */ |
| final void controlSetFileSeparator(final char newSeparator) { |
| final char oldSeparator= this.fileSeparator; |
| if (newSeparator != 0) { |
| this.fileSeparator= newSeparator; |
| } |
| else { |
| this.fileSeparator= (isRemote()) ? '/' : File.separatorChar; |
| } |
| } |
| |
| protected final void controlSetWorkspaceDir(final IFileStore directory) { |
| if ((this.workspaceDir != null) ? !this.workspaceDir.equals(directory) : directory != null) { |
| this.workspaceDir= directory; |
| this.properties.put("wd", directory); |
| if (!this.isRefreshing) { |
| firePropertiesChanged(); |
| } |
| } |
| } |
| |
| protected final void controlSetRemoteWorkspaceDir(final IPath toolPath) { |
| this.remoteWorkspaceDirPath= toolPath; |
| try { |
| controlSetWorkspaceDir(toFileStore(toolPath)); |
| } |
| catch (final CoreException e) { |
| controlSetWorkspaceDir(null); |
| } |
| } |
| |
| |
| private final void firePrompt(final Prompt prompt, final List<DebugEvent> eventCollection) { |
| final DebugEvent event= new DebugEvent(ToolWorkspace.this, DebugEvent.CHANGE, DETAIL_PROMPT); |
| event.setData(prompt); |
| if (eventCollection != null) { |
| eventCollection.add(event); |
| return; |
| } |
| else { |
| fireEvent(event); |
| } |
| } |
| |
| protected final void fireEvent(final DebugEvent event) { |
| final DebugPlugin manager= DebugPlugin.getDefault(); |
| if (manager != null) { |
| manager.fireDebugEventSet(new DebugEvent[] { event }); |
| } |
| } |
| |
| public final void addPropertyListener(final Listener listener) { |
| this.propertyListener.add(listener); |
| } |
| |
| public final void removePropertyListener(final Listener listener) { |
| this.propertyListener.remove(listener); |
| } |
| |
| protected final void addPropertyChanged(final String property, final Object attr) { |
| this.properties.put(property, attr); |
| } |
| |
| protected final void firePropertiesChanged() { |
| if (this.properties.isEmpty()) { |
| return; |
| } |
| for (final Listener listener : this.propertyListener.toList()) { |
| try { |
| listener.propertyChanged(ToolWorkspace.this, this.properties); |
| } |
| catch (final Exception e) { |
| NicoCorePlugin.logError(0, "An unexpected exception was thrown when notifying a tool workspace listener about changes.", e); |
| } |
| } |
| this.properties.clear(); |
| } |
| |
| public ImList<IDynamicVariable> getStringVariables() { |
| return this.stringVariables; |
| } |
| |
| protected void dispose() { |
| } |
| |
| } |
