org.gluu.credmanager.core.ExtensionsManager クラス

org.gluu.credmanager.core.ExtensionsManager の継承関係図

org.gluu.credmanager.core.ExtensionsManager 連携図

公開メンバ関数
Optional< AuthnMethod >	getExtensionForAcr (String acr)
boolean	pluginImplementsAuthnMethod (String acr, String plugId)
ClassLoader	getPluginClassLoader (String clsName)
List< AuthnMethod >	getAuthnMethodExts ()
Path	getPluginsRoot ()
List< PluginWrapper >	getPlugins ()
String	loadPlugin (Path path)
boolean	unloadPlugin (String pluginId)
boolean	stopPlugin (String pluginId)
boolean	deletePlugin (String pluginId)
boolean	startPlugin (String pluginId)

静的公開変数類
static final String	ASSETS_DIR = "assets"

関数
void	scan ()
public< T > List< T >	getSystemExtensionsForClass (Class< T > clazz)

非公開メンバ関数
void	inited ()
boolean	startPlugin (String pluginId, boolean refreshLabels)
List< AuthnMethod >	scanInnerAuthnMechanisms ()
void	parsePluginAuthnMethodExtensions (String pluginId)
Path	getDestinationPathForPlugin (String pluginId)
void	extractResources (String pluginId, Path path) throws IOException
void	reconfigureServices (String pluginId, Path path, ClassLoader cl)
void	purgePluginsPath ()

非公開変数類
Logger	logger
ConfigurationHandler	configurationHandler
ZKService	zkService
MainSettings	mainSettings
ResourceExtractor	resourceExtractor
RSRegistryHandler	registryHandler
Path	pluginsRoot
PluginManager	pluginManager
Map< String, List< AuthnMethod > >	plugExtensionMap

静的非公開変数類
static final String	PLUGINS_DIR_NAME = "plugins"
static final Class< AuthnMethod >	AUTHN_METHOD_CLASS = AuthnMethod.class

詳解

著者

jgomer

関数詳解

deletePlugin()

boolean org.gluu.credmanager.core.ExtensionsManager.deletePlugin ( String  pluginId )

inline

                                                 {

        //Not used, see: https://github.com/pf4j/pf4j/issues/217
        boolean success = pluginManager.deletePlugin(pluginId);
        if (!success) {
            logger.warn("Plugin '{}' could not be unloaded or deleted", pluginId);
        }
        return success;

    }

extractResources()

void org.gluu.credmanager.core.ExtensionsManager.extractResources ( String  pluginId, Path  path  ) throws IOException

inlineprivate

                                                                                 {

        Path destPath = getDestinationPathForPlugin(pluginId);
        logger.info("Extracting resources for plugin {} to {}", pluginId, destPath.toString());

        if (Files.isDirectory(path)) {
            path = Paths.get(path.toString(), ASSETS_DIR);
            if (Files.isDirectory(path)) {
                resourceExtractor.createDirectory(path, destPath);
            } else {
                logger.info("No resources to extract");
            }
        } else if (Utils.isJarFile(path)) {
            try (JarInputStream jis = new JarInputStream(new BufferedInputStream(new FileInputStream(path.toString())), false)) {
                resourceExtractor.createDirectory(jis, ASSETS_DIR + "/", destPath);
            }
        }

    }

getAuthnMethodExts()

List<AuthnMethod> org.gluu.credmanager.core.ExtensionsManager.getAuthnMethodExts ( )

inline

                                                  {
        return plugExtensionMap.values().stream().flatMap(List::stream).collect(Collectors.toList());
    }

getDestinationPathForPlugin()

Path org.gluu.credmanager.core.ExtensionsManager.getDestinationPathForPlugin ( String  pluginId )

inlineprivate

                                                              {
        return Paths.get(zkService.getAppFileSystemRoot(), RSRegistryHandler.ENDPOINTS_PREFIX, pluginId);
    }

getExtensionForAcr()

Optional<AuthnMethod> org.gluu.credmanager.core.ExtensionsManager.getExtensionForAcr ( String  acr )

