Пример #1
0
  @Override
  public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
      throws IOException, ServletException {

    if (!(request instanceof HttpServletRequest)) {
      throw new ServletException("Only HttpServletRequest requests are supported");
    }

    final HttpServletRequest httpRequest = (HttpServletRequest) request;
    final HttpServletResponse httpResponse = (HttpServletResponse) response;

    // extract the callback method from the request query parameters
    String callback = getCallbackMethod(httpRequest);

    if (!isJSONPRequest(callback)) {
      // Request is not a JSONP request move on
      chain.doFilter(request, response);
    } else {
      // Need to check if the callback method is safe
      if (!SAFE_PRN.matcher(callback).matches()) {
        throw new ServletException(
            "JSONP Callback method '" + CALLBACK_METHOD + "' parameter not valid function");
      }

      // Will stream updated response
      final ByteArrayOutputStream byteStream = new ByteArrayOutputStream();

      // Create a custom response wrapper to adding in the padding
      HttpServletResponseWrapper responseWrapper =
          new HttpServletResponseWrapper(httpResponse) {

            @Override
            public ServletOutputStream getOutputStream() throws IOException {
              return new ServletOutputStream() {
                @Override
                public void write(int b) throws IOException {
                  byteStream.write(b);
                }
              };
            }

            @Override
            public PrintWriter getWriter() throws IOException {
              return new PrintWriter(byteStream);
            }
          };

      // Process the rest of the filter chain, including the JAX-RS request
      chain.doFilter(request, responseWrapper);

      // Override response content and encoding
      response.setContentType(CONTENT_TYPE);
      response.setCharacterEncoding("UTF-8");

      // Write the padded updates to the output stream.
      response.getOutputStream().write((callback + "(").getBytes());
      response.getOutputStream().write(byteStream.toByteArray());
      response.getOutputStream().write(");".getBytes());
    }
  }
