Example usage for com.google.common.net HttpHeaders LOCATION

List of usage examples for com.google.common.net HttpHeaders LOCATION

Introduction

In this page you can find the example usage for com.google.common.net HttpHeaders LOCATION.

Prototype

String LOCATION

To view the source code for com.google.common.net HttpHeaders LOCATION.

Click Source Link

Document

The HTTP Location header field name.

Usage

From source file:org.haiku.haikudepotserver.support.web.FallbackController.java

private void redirectToPkg(HttpServletResponse response, String term) throws IOException {
    ObjectContext context = serverRuntime.newContext();

    Optional<PkgVersion> pkgVersionOptional = tryGetPkgVersion(context, term);

    if (pkgVersionOptional.isPresent()) {
        UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(baseUrl).pathSegment("#!", "pkg");
        pkgVersionOptional.get().appendPathSegments(builder);
        UriComponents uriComponents = builder.build();

        response.setStatus(HttpServletResponse.SC_MOVED_TEMPORARILY);
        response.setHeader(HttpHeaders.LOCATION, uriComponents.toUriString());

        PrintWriter w = response.getWriter();
        w.format("redirecting to; %s", uriComponents.toUriString());
        w.flush();//from   www  . j a  v  a 2s .  c o m

        LOGGER.info("did redirect to a package for; {}", term);
    } else {
        response.setStatus(HttpServletResponse.SC_NOT_FOUND);

        PrintWriter w = response.getWriter();
        w.format("unable to find an entity for; %s", termDebug(term));
        w.flush();

        LOGGER.info("did not find a package for; {}", termDebug(term));
    }
}

From source file:org.killbill.billing.plugin.core.PluginServlet.java

protected void buildCreatedResponse(final String location, final HttpServletResponse resp) throws IOException {
    resp.setHeader(HttpHeaders.LOCATION, location);
    buildResponse(HttpServletResponse.SC_CREATED, null, resp);
}

From source file:com.bouncestorage.chaoshttpproxy.ChaosHttpProxyHandler.java

