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

Introduction

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

Prototype

String USER_AGENT

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

Click Source Link

Document

The HTTP User-Agent header field name.

Usage

From source file:org.sonatype.nexus.servlet.BrowserDetector.java

/**
 * Determine if the given request appears to be initiated from a web-browser.
 *//*from  w  w w  . j  av a2s  . c o  m*/
public boolean isBrowserInitiated(final HttpServletRequest request) {
    checkNotNull(request);

    // skip if disabled
    if (disable) {
        return false;
    }

    String userAgentString = request.getHeader(HttpHeaders.USER_AGENT);

    // skip if excluded
    if (excludedUserAgents.contains(userAgentString)) {
        return false;
    }

    UserAgent userAgent = parseUserAgent(userAgentString);
    if (userAgent != null) {
        switch (userAgent.getBrowser().getBrowserType()) {
        case WEB_BROWSER:
        case MOBILE_BROWSER:
        case TEXT_BROWSER:
            return true;
        }
    }
    return false;
}

From source file:com.facebook.nifty.client.HttpClientChannel.java

@Override
protected ChannelFuture writeRequest(ChannelBuffer request) {
    HttpRequest httpRequest = new DefaultHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.POST, endpointUri);

    httpRequest.setHeader(HttpHeaders.HOST, hostName);
    httpRequest.setHeader(HttpHeaders.CONTENT_LENGTH, request.readableBytes());
    httpRequest.setHeader(HttpHeaders.CONTENT_TYPE, "application/x-thrift");
    httpRequest.setHeader(HttpHeaders.USER_AGENT, "Java/Swift-HttpThriftClientChannel");

    if (headerDictionary != null) {
        for (Map.Entry<String, String> entry : headerDictionary.entrySet()) {
            httpRequest.setHeader(entry.getKey(), entry.getValue());
        }/*from w ww .j a  va 2 s . co  m*/
    }

    httpRequest.setContent(request);

    return underlyingNettyChannel.write(httpRequest);
}

From source file:org.sonatype.nexus.security.anonymous.AnonymousFilter.java

@Override
protected boolean preHandle(final ServletRequest request, final ServletResponse response) throws Exception {
    Subject subject = SecurityUtils.getSubject();
    AnonymousManager manager = anonymousManager.get();

    if (subject.getPrincipal() == null && manager.isEnabled()) {
        request.setAttribute(ORIGINAL_SUBJECT, subject);
        subject = manager.buildSubject();
        ThreadContext.bind(subject);//from   w  w  w .  j ava2  s .  co m
        log.trace("Bound anonymous subject: {}", subject);

        // fire an event if we haven't already seen this ClientInfo since the server started
        if (request instanceof HttpServletRequest) {
            String userId = manager.getConfiguration().getUserId();
            ClientInfo clientInfo = new ClientInfo(userId, request.getRemoteAddr(),
                    ((HttpServletRequest) request).getHeader(HttpHeaders.USER_AGENT));
            if (!cache.contains(clientInfo)) {
                log.trace("Tracking new anonymous access from: {}", clientInfo);
                eventBus.post(new AnonymousAccessEvent(clientInfo, new Date()));
                cache.add(clientInfo);
            }
        }
    }

    return true;
}

From source file:org.codelabor.system.sniffer.web.filter.AbstractLogbackMappedDiagnosticContextFilter.java

@Override
protected void beforeRequest(HttpServletRequest request, String message) {
    logger.debug("beforeRequest");

    String username = getUsername();

    String sessionId = null;/*from   www . j  a  va 2 s  .c om*/
    HttpSession session = request.getSession();
    if (session != null) {
        sessionId = session.getId();
    }

    String requestId = null;
    RequestContext requestContext = RequestContextHolder.getContext();
    if (requestContext != null) {
        requestId = RequestContextHolder.getContext().getRequestId();
    }
    String remoteAddr = request.getRemoteAddr();
    String remoteHost = request.getRemoteHost();
    String requestUri = request.getRequestURI();
    String requestURL = request.getRequestURL().toString();
    String queryString = request.getQueryString();
    String userAgent = request.getHeader(HttpHeaders.USER_AGENT);
    String xForwardedFor = request.getHeader(HttpHeaders.X_FORWARDED_FOR);
    String servletContainerId = System.getProperty(ServletContainerConstants.SERVLET_CONTAINER_ID_KEY);

    MDC.put("requestId", requestId);
    MDC.put("username", getUsername());
    MDC.put("sessionId", sessionId);
    MDC.put("servletContainerId", servletContainerId);
    MDC.put(RequestConstants.REMOTE_ADDR, remoteAddr);
    MDC.put(RequestConstants.REMOTE_HOST, remoteHost);
    MDC.put(RequestConstants.REQUEST_URI, requestUri);
    MDC.put(RequestConstants.REQUEST_URL, requestURL);
    MDC.put(RequestConstants.QUERY_STRING, queryString);
    MDC.put(HeaderConstants.USER_AGENT, userAgent);
    MDC.put(HeaderConstants.X_FORWARDED_FOR, xForwardedFor);

    logger.debug("requestId: {}", requestId);
    logger.debug("username: {}, sessionId: {}", username);
    logger.debug("sessionId: {}", sessionId);
    logger.debug("servletContainerId: {}", servletContainerId);
    logger.debug("remoteAddr: {}", remoteAddr);
    logger.debug("remoteHost: {}", remoteHost);
    logger.debug("xForwardedFor: {}", xForwardedFor);
    logger.debug("requestUri: {}", requestUri);
    logger.debug("requestURL: {}", requestURL);
    logger.debug("queryString: {}", queryString);
    logger.debug("userAgent: {}", userAgent);
    logger.debug("xForwardedFor: {}", xForwardedFor);
}

