#2187

Committed 07 Jun 2025 09:11AM UTC coverage: 69.535% (-0.5%) from 69.989%

Build # #2187

Build Type

push

Committed by

Commit Message

redis-8.0

Run Details

1 of 123 new or added lines in 13 files covered. (0.81%)

1 existing line in 1 file now uncovered.

6642 of 9552 relevant lines covered (69.54%)

0.7 hits per line

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

38.6

/src/main/java/com/moilioncircle/redis/replicator/rdb/dump/parser/IterableDumpValueParser.java

/*
 * Copyright 2016-2017 Leon Chen
 *
 * 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 com.moilioncircle.redis.replicator.rdb.dump.parser;

import static com.moilioncircle.redis.replicator.Constants.RDB_OPCODE_FUNCTION;
import static com.moilioncircle.redis.replicator.Constants.RDB_OPCODE_FUNCTION2;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_HASH;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_HASH_LISTPACK;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_HASH_LISTPACK_EX;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_HASH_METADATA;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_HASH_ZIPLIST;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_HASH_ZIPMAP;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_LIST;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_LIST_QUICKLIST;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_LIST_QUICKLIST_2;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_LIST_ZIPLIST;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_MODULE;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_MODULE_2;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_SET;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_SET_INTSET;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_SET_LISTPACK;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_STREAM_LISTPACKS;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_STREAM_LISTPACKS_2;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_STREAM_LISTPACKS_3;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_STRING;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_ZSET;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_ZSET_2;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_ZSET_LISTPACK;
import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_ZSET_ZIPLIST;

import java.io.IOException;
import java.io.UncheckedIOException;
import java.util.Objects;

import com.moilioncircle.redis.replicator.Replicator;
import com.moilioncircle.redis.replicator.event.EventListener;
import com.moilioncircle.redis.replicator.io.RedisInputStream;
import com.moilioncircle.redis.replicator.rdb.RdbValueVisitor;
import com.moilioncircle.redis.replicator.rdb.datatype.Function;
import com.moilioncircle.redis.replicator.rdb.datatype.KeyValuePair;
import com.moilioncircle.redis.replicator.rdb.datatype.KeyValuePairs;
import com.moilioncircle.redis.replicator.rdb.dump.datatype.DumpFunction;
import com.moilioncircle.redis.replicator.rdb.dump.datatype.DumpKeyValuePair;
import com.moilioncircle.redis.replicator.rdb.iterable.ValueIterableEventListener;
import com.moilioncircle.redis.replicator.rdb.iterable.ValueIterableRdbValueVisitor;
import com.moilioncircle.redis.replicator.util.ByteArray;

/**
 * @author Leon Chen
 * @since 3.1.0
 */
public class IterableDumpValueParser implements DumpValueParser {

    protected final int batchSize;
    protected final boolean order;
    protected final Replicator replicator;
    protected final RdbValueVisitor valueVisitor;

    public IterableDumpValueParser(Replicator replicator) {
        this(64, replicator);
    }

    public IterableDumpValueParser(int batchSize, Replicator replicator) {
        this(true, batchSize, replicator);
    }

    public IterableDumpValueParser(boolean order, int batchSize, Replicator replicator) {
        Objects.requireNonNull(replicator);
        this.order = order;
        this.batchSize = batchSize;
        this.replicator = replicator;
        this.valueVisitor = new ValueIterableRdbValueVisitor(replicator);
    }

    @Override
    public void parse(DumpKeyValuePair kv, EventListener listener) {
        Objects.requireNonNull(listener);
        new ValueIterableEventListener(order, batchSize, listener).onEvent(replicator, parse(kv));
    }
    
    @Override
    public void parse(DumpFunction function, EventListener listener) {
        Objects.requireNonNull(listener);
        new ValueIterableEventListener(order, batchSize, listener).onEvent(replicator, parse(function));
    }
    
