Example usage for com.google.common.net MediaType parse

Introduction

In this page you can find the example usage for com.google.common.net MediaType parse.

Prototype

public static MediaType parse(String input) 

Source Link

Document

Parses a media type from its string representation.

Usage

From source file:io.soabase.web.assets.InternalAssetServlet.java

private void serveTemplate(HttpServletRequest request, HttpServletResponse response, String path) {
    try {/*from  ww  w . ja  va 2s  . c  om*/
        Template template = getTemplate(path);
        String content = template
                .apply(contextCache.getContext(request, requestLanguage.getLanguageCode(request)));
        String mimeTypeOfExtension = request.getServletContext().getMimeType(request.getRequestURI());
        MediaType mediaType = MediaType.parse(mimeTypeOfExtension);
        response.setContentType(mediaType.type() + '/' + mediaType.subtype());
        if (mediaType.type().equals("text") || mediaType.subtype().equals("javascript")) {
            response.setCharacterEncoding(Charsets.UTF_8.name());
        }
        response.setContentLength(content.length());
        CharStreams.copy(new StringReader(content), response.getWriter());
    } catch (Exception e) {
        log.error("Could not serve template: " + path, e);
    }
}

---

From source file:com.mastfrog.tinymavenproxy.GetActeur.java

private static MediaType findMimeType(Path path) {
    if (path.size() == 0) {
        return MediaType.ANY_APPLICATION_TYPE;
    }/*w w w  .  j  a v  a 2  s .c o  m*/
    String file = path.getLastElement().toString();
    int ix = file.lastIndexOf(".");
    if (ix < 0) {
        return MediaType.ANY_APPLICATION_TYPE;
    }
    String ext = file.substring(ix + 1);
    switch (ext) {
    case "html":
        return MediaType.HTML_UTF_8;
    case "jar":
        return MediaType.parse("application/java-archive");
    case "xml":
    case "pom":
        return MediaType.XML_UTF_8;
    case "sha1":
    default:
        return MediaType.PLAIN_TEXT_UTF_8;
    }
}

---

From source file:org.wikimedia.analytics.kraken.pageview.PageviewFilter.java

/**
 *
 * @param url/*from  w w  w.ja v  a  2 s.c  o m*/
 * @param mimeType
 * @return
 */
public final boolean isValidMimeType(final URL url, final String mimeType) {
    PageviewType pageviewType = PageviewType.determinePageviewType(url);
    MediaType mediaType;
    try {
        mediaType = MediaType.parse(mimeType);
    } catch (java.lang.IllegalArgumentException e) {
        return false;
    }

    switch (pageviewType) {
    case IMAGE:
        return (mediaType.type().contains("image"));

    case API:
        return (mediaType.type().equals("application") && mediaType.subtype().equals("json"));

    case REGULAR:
        return (mediaType.type().equals("text")
                && ((mediaType.subtype().equals("html")) || mediaType.subtype().equals("vnd.wap.wml")));

    default:
        return (mediaType.type().equals("text") && (mediaType.subtype().equals("html")));
    }
}

---

From source file:com.linkedin.flashback.netty.builder.RecordedHttpMessageBuilder.java

/**
 * Get char set from headers/*from  ww  w . ja v a 2  s .  c om*/
 *
 * */
protected String getCharset() {
    String header = getHeader(HttpHeaders.CONTENT_TYPE);
    if (Strings.isNullOrEmpty(header)) {
        return DEFAULT_CHARSET;
    } else {
        return MediaType.parse(header).charset().or(Charsets.UTF_8).toString();
    }
}

---

From source file:com.lumata.lib.lupa.internal.ProxiedReadableResource.java

private void setContentTypeFromHeader(HttpResponse response) {
    Header header = response.getFirstHeader(HttpHeaders.CONTENT_TYPE);
    if (header != null && header.getValue() != null) {
        setContentType(MediaType.parse(header.getValue()));
    }//from   w ww  .j  ava 2 s. c om
}

---

From source file:io.bazel.rules.closure.http.HttpMessage.java

public final T setHeader(String name, @Nullable String value) {
    checkArgument(CharMatcher.whitespace().matchesNoneOf(name));
    name = Ascii.toLowerCase(name);/*from  w  w  w .j  a  v  a  2 s .c  o m*/
    value = emptyToNull(value);
    switch (name) {
    case "content-type":
        setContentType(value == null ? null : MediaType.parse(value));
        break;
    case "content-length":
        setContentLength(value == null ? -1 : Long.parseLong(value));
        break;
    default:
        if (value == null) {
            headers.remove(name);
        } else {
            checkArgument(CRLF.matchesNoneOf(value));
            headers.put(name, checkNotNull(value));
        }
    }
    return castThis();
}

---

From source file:com.outerspacecat.openid.rp.Provider.java

/**
 * Returns a well-known provider.//from w  ww  . j av a2s  . c  o m
 * 
 * @param metadata information about the provider. Must be non {@code null}.
 * @return a provider. Never {@code null}.
 * @throws IOException if a provider cannot be obtained
 */
