Examples with CacheConnectionImpl lucee.runtime.cache.CacheConnectionImpl used on opensource projects

Example 1 with CacheConnectionImpl

use of lucee.runtime.cache.CacheConnectionImpl in project Lucee by lucee.

the class XMLConfigWebFactory method loadCache.

/*private static ClassDefinition matchJDBCBundle(Config config, ClassDefinition cd) {
		if(!cd.isBundle()) {
			if("org.hsqldb.jdbcDriver".equals(cd.getClassName())) 
				return new ClassDefinitionImpl<>(cd.getClassName(), "hypersonic.hsqldb", null, config.getIdentification());
			if("org.gjt.mm.mysql.Driver".equals(cd.getClassName())) 
				return new ClassDefinitionImpl<>(cd.getClassName(), "com.mysql.jdbc", null, config.getIdentification());
			if("org.h2.Driver".equals(cd.getClassName())) 
				return new ClassDefinitionImpl<>(cd.getClassName(), "org.h2", null, config.getIdentification());
			if("net.sourceforge.jtds.jdbc.Driver".equals(cd.getClassName())) 
				return new ClassDefinitionImpl<>(cd.getClassName(), "jtds", null, config.getIdentification());
			if("com.microsoft.jdbc.sqlserver.SQLServerDriver".equals(cd.getClassName())) 
				return new ClassDefinitionImpl<>(cd.getClassName(), "microsoft.sqljdbc", null, config.getIdentification());
		
		}
		return cd;
	}*/
/**
 * @param configServer
 * @param config
 * @param doc
 */
/**
 * @param configServer
 * @param config
 * @param doc
 */