Пример #2
0
  private void sendProcessingError(Throwable t, ServletResponse response) {
    String stackTrace = getStackTrace(t);

    if (stackTrace != null && !stackTrace.equals("")) {
      try {
        response.setContentType("text/html");
        PrintStream ps = new PrintStream(response.getOutputStream());
        PrintWriter pw = new PrintWriter(ps);
        pw.print("<html>\n<head>\n<title>Error</title>\n</head>\n<body>\n"); // NOI18N

        // PENDING! Localize this for next official release
        pw.print("<h1>The resource did not process correctly</h1>\n<pre>\n");
        pw.print(stackTrace);
        pw.print("</pre></body>\n</html>"); // NOI18N
        pw.close();
        ps.close();
        response.getOutputStream().close();
      } catch (Exception ex) {
      }
    } else {
      try {
        PrintStream ps = new PrintStream(response.getOutputStream());
        t.printStackTrace(ps);
        ps.close();
        response.getOutputStream().close();
      } catch (Exception ex) {
      }
    }
  }
 @Override
 public void doFilter(
     ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
     throws IOException, ServletException {
   servletResponse.getOutputStream().print("[");
   filterChain.doFilter(servletRequest, servletResponse);
   servletResponse.getOutputStream().print("]");
 }
Пример #4
0
 /* ------------------------------------------------------------ */
 private void commitResponse(ServletResponse response, Request baseRequest) throws IOException {
   if (baseRequest.getResponse().isWriting()) {
     try {
       response.getWriter().close();
     } catch (IllegalStateException e) {
       response.getOutputStream().close();
     }
   } else {
     try {
       response.getOutputStream().close();
     } catch (IllegalStateException e) {
       response.getWriter().close();
     }
   }
 }
 @Override
 public void service(ServletRequest request, ServletResponse response)
     throws ServletException, IOException {
   String attributesToEncryptPropertyFileName =
       request.getParameter(ATTRIBUTES_TO_ENCRYPT_PROPERTIES);
   if (StringUtils.isBlank(attributesToEncryptPropertyFileName)) {
     throw new IllegalArgumentException(
         "No valid "
             + ATTRIBUTES_TO_ENCRYPT_PROPERTIES
             + " parameter was passed to this Servlet.");
   }
   boolean checkOjbEncryptConfig = true;
   String checkOjbEncryptConfigValue = request.getParameter(CHECK_OJB_ENCRYPT_CONFIG);
   if (!StringUtils.isBlank(checkOjbEncryptConfigValue)) {
     checkOjbEncryptConfig = Boolean.valueOf(checkOjbEncryptConfigValue).booleanValue();
   }
   execute(attributesToEncryptPropertyFileName, checkOjbEncryptConfig);
   response
       .getOutputStream()
       .write(
           ("<html><body><p>Successfully encrypted attributes as defined in: "
                   + attributesToEncryptPropertyFileName
                   + "</p></body></html>")
               .getBytes());
 }
  /**
   * @see {@link ExternalContext#getResponseOutputStream()}
   * @since JSF 2.0
   */
  @Override
  public OutputStream getResponseOutputStream() throws IOException {

    if (portletResponse instanceof MimeResponse) {

      if (facesImplementationServletResponse != null) {
        logger.debug(
            "Delegating to AFTER_VIEW_CONTENT servletResponse=[{0}]",
            facesImplementationServletResponse);

        return facesImplementationServletResponse.getOutputStream();
      } else {
        MimeResponse mimeResponse = (MimeResponse) portletResponse;

        return mimeResponse.getPortletOutputStream();
      }
    } else {

      if (manageIncongruities) {
        return incongruityContext.getResponseOutputStream();
      } else {
        throw new IllegalStateException();
      }
    }
  }
Пример #7
0
 // --> /demo/getAudio/getAudio
 @RequestMapping(value = "/getAudio", method = RequestMethod.GET)
 @ResponseBody
 public void getAudio(ServletResponse response) throws IOException {
   File imageFile = new File("E:\\My Music\\Nhac Chuong\\Sinbad.mp3");
   byte[] byteArray = IOUtils.toByteArray(new FileInputStream(imageFile));
   response.setContentType("audio/mpeg");
   response.getOutputStream().write(byteArray);
 }
Пример #8
0
 // --> /demo/getAudio/getImage
 @RequestMapping(value = "/getImage", method = RequestMethod.GET)
 @ResponseBody
 public void getImage(ServletResponse response) throws IOException {
   File imageFile = new File("E:\\Hinh Anh\\WP_000337.png");
   byte[] byteArray = IOUtils.toByteArray(new FileInputStream(imageFile));
   response.setContentType("image/png");
   response.getOutputStream().write(byteArray);
 }
Пример #9
0
  public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
      throws IOException, ServletException {
    if (null != request.getAttribute("FLAG")) {
      chain.doFilter(request, response);
      return;
    }
    request.setAttribute("FLAG", FLAG);

    String encoding = this.encoding;
    HttpServletRequest req = (HttpServletRequest) request;
    HttpServletResponse res = (HttpServletResponse) response;
    String resourcePath = req.getServletPath();
    RequestContext requestContext =
        new RequestContext(config.getServletContext(), req, resourcePath);
    request.setAttribute("context", requestContext);

    for (Decorator decorator : decorators) {
      int returned = decorator.parseRequest(req, res, requestContext);
      switch (returned) {
        case Decorator.OK:
          // do nothing
          break;
        case Decorator.REDIRECT:
          res.sendRedirect(requestContext.getResourcePath());
          return;
        case Decorator.MOVED_PERMANENTLY:
          res.setStatus(HttpServletResponse.SC_MOVED_PERMANENTLY);
          res.setHeader("Location", requestContext.getResourcePath());
          return;
        default:
          // do nothing
      }
    }

    if (pattern.matcher(requestContext.getResourcePath()).matches()) {
      WebContent content = new WebContent();
      if (requestContext.getResourcePath().startsWith("/WEB-INF/admin/")) {
        encoding = "UTF-8";
      }
      ByteArrayResponseWrapper wrapper = new ByteArrayResponseWrapper(res);
      request.getRequestDispatcher(requestContext.getResourcePath()).include(req, wrapper);
      wrapper.finish();
      content.setWholeContent(wrapper.getString(encoding));
      response.setContentType(wrapper.getContentType());
      content.finish();

      for (Decorator decorator : decorators) {
        decorator.decorate(requestContext, content, content);
        content.finish();
      }
      byte[] theContent = content.toString().getBytes(encoding);
      response.setContentLength(theContent.length);
      response.getOutputStream().write(theContent);
      return;
    }
    request.getRequestDispatcher(requestContext.getResourcePath()).forward(req, res);
  }
Пример #10
0
  /**
   * @param pServletRequest parameter
   * @param pServletResponse parameter
   * @throws IOException exception
   * @throws ServletException exception
   */
  @Override
  public void handleService(ServletRequest pServletRequest, ServletResponse pServletResponse)
      throws IOException, ServletException {
    final ByteArrayOutputStream pdf = new ByteArrayOutputStream();
    final String deliveryId = pServletRequest.getParameter(DELIVERY_ID_PARAM);
    RepositoryItem orderBOItem = mOrderManager.getFactureBO(deliveryId);
    OutputStream out = null;

    if (orderBOItem != null) {
      RepositoryItem orderFOItem = mOrderManager.getOrderFO(orderBOItem);
      String profileId =
          (String) orderFOItem.getPropertyValue(CastoConstantesOrders.ORDER_PROPERTY_PROFILEID);
      String currProfileId = getProfileServices().getCurrentProfileId();
      if (!currProfileId.equalsIgnoreCase(profileId)) {
        if (isLoggingError()) {
          logError(
              "Facture with id="
                  + deliveryId
                  + " doesn't belong to profile with id="
                  + currProfileId);
        }
        return;
      }

      Map params = new HashMap();
      params.put(
          "url",
          pServletRequest.getScheme()
              + "://"
              + pServletRequest.getServerName()
              + ":"
              + pServletRequest.getServerPort());

      try {
        PrintPdfHelper.getInstance().generateInvoicePdf(pdf, orderBOItem, params, mCountryList);

        // Set header
        pServletResponse.setContentType(CONTENT_TYPE_PDF);
        pServletResponse.setContentLength(pdf.size());

        out = pServletResponse.getOutputStream();
        pdf.writeTo(out);
        out.flush();
      } catch (IOException e) {
        logError(e);
      } finally {
        if (out != null) {
          out.close();
        }
      }
    } else {
      logError("Facture with id=" + deliveryId + " was not found.");
    } // end if-else
  }
 protected void writeData(ServletResponse response, String data) throws IOException {
   idleCheck.activity();
   Log.debug("Session[" + session.getSessionId() + "]: writeData(START): " + data);
   ServletOutputStream os = response.getOutputStream();
   os.println("Content-Type: text/plain");
   os.println();
   os.println(data);
   os.println(boundarySeperator);
   response.flushBuffer();
   Log.debug("Session[" + session.getSessionId() + "]: writeData(END): " + data);
 }
 @Override
 public void doFilter(
     ServletRequest servletRequest, ServletResponse servletResponse, FilterChain chain)
     throws IOException, ServletException {
   HttpServletRequest request = (HttpServletRequest) servletRequest;
   HttpServletResponse response = (HttpServletResponse) servletResponse;
   checkOutput:
   {
     if (!configurer.determineEnvironment().equals(configurer.getDefaultEnvironment())
         || useWhileInDefaultEnvironment) {
       String path = getResourcePath(request);
       String gzipPath = path + ".gz";
       if (useGzipCompression(request, response, path, gzipPath)) {
         File output = new File(getServletContext().getRealPath(gzipPath));
         if (output.exists()) {
           response.addHeader("Content-Encoding", "gzip");
           ServletOutputStream sos = servletResponse.getOutputStream();
           BufferedInputStream bis = null;
           try {
             bis = new BufferedInputStream(new FileInputStream(output));
             boolean eof = false;
             while (!eof) {
               int temp = bis.read();
               if (temp < 0) {
                 eof = true;
               } else {
                 sos.write(temp);
               }
             }
           } finally {
             sos.flush();
             try {
               if (bis != null) {
                 bis.close();
               }
             } catch (Exception e) {
               // do nothing
             }
           }
           break checkOutput;
         }
       }
     }
     chain.doFilter(request, response);
   }
 }
Пример #13
0
  public void service(ServletRequest req, ServletResponse res)
      throws ServletException, IOException {
    List list = (List) ((HttpServletRequest) req).getSession().getAttribute("regionhistoryinfo");
    String historydate =
        (String) ((HttpServletRequest) req).getSession().getAttribute("mystatdate");

    res.setContentType("image/jpeg");
    String title = null;
    if (list.size() == 0) {
      logger.info("list is null");
    } else {
      title = historydate + "各地市短信发送情况显示图";
      JFreeChart jfreechart = createChart(getDataSet(list), title);
      int width = 700;
      int height = 490;
      Font font = new Font("黑体", Font.CENTER_BASELINE, 12);
      ChartUtilities.writeChartAsJPEG(res.getOutputStream(), 1.0f, jfreechart, width, height, null);
    }
  }
Пример #14
0
 @Override
 public void service(
     javax.servlet.ServletRequest servletRequest, javax.servlet.ServletResponse servletResponse)
     throws ServletException, IOException {
   HttpServletRequest req = (HttpServletRequest) servletRequest;
   HttpServletResponse resp = (HttpServletResponse) servletResponse;
   try {
     setThreadlocals(req, resp);
     tlServletConfig.set(config);
     Request request = new ServletRequest(req, servletContext);
     Response response = new ServletResponse(resp);
     httpManager.process(request, response);
   } finally {
     clearThreadlocals();
     tlServletConfig.remove();
     ServletRequest.clearThreadLocals();
     servletResponse.getOutputStream().flush();
     servletResponse.flushBuffer();
   }
 }
Пример #15
0
  @Override
  public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
      throws IOException, ServletException {
    HttpServletResponse response = (HttpServletResponse) res;
    response.setContentType("image/png");
    response.setHeader("Pragma", "No-cache");
    response.setHeader("Cache-Control", "no-cache");
    response.setDateHeader("Expire", 0);
    try {
      Session session = SecurityUtils.getSubject().getSession();

      String token =
          EncoderHelper.getChallangeAndWriteImage(captchaService, "png", res.getOutputStream());
      session.removeAttribute(KEY_CAPTCHA);
      session.setAttribute(KEY_CAPTCHA, token);

    } catch (Exception e) {
      e.printStackTrace();
    }
  }
Пример #16
0
  public void service(ServletRequest request, ServletResponse response)
      throws ServletException, IOException {

    ServletOutputStream sos = null;

    try {
      sos = response.getOutputStream();

      // set buffer size
      response.setBufferSize(FAILED.length() * 2);

      // Write some data to the stream
      sos.println(FAILED);

      // Reset the response
      response.reset();
      sos.println(PASSED);
    } catch (IllegalStateException e) {
      throw e;
    }
  }
Пример #17
0
  @Override
  public void service(ServletRequest request, ServletResponse response)
      throws ServletException, IOException {

    String mitabUrl = request.getParameter("mitabUrl");

    String url = mitabUrl.substring(0, mitabUrl.lastIndexOf("/"));
    String query = mitabUrl.substring(mitabUrl.lastIndexOf("/"));

    if (query != null) {
      query = UrlUtils.encodeUrl(query);

      String encodedUrl = url + query;

      if (log.isDebugEnabled()) log.debug("encodedUrl: " + encodedUrl);

      final URL inputUrl = new URL(encodedUrl);
      final InputStream is = inputUrl.openStream();

      ServletOutputStream stream = response.getOutputStream();
      try {
        response.setContentType("text/plain");

        final Tab2Cytoscapeweb tab2Cytoscapeweb = new Tab2Cytoscapeweb();

        String output = null;
        try {
          output = tab2Cytoscapeweb.convert(is);
        } catch (PsimiTabException e) {
          throw new IllegalStateException("Could not parse input MITAB.", e);
        }
        stream.write(output.getBytes());
        stream.flush();
      } finally {
        is.close();
      }
    }
  } // We don't have url
Пример #18
0
  /** @see javax.faces.context.ExternalContext#getResponseOutputStream() */
  @Override
  public OutputStream getResponseOutputStream() throws IOException {

    return response.getOutputStream();
  }
Пример #19
0
  @Override
  public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
      throws IOException, ServletException {

    HttpServletRequest httpRequest = (HttpServletRequest) request;
    HttpServletResponse httpResponse = (HttpServletResponse) response;

    if (!isIncluded(httpRequest) && acceptsGZipEncoding(httpRequest) && !response.isCommitted()) {
      // Client accepts zipped content
      if (log.isTraceEnabled()) {
        log.trace("{} Written with gzip compression", httpRequest.getRequestURL());
      }

      // Create a gzip stream
      final ByteArrayOutputStream compressed = new ByteArrayOutputStream();
      final GZIPOutputStream gzout = new GZIPOutputStream(compressed);

      // Handle the request
      final GZipServletResponseWrapper wrapper =
          new GZipServletResponseWrapper(httpResponse, gzout);
      wrapper.setDisableFlushBuffer(true);
      chain.doFilter(request, wrapper);
      wrapper.flush();

      gzout.close();

      // double check one more time before writing out
      // repsonse might have been committed due to error
      if (response.isCommitted()) {
        return;
      }

      // return on these special cases when content is empty or unchanged
      switch (wrapper.getStatus()) {
        case HttpServletResponse.SC_NO_CONTENT:
        case HttpServletResponse.SC_RESET_CONTENT:
        case HttpServletResponse.SC_NOT_MODIFIED:
          return;
        default:
      }

      // Saneness checks
      byte[] compressedBytes = compressed.toByteArray();
      boolean shouldGzippedBodyBeZero =
          GZipResponseUtil.shouldGzippedBodyBeZero(compressedBytes, httpRequest);
      boolean shouldBodyBeZero =
          GZipResponseUtil.shouldBodyBeZero(httpRequest, wrapper.getStatus());
      if (shouldGzippedBodyBeZero || shouldBodyBeZero) {
        // No reason to add GZIP headers or write body if no content was written or status code
        // specifies no
        // content
        response.setContentLength(0);
        return;
      }

      // Write the zipped body
      GZipResponseUtil.addGzipHeader(httpResponse);

      response.setContentLength(compressedBytes.length);

      response.getOutputStream().write(compressedBytes);

    } else {
      // Client does not accept zipped content - don't bother zipping
      if (log.isTraceEnabled()) {
        log.trace(
            "{} Written without gzip compression because the request does not accept gzip",
            httpRequest.getRequestURL());
      }
      chain.doFilter(request, response);
    }
  }
Пример #20
0
 /**
  * Writes the given object as response body to the servlet response
  *
  * <p>The content type will be set to {@link HttpConstants#CONTENT_TYPE_JAVA_SERIALIZED_OBJECT}
  *
  * @param response servlet response
  * @param target object to write
  * @throws IOException is thrown if error writing
  */
 public static void writeObjectToServletResponse(ServletResponse response, Object target)
     throws IOException {
   response.setContentType(HttpConstants.CONTENT_TYPE_JAVA_SERIALIZED_OBJECT);
   writeObjectToStream(response.getOutputStream(), target);
 }
Пример #21
0
 protected void writeJSON(JSONObject object, ServletResponse resp) throws IOException {
   resp.setContentType("application/json");
   OutputStreamWriter writer = new OutputStreamWriter(resp.getOutputStream(), "utf-8");
   writer.write(object.toString());
   writer.flush();
 }
Пример #22
0
 public ServletOutputStream getOutputStream() throws IOException {
   return response.getOutputStream();
 }
 public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
     throws IOException, ServletException {
   chain.doFilter(request, response);
   ServletOutputStream os = response.getOutputStream();
   os.print("Hello");
 }
  @Override
  public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
      throws IOException, ServletException {

    HttpServletRequest request = (HttpServletRequest) req;

    String requestPath;
    if (request.getQueryString() == null) {
      requestPath = request.getRequestURI();
    } else {
      requestPath = request.getRequestURI() + "?" + request.getQueryString();
    }

    String key = null;
    String keyFromHeader = request.getHeader("API-Key");
    String keyFromParam = request.getParameter("api_key");

    if (keyFromHeader == keyFromParam) {
      key = keyFromHeader;
    } else {

      if (keyFromHeader == null) {
        key = keyFromParam;
      } else if (keyFromParam == null) {
        key = keyFromHeader;
      } else {
        // Keys don't match. Don't continue.
        ErrorJSONObject errorObj =
            new ErrorJSONObject(
                "API key presented in Header does not match API key presented as URL Parameter.");
        ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
        String json = ow.writeValueAsString(errorObj);
        res.getOutputStream().write(json.getBytes());
      }
    }

    if (key == null) {
      for (int i = 0; i < ALLOWED_REQUEST_PATHS.length; i++) {
        if (request.getServletPath().matches(ALLOWED_REQUEST_PATHS[i])) {
          chain.doFilter(req, res); // continue
          return;
        }
      }

      // No Key. Don't continue.
      ErrorJSONObject errorObj =
          new ErrorJSONObject("API key must be presented in order to use this API");
      ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
      String json = ow.writeValueAsString(errorObj);
      res.getOutputStream().write(json.getBytes());

    } else {

      ApiKeyDTO retrievedKey = apiKeyManager.findKey(key);

      if (retrievedKey == null) {
        // Invalid key. Don't continue.
        ErrorJSONObject errorObj = new ErrorJSONObject("Invalid API Key");
        ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
        String json = ow.writeValueAsString(errorObj);
        res.getOutputStream().write(json.getBytes());
      } else {
        try {
          apiKeyManager.logApiKeyActivity(key, requestPath);
        } catch (EntityCreationException e) {
          throw new ServletException(e);
        }
        chain.doFilter(req, res); // continue
      }
    }
  }
  @Override
  public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)
      throws IOException, ServletException {
    if (req instanceof HttpServletRequest && resp instanceof HttpServletResponse) {
      HttpServletRequest httpReq = ((HttpServletRequest) req);
      HttpServletResponse httpResp = ((HttpServletResponse) resp);

      String requestEnrichment = httpReq.getHeader(ENRICHMENT_REQUEST);

      if (requestEnrichment != null && !"null".equals(requestEnrichment)) {

        final AtomicReference<NonWritingServletOutputStream> stream =
            new AtomicReference<NonWritingServletOutputStream>();
        final AtomicReference<NonWritingPrintWriter> writer =
            new AtomicReference<NonWritingPrintWriter>();

        HttpServletResponseWrapper responseWrapper =
            new HttpServletResponseWrapper((HttpServletResponse) resp) {
              @Override
              public ServletOutputStream getOutputStream() throws IOException {
                stream.set(new NonWritingServletOutputStream());
                return stream.get();
              }

              @Override
              public PrintWriter getWriter() throws IOException {
                writer.set(NonWritingPrintWriter.newInstance());
                return writer.get();
              }
            };

        String responseEnrichment = "null";

        try {
          RequestPayload requestPayload =
              SerializationUtils.deserializeFromBase64(requestEnrichment);
          ServerAssertion serverAssertion = requestPayload.getAssertion();

          ManagerBuilder builder =
              ManagerBuilder.from().extension(Class.forName(DEFAULT_EXTENSION_CLASS));
          Manager manager = builder.create();
          manager.start();
          manager.bind(ApplicationScoped.class, Manager.class, manager);
          manager.inject(this);

          req.setAttribute(
              WarpCommons.LIFECYCLE_MANAGER_STORE_REQUEST_ATTRIBUTE, lifecycleManagerStore);

          manager.fire(new BeforeSuite());
          manager.fire(new BeforeRequest(req));
          lifecycleManagerStore.get().bind(ServletRequest.class, req);

          assertionRegistry.get().registerAssertion(serverAssertion);

          lifecycleManager.get().fireLifecycleEvent(new BeforeServletEvent());

          try {
            chain.doFilter(req, responseWrapper);

            lifecycleManager.get().fireLifecycleEvent(new AfterServletEvent());

            // request successfully finished
            TestResult firstFailedResult = testResultStore.get().getFirstFailed();
            if (firstFailedResult == null) {
              ResponsePayload responsePayload = new ResponsePayload(serverAssertion);
              responseEnrichment = SerializationUtils.serializeToBase64(responsePayload);
              httpResp.setHeader(ENRICHMENT_RESPONSE, responseEnrichment);
            } else {
              Throwable throwable = firstFailedResult.getThrowable();
              if (throwable instanceof InvocationTargetException) {
                throwable = throwable.getCause();
              }
              ResponsePayload responsePayload = new ResponsePayload(throwable);
              enrichResponse(httpResp, responsePayload);
            }
          } catch (Exception e) {
            log.log(Level.SEVERE, "The error occured during request execution", e);
            throw e;
          } finally {
            assertionRegistry.get().unregisterAssertion(serverAssertion);

            lifecycleManagerStore.get().unbind(ServletRequest.class, req);
            manager.fire(new AfterRequest(req));
            manager.fire(new AfterSuite());
          }

        } catch (Throwable e) {
          // exception occured during request execution
          ResponsePayload responsePayload = new ResponsePayload(e);
          responseEnrichment = SerializationUtils.serializeToBase64(responsePayload);
          httpResp.setHeader(ENRICHMENT_RESPONSE, responseEnrichment);
          httpResp.sendError(500);
        }

        if (writer.get() != null) {
          writer.get().finallyWriteAndClose(resp.getOutputStream());
        }
        if (stream.get() != null) {
          stream.get().finallyWriteAndClose(resp.getOutputStream());
        }

        return;
      }
    }

    chain.doFilter(req, resp);
  }