inline

                                                                {

        AuthnMethod handler = null;
        String plugId = mainSettings.getAcrPluginMap().get(acr);

        List<AuthnMethod> exts = plugExtensionMap.get(plugId);
        //Returns the first occurrence!
        for (AuthnMethod aMethod : exts) {
            if (aMethod.getAcr().equals(acr)) {
                handler = exts.get(0);
                break;
            }
        }
        return Optional.ofNullable(handler);

    }

getPluginClassLoader()

ClassLoader org.gluu.credmanager.core.ExtensionsManager.getPluginClassLoader ( String  clsName )

inline

org.gluu.credmanager.service.IExtensionsManagerを実装しています。

                                                            {

        ClassLoader clsLoader = null;
        for (PluginWrapper wrapper : pluginManager.getStartedPlugins()) {
            try {
                String pluginClassName = wrapper.getDescriptor().getPluginClass();
                ClassLoader loader = wrapper.getPluginClassLoader();

                Class<?> cls = loader.loadClass(pluginClassName);
                if (clsName.startsWith(cls.getPackage().getName())) {
                    clsLoader = loader;
                    break;
                }
            } catch (ClassNotFoundException e) {
                //Intentionally left empty
            }
        }
        return clsLoader;

    }

getPlugins()

List<PluginWrapper> org.gluu.credmanager.core.ExtensionsManager.getPlugins ( )

inline

                                            {
        return pluginManager.getPlugins();
    }

getPluginsRoot()

Path org.gluu.credmanager.core.ExtensionsManager.getPluginsRoot ( )

inline

                                 {
        return pluginsRoot;
    }

getSystemExtensionsForClass()

public<T> List<T> org.gluu.credmanager.core.ExtensionsManager.getSystemExtensionsForClass ( Class< T >  clazz )

inlinepackage

                                                                   {
        return pluginManager.getExtensions(clazz);
    }

inited()

void org.gluu.credmanager.core.ExtensionsManager.inited ( )

inlineprivate

                          {

        pluginsRoot = Paths.get(System.getProperty("server.base"), PLUGINS_DIR_NAME);
        pluginManager = new DefaultPluginManager();
        plugExtensionMap = new HashMap<>();    //It accepts null keys

        if (Files.isDirectory(pluginsRoot)) {
            purgePluginsPath();
        } else {
            pluginsRoot = null;
            logger.warn("External plugins directory does not exist: there is no valid location for searching");
        }

    }

loadPlugin()

String org.gluu.credmanager.core.ExtensionsManager.loadPlugin ( Path  path )

inline

                                        {
        String id = pluginManager.loadPlugin(path);
        if (id != null) {
            logger.debug("Loaded plugin {}, now in state {}", id, pluginManager.getPlugin(id).getPluginState().toString());
        } else {
            logger.warn("Plugin found at {} could not be loaded", path.toString());
        }
        return id;
    }

parsePluginAuthnMethodExtensions()

void org.gluu.credmanager.core.ExtensionsManager.parsePluginAuthnMethodExtensions ( String  pluginId )

inlineprivate

                                                                   {

        List<AuthnMethod> ames = pluginManager.getExtensions(AUTHN_METHOD_CLASS, pluginId);
        if (ames.size() > 0) {
            logger.info("Plugin extends {} at {} point(s)", AUTHN_METHOD_CLASS.getName(), ames.size());

            for (AuthnMethod ext : ames) {
                logger.info("Extension point found to deal with acr value '{}'", ext.getAcr());
            }

            List<AuthnMethod> exts = new ArrayList<>(ames);
            //I think this is safer than simply plugExtensionMap.put(pluginId, ames)
            plugExtensionMap.put(pluginId, exts);

        }

    }

pluginImplementsAuthnMethod()

boolean org.gluu.credmanager.core.ExtensionsManager.pluginImplementsAuthnMethod ( String  acr, String  plugId  )

inline

                                                                          {
        return plugExtensionMap.get(plugId).stream().anyMatch(aMethod -> aMethod.getAcr().equals(acr));
    }

purgePluginsPath()

void org.gluu.credmanager.core.ExtensionsManager.purgePluginsPath ( )