From source file:org.sonatype.nexus.repository.httpbridge.internal.ExhaustRequestFilter.java

/**
 * Returns {@code true} if we need to exhaust the request before responding to the client.
 *///from   ww w  .j  ava  2 s  .  co m
private boolean exhaustRequest(final ServletRequest request, final ServletResponse response) {
    if (request instanceof HttpServletRequest && response instanceof HttpServletResponse) {

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

        // only needed when an error occurs...
        if (httpResponse.getStatus() >= 400) {
            String method = httpRequest.getMethod();
            // ...for upload requests
            if (HttpMethods.PUT.equals(method) || HttpMethods.POST.equals(method)) {
                /// ...from an affected user-agent
                String agent = httpRequest.getHeader(HttpHeaders.USER_AGENT);
                return exhaustForAgentsPattern.matcher(agent).matches();
            }
        }
    }
    return false;
}

From source file:org.graylog2.periodical.VersionCheckThread.java

@Override
public void doRun() {
    final Request request = new Request.Builder().addHeader(HttpHeaders.USER_AGENT, USER_AGENT).get()
            .url(versionCheckUri.toString()).build();

    final Response response;
    try {/*  w  ww .ja  v a 2  s  . c  o  m*/
        response = httpClient.newCall(request).execute();
    } catch (IOException e) {
        LOG.error("Couldn't perform version check", e);
        return;
    }

    if (response.isSuccessful()) {
        final VersionCheckResponse versionCheckResponse;
        try {
            versionCheckResponse = objectMapper.readValue(response.body().byteStream(),
                    VersionCheckResponse.class);
        } catch (IOException e) {
            LOG.error("Couldn't parse version check response", e);
            return;
        }

        final VersionResponse version = versionCheckResponse.version;
        final com.github.zafarkhaja.semver.Version reportedVersion = com.github.zafarkhaja.semver.Version
                .forIntegers(version.major, version.minor, version.patch);

        LOG.debug("Version check reports current version: " + versionCheckResponse);
        if (reportedVersion.greaterThan(ServerVersion.VERSION.getVersion())) {
            LOG.debug("Reported version is higher than ours ({}). Writing notification.",
                    ServerVersion.VERSION);

            Notification notification = notificationService.buildNow().addSeverity(Notification.Severity.NORMAL)
                    .addType(Notification.Type.OUTDATED_VERSION)
                    .addDetail("current_version", versionCheckResponse.toString());
            notificationService.publishIfFirst(notification);
        } else {
            LOG.debug("Reported version is not higher than ours ({}).", ServerVersion.VERSION);
            notificationService.fixed(Notification.Type.OUTDATED_VERSION);
        }
    } else {
        LOG.error("Version check unsuccessful (response code {}).", response.code());
    }
}

From source file:org.haiku.haikudepotserver.support.logging.LoggingFilter.java

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
        throws IOException, ServletException {

    try {/*w w w .ja  v  a  2s.  co m*/

        MDC.put(KEY_AUTHENTICATEDUSERNICKNAME, VALUE_ABSENT);
        MDC.put(KEY_USERAGENT, VALUE_ABSENT);
        MDC.put(KEY_USERAGENTCODE, VALUE_ABSENT);

        Optional<ObjectId> authenticatedUserOidOptional = AuthenticationHelper.getAuthenticatedUserObjectId();

        if (authenticatedUserOidOptional.isPresent()) {
            ObjectContext context = serverRuntime.newContext();
            User user = User.getByObjectId(context, authenticatedUserOidOptional.get());
            MDC.put(KEY_AUTHENTICATEDUSERNICKNAME, user.getNickname());
        }

        if (HttpServletRequest.class.isAssignableFrom(request.getClass())) {
            HttpServletRequest hRequest = (HttpServletRequest) request;
            String userAgent = hRequest.getHeader(HttpHeaders.USER_AGENT);

            if (!Strings.isNullOrEmpty(userAgent)) {
                MDC.put(KEY_USERAGENT, userAgent);

                Optional<Agent> agentOptional = browserDetect(userAgent);

                if (agentOptional.isPresent()) {
                    MDC.put(KEY_USERAGENTCODE, agentOptional.get().getCode());
                }
            }
        }

        chain.doFilter(request, response);
    } finally {
        MDC.clear();
    }

}