public static Provider get(final WellKnown metadata) throws IOException {
    Preconditions.checkNotNull(metadata, "metadata required");

    Provider cached = null;
    synchronized (wellKnownCache) {
        Optional<Provider> option = wellKnownCache.get(metadata.getUri());
        if (option.isPresent())
            cached = option.get();
    }
    if (cached != null && !cached.isExpired())
        return cached;

    HttpURLConnection conn = null;
    InputStream in = null;
    try {
        conn = (HttpURLConnection) metadata.getUri().toURL().openConnection();
        conn.setUseCaches(false);
        conn.setRequestMethod("GET");
        conn.setConnectTimeout(5000);
        conn.setReadTimeout(5000);
        conn.addRequestProperty("Accept", "application/xrds+xml");
        conn.addRequestProperty("Accept-Encoding", "gzip");
        conn.connect();
        int code = conn.getResponseCode();
        if (code / 100 != 2)
            throw new IOException("unexpected response code: " + code);

        MediaType mt = null;
        try {
            if (conn.getContentType() != null)
                mt = MediaType.parse(conn.getContentType());
        } catch (IllegalArgumentException e) {
        }

        Instant expirationDate = null;
        if (conn.getExpiration() > 0) {
            expirationDate = Instant.ofEpochMilli(conn.getExpiration());
        } else {
            expirationDate = Instant.now();
        }

        in = new BufferedInputStream(conn.getInputStream());
        if ("gzip".equalsIgnoreCase(conn.getContentEncoding()))
            in = new GZIPInputStream(in);

        InputSource src = null;
        if (mt != null && mt.charset().isPresent()) {
            src = new InputSource(new InputStreamReader(in, mt.charset().get()));
        } else {
            src = new InputSource(in);
        }

        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        factory.setNamespaceAware(true);
        Document doc = factory.newDocumentBuilder().parse(src);

        List<Service> services = new ArrayList<Service>();

        XPath xpath = XPathFactory.newInstance().newXPath();
        xpath.setNamespaceContext(NAMESPACE_CONTEXT);

        NodeList serviceNodes = (NodeList) xpath.evaluate("/xrds:XRDS/xrd:XRD/xrd:Service", doc,
                XPathConstants.NODESET);
        for (int i = 0; i < serviceNodes.getLength(); ++i) {
            Node serviceNode = serviceNodes.item(i);

            Set<String> types = new HashSet<String>();
            NodeList typeNodes = (NodeList) xpath.evaluate("xrd:Type", serviceNode, XPathConstants.NODESET);
            for (int j = 0; j < typeNodes.getLength(); ++j)
                types.add(typeNodes.item(j).getTextContent());
            if (!types.contains("http://specs.openid.net/auth/2.0/server"))
                continue;

            int servicePriority = 0;
            Double servicePriorityNode = (Double) xpath.evaluate("@priority", serviceNode,
                    XPathConstants.NUMBER);
            if (servicePriorityNode != null && servicePriorityNode >= 0)
                servicePriority = servicePriorityNode.intValue();

            List<Endpoint> endpoints = new ArrayList<Endpoint>();

            NodeList uriNodes = (NodeList) xpath.evaluate("xrd:URI", serviceNode, XPathConstants.NODESET);
            for (int j = 0; j < uriNodes.getLength(); ++j) {
                Node uriNode = uriNodes.item(j);

                int uriPriority = 0;
                Double uriPriorityNode = (Double) xpath.evaluate("@priority", uriNode, XPathConstants.NUMBER);
                if (uriPriorityNode != null && uriPriorityNode >= 0)
                    uriPriority = uriPriorityNode.intValue();

                try {
                    URI uri = new URI(uriNode.getTextContent());
                    if (uri.getScheme().equals("http") || uri.getScheme().equals("https"))
                        endpoints.add(new Endpoint(uriPriority, uri));
                } catch (URISyntaxException e) {
                }
            }

            if (!endpoints.isEmpty()) {
                Collections.shuffle(endpoints);
                services.add(new Service(servicePriority, endpoints));
            }
        }

        if (services.isEmpty())
            throw new IOException("could not perform discovery on well-known URI: " + metadata.getUri());
        Collections.shuffle(services);

        Provider ret = new Provider(services, expirationDate);
        if (!ret.isExpired()) {
            synchronized (wellKnownCache) {
                wellKnownCache.put(metadata.getUri(), ret);
            }
        }

        return ret;
    } catch (XPathException e) {
        throw new IOException(e);
    } catch (FactoryConfigurationError e) {
        throw new RuntimeException(e);
    } catch (SAXException e) {
        throw new IOException(e);
    } catch (ParserConfigurationException e) {
        throw new RuntimeException(e);
    } finally {
        if (in != null)
            in.close();
    }
}

---

From source file:com.mastfrog.acteur.wicket.adapters.ResponseAdapter.java

@Override
public void setContentType(String string) {
    resp.add(Headers.CONTENT_TYPE, MediaType.parse(string));
}

