1267

pending completion

Build # 1267

Build Type

push

Appveyor

Committed by

oldratlee

Commit Message

chore(ci): upgrade CI JDK 🤖

Run Details

527 of 645 relevant lines covered (81.71%)

0.82 hits per line

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

92.06

/library/src/main/java/com/alibaba/dcm/internal/InetAddressCacheUtilCommons.java

package com.alibaba.dcm.internal;

import edu.umd.cs.findbugs.annotations.ReturnValuesAreNonnullByDefault;
import org.jetbrains.annotations.ApiStatus;
import sun.net.InetAddressCachePolicy;

import javax.annotation.Nullable;
import javax.annotation.ParametersAreNonnullByDefault;
import java.lang.reflect.Field;
import java.net.InetAddress;
import java.net.UnknownHostException;

/**
 * Util class to manipulate dns cache.
 *
 * @author Jerry Lee (oldratlee at gmail dot com)
 * @since 1.6.0
 */
@ParametersAreNonnullByDefault
@ReturnValuesAreNonnullByDefault
@ApiStatus.Internal
public final class InetAddressCacheUtilCommons {
    /**
     * We never really have "never".
     * <p>
     * {@code Long.MAX_VALUE(~9e18)} nanoseconds is ~292 years.
     * <p>
     * {@code Long.MAX_VALUE / 1e9 / 3600 / 24 / 365 ~= 292.47}.
     *
     * @see System#nanoTime()
     */
    public static final long NEVER_EXPIRATION = Long.MAX_VALUE;

    static InetAddress[] toInetAddressArray(String host, String[] ips) throws UnknownHostException {
        InetAddress[] addresses = new InetAddress[ips.length];
        for (int i = 0; i < addresses.length; i++) {
            addresses[i] = InetAddress.getByAddress(host, IpParserUtil.ip2ByteArray(ips[i]));
        }
        return addresses;
    }

    static String[] getIpFromInetAddress(@Nullable InetAddress[] inetAddresses) {
        if (inetAddresses == null) return new String[0];

        final String[] ips = new String[inetAddresses.length];
        for (int i = 0; i < inetAddresses.length; i++) {
            ips[i] = inetAddresses[i].getHostAddress();
        }
        return ips;
    }

    /**
     * Set JVM DNS cache policy.
     *
     * @param cacheSeconds set default dns cache time. Special input case:
     *                     <ul>
     *                     <li> {@link InetAddressCachePolicy#FOREVER}({@code -1}) means never expired.(In effect, all negative value)</li>
     *                     <li> {@link InetAddressCachePolicy#NEVER}(@code 0) never cached.</li>
     *                     </ul>
     * @see InetAddressCachePolicy
     * @see InetAddressCachePolicy#cachePolicy
     * @see InetAddressCachePolicy#get()
     * @see InetAddressCachePolicy#FOREVER
     * @see InetAddressCachePolicy#NEVER
     * @see InetAddressCachePolicy#DEFAULT_POSITIVE
     */
    public static void setDnsCachePolicy(int cacheSeconds)
            throws NoSuchFieldException, IllegalAccessException {
        setCachePolicy0(false, cacheSeconds);
    }

    /**
     * Get JVM DNS cache policy.
     *
     * @see InetAddressCachePolicy#get()
     * @see InetAddressCachePolicy#FOREVER
     * @see InetAddressCachePolicy#NEVER
     * @see InetAddressCachePolicy#DEFAULT_POSITIVE
     */
    public static int getDnsCachePolicy() {
        return InetAddressCachePolicy.get();
    }

    /**
     * Set JVM DNS negative cache policy.
     *
     * @param negativeCacheSeconds set default dns cache time. Special input case:
     *                             <ul>
     *                             <li> {@link InetAddressCachePolicy#FOREVER}({@code -1}) means never expired.(In effect, all negative value)</li>
     *                             <li> {@link InetAddressCachePolicy#NEVER}(@code 0) never cached.</li>
     *                             </ul>
     * @see InetAddressCachePolicy
     * @see InetAddressCachePolicy#negativeCachePolicy
     * @see InetAddressCachePolicy#FOREVER
     * @see InetAddressCachePolicy#NEVER
     */
    public static void setDnsNegativeCachePolicy(int negativeCacheSeconds)
            throws NoSuchFieldException, IllegalAccessException {
        setCachePolicy0(true, negativeCacheSeconds);
    }