Пример #26
0
 public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
     throws IOException, ServletException {
   HttpServletRequest request = (HttpServletRequest) req;
   HttpServletResponse response = (HttpServletResponse) res;
   String r = sc.getRealPath("");
   String path = fc.getInitParameter(request.getRequestURI());
   if (path != null && path.equals("nocache")) {
     chain.doFilter(request, response);
     return;
   }
   path = r + path;
   String id = request.getRequestURI() + request.getQueryString();
   String localeSensitive = fc.getInitParameter("locale-sensitive");
   if (localeSensitive != null) {
     StringWriter ldata = new StringWriter();
     Enumeration locales = request.getLocales();
     while (locales.hasMoreElements()) {
       Locale locale = (Locale) locales.nextElement();
       ldata.write(locale.getISO3Language());
     }
     id = id + ldata.toString();
   }
   File tempDir = (File) sc.getAttribute("javax.servlet.context.tempdir");
   String temp = tempDir.getAbsolutePath();
   File file = new File(temp + id);
   if (path == null) {
     path = sc.getRealPath(request.getRequestURI());
   }
   File current = new File(path);
   try {
     long now = Calendar.getInstance().getTimeInMillis();
     if (!file.exists()
         || (file.exists() && current.lastModified() > file.lastModified())
         || cacheTimeout < now - file.lastModified()) {
       String name = file.getAbsolutePath();
       name = name.substring(0, name.lastIndexOf("/") == -1 ? 0 : name.lastIndexOf("/"));
       new File(name).mkdirs();
       ByteArrayOutputStream baos = new ByteArrayOutputStream();
       CacheResponseWrapper wrappedResponse = new CacheResponseWrapper(response, baos);
       chain.doFilter(req, wrappedResponse);
       FileOutputStream fos = new FileOutputStream(file);
       fos.write(baos.toByteArray());
       fos.flush();
       fos.close();
     }
   } catch (ServletException e) {
     if (!file.exists()) {
       throw new ServletException(e);
     }
   } catch (IOException e) {
     if (!file.exists()) {
       throw e;
     }
   }
   FileInputStream fis = new FileInputStream(file);
   String mt = sc.getMimeType(request.getRequestURI());
   response.setContentType(mt);
   ServletOutputStream sos = res.getOutputStream();
   for (int i = fis.read(); i != -1; i = fis.read()) {
     sos.write((byte) i);
   }
 }