---

From source file:com.github.fge.jsonschema.core.keyword.syntax.checkers.hyperschema.LinksSyntaxChecker.java

private void checkLDO(final ProcessingReport report, final MessageBundle bundle, final SchemaTree tree,
        final int index) throws ProcessingException {
    final JsonNode ldo = getNode(tree).get(index);

    String value;//from www. j  a  va 2s  . c o m

    checkLDOProperty(report, bundle, tree, index, "rel", NodeType.STRING, "draftv4.ldo.rel.incorrectType");

    if (checkLDOProperty(report, bundle, tree, index, "href", NodeType.STRING,
            "draftv4.ldo.href.incorrectType")) {
        value = ldo.get("href").textValue();
        try {
            new URITemplate(value);
        } catch (URITemplateParseException ignored) {
            report.error(
                    LDOMsg(tree, bundle, "draftv4.ldo.href.notURITemplate", index).putArgument("value", value));
        }
    }

    checkLDOProperty(report, bundle, tree, index, "title", NodeType.STRING, "draftv4.ldo.title.incorrectType");

    if (checkLDOProperty(report, bundle, tree, index, "mediaType", NodeType.STRING,
            "draftv4.ldo.mediaType.incorrectType")) {
        value = ldo.get("mediaType").textValue();
        try {
            MediaType.parse(value);
        } catch (IllegalArgumentException ignored) {
            report.error(LDOMsg(tree, bundle, "draftv4.ldo.mediaType.notMediaType", index).putArgument("value",
                    value));
        }
    }

    checkLDOProperty(report, bundle, tree, index, "method", NodeType.STRING,
            "draftv4.ldo.method.incorrectType");

    if (checkLDOProperty(report, bundle, tree, index, "encType", NodeType.STRING,
            "draftv4.ldo.enctype.incorrectType")) {
        value = ldo.get("encType").textValue();
        try {
            MediaType.parse(value);
        } catch (IllegalArgumentException ignored) {
            report.error(LDOMsg(tree, bundle, "draftv4.ldo.enctype.notMediaType", index).putArgument("value",
                    value));
        }
    }
}

---

From source file:jp.opencollector.guacamole.auth.delegated.DelegatedAuthenticationProvider.java

private static Optional<GuacamoleConfiguration> buildConfigurationFromRequest(HttpServletRequest req)
        throws GuacamoleException {
    try {//from w w  w.java  2s.  c  om
        if (req.getClass().getName().equals("org.glyptodon.guacamole.net.basic.rest.APIRequest")) {
            final GuacamoleConfiguration config = new GuacamoleConfiguration();
            final String protocol = req.getParameter("protocol");
            if (protocol == null)
                throw new GuacamoleException("required parameter \"protocol\" is missing");
            config.setProtocol(protocol);
            for (Map.Entry<String, String[]> param : req.getParameterMap().entrySet()) {
                String[] values = param.getValue();
                if (values.length > 0)
                    config.setParameter(param.getKey(), values[0]);
            }
            return Optional.of(config);
        } else {
            final ServletInputStream is = req.getInputStream();
            if (!is.isReady()) {
                MediaType contentType = MediaType.parse(req.getContentType());
                boolean invalidContentType = true;
                if (contentType.type().equals("application")) {
                    if (contentType.subtype().equals("json")) {
                        invalidContentType = false;
                    } else if (contentType.subtype().equals("x-www-form-urlencoded")
                            && req.getParameter("token") != null) {
                        return Optional.<GuacamoleConfiguration>absent();
                    }
                }
                if (invalidContentType)
                    throw new GuacamoleException(String.format("expecting application/json, got %s",
                            contentType.withoutParameters()));
                final GuacamoleConfiguration config = new GuacamoleConfiguration();
                try {
                    final ObjectMapper mapper = new ObjectMapper();
                    JsonNode root = (JsonNode) mapper.readTree(
                            createJsonParser(req.getInputStream(), contentType.charset().or(UTF_8), mapper));
                    {
                        final JsonNode protocol = root.get("protocol");
                        if (protocol == null)
                            throw new GuacamoleException("required parameter \"protocol\" is missing");
                        final JsonNode parameters = root.get("parameters");
                        if (parameters == null)
                            throw new GuacamoleException("required parameter \"parameters\" is missing");
                        config.setProtocol(protocol.asText());
                        {
                            for (Iterator<Entry<String, JsonNode>> i = parameters.fields(); i.hasNext();) {
                                Entry<String, JsonNode> member = i.next();
                                config.setParameter(member.getKey(), member.getValue().asText());
                            }
                        }
                    }
                } catch (ClassCastException e) {
                    throw new GuacamoleException("error occurred during parsing configuration", e);
                }
                return Optional.of(config);
            } else {
                return Optional.<GuacamoleConfiguration>absent();
            }
        }
    } catch (IOException e) {
        throw new GuacamoleException("error occurred during retrieving configuration from the request body", e);
    }
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• »