    /**
     * Get JVM DNS negative cache policy.
     *
     * @see InetAddressCachePolicy#getNegative()
     * @see InetAddressCachePolicy#FOREVER
     * @see InetAddressCachePolicy#NEVER
     */
    public static int getDnsNegativeCachePolicy() {
        return InetAddressCachePolicy.getNegative();
    }

    private static void setCachePolicy0(boolean isNegative, int seconds)
            throws NoSuchFieldException, IllegalAccessException {
        if (seconds < 0) {
            seconds = -1;
        }

        initFieldsOfInetAddressCachePolicy();

        synchronized (InetAddressCachePolicy.class) { // static synchronized method!
            if (isNegative) {
                negativeCachePolicyFiledOfInetAddressCachePolicy.setInt(null, seconds);
                negativeSetOfInetAddressCachePolicy.setBoolean(null, true);
            } else {
                cachePolicyFiledOfInetAddressCachePolicy.setInt(null, seconds);
                setFiledOfInetAddressCachePolicy.setBoolean(null, true);
            }
        }
    }

    /**
     * {@link InetAddressCachePolicy.cachePolicy}
     */
    private static volatile Field cachePolicyFiledOfInetAddressCachePolicy = null;
    /**
     * {@link InetAddressCachePolicy.negativeCachePolicy}
     */
    private static volatile Field negativeCachePolicyFiledOfInetAddressCachePolicy = null;
    /**
     * {@link InetAddressCachePolicy.propertySet}
     * or {@link InetAddressCachePolicy.set}
     */
    private static volatile Field setFiledOfInetAddressCachePolicy = null;
    /**
     * {@link InetAddressCachePolicy.propertyNegativeSet}
     * or {@link InetAddressCachePolicy.negativeSet}
     */
    private static volatile Field negativeSetOfInetAddressCachePolicy = null;

    @SuppressWarnings("JavaReflectionMemberAccess")
    private static void initFieldsOfInetAddressCachePolicy() throws NoSuchFieldException {
        if (negativeSetOfInetAddressCachePolicy != null) return;

        final Class<?> clazz = InetAddressCachePolicy.class;
        synchronized (InetAddressCacheUtilCommons.class) {
            // double check
            if (negativeSetOfInetAddressCachePolicy != null) return;

            Field f = clazz.getDeclaredField("cachePolicy");
            f.setAccessible(true);
            cachePolicyFiledOfInetAddressCachePolicy = f;

            f = clazz.getDeclaredField("negativeCachePolicy");
            f.setAccessible(true);
            negativeCachePolicyFiledOfInetAddressCachePolicy = f;

            try {
                f = clazz.getDeclaredField("propertySet");
            } catch (NoSuchFieldException e) {
                f = clazz.getDeclaredField("set");
            }
            f.setAccessible(true);
            setFiledOfInetAddressCachePolicy = f;

            try {
                f = clazz.getDeclaredField("propertyNegativeSet");
            } catch (NoSuchFieldException e) {
                f = clazz.getDeclaredField("negativeSet");
            }
            f.setAccessible(true);
            negativeSetOfInetAddressCachePolicy = f;
        }
    }

    private static volatile Boolean isNew;

    /**
     * Check the new or old implementation of {@link InetAddress}
     * by whether the field {@link InetAddress.expirySet} is existed or not.
     */
    public static boolean isNewInetAddressImpl() {
        if (isNew != null) return isNew;

        synchronized (InetAddressCacheUtilCommons.class) {
            // double check
            if (isNew != null) return isNew;

            try {
                InetAddress.class.getDeclaredField("expirySet");
                isNew = true;
            } catch (NoSuchFieldException e) {
                isNew = false;
            }

            return isNew;
        }
    }

    private InetAddressCacheUtilCommons() {
    }
}

