org.keycloak.adapters.elytron.ElytronHttpFacade クラス

org.keycloak.adapters.elytron.ElytronHttpFacade の継承関係図

org.keycloak.adapters.elytron.ElytronHttpFacade 連携図

公開メンバ関数
	ElytronHttpFacade (HttpServerRequest request, AdapterDeploymentContext deploymentContext, CallbackHandler handler)
Request	getRequest ()
Response	getResponse ()
X509Certificate []	getCertificateChain ()
KeycloakSecurityContext	getSecurityContext ()
boolean	restoreRequest ()
void	suspendRequest ()
boolean	isAuthorized ()

関数
void	authenticationComplete (ElytronAccount account, boolean storeToken)
void	authenticationComplete ()
void	authenticationFailed ()
void	noAuthenticationInProgress ()
void	noAuthenticationInProgress (AuthChallenge challenge)
void	authenticationInProgress ()
HttpScope	getScope (Scope scope)
HttpScope	getScope (Scope scope, String id)
Collection< String >	getScopeIds (Scope scope)
AdapterTokenStore	getTokenStore ()
KeycloakDeployment	getDeployment ()

静的変数
static final String	UNDERTOW_EXCHANGE = ElytronHttpFacade.class.getName() + ".undertow.exchange"

非公開メンバ関数
AdapterTokenStore	createTokenStore ()

非公開変数類
final HttpServerRequest	request
final CallbackHandler	callbackHandler
final AdapterTokenStore	tokenStore
final AdapterDeploymentContext	deploymentContext
Consumer< HttpServerResponse >	responseConsumer
ElytronAccount	account
SecurityIdentity	securityIdentity
boolean	restored
final Map< String, String >	headers = new HashMap<>()

詳解

著者

Pedro Igor

構築子と解体子

ElytronHttpFacade()

org.keycloak.adapters.elytron.ElytronHttpFacade.ElytronHttpFacade ( HttpServerRequest  request, AdapterDeploymentContext  deploymentContext, CallbackHandler  handler  )

inline

                                                                                                                             {
        this.request = request;
        this.deploymentContext = deploymentContext;
        this.callbackHandler = handler;
        this.tokenStore = createTokenStore();
        this.responseConsumer = response -> {};
    }

関数詳解

authenticationComplete() [1/2]

void org.keycloak.adapters.elytron.ElytronHttpFacade.authenticationComplete ( ElytronAccount  account, boolean  storeToken  )

inlinepackage

                                                                            {
        this.securityIdentity = SecurityIdentityUtil.authorize(this.callbackHandler, account.getPrincipal());

        if (securityIdentity != null) {
            this.account = account;
            RefreshableKeycloakSecurityContext keycloakSecurityContext = account.getKeycloakSecurityContext();
            account.setCurrentRequestInfo(keycloakSecurityContext.getDeployment(), this.tokenStore);
            if (storeToken) {
                this.tokenStore.saveAccountInfo(account);
            }
        }
    }

authenticationComplete() [2/2]

void org.keycloak.adapters.elytron.ElytronHttpFacade.authenticationComplete ( )

inlinepackage

                                  {
        if (securityIdentity != null) {
            HttpScope requestScope = request.getScope(Scope.EXCHANGE);
            RefreshableKeycloakSecurityContext keycloakSecurityContext = account.getKeycloakSecurityContext();

            requestScope.setAttachment(KeycloakSecurityContext.class.getName(), keycloakSecurityContext);

            this.request.authenticationComplete(response -> {
                if (!restored) {
                    responseConsumer.accept(response);
                }
            }, () -> ((ElytronTokeStore) tokenStore).logout(true));
        }
    }

authenticationFailed()

void org.keycloak.adapters.elytron.ElytronHttpFacade.authenticationFailed ( )

inlinepackage

                                {
        this.request.authenticationFailed("Authentication Failed", response -> responseConsumer.accept(response));
    }

authenticationInProgress()

