#2155

Committed 06 Jun 2025 04:52AM UTC coverage: 71.406% (-0.2%) from 71.609%

Build # #2155

Build Type

push

Committed by chenby

Commit Message

redis 8.0

Run Details

3 of 33 new or added lines in 14 files covered. (9.09%)

3 existing lines in 2 files now uncovered.

6635 of 9292 relevant lines covered (71.41%)

0.71 hits per line

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

97.71

/src/main/java/com/moilioncircle/redis/replicator/rdb/dump/DumpRdbVisitor.java

/*
 * Copyright 2016-2018 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;

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_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 com.moilioncircle.redis.replicator.Replicator;
import com.moilioncircle.redis.replicator.event.Event;
import com.moilioncircle.redis.replicator.io.RedisInputStream;
import com.moilioncircle.redis.replicator.rdb.BaseRdbParser;
import com.moilioncircle.redis.replicator.rdb.DefaultRdbVisitor;
import com.moilioncircle.redis.replicator.rdb.RdbValueVisitor;
import com.moilioncircle.redis.replicator.rdb.datatype.ContextKeyValuePair;
import com.moilioncircle.redis.replicator.rdb.datatype.KeyValuePair;
import com.moilioncircle.redis.replicator.rdb.dump.datatype.DumpKeyValuePair;

/**
 * @author Leon Chen
 * @since 2.5.0
 */
public class DumpRdbVisitor extends DefaultRdbVisitor {
    
    protected int version = -1;

    public DumpRdbVisitor(Replicator replicator) {
        this(replicator, -1);
    }

    /**
     * @param replicator the replicator
     * @param version    dumped version : redis 2.8.x = 6, redis 3.x = 7, redis 4.0.x = 8, redis 5.0+ = 9. 
     *                   -1 means dumped version = rdb version
     * @since 2.6.0
     */
    public DumpRdbVisitor(Replicator replicator, int version) {
        this(replicator, version, 8192);
    }

    public DumpRdbVisitor(Replicator replicator, int version, int size) {
        super(replicator, new DumpRdbValueVisitor(replicator, version, size));
        this.version = version;
    }
    
    /**
     * @param replicator the replicator
     * @param valueVisitor rdb value visitor
     * @since 3.5.1
     */
    public DumpRdbVisitor(Replicator replicator, RdbValueVisitor valueVisitor) {
        super(replicator, valueVisitor);
    }
    
    @Override
    public Event applyString(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], byte[]> o0 = new DumpKeyValuePair();
        byte[] key = parser.rdbLoadEncodedStringObject().first();

