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
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
|
/*******************************************************************************
* Copyright (c) 2000, 2020 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 java.nio.charset.Charset;
import org.eclipse.debug.core.model.IBinaryStreamMonitor;
import org.eclipse.debug.core.model.IBinaryStreamsProxy;
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 {@link IStreamsProxy},
* {@link IStreamsProxy2} and {@link IBinaryStreamsProxy}.
* <p>
* Will use the same monitor instances for binary and string stream handling.
*/
public class StreamsProxy implements IBinaryStreamsProxy {
/**
* 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 charset the process's charset or <code>null</code> if default
*/
@SuppressWarnings("resource")
public StreamsProxy(Process process, Charset charset) {
if (process == null) {
return;
}
fOutputMonitor = new OutputStreamMonitor(process.getInputStream(), charset);
fErrorMonitor = new OutputStreamMonitor(process.getErrorStream(), charset);
fInputMonitor = new InputStreamMonitor(process.getOutputStream(), charset);
fOutputMonitor.startMonitoring();
fErrorMonitor.startMonitoring();
fInputMonitor.startMonitoring();
}
/**
* 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
* @deprecated use {@link #StreamsProxy(Process, Charset)} instead
*/
@Deprecated
public StreamsProxy(Process process, String encoding) {
// This constructor was once removed in favor of the Charset variant
// but Bug 562653 brought up a client which use this internal class via
// reflection and breaks without this constructor. So we restored the
// old constructor for the time being.
this(process, Charset.forName(encoding));
}
/**
* 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();
}
@Override
public IStreamMonitor getErrorStreamMonitor() {
return fErrorMonitor;
}
@Override
public IStreamMonitor getOutputStreamMonitor() {
return fOutputMonitor;
}
@Override
public void write(String input) throws IOException {
if (!isClosed(false)) {
fInputMonitor.write(input);
} else {
throw new IOException();
}
}
@Override
public void closeInputStream() throws IOException {
if (!isClosed(false)) {
fInputMonitor.closeInputStream();
} else {
throw new IOException();
}
}
@Override
public IBinaryStreamMonitor getBinaryErrorStreamMonitor() {
return fErrorMonitor;
}
@Override
public IBinaryStreamMonitor getBinaryOutputStreamMonitor() {
return fOutputMonitor;
}
@Override
public void write(byte[] data, int offset, int length) throws IOException {
if (!isClosed(false)) {
fInputMonitor.write(data, offset, length);
} else {
throw new IOException();
}
}
}
|