Пример #27
0
 @Override
 public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
     throws IOException, ServletException {
   response.getOutputStream().println("Extra Info");
   chain.doFilter(request, response);
 }
Пример #28
0
  public void service(ServletRequest request, ServletResponse response) {
    int font;
    pdflib p = null;
    int i, blockcontainer, page;
    String infile = "boilerplate.pdf";
    /* This is where font/image/PDF input files live. Adjust as necessary.
     *
     * Note that this directory must also contain the LuciduxSans font
     * outline and metrics files.
     */
    String searchpath = "../data";
    String[][] data = {
      {"name", "Victor Kraxi"},
      {"business.title", "Chief Paper Officer"},
      {"business.address.line1", "17, Aviation Road"},
      {"business.address.city", "Paperfield"},
      {"business.telephone.voice", "phone +1 234 567-89"},
      {"business.telephone.fax", "fax +1 234 567-98"},
      {"business.email", "*****@*****.**"},
      {"business.homepage", "www.kraxi.com"},
    };
    byte[] buf;
    ServletOutputStream out;

    try {
      p = new pdflib();

      // Generate a PDF in memory; insert a file name to create PDF on disk
      if (p.begin_document("", "") == -1) {
        throw new Exception("Error: " + p.get_errmsg());
      }

      /*Set the search path for fonts and PDF files */
      p.set_parameter("SearchPath", searchpath);

      p.set_info("Creator", "businesscard.java");
      p.set_info("Author", "Thomas Merz");
      p.set_info("Title", "PDFlib block processing sample (Java)");

      blockcontainer = p.open_pdi(infile, "", 0);
      if (blockcontainer == -1) {
        throw new Exception("Error: " + p.get_errmsg());
      }

      page = p.open_pdi_page(blockcontainer, 1, "");
      if (page == -1) {
        throw new Exception("Error: " + p.get_errmsg());
      }

      p.begin_page_ext(20, 20, ""); // dummy page size

      // This will adjust the page size to the block container's size.
      p.fit_pdi_page(page, 0, 0, "adjustpage");

      // Fill all text blocks with dynamic data
      for (i = 0; i < (int) data.length; i++) {
        if (p.fill_textblock(page, data[i][0], data[i][1], "embedding encoding=unicode") == -1) {
          System.err.println("Warning: " + p.get_errmsg());
        }
      }

      p.end_page_ext(""); // close page
      p.close_pdi_page(page);

      p.end_document(""); // close PDF document
      p.close_pdi(blockcontainer);

      buf = p.get_buffer();

      response.setContentType("application/pdf");
      response.setContentLength(buf.length);

      out = response.getOutputStream();
      out.write(buf);
      out.close();

    } catch (PDFlibException e) {
      System.err.print("PDFlib exception occurred in businesscard sample:\n");
      System.err.print(
          "[" + e.get_errnum() + "] " + e.get_apiname() + ": " + e.get_errmsg() + "\n");
    } catch (Exception e) {
      System.err.println(e.getMessage());
    } finally {
      if (p != null) {
        p.delete(); /* delete the PDFlib object */
      }
    }
  }