cadi/core/src/main/java/org/onap/aaf/cadi/BufferedServletInputStream.java

   1 /**
   2  * ============LICENSE_START====================================================
   3  * org.onap.aaf
   4  * ===========================================================================
   5  * Copyright (c) 2018 AT&T Intellectual Property. All rights reserved.
   6  * ===========================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END====================================================
  19  *
  20  */
  21
  22 package org.onap.aaf.cadi;
  23
  24 import java.io.IOException;
  25 import java.io.InputStream;
  26
  27 import javax.servlet.ServletInputStream;
  28
  29 /**
  30  * BufferedServletInputStream
  31  *
  32  * There are cases in brain-dead middleware (SOAP) where they store routing information in the content.
  33  *
  34  * In HTTP, this requires reading the content from the InputStream which, of course, cannot be re-read.
  35  *
  36  * BufferedInputStream exists to implement the "Mark" protocols for Streaming, which will enable being
  37  * re-read.  Unfortunately, J2EE chose to require a "ServletInputStream" as an abstract class, rather than
  38  * an interface, which requires we create a delegating pattern, rather than the preferred inheriting pattern.
  39  *
  40  * Unfortunately, the standard "BufferedInputStream" cannot be used, because it simply creates a byte array
  41  * in the "mark(int)" method of that size.  This is not appropriate for this application, because the Header
  42  * can be potentially huge, and if a buffer was allocated to accommodate all possibilities, the cost of memory
  43  * allocation would be too large for high performance transactions.
  44  *
  45  *
  46  * @author Jonathan
  47  *
  48  */
  49 public class BufferedServletInputStream extends ServletInputStream {
  50         private static final int NONE = 0;
  51         private static final int STORE = 1;
  52         private static final int READ = 2;
  53
  54         private InputStream is;
  55         private int state = NONE;
  56         private Capacitor capacitor;
  57
  58         public BufferedServletInputStream(InputStream is) {
  59                 this.is = is;
  60                 capacitor = null;
  61         }
  62
  63
  64         public int read() throws IOException {
  65                 int value=-1;
  66                 if(capacitor==null) {
  67                         value=is.read();
  68                 } else {
  69                         switch(state) {
  70                                 case STORE:
  71                                         value = is.read();
  72                                         if(value>=0) {
  73                                                 capacitor.put((byte)value);
  74                                         }
  75                                         break;
  76                                 case READ:
  77                                         value = capacitor.read();
  78                                         if(value<0) {
  79                                                 capacitor.done();
  80                                                 capacitor=null; // all done with buffer
  81                                                 value = is.read();
  82                                         }
  83                         }
  84                 }
  85                 return value;
  86         }
  87
  88         public int read(byte[] b) throws IOException {
  89                 return read(b,0,b.length);
  90         }
  91
  92
  93         public int read(byte[] b, int off, int len) throws IOException {
  94                 int count = -1;
  95                 if(capacitor==null) {
  96                         count = is.read(b,off,len);
  97                 } else {
  98                         switch(state) {
  99                                 case STORE:
 100                                         count = is.read(b, off, len);
 101                                         if(count>0) {
 102                                                 capacitor.put(b, off, count);
 103                                         }
 104                                         break;
 105                                 case READ:
 106                                         count = capacitor.read(b, off, len);
 107                                         if(count<=0) {
 108                                                 capacitor.done();
 109                                                 capacitor=null; // all done with buffer
 110                                         }
 111                                         if(count<len) {
 112                                                 int temp = is.read(b, count, len-count);
 113                                                 if(temp>0) { // watch for -1
 114                                                         count+=temp;
 115                                                 } else if(count<=0) {
 116                             count = temp; // must account for Stream coming back -1
 117                                                 }
 118                                         }
 119                                         break;
 120                         }
 121                 }
 122                 return count;
 123         }
 124
 125         public long skip(long n) throws IOException {
 126                 long skipped = capacitor.skip(n);
 127                 if(skipped<n) {
 128                         skipped += is.skip(n-skipped);
 129                 }
 130                 return skipped;
 131         }
 132
 133
 134         public int available() throws IOException {
 135                 int count = is.available();
 136                 if(capacitor!=null)count+=capacitor.available();
 137                 return count;
 138         }
 139
 140         /**
 141          * Return just amount buffered (for debugging purposes, mostly)
 142          * @return
 143          */
 144         public int buffered() {
 145                 return capacitor.available();
 146         }
 147
 148
 149         public void close() throws IOException {
 150                 if(capacitor!=null) {
 151                         capacitor.done();
 152                         capacitor=null;
 153                 }
 154                 is.close();
 155         }
 156
 157
 158         /**
 159          * Note: Readlimit is ignored in this implementation, because the need was for unknown buffer size which wouldn't
 160          * require allocating and dumping huge chunks of memory every use, or risk overflow.
 161          */
 162         public synchronized void mark(int readlimit) {
 163                 switch(state) {
 164                         case NONE:
 165                                 capacitor = new Capacitor();
 166                                 break;
 167                         case READ:
 168                                 capacitor.done();
 169                                 break;
 170                 }
 171                 state = STORE;
 172         }
 173
 174
 175         /**
 176          * Reset Stream
 177          *
 178          * Calling this twice is not supported in typical Stream situations, but it is allowed in this service.  The caveat is that it can only reset
 179          * the data read in since Mark has been called.  The data integrity is only valid if you have not continued to read past what is stored.
 180          *
 181          */
 182         public synchronized void reset() throws IOException {
 183                 switch(state) {
 184                         case STORE:
 185                                 capacitor.setForRead();
 186                                 state = READ;
 187                                 break;
 188                         case READ:
 189                                 capacitor.reset();
 190                                 break;
 191                         case NONE:
 192                                 throw new IOException("InputStream has not been marked");
 193                 }
 194         }
 195
 196
 197         public boolean markSupported() {
 198                 return true;
 199         }
 200 }