Python OpenIDServiceEndpoint.server_url方法代码示例

# 需要导入模块: from openid.consumer.discover import OpenIDServiceEndpoint [as 别名]
# 或者: from openid.consumer.discover.OpenIDServiceEndpoint import server_url [as 别名]
 def begin(self, url):
     endpoint = OpenIDServiceEndpoint()
     endpoint.claimed_id = 'oid'
     endpoint.server_url = 'http://localhost/'
     endpoint.type_uris = [OPENID_2_0_TYPE]
     auth_request = consumer.AuthRequest(endpoint, None)
     return auth_request

# 需要导入模块: from openid.consumer.discover import OpenIDServiceEndpoint [as 别名]
# 或者: from openid.consumer.discover.OpenIDServiceEndpoint import server_url [as 别名]
 def v1endpoint(self, port):
     """Return an OpenID 1.1 OpenIDServiceEndpoint for the server."""
     base = "http://%s:%s" % (socket.getfqdn('127.0.0.1'), port)
     ep = OpenIDServiceEndpoint()
     ep.claimed_id = base + "/id/bob"
     ep.server_url = base + "/openidserver"
     ep.type_uris = [OPENID_1_1_TYPE]
     return ep

# 需要导入模块: from openid.consumer.discover import OpenIDServiceEndpoint [as 别名]
# 或者: from openid.consumer.discover.OpenIDServiceEndpoint import server_url [as 别名]
def _verifyDiscoveryResultsOpenID2(self, resp_msg, endpoint):
    to_match = OpenIDServiceEndpoint()
    to_match.type_uris = [OPENID_2_0_TYPE]
    to_match.claimed_id = resp_msg.getArg(OPENID2_NS, 'claimed_id')
    to_match.local_id = resp_msg.getArg(OPENID2_NS, 'identity')

    # Raises a KeyError when the op_endpoint is not present
    to_match.server_url = resp_msg.getArg(
        OPENID2_NS, 'op_endpoint', no_default)

    # claimed_id and identifier must both be present or both
    # be absent
    if (to_match.claimed_id is None and
        to_match.local_id is not None):
        raise consumer.ProtocolError(
            'openid.identity is present without openid.claimed_id')

    elif (to_match.claimed_id is not None and
          to_match.local_id is None):
        raise consumer.ProtocolError(
            'openid.claimed_id is present without openid.identity')

    # This is a response without identifiers, so there's really no
    # checking that we can do, so return an endpoint that's for
    # the specified `openid.op_endpoint'
    elif to_match.claimed_id is None:
        return OpenIDServiceEndpoint.fromOPEndpointURL(to_match.server_url)

    # The claimed ID doesn't match, so we have to do discovery
    # again. This covers not using sessions, OP identifier
    # endpoints and responses that didn't match the original
    # request.
    if to_match.server_url.startswith(u'https://www.google.com/a/'):
        import urllib
        claimed_id = u'https://www.google.com/accounts/o8/user-xrds?uri=%s' % urllib.quote_plus(to_match.claimed_id)
    else:
        claimed_id = to_match.claimed_id

    if not endpoint:
        oidutil.log('No pre-discovered information supplied.')
        endpoint = self._discoverAndVerify(claimed_id, [to_match])
    else:
        # The claimed ID matches, so we use the endpoint that we
        # discovered in initiation. This should be the most common
        # case.
        try:
            self._verifyDiscoverySingle(endpoint, to_match)
        except consumer.ProtocolError, e:
            oidutil.log(
                "Error attempting to use stored discovery information: " +
                str(e))
            oidutil.log("Attempting discovery to verify endpoint")
            endpoint = self._discoverAndVerify(
                claimed_id, [to_match])

# 需要导入模块: from openid.consumer.discover import OpenIDServiceEndpoint [as 别名]
# 或者: from openid.consumer.discover.OpenIDServiceEndpoint import server_url [as 别名]
    def make_endpoint(self, protocol_uri, claimed_id, local_id=None):
        """Create an endpoint for use with `Consumer.beginWithoutDiscovery`.

        :arg protocol_uri: The URI for the OpenID protocol version.  This
            should be one of the OPENID_X_Y_TYPE constants.
        :arg claimed_id: The claimed identity URL for the endpoint.
        :arg local_id: The OP local identifier for the endpoint.  If this
            argument is not provided, it defaults to claimed_id.
        """
        msg = "Unexpected protocol URI: %s" % protocol_uri
        assert protocol_uri in OPENID_TYPES, msg

        endpoint = OpenIDServiceEndpoint()
        endpoint.type_uris = [protocol_uri]
        endpoint.server_url = self.base_openid_url
        endpoint.claimed_id = claimed_id
        endpoint.local_id = local_id or claimed_id
        return endpoint

