[VERSION] Update version to 1.0.0
[sdnc/core.git] / filters / provider / src / main / java / org / openecomp / sdnc / filters / RequestResponseLoggingFilter.java
1 /*-
2  * ============LICENSE_START=======================================================
3  * openECOMP : SDN-C
4  * ================================================================================
5  * Copyright (C) 2017 AT&T Intellectual Property. All rights
6  *                                              reserved.
7  * ================================================================================
8  * Licensed under the Apache License, Version 2.0 (the "License");
9  * you may not use this file except in compliance with the License.
10  * You may obtain a copy of the License at
11  * 
12  *      http://www.apache.org/licenses/LICENSE-2.0
13  * 
14  * Unless required by applicable law or agreed to in writing, software
15  * distributed under the License is distributed on an "AS IS" BASIS,
16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17  * See the License for the specific language governing permissions and
18  * limitations under the License.
19  * ============LICENSE_END=========================================================
20  */
21
22 package org.openecomp.sdnc.filters;
23
24 import java.io.BufferedReader;
25 import java.io.ByteArrayInputStream;
26 import java.io.ByteArrayOutputStream;
27 import java.io.IOException;
28 import java.io.InputStream;
29 import java.io.InputStreamReader;
30 import java.io.PrintWriter;
31 import java.util.Enumeration;
32 import java.util.zip.GZIPInputStream;
33 import java.util.zip.Inflater;
34
35 import javax.servlet.Filter;
36 import javax.servlet.FilterChain;
37 import javax.servlet.FilterConfig;
38 import javax.servlet.ServletException;
39 import javax.servlet.ServletInputStream;
40 import javax.servlet.ServletOutputStream;
41 import javax.servlet.ServletRequest;
42 import javax.servlet.ServletResponse;
43 import javax.servlet.http.HttpServletRequest;
44 import javax.servlet.http.HttpServletRequestWrapper;
45 import javax.servlet.http.HttpServletResponse;
46 import javax.servlet.http.HttpServletResponseWrapper;
47
48 public class RequestResponseLoggingFilter implements Filter {
49
50         private static org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger("org.openecomp.sdnc.filters.request.response");
51
52         private static class ByteArrayServletStream extends ServletOutputStream {
53
54                 ByteArrayOutputStream baos;
55
56                 ByteArrayServletStream(ByteArrayOutputStream baos) {
57                         this.baos = baos;
58                 }
59
60                 public void write(int param) throws IOException {
61                         baos.write(param);
62                 }
63         }
64
65         private static class ByteArrayPrintWriter {
66
67                 private ByteArrayOutputStream baos = new ByteArrayOutputStream();
68
69                 private PrintWriter pw = new PrintWriter(baos);
70
71                 private ServletOutputStream sos = new ByteArrayServletStream(baos);
72
73                 public PrintWriter getWriter() {
74                         return pw;
75                 }
76
77                 public ServletOutputStream getStream() {
78                         return sos;
79                 }
80
81                 byte[] toByteArray() {
82                         return baos.toByteArray();
83                 }
84         }
85
86         private class BufferedServletInputStream extends ServletInputStream {
87
88                 ByteArrayInputStream bais;
89
90                 public BufferedServletInputStream(ByteArrayInputStream bais) {
91                         this.bais = bais;
92                 }
93
94                 public int available() {
95                         return bais.available();
96                 }
97
98                 public int read() {
99                         return bais.read();
100                 }
101
102                 public int read(byte[] buf, int off, int len) {
103                         return bais.read(buf, off, len);
104                 }
105
106         }
107
108         private class BufferedRequestWrapper extends HttpServletRequestWrapper {
109
110                 ByteArrayInputStream bais;
111
112                 ByteArrayOutputStream baos;
113
114                 BufferedServletInputStream bsis;
115
116                 byte[] buffer;
117
118                 public BufferedRequestWrapper(HttpServletRequest req) throws IOException {
119                         super(req);
120
121                         InputStream is = req.getInputStream();
122                         baos = new ByteArrayOutputStream();
123                         byte buf[] = new byte[1024];
124                         int letti;
125                         while ((letti = is.read(buf)) > 0) {
126                                 baos.write(buf, 0, letti);
127                         }
128                         buffer = baos.toByteArray();
129
130                 }
131
132                 public ServletInputStream getInputStream() {
133                         try {
134                                 bais = new ByteArrayInputStream(buffer);
135                                 bsis = new BufferedServletInputStream(bais);
136                         } catch (Exception ex) {
137                                 ex.printStackTrace();
138                         }
139
140                         return bsis;
141                 }
142
143                 public byte[] getBuffer() {
144                         return buffer;
145                 }
146
147         }
148
149         public void init(FilterConfig filterConfig) throws ServletException {
150         }
151
152         public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
153                         throws IOException, ServletException {
154
155                 final HttpServletRequest httpRequest = (HttpServletRequest) servletRequest;
156                 BufferedRequestWrapper bufferedRequest = new BufferedRequestWrapper(httpRequest);
157
158                 StringBuilder requestHeaders = new StringBuilder("REQUEST|");
159                 requestHeaders.append(httpRequest.getMethod());
160                 requestHeaders.append(":");
161                 requestHeaders.append(httpRequest.getRequestURL().toString());
162                 requestHeaders.append("|");
163                 String header;
164                 for (Enumeration<String> e = httpRequest.getHeaderNames(); e.hasMoreElements();) {
165                         header = e.nextElement();
166                         requestHeaders.append(header);
167                         requestHeaders.append(":");
168                         requestHeaders.append(httpRequest.getHeader(header));
169                         requestHeaders.append(";");
170
171                 }
172                 log.info(requestHeaders.toString());
173
174                 log.info("REQUEST BODY|" + new String(bufferedRequest.getBuffer()));
175
176                 final HttpServletResponse response = (HttpServletResponse) servletResponse;
177
178                 final ByteArrayPrintWriter pw = new ByteArrayPrintWriter();
179                 HttpServletResponse wrappedResp = new HttpServletResponseWrapper(response) {
180                         public PrintWriter getWriter() {
181                                 return pw.getWriter();
182                         }
183
184                         public ServletOutputStream getOutputStream() {
185                                 return pw.getStream();
186                         }
187
188                 };
189
190                 try {
191                         
192                 filterChain.doFilter(bufferedRequest, wrappedResp);
193                 
194                 }catch (Exception e){
195                         log.error("Chain Exception",e);
196                         throw e;
197                 } finally {
198                 byte[] bytes = pw.toByteArray();
199                 response.getOutputStream().write(bytes);
200
201                 StringBuilder responseHeaders = new StringBuilder("RESPONSE HEADERS|");
202
203                 for (String headerName : response.getHeaderNames()) {
204                         responseHeaders.append(headerName);
205                         responseHeaders.append(":");
206                         responseHeaders.append(response.getHeader(headerName));
207                         responseHeaders.append(";");
208
209                 }
210                 log.info(responseHeaders.toString());
211
212                 if ("gzip".equals(response.getHeader("Content-Encoding"))) {
213
214                         log.info("UNGZIPED RESPONSE BODY|" + decompressGZIPByteArray(bytes));
215
216                 } else {
217
218                         log.info("RESPONSE BODY|" + new String(bytes));
219                 }
220                 }
221         }
222
223         public void destroy() {
224         }
225
226         private String decompressGZIPByteArray(byte[] bytes) {
227
228                 BufferedReader in = null;
229                 InputStreamReader inR = null;
230                 ByteArrayInputStream byteS = null;
231                 GZIPInputStream gzS = null;
232                 StringBuilder str = new StringBuilder();
233                 try {
234                         byteS = new ByteArrayInputStream(bytes);
235                         gzS = new GZIPInputStream(byteS);
236                         inR = new InputStreamReader(gzS);
237                         in = new BufferedReader(inR);
238
239                         if (in != null) {
240
241                                 String content;
242
243                                 while ((content = in.readLine()) != null) {
244                                         str.append(content);
245                                 }
246                         }
247
248                 } catch (Exception e) {
249                         log.error("Failed get read GZIPInputStream", e);
250                 } finally {
251
252                         if (byteS != null)
253                                 try {
254                                         byteS.close();
255                                 } catch (IOException e1) {
256                                         log.error("Failed to close ByteStream", e1);
257                                 }
258                         if (gzS != null)
259                                 try {
260                                         gzS.close();
261                                 } catch (IOException e2) {
262                                         log.error("Failed to close GZStream", e2);
263                                 }
264                         if (inR != null)
265                                 try {
266                                         inR.close();
267                                 } catch (IOException e3) {
268                                         log.error("Failed to close InputReader", e3);
269                                 }
270                         if (in != null)
271                                 try {
272                                         in.close();
273                                 } catch (IOException e) {
274                                         log.error("Failed to close BufferedReader", e);
275                                 }
276                 }
277                 return str.toString();
278         }
279 }