Java HttpServletResponse.SC_OK属性代码示例

/**
 * Return a snapshot of the console.
 * 
 * @param subscription
 *            the valid screenshot of the console.
 * @return the valid screenshot of the console.
 */
@GET
@Path("{subscription:\\d+}/console.png")
@Produces("image/png")
public StreamingOutput getConsole(@PathParam("subscription") final int subscription) {
	final Map<String, String> parameters = subscriptionResource.getParameters(subscription);
	final VCloudCurlProcessor processor = new VCloudCurlProcessor();
	authenticate(parameters, processor);

	// Get the screen thumbnail
	return output -> {
		final String url = StringUtils.appendIfMissing(parameters.get(PARAMETER_API), "/") + "vApp/vm-" + parameters.get(PARAMETER_VM)
				+ "/screen";
		final CurlRequest curlRequest = new CurlRequest("GET", url, null, (request, response) -> {
			if (response.getStatusLine().getStatusCode() == HttpServletResponse.SC_OK) {
				// Copy the stream
				IOUtils.copy(response.getEntity().getContent(), output);
				output.flush();
			}
			return false;
		});
		processor.process(curlRequest);
	};
}
 

/**
 *
 * @param httpURLConnection
 *            {@link HttpURLConnection}
 * @return HTTPResponse the http response
 * @throws IOException
 *             IOException from java.net
 */
protected HTTPResponse resultConnection(final HttpURLConnection httpURLConnection) throws IOException {
	final HTTPResponse ret = new HTTPResponse();

	ret.setResponseCode(httpURLConnection.getResponseCode());
	ret.setFinalURL(httpURLConnection.getURL());

	InputStream retStream;

	if (HttpServletResponse.SC_OK <= ret.getResponseCode()
			&& ret.getResponseCode() < HttpServletResponse.SC_BAD_REQUEST) {
		retStream = httpURLConnection.getInputStream();
	} else {
		retStream = httpURLConnection.getErrorStream();
	}
	ret.setContent(inputStreamToByte(retStream));

	fillHttpResponseHeader(ret, httpURLConnection.getHeaderFields());

	return ret;
}
 

@Override
public void doFilter(ServletRequest request, ServletResponse response,
    FilterChain filterChain) throws IOException, ServletException {
  KMSResponse kmsResponse = new KMSResponse(response);
  super.doFilter(request, kmsResponse, filterChain);

  if (kmsResponse.statusCode != HttpServletResponse.SC_OK &&
      kmsResponse.statusCode != HttpServletResponse.SC_CREATED &&
      kmsResponse.statusCode != HttpServletResponse.SC_UNAUTHORIZED) {
    KMSWebApp.getInvalidCallsMeter().mark();
  }

  // HttpServletResponse.SC_UNAUTHORIZED is because the request does not
  // belong to an authenticated user.
  if (kmsResponse.statusCode == HttpServletResponse.SC_UNAUTHORIZED) {
    KMSWebApp.getUnauthenticatedCallsMeter().mark();
    String method = ((HttpServletRequest) request).getMethod();
    StringBuffer requestURL = ((HttpServletRequest) request).getRequestURL();
    String queryString = ((HttpServletRequest) request).getQueryString();
    if (queryString != null) {
      requestURL.append("?").append(queryString);
    }

    KMSWebApp.getKMSAudit().unauthenticated(
        request.getRemoteHost(), method, requestURL.toString(),
        kmsResponse.msg);
  }
}
 

public void doTestNonLogin(String uri, boolean useCookie,
            int expectedRC) throws Exception {

        Map<String,List<String>> reqHeaders =
                new HashMap<String,List<String>>();
        Map<String,List<String>> respHeaders =
                new HashMap<String,List<String>>();

        if (useCookie && (cookies != null)) {
            reqHeaders.put(CLIENT_COOKIE_HEADER, cookies);
        }

        ByteChunk bc = new ByteChunk();
        int rc = getUrl(HTTP_PREFIX + getPort() + uri, bc, reqHeaders,
                respHeaders);

        if (expectedRC != HttpServletResponse.SC_OK) {
            assertEquals(expectedRC, rc);
            assertTrue(bc.getLength() > 0);
        }
        else {
            assertEquals("OK", bc.toString());
        }
}
 