1	package com.alibaba.dcm.internal;
2
3	import edu.umd.cs.findbugs.annotations.ReturnValuesAreNonnullByDefault;
4	import org.jetbrains.annotations.ApiStatus;
5	import sun.net.InetAddressCachePolicy;
6
7	import javax.annotation.Nullable;
8	import javax.annotation.ParametersAreNonnullByDefault;
9	import java.lang.reflect.Field;
10	import java.net.InetAddress;
11	import java.net.UnknownHostException;
12
13	/**
14	* Util class to manipulate dns cache.
15	*
16	* @author Jerry Lee (oldratlee at gmail dot com)
17	* @since 1.6.0
18	*/
19	@ParametersAreNonnullByDefault
20	@ReturnValuesAreNonnullByDefault
21	@ApiStatus.Internal
22	public final class InetAddressCacheUtilCommons {
23	/**
24	* We never really have "never".
25	* <p>
26	* {@code Long.MAX_VALUE(~9e18)} nanoseconds is ~292 years.
27	* <p>
28	* {@code Long.MAX_VALUE / 1e9 / 3600 / 24 / 365 ~= 292.47}.
29	*
30	* @see System#nanoTime()
31	*/
32	public static final long NEVER_EXPIRATION = Long.MAX_VALUE;
33
34	static InetAddress[] toInetAddressArray(String host, String[] ips) throws UnknownHostException {
35	InetAddress[] addresses = new InetAddress[ips.length];	1✔
36	for (int i = 0; i < addresses.length; i++) {	1✔
37	addresses[i] = InetAddress.getByAddress(host, IpParserUtil.ip2ByteArray(ips[i]));	1✔
38	}
39	return addresses;	1✔
40	}
41
42	static String[] getIpFromInetAddress(@Nullable InetAddress[] inetAddresses) {
43	if (inetAddresses == null) return new String[0];	1✔
44
45	final String[] ips = new String[inetAddresses.length];	1✔
46	for (int i = 0; i < inetAddresses.length; i++) {	1✔
47	ips[i] = inetAddresses[i].getHostAddress();	1✔
48	}
49	return ips;	1✔
50	}
51
52	/**
53	* Set JVM DNS cache policy.
54	*
55	* @param cacheSeconds set default dns cache time. Special input case:
56	* <ul>
57	* <li> {@link InetAddressCachePolicy#FOREVER}({@code -1}) means never expired.(In effect, all negative value)</li>
58	* <li> {@link InetAddressCachePolicy#NEVER}(@code 0) never cached.</li>
59	* </ul>
60	* @see InetAddressCachePolicy
61	* @see InetAddressCachePolicy#cachePolicy
62	* @see InetAddressCachePolicy#get()
63	* @see InetAddressCachePolicy#FOREVER
64	* @see InetAddressCachePolicy#NEVER
65	* @see InetAddressCachePolicy#DEFAULT_POSITIVE
66	*/
67	public static void setDnsCachePolicy(int cacheSeconds)
68	throws NoSuchFieldException, IllegalAccessException {
69	setCachePolicy0(false, cacheSeconds);	1✔
70	}	1✔
71
72	/**
73	* Get JVM DNS cache policy.
74	*
75	* @see InetAddressCachePolicy#get()
76	* @see InetAddressCachePolicy#FOREVER
77	* @see InetAddressCachePolicy#NEVER
78	* @see InetAddressCachePolicy#DEFAULT_POSITIVE
79	*/
80	public static int getDnsCachePolicy() {
81	return InetAddressCachePolicy.get();	1✔
82	}
83
84	/**
85	* Set JVM DNS negative cache policy.
86	*
87	* @param negativeCacheSeconds set default dns cache time. Special input case:
88	* <ul>
89	* <li> {@link InetAddressCachePolicy#FOREVER}({@code -1}) means never expired.(In effect, all negative value)</li>
90	* <li> {@link InetAddressCachePolicy#NEVER}(@code 0) never cached.</li>
91	* </ul>
92	* @see InetAddressCachePolicy
93	* @see InetAddressCachePolicy#negativeCachePolicy
94	* @see InetAddressCachePolicy#FOREVER
95	* @see InetAddressCachePolicy#NEVER
96	*/
97	public static void setDnsNegativeCachePolicy(int negativeCacheSeconds)
98	throws NoSuchFieldException, IllegalAccessException {
99	setCachePolicy0(true, negativeCacheSeconds);	1✔
100	}	1✔
101
102	/**
103	* Get JVM DNS negative cache policy.
104	*
105	* @see InetAddressCachePolicy#getNegative()
106	* @see InetAddressCachePolicy#FOREVER
107	* @see InetAddressCachePolicy#NEVER
108	*/
109	public static int getDnsNegativeCachePolicy() {
110	return InetAddressCachePolicy.getNegative();	1✔
111	}
112
113	private static void setCachePolicy0(boolean isNegative, int seconds)
114	throws NoSuchFieldException, IllegalAccessException {
115	if (seconds < 0) {	1✔
116	seconds = -1;	×
117	}
118
119	initFieldsOfInetAddressCachePolicy();	1✔
120
121	synchronized (InetAddressCachePolicy.class) { // static synchronized method!	1✔
122	if (isNegative) {	1✔
123	negativeCachePolicyFiledOfInetAddressCachePolicy.setInt(null, seconds);	1✔
124	negativeSetOfInetAddressCachePolicy.setBoolean(null, true);	1✔
125	} else {
126	cachePolicyFiledOfInetAddressCachePolicy.setInt(null, seconds);	1✔
127	setFiledOfInetAddressCachePolicy.setBoolean(null, true);	1✔
128	}
129	}	1✔
130	}	1✔
131
132	/**
133	* {@link InetAddressCachePolicy.cachePolicy}
134	*/
135	private static volatile Field cachePolicyFiledOfInetAddressCachePolicy = null;	1✔
136	/**
137	* {@link InetAddressCachePolicy.negativeCachePolicy}
138	*/
139	private static volatile Field negativeCachePolicyFiledOfInetAddressCachePolicy = null;	1✔
140	/**
141	* {@link InetAddressCachePolicy.propertySet}
142	* or {@link InetAddressCachePolicy.set}
143	*/
144	private static volatile Field setFiledOfInetAddressCachePolicy = null;	1✔
145	/**
146	* {@link InetAddressCachePolicy.propertyNegativeSet}
147	* or {@link InetAddressCachePolicy.negativeSet}
148	*/
149	private static volatile Field negativeSetOfInetAddressCachePolicy = null;	1✔
150
151	@SuppressWarnings("JavaReflectionMemberAccess")
152	private static void initFieldsOfInetAddressCachePolicy() throws NoSuchFieldException {
153	if (negativeSetOfInetAddressCachePolicy != null) return;	1✔
154
155	final Class<?> clazz = InetAddressCachePolicy.class;	1✔
156	synchronized (InetAddressCacheUtilCommons.class) {	1✔
157	// double check
158	if (negativeSetOfInetAddressCachePolicy != null) return;	1✔
159
160	Field f = clazz.getDeclaredField("cachePolicy");	1✔
161	f.setAccessible(true);	1✔
162	cachePolicyFiledOfInetAddressCachePolicy = f;	1✔
163
164	f = clazz.getDeclaredField("negativeCachePolicy");	1✔
165	f.setAccessible(true);	1✔
166	negativeCachePolicyFiledOfInetAddressCachePolicy = f;	1✔
167
168	try {
169	f = clazz.getDeclaredField("propertySet");	1✔
170	} catch (NoSuchFieldException e) {	×
171	f = clazz.getDeclaredField("set");	×
172	}	1✔
173	f.setAccessible(true);	1✔
174	setFiledOfInetAddressCachePolicy = f;	1✔
175
176	try {
177	f = clazz.getDeclaredField("propertyNegativeSet");	1✔
178	} catch (NoSuchFieldException e) {	×
179	f = clazz.getDeclaredField("negativeSet");	×
180	}	1✔
181	f.setAccessible(true);	1✔
182	negativeSetOfInetAddressCachePolicy = f;	1✔
183	}	1✔
184	}	1✔
185
186	private static volatile Boolean isNew;
187
188	/**
189	* Check the new or old implementation of {@link InetAddress}
190	* by whether the field {@link InetAddress.expirySet} is existed or not.
191	*/
192	public static boolean isNewInetAddressImpl() {
193	if (isNew != null) return isNew;	1✔
194
195	synchronized (InetAddressCacheUtilCommons.class) {	1✔
196	// double check
197	if (isNew != null) return isNew;	1✔
198
199	try {
200	InetAddress.class.getDeclaredField("expirySet");	1✔
201	isNew = true;	1✔
202	} catch (NoSuchFieldException e) {	1✔
203	isNew = false;	1✔
204	}	1✔
205
206	return isNew;	1✔
207	}
208	}
209
210	private InetAddressCacheUtilCommons() {
211	}
212	}

alibaba / java-dns-cache-manipulator / 1267

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