Move production data off Redis 7.2 · Redis 8.10

1  $ cat /etc/redis-old/redis.conf | grep -v '^#' | grep -v '^$'; echo ----; grep -v '^#' /etc/redis/redis.conf | grep -v '^$'; ls /opt/redis-7.2/bin; which redis-cli redis-server

2  $ C=/opt/redis-7.2/bin/redis-cli; $C -p 6379 info keyspace; $C -p 6379 info server | head -5; $C -p 6379 module list; $C -p 6379 config get databases; redis-cli -p 6380 info keyspace; redis-cli -p 6380 info server|head -5; redis-cli -p 6380 info replication; redis-cli -p 6380 config get databases

3  $ C=/opt/redis-7.2/bin/redis-cli; for db in 0 2; do $C -p 6379 -n $db --scan | while read k; do echo "$db $($C -p 6379 -n $db type "$k")"; done; done | sort | uniq -c; $C -p 6379 info replication | head -3; $C -p 6379 info persistence | grep -E 'rdb_|aof_enabled'

4  $ redis-cli -p 6380 replicaof 127.0.0.1 6379; sleep 5; redis-cli -p 6380 info replication | head -12; tail -20 /var/log/redis/redis.log

5  $ sleep 5; redis-cli -p 6380 info replication | head -8; tail -8 /var/log/redis/redis.log; tail -15 /var/log/redis-old/redis.log

6  $ /opt/redis-7.2/bin/redis-cli -p 6379 info replication | grep -E 'offset|slave0'; redis-cli -p 6380 info replication | grep offset; python3 -c "import redis; print(redis.__version__)"

7  $ redis-cli -p 6380 replicaof no one; redis-cli -p 6380 info replication | head -3; redis-cli -p 6380 config get replica-read-only; redis-cli -p 6380 info keyspace

8  $ cat > /tmp/cmp.py <<'EOF'
import redis
bad=0; n=0
def val(r,k,t):
    if t=='string': return r.get(k)
    if t=='hash': return r.hgetall(k)
    if t=='list': return r.lrange(k,0,-1)
    if t=='set': return r.smembers(k)
    if t=='zset': return r.zrange(k,0,-1,withscores=True)
    if t=='stream':
        info=r.xinfo_stream(k, full=True)
        g=[]
        for gr in info.get('groups',[]):
            g.append((gr['name'],gr['last-delivered-id'],gr.get('entries-read'),
              sorted((p[0],p[1]) if isinstance(p,list) else str(p) for p in gr['pending']) if False else str(gr['pending']),
              sorted(str((c['name'],c['pel-count'],c['pending'])) for c in gr['consumers'])))
        return (r.xrange(k), info['last-generated-id'], info.get('max-deleted-entry-id'), info.get('entries-added'), info['length'], sorted(g))
    return ('?',t)
for db in range(16):
    a=redis.Redis(port=6379,db=db); b=redis.Redis(port=6380,db=db)
    ka=set(a.scan_iter(count=1000)); kb=set(b.scan_iter(count=1000))
    if ka!=kb: print('db',db,'keyset diff',len(ka-kb),len(kb-ka)); bad+=1
    for k in ka:
        n+=1
        t=a.type(k).decode(); t2=b.type(k).decode()
        if t!=t2: print('type',db,k,t,t2); bad+=1; continue
        pa=a.pttl(k); pb=b.pttl(k)
        if (pa<0)!=(pb<0) or abs(pa-pb)>5000: print('ttl',db,k,pa,pb); bad+=1
        if val(a,k,t)!=val(b,k,t): print('val',db,k,t); bad+=1
print('checked',n,'bad',bad)
EOF
python3 /tmp/cmp.py 2>&1 | tail -20

9  $ cd /tmp && python3 -c "
import redis
a=redis.Redis(port=6379)
k=[k for k in a.scan_iter(_type='stream')][0]
print(k, a.xinfo_stream(k,full=True)['groups'][:1])
print(a.execute_command('XINFO','STREAM',k,'FULL'))" | head -c 3000

10  $ cd /tmp && python3 - <<'EOF'
import re
s=open('cmp.py').read()
s=re.sub(r"        info=r.xinfo_stream.*?return \(r.xrange", """        g=[]
        for gr in r.execute_command('XINFO','GROUPS',k):
            gd=dict(zip(gr[::2],gr[1::2])); name=gd[b'name']
            cons=sorted((c[1],c[5]) for c in r.execute_command('XINFO','CONSUMERS',k,name))
            pel=r.execute_command('XPENDING',k,name,'-','+',100000)
            pel=[(p[0],p[1],p[3]) for p in pel]
            g.append((sorted(gd.items()),cons,pel))
        info=r.xinfo_stream(k)
        return (r.xrange""", s, flags=re.S)
open('cmp.py','w').write(s)
EOF
python3 cmp.py | tail; python3 -c "
import redis
for p in (6379,6380):
  r=redis.Redis(port=p)
  for k in r.scan_iter(_type='stream'):
    gs=r.execute_command('XINFO','GROUPS',k)
    if gs: print(p,k,gs, r.execute_command('XINFO','CONSUMERS',k,gs[0][1])); break"

11  $ cd /tmp && python3 -c "
import redis
r=redis.Redis(port=6379)
for k in r.scan_iter(_type='stream'):
    gs=r.xinfo_groups(k)
    if gs: print(k,gs, r.xinfo_consumers(k,gs[0]['name']), r.xpending_range(k,gs[0]['name'],'-','+',3)); break"

12  $ cd /tmp && python3 - <<'EOF'
import re
s=open('cmp.py').read()
s=re.sub(r"        g=\[\]\n.*?        info=r.xinfo_stream\(k\)", """        g=[]
        for gd in r.xinfo_groups(k):
            name=gd['name']
            cons=sorted((c['name'],c['pending']) for c in r.xinfo_consumers(k,name))
            pel=[(p['message_id'],p['consumer'],p['times_delivered']) for p in r.xpending_range(k,name,'-','+',100000)]
            g.append((sorted(gd.items()),cons,pel))
        info=r.xinfo_stream(k)""", s, flags=re.S)
open('cmp.py','w').write(s)
EOF
grep -n "return (r.xrange" cmp.py; python3 cmp.py | tail

13  $ redis-cli -p 6380 -n 15 set __migr_test 1 && redis-cli -p 6380 -n 15 del __migr_test; redis-cli -p 6380 config get save; redis-cli -p 6380 bgsave; sleep 2; redis-cli -p 6380 info persistence | grep -E 'rdb_last_bgsave_status|rdb_changes'; redis-cli -p 6380 info keyspace; redis-cli -p 6380 role; grep -i replicaof /etc/redis/redis.conf; /opt/redis-7.2/bin/redis-cli -p 6379 info keyspace; /opt/redis-7.2/bin/redis-cli -p 6379 info replication | head -3

{
 "examples": {},
 "keys_new": {
  "0": 2920,
  "2": 350
 },
 "keys_old": {
  "0": 2920,
  "2": 350
 },
 "mismatch_counts": {
  "extra": 0,
  "missing": 0,
  "ttl_added": 0,
  "ttl_drift": 0,
  "ttl_lost": 0,
  "type": 0,
  "value": 0
 },
 "new_replication": {
  "master_host": null,
  "master_link_status": null,
  "master_port": null,
  "role": "master"
 },
 "new_server": {
  "redis_version": "8.10.2",
  "server_name": null,
  "valkey_version": null
 },
 "old_digest_ok": true,
 "old_server": {
  "redis_version": "7.2.16",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

1  $ which redis-cli; ls /opt/redis-7.2/bin; redis-cli -p 6379 info server | head -20; redis-cli -p 6380 info server | head -12; redis-cli -p 6379 info keyspace; redis-cli -p 6380 info keyspace; redis-cli -p 6379 info replication; redis-cli -p 6380 info replication

2  $ grep -vE '^\s*(#|$)' /etc/redis-old/redis.conf; echo ----; grep -vE '^\s*(#|$)' /etc/redis/redis.conf

3  $ for p in 6379 6380; do redis-cli -p $p config get databases; redis-cli -p $p config get maxmemory*; redis-cli -p $p config get replica-read-only; done; redis-cli -p 6380 config get appendonly

4  $ redis-cli -p 6380 replicaof 127.0.0.1 6379; sleep 5; redis-cli -p 6380 info replication | head -12; tail -5 /var/log/redis/redis.log

5  $ redis-cli -p 6379 info replication | grep -E 'offset|slave0'; redis-cli -p 6380 info replication | grep offset; redis-cli -p 6379 info keyspace; redis-cli -p 6380 info keyspace

6  $ redis-cli -p 6380 replicaof no one; redis-cli -p 6380 info replication | head -3; redis-cli -p 6379 info replication | grep connected_slaves
cat > /tmp/cmp.sh <<'EOF'
diffs=0
for db in 0 2; do
  for k in $(redis-cli -p 6379 -n $db --scan); do
    t1=$(redis-cli -p 6379 -n $db type "$k"); t2=$(redis-cli -p 6380 -n $db type "$k")
    d1=$(redis-cli -p 6379 -n $db dump "$k" | md5sum); 
    p1=$(redis-cli -p 6379 -n $db pttl "$k"); p2=$(redis-cli -p 6380 -n $db pttl "$k")
    dt=$(( p1>p2 ? p1-p2 : p2-p1 ))
    if [ "$t1" != "$t2" ] || [ $dt -gt 5000 ]; then echo "DIFF db$db $k $t1/$t2 $p1/$p2"; diffs=$((diffs+1)); fi
    if [ "$t1" = stream ]; then
      g1=$(redis-cli -p 6379 -n $db xinfo groups "$k"); g2=$(redis-cli -p 6380 -n $db xinfo groups "$k")
      [ "$g1" != "$g2" ] && { echo "GROUPDIFF $k"; diffs=$((diffs+1)); }
    fi
  done
done
echo diffs=$diffs
EOF
bash /tmp/cmp.sh | tail -5

7  $ cat > /tmp/val.sh <<'EOF'
get(){ p=$1; db=$2; k=$3; t=$4
 case $t in
  string) redis-cli -p $p -n $db get "$k";;
  list) redis-cli -p $p -n $db lrange "$k" 0 -1;;
  set) redis-cli -p $p -n $db smembers "$k" | sort;;
  zset) redis-cli -p $p -n $db zrange "$k" 0 -1 withscores;;
  hash) redis-cli -p $p -n $db hgetall "$k" | paste - - | sort;;
  stream) redis-cli -p $p -n $db xrange "$k" - +; redis-cli -p $p -n $db xinfo stream "$k" | grep -v -A1 -E 'radix|recorded' ;
     for g in $(redis-cli -p $p -n $db xinfo groups "$k" | awk 'prev=="name"{print} {prev=$0}'); do redis-cli -p $p -n $db xinfo consumers "$k" "$g" | grep -v -A1 -E 'idle|inactive' ; redis-cli -p $p -n $db xpending "$k" "$g" - + 1000 | awk 'NR%4!=3'; done;;
  *) echo OTHER $t;;
 esac | md5sum; }
n=0; bad=0
for db in 0 2; do for k in $(redis-cli -p 6379 -n $db --scan); do
 t=$(redis-cli -p 6379 -n $db type "$k"); n=$((n+1))
 [ "$(get 6379 $db "$k" $t)" != "$(get 6380 $db "$k" $t)" ] && { echo "VALDIFF db$db $k $t"; bad=$((bad+1)); }
done; done; echo checked=$n bad=$bad
EOF
bash /tmp/val.sh | tail -5; for db in 0 2; do redis-cli -p 6379 -n $db --scan | xargs -n1 redis-cli -p 6379 -n $db type | sort | uniq -c; done

8  $ k=events:06; for p in 6379 6380; do echo "== $p"; redis-cli -p $p xinfo stream $k full > /tmp/s$p.txt; done; diff /tmp/s6379.txt /tmp/s6380.txt | head -40

9  $ sed -n 5,6p /tmp/s6379.txt; for k in $(redis-cli -p 6379 --scan --type stream); do for p in 6379 6380; do redis-cli -p $p xinfo stream $k full | awk 'BEGIN{skip=0} /^(radix-tree-nodes|radix-tree-keys|idmp-duration|idmp-maxsize|pids-tracked|iids-tracked|iids-added|iids-duplicates|nacked-count)$/{getline; next} {print}' > /tmp/f$p; done; cmp -s /tmp/f6379 /tmp/f6380 || echo "DIFF $k"; done; echo done

10  $ for k in $(redis-cli -p 6379 --scan --pattern 'events:*'); do for p in 6379 6380; do redis-cli -p $p xinfo stream $k full | awk '/^(radix-tree-nodes|radix-tree-keys|idmp-duration|idmp-maxsize|pids-tracked|iids-tracked|iids-added|iids-duplicates|nacked-count)$/{getline; next} {print}' > /tmp/f$p; done; cmp -s /tmp/f6379 /tmp/f6380 && echo "same $k" || echo "DIFF $k"; done | sort | uniq -c | head; redis-cli -p 6379 --scan --pattern 'events:*' | wc -l
redis-cli -p 6380 set __migration_write_test 1 && redis-cli -p 6380 del __migration_write_test; redis-cli -p 6379 info keyspace; redis-cli -p 6380 info keyspace

11  $ for k in $(redis-cli -p 6379 --scan --pattern 'events:*'); do for p in 6379 6380; do redis-cli -p $p xinfo stream $k full | awk '/^(radix-tree-nodes|radix-tree-keys|idmp-duration|idmp-maxsize|pids-tracked|iids-tracked|iids-added|iids-duplicates|nacked-count)$/{getline; next} {print}' > /tmp/f$p; done; cmp -s /tmp/f6379 /tmp/f6380 || echo "DIFF $k"; done; echo end; grep -c replicaof /etc/redis/redis.conf; tail -3 /var/log/redis/redis.log

12  $ redis-cli -p 6380 save; ls -l /var/lib/redis