private static void loadCache(ConfigServerImpl configServer, ConfigImpl config, Document doc, Log log) {
    boolean hasCS = configServer != null;
    // load Cache info
    {
        Element parent = getChildByName(doc.getDocumentElement(), "caches");
        Element[] children = getChildren(parent, "cache");
        Map<String, ClassDefinition> map = new HashMap<String, ClassDefinition>();
        // first add the server drivers, so they can be overwritten
        if (configServer != null) {
            Iterator<ClassDefinition> it = configServer.getCacheDefinitions().values().iterator();
            ClassDefinition cd;
            while (it.hasNext()) {
                cd = it.next();
                map.put(cd.getClassName(), cd);
            }
        }
        ClassDefinition cd;
        String label;
        for (Element child : children) {
            cd = getClassDefinition(child, "", config.getIdentification());
            // check if it is a bundle
            if (!cd.isBundle()) {
                log.error("Datasource", "[" + cd + "] does not have bundle info");
                continue;
            }
            map.put(cd.getClassName(), cd);
        }
        config.setCacheDefinitions(map);
    }
    Map<String, CacheConnection> caches = new HashMap<String, CacheConnection>();
    boolean hasAccess = ConfigWebUtil.hasAccess(config, SecurityManagerImpl.TYPE_CACHE);
    // print.o("LOAD CACHE:"+hasAccess+":"+hasCS);
    Element eCache = getChildByName(doc.getDocumentElement(), "cache");
    // has changes
    String md5 = getMD5(eCache, hasCS ? configServer.getCacheMD5() : "");
    if (md5.equals(config.getCacheMD5()))
        return;
    config.setCacheMD5(md5);
    String[] typeNames = new String[] { "resource", "function", "include", "query", "template", "object", "file", "http", "webservice" };
    int[] types = new int[] { ConfigImpl.CACHE_TYPE_RESOURCE, ConfigImpl.CACHE_TYPE_FUNCTION, ConfigImpl.CACHE_TYPE_INCLUDE, ConfigImpl.CACHE_TYPE_QUERY, ConfigImpl.CACHE_TYPE_TEMPLATE, ConfigImpl.CACHE_TYPE_OBJECT, ConfigImpl.CACHE_TYPE_FILE, ConfigImpl.CACHE_TYPE_HTTP, ConfigImpl.CACHE_TYPE_WEBSERVICE };
    // default cache
    for (int i = 0; i < types.length; i++) {
        String def = getAttr(eCache, "default-" + typeNames[i]);
        if (hasAccess && !StringUtil.isEmpty(def)) {
            config.setCacheDefaultConnectionName(types[i], def);
        } else if (hasCS) {
            if (eCache.hasAttribute("default-" + typeNames[i]))
                config.setCacheDefaultConnectionName(types[i], "");
            else
                config.setCacheDefaultConnectionName(types[i], configServer.getCacheDefaultConnectionName(types[i]));
        } else
            config.setCacheDefaultConnectionName(+types[i], "");
    }
    // cache connections
    Element[] eConnections = getChildren(eCache, "connection");
    // if(hasAccess) {
    ClassDefinition cd;
    String name;
    CacheConnection cc;
    // caches
    if (hasAccess)
        for (int i = 0; i < eConnections.length; i++) {
            Element eConnection = eConnections[i];
            name = getAttr(eConnection, "name");
            cd = getClassDefinition(eConnection, "", config.getIdentification());
            if (!cd.isBundle()) {
                ClassDefinition _cd = config.getCacheDefinition(cd.getClassName());
                if (_cd != null)
                    cd = _cd;
            }
            try {
                Struct custom = toStruct(getAttr(eConnection, "custom"));
                // Workaround for old EHCache class defintions
                if (cd.getClassName() != null && cd.getClassName().endsWith(".EHCacheLite")) {
                    cd = new ClassDefinitionImpl("org.lucee.extension.cache.eh.EHCache");
                    if (!custom.containsKey("distributed"))
                        custom.setEL("distributed", "off");
                    if (!custom.containsKey("asynchronousReplicationIntervalMillis"))
                        custom.setEL("asynchronousReplicationIntervalMillis", "1000");
                    if (!custom.containsKey("maximumChunkSizeBytes"))
                        custom.setEL("maximumChunkSizeBytes", "5000000");
                } else // 
                if (cd.getClassName() != null && (cd.getClassName().endsWith(".extension.io.cache.eh.EHCache") || cd.getClassName().endsWith("lucee.runtime.cache.eh.EHCache")))
                    cd = new ClassDefinitionImpl("org.lucee.extension.cache.eh.EHCache");
                // else cacheClazz = cd.getClazz();
                cc = new CacheConnectionImpl(config, name, cd, custom, Caster.toBooleanValue(getAttr(eConnection, "read-only"), false), Caster.toBooleanValue(getAttr(eConnection, "storage"), false));
                if (!StringUtil.isEmpty(name)) {
                    caches.put(name.toLowerCase(), cc);
                } else
                    SystemOut.print(config.getErrWriter(), "missing cache name");
            } catch (ClassException ce) {
                log.error("Cache", ce);
            // SystemOut.print(config.getErrWriter(), ExceptionUtil.getStacktrace(ce, true));
            } catch (BundleException be) {
                log.error("Cache", be);
            // SystemOut.print(config.getErrWriter(), ExceptionUtil.getStacktrace(be, true));
            } catch (IOException e) {
                log.error("Cache", e);
            // SystemOut.print(config.getErrWriter(), ExceptionUtil.getStacktrace(e, true));
            }
        }
    // }
    // call static init once per driver
    {
        // group by classes
        final Map<ClassDefinition, List<CacheConnection>> _caches = new HashMap<ClassDefinition, List<CacheConnection>>();
        {
            Iterator<Entry<String, CacheConnection>> it = caches.entrySet().iterator();
            Entry<String, CacheConnection> entry;
            List<CacheConnection> list;
            while (it.hasNext()) {
                entry = it.next();
                cc = entry.getValue();
                // Jira 3196 ?!
                if (cc == null)
                    continue;
                list = _caches.get(cc.getClassDefinition());
                if (list == null) {
                    list = new ArrayList<CacheConnection>();
                    _caches.put(cc.getClassDefinition(), list);
                }
                list.add(cc);
            }
        }
        // call
        Iterator<Entry<ClassDefinition, List<CacheConnection>>> it = _caches.entrySet().iterator();
        Entry<ClassDefinition, List<CacheConnection>> entry;
        List<CacheConnection> list;
        ClassDefinition _cd;
        while (it.hasNext()) {
            entry = it.next();
            list = entry.getValue();
            _cd = entry.getKey();
            try {
                Method m = _cd.getClazz().getMethod("init", new Class[] { Config.class, String[].class, Struct[].class });
                if (Modifier.isStatic(m.getModifiers()))
                    m.invoke(null, new Object[] { config, _toCacheNames(list), _toArguments(list) });
                else
                    SystemOut.print(config.getErrWriter(), "method [init(Config,String[],Struct[]):void] for class [" + _cd.toString() + "] is not static");
            } catch (InvocationTargetException e) {
                log.error("Cache", e.getTargetException());
            } catch (RuntimeException e) {
                log.error("Cache", e);
            } catch (NoSuchMethodException e) {
                log.error("Cache", "missing method [public static init(Config,String[],Struct[]):void] for class [" + _cd.toString() + "] ");
            // SystemOut.print(config.getErrWriter(), "missing method [public static init(Config,String[],Struct[]):void] for class [" + _cd.toString() + "] ");
            } catch (Throwable e) {
                ExceptionUtil.rethrowIfNecessary(e);
                log.error("Cache", e);
            }
        }
    }
    // Copy Parent caches as readOnly
    if (hasCS) {
        Map<String, CacheConnection> ds = configServer.getCacheConnections();
        Iterator<Entry<String, CacheConnection>> it = ds.entrySet().iterator();
        Entry<String, CacheConnection> entry;
        while (it.hasNext()) {
            entry = it.next();
            cc = entry.getValue();
            if (!caches.containsKey(entry.getKey()))
                caches.put(entry.getKey(), new ServerCacheConnection(configServer, cc));
        }
    }
    config.setCaches(caches);
}

