Java OpenIDException类代码示例

import org.openid4java.OpenIDException; //导入依赖的package包/类
public static IndirectError createIndirectError(OpenIDException e,
                                                String msg, String returnTo,
                                                boolean compatibility)
{
    IndirectError err = new IndirectError(e, msg, returnTo, compatibility);

    try
    {
        err.validate();
    }
    catch (MessageException ex)
    {
        _log.error("Invalid " + (compatibility? "OpenID1" : "OpenID2") +
                   " indirect error message created for message: " + msg);
    }

    _log.debug("Created indirect error message:\n" + err.keyValueFormEncoding());

    return err;
}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
public void validate() throws MessageException
{
    if (! MODE_CHKAUTH.equals(getParameterValue("openid.mode")))
    {
        throw new MessageException(
            "Invalid openid.mode in verification request: "
            + getParameterValue("openid.mode"),
            OpenIDException.VERIFY_ERROR);
    }

    set("openid.mode", MODE_IDRES);

    if (DEBUG) _log.debug("Delegating verification request validity check " +
                          "to auth response...");

    super.validate();

    set("openid.mode", MODE_CHKAUTH);
}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
public static DirectError createDirectError(OpenIDException e, String msg, boolean compatibility)
{
    DirectError err = new DirectError(e, msg, compatibility);

    try
    {
        err.validate();
    }
    catch (MessageException ex)
    {
        _log.error("Invalid " + (compatibility? "OpenID1" : "OpenID2") +
                   " direct error message created for message: " + msg);
    }

    _log.debug("Created direct error message:\n" + err.keyValueFormEncoding());

    return err;
}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
/**
 * Checks the validity of the extension.
 * <p>
 * Used when constructing a extension from a parameter list.
 *
 * @throws MessageException if the PapeRequest is not valid.
 */
public void validate() throws MessageException
{
    if (! _parameters.hasParameter("preferred_auth_policies"))
    {
        throw new MessageException(
            "preferred_auth_policies is required in a PAPE request.",
            OpenIDException.PAPE_ERROR);
    }

    Iterator it = _parameters.getParameters().iterator();
    while (it.hasNext())
    {
        String paramName = ((Parameter) it.next()).getKey();
        if (! PAPE_FIELDS.contains(paramName) && ! paramName.startsWith(PapeMessage.AUTH_LEVEL_NS_PREFIX))
        {
            throw new MessageException(
                "Invalid parameter name in PAPE request: " + paramName,
                OpenIDException.PAPE_ERROR);
        }
    }
}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
private HTMLDocumentImpl parseDocument(String htmlData) throws DiscoveryException
{
    OpenID4JavaDOMParser parser = new OpenID4JavaDOMParser();
    try
    {
        parser.parse(OpenID4JavaDOMParser.createInputSource(htmlData));
    }
    catch (Exception e)
    {
        throw new DiscoveryException("Error parsing HTML message",
        		OpenIDException.DISCOVERY_HTML_PARSE_ERROR, e);
    }

    if (parser.isIgnoredHeadStartElement())
    {
        throw new DiscoveryException(
                "HTML response must have exactly one HEAD element.",
                OpenIDException.DISCOVERY_HTML_PARSE_ERROR);
    }

    return (HTMLDocumentImpl) parser.getDocument();
}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
private HTMLDocumentImpl parseDocument(String htmlData) throws YadisException
{
    OpenID4JavaDOMParser parser = new OpenID4JavaDOMParser();
    try
    {
        parser.parse(OpenID4JavaDOMParser.createInputSource(htmlData));
    }
    catch (Exception e)
    {
        throw new YadisException("Error parsing HTML message",
                OpenIDException.YADIS_HTMLMETA_INVALID_RESPONSE, e);
    }

    if (parser.isIgnoredHeadStartElement())
    {
            throw new YadisException("HTML response must have exactly one HEAD element.",
                            OpenIDException.YADIS_HTMLMETA_INVALID_RESPONSE);
    }

    return (HTMLDocumentImpl) parser.getDocument();
}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
/**
 * Constructs a URL object from a string;
 * needed by the YadisURL(String) constructor
 *
 * @param urlString         URL-type identifier in string format
 * @return                  URL object
 * @throws YadisException   if the provided string is not a valid URL
 */