    @Override
    public Function parse(DumpFunction function) {
        Objects.requireNonNull(function);
        try (RedisInputStream in = new RedisInputStream(new ByteArray(function.getSerialized()))) {
            int valueType = in.read();
            if (valueType == RDB_OPCODE_FUNCTION) {
                return valueVisitor.applyFunction(in, 0);
            } else if (valueType == RDB_OPCODE_FUNCTION2) {
                return valueVisitor.applyFunction2(in, 0);
            } else {
                throw new AssertionError("unexpected value type:" + valueType);
            }
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    }
    
    @Override
    public KeyValuePair<?, ?> parse(DumpKeyValuePair kv) {
        Objects.requireNonNull(kv);
        try (RedisInputStream in = new RedisInputStream(new ByteArray(kv.getValue()))) {
            int valueType = in.read();
            switch (valueType) {
                case RDB_TYPE_STRING:
                    return KeyValuePairs.string(kv, valueVisitor.applyString(in, 0));
                case RDB_TYPE_LIST:
                    return KeyValuePairs.iterList(kv, valueVisitor.applyList(in, 0));
                case RDB_TYPE_SET:
                    return KeyValuePairs.iterSet(kv, valueVisitor.applySet(in, 0));
                case RDB_TYPE_SET_LISTPACK:
                    return KeyValuePairs.iterSet(kv, valueVisitor.applySetListPack(in, 0));
                case RDB_TYPE_ZSET:
                    return KeyValuePairs.iterZset(kv, valueVisitor.applyZSet(in, 0));
                case RDB_TYPE_ZSET_2:
                    return KeyValuePairs.iterZset(kv, valueVisitor.applyZSet2(in, 0));
                case RDB_TYPE_HASH:
                    return KeyValuePairs.iterHash(kv, valueVisitor.applyHash(in, 0));
                case RDB_TYPE_HASH_ZIPMAP:
                    return KeyValuePairs.iterHash(kv, valueVisitor.applyHashZipMap(in, 0));
                case RDB_TYPE_LIST_ZIPLIST:
                    return KeyValuePairs.iterList(kv, valueVisitor.applyListZipList(in, 0));
                case RDB_TYPE_SET_INTSET:
                    return KeyValuePairs.iterSet(kv, valueVisitor.applySetIntSet(in, 0));
                case RDB_TYPE_ZSET_ZIPLIST:
                    return KeyValuePairs.iterZset(kv, valueVisitor.applyZSetZipList(in, 0));
                case RDB_TYPE_ZSET_LISTPACK:
                    return KeyValuePairs.iterZset(kv, valueVisitor.applyZSetListPack(in, 0));
                case RDB_TYPE_HASH_ZIPLIST:
                    return KeyValuePairs.iterHash(kv, valueVisitor.applyHashZipList(in, 0));
                case RDB_TYPE_HASH_LISTPACK:
                    return KeyValuePairs.iterHash(kv, valueVisitor.applyHashListPack(in, 0));
                case RDB_TYPE_LIST_QUICKLIST:
                    return KeyValuePairs.iterList(kv, valueVisitor.applyListQuickList(in, 0));
                case RDB_TYPE_LIST_QUICKLIST_2:
                    return KeyValuePairs.iterList(kv, valueVisitor.applyListQuickList2(in, 0));
                case RDB_TYPE_MODULE:
                    return KeyValuePairs.module(kv, valueVisitor.applyModule(in, 0));
                case RDB_TYPE_MODULE_2:
                    return KeyValuePairs.module(kv, valueVisitor.applyModule2(in, 0));
                case RDB_TYPE_STREAM_LISTPACKS:
                    return KeyValuePairs.stream(kv, valueVisitor.applyStreamListPacks(in, 0));
                case RDB_TYPE_STREAM_LISTPACKS_2:
                    return KeyValuePairs.stream(kv, valueVisitor.applyStreamListPacks2(in, 0));
                case RDB_TYPE_STREAM_LISTPACKS_3:
                    return KeyValuePairs.stream(kv, valueVisitor.applyStreamListPacks3(in, 0));
                case RDB_TYPE_HASH_LISTPACK_EX:
                    return KeyValuePairs.iterTTLHash(kv, valueVisitor.applyHashListPackEx(in, 0));
                case RDB_TYPE_HASH_METADATA:
                    return KeyValuePairs.iterTTLHash(kv, valueVisitor.applyHashMetadata(in, 0));
                default:
                    throw new AssertionError("unexpected value type:" + valueType);
            }
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    }
}

1	/*
2	* Copyright 2016-2017 Leon Chen
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* http://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16
17	package com.moilioncircle.redis.replicator.rdb.dump.parser;
18
19	import static com.moilioncircle.redis.replicator.Constants.RDB_OPCODE_FUNCTION;
20	import static com.moilioncircle.redis.replicator.Constants.RDB_OPCODE_FUNCTION2;
21	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_HASH;
22	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_HASH_LISTPACK;
23	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_HASH_LISTPACK_EX;
24	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_HASH_METADATA;
25	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_HASH_ZIPLIST;
26	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_HASH_ZIPMAP;
27	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_LIST;
28	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_LIST_QUICKLIST;
29	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_LIST_QUICKLIST_2;
30	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_LIST_ZIPLIST;
31	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_MODULE;
32	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_MODULE_2;
33	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_SET;
34	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_SET_INTSET;
35	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_SET_LISTPACK;
36	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_STREAM_LISTPACKS;
37	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_STREAM_LISTPACKS_2;
38	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_STREAM_LISTPACKS_3;
39	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_STRING;
40	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_ZSET;
41	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_ZSET_2;
42	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_ZSET_LISTPACK;
43	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_ZSET_ZIPLIST;
44
45	import java.io.IOException;
46	import java.io.UncheckedIOException;
47	import java.util.Objects;
48
49	import com.moilioncircle.redis.replicator.Replicator;
50	import com.moilioncircle.redis.replicator.event.EventListener;
51	import com.moilioncircle.redis.replicator.io.RedisInputStream;
52	import com.moilioncircle.redis.replicator.rdb.RdbValueVisitor;
53	import com.moilioncircle.redis.replicator.rdb.datatype.Function;
54	import com.moilioncircle.redis.replicator.rdb.datatype.KeyValuePair;
55	import com.moilioncircle.redis.replicator.rdb.datatype.KeyValuePairs;
56	import com.moilioncircle.redis.replicator.rdb.dump.datatype.DumpFunction;
57	import com.moilioncircle.redis.replicator.rdb.dump.datatype.DumpKeyValuePair;
58	import com.moilioncircle.redis.replicator.rdb.iterable.ValueIterableEventListener;
59	import com.moilioncircle.redis.replicator.rdb.iterable.ValueIterableRdbValueVisitor;
60	import com.moilioncircle.redis.replicator.util.ByteArray;
61
62	/**
63	* @author Leon Chen
64	* @since 3.1.0
65	*/
66	public class IterableDumpValueParser implements DumpValueParser {
67
68	protected final int batchSize;
69	protected final boolean order;
70	protected final Replicator replicator;
71	protected final RdbValueVisitor valueVisitor;
72
73	public IterableDumpValueParser(Replicator replicator) {
74	this(64, replicator);	×
75	}	×
76
77	public IterableDumpValueParser(int batchSize, Replicator replicator) {
78	this(true, batchSize, replicator);	1✔
79	}	1✔
80
81	public IterableDumpValueParser(boolean order, int batchSize, Replicator replicator) {	1✔
82	Objects.requireNonNull(replicator);	1✔
83	this.order = order;	1✔
84	this.batchSize = batchSize;	1✔
85	this.replicator = replicator;	1✔
86	this.valueVisitor = new ValueIterableRdbValueVisitor(replicator);	1✔
87	}	1✔
88
89	@Override
90	public void parse(DumpKeyValuePair kv, EventListener listener) {
91	Objects.requireNonNull(listener);	1✔
92	new ValueIterableEventListener(order, batchSize, listener).onEvent(replicator, parse(kv));	1✔
93	}	1✔
94
95	@Override
96	public void parse(DumpFunction function, EventListener listener) {
97	Objects.requireNonNull(listener);	×
98	new ValueIterableEventListener(order, batchSize, listener).onEvent(replicator, parse(function));	×
99	}	×
100
101	@Override
102	public Function parse(DumpFunction function) {
103	Objects.requireNonNull(function);	×
104	try (RedisInputStream in = new RedisInputStream(new ByteArray(function.getSerialized()))) {	×
105	int valueType = in.read();	×
106	if (valueType == RDB_OPCODE_FUNCTION) {	×
107	return valueVisitor.applyFunction(in, 0);	×
108	} else if (valueType == RDB_OPCODE_FUNCTION2) {	×
109	return valueVisitor.applyFunction2(in, 0);	×
110	} else {
111	throw new AssertionError("unexpected value type:" + valueType);	×
112	}
113	} catch (IOException e) {	×
114	throw new UncheckedIOException(e);	×
115	}
116	}
117
118	@Override
119	public KeyValuePair<?, ?> parse(DumpKeyValuePair kv) {
120	Objects.requireNonNull(kv);	1✔
121	try (RedisInputStream in = new RedisInputStream(new ByteArray(kv.getValue()))) {	1✔
122	int valueType = in.read();	1✔
123	switch (valueType) {	1✔
124	case RDB_TYPE_STRING:
125	return KeyValuePairs.string(kv, valueVisitor.applyString(in, 0));	1✔
126	case RDB_TYPE_LIST:
127	return KeyValuePairs.iterList(kv, valueVisitor.applyList(in, 0));	×
128	case RDB_TYPE_SET:
129	return KeyValuePairs.iterSet(kv, valueVisitor.applySet(in, 0));	×
130	case RDB_TYPE_SET_LISTPACK:
131	return KeyValuePairs.iterSet(kv, valueVisitor.applySetListPack(in, 0));	×
132	case RDB_TYPE_ZSET:
133	return KeyValuePairs.iterZset(kv, valueVisitor.applyZSet(in, 0));	×
134	case RDB_TYPE_ZSET_2:
135	return KeyValuePairs.iterZset(kv, valueVisitor.applyZSet2(in, 0));	×
136	case RDB_TYPE_HASH:
137	return KeyValuePairs.iterHash(kv, valueVisitor.applyHash(in, 0));	×
138	case RDB_TYPE_HASH_ZIPMAP:
139	return KeyValuePairs.iterHash(kv, valueVisitor.applyHashZipMap(in, 0));	×
140	case RDB_TYPE_LIST_ZIPLIST:
141	return KeyValuePairs.iterList(kv, valueVisitor.applyListZipList(in, 0));	×
142	case RDB_TYPE_SET_INTSET:
143	return KeyValuePairs.iterSet(kv, valueVisitor.applySetIntSet(in, 0));	1✔
144	case RDB_TYPE_ZSET_ZIPLIST:
145	return KeyValuePairs.iterZset(kv, valueVisitor.applyZSetZipList(in, 0));	1✔
146	case RDB_TYPE_ZSET_LISTPACK:
147	return KeyValuePairs.iterZset(kv, valueVisitor.applyZSetListPack(in, 0));	×
148	case RDB_TYPE_HASH_ZIPLIST:
149	return KeyValuePairs.iterHash(kv, valueVisitor.applyHashZipList(in, 0));	1✔
150	case RDB_TYPE_HASH_LISTPACK:
151	return KeyValuePairs.iterHash(kv, valueVisitor.applyHashListPack(in, 0));	×
152	case RDB_TYPE_LIST_QUICKLIST:
153	return KeyValuePairs.iterList(kv, valueVisitor.applyListQuickList(in, 0));	1✔
154	case RDB_TYPE_LIST_QUICKLIST_2:
155	return KeyValuePairs.iterList(kv, valueVisitor.applyListQuickList2(in, 0));	×
156	case RDB_TYPE_MODULE:
157	return KeyValuePairs.module(kv, valueVisitor.applyModule(in, 0));	×
158	case RDB_TYPE_MODULE_2:
159	return KeyValuePairs.module(kv, valueVisitor.applyModule2(in, 0));	×
160	case RDB_TYPE_STREAM_LISTPACKS:
161	return KeyValuePairs.stream(kv, valueVisitor.applyStreamListPacks(in, 0));	×
162	case RDB_TYPE_STREAM_LISTPACKS_2:
163	return KeyValuePairs.stream(kv, valueVisitor.applyStreamListPacks2(in, 0));	×
164	case RDB_TYPE_STREAM_LISTPACKS_3:
165	return KeyValuePairs.stream(kv, valueVisitor.applyStreamListPacks3(in, 0));	×
166	case RDB_TYPE_HASH_LISTPACK_EX:
NEW 167	return KeyValuePairs.iterTTLHash(kv, valueVisitor.applyHashListPackEx(in, 0));	×
168	case RDB_TYPE_HASH_METADATA:
NEW 169	return KeyValuePairs.iterTTLHash(kv, valueVisitor.applyHashMetadata(in, 0));	×
170	default:
171	throw new AssertionError("unexpected value type:" + valueType);	×
172	}
173	} catch (IOException e) {	1✔
174	throw new UncheckedIOException(e);	×
175	}
176	}
177	}

leonchen83 / redis-replicator / #2187

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