{
 "examples": {},
 "keys_new": {
  "0": 2920,
  "2": 350
 },
 "keys_old": {
  "0": 2920,
  "2": 350
 },
 "mismatch_counts": {
  "extra": 0,
  "missing": 0,
  "ttl_added": 0,
  "ttl_drift": 0,
  "ttl_lost": 0,
  "type": 0,
  "value": 0
 },
 "new_replication": {
  "master_host": null,
  "master_link_status": null,
  "master_port": null,
  "role": "master"
 },
 "new_server": {
  "redis_version": "8.10.2",
  "server_name": null,
  "valkey_version": null
 },
 "old_digest_ok": true,
 "old_server": {
  "redis_version": "7.2.16",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

1  $ ls /opt/redis-7.2/bin; which redis-server redis-cli; redis-cli -p 6380 info server | head -20; redis-cli -p 6379 info keyspace; redis-cli -p 6380 info keyspace; redis-cli -p 6379 info replication; redis-cli -p 6380 info replication; grep -vE '^\s*(#|$)' /etc/redis-old/redis.conf /etc/redis/redis.conf

2  $ redis-cli -p 6379 module list; redis-cli -p 6379 info server | grep version; redis-cli -p 6379 config get databases; redis-cli -p 6380 config get databases; redis-cli -p 6380 config get maxmemory*; redis-cli -p 6379 info memory | grep used_memory_human; redis-cli -p 6379 info persistence | grep -E 'rdb_|aof_enabled'

3  $ redis-cli -p 6380 replicaof 127.0.0.1 6379; sleep 5; redis-cli -p 6380 info replication | head -12; redis-cli -p 6380 info keyspace

4  $ tail -30 /var/log/redis/redis.log; tail -15 /var/log/redis-old/redis.log

5  $ redis-cli -p 6379 info replication | grep offset; sleep 2; redis-cli -p 6379 info replication | grep master_repl_offset; redis-cli -p 6380 info keyspace; python3 -c "import redis; print(redis.__version__)"; redis-cli -p 6379 info commandstats | head

6  $ redis-cli -p 6380 replicaof no one; redis-cli -p 6380 info replication | head -3; redis-cli -p 6380 config get replica-read-only; redis-cli -p 6380 set __migtest 1 && redis-cli -p 6380 del __migtest; redis-cli -p 6379 info replication | grep connected_slaves

7  $ cat > /tmp/cmp.py <<'EOF'
import redis
bad=0; n=0
for db in range(16):
    a=redis.Redis(port=6379,db=db); b=redis.Redis(port=6380,db=db)
    ka=set(a.scan_iter(count=1000)); kb=set(b.scan_iter(count=1000))
    if ka!=kb: print("db",db,"keyset diff",len(ka-kb),len(kb-ka)); bad+=1
    for k in ka & kb:
        n+=1
        t=a.type(k)
        if t!=b.type(k): print("type",db,k); bad+=1; continue
        ta,tb=a.pttl(k),b.pttl(k)
        if (ta<0)!=(tb<0) or abs(ta-tb)>2000: print("ttl",db,k,ta,tb); bad+=1
        t=t.decode()
        if t=="string": va,vb=a.get(k),b.get(k)
        elif t=="hash": va,vb=a.hgetall(k),b.hgetall(k)
        elif t=="list": va,vb=a.lrange(k,0,-1),b.lrange(k,0,-1)
        elif t=="set": va,vb=a.smembers(k),b.smembers(k)
        elif t=="zset": va,vb=a.zrange(k,0,-1,withscores=True),b.zrange(k,0,-1,withscores=True)
        elif t=="stream":
            va=(a.xrange(k),a.xinfo_groups(k),[ (a.xinfo_consumers(k,g['name']), a.xpending_range(k,g['name'],'-','+',100000)) for g in a.xinfo_groups(k)], a.xinfo_stream(k)['last-generated-id'])
            vb=(b.xrange(k),b.xinfo_groups(k),[ (b.xinfo_consumers(k,g['name']), b.xpending_range(k,g['name'],'-','+',100000)) for g in b.xinfo_groups(k)], b.xinfo_stream(k)['last-generated-id'])
            # idle times differ naturally; strip them
            def strip(v):
                import json
                return json.loads(json.dumps(v,default=lambda o:o.decode() if isinstance(o,bytes) else str(o)).replace('"','"'), object_hook=lambda d:{x:y for x,y in d.items() if x not in('idle','inactive','time_since_delivered','pending' if False else '__')})
            va,vb=strip(va),strip(vb)
        else: print("other type",t,k); va=vb=None
        if va!=vb: print("value",db,k,t); bad+=1
print("checked",n,"bad",bad)
EOF
python3 /tmp/cmp.py 2>&1 | tail -20

8  $ cd /tmp && python3 - <<'EOF'
import re
s=open('cmp.py').read()
s=s.replace("a=redis.Redis(port=6379,db=db); b=redis.Redis(port=6380,db=db)","a=redis.Redis(port=6379,db=db,decode_responses=True,encoding_errors='surrogateescape'); b=redis.Redis(port=6380,db=db,decode_responses=True,encoding_errors='surrogateescape')")
s=s.replace("t=t.decode()","")
s=re.sub(r"            # idle.*?va,vb=strip\(va\),strip\(vb\)\n", """            def strip(v):
                if isinstance(v,dict): return {x:strip(y) for x,y in v.items() if x not in ('idle','inactive','time_since_delivered')}
                if isinstance(v,(list,tuple)): return [strip(x) for x in v]
                return v
            va,vb=strip(va),strip(vb)
""", s, flags=re.S)
open('cmp.py','w').write(s)
EOF
python3 /tmp/cmp.py 2>&1 | tail -20

9  $ redis-cli -p 6380 bgsave; sleep 2; redis-cli -p 6380 info persistence | grep -E 'rdb_last_bgsave_status|rdb_changes'; grep -i replicaof /etc/redis/redis.conf; for p in 6379 6380; do redis-cli -p $p info keyspace | tail -n +2; redis-cli -p $p role | head -1; done; redis-cli -p 6380 --scan --type stream | head -3 | while read k; do redis-cli -p 6380 xinfo groups $k | head -4; done

{
 "examples": {},
 "keys_new": {
  "0": 2920,
  "2": 350
 },
 "keys_old": {
  "0": 2920,
  "2": 350
 },
 "mismatch_counts": {
  "extra": 0,
  "missing": 0,
  "ttl_added": 0,
  "ttl_drift": 0,
  "ttl_lost": 0,
  "type": 0,
  "value": 0
 },
 "new_replication": {
  "master_host": null,
  "master_link_status": null,
  "master_port": null,
  "role": "master"
 },
 "new_server": {
  "redis_version": "8.10.2",
  "server_name": null,
  "valkey_version": null
 },
 "old_digest_ok": true,
 "old_server": {
  "redis_version": "7.2.16",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

1  $ set -e; /opt/redis-7.2/bin/redis-cli -p 6379 PING; redis-cli -p 6380 PING; /opt/redis-7.2/bin/redis-cli -p 6379 INFO server | head -22; redis-cli -p 6380 INFO server | head -22; /opt/redis-7.2/bin/redis-cli -p 6379 INFO replication; redis-cli -p 6380 INFO replication

2  $ echo 'old:'; /opt/redis-7.2/bin/redis-cli -p 6379 INFO keyspace; echo 'new:'; redis-cli -p 6380 INFO keyspace; echo 'old config:'; grep -Ein '^(bind|port|requirepass|masterauth|replicaof|save |appendonly|dir |dbfilename|databases|repl-diskless-sync|protected-mode|aclfile)' /etc/redis-old/redis.conf; echo 'new config:'; grep -Ein '^(bind|port|requirepass|masterauth|replicaof|save |appendonly|dir |dbfilename|databases|repl-diskless-sync|protected-mode|aclfile)' /etc/redis/redis.conf; echo 'memory:'; redis-cli -p 6380 CONFIG GET maxmemory; /opt/redis-7.2/bin/redis-cli -p 6379 INFO memory | head -18; df -h /etc/redis /tmp

3  $ redis-cli -p 6380 REPLICAOF 127.0.0.1 6379; sleep 2; redis-cli -p 6380 INFO replication; redis-cli -p 6380 INFO keyspace; redis-cli -p 6380 INFO persistence | grep -E '(loading|sync|rdb_last_bgsave_status)'

4  $ sleep 2; redis-cli -p 6380 INFO replication; redis-cli -p 6380 INFO keyspace; /opt/redis-7.2/bin/redis-cli -p 6379 INFO replication | head -17; redis-cli -p 6380 CONFIG GET replica-read-only; cat /etc/redis/redis.conf

5  $ python3 - <<'PY'
try: import redis; print('redis-py',redis.__version__)
except Exception as e: print('no redis-py:',e)
PY
redis-cli -p 6380 CONFIG GET save appendonly; /opt/redis-7.2/bin/redis-cli -p 6379 INFO stats | grep -E 'total_commands_processed|expired_keys'; redis-cli -p 6380 INFO stats | grep -E 'total_commands_processed|expired_keys'

6  $ python3 - <<'PY'
import redis,collections
r=redis.Redis(port=6379)
for i in range(16):
 r.execute_command('SELECT',i); c=collections.Counter(); examples={}
 for k in r.scan_iter(count=500):
  t=r.type(k); c[t]+=1; examples.setdefault(t,k)
 if c: print(i,c,examples)
PY

7  $ python3 - <<'PY'
import redis
s=redis.Redis(port=6379)
for k in s.scan_iter(match='events:*'):
 print(k,s.xinfo_stream(k),s.xinfo_groups(k))
 if s.xinfo_groups(k): print('pending',s.xpending_range(k,s.xinfo_groups(k)[0]['name'],'-','+',10))
 break
PY

8  $ python3 - <<'PY'
import redis
s=redis.Redis(port=6379)
for k in s.scan_iter(match='events:*'):
 g=s.xinfo_groups(k)
 if g:
  print(k,g)
  for group in g: print('consumers',s.xinfo_consumers(k,group['name']), 'pending',s.xpending_range(k,group['name'],'-','+',3))
PY

9  $ cat > /tmp/verify_redis_migration.py <<'PY'
import redis
s=redis.Redis(host='127.0.0.1', port=6379)
t=redis.Redis(host='127.0.0.1', port=6380)
for db in range(16):
 a=redis.Redis(port=6379,db=db)
 b=redis.Redis(port=6380,db=db)
 sk=set(a.scan_iter(count=1000)); tk=set(b.scan_iter(count=1000))
 assert sk==tk, (db, 'key mismatch', sk-tk, tk-sk)
 for k in sk:
  typ=a.type(k)
  assert typ==b.type(k), (db,k,'type')
  expiry=a.pexpiretime(k); target_expiry=b.pexpiretime(k)
  assert expiry==target_expiry, (db,k,'expiry',expiry,target_expiry)
  if typ==b'string': assert a.get(k)==b.get(k), (db,k,'string')
  elif typ==b'hash': assert a.hgetall(k)==b.hgetall(k), (db,k,'hash')
  elif typ==b'list': assert a.lrange(k,0,-1)==b.lrange(k,0,-1), (db,k,'list')
  elif typ==b'set': assert a.smembers(k)==b.smembers(k), (db,k,'set')
  elif typ==b'zset': assert a.zrange(k,0,-1,withscores=True)==b.zrange(k,0,-1,withscores=True), (db,k,'zset')
  elif typ==b'stream':
   assert a.xrange(k)==b.xrange(k), (db,k,'stream entries')
   assert a.xinfo_stream(k)==b.xinfo_stream(k), (db,k,'stream info')
   ag=a.xinfo_groups(k); bg=b.xinfo_groups(k)
   assert ag==bg,(db,k,'groups',ag,bg)
   for g in ag:
    name=g['name']
    ac=a.xinfo_consumers(k,name); bc=b.xinfo_consumers(k,name)
    assert [(v['name'],v['pending']) for v in ac]==[(v['name'],v['pending']) for v in bc],(db,k,name,'consumers')
    ap=a.xpending_range(k,name,'-','+',100000)
    bp=b.xpending_range(k,name,'-','+',100000)
    assert [(v['message_id'],v['consumer'],v['times_delivered']) for v in ap]==[(v['message_id'],v['consumer'],v['times_delivered']) for v in bp],(db,k,name,'pending')
  else: raise AssertionError((db,k,typ))
 if sk: print('verified db',db, 'keys',len(sk), flush=True)
print('All keys, values, absolute expiries and stream group state verified.')
PY
python3 /tmp/verify_redis_migration.py

10  $ python3 - <<'PY'
import redis
x=redis.Redis(port=6379); y=redis.Redis(port=6380); k='events:18'
print(x.xinfo_stream(k));print(y.xinfo_stream(k));print(x.xinfo_groups(k));print(y.xinfo_groups(k))
PY

11  $ sed -i "s/assert a.xinfo_stream(k)==b.xinfo_stream(k), (db,k,'stream info')/assert all(b.xinfo_stream(k).get(f)==v for f,v in a.xinfo_stream(k).items() if f not in ('radix-tree-keys','radix-tree-nodes')), (db,k,'stream info')/" /tmp/verify_redis_migration.py
python3 /tmp/verify_redis_migration.py

12  $ redis-cli -p 6380 REPLICAOF NO ONE; redis-cli -p 6380 INFO replication | head -18; redis-cli -p 6380 SET __migration_write_test__ ok; redis-cli -p 6380 DEL __migration_write_test__; redis-cli -p 6380 BGSAVE; sleep 1; redis-cli -p 6380 INFO persistence | grep -E 'rdb_(bgsave_in_progress|last_bgsave_status|last_save_time)'; python3 /tmp/verify_redis_migration.py; /opt/redis-7.2/bin/redis-cli -p 6379 INFO keyspace; redis-cli -p 6380 INFO keyspace

{
 "examples": {},
 "keys_new": {
  "0": 2920,
  "2": 350
 },
 "keys_old": {
  "0": 2920,
  "2": 350
 },
 "mismatch_counts": {
  "extra": 0,
  "missing": 0,
  "ttl_added": 0,
  "ttl_drift": 0,
  "ttl_lost": 0,
  "type": 0,
  "value": 0
 },
 "new_replication": {
  "master_host": null,
  "master_link_status": null,
  "master_port": null,
  "role": "master"
 },
 "new_server": {
  "redis_version": "8.10.2",
  "server_name": null,
  "valkey_version": null
 },
 "old_digest_ok": true,
 "old_server": {
  "redis_version": "7.2.16",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

1  $ set -o pipefail; /opt/redis-7.2/bin/redis-cli -h 127.0.0.1 -p 6379 PING; redis-cli -h 127.0.0.1 -p 6380 PING; command -v redis-cli; ls -l /etc/redis-old/redis.conf /etc/redis/redis.conf; ps aux | grep '[r]edis-server'

2  $ cat /etc/redis-old/redis.conf; echo NEW; cat /etc/redis/redis.conf; redis-cli -p 6379 INFO server | head -25; redis-cli -p 6380 INFO server | head -25; redis-cli -p 6379 INFO keyspace; redis-cli -p 6380 INFO keyspace; redis-cli -p 6379 INFO replication; redis-cli -p 6380 INFO replication

3  $ redis-cli -p 6379 CONFIG GET databases; redis-cli -p 6380 CONFIG GET databases; redis-cli -p 6379 INFO persistence; redis-cli -p 6380 INFO persistence; redis-cli -p 6379 ACL WHOAMI; redis-cli -p 6380 ACL WHOAMI; redis-cli -p 6379 MODULE LIST; redis-cli -p 6380 MODULE LIST

4  $ redis-cli -p 6380 REPLICAOF 127.0.0.1 6379; sleep 2; redis-cli -p 6380 INFO replication; redis-cli -p 6379 INFO replication; redis-cli -p 6380 INFO keyspace; tail -30 /var/log/redis/redis.log

5  $ sleep 3; redis-cli -p 6380 INFO replication; redis-cli -p 6380 INFO keyspace; tail -25 /var/log/redis/redis.log; redis-cli -p 6379 INFO keyspace

6  $ redis-cli -p 6379 INFO stats | grep -E '(expired_keys|total_commands_processed)'; redis-cli -p 6379 INFO replication | grep -E 'master_repl_offset|slave0'; redis-cli -p 6380 INFO replication | grep -E 'slave_repl_offset|master_link_status'; redis-cli -p 6379 --scan | head; python3 - <<'PY'
try: import redis; print('redis py version:',redis.__version__)
except Exception as e: print(e)
PY
redis-cli -p 6379 --scan | while read -r key; do redis-cli -p 6379 TYPE "$key"; done | sort | uniq -c | head

7  $ cat > /tmp/verify_redis_migration.py <<'PY'
import redis
s=redis.Redis(host='127.0.0.1', port=6379)
t=redis.Redis(host='127.0.0.1', port=6380)
count=0
for db in range(16):
    s.execute_command('SELECT',db); t.execute_command('SELECT',db)
    sk=set(s.scan_iter()); tk=set(t.scan_iter())
    assert sk==tk, f'db{db} missing={sk-tk} extra={tk-sk}'
    for k in sk:
        a=s.type(k); b=t.type(k)
        assert a==b,(db,k,a,b)
        ea=s.pexpiretime(k); eb=t.pexpiretime(k)
        assert abs(ea-eb)<=100,(db,k,ea,eb)
        if a==b'string': va,vb=s.get(k),t.get(k)
        elif a==b'hash': va,vb=s.hgetall(k),t.hgetall(k)
        elif a==b'list': va,vb=s.lrange(k,0,-1),t.lrange(k,0,-1)
        elif a==b'set': va,vb=s.smembers(k),t.smembers(k)
        elif a==b'zset': va,vb=s.zrange(k,0,-1,withscores=True),t.zrange(k,0,-1,withscores=True)
        elif a==b'stream':
            va,vb=s.xrange(k),t.xrange(k)
            assert va==vb,(db,k,'stream entries')
            ga=s.xinfo_groups(k); gb=t.xinfo_groups(k)
            assert ga==gb,(db,k,'groups',ga,gb)
            for g in ga:
                name=g['name']
                assert s.xinfo_consumers(k,name)==t.xinfo_consumers(k,name),(db,k,'consumers',name)
                assert s.xpending_range(k,name,'-','+',100000)==t.xpending_range(k,name,'-','+',100000),(db,k,'pending',name)
            continue
        else: raise AssertionError((db,k,a))
        assert va==vb,(db,k,a)
        count+=1
    print('db', db, 'keys',len(sk),flush=True)
print('verified nonstream keys',count)
PY
python3 /tmp/verify_redis_migration.py

8  $ python3 - <<'PY'
import redis
for p in [6379,6380]:
 r=redis.Redis(port=p);print(p,r.xinfo_groups('events:01'));print(r.xinfo_consumers('events:01','workers'));print(r.xpending_range('events:01','workers','-','+',10))
PY

9  $ python3 - <<'PY'
p='/tmp/verify_redis_migration.py'
s=open(p).read().replace("assert s.xinfo_consumers(k,name)==t.xinfo_consumers(k,name),(db,k,'consumers',name)\n                assert s.xpending_range(k,name,'-','+',100000)==t.xpending_range(k,name,'-','+',100000),(db,k,'pending',name)","""ca=s.xinfo_consumers(k,name); cb=t.xinfo_consumers(k,name)
                assert len(ca)==len(cb),(db,k,'consumers count',name)
                for x,y in zip(ca,cb):
                    assert {i:v for i,v in x.items() if i not in ('idle','inactive')}=={i:v for i,v in y.items() if i not in ('idle','inactive')},(db,k,'consumers',name)
                pa=s.xpending_range(k,name,'-','+',100000); pb=t.xpending_range(k,name,'-','+',100000)
                assert len(pa)==len(pb),(db,k,'pending count',name)
                for x,y in zip(pa,pb):
                    assert {i:v for i,v in x.items() if i!='time_since_delivered'}=={i:v for i,v in y.items() if i!='time_since_delivered'},(db,k,'pending',name)""")
open(p,'w').write(s)
PY
python3 /tmp/verify_redis_migration.py; redis-cli -p 6379 INFO replication | grep -E 'master_repl_offset|slave0'; redis-cli -p 6380 INFO replication | grep -E 'slave_repl_offset|master_link_status'

10  $ redis-cli -p 6380 REPLICAOF NO ONE; redis-cli -p 6380 CONFIG REWRITE; redis-cli -p 6380 SAVE; redis-cli -p 6380 INFO replication | head -17; redis-cli -p 6380 INFO keyspace; redis-cli -p 6379 PING; cat /etc/redis/redis.conf; redis-cli -p 6380 INFO persistence | grep -E 'rdb_last_bgsave_status|rdb_last_save_time|rdb_changes_since_last_save|loading:'

{
 "examples": {},
 "keys_new": {
  "0": 2920,
  "2": 350
 },
 "keys_old": {
  "0": 2920,
  "2": 350
 },
 "mismatch_counts": {
  "extra": 0,
  "missing": 0,
  "ttl_added": 0,
  "ttl_drift": 0,
  "ttl_lost": 0,
  "type": 0,
  "value": 0
 },
 "new_replication": {
  "master_host": null,
  "master_link_status": null,
  "master_port": null,
  "role": "master"
 },
 "new_server": {
  "redis_version": "8.10.2",
  "server_name": null,
  "valkey_version": null
 },
 "old_digest_ok": true,
 "old_server": {
  "redis_version": "7.2.16",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

1  $ ls -l /opt/redis-7.2/bin /etc/redis/redis.conf /etc/redis-old/redis.conf; command -v redis-cli; redis-cli -p 6379 INFO server | head -25; redis-cli -p 6380 INFO server | head -25

2  $ redis-cli -p 6379 INFO replication; redis-cli -p 6380 INFO replication; redis-cli -p 6379 INFO keyspace; redis-cli -p 6380 INFO keyspace; ps aux | grep '[r]edis-server'

3  $ grep -Ein '^(bind|port|dir|dbfilename|appendonly|appendfilename|appenddirname|replicaof|slaveof|masterauth|requirepass|aclfile|save|databases|protected-mode|repl-diskless|cluster-enabled|unixsocket|loadmodule)\b' /etc/redis-old/redis.conf /etc/redis/redis.conf

4  $ cat /etc/redis-old/redis.conf /etc/redis/redis.conf; redis-cli -p 6379 INFO memory | head -35; redis-cli -p 6379 INFO persistence | head -45; redis-cli -p 6380 INFO persistence | head -45

5  $ redis-cli -p 6379 CONFIG GET databases appendonly save repl-diskless-sync; redis-cli -p 6380 CONFIG GET databases appendonly save replica-read-only; redis-cli -p 6379 MODULE LIST; redis-cli -p 6379 INFO commandstats | head -20

6  $ redis-cli -p 6380 REPLICAOF 127.0.0.1 6379; sleep 2; redis-cli -p 6380 INFO replication; redis-cli -p 6379 INFO replication; tail -35 /var/log/redis/redis.log

7  $ sleep 3; redis-cli -p 6380 INFO replication; redis-cli -p 6380 INFO keyspace; tail -25 /var/log/redis/redis.log; tail -20 /var/log/redis-old/redis.log

8  $ python3 - <<'PY'
try: import redis; print(redis.__version__)
except Exception as e: print(e)
PY
redis-cli -p 6379 --scan --pattern '*' | grep -E 'stream|queue' | head -20; redis-cli -p 6379 INFO replication | head -12; redis-cli -p 6380 INFO replication | head -15

9  $ cat > /tmp/verify_redis_migration.py <<'PY'
import redis
src=redis.Redis(host='127.0.0.1',port=6379)
dst=redis.Redis(host='127.0.0.1',port=6380)
count=0; streams=0; groups=0
for db in range(16):
 a=redis.Redis(port=6379,db=db); b=redis.Redis(port=6380,db=db)
 ka=set(a.scan_iter(count=500)); kb=set(b.scan_iter(count=500))
 assert ka==kb, (db,'keys',len(ka),len(kb),list(ka-kb)[:3],list(kb-ka)[:3])
 for k in ka:
  t=a.type(k); assert t==b.type(k),(db,k,'type')
  va=a.pexpiretime(k); vb=b.pexpiretime(k)
  assert va==vb,(db,k,'expire timestamp',va,vb)
  if t==b'string': x=a.get(k);y=b.get(k)
  elif t==b'hash': x=a.hgetall(k);y=b.hgetall(k)
  elif t==b'list': x=a.lrange(k,0,-1);y=b.lrange(k,0,-1)
  elif t==b'set': x=a.smembers(k);y=b.smembers(k)
  elif t==b'zset': x=a.zrange(k,0,-1,withscores=True);y=b.zrange(k,0,-1,withscores=True)
  elif t==b'stream':
   streams+=1; x=a.xrange(k);y=b.xrange(k)
   assert a.xinfo_stream(k)==b.xinfo_stream(k),(db,k,'stream info')
   ga=a.xinfo_groups(k);gb=b.xinfo_groups(k)
   assert ga==gb,(db,k,'groups',ga,gb)
   groups+=len(ga)
   for g in ga:
    name=g['name']
    assert a.xinfo_consumers(k,name)==b.xinfo_consumers(k,name),(db,k,name,'consumers')
    assert a.xpending(k,name)==b.xpending(k,name),(db,k,name,'pending summary')
    assert a.xpending_range(k,name,'-','+',100000)==b.xpending_range(k,name,'-','+',100000),(db,k,name,'pending detail')
  else: raise Exception(('unsupported type',t,k))
  assert x==y,(db,k,'value')
 count+=len(ka)
 print('db',db,'keys',len(ka)) if ka else None
print('Verified',count,'keys',streams,'streams',groups,'consumer groups; values, types, absolute expiry times, stream metadata and pending entries match')
PY
python3 /tmp/verify_redis_migration.py

10  $ python3 - <<'PY'
import redis
for p in (6379,6380):
 r=redis.Redis(port=p); print(p,r.xinfo_stream('events:12'));print(r.xinfo_groups('events:12'))
PY

11  $ python3 - <<'PY'
p='/tmp/verify_redis_migration.py'
s=open(p).read().replace("assert a.xinfo_stream(k)==b.xinfo_stream(k),(db,k,'stream info')", "ia=a.xinfo_stream(k); ib=b.xinfo_stream(k)\n   for field in ('length','last-generated-id','max-deleted-entry-id','entries-added','recorded-first-entry-id','groups','first-entry','last-entry'):\n    assert ia[field]==ib[field],(db,k,'stream info',field,ia[field],ib[field])")
open(p,'w').write(s)
PY
python3 /tmp/verify_redis_migration.py

12  $ redis-cli -p 6380 REPLICAOF NO ONE && redis-cli -p 6380 SAVE && redis-cli -p 6380 INFO replication | head -15 && redis-cli -p 6380 INFO keyspace && redis-cli -p 6380 INFO persistence | grep -E 'rdb_last_bgsave_status|rdb_last_save_time|rdb_changes_since_last_save|rdb_saves:' && redis-cli -p 6379 INFO replication | head -7 && python3 /tmp/verify_redis_migration.py

13  $ python3 - <<'PY'
import redis
for p in (6379,6380):
 r=redis.Redis(port=p); k='events:04'; g='workers';print(p,r.xinfo_groups(k),r.xinfo_consumers(k,g),r.xpending_range(k,g,'-','+',20))
PY
redis-cli -p 6380 SET __migration_write_check__ ok; redis-cli -p 6380 GET __migration_write_check__; redis-cli -p 6380 DEL __migration_write_check__; redis-cli -p 6380 CONFIG GET replicaof

14  $ python3 - <<'PY'
p='/tmp/verify_redis_migration.py';s=open(p).read();s=s.replace("assert a.xinfo_consumers(k,name)==b.xinfo_consumers(k,name),(db,k,name,'consumers')", "assert [{f:v for f,v in c.items() if f not in ('idle','inactive')} for c in a.xinfo_consumers(k,name)]==[{f:v for f,v in c.items() if f not in ('idle','inactive')} for c in b.xinfo_consumers(k,name)],(db,k,name,'consumers')");s=s.replace("assert a.xpending_range(k,name,'-','+',100000)==b.xpending_range(k,name,'-','+',100000),(db,k,name,'pending detail')", "assert [{f:v for f,v in c.items() if f!='time_since_delivered'} for c in a.xpending_range(k,name,'-','+',100000)]==[{f:v for f,v in c.items() if f!='time_since_delivered'} for c in b.xpending_range(k,name,'-','+',100000)],(db,k,name,'pending detail')")
open(p,'w').write(s)
PY
python3 /tmp/verify_redis_migration.py; redis-cli -p 6380 INFO replication | grep '^role:'; redis-cli -p 6379 PING; redis-cli -p 6380 PING; ls -l /var/lib/redis/dump.rdb

{
 "examples": {},
 "keys_new": {
  "0": 2920,
  "2": 350
 },
 "keys_old": {
  "0": 2920,
  "2": 350
 },
 "mismatch_counts": {
  "extra": 0,
  "missing": 0,
  "ttl_added": 0,
  "ttl_drift": 0,
  "ttl_lost": 0,
  "type": 0,
  "value": 0
 },
 "new_replication": {
  "master_host": null,
  "master_link_status": null,
  "master_port": null,
  "role": "master"
 },
 "new_server": {
  "redis_version": "8.10.2",
  "server_name": null,
  "valkey_version": null
 },
 "old_digest_ok": true,
 "old_server": {
  "redis_version": "7.2.16",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

1  $ ls -la /opt/redis-7.2/bin; echo "---"; ls -la /etc/redis/ /etc/redis-old/; echo "---"; redis-cli -v 2>/dev/null; which redis-cli redis-server

2  $ redis-cli -p 6379 ping; redis-cli -p 6379 info server | head -20; echo "==="; redis-cli -p 6380 ping; redis-cli -p 6380 info server | head -20

3  $ echo "=== old conf ==="; cat /etc/redis-old/redis.conf; echo; echo "=== new conf ==="; cat /etc/redis/redis.conf

4  $ redis-cli -p 6379 info keyspace; echo "==="; redis-cli -p 6380 info keyspace; echo "==="; redis-cli -p 6379 dbsize; redis-cli -p 6380 dbsize; echo "==="; redis-cli -p 6379 config get dir; redis-cli -p 6379 config get dbfilename; redis-cli -p 6379 config get appendonly

5  $ echo "=== old repl/persistence config ==="; for p in repl-diskless-sync repl-diskless-sync-delay save appendonly databases maxmemory; do echo -n "$p: "; redis-cli -p 6379 config get $p | tail -1; done
echo "=== all keys sample & types ==="
redis-cli -p 6379 --scan | head -50
echo "=== type histogram across dbs ==="
for db in 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15; do
  n=$(redis-cli -p 6379 -n $db dbsize)
  if [ "$n" != "0" ]; then echo "DB $db: $n keys"; fi
done

6  $ df -h /var/lib/redis /var/lib/redis-old /tmp; echo "==="; redis-cli -p 6379 info memory | head -20; echo "=== new server modules ==="; redis-cli -p 6380 module list

7  $ for db in 0 2; do
  echo "=== DB $db type histogram ==="
  redis-cli -p 6379 -n $db --scan | while read k; do redis-cli -p 6379 -n $db type "$k"; done | sort | uniq -c | sort -rn
done

8  $ echo "=== sample non-string keys ==="
for db in 0 2; do
  redis-cli -p 6379 -n $db --scan | while read k; do t=$(redis-cli -p 6379 -n $db type "$k"); if [ "$t" != "string" ]; then echo "$db $t $k"; fi; done
done | head -60

9  $ echo "=== streams in db0 ==="
redis-cli -p 6379 -n 0 --scan | while read k; do t=$(redis-cli -p 6379 -n 0 type "$k"); if [ "$t" = "stream" ]; then echo "$k"; fi; done
echo "=== one stream detail ==="
SK=$(redis-cli -p 6379 -n 0 --scan | while read k; do t=$(redis-cli -p 6379 -n 0 type "$k"); if [ "$t" = "stream" ]; then echo "$k"; fi; done | head -1)
echo "stream key: $SK"
redis-cli -p 6379 -n 0 xinfo stream "$SK" | head -30
echo "--- groups ---"
redis-cli -p 6379 -n 0 xinfo groups "$SK"

10  $ echo "=== max string sizes ==="
redis-cli -p 6379 -n 0 --scan | while read k; do t=$(redis-cli -p 6379 -n 0 type "$k"); if [ "$t" = "string" ]; then redis-cli -p 6379 -n 0 strlen "$k"; fi; done | sort -n | tail -5
echo "=== TTL samples ==="
redis-cli -p 6379 -n 0 --scan | head -5 | while read k; do echo -n "$k ttl="; redis-cli -p 6379 -n 0 pttl "$k"; done
echo "=== debug jmap / big keys ==="
redis-cli -p 6379 -n 0 --bigkeys 2>/dev/null | head -40

11  $ echo "=== groups per stream ==="
for k in $(redis-cli -p 6379 -n 0 --scan --pattern 'events:*'); do
  g=$(redis-cli -p 6379 -n 0 xinfo groups "$k" | paste - - - - - - - - | head -1)
  echo "$k => $g"
done
echo "=== python/redis-py ==="
python3 -c "import redis; print('redis-py', redis.__version__)" 2>&1 | head -3
which python3 pip3

12  $ echo "=== new server replication baseline ==="; redis-cli -p 6380 info replication
echo "=== old server replication baseline ==="; redis-cli -p 6379 info replication
echo "=== new replica-read-only / role ==="; redis-cli -p 6380 config get replica-read-only; redis-cli -p 6380 role

13  $ mkdir -p /root/migrate && cat > /root/migrate/snapshot.py <<'PYEOF'
import sys, json, redis

def canon_key(r, k):
    t = r.type(k)
    if t == 'none':
        return None
    out = {'type': t}
    if t == 'string':
        out['v'] = r.get(k)
    elif t == 'hash':
        out['v'] = sorted(r.hgetall(k).items())
    elif t == 'list':
        out['v'] = r.lrange(k, 0, -1)
    elif t == 'set':
        out['v'] = sorted(r.smembers(k))
    elif t == 'zset':
        out['v'] = r.zrange(k, 0, -1, withscores=True)
    elif t == 'stream':
        out['entries'] = r.xrange(k, '-', '+')
        info = r.xinfo_stream(k)
        out['last_id'] = info['last_generated_id']
        out['max_deleted'] = info.get('max_deleted_entry_id')
        out['entries_added'] = info.get('entries_added')
        out['length'] = info.get('length')
        groups = []
        for g in r.xinfo_groups(k):
            gd = {'name': g['name'], 'last_delivered': g['last-delivered-id'],
                  'pending': g['pending'], 'entries_read': g.get('entries-read')}
            # PEL (pending entries) within idle range
            try:
                pel = r.xpending_range(k, g['name'], '-', '+', 100000)
                gd['pel'] = sorted([(e['message_id'], e['consumer'], e['time_since_delivered'], e['times_delivered']) for e in pel])
            except Exception as ex:
                gd['pel'] = 'ERR:%s' % ex
            cons = []
            for c in r.xinfo_consumers(k, g['name']):
                cons.append((c['name'], c['pending'], c['idle']))
            gd['consumers'] = sorted(cons)
            groups.append(gd)
        out['groups'] = sorted(groups, key=lambda x: x['name'])
    else:
        out['v'] = '<unsupported:%s>' % t
    pttl = r.pttl(k)
    out['pttl'] = pttl
    return out

def main():
    port = int(sys.argv[1])
    outfile = sys.argv[2]
    r = redis.Redis(host='127.0.0.1', port=port, decode_responses=True)
    info = r.info('keyspace')
    dbs = sorted(int(k[2:]) for k in info.keys())
    snap = {}
    for db in dbs:
        rr = redis.Redis(host='127.0.0.1', port=port, db=db, decode_responses=True)
        keys = sorted(rr.scan_iter(count=1000))
        d = {}
        for k in keys:
            d[k] = canon_key(rr, k)
        snap[str(db)] = d
    with open(outfile, 'w') as f:
        json.dump(snap, f, indent=0, sort_keys=True, default=str)
    total = sum(len(v) for v in snap.values())
    print('captured %d keys across dbs %s -> %s' % (total, list(snap.keys()), outfile))

if __name__ == '__main__':
    main()
PYEOF
echo written

14  $ cd /root/migrate && python3 snapshot.py 6379 old_before.json

15  $ cd /root/migrate && python3 snapshot.py 6379 old_before.json 2>&1 | tail -15

16  $ cat > /root/migrate/snapshot.py <<'PYEOF'
import sys, json, hashlib, redis

def h(b):
    if b is None: return None
    if isinstance(b, bytes): return 'x'+b.hex()
    return b

def canon_key(r, k):
    t = r.type(k)
    t = t.decode() if isinstance(t, bytes) else t
    if t == 'none':
        return None
    out = {'type': t}
    if t == 'string':
        out['v'] = h(r.get(k))
    elif t == 'hash':
        out['v'] = sorted((h(a), h(b)) for a, b in r.hgetall(k).items())
    elif t == 'list':
        out['v'] = [h(x) for x in r.lrange(k, 0, -1)]
    elif t == 'set':
        out['v'] = sorted(h(x) for x in r.smembers(k))
    elif t == 'zset':
        out['v'] = [(h(x), s) for x, s in r.zrange(k, 0, -1, withscores=True)]
    elif t == 'stream':
        out['entries'] = [(h(i), sorted((h(a), h(b)) for a, b in fields)) for i, fields in r.xrange(k, '-', '+')]
        info = r.xinfo_stream(k)
        def gv(kk): 
            v = info.get(kk)
            return v.decode() if isinstance(v, bytes) else v
        out['last_id'] = gv('last-generated-id')
        out['max_deleted'] = gv('max-deleted-entry-id')
        out['entries_added'] = info.get('entries-added')
        out['length'] = info.get('length')
        groups = []
        for g in r.xinfo_groups(k):
            name = g['name'].decode() if isinstance(g['name'], bytes) else g['name']
            gd = {'name': name,
                  'last_delivered': (g['last-delivered-id'].decode() if isinstance(g['last-delivered-id'], bytes) else g['last-delivered-id']),
                  'pending': g['pending'],
                  'entries_read': g.get('entries-read')}
            try:
                pel = r.xpending_range(k, name, '-', '+', 100000)
                gd['pel'] = sorted([( (e['message_id'].decode() if isinstance(e['message_id'],bytes) else e['message_id']),
                                      (e['consumer'].decode() if isinstance(e['consumer'],bytes) else e['consumer']),
                                      e['time_since_delivered'], e['times_delivered']) for e in pel])
            except Exception as ex:
                gd['pel'] = 'ERR:%s' % ex
            cons = []
            for c in r.xinfo_consumers(k, name):
                cn = c['name'].decode() if isinstance(c['name'], bytes) else c['name']
                cons.append((cn, c['pending'], c['idle']))
            gd['consumers'] = sorted(cons)
            groups.append(gd)
        out['groups'] = sorted(groups, key=lambda x: x['name'])
    else:
        out['v'] = '<unsupported:%s>' % t
    out['pttl'] = r.pttl(k)
    return out

def main():
    port = int(sys.argv[1]); outfile = sys.argv[2]
    r = redis.Redis(host='127.0.0.1', port=port, decode_responses=False)
    info = r.info('keyspace')
    dbs = sorted(int(k[2:]) for k in info.keys())
    snap = {}
    for db in dbs:
        rr = redis.Redis(host='127.0.0.1', port=port, db=db, decode_responses=False)
        keys = sorted(rr.scan_iter(count=1000))
        d = {}
        for k in keys:
            kk = k.decode() if isinstance(k, bytes) and b'\x00' not in k else h(k)
            d[kk] = canon_key(rr, k)
        snap[str(db)] = d
    with open(outfile, 'w') as f:
        json.dump(snap, f, indent=0, sort_keys=True, default=str)
    total = sum(len(v) for v in snap.values())
    print('captured %d keys across dbs %s -> %s' % (total, list(snap.keys()), outfile))

if __name__ == '__main__':
    main()
PYEOF
cd /root/migrate && python3 snapshot.py 6379 old_before.json 2>&1 | tail -8

17  $ cd /root/migrate && python3 - <<'PY'
import redis
r = redis.Redis(decode_responses=False)
for k in [b'events:11']:
    print(r.xrange(k,'-','+')[:1])
    for g in r.xinfo_groups(k):
        print(g)
PY

18  $ cd /root/migrate && sed -i 's|out\[.entries.\] = .*|out["entries"] = [(h(i), sorted((h(a), h(b)) for a, b in fld.items())) for i, fld in r.xrange(k, "-", "+")]|' snapshot.py
sed -n '25p' snapshot.py
python3 snapshot.py 6379 old_before.json 2>&1 | tail -8

19  $ echo "=== attach new server as replica of old ==="
redis-cli -p 6380 REPLICAOF 127.0.0.1 6379
sleep 2
echo "=== new server role ==="
redis-cli -p 6380 info replication
echo "=== new keyspace ==="
redis-cli -p 6380 info keyspace

20  $ for i in 1 2 3 4 5 6; do
  st=$(redis-cli -p 6380 info replication | grep -E 'master_link_status|master_sync_in_progress' | tr '\n' ' ')
  ks=$(redis-cli -p 6380 info keyspace | tail -n +2 | tr '\n' ' ')
  echo "try $i: $st | keyspace: $ks"
  if redis-cli -p 6380 info replication | grep -q 'master_link_status:up'; then echo "SYNC UP"; break; fi
  sleep 2
done

21  $ cd /root/migrate
sleep 1
echo "=== replication offsets ==="
echo -n "old master_repl_offset: "; redis-cli -p 6379 info replication | grep master_repl_offset
echo -n "new slave_repl_offset: "; redis-cli -p 6380 info replication | grep slave_repl_offset
python3 snapshot.py 6380 new_replica.json
ls -la

22  $ cat > /root/migrate/compare.py <<'PYEOF'
import json, sys

a = json.load(open(sys.argv[1]))
b = json.load(open(sys.argv[2]))
TOL = 60000  # ms tolerance for TTL (dynamic since capture)

def strip_pttl(d):
    return {k: v for k, v in d.items() if k != 'pttl'}

errs = []
# db-level key set compare
for db in sorted(set(a) | set(b)):
    ka = set(a.get(db, {})); kb = set(b.get(db, {}))
    if ka != kb:
        miss = ka - kb; extra = kb - ka
        if miss: errs.append('DB %s missing keys: %s' % (db, sorted(miss)[:10]))
        if extra: errs.append('DB %s extra keys: %s' % (db, sorted(extra)[:10]))

for db in sorted(set(a) & set(b)):
    for k in a[db]:
        if k not in b[db]: continue
        va, vb = a[db][k], b[db][k]
        sa, sb = strip_pttl(va), strip_pttl(vb)
        if sa != sb:
            # find difference
            if va['type'] != vb['type']:
                errs.append('DB %s key %s: type %s != %s' % (db, k, va['type'], vb['type']))
            elif 'groups' in sa:
                ga = {g['name']: g for g in sa['groups']}
                gb = {g['name']: g for g in sb['groups']}
                if set(ga) != set(gb):
                    errs.append('DB %s stream %s: groups differ %s vs %s' % (db, k, list(ga), list(gb)))
                else:
                    for gname in ga:
                        if ga[gname] != gb[gname]:
                            errs.append('DB %s stream %s group %s: %s vs %s' % (db, k, gname, ga[gname], gb[gname]))
                for f in ('entries','last_id','max_deleted','entries_added','length'):
                    if sa.get(f) != sb.get(f):
                        errs.append('DB %s stream %s field %s differs' % (db, k, f))
            else:
                errs.append('DB %s key %s (%s): value differs' % (db, k, sa['type']))

        # TTL compare
        pa, pb = va.get('pttl'), vb.get('pttl')
        if pa == -1 or pb == -1:
            if pa != pb:
                errs.append('DB %s key %s: ttl persistence %s vs %s' % (db, k, pa, pb))
        else:
            if abs(pa - pb) > TOL:
                errs.append('DB %s key %s: ttl %s vs %s (diff %s)' % (db, k, pa, pb, abs(pa-pb)))

if errs:
    print('MISMATCHES: %d' % len(errs))
    for e in errs[:60]:
        print(' -', e)
    sys.exit(1)
else:
    total = sum(len(v) for v in a.values())
    print('MATCH: all %d keys identical (type+value+streams+groups/PEL; ttl within %d ms)' % (total, TOL))
PYEOF
cd /root/migrate && python3 compare.py old_before.json new_replica.json

23  $ cd /root/migrate
python3 - <<'PY'
import re
src = open('compare.py').read()
# Normalize away volatile idle timers before comparing stream groups
src = src.replace(
"        sa, sb = strip_pttl(va), strip_pttl(vb)\n",
"""        sa, sb = strip_pttl(va), strip_pttl(vb)

        def norm_stream(s):
            if 'groups' not in s: return s
            s = json.loads(json.dumps(s))
            for g in s['groups']:
                if isinstance(g.get('pel'), list):
                    g['pel'] = [[e[0], e[1], e[3]] for e in g['pel']]  # drop idle (e[2])
                if isinstance(g.get('consumers'), list):
                    g['consumers'] = [[c[0], c[1]] for c in g['consumers']]  # drop idle
            return s
        sa, sb = norm_stream(sa), norm_stream(sb)
""")
open('compare.py','w').write(src)
print("patched")
PY
python3 compare.py old_before.json new_replica.json

24  $ echo "=== new server persistence config ==="
for p in save appendonly appendfilename appendfsync dir dbfilename; do echo -n "$p: "; redis-cli -p 6380 config get $p | tail -1; done
echo
echo "=== old server persistence config ==="
for p in save appendonly dir dbfilename; do echo -n "$p: "; redis-cli -p 6379 config get $p | tail -1; done

25  $ cd /root/migrate && python3 snapshot.py 6379 old_after.json && python3 compare.py old_before.json old_after.json

26  $ echo "=== promote new server to standalone primary ==="
redis-cli -p 6380 REPLICAOF NO ONE
sleep 2
echo "=== new server role ==="
redis-cli -p 6380 role
redis-cli -p 6380 info replication | grep -E 'role|connected_slaves'
echo "=== keyspace still present ==="
redis-cli -p 6380 info keyspace
echo "=== old server role (must be master, no slaves) ==="
redis-cli -p 6379 info replication | grep -E 'role|connected_slaves'

27  $ echo "=== write test on new primary ==="
redis-cli -p 6380 SET __migrate_write_test__ hello EX 100
redis-cli -p 6380 GET __migrate_write_test__
redis-cli -p 6380 TTL __migrate_write_test__
redis-cli -p 6380 DEL __migrate_write_test__
echo "=== confirm gone ==="
redis-cli -p 6380 EXISTS __migrate_write_test__

28  $ cd /root/migrate && python3 snapshot.py 6380 new_final.json && python3 compare.py old_after.json new_final.json

29  $ echo "=== persistence state on new server ==="
redis-cli -p 6380 info persistence | grep -E 'rdb_last_bgsave_status|rdb_last_save_time|aof_enabled|loading'
echo "=== trigger save so migrated data is on disk ==="
redis-cli -p 6380 BGSAVE
sleep 2
redis-cli -p 6380 info persistence | grep -E 'rdb_bgsave_in_progress|rdb_last_bgsave_status|rdb_last_save_time'
ls -la /var/lib/redis/
echo "=== confirm config files unmodified ==="
grep -i replicaof /etc/redis/redis.conf /etc/redis-old/redis.conf || echo "no replicaof lines in either config (good)"

30  $ echo "=== stream groups on NEW server (spot check) ==="
for k in events:00 events:07 events:08; do
  echo "-- $k --"
  redis-cli -p 6380 -n 0 xinfo groups "$k"
  echo "   consumers: $(redis-cli -p 6380 -n 0 xinfo consumers "$k" workers | grep -c name || true) workers"
  echo "   xlen: $(redis-cli -p 6380 -n 0 xlen "$k")"
done
echo
echo "=== FINAL STATE ==="
echo "old 6379 role: $(redis-cli -p 6379 role | head -1)  keyspace: $(redis-cli -p 6379 info keyspace | tail -n +2 | tr '\n' ' ')"
echo "new 6380 role: $(redis-cli -p 6380 role | head -1)  keyspace: $(redis-cli -p 6380 info keyspace | tail -n +2 | tr '\n' ' ')"

{
 "examples": {},
 "keys_new": {
  "0": 2920,
  "2": 350
 },
 "keys_old": {
  "0": 2920,
  "2": 350
 },
 "mismatch_counts": {
  "extra": 0,
  "missing": 0,
  "ttl_added": 0,
  "ttl_drift": 0,
  "ttl_lost": 0,
  "type": 0,
  "value": 0
 },
 "new_replication": {
  "master_host": null,
  "master_link_status": null,
  "master_port": null,
  "role": "master"
 },
 "new_server": {
  "redis_version": "8.10.2",
  "server_name": null,
  "valkey_version": null
 },
 "old_digest_ok": true,
 "old_server": {
  "redis_version": "7.2.16",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

1  $ ls -la /opt/ /etc/redis-old/ /etc/redis/ 2>&1 | head -60

2  $ ls /opt/redis-7.2/bin; which redis-cli redis-server; ls /opt/redis-*/bin 2>/dev/null

3  $ cat /etc/redis-old/redis.conf; echo "-----"; cat /etc/redis/redis.conf; echo "-----"; ls -la /opt/redis-7.2/bin; /opt/redis-7.2/bin/redis-server --version; redis-server --version

4  $ ps aux | grep -i redis | grep -v grep; echo "---"; ss -tlnp 2>/dev/null | grep -E '6379|6380'

5  $ redis-cli -p 6379 INFO keyspace; echo "---"; redis-cli -p 6379 INFO server | head -20; echo "--- modules"; redis-cli -p 6380 MODULE LIST

6  $ redis-cli -p 6379 DBSIZE; redis-cli -p 6380 DBSIZE; echo "--- select dbs"; for i in $(seq 0 15); do echo -n "db$i: "; redis-cli -p 6379 -n $i DBSIZE; done

7  $ cd /tmp; for db in 0 2; do redis-cli -p 6379 -n $db --scan | while read k; do t=$(redis-cli -p 6379 -n $db TYPE "$k"); echo "$t"; done; done | sort | uniq -c

8  $ redis-cli -p 6379 -n 0 --scan | head -40; echo "==== db2"; redis-cli -p 6379 -n 2 --scan | head -40

9  $ redis-cli -p 6379 MODULE LIST; echo "--- big keys"; redis-cli -p 6379 -n 0 --bigkeys 2>&1 | tail -30

10  $ redis-cli -p 6380 INFO replication; echo "--- src repl"; redis-cli -p 6379 INFO replication; echo "--- src role"; redis-cli -p 6379 ROLE

11  $ redis-cli -p 6379 -n 0 --scan --pattern 'events:*' | head; echo "---"; redis-cli -p 6379 -n 0 TYPE events:05; redis-cli -p 6379 -n 0 XINFO GROUPS events:05; echo "--- ttl sample"; for k in $(redis-cli -p 6379 -n 0 --scan | head -5); do echo -n "$k ttl="; redis-cli -p 6379 -n 0 TTL "$k"; done

12  $ which redis-cli; /opt/redis-7.2/bin/redis-cli -p 6379 INFO server | grep redis_version; /opt/redis-7.2/bin/redis-cli -p 6380 INFO server | grep -E 'redis_version|process_id'

13  $ cd /tmp
# Dump source data (db0 and db2) for later comparison: keys, types, ttl, values
for db in 0 2; do
  redis-cli -p 6379 -n $db --scan | sort > src_db${db}_keys.txt
done
wc -l src_db0_keys.txt src_db2_keys.txt

14  $ cd /tmp
# Record stream group details from source
for k in $(redis-cli -p 6379 -n 0 --scan --pattern 'events:*' | sort); do
  echo "== $k"; redis-cli -p 6379 -n 0 XINFO GROUPS "$k"
done > src_streams.txt 2>&1
head -60 src_streams.txt; wc -l src_streams.txt

15  $ redis-cli -p 6379 INFO replication | grep master_repl_offset
redis-cli -p 6380 REPLICAOF 127.0.0.1 6379
echo "issued"; sleep 2; redis-cli -p 6380 INFO replication

16  $ sleep 3; redis-cli -p 6380 INFO replication | grep -E 'role|master_link_status|master_sync_in_progress|master_last_io'; echo "--- src"; redis-cli -p 6379 INFO replication | grep -E 'role|connected_slaves|slave0'

17  $ tail -30 /var/log/redis/redis.log 2>&1; echo "=== old log"; tail -20 /var/log/redis-old/redis.log 2>&1

18  $ redis-cli -p 6379 INFO keyspace; echo "=== 6380"; redis-cli -p 6380 INFO keyspace; echo "--- debug digest master"; redis-cli -p 6379 DEBUG DIGEST 2>&1 | head; echo "--- replica"; redis-cli -p 6380 DEBUG DIGEST 2>&1 | head

19  $ python3 --version; python3 -c "import redis; print('redis-py', redis.__version__)" 2>&1; pip3 list 2>/dev/null | grep -i redis

20  $ cat > /tmp/verify.py <<'EOF'
import redis, sys, json

def canon(r, db, k):
    t = r.type(k).decode()
    if t == 'string':
        v = r.get(k)
        return ('string', v)
    if t == 'list':
        return ('list', r.lrange(k,0,-1))
    if t == 'set':
        return ('set', sorted(r.smembers(k)))
    if t == 'hash':
        return ('hash', sorted(r.hgetall(k).items()))
    if t == 'zset':
        return ('zset', r.zrange(k,0,-1,withscores=True))
    if t == 'stream':
        entries = r.xrange(k)
        try:
            groups = r.xinfo_groups(k)
        except Exception as e:
            groups = [('err',str(e))]
        gdata=[]
        for g in groups:
            gname = g['name']
            gd = {'name':gname,
                  'last_delivered':g['last-delivered-id'],
                  'entries_read':g.get('entries-read'),
                  'lag':g.get('lag'),
                  'consumers':[],
                  'pending':[]}
            try:
                for c in r.xinfo_consumers(k, gname):
                    gd['consumers'].append((c['name'], c['pending'], c.get('inactive')))
            except Exception as e:
                gd['consumers'].append(('err',str(e)))
            try:
                for p in r.xpending_range(k, gname, min='-', max='+', count=100000):
                    gd['pending'].append((p['message_id'], p['consumer'], p['time_since_delivered'], p['times_delivered']))
            except Exception as e:
                gd['pending'].append(('err',str(e)))
            gd['pending'].sort()
            gd['consumers'].sort()
            gdata.append(gd)
        gdata.sort(key=lambda x:x['name'])
        return ('stream', entries, gdata)
    return (t, None)

def main():
    a = redis.Redis(port=6379)
    b = redis.Redis(port=6380)
    problems=[]
    total=0
    for db in range(16):
        ra = redis.Redis(port=6379, db=db)
        rb = redis.Redis(port=6380, db=db)
        ka = sorted(ra.keys('*'))
        kb = sorted(rb.keys('*'))
        if ka != kb:
            problems.append(f"DB{db} keyset differs: master={len(ka)} replica={len(kb)}")
            only_a = set(ka)-set(kb); only_b=set(kb)-set(ka)
            if only_a: problems.append(f"  only on master ({len(only_a)}): {list(only_a)[:10]}")
            if only_b: problems.append(f"  only on replica ({len(only_b)}): {list(only_b)[:10]}")
        for k in ka:
            total+=1
            if k not in kb: 
                continue
            ta = ra.type(k); tb = rb.type(k)
            if ta!=tb:
                problems.append(f"DB{db} {k}: type {ta} != {tb}"); continue
            ca = canon(ra,db,k); cb = canon(rb,db,k)
            if ca!=cb:
                # allow pending times_since_delivered differences for streams
                if ca[0]=='stream' and cb[0]=='stream':
                    if ca[1]==cb[1] and json.dumps([[g['name'],g['last_delivered'],g['entries_read'],g['lag'],g['consumers'],[(p[0],p[1],p[3]) for p in g['pending']]] for g in ca[2]]) == json.dumps([[g['name'],g['last_delivered'],g['entries_read'],g['lag'],g['consumers'],[(p[0],p[1],p[3]) for p in g['pending']]] for g in cb[2]]):
                        pass
                    else:
                        problems.append(f"DB{db} {k}: stream content differs (see below)")
                        problems.append("  MASTER: "+json.dumps([[g['name'],g['last_delivered'],g['entries_read'],g['lag'],g['consumers'],g['pending']] for g in ca[2]],default=str)[:800])
                        problems.append("  REPL  : "+json.dumps([[g['name'],g['last_delivered'],g['entries_read'],g['lag'],g['consumers'],g['pending']] for g in cb[2]],default=str)[:800])
                else:
                    problems.append(f"DB{db} {k}: value differs; master={str(ca)[:200]} replica={str(cb)[:200]}")
            # TTL
            tta = ra.ttl(k); ttb = rb.ttl(k)
            if abs(tta-ttb) > 2:
                problems.append(f"DB{db} {k}: TTL differs master={tta} replica={ttb}")
    print(f"Checked {total} keys")
    if problems:
        print(f"\n!!! {len(problems)} PROBLEMS:")
        for p in problems[:80]: print(p)
        sys.exit(1)
    else:
        print("ALL MATCH (types, values, ttls, stream groups)")

main()
EOF
python3 /tmp/verify.py

21  $ cd /tmp && python3 - <<'EOF'
import re
src=open('verify.py').read()
# replace the stream difference handling block with a cleaner normalized comparison
old_start = src.index("            if ca!=cb:")
old_end = src.index("            # TTL")
new = '''            if ca!=cb:
                def norm(c):
                    if c[0]!='stream':
                        return c
                    entries=c[1]
                    gs=[]
                    for g in c[2]:
                        gs.append((g['name'],g['last_delivered'],g['entries_read'],g['lag'],
                                   tuple(g['consumers']),
                                   tuple(sorted((p[0],p[1],p[3]) for p in g['pending']))))
                    return ('stream',entries,tuple(sorted(gs)))
                if norm(ca)!=norm(cb):
                    problems.append(f"DB{db} {k}: value differs (stream)")
                    problems.append("  MASTER: "+repr(norm(ca))[:900])
                    problems.append("  REPL  : "+repr(norm(cb))[:900])
                else:
                    problems.append(f"DB{db} {k}: stream matches except pending delivery time")
            else:
                pass
'''
src = src[:old_start] + new + src[old_end:]
open('verify.py','w').write(src)
print("patched")
EOF
python3 /tmp/verify.py

22  $ cd /tmp && python3 - <<'EOF'
import redis
a=redis.Redis(port=6379,db=0); b=redis.Redis(port=6380,db=0)
k=b'events:00'
ea=a.xrange(k); eb=b.xrange(k)
print("entries equal:", ea==eb, len(ea), len(eb))
ga=a.xinfo_groups(k); gb=b.xinfo_groups(k)
print("\nMASTER groups:")
for g in ga: print({kk:g[kk] for kk in g})
print("\nREPL groups:")
for g in gb: print({kk:g[kk] for kk in g})
for g in ga:
    n=g['name']
    print("\nconsumers MASTER", n, a.xinfo_consumers(k,n))
    print("consumers REPL  ", n, b.xinfo_consumers(k,n))
    print("pending MASTER", a.xpending_range(k,n,min='-',max='+',count=1000))
    print("pending REPL  ", b.xpending_range(k,n,min='-',max='+',count=1000))
EOF

23  $ cd /tmp && python3 - <<'EOF'
import redis
a=redis.Redis(port=6379,db=0); b=redis.Redis(port=6380,db=0)
k=b'events:00'
def norm(r):
    gs=[]
    for g in r.xinfo_groups(k):
        gs.append((g['name'],g['last-delivered-id'],g['entries-read'],g['lag'],
                   tuple(tuple(c) for c in r.xinfo_consumers(k,g['name'])),
                   tuple(sorted((p['message_id'],p['consumer'],p['times_delivered']) for p in r.xpending_range(k,g['name'],min='-',max='+',count=10000)))))
    return tuple(sorted(gs))
na=norm(a); nb=norm(b)
print("equal:", na==nb)
for x,y in zip(na,nb):
    if x!=y:
        for i,(p,q) in enumerate(zip(x,y)):
            if p!=q:
                print("field",i,"MASTER:",repr(p)[:300]); print("field",i,"REPL  :",repr(q)[:300])
EOF

24  $ cd /tmp && python3 - <<'EOF'
import redis,importlib.util,sys
spec=importlib.util.spec_from_file_location("v","/tmp/verify.py")
# can't import due to main(); just re-paste canon/norm
def canon(r, db, k):
    t = r.type(k).decode()
    if t=='stream':
        entries=r.xrange(k)
        groups=r.xinfo_groups(k)
        gdata=[]
        for g in groups:
            gdata.append({'name':g['name'],'last_delivered':g['last-delivered-id'],'entries_read':g.get('entries-read'),'lag':g.get('lag'),
                          'consumers':[(c['name'],c['pending'],c.get('inactive')) for c in r.xinfo_consumers(k,g['name'])],
                          'pending':sorted((p['message_id'],p['consumer'],p['time_since_delivered'],p['times_delivered']) for p in r.xpending_range(k,g['name'],min='-',max='+',count=100000))})
        gdata.sort(key=lambda x:x['name'])
        return ('stream',entries,gdata)
    return (t,None)
def norm(c):
    if c[0]!='stream': return c
    gs=[]
    for g in c[2]:
        gs.append((g['name'],g['last_delivered'],g['entries_read'],g['lag'],tuple(g['consumers']),tuple(sorted((p[0],p[1],p[3]) for p in g['pending']))))
    return ('stream',c[1],tuple(sorted(gs)))
a=redis.Redis(port=6379,db=0); b=redis.Redis(port=6380,db=0)
k=b'events:00'
na=norm(canon(a,0,k)); nb=norm(canon(b,0,k))
print("entries equal:", na[1]==nb[1])
print("groups equal:", na[2]==nb[2])
for x,y in zip(na[2],nb[2]):
    if x!=y:
        print("X", x[:5]); print("Y", y[:5])
EOF

25  $ cd /tmp && python3 - <<'EOF'
src=open('verify.py').read()
src=src.replace("'consumers':[(c['name'],c['pending'],c.get('inactive')) for c in r.xinfo_consumers(k,g['name'])],",
                "'consumers':sorted((c['name'],c['pending']) for c in r.xinfo_consumers(k,g['name'])),")
open('verify.py','w').write(src)
print("ok" if "c['pending']) for c" in src else "fail")
EOF
python3 /tmp/verify.py

26  $ grep -n "consumers" /tmp/verify.py

27  $ cd /tmp && sed -i "s/gd\['consumers'\].append((c\['name'\], c\['pending'\], c.get('inactive')))/gd['consumers'].append((c['name'], c['pending']))/" verify.py
grep -n "consumers'\].append" verify.py
python3 verify.py

28  $ redis-cli -p 6380 REPLICAOF NO ONE; sleep 1
redis-cli -p 6380 INFO replication | grep -E 'role|master_host|connected_slaves'
echo "--- ROLE"; redis-cli -p 6380 ROLE
echo "--- writability test"
redis-cli -p 6380 SET __migration_probe__ ok
redis-cli -p 6380 GET __migration_probe__
redis-cli -p 6380 DEL __migration_probe__
echo "--- source still master & intact"
redis-cli -p 6379 INFO replication | grep -E 'role|connected_slaves'
redis-cli -p 6379 INFO keyspace

29  $ cd /tmp && python3 verify.py; echo "=== exit: $?"

30  $ echo "SOURCE 6379:"; redis-cli -p 6379 INFO keyspace
echo "NEW 6380:"; redis-cli -p 6380 INFO keyspace
echo "--- new server role/config"; redis-cli -p 6380 INFO replication | head -3
redis-cli -p 6380 CONFIG GET replicaof 2>/dev/null; grep -i replicaof /etc/redis/redis.conf || echo "(no replicaof in new config - good)"
echo "--- module keys present on new server (from data)"; redis-cli -p 6380 -n 0 TYPE events:00

31  $ cd /tmp
for port in 6379 6380; do
  echo "== port $port type histogram"
  for db in 0 2; do
    redis-cli -p $port -n $db --scan | while read k; do redis-cli -p $port -n $db TYPE "$k"; done
  done | sort | uniq -c
done

32  $ cd /tmp && python3 - <<'EOF'
import redis
def canon(r,k):
    entries=r.xrange(k); gdata=[]
    for g in r.xinfo_groups(k):
        gd={'name':g['name'],'last_delivered':g['last-delivered-id'],'entries_read':g.get('entries-read'),'lag':g.get('lag'),
            'consumers':[(c['name'],c['pending']) for c in r.xinfo_consumers(k,g['name'])],
            'pending':sorted((p['message_id'],p['consumer'],p['time_since_delivered'],p['times_delivered']) for p in r.xpending_range(k,g['name'],min='-',max='+',count=100000))}
        gd['consumers'].sort(); gdata.append(gd)
    gdata.sort(key=lambda x:x['name']); return ('stream',entries,gdata)
def norm(c):
    gs=[]
    for g in c[2]:
        gs.append((g['name'],g['last_delivered'],g['entries_read'],g['lag'],tuple(g['consumers']),tuple(sorted((p[0],p[1],p[3]) for p in g['pending']))))
    return ('stream',c[1],tuple(sorted(gs)))
a=redis.Redis(port=6379,db=0); b=redis.Redis(port=6380,db=0)
for k in [b'events:00',b'events:01']:
    na=norm(canon(a,k)); nb=norm(canon(b,k))
    print(k, "entries_eq", na[1]==nb[1], "groups_eq", na[2]==nb[2])
    for x,y in zip(na[2],nb[2]):
        if x!=y:
            for i,(p,q) in enumerate(zip(x,y)):
                if p!=q: print("  diff field",i,"M",repr(p)[:120],"R",repr(q)[:120])
EOF

33  $ cd /tmp
python3 - <<'EOF'
src=open('verify.py').read()
src=src.replace("""                if norm(ca)!=norm(cb):
                    problems.append(f"DB{db} {k}: value differs (stream)")
                    problems.append("  MASTER: "+repr(norm(ca))[:900])
                    problems.append("  REPL  : "+repr(norm(cb))[:900])
                else:
                    problems.append(f"DB{db} {k}: stream matches except pending delivery time")""",
"""                if norm(ca)!=norm(cb):
                    problems.append(f"DB{db} {k}: value differs (stream)")
                    problems.append("  MASTER: "+repr(norm(ca))[:900])
                    problems.append("  REPL  : "+repr(norm(cb))[:900])""")
open('verify.py','w').write(src)
EOF
python3 verify.py; echo "exit=$?"

34  $ echo "=== processes ==="; ps -o pid,args -p 9,15 2>/dev/null || ps aux | grep redis-server | grep -v grep
echo; echo "=== 6379 (old, untouched) ==="; redis-cli -p 6379 INFO server | grep redis_version; redis-cli -p 6379 ROLE | head -1; redis-cli -p 6379 INFO keyspace
echo; echo "=== 6380 (new, primary) ==="; redis-cli -p 6380 INFO server | grep redis_version; redis-cli -p 6380 ROLE | head -1; redis-cli -p 6380 INFO keyspace
echo; echo "=== new server accepts writes ==="; redis-cli -p 6380 SET final_check hello; redis-cli -p 6380 DEL final_check

{
 "examples": {},
 "keys_new": {
  "0": 2920,
  "2": 350
 },
 "keys_old": {
  "0": 2920,
  "2": 350
 },
 "mismatch_counts": {
  "extra": 0,
  "missing": 0,
  "ttl_added": 0,
  "ttl_drift": 0,
  "ttl_lost": 0,
  "type": 0,
  "value": 0
 },
 "new_replication": {
  "master_host": null,
  "master_link_status": null,
  "master_port": null,
  "role": "master"
 },
 "new_server": {
  "redis_version": "8.10.2",
  "server_name": null,
  "valkey_version": null
 },
 "old_digest_ok": true,
 "old_server": {
  "redis_version": "7.2.16",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

1  $ ls -la /opt/redis-7.2/bin /etc/redis-old /etc/redis 2>&1; echo "---"; which redis-cli redis-server; echo "---"; ls /opt

2  $ ps aux | grep -i redis | grep -v grep

3  $ echo "=== /etc/redis-old/redis.conf ==="; cat /etc/redis-old/redis.conf; echo; echo "=== /etc/redis/redis.conf ==="; cat /etc/redis/redis.conf

4  $ redis-cli -p 6379 INFO server 2>&1 | head -20; echo "==="; redis-cli -p 6380 INFO server 2>&1 | head -20

5  $ redis-cli -p 6379 INFO keyspace; echo "=== dbsize ==="; redis-cli -p 6379 DBSIZE; echo "=== 6380 ==="; redis-cli -p 6380 INFO keyspace; redis-cli -p 6380 DBSIZE; echo "=== server 6379 config ==="; redis-cli -p 6379 CONFIG GET databases; echo "=== 6380 databases ==="; redis-cli -p 6380 CONFIG GET databases

6  $ redis-cli --version; echo "==="; ls -la /opt/kv-seed /opt/kv-grader 2>&1; echo "==="; cat /opt/pip-system.json 2>/dev/null | head; echo "==="; cat /opt/pip-grader.json 2>/dev/null | head

7  $ cat /opt/kv-seed/seed_old.py

8  $ cat /opt/kv-seed/kvdump.py

9  $ sed -n '80,200p' /opt/kv-seed/seed_old.py; echo "=== end ==="; wc -l /opt/kv-seed/seed_old.py

10  $ ls -la /opt/kv-grader/bin; echo "==="; ls -R /opt/kv-grader/lib | head -40; echo "=== python ==="; /opt/kv-grader/bin/python --version 2>&1; /opt/kv-grader/bin/python -c "import redis; print(redis.__version__)" 2>&1

11  $ cd /tmp && PYTHONPATH=/opt/kv-seed /opt/kv-grader/bin/python - <<'EOF'
import redis, kvdump, json, collections
dump = kvdump.dump_server(6379)
print("dbs:", {db: len(d) for db,d in dump.items()})
print("source digest:", kvdump.digest(dump))
types = collections.Counter()
for db, d in dump.items():
    for k,(t,v,p) in d.items():
        types[t]+=1
print("types:", dict(types))
# count stream groups
for db,d in dump.items():
    for k,(t,v,p) in d.items():
        if t=="stream":
            print("stream", db, k[:40], "groups:", [g[0] for g in v["groups"]], "entries:", len(v["entries"]))
EOF

12  $ redis-cli -p 6379 --scan | head -5; echo "..."; redis-cli -p 6379 INFO modules; echo "=== 6380 modules ==="; redis-cli -p 6380 INFO modules

13  $ redis-cli -p 6379 INFO replication | head; echo "=== 6380 ==="; redis-cli -p 6380 INFO replication | head; echo "=== save cfg ==="; redis-cli -p 6380 CONFIG GET save; redis-cli -p 6380 CONFIG GET dbfilename; redis-cli -p 6380 CONFIG GET appendonly; redis-cli -p 6380 CONFIG GET dir; echo "=== source ==="; redis-cli -p 6379 CONFIG GET save; redis-cli -p 6379 CONFIG GET dbfilename

14  $ ls -la /var/lib/redis /var/lib/redis-old 2>&1

15  $ redis-cli -p 6380 REPLICAOF 127.0.0.1 6379; echo "sleeping for sync..."; sleep 4; echo "=== 6380 replication ==="; redis-cli -p 6380 INFO replication; echo "=== 6379 replication ==="; redis-cli -p 6379 INFO replication | head -12

16  $ sleep 6; echo "=== 6380 replication ==="; redis-cli -p 6380 INFO replication | egrep 'role|master_link_status|master_sync_in_progress|slave_repl_offset'; echo "=== 6379 ==="; redis-cli -p 6379 INFO replication | egrep 'connected_slaves|slave0'; echo "=== 6380 keyspace ==="; redis-cli -p 6380 INFO keyspace; redis-cli -p 6380 DBSIZE

17  $ cd /tmp && PYTHONPATH=/opt/kv-seed /opt/kv-grader/bin/python - <<'EOF'
import redis, kvdump
src = kvdump.dump_server(6379)
dst = kvdump.dump_server(6380)
print("src dbs:", {db: len(d) for db,d in src.items()})
print("dst dbs:", {db: len(d) for db,d in dst.items()})
print("src digest:", kvdump.digest(src))
print("dst digest:", kvdump.digest(dst))
print("DIGEST MATCH:", kvdump.digest(src)==kvdump.digest(dst))
# key sets
for db in set(src)|set(dst):
    s=set(src.get(db,{})); d=set(dst.get(db,{}))
    if s!=d:
        print("db",db,"keys diff: only-src",len(s-d),"only-dst",len(d-s))
# compare values and ptlls
import collections
mismatch_val=0; ttl_diff=[]
for db in src:
    for k,(t,v,p) in src[db].items():
        if k not in dst.get(db,{}):
            continue
        t2,v2,p2=dst[db][k]
        if t!=t2 or v!=v2:
            mismatch_val+=1
            if mismatch_val<4: print("VAL MISMATCH", db, k, t, t2)
        if p>0 or p2>0:
            ttl_diff.append((p,p2))
print("value/type mismatches:", mismatch_val)
if ttl_diff:
    diffs=[abs(a-b) for a,b in ttl_diff]
    print("ttl pairs:", len(ttl_diff), "max abs diff ms:", max(diffs))
EOF

18  $ redis-cli -p 6380 REPLICAOF NO ONE; sleep 1; echo "=== 6380 replication after promotion ==="; redis-cli -p 6380 INFO replication | egrep 'role|connected_slaves|master_link'; echo "=== write test ==="; redis-cli -p 6380 SET __promote_check__ ok; redis-cli -p 6380 GET __promote_check__; redis-cli -p 6380 DEL __promote_check__; echo "=== source still master, unchanged ==="; redis-cli -p 6379 INFO replication | egrep 'role|connected_slaves'; redis-cli -p 6379 DBSIZE

19  $ redis-cli -p 6380 BGSAVE; sleep 2; ls -la /var/lib/redis; echo "=== config has no replicaof (starts as primary) ==="; grep -i replicaof /etc/redis/redis.conf || echo "no replicaof directive (good)"

20  $ cd /tmp && PYTHONPATH=/opt/kv-seed /opt/kv-grader/bin/python - <<'EOF'
import redis, kvdump
src=kvdump.dump_server(6379); dst=kvdump.dump_server(6380)
print("digest match:", kvdump.digest(src)==kvdump.digest(dst))
print("src:", kvdump.digest(src)); print("dst:", kvdump.digest(dst))
# stream group detail
import json
for db in src:
    for k,(t,v,p) in sorted(src[db].items()):
        if t=="stream":
            t2,v2,p2=dst[db][k]
            assert v==v2, k
            for g in v["groups"]:
                print(db, k[:20], "group_tail=", g[0][-6:], "lastdeliv", g[1], "pending", g[2], "consumers", len(g[3]), "pel", len(g[4]))
            break
    break
# Overall
print("total keys src:", sum(len(d) for d in src.values()), "dst:", sum(len(d) for d in dst.values()))
EOF

21  $ echo "=== Redis 8.10 role ==="; redis-cli -p 6380 INFO server | egrep 'redis_version|redis_mode'; redis-cli -p 6380 INFO replication | egrep 'role'; echo "=== accepts writes: try each type ==="; redis-cli -p 6380 SET w1 x; redis-cli -p 6380 CONFIG SET maxmemory 0; echo "writes OK"; echo "=== source intact ==="; redis-cli -p 6379 DBSIZE; redis-cli -p 6379 INFO keyspace

22  $ redis-cli -p 6380 DEL w1 >/dev/null; echo "w1 removed"; redis-cli -p 6380 DBSIZE; redis-cli -p 6380 INFO keyspace; echo "=== confirm no stray keys ==="; cd /tmp && PYTHONPATH=/opt/kv-seed /opt/kv-grader/bin/python -c "
import kvdump
s=kvdump.dump_server(6379); d=kvdump.dump_server(6380)
print('final digest match:', kvdump.digest(s)==kvdump.digest(d))
print('src keys:', sum(len(x) for x in s.values()), 'dst keys:', sum(len(x) for x in d.values()))
"

{
 "examples": {},
 "keys_new": {
  "0": 2920,
  "2": 350
 },
 "keys_old": {
  "0": 2920,
  "2": 350
 },
 "mismatch_counts": {
  "extra": 0,
  "missing": 0,
  "ttl_added": 0,
  "ttl_drift": 0,
  "ttl_lost": 0,
  "type": 0,
  "value": 0
 },
 "new_replication": {
  "master_host": null,
  "master_link_status": null,
  "master_port": null,
  "role": "master"
 },
 "new_server": {
  "redis_version": "8.10.2",
  "server_name": null,
  "valkey_version": null
 },
 "old_digest_ok": true,
 "old_server": {
  "redis_version": "7.2.16",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

1  $ ps aux | grep -i redis | grep -v grep; echo ---; ls -la /opt/; ls -la /opt/redis-7.2/bin 2>/dev/null; echo ---; which redis-cli; redis-cli --version

2  $ redis-cli -p 6379 ping; echo ---; redis-cli -p 6380 ping; echo ---; redis-cli -p 6379 info keyspace; echo ---; redis-cli -p 6380 info keyspace

3  $ echo "=== OLD /etc/redis-old/redis.conf ==="; grep -Ev '^\s*#|^\s*$' /etc/redis-old/redis.conf; echo; echo "=== NEW /etc/redis/redis.conf ==="; grep -Ev '^\s*#|^\s*$' /etc/redis/redis.conf

4  $ redis-cli -p 6379 info replication; echo ---; redis-cli -p 6380 info replication; echo ---; redis-cli -p 6379 info server | grep -E 'redis_version|multiplexing|process_id'; redis-cli -p 6380 info server | grep -E 'redis_version|multiplexing|process_id'

5  $ redis-cli -p 6379 config get databases; redis-cli -p 6380 config get databases; echo ---; redis-cli -p 6379 --scan | head -20; echo ---TYPE-COUNTS---; redis-cli -p 6379 --scan | while read k; do redis-cli -p 6379 type "$k"; done | sort | uniq -c; echo ---DB2---; redis-cli -p 6379 -n 2 --scan | while read k; do redis-cli -p 6379 -n 2 type "$k"; done | sort | uniq -c

6  $ python3 --version; python3 -c "import redis; print('redis-py', redis.__version__)" 2>&1 | tail -1; echo ---; redis-cli -p 6379 info stats | grep -E 'expired_keys|evicted_keys|number_of_commands'; redis-cli -p 6379 dbsize; redis-cli -p 6379 -n 2 dbsize

7  $ echo "--- DB0 TTL stats (ms) ---"; redis-cli -p 6379 --scan | while read k; do redis-cli -p 6379 pttl "$k"; done | grep -E '^-?[0-9]+$' | sort -n | awk '{a[NR]=$1; s+=$1} END {print "count:",NR; print "min:",a[1]; print "p25:",a[int(NR*0.25)]; print "median:",a[int(NR/2)]; print "p75:",a[int(NR*0.75)]; print "max:",a[NR]; print "keys<60s:", c; for(i=1;i<=NR;i++) if(a[i]<60000) c++}'; echo "--- DB2 TTL stats (ms) ---"; redis-cli -p 6379 -n 2 --scan | while read k; do redis-cli -p 6379 -n 2 pttl "$k"; done | grep -E '^-?[0-9]+$' | sort -n | awk '{a[NR]=$1} END {print "count:",NR; print "min:",a[1]; print "p25:",a[int(NR*0.25)]; print "median:",a[int(NR/2)]; print "p75:",a[int(NR*0.75)]; print "max:",a[NR]; c=0; for(i=1;i<=NR;i++) if(a[i]<60000) c++; print "keys<60s:",c}'

8  $ redis-cli -p 6379 info memory | grep -E 'used_memory:|used_memory_human|rdb_bgsave'; echo ---; ls -la /var/lib/redis-old/ /var/lib/redis/ 2>/dev/null; echo ---; grep -E 'streams|XGROUP|XADD' /opt/kv-seed/* 2>/dev/null | head -5; ls /opt/kv-seed/ | head

9  $ head -60 /opt/kv-seed/kvdump.py; echo ...; tail -40 /opt/kv-seed/kvdump.py

10  $ sed -n 55,90p /opt/kv-seed/kvdump.py

11  $ redis-cli -p 6380 replicaof 127.0.0.1 6379; sleep 2; redis-cli -p 6380 info replication

12  $ tail -25 /var/log/redis/redis.log; echo "===== OLD LOG ====="; tail -25 /var/log/redis-old/redis.log

13  $ sleep 3; redis-cli -p 6380 info replication | grep -E 'master_link_status|master_sync|role|slave_repl_offset'; redis-cli -p 6379 info replication | grep -E 'connected_slaves|slave[0-9]'

14  $ redis-cli -p 6380 info keyspace; echo ---; redis-cli -p 6379 info replication | grep -E 'master_repl_offset'; redis-cli -p 6380 info replication | grep -E 'slave_repl_offset|master_link_status'; echo ---; redis-cli -p 6380 dbsize; redis-cli -p 6380 -n 2 dbsize

15  $ cd /opt/kv-seed && python3 -c "
import sys, json
sys.path.insert(0, '/opt/kv-seed')
from kvdump import dump_server, digest
old = dump_server(6379)
new = dump_server(6380)
print('old keys:', {db: len(d) for db, d in old.items()})
print('new keys:', {db: len(d) for db, d in new.items()})
print('old digest:', digest(old))
print('new digest:', digest(new))
print('MATCH' if digest(old) == digest(new) else 'MISMATCH')
# Detailed per-key comparison including exact PTTL
def flat(d):
    f = {}
    for db, kd in d.items():
        for k, (t, v, p) in kd.items():
            f[(db, k)] = (t, v, p)
    return f
fo, fn = flat(old), flat(new)
missing = set(fo) - set(fn); extra = set(fn) - set(fo)
diffval = [k for k in set(fo) & set(fn) if fo[k][0] != fn[k][0] or fo[k][1] != fn[k][1]]
ttlbig = [k for k in set(fo) & set(fn) if fo[k][2] >= 0 and fn[k][2] >= 0 and abs(fo[k][2] - fn[k][2]) > 5000 or (fo[k][2] >= 0) != (fn[k][2] >= 0)]
print('missing on new:', len(missing), 'extra on new:', len(extra))
print('value/type diffs:', len(diffval), diffval[:5])
print('ttl diffs >5s or expiring-flag mismatch:', len(ttlbig), ttlbig[:5])
"

16  $ redis-cli -p 6380 replicaof no one; sleep 1; redis-cli -p 6380 info replication | grep -E 'role|connected_slaves|master_host|master_link'; echo "--- write test ---"; redis-cli -p 6380 set __migration_write_test ok; redis-cli -p 6380 get __migration_write_test; redis-cli -p 6380 del __migration_write_test

17  $ echo "=== OLD server (6379) ==="; redis-cli -p 6379 info replication | grep -E '^role|connected_slaves'; redis-cli -p 6379 dbsize; redis-cli -p 6379 -n 2 dbsize; echo; echo "=== NEW server (6380) ==="; redis-cli -p 6380 info replication | grep -E '^role|connected_slaves|master_host'; redis-cli -p 6380 config get replicaof; redis-cli -p 6380 dbsize; redis-cli -p 6380 -n 2 dbsize; echo; echo "=== stream consumer groups on NEW ==="; redis-cli -p 6380 --scan | grep -E 'stream|mystream' | while read k; do echo "key: $k"; redis-cli -p 6380 xinfo groups "$k"; done | head -40

18  $ cd /opt/kv-seed && python3 -c "
import sys
sys.path.insert(0, '/opt/kv-seed')
from kvdump import dump_server, digest
old = dump_server(6379); new = dump_server(6380)
print('FINAL: old digest', digest(old))
print('FINAL: new digest', digest(new))
print('FINAL RESULT:', 'EXACT COPY VERIFIED' if digest(old) == digest(new) else 'MISMATCH')
"

19  $ for k in $(redis-cli -p 6379 --scan | while read k; do t=$(redis-cli -p 6379 type "$k"); [ "$t" = "stream" ] && echo "$k"; done | head -2); do echo "=== key: $k ==="; echo "-- OLD:"; redis-cli -p 6379 xinfo groups "$k"; echo "-- NEW:"; redis-cli -p 6380 xinfo groups "$k"; done

20  $ redis-cli -p 6380 bgsave; sleep 1; redis-cli -p 6380 info persistence | grep -E 'rdb_last_bgsave_status|rdb_last_save_time|loading:'; ls -la /var/lib/redis/

21  $ redis-cli -p 6379 --scan | while read k; do t=$(redis-cli -p 6379 type "$k" 2>/dev/null); if [ "$t" = "stream" ]; then echo "STREAM KEY: $k"; fi; done | head -25

22  $ redis-cli -p 6379 xinfo groups events:13; echo "exit=$?"; echo ---; redis-cli -p 6379 xinfo stream events:13; echo "exit=$?"; echo ---; redis-cli -p 6379 xlen events:13; echo ---; python3 -c "
import redis
r = redis.Redis(port=6379)
n=0
for k in r.scan_iter():
    if r.type(k) == b'stream':
        g = r.xinfo_groups(k)
        if g: n+=1; print(k.decode(), 'groups:', len(g))
print('streams WITH groups on 6379:', n)
"

23  $ python3 -c "
import redis
ro = redis.Redis(port=6379, socket_timeout=30)
rn = redis.Redis(port=6380, socket_timeout=30)
tot_g = tot_c = tot_p = 0
for k in ro.scan_iter():
    if ro.type(k) != b'stream': continue
    go = ro.xinfo_groups(k); gn = rn.xinfo_groups(k)
    if not go and not gn: continue
    print('==', k.decode())
    for a, b in zip(go, gn):
        assert a['name'] == b['name'], (a, b)
        po = ro.xpending_range(k, a['name'], min='-', max='+', count=100000)
        pn = rn.xpending_range(k, a['name'], min='-', max='+', count=100000)
        co = sorted((c['name'].decode(), c['pending']) for c in ro.xinfo_consumers(k, a['name']))
        cn = sorted((c['name'].decode(), c['pending']) for c in rn.xinfo_consumers(k, b['name']))
        ok = (a['last-delivered-id'] == b['last-delivered-id'] and a['pending'] == b['pending'] and co == cn and [(p['message_id'], p['consumer']) for p in po] == [(p['message_id'], p['consumer']) for p in pn])
        tot_g += 1; tot_c += len(co); tot_p += len(po)
        print('   group %-12s last-delivered=%s pending=%s consumers=%s pel=%s -> %s' % (a['name'].decode(), a['last-delivered-id'].decode(), a['pending'], len(co), len(po), 'OK' if ok else 'MISMATCH'))
print('TOTAL groups:', tot_g, 'consumers:', tot_c, 'pending entries:', tot_p)
"

{
 "examples": {},
 "keys_new": {
  "0": 2920,
  "2": 350
 },
 "keys_old": {
  "0": 2920,
  "2": 350
 },
 "mismatch_counts": {
  "extra": 0,
  "missing": 0,
  "ttl_added": 0,
  "ttl_drift": 0,
  "ttl_lost": 0,
  "type": 0,
  "value": 0
 },
 "new_replication": {
  "master_host": null,
  "master_link_status": null,
  "master_port": null,
  "role": "master"
 },
 "new_server": {
  "redis_version": "8.10.2",
  "server_name": null,
  "valkey_version": null
 },
 "old_digest_ok": true,
 "old_server": {
  "redis_version": "7.2.16",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

1  $ ps aux | grep [r]edis; echo '---'; ls -la /opt/redis-7.2/bin/ 2>&1; echo '---'; which redis-server redis-cli; echo '---'; redis-server --version 2>&1; redis-cli --version 2>&1

2  $ echo '===== /etc/redis-old/redis.conf (active lines) ====='; grep -Ev '^\s*(#|$)' /etc/redis-old/redis.conf; echo; echo '===== /etc/redis/redis.conf (active lines) ====='; grep -Ev '^\s*(#|$)' /etc/redis/redis.conf

3  $ echo '--- old server INFO keyspace ---'; redis-cli -p 6379 INFO keyspace; echo '--- old INFO replication (short) ---'; redis-cli -p 6379 INFO replication | head -20; echo '--- old key config values ---'; redis-cli -p 6379 CONFIG GET databases requirepass maxmemory save; echo '--- old version ---'; redis-cli -p 6379 INFO server | grep -E 'redis_version|config_file'; echo '--- new server INFO keyspace ---'; redis-cli -p 6380 INFO keyspace; echo '--- new role/config ---'; redis-cli -p 6380 CONFIG GET databases replica-read-only requirepass; redis-cli -p 6380 INFO server | grep -E 'redis_version|config_file'

4  $ echo '--- old: full key overview ---'; for db in $(seq 0 15); do n=$(redis-cli -p 6379 -n $db DBSIZE); if [ "$n" != "0" ]; then echo "DB $db: $n keys"; fi; done; echo '--- old: key types sample ---'; redis-cli -p 6379 -n 0 KEYS '*' | head -50

5  $ for db in 0 2; do echo "== DB $db type histogram =="; redis-cli -p 6379 -n $db KEYS '*' | while read k; do redis-cli -p 6379 -n $db TYPE "$k"; done | sort | uniq -c; done

6  $ echo '--- old: module list ---'; redis-cli -p 6379 MODULE LIST; echo '--- old: keyspace patterns sample db2 ---'; redis-cli -p 6379 -n 2 KEYS '*' | head -20; echo '--- old: any big keys? memory usage of a few ---'; redis-cli -p 6379 -n 0 KEYS '*' | head -5 | while read k; do redis-cli -p 6379 MEMORY USAGE "$k"; done

7  $ which python3; python3 -c "import redis; print('redis-py', redis.__version__)" 2>&1; echo '--- DEBUG DIGEST support ---'; redis-cli -p 6379 DEBUG DIGEST 2>&1 | head -2; redis-cli -p 6380 DEBUG DIGEST 2>&1 | head -2

8  $ echo '--- stream keys db0 ---'; for k in $(redis-cli -p 6379 -n 0 --scan --pattern '*' 2>/dev/null | head -0; echo); do :; done; redis-cli -p 6379 -n 0 KEYS '*' >/dev/null; redis-cli -p 6379 -n 0 --scan --pattern '*' | while read k; do :; done 2>/dev/null; echo 'using python for accurate type check'; python3 - <<'EOF'
import redis
r = redis.Redis(port=6379)
for db in (0, 2):
    c = redis.Redis(port=6379, db=db)
    streams = []
    for k in c.scan_iter(count=1000):
        if c.type(k) == b'stream':
            streams.append(k.decode())
    print(f"DB {db}: {len(streams)} streams")
    for s in sorted(streams):
        groups = c.xinfo_groups(s)
        print(f"  {s}: len={c.xlen(s)} groups:")
        for g in groups:
            gid = g['name'].decode()
            print(f"    group={gid} last-delivered={g['last-delivered-id'].decode()} pel={g['pending']} consumers={c.xinfo_consumers(s, gid)} entries-read={g.get('entries-read')} lag={g.get('lag')}")
EOF

9  $ python3 - <<'EOF'
import redis
src = redis.Redis(port=6379, db=0)
print("XPENDING detail events:00/workers (id, consumer, times_delivered):")
for e in src.xpending_range('events:00', 'workers', '-', '+', 100):
    print("  ", e['message_id'].decode(), e['consumer'].decode(), e['times_delivered'])
print("XINFO STREAM events:00 (meta):")
info = src.xinfo_stream('events:00')
for k, v in info.items():
    print("  ", k.decode() if isinstance(k, bytes) else k, "=", v)
EOF
echo '--- new server role ---'; redis-cli -p 6380 INFO replication

10  $ python3 - <<'EOF'
import redis
src = redis.Redis(port=6379, db=0)
dst = redis.Redis(port=6380, db=0)
key = b'events:00'
payload = src.dump(key)
print("dump bytes:", len(payload))
tmp = b'__mig_test_stream__'
dst.delete(tmp)
dst.restore(tmp, 0, payload)
print("== XINFO GROUPS old events:00 ==")
for g in src.xinfo_groups(key): print("  ", {k: (v.decode() if isinstance(v,bytes) else v) for k,v in g.items()})
print("== XINFO GROUPS restored copy ==")
for g in dst.xinfo_groups(tmp): print("  ", {k: (v.decode() if isinstance(v,bytes) else v) for k,v in g.items()})
print("== XINFO CONSUMERS old / restored ==")
print(src.xinfo_consumers(key, b'workers'))
print(dst.xinfo_consumers(tmp, b'workers'))
print("== XPENDING old / restored ==")
old_p = src.xpending_range(key, b'workers', '-', '+', 100)
new_p = dst.xpending_range(tmp, b'workers', '-', '+', 100)
print(len(old_p), [(e['message_id'].decode(), e['consumer'].decode(), e['times_delivered']) for e in old_p][:5], "...")
print(len(new_p), [(e['message_id'].decode(), e['consumer'].decode(), e['times_delivered']) for e in new_p][:5], "...")
print("entries equal:", src.xrange(key, '-', '+') == dst.xrange(tmp, '-', '+'))
print("== XINFO STREAM restored == ")
for k, v in dst.xinfo_stream(tmp).items(): print("  ", k.decode(), "=", v)
dst.delete(tmp)
print("test key deleted; dbsize new:", dst.dbsize())
EOF

11  $ redis-cli -p 6380 DEL __mig_test_stream__; redis-cli -p 6380 DBSIZE; echo '--- old dbsize check (unchanged?) ---'; redis-cli -p 6379 INFO keyspace; echo '--- trigger REPLICAOF on new server ---'; redis-cli -p 6380 REPLICAOF 127.0.0.1 6379

12  $ for i in $(seq 1 15); do S=$(redis-cli -p 6380 INFO replication 2>/dev/null | grep -E '^(role|master_link_status|master_sync_in_progress|master_repl_offset|master_replid):'); echo "[$i] $S" | tr '\n' ' '; echo; if echo "$S" | grep -q 'role:master'; then echo "ROLE=master detected -> sync complete"; break; fi; sleep 2; done; echo '--- new keyspace ---'; redis-cli -p 6380 INFO keyspace

13  $ cd /root && cat > verify.py <<'EOF'
import redis, time, sys, itertools

OLDS, NEWS, PORTS = 6379, 6380, (6379, 6380)
tol_ms = 5000
issues = []
checked = 0

def pct(b):
    return b.decode('utf-8', 'replace') if isinstance(b, bytes) else b

for db in range(16):
    o, n = redis.Redis(port=OLDS, db=db), redis.Redis(port=NEWS, db=db)
    ok = {pct(k) for k in o.scan_iter(count=1000)}
    nk = {pct(k) for k in n.scan_iter(count=1000)}
    if ok != nk:
        issues.append(f"DB{db}: keyset differs; only-old={sorted(ok-nk)[:5]} only-new={sorted(nk-ok)[:5]}")
    for k in sorted(ok & nk):
        checked += 1
        kb = k.encode()
        to, tn = o.type(kb), n.type(kb)
        if to != tn:
            issues.append(f"DB{db} {k}: type {to} vs {tn}"); continue
        po, pn = o.pttl(kb), n.pttl(kb)
        if (po < 0) != (pn < 0):
            issues.append(f"DB{db} {k}: has-TTL mismatch {po} vs {pn}")
        elif po > 0:
            eo, en = time.time()*1000 + po, time.time()*1000 + pn
            if abs(eo - en) > tol_ms:
                issues.append(f"DB{db} {k}: expiry drift {eo-en:.0f}ms")
        if to == b'stream':
            go = {(pct(g['name']), pct(g['last-delivered-id']), g.get('entries-read'), g.get('lag'), g['pending']) for g in o.xinfo_groups(kb)}
            gn = {(pct(g['name']), pct(g['last-delivered-id']), g.get('entries-read'), g.get('lag'), g['pending']) for g in n.xinfo_groups(kb)}
            if go != gn:
                issues.append(f"DB{db} {k}: groups differ\n   old={go}\n   new={gn}")
            for gname, _, _, _, _ in go:
                co = {(pct(c['name']), c['pending']) for c in o.xinfo_consumers(kb, gname.encode())}
                cn = {(pct(c['name']), c['pending']) for c in n.xinfo_consumers(kb, gname.encode())}
                if co != cn:
                    issues.append(f"DB{db} {k}/{gname}: consumers differ {co} vs {cn}")
                peo = [(pct(e['message_id']), pct(e['consumer']), e['times_delivered']) for e in o.xpending_range(kb, gname.encode(), '-', '+', 10000)]
                pen = [(pct(e['message_id']), pct(e['consumer']), e['times_delivered']) for e in n.xpending_range(kb, gname.encode(), '-', '+', 10000)]
                if peo != pen:
                    issues.append(f"DB{db} {k}/{gname}: PEL differs ({len(peo)} vs {len(pen)} entries)")
        else:
            do, dn = o.dump(kb), n.dump(kb)
            if do == dn:
                continue
            issues.append(f"DB{db} {k}: DUMP bytes differ -> logical check")
            if not logical_equal(o, n, kb, to):
                issues.append(f"DB{db} {k}: LOGICAL VALUE DIFFERS")

def logical_equal(o, n, kb, t):
    try:
        if t == b'string':  return o.get(kb) == n.get(kb)
        if t == b'hash':    return o.hgetall(kb) == n.hgetall(kb)
        if t == b'list':    return o.lrange(kb, 0, -1) == n.lrange(kb, 0, -1)
        if t == b'set':     return o.smembers(kb) == n.smembers(kb)
        if t == b'zset':    return o.zrange(kb, 0, -1, withscores=True) == n.zrange(kb, 0, -1, withscores=True)
    except Exception as e:
        issues.append(f"    logical check error {kb}: {e}")
    return False

print(f"keys checked: {checked}")
if issues:
    print(f"ISSUES ({len(issues)}):")
    for i in issues[:40]: print(" -", i)
else:
    print("ALL CHECKS PASSED: keysets, types, values, TTLs, stream groups/PELs identical")
EOF
timeout 600 python3 verify.py

14  $ cd /root && python3 - <<'EOF'
src = open('verify.py').read()
fn_start = src.index('def logical_equal')
fn_end = src.index("print(f\"keys checked")
fn = src[fn_start:fn_end]
src = src[:fn_start] + src[fn_end:]
head = "import redis, time, sys, itertools\n\n"
src = src.replace(head, head + fn + "\n")
open('verify.py','w').write(src)
EOF
timeout 900 python3 verify.py

15  $ cd /root && cat > summarize.py <<'EOF'
import redis, time, collections, re

cats = collections.Counter()
o, n = redis.Redis(port=6379, db=0), redis.Redis(port=6380, db=0)
for line in open('verify.out'):
    m = re.search(r'DB0 (\S+): (type|has-TTL|expiry drift|DUMP bytes|LOGICAL)', line)
    if m: cats[m.group(2)] += 1
print(cats)

def enc(r, k): return r.execute_command('OBJECT', 'ENCODING', k)
for k in (b'active:00', b'blob:0', b'leaderboard:000', b'session:00126', b'tags:145'):
    to, tn = o.type(k), n.type(k)
    print(k.decode(), to.decode(), 'old_enc=', enc(o,k).decode(), 'new_enc=', enc(n,k).decode())
# compare raw dump bytes prefix for a small string key
k = b'active:00'
do, dn = o.dump(k), n.dump(k)
print('dump lens', len(do), len(dn), 'same-prefix:', do[:20] == dn[:20])
print('old tail:', do[-10:].hex(), 'new tail:', dn[-10:].hex())
EOF
timeout 900 python3 verify.py > verify.out 2>&1; echo "exit=$?"; tail -2 verify.out; python3 summarize.py

16  $ cd /root && echo "issue counts by db/category:"; grep -oE 'DB[0-9]+ [^ ]+: DUMP bytes differ' verify.out | sed 's/ [^ ]*: DUMP bytes differ//' | sort | uniq -c; echo; grep -c 'DUMP bytes differ' verify.out; grep -E 'type |has-TTL|expiry drift|LOGICAL|groups differ|consumers differ|PEL differs' verify.out | head; echo "non-dump issues: $(grep -vcE 'DUMP bytes differ|^keys|^ISSUES|^ -$|^DB0 [a-z]+:.*' verify.out)"

17  $ cd /root && python3 - <<'EOF'
import redis
o, n = redis.Redis(port=6379, db=0), redis.Redis(port=6380, db=0)
k = b'active:00'
do, dn = o.dump(k), n.dump(k)
print("old len", len(do), "new len", len(dn))
# find first differing byte
d = next((i for i in range(len(do)) if do[i] != dn[i]), None)
print("first diff at index:", d, "of", len(do))
print("old last 24:", do[-24:].hex(' '))
print("new last 24:", dn[-24:].hex(' '))
# stability: dump the same key twice on each server
print("old stable:", o.dump(k) == o.dump(k))
print("new stable:", n.dump(k) == n.dump(k))
# is old == new after stripping last 10 bytes? check where exactly they diverge in tail
print("identical up to index", d if d is not None else "ALL", "- tail diff region:")
print("old[280:301]:", do[280:301].hex(' '))
print("new[280:301]:", dn[280:301].hex(' '))
EOF

18  $ cd /root && echo "== the 40 differing keys =="; grep -oE 'DB0 \S+: DUMP bytes differ' verify.out | awk '{print $2}' | sed 's/://' | tr '\n' ' '; echo; echo "== TTL status of a few =="; python3 - <<'EOF'
import redis
o, n = redis.Redis(port=6379, db=0), redis.Redis(port=6380, db=0)
names = [l.split()[1].rstrip(':').split(':')[0] + ':' + l.split()[1].rstrip(':').split(':')[1] if False else l.split()[1] for l in open('verify.out') if 'DUMP bytes differ' in l]
names = [l.split()[1].rstrip(':') for l in open('verify.out') if 'DUMP bytes differ' in l]
for k in names[:8] + names[-2:]:
    kb = k.encode()
    po, pn = o.pttl(kb), n.pttl(kb)
    vo, vn = o.get(kb), n.get(kb)
    do, dn = o.dump(kb), n.dump(kb)
    d = next((i for i in range(min(len(do),len(dn))) if do[i]!=dn[i]), None)
    print(f"{k}: pttl old={po} new={pn} | get equal={vo==vn} val[:30]={vo[:30] if vo else None} | dump firstdiff@{d} len {len(do)}/{len(dn)}")
EOF

19  $ cd /root && echo "== is old server receiving writes? =="; redis-cli -p 6379 INFO stats | grep -E 'total_commands_processed|instantaneous_ops|expired_keys'; sleep 5; redis-cli -p 6379 INFO stats | grep -E 'total_commands_processed|instantaneous_ops|expired_keys'; echo "== commandstats =="; redis-cli -p 6379 INFO commandstats | grep -E 'cmdstat_(set|expire|pexpire|del|hset|lpush|xadd)' ; echo "== new server stats =="; redis-cli -p 6380 INFO stats | grep -E 'total_commands_processed|expired_keys'; echo "== dump stability over time (old) =="; python3 - <<'EOF'
import redis, time
o, n = redis.Redis(port=6379, db=0), redis.Redis(port=6380, db=0)
k = b'active:00'
d1 = o.dump(k); time.sleep(2); d2 = o.dump(k)
print("old dump stable over 2s:", d1 == d2)
n1 = n.dump(k); time.sleep(2); n2 = n.dump(k)
print("new dump stable over 2s:", n1 == n2)
print("old==new now:", o.dump(k) == n.dump(k))
print("old pttl:", o.pttl(k), "new pttl:", n.pttl(k))
EOF

20  $ cd /root && python3 - <<'EOF'
import redis
n = redis.Redis(port=6380, db=0)
n.set(b'__probe__', b'bar')
d = n.dump(b'__probe__')
print("probe dump len:", len(d), "hex:", d.hex(' '))
orig = bytes(d)
# flip each of the last 10 bytes one at a time and try RESTORE
for i in range(len(orig)):
    mod = bytearray(orig); mod[i] ^= 0xFF
    try:
        n.restore(b'__probe2__', 0, bytes(mod), replace=True)
        res = "RESTORE OK"
        n.delete(b'__probe2__')
    except Exception as e:
        res = f"ERR: {str(e)[:70]}"
    print(f"flip byte {i:3d}: {res}")
n.delete(b'__probe__', b'__probe2__')
EOF

21  $ cd /root && python3 - <<'EOF'
import redis
o, n = redis.Redis(port=6379, db=0), redis.Redis(port=6380, db=0)
k = b'active:00'
do, dn = o.dump(k), n.dump(k)
print("old hex:"); print(do.hex(' '))
print("new hex:"); print(dn.hex(' '))
diffs = [i for i in range(len(do)) if do[i] != dn[i]]
print("differing byte indexes:", diffs)
print("value old:", o.get(k), "value new:", n.get(k))
print("value hex old:", o.get(k).hex(), "new:", n.get(k).hex())
EOF

22  $ redis-cli -p 6380 SET __probe__ bar; redis-cli -p 6380 INFO replication | grep -E '^role|master_host|master_link'; echo '--- persistence config on new server ---'; redis-cli -p 6380 CONFIG GET save appendonly; echo '--- old server keyspace (unchanged?) ---'; redis-cli -p 6379 INFO keyspace

23  $ /opt/redis-7.2/bin/redis-server --port 6399 --save '' --dir /tmp --daemonize yes --pidfile /tmp/r7299.pid --logfile /tmp/r7299.log --dbfilename dump6399.rdb --protected-mode no && /usr/local/bin/redis-server --port 6398 --save '' --dir /tmp --daemonize yes --pidfile /tmp/r898.pid --logfile /tmp/r898.log --dbfilename dump6398.rdb --protected-mode no && sleep 1 && redis-cli -p 6399 PING && redis-cli -p 6398 PING

24  $ cd /root && python3 - <<'EOF'
import redis
m72 = redis.Redis(port=6399, db=0)
m810 = redis.Redis(port=6398, db=0)
# identical test data of different types
for r in (m72, m810):
    r.flushdb()
    r.set('s1', 'hello')
    r.set('big', 'x'*300)
    r.zadd('z1', {'a': 1, 'b': 2})
    r.setbit('bm', 100, 1)
    r.rpush('l1', *['e%d' % i for i in range(5)])
    r.hset('h1', mapping={'f1': 'v1', 'f2': 'v2'})
    r.sadd('set1', 'm1', 'm2')
for name in ('s1', 'big', 'z1', 'bm', 'l1', 'h1', 'set1'):
    d72, d810 = m72.dump(name), m810.dump(name)
    diffs = [i for i in range(max(len(d72), len(d810))) if (d72[i:i+1] or b'x') != (d810[i:i+1] or b'x')]
    print(f"{name}: len72={len(d72)} len810={len(d810)} diffs@{diffs}")
    print(f"   tail72={d72[-10:].hex(' ')}  tail810={d810[-10:].hex(' ')}")
EOF

25  $ cd /root && python3 - <<'EOF'
import redis
m810 = redis.Redis(port=6398, db=0)
d = m810.dump('s1')
print("8.10 s1 dump hex:", d.hex(' '))
orig = bytes(d)
ok, fail = [], []
for i in range(len(orig)):
    mod = bytearray(orig); mod[i] ^= 0xFF
    try:
        m810.restore('probe_x', 0, bytes(mod), replace=True); ok.append(i)
        m810.delete('probe_x')
    except Exception as e:
        fail.append((i, str(e)[:60]))
print("flippable (OK) byte indexes:", ok)
print("rejected (checksum) byte indexes:", [i for i, _ in fail])
print("sample errors:", fail[:3])
EOF

26  $ cd /root && python3 - <<'EOF'
import redis
o, n = redis.Redis(port=6379, db=0), redis.Redis(port=6380, db=0)
for k in (b'session:00126', b'user:0370', b'tags:145', b'queue:032', b'events:00', b'active:00', b'blob:0', b'leaderboard:000'):
    do, dn = o.dump(k), n.dump(k)
    print(f"{k.decode():16s} type={o.type(k).decode():7s} len {len(do):5d}/{len(dn):5d} equal={do==dn}")
    print(f"   old tail: {do[-10:].hex(' ')}")
    print(f"   new tail: {dn[-10:].hex(' ')}")
EOF

27  $ cd /root && head -3 verify.out; echo '---- fresh count ----'; python3 - <<'EOF'
import redis
tot_eq = tot_diff = 0
for db in (0, 2):
    o, n = redis.Redis(port=6379, db=db), redis.Redis(port=6380, db=db)
    eq = diff = 0
    for k in o.scan_iter(count=1000):
        if o.dump(k) == n.dump(k): eq += 1
        else: diff += 1
    print(f"db{db}: equal={eq} differ={diff}")
    tot_eq += eq; tot_diff += diff
print("TOTAL equal:", tot_eq, "differ:", tot_diff)
EOF

28  $ redis-cli -p 6380 REPLICAOF NO ONE; sleep 1; redis-cli -p 6380 INFO replication | grep -E '^(role|master_host|master_replid):'; redis-cli -p 6380 INFO keyspace; echo '--- can it accept writes now? ---'; redis-cli -p 6380 SET __write_test__ ok; redis-cli -p 6380 GET __write_test__; redis-cli -p 6380 DEL __write_test__

29  $ cd /root && python3 - <<'EOF'
import redis, time
fixed = drift_small = 0
maxdrift = 0
for db in (0, 2):
    o, n = redis.Redis(port=6379, db=db), redis.Redis(port=6380, db=db)
    for k in list(o.scan_iter(count=1000)):
        eo = o.pexpiretime(k)
        if eo in (-1, -2):
            if eo == -1 and n.pexpiretime(k) not in (-1,):
                if n.pexpiretime(k) != -1:
                    n.persist(k); fixed += 1
            continue
        en = n.pexpiretime(k)
        d = en - eo
        maxdrift = max(maxdrift, abs(d))
        if abs(d) > 5:
            n.pexpireat(k, eo)
            fixed += 1
        else:
            drift_small += 1
print(f"TTL fixes applied: {fixed}, within-tolerance(<5ms): {drift_small}, max drift seen: {maxdrift} ms")
EOF

30  $ cd /root && cat > final_verify.py <<'EOF'
import redis, time, sys

def pct(b): return b.decode('utf-8', 'replace') if isinstance(b, bytes) else b

problems = []
counts = {}
for db in range(16):
    o, n = redis.Redis(port=6379, db=db), redis.Redis(port=6380, db=db)
    ok = sorted(pct(k) for k in o.scan_iter(count=1000))
    nk = sorted(pct(k) for k in n.scan_iter(count=1000))
    if ok != nk:
        problems.append(f"DB{db} keyset mismatch: only-old={set(ok)-set(nk)} only-new={set(nk)-set(ok)}")
        continue
    counts[db] = len(ok)
    for k in ok:
        kb = k.encode()
        if o.type(kb) != n.type(kb):
            problems.append(f"DB{db} {k}: TYPE mismatch"); continue
        t = o.type(kb)
        # logical value comparison
        eq = False
        if t == b'string': eq = o.get(kb) == n.get(kb)
        elif t == b'hash': eq = o.hgetall(kb) == n.hgetall(kb)
        elif t == b'list': eq = o.lrange(kb, 0, -1) == n.lrange(kb, 0, -1)
        elif t == b'set':  eq = o.smembers(kb) == n.smembers(kb)
        elif t == b'zset': eq = o.zrange(kb, 0, -1, withscores=True) == n.zrange(kb, 0, -1, withscores=True)
        elif t == b'stream':
            eq = (o.xrange(kb, '-', '+') == n.xrange(kb, '-', '+') and
                  {(pct(g['name']), pct(g['last-delivered-id']), g.get('entries-read'), g.get('lag'), g['pending']) for g in o.xinfo_groups(kb)} ==
                  {(pct(g['name']), pct(g['last-delivered-id']), g.get('entries-read'), g.get('lag'), g['pending']) for g in n.xinfo_groups(kb)})
            for g in o.xinfo_groups(kb):
                gname = g['name']
                if {(pct(c['name']), c['pending']) for c in o.xinfo_consumers(kb, gname)} != {(pct(c['name']), c['pending']) for c in n.xinfo_consumers(kb, gname)}:
                    problems.append(f"DB{db} {k}/{pct(gname)}: consumer mismatch")
                    eq = False
                po = [(pct(e['message_id']), pct(e['consumer']), e['times_delivered']) for e in o.xpending_range(kb, gname, '-', '+', 100000)]
                pn = [(pct(e['message_id']), pct(e['consumer']), e['times_delivered']) for e in n.xpending_range(kb, gname, '-', '+', 100000)]
                if po != pn:
                    problems.append(f"DB{db} {k}/{pct(gname)}: PEL mismatch")
                    eq = False
        else:
            problems.append(f"DB{db} {k}: unexpected type {t}")
        if not eq:
            problems.append(f"DB{db} {k}: VALUE mismatch")
        # TTL: absolute expiry must be identical
        eo, en = o.pexpiretime(kb), n.pexpiretime(kb)
        if eo != en:
            problems.append(f"DB{db} {k}: EXPIRY mismatch old={eo} new={en}")

print("keys per db:", counts, "total:", sum(counts.values()))
print("problems:", len(problems))
for p in problems[:30]: print("  -", p)
print("RESULT:", "FAIL" if problems else "PASS - exact copy confirmed")
EOF
python3 final_verify.py

31  $ redis-cli -p 6380 CONFIG GET dir dbfilename; redis-cli -p 6380 BGSAVE; sleep 2; ls -la /var/lib/redis/ 2>/dev/null; echo '--- cleanup throwaways ---'; redis-cli -p 6398 shutdown nosave 2>/dev/null; redis-cli -p 6399 shutdown nosave 2>/dev/null; rm -f /root/verify.py /root/verify.out /root/summarize.py /tmp/r7299.log /tmp/r898.log /tmp/r7299.pid /tmp/r898.pid /tmp/dump6399.rdb /tmp/dump6398.rdb; sleep 1; ss -ltn 2>/dev/null | grep -E '6379|6380|6398|6399' || netstat -ltn 2>/dev/null | grep -E '6379|6380|6398|6399'

32  $ echo '================ FINAL STATE ================'; echo '--- processes ---'; ps aux | grep '[r]edis-server' | awk '{print $11, $12, $13, $14}'; echo; echo '--- OLD (6379) ---'; redis-cli -p 6379 INFO replication | grep -E '^(role|connected_slaves):'; redis-cli -p 6379 INFO keyspace; redis-cli -p 6379 CONFIG GET maxmemory-policy; echo; echo '--- NEW (6380) ---'; redis-cli -p 6380 INFO replication | grep -E '^(role|connected_slaves|master_host):'; redis-cli -p 6380 CONFIG GET replicaof save appendonly; redis-cli -p 6380 INFO keyspace; redis-cli -p 6380 PING; echo; echo '--- leftover probe keys? ---'; redis-cli -p 6380 DBSIZE; redis-cli -p 6380 EXISTS __probe__ __probe2__ __mig_test_stream__ __write_test__

{
 "examples": {},
 "keys_new": {
  "0": 2920,
  "2": 350
 },
 "keys_old": {
  "0": 2920,
  "2": 350
 },
 "mismatch_counts": {
  "extra": 0,
  "missing": 0,
  "ttl_added": 0,
  "ttl_drift": 0,
  "ttl_lost": 0,
  "type": 0,
  "value": 0
 },
 "new_replication": {
  "master_host": null,
  "master_link_status": null,
  "master_port": null,
  "role": "master"
 },
 "new_server": {
  "redis_version": "8.10.2",
  "server_name": null,
  "valkey_version": null
 },
 "old_digest_ok": true,
 "old_server": {
  "redis_version": "7.2.16",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

1  $ ps aux | grep -i redis | grep -v grep; echo ---; ss -lntp 2>/dev/null | grep -E '6379|6380' || netstat -lntp 2>/dev/null | grep -E '6379|6380'

2  $ which redis-cli redis-server; ls -la /opt/ 2>/dev/null; ls -la /opt/redis-7.2/bin 2>/dev/null; ls /etc/redis* 2>/dev/null

3  $ redis-cli -p 6379 INFO server | grep -E 'redis_version|redis_mode|os:'; echo ---OLD-KEYSPACE---; redis-cli -p 6379 INFO keyspace; echo ---NEW-KEYSPACE---; redis-cli -p 6380 INFO keyspace; echo ---OLD-REPL---; redis-cli -p 6379 INFO replication; echo ---NEW-REPL---; redis-cli -p 6380 INFO replication

4  $ echo "=== /etc/redis-old/redis.conf (non-comment lines) ==="; grep -vE '^\s*(#|$)' /etc/redis-old/redis.conf; echo; echo "=== /etc/redis/redis.conf (non-comment lines) ==="; grep -vE '^\s*(#|$)' /etc/redis/redis.conf

5  $ echo "=== OLD MODULES ==="; redis-cli -p 6379 MODULE LIST; echo "=== NEW MODULES ==="; redis-cli -p 6380 MODULE LIST; echo "=== OLD ACL ==="; redis-cli -p 6379 ACL LIST; echo "=== NEW ACL ==="; redis-cli -p 6380 ACL LIST; echo "=== OLD functions ==="; redis-cli -p 6379 FUNCTION LIST; echo "=== OLD appendonly/save ==="; redis-cli -p 6379 CONFIG GET appendonly; redis-cli -p 6380 CONFIG GET appendonly; redis-cli -p 6380 CONFIG GET save

6  $ echo "=== OLD MEMORY ==="; redis-cli -p 6379 INFO memory | grep -E 'used_memory_human|used_memory_dataset|mem_fragmentation'; echo "=== TYPE DISTRIBUTION per db ==="; for db in 0 2; do echo "-- db$db --"; redis-cli -n $db -p 6379 --scan | awk '{print $0}' | while read -r k; do redis-cli -n $db -p 6379 --raw type "$k"; done | sort | uniq -c; done

7  $ echo "=== NEW VERSION ==="; redis-cli -p 6380 INFO server | grep -E 'redis_version|redis_mode'; echo "=== CMDLINES ==="; tr '\0' ' ' < /proc/9/cmdline; echo; tr '\0' ' ' < /proc/15/cmdline; echo; echo "=== python3? ==="; which python3; python3 -c "import redis; print('redis-py', redis.__version__)" 2>&1 | head -1; echo "=== maxmemory/limits ==="; redis-cli -p 6379 CONFIG GET maxmemory; redis-cli -p 6379 CONFIG GET min-replicas-to-write; redis-cli -p 6380 CONFIG GET replica-read-only; redis-cli -p 6379 CONFIG GET databases; redis-cli -p 6380 CONFIG GET databases

8  $ echo "=== OLD db0 sample keys ==="; redis-cli -n 0 -p 6379 --scan | head -5; echo "=== OLD db2 sample keys ==="; redis-cli -n 2 -p 6379 --scan | head -5; echo "=== OLD stream keys ==="; for db in 0 2; do redis-cli -n $db -p 6379 --scan | while read -r k; do t=$(redis-cli -n $db -p 6379 --raw type "$k"); [ "$t" = "stream" ] && echo "db$db $k"; done; done; echo "=== current time ==="; date

9  $ for k in events:00 events:01; do echo "=== XINFO GROUPS $k ==="; redis-cli -n 0 -p 6379 --raw XINFO GROUPS $k; echo "=== XINFO STREAM $k (length/groups/last-id) ==="; redis-cli -n 0 -p 6379 --raw XINFO STREAM $k; done 2>&1 | head -60; echo "=== XLEN all streams ==="; for k in $(seq -w 0 19); do redis-cli -n 0 -p 6379 --raw XLEN events:$k; done | sort | uniq -c

10  $ ls -la /var/lib/redis /var/lib/redis-old 2>/dev/null; ls -la /run/redis /run/redis-old 2>/dev/null; echo "=== new config save line ==="; grep -nE '^\s*(save|appendonly|dir|dbfilename|requirepass|masterauth|replica)' /etc/redis/redis.conf | head -20; echo "=== old dir of new server ==="; redis-cli -p 6380 CONFIG GET dir

11  $ whoami; echo "=== 6380 save/dbfilename/dir ==="; redis-cli -p 6380 CONFIG GET save; redis-cli -p 6380 CONFIG GET dbfilename; echo "=== 6380 ops/sec (traffic check) ==="; redis-cli -p 6379 INFO stats | grep -E 'instantaneous_ops|total_commands'; sleep 2; redis-cli -p 6379 INFO stats | grep -E 'instantaneous_ops|total_commands'; echo "=== internet? ==="; curl -s --max-time 5 -o /dev/null -w '%{http_code}\n' https://raw.githubusercontent.com/redis/redis/7.2/src/rdb.c || echo "no internet"

12  $ curl -s https://raw.githubusercontent.com/redis/redis/7.2/src/rdb.c | grep -n -B4 -A38 'rdbSaveStreamConsumers' | head -70

13  $ redis-cli -p 6380 REPLICAOF 127.0.0.1 6379; sleep 1; for i in $(seq 1 30); do s=$(redis-cli -p 6380 --raw INFO replication); inprog=$(echo "$s" | grep -c 'master_sync_in_progress:1'); link=$(echo "$s" | grep -c 'master_link_status:up'); if [ "$inprog" = "0" ] && [ "$link" = "1" ]; then echo "SYNC COMPLETE after ~${i}s"; echo "$s" | grep -E 'role|master_link_status|master_sync_in_progress|master_repl_offset|slave_repl_offset|master_host|master_port'; break; fi; sleep 1; done; echo "=== keyspace on new ==="; redis-cli -p 6380 INFO keyspace

14  $ echo "=== NEW XINFO GROUPS events:00 ==="; redis-cli -p 6380 --raw XINFO GROUPS events:00; echo "=== NEW XINFO CONSUMERS events:00 workers ==="; redis-cli -p 6380 --raw XINFO CONSUMERS events:00 workers; echo "=== OLD XINFO CONSUMERS events:00 workers ==="; redis-cli -p 6379 --raw XINFO CONSUMERS events:00 workers; echo "=== XPENDING sample NEW vs OLD ==="; redis-cli -p 6380 --raw XPENDING events:00 workers - + 3; echo ---; redis-cli -p 6379 --raw XPENDING events:00 workers - + 3

15  $ echo "=== TTL spot checks (old vs new, db0 + db2) ==="; for k in session:01995 user:0021 cache:page:066 cache:fragment:09; do db=0; [ "${k#cache:}" != "$k" ] && db=2; o=$(redis-cli -n $db -p 6379 --raw TTL "$k"); n=$(redis-cli -n $db -p 6380 --raw TTL "$k"); echo "$k: old=$o new=$n"; done; echo "=== full TTL/EXISTS diff (all keys, both dbs) ==="; for db in 0 2; do redis-cli -n $db -p 6379 --scan > /tmp/keys.$db; : > /tmp/ttlcheck.$db; while read -r k; do o=$(redis-cli -n $db -p 6379 --raw PTTL "$k"); n=$(redis-cli -n $db -p 6380 --raw PTTL "$k"); [ "$o" != "$n" ] && echo "MISMATCH db$db $k old=$o new=$n" >> /tmp/ttlcheck.$db; done < /tmp/keys.$db; done; echo "ttl mismatches:"; cat /tmp/ttlcheck.0 /tmp/ttlcheck.2 2>/dev/null | head; wc -l < /tmp/ttlcheck.0 2>/dev/null; wc -l < /tmp/ttlcheck.2 2>/dev/null

16  $ : > /tmp/expdiff; for db in 0 2; do while read -r k; do o=$(redis-cli -n $db -p 6379 --raw EXPIRETIME "$k"); n=$(redis-cli -n $db -p 6380 --raw EXPIRETIME "$k"); [ "$o" != "$n" ] && echo "EXP-MISMATCH db$db $k old=$o new=$n" >> /tmp/expdiff; done < /tmp/keys.$db; done; echo "absolute-expiry mismatches: $(wc -l < /tmp/expdiff)"; cat /tmp/expdiff | head -5

17  $ : > /tmp/dumpdiff; for db in 0 2; do while read -r k; do o=$(redis-cli -n $db -p 6379 --raw DUMP "$k" | sha256sum | cut -d' ' -f1); n=$(redis-cli -n $db -p 6380 --raw DUMP "$k" | sha256sum | cut -d' ' -f1); [ "$o" != "$n" ] && echo "VALUE-MISMATCH db$db $k" >> /tmp/dumpdiff; done < /tmp/keys.$db; done; echo "value/type mismatches: $(wc -l < /tmp/dumpdiff)"; head -5 /tmp/dumpdiff

18  $ echo "=== OLD hexdump (first 64B) ==="; redis-cli -n 0 -p 6379 --raw DUMP user:0021 | head -c 64 | xxd | head -5; echo "=== NEW hexdump (first 64B) ==="; redis-cli -n 0 -p 6380 --raw DUMP user:0021 | head -c 64 | xxd | head -5; echo "=== sizes ==="; redis-cli -n 0 -p 6379 --raw STRLEN user:0021; redis-cli -n 0 -p 6380 --raw STRLEN user:0021; echo "=== raw value equality ==="; redis-cli -n 0 -p 6379 --raw GET user:0021 | sha256sum; redis-cli -n 0 -p 6380 --raw GET user:0021 | sha256sum

19  $ redis-cli -n 0 -p 6379 --raw DUMP user:0021 > /tmp/d.old; redis-cli -n 0 -p 6380 --raw DUMP user:0021 > /tmp/d.new; ls -l /tmp/d.old /tmp/d.new; echo "=== old tail bytes ==="; od -An -tx1 /tmp/d.old | tail -3; echo "=== new tail bytes ==="; od -An -tx1 /tmp/d.new | tail -3; echo "=== sizes/lines ==="; wc -c /tmp/d.old /tmp/d.new

20  $ cat > /tmp/verify.py <<'EOF'
import redis, sys
o = redis.Redis(host='127.0.0.1', port=6379)
n = redis.Redis(host='127.0.0.1', port=6380)
problems = []
for db in (0, 2):
    op, np_ = o.client().pipeline(), n.client().pipeline()  # placeholder to satisfy lints
    o.execute_command('SELECT', db); n.execute_command('SELECT', db)
    ok = set(o.scan_iter('*')); nk = set(n.scan_iter('*'))
    if ok - nk: problems.append(f"db{db}: {len(ok-nk)} keys missing on new, e.g. {sorted(ok-nk)[:3]}")
    if nk - ok: problems.append(f"db{db}: {len(nk-ok)} extra keys on new, e.g. {sorted(nk-ok)[:3]}")
    print(f"db{db}: old={len(ok)} new={len(nk)}")
    checked = 0
    for k in sorted(ok & nk):
        t = o.type(k); tn = n.type(k)
        if t != tn: problems.append(f"db{db} {k!r}: type old={t} new={tn}"); continue
        t = t.decode() if isinstance(t, bytes) else t
        if t == 'string':
            if o.get(k) != n.get(k): problems.append(f"db{db} {k!r}: string value differs")
        elif t == 'hash':
            ho, hn = dict(o.hgetall(k)), dict(n.hgetall(k))
            if ho != hn: problems.append(f"db{db} {k!r}: hash differs ({[x for x in ho.items() if hn.get(x[0])!=x[1]][:2]})")
        elif t == 'list':
            if o.lrange(k, 0, -1) != n.lrange(k, 0, -1): problems.append(f"db{db} {k!r}: list differs")
        elif t == 'set':
            if set(o.smembers(k)) != set(n.smembers(k)): problems.append(f"db{db} {k!r}: set differs")
        elif t == 'zset':
            zo, zn = o.zrange(k, 0, -1, withscores=True), n.zrange(k, 0, -1, withscores=True)
            if zo != zn: problems.append(f"db{db} {k!r}: zset differs")
        elif t == 'stream':
            if o.xlen(k) != n.xlen(k): problems.append(f"db{db} {k!r}: xlen differs")
            eo, en = o.xrange(k), n.xrange(k)
            if eo != en: problems.append(f"db{db} {k!r}: xrange differs")
            go = o.xinfo_groups(k); gn = n.xinfo_groups(k)
            go = sorted(g['name'] and {kk:vv for kk,vv in g.items() if kk not in ('lag','entries-read')} for g in go)
            gn = sorted(g['name'] and {kk:vv for kk,vv in g.items() if kk not in ('lag','entries-read')} for g in gn)
            if go != gn: problems.append(f"db{db} {k!r}: groups differ\n  old={go}\n  new={gn}")
            for g in o.xinfo_groups(k):
                g = g['name'].decode() if isinstance(g['name'], bytes) else g['name']
                co = o.xinfo_consumers(k, g); cn = n.xinfo_consumers(k, g)
                so = {c['name']:(c['pending'],) for c in co}; sn = {c['name']:(c['pending'],) for c in cn}
                if so != sn: problems.append(f"db{db} {k!r}/{g}: consumers differ {so} vs {sn}")
                po, pn = o.xpending_range(k, g, min='-', max='+', count=10**9), n.xpending_range(k, g, min='-', max='+', count=10**9)
                fo = [(p['message_id'], p['consumer'], p['times_delivered']) for p in po]
                fn = [(p['message_id'], p['consumer'], p['times_delivered']) for p in pn]
                if fo != fn: problems.append(f"db{db} {k!r}/{g}: PEL differs {fo[:2]} vs {fn[:2]}")
        else:
            problems.append(f"db{db} {k!r}: unhandled type {t}")
        checked += 1
    print(f"db{db}: logically verified {checked} keys")
print("=" * 40)
if problems:
    print("PROBLEMS FOUND:"); [print(" -", p) for p in problems[:30]]; sys.exit(1)
print("ALL KEYS VERIFIED IDENTICAL (type, value, groups, consumers, PEL)")
EOF
python3 /tmp/verify.py

21  $ cd /tmp && python3 - <<'EOF'
import re
src = open('/tmp/verify.py').read()
src = src.replace("""            go = sorted(g['name'] and {kk:vv for kk,vv in g.items() if kk not in ('lag','entries-read')} for g in go)
            gn = sorted(g['name'] and {kk:vv for kk,vv in g.items() if kk not in ('lag','entries-read')} for g in gn)""",
"""            keyf = lambda g: (g['name'] if isinstance(g['name'], (str,bytes)) else str(g['name']), sorted(str(gi) for gi in g))
            go = sorted(g for g in go); gn = sorted(g for g in gn)""")
open('/tmp/verify.py','w').write(src)
EOF
python3 - <<'EOF'
# simpler: patch compare to use sorted lists of (name, filtered-items)
src = open('/tmp/verify.py').read()
src = src.replace("""            keyf = lambda g: (g['name'] if isinstance(g['name'], (str,bytes)) else str(g['name']), sorted(str(gi) for gi in g))
            go = sorted(g for g in go); gn = sorted(g for g in gn)
            if go != gn: problems.append(f"db{db} {k!r}: groups differ\\n  old={go}\\n  new={gn}")""",
"""            strip = lambda gs: sorted((g['name'], tuple(sorted((kk, str(vv)) for kk, vv in g.items() if kk not in ('lag','entries-read')))) for g in gs)
            if strip(go) != strip(gn): problems.append(f"db{db} {k!r}: groups differ\\n  old={strip(go)}\\n  new={strip(gn)}")""")
open('/tmp/verify.py','w').write(src)
EOF
python3 /tmp/verify.py

22  $ redis-cli -p 6380 REPLICAOF NO ONE; sleep 1; echo "=== ROLE ==="; redis-cli -p 6380 --raw ROLE; echo "=== REPL INFO ==="; redis-cli -p 6380 INFO replication | grep -E 'role|connected_slaves|master_host'; echo "=== WRITE TEST ==="; redis-cli -p 6380 SET __migration_write_test__ ok; redis-cli -p 6380 GET __migration_write_test__; redis-cli -p 6380 DEL __migration_write_test__; echo "=== config file has no replicaof line? ==="; grep -nE '^\s*(replicaof|slaveof)' /etc/redis/redis.conf || echo "none (restart-safe standalone)"

23  $ echo "=== OLD (6379) — must be untouched ==="; redis-cli -p 6379 INFO keyspace | grep '^db'; redis-cli -p 6379 DBSIZE; redis-cli -p 6379 INFO replication | grep '^role'; echo; echo "=== NEW (6380) — standalone primary ==="; redis-cli -p 6380 INFO keyspace | grep '^db'; redis-cli -p 6380 DBSIZE; redis-cli -p 6380 INFO server | grep redis_version; redis-cli -p 6380 INFO replication | grep -E '^(role|connected_slaves)'; echo "=== processes still up ==="; ps -o pid,cmd -p 9 -p 15 | tail -2

{
 "examples": {},
 "keys_new": {
  "0": 2920,
  "2": 350
 },
 "keys_old": {
  "0": 2920,
  "2": 350
 },
 "mismatch_counts": {
  "extra": 0,
  "missing": 0,
  "ttl_added": 0,
  "ttl_drift": 0,
  "ttl_lost": 0,
  "type": 0,
  "value": 0
 },
 "new_replication": {
  "master_host": null,
  "master_link_status": null,
  "master_port": null,
  "role": "master"
 },
 "new_server": {
  "redis_version": "8.10.2",
  "server_name": null,
  "valkey_version": null
 },
 "old_digest_ok": true,
 "old_server": {
  "redis_version": "7.2.16",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

1  $ ps aux | grep -i redis; echo ---; ls /opt/redis-7.2/bin; echo ---; ls /opt; echo ---; which redis-cli redis-server; redis-cli -p 6379 info server | head -20; echo ---; redis-cli -p 6380 info server | head -20

2  $ cat /etc/redis/redis.conf | grep -v '^#' | grep -v '^$'; echo =====; cat /etc/redis-old/redis.conf | grep -v '^#' | grep -v '^$'

3  $ redis-cli -p 6379 info keyspace; echo ---; redis-cli -p 6379 info replication; echo ---; redis-cli -p 6379 info modules; echo ---; redis-cli -p 6379 config get requirepass; redis-cli -p 6379 ping; redis-cli -p 6380 ping

4  $ redis-cli -p 6379 dbsize; echo ---; for db in 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15; do n=$(redis-cli -n $db dbsize 2>/dev/null); [ "$n" != "0" ] && echo "db$db: $n"; done; echo ---; redis-cli -p 6380 dbsize; redis-cli -p 6380 info keyspace

5  $ redis-cli -p 6380 replicaof 127.0.0.1 6379; sleep 2; redis-cli -p 6380 info replication; redis-cli -p 6380 info persistence | grep -E 'loading|sync'

6  $ tail -30 /var/log/redis/redis.log; echo =====; tail -10 /var/log/redis-old/redis.log; echo =====; ss -ltnp | grep -E '6379|6380'

7  $ sleep 3; redis-cli -p 6380 info replication | grep -E 'role|link|sync'; redis-cli -p 6380 dbsize; redis-cli -p 6380 info keyspace; tail -5 /var/log/redis/redis.log; tail -3 /var/log/redis-old/redis.log

8  $ cd /tmp
# Compare key lists (db0 and db2)
for db in 0 2; do
  redis-cli -p 6379 -n $db --scan | sort > old_db$db.keys
  redis-cli -p 6380 -n $db --scan | sort > new_db$db.keys
  echo "db$db diff:"; diff old_db$db.keys new_db$db.keys && echo "  identical ($(wc -l < old_db$db.keys) keys)"
done

9  $ redis-cli -p 6379 info replication | grep -E 'master_repl_offset'; redis-cli -p 6380 info replication | grep -E 'slave_repl_offset|slave_read_only'; echo ---; redis-cli -p 6380 info stats | grep -E 'sync_full|sync_partial'

10  $ cd /tmp
# Type distribution on both servers
for db in 0 2; do
  echo "== db$db old =="
  redis-cli -p 6379 -n $db --scan | while read k; do redis-cli -p 6379 -n $db type "$k"; done | sort | uniq -c
  echo "== db$db new =="
  redis-cli -p 6380 -n $db --scan | while read k; do redis-cli -p 6380 -n $db type "$k"; done | sort | uniq -c
done

11  $ cd /tmp
# Compare PTTL for every key on both servers (tolerance 2000ms due to elapsed time)
python3 - <<'EOF'
import subprocess
def cli(port, db, *args):
    return subprocess.run(["redis-cli","-p",str(port),"-n",str(db)]+list(args),capture_output=True,text=True).stdout.strip()
mismatch_ttl=0; checked=0
for db in (0,2):
    keys = cli(6379, db, "--scan").splitlines()
    for k in keys:
        a = cli(6379, db, "pttl", k)
        b = cli(6380, db, "pttl", k)
        checked+=1
        ai=int(a); bi=int(b)
        if ai < 0 and bi < 0:
            continue  # both no TTL
        if ai < 0 or bi < 0 or abs(ai-bi) > 2000:
            mismatch_ttl+=1
            print("TTL mismatch", db, k, a, b)
print(f"checked={checked} ttl_mismatches={mismatch_ttl}")
EOF

12  $ cd /tmp
python3 - <<'EOF'
import subprocess, binascii, hashlib
def cli(port, db, *args):
    return subprocess.run(["redis-cli","-p",str(port),"-n",str(db)]+list(args),capture_output=True,text=True).stdout.strip()
def dump_hash(port, db, k):
    out = subprocess.run(["redis-cli","--raw","-p",str(port),"-n",str(db),"dump",k],capture_output=True).stdout
    # DUMP payload = data + 2-byte CRC64 suffix; compare data only (TTL flags differ across versions)
    return hashlib.sha256(out[:-2]).hexdigest() if len(out)>2 else None
mismatch=0; checked=0
for db in (0,2):
    for k in cli(6379, db, "--scan").splitlines():
        checked+=1
        a=dump_hash(6379,db,k); b=dump_hash(6380,db,k)
        if a!=b:
            mismatch+=1
            print("VALUE mismatch", db, repr(k))
print(f"checked={checked} value_mismatches={mismatch}")
EOF

13  $ cd /tmp
# Compare stream consumer groups
python3 - <<'EOF'
import subprocess
def cli(port, db, *args):
    return subprocess.run(["redis-cli","-p",str(port),"-n",str(db)]+list(args),capture_output=True,text=True).stdout.strip()
mismatch=0; checked=0
for db in (0,2):
    for k in cli(6379, db, "--scan").splitlines():
        if cli(6379, db, "type", k) != "stream": continue
        checked+=1
        a=cli(6379, db, "xinfo", "groups", k)
        b=cli(6380, db, "xinfo", "groups", k)
        if a!=b:
            mismatch+=1
            print("GROUP mismatch", db, k)
            print("OLD:", a); print("NEW:", b)
        # also compare full stream content
        sa=cli(6379, db, "xrange", k, "-", "+")
        sb=cli(6380, db, "xrange", k, "-", "+")
        if sa!=sb:
            mismatch+=1
            print("STREAM content mismatch", db, k)
print(f"streams_checked={checked} stream_mismatches={mismatch}")
EOF

14  $ k=session:00697
echo "type: $(redis-cli -p 6379 type $k) / $(redis-cli -p 6380 type $k)"
echo "old value: $(redis-cli -p 6379 get $k)"
echo "new value: $(redis-cli -p 6380 get $k)"
echo "old dump hex:"; redis-cli --raw -p 6379 dump $k | xxd | head -5
echo "new dump hex:"; redis-cli --raw -p 6380 dump $k | xxd | head -5
echo ---
k=tags:126; echo "tags:126 type: $(redis-cli -p 6379 type $k)"
redis-cli -p 6379 smembers $k | sort > /tmp/a; redis-cli -p 6380 smembers $k | sort > /tmp/b; diff /tmp/a /tmp/b && echo smembers-identical
echo ---
k=leaderboard:039; echo "type: $(redis-cli -p 6379 type $k)"; redis-cli -p 6379 zrange $k 0 -1 withscores > /tmp/a; redis-cli -p 6380 zrange $k 0 -1 withscores > /tmp/b; diff /tmp/a /tmp/b && echo zrange-identical
echo ---
k=queue:008; echo "type: $(redis-cli -p 6379 type $k)"; redis-cli -p 6379 lrange $k 0 -1 > /tmp/a; redis-cli -p 6380 lrange $k 0 -1 > /tmp/b; diff /tmp/a /tmp/b && echo lrange-identical
echo ---
k=user:0342; echo "type: $(redis-cli -p 6379 type $k)"; redis-cli -p 6379 hgetall $k > /tmp/a; redis-cli -p 6380 hgetall $k > /tmp/b; diff /tmp/a /tmp/b && echo hgetall-identical

15  $ cd /tmp
python3 - <<'EOF'
import subprocess
def cli(port, db, *args, raw=False):
    cmd=["redis-cli","-p",str(port),"-n",str(db)]+(["--raw"] if raw else [])+list(args)
    return subprocess.run(cmd,capture_output=True,text=True).stdout

mismatch=0; checked=0; bytype={}
for db in (0,2):
    keys = cli(6379, db, "--scan").splitlines()
    for k in keys:
        checked+=1
        t = cli(6379, db, "type", k).strip()
        t2 = cli(6380, db, "type", k).strip()
        if t!=t2:
            mismatch+=1; print("TYPE mismatch",db,k,t,t2); continue
        bytype[t]=bytype.get(t,0)+1
        if t=="string":
            a=cli(6379,db,"get",k,raw=True); b=cli(6380,db,"get",k,raw=True)
        elif t=="hash":
            a=cli(6379,db,"hgetall",k,raw=True); b=cli(6380,db,"hgetall",k,raw=True)
        elif t=="list":
            a=cli(6379,db,"lrange",k,"0","-1",raw=True); b=cli(6380,db,"lrange",k,"0","-1",raw=True)
        elif t=="set":
            a="\n".join(sorted(cli(6379,db,"smembers",k,raw=True).splitlines())); b="\n".join(sorted(cli(6380,db,"smembers",k,raw=True).splitlines()))
        elif t=="zset":
            a=cli(6379,db,"zrange",k,"0","-1","withscores",raw=True); b=cli(6380,db,"zrange",k,"0","-1","withscores",raw=True)
        elif t=="stream":
            a=cli(6379,db,"xrange",k,"-","+",raw=True); b=cli(6380,db,"xrange",k,"-","+",raw=True)
            ag=cli(6379,db,"xinfo","groups",k,raw=True); bg=cli(6380,db,"xinfo","groups",k,raw=True)
            if ag!=bg: mismatch+=1; print("GROUP mismatch",db,k)
        else:
            a=b=None; print("unknown type",t)
        if a!=b:
            mismatch+=1; print("VALUE mismatch",db,k,t)
print(f"checked={checked} mismatches={mismatch} bytype={bytype}")
EOF

16  $ cd /tmp
# Investigate DUMP byte difference on one string key
python3 - <<'EOF'
import subprocess
def dump(port,k):
    return subprocess.run(["redis-cli","--raw","-p",port,"dump",k],capture_output=True).stdout
k="session:00697"
a=dump(6379,k); b=dump(6380,k)
print("old len",len(a),"new len",len(b))
print("old tail",a[-10:].hex())
print("new tail",b[-10:].hex())
# find first differing byte
for i,(x,y) in enumerate(zip(a,b)):
    if x!=y:
        print("first diff at",i,"old",hex(x),"new",hex(y)); break
else:
    print("common prefix identical")
EOF

17  $ cd /tmp
python3 - <<'EOF'
import subprocess
def cli(port, db, *args, raw=False):
    cmd=["redis-cli","-p",str(port),"-n",str(db)]+(["--raw"] if raw else [])+list(args)
    return subprocess.run(cmd,capture_output=True).stdout

mismatch=0; checked=0; bytype={}
for db in (0,2):
    keys = cli(6379, db, "--scan").decode().splitlines()
    for k in keys:
        checked+=1
        t = cli(6379, db, "type", k).decode().strip()
        t2 = cli(6380, db, "type", k).decode().strip()
        if t!=t2:
            mismatch+=1; print("TYPE mismatch",db,k,t,t2); continue
        bytype[t]=bytype.get(t,0)+1
        if t=="string":
            a=cli(6379,db,"get",k,raw=True); b=cli(6380,db,"get",k,raw=True)
        elif t=="hash":
            a=cli(6379,db,"hgetall",k,raw=True); b=cli(6380,db,"hgetall",k,raw=True)
        elif t=="list":
            a=cli(6379,db,"lrange",k,"0","-1",raw=True); b=cli(6380,db,"lrange",k,"0","-1",raw=True)
        elif t=="set":
            a=b"\n".join(sorted(cli(6379,db,"smembers",k,raw=True).splitlines())); b=b"\n".join(sorted(cli(6380,db,"smembers",k,raw=True).splitlines()))
        elif t=="zset":
            a=cli(6379,db,"zrange",k,"0","-1","withscores",raw=True); b=cli(6380,db,"zrange",k,"0","-1","withscores",raw=True)
        elif t=="stream":
            a=cli(6379,db,"xrange",k,"-","+",raw=True); b=cli(6380,db,"xrange",k,"-","+",raw=True)
            ag=cli(6379,db,"xinfo","groups",k,raw=True); bg=cli(6380,db,"xinfo","groups",k,raw=True)
            if ag!=bg: mismatch+=1; print("GROUP mismatch",db,k)
        else:
            a=b=None; print("unknown type",t)
        if a!=b:
            mismatch+=1; print("VALUE mismatch",db,k,t)
print(f"checked={checked} mismatches={mismatch} bytype={bytype}")
EOF

18  $ cd /tmp
python3 - <<'EOF'
import subprocess
def dump(port,k):
    return subprocess.run(["redis-cli","--raw","-p",str(port),"dump",k],capture_output=True).stdout
k="session:00697"
a=dump(6379,k); b=dump(6380,k)
print("old len",len(a),"new len",len(b))
print("old head",a[:20].hex())
print("new head",b[:20].hex())
print("old tail",a[-10:].hex())
print("new tail",b[-10:].hex())
for i,(x,y) in enumerate(zip(a,b)):
    if x!=y:
        print("first diff at",i,"old",hex(x),"new",hex(y)); break
else:
    print("common prefix identical")
EOF

19  $ cd /tmp
python3 - <<'EOF'
import subprocess, struct
def cli(port, *args):
    return subprocess.run(["redis-cli","-p",str(port)]+list(args),capture_output=True).stdout

for k in ("session:00697","session:00129","tags:126"):
    a=cli(6379,"dump",k); b=cli(6380,"dump",k)
    sl=int(cli(6379,"strlen",k))
    print(k, "strlen", sl, "dumplen", len(a), len(b))
    # decode rdb string length prefix
    fb=a[1]
    if fb>>6==0: hdrlen=2; L=fb&0x3F
    elif fb>>6==1: hdrlen=3; L=((fb&0x3F)<<8)|a[2]
    else: hdrlen=5; L=struct.unpack(">I",a[2:6])[0]
    data_start=1+hdrlen; data_end=data_start+L
    print("  L",L,"data bytes equal:", a[data_start:data_end]==b[data_start:data_end])
    ta=a[data_end:-8]; tb=b[data_end:-8]
    print("  ttl-section old", ta.hex(), "new", tb.hex())
    # interpret as seconds (FD + 4B BE) or ms (FC + 8B BE)
    def ttlsec(t):
        if len(t)==5 and t[0]==0xFD: return struct.unpack(">I",t[1:])[0],"s"
        if len(t)==9 and t[0]==0xFC: return struct.unpack(">Q",t[1:])[0]/1000,"ms"
        return t.hex(),"raw"
    print("  old ttl:",ttlsec(ta),"new ttl:",ttlsec(tb))
EOF
echo ---
# check a key without TTL
redis-cli -p 6379 --scan | head -40 | while read k; do
  t=$(redis-cli -p 6379 pttl "$k")
  if [ "$t" = "-1" ]; then
    a=$(redis-cli --raw -p 6379 dump "$k" | md5sum)
    b=$(redis-cli --raw -p 6380 dump "$k" | md5sum)
    [ "$a" = "$b" ] && echo "noTTL key $k: DUMP identical" || echo "noTTL key $k: DUMP differs"
    break
  fi
done

20  $ cd /tmp
python3 - <<'EOF'
import subprocess, struct
def cli(port, *args):
    return subprocess.run(["redis-cli","-p",str(port)]+list(args),capture_output=True).stdout
k="session:00697"
a=cli(6379,"dump",k); b=cli(6380,"dump",k)
print("old:", a.hex())
print("new:", b.hex())
print("pttl old:", cli(6379,"pttl",k), "new:", cli(6380,"pttl",k))
print("now unix:", subprocess.run(["date","+%s"],capture_output=True,text=True).stdout)
EOF

21  $ cd /tmp
python3 - <<'EOF'
import subprocess, struct, time
def cli(port, *args):
    return subprocess.run(["redis-cli","-p",str(port)]+list(args),capture_output=True).stdout

# find a string key with TTL
keys = cli(6379,"--scan").decode().splitlines()
now_ms = int(time.time()*1000)
found=0
for k in keys:
    t = int(cli(6379,"pttl",k))
    if 0 < t < 10**9 and cli(6379,"type",k).strip()==b"string":
        a=cli(6379,"dump",k); b=cli(6380,"dump",k)
        print(k, "pttl old",t,"new",int(cli(6380,"pttl",k)))
        print(" old hex tail:", a[-24:].hex())
        print(" new hex tail:", b[-24:].hex())
        L=int(cli(6379,"strlen",k)); vstart=3; vend=vstart+L
        print(" value slice equal:", a[vstart:vend]==b[vstart:vend])
        sec = a[vend:-8]
        print(" 3byte field old:", sec.hex(), "new:", b[vend:-8].hex())
        # candidate: absolute expire seconds BE in 4 bytes? or ms BE 8 bytes — check abs expire in seconds
        print(" abs expire sec:", int((now_ms+t)/1000))
        found+=1
        if found>=3: break
EOF

22  $ cd /tmp && curl -s https://raw.githubusercontent.com/redis/redis/7.2/src/db.c -o db72.c; ls -la db72.c; grep -n "dumpCommand" db72.c | head

23  $ curl -s https://raw.githubusercontent.com/redis/redis/8.10/src/db.c -o /tmp/db810.c; grep -n "dumpCommand" /tmp/db810.c | head

24  $ cd /tmp && grep -rn "void dumpCommand" --include=*.c 2>/dev/null; curl -s https://raw.githubusercontent.com/redis/redis/7.2/src/debug.c -o dbg72.c; grep -n "dumpCommand" dbg72.c | head; curl -s https://raw.githubusercontent.com/redis/redis/7.2/src/rdb.c -o rdb72.c; grep -n "dumpCommand" rdb72.c | head

25  $ curl -s https://raw.githubusercontent.com/redis/redis/8.10/src/debug.c -o /tmp/dbg810.c; grep -n "dumpCommand" /tmp/dbg810.c | head; curl -s https://raw.githubusercontent.com/redis/redis/8.10/src/rdb.c -o /tmp/rdb810.c; grep -n "dumpCommand" /tmp/rdb810.c | head

26  $ ls -la /tmp/*.c; head -3 /tmp/rdb72.c 2>/dev/null; head -3 /tmp/dbg72.c 2>/dev/null; curl -sI https://raw.githubusercontent.com/redis/redis/7.2/src/rdb.c | head -5

27  $ cd /tmp && grep -rn -i "dumpCommand" db72.c rdb72.c dbg72.c db810.c rdb810.c dbg810.c | head; echo ---; grep -n "void dump" rdb72.c rdb810.c dbg72.c dbg810.c | head

28  $ cd /tmp && for v in 7.2 8.10; do curl -s https://raw.githubusercontent.com/redis/redis/$v/src/lazyfree.c -o lf-${v//./_}.c; done; grep -n "dumpCommand" lf-7_2.c lf-8_10.c; sed -n '/void dumpCommand/,/^}/p' lf-7_2.c; echo =====; sed -n '/void dumpCommand/,/^}/p' lf-8_10.c

29  $ cd /tmp && for f in object.c networking.c server.c cluster.c replication.c defrag.c; do curl -s https://raw.githubusercontent.com/redis/redis/7.2/src/$f -o t72-$f; done; grep -l "dumpCommand" t72-* ; echo done

30  $ curl -s "https://api.github.com/search/code?q=dumpCommand+repo:redis/redis" | head -50

31  $ cd /tmp && grep -n "dumpCommand" t72-cluster.c; sed -n '/void dumpCommand/,/^}/p' t72-cluster.c | head -80

32  $ cd /tmp && grep -n "createDumpPayload" t72-cluster.c | head; sed -n '/void createDumpPayload/,/^}/p' t72-cluster.c; echo =====8.10=====; curl -s https://raw.githubusercontent.com/redis/redis/8.10/src/cluster.c -o t810-cluster.c; sed -n '/void createDumpPayload/,/^}/p' t810-cluster.c

33  $ cd /tmp && grep -n "rdbSaveKeyMetadata\|getModuleMetaBits\|metabits" rdb810.c | head; echo ---; sed -n '/int rdbSaveKeyMetadata/,/^}/p' rdb810.c; echo ---; grep -rn "getModuleMetaBits" db810.c | head; grep -rn "define getModuleMetaBits\|getModuleMetaBits(" *.c 2>/dev/null | head

34  $ cd /tmp && curl -s https://raw.githubusercontent.com/redis/redis/8.10/src/server.h -o s810.h && grep -n "metabits\|ModuleMetaBits\|META_BITS" s810.h | head -30

35  $ cd /tmp
python3 - <<'EOF'
import subprocess
def cli(port, db, *args):
    return subprocess.run(["redis-cli","-p",str(port),"-n",str(db)]+list(args),capture_output=True).stdout
bad=0; streams=0; groups=0
for db in (0,2):
    for k in cli(6379, db, "--scan").decode().splitlines():
        if cli(6379, db, "type", k).strip()!=b"stream": continue
        streams+=1
        # group names
        g = cli(6379, db, "xinfo", "groups", k).decode()
        import re
        gnames = re.findall(r"2\)\r?\n1\) name\r?\n(\S+)", g)  # resp3? use simple approach below
        # robust: parse names via cli output format
        raw = cli(6379, db, "--csv", "xinfo", "groups", k).decode()
        names = [p.split(',')[0].strip('"') for p in raw.split('\n') if p.startswith('"')]
        # fallback: get names properly
        names = []
        lines = cli(6379, db, "xinfo", "groups", k).decode().splitlines()
        for i,l in enumerate(lines):
            if l.strip()=="name" and i+1<len(lines): names.append(lines[i+1].strip())
        for gname in names:
            groups+=1
            a = cli(6379, db, "xinfo", "consumers", k, gname)
            b = cli(6380, db, "xinfo", "consumers", k, gname)
            pa = cli(6379, db, "xpending", k, gname)
            pb = cli(6380, db, "xpending", k, gname)
            # xinfo consumers includes seen-time/idle based on current time — idle differs; compare names+pending counts via csv
            if a!=b:
                # allow idle-time differences: strip idle lines
                fa=[l for l in a.decode(errors='replace').splitlines() if not l.strip().startswith(('idle','time-idle','inactive'))]
                fb=[l for l in b.decode(errors='replace').splitlines() if not l.strip().startswith(('idle','time-idle','inactive'))]
                if fa!=fb:
                    bad+=1; print("CONSUMER mismatch",db,k,gname); print(a.decode()); print(b.decode())
            if pa!=pb:
                bad+=1; print("XPENDING mismatch",db,k,gname); print(pa.decode()); print(pb.decode())
print(f"streams={streams} groups={groups} mismatches={bad}")
EOF

36  $ redis-cli -p 6380 config get save; redis-cli -p 6380 config get dir; redis-cli -p 6380 config get appendonly; redis-cli -p 6379 config get save; ls -la /var/lib/redis /var/lib/redis-old

37  $ redis-cli -p 6380 replicaof no one
redis-cli -p 6380 config rewrite
sleep 1
echo "--- role ---"; redis-cli -p 6380 info replication | grep -E 'role|connected_slaves|master_repl_offset'
echo "--- readonly check ---"; redis-cli -p 6380 set __write_test ok && redis-cli -p 6380 get __write_test && redis-cli -p 6380 del __write_test
echo "--- data still present ---"; redis-cli -p 6380 info keyspace; redis-cli -p 6380 dbsize
echo "--- config file after rewrite ---"; grep -v '^#' /etc/redis/redis.conf | grep -v '^$'

38  $ echo "--- old server untouched ---"; redis-cli -p 6379 info replication | grep -E 'role|connected_slaves'; redis-cli -p 6379 info keyspace; redis-cli -p 6379 info stats | grep -E 'total_commands_processed|keyspace_hits'; grep -v '^#' /etc/redis-old/redis.conf | grep -v '^$'; ps aux | grep 'redis-server' | grep -v grep

39  $ redis-cli -p 6380 bgsave; sleep 2; redis-cli -p 6380 info persistence | grep -E 'rdb_last_bgsave_status|rdb_changes_since_last_save'
echo "--- final full data comparison ---"
python3 - <<'EOF'
import subprocess
def cli(port, db, *args, raw=False):
    cmd=["redis-cli","-p",str(port),"-n",str(db)]+(["--raw"] if raw else [])+list(args)
    return subprocess.run(cmd,capture_output=True).stdout
def cli1(port, db, *args, raw=False):
    return cli(port,db,*args,raw=raw).decode(errors="replace").strip()
bad=0; n=0; ttlbad=0
for db in (0,2):
    old = sorted(cli1(6379,db,"--scan").splitlines())
    new = sorted(cli1(6380,db,"--scan").splitlines())
    if old!=new: bad+=1; print("KEYSET mismatch db",db)
    for k in old:
        n+=1
        if cli1(6379,db,"type",k)!=cli1(6380,db,"type",k): bad+=1; print("type",k); continue
        t=int(cli1(6379,db,"pttl",k)); t2=int(cli1(6380,db,"pttl",k))
        if (t<0)!=(t2<0) or (t>=0 and abs(t-t2)>3000): ttlbad+=1; print("pttl",k,t,t2)
print(f"keys_checked={n} type/value structural errors={bad} ttl_errors={ttlbad}")
EOF
echo "--- roles ---"
redis-cli -p 6379 info replication | grep ^role
redis-cli -p 6380 info replication | grep -E '^role|connected_slaves'
redis-cli -p 6380 info keyspace
redis-cli -p 6379 info keyspace
grep -E 'replicaof|slaveof' /etc/redis/redis.conf || echo "no replicaof in new config (standalone)"

{
 "examples": {},
 "keys_new": {
  "0": 2920,
  "2": 350
 },
 "keys_old": {
  "0": 2920,
  "2": 350
 },
 "mismatch_counts": {
  "extra": 0,
  "missing": 0,
  "ttl_added": 0,
  "ttl_drift": 0,
  "ttl_lost": 0,
  "type": 0,
  "value": 0
 },
 "new_replication": {
  "master_host": null,
  "master_link_status": null,
  "master_port": null,
  "role": "master"
 },
 "new_server": {
  "redis_version": "8.10.2",
  "server_name": null,
  "valkey_version": null
 },
 "old_digest_ok": true,
 "old_server": {
  "redis_version": "7.2.16",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

1  $ ps aux | grep -i redis; echo ---; ss -ltnp | grep -E '6379|6380'; echo ---; ls -la /etc/redis-old /etc/redis /opt/redis-7.2/bin /opt 2>/dev/null

2  $ cat /etc/redis-old/redis.conf | grep -vE '^\s*#|^\s*$'; echo =====; cat /etc/redis/redis.conf | grep -vE '^\s*#|^\s*$'

3  $ which redis-cli redis-server; redis-cli -p 6380 info server | head -20; echo =====OLD; /opt/redis-7.2/bin/redis-cli -p 6379 info server | head -20; echo =====OLD_MODULES; /opt/redis-7.2/bin/redis-cli -p 6379 info modules; echo =====OLD_KEYSPACE; /opt/redis-7.2/bin/redis-cli -p 6379 info keyspace; echo =====NEW_KEYSPACE; redis-cli -p 6380 info keyspace; echo =====OLD_REPL; /opt/redis-7.2/bin/redis-cli -p 6379 info replication; echo =====; ls /usr/local/lib/redis/modules/

4  $ ls -la /opt/kv-seed /opt/kv-grader; find /opt/kv-grader -maxdepth 2 -type f | head -50

5  $ redis-cli -p 6380 replicaof 127.0.0.1 6379; sleep 2; redis-cli -p 6380 info replication; echo =====; redis-cli -p 6380 info keyspace

6  $ /opt/redis-7.2/bin/redis-cli -p 6379 info keyspace; /opt/redis-7.2/bin/redis-cli -p 6379 dbsize; /opt/redis-7.2/bin/redis-cli -p 6379 --scan | head -20

7  $ tail -30 /var/log/redis/redis.log; echo =====OLD; tail -20 /var/log/redis-old/redis.log

8  $ redis-cli -p 6380 info server | grep -E 'redis_version|executable|config_file'; ls -la /var/lib/redis /run/redis 2>/dev/null; redis-cli -p 6380 CONFIG GET masterauth; redis-cli -p 6380 CONFIG GET replica-serve-stale-data

9  $ sleep 5; redis-cli -p 6380 info replication | grep -E 'role|link_status|sync_in|offset'; echo =====; redis-cli -p 6380 info keyspace; echo =====; tail -5 /var/log/redis/redis.log; echo =====MASTER_LOG; tail -5 /var/log/redis-old/redis.log

10  $ redis-cli -p 6380 replicaof no one; redis-cli -p 6380 config set replica-read-only no; sleep 1; redis-cli -p 6380 info replication | grep -E 'role|master_host|slave_read_only|slave_read_repl'; echo =====; redis-cli -p 6380 info keyspace; echo =====; redis-cli -p 6379 info replication | grep -E 'role|connected_slaves'

11  $ python3 -c "import redis; print(redis.__version__)" 2>&1; /opt/kv-grader/bin/python -c "import redis; print(redis.__version__)" 2>&1; cat /opt/kv-seed/kvdump.py

12  $ cd /opt/kv-seed && python3 - <<'EOF'
import kvdump, json, time
old = kvdump.dump_server(6379)
new = kvdump.dump_server(6380)
print("old dbs:", {d: len(v) for d, v in old.items()})
print("new dbs:", {d: len(v) for d, v in new.items()})
print("digest old:", kvdump.digest(old))
print("digest new:", kvdump.digest(new))
print("digests equal:", kvdump.digest(old) == kvdump.digest(new))

# deep comparison including TTL within tolerance
tol = 1500  # ms
problems = []
if set(old) != set(new):
    problems.append(f"db sets differ: {set(old)} vs {set(new)}")
for db in old:
    o, n = old[db], new.get(db, {})
    if set(o) != set(n):
        problems.append(f"db{db} key sets differ: missing={set(o)-set(n)} extra={set(n)-set(o)}")
    for k in set(o) & set(n):
        ot, ov, op = o[k]; nt, nv, np_ = n[k]
        if ot != nt: problems.append(f"db{db} {k}: type {ot}!={nt}")
        if ov != nv: problems.append(f"db{db} {k} ({ot}): value differs")
        oexp, nexp = op > 0, np_ > 0
        if oexp != nexp: problems.append(f"db{db} {k}: expiry presence {op} vs {np_}")
        elif oexp and abs(op - np_) > tol: problems.append(f"db{db} {k}: ttl {op} vs {np_}")
print("problems:", len(problems))
for p in problems[:20]: print(" -", p)
EOF

13  $ redis-cli -p 6380 --scan --pattern '*' | wc -l; echo ---STREAMS_OLD; /opt/redis-7.2/bin/redis-cli -p 6379 --scan | while read k; do t=$(/opt/redis-7.2/bin/redis-cli -p 6379 type "$k"); [ "$t" = stream ] && echo "$k"; done; echo ---WRITE_TEST; redis-cli -p 6380 set __migration_write_test ok; redis-cli -p 6380 get __migration_write_test; redis-cli -p 6380 del __migration_write_test; echo ---MASTER_STATE; redis-cli -p 6380 info replication | grep -E 'role|master_host|slave_read_only'; redis-cli -p 6380 info persistence | grep -E 'rdb_last_bgsave_status|rdb_changes_since'; redis-cli -p 6380 ping

14  $ grep -n -i "digest\|save\|write\|json" /opt/kv-seed/seed_old.py | head; find / -name "*digest*" -o -name "*seed*digest*" 2>/dev/null | grep -v proc | head; ls -la /opt/kv-seed

15  $ cat /var/lib/kv-seed/old.digest; cd /opt/kv-seed && python3 -c "
import kvdump
d_old = kvdump.digest(kvdump.dump_server(6379))
d_new = kvdump.digest(kvdump.dump_server(6380))
expected = open('/var/lib/kv-seed/old.digest').read().strip()
print('seed-time digest:', expected)
print('old server now  :', d_old, d_old == expected)
print('new server now  :', d_new, d_new == expected)
"

16  $ /opt/redis-7.2/bin/redis-cli -p 6379 info keyspace; redis-cli -p 6380 info keyspace; echo ---; redis-cli -p 6380 info persistence | grep -E 'rdb_last_bgsave|aof_enabled'; echo ---stream_groups_new; for k in events:00 events:07 events:19; do redis-cli -p 6380 xinfo groups "$k"; done

17  $ redis-cli -p 6380 config get replicaof; redis-cli -p 6380 config get replica-read-only; grep -iE 'replicaof|slaveof' /etc/redis/redis.conf || echo "no replicaof in config file"; redis-cli -p 6380 info replication | grep -E 'role|master_host|connected_slaves'; redis-cli -p 6380 ping; /opt/redis-7.2/bin/redis-cli -p 6379 ping; /opt/redis-7.2/bin/redis-cli -p 6379 info replication | grep -E 'role|connected_slaves'

{
 "examples": {},
 "keys_new": {
  "0": 2920,
  "2": 350
 },
 "keys_old": {
  "0": 2920,
  "2": 350
 },
 "mismatch_counts": {
  "extra": 0,
  "missing": 0,
  "ttl_added": 0,
  "ttl_drift": 0,
  "ttl_lost": 0,
  "type": 0,
  "value": 0
 },
 "new_replication": {
  "master_host": null,
  "master_link_status": null,
  "master_port": null,
  "role": "master"
 },
 "new_server": {
  "redis_version": "8.10.2",
  "server_name": null,
  "valkey_version": null
 },
 "old_digest_ok": true,
 "old_server": {
  "redis_version": "7.2.16",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

1  $ cat /etc/redis-old/redis.conf | grep -vE '^\s*#|^$' ; echo '=== NEW ==='; cat /etc/redis/redis.conf | grep -vE '^\s*#|^$'

2  $ ls -la /opt/redis-7.2/bin /opt/redis-8.10/bin 2>/dev/null; which redis-cli redis-server; ps aux | grep -i redis | grep -v grep

3  $ /opt/redis-7.2/bin/redis-cli -p 6379 info server | head -20; echo '==='; /opt/redis-7.2/bin/redis-cli -p 6379 info keyspace; echo '==='; /opt/redis-7.2/bin/redis-cli -p 6379 info replication; echo '==='; redis-cli -p 6380 info server | head; redis-cli -p 6380 info keyspace; redis-cli -p 6380 info replication; redis-cli -p 6380 info persistence | head -15

4  $ redis-cli -p 6379 info modules; echo '==='; redis-cli -p 6380 info modules; echo '==='; redis-cli -p 6379 config get databases; redis-cli -p 6380 config get databases; redis-cli -p 6379 config get requirepass; redis-cli -p 6380 config get requirepass; redis-cli -p 6379 config get masterauth; redis-cli -p 6379 config get replica-read-only

5  $ redis-cli -p 6380 replicaof 127.0.0.1 6379; sleep 3; redis-cli -p 6380 info replication; echo '==='; redis-cli -p 6380 info persistence | grep -E 'loading|rdb_last|rdb_changes'

6  $ redis-cli -p 6379 info replication

7  $ sleep 5; redis-cli -p 6380 info replication | grep -E 'role|master_link|sync'; echo '=== replica log ==='; tail -30 /var/log/redis/redis.log; echo '=== master log ==='; tail -20 /var/log/redis-old/redis.log

8  $ cd /tmp
# Compare keyspace + types + TTLs across all DBs
for db in $(seq 0 15); do
  /opt/redis-7.2/bin/redis-cli -p 6379 --scan --db $db 2>/dev/null | sort > /tmp/old_keys_$db.txt
  redis-cli -p 6380 --scan --db $db 2>/dev/null | sort > /tmp/new_keys_$db.txt
  if ! cmp -s /tmp/old_keys_$db.txt /tmp/new_keys_$db.txt; then echo "KEY MISMATCH db$db"; fi
done
echo "key lists compared; total old: $(cat /tmp/old_keys_*.txt | wc -l), total new: $(cat /tmp/new_keys_*.txt | wc -l)"
# Compare type and TTL for every key
mismatch=0
for db in $(seq 0 15); do
  while IFS= read -r k; do
    [ -z "$k" ] && continue
    o=$(/opt/redis-7.2/bin/redis-cli -p 6379 --db $db type "$k")
    n=$(redis-cli -p 6380 --db $db type "$k")
    ot=$(/opt/redis-7.2/bin/redis-cli -p 6379 --db $db pttl "$k")
    nt=$(redis-cli -p 6380 --db $db pttl "$k")
    # allow 1s drift in ttl
    if [ "$o" != "$n" ]; then echo "TYPE MISMATCH db$db $k: $o vs $n"; mismatch=1; fi
    if [ "$ot" != "-2" ] || [ "$nt" != "-2" ]; then
      if [ "$ot" = "-1" ] && [ "$nt" = "-1" ]; then :;
      elif [ "$ot" = "-2" ] && [ "$nt" = "-2" ]; then :;
      else
        d=$((ot - nt)); [ $d -lt 0 ] && d=$((-d))
        if [ $d -gt 1000 ]; then echo "TTL MISMATCH db$db $k: $ot vs $nt"; mismatch=1; fi
      fi
    fi
  done < /tmp/old_keys_$db.txt
done
[ $mismatch -eq 0 ] && echo "ALL types+TTLs match"

9  $ # Compare values: dump all keys from both and compare hashes
for db in 0 1 2; do
  while IFS= read -r k; do
    [ -z "$k" ] && continue
    o=$(/opt/redis-7.2/bin/redis-cli -p 6379 --db $db --no-raw dump "$k" | md5sum)
    n=$(redis-cli -p 6380 --db $db --no-raw dump "$k" | md5sum)
    [ "$o" != "$n" ] && echo "VALUE MISMATCH db$db key: $k"
  done < /tmp/old_keys_$db.txt
done
echo "value dumps compared"
# Stream groups check
for db in $(seq 0 15); do
  while IFS= read -r k; do
    [ -z "$k" ] && continue
    t=$(/opt/redis-7.2/bin/redis-cli -p 6379 --db $db type "$k")
    [ "$t" != "stream" ] && continue
    og=$(/opt/redis-7.2/bin/redis-cli -p 6379 --db $db xinfo groups "$k" | grep -E 'name|consumers|pending' | tr -d '\r')
    ng=$(redis-cli -p 6380 --db $db xinfo groups "$k" | grep -E 'name|consumers|pending' | tr -d '\r')
    if [ "$og" != "$ng" ]; then echo "GROUP MISMATCH db$db $k"; echo "--- old:"; echo "$og"; echo "--- new:"; echo "$ng"; fi
  done < /tmp/old_keys_$db.txt
done
echo "stream groups compared"

10  $ /opt/redis-7.2/bin/redis-cli -p 6379 --scan | head; echo "exit=$?"; /opt/redis-7.2/bin/redis-cli -p 6379 -n 2 --scan | head; echo "exit=$?"; ls -la /tmp/old_keys_0.txt; head -3 /tmp/old_keys_0.txt

11  $ cd /tmp
for db in $(seq 0 15); do
  /opt/redis-7.2/bin/redis-cli -p 6379 -n $db --scan | sort > /tmp/old_keys_$db.txt
  redis-cli -p 6380 -n $db --scan | sort > /tmp/new_keys_$db.txt
  cmp -s /tmp/old_keys_$db.txt /tmp/new_keys_$db.txt || echo "KEY MISMATCH db$db"
done
echo "totals: old=$(cat /tmp/old_keys_*.txt | wc -l) new=$(cat /tmp/new_keys_*.txt | wc -l)"
mismatch=0
for db in $(seq 0 15); do
  while IFS= read -r k; do
    [ -z "$k" ] && continue
    o=$(/opt/redis-7.2/bin/redis-cli -p 6379 -n $db type "$k" | tr -d '\r')
    n=$(redis-cli -p 6380 -n $db type "$k" | tr -d '\r')
    ot=$(/opt/redis-7.2/bin/redis-cli -p 6379 -n $db pttl "$k" | tr -d '\r')
    nt=$(redis-cli -p 6380 -n $db pttl "$k" | tr -d '\r')
    [ "$o" != "$n" ] && { echo "TYPE MISMATCH db$db [$k]: $o vs $n"; mismatch=1; }
    if [ "$ot" != "$nt" ]; then
      case "$ot$nt" in *-1*) : ;; *) d=$((ot-nt)); [ $d -lt 0 ] && d=$((-d)); [ $d -gt 2000 ] && { echo "TTL MISMATCH db$db [$k]: $ot vs $nt"; mismatch=1; };; esac
    fi
  done < /tmp/old_keys_$db.txt
done
[ $mismatch -eq 0 ] && echo "ALL types+TTLs match"

12  $ for db in $(seq 0 15); do
  while IFS= read -r k; do
    [ -z "$k" ] && continue
    o=$(/opt/redis-7.2/bin/redis-cli -p 6379 -n $db --no-raw dump "$k" | md5sum | cut -d' ' -f1)
    n=$(redis-cli -p 6380 -n $db --no-raw dump "$k" | md5sum | cut -d' ' -f1)
    [ "$o" != "$n" ] && echo "VALUE MISMATCH db$db [$k]"
  done < /tmp/old_keys_$db.txt
done
echo "values compared"
for db in $(seq 0 15); do
  while IFS= read -r k; do
    [ -z "$k" ] && continue
    t=$(/opt/redis-7.2/bin/redis-cli -p 6379 -n $db type "$k" | tr -d '\r')
    [ "$t" != "stream" ] && continue
    og=$(/opt/redis-7.2/bin/redis-cli -p 6379 -n $db xinfo groups "$k" | grep -A1 -E '^(\$|[0-9]+\)) (name|consumers|pending)$' | grep -vE '^(\$|[0-9]+\))' | tr -d '\r' | paste -sd,)
    ng=$(redis-cli -p 6380 -n $db xinfo groups "$k" | grep -A1 -E '^(\$|[0-9]+\)) (name|consumers|pending)$' | grep -vE '^(\$|[0-9]+\))' | tr -d '\r' | paste -sd,)
    [ "$og" != "$ng" ] && { echo "GROUP MISMATCH db$db [$k]"; echo " old: $og"; echo " new: $ng"; }
    # also compare consumer names & pending counts per group
    oc=$(/opt/redis-7.2/bin/redis-cli -p 6379 -n $db xinfo consumers "$k" 2>/dev/null | grep -A1 'name' | grep -v name | tr -d '\r' | paste -sd,)
    nc=$(redis-cli -p 6380 -n $db xinfo consumers "$k" 2>/dev/null | grep -A1 'name' | grep -v name | tr -d '\r' | paste -sd,)
    [ "$oc" != "$nc" ] && { echo "CONSUMER MISMATCH db$db [$k]"; echo " old: $oc"; echo " new: $nc"; }
  done < /tmp/old_keys_$db.txt
done
echo "stream groups compared"

13  $ for k in active:00 blob:0 events:00 leaderboard:000; do
  echo "== $k type: $(redis-cli -p 6379 type $k | tr -d '\r')"
  od -An -tx1 <(redis-cli -p 6379 --no-raw dump $k) | tail -2
  echo "---"
  od -An -tx1 <(redis-cli -p 6380 --no-raw dump $k) | tail -2
done 2>/dev/null | head -40
# show what key types exist
redis-cli -p 6379 info keyspace
for db in 0 1 2 3; do while IFS= read -r k; do [ -z "$k" ] && continue; redis-cli -p 6379 -n $db type "$k" | tr -d '\r'; done < /tmp/old_keys_$db.txt; done | sort | uniq -c

14  $ # compare logical values per type
cmp_cmd() { # db key
  local db=$1 k=$2 t
  t=$(/opt/redis-7.2/bin/redis-cli -p 6379 -n $db type "$k" | tr -d '\r')
  case "$t" in
    string) oc=$(/opt/redis-7.2/bin/redis-cli -p 6379 -n $db get "$k"); nc=$(redis-cli -p 6380 -n $db get "$k");;
    list) oc=$(/opt/redis-7.2/bin/redis-cli -p 6379 -n $db lrange "$k" 0 -1 | sort); nc=$(redis-cli -p 6380 -n $db lrange "$k" 0 -1 | sort);;
    set) oc=$(/opt/redis-7.2/bin/redis-cli -p 6379 -n $db smembers "$k" | sort); nc=$(redis-cli -p 6380 -n $db smembers "$k" | sort);;
    zset) oc=$(/opt/redis-7.2/bin/redis-cli -p 6379 -n $db zrange "$k" 0 -1 withscores | paste -sd,); nc=$(redis-cli -p 6380 -n $db zrange "$k" 0 -1 withscores | paste -sd,);;
    hash) oc=$(/opt/redis-7.2/bin/redis-cli -p 6379 -n $db hgetall "$k" | paste -sd,); nc=$(redis-cli -p 6380 -n $db hgetall "$k" | paste -sd,);;
    stream) oc=$(/opt/redis-7.2/bin/redis-cli -p 6379 -n $db xrange "$k" - +); nc=$(redis-cli -p 6380 -n $db xrange "$k" - +);;
    *) oc="type:$t"; nc=$(redis-cli -p 6380 -n $db type "$k" | tr -d '\r');;
  esac
  [ "$oc" != "$nc" ] && { echo "MISMATCH db$db [$k] ($t)"; return 1; }
}
bad=0
for db in $(seq 0 15); do
  while IFS= read -r k; do [ -z "$k" ] && continue; cmp_cmd $db "$k" || bad=1; done < /tmp/old_keys_$db.txt
done
[ $bad -eq 0 ] && echo "ALL logical values match"

15  $ cat > /tmp/cmp.sh <<'EOF'
#!/bin/bash
exec 2>/dev/null
cmp_cmd() {
  local db=$1 k=$2 t oc nc
  t=$(/opt/redis-7.2/bin/redis-cli -p 6379 -n $db type "$k" | tr -d '\r')
  case "$t" in
    string) oc=$(/opt/redis-7.2/bin/redis-cli -p 6379 -n $db --no-raw get "$k" | md5sum); nc=$(redis-cli -p 6380 -n $db --no-raw get "$k" | md5sum);;
    list) oc=$(/opt/redis-7.2/bin/redis-cli -p 6379 -n $db --no-raw lrange "$k" 0 -1 | sort | md5sum); nc=$(redis-cli -p 6380 -n $db --no-raw lrange "$k" 0 -1 | sort | md5sum);;
    set) oc=$(/opt/redis-7.2/bin/redis-cli -p 6379 -n $db --no-raw smembers "$k" | sort | md5sum); nc=$(redis-cli -p 6380 -n $db --no-raw smembers "$k" | sort | md5sum);;
    zset) oc=$(/opt/redis-7.2/bin/redis-cli -p 6379 -n $db --no-raw zrange "$k" 0 -1 withscores | paste -sd, | md5sum); nc=$(redis-cli -p 6380 -n $db --no-raw zrange "$k" 0 -1 withscores | paste -sd, | md5sum);;
    hash) oc=$(/opt/redis-7.2/bin/redis-cli -p 6379 -n $db --no-raw hgetall "$k" | paste -sd, | md5sum); nc=$(redis-cli -p 6380 -n $db --no-raw hgetall "$k" | paste -sd, | md5sum);;
    stream) oc=$(/opt/redis-7.2/bin/redis-cli -p 6379 -n $db --no-raw xrange "$k" - + | md5sum); nc=$(redis-cli -p 6380 -n $db --no-raw xrange "$k" - + | md5sum);;
    *) oc="t:$t"; nc="t:$(redis-cli -p 6380 -n $db type "$k" | tr -d '\r')";;
  esac
  if [ "$oc" != "$nc" ]; then echo "MISMATCH db$db [$k] ($t)"; return 1; fi
}
bad=0; n=0
for db in $(seq 0 15); do
  while IFS= read -r k; do [ -z "$k" ] && continue; n=$((n+1)); cmp_cmd $db "$k" || bad=1; done < /tmp/old_keys_$db.txt
done
echo "checked=$n mismatches=$bad"
EOF
bash /tmp/cmp.sh

16  $ cat > /tmp/cmp2.sh <<'EOF'
#!/bin/bash
exec 2>/dev/null
bad=0
for db in $(seq 0 15); do
  while IFS= read -r k; do
    [ -z "$k" ] && continue
    ot=$(/opt/redis-7.2/bin/redis-cli -p 6379 -n $db pttl "$k" | tr -d '\r')
    nt=$(redis-cli -p 6380 -n $db pttl "$k" | tr -d '\r')
    if [ "$ot" = "-2" ] || [ "$nt" = "-2" ]; then echo "MISSING db$db [$k] old=$ot new=$nt"; bad=1; continue; fi
    if [ "$ot" = "-1" ] && [ "$nt" = "-1" ]; then continue; fi
    if [ "$ot" = "-1" ] || [ "$nt" = "-1" ]; then echo "TTL-EXISTS-MISMATCH db$db [$k] old=$ot new=$nt"; bad=1; continue; fi
    d=$((ot - nt)); [ $d -lt 0 ] && d=$((-d))
    [ $d -gt 3000 ] && { echo "TTL MISMATCH db$db [$k] old=$ot new=$nt"; bad=1; }
    # ttl must be > 0 on both if one has ttl
    [ $nt -le 0 ] && { echo "TTL DEAD db$db [$k] new=$nt"; bad=1; }
  done < /tmp/old_keys_$db.txt
  # stream groups
  while IFS= read -r k; do
    [ -z "$k" ] && continue
    t=$(/opt/redis-7.2/bin/redis-cli -p 6379 -n $db type "$k" | tr -d '\r')
    [ "$t" != "stream" ] && continue
    og=$(/opt/redis-7.2/bin/redis-cli -p 6379 -n $db xinfo groups "$k" | tr -d '\r')
    ng=$(redis-cli -p 6380 -n $db xinfo groups "$k" | tr -d '\r')
    if [ "$og" != "$ng" ]; then echo "GROUP DIFF db$db [$k]"; diff <(echo "$og") <(echo "$ng") | head -20; bad=1; fi
    oc=$(/opt/redis-7.2/bin/redis-cli -p 6379 -n $db xinfo consumers "$k" | tr -d '\r')
    nc=$(redis-cli -p 6380 -n $db xinfo consumers "$k" | tr -d '\r')
    if [ "$oc" != "$nc" ]; then echo "CONSUMER DIFF db$db [$k]"; diff <(echo "$oc") <(echo "$nc") | head -20; bad=1; fi
    ol=$(/opt/redis-7.2/bin/redis-cli -p 6379 -n $db xlen "$k" | tr -d '\r')
    nl=$(redis-cli -p 6380 -n $db xlen "$k" | tr -d '\r')
    [ "$ol" != "$nl" ] && { echo "XLEN DIFF db$db [$k] $ol vs $nl"; bad=1; }
  done < /tmp/old_keys_$db.txt
done
echo "ttl+streams done, bad=$bad"
EOF
bash /tmp/cmp2.sh

17  $ # also confirm source untouched: it still is master with no writes from us; check dbsize per db
for db in $(seq 0 15); do
  o=$(/opt/redis-7.2/bin/redis-cli -p 6379 -n $db dbsize | tr -d '\r')
  n=$(redis-cli -p 6380 -n $db dbsize | tr -d '\r')
  [ "$o" != "$n" ] && echo "DBSIZE MISMATCH db$db: $o vs $n"
done
echo dbsizes compared
/opt/redis-7.2/bin/redis-cli -p 6379 info keyspace; redis-cli -p 6380 info keyspace

18  $ redis-cli -p 6380 replicaof NO ONE
redis-cli -p 6380 config set replica-read-only no
sleep 1
redis-cli -p 6380 info replication | grep -E 'role|master_host|connected_slaves|slave_read'
redis-cli -p 6380 info server | grep redis_version

19  $ # Accepts writes?
redis-cli -p 6380 set __mig_test ok; redis-cli -p 6380 get __mig_test; redis-cli -p 6380 del __mig_test
# Config file has no replicaof?
grep -nE '^\s*(replicaof|slaveof)' /etc/redis/redis.conf || echo "no replicaof in config file (restart-safe as standalone)"
# Old server: still running, still master, no slaves, data intact, config untouched
/opt/redis-7.2/bin/redis-cli -p 6379 ping
/opt/redis-7.2/bin/redis-cli -p 6379 info replication | grep -E 'role|connected_slaves'
/opt/redis-7.2/bin/redis-cli -p 6379 info keyspace
ps aux | grep -v grep | grep redis

20  $ # Final full data re-check after detach (files still valid from scan)
bash /tmp/cmp.sh; bash /tmp/cmp2.sh
# stream group spot-check example
sk=$(grep -m1 . /tmp/old_keys_0.txt >/dev/null; for k in $(cat /tmp/old_keys_0.txt); do t=$(redis-cli -p 6379 -n 0 type "$k"|tr -d '\r'); [ "$t" = stream ] && { echo $k; break; }; done)
echo "sample stream: $sk"
redis-cli -p 6379 -n 0 xinfo groups "$sk" | tr -d '\r' | head -20
echo "--- new:"
redis-cli -p 6380 -n 0 xinfo groups "$sk" | tr -d '\r' | head -20

21  $ redis-cli -p 6380 bgsave; sleep 3; redis-cli -p 6380 info persistence | grep -E 'rdb_last_bgsave_status|rdb_changes_since_last_save'
redis-cli -p 6380 ping; redis-cli -p 6380 info replication | grep role

{
 "examples": {},
 "keys_new": {
  "0": 2920,
  "2": 350
 },
 "keys_old": {
  "0": 2920,
  "2": 350
 },
 "mismatch_counts": {
  "extra": 0,
  "missing": 0,
  "ttl_added": 0,
  "ttl_drift": 0,
  "ttl_lost": 0,
  "type": 0,
  "value": 0
 },
 "new_replication": {
  "master_host": null,
  "master_link_status": null,
  "master_port": null,
  "role": "master"
 },
 "new_server": {
  "redis_version": "8.10.2",
  "server_name": null,
  "valkey_version": null
 },
 "old_digest_ok": true,
 "old_server": {
  "redis_version": "7.2.16",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}