de.acosix.alfresco.keycloak.repo.authentication.SimpleCacheBackedSessionIdMapper Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of de.acosix.alfresco.keycloak.repo Show documentation
The newest version!
/*
 * Copyright 2019 - 2021 Acosix GmbH
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package de.acosix.alfresco.keycloak.repo.authentication;

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

import org.alfresco.repo.cache.SimpleCache;
import org.alfresco.util.PropertyCheck;
import org.keycloak.adapters.spi.SessionIdMapper;
import org.springframework.beans.factory.InitializingBean;

/**
 * @author Axel Faust
 */
public class SimpleCacheBackedSessionIdMapper implements SessionIdMapper, InitializingBean
{

    protected SimpleCache ssoToSession;

    protected SimpleCache sessionToSso;

    protected SimpleCache> principalToSession;

    protected SimpleCache sessionToPrincipal;

    /**
     * {@inheritDoc}
     */
    @Override
    public void afterPropertiesSet()
    {
        PropertyCheck.mandatory(this, "ssoToSession", this.ssoToSession);
        PropertyCheck.mandatory(this, "sessionToSso", this.sessionToSso);
        PropertyCheck.mandatory(this, "principalToSession", this.principalToSession);
        PropertyCheck.mandatory(this, "sessionToPrincipal", this.sessionToPrincipal);
    }

    /**
     * @param ssoToSession
     *            the ssoToSession to set
     */
    public void setSsoToSession(final SimpleCache ssoToSession)
    {
        this.ssoToSession = ssoToSession;
    }

    /**
     * @param sessionToSso
     *            the sessionToSso to set
     */
    public void setSessionToSso(final SimpleCache sessionToSso)
    {
        this.sessionToSso = sessionToSso;
    }

    /**
     * @param principalToSession
     *            the principalToSession to set
     */
    public void setPrincipalToSession(final SimpleCache> principalToSession)
    {
        this.principalToSession = principalToSession;
    }

    /**
     * @param sessionToPrincipal
     *            the sessionToPrincipal to set
     */
    public void setSessionToPrincipal(final SimpleCache sessionToPrincipal)
    {
        this.sessionToPrincipal = sessionToPrincipal;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean hasSession(final String id)
    {
        final boolean hasSession = this.sessionToSso.contains(id) || this.sessionToPrincipal.contains(id);
        return hasSession;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void clear()
    {
        this.ssoToSession.clear();
        this.sessionToSso.clear();
        this.principalToSession.clear();
        this.sessionToPrincipal.clear();
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public Set getUserSessions(final String principal)
    {
        Set userSessions = Collections.emptySet();
        final Set lookup = this.principalToSession.get(principal);
        if (lookup != null)
        {
            userSessions = new HashSet<>(lookup);
        }
        return userSessions;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getSessionFromSSO(final String sso)
    {
        return this.ssoToSession.get(sso);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void map(final String sso, final String principal, final String session)
    {
        if (sso != null)
        {
            this.ssoToSession.put(sso, session);
            this.sessionToSso.put(session, sso);
        }

        if (principal != null)
        {
            Set userSessions = this.principalToSession.get(principal);
            if (userSessions == null)
            {
                userSessions = new HashSet<>();
                this.principalToSession.put(principal, userSessions);

            }
            userSessions.add(session);
            this.sessionToPrincipal.put(session, principal);
        }
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void removeSession(final String session)
    {
        final String sso = this.sessionToSso.get(session);
        this.sessionToSso.remove(session);
        if (sso != null)
        {
            this.ssoToSession.remove(sso);
        }
        final String principal = this.sessionToPrincipal.get(session);
        this.sessionToPrincipal.remove(session);
        if (principal != null)
        {
            final Set sessions = this.principalToSession.get(principal);
            sessions.remove(session);
            if (sessions.isEmpty())
            {
                this.principalToSession.remove(principal);
            }
        }
    }

}