inlineprivate

                                    {

        //Deletes all files in path directory as a consequence of https://github.com/pf4j/pf4j/issues/217
        //Also prevents cheating...
        try {
            List<PluginInfo> pls = Optional.ofNullable(mainSettings.getKnownPlugins()).orElse(Collections.emptyList());
            List<String> validFileNames = pls.stream().map(PluginInfo::getRelativePath).collect(Collectors.toList());

            Files.list(pluginsRoot).forEach(p -> {
                if (Files.isRegularFile(p)) {
                    if (!validFileNames.contains(p.getFileName().toString())) {
                        try {
                            Files.delete(p);
                        } catch (Exception e) {
                            logger.error("Error deleting unnecesary file {}: {}", p.toString(), e.getMessage());
                        }
                    }
                } else if (Files.isDirectory(p)) {
                    //TODO add support for directory-based plugins
                }
            });

        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            logger.warn("An error occured while cleaning plugins directory {}", pluginsRoot.toString());
        }

    }

reconfigureServices()

void org.gluu.credmanager.core.ExtensionsManager.reconfigureServices ( String  pluginId, Path  path, ClassLoader  cl  )

inlineprivate

                                                                                 {

        try {
            extractResources(pluginId, path);
        } catch (IOException e) {
            logger.error("Error when extracting plugin resources");
            logger.error(e.getMessage(), e);
        }
        zkService.readPluginLabels(pluginId, path);
        registryHandler.scan(pluginId, path, cl);

    }

scan()

void org.gluu.credmanager.core.ExtensionsManager.scan ( )

inlinepackage

                {

        //Load inner extensions first, then load plugins
        plugExtensionMap.put(null, scanInnerAuthnMechanisms());

        if (pluginsRoot != null) {
            List<PluginInfo> pls = Optional.ofNullable(mainSettings.getKnownPlugins()).orElse(Collections.emptyList());

            if (pls.size() > 0) {
                logger.info("Loading external plugins...");

                List<String> loaded = new ArrayList<>();
                for (PluginInfo pl : pls) {
                    String id = loadPlugin(Paths.get(pluginsRoot.toString(), pl.getRelativePath()));
                    if (id != null) {
                        loaded.add(id);
                    }
                }

                logger.info("Total plugins loaded {}", loaded.size());
                int started = 0;

                for (String pluginId : loaded) {
                    if (pls.stream().anyMatch(pl -> pl.getId().equals(pluginId) && PluginState.STARTED.toString().equals(pl.getState()))) {

                        if (startPlugin(pluginId, false)) {
                            started++;
                            PluginWrapper wrapper = pluginManager.getPlugin(pluginId);

                            logger.info("Plugin {} ({}) started", pluginId, wrapper.getDescriptor().getPluginClass());

                            Set<String> classNames = pluginManager.getExtensionClassNames(pluginId);
                            //classNames.remove(AUTHN_METHOD_CLASS.getName());
                            if (classNames.size() > 0) {
                                logger.info("Plugin's extensions are at: {}", classNames.toString());
                            }
                            logger.info("");

                        }
                    }
                }
                logger.info("Plugins started {}", started);
            }
            zkService.refreshLabels();

        }

        long distinctAcrs = plugExtensionMap.values().stream().flatMap(List::stream).map(AuthnMethod::getAcr).distinct().count();
        if (distinctAcrs < plugExtensionMap.values().stream().mapToLong(List::size).sum()) {
            logger.warn("Several extensions pretend to handle the same acr.");
            logger.warn("Only the first one parsed for the plugin referenced in the config file will be effective");
            logger.warn("The system extension (if exists) will be used if no plugin can handle an acr");
        }

    }

scanInnerAuthnMechanisms()

List<AuthnMethod> org.gluu.credmanager.core.ExtensionsManager.scanInnerAuthnMechanisms ( )

inlineprivate

                                                         {

        List<AuthnMethod> actualAMEs = new ArrayList<>();
        List<AuthnMethod> authnMethodExtensions = pluginManager.getExtensions(AUTHN_METHOD_CLASS);
        if (authnMethodExtensions != null) {

            for (AuthnMethod ext : authnMethodExtensions) {
                String acr = ext.getAcr();
                String name = ext.getClass().getName();
                logger.info("Found system extension '{}' for {}", name, acr);
                actualAMEs.add(ext);
            }
        }
        return actualAMEs;

    }