@Override
public void handle(String target, Request baseRequest, HttpServletRequest request,
        HttpServletResponse servletResponse) throws IOException {
    baseRequest.setHandled(true);/*www  .  j  a  va2  s . c  o  m*/

    // CONNECT is not supported pending implementation of MITM HTTPS
    if (request.getMethod().equals("CONNECT")) {
        logger.debug("CONNECT is not supported");
        servletResponse.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED);
        return;
    }

    Failure failure = supplier.get();
    logger.debug("request: {}", request);
    logger.debug("Failure: {}", failure);
    try (InputStream is = request.getInputStream(); OutputStream os = servletResponse.getOutputStream()) {
        HostAndPort hostAndPort = HostAndPort.fromString(request.getHeader(HttpHeaders.HOST));
        String queryString = request.getQueryString();
        URI uri;
        try {
            uri = new URI(request.getScheme(), /*userInfo=*/ null, hostAndPort.getHostText(),
                    hostAndPort.hasPort() ? hostAndPort.getPort() : 80, request.getRequestURI(), queryString,
                    /*fragment=*/ null);
        } catch (URISyntaxException use) {
            throw new IOException(use);
        }
        logger.debug("uri: {}", uri);
        URI redirectedUri = redirects.get(uri);
        if (redirectedUri != null) {
            // TODO: parameters
            uri = redirectedUri;
            logger.debug("redirected uri: {}", uri);
        }

        switch (failure) {
        case HTTP_301:
        case HTTP_302:
        case HTTP_303:
        case HTTP_307:
        case HTTP_308:
            servletResponse.setStatus(failure.getResponseCode());
            URI redirectUri;
            try {
                redirectUri = new URI(request.getScheme(), /*userInfo=*/ null, hostAndPort.getHostText(),
                        hostAndPort.hasPort() ? hostAndPort.getPort() : 80, "/" + UUID.randomUUID().toString(),
                        /*query=*/ null, /*fragment=*/ null);
            } catch (URISyntaxException use) {
                throw new IOException(use);
            }
            redirects.put(redirectUri, uri);
            servletResponse.addHeader(HttpHeaders.LOCATION, redirectUri.toString());
            return;
        case HTTP_408:
        case HTTP_500:
        case HTTP_503:
        case HTTP_504:
            servletResponse.setStatus(failure.getResponseCode());
            return;
        case TIMEOUT:
            Uninterruptibles.sleepUninterruptibly(Long.MAX_VALUE, TimeUnit.DAYS);
            return;
        default:
            break;
        }

        InputStreamResponseListener listener = new InputStreamResponseListener();
        InputStream iss = failure == Failure.PARTIAL_REQUEST ?
        // TODO: random limit
                ByteStreams.limit(is, 1024) : is;
        org.eclipse.jetty.client.api.Request clientRequest = client.newRequest(uri.toString())
                .method(request.getMethod());
        long userContentLength = -1;
        for (String headerName : Collections.list(request.getHeaderNames())) {
            if (headerName.equalsIgnoreCase(HttpHeaders.EXPECT)
                    || headerName.equalsIgnoreCase("Proxy-Connection")) {
                continue;
            }
            String headerValue = request.getHeader(headerName);
            logger.trace("{}: {}", headerName, headerValue);

            if (headerName.equalsIgnoreCase(HttpHeaders.CONTENT_MD5)
                    && failure == Failure.CORRUPT_REQUEST_CONTENT_MD5) {
                headerValue = headerValue.toUpperCase();
            }
            if (headerName.equalsIgnoreCase(HttpHeaders.CONTENT_LENGTH)) {
                userContentLength = Long.parseLong(headerValue);
            }
            clientRequest.header(headerName, headerValue);
        }

        // Work around Jetty bug that strips Content-Length
        // https://bugs.eclipse.org/bugs/show_bug.cgi?id=475613.
        final long length = userContentLength;
        clientRequest.content(new InputStreamContentProvider(iss) {
            @Override
            public long getLength() {
                return length != -1 ? length : super.getLength();
            }
        });
        clientRequest.send(listener);
        if (failure == Failure.PARTIAL_REQUEST) {
            return;
        }

        Response response;
        try {
            response = listener.get(Long.MAX_VALUE, TimeUnit.SECONDS);
        } catch (ExecutionException | InterruptedException | TimeoutException e) {
            throw new IOException(e);
        }
        int status = response.getStatus();
        logger.trace("status: {}", status);
        servletResponse.setStatus(status);
        List<HttpField> headers = Lists.newArrayList(response.getHeaders());
        if (failure == Failure.REORDER_HEADERS) {
            Collections.shuffle(headers);
        }
        for (HttpField field : headers) {
            String header = field.getName();
            String value = field.getValue();
            logger.trace("header: {}: {}", header, value);
            switch (failure) {
            case CHANGE_HEADER_CASE:
                // TODO: randomly change between upper- and lower-case
                header = header.toUpperCase();
                break;
            case CORRUPT_RESPONSE_CONTENT_MD5:
                if (header.equals(HttpHeaders.CONTENT_MD5)) {
                    value = BaseEncoding.base64().encode(new byte[Hashing.md5().bits() / 8]);
                }
                break;
            default:
                break;
            }
            servletResponse.addHeader(header, value);
        }
        try (InputStream responseContent = listener.getInputStream()) {
            switch (failure) {
            case PARTIAL_RESPONSE:
                byte[] array = new byte[1024];
                int count = responseContent.read(array);
                if (count != -1) {
                    // TODO: randomly read n - 1 bytes
                    os.write(array, 0, count / 2);
                    os.flush();
                }
                return;
            case SLOW_RESPONSE:
                for (int i = 0; i < 10; ++i) {
                    int ch = responseContent.read();
                    if (ch == -1) {
                        break;
                    }
                    os.write(ch);
                    os.flush();
                    Uninterruptibles.sleepUninterruptibly(1, TimeUnit.SECONDS);
                }
                break;
            default:
                break;
            }
            ByteStreams.copy(responseContent, os);
        }
    }
}

From source file:org.icgc.dcc.submission.web.resource.NextReleaseResource.java