        o0.setValueRdbType(RDB_TYPE_STRING);
        o0.setKey(key);
        o0.setValue(valueVisitor.applyString(in, version));
        return context.valueOf(o0);
    }

    @Override
    public Event applyList(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], byte[]> o1 = new DumpKeyValuePair();
        byte[] key = parser.rdbLoadEncodedStringObject().first();

        o1.setValueRdbType(RDB_TYPE_LIST);
        o1.setKey(key);
        o1.setValue(valueVisitor.applyList(in, version));
        return context.valueOf(o1);
    }

    @Override
    public Event applySet(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], byte[]> o2 = new DumpKeyValuePair();
        byte[] key = parser.rdbLoadEncodedStringObject().first();

        o2.setValueRdbType(RDB_TYPE_SET);
        o2.setKey(key);
        o2.setValue(valueVisitor.applySet(in, version));
        return context.valueOf(o2);
    }
    
    @Override
    public Event applySetListPack(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], byte[]> o20 = new DumpKeyValuePair();
        byte[] key = parser.rdbLoadEncodedStringObject().first();
        if (this.version != -1 && this.version < 11 /* since redis rdb version 11 */) {
            o20.setValueRdbType(RDB_TYPE_SET);
        } else {
            o20.setValueRdbType(RDB_TYPE_SET_LISTPACK);
        }
        o20.setKey(key);
        o20.setValue(valueVisitor.applySetListPack(in, version));
        return context.valueOf(o20);
    }

    @Override
    public Event applyZSet(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], byte[]> o3 = new DumpKeyValuePair();
        byte[] key = parser.rdbLoadEncodedStringObject().first();

        o3.setValueRdbType(RDB_TYPE_ZSET);
        o3.setKey(key);
        o3.setValue(valueVisitor.applyZSet(in, version));
        return context.valueOf(o3);
    }

    @Override
    public Event applyZSet2(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], byte[]> o5 = new DumpKeyValuePair();
        byte[] key = parser.rdbLoadEncodedStringObject().first();
        if (this.version != -1 && this.version < 8 /* since redis rdb version 8 */) {
            o5.setValueRdbType(RDB_TYPE_ZSET);
        } else {
            o5.setValueRdbType(RDB_TYPE_ZSET_2);
        }
        o5.setKey(key);
        o5.setValue(valueVisitor.applyZSet2(in, version));
        return context.valueOf(o5);
    }

    @Override
    public Event applyHash(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], byte[]> o4 = new DumpKeyValuePair();
        byte[] key = parser.rdbLoadEncodedStringObject().first();

        o4.setValueRdbType(RDB_TYPE_HASH);
        o4.setKey(key);
        o4.setValue(valueVisitor.applyHash(in, version));
        return context.valueOf(o4);
    }

    @Override
    public Event applyHashZipMap(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], byte[]> o9 = new DumpKeyValuePair();
        byte[] key = parser.rdbLoadEncodedStringObject().first();

        o9.setValueRdbType(RDB_TYPE_HASH_ZIPMAP);
        o9.setKey(key);
        o9.setValue(valueVisitor.applyHashZipMap(in, version));
        return context.valueOf(o9);
    }

    @Override
    public Event applyListZipList(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], byte[]> o10 = new DumpKeyValuePair();
        byte[] key = parser.rdbLoadEncodedStringObject().first();

        o10.setValueRdbType(RDB_TYPE_LIST_ZIPLIST);
        o10.setKey(key);
        o10.setValue(valueVisitor.applyListZipList(in, version));
        return context.valueOf(o10);
    }

    @Override
    public Event applySetIntSet(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], byte[]> o11 = new DumpKeyValuePair();
        byte[] key = parser.rdbLoadEncodedStringObject().first();

        o11.setValueRdbType(RDB_TYPE_SET_INTSET);
        o11.setKey(key);
        o11.setValue(valueVisitor.applySetIntSet(in, version));
        return context.valueOf(o11);
    }

    @Override
    public Event applyZSetZipList(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], byte[]> o12 = new DumpKeyValuePair();
        byte[] key = parser.rdbLoadEncodedStringObject().first();

        o12.setValueRdbType(RDB_TYPE_ZSET_ZIPLIST);
        o12.setKey(key);
        o12.setValue(valueVisitor.applyZSetZipList(in, version));
        return context.valueOf(o12);
    }
    
    @Override
    public Event applyZSetListPack(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], byte[]> o17 = new DumpKeyValuePair();
        byte[] key = parser.rdbLoadEncodedStringObject().first();
        if (this.version != -1 && this.version < 10 /* since redis rdb version 10 */) {
            o17.setValueRdbType(RDB_TYPE_ZSET);
        } else {
            o17.setValueRdbType(RDB_TYPE_ZSET_LISTPACK);
        }
        o17.setKey(key);
        o17.setValue(valueVisitor.applyZSetListPack(in, version));
        return context.valueOf(o17);
    }

    @Override
    public Event applyHashZipList(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], byte[]> o13 = new DumpKeyValuePair();
        byte[] key = parser.rdbLoadEncodedStringObject().first();

        o13.setValueRdbType(RDB_TYPE_HASH_ZIPLIST);
        o13.setKey(key);
        o13.setValue(valueVisitor.applyHashZipList(in, version));
        return context.valueOf(o13);
    }
    
    @Override
    public Event applyHashListPack(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], byte[]> o16 = new DumpKeyValuePair();
        byte[] key = parser.rdbLoadEncodedStringObject().first();
        if (this.version != -1 && this.version < 10 /* since redis rdb version 10 */) {
            o16.setValueRdbType(RDB_TYPE_HASH);
        } else {
            o16.setValueRdbType(RDB_TYPE_HASH_LISTPACK);
        }
        o16.setKey(key);
        o16.setValue(valueVisitor.applyHashListPack(in, version));
        return context.valueOf(o16);
    }

    @Override
    public Event applyListQuickList(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], byte[]> o14 = new DumpKeyValuePair();
        byte[] key = parser.rdbLoadEncodedStringObject().first();
        if (this.version != -1 && this.version < 7 /* since redis rdb version 7 */) {
            o14.setValueRdbType(RDB_TYPE_LIST);
        } else {
            o14.setValueRdbType(RDB_TYPE_LIST_QUICKLIST);
        }
        o14.setKey(key);
        o14.setValue(valueVisitor.applyListQuickList(in, version));
        return context.valueOf(o14);
    }
    
    @Override
    public Event applyListQuickList2(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], byte[]> o18 = new DumpKeyValuePair();
        byte[] key = parser.rdbLoadEncodedStringObject().first();
        if (this.version != -1 && this.version < 10 /* since redis rdb version 10 */) {
            o18.setValueRdbType(RDB_TYPE_LIST);
        } else {
            o18.setValueRdbType(RDB_TYPE_LIST_QUICKLIST_2);
        }
        o18.setKey(key);
        o18.setValue(valueVisitor.applyListQuickList2(in, version));
        return context.valueOf(o18);
    }

    @Override
    public Event applyModule(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], byte[]> o6 = new DumpKeyValuePair();
        byte[] key = parser.rdbLoadEncodedStringObject().first();

        o6.setValueRdbType(RDB_TYPE_MODULE);
        o6.setKey(key);
        o6.setValue(valueVisitor.applyModule(in, version));
        return context.valueOf(o6);
    }

    @Override
    public Event applyModule2(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], byte[]> o7 = new DumpKeyValuePair();
        byte[] key = parser.rdbLoadEncodedStringObject().first();

        o7.setValueRdbType(RDB_TYPE_MODULE_2);
        o7.setKey(key);
        o7.setValue(valueVisitor.applyModule2(in, version));
        return context.valueOf(o7);
    }

    @Override
    public Event applyStreamListPacks(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], byte[]> o15 = new DumpKeyValuePair();
        byte[] key = parser.rdbLoadEncodedStringObject().first();

        o15.setValueRdbType(RDB_TYPE_STREAM_LISTPACKS);
        o15.setKey(key);
        o15.setValue(valueVisitor.applyStreamListPacks(in, version));
        return context.valueOf(o15);
    }
    
    @Override
    public Event applyStreamListPacks2(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], byte[]> o19 = new DumpKeyValuePair();
        byte[] key = parser.rdbLoadEncodedStringObject().first();
        if (this.version != -1 && this.version < 10 /* since redis rdb version 10 */) {
            o19.setValueRdbType(RDB_TYPE_STREAM_LISTPACKS);
        } else {
            o19.setValueRdbType(RDB_TYPE_STREAM_LISTPACKS_2);
        }
        o19.setKey(key);
        o19.setValue(valueVisitor.applyStreamListPacks2(in, version));
        return context.valueOf(o19);
    }
    
    @Override
    public Event applyStreamListPacks3(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        BaseRdbParser parser = new BaseRdbParser(in);
        KeyValuePair<byte[], byte[]> o21 = new DumpKeyValuePair();
        byte[] key = parser.rdbLoadEncodedStringObject().first();
        if (this.version != -1 && this.version < 11 /* since redis rdb version 11 */) {
            o21.setValueRdbType(RDB_TYPE_STREAM_LISTPACKS);
        } else {
            o21.setValueRdbType(RDB_TYPE_STREAM_LISTPACKS_3);
        }
        o21.setKey(key);
        o21.setValue(valueVisitor.applyStreamListPacks3(in, version));
        return context.valueOf(o21);
    }
    
    @Override
    public Event applyHashMetadata(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException{
        // TODO
        return null;
    }
    
    @Override
    public Event applyHashListPackEx(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
        // TODO
        return null;
    }
}