void org.keycloak.adapters.elytron.ElytronHttpFacade.authenticationInProgress ( )

inlinepackage

                                    {
        this.request.authenticationInProgress(response -> responseConsumer.accept(response));
    }

createTokenStore()

AdapterTokenStore org.keycloak.adapters.elytron.ElytronHttpFacade.createTokenStore ( )

inlineprivate

                                                 {
        KeycloakDeployment deployment = getDeployment();

        if (TokenStore.SESSION.equals(deployment.getTokenStore())) {
            return new ElytronSessionTokenStore(this, this.callbackHandler);
        } else {
            return new ElytronCookieTokenStore(this, this.callbackHandler);
        }
    }

getCertificateChain()

X509Certificate [] org.keycloak.adapters.elytron.ElytronHttpFacade.getCertificateChain ( )

inline

                                                   {
        return new X509Certificate[0];
    }

getDeployment()

KeycloakDeployment org.keycloak.adapters.elytron.ElytronHttpFacade.getDeployment ( )

inlinepackage

                                       {
        return deploymentContext.resolveDeployment(this);
    }

getRequest()

Request org.keycloak.adapters.elytron.ElytronHttpFacade.getRequest ( )

inline

                                {
        return new Request() {
            private InputStream inputStream;

            @Override
            public String getMethod() {
                return request.getRequestMethod();
            }

            @Override
            public String getURI() {
                try {
                    return URLDecoder.decode(request.getRequestURI().toString(), "UTF-8");
                } catch (UnsupportedEncodingException e) {
                    throw new RuntimeException("Failed to decode request URI", e);
                }
            }

            @Override
            public String getRelativePath() {
                return request.getRequestPath();
            }

            @Override
            public boolean isSecure() {
                return request.getRequestURI().getScheme().equals("https");
            }

            @Override
            public String getFirstParam(String param) {
                return request.getFirstParameterValue(param);
            }

            @Override
            public String getQueryParamValue(String param) {
                URI requestURI = request.getRequestURI();
                String query = requestURI.getQuery();
                if (query != null) {
                    String[] parameters = query.split("&");
                    for (String parameter : parameters) {
                        String[] keyValue = parameter.split("=");
                        if (keyValue[0].equals(param)) {
                            return keyValue[1];
                        }
                    }
                }
                return null;
            }

            @Override
            public Cookie getCookie(final String cookieName) {
                List<HttpServerCookie> cookies = request.getCookies();

                if (cookies != null) {
                    for (HttpServerCookie cookie : cookies) {
                        if (cookie.getName().equals(cookieName)) {
                            return new Cookie(cookie.getName(), cookie.getValue(), cookie.getVersion(), cookie.getDomain(), cookie.getPath());
                        }
                    }
                }

                return null;
            }

            @Override
            public String getHeader(String name) {
                return request.getFirstRequestHeaderValue(name);
            }

            @Override
            public List<String> getHeaders(String name) {
                return request.getRequestHeaderValues(name);
            }

            @Override
            public InputStream getInputStream() {
                return getInputStream(false);
            }

            @Override
            public InputStream getInputStream(boolean buffered) {
                if (inputStream != null) {
                    return inputStream;
                }

                if (buffered) {
                    return inputStream = new BufferedInputStream(request.getInputStream());
                }

                return request.getInputStream();
            }

            @Override
            public String getRemoteAddr() {
                InetSocketAddress sourceAddress = request.getSourceAddress();
                if (sourceAddress == null) {
                    return "";
                }
                InetAddress address = sourceAddress.getAddress();
                if (address == null) {
                    // this is unresolved, so we just return the host name not exactly spec, but if the name should be
                    // resolved then a PeerNameResolvingHandler should be used and this is probably better than just
                    // returning null
                    return sourceAddress.getHostString();
                }
                return address.getHostAddress();
            }

            @Override
            public void setError(AuthenticationError error) {
                request.getScope(Scope.EXCHANGE).setAttachment(AuthenticationError.class.getName(), error);
            }

            @Override
            public void setError(LogoutError error) {
                request.getScope(Scope.EXCHANGE).setAttachment(LogoutError.class.getName(), error);
            }
        };
    }