@GET
public Response getNextRelease(@Context SecurityContext securityContext) {
    log.debug("Getting nextRelease");
    if (hasReleaseViewPrivilege(securityContext) == false) {
        return unauthorizedResponse();
    }//  ww  w .jav  a 2s . c  o m

    String prefix = config.getString("http.ws.path");
    String redirectionPath = JOINER.join(prefix, "releases", releaseService.getNextRelease() // guaranteed not to be null
            .getName());

    return Response.status(Status.MOVED_PERMANENTLY).header(HttpHeaders.LOCATION, redirectionPath).build();
}

From source file:com.uber.sdk.rides.client.internal.RetrofitUberRidesClient.java

/**
 * Builds a RestAdapter./*w w w .j  a  v  a  2 s .  c  o  m*/
 */
private static RestAdapter buildRestAdapter(final Session session, String endpointHost,
        final OAuth2Helper oAuth2Helper, RestAdapter.LogLevel logLevel, OkHttpClient httpClient)
        throws IOException {

    RequestInterceptor requestInterceptor = new RequestInterceptor() {

        @Override
        public void intercept(RequestFacade requestFacade) {
            Credential credential = session.getCredential();
            if (credential != null) {
                oAuth2Helper.refreshCredentialIfNeeded(credential);
                requestFacade.addHeader("Authorization", "Bearer " + credential.getAccessToken());
            } else {
                requestFacade.addHeader("Authorization", "Token " + session.getServerToken());
            }

            if (session.getLocale() != null) {
                requestFacade.addHeader("Accept-Language", session.getLocale().getLanguage());
            }

            requestFacade.addHeader("X-Uber-User-Agent", "Java Rides SDK v" + LIB_VERSION);
        }
    };

    if (httpClient == null) {
        httpClient = new OkHttpClient();
        httpClient.setConnectTimeout(1, TimeUnit.MINUTES);
        httpClient.setReadTimeout(1, TimeUnit.MINUTES);
        httpClient.setFollowRedirects(false);
        httpClient.interceptors().add(new Interceptor() {
            @Override
            public Response intercept(Chain chain) throws IOException {
                Request oldRequest = chain.request();
                Response response = chain.proceed(oldRequest);
                if (response.isRedirect()) {
                    String redirectUrl = response.header(HttpHeaders.LOCATION);
                    Request newRequest = oldRequest.newBuilder().url(redirectUrl).build();
                    return chain.proceed(newRequest);
                }
                return response;
            }
        });
    }

    return new RestAdapter.Builder().setEndpoint(endpointHost)
            .setConverter(new GsonConverter(new GsonBuilder().create()))
            .setRequestInterceptor(requestInterceptor).setClient(new OkClient(httpClient)).setLogLevel(logLevel)
            .build();
}

From source file:org.haiku.haikudepotserver.pkg.controller.PkgDownloadController.java