# 需要导入模块: from openid.consumer.discover import OpenIDServiceEndpoint [as 别名]
# 或者: from openid.consumer.discover.OpenIDServiceEndpoint import server_url [as 别名]
def make_endpoint(protocol_uri, claimed_id, local_id=None):
    """Create an endpoint for use with `Consumer.beginWithoutDiscovery`.

    :arg protocol_uri: The URI for the OpenID protocol version.  This
        should be one of the OPENID_X_Y_TYPE constants.
    :arg claimed_id: The claimed identity URL for the endpoint.
    :arg local_id: The OP local identifier for the endpoint.  If this
        argument is not provided, it defaults to claimed_id.
    """
    assert protocol_uri in [
        OPENID_1_0_TYPE, OPENID_1_1_TYPE, OPENID_2_0_TYPE], (
        "Unexpected protocol URI: %s" % protocol_uri)

    endpoint = OpenIDServiceEndpoint()
    endpoint.type_uris = [protocol_uri]
    endpoint.server_url = get_requested_server_url(claimed_id)
    endpoint.claimed_id = claimed_id
    endpoint.local_id = local_id or claimed_id
    return endpoint

# 需要导入模块: from openid.consumer.discover import OpenIDServiceEndpoint [as 别名]
# 或者: from openid.consumer.discover.OpenIDServiceEndpoint import server_url [as 别名]
    def make_identifier_select_endpoint(self, protocol_uri):
        """Create an endpoint for use in OpenID identifier select mode.

        :arg protocol_uri: The URI for the OpenID protocol version.  This
            should be one of the OPENID_X_Y_TYPE constants.

        If the OpenID 1.x protocol is selected, the endpoint will be
        suitable for use with Launchpad's non-standard identifier select
        workflow.
        """
        msg = "Unexpected protocol URI: %s" % protocol_uri
        assert protocol_uri in OPENID_TYPES, msg

        endpoint = OpenIDServiceEndpoint()
        endpoint.server_url = self.base_openid_url
        if protocol_uri == OPENID_2_0_TYPE:
            endpoint.type_uris = [OPENID_IDP_2_0_TYPE]
        else:
            endpoint.type_uris = [protocol_uri]
            endpoint.claimed_id = IDENTIFIER_SELECT
            endpoint.local_id = IDENTIFIER_SELECT
        return endpoint

# 需要导入模块: from openid.consumer.discover import OpenIDServiceEndpoint [as 别名]
# 或者: from openid.consumer.discover.OpenIDServiceEndpoint import server_url [as 别名]
def make_identifier_select_endpoint():
    """Create an endpoint for use in OpenID identifier select mode."""
    endpoint = OpenIDServiceEndpoint()
    endpoint.server_url = get_server_url()
    endpoint.type_uris = [OPENID_IDP_2_0_TYPE]
    return endpoint

# 需要导入模块: from openid.consumer.discover import OpenIDServiceEndpoint [as 别名]
# 或者: from openid.consumer.discover.OpenIDServiceEndpoint import server_url [as 别名]
def _test_success(server_url, user_url, delegate_url, links, immediate=False):
    store = _memstore.MemoryStore()
    if immediate:
        mode = 'checkid_immediate'
    else:
        mode = 'checkid_setup'

    endpoint = OpenIDServiceEndpoint()
    endpoint.identity_url = user_url
    endpoint.server_url = server_url
    endpoint.delegate = delegate_url

    fetcher = TestFetcher(None, None, assocs[0])
    fetchers.setDefaultFetcher(fetcher, wrap_exceptions=False)

    def run():
        trust_root = consumer_url

        consumer = GenericConsumer(store)
        request = consumer.begin(endpoint)

        return_to = consumer_url
        redirect_url = request.redirectURL(trust_root, return_to, immediate)

        parsed = urlparse.urlparse(redirect_url)
        qs = parsed[4]
        q = parseQuery(qs)
        new_return_to = q['openid.return_to']
        del q['openid.return_to']
        assert q == {
            'openid.mode':mode,
            'openid.identity':delegate_url,
            'openid.trust_root':trust_root,
            'openid.assoc_handle':fetcher.assoc_handle,
            }, (q, user_url, delegate_url, mode)

        assert new_return_to.startswith(return_to)
        assert redirect_url.startswith(server_url)

        query = {
            'nonce':request.return_to_args['nonce'],
            'openid.mode':'id_res',
            'openid.return_to':new_return_to,
            'openid.identity':delegate_url,
            'openid.assoc_handle':fetcher.assoc_handle,
            }

        assoc = store.getAssociation(server_url, fetcher.assoc_handle)
        assoc.addSignature(['mode', 'return_to', 'identity'], query)

        info = consumer.complete(query, request.endpoint)
        assert info.status == SUCCESS, info.message
        assert info.identity_url == user_url

    assert fetcher.num_assocs == 0
    run()
    assert fetcher.num_assocs == 1

    # Test that doing it again uses the existing association
    run()
    assert fetcher.num_assocs == 1

    # Another association is created if we remove the existing one
    store.removeAssociation(server_url, fetcher.assoc_handle)
    run()
    assert fetcher.num_assocs == 2

    # Test that doing it again uses the existing association
    run()
    assert fetcher.num_assocs == 2

# 需要导入模块: from openid.consumer.discover import OpenIDServiceEndpoint [as 别名]
# 或者: from openid.consumer.discover.OpenIDServiceEndpoint import server_url [as 别名]
 def __init__(self, openid_namespace=OPENID2_NS):
     super(TestMessage, self).__init__(openid_namespace=openid_namespace)
     endpoint = OpenIDServiceEndpoint()
     endpoint.claimed_id = make_claimed_id('some-id')
     endpoint.server_url = SERVER_URL
     self.endpoint = endpoint