/**
    * Clean return of Exception in JSon format & log Exception.
    * @param request
    * @param response
    * @param out
    * @param exception
    */
   public static void logAndReturnException(HttpServletRequest request, HttpServletResponse response, OutputStream out, Exception exception) {
try {

    JsonErrorReturn jsonErrorReturn = new JsonErrorReturn(
	    response,
	    HttpServletResponse.SC_OK,
	    JsonErrorReturn.ERROR_ACEQL_ERROR, exception.getMessage(), ExceptionUtils.getStackTrace(exception));

    ServerSqlManager.writeLine(out, jsonErrorReturn.build());
    LoggerUtil.log(request, exception);
    
} catch (Exception e) {
    // Should never happen
    e.printStackTrace();
}
   }
 

private void doTestNonLogin(String uri, boolean useCookie,
        int expectedRC) throws Exception {

    Map<String,List<String>> reqHeaders =
            new HashMap<String,List<String>>();
    Map<String,List<String>> respHeaders =
            new HashMap<String,List<String>>();

    if (useCookie && (cookies != null)) {
        reqHeaders.put(CLIENT_COOKIE_HEADER, cookies);
    }

    ByteChunk bc = new ByteChunk();
    int rc = getUrl(HTTP_PREFIX + getPort() + uri, bc, reqHeaders,
            respHeaders);

    if (expectedRC != HttpServletResponse.SC_OK) {
        assertEquals(expectedRC, rc);
        assertTrue(bc.getLength() > 0);
    }
    else {
        assertEquals("OK", bc.toString());
    }
}
 

@Override
public void onError(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse,
                    Throwable exception, Span span) {
    Tags.ERROR.set(span, Boolean.TRUE);
    span.log(logsForException(exception));

    if (httpServletResponse.getStatus() == HttpServletResponse.SC_OK) {
        // exception is thrown in filter chain, but status code is incorrect
        Tags.HTTP_STATUS.set(span, 500);
    }
}
 

@Operation("move")
@WebApiDescription(title = "Move Node",
        description="Moves one or more nodes (files or folders) to a new target folder, with option to rename.",
        successStatus = HttpServletResponse.SC_OK)
public Node moveById(String nodeId, NodeTarget target, Parameters parameters, WithResponse withResponse)
{
    return nodes.moveOrCopyNode(nodeId, target.getTargetParentId(), target.getName(), parameters, false);
}
 

private void assertPageContains(String pageUrl, String expectedBody,
        int expectedStatus) throws IOException {
    ByteChunk res = new ByteChunk();
    int sc = getUrl("http://localhost:" + getPort() + pageUrl, res, null);

    Assert.assertEquals(expectedStatus, sc);

    if (expectedStatus == HttpServletResponse.SC_OK) {
        String result = res.toString();
        Assert.assertTrue(result, result.indexOf(expectedBody) > -1);
    }
}
 

@Operation("lock")
@WebApiDescription(title = "Lock Node",
        description="Places a lock on a node.",
        successStatus = HttpServletResponse.SC_OK)
public Node lock(String nodeId, LockInfo lockInfo, Parameters parameters, WithResponse withResponse)
{
    return nodes.lock(nodeId, lockInfo, parameters);
}
 