getResponse()

Response org.keycloak.adapters.elytron.ElytronHttpFacade.getResponse ( )

inline

                                  {
        return new Response() {

            @Override
            public void setStatus(final int status) {
                if (status < 200 || status > 300) {
                    responseConsumer = responseConsumer.andThen(response -> response.setStatusCode(status));
                }
            }

            @Override
            public void addHeader(final String name, final String value) {
                headers.put(name, value);
                responseConsumer = responseConsumer.andThen(new Consumer<HttpServerResponse>() {
                    @Override
                    public void accept(HttpServerResponse response) {
                        String latestValue = headers.get(name);

                        if (latestValue.equals(value)) {
                            response.addResponseHeader(name, latestValue);
                        }
                    }
                });
            }

            @Override
            public void setHeader(String name, String value) {
                addHeader(name, value);
            }

            @Override
            public void resetCookie(final String name, final String path) {
                responseConsumer = responseConsumer.andThen(response -> setCookie(name, "", path, null, 0, false, false, response));
                HttpScope exchangeScope = getScope(Scope.EXCHANGE);
                ProtectedHttpServerExchange undertowExchange = ProtectedHttpServerExchange.class.cast(exchangeScope.getAttachment(UNDERTOW_EXCHANGE));

                if (undertowExchange != null) {
                    CookieImpl cookie = new CookieImpl(name, "");

                    cookie.setMaxAge(0);
                    cookie.setPath(path);

                    undertowExchange.getExchange().setResponseCookie(cookie);
                }
            }

            @Override
            public void setCookie(final String name, final String value, final String path, final String domain, final int maxAge, final boolean secure, final boolean httpOnly) {
                responseConsumer = responseConsumer.andThen(response -> setCookie(name, value, path, domain, maxAge, secure, httpOnly, response));
            }

            private void setCookie(final String name, final String value, final String path, final String domain, final int maxAge, final boolean secure, final boolean httpOnly, HttpServerResponse response) {
                response.setResponseCookie(new HttpServerCookie() {
                    @Override
                    public String getName() {
                        return name;
                    }

                    @Override
                    public String getValue() {
                        return value;
                    }

                    @Override
                    public String getDomain() {
                        return domain;
                    }

                    @Override
                    public int getMaxAge() {
                        return maxAge;
                    }

                    @Override
                    public String getPath() {
                        return path;
                    }

                    @Override
                    public boolean isSecure() {
                        return secure;
                    }

                    @Override
                    public int getVersion() {
                        return 0;
                    }

                    @Override
                    public boolean isHttpOnly() {
                        return httpOnly;
                    }
                });
            }

            @Override
            public OutputStream getOutputStream() {
                ByteArrayOutputStream stream = new ByteArrayOutputStream();
                responseConsumer = responseConsumer.andThen(new Consumer<HttpServerResponse>() {
                    @Override
                    public void accept(HttpServerResponse httpServerResponse) {
                        try {
                            httpServerResponse.getOutputStream().write(stream.toByteArray());
                        } catch (IOException e) {
                            throw new RuntimeException("Failed to write to response output stream", e);
                        }
                    }
                });
                return stream;
            }

            @Override
            public void sendError(int code) {
                setStatus(code);
            }

            @Override
            public void sendError(final int code, final String message) {
                responseConsumer = responseConsumer.andThen(response -> {
                    response.setStatusCode(code);
                    response.addResponseHeader("Content-Type", "text/html");
                    try {
                        response.getOutputStream().write(message.getBytes());
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                });
            }

            @Override
            public void end() {

            }
        };
    }

getScope() [1/2]

HttpScope org.keycloak.adapters.elytron.ElytronHttpFacade.getScope ( Scope  scope )

inlinepackage

                                    {
        return request.getScope(scope);
    }

getScope() [2/2]

HttpScope org.keycloak.adapters.elytron.ElytronHttpFacade.getScope ( Scope  scope, String  id  )

inlinepackage

                                               {
        return request.getScope(scope, id);
    }

getScopeIds()

Collection<String> org.keycloak.adapters.elytron.ElytronHttpFacade.getScopeIds ( Scope  scope )

inlinepackage

                                                {
        return request.getScopeIds(scope);
    }

getSecurityContext()

KeycloakSecurityContext org.keycloak.adapters.elytron.ElytronHttpFacade.getSecurityContext ( )

inline

org.keycloak.adapters.OIDCHttpFacadeを実装しています。

                                                        {
        if (account == null) {
            return null;
        }
        return this.account.getKeycloakSecurityContext();
    }

getTokenStore()

AdapterTokenStore org.keycloak.adapters.elytron.ElytronHttpFacade.getTokenStore ( )

inlinepackage

                                      {
        return this.tokenStore;
    }

isAuthorized()

boolean org.keycloak.adapters.elytron.ElytronHttpFacade.isAuthorized ( )

inline

                                  {
        return this.securityIdentity != null;
    }

noAuthenticationInProgress() [1/2]

void org.keycloak.adapters.elytron.ElytronHttpFacade.noAuthenticationInProgress ( )

inlinepackage

                                      {
        this.request.noAuthenticationInProgress();
    }

noAuthenticationInProgress() [2/2]

void org.keycloak.adapters.elytron.ElytronHttpFacade.noAuthenticationInProgress ( AuthChallenge  challenge )

inlinepackage

                                                             {
        if (challenge != null) {
            challenge.challenge(this);
        }
        this.request.noAuthenticationInProgress(response -> responseConsumer.accept(response));
    }

restoreRequest()

boolean org.keycloak.adapters.elytron.ElytronHttpFacade.restoreRequest ( )

inline

                                    {
        restored = this.request.resumeRequest();
        return restored;
    }

suspendRequest()

void org.keycloak.adapters.elytron.ElytronHttpFacade.suspendRequest ( )

inline

                                 {
        responseConsumer = responseConsumer.andThen(httpServerResponse -> request.suspendRequest());
    }

メンバ詳解

account

ElytronAccount org.keycloak.adapters.elytron.ElytronHttpFacade.account

private

callbackHandler

final CallbackHandler org.keycloak.adapters.elytron.ElytronHttpFacade.callbackHandler

private

deploymentContext

final AdapterDeploymentContext org.keycloak.adapters.elytron.ElytronHttpFacade.deploymentContext

private

headers

final Map<String, String> org.keycloak.adapters.elytron.ElytronHttpFacade.headers = new HashMap<>()

private

request

final HttpServerRequest org.keycloak.adapters.elytron.ElytronHttpFacade.request

private

responseConsumer

Consumer<HttpServerResponse> org.keycloak.adapters.elytron.ElytronHttpFacade.responseConsumer

private

restored

boolean org.keycloak.adapters.elytron.ElytronHttpFacade.restored

private

securityIdentity

SecurityIdentity org.keycloak.adapters.elytron.ElytronHttpFacade.securityIdentity

private

tokenStore

final AdapterTokenStore org.keycloak.adapters.elytron.ElytronHttpFacade.tokenStore

private

UNDERTOW_EXCHANGE

final String org.keycloak.adapters.elytron.ElytronHttpFacade.UNDERTOW_EXCHANGE = ElytronHttpFacade.class.getName() + ".undertow.exchange"

staticpackage

---

このクラス詳解は次のファイルから抽出されました:

• D:/AppData/OpenId/keycloak/doxygen/src/adapters/oidc/wildfly-elytron/src/main/java/org/keycloak/adapters/elytron/ElytronHttpFacade.java