@RequestMapping(value = { "/" + SEGMENT_PKGDOWNLOAD + PATH }, method = RequestMethod.GET)
public void download(HttpServletResponse response, @PathVariable(value = KEY_PKGNAME) String pkgName,
        @PathVariable(value = KEY_REPOSITORYCODE) String repositoryCode,
        @PathVariable(value = KEY_MAJOR) String major, @PathVariable(value = KEY_MINOR) String minor,
        @PathVariable(value = KEY_MICRO) String micro, @PathVariable(value = KEY_PRERELEASE) String prerelease,
        @PathVariable(value = KEY_REVISION) String revisionStr,
        @PathVariable(value = KEY_ARCHITECTURECODE) String architectureCode)
        throws IOException, RequestObjectNotFound {

    Preconditions.checkArgument(null != response, "the response is required");

    ObjectContext context = serverRuntime.newContext();

    Pkg pkg = Pkg.tryGetByName(context, pkgName).orElseThrow(() -> {
        LOGGER.info("unable to find the package; {}", pkgName);
        return new RequestObjectNotFound();
    });//w w w  . j  a  v a 2s. c om

    Repository repository = Repository.tryGetByCode(context, repositoryCode).orElseThrow(() -> {
        LOGGER.info("unable to find the repository; {}", repositoryCode);
        return new RequestObjectNotFound();
    });

    Architecture architecture = Architecture.tryGetByCode(context, architectureCode).orElseThrow(() -> {
        LOGGER.info("unable to find the architecture; {}", architectureCode);
        return new RequestObjectNotFound();
    });

    revisionStr = hyphenToNull(revisionStr);

    VersionCoordinates versionCoordinates = new VersionCoordinates(hyphenToNull(major), hyphenToNull(minor),
            hyphenToNull(micro), hyphenToNull(prerelease),
            null == revisionStr ? null : Integer.parseInt(revisionStr));

    PkgVersion pkgVersion = PkgVersion.getForPkg(context, pkg, repository, architecture, versionCoordinates)
            .orElseThrow(() -> {
                LOGGER.info("unable to find the pkg version; {}, {}", pkgName, versionCoordinates);
                return new RequestObjectNotFound();
            });

    Optional<URL> urlOptional = pkgVersion.tryGetHpkgURL();

    if (!urlOptional.isPresent()) {
        LOGGER.info("unable to allow download of the hpkg data as no url was able to be generated");
        response.setStatus(HttpServletResponse.SC_NOT_FOUND);
    } else {
        URL url = urlOptional.get();

        // if it is an HTTP URL then it should be possible to redirect the browser to that URL
        // instead of piping it through the application server.

        if (ImmutableSet.of("http", "https").contains(url.getProtocol())) {
            response.setStatus(HttpServletResponse.SC_MOVED_TEMPORARILY);
            response.setHeader(HttpHeaders.LOCATION, url.toString());
            response.setContentType(MediaType.PLAIN_TEXT_UTF_8.toString());

            PrintWriter writer = response.getWriter();
            writer.print(url.toString());
            writer.flush();
        } else {
            response.setContentType(MediaType.OCTET_STREAM.toString());
            response.setHeader(HttpHeaders.CONTENT_DISPOSITION,
                    String.format("attachment; filename=\"%s\"", pkgVersion.getHpkgFilename()));

            try (InputStream inputStream = url.openStream()) {
                LOGGER.info("downloaded package version; {} - {}", pkg.getName(), pkgVersion);
                ByteStreams.copy(inputStream, response.getOutputStream());
            } catch (IOException ioe) {
                // logged without a stack trace because it happens fairly often that a robot will initiate the download and then drop it.
                LOGGER.error("unable to relay data to output stream from '{}'; {} -- {}", url.toString(),
                        ioe.getClass().getSimpleName(), ioe.getMessage());
            }
        }
    }
}

From source file:jetbrains.buildServer.projectPush.PostProjectToSandboxController.java

@Nullable
@Override/*from  w  w w  .j  av a 2  s .  c  om*/
protected ModelAndView doHandle(@NotNull HttpServletRequest request, @NotNull HttpServletResponse response)
        throws Exception {
    if (!isPost(request)) {
        response.sendError(HttpStatus.METHOD_NOT_ALLOWED.value());
        return null;
    }

    final StringBuilder stringBuffer = new StringBuilder();
    try {
        String line;
        BufferedReader reader = request.getReader();
        while ((line = reader.readLine()) != null)
            stringBuffer.append(line);
    } catch (Exception e) {
        response.sendError(HttpStatus.BAD_REQUEST.value(), e.getMessage());
        return null;
    }

    final String projectName = stringBuffer.toString();
    if (projectName.isEmpty()) {
        response.sendError(HttpStatus.BAD_REQUEST.value(), "Project name is empty.");
        return null;
    }

    if (mySettings.isDisabled()) {
        response.sendError(HttpStatus.FORBIDDEN.value(), "Sandbox disabled.");
        return null;
    }

    SUser user;
    user = SessionUser.getUser(request);
    if (user == null) {
        user = myAuthHelper.getAuthenticatedUser(request, response);
    }
    if (user == null)
        return null;

    final Role projectAdminRole = myRolesHelper.findProjectAdminRole();
    if (projectAdminRole == null) {
        response.sendError(HttpStatus.INTERNAL_SERVER_ERROR.value(),
                "Failed to locate Project Admin role on the server.");
        return null;
    }

    final SProject project;
    try {
        final String sandboxProjectId = mySettings.getSandboxProjectId();
        final SProject sandboxProject = myProjectManager.findProjectByExternalId(sandboxProjectId);
        if (sandboxProject == null) {
            response.sendError(HttpStatus.INTERNAL_SERVER_ERROR.value(),
                    "Failed to locate sandbox project by ID " + sandboxProjectId);
            return null;
        }

        if (sandboxProject.findProjectByName(projectName) != null) {
            response.sendError(HttpStatus.CONFLICT.value(),
                    "Project with name " + projectName + " already exists.");
            return null;
        }

        project = sandboxProject.createProject(
                myProjectIdentifiersManager.generateNewExternalId(null, projectName, null), projectName);
        project.persist();
    } catch (Exception e) {
        response.sendError(HttpStatus.INTERNAL_SERVER_ERROR.value(), e.getMessage());
        return null;
    }

    try {
        myRolesHelper.addRole(user, RoleScope.projectScope(project.getProjectId()), projectAdminRole);
    } catch (Throwable throwable) {
        response.sendError(HttpStatus.INTERNAL_SERVER_ERROR.value(), throwable.getMessage());
        return null;
    }

    response.setStatus(HttpStatus.CREATED.value());
    response.setHeader(HttpHeaders.LOCATION, RESTApiHelper.getProjectURI(project));

    return null;
}