private static URL urlFromString(String urlString) throws YadisException
{
    URL url;

    try
    {
        url = new URL(urlString);
    }
    catch (MalformedURLException e)
    {
        throw new YadisException("Invalid URL: " + urlString,
                OpenIDException.YADIS_INVALID_URL, e);
    }

    return url;
}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
public YadisResult discover(String url, int maxRedirects, HttpFetcher httpFetcher, Set serviceTypes)
    throws DiscoveryException
{
    YadisUrl yadisUrl = new YadisUrl(url);

    // try to retrieve the Yadis Descriptor URL with a HEAD call first
    YadisResult result = retrieveXrdsLocation(yadisUrl, false, maxRedirects, serviceTypes);

    // try GET 
    if (result.getXrdsLocation() == null)
        result = retrieveXrdsLocation(yadisUrl, true, maxRedirects, serviceTypes);

    if (result.getXrdsLocation() != null)
    {
        retrieveXrdsDocument(result, maxRedirects, serviceTypes);
    }
    else if (result.hasEndpoints())
    {
        // report the yadis url as the xrds location
        result.setXrdsLocation(url, OpenIDException.YADIS_INVALID_URL);
    }

    _log.info("Yadis discovered " + result.getEndpointCount() + " endpoints from: " + url);
    return result;
}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
/**
 * Parses the HTML input stream and scans for the Yadis XRDS location
 * in the HTML HEAD Meta tags.
 *
 * @param input             input data stream
 * @return String           the XRDS location URL, or null if not found
 * @throws YadisException   on parsing errors or Yadis protocal violations
 */
private String getHtmlMeta(String input) throws YadisException
{
    String xrdsLocation;

    if (input == null)
        throw new YadisException("Cannot download HTML message",
                OpenIDException.YADIS_HTMLMETA_DOWNLOAD_ERROR);

    xrdsLocation = YADIS_HTML_PARSER.getHtmlMeta(input);
    if (DEBUG)
    {
        _log.debug("input:\n" + input);
        _log.debug("xrdsLocation: " + xrdsLocation);
    }
    return xrdsLocation;
}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
public void testInvalidUrl()
{
    try
    {
        _resolver.discover("bla.com");

        fail("Should have failed with error code " +
             OpenIDException.YADIS_INVALID_URL);
    }
    catch (DiscoveryException expected)
    {
        assertEquals(expected.getMessage(),
                OpenIDException.YADIS_INVALID_URL, expected.getErrorCode());
    }

}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
public void testHeadTransportError() throws Exception
{
    _server.stop();

    try
    {
        _resolver.discover("http://localhost:" + _servletPort +
                           "/?servertopped");

        fail("Should have failed with error code " +
             OpenIDException.YADIS_HEAD_TRANSPORT_ERROR);
    }
    catch (YadisException expected)
    {
        assertEquals(expected.getMessage(),
                OpenIDException.YADIS_HEAD_TRANSPORT_ERROR, expected.getErrorCode());
    }
}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
public void testMultipleXrdsLocationInHtml()
{
    try
    {
        _resolver.discover("http://localhost:" +
            _servletPort + "/?html=multiplexrdslocation");

        fail("Should have failed with error code " +
             OpenIDException.YADIS_HTMLMETA_INVALID_RESPONSE);
    }
    catch (DiscoveryException expected)
    {
        assertEquals(expected.getMessage(),
            OpenIDException.YADIS_HTMLMETA_INVALID_RESPONSE, expected.getErrorCode());
    }
}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
public void testHtmlHeadElementsNoHead()
{
    try
    {
        _resolver.discover("http://localhost:" +
            _servletPort + "/?html=nohead");

        fail("Should have failed with error code " +
            OpenIDException.YADIS_HTMLMETA_INVALID_RESPONSE);
    }
    catch (DiscoveryException expected)
    {
        assertEquals(expected.getMessage(),
            OpenIDException.YADIS_HTMLMETA_INVALID_RESPONSE, expected.getErrorCode());
    }
}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
public void testEmptyHtml()
{
    try
    {
        _resolver.discover("http://localhost:" +
            _servletPort + "/?html=empty");

        fail("Should have failed with error code " +
            OpenIDException.YADIS_HTMLMETA_INVALID_RESPONSE);
    }
    catch (DiscoveryException expected)
    {
        assertEquals(expected.getMessage(),
            OpenIDException.YADIS_HTMLMETA_INVALID_RESPONSE, expected.getErrorCode());
    }
}
 

import org.openid4java.OpenIDException; //导入依赖的package包/类
public void testGetError() throws Exception
{
    try
    {
        _resolver.discover("http://localhost:" +
            _servletPort + "/?html=nonexistantfile");

        fail("Should have failed with error code " +
            OpenIDException.YADIS_GET_ERROR);
    }
    catch (YadisException expected)
    {
        assertEquals(expected.getMessage(),
            OpenIDException.YADIS_GET_ERROR, expected.getErrorCode());
    }
}