Esempio n. 1
0
    def authenticate_tenant(self, tenant_id, log=None):
        """
        see :meth:`IAuthenticator.authenticate_tenant`
        """
        auth = partial(self._auth_me, log=log)

        d = user_for_tenant(
            self._admin_url, self._identity_admin_user, self._identity_admin_password, tenant_id, log=log
        )

        def impersonate(user):
            iud = impersonate_user(self._admin_url, self._token, user, log=log)
            iud.addCallback(extract_token)
            return iud

        d.addCallback(lambda user: retry_on_unauth(partial(impersonate, user), auth))

        def endpoints(token):
            scd = endpoints_for_token(self._admin_url, self._token, token, log=log)
            scd.addCallback(lambda endpoints: (token, _endpoints_to_service_catalog(endpoints)))
            return scd

        d.addCallback(lambda token: retry_on_unauth(partial(endpoints, token), auth))

        return d
Esempio n. 2
0
    def authenticate_tenant(self, tenant_id, log=None):
        """
        see :meth:`IAuthenticator.authenticate_tenant`
        """
        auth = partial(self._auth_me, log=log)

        d = user_for_tenant(self._admin_url,
                            self._identity_admin_user,
                            self._identity_admin_password,
                            tenant_id,
                            log=log)

        def impersonate(user):
            iud = impersonate_user(self._admin_url, self._token, user, log=log)
            iud.addCallback(extract_token)
            return iud

        d.addCallback(
            lambda user: retry_on_unauth(partial(impersonate, user), auth))

        def endpoints(token):
            scd = endpoints_for_token(self._admin_url,
                                      self._token,
                                      token,
                                      log=log)
            scd.addCallback(lambda endpoints:
                            (token, _endpoints_to_service_catalog(endpoints)))
            return scd

        d.addCallback(
            lambda token: retry_on_unauth(partial(endpoints, token), auth))

        return d
Esempio n. 3
0
 def test_non_apierror(self):
     """
     Any error other than APIError in UpstreamError is propogated
     """
     d = retry_on_unauth(
         lambda: fail(UpstreamError(Failure(ValueError('a')), 'identity', 'o')),
         self.auth)
     f = self.failureResultOf(d, UpstreamError)
     f.value.reason.trap(ValueError)
Esempio n. 4
0
 def test_500_error(self):
     """
     Any error other than 401 is propogated
     """
     d = retry_on_unauth(
         lambda: fail(UpstreamError(Failure(APIError(500, 'a')), 'identity', 'o')),
         self.auth)
     f = self.failureResultOf(d, UpstreamError)
     f.value.reason.trap(APIError)
     self.assertEqual(f.value.reason.value.code, 500)
Esempio n. 5
0
 def test_auth_error_propogates(self):
     """
     `auth()` errors are propogated
     """
     auth = mock.Mock(spec=[], return_value=fail(ValueError('a')))
     func = mock.Mock(side_effect=[
         fail(UpstreamError(Failure(APIError(401, '401')), 'identity', 'o')),
         succeed('r')])
     d = retry_on_unauth(func, auth)
     self.failureResultOf(d, ValueError)
     auth.assert_called_once_with()
Esempio n. 6
0
 def test_auth_error(self):
     """
     Calls auth() followed by func() again if initial func() returns 401
     """
     auth = mock.Mock(spec=[], return_value=succeed('a'))
     func = mock.Mock(side_effect=[
         fail(UpstreamError(Failure(APIError(401, '401')), 'identity', 'o')),
         succeed('r')])
     d = retry_on_unauth(func, auth)
     self.assertEqual(self.successResultOf(d), 'r')
     auth.assert_called_once_with()
Esempio n. 7
0
 def test_non_upstream(self):
     """
     Any error other than UpstreamError is returned
     """
     d = retry_on_unauth(lambda: fail(ValueError('a')), self.auth)
     self.failureResultOf(d, ValueError)
Esempio n. 8
0
 def test_success(self):
     """
     `func` value is returned if it succeeds
     """
     d = retry_on_unauth(lambda: succeed('a'), self.auth)
     self.assertEqual(self.successResultOf(d), 'a')