startPlugin() [1/2]

boolean org.gluu.credmanager.core.ExtensionsManager.startPlugin ( String  pluginId )

inline

                                                {
        return startPlugin(pluginId, true);
    }

startPlugin() [2/2]

boolean org.gluu.credmanager.core.ExtensionsManager.startPlugin ( String  pluginId, boolean  refreshLabels  )

inlineprivate

                                                                        {

        boolean success = false;
        PluginState state = pluginManager.startPlugin(pluginId);
        Path path = pluginManager.getPlugin(pluginId).getPluginPath();

        if (PluginState.STARTED.equals(state)) {
            parsePluginAuthnMethodExtensions(pluginId);

            /*
            //Notifies activation/deactivation for extensions handling authentication methods
            Set<String> acrs = configurationHandler.retrieveAcrs();
            plugExtensionMap.forEach(pair -> pair.getX().deactivate());
            for (String acr : acrs) {
                getExtensionForAcr(acr).activate();
            } */
            reconfigureServices(pluginId, path, pluginManager.getPluginClassLoader(pluginId));
            success = true;

            if (refreshLabels) {
                zkService.refreshLabels();
            }
        } else {
            logger.warn("Plugin loaded from {} not started. Current state is {}", path.toString(), state == null ? null : state.toString());
        }
        return success;

    }

stopPlugin()

boolean org.gluu.credmanager.core.ExtensionsManager.stopPlugin ( String  pluginId )

inline

                                               {

        PluginState state = pluginManager.stopPlugin(pluginId);
        try {
            if (state.equals(PluginState.STOPPED)) {
                plugExtensionMap.remove(pluginId);
                zkService.removePluginLabels(pluginId);
                registryHandler.remove(pluginId);
                resourceExtractor.removeDestinationDirectory(getDestinationPathForPlugin(pluginId));
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
        return state.equals(PluginState.STOPPED);

    }

unloadPlugin()

boolean org.gluu.credmanager.core.ExtensionsManager.unloadPlugin ( String  pluginId )

inline

                                                 {
        boolean unloaded = pluginManager.unloadPlugin(pluginId);
        logger.debug("Plugin {} was{} unloaded", pluginId, unloaded ? "" : "not");
        return unloaded;
    }

メンバ詳解

ASSETS_DIR

final String org.gluu.credmanager.core.ExtensionsManager.ASSETS_DIR = "assets"

static

AUTHN_METHOD_CLASS

final Class<AuthnMethod> org.gluu.credmanager.core.ExtensionsManager.AUTHN_METHOD_CLASS = AuthnMethod.class

staticprivate

configurationHandler

ConfigurationHandler org.gluu.credmanager.core.ExtensionsManager.configurationHandler

private

logger

Logger org.gluu.credmanager.core.ExtensionsManager.logger

private

mainSettings

MainSettings org.gluu.credmanager.core.ExtensionsManager.mainSettings

private

plugExtensionMap

Map<String, List<AuthnMethod> > org.gluu.credmanager.core.ExtensionsManager.plugExtensionMap

private

pluginManager

PluginManager org.gluu.credmanager.core.ExtensionsManager.pluginManager

private

PLUGINS_DIR_NAME

final String org.gluu.credmanager.core.ExtensionsManager.PLUGINS_DIR_NAME = "plugins"

staticprivate

pluginsRoot

Path org.gluu.credmanager.core.ExtensionsManager.pluginsRoot

private

registryHandler

RSRegistryHandler org.gluu.credmanager.core.ExtensionsManager.registryHandler

private

resourceExtractor

ResourceExtractor org.gluu.credmanager.core.ExtensionsManager.resourceExtractor

private

zkService

ZKService org.gluu.credmanager.core.ExtensionsManager.zkService

private

---

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

• D:/AppData/OpenId/gluu/src/cred-manager/app/src/main/java/org/gluu/credmanager/core/ExtensionsManager.java