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
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
|
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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 org.apache.thrift.transport;
import org.apache.thrift.TConfiguration;
import java.io.Closeable;
import java.nio.ByteBuffer;
/**
* Generic class that encapsulates the I/O layer. This is basically a thin
* wrapper around the combined functionality of Java input/output streams.
*
*/
public abstract class TTransport implements Closeable {
/**
* Queries whether the transport is open.
*
* @return True if the transport is open.
*/
public abstract boolean isOpen();
/**
* Is there more data to be read?
*
* @return True if the remote side is still alive and feeding us
*/
public boolean peek() {
return isOpen();
}
/**
* Opens the transport for reading/writing.
*
* @throws TTransportException if the transport could not be opened
*/
public abstract void open()
throws TTransportException;
/**
* Closes the transport.
*/
public abstract void close();
/**
* Reads a sequence of bytes from this channel into the given buffer. An
* attempt is made to read up to the number of bytes remaining in the buffer,
* that is, dst.remaining(), at the moment this method is invoked. Upon return
* the buffer's position will move forward the number of bytes read; its limit
* will not have changed. Subclasses are encouraged to provide a more
* efficient implementation of this method.
*
* @param dst The buffer into which bytes are to be transferred
* @return The number of bytes read, possibly zero, or -1 if the channel has
* reached end-of-stream
* @throws TTransportException if there was an error reading data
*/
public int read(ByteBuffer dst) throws TTransportException {
byte[] arr = new byte[dst.remaining()];
this.readAll(arr, 0, arr.length);
dst.put(arr);
return arr.length;
}
/**
* Reads up to len bytes into buffer buf, starting at offset off.
*
* @param buf Array to read into
* @param off Index to start reading at
* @param len Maximum number of bytes to read
* @return The number of bytes actually read
* @throws TTransportException if there was an error reading data
*/
public abstract int read(byte[] buf, int off, int len)
throws TTransportException;
/**
* Guarantees that all of len bytes are actually read off the transport.
*
* @param buf Array to read into
* @param off Index to start reading at
* @param len Maximum number of bytes to read
* @return The number of bytes actually read, which must be equal to len
* @throws TTransportException if there was an error reading data
*/
public int readAll(byte[] buf, int off, int len)
throws TTransportException {
int got = 0;
int ret = 0;
while (got < len) {
ret = read(buf, off+got, len-got);
if (ret <= 0) {
throw new TTransportException(
"Cannot read. Remote side has closed. Tried to read "
+ len
+ " bytes, but only got "
+ got
+ " bytes. (This is often indicative of an internal error on the server side. Please check your server logs.)");
}
got += ret;
}
return got;
}
/**
* Writes the buffer to the output
*
* @param buf The output data buffer
* @throws TTransportException if an error occurs writing data
*/
public void write(byte[] buf) throws TTransportException {
write(buf, 0, buf.length);
}
/**
* Writes up to len bytes from the buffer.
*
* @param buf The output data buffer
* @param off The offset to start writing from
* @param len The number of bytes to write
* @throws TTransportException if there was an error writing data
*/
public abstract void write(byte[] buf, int off, int len)
throws TTransportException;
/**
* Writes a sequence of bytes to the buffer. An attempt is made to write all
* remaining bytes in the buffer, that is, src.remaining(), at the moment this
* method is invoked. Upon return the buffer's position will updated; its limit
* will not have changed. Subclasses are encouraged to provide a more efficient
* implementation of this method.
*
* @param src The buffer from which bytes are to be retrieved
* @return The number of bytes written, possibly zero
* @throws TTransportException if there was an error writing data
*/
public int write(ByteBuffer src) throws TTransportException {
byte[] arr = new byte[src.remaining()];
src.get(arr);
write(arr);
return arr.length;
}
/**
* Flush any pending data out of a transport buffer.
*
* @throws TTransportException if there was an error writing out data.
*/
public void flush()
throws TTransportException {}
/**
* Access the protocol's underlying buffer directly. If this is not a
* buffered transport, return null.
* @return protocol's Underlying buffer
*/
public byte[] getBuffer() {
return null;
}
/**
* Return the index within the underlying buffer that specifies the next spot
* that should be read from.
* @return index within the underlying buffer that specifies the next spot
* that should be read from
*/
public int getBufferPosition() {
return 0;
}
/**
* Get the number of bytes remaining in the underlying buffer. Returns -1 if
* this is a non-buffered transport.
* @return the number of bytes remaining in the underlying buffer. <br> Returns -1 if
* this is a non-buffered transport.
*/
public int getBytesRemainingInBuffer() {
return -1;
}
/**
* Consume len bytes from the underlying buffer.
* @param len
*/
public void consumeBuffer(int len) {}
public abstract TConfiguration getConfiguration();
public abstract void updateKnownMessageSize(long size) throws TTransportException;
public abstract void checkReadBytesAvailable(long numBytes) throws TTransportException;
}
|
