blob: 1c7ab5bf9ef02ac382e20dc695ce2814d87bfc00 (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
|
/*******************************************************************************
* Copyright (c) 2000, 2013 IBM Corporation and others.
*
* This program and the accompanying materials
* are made available under the terms of the Eclipse Public License 2.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.debug.internal.core;
import java.io.IOException;
import org.eclipse.debug.core.model.IStreamMonitor;
import org.eclipse.debug.core.model.IStreamsProxy;
import org.eclipse.debug.core.model.IStreamsProxy2;
/**
* Standard implementation of a streams proxy for IStreamsProxy.
*/
public class StreamsProxy implements IStreamsProxy, IStreamsProxy2 {
/**
* The monitor for the output stream (connected to standard out of the process)
*/
private OutputStreamMonitor fOutputMonitor;
/**
* The monitor for the error stream (connected to standard error of the process)
*/
private OutputStreamMonitor fErrorMonitor;
/**
* The monitor for the input stream (connected to standard in of the process)
*/
private InputStreamMonitor fInputMonitor;
/**
* Records the open/closed state of communications with
* the underlying streams. Note: fClosed is initialized to
* <code>false</code> by default.
*/
private boolean fClosed;
/**
* Creates a <code>StreamsProxy</code> on the streams
* of the given system process.
*
* @param process system process to create a streams proxy on
* @param encoding the process's encoding or <code>null</code> if default
*/
public StreamsProxy(Process process, String encoding) {
if (process == null) {
return;
}
fOutputMonitor= new OutputStreamMonitor(process.getInputStream(), encoding);
fErrorMonitor= new OutputStreamMonitor(process.getErrorStream(), encoding);
fInputMonitor= new InputStreamMonitor(process.getOutputStream(), encoding);
fOutputMonitor.startMonitoring();
fErrorMonitor.startMonitoring();
fInputMonitor.startMonitoring();
}
/**
* Causes the proxy to close all
* communications between it and the
* underlying streams after all remaining data
* in the streams is read.
*/
public void close() {
if (!isClosed(true)) {
fOutputMonitor.close();
fErrorMonitor.close();
fInputMonitor.close();
}
}
/**
* Returns whether the proxy is currently closed. This method
* synchronizes access to the <code>fClosed</code> flag.
*
* @param setClosed If <code>true</code> this method will also set the
* <code>fClosed</code> flag to true. Otherwise, the <code>fClosed</code>
* flag is not modified.
* @return Returns whether the stream proxy was already closed.
*/
private synchronized boolean isClosed(boolean setClosed) {
boolean closed = fClosed;
if (setClosed) {
fClosed = true;
}
return closed;
}
/**
* Causes the proxy to close all
* communications between it and the
* underlying streams immediately.
* Data remaining in the streams is lost.
*/
public void kill() {
synchronized (this) {
fClosed= true;
}
fOutputMonitor.kill();
fErrorMonitor.kill();
fInputMonitor.close();
}
/**
* @see IStreamsProxy#getErrorStreamMonitor()
*/
@Override
public IStreamMonitor getErrorStreamMonitor() {
return fErrorMonitor;
}
/**
* @see IStreamsProxy#getOutputStreamMonitor()
*/
@Override
public IStreamMonitor getOutputStreamMonitor() {
return fOutputMonitor;
}
/**
* @see IStreamsProxy#write(String)
*/
@Override
public void write(String input) throws IOException {
if (!isClosed(false)) {
fInputMonitor.write(input);
} else {
throw new IOException();
}
}
/* (non-Javadoc)
* @see org.eclipse.debug.core.model.IStreamsProxy2#closeInputStream()
*/
@Override
public void closeInputStream() throws IOException {
if (!isClosed(false)) {
fInputMonitor.closeInputStream();
} else {
throw new IOException();
}
}
}
|