private void doTestBasic(String uri,
        TestSSOnonLoginAndBasicAuthenticator.BasicCredentials credentials,
        boolean useCookie, int expectedRC) throws Exception {

    Map<String,List<String>> reqHeaders = new HashMap<String,List<String>>();
    Map<String,List<String>> respHeaders = new HashMap<String,List<String>>();

    if (useCookie && (cookies != null)) {
        reqHeaders.put(CLIENT_COOKIE_HEADER, cookies);
    }
    else {
        if (credentials != null) {
            List<String> auth = new ArrayList<String>();
            auth.add(credentials.getCredentials());
            reqHeaders.put(CLIENT_AUTH_HEADER, auth);
        }
    }

    ByteChunk bc = new ByteChunk();
    int rc = getUrl(HTTP_PREFIX + getPort() + uri, bc, reqHeaders,
            respHeaders);

    assertEquals("Unexpected Return Code", expectedRC, rc);
    if (expectedRC != HttpServletResponse.SC_OK) {
        assertTrue(bc.getLength() > 0);
        if (expectedRC == HttpServletResponse.SC_UNAUTHORIZED) {
            // The server should identify the acceptable method(s)
            boolean methodFound = false;
            List<String> authHeaders = respHeaders.get(SERVER_AUTH_HEADER);
            for (String authHeader : authHeaders) {
                if (authHeader.indexOf(NICE_METHOD) > -1) {
                    methodFound = true;
                    break;
                }
            }
            assertTrue(methodFound);
        }
    }
    else {
        String thePage = bc.toString();
        assertNotNull(thePage);
        assertTrue(thePage.startsWith("OK"));
        if (useCookie) {
            List<String> newCookies = respHeaders.get(SERVER_COOKIE_HEADER);
            if (newCookies != null) {
                // harvest cookies whenever the server sends some new ones
                cookies = newCookies;
            }
        }
        else {
            encodedURL = "";
            final String start = "<a href=\"";
            final String end = "\">";
            int iStart = thePage.indexOf(start);
            int iEnd = 0;
            if (iStart > -1) {
                iStart += start.length();
                iEnd = thePage.indexOf(end, iStart);
                if (iEnd > -1) {
                    encodedURL = thePage.substring(iStart, iEnd);
                }
            }
        }
    }
}
 

private void doTestBasic(String uri, BasicCredentials credentials,
        boolean useCookie, int expectedRC) throws Exception {

    Map<String,List<String>> reqHeaders =
            new HashMap<String, List<String>>();
    Map<String,List<String>> respHeaders =
            new HashMap<String, List<String>>();

    if (useCookie && (cookies != null)) {
        reqHeaders.put(CLIENT_COOKIE_HEADER, cookies);
    }
    else {
        if (credentials != null) {
            List<String> auth = new ArrayList<String>();
            auth.add(credentials.getCredentials());
            reqHeaders.put(CLIENT_AUTH_HEADER, auth);
        }
    }

    ByteChunk bc = new ByteChunk();
    int rc = getUrl(HTTP_PREFIX + getPort() + uri, bc, reqHeaders,
            respHeaders);

    if (expectedRC != HttpServletResponse.SC_OK) {
        assertEquals(expectedRC, rc);
        assertTrue(bc.getLength() > 0);
        if (expectedRC == HttpServletResponse.SC_UNAUTHORIZED) {
            // The server should identify the acceptable method(s)
            boolean methodFound = false;
            List<String> authHeaders = respHeaders.get(SERVER_AUTH_HEADER);
            for (String authHeader : authHeaders) {
                if (authHeader.indexOf(NICE_METHOD) > -1) {
                    methodFound = true;
                    break;
                }
            }
            assertTrue(methodFound);
        }
    }
    else {
        assertEquals("OK", bc.toString());
        List<String> newCookies = respHeaders.get(SERVER_COOKIE_HEADER);
        if (newCookies != null) {
            // harvest cookies whenever the server sends some new ones
            cookies = newCookies;
        }
    }
}
 

private void validateStatusCode(SimpleHttpResponse httpResponse) throws InvalidResponseException {
    final int statusCode = httpResponse.getResponseCode();
    if (statusCode == HttpServletResponse.SC_OK) {
        return;
    }

    String errMessage = getErrorMessageByStatusCode(httpResponse.getRequestPath(), statusCode);
    errMessage += MessageFormat.format(ERROR_SERVICE_RETURN, statusCode, httpResponse.getResponseMessage());

    throw new InvalidResponseException(errMessage);
}
 

/**
 * Release all object references, and initialize instance variables, in
 * preparation for reuse of this object.
 */
public void recycle() {

    super.recycle();
    cookies.clear();
    headers.clear();
    message = getStatusMessage(HttpServletResponse.SC_OK);
    status = HttpServletResponse.SC_OK;

}
 

/**
 * Clear any content written to the buffer.  In addition, all cookies
 * and headers are cleared, and the status is reset.
 *
 * @exception IllegalStateException if this response has already
 *  been committed
 */
public void reset() {

    if (included)
        return;     // Ignore any call from an included servlet

    super.reset();
    cookies.clear();
    headers.clear();
    message = null;
    status = HttpServletResponse.SC_OK;

}