#405

Committed 16 Apr 2024 05:58AM UTC coverage: 0.0% (-88.9%) from 88.866%

Build # #405

Build Type

push

Committed by

Commit Message

add encoding to fix coverage report

Run Details

0 of 5353 relevant lines covered (0.0%)

0.0 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/jetcache-anno/src/main/java/com/alicp/jetcache/anno/support/ConfigProvider.java

package com.alicp.jetcache.anno.support;

import com.alicp.jetcache.CacheBuilder;
import com.alicp.jetcache.CacheManager;
import com.alicp.jetcache.embedded.EmbeddedCacheBuilder;
import com.alicp.jetcache.external.ExternalCacheBuilder;
import com.alicp.jetcache.support.AbstractLifecycle;
import com.alicp.jetcache.support.StatInfo;
import com.alicp.jetcache.support.StatInfoLogger;
import com.alicp.jetcache.template.CacheBuilderTemplate;
import com.alicp.jetcache.template.CacheMonitorInstaller;
import com.alicp.jetcache.template.MetricsMonitorInstaller;
import com.alicp.jetcache.template.NotifyMonitorInstaller;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.time.Duration;
import java.util.function.Consumer;
import java.util.function.Function;

/**
 * Created on 2016/11/29.
 *
 * @author huangli
 */
public class ConfigProvider extends AbstractLifecycle {

    private static final Logger logger = LoggerFactory.getLogger(ConfigProvider.class);

    protected GlobalCacheConfig globalCacheConfig;

    protected EncoderParser encoderParser;
    protected KeyConvertorParser keyConvertorParser;
    private Consumer<StatInfo> metricsCallback;

    private CacheBuilderTemplate cacheBuilderTemplate;

    public ConfigProvider() {
        encoderParser = new DefaultEncoderParser();
        keyConvertorParser = new DefaultKeyConvertorParser();
        metricsCallback = new StatInfoLogger(false);
    }

    @Override
    protected void doInit() {
        cacheBuilderTemplate = new CacheBuilderTemplate(globalCacheConfig.isPenetrationProtect(),
                globalCacheConfig.getLocalCacheBuilders(), globalCacheConfig.getRemoteCacheBuilders());
        for (CacheBuilder builder : globalCacheConfig.getLocalCacheBuilders().values()) {
            EmbeddedCacheBuilder eb = (EmbeddedCacheBuilder) builder;
            if (eb.getConfig().getKeyConvertor() instanceof ParserFunction) {
                ParserFunction f = (ParserFunction) eb.getConfig().getKeyConvertor();
                eb.setKeyConvertor(parseKeyConvertor(f.getValue()));
            }
        }
        for (CacheBuilder builder : globalCacheConfig.getRemoteCacheBuilders().values()) {
            ExternalCacheBuilder eb = (ExternalCacheBuilder) builder;
            if (eb.getConfig().getKeyConvertor() instanceof ParserFunction) {
                ParserFunction f = (ParserFunction) eb.getConfig().getKeyConvertor();
                eb.setKeyConvertor(parseKeyConvertor(f.getValue()));
            }
            if (eb.getConfig().getValueEncoder() instanceof ParserFunction) {
                ParserFunction f = (ParserFunction) eb.getConfig().getValueEncoder();
                eb.setValueEncoder(parseValueEncoder(f.getValue()));
            }
            if (eb.getConfig().getValueDecoder() instanceof ParserFunction) {
                ParserFunction f = (ParserFunction) eb.getConfig().getValueDecoder();
                eb.setValueDecoder(parseValueDecoder(f.getValue()));
            }
        }
        initCacheMonitorInstallers();
    }

    protected void initCacheMonitorInstallers() {
        cacheBuilderTemplate.getCacheMonitorInstallers().add(metricsMonitorInstaller());
        cacheBuilderTemplate.getCacheMonitorInstallers().add(notifyMonitorInstaller());
        for (CacheMonitorInstaller i : cacheBuilderTemplate.getCacheMonitorInstallers()) {
            if (i instanceof AbstractLifecycle) {
                ((AbstractLifecycle) i).init();
            }
        }
    }

    protected CacheMonitorInstaller metricsMonitorInstaller() {
        Duration interval = null;
        if (globalCacheConfig.getStatIntervalMinutes() > 0) {
            interval = Duration.ofMinutes(globalCacheConfig.getStatIntervalMinutes());
        }

        MetricsMonitorInstaller i = new MetricsMonitorInstaller(metricsCallback, interval);
        i.init();
        return i;
    }

    protected CacheMonitorInstaller notifyMonitorInstaller() {
        return new NotifyMonitorInstaller(area -> globalCacheConfig.getRemoteCacheBuilders().get(area));
    }

    public CacheBuilderTemplate getCacheBuilderTemplate() {
        return cacheBuilderTemplate;
    }