Example 2 with CacheConnectionImpl

use of lucee.runtime.cache.CacheConnectionImpl in project Lucee by lucee.

the class ModernApplicationContext method toCacheConnection.

public static CacheConnection toCacheConnection(Config config, String name, Struct data) throws ApplicationException, CacheException, ClassException, BundleException {
    // class definition
    String className = Caster.toString(data.get(KeyConstants._class, null), null);
    if (StringUtil.isEmpty(className))
        throw new ApplicationException("missing key class in struct the defines a cachec connection");
    ClassDefinition cd = new ClassDefinitionImpl(className, Caster.toString(data.get(KeyConstants._bundleName, null), null), Caster.toString(data.get(KeyConstants._bundleVersion, null), null), config.getIdentification());
    CacheConnectionImpl cc = new CacheConnectionImpl(config, name, cd, Caster.toStruct(data.get(KeyConstants._custom, null), null), Caster.toBooleanValue(data.get(KeyConstants._readonly, null), false), Caster.toBooleanValue(data.get(KeyConstants._storage, null), false));
    String id = cc.id();
    CacheConnection icc = initCacheConnections.get(id);
    if (icc != null)
        return icc;
    try {
        Method m = cd.getClazz().getMethod("init", new Class[] { Config.class, String[].class, Struct[].class });
        if (Modifier.isStatic(m.getModifiers()))
            m.invoke(null, new Object[] { config, new String[] { cc.getName() }, new Struct[] { cc.getCustom() } });
        else
            SystemOut.print(config.getErrWriter(), "method [init(Config,String[],Struct[]):void] for class [" + cd.toString() + "] is not static");
        initCacheConnections.put(id, cc);
    } catch (Throwable t) {
        ExceptionUtil.rethrowIfNecessary(t);
    }
    return cc;
}