← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/libjboss-remoting-java/oneiric

« back to all changes in this revision

Viewing changes to src/main/org/jboss/remoting/transport/multiplex/MultiplexingOutputStream.java

  • Committer: Package Import Robot
  • Author(s): Torsten Werner
  • Date: 2011-09-09 14:01:03 UTC
  • mfrom: (1.1.6 upstream)
  • Revision ID: package-import@ubuntu.com-20110909140103-hqokx61534tas9rg
Tags: 2.5.3.SP1-1
http://bugs.debian.org/628303
* Newer but not newest upstream release. Do not build samples.
* Change debian/watch to upstream's svn repo.
* Add patch to fix compile error caused by tomcat update.
  (Closes: #628303)
* Switch to source format 3.0.
* Switch to debhelper level 7.
* Remove useless Depends.
* Update Standards-Version: 3.9.2.
* Update README.source.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/main/org/jboss/remoting/transport/multiplex/MultiplexingOutputStream.java
 
1
/*
 
2
* JBoss, Home of Professional Open Source
 
3
* Copyright 2005, JBoss Inc., and individual contributors as indicated
 
4
* by the @authors tag. See the copyright.txt in the distribution for a
 
5
* full listing of individual contributors.
 
6
*
 
7
* This is free software; you can redistribute it and/or modify it
 
8
* under the terms of the GNU Lesser General Public License as
 
9
* published by the Free Software Foundation; either version 2.1 of
 
10
* the License, or (at your option) any later version.
 
11
*
 
12
* This software is distributed in the hope that it will be useful,
 
13
* but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 
15
* Lesser General Public License for more details.
 
16
*
 
17
* You should have received a copy of the GNU Lesser General Public
 
18
* License along with this software; if not, write to the Free
 
19
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 
20
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 
21
*/
 
22
 
 
23
/*
 
24
 * Created on Jul 22, 2005
 
25
 */
 
26
 
 
27
package org.jboss.remoting.transport.multiplex;
 
28
 
 
29
import java.io.IOException;
 
30
import java.io.OutputStream;
 
31
import java.net.SocketException;
 
32
 
 
33
import org.jboss.logging.Logger;
 
34
 
 
35
/**
 
36
 * <code>MultiplexingOutputStream</code> is the class returned by
 
37
 * <code>VirtualSocket.getOutputStream()</code>.  
 
38
 * It supports the methods and behavior implemented by the <code>OutputStream</code> returned by
 
39
 * <code>java.net.Socket.getOutputStream()</code>.  For more information about the behavior
 
40
 * of the methods, see the javadoc for <code>java.io.OutputStream</code>.
 
41
 * <p>
 
42
 * Copyright (c) 2005
 
43
 * <p>
 
44
 * @author <a href="mailto:r.sigal@computer.org">Ron Sigal</a>
 
45
 * 
 
46
 * @deprecated As of release 2.4.0 the multiplex transport will no longer be actively supported.
 
47
 */
 
48
public class MultiplexingOutputStream extends OutputStream
 
49
{
 
50
   protected static final Logger log = Logger.getLogger(MultiplexingOutputStream.class);
 
51
   private MultiplexingManager manager;
 
52
   private OutputMultiplexor outputMultiplexor;
 
53
   private VirtualSocket virtualSocket;
 
54
   private SocketId socketId;
 
55
   private boolean outputShutdown = false;
 
56
   private boolean closed = false;
 
57
   private IOException writeException;
 
58
   
 
59
   private static final int OPEN                                = 0;
 
60
   private static final int CONNECTION_RESET    = 1;
 
61
   private static final int CLOSED                              = 2;
 
62
   private int connectionState = OPEN;
 
63
 
 
64
   private byte[] oneByte = new byte[1];
 
65
   private byte[] fourBytes = new byte[4];
 
66
   
 
67
/**
 
68
 * 
 
69
 * @param manager
 
70
 * @param socketId
 
71
 */
 
72
   public MultiplexingOutputStream(MultiplexingManager manager, SocketId socketId)
 
73
   {
 
74
      this(manager, null, socketId);
 
75
   }
 
76
   
 
77
   
 
78
/**
 
79
 * 
 
80
 * @param manager
 
81
 * @param virtualSocket
 
82
 * @param socketId
 
83
 */
 
84
   public MultiplexingOutputStream(MultiplexingManager manager, VirtualSocket virtualSocket, SocketId socketId)
 
85
   {
 
86
      this.manager = manager;
 
87
      this.virtualSocket = virtualSocket;
 
88
      this.socketId = socketId;
 
89
      this.outputMultiplexor = manager.getOutputMultiplexor();
 
90
   }
 
91
   
 
92
//////////////////////////////////////////////////////////////////////////////////////////////////
 
93
///                  The following methods are required of all OutputStreams                  '///
 
94
//////////////////////////////////////////////////////////////////////////////////////////////////
 
95
 
 
96
 /*************************************************************************************************
 
97
       ok: public void write(int b) throws IOException;
 
98
       ok: public void write(byte b[]) throws IOException;
 
99
       ok: public void write(byte b[], int off, int len) throws IOException;
 
100
           public void flush() throws IOException;
 
101
       ok: public void close() throws IOException;
 
102
 *************************************************************************************************/
 
103
 
 
104
   
 
105
/**
 
106
 * See superclass javadoc.
 
107
 */
 
108
   public void close() throws IOException
 
109
   {
 
110
      log.debug("MultiplexingOutputStream.close() entered");
 
111
      
 
112
      if (closed)
 
113
         return;
 
114
         
 
115
      closed = true;
 
116
      
 
117
      if (virtualSocket != null)
 
118
         virtualSocket.close();
 
119
   }
 
120
   
 
121
   
 
122
/**
 
123
 * See superclass javadoc.
 
124
 */
 
125
   public void flush() throws IOException
 
126
   {
 
127
      // Could use flush() to raise priority of messages waiting in OutputMultiplexor's write queue.
 
128
   }
 
129
   
 
130
   
 
131
/**
 
132
 * See superclass javadoc.
 
133
 */
 
134
   public void write(int i) throws IOException
 
135
   {
 
136
      checkStatus();
 
137
      oneByte[0] = (byte) i;
 
138
      outputMultiplexor.write(manager, socketId, oneByte);
 
139
   }
 
140
   
 
141
/**
 
142
 * See superclass javadoc.
 
143
 */
 
144
   public void write(byte[] array) throws IOException, NullPointerException
 
145
   { 
 
146
      checkStatus();
 
147
      outputMultiplexor.write(manager, socketId, array);
 
148
   }
 
149
   
 
150
   
 
151
/**
 
152
 * See superclass javadoc.
 
153
 */
 
154
   public void write(byte[] array, int off, int len)
 
155
   throws IOException, NullPointerException, IndexOutOfBoundsException
 
156
   { 
 
157
      checkStatus();
 
158
 
 
159
      if (array == null)
 
160
         throw new NullPointerException();
 
161
      
 
162
      if (off < 0 || len < 0 || off + len > array.length)
 
163
         throw new IndexOutOfBoundsException();
 
164
      
 
165
      byte[] subArray = new byte[len];
 
166
      
 
167
      for (int i = 0; i < len; i++)
 
168
         subArray[i] = array[off + i];
 
169
 
 
170
      outputMultiplexor.write(manager, socketId, subArray);
 
171
   }
 
172
   
 
173
  
 
174
//////////////////////////////////////////////////////////////////////////////////////////////////
 
175
///              The following methods are specific to MultiplexingOutputStream               '///
 
176
//////////////////////////////////////////////////////////////////////////////////////////////////
 
177
 
 
178
   protected void setWriteException(IOException e)
 
179
   {
 
180
      writeException = e;
 
181
   }
 
182
   
 
183
   
 
184
/**
 
185
 * <code>writeInt()</code> is borrowed from <code>DataOutputStream</code>.
 
186
 * It saves the extra expense of creating a <code>DataOutputStream</code>. 
 
187
 * @param i
 
188
 * @throws IOException
 
189
 */
 
190
   public void writeInt(int i) throws IOException
 
191
   {
 
192
      fourBytes[0] = (byte) ((i >>> 24) & 0xff);
 
193
      fourBytes[1] = (byte) ((i >>> 16) & 0xff);
 
194
      fourBytes[2] = (byte) ((i >>>  8) & 0xff);
 
195
      fourBytes[3] = (byte) ((i >>>  0) & 0xff);
 
196
      outputMultiplexor.write(manager, socketId, fourBytes);
 
197
   }
 
198
   
 
199
/**
 
200
 * Determines how to handle a write request depending on what this socket knows about the state
 
201
 * of the peer socket.
 
202
 * <p>
 
203
 * Once this socket knows that the peer socket has closed, no more write requests will be honored.
 
204
 * There seem to be two ways for a socket A to learn that its peer socket B has closed.
 
205
 * <p>
 
206
 * <ol>
 
207
 *  <li>If socket A has executed a write, but no subsequent write is performed on B,
 
208
 *      then the acknowledgement of the write will carry back the information that B has closed.
 
209
 *  <li>If socket B has no pending acknowledgements to send at the time it closes, and then socket A
 
210
 *      does a write after B has closed, the (negative) acknowledgement of the write will carry back
 
211
 *      the information that B has closed.
 
212
 * </ol>
 
213
 * <p>
 
214
 * Java seems to respond differently to the two cases.  The first write after this socket has learned
 
215
 * of the peer's closing through the first scenario will result in a SocketException("Connection reset").
 
216
 * In the second scenario, the first write by this socket after the peer has closed 
 
217
 * will quietly fail (no exception is thrown).  All subsequent writes after either of these two 
 
218
 * scenarios will result in a  SocketException("Broken pipe").
 
219
 * <p>
 
220
 * Currently, MultiplexingOutputStream implements only a simplified version of this behavior.  In
 
221
 * particular, it allows in all cases one write to silently fail, after which all writes result in a
 
222
 * SocketException("Broken pipe");
 
223
 * <p>
 
224
 * Note.  This discussion is based on empirical observation on a linux system, not on examination of code.
 
225
 * Your mileage may vary.
 
226
 */
 
227
   protected void checkStatus() throws IOException
 
228
   {
 
229
      if (closed)
 
230
         throw new SocketException("Socket closed");
 
231
      
 
232
      if (outputShutdown)
 
233
         throw new SocketException("Broken pipe");
 
234
      
 
235
      if (writeException != null)
 
236
         throw writeException;
 
237
      
 
238
      switch (connectionState)
 
239
      {
 
240
         case OPEN:
 
241
            return;
 
242
 
 
243
         case CONNECTION_RESET:
 
244
            connectionState = CLOSED;
 
245
            return;
 
246
            
 
247
         case CLOSED:
 
248
            throw new SocketException("Broken pipe");
 
249
            
 
250
         default:
 
251
            log.error("unrecognized connection state: " + connectionState);
 
252
      }
 
253
   }
 
254
   
 
255
   
 
256
/**
 
257
 * 
 
258
 */
 
259
   protected void handleRemoteDisconnect()
 
260
   {
 
261
      log.debug("entering handleRemoteDisconnect()");
 
262
      
 
263
      switch (connectionState)
 
264
      {
 
265
         case OPEN:
 
266
            connectionState = CONNECTION_RESET;
 
267
            return;
 
268
            
 
269
         default:
 
270
            connectionState = CLOSED;
 
271
            log.error("invalid connection state in handleRemoteDisconnect(): " + connectionState);
 
272
      }
 
273
   }
 
274
   
 
275
   
 
276
/**
 
277
 * 
 
278
 */
 
279
   protected void shutdown()
 
280
   {
 
281
      outputShutdown = true;
 
282
   }
 
283
   
 
284
   
 
285
/**
 
286
 * @param i
 
287
 * @param brackets
 
288
 * @throws IOException
 
289
 */
 
290
   protected void write(int i, int brackets) throws IOException
 
291
   {
 
292
      log.debug("brackets: " + brackets);
 
293
      oneByte[0] = (byte) i;
 
294
      outputMultiplexor.write(manager, socketId, oneByte, brackets);
 
295
   }
 
296
   
 
297
   
 
298
/**
 
299
 * @param i
 
300
 * @param brackets
 
301
 * @throws IOException
 
302
 */
 
303
   protected void writeInt(int i, int brackets) throws IOException
 
304
   {
 
305
      log.debug("brackets: " + brackets);
 
306
      fourBytes[0] = (byte) ((i >>> 24) & 0xff);
 
307
      fourBytes[1] = (byte) ((i >>> 16) & 0xff);
 
308
      fourBytes[2] = (byte) ((i >>>  8) & 0xff);
 
309
      fourBytes[3] = (byte) ((i >>>  0) & 0xff);
 
310
      outputMultiplexor.write(manager, socketId, fourBytes, brackets);
 
311
   }
 
312
}