    @Override
    public void doShutdown() {
        try {
            for (CacheMonitorInstaller i : cacheBuilderTemplate.getCacheMonitorInstallers()) {
                if (i instanceof AbstractLifecycle) {
                    ((AbstractLifecycle) i).shutdown();
                }
            }
        } catch (Exception e) {
            logger.error("close fail", e);
        }
    }

    /**
     * Keep this method for backward compatibility.
     * NOTICE: there is no getter for encoderParser.
     */
    public Function<Object, byte[]> parseValueEncoder(String valueEncoder) {
        return encoderParser.parseEncoder(valueEncoder);
    }

    /**
     * Keep this method for backward compatibility.
     * NOTICE: there is no getter for encoderParser.
     */
    public Function<byte[], Object> parseValueDecoder(String valueDecoder) {
        return encoderParser.parseDecoder(valueDecoder);
    }

    /**
     * Keep this method for backward compatibility.
     * NOTICE: there is no getter for keyConvertorParser.
     */
    public Function<Object, Object> parseKeyConvertor(String convertor) {
        return keyConvertorParser.parseKeyConvertor(convertor);
    }

    public CacheNameGenerator createCacheNameGenerator(String[] hiddenPackages) {
        return new DefaultCacheNameGenerator(hiddenPackages);
    }

    public CacheContext newContext(CacheManager cacheManager) {
        return new CacheContext(cacheManager, this, globalCacheConfig);
    }

    public void setEncoderParser(EncoderParser encoderParser) {
        this.encoderParser = encoderParser;
    }

    public void setKeyConvertorParser(KeyConvertorParser keyConvertorParser) {
        this.keyConvertorParser = keyConvertorParser;
    }

    public GlobalCacheConfig getGlobalCacheConfig() {
        return globalCacheConfig;
    }

    public void setGlobalCacheConfig(GlobalCacheConfig globalCacheConfig) {
        this.globalCacheConfig = globalCacheConfig;
    }

    public void setMetricsCallback(Consumer<StatInfo> metricsCallback) {
        this.metricsCallback = metricsCallback;
    }

}