From source file:com.google.gerrit.util.http.testutil.FakeHttpServletResponse.java

@Override
public synchronized void sendRedirect(String loc) {
    status = SC_FOUND;
    setHeader(HttpHeaders.LOCATION, loc);
    committed = true;
}

From source file:org.haiku.haikudepotserver.pkg.controller.PkgSearchController.java

/**
 * <p>This method will try to find the identified package.  If it finds it then it will redirect to a view of
 * that package.  If it does not find it then it will redirect to a search page querying that expression.</p>
 *///from   w  w  w .  j  a  v a2  s . c  om

@RequestMapping(value = "search", method = RequestMethod.GET)
public void handleSearch(HttpServletResponse response,
        @RequestParam(value = KEY_QUERY, required = false) String query) throws IOException {

    if (null != query) {
        query = query.trim().toLowerCase();
    }

    UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(baseUrl);
    Optional<PkgVersion> pkgVersionOptional = Optional.empty();

    if (!Strings.isNullOrEmpty(query) && Pkg.PATTERN_NAME.matcher(query).matches()) {
        ObjectContext context = serverRuntime.newContext();
        Optional<Pkg> pkgOptional = Pkg.tryGetByName(context, query);

        if (pkgOptional.isPresent()) {
            pkgVersionOptional = pkgService.getLatestPkgVersionForPkg(context, pkgOptional.get(),
                    Repository.getByCode(context, Repository.CODE_DEFAULT), // TODO - user interface for choosing?
                    Collections
                            .singletonList(Architecture.tryGetByCode(context, defaultArchitectureCode).get()));
        }
    }

    if (pkgVersionOptional.isPresent()) {

        PkgVersion pv = pkgVersionOptional.get();

        builder.pathSegment("#!", "pkg", pv.getPkg().getName());
        pv.toVersionCoordinates().appendPathSegments(builder);
        builder.pathSegment(pv.getArchitecture().getCode());
    } else {
        builder.path("#!/");
        builder.queryParam(KEY_QUERY, query);
    }

    String uri = builder.build().toUriString();

    response.setStatus(HttpServletResponse.SC_SEE_OTHER);
    response.setHeader(HttpHeaders.LOCATION, uri);
    response.setContentType(MediaType.PLAIN_TEXT_UTF_8.toString());

    PrintWriter printWriter = response.getWriter();
    printWriter.print(uri);
    printWriter.flush();
}

From source file:io.github.mike10004.vhs.testsupport.MakeFileUploadHar.java

private static NanoHTTPD.Response redirect(String path) {
    NanoHTTPD.Response r = NanoHTTPD.newFixedLengthResponse(NanoHTTPD.Response.Status.REDIRECT, "text/plain",
            "redirecting...");
    r.addHeader(HttpHeaders.LOCATION, path);
    return r;/*from w ww  . j  ava2s .co m*/
}