1	/*
2	* Copyright 2016-2018 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;
18
19	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_HASH;
20	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_HASH_LISTPACK;
21	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_HASH_ZIPLIST;
22	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_HASH_ZIPMAP;
23	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_LIST;
24	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_LIST_QUICKLIST;
25	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_LIST_QUICKLIST_2;
26	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_LIST_ZIPLIST;
27	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_MODULE;
28	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_MODULE_2;
29	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_SET;
30	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_SET_INTSET;
31	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_SET_LISTPACK;
32	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_STREAM_LISTPACKS;
33	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_STREAM_LISTPACKS_2;
34	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_STREAM_LISTPACKS_3;
35	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_STRING;
36	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_ZSET;
37	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_ZSET_2;
38	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_ZSET_LISTPACK;
39	import static com.moilioncircle.redis.replicator.Constants.RDB_TYPE_ZSET_ZIPLIST;
40
41	import java.io.IOException;
42
43	import com.moilioncircle.redis.replicator.Replicator;
44	import com.moilioncircle.redis.replicator.event.Event;
45	import com.moilioncircle.redis.replicator.io.RedisInputStream;
46	import com.moilioncircle.redis.replicator.rdb.BaseRdbParser;
47	import com.moilioncircle.redis.replicator.rdb.DefaultRdbVisitor;
48	import com.moilioncircle.redis.replicator.rdb.RdbValueVisitor;
49	import com.moilioncircle.redis.replicator.rdb.datatype.ContextKeyValuePair;
50	import com.moilioncircle.redis.replicator.rdb.datatype.KeyValuePair;
51	import com.moilioncircle.redis.replicator.rdb.dump.datatype.DumpKeyValuePair;
52
53	/**
54	* @author Leon Chen
55	* @since 2.5.0
56	*/
57	public class DumpRdbVisitor extends DefaultRdbVisitor {
58
59	protected int version = -1;	1✔
60
61	public DumpRdbVisitor(Replicator replicator) {
62	this(replicator, -1);	1✔
63	}	1✔
64
65	/**
66	* @param replicator the replicator
67	* @param version dumped version : redis 2.8.x = 6, redis 3.x = 7, redis 4.0.x = 8, redis 5.0+ = 9.
68	* -1 means dumped version = rdb version
69	* @since 2.6.0
70	*/
71	public DumpRdbVisitor(Replicator replicator, int version) {
72	this(replicator, version, 8192);	1✔
73	}	1✔
74
75	public DumpRdbVisitor(Replicator replicator, int version, int size) {
76	super(replicator, new DumpRdbValueVisitor(replicator, version, size));	1✔
77	this.version = version;	1✔
78	}	1✔
79
80	/**
81	* @param replicator the replicator
82	* @param valueVisitor rdb value visitor
83	* @since 3.5.1
84	*/
85	public DumpRdbVisitor(Replicator replicator, RdbValueVisitor valueVisitor) {
86	super(replicator, valueVisitor);	×
87	}	×
88
89	@Override
90	public Event applyString(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
91	BaseRdbParser parser = new BaseRdbParser(in);	1✔
92	KeyValuePair<byte[], byte[]> o0 = new DumpKeyValuePair();	1✔
93	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
94
95	o0.setValueRdbType(RDB_TYPE_STRING);	1✔
96	o0.setKey(key);	1✔
97	o0.setValue(valueVisitor.applyString(in, version));	1✔
98	return context.valueOf(o0);	1✔
99	}
100
101	@Override
102	public Event applyList(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
103	BaseRdbParser parser = new BaseRdbParser(in);	1✔
104	KeyValuePair<byte[], byte[]> o1 = new DumpKeyValuePair();	1✔
105	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
106
107	o1.setValueRdbType(RDB_TYPE_LIST);	1✔
108	o1.setKey(key);	1✔
109	o1.setValue(valueVisitor.applyList(in, version));	1✔
110	return context.valueOf(o1);	1✔
111	}
112
113	@Override
114	public Event applySet(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
115	BaseRdbParser parser = new BaseRdbParser(in);	1✔
116	KeyValuePair<byte[], byte[]> o2 = new DumpKeyValuePair();	1✔
117	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
118
119	o2.setValueRdbType(RDB_TYPE_SET);	1✔
120	o2.setKey(key);	1✔
121	o2.setValue(valueVisitor.applySet(in, version));	1✔
122	return context.valueOf(o2);	1✔
123	}
124
125	@Override
126	public Event applySetListPack(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
127	BaseRdbParser parser = new BaseRdbParser(in);	1✔
128	KeyValuePair<byte[], byte[]> o20 = new DumpKeyValuePair();	1✔
129	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
130	if (this.version != -1 && this.version < 11 /* since redis rdb version 11 */) {	1✔
131	o20.setValueRdbType(RDB_TYPE_SET);	1✔
132	} else {
133	o20.setValueRdbType(RDB_TYPE_SET_LISTPACK);	1✔
134	}
135	o20.setKey(key);	1✔
136	o20.setValue(valueVisitor.applySetListPack(in, version));	1✔
137	return context.valueOf(o20);	1✔
138	}
139
140	@Override
141	public Event applyZSet(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
142	BaseRdbParser parser = new BaseRdbParser(in);	1✔
143	KeyValuePair<byte[], byte[]> o3 = new DumpKeyValuePair();	1✔
144	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
145
146	o3.setValueRdbType(RDB_TYPE_ZSET);	1✔
147	o3.setKey(key);	1✔
148	o3.setValue(valueVisitor.applyZSet(in, version));	1✔
149	return context.valueOf(o3);	1✔
150	}
151
152	@Override
153	public Event applyZSet2(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
154	BaseRdbParser parser = new BaseRdbParser(in);	1✔
155	KeyValuePair<byte[], byte[]> o5 = new DumpKeyValuePair();	1✔
156	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
157	if (this.version != -1 && this.version < 8 /* since redis rdb version 8 */) {	1✔
158	o5.setValueRdbType(RDB_TYPE_ZSET);	1✔
159	} else {
160	o5.setValueRdbType(RDB_TYPE_ZSET_2);	1✔
161	}
162	o5.setKey(key);	1✔
163	o5.setValue(valueVisitor.applyZSet2(in, version));	1✔
164	return context.valueOf(o5);	1✔
165	}
166
167	@Override
168	public Event applyHash(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
169	BaseRdbParser parser = new BaseRdbParser(in);	1✔
170	KeyValuePair<byte[], byte[]> o4 = new DumpKeyValuePair();	1✔
171	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
172
173	o4.setValueRdbType(RDB_TYPE_HASH);	1✔
174	o4.setKey(key);	1✔
175	o4.setValue(valueVisitor.applyHash(in, version));	1✔
176	return context.valueOf(o4);	1✔
177	}
178
179	@Override
180	public Event applyHashZipMap(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
181	BaseRdbParser parser = new BaseRdbParser(in);	1✔
182	KeyValuePair<byte[], byte[]> o9 = new DumpKeyValuePair();	1✔
183	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
184
185	o9.setValueRdbType(RDB_TYPE_HASH_ZIPMAP);	1✔
186	o9.setKey(key);	1✔
187	o9.setValue(valueVisitor.applyHashZipMap(in, version));	1✔
188	return context.valueOf(o9);	1✔
189	}
190
191	@Override
192	public Event applyListZipList(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
193	BaseRdbParser parser = new BaseRdbParser(in);	1✔
194	KeyValuePair<byte[], byte[]> o10 = new DumpKeyValuePair();	1✔
195	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
196
197	o10.setValueRdbType(RDB_TYPE_LIST_ZIPLIST);	1✔
198	o10.setKey(key);	1✔
199	o10.setValue(valueVisitor.applyListZipList(in, version));	1✔
200	return context.valueOf(o10);	1✔
201	}
202
203	@Override
204	public Event applySetIntSet(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
205	BaseRdbParser parser = new BaseRdbParser(in);	1✔
206	KeyValuePair<byte[], byte[]> o11 = new DumpKeyValuePair();	1✔
207	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
208
209	o11.setValueRdbType(RDB_TYPE_SET_INTSET);	1✔
210	o11.setKey(key);	1✔
211	o11.setValue(valueVisitor.applySetIntSet(in, version));	1✔
212	return context.valueOf(o11);	1✔
213	}
214
215	@Override
216	public Event applyZSetZipList(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
217	BaseRdbParser parser = new BaseRdbParser(in);	1✔
218	KeyValuePair<byte[], byte[]> o12 = new DumpKeyValuePair();	1✔
219	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
220
221	o12.setValueRdbType(RDB_TYPE_ZSET_ZIPLIST);	1✔
222	o12.setKey(key);	1✔
223	o12.setValue(valueVisitor.applyZSetZipList(in, version));	1✔
224	return context.valueOf(o12);	1✔
225	}
226
227	@Override
228	public Event applyZSetListPack(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
229	BaseRdbParser parser = new BaseRdbParser(in);	1✔
230	KeyValuePair<byte[], byte[]> o17 = new DumpKeyValuePair();	1✔
231	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
232	if (this.version != -1 && this.version < 10 /* since redis rdb version 10 */) {	1✔
233	o17.setValueRdbType(RDB_TYPE_ZSET);	1✔
234	} else {
235	o17.setValueRdbType(RDB_TYPE_ZSET_LISTPACK);	1✔
236	}
237	o17.setKey(key);	1✔
238	o17.setValue(valueVisitor.applyZSetListPack(in, version));	1✔
239	return context.valueOf(o17);	1✔
240	}
241
242	@Override
243	public Event applyHashZipList(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
244	BaseRdbParser parser = new BaseRdbParser(in);	1✔
245	KeyValuePair<byte[], byte[]> o13 = new DumpKeyValuePair();	1✔
246	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
247
248	o13.setValueRdbType(RDB_TYPE_HASH_ZIPLIST);	1✔
249	o13.setKey(key);	1✔
250	o13.setValue(valueVisitor.applyHashZipList(in, version));	1✔
251	return context.valueOf(o13);	1✔
252	}
253
254	@Override
255	public Event applyHashListPack(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
256	BaseRdbParser parser = new BaseRdbParser(in);	1✔
257	KeyValuePair<byte[], byte[]> o16 = new DumpKeyValuePair();	1✔
258	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
259	if (this.version != -1 && this.version < 10 /* since redis rdb version 10 */) {	1✔
260	o16.setValueRdbType(RDB_TYPE_HASH);	1✔
261	} else {
262	o16.setValueRdbType(RDB_TYPE_HASH_LISTPACK);	1✔
263	}
264	o16.setKey(key);	1✔
265	o16.setValue(valueVisitor.applyHashListPack(in, version));	1✔
266	return context.valueOf(o16);	1✔
267	}
268
269	@Override
270	public Event applyListQuickList(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
271	BaseRdbParser parser = new BaseRdbParser(in);	1✔
272	KeyValuePair<byte[], byte[]> o14 = new DumpKeyValuePair();	1✔
273	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
274	if (this.version != -1 && this.version < 7 /* since redis rdb version 7 */) {	1✔
275	o14.setValueRdbType(RDB_TYPE_LIST);	1✔
276	} else {
277	o14.setValueRdbType(RDB_TYPE_LIST_QUICKLIST);	1✔
278	}
279	o14.setKey(key);	1✔
280	o14.setValue(valueVisitor.applyListQuickList(in, version));	1✔
281	return context.valueOf(o14);	1✔
282	}
283
284	@Override
285	public Event applyListQuickList2(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
286	BaseRdbParser parser = new BaseRdbParser(in);	1✔
287	KeyValuePair<byte[], byte[]> o18 = new DumpKeyValuePair();	1✔
288	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
289	if (this.version != -1 && this.version < 10 /* since redis rdb version 10 */) {	1✔
290	o18.setValueRdbType(RDB_TYPE_LIST);	1✔
291	} else {
292	o18.setValueRdbType(RDB_TYPE_LIST_QUICKLIST_2);	1✔
293	}
294	o18.setKey(key);	1✔
295	o18.setValue(valueVisitor.applyListQuickList2(in, version));	1✔
296	return context.valueOf(o18);	1✔
297	}
298
299	@Override
300	public Event applyModule(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
301	BaseRdbParser parser = new BaseRdbParser(in);	1✔
302	KeyValuePair<byte[], byte[]> o6 = new DumpKeyValuePair();	1✔
303	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
304
305	o6.setValueRdbType(RDB_TYPE_MODULE);	1✔
306	o6.setKey(key);	1✔
307	o6.setValue(valueVisitor.applyModule(in, version));	1✔
308	return context.valueOf(o6);	1✔
309	}
310
311	@Override
312	public Event applyModule2(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
313	BaseRdbParser parser = new BaseRdbParser(in);	1✔
314	KeyValuePair<byte[], byte[]> o7 = new DumpKeyValuePair();	1✔
315	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
316
317	o7.setValueRdbType(RDB_TYPE_MODULE_2);	1✔
318	o7.setKey(key);	1✔
319	o7.setValue(valueVisitor.applyModule2(in, version));	1✔
320	return context.valueOf(o7);	1✔
321	}
322
323	@Override
324	public Event applyStreamListPacks(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
325	BaseRdbParser parser = new BaseRdbParser(in);	1✔
326	KeyValuePair<byte[], byte[]> o15 = new DumpKeyValuePair();	1✔
327	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
328
329	o15.setValueRdbType(RDB_TYPE_STREAM_LISTPACKS);	1✔
330	o15.setKey(key);	1✔
331	o15.setValue(valueVisitor.applyStreamListPacks(in, version));	1✔
332	return context.valueOf(o15);	1✔
333	}
334
335	@Override
336	public Event applyStreamListPacks2(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
337	BaseRdbParser parser = new BaseRdbParser(in);	1✔
338	KeyValuePair<byte[], byte[]> o19 = new DumpKeyValuePair();	1✔
339	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
340	if (this.version != -1 && this.version < 10 /* since redis rdb version 10 */) {	1✔
341	o19.setValueRdbType(RDB_TYPE_STREAM_LISTPACKS);	1✔
342	} else {
343	o19.setValueRdbType(RDB_TYPE_STREAM_LISTPACKS_2);	1✔
344	}
345	o19.setKey(key);	1✔
346	o19.setValue(valueVisitor.applyStreamListPacks2(in, version));	1✔
347	return context.valueOf(o19);	1✔
348	}
349
350	@Override
351	public Event applyStreamListPacks3(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
352	BaseRdbParser parser = new BaseRdbParser(in);	1✔
353	KeyValuePair<byte[], byte[]> o21 = new DumpKeyValuePair();	1✔
354	byte[] key = parser.rdbLoadEncodedStringObject().first();	1✔
355	if (this.version != -1 && this.version < 11 /* since redis rdb version 11 */) {	1✔
356	o21.setValueRdbType(RDB_TYPE_STREAM_LISTPACKS);	1✔
357	} else {
358	o21.setValueRdbType(RDB_TYPE_STREAM_LISTPACKS_3);	1✔
359	}
360	o21.setKey(key);	1✔
361	o21.setValue(valueVisitor.applyStreamListPacks3(in, version));	1✔
362	return context.valueOf(o21);	1✔
363	}
364
365	@Override
366	public Event applyHashMetadata(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException{
367	// TODO
NEW 368	return null;	×
369	}
370
371	@Override
372	public Event applyHashListPackEx(RedisInputStream in, int version, ContextKeyValuePair context) throws IOException {
373	// TODO
NEW 374	return null;	×
375	}
376	}

leonchen83 / redis-replicator / #2155

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