From source file:org.haiku.haikudepotserver.support.desktopapplication.DesktopApplicationMinimumVersionFilter.java

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
        throws IOException, ServletException {

    HttpServletRequest httpRequest = (HttpServletRequest) request;
    String userAgentString = httpRequest.getHeader(HttpHeaders.USER_AGENT);

    if (checkVersion(userAgentString)) {
        chain.doFilter(request, response);
    } else {// ww w. java 2 s .com
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        httpServletResponse.setStatus(HttpServletResponse.SC_PRECONDITION_FAILED);
        httpServletResponse.setHeader(HEADER_MINIMUM_VERSION, minimumVersionString);
        httpServletResponse.setContentType(MediaType.TEXT_PLAIN.toString());

        PrintWriter writer = httpServletResponse.getWriter();
        writer.append("The desktop application has a version that is too old to communicate with the\n");
        writer.append("application server.  The minimum version allowed by the application server is\n");
        writer.append("'");
        writer.append(minimumVersionString);
        writer.append("'.  You should upgrade your client.\n");
        writer.close();

        LOGGER.debug("rejected desktop client owing to older version; {}", userAgentString);
    }
}

From source file:org.graylog.plugins.usagestatistics.UsageStatsPeriodical.java

@Override
public void doRun() {
    if (!isEnabled()) {
        log.debug("Anonymous usage statistics disabled: Not transmitting statistics");
        return;/*from   w  w  w. j a  v  a 2 s  .c om*/
    }

    log.debug("Anonymous usage statistics activated: Transmitting node statistics.");
    final byte[] requestBody = buildPayload();

    if (config.isOfflineMode()) {
        final String filename = String.format(filenamePattern, DateTime.now(DateTimeZone.UTC).getMillis());

        if (!config.getDirectory().exists()) {
            boolean success = config.getDirectory().mkdirs();
            if (!success) {
                log.error("Couldn't create directory {}", config.getDirectory().getAbsolutePath());
                return;
            }
        }

        final File file = new File(config.getDirectory(), filename);

        log.debug("Anonymous usage statistics are in offline mode. Writing data into {}", file);
        try (final OutputStream outputStream = new FileOutputStream(file)) {
            outputStream.write(requestBody);
        } catch (IOException e) {
            log.warn("Couldn't write usage statistics into " + file, e);
        }
    } else {
        final Headers headers = new Headers.Builder().add(HttpHeaders.USER_AGENT, USER_AGENT)
                .add("X-Usage-Statistics-Version", USAGE_STATS_VERSION).build();

        final UsageStatsRequest request = UsageStatsRequest.create(headers, requestBody);

        boolean success = uploadDataSet(request);
        if (!success) {
            cachedRequestsQueue.add(request);
        } else if (!cachedRequestsQueue.isEmpty()) {
            log.debug("Trying to upload {} queued data sets", cachedRequestsQueue.size());
            uploadQueuedDataSets();
        }
    }
}

From source file:com.google.cloud.runtimes.tomcat.trace.TraceValve.java

/**
 * Create labels for Stackdriver trace with basic response and request info.
 *//*  w w  w . jav  a  2  s .co m*/
private Labels createLabels(Request request, Response response) {
    Labels.Builder labels = Labels.builder();
    this.annotateIfNotEmpty(labels, HttpLabels.HTTP_METHOD.getValue(), request.getMethod());
    this.annotateIfNotEmpty(labels, HttpLabels.HTTP_URL.getValue(), request.getRequestURI());
    this.annotateIfNotEmpty(labels, HttpLabels.HTTP_CLIENT_PROTOCOL.getValue(), request.getProtocol());
    this.annotateIfNotEmpty(labels, HttpLabels.HTTP_USER_AGENT.getValue(),
            request.getHeader(HttpHeaders.USER_AGENT));
    this.annotateIfNotEmpty(labels, HttpLabels.HTTP_REQUEST_SIZE.getValue(),
            request.getHeader(HttpHeaders.CONTENT_LENGTH));
    this.annotateIfNotEmpty(labels, HttpLabels.HTTP_RESPONSE_SIZE.getValue(),
            response.getHeader(HttpHeaders.CONTENT_LENGTH));
    labels.add(HttpLabels.HTTP_STATUS_CODE.getValue(), Integer.toString(response.getStatus()));
    return labels.build();
}

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

Introduction

Prototype

Document

Usage