1	package com.alicp.jetcache.anno.support;
2
3	import com.alicp.jetcache.CacheBuilder;
4	import com.alicp.jetcache.CacheManager;
5	import com.alicp.jetcache.embedded.EmbeddedCacheBuilder;
6	import com.alicp.jetcache.external.ExternalCacheBuilder;
7	import com.alicp.jetcache.support.AbstractLifecycle;
8	import com.alicp.jetcache.support.StatInfo;
9	import com.alicp.jetcache.support.StatInfoLogger;
10	import com.alicp.jetcache.template.CacheBuilderTemplate;
11	import com.alicp.jetcache.template.CacheMonitorInstaller;
12	import com.alicp.jetcache.template.MetricsMonitorInstaller;
13	import com.alicp.jetcache.template.NotifyMonitorInstaller;
14	import org.slf4j.Logger;
15	import org.slf4j.LoggerFactory;
16
17	import java.time.Duration;
18	import java.util.function.Consumer;
19	import java.util.function.Function;
20
21	/**
22	* Created on 2016/11/29.
23	*
24	* @author huangli
25	*/
26	public class ConfigProvider extends AbstractLifecycle {
27
28	private static final Logger logger = LoggerFactory.getLogger(ConfigProvider.class);	×
29
30	protected GlobalCacheConfig globalCacheConfig;
31
32	protected EncoderParser encoderParser;
33	protected KeyConvertorParser keyConvertorParser;
34	private Consumer<StatInfo> metricsCallback;
35
36	private CacheBuilderTemplate cacheBuilderTemplate;
37
38	public ConfigProvider() {	×
39	encoderParser = new DefaultEncoderParser();	×
40	keyConvertorParser = new DefaultKeyConvertorParser();	×
41	metricsCallback = new StatInfoLogger(false);	×
42	}	×
43
44	@Override
45	protected void doInit() {
46	cacheBuilderTemplate = new CacheBuilderTemplate(globalCacheConfig.isPenetrationProtect(),	×
47	globalCacheConfig.getLocalCacheBuilders(), globalCacheConfig.getRemoteCacheBuilders());	×
48	for (CacheBuilder builder : globalCacheConfig.getLocalCacheBuilders().values()) {	×
49	EmbeddedCacheBuilder eb = (EmbeddedCacheBuilder) builder;	×
50	if (eb.getConfig().getKeyConvertor() instanceof ParserFunction) {	×
51	ParserFunction f = (ParserFunction) eb.getConfig().getKeyConvertor();	×
52	eb.setKeyConvertor(parseKeyConvertor(f.getValue()));	×
53	}
54	}	×
55	for (CacheBuilder builder : globalCacheConfig.getRemoteCacheBuilders().values()) {	×
56	ExternalCacheBuilder eb = (ExternalCacheBuilder) builder;	×
57	if (eb.getConfig().getKeyConvertor() instanceof ParserFunction) {	×
58	ParserFunction f = (ParserFunction) eb.getConfig().getKeyConvertor();	×
59	eb.setKeyConvertor(parseKeyConvertor(f.getValue()));	×
60	}
61	if (eb.getConfig().getValueEncoder() instanceof ParserFunction) {	×
62	ParserFunction f = (ParserFunction) eb.getConfig().getValueEncoder();	×
63	eb.setValueEncoder(parseValueEncoder(f.getValue()));	×
64	}
65	if (eb.getConfig().getValueDecoder() instanceof ParserFunction) {	×
66	ParserFunction f = (ParserFunction) eb.getConfig().getValueDecoder();	×
67	eb.setValueDecoder(parseValueDecoder(f.getValue()));	×
68	}
69	}	×
70	initCacheMonitorInstallers();	×
71	}	×
72
73	protected void initCacheMonitorInstallers() {
74	cacheBuilderTemplate.getCacheMonitorInstallers().add(metricsMonitorInstaller());	×
75	cacheBuilderTemplate.getCacheMonitorInstallers().add(notifyMonitorInstaller());	×
76	for (CacheMonitorInstaller i : cacheBuilderTemplate.getCacheMonitorInstallers()) {	×
77	if (i instanceof AbstractLifecycle) {	×
78	((AbstractLifecycle) i).init();	×
79	}
80	}	×
81	}	×
82
83	protected CacheMonitorInstaller metricsMonitorInstaller() {
84	Duration interval = null;	×
85	if (globalCacheConfig.getStatIntervalMinutes() > 0) {	×
86	interval = Duration.ofMinutes(globalCacheConfig.getStatIntervalMinutes());	×
87	}
88
89	MetricsMonitorInstaller i = new MetricsMonitorInstaller(metricsCallback, interval);	×
90	i.init();	×
91	return i;	×
92	}
93
94	protected CacheMonitorInstaller notifyMonitorInstaller() {
95	return new NotifyMonitorInstaller(area -> globalCacheConfig.getRemoteCacheBuilders().get(area));	×
96	}
97
98	public CacheBuilderTemplate getCacheBuilderTemplate() {
99	return cacheBuilderTemplate;	×
100	}
101
102	@Override
103	public void doShutdown() {
104	try {
105	for (CacheMonitorInstaller i : cacheBuilderTemplate.getCacheMonitorInstallers()) {	×
106	if (i instanceof AbstractLifecycle) {	×
107	((AbstractLifecycle) i).shutdown();	×
108	}
109	}	×
110	} catch (Exception e) {	×
111	logger.error("close fail", e);	×
112	}	×
113	}	×
114
115	/**
116	* Keep this method for backward compatibility.
117	* NOTICE: there is no getter for encoderParser.
118	*/
119	public Function<Object, byte[]> parseValueEncoder(String valueEncoder) {
120	return encoderParser.parseEncoder(valueEncoder);	×
121	}
122
123	/**
124	* Keep this method for backward compatibility.
125	* NOTICE: there is no getter for encoderParser.
126	*/
127	public Function<byte[], Object> parseValueDecoder(String valueDecoder) {
128	return encoderParser.parseDecoder(valueDecoder);	×
129	}
130
131	/**
132	* Keep this method for backward compatibility.
133	* NOTICE: there is no getter for keyConvertorParser.
134	*/
135	public Function<Object, Object> parseKeyConvertor(String convertor) {
136	return keyConvertorParser.parseKeyConvertor(convertor);	×
137	}
138
139	public CacheNameGenerator createCacheNameGenerator(String[] hiddenPackages) {
140	return new DefaultCacheNameGenerator(hiddenPackages);	×
141	}
142
143	public CacheContext newContext(CacheManager cacheManager) {
144	return new CacheContext(cacheManager, this, globalCacheConfig);	×
145	}
146
147	public void setEncoderParser(EncoderParser encoderParser) {
148	this.encoderParser = encoderParser;	×
149	}	×
150
151	public void setKeyConvertorParser(KeyConvertorParser keyConvertorParser) {
152	this.keyConvertorParser = keyConvertorParser;	×
153	}	×
154
155	public GlobalCacheConfig getGlobalCacheConfig() {
156	return globalCacheConfig;	×
157	}
158
159	public void setGlobalCacheConfig(GlobalCacheConfig globalCacheConfig) {
160	this.globalCacheConfig = globalCacheConfig;	×
161	}	×
162
163	public void setMetricsCallback(Consumer<StatInfo> metricsCallback) {
164	this.metricsCallback = metricsCallback;	×
165	}	×
166
167	}

alibaba / jetcache / #405

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous