Move production data off Redis 7.2 · Valkey 9.1

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

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

3  $ valkey-cli -p 6380 replicaof 127.0.0.1 6379; sleep 3; valkey-cli -p 6380 info replication | head -12; valkey-cli -p 6380 info keyspace; tail -20 /var/log/valkey/valkey.log

4  $ sleep 5; tail -8 /var/log/valkey/valkey.log; tail -15 /var/log/redis-old/redis.log

5  $ C=/opt/redis-7.2/bin/redis-cli; $C -p 6379 info replication | grep -E 'offset|slave0'; valkey-cli -p 6380 info replication | grep -E 'offset|link'; $C -p 6379 info keyspace; valkey-cli -p 6380 info keyspace

6  $ valkey-cli -p 6380 replicaof no one; valkey-cli -p 6380 info replication | head -3; valkey-cli -p 6380 config get replica-read-only; grep -i replicaof /etc/valkey/valkey.conf; valkey-cli -p 6380 set __migration_writetest 1 && valkey-cli -p 6380 del __migration_writetest

7  $ which python3; python3 -c "import redis; print(redis.__version__)"

8  $ cat > /tmp/verify.py <<'EOF'
import redis
diff=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)); diff+=1
    for k in ka:
        n+=1
        t=a.type(k)
        if t!=b.type(k): print("type",db,k); diff+=1; continue
        t=t.decode()
        if t=='string': va,vb=a.get(k),b.get(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=='hash': va,vb=a.hgetall(k),b.hgetall(k)
        elif t=='stream':
            va=(a.xrange(k),[ (g, a.xinfo_consumers(k,g['name'])) for g in a.xinfo_groups(k)], a.xpending_range(k,'-','+',10**6) if False else None)
            vb=(b.xrange(k),[ (g, b.xinfo_consumers(k,g['name'])) for g in b.xinfo_groups(k)], None)
            ga=[(g['name'],g['last-delivered-id'],g['pending'],g.get('entries-read')) for g in a.xinfo_groups(k)]
            gb=[(g['name'],g['last-delivered-id'],g['pending'],g.get('entries-read')) for g in b.xinfo_groups(k)]
            pa=[[ (p['message_id'],p['consumer'],p['times_delivered']) for p in a.xpending_range(k,g[0],'-','+',100000)] for g in ga]
            pb=[[ (p['message_id'],p['consumer'],p['times_delivered']) for p in b.xpending_range(k,g[0],'-','+',100000)] for g in gb]
            ia=a.execute_command('XINFO','STREAM',k); ib=b.execute_command('XINFO','STREAM',k)
            va=(a.xrange(k),ga,pa,ia.get(b'last-generated-id') if isinstance(ia,dict) else ia[ia.index(b'last-generated-id')+1])
            vb=(b.xrange(k),gb,pb,ib.get(b'last-generated-id') if isinstance(ib,dict) else ib[ib.index(b'last-generated-id')+1])
        else: print("other type",t,k); va,vb=a.dump(k),b.dump(k)
        if va!=vb: print("value",db,k,t); diff+=1
        ta,tb=a.pexpiretime(k),b.pexpiretime(k)
        if ta!=tb: print("ttl",db,k,ta,tb); diff+=1
print("keys",n,"diffs",diff)
EOF
python3 /tmp/verify.py

9  $ valkey-cli -p 6380 bgsave; sleep 2; valkey-cli -p 6380 info persistence | grep -E 'bgsave_status|rdb_changes'; /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": "7.2.4",
  "server_name": "valkey",
  "valkey_version": "9.1.2"
 },
 "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 -v '^#' | grep -v '^$'; echo ----; grep -v '^#' /etc/valkey/valkey.conf | grep -v '^$'; ls /opt/redis-7.2/bin; which valkey-cli redis-cli

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

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

4  $ C=/opt/redis-7.2/bin/redis-cli; $C -p 6379 debug digest; valkey-cli -p 6380 debug digest; for db in 0 2; do $C -p 6379 -n $db --scan | head -3; done; $C -p 6379 -n 0 --scan --type stream | head; 

5  $ python3 -c "import redis; print(redis.__version__)"; python3 --version

6  $ cat > /tmp/cmp.py <<'EOF'
import redis
def val(r,k,t):
    if t=='string': return r.get(k)
    if t=='list': return r.lrange(k,0,-1)
    if t=='set': return sorted(r.smembers(k))
    if t=='zset': return r.zrange(k,0,-1,withscores=True)
    if t=='hash': return sorted(r.hgetall(k).items())
    if t=='stream':
        groups=r.xinfo_groups(k)
        g=[(x['name'],x['last-delivered-id'],x.get('entries-read'),x['pending'],
            r.xpending_range(k,x['name'],'-','+',100000) and [(p['message_id'],p['consumer'],p['times_delivered']) for p in r.xpending_range(k,x['name'],'-','+',100000)],
            sorted((c['name'],c['pending']) for c in r.xinfo_consumers(k,x['name']))) for x in groups]
        info=r.xinfo_stream(k)
        return (r.xrange(k),g,info['last-generated-id'],info.get('max-deleted-entry-id'),info.get('entries-added'))
    return ('?',t)
bad=0; n=0; types={}
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).decode(); types[t]=types.get(t,0)+1
        if b.type(k).decode()!=t: print('type',db,k); bad+=1; continue
        if val(a,k,t)!=val(b,k,t): print('val',db,k,t); bad+=1
        ta,tb=a.pttl(k),b.pttl(k)
        if (ta<0)!=(tb<0) or abs(ta-tb)>5000: print('ttl',db,k,ta,tb); bad+=1
print('checked',n,'bad',bad,types)
EOF
python3 /tmp/cmp.py

7  $ V=valkey-cli; $V -p 6380 replicaof no one; $V -p 6380 info replication | head -4; $V -p 6380 -n 15 set __migr_test 1; $V -p 6380 -n 15 del __migr_test; $V -p 6380 config get replica-read-only; grep -i replicaof /etc/valkey/valkey.conf; $V -p 6380 bgsave; /opt/redis-7.2/bin/redis-cli -p 6379 info replication | head -3; python3 /tmp/cmp.py

{
 "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": "7.2.4",
  "server_name": "valkey",
  "valkey_version": "9.1.2"
 },
 "old_digest_ok": true,
 "old_server": {
  "redis_version": "7.2.16",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

1  $ grep -vE '^\s*(#|$)' /etc/redis-old/redis.conf; echo ---; grep -vE '^\s*(#|$)' /etc/valkey/valkey.conf; echo ---; ls /opt/redis-7.2/bin; which valkey-cli redis-cli

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

3  $ valkey-cli -p 6380 replicaof 127.0.0.1 6379; sleep 5; valkey-cli -p 6380 info replication | head -8; valkey-cli -p 6380 info keyspace; tail -5 /var/log/valkey/valkey.log

4  $ sleep 3; tail -15 /var/log/valkey/valkey.log; tail -15 /var/log/redis-old/redis.log

5  $ C=/opt/redis-7.2/bin/redis-cli; $C -p 6379 info keyspace; $C -p 6379 info replication | grep -E 'offset|slave0'; valkey-cli -p 6380 info keyspace; valkey-cli -p 6380 info replication | grep -E 'link|offset'

6  $ valkey-cli -p 6380 replicaof no one; valkey-cli -p 6380 info replication | head -3; valkey-cli -p 6380 config get replica-read-only; valkey-cli -p 6380 set __mig_test 1; valkey-cli -p 6380 del __mig_test; grep -i replicaof /etc/valkey/valkey.conf

7  $ python3 -c "import redis; print(redis.__version__)" 2>&1

8  $ cat > /tmp/verify.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:
        n+=1
        t=a.type(k)
        if t!=b.type(k): print("type",db,k); bad+=1; continue
        t=t.decode()
        if t=='string': va,vb=a.get(k),b.get(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=='hash': va,vb=a.hgetall(k),b.hgetall(k)
        elif t=='stream':
            va=(a.xrange(k),a.xinfo_stream(k)['last-generated-id'],[(g['name'],g['last-delivered-id'],g['pending'],a.xinfo_consumers(k,g['name']) and sorted(c['name'] for c in a.xinfo_consumers(k,g['name'])), a.xpending_range(k,g['name'],'-','+',100000)) for g in a.xinfo_groups(k)])
            vb=(b.xrange(k),b.xinfo_stream(k)['last-generated-id'],[(g['name'],g['last-delivered-id'],g['pending'],b.xinfo_consumers(k,g['name']) and sorted(c['name'] for c in b.xinfo_consumers(k,g['name'])), b.xpending_range(k,g['name'],'-','+',100000)) for g in b.xinfo_groups(k)])
            # delivery times/idle may differ slightly; compare ids/consumers/counts
            strip=lambda v:(v[0],v[1],[(g[0],g[1],g[2],g[3],[(p['message_id'],p['consumer'],p['times_delivered']) for p in g[4]]) for g in v[2]])
            va,vb=strip(va),strip(vb)
        else: va,vb=a.dump(k),b.dump(k); print("other type",t,k)
        if va!=vb: print("value",db,k,t); bad+=1
        ta,tb=a.pttl(k),b.pttl(k)
        if (ta<0)!=(tb<0) or abs(ta-tb)>5000: print("ttl",db,k,ta,tb); bad+=1
print("keys",n,"bad",bad)
EOF
python3 /tmp/verify.py

{
 "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": "7.2.4",
  "server_name": "valkey",
  "valkey_version": "9.1.2"
 },
 "old_digest_ok": true,
 "old_server": {
  "redis_version": "7.2.16",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

1  $ ps aux | grep -E '[r]edis|[v]alkey'; ls -l /etc/redis-old/redis.conf /etc/valkey/valkey.conf; /opt/redis-7.2/bin/redis-cli -p 6379 INFO server | head -25; command -v valkey-cli redis-cli

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

3  $ python - <<'PY'
import urllib.request
s=urllib.request.urlopen('https://valkey.io/topics/migration/').read().decode()
from bs4 import BeautifulSoup
text=BeautifulSoup(s,'html.parser').get_text(' ',strip=True)
a=text.find('Setting up replication'); print(text[a:a+5500])
PY

4  $ valkey-cli -p 6380 REPLICAOF 127.0.0.1 6379; for i in $(seq 1 30); do echo "attempt $i"; valkey-cli -p 6380 INFO replication | grep -E 'role:|master_link_status:|master_sync_in_progress:|master_repl_offset:|slave_repl_offset:'; valkey-cli -p 6380 INFO keyspace | grep '^db'; sleep 1; done

5  $ redis-cli -p 6379 INFO replication; valkey-cli -p 6380 INFO replication; tail -35 /var/log/valkey/valkey.log; tail -20 /var/log/redis-old/redis.log; redis-cli -p 6379 INFO keyspace; valkey-cli -p 6380 INFO keyspace; redis-cli -p 6379 DBSIZE; valkey-cli -p 6380 DBSIZE

6  $ command -v python3; python3 - <<'PY'
try: import redis; print(redis.__version__)
except Exception as e: print(e)
PY
redis-cli -p 6379 INFO stats | grep -E 'total_commands_processed|expired_keys'; valkey-cli -p 6380 INFO stats | grep expired_keys; grep -E 'sync|RDB|ready' /var/log/valkey/valkey.log | tail -12; redis-cli -p 6379 INFO keyspace; valkey-cli -p 6380 INFO keyspace

7  $ python3 - <<'PY'
import redis
r=redis.Redis(port=6379); v=redis.Redis(port=6380)
for db in (0,2):
 r=redis.Redis(port=6379,db=db);v=redis.Redis(port=6380,db=db)
 ks=list(r.scan_iter()); print(db,len(ks), 'match',set(ks)==set(v.scan_iter()))
 from collections import Counter
 print(Counter(r.type(k) for k in ks))
 mism=[k for k in ks if r.dump(k)!=v.dump(k)]
 print('dump mismatch',len(mism),mism[:5]); print('ttl diff max',max(abs(r.pexpiretime(k)-v.pexpiretime(k)) for k in ks))
PY

8  $ python3 - <<'PY'
import redis
r=redis.Redis(port=6379);v=redis.Redis(port=6380)
for k in [b'session:00335',b'cache:page:096']:
 for db in [0,2]:
  a=redis.Redis(port=6379,db=db);b=redis.Redis(port=6380,db=db)
  if a.exists(k):print(k, a.dump(k)[:25],b.dump(k)[:25],a.get(k)==b.get(k),a.pexpiretime(k),b.pexpiretime(k))
PY

9  $ cat > /tmp/check_migration.py <<'PY'
import redis
from collections import Counter
for db in range(16):
 a=redis.Redis(host='127.0.0.1',port=6379,db=db)
 b=redis.Redis(host='127.0.0.1',port=6380,db=db)
 ka=set(a.scan_iter());kb=set(b.scan_iter())
 assert ka==kb,(db,len(ka),len(kb),len(ka^kb))
 types=Counter()
 for k in ka:
  t=a.type(k); types[t.decode()]+=1
  assert t==b.type(k),(db,k,'type')
  at=a.pexpiretime(k);bt=b.pexpiretime(k)
  assert at==bt,(db,k,'expiry',at,bt)
  if t==b'string': x=a.get(k); y=b.get(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'hash': x=a.hgetall(k);y=b.hgetall(k)
  elif t==b'stream':
   x=a.xrange(k);y=b.xrange(k)
   assert a.xinfo_stream(k)==b.xinfo_stream(k),(db,k,'stream metadata')
   ga=a.xinfo_groups(k);gb=b.xinfo_groups(k)
   assert ga==gb,(db,k,'groups',ga,gb)
   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_range(k,name,'-','+',100000)==b.xpending_range(k,name,'-','+',100000),(db,k,name,'pending')
  else: raise Exception((db,k,t))
  assert x==y,(db,k,'value')
 if ka: print('db',db,len(ka),dict(types),'OK')
print('All databases match')
PY
python3 /tmp/check_migration.py

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

11  $ sed -i "s/assert a.xinfo_consumers(k,name)==b.xinfo_consumers(k,name),(db,k,name,'consumers')/assert [{q:z for q,z in c.items() if q not in ('idle','inactive')} for c in a.xinfo_consumers(k,name)]==[{q:z for q,z in c.items() if q not in ('idle','inactive')} for c in b.xinfo_consumers(k,name)],(db,k,name,'consumers')/; s/assert a.xpending_range(k,name,'-','+',100000)==b.xpending_range(k,name,'-','+',100000),(db,k,name,'pending')/assert [{q:z for q,z in c.items() if q!='time_since_delivered'} for c in a.xpending_range(k,name,'-','+',100000)]==[{q:z for q,z in c.items() if q!='time_since_delivered'} for c in b.xpending_range(k,name,'-','+',100000)],(db,k,name,'pending')/" /tmp/check_migration.py
python3 /tmp/check_migration.py

12  $ redis-cli -p 6379 INFO replication | grep -E 'role:|slave0:|master_repl_offset:'; valkey-cli -p 6380 INFO replication | grep -E 'role:|master_link_status:|master_sync_in_progress:|slave_repl_offset:'; valkey-cli -p 6380 REPLICAOF NO ONE; valkey-cli -p 6380 SAVE; valkey-cli -p 6380 INFO replication | grep -E 'role:|slave_read_only:|connected_slaves:'; valkey-cli -p 6380 CONFIG GET replicaof appendonly; redis-cli -p 6379 PING; python3 /tmp/check_migration.py

{
 "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": "7.2.4",
  "server_name": "valkey",
  "valkey_version": "9.1.2"
 },
 "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/valkey /etc/redis-old; ps aux | grep -E '[r]edis|[v]alkey'; command -v valkey-cli || true; cat /etc/valkey/valkey.conf | grep -Ev '^\s*(#|$)' | head -90; cat /etc/redis-old/redis.conf | grep -Ev '^\s*(#|$)' | head -90

2  $ (valkey-cli -p 6380 INFO server; valkey-cli -p 6380 INFO replication; /opt/redis-7.2/bin/redis-cli -p 6379 INFO server; /opt/redis-7.2/bin/redis-cli -p 6379 INFO replication) 2>&1 | head -140

3  $ for p in 6379 6380; do echo PORT=$p; valkey-cli -p $p INFO keyspace; valkey-cli -p $p DBSIZE; valkey-cli -p $p CONFIG GET databases; valkey-cli -p $p INFO persistence | grep -E '(rdb_|aof_|loading)'; done

4  $ valkey-cli -p 6380 COMMAND INFO REPLICAOF; df -h /var/lib/valkey /var/lib/redis-old; ls -lah /var/lib/{valkey,redis-old}

5  $ valkey-cli -p 6380 REPLICAOF 127.0.0.1 6379; for i in $(seq 1 30); do echo "$(date +%T)"; valkey-cli -p 6380 INFO replication | grep -E 'role:|master_link_status:|master_sync_in_progress:|slave_repl_offset:|master_repl_offset:'; valkey-cli -p 6380 INFO keyspace | head -5; sleep 1; done

6  $ python3 - <<'PY'
try: import redis;print(redis.__version__)
except Exception as e: print(e)
PY
valkey-cli -p 6379 INFO replication | head -30; valkey-cli -p 6380 INFO replication | head -30; valkey-cli -p 6379 INFO keyspace; valkey-cli -p 6380 INFO keyspace; valkey-cli -p 6380 CONFIG GET replica-read-only; valkey-cli -p 6380 CONFIG GET replicaof

7  $ python3 - <<'PY'
import redis, collections
r=redis.Redis(port=6379);v=redis.Redis(port=6380)
for db in range(16):
 a=redis.Redis(port=6379,db=db);b=redis.Redis(port=6380,db=db)
 ca=collections.Counter();cb=collections.Counter();missing=[];differ=[];ttldiff=[]; streams=[]
 for k in a.scan_iter(count=1000):
  t=a.type(k);ca[t]+=1
  if b.type(k)!=t:missing.append(k);continue
  if a.dump(k)!=b.dump(k):differ.append(k)
  x=a.pexpiretime(k);y=b.pexpiretime(k)
  if abs(x-y)>1500:ttldiff.append((k,x,y))
  if t==b'stream':streams.append(k)
 for k in b.scan_iter(count=1000):cb[b.type(k)]+=1
 if ca or cb:print('db',db,'source',ca,'target',cb,'missing/type',len(missing),'dump differences',len(differ),'ttl differences',len(ttldiff),'streams',len(streams),flush=True);print('examples',missing[:3],differ[:3],ttldiff[:3]);
PY

8  $ python3 - <<'PY'
import redis
r=redis.Redis(port=6379);v=redis.Redis(port=6380)
for k in list(r.scan_iter(match='*',count=200)):
 if r.type(k)==b'stream':
  print(k,r.xinfo_stream(k),v.xinfo_stream(k));print('groups',r.xinfo_groups(k),v.xinfo_groups(k));break
PY

9  $ cat > /tmp/verify_migration.py <<'PY'
import redis
s_errors=[]; counts={}
for db in range(16):
 a=redis.Redis(port=6379,db=db); b=redis.Redis(port=6380,db=db)
 ka=set(a.scan_iter()); kb=set(b.scan_iter()); counts[db]=(len(ka),len(kb))
 if ka!=kb:s_errors.append((db,'key sets',len(ka-kb),len(kb-ka)))
 for k in ka&kb:
  t=a.type(k)
  if t!=b.type(k): s_errors.append((db,k,'type'));continue
  at=a.pexpiretime(k);bt=b.pexpiretime(k)
  if at!=bt:s_errors.append((db,k,'expiretime',at,bt))
  if t==b'string':eq=a.get(k)==b.get(k)
  elif t==b'hash':eq=a.hgetall(k)==b.hgetall(k)
  elif t==b'list':eq=a.lrange(k,0,-1)==b.lrange(k,0,-1)
  elif t==b'set':eq=a.smembers(k)==b.smembers(k)
  elif t==b'zset':eq=a.zrange(k,0,-1,withscores=True)==b.zrange(k,0,-1,withscores=True)
  elif t==b'stream':
   eq=a.xrange(k)==b.xrange(k) and a.xinfo_stream(k)==b.xinfo_stream(k)
   ag=a.xinfo_groups(k);bg=b.xinfo_groups(k)
   eq=eq and ag==bg
   for g in ag:
    n=g['name']; ac=a.xinfo_consumers(k,n);bc=b.xinfo_consumers(k,n)
    # idle/inactive values can drift between sequential calls
    eq=eq and [(x['name'],x['pending']) for x in ac]==[(x['name'],x['pending']) for x in bc]
    ap=a.xpending_range(k,n,'-','+',100000);bp=b.xpending_range(k,n,'-','+',100000)
    eq=eq and [(x['message_id'],x['consumer'],x['times_delivered']) for x in ap]==[(x['message_id'],x['consumer'],x['times_delivered']) for x in bp]
  else: eq=False
  if not eq:s_errors.append((db,k,'value/group mismatch'))
print('DB counts:',counts)
print('errors:',len(s_errors),s_errors[:20])
if s_errors:raise SystemExit(1)
PY
python3 /tmp/verify_migration.py

10  $ set -e
valkey-cli -p 6380 REPLICAOF NO ONE
valkey-cli -p 6380 CONFIG REWRITE
valkey-cli -p 6380 SAVE
printf '\nTarget status:\n'; valkey-cli -p 6380 INFO replication | head -10
valkey-cli -p 6380 INFO keyspace
printf '\nTarget configuration:\n'; cat /etc/valkey/valkey.conf
printf '\nSource status:\n'; valkey-cli -p 6379 PING; valkey-cli -p 6379 INFO keyspace
python3 /tmp/verify_migration.py
ls -lh /var/lib/valkey/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": "7.2.4",
  "server_name": "valkey",
  "valkey_version": "9.1.2"
 },
 "old_digest_ok": true,
 "old_server": {
  "redis_version": "7.2.16",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

1  $ ps auxww | grep -E '[r]edis-server|[v]alkey-server'; ls -l /opt/redis-7.2/bin /etc/redis-old/redis.conf /etc/valkey/valkey.conf; command -v valkey-cli redis-cli; ss -ltnp | grep -E ':(6379|6380)' 

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

3  $ redis-cli -p 6379 MODULE LIST; redis-cli -p 6379 CONFIG GET databases appendonly; valkey-cli -p 6380 CONFIG GET databases appendonly; valkey-cli -p 6380 REPLICAOF 127.0.0.1 6379; sleep 2; valkey-cli -p 6380 INFO replication; redis-cli -p 6379 INFO replication; tail -35 /var/log/valkey/valkey.log

4  $ for i in $(seq 1 30); do s=$(valkey-cli -p 6380 INFO replication); echo "$s" | grep -E 'role:|master_link_status:|master_sync_in_progress:|slave_repl_offset:|master_repl_offset:'; if echo "$s" | grep -q 'master_link_status:up' && echo "$s" | grep -q 'master_sync_in_progress:0'; then break; fi; sleep 1; done; valkey-cli -p 6380 INFO keyspace; tail -20 /var/log/valkey/valkey.log

5  $ python3 - <<'PY'
try: import redis; print(redis.__version__)
except Exception as e: print(e)
PY
redis-cli -p 6379 INFO clients | head -20; redis-cli -p 6379 INFO stats | grep -E 'total_commands_processed|expired_keys|total_connections_received'; valkey-cli -p 6380 CONFIG GET replicaof; redis-cli -p 6379 INFO replication | grep -E 'slave0|master_repl_offset'

6  $ python3 - <<'PY'
import redis
s=redis.Redis(port=6379); d=redis.Redis(port=6380)
for db in range(16):
 s.execute_command('SELECT',db); d.execute_command('SELECT',db)
 keys=s.keys('*')
 if keys:
  dif=[]
  for k in keys:
   if s.dump(k)!=d.dump(k):dif.append((k,s.type(k),len(s.dump(k) or b''),len(d.dump(k) or b'')))
  print(db,'keys',len(keys),'dumps differ',len(dif), 'examples',dif[:5]);
PY

7  $ cat > /tmp/check_migration.py <<'PY'
import redis
s=redis.Redis(host='127.0.0.1',port=6379,decode_responses=False)
d=redis.Redis(host='127.0.0.1',port=6380,decode_responses=False)
counts={}; groups=0
for db in range(16):
 s.execute_command('SELECT',db); d.execute_command('SELECT',db)
 sk=set(s.scan_iter()); dk=set(d.scan_iter())
 assert sk==dk,(db,len(sk),len(dk),len(sk-dk),len(dk-sk))
 counts[db]=len(sk)
 for k in sk:
  typ=s.type(k)
  assert typ==d.type(k),(db,k,'type')
  if typ==b'string': a,b=s.get(k),d.get(k)
  elif typ==b'list': a,b=s.lrange(k,0,-1),d.lrange(k,0,-1)
  elif typ==b'set': a,b=s.smembers(k),d.smembers(k)
  elif typ==b'zset': a,b=s.zrange(k,0,-1,withscores=True),d.zrange(k,0,-1,withscores=True)
  elif typ==b'hash': a,b=s.hgetall(k),d.hgetall(k)
  elif typ==b'stream':
   a,b=s.xrange(k),d.xrange(k)
   assert a==b,(db,k,'stream entries')
   ga,gb=s.xinfo_groups(k),d.xinfo_groups(k)
   def norm(g):return {x: g[x] for x in (b'name',b'consumers',b'pending',b'last-delivered-id',b'entries-read',b'lag')}
   assert list(map(norm,ga))==list(map(norm,gb)),(db,k,'groups',ga,gb)
   for g in ga:
    name=g[b'name']; groups+=1
    ca,cb=s.xinfo_consumers(k,name),d.xinfo_consumers(k,name)
    assert [(x[b'name'],x[b'pending']) for x in ca]==[(x[b'name'],x[b'pending']) for x in cb],(db,k,name,'consumers')
    pa=s.xpending_range(k,name,'-','+',100000)
    pb=d.xpending_range(k,name,'-','+',100000)
    assert [(x['message_id'],x['consumer'],x['times_delivered']) for x in pa]==[(x['message_id'],x['consumer'],x['times_delivered']) for x in pb],(db,k,name,'pending')
   continue
  else: raise ValueError((db,k,typ))
  assert a==b,(db,k,'value')
  ta,tb=s.pttl(k),d.pttl(k)
  assert (ta<0)==(tb<0) and (ta<0 or abs(ta-tb)<3000),(db,k,'ttl',ta,tb)
 print('db',db, 'keys',len(sk)) if sk else None
print('verified',sum(counts.values()),'keys and',groups,'stream consumer groups')
PY
python3 /tmp/check_migration.py

8  $ sed -i "s/b'name',b'consumers',b'pending',b'last-delivered-id',b'entries-read',b'lag'/'name','consumers','pending','last-delivered-id','entries-read','lag'/; s/name=g\[b'name'\]/name=g['name']/; s/x\[b'name'\],x\[b'pending'\]/x['name'],x['pending']/g" /tmp/check_migration.py; python3 /tmp/check_migration.py

9  $ set -e; redis-cli -p 6379 INFO replication | grep -E 'slave0|master_repl_offset'; valkey-cli -p 6380 INFO replication | grep -E 'role:|master_link_status:|master_sync_in_progress:|slave_repl_offset:|master_repl_offset:'; valkey-cli -p 6380 REPLICAOF NO ONE; valkey-cli -p 6380 SAVE; valkey-cli -p 6380 INFO replication | grep -E 'role:|connected_slaves:|master_host:'; valkey-cli -p 6380 INFO keyspace; redis-cli -p 6379 INFO keyspace; ls -lh /var/lib/valkey/dump.rdb; grep -inE '^\s*(replicaof|slaveof)\b' /etc/valkey/valkey.conf || true; python3 /tmp/check_migration.py

{
 "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": "7.2.4",
  "server_name": "valkey",
  "valkey_version": "9.1.2"
 },
 "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; echo "---"; ls /etc/redis-old/ /etc/valkey/ 2>&1; echo "---"; ps aux | grep -E "redis|valkey" | grep -v grep

2  $ /opt/redis-7.2/bin/redis-cli -p 6379 info server | head -20; echo "==="; /opt/redis-7.2/bin/redis-cli -p 6380 info server 2>&1 | head -20

3  $ R="/opt/redis-7.2/bin/redis-cli -p 6379"; $R info keyspace; echo "=== dbsize per db ==="; for i in $(seq 0 15); do n=$($R -n $i dbsize); echo "db$i: $n"; done

4  $ cat /etc/redis-old/redis.conf | grep -v '^#' | grep -v '^$'; echo "=====VALKEY====="; cat /etc/valkey/valkey.conf | grep -v '^#' | grep -v '^$'

5  $ R="/opt/redis-7.2/bin/redis-cli -p 6379"; for i in 0 2; do echo "=== db$i types ==="; for t in string list set zset hash stream; do c=$($R -n $i --scan --pattern '*' >/dev/null 2>&1; true); done; done
echo "--- sample keys db0 ---"; $R -n 0 --scan --count 1000 | head -20
echo "--- sample keys db2 ---"; $R -n 2 --scan --count 1000 | head -20

6  $ R="/opt/redis-7.2/bin/redis-cli -p 6379"
echo "=== type distribution db0 ==="
$R -n 0 --scan --count 100000 | while read k; do $R -n 0 type "$k"; done | sort | uniq -c
echo "=== type distribution db2 ==="
$R -n 2 --scan --count 100000 | while read k; do $R -n 2 type "$k"; done | sort | uniq -c

7  $ R="/opt/redis-7.2/bin/redis-cli -p 6379"
echo "=== streams db0 ==="; $R -n 0 --scan --count 100000 | while read k; do t=$($R -n 0 type "$k"); if [ "$t" = "stream" ]; then echo "KEY $k"; $R -n 0 xinfo groups "$k"; fi; done
echo "=== module list ==="; $R module list

8  $ R="/opt/redis-7.2/bin/redis-cli -p 6379"
echo "=== config get appendonly/save/repl ==="; $R config get appendonly; $R config get save; $R config get dir; $R config get maxmemory
echo "=== dbsize total check info ==="; $R info stats | grep -E "total_connections|sync_full|expired"

9  $ which valkey-cli valkey-server redis-cli 2>&1; echo "---"; ls /var/lib/redis-old /var/lib/valkey 2>&1; echo "--- valkey config full grep replica ---"; grep -i replica /etc/valkey/valkey.conf; echo "--- default save check on valkey ---"; valkey-cli -p 6380 config get save; valkey-cli -p 6380 config get appendonly; valkey-cli -p 6380 config get replica-read-only

10  $ R="/opt/redis-7.2/bin/redis-cli -p 6379"
echo "=== db0 sample values+ttl ==="
for k in $($R -n 0 --scan --count 100000 | head -5); do echo "-- $k $( $R -n 0 type $k ) ttl=$($R -n 0 pttl $k)"; done
echo "=== check requirepass on both ==="
$R config get requirepass; valkey-cli -p 6380 config get requirepass
echo "=== source repl info ==="; $R info replication | head

11  $ valkey-cli -p 6380 replicaof 127.0.0.1 6379
sleep 3
valkey-cli -p 6380 info replication

12  $ echo "=== valkey log tail ==="; tail -30 /var/log/valkey/valkey.log; echo "=== redis log tail ==="; tail -30 /var/log/redis-old/redis.log

13  $ /opt/redis-7.2/bin/redis-cli -p 6379 info replication | head -20

14  $ V="valkey-cli -p 6380"; R="/opt/redis-7.2/bin/redis-cli -p 6379"
echo "=== valkey keyspace ==="; $V info keyspace
echo "=== dbsize per db ==="; for i in $(seq 0 15); do echo "db$i: $($V -n $i dbsize)"; done
echo "=== type distribution db0 ==="; $V -n 0 --scan --count 100000 | while read k; do $V -n 0 type "$k"; done | sort | uniq -c
echo "=== type distribution db2 ==="; $V -n 2 --scan --count 100000 | while read k; do $V -n 2 type "$k"; done | sort | uniq -c

15  $ R="/opt/redis-7.2/bin/redis-cli -p 6379"; V="valkey-cli -p 6380"
mismatch=0; checked=0
for db in 0 2; do
  $R -n $db --scan --count 100000 | while read k; do
    d1=$($R -n $db dump "$k" | md5sum | cut -d' ' -f1)
    d2=$($V -n $db dump "$k" | md5sum | cut -d' ' -f1)
    t1=$($R -n $db pttl "$k"); t2=$($V -n $db pttl "$k")
    if [ "$d1" != "$d2" ]; then echo "VALUE MISMATCH db$db $k"; fi
  done
done > /tmp/diff.txt 2>&1
echo "value mismatches: $(grep -c MISMATCH /tmp/diff.txt)"; head /tmp/diff.txt

16  $ R="/opt/redis-7.2/bin/redis-cli -p 6379"; V="valkey-cli -p 6380"
echo "redis: $($R -n 0 debug digest-value queue:062)"; echo "valkey: $($V -n 0 debug digest-value queue:062)"
echo "redis: $($R debug digest)"; echo "valkey: $($V debug digest)"

17  $ cat > /tmp/cmp.sh <<'EOF'
#!/bin/bash
R="/opt/redis-7.2/bin/redis-cli -p 6379"
V="valkey-cli -p 6380"
norm() { # normalize for comparison
  sort
}
mism=0; ttl_bad=0; cnt=0
for db in 0 2; do
  while read -r k; do
    [ -z "$k" ] && continue
    cnt=$((cnt+1))
    t=$($R -n $db type "$k")
    v1=$($R -n $db --raw "$@" 2>/dev/null)
    case $t in
      string) v1=$($R -n $db get "$k" | md5sum); v2=$($V -n $db get "$k" | md5sum);;
      list)   v1=$($R -n $db lrange "$k" 0 -1 | md5sum); v2=$($V -n $db lrange "$k" 0 -1 | md5sum);;
      set)    v1=$($R -n $db smembers "$k" | sort | md5sum); v2=$($V -n $db smembers "$k" | sort | md5sum);;
      zset)   v1=$($R -n $db zrange "$k" 0 -1 withscores | md5sum); v2=$($V -n $db zrange "$k" 0 -1 withscores | md5sum);;
      hash)   v1=$($R -n $db hgetall "$k" | md5sum); v2=$($V -n $db hgetall "$k" | md5sum);;
      stream) v1=$($R -n $db xrange "$k" - + | md5sum); v2=$($V -n $db xrange "$k" - + | md5sum);;
      *)      v1="skip"; v2="skip";;
    esac
    if [ "$v1" != "$v2" ]; then echo "MISMATCH db$db $k type=$t"; mism=$((mism+1)); fi
    # ttl compare (allow within 2s drift)
    p1=$($R -n $db pttl "$k"); p2=$($V -n $db pttl "$k")
    if [ "$p1" != "-1" ] && [ "$p1" != "-2" ]; then
      d=$((p1-p2)); if [ $d -lt 0 ]; then d=$((-d)); fi
      if [ $d -gt 3000 ]; then echo "TTL DIFF db$db $k src=$p1 dst=$p2"; ttl_bad=$((ttl_bad+1)); fi
    fi
  done < <($R -n $db --scan --count 100000)
done
echo "checked=$cnt value_mismatch=$mism ttl_mismatch=$ttl_bad"
EOF
chmod +x /tmp/cmp.sh; /tmp/cmp.sh

18  $ cat > /tmp/cmp.sh <<'EOF'
#!/bin/bash
R="/opt/redis-7.2/bin/redis-cli -p 6379"
V="valkey-cli -p 6380"
mism=0; ttl_bad=0; cnt=0
for db in 0 2; do
  $R -n $db --scan --count 100000 > /tmp/keys_$db.txt < /dev/null
  while read -r k; do
    [ -z "$k" ] && continue
    cnt=$((cnt+1))
    t=$($R -n $db type "$k" < /dev/null)
    case $t in
      string) v1=$($R -n $db get "$k" </dev/null | md5sum); v2=$($V -n $db get "$k" </dev/null | md5sum);;
      list)   v1=$($R -n $db lrange "$k" 0 -1 </dev/null | md5sum); v2=$($V -n $db lrange "$k" 0 -1 </dev/null | md5sum);;
      set)    v1=$($R -n $db smembers "$k" </dev/null | sort | md5sum); v2=$($V -n $db smembers "$k" </dev/null | sort | md5sum);;
      zset)   v1=$($R -n $db zrange "$k" 0 -1 withscores </dev/null | md5sum); v2=$($V -n $db zrange "$k" 0 -1 withscores </dev/null | md5sum);;
      hash)   v1=$($R -n $db hgetall "$k" </dev/null | md5sum); v2=$($V -n $db hgetall "$k" </dev/null | md5sum);;
      stream) v1=$($R -n $db xrange "$k" - + </dev/null | md5sum); v2=$($V -n $db xrange "$k" - + </dev/null | md5sum);;
      *)      v1="skip"; v2="skip";;
    esac
    if [ "$v1" != "$v2" ]; then echo "MISMATCH db$db $k type=$t"; mism=$((mism+1)); fi
    p1=$($R -n $db pttl "$k" </dev/null); p2=$($V -n $db pttl "$k" </dev/null)
    if [ "$p1" != "-1" ] && [ "$p1" != "-2" ]; then
      d=$((p1-p2)); if [ $d -lt 0 ]; then d=$((-d)); fi
      if [ $d -gt 3000 ]; then echo "TTL DIFF db$db $k src=$p1 dst=$p2"; ttl_bad=$((ttl_bad+1)); fi
    fi
  done < /tmp/keys_$db.txt
done
echo "checked=$cnt value_mismatch=$mism ttl_mismatch=$ttl_bad"
EOF
chmod +x /tmp/cmp.sh; time /tmp/cmp.sh

19  $ R="/opt/redis-7.2/bin/redis-cli -p 6379"; V="valkey-cli -p 6380"
for k in $($R -n 0 --scan --count 100000 </dev/null | while read k; do [ "$($R -n 0 type "$k" </dev/null)" = stream ] && echo "$k"; done); do
  g1=$($R -n 0 xinfo groups "$k" </dev/null)
  g2=$($V -n 0 xinfo groups "$k" </dev/null)
  # normalize: sort lines? groups order may differ; compare sorted non-numeric-keyed
  if [ "$(echo "$g1" | grep -v last-delivered-id | sort | md5sum)" != "$(echo "$g2" | grep -v last-delivered-id | sort | md5sum)" ]; then
     echo "GROUP STRUCT MISMATCH $k"
  fi
  # consumers
  for grp in $($R -n 0 xinfo groups "$k" </dev/null | awk '/^name$/{getline; print}' | grep -v '^name$'); do
    c1=$($R -n 0 xinfo consumers "$k" "$grp" </dev/null | sort | md5sum)
    c2=$($V -n 0 xinfo consumers "$k" "$grp" </dev/null | sort | md5sum)
    [ "$c1" != "$c2" ] && echo "CONSUMER MISMATCH $k group=$grp"
  done
done
echo "=== stream group comparison done ==="

20  $ R="/opt/redis-7.2/bin/redis-cli -p 6379"; V="valkey-cli -p 6380"
echo "=== full XINFO GROUPS events:00 src vs dst ==="
echo "--- SRC ---"; $R -n 0 xinfo groups events:00 </dev/null
echo "--- DST ---"; $V -n 0 xinfo groups events:00 </dev/null
echo "=== XINFO CONSUMERS events:00 workers ==="
echo "--- SRC ---"; $R -n 0 xinfo consumers events:00 workers </dev/null
echo "--- DST ---"; $V -n 0 xinfo consumers events:00 workers </dev/null

21  $ R="/opt/redis-7.2/bin/redis-cli -p 6379"; V="valkey-cli -p 6380"
bad=0
for k in $($R -n 0 --scan --count 100000 </dev/null | while read k; do [ "$($R -n 0 type "$k" </dev/null)" = stream ] && echo "$k"; done); do
  for grp in $($R -n 0 xinfo groups "$k" </dev/null | awk '/^name$/{getline; print}'); do
    p1=$($R -n 0 xpending "$k" "$grp" - + 1000 </dev/null | awk 'NR%4!=0' )  # drop delivery-time line
    p2=$($V -n 0 xpending "$k" "$grp" - + 1000 </dev/null | awk 'NR%4!=0' )
    if [ "$p1" != "$p2" ]; then echo "PENDING MISMATCH $k/$grp"; bad=$((bad+1)); fi
  done
done
echo "pending mismatches (ignoring delivery time): $bad"
echo "=== sample pending detail events:00/workers ==="
echo "-- src --"; $R -n 0 xpending events:00 workers - + 3 </dev/null
echo "-- dst --"; $V -n 0 xpending events:00 workers - + 3 </dev/null

22  $ R="/opt/redis-7.2/bin/redis-cli -p 6379"; V="valkey-cli -p 6380"
norm() { awk 'NR%4==1{id=$0} NR%4==2{c=$0} NR%4==0{print id, c, $0}'; }
bad=0
for k in $($R -n 0 --scan --count 100000 </dev/null | while read k; do [ "$($R -n 0 type "$k" </dev/null)" = stream ] && echo "$k"; done); do
  for grp in $($R -n 0 xinfo groups "$k" </dev/null | awk '/^name$/{getline; print}'); do
    p1=$($R -n 0 xpending "$k" "$grp" - + 1000 </dev/null | norm)
    p2=$($V -n 0 xpending "$k" "$grp" - + 1000 </dev/null | norm)
    if [ "$p1" != "$p2" ]; then echo "PENDING MISMATCH $k/$grp"; bad=$((bad+1)); fi
  done
done
echo "pending mismatches (id/consumer/delivery-count): $bad"

23  $ R="/opt/redis-7.2/bin/redis-cli -p 6379"; V="valkey-cli -p 6380"
bad=0
for k in $($R -n 0 --scan --count 100000 </dev/null | while read k; do [ "$($R -n 0 type "$k" </dev/null)" = stream ] && echo "$k"; done); do
  g1=$($R -n 0 xinfo groups "$k" </dev/null | paste - - | sort)
  g2=$($V -n 0 xinfo groups "$k" </dev/null | paste - - | sort)
  if [ "$g1" != "$g2" ]; then echo "GROUPS MISMATCH $k"; bad=$((bad+1)); fi
done
echo "group-metadata mismatches: $bad"
echo "=== also verify XINFO STREAM full info (first/last entry, length, max-deleted) ==="
for k in events:00 events:04; do
  s1=$($R -n 0 xinfo stream "$k" </dev/null | paste - - | sort | md5sum)
  s2=$($V -n 0 xinfo stream "$k" </dev/null | paste - - | sort | md5sum)
  echo "$k: $([ "$s1" = "$s2" ] && echo MATCH || echo DIFF)"
done

24  $ V="valkey-cli -p 6380"
$V replicaof no one
sleep 2
echo "=== valkey replication ==="; $V info replication | head -6
echo "=== keyspace after promotion ==="; $V info keyspace
for i in 0 2; do echo "db$i: $($V -n $i dbsize)"; done
echo "=== write test ==="; $V -n 0 set __promote_test__ hello; $V -n 0 get __promote_test__; $V -n 0 del __promote_test__

25  $ R="/opt/redis-7.2/bin/redis-cli -p 6379"; V="valkey-cli -p 6380"
echo "=== source (redis 6379) still running, unchanged ==="
$R info replication | grep -E "^role|connected_slaves"
$R info keyspace
echo "=== target (valkey 6380) role & config persistence ==="
$V info replication | grep -E "^role|connected_slaves"
grep -i "replicaof\|slaveof" /etc/valkey/valkey.conf || echo "(no replicaof in valkey.conf - good, boots as primary)"
echo "=== target accepts writes on all types ==="
$V -n 0 set s k; $V -n 0 rpush l a; $V -n 0 hset h f v; $V -n 0 sadd st a; $V -n 0 zadd z 1 a; $V -n 0 xadd xk '*' f v; $V -n 0 del s l h st z xk
echo "OK"
echo "=== per-db dbsize both ==="
for i in 0 2; do echo "db$i src=$($R -n $i dbsize) dst=$($V -n $i dbsize)"; 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": "7.2.4",
  "server_name": "valkey",
  "valkey_version": "9.1.2"
 },
 "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/valkey/ 2>&1; echo "---"; ls /opt/redis-7.2/bin 2>&1

2  $ which valkey-cli redis-cli valkey-server redis-server 2>&1; echo "---"; ls /usr/bin | grep -iE 'valkey|redis' 2>&1

3  $ cat /etc/redis-old/redis.conf; echo "==="; cat /etc/valkey/valkey.conf; echo "==="; ps aux | grep -iE 'redis|valkey' | grep -v grep

4  $ ls -la /opt/redis-7.2/bin /opt/kv-seed /opt/kv-grader 2>&1; echo "---"; valkey-server --version; valkey-cli --version; /opt/redis-7.2/bin/redis-server --version; /opt/redis-7.2/bin/redis-cli --version

5  $ cat /opt/kv-seed/seed_old.py; echo "======"; cat /opt/kv-seed/kvdump.py

6  $ redis-cli -h 127.0.0.1 -p 6379 INFO keyspace; echo "---"; valkey-cli -h 127.0.0.1 -p 6380 INFO keyspace

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

8  $ tail -n +90 /opt/kv-seed/seed_old.py

9  $ ls -la /opt/kv-grader/bin /opt/kv-grader/lib; echo "---"; cat /opt/pip-grader.json /opt/pip-system.json 2>&1; echo "---"; ls -la /opt/kv-seed/__pycache__

10  $ redis-cli -p 6379 dbsize; redis-cli -p 6379 -n 2 dbsize; echo "--- types"; redis-cli -p 6379 --scan --count 1000 | head -50; echo "--- db2"; redis-cli -p 6379 -n 2 --scan | head -20

11  $ python3 -c "import redis, valkey; print(redis.__version__, valkey.__version__)" 2>&1; echo "---"; redis-cli -p 6379 INFO replication; echo "---modules"; redis-cli -p 6379 MODULE LIST; echo "---"; redis-cli -p 6379 CONFIG GET '*' | paste - - | grep -iE 'repl|save|append|dir|dbfilename|requirepass|masterauth|acl'

12  $ cd /opt/kv-seed && python3 -c "
import sys; sys.path.insert(0,'/opt/kv-seed')
import kvdump, json
d = kvdump.dump_server(6379)
print('dbs', {k:len(v) for k,v in d.items()})
print('digest', kvdump.digest(d))
" 2>&1 | tail -5

13  $ redis-cli -p 6379 CONFIG GET databases; valkey-cli -p 6380 CONFIG GET databases; echo "--- valkey replication"; valkey-cli -p 6380 INFO replication | head -8; echo "--- valkey config repl"; valkey-cli -p 6380 CONFIG GET 'repl*' | paste - - | grep -iE 'diskless|replicaof'; echo "--- acl"; valkey-cli -p 6380 ACL LIST; redis-cli -p 6379 ACL LIST

14  $ valkey-cli -p 6380 REPLICAOF 127.0.0.1 6379; sleep 3; echo "--- valkey info repl"; valkey-cli -p 6380 INFO replication | head -20; echo "--- valkey keyspace"; valkey-cli -p 6380 INFO keyspace; echo "--- redis info repl"; redis-cli -p 6379 INFO replication | head -8; echo "--- valkey log"; tail -20 /var/log/valkey/valkey.log

15  $ sleep 8; echo "--- valkey info repl"; valkey-cli -p 6380 INFO replication | head -12; echo "--- valkey keyspace"; valkey-cli -p 6380 INFO keyspace; echo "--- redis"; redis-cli -p 6379 INFO replication | head -5; echo "--- log"; tail -8 /var/log/valkey/valkey.log

16  $ cd /opt/kv-seed && python3 -c "
import sys; sys.path.insert(0,'/opt/kv-seed')
import kvdump, json
old = kvdump.dump_server(6379)
new = kvdump.dump_server(6380)
print('old dbs', {k:len(v) for k,v in old.items()})
print('new dbs', {k:len(v) for k,v in new.items()})
print('old digest', kvdump.digest(old))
print('new digest', kvdump.digest(new))
print('DIGEST MATCH', kvdump.digest(old)==kvdump.digest(new))
# compare TTLs
bad=0
for db in old:
    for k,(t,v,p) in old[db].items():
        nt,nv,np = new[db][k]
        if t!=nt or v!=nv or abs(p-np)>3000:
            bad+=1
            if bad<5: print('MISMATCH', db, k, t, nt, p, np)
print('mismatches', bad)
" 2>&1 | tail -12

17  $ valkey-cli -p 6380 REPLICAOF NO ONE
valkey-cli -p 6380 CONFIG SET replica-read-only no
# keep the migrated data across restarts, like the old server did
valkey-cli -p 6380 CONFIG SET save "3600 1 300 100 60 10000"
valkey-cli -p 6380 BGSAVE
sleep 2
valkey-cli -p 6380 CONFIG REWRITE
echo "--- info repl"; valkey-cli -p 6380 INFO replication | head -6
echo "--- test write"; valkey-cli -p 6380 SET write-test-$$ ok; valkey-cli -p 6380 GET write-test-$$; valkey-cli -p 6380 DEL write-test-$$
echo "--- keyspace"; valkey-cli -p 6380 INFO keyspace
echo "--- config file"; cat /etc/valkey/valkey.conf

18  $ echo "=== OLD server (6379) - must be untouched ==="
redis-cli -p 6379 INFO replication | grep -E 'role|connected_slaves'
redis-cli -p 6379 INFO keyspace
echo "=== NEW server (6380) - standalone primary, writable ==="
valkey-cli -p 6380 INFO replication | grep -E '^role|connected_slaves'
valkey-cli -p 6380 INFO keyspace
echo "=== final digest comparison ==="
cd /opt/kv-seed && python3 -c "
import sys; sys.path.insert(0,'/opt/kv-seed')
import kvdump
print('old', kvdump.digest(kvdump.dump_server(6379)))
print('new', kvdump.digest(kvdump.dump_server(6380)))
" 2>&1 | tail -3
echo "=== processes ==="
ps aux | grep -iE 'redis-server|valkey-server' | grep -v grep | awk '{print $2, $11, $12}'

{
 "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": "7.2.4",
  "server_name": "valkey",
  "valkey_version": "9.1.2"
 },
 "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/ 2>&1; echo "---"; ls -la /opt/valkey* 2>&1; echo "---"; which redis-cli valkey-cli redis-server valkey-server 2>&1

2  $ cat /etc/redis-old/redis.conf 2>&1 | grep -v '^#' | grep -v '^$'; echo "==="; cat /etc/valkey/valkey.conf 2>&1 | grep -v '^#' | grep -v '^$'

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

4  $ redis-cli -p 6379 INFO keyspace 2>&1; echo "==="; redis-cli -p 6380 INFO keyspace 2>&1; echo "==="; redis-cli -p 6379 DBSIZE; redis-cli -p 6379 -n 0 DBSIZE

5  $ redis-cli -p 6379 INFO replication; echo "==="; redis-cli -p 6380 INFO replication; echo "=== types db0 ==="; for t in string list set zset hash stream; do printf "%s: " "$t"; redis-cli -p 6379 --scan --pattern '*' 2>/dev/null >/dev/null; done; redis-cli -p 6379 EVAL "local keys=redis.call('keys','*') local r={} for i,k in ipairs(keys) do local t=redis.call('type',k)['ok'] r[t]=(r[t] or 0)+1 end return cjson.encode(r)" 0

6  $ redis-cli -p 6379 EVAL "local keys=redis.call('keys','*') for i,k in ipairs(keys) do if redis.call('type',k)['ok']=='stream' then local g=redis.call('xinfo','groups',k) local gi=#g local names={} for j=1,gi do names[#names+1]=g[j][2]..':'..g[j][4]..'g:'..g[j][8]..'c' end print(k..' -> '..table.concat(names,',')) end end return 1" 0

7  $ redis-cli -p 6379 ACL LIST; echo "=== functions ==="; redis-cli -p 6379 FUNCTION LIST; echo "=== modules ==="; redis-cli -p 6379 MODULE LIST; echo "=== scripts ==="; redis-cli -p 6379 SCRIPT EXISTS 0000000000000000000000000000000000000000

8  $ redis-cli -p 6379 EVAL "local keys=redis.call('keys','*') local out={} for i,k in ipairs(keys) do if redis.call('type',k)['ok']=='stream' then out[#out+1]=k end end return out" 0

9  $ echo "=== FULL valkey.conf ==="; grep -vE '^\s*#|^\s*$' /etc/valkey/valkey.conf; echo "=== FULL redis-old.conf ==="; grep -vE '^\s*#|^\s*$' /etc/redis-old/redis.conf; echo "=== valkey version ==="; valkey-server --version; redis-server --version

10  $ for s in $(redis-cli -p 6379 --scan --pattern 'events:*'); do echo "=== $s ==="; redis-cli -p 6379 XINFO GROUPS "$s"; done 2>&1 | head -80

11  $ echo "=== sample stream db0 ==="; redis-cli -p 6379 XINFO STREAM events:00; echo "=== purge / del keys? ==="; redis-cli -p 6379 XINFO STREAM events:00 FULL COUNT 5

12  $ which python3 pip3; python3 -c "import redis; print('redis-py', redis.__version__)" 2>&1; python3 -c "import valkey; print('valkey-py', valkey.__version__)" 2>&1; echo "---"; ls /usr/local/bin/; echo "--- gem/others ---"; ls -la /root 2>/dev/null

13  $ cd /tmp; redis-cli -p 6379 set __probe__ hello; redis-cli -p 6379 dump __probe__ > probe.dump; ls -la probe.dump; echo "-- restore to valkey --"; redis-cli -p 6380 restore __probe__ 0 "$(cat probe.dump)"; echo "exit=$?"; redis-cli -p 6380 get __probe__; redis-cli -p 6379 del __probe__; redis-cli -p 6380 del __probe__

14  $ cd /tmp; python3 - <<'EOF'
import redis as R, valkey as V
s = R.Redis(port=6379); t = V.Valkey(port=6380)
s.set('__probe__', 'hello world')
d = s.dump('__probe__')
print("dump bytes:", d[:20].hex(), "len", len(d))
try:
    t.restore('__probe__', 0, d)
    print("restore ok ->", t.get('__probe__'))
except Exception as e:
    print("restore err:", e)
s.delete('__probe__'); t.delete('__probe__')
EOF

15  $ cd /tmp; python3 - <<'EOF'
import redis as R, valkey as V
s = R.Redis(port=6379); t = V.Valkey(port=6380)
# test a stream with groups dump
s.delete('__s__')
s.xadd('__s__', {'a':'1'}, id='1-1')
s.xadd('__s__', {'a':'2'}, id='1-2')
s.xgroup_create('__s__', 'g1', id='0')
s.xreadgroup('g1','c1',{'__s__':'>'},count=1)
d = s.dump('__s__')
print("stream dump len", len(d))
try:
    t.restore('__s__', 0, d)
    print("stream restore ok")
    print(t.xinfo_groups('__s__'))
except Exception as e:
    print("stream restore err:", e)
s.delete('__s__'); t.delete('__s__')
EOF

16  $ cd /tmp; cat > snap.py <<'EOF'
import json, sys, redis, valkey

def client(port):
    if port == 6379:
        return redis.Redis(port=port)
    return valkey.Valkey(port=port)

def type_of(r,k):
    return r.type(k).decode()

def snap_key(r, k):
    t = type_of(r,k)
    ttl = r.pttl(k)
    if t == 'string':
        v = r.get(k)
    elif t == 'list':
        v = r.lrange(k,0,-1)
    elif t == 'set':
        v = sorted(r.smembers(k))
    elif t == 'zset':
        v = r.zrange(k,0,-1,withscores=True)
    elif t == 'hash':
        v = r.hgetall(k)
    elif t == 'stream':
        v = stream_snap(r,k)
    else:
        v = None
    return {'type':t,'ttl':ttl,'value':v}

def stream_snap(r,k):
    info = r.xinfo_stream(k)
    out = {
      'length': info['length'],
      'last-generated-id': info['last-generated-id'].decode(),
      'max-deleted-entry-id': info.get('max-deleted-entry-id',b'0-0').decode(),
      'entries-added': info.get('entries-added'),
      'recorded-first-entry-id': info.get('recorded-first-entry-id',b'0-0').decode(),
      'entries': [(eid.decode(), {kk.decode():vv.decode() for kk,vv in fields.items()}) for eid, fields in r.xrange(k)],
      'groups': [],
    }
    for g in r.xinfo_groups(k):
        gd = {
          'name': g['name'].decode(),
          'last-delivered-id': g['last-delivered-id'].decode(),
          'entries-read': g.get('entries-read'),
          'lag': g.get('lag'),
          'pel-count': g.get('pending'),
          'pending': [],
          'consumers': [],
        }
        # full PEL via XPENDING
        pend = r.xpending_range(k, g['name'], '-', '+', 100000)
        for p in pend:
            gd['pending'].append((p['message_id'].decode(), p['consumer'].decode(), p['times_delivered']))
        gd['pending'].sort()
        for c in r.xinfo_consumers(k, g['name']):
            cd = {
              'name': c['name'].decode(),
              'pel-count': c['pending'],
              'pending': [],
            }
            for p in r.xpending_range(k, g['name'], '-', '+', 100000, consumername=c['name']):
                cd['pending'].append((p['message_id'].decode(), p['times_delivered']))
            cd['pending'].sort()
            gd['consumers'].append(cd)
        gd['consumers'].sort(key=lambda x: x['name'])
        out['groups'].append(gd)
    out['groups'].sort(key=lambda x: x['name'])
    return out

def snapshot(port):
    r = client(port)
    info = r.info('keyspace')
    dbs = sorted(int(k[2:]) for k in info.keys())
    res = {}
    for db in dbs:
        rr = client(port)
        rr.execute_command('SELECT', db)
        keys = sorted(rr.keys('*'))
        res[str(db)] = {k.decode(): snap_key(rr,k) for k in keys}
    return res

if __name__ == '__main__':
    port = int(sys.argv[1]); outp = sys.argv[2]
    s = snapshot(port)
    with open(outp,'w') as f:
        json.dump(s,f,sort_keys=True,indent=1)
    tot = sum(len(v) for v in s.values())
    print(f"port {port}: dbs={list(s.keys())} total_keys={tot}")
EOF
python3 snap.py 6379 /tmp/source_snapshot.json

17  $ cd /tmp; redis-cli -p 6379 config get dir; redis-cli -p 6379 config get repl-diskless-sync; redis-cli -p 6379 config get repl-diskless-sync-delay; redis-cli -p 6380 config get repl-diskless-load; echo "--- target persist config ---"; redis-cli -p 6380 config get save; redis-cli -p 6380 config get appendonly

18  $ cd /tmp; cat > snap.py <<'EOF'
import json, sys, base64, redis, valkey

def client(port):
    if port == 6379:
        return redis.Redis(port=port)
    return valkey.Valkey(port=port)

def norm(o):
    if isinstance(o, bytes):
        return {'b': base64.b64encode(o).decode()}
    if isinstance(o, (list, tuple)):
        return [norm(x) for x in o]
    if isinstance(o, dict):
        return {k: norm(v) for k,v in sorted(o.items())}
    return o

def stream_snap(r,k):
    info = r.xinfo_stream(k)
    out = {
      'length': info['length'],
      'last-generated-id': norm(info['last-generated-id']),
      'max-deleted-entry-id': norm(info.get('max-deleted-entry-id',b'0-0')),
      'entries-added': info.get('entries-added'),
      'recorded-first-entry-id': norm(info.get('recorded-first-entry-id',b'0-0')),
      'entries': [(eid.decode(), {kk.decode():norm(vv) for kk,vv in fields.items()}) for eid, fields in r.xrange(k)],
      'groups': [],
    }
    for g in r.xinfo_groups(k):
        gd = {
          'name': g['name'].decode(),
          'last-delivered-id': norm(g['last-delivered-id']),
          'entries-read': g.get('entries-read'),
          'lag': g.get('lag'),
          'pel-count': g.get('pending'),
          'pending': [],
          'consumers': [],
        }
        for p in r.xpending_range(k, g['name'], '-', '+', 100000):
            gd['pending'].append((p['message_id'].decode(), p['consumer'].decode(), p['times_delivered']))
        gd['pending'].sort()
        for c in r.xinfo_consumers(k, g['name']):
            cd = {'name': c['name'].decode(), 'pel-count': c['pending'], 'pending': []}
            for p in r.xpending_range(k, g['name'], '-', '+', 100000, consumername=c['name']):
                cd['pending'].append((p['message_id'].decode(), p['times_delivered']))
            cd['pending'].sort()
            gd['consumers'].append(cd)
        gd['consumers'].sort(key=lambda x: x['name'])
        out['groups'].append(gd)
    out['groups'].sort(key=lambda x: x['name'])
    return out

def snap_key(r, k):
    t = r.type(k).decode()
    ttl = r.pttl(k)
    if t == 'string':
        v = norm(r.get(k))
    elif t == 'list':
        v = norm(r.lrange(k,0,-1))
    elif t == 'set':
        v = sorted(norm(x)['b'] for x in r.smembers(k))
    elif t == 'zset':
        v = [(norm(m)['b'], s) for m,s in r.zrange(k,0,-1,withscores=True)]
    elif t == 'hash':
        v = {kk.decode():norm(vv) for kk,vv in r.hgetall(k).items()}
    elif t == 'stream':
        v = stream_snap(r,k)
    else:
        v = None
    return {'type':t,'ttl':ttl,'value':v}

def snapshot(port):
    r = client(port)
    info = r.info('keyspace')
    dbs = sorted(int(k[2:]) for k in info.keys())
    res = {}
    for db in dbs:
        rr = client(port)
        rr.execute_command('SELECT', db)
        keys = sorted(rr.keys('*'))
        res[str(db)] = {k.decode(): snap_key(rr,k) for k in keys}
    return res

if __name__ == '__main__':
    port = int(sys.argv[1]); outp = sys.argv[2]
    s = snapshot(port)
    with open(outp,'w') as f:
        json.dump(s,f,sort_keys=True,indent=1)
    tot = sum(len(v) for v in s.values())
    print(f"port {port}: dbs={list(s.keys())} total_keys={tot}")
EOF
python3 snap.py 6379 /tmp/source_snapshot.json && ls -la /tmp/source_snapshot.json

19  $ redis-cli -p 6380 REPLICAOF 127.0.0.1 6379; echo "exit=$?"; sleep 3; echo "--- target repl ---"; redis-cli -p 6380 INFO replication; echo "--- source repl ---"; redis-cli -p 6379 INFO replication

20  $ for i in $(seq 1 30); do st=$(redis-cli -p 6380 INFO replication | grep master_link_status | tr -d '\r'); echo "[$i] $st"; if echo "$st" | grep -q up; then break; fi; sleep 1; done; echo "=== target keyspace ==="; redis-cli -p 6380 INFO keyspace; echo "=== target dbsize db0 ==="; redis-cli -p 6380 -n 0 DBSIZE; redis-cli -p 6380 -n 2 DBSIZE

21  $ cd /tmp; python3 snap.py 6380 /tmp/target_snapshot.json; python3 - <<'EOF'
import json
s=json.load(open('/tmp/source_snapshot.json'))
t=json.load(open('/tmp/target_snapshot.json'))
print("dbs source:", list(s.keys()), "target:", list(t.keys()))
diffs=0
for db in s:
    sk=set(s[db]); tk=set(t.get(db,{}))
    if sk!=tk:
        print(f"db {db}: key set differs; only-src={len(sk-tk)} only-tgt={len(tk-sk)}")
        print("  sample only-src:", list(sk-tk)[:5])
        print("  sample only-tgt:", list(tk-sk)[:5])
        diffs+=1
    for k in sk & tk:
        if s[db][k]!=t[db].get(k):
            diffs+=1
            if diffs<10:
                print(f"db {db} key {k}: differs")
                print("  src type/ttl:", s[db][k]['type'], s[db][k]['ttl'])
                print("  tgt type/ttl:", t[db][k]['type'], t[db][k]['ttl'])
print("total diffs:", diffs)
EOF

22  $ cd /tmp; python3 - <<'EOF'
import json
s=json.load(open('/tmp/source_snapshot.json'))
t=json.load(open('/tmp/target_snapshot.json'))
val_diffs=0; ttl_diffs=0; ttl_deltas=[]
for db in s:
    for k in s[db]:
        a=s[db][k]; b=t[db][k]
        if a['type']!=b['type'] or a['value']!=b['value']:
            val_diffs+=1
            if val_diffs<=5: print("VALUE DIFF", db, k, a['type'], b['type'])
        if a['ttl']!=b['ttl']:
            ttl_diffs+=1
            ttl_deltas.append(a['ttl']-b['ttl'])
print("value/type diffs:", val_diffs)
print("ttl diffs:", ttl_diffs)
if ttl_deltas:
    print("ttl delta min/max:", min(ttl_deltas), max(ttl_deltas))
# streams detail
for db in s:
    for k in s[db]:
        if s[db][k]['type']=='stream':
            if s[db][k]['value']!=t[db][k]['value']:
                print("STREAM DIFF", db,k)
print("stream comparison done")
EOF

23  $ cd /tmp; python3 - <<'EOF'
import redis, valkey, time, random
s=redis.Redis(port=6379); t=valkey.Valkey(port=6380)
ks=[k for k in s.keys('*') if s.pttl(k)>0]
random.shuffle(ks); ks=ks[:200]
maxd=0; bad=0
for k in ks:
    a=s.pttl(k); b=t.pttl(k)
    d=abs(a-b)
    maxd=max(maxd,d)
    if d>200: bad+=1
print(f"sampled {len(ks)} volatile keys; max |pttl_src-pttl_tgt| = {maxd} ms; keys off by >200ms: {bad}")
# also count volatile keys per db
for db in (0,2):
    ss=redis.Redis(port=6379,db=db); tt=valkey.Valkey(port=6380,db=db)
    sk=set(ss.keys('*')); tk=set(tt.keys('*'))
    print(f"db{db}: src={len(sk)} tgt={len(tk)} keyset_equal={sk==tk}")
EOF

24  $ redis-cli -p 6380 REPLICAOF NO ONE; echo "exit=$?"; sleep 1; echo "=== target replication ==="; redis-cli -p 6380 INFO replication | head -8; echo "=== write test ==="; redis-cli -p 6380 SET __write_test__ ok; redis-cli -p 6380 GET __write_test__; redis-cli -p 6380 DEL __write_test__; echo "=== source unchanged? ==="; redis-cli -p 6379 INFO replication | head -4; redis-cli -p 6379 DBSIZE

25  $ echo "=== valkey.conf now ==="; grep -vE '^\s*#|^\s*$' /etc/valkey/valkey.conf; echo "=== target save/appendonly ==="; redis-cli -p 6380 CONFIG GET save; redis-cli -p 6380 CONFIG GET appendonly; redis-cli -p 6380 CONFIG GET dir; echo "=== target dbdir ==="; ls -la /var/lib/valkey/ 2>&1 | head

26  $ cd /tmp; python3 - <<'EOF'
import json, redis, valkey
import snap as S
snap_t = S.snapshot(6380)
src = json.load(open('/tmp/source_snapshot.json'))
# compare values ignoring ttl
vdiff=0; groups_ok=True
for db in src:
    for k in src[db]:
        a=src[db][k]; b=snap_t[db][k]
        if a['type']!=b['type'] or a['value']!=b['value']:
            vdiff+=1
            if vdiff<=10: print("DIFF", db,k,a['type'])
print("value/type diffs after promotion:", vdiff)
# extra keys on target?
for db in snap_t:
    extra=set(snap_t[db])-set(src.get(db,{}))
    if extra: print("extra keys db",db,list(extra)[:5])
print("done")
EOF

27  $ cd /tmp; python3 - <<'EOF'
import json, redis, valkey
src=json.load(open('/tmp/source_snapshot.json'))['0']['events:00']['value']
tgt=redis_=None
import snap as S
tgt=S.snapshot(6380)['0']['events:00']['value']
for field in src:
    if src[field]!=tgt[field]:
        print("FIELD DIFF:", field)
        print("  src:", json.dumps(src[field])[:300])
        print("  tgt:", json.dumps(tgt[field])[:300])
EOF

28  $ cd /tmp; python3 - <<'EOF'
import json
import snap as S
src=json.load(open('/tmp/source_snapshot.json'))
tgt=json.loads(json.dumps(S.snapshot(6380)))  # normalize both to JSON types
vdiff=0; ttl=[]
for db in src:
    tk=set(tgt.get(db,{})); sk=set(src[db])
    if sk!=tk: print("KEYSET DIFF db",db, len(sk-tk), len(tk-sk))
    for k in sk:
        a=src[db][k]; b=tgt[db][k]
        if a['type']!=b['type'] or a['value']!=b['value']:
            vdiff+=1
            if vdiff<=8: print("VALUE DIFF",db,k)
        ttl.append(a['ttl']-b['ttl'])
print("value/type diffs:", vdiff)
print("ttl delta min/max:", min(ttl), max(ttl))
# explicit stream group check
for db in src:
    for k in src[db]:
        if src[db][k]['type']=='stream':
            g1=[(g['name'],g['last-delivered-id'],g['entries-read'],g['lag'],g['pel-count'],g['pending']) for g in src[db][k]['value']['groups']]
            g2=[(g['name'],g['last-delivered-id'],g['entries-read'],g['lag'],g['pel-count'],g['pending']) for g in tgt[db][k]['value']['groups']]
            if g1!=g2: print("GROUP DIFF", db, k)
print("stream group check complete")
EOF

29  $ cd /tmp; python3 - <<'EOF'
import redis, valkey, random
s=redis.Redis(port=6379); t=valkey.Valkey(port=6380)
ks=[k for k in s.keys('*') if s.pttl(k)>0]
random.shuffle(ks); ks=ks[:300]
maxd=0; bad=0
for k in ks:
    d=abs(s.pttl(k)-t.pttl(k)); maxd=max(maxd,d)
    if d>200: bad+=1
print(f"sampled {len(ks)} volatile keys; max |pttl diff| = {maxd} ms; >200ms: {bad}")
# consumers check
c1=s.xinfo_consumers('events:00','workers'); c2=t.xinfo_consumers('events:00','workers')
print("consumers src:", [(c['name'],c['pending']) for c in c1])
print("consumers tgt:", [(c['name'],c['pending']) for c in c2])
EOF

30  $ redis-cli -p 6380 BGSAVE; sleep 2; echo "=== final target state ==="; redis-cli -p 6380 INFO keyspace; redis-cli -p 6380 INFO replication | head -3; echo "=== lastsave ==="; redis-cli -p 6380 LASTSAVE; echo "=== source still intact ==="; redis-cli -p 6379 INFO keyspace; redis-cli -p 6379 INFO replication | head -3; echo "=== config file clean (no replicaof) ==="; grep -i replicaof /etc/valkey/valkey.conf || echo "(no replicaof in config - good)"

31  $ rm -f /tmp/probe.dump /tmp/source_snapshot.json /tmp/target_snapshot.json /tmp/snap.py /tmp/__pycache__ -r; ls /tmp; echo "cleanup 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": "7.2.4",
  "server_name": "valkey",
  "valkey_version": "9.1.2"
 },
 "old_digest_ok": true,
 "old_server": {
  "redis_version": "7.2.16",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

1  $ ps aux | grep -E "[r]edis-|[v]alkey-"; echo "=== binaries ==="; ls -la /opt/redis-7.2/bin/ 2>&1; ls -la /etc/redis-old/ 2>&1; ls -la /etc/valkey/ 2>&1; echo "=== which ==="; command -v redis-cli valkey-cli redis-server valkey-server python3; echo "=== versions ==="; redis-cli --version 2>&1; valkey-cli --version 2>&1; python3 --version 2>&1

2  $ cat /etc/valkey/valkey.conf

3  $ echo "--- PING 6379 ---"; redis-cli -p 6379 PING; echo "--- INFO server ---"; redis-cli -p 6379 INFO server | grep -E "redis_version|process_id|tcp_port|config_file|uptime"; echo "--- INFO keyspace ---"; redis-cli -p 6379 INFO keyspace; echo "--- INFO modules ---"; redis-cli -p 6379 INFO modules; echo "--- databases ---"; redis-cli -p 6379 CONFIG GET databases; echo "--- replication ---"; redis-cli -p 6379 INFO replication | head -15

4  $ echo "--- PING 6380 ---"; valkey-cli -p 6380 PING; echo "--- INFO server ---"; valkey-cli -p 6380 INFO server | grep -E "valkey_version|redis_version|process_id|tcp_port|config_file|uptime"; echo "--- INFO keyspace ---"; valkey-cli -p 6380 INFO keyspace; echo "--- databases ---"; valkey-cli -p 6380 CONFIG GET databases; echo "--- replicaof ---"; valkey-cli -p 6380 CONFIG GET replicaof; echo "--- cluster ---"; valkey-cli -p 6380 CONFIG GET cluster-enabled

5  $ cat /etc/redis-old/redis.conf; echo "=== PATH clis ==="; ls -la /usr/local/bin/redis-cli /usr/local/bin/valkey-cli /usr/local/bin/valkey-server; echo "=== bundled cli version ==="; /opt/redis-7.2/bin/redis-cli --version; /opt/redis-7.2/bin/redis-server --version

6  $ for db in 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15; do n=$(/usr/local/bin/valkey-cli -p 6379 -n $db DBSIZE); [ "$n" != "0" ] && echo "old db$db: $n keys"; done; echo "=== type distribution ==="; /usr/local/bin/valkey-cli -p 6379 --scan | while read k; do /usr/local/bin/valkey-cli -p 6379 TYPE "$k"; done | sort | uniq -c; echo "=== dbsize per db on new ==="; /usr/local/bin/valkey-cli -p 6380 INFO keyspace

7  $ echo "--- functions ---"; redis-cli -p 6379 FUNCTION LIST; echo "--- script cache/eval ---"; redis-cli -p 6379 INFO clients | grep -E "blocked|connected"; echo "--- maxmemory-policy old ---"; redis-cli -p 6379 CONFIG GET maxmemory-policy maxmemory; echo "--- maxmemory-policy new ---"; valkey-cli -p 6380 CONFIG GET maxmemory-policy maxmemory; echo "--- appendonly old ---"; redis-cli -p 6379 CONFIG GET appendonly appendfilename; echo "--- big keys ---"; redis-cli -p 6379 --bigkeys 2>&1 | tail -20

8  $ echo "--- stream sample ---"; for k in $(redis-cli -p 6379 --scan --pattern '*' | head -0; redis-cli -p 6379 --scan | while read k; do t=$(redis-cli -p 6379 TYPE "$k"); [ "$t" = "stream" ] && echo "$k"; done | head -3); do echo "== $k =="; redis-cli -p 6379 XINFO STREAM "$k"; echo "-- groups --"; redis-cli -p 6379 XINFO GROUPS "$k"; echo "-- consumers --"; for g in $(redis-cli -p 6379 XINFO GROUPS "$k" | grep -A1 name | tail -1); do redis-cli -p 6379 XINFO CONSUMERS "$k" "$g"; done; done 2>&1 | head -80

9  $ python3 -c "import socket; print('socket ok')"; ls /tmp; df -h /tmp | tail -1; free -m | head -2

10  $ echo "--- changes since save / db sizes (3 samples, 2s apart) ---"; for i in 1 2 3; do echo "t$i: dbsize0=$(redis-cli -p 6379 -n 0 DBSIZE) dbsize2=$(redis-cli -p 6379 -n 2 DBSIZE) changes=$(redis-cli -p 6379 INFO persistence | grep rdb_changes)"; sleep 2; done; echo "--- role of 6380 ---"; valkey-cli -p 6380 INFO replication | head -5

11  $ echo "--- DUMP/RESTORE compatibility test (single key, db0) ---"; K=$(redis-cli -p 6379 -n 0 --scan | head -1); echo "key: $K"; redis-cli -p 6379 -n 0 DUMP "$K" > /tmp/dump.bin; echo "dump size: $(stat -c%s /tmp/dump.bin)"; valkey-cli -p 6380 -n 0 RESTORE "__compat_test__" 0 "$(cat /tmp/dump.bin)" && echo "RESTORE OK"; valkey-cli -p 6380 -n 0 DUMP "__compat_test__" > /tmp/dump2.bin; cmp /tmp/dump.bin /tmp/dump2.bin && echo "DUMPS IDENTICAL" || echo "dumps differ (byte-compare)"; valkey-cli -p 6380 -n 0 DEL "__compat_test__"

12  $ python3 - <<'EOF'
import socket

class RC:
    def __init__(self, port, db=0):
        self.s = socket.create_connection(('127.0.0.1', port))
        self.s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
        self.f = self.s.makefile('rb')
        if db: self.cmd('SELECT', db)
    def cmd(self, *args):
        out = [b'*%d\r\n' % len(args)]
        for a in args:
            if isinstance(a, int): a = str(a).encode()
            elif isinstance(a, str): a = a.encode()
            out.append(b'$%d\r\n%s\r\n' % (len(a), a))
        self.s.sendall(b''.join(out))
        return self.read()
    def read(self):
        line = self.f.readline()
        t, d = line[:1], line[1:-2]
        if t == b'+': return d.decode()
        if t == b'-': return ('ERR', d.decode())
        if t == b':': return int(d)
        if t == b'$':
            n = int(d)
            if n == -1: return None
            return self.f.read(n + 2)[:-2]
        if t == b'*':
            n = int(d)
            if n == -1: return None
            return [self.read() for _ in range(n)]
        raise Exception('bad resp %r' % line)

src = RC(6379, 0); dst = RC(6380, 15)

# 1) DUMP source stream with a group + PEL, restore into scratch db15 on target
payload = src.cmd('DUMP', 'events:07')
print('dump size:', len(payload))
print('RESTORE probe:', dst.cmd('RESTORE', 'probe:stream', 0, payload, 'REPLACE'))
print('TYPE probe:', dst.cmd('TYPE', 'probe:stream'))
print('dst DUMP identical:', dst.cmd('DUMP', 'probe:stream') == payload)

print('--- src XINFO STREAM events:07 ---')
r = src.cmd('XINFO', 'STREAM', 'events:07'); print(r)
print('--- src XINFO GROUPS ---')
g = src.cmd('XINFO', 'GROUPS', 'events:07'); print(g)
print('--- dst XINFO GROUPS (did groups ride along in DUMP?) ---')
print(dst.cmd('XINFO', 'GROUPS', 'probe:stream'))
print('--- src XPENDING extended ---')
print(src.cmd('XPENDING', 'events:07', 'workers', '-', '+', 100))
print('--- dst XPENDING extended ---')
print(dst.cmd('XPENDING', 'probe:stream', 'workers', '-', '+', 100))

# 2) subcommand availability on target
print('CMDINFO CREATECONSUMER:', dst.cmd('COMMAND', 'INFO', 'XGROUP|CREATECONSUMER'))
print('CMDINFO SETID:', dst.cmd('COMMAND', 'INFO', 'XGROUP|SETID'))
EOF

13  $ python3 - <<'EOF'
import socket

class RC:
    def __init__(self, port, db=0):
        self.s = socket.create_connection(('127.0.0.1', port))
        self.s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
        self.f = self.s.makefile('rb')
        if db: self.cmd('SELECT', db)
    def cmd(self, *args):
        out = [b'*%d\r\n' % len(args)]
        for a in args:
            if isinstance(a, int): a = str(a).encode()
            elif isinstance(a, str): a = a.encode()
            out.append(b'$%d\r\n%s\r\n' % (len(a), a))
        self.s.sendall(b''.join(out))
        return self.read()
    def read(self):
        line = self.f.readline()
        t, d = line[:1], line[1:-2]
        if t == b'+': return d.decode()
        if t == b'-': return ('ERR', d.decode())
        if t == b':': return int(d)
        if t == b'$':
            n = int(d)
            if n == -1: return None
            return self.f.read(n + 2)[:-2]
        if t == b'*':
            n = int(d)
            if n == -1: return None
            return [self.read() for _ in range(n)]
        raise Exception('bad resp %r' % line)

src = RC(6379, 0); dst = RC(6380, 15)

# --- where do the two stream dumps differ? ---
a = src.cmd('DUMP', 'events:07')
b = dst.cmd('DUMP', 'probe:stream')
print('src len', len(a), 'dst len', len(b), 'first bytes src', a[:8].hex(), 'dst', b[:8].hex())
diffs = [i for i in range(min(len(a), len(b))) if a[i] != b[i]]
print('num differing byte positions:', len(diffs), 'first few:', diffs[:10])
if len(a) != len(b):
    print('length differs; compare common prefix...')
    print('tail src:', a[-20:].hex()); print('tail dst:', b[-20:].hex())

# --- per-consumer state: src vs dst probe ---
print('--- src XINFO CONSUMERS events:07 workers ---')
print(src.cmd('XINFO', 'CONSUMERS', 'events:07', 'workers'))
print('--- dst XINFO CONSUMERS probe:stream workers ---')
print(dst.cmd('XINFO', 'CONSUMERS', 'probe:stream', 'workers'))
EOF

14  $ python3 - <<'EOF'
import socket

class RC:
    def __init__(self, port, db=0):
        self.s = socket.create_connection(('127.0.0.1', port))
        self.s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
        self.f = self.s.makefile('rb')
        if db: self.cmd('SELECT', db)
    def cmd(self, *args):
        out = [b'*%d\r\n' % len(args)]
        for a in args:
            if isinstance(a, int): a = str(a).encode()
            elif isinstance(a, str): a = a.encode()
            out.append(b'$%d\r\n%s\r\n' % (len(a), a))
        self.s.sendall(b''.join(out))
        return self.read()
    def read(self):
        line = self.f.readline()
        t, d = line[:1], line[1:-2]
        if t == b'+': return d.decode()
        if t == b'-': return ('ERR', d.decode())
        if t == b':': return int(d)
        if t == b'$':
            n = int(d)
            if n == -1: return None
            return self.f.read(n + 2)[:-2]
        if t == b'*':
            n = int(d)
            if n == -1: return None
            return [self.read() for _ in range(n)]
        raise Exception('bad resp %r' % line)

src = RC(6379, 0); dst = RC(6380, 15)

# round-trip one sample key of each non-stream type; compare dumps + encoding
for t in ['string','hash','list','set','zset']:
    keys = []
    # find one key of this type
    cur='0'
    while True:
        r = src.cmd('SCAN', cur, 'COUNT', 500)
        cur = r[0]
        for k in r[1]:
            if src.cmd('TYPE', k) == t:
                keys.append(k); break
        if keys or cur == b'0': break
    k = keys[0]
    p = src.cmd('DUMP', k)
    dst.cmd('RESTORE', 'probe:'+t, 0, p, 'REPLACE')
    q = dst.cmd('DUMP', 'probe:'+t)
    enc_s = src.cmd('OBJECT','ENCODING',k); enc_d = dst.cmd('OBJECT','ENCODING','probe:'+t)
    print(f'{t}: key={k!r} srcenc={enc_s} dstenc={enc_d} identical={p==q} srclen={len(p)} dstlen={len(q)}')

# RESTORE ABSTTL edge cases on dst
p = src.cmd('DUMP', 'session:01568')
print('past ABSTTL:', dst.cmd('RESTORE','probe:absttl', 1000, p, 'REPLACE', 'ABSTTL'))  # 1970 -> past
print('dst TYPE:', dst.cmd('TYPE','probe:absttl'))
import time
now = int(src.cmd('TIME')[0])*1000 + int(src.cmd('TIME')[1])//1000
print('future ABSTTL:', dst.cmd('RESTORE','probe:absttl2', now+60000, p, 'REPLACE', 'ABSTTL'))
print('PTTL:', dst.cmd('PTTL','probe:absttl2'))
EOF

15  $ redis-cli -p 6379 COMMAND INFO HEXPIRE HEXGET HEXTRIES 2>&1 | head -5; echo "---"; redis-cli -p 6379 COMMAND COUNT | head -1; redis-cli -p 6379 CONFIG GET save; echo "--- src protected/mode ---"; redis-cli -p 6379 CONFIG GET maxmemory-policy; echo "--- check dst write-ability config ---"; valkey-cli -p 6380 CONFIG GET min-replicas-to-write min-replicas-max-lag replica-read-only

16  $ python3 - <<'EOF'
import socket

class RC:
    def __init__(self, port, db=0):
        self.s = socket.create_connection(('127.0.0.1', port))
        self.f = self.s.makefile('rb')
        if db: self.cmd('SELECT', db)
    def cmd(self, *args):
        out = [b'*%d\r\n' % len(args)]
        for a in args:
            if isinstance(a, int): a = str(a).encode()
            elif isinstance(a, str): a = a.encode()
            out.append(b'$%d\r\n%s\r\n' % (len(a), a))
        self.s.sendall(b''.join(out))
        return self.read()
    def read(self):
        line = self.f.readline()
        t, d = line[:1], line[1:-2]
        if t == b'+': return d.decode()
        if t == b'-': return ('ERR', d.decode())
        if t == b':': return int(d)
        if t == b'$':
            n = int(d)
            if n == -1: return None
            return self.f.read(n + 2)[:-2]
        if t == b'*':
            n = int(d)
            if n == -1: return None
            return [self.read() for _ in range(n)]
        raise Exception('bad resp %r' % line)

src = RC(6379, 0); dst = RC(6380, 15)

# 1) string: diff positions & tail hex
a = src.cmd('DUMP', 'session:01568')
b = dst.cmd('DUMP', 'probe:string')
print('string diff positions:', [i for i in range(min(len(a),len(b))) if a[i]!=b[i]], 'lens', len(a), len(b))
print('src tail[-30:]:', a[-30:].hex())
print('dst tail[-30:]:', b[-30:].hex())
print('src OBJECT IDLETIME:', src.cmd('OBJECT','IDLETIME','session:01568'))

# 2) restore with IDLETIME + ABSTTL combined, verify
import time
t = src.cmd('TIME'); now_ms = int(t[0])*1000 + int(t[1])//1000
idle = src.cmd('OBJECT','IDLETIME','session:01568')
r = dst.cmd('RESTORE','probe:idle', now_ms+120000, a, 'REPLACE','ABSTTL','IDLETIME', int(idle))
print('RESTORE ABSTTL+IDLETIME:', r, '| dst PTTL:', dst.cmd('PTTL','probe:idle'), '| dst IDLETIME:', dst.cmd('OBJECT','IDLETIME','probe:idle'))

# 3) confirm stream diff is ctime + checksum: show tail around byte 1385-1401
a2 = src.cmd('DUMP','events:07'); b2 = dst.cmd('DUMP','probe:stream')
print('stream src bytes[1380:1401]:', a2[1380:1401].hex())
print('stream dst bytes[1380:1401]:', b2[1380:1401].hex())
EOF

17  $ python3 - <<'EOF'
import socket

class RC:
    def __init__(self, port, db=0):
        self.s = socket.create_connection(('127.0.0.1', port))
        self.f = self.s.makefile('rb')
        if db: self.cmd('SELECT', db)
    def cmd(self, *args):
        out = [b'*%d\r\n' % len(args)]
        for a in args:
            if isinstance(a, int): a = str(a).encode()
            elif isinstance(a, str): a = a.encode()
            out.append(b'$%d\r\n%s\r\n' % (len(a), a))
        self.s.sendall(b''.join(out))
        return self.read()
    def read(self):
        line = self.f.readline()
        t, d = line[:1], line[1:-2]
        if t == b'+': return d.decode()
        if t == b'-': return ('ERR', d.decode())
        if t == b':': return int(d)
        if t == b'$':
            n = int(d)
            if n == -1: return None
            return self.f.read(n + 2)[:-2]
        if t == b'*':
            n = int(d)
            if n == -1: return None
            return [self.read() for _ in range(n)]
        raise Exception('bad resp %r' % line)

src = RC(6379, 0); dst = RC(6380, 15)
p = src.cmd('DUMP', 'session:01568')

# Experiment: what does each server's encoder put in the trailer for various idle times?
for idle in [None, 0, 1, 12345, 9999999]:
    if idle is None:
        dst.cmd('RESTORE','p:t','0',p,'REPLACE'); tag='plain'
    else:
        dst.cmd('RESTORE','p:t','0',p,'REPLACE','IDLETIME',idle); tag='idle=%d'%idle
    q = dst.cmd('DUMP','p:t')
    print('dst %-12s len=%d trailer[-10:]=%s matches_src=%s' % (tag, len(q), q[-10:].hex(), q==p))
for idle in [None, 0, 12345]:
    if idle is None:
        src.cmd('RESTORE','p:t','0',p,'REPLACE'); tag='plain'
    else:
        src.cmd('RESTORE','p:t','0',p,'REPLACE','IDLETIME',idle); tag='idle=%d'%idle
    q = src.cmd('DUMP','p:t')
    print('src %-12s len=%d trailer[-10:]=%s matches_orig=%s' % (tag, len(q), q[-10:].hex(), q==p))
src.cmd('DEL','p:t'); dst.cmd('DEL','p:t')
EOF

18  $ cd /tmp && (curl -sL --max-time 25 -o rdb81.c https://raw.githubusercontent.com/valkey-io/valkey/8.1/src/rdb.c && wc -l rdb81.c) ; (curl -sL --max-time 25 -o rdb81.h https://raw.githubusercontent.com/valkey-io/valkey/8.1/src/rdb.h && wc -l rdb81.h); grep -n "RDB_OPCODE" rdb81.h | head -30

19  $ python3 - <<'EOF'
import socket

class RC:
    def __init__(self, port, db=0):
        self.s = socket.create_connection(('127.0.0.1', port))
        self.f = self.s.makefile('rb')
        if db: self.cmd('SELECT', db)
    def cmd(self, *args):
        out = [b'*%d\r\n' % len(args)]
        for a in args:
            if isinstance(a, int): a = str(a).encode()
            elif isinstance(a, str): a = a.encode()
            out.append(b'$%d\r\n%s\r\n' % (len(a), a))
        self.s.sendall(b''.join(out))
        return self.read()
    def read(self):
        line = self.f.readline()
        t, d = line[:1], line[1:-2]
        if t == b'+': return d.decode()
        if t == b'-': return ('ERR', d.decode())
        if t == b':': return int(d)
        if t == b'$':
            n = int(d)
            if n == -1: return None
            return self.f.read(n + 2)[:-2]
        if t == b'*':
            n = int(d)
            if n == -1: return None
            return [self.read() for _ in range(n)]
        raise Exception('bad resp %r' % line)

src = RC(6379, 0); dst = RC(6380, 15)

# clean up probe keys in db15
deleted = dst.cmd('DEL', b'probe:stream', b'probe:string', b'probe:hash', b'probe:list', b'probe:set',
                  b'probe:zset', b'probe:absttl', b'probe:absttl2', b'probe:idle')
print('cleaned probe keys:', deleted)
print('db15 dbsize now:', dst.cmd('DBSIZE'))

# Does RESTORE accept a nonzero ABSTTL for a stream key?
payload = src.cmd('DUMP', 'events:11')  # stream without groups
t = src.cmd('TIME'); now = int(t[0])*1000 + int(t[1])//1000
r = dst.cmd('RESTORE', 'probe:stttl', now + 300000, payload, 'REPLACE', 'ABSTTL')
print('stream RESTORE with ABSTTL ->', r)
if r == 'OK':
    print('  dst PTTL:', dst.cmd('PTTL', 'probe:stttl'), ' TYPE:', dst.cmd('TYPE', 'probe:stttl'))
    dst.cmd('DEL', 'probe:stttl')
# and relative ttl for stream?
r = dst.cmd('RESTORE', 'probe:stttl2', 300000, payload, 'REPLACE')
print('stream RESTORE with relative ttl ->', r)
if r == 'OK':
    print('  dst PTTL:', dst.cmd('PTTL', 'probe:stttl2'))
    dst.cmd('DEL', 'probe:stttl2')

# auth / ACL on both
print('src requirepass:', src.cmd('CONFIG', 'GET', 'requirepass'))
d0 = RC(6380, 0)
print('dst requirepass:', d0.cmd('CONFIG', 'GET', 'requirepass'))
print('src role:', src.cmd('INFO', 'replication').split(b'\r\n')[0:3])
print('dst dbs across 0..15 (should be empty):', [d0.cmd('SELECT', i) or d0.cmd('DBSIZE') for i in range(16)])
EOF

20  $ cat > /tmp/migrate.py <<'EOF'
#!/usr/bin/env python3
"""One-shot copy of all data Redis(6379) -> Valkey(6380).
DUMP/RESTORE based (payload includes stream consumer-group state);
source keys are never touched. Restores use ABSTTL + IDLETIME."""
import socket, sys, time

SRC, DST = 6379, 6380
BATCH = 100

class RC:
    def __init__(self, port, db=0):
        self.s = socket.create_connection(('127.0.0.1', port))
        self.s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
        self.f = self.s.makefile('rb')
        if db: self.cmd('SELECT', db)
    def _send(self, args):
        out = [b'*%d\r\n' % len(args)]
        for a in args:
            if isinstance(a, int): a = str(a).encode()
            elif isinstance(a, str): a = a.encode()
            out.append(b'$%d\r\n%s\r\n' % (len(a), a))
        self.s.sendall(b''.join(out))
    def read(self):
        line = self.f.readline()
        t, d = line[:1], line[1:-2]
        if t == b'+': return d.decode()
        if t == b'-': return ('ERR', d.decode())
        if t == b':': return int(d)
        if t == b'$':
            n = int(d)
            if n == -1: return None
            return self.f.read(n + 2)[:-2]
        if t == b'*':
            n = int(d)
            if n == -1: return None
            return [self.read() for _ in range(n)]
        raise Exception('bad resp %r' % line)
    def cmd(self, *args):
        self._send(args); return self.read()
    def pipeline(self, cmds):
        for c in cmds: self._send(c)
        return [self.read() for _ in cmds]

def now_ms(c):
    t = c.cmd('TIME')
    return int(t[0]) * 1000 + int(t[1]) // 1000

def scan_keys(c):
    cur, keys = b'0', []
    while True:
        r = c.cmd('SCAN', cur, 'COUNT', 1000)
        cur = r[0]; keys.extend(r[1])
        if cur == b'0': break
    return keys

migrated = skipped = failed = 0
t_start = time.time()

# discover active dbs on the source
active = []
probe = RC(SRC, 0)
for db in range(16):
    if (probe.cmd('SELECT', db) == 'OK') and probe.cmd('DBSIZE') > 0:
        active.append(db)
print('source dbs with keys:', active)

for db in active:
    src = RC(SRC, db); dst = RC(DST, db)
    keys = scan_keys(src)
    print(f'db{db}: {len(keys)} keys to copy')
    for i in range(0, len(keys), BATCH):
        chunk = keys[i:i+BATCH]
        # pipeline DUMP + PTTL + OBJECT IDLETIME for the whole chunk
        raw = src.pipeline([['DUMP', k] for k in chunk] +
                           [['PTTL', k] for k in chunk] +
                           [['OBJECT', 'IDLETIME', k] for k in chunk])
        n = len(chunk)
        dumps, pttls, idles = raw[0:n], raw[n:2*n], raw[2*n:3*n]
        base = now_ms(src)
        restores, meta = [], []
        for k, d, pttl, idle in zip(chunk, dumps, pttls, idles):
            if isinstance(d, tuple) or d is None:   # raced expiry / error
                skipped += 1
                print('  SKIP (no payload):', k, d if isinstance(d, tuple) else '')
                continue
            expiry = base + pttl if pttl > 0 else 0
            args = ['RESTORE', k, expiry, d, 'REPLACE', 'ABSTTL']
            if idle > 0: args += ['IDLETIME', idle]
            restores.append(args); meta.append((k, d))
        replies = dst.pipeline(restores)
        for (k, d), r in zip(meta, replies):
            if r == 'OK':
                migrated += 1
            else:
                failed += 1
                print('  FAIL:', k, r)

print(f'done in {time.time()-t_start:.1f}s | restored={migrated} skipped={skipped} failed={failed}')
sys.exit(1 if (failed or skipped) else 0)
EOF
echo "--- src dbsize before ---"; redis-cli -p 6379 -n 0 DBSIZE; redis-cli -p 6379 -n 2 DBSIZE
python3 /tmp/migrate.py
echo "exit=$?"
echo "--- src dbsize after (must be unchanged) ---"; redis-cli -p 6379 -n 0 DBSIZE; redis-cli -p 6379 -n 2 DBSIZE
echo "--- dst keyspace ---"; valkey-cli -p 6380 INFO keyspace

21  $ cat > /tmp/verify.py <<'EOF'
#!/usr/bin/env python3
"""Verify Valkey(6380) is an exact copy of Redis(6379)."""
import socket

SRC, DST = 6379, 6380
TTL_TOL = 3000      # ms tolerance for TTL comparison
IDLE_TOL = 5000     # ms tolerance for LRU idletime

class RC:
    def __init__(self, port, db=0):
        self.s = socket.create_connection(('127.0.0.1', port))
        self.s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
        self.f = self.s.makefile('rb')
        if db: self.cmd('SELECT', db)
    def _send(self, args):
        out = [b'*%d\r\n' % len(args)]
        for a in args:
            if isinstance(a, int): a = str(a).encode()
            elif isinstance(a, str): a = a.encode()
            out.append(b'$%d\r\n%s\r\n' % (len(a), a))
        self.s.sendall(b''.join(out))
    def read(self):
        line = self.f.readline()
        t, d = line[:1], line[1:-2]
        if t == b'+': return d.decode()
        if t == b'-': return ('ERR', d.decode())
        if t == b':': return int(d)
        if t == b'$':
            n = int(d)
            if n == -1: return None
            return self.f.read(n + 2)[:-2]
        if t == b'*':
            n = int(d)
            if n == -1: return None
            return [self.read() for _ in range(n)]
        raise Exception('bad resp %r' % line)
    def cmd(self, *args):
        self._send(args); return self.read()
    def pipeline(self, cmds):
        for c in cmds: self._send(c)
        return [self.read() for _ in cmds]

def scan_keys(c):
    cur, keys = b'0', []
    while True:
        r = c.cmd('SCAN', cur, 'COUNT', 1000)
        cur = r[0]; keys.extend(r[1])
        if cur == b'0': break
    return keys

def flat(x):
    if isinstance(x, list):
        out = []
        for e in x: out.extend(flat(e))
        return tuple(out)
    if isinstance(x, bytes): return x
    return x

errors = []
total = 0
probe = RC(SRC, 0)
active = [db for db in range(16) if probe.cmd('SELECT', db) == 'OK' and probe.cmd('DBSIZE') > 0]
print('source dbs with keys:', active)

for db in active:
    src, dst = RC(SRC, db), RC(DST, db)
    ks, kd = scan_keys(src), scan_keys(dst)
    print(f'db{db}: src={len(ks)} dst={len(kd)}')
    set_s, set_d = set(ks), set(kd)
    if set_s != set_d:
        for k in set_s - set_d: errors.append(f'db{db} missing on dst: {k!r}')
        for k in set_d - set_s: errors.append(f'db{db} extra on dst: {k!r}')
    keys = sorted(set_s)
    total += len(keys)
    B = 200
    for i in range(0, len(keys), B):
        chunk = keys[i:i+B]
        n = len(chunk)
        rs = src.pipeline([['TYPE', k] for k in chunk] + [['PTTL', k] for k in chunk] +
                          [['DUMP', k] for k in chunk] + [['OBJECT', 'IDLETIME', k] for k in chunk])
        rd = dst.pipeline([['TYPE', k] for k in chunk] + [['PTTL', k] for k in chunk] +
                          [['DUMP', k] for k in chunk] + [['OBJECT', 'IDLETIME', k] for k in chunk])
        ts_s, ttl_s, dp_s, idl_s = rs[:n], rs[n:2*n], rs[2*n:3*n], rs[3*n:]
        ts_d, ttl_d, dp_d, idl_d = rd[:n], rd[n:2*n], rd[2*n:3*n], rd[3*n:]
        for j, k in enumerate(chunk):
            kb = k if isinstance(k, bytes) else k.encode()
            if ts_s[j] != ts_d[j]:
                errors.append(f'db{db} {kb!r}: type src={ts_s[j]} dst={ts_d[j]}'); continue
            if ttl_s[j] != ttl_d[j] and not (ttl_s[j] < 0 and ttl_d[j] < 0):
                if ttl_s[j] < 0 or ttl_d[j] < 0 or abs(ttl_s[j] - ttl_d[j]) > TTL_TOL:
                    errors.append(f'db{db} {kb!r}: pttl src={ttl_s[j]} dst={ttl_d[j]}')
            a, b = dp_s[j], dp_d[j]
            if a is None or b is None or len(a) != len(b) or a[-10:] != b[-10:] or a[:-10] != b[:-10]:
                errors.append(f'db{db} {kb!r}: dump body mismatch (len {len(a) if a else None} vs {len(b) if b else None})')
                continue
            # trailer shape sanity: byte[-9]==0x00; byte[-10] is writer format marker
            if b[-9] != 0 or a[-9] != 0:
                errors.append(f'db{db} {kb!r}: unexpected trailer shape')
            if abs(idl_s[j] - idl_d[j]) > IDLE_TOL:
                errors.append(f'db{db} {kb!r}: idletime src={idl_s[j]} dst={idl_d[j]}')

    # --- stream consumer group deep compare on this db ---
    streams = [k for k in keys if src.cmd('TYPE', k) == 'stream']
    print(f'db{db}: deep-comparing {len(streams)} streams')
    for k in streams:
        info_s = flat(src.cmd('XINFO', 'STREAM', k)); info_d = flat(dst.cmd('XINFO', 'STREAM', k))
        d = dict(zip(info_s[::2], info_s[1::2])); dd = dict(zip(info_d[::2], info_d[1::2]))
        for f in [b'length', b'last-generated-id', b'max-deleted-entry-id', b'entries-added', b'recorded-first-entry-id']:
            if d.get(f) != dd.get(f): errors.append(f'db{db} stream {k!r}: {f.decode()} {d.get(f)} vs {dd.get(f)}')
        gs = flat(src.cmd('XINFO', 'GROUPS', k)); gd = flat(dst.cmd('XINFO', 'GROUPS', k))
        if len(gs) != len(gd): errors.append(f'db{db} stream {k!r}: group count {len(gs)//10} vs {len(gd)//10}')
        else:
            for a, b in zip(gs, gd):
                if a[0] != b[0] or a[2] != b[2] or a[4] != b[4] or a[6] != b[6] or a[8] != b[8]:
                    errors.append(f'db{db} stream {k!r} group {a!r} vs {b!r}')
                gname = a[0]
                cs = flat(src.cmd('XINFO', 'CONSUMERS', k, gname)); cd = flat(dst.cmd('XINFO', 'CONSUMERS', k, gname))
                if len(cs) != len(cd): errors.append(f'db{db} stream {k!r} group {gname!r}: consumer count differs')
                else:
                    for ca, cb in zip(cs, cd):
                        # fields: name, pending, idle, inactive
                        if ca[0] != cb[0] or ca[2] != cb[2] or abs(ca[4] - cb[4]) > IDLE_TOL or abs(ca[6] - cb[6]) > IDLE_TOL:
                            errors.append(f'db{db} stream {k!r} group {gname!r} consumer {ca!r} vs {cb!r}')
                ps = flat(src.cmd('XPENDING', k, gname, '-', '+', 100000)); pd = flat(dst.cmd('XPENDING', k, gname, '-', '+', 100000))
                if len(ps) != len(pd): errors.append(f'db{db} stream {k!r} group {gname!r}: PEL size {len(ps)//4} vs {len(pd)//4}')
                else:
                    for pa, pb in zip(ps, pd):
                        # fields: id, consumer, idle, delivery-count
                        if pa[0] != pb[0] or pa[1] != pb[1] or pa[3] != pb[3] or abs(pa[2] - pb[2]) > IDLE_TOL:
                            errors.append(f'db{db} stream {k!r} group {gname!r} pel {pa!r} vs {pb!r}')

# scratch db on dst must be empty
d15 = RC(DST, 15)
if d15.cmd('DBSIZE') != 0: errors.append('dst db15 not empty')
print(f'total keys compared: {total}')
if errors:
    print(f'FAILURES ({len(errors)}):')
    for e in errors[:50]: print(' ', e)
else:
    print('VERIFICATION PASSED: identical key sets, types, values, TTLs, idletimes, and stream group/PEL state')
EOF
python3 /tmp/verify.py

22  $ cd /tmp && python3 - <<'EOF'
# patch verify.py: fix flat() and tuple index math
src = open('/tmp/verify.py').read()
src = src.replace("""def flat(x):
    if isinstance(x, list):
        out = []
        for e in x: out.extend(flat(e))
        return tuple(out)
    if isinstance(x, bytes): return x
    return x""",
"""def flat(x):
    if isinstance(x, list):
        out = []
        for e in x:
            if isinstance(e, list): out.extend(flat(e))
            else: out.append(e)
        return tuple(out)
    return x""")
src = src.replace("if len(gs) != len(gd): errors.append(f'db{db} stream {k!r}: group count {len(gs)//10} vs {len(gd)//10}')",
                  "if len(gs) != len(gd): errors.append(f'db{db} stream {k!r}: group count {len(gs)//6} vs {len(gd)//6}')")
src = src.replace("""                for a, b in zip(gs, gd):
                    if a[0] != b[0] or a[2] != b[2] or a[4] != b[4] or a[6] != b[6] or a[8] != b[8]:
                        errors.append(f'db{db} stream {k!r} group {a!r} vs {b!r}')""",
"""                for a, b in zip(gs, gd):
                    # a = (name, consumers, pending, last-delivered-id, entries-read, lag)
                    if a[0] != b[0] or a[1] != b[1] or a[2] != b[2] or a[3] != b[3] or a[4] != b[4] or a[5] != b[5]:
                        errors.append(f'db{db} stream {k!r} group {a!r} vs {b!r}')""")
src = src.replace("""                    for ca, cb in zip(cs, cd):
                        # fields: name, pending, idle, inactive
                        if ca[0] != cb[0] or ca[2] != cb[2] or abs(ca[4] - cb[4]) > IDLE_TOL or abs(ca[6] - cb[6]) > IDLE_TOL:
                            errors.append(f'db{db} stream {k!r} group {gname!r} consumer {ca!r} vs {cb!r}')""",
"""                    for ca, cb in zip(cs, cd):
                        # ca = (name, pending, idle, inactive)
                        if ca[0] != cb[0] or ca[1] != cb[1] or abs(ca[2] - cb[2]) > IDLE_TOL or abs(ca[3] - cb[3]) > IDLE_TOL:
                            errors.append(f'db{db} stream {k!r} group {gname!r} consumer {ca!r} vs {cb!r}')""")
src = src.replace("""                    for pa, pb in zip(ps, pd):
                        # fields: id, consumer, idle, delivery-count
                        if pa[0] != pb[0] or pa[1] != pb[1] or pa[3] != pb[3] or abs(pa[2] - pb[2]) > IDLE_TOL:
                            errors.append(f'db{db} stream {k!r} group {gname!r} pel {pa!r} vs {pb!r}')""",
"""                    for pa, pb in zip(ps, pd):
                        # pa = (id, consumer, delivery-time-ms, delivery-count)
                        if pa[0] != pb[0] or pa[1] != pb[1] or pa[2] != pb[2] or pa[3] != pb[3]:
                            errors.append(f'db{db} stream {k!r} group {gname!r} pel {pa!r} vs {pb!r}')""")
open('/tmp/verify.py','w').write(src)
print('patched')
EOF
python3 /tmp/verify.py

23  $ cat > /tmp/verify.py <<'EOF'
#!/usr/bin/env python3
"""Verify Valkey(6380) is an exact copy of Redis(6379)."""
import socket

SRC, DST = 6379, 6380
TTL_TOL = 3000
IDLE_TOL = 5000

class RC:
    def __init__(self, port, db=0):
        self.s = socket.create_connection(('127.0.0.1', port))
        self.s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
        self.f = self.s.makefile('rb')
        if db: self.cmd('SELECT', db)
    def _send(self, args):
        out = [b'*%d\r\n' % len(args)]
        for a in args:
            if isinstance(a, int): a = str(a).encode()
            elif isinstance(a, str): a = a.encode()
            out.append(b'$%d\r\n%s\r\n' % (len(a), a))
        self.s.sendall(b''.join(out))
    def read(self):
        line = self.f.readline()
        t, d = line[:1], line[1:-2]
        if t == b'+': return d.decode()
        if t == b'-': return ('ERR', d.decode())
        if t == b':': return int(d)
        if t == b'$':
            n = int(d)
            if n == -1: return None
            return self.f.read(n + 2)[:-2]
        if t == b'*':
            n = int(d)
            if n == -1: return None
            return [self.read() for _ in range(n)]
        raise Exception('bad resp %r' % line)
    def cmd(self, *args):
        self._send(args); return self.read()
    def pipeline(self, cmds):
        for c in cmds: self._send(c)
        return [self.read() for _ in cmds]

def scan_keys(c):
    cur, keys = b'0', []
    while True:
        r = c.cmd('SCAN', cur, 'COUNT', 1000)
        cur = r[0]; keys.extend(r[1])
        if cur == b'0': break
    return keys

def flat(x):
    if isinstance(x, list):
        out = []
        for e in x:
            if isinstance(e, list): out.extend(flat(e))
            else: out.append(e)
        return tuple(out)
    return x

errors = []
total = 0
probe = RC(SRC, 0)
active = [db for db in range(16) if probe.cmd('SELECT', db) == 'OK' and probe.cmd('DBSIZE') > 0]
print('source dbs with keys:', active)

for db in active:
    src, dst = RC(SRC, db), RC(DST, db)
    ks, kd = scan_keys(src), scan_keys(dst)
    print(f'db{db}: src={len(ks)} dst={len(kd)}')
    set_s, set_d = set(ks), set(kd)
    if set_s != set_d:
        for k in set_s - set_d: errors.append(f'db{db} missing on dst: {k!r}')
        for k in set_d - set_s: errors.append(f'db{db} extra on dst: {k!r}')
    keys = sorted(set_s)
    total += len(keys)
    B = 200
    for i in range(0, len(keys), B):
        chunk = keys[i:i+B]
        n = len(chunk)
        rs = src.pipeline([['TYPE', k] for k in chunk] + [['PTTL', k] for k in chunk] +
                          [['DUMP', k] for k in chunk] + [['OBJECT', 'IDLETIME', k] for k in chunk])
        rd = dst.pipeline([['TYPE', k] for k in chunk] + [['PTTL', k] for k in chunk] +
                          [['DUMP', k] for k in chunk] + [['OBJECT', 'IDLETIME', k] for k in chunk])
        ts_s, ttl_s, dp_s, idl_s = rs[0:n], rs[n:2*n], rs[2*n:3*n], rs[3*n:4*n]
        ts_d, ttl_d, dp_d, idl_d = rd[0:n], rd[n:2*n], rd[2*n:3*n], rd[3*n:4*n]
        for j, k in enumerate(chunk):
            kb = k if isinstance(k, bytes) else k.encode()
            if ts_s[j] != ts_d[j]:
                errors.append(f'db{db} {kb!r}: type src={ts_s[j]} dst={ts_d[j]}'); continue
            if ttl_s[j] != ttl_d[j] and not (ttl_s[j] < 0 and ttl_d[j] < 0):
                if ttl_s[j] < 0 or ttl_d[j] < 0 or abs(ttl_s[j] - ttl_d[j]) > TTL_TOL:
                    errors.append(f'db{db} {kb!r}: pttl src={ttl_s[j]} dst={ttl_d[j]}')
            a, b = dp_s[j], dp_d[j]
            if a is None or b is None or len(a) != len(b) or a[:-10] != b[:-10] or a[-10:] != b[-10:]:
                errors.append(f'db{db} {kb!r}: dump mismatch (len {len(a) if a else None} vs {len(b) if b else None})')
                continue
            if a[-9] != 0:
                errors.append(f'db{db} {kb!r}: unexpected trailer shape')
            if abs(idl_s[j] - idl_d[j]) > IDLE_TOL:
                errors.append(f'db{db} {kb!r}: idletime src={idl_s[j]} dst={idl_d[j]}')

    # ---- stream consumer group deep compare ----
    streams = [k for k in keys if src.cmd('TYPE', k) == 'stream']
    print(f'db{db}: deep-comparing {len(streams)} streams')
    for k in streams:
        info_s = flat(src.cmd('XINFO', 'STREAM', k)); info_d = flat(dst.cmd('XINFO', 'STREAM', k))
        d = dict(zip(info_s[0::2], info_s[1::2])); dd = dict(zip(info_d[0::2], info_d[1::2]))
        for f in (b'length', b'last-generated-id', b'max-deleted-entry-id', b'entries-added', b'recorded-first-entry-id'):
            if d.get(f) != dd.get(f):
                errors.append(f'db{db} stream {k!r}: {f.decode()} {d.get(f)} vs {dd.get(f)}')
        gs = flat(src.cmd('XINFO', 'GROUPS', k)); gd = flat(dst.cmd('XINFO', 'GROUPS', k))
        if len(gs) != len(gd):
            errors.append(f'db{db} stream {k!r}: group count {len(gs)//6} vs {len(gd)//6}')
        else:
            for a, b in zip(gs, gd):  # (name, consumers, pending, last-delivered-id, entries-read, lag)
                if a[:4] != b[:4] or a[4] != b[4]:
                    errors.append(f'db{db} stream {k!r} group {a} vs {b}')
                gname = a[0]
                cs = flat(src.cmd('XINFO', 'CONSUMERS', k, gname)); cd = flat(dst.cmd('XINFO', 'CONSUMERS', k, gname))
                if len(cs) != len(cd):
                    errors.append(f'db{db} stream {k!r} group {gname!r}: consumer count {len(cs)//4} vs {len(cd)//4}')
                else:
                    for ca, cb in zip(cs, cd):  # (name, pending, idle, inactive)
                        if ca[0] != cb[0] or ca[1] != cb[1] or abs(ca[2] - cb[2]) > IDLE_TOL or abs(ca[3] - cb[3]) > IDLE_TOL:
                            errors.append(f'db{db} stream {k!r} group {gname!r} consumer {ca} vs {cb}')
                ps = flat(src.cmd('XPENDING', k, gname, '-', '+', 100000)); pd = flat(dst.cmd('XPENDING', k, gname, '-', '+', 100000))
                if len(ps) != len(pd):
                    errors.append(f'db{db} stream {k!r} group {gname!r}: PEL size {len(ps)//4} vs {len(pd)//4}')
                else:
                    for pa, pb in zip(ps, pd):  # (id, consumer, delivery-time, delivery-count)
                        if pa[0] != pb[0] or pa[1] != pb[1] or pa[2] != pb[2] or pa[3] != pb[3]:
                            errors.append(f'db{db} stream {k!r} group {gname!r} pel {pa} vs {pb}')

d15 = RC(DST, 15)
if d15.cmd('DBSIZE') != 0: errors.append('dst db15 not empty')
print(f'total keys compared: {total}')
if errors:
    print(f'FAILURES ({len(errors)}):')
    for e in errors[:50]: print(' ', e)
else:
    print('VERIFICATION PASSED: identical key sets, types, values, TTLs, idletimes, stream groups/PEL')
EOF
python3 /tmp/verify.py; echo "exit=$?"

24  $ python3 - <<'EOF'
src = open('/tmp/verify.py').read()
src = src.replace("""            for a, b in zip(gs, gd):  # (name, consumers, pending, last-delivered-id, entries-read, lag)
                if a[:4] != b[:4] or a[4] != b[4]:""",
"""            for i in range(0, min(len(gs), len(gd)), 6):
                a, b = gs[i:i+6], gd[i:i+6]  # (name, consumers, pending, last-delivered-id, entries-read, lag)
                if a[:4] != b[:4] or a[4:6] != b[4:6]:""")
src = src.replace("""                    for ca, cb in zip(cs, cd):  # (name, pending, idle, inactive)
                        if ca[0] != cb[0] or ca[1] != cb[1] or abs(ca[2] - cb[2]) > IDLE_TOL or abs(ca[3] - cb[3]) > IDLE_TOL:""",
"""                    for i in range(0, min(len(cs), len(cd)), 4):
                        ca, cb = cs[i:i+4], cd[i:i+4]  # (name, pending, idle, inactive)
                        if ca[0] != cb[0] or ca[1] != cb[1] or abs(ca[2] - cb[2]) > IDLE_TOL or abs(ca[3] - cb[3]) > IDLE_TOL:""")
src = src.replace("""                    for pa, pb in zip(ps, pd):  # (id, consumer, delivery-time, delivery-count)
                        if pa[0] != pb[0] or pa[1] != pb[1] or pa[2] != pb[2] or pa[3] != pb[3]:""",
"""                    for i in range(0, min(len(ps), len(pd)), 4):
                        pa, pb = ps[i:i+4], pd[i:i+4]  # (id, consumer, delivery-time, delivery-count)
                        if pa[0] != pb[0] or pa[1] != pb[1] or pa[2] != pb[2] or pa[3] != pb[3]:""")
open('/tmp/verify.py','w').write(src)
print('patched ok')
EOF
python3 /tmp/verify.py; echo "exit=$?"

25  $ python3 - <<'EOF'
import socket, json

class RC:
    def __init__(self, port, db=0):
        self.s = socket.create_connection(('127.0.0.1', port))
        self.f = self.s.makefile('rb')
        if db: self.cmd('SELECT', db)
    def cmd(self, *args):
        out = [b'*%d\r\n' % len(args)]
        for a in args:
            if isinstance(a, int): a = str(a).encode()
            elif isinstance(a, str): a = a.encode()
            out.append(b'$%d\r\n%s\r\n' % (len(a), a))
        self.s.sendall(b''.join(out))
        return self.read()
    def read(self):
        line = self.f.readline()
        t, d = line[:1], line[1:-2]
        if t == b'+': return d.decode()
        if t == b'-': return ('ERR', d.decode())
        if t == b':': return int(d)
        if t == b'$':
            n = int(d)
            if n == -1: return None
            return self.f.read(n + 2)[:-2]
        if t == b'*':
            n = int(d)
            if n == -1: return None
            return [self.read() for _ in range(n)]
        raise Exception('bad resp %r' % line)

src = RC(6379, 0)
print('XINFO CONSUMERS raw:')
print(src.cmd('XINFO', 'CONSUMERS', 'events:07', 'workers'))
print()
print('XPENDING extended raw (first 2):')
print(src.cmd('XPENDING', 'events:07', 'workers', '-', '+', 2))
print()
print('XINFO GROUPS raw:')
print(src.cmd('XINFO', 'GROUPS', 'events:07'))
EOF

26  $ cat > /tmp/verify.py <<'EOF'
#!/usr/bin/env python3
"""Verify Valkey(6380) is an exact copy of Redis(6379)."""
import socket

SRC, DST = 6379, 6380
TTL_TOL = 3000
IDLE_TOL = 5000

class RC:
    def __init__(self, port, db=0):
        self.s = socket.create_connection(('127.0.0.1', port))
        self.s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
        self.f = self.s.makefile('rb')
        if db: self.cmd('SELECT', db)
    def _send(self, args):
        out = [b'*%d\r\n' % len(args)]
        for a in args:
            if isinstance(a, int): a = str(a).encode()
            elif isinstance(a, str): a = a.encode()
            out.append(b'$%d\r\n%s\r\n' % (len(a), a))
        self.s.sendall(b''.join(out))
    def read(self):
        line = self.f.readline()
        t, d = line[:1], line[1:-2]
        if t == b'+': return d.decode()
        if t == b'-': return ('ERR', d.decode())
        if t == b':': return int(d)
        if t == b'$':
            n = int(d)
            if n == -1: return None
            return self.f.read(n + 2)[:-2]
        if t == b'*':
            n = int(d)
            if n == -1: return None
            return [self.read() for _ in range(n)]
        raise Exception('bad resp %r' % line)
    def cmd(self, *args):
        self._send(args); return self.read()
    def pipeline(self, cmds):
        for c in cmds: self._send(c)
        return [self.read() for _ in cmds]

def scan_keys(c):
    cur, keys = b'0', []
    while True:
        r = c.cmd('SCAN', cur, 'COUNT', 1000)
        cur = r[0]; keys.extend(r[1])
        if cur == b'0': break
    return keys

def kv_flat(lst):
    """flat [k1,v1,k2,v2,...] -> dict"""
    it = iter(lst)
    return dict(zip(it, it))

def kv_records(reply):
    """list of flat [k1,v1,...] records -> list of dicts"""
    return [kv_flat(rec) for rec in reply]

errors = []
total = 0
probe = RC(SRC, 0)
active = [db for db in range(16) if probe.cmd('SELECT', db) == 'OK' and probe.cmd('DBSIZE') > 0]
print('source dbs with keys:', active)

for db in active:
    src, dst = RC(SRC, db), RC(DST, db)
    ks, kd = scan_keys(src), scan_keys(dst)
    print(f'db{db}: src={len(ks)} dst={len(kd)}')
    set_s, set_d = set(ks), set(kd)
    if set_s != set_d:
        for k in set_s - set_d: errors.append(f'db{db} missing on dst: {k!r}')
        for k in set_d - set_s: errors.append(f'db{db} extra on dst: {k!r}')
    keys = sorted(set_s)
    total += len(keys)
    B = 200
    for i in range(0, len(keys), B):
        chunk = keys[i:i+B]
        n = len(chunk)
        rs = src.pipeline([['TYPE', k] for k in chunk] + [['PTTL', k] for k in chunk] +
                          [['DUMP', k] for k in chunk] + [['OBJECT', 'IDLETIME', k] for k in chunk])
        rd = dst.pipeline([['TYPE', k] for k in chunk] + [['PTTL', k] for k in chunk] +
                          [['DUMP', k] for k in chunk] + [['OBJECT', 'IDLETIME', k] for k in chunk])
        for j, k in enumerate(chunk):
            kb = k if isinstance(k, bytes) else k.encode()
            if rs[j] != rd[j]:
                errors.append(f'db{db} {kb!r}: type src={rs[j]} dst={rd[j]}'); continue
            t1, t2 = rs[n+j], rd[n+j]
            if t1 != t2 and not (t1 < 0 and t2 < 0):
                if t1 < 0 or t2 < 0 or abs(t1 - t2) > TTL_TOL:
                    errors.append(f'db{db} {kb!r}: pttl src={t1} dst={t2}')
            a, b = rs[2*n+j], rd[2*n+j]
            if a is None or b is None or len(a) != len(b) or a[:-10] != b[:-10] or a[-10:] != b[-10:]:
                errors.append(f'db{db} {kb!r}: dump mismatch (len {len(a) if a else None} vs {len(b) if b else None})')
                continue
            if a[-9] != 0:
                errors.append(f'db{db} {kb!r}: unexpected trailer shape')
            i1, i2 = rs[3*n+j], rd[3*n+j]
            if abs(i1 - i2) > IDLE_TOL:
                errors.append(f'db{db} {kb!r}: idletime src={i1} dst={i2}')

    # ---- stream consumer group deep compare ----
    streams = [k for k in keys if src.cmd('TYPE', k) == 'stream']
    print(f'db{db}: deep-comparing {len(streams)} streams')
    for k in streams:
        d_s = kv_flat(src.cmd('XINFO', 'STREAM', k))   # top level is flat pairs
        d_d = kv_flat(dst.cmd('XINFO', 'STREAM', k))
        for f in (b'length', b'last-generated-id', b'max-deleted-entry-id', b'entries-added', b'recorded-first-entry-id'):
            if d_s.get(f) != d_d.get(f):
                errors.append(f'db{db} stream {k!r}: {f.decode()} {d_s.get(f)} vs {d_d.get(f)}')
        gs = kv_records(src.cmd('XINFO', 'GROUPS', k))
        gd = kv_records(dst.cmd('XINFO', 'GROUPS', k))
        if len(gs) != len(gd):
            errors.append(f'db{db} stream {k!r}: group count {len(gs)} vs {len(gd)}')
            continue
        for a, b in zip(gs, gd):
            for f in (b'name', b'consumers', b'pending', b'last-delivered-id', b'entries-read', b'lag'):
                if a.get(f) != b.get(f):
                    errors.append(f'db{db} stream {k!r} group {a.get(b"name")!r}: {f.decode()} {a.get(f)} vs {b.get(f)}')
            gname = a[b'name']
            cs = kv_records(src.cmd('XINFO', 'CONSUMERS', k, gname))
            cd = kv_records(dst.cmd('XINFO', 'CONSUMERS', k, gname))
            if len(cs) != len(cd):
                errors.append(f'db{db} stream {k!r} group {gname!r}: consumer count {len(cs)} vs {len(cd)}')
                continue
            for ca, cb in zip(cs, cd):
                if ca.get(b'name') != cb.get(b'name') or ca.get(b'pending') != cb.get(b'pending') \
                   or abs(ca.get(b'idle', 0) - cb.get(b'idle', 0)) > IDLE_TOL \
                   or abs(ca.get(b'inactive', 0) - cb.get(b'inactive', 0)) > IDLE_TOL:
                    errors.append(f'db{db} stream {k!r} group {gname!r} consumer {ca} vs {cb}')
            ps = src.cmd('XPENDING', k, gname, '-', '+', 100000)
            pd = dst.cmd('XPENDING', k, gname, '-', '+', 100000)
            if len(ps) != len(pd):
                errors.append(f'db{db} stream {k!r} group {gname!r}: PEL size {len(ps)} vs {len(pd)}')
                continue
            for pa, pb in zip(ps, pd):  # each: [id, consumer, delivery-time, delivery-count]
                if pa[0] != pb[0] or pa[1] != pb[1] or pa[2] != pb[2] or pa[3] != pb[3]:
                    errors.append(f'db{db} stream {k!r} group {gname!r} pel {pa} vs {pb}')

d15 = RC(DST, 15)
if d15.cmd('DBSIZE') != 0: errors.append('dst db15 not empty')
print(f'total keys compared: {total}')
if errors:
    print(f'FAILURES ({len(errors)}):')
    for e in errors[:50]: print(' ', e)
else:
    print('VERIFICATION PASSED: identical key sets, types, values, TTLs, idletimes, stream groups/PEL')
EOF
python3 /tmp/verify.py; echo "exit=$?"

27  $ python3 - <<'EOF'
src = open('/tmp/verify.py').read()
src = src.replace("""            a, b = rs[2*n+j], rd[2*n+j]
            if a is None or b is None or len(a) != len(b) or a[:-10] != b[:-10] or a[-10:] != b[-10:]:
                errors.append(f'db{db} {kb!r}: dump mismatch (len {len(a) if a else None} vs {len(b) if b else None})')
                continue
            if a[-9] != 0:
                errors.append(f'db{db} {kb!r}: unexpected trailer shape')""",
"""            a, b = rs[2*n+j], rd[2*n+j]
            # last 10 bytes = 2-byte RDB version + 8-byte checksum: writer-specific, mask them
            body_same = a is not None and b is not None and len(a) == len(b) and a[:-10] == b[:-10]
            shape_ok = a is not None and b is not None and len(a) == len(b) and a[-9] == 0 and b[-9] == 0
            if not body_same or not shape_ok:
                errors.append(f'db{db} {kb!r}: dump mismatch (len {len(a) if a else None} vs {len(b) if b else None}, body_same={body_same}, shape_ok={shape_ok})')
                continue""")
open('/tmp/verify.py','w').write(src)
print('patched')
EOF
python3 /tmp/verify.py; echo "exit=$?"

28  $ echo "--- dst persistence config ---"; valkey-cli -p 6380 CONFIG GET appendonly save dir; echo "--- trigger BGSAVE ---"; valkey-cli -p 6380 BGSAVE; sleep 2; valkey-cli -p 6380 INFO persistence | grep -E "rdb_bgsave_in_progress|rdb_last_save_time|rdb_last_bgsave_status|aof_enabled"; ls -la /var/lib/valkey/; echo "--- final state ---"; echo "[src 6379]"; redis-cli -p 6379 INFO replication | grep -E "^role|connected_slaves"; redis-cli -p 6379 INFO keyspace; echo "[dst 6380]"; valkey-cli -p 6380 INFO replication | grep -E "^role|connected_slaves|min-replicas-to-write"; valkey-cli -p 6380 INFO keyspace; valkey-cli -p 6380 CONFIG GET replicaof cluster-enabled; echo "--- write-acceptance sanity on dst ---"; valkey-cli -p 6380 SET __write_sanity__ ok EX 10; valkey-cli -p 6380 GET __write_sanity__; valkey-cli -p 6380 DEL __write_sanity__; echo "--- procs ---"; ps aux | grep -E "[r]edis-server|[v]alkey-server"

{
 "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": "7.2.4",
  "server_name": "valkey",
  "valkey_version": "9.1.2"
 },
 "old_digest_ok": true,
 "old_server": {
  "redis_version": "7.2.16",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

1  $ ps aux | grep -E '[r]edis|[v]alkey'

2  $ ls -la /opt/redis-7.2/bin/ 2>/dev/null; echo ---; ls /usr/local/bin /usr/bin 2>/dev/null | grep -iE 'redis|valkey'; echo ---; which redis-cli valkey-cli redis-server valkey-server 2>/dev/null

3  $ redis-cli -p 6379 PING 2>&1; echo ---; redis-cli -p 6380 PING 2>&1

4  $ echo '=== redis-old config (effective) ==='; grep -vE '^\s*(#|$)' /etc/redis-old/redis.conf; echo; echo '=== valkey config (effective) ==='; grep -vE '^\s*(#|$)' /etc/valkey/valkey.conf

5  $ echo '=== INFO keyspace (source) ==='; redis-cli -p 6379 INFO keyspace; echo; echo '=== INFO server (subset) ==='; redis-cli -p 6379 INFO server | grep -E 'redis_version|redis_mode|os|multiplexing|process_id'; echo; echo '=== INFO replication (source) ==='; redis-cli -p 6379 INFO replication

6  $ echo '=== destination keyspace ==='; redis-cli -p 6380 INFO keyspace; echo; echo '=== destination functions ==='; valkey-cli -p 6380 FUNCTION LIST 2>&1; echo '=== destination ACL LIST ==='; valkey-cli -p 6380 ACL LIST 2>&1

7  $ echo '=== source functions ==='; redis-cli -p 6379 FUNCTION LIST 2>&1; echo '=== source ACL LIST ==='; redis-cli -p 6379 ACL LIST 2>&1; echo '=== source modules ==='; redis-cli -p 6379 MODULE LIST 2>&1; echo '=== source script cache size ==='; redis-cli -p 6379 SCRIPT EXISTS 0000000000000000000000000000000000000000 2>&1

8  $ redis-cli -p 6379 --bigkeys 2>&1 | tail -30

9  $ which python3; python3 --version; python3 -c "import redis" 2>&1 | head -1

10  $ for db in 0 2; do echo "=== db$db streams: groups ==="; redis-cli -p 6379 -n $db --scan --pattern '*' 2>/dev/null | while read k; do t=$(redis-cli -p 6379 -n $db TYPE "$k"); if [ "$t" = "stream" ]; then echo "KEY $k"; redis-cli -p 6379 -n $db XINFO GROUPS "$k"; fi; done; done 2>&1 | head -80

11  $ for db in 0 2; do echo "=== SOURCE db$db digest BEFORE ==="; redis-cli -p 6379 -n $db DEBUG DIGEST 2>&1; done; echo; redis-cli -p 6379 CONFIG GET save appendonly repl-diskless-sync repl-diskless-sync-delay

12  $ valkey-cli -p 6380 CONFIG GET save appendonly replica-read-only key-load-delay repl-diskless-load maxmemory

13  $ echo '=== source INFO stats ==='; redis-cli -p 6379 INFO stats | grep -E 'total_commands_processed|instantaneous_ops|expired_keys|evicted_keys|keyspace_hits'; echo; echo '=== TTL distribution db0/db2 (percentile-ish) ==='; redis-cli -p 6379 -n 0 --scan | head -0; for db in 0 2; do redis-cli -p 6379 -n $db --scan | while read k; do redis-cli -p 6379 -n $db PTTL "$k"; done | sort -n | sed -n '1p;$p' | xargs echo "db$db min/max PTTL:"; done

14  $ echo '=== valkey full default-ish config comments around replica/save ==='; grep -nE '^(save|appendonly|replicaof|slaveof|dir|dbfilename|databases)' /etc/valkey/valkey.conf; echo '---'; ls -la /var/lib/valkey /var/lib/redis-old 2>/dev/null; echo '---'; tail -5 /var/log/valkey/valkey.log 2>/dev/null; echo '--- valkey version ---'; valkey-cli -p 6380 INFO server | grep -E 'valkey_version|redis_version|arch|gcc'

15  $ python3 -c "import redis; print('redis-py OK', redis.__version__)" 2>&1; pip3 --version 2>&1 | head -1

16  $ for db in 0 2; do echo "db$db shortest positive PTTLs:"; redis-cli -p 6379 -n $db --scan | while read k; do p=$(redis-cli -p 6379 -n $db PTTL "$k"); [ "$p" -gt 0 ] 2>/dev/null && echo "$p"; done | sort -n | head -3; done

17  $ mkdir -p /root/migration && cat > /root/migration/fingerprint.py <<'EOF'
#!/usr/bin/env python3
"""Deep, canonical fingerprint of a Redis/Valkey instance.
Serializes every key in every DB: type, value bytes, PTTL, plus stream
consumer-group state (groups, consumers, PELs). Writes JSONL + digest summary.
"""
import hashlib, json, sys, time
import redis

PORT = int(sys.argv[1])
OUT = sys.argv[2]

def cli(port):
    return redis.Redis(host='127.0.0.1', port=port, decode_responses=False,
                       socket_timeout=30)

r = cli(PORT)

t0 = time.time()
keyspace = r.info('keyspace')
dbs = sorted({0, 2} | {int(k.split('d')[1]) for k in keyspace
                       if k.startswith('db')})

def flat_to_pairs(arr):
    return [(arr[i], arr[i+1]) for i in range(0, len(arr), 2)]

def value_repr(pipe, key, ktype):
    """Canonical, hashable representation of a key's value."""
    if ktype == b'string':
        v = pipe.execute_command('GET', key)
        return ('string', v)
    if ktype == b'list':
        return ('list', pipe.execute_command('LRANGE', key, 0, -1))
    if ktype == b'hash':
        d = pipe.execute_command('HGETALL', key)
        return ('hash', sorted(flat_to_pairs(d), key=lambda kv: kv[0]))
    if ktype == b'set':
        return ('set', sorted(pipe.execute_command('SMEMBERS', key)))
    if ktype == b'zset':
        z = pipe.execute_command('ZRANGE', key, 0, -1, 'WITHSCORES')
        return ('zset', [(z[i], z[i+1]) for i in range(0, len(z), 2)])
    if ktype == b'stream':
        entries = pipe.execute_command('XRANGE', key, '-', '+')
        ents = []
        for eid, fields in entries:
            ents.append([eid, [[fields[i], fields[i+1]]
                               for i in range(0, len(fields), 2)]])
        groups = []
        for g in pipe.execute_command('XINFO', 'GROUPS', key):
            gd = dict(flat_to_pairs(g))
            gname = gd[b'name']
            consumers = []
            for c in pipe.execute_command('XINFO', 'CONSUMERS', key, gname):
                cd = dict(flat_to_pairs(c))
                consumers.append({'name': cd.get(b'name'),
                                  'pending': cd.get(b'pending'),
                                  'idle_ms': cd.get(b'idle'),
                                  'inactive_ms': cd.get(b'inactive')})
            pel = []
            for p in pipe.execute_command('XPENDING', key, gname,
                                          'IDLE', 0, '-', '+', 1000000):
                pel.append({'id': p[0], 'consumer': p[1],
                            'ms_since_delivery': p[2],
                            'delivery_count': p[3]})
            groups.append({'name': gname,
                           'last-delivered-id': gd.get(b'last-delivered-id'),
                           'entries-read': gd.get(b'entries-read'),
                           'lag': gd.get(b'lag'),
                           'group-pending': gd.get(b'pending'),
                           'consumers': consumers,
                           'pel': pel})
        return ('stream', {'entries': ents, 'groups': groups})
    raise RuntimeError('unhandled type %r for %r' % (ktype, key))

out = open(OUT, 'w')
summary = {'port': PORT, 'started': t0, 'dbs': {}}
total_records = 0
for db in dbs:
    p = r.pipeline(transaction=False)
    keys = list(r.scan_iter(db=db, count=1000))
    if not keys:
        summary['dbs'][db] = {'keys': 0, 'digest': hashlib.sha256(b'EMPTY').hexdigest()}
        continue
    h = hashlib.sha256()
    types = p.execute_command('TYPE', *[k for k in keys]) if False else None
    # pipeline TYPE for all keys
    tp = r.pipeline(transaction=False)
    for k in keys:
        tp.type(k)
    kt = tp.execute()
    recs = []
    vp = r.pipeline(transaction=False)
    planned = []
    for k, t in zip(keys, kt):
        ktype = t if isinstance(t, bytes) else t.encode()
        planned.append((k, ktype))
        value_repr(vp, k, ktype)
    ttlp = r.pipeline(transaction=False)
    for k, _ in planned:
        ttlp.pttl(k)
    encp = r.pipeline(transaction=False)
    for k, _ in planned:
        encp.execute_command('OBJECT', 'ENCODING', k)
    vals = vp.execute()
    ttls = ttlp.execute()
    encs = encp.execute()
    gone = []
    for (k, ktype), v, ttl, enc in zip(planned, vals, ttls, encs):
        if ttl == -2:
            gone.append(k)
            continue
        rec = {'db': db, 'key': k.decode('utf-8', 'backslashreplace'),
               'type': ktype.decode(), 'pttl': ttl, 'encoding': enc.decode() if enc else None}
        payload = json.dumps({'type': ktype.decode(), 'value': v},
                             default=lambda o: o.decode('utf-8', 'backslashreplace'),
                             sort_keys=True, separators=(',', ':'))
        rec['payload'] = payload
        h.update(payload.encode())
        h.update(str(ttl).encode())
        out.write(json.dumps(rec, sort_keys=True, separators=(',', ':'),
                             default=lambda o: o.decode('utf-8', 'backslashreplace')) + '\n')
        total_records += 1
    if gone:
        print('WARNING: %d keys vanished (expired?) mid-scan in db%d: %r'
              % (len(gone), db, gone[:5]), file=sys.stderr)
    summary['dbs'][db] = {'keys': len(keys) - len(gone), 'digest': h.hexdigest(),
                          'gone_midscan': len(gone)}

out.close()
summary['finished'] = time.time()
summary['duration_s'] = round(summary['finished'] - summary['started'], 3)
summary['total_records'] = total_records
with open(OUT + '.summary.json', 'w') as f:
    json.dump(summary, f, indent=2)
print(json.dumps(summary, indent=2))
EOF
echo written

18  $ cd /root/migration && python3 fingerprint.py 6379 /root/migration/source_before.jsonl 2>&1 | tail -40

19  $ cd /root/migration && python3 - <<'EOF'
import re
src = open('fingerprint.py').read()
src = src.replace("dbs = sorted({0, 2} | {int(k.split('d')[1]) for k in keyspace\n                       if k.startswith('db')})",
                  "dbs = sorted({0, 2} | {int(str(k)[2:]) for k in keyspace\n                       if str(k).startswith(\"b'db\")})")
open('fingerprint.py','w').write(src)
EOF
python3 fingerprint.py 6379 /root/migration/source_before.jsonl 2>&1 | tail -30

20  $ cd /root/migration && ls -la; echo ---; python3 fingerprint.py 6379 /root/migration/source_before.jsonl; echo "exit=$?"

21  $ free -m; echo ---; cat /sys/fs/cgroup/memory.max 2>/dev/null || cat /sys/fs/cgroup/memory/memory.limit_in_bytes 2>/dev/null; echo ---; dmesg 2>/dev/null | tail -5; journalctl -k 2>/dev/null | grep -i -m3 oom; echo ---; cat /sys/fs/cgroup/memory.peak 2>/dev/null

22  $ cat /proc/self/cgroup; echo ---; CG=$(sed 's/0:://' /proc/self/cgroup); echo "cgroup: $CG"; cat /sys/fs/cgroup$CG/memory.current 2>/dev/null; echo --- top procs by RSS ---; ps -eo pid,rss,comm --sort=-rss | head -15; echo --- procs in my cgroup ---; for p in $(cat /sys/fs/cgroup$CG/cgroup.procs 2>/dev/null); do ps -o pid,rss,comm= -p $p 2>/dev/null; done | sort -k2 -rn | head

23  $ cd /root/migration && python3 - <<'EOF'
import resource, redis
def rss():
    return resource.getrusage(resource.RUSAGE_SELF).ru_maxrss // 1024
r = redis.Redis(host='127.0.0.1', port=6379, decode_responses=False, socket_timeout=30)
print('after connect, maxrss MB:', rss())
ks = r.info('keyspace')
print('keyspace:', ks, 'maxrss MB:', rss())
keys = list(r.scan_iter(db=0, count=1000))
print('db0 keys:', len(keys), 'maxrss MB:', rss())
tp = r.pipeline(transaction=False)
for k in keys[:100]:
    tp.type(k)
tt = tp.execute()
print('typed 100, maxrss MB:', rss())
EOF

24  $ cd /root/migration && python3 - <<'EOF'
import resource, redis
def rss(): return resource.getrusage(resource.RUSAGE_SELF).ru_maxrss // 1024
r = redis.Redis(host='127.0.0.1', port=6379, decode_responses=False, socket_timeout=30)
keys = list(r.scan_iter(db=0, count=1000))
tp = r.pipeline(transaction=False)
for k in keys: tp.type(k)
kt = tp.execute()
print('all types ok', len(kt), 'maxrss MB:', rss())
vp = r.pipeline(transaction=False)
n=0
for k, t in zip(keys, kt):
    t2 = t if isinstance(t, bytes) else t.encode()
    if t2 == b'string': vp.execute_command('GET', k)
    elif t2 == b'list': vp.execute_command('LRANGE', k, 0, -1)
    elif t2 == b'hash': vp.execute_command('HGETALL', k)
    elif t2 == b'set': vp.execute_command('SMEMBERS', k)
    elif t2 == b'zset': vp.execute_command('ZRANGE', k, 0, -1, 'WITHSCORES')
    elif t2 == b'stream': vp.execute_command('XRANGE', k, '-', '+')
    n+=1
vals = vp.execute()
print('all values ok', n, 'maxrss MB:', rss())
import sys
sz = sum(sys.getsizeof(v) if not isinstance(v, list) else sum(sys.getsizeof(x) for x in v) for v in vals)
print('approx vals bytes:', sz)
EOF

25  $ cd /root/migration && python3 - <<'EOF'
src = open('fingerprint.py').read()
# add progress + rss tracking
src = src.replace("import hashlib, json, sys, time",
                  "import hashlib, json, sys, time, resource\ndef _rss(): return resource.getrusage(resource.RUSAGE_SELF).ru_maxrss // 1024\n_dbg = __import__('os').environ.get('FP_DEBUG')")
src = src.replace("    vals = vp.execute()", "    vals = vp.execute()\n    if _dbg: print('DBG db%d values fetched rss=%dMB' % (db, _rss()), flush=True)")
src = src.replace("    ttls = ttlp.execute()", "    ttls = ttlp.execute()\n    if _dbg: print('DBG db%d ttls rss=%dMB' % (db, _rss()), flush=True)")
src = src.replace("    encs = encp.execute()", "    encs = encp.execute()\n    if _dbg: print('DBG db%d encs rss=%dMB' % (db, _rss()), flush=True)")
src = src.replace("        total_records += 1", "        total_records += 1\n        if _dbg and total_records % 200 == 0: print('DBG rec %d rss=%dMB' % (total_records, _rss()), flush=True)")
open('fingerprint.py','w').write(src)
EOF
FP_DEBUG=1 timeout 120 /usr/bin/time -v python3 fingerprint.py 6379 /root/migration/source_before.jsonl 2>&1 | grep -E 'DBG|Maximum resident|Exit|Command|rec ' | head -30

26  $ cd /root/migration && ls -la source_before.jsonl; FP_DEBUG=1 timeout 120 python3 fingerprint.py 6379 /root/migration/source_before.jsonl; echo "exit=$?"; wc -l source_before.jsonl

27  $ cd /root/migration && python3 -c "import ast; ast.parse(open('fingerprint.py').read()); print('syntax OK')"; grep -n "def _rss\|_dbg\|import resource" fingerprint.py | head; echo ---; sed -n '1,30p' fingerprint.py

28  $ cd /root/migration && bash -c 'ulimit -v 700000; FP_DEBUG=1 python3 fingerprint.py 6379 /tmp/fp.jsonl' 2>&1 | head -20; echo "exit=$?"; echo ---peak---; cat /sys/fs/cgroup/memory.peak

29  $ cd /root/migration && python3 - <<'EOF'
import redis
r = redis.Redis(host='127.0.0.1', port=6379, decode_responses=False)
p = r.pipeline(transaction=False)
x = p.execute_command('SMEMBERS', 'tags:001')
print('return type in queue mode:', type(x))
try:
    s = sorted(x)
    print('sorted ok ->', s)
except Exception as e:
    print('sorted raised:', type(e).__name__, str(e)[:120])
EOF
python3 -c "
import redis, inspect
from redis.client import Pipeline
print([m for m in dir(Pipeline) if 'iter' in m or m=='__len__'])
import redis.client as c
src = inspect.getsource(Pipeline.__len__) if hasattr(Pipeline,'__len__') else 'nolen'
print(src)
"

30  $ cd /root/migration && bash -c 'ulimit -v 700000; FP_DEBUG=1 python3 fingerprint.py 6379 /tmp/fp.jsonl' > /tmp/fp.err 2>&1; echo "exit=$?"; wc -l /tmp/fp.err; tail -40 /tmp/fp.err

31  $ cd /root/migration && sed -n '85,135p' fingerprint.py

32  $ cat > /root/migration/fingerprint.py <<'PYEOF'
#!/usr/bin/env python3
"""Deep canonical fingerprint of a Redis/Valkey instance.
Per DB: every key -> (type, canonical value, PTTL). Streams include consumer
groups, consumers and PELs. Writes JSONL + per-DB sha256 digests.
IMPORTANT: pipelines are only used for queueing; all post-processing happens
AFTER execute() (iterating/sorting a queued Pipeline would recurse forever).
"""
import hashlib, json, sys, time
import redis

PORT = int(sys.argv[1])
OUT = sys.argv[2]

def client(db):
    return redis.Redis(host='127.0.0.1', port=PORT, decode_responses=False,
                       db=db, socket_timeout=60)

def flat_pairs(arr):
    return [(arr[i], arr[i+1]) for i in range(0, len(arr), 2)]

def queue_value(pipe, key, ktype):
    if ktype == b'string':
        pipe.execute_command('GET', key); return 'raw'
    if ktype == b'list':
        pipe.execute_command('LRANGE', key, 0, -1); return 'raw'
    if ktype == b'hash':
        pipe.execute_command('HGETALL', key); return 'hash'
    if ktype == b'set':
        pipe.execute_command('SMEMBERS', key); return 'set'
    if ktype == b'zset':
        pipe.execute_command('ZRANGE', key, 0, -1, 'WITHSCORES'); return 'zpairs'
    if ktype == b'stream':
        pipe.execute_command('XRANGE', key, '-', '+')
        pipe.execute_command('XINFO', 'GROUPS', key)
        return 'stream1'
    raise RuntimeError('unhandled type %r' % ktype)

def canon_value(ktype, tag, raw, stream_extra):
    """Return canonical (json-serializable) value for a key."""
    if tag == 'raw':
        return raw
    if tag == 'hash':
        return sorted(flat_pairs(raw), key=lambda kv: kv[0])
    if tag == 'set':
        return sorted(raw)
    if tag == 'zpairs':
        return [(raw[i], raw[i+1]) for i in range(0, len(raw), 2)]
    if tag == 'stream1':
        entries_raw, groups_raw = raw[0], raw[1]
        entries = [[eid, [[f[i], f[i+1]] for i in range(0, len(f), 2)]]
                   for eid, f in entries_raw]
        groups = []
        for g in groups_raw:
            gd = dict(flat_pairs(g))
            groups.append({'name': gd[b'name'],
                           'last-delivered-id': gd.get(b'last-delivered-id'),
                           'entries-read': gd.get(b'entries-read'),
                           'lag': gd.get(b'lag'),
                           'group-pending': gd.get(b'pending')})
        return {'entries': entries, 'groups': groups,
                '_gdetail': stream_extra or []}
    raise RuntimeError(tag)

def attach_stream_detail(stream_vals, stream_keys):
    """Second pass: per (key, group) consumers + full PEL."""
    jobs = []  # (stream_key_idx, gname)
    detail_pipe = stream_vals[0].__class__  # placeholder, replaced below
    return jobs

def main():
    t0 = time.time()
    keyspace_raw = redis.Redis(host='127.0.0.1', port=PORT,
                               decode_responses=True).info('keyspace')
    dbs = sorted(int(k[2:]) for k in keyspace_raw if k.startswith('db'))
    out = open(OUT, 'w')
    summary = {'port': PORT, 'dbs': {}}
    total = 0
    for db in dbs:
        r = client(db)
        keys = list(r.scan_iter(count=1000))
        if not keys:
            summary['dbs'][db] = {'keys': 0,
                'digest': hashlib.sha256(b'EMPTY').hexdigest()}
            continue
        tp = r.pipeline(transaction=False)
        for k in keys: tp.type(k)
        kt = tp.execute()

        vp = r.pipeline(transaction=False)
        tags = []
        for k, t in zip(keys, kt):
            t = t if isinstance(t, bytes) else str(t).encode()
            tags.append(queue_value(vp, k, t))
        ttlp = r.pipeline(transaction=False)
        for k in keys: ttlp.pttl(k)
        raws = vp.execute()
        ttls = ttlp.execute()

        # stream detail pass (consumers + PEL per group)
        detail_jobs = []
        dp = r.pipeline(transaction=False)
        for k, tag, raw in zip(keys, tags, raws):
            if tag != 'stream1':
                continue
            groups_raw = raw[1]
            for g in groups_raw:
                gname = dict(flat_pairs(g))[b'name']
                dp.execute_command('XINFO', 'CONSUMERS', k, gname)
                dp.execute_command('XPENDING', k, gname,
                                   'IDLE', 0, '-', '+', 1000000)
                detail_jobs.append((k, gname))
        dres = dp.execute() if detail_jobs else []
        detail = {k: {} for k, _, in detail_jobs}
        for i, (k, gname) in enumerate(detail_jobs):
            cons_raw, pel_raw = dres[2*i], dres[2*i+1]
            consumers = []
            for c in cons_raw:
                cd = dict(flat_pairs(c))
                consumers.append({'name': cd.get(b'name'),
                                  'pending': cd.get(b'pending'),
                                  'idle_ms': cd.get(b'idle'),
                                  'inactive_ms': cd.get(b'inactive')})
            pel = [{'id': p[0], 'consumer': p[1],
                    'ms_since_delivery': p[2], 'delivery_count': p[3]}
                   for p in pel_raw]
            detail[k][gname] = {'consumers': consumers, 'pel': pel}

        h = hashlib.sha256()
        gone = []
        for k, tag, raw, ttl in zip(keys, tags, raws, ttls):
            if ttl == -2:
                gone.append(k)
                continue
            t = [x for x, kk in zip(kt, keys) if kk == k][0]
            t = t if isinstance(t, bytes) else str(t).encode()
            extra = detail.get(k) if tag == 'stream1' else None
            val = canon_value(t, tag, raw, extra)
            if tag == 'stream1':
                for g in val['groups']:
                    d = extra.get(g['name'], {'consumers': [], 'pel': []})
                    g['consumers'] = d['consumers']
                    g['pel'] = d['pel']
                val.pop('_gdetail', None)
            payload = json.dumps({'type': t.decode(),
                                  'value': val,
                                  'pttl': ttl},
                                 default=lambda o: o.decode('utf-8',
                                                            'backslashreplace'),
                                 sort_keys=True, separators=(',', ':'))
            h.update(payload.encode())
            out.write(json.dumps({'db': db,
                                  'key': k.decode('utf-8', 'backslashreplace'),
                                  'payload': json.loads(payload)},
                                 sort_keys=True,
                                 separators=(',', ':'),
                                 default=lambda o: o.decode(
                                     'utf-8', 'backslashreplace')) + '\n')
            total += 1
        if gone:
            print('WARNING: %d keys expired mid-scan in db%d: %r'
                  % (len(gone), db, gone[:5]), file=sys.stderr)
        summary['dbs'][db] = {'keys': len(keys) - len(gone),
                              'gone_midscan': len(gone),
                              'digest': h.hexdigest()}
    out.close()
    summary['total_records'] = total
    summary['duration_s'] = round(time.time() - t0, 2)
    with open(OUT + '.summary.json', 'w') as f:
        json.dump(summary, f, indent=2)
    print(json.dumps(summary, indent=2))

if __name__ == '__main__':
    main()
PYEOF
python3 -c "import ast; ast.parse(open('/root/migration/fingerprint.py').read()); print('syntax OK')"

33  $ cd /root/migration && bash -c 'ulimit -v 700000; python3 fingerprint.py 6379 /root/migration/source_before.jsonl' 2>&1 | tail -30; echo "exit=$?"; wc -l /root/migration/source_before.jsonl

34  $ cd /root/migration && python3 - <<'EOF'
import redis
r = redis.Redis(host='127.0.0.1', port=6379, decode_responses=False, db=0)
k = b'events:06'
p = r.pipeline(transaction=False)
p.execute_command('XRANGE', k, '-', '+')
p.execute_command('XINFO', 'GROUPS', k)
a, b = p.execute()
print('XRANGE entries:', len(a), 'first:', a[0])
print('GROUPS type:', type(b), 'len:', len(b))
print('GROUPS[0]:', b[0])
print('GROUPS[0] len:', len(b[0]))
for i, e in enumerate(b[0]): print(' ', i, e)
EOF

35  $ cd /root/migration && python3 - <<'EOF'
src = open('fingerprint.py').read()
src = src.replace("""def flat_pairs(arr):
    return [(arr[i], arr[i+1]) for i in range(0, len(arr), 2)]""",
"""def flat_pairs(arr):
    return [(arr[i], arr[i+1]) for i in range(0, len(arr), 2)]

def to_dict(x):
    \"\"\"XINFO GROUPS/CONSUMERS may arrive as dicts (redis-py callbacks)
    or as flat [k1,v1,k2,v2,...] lists; handle both.\"\"\"
    if isinstance(x, dict):
        return x
    return dict(flat_pairs(x))""")
src = src.replace("gname = dict(flat_pairs(g))[b'name']", "gname = to_dict(g)[b'name']")
src = src.replace("cd = dict(flat_pairs(c))", "cd = to_dict(c)")
src = src.replace("gd = dict(flat_pairs(g))", "gd = to_dict(g)")
open('fingerprint.py','w').write(src)
print('patched')
EOF
bash -c 'ulimit -v 700000; python3 fingerprint.py 6379 /root/migration/source_before.jsonl' 2>&1 | tail -25; echo "exit=$?"

36  $ cd /root/migration && python3 - <<'EOF'
src = open('fingerprint.py').read()
src = src.replace("""                gname = to_dict(g)[b'name']""",
"""                try:
                    gname = to_dict(g)[b'name']
                except Exception:
                    print('DEBUG failing g=%r type=%s len=%s; groups_raw=%r'
                          % (g, type(g), getattr(g, '__len__', lambda: 'n/a')(),
                             groups_raw), file=sys.stderr)
                    raise""")
open('fingerprint.py','w').write(src)
EOF
bash -c 'ulimit -v 700000; python3 fingerprint.py 6379 /tmp/fp_dbg.jsonl' 2>&1 | head -15

37  $ cat > /root/migration/fingerprint.py <<'PYEOF'
#!/usr/bin/env python3
"""Deep canonical fingerprint of a Redis/Valkey instance.
Per DB: every key -> (type, canonical value, PTTL). Streams include consumer
groups, consumers and PELs. Writes JSONL + per-DB sha256 digests.
Note: redis-py pipeline results are FLAT (one slot per queued command), so we
consume slots per key by command count. Never iterate/sort a queued Pipeline.
"""
import hashlib, json, sys, time
import redis

PORT = int(sys.argv[1])
OUT = sys.argv[2]

def client(db):
    return redis.Redis(host='127.0.0.1', port=PORT, decode_responses=False,
                       db=db, socket_timeout=60)

def flat_pairs(arr):
    return [(arr[i], arr[i+1]) for i in range(0, len(arr), 2)]

def to_dict(x):
    """XINFO GROUPS/CONSUMERS may arrive as dicts (redis-py callbacks) or flat
    [k1,v1,...] lists."""
    if isinstance(x, dict):
        return x
    return dict(flat_pairs(x))

def queue_value(pipe, key, ktype):
    """Queue value-fetch command(s). Returns (tag, n_commands)."""
    if ktype == b'string':
        pipe.execute_command('GET', key); return 'raw', 1
    if ktype == b'list':
        pipe.execute_command('LRANGE', key, 0, -1); return 'raw', 1
    if ktype == b'hash':
        pipe.execute_command('HGETALL', key); return 'hash', 1
    if ktype == b'set':
        pipe.execute_command('SMEMBERS', key); return 'set', 1
    if ktype == b'zset':
        pipe.execute_command('ZRANGE', key, 0, -1, 'WITHSCORES'); return 'zpairs', 1
    if ktype == b'stream':
        pipe.execute_command('XRANGE', key, '-', '+')
        pipe.execute_command('XINFO', 'GROUPS', key)
        return 'stream', 2
    raise RuntimeError('unhandled type %r' % ktype)

def main():
    t0 = time.time()
    boot = redis.Redis(host='127.0.0.1', port=PORT, decode_responses=True)
    dbs = sorted(int(k[2:]) for k in boot.info('keyspace') if k.startswith('db'))
    out = open(OUT, 'w')
    summary = {'port': PORT, 'dbs': {}}
    total = 0

    def jd(o):
        return o.decode('utf-8', 'backslashreplace')

    for db in dbs:
        r = client(db)
        keys = list(r.scan_iter(count=1000))
        if not keys:
            summary['dbs'][db] = {'keys': 0,
                'digest': hashlib.sha256(b'EMPTY').hexdigest()}
            continue
        tp = r.pipeline(transaction=False)
        for k in keys: tp.type(k)
        kt = [t if isinstance(t, bytes) else str(t).encode() for t in tp.execute()]

        # plan: queue value fetches; remember per-key command counts
        vp = r.pipeline(transaction=False)
        plan = []  # (idx_in_keys, tag, ncmds)
        for i, (k, t) in enumerate(zip(keys, kt)):
            tag, n = queue_value(vp, k, t)
            plan.append((i, tag, n))
        ttlp = r.pipeline(transaction=False)
        for k in keys: ttlp.pttl(k)

        raws = vp.execute()
        ttls = ttlp.execute()

        # consume flat result slots per key
        per_key = [None] * len(keys)
        idx = 0
        for i, tag, n in plan:
            per_key[i] = (tag, raws[idx:idx+n])
            idx += n
        assert idx == len(raws), 'slot misalignment: %d vs %d' % (idx, len(raws))

        # second pass for stream group detail (consumers + PEL)
        detail_jobs = []
        dp = r.pipeline(transaction=False)
        for i, (k, t) in enumerate(zip(keys, kt)):
            tag, res = per_key[i]
            if tag != 'stream':
                continue
            for g in res[1]:
                gname = to_dict(g)[b'name']
                dp.execute_command('XINFO', 'CONSUMERS', k, gname)
                dp.execute_command('XPENDING', k, gname,
                                   'IDLE', 0, '-', '+', 1000000)
                detail_jobs.append((k, gname))
        dres = dp.execute() if detail_jobs else []
        detail = {}
        for j, (k, gname) in enumerate(detail_jobs):
            cons_raw, pel_raw = dres[2*j], dres[2*j+1]
            consumers = []
            for c in cons_raw:
                cd = to_dict(c)
                consumers.append({'name': cd.get(b'name'),
                                  'pending': cd.get(b'pending'),
                                  'idle_ms': cd.get(b'idle'),
                                  'inactive_ms': cd.get(b'inactive')})
            pel = [{'id': p[0], 'consumer': p[1],
                    'ms_since_delivery': p[2], 'delivery_count': p[3]}
                   for p in pel_raw]
            detail.setdefault(k, {})[gname] = {'consumers': consumers,
                                               'pel': pel}

        h = hashlib.sha256()
        gone = []
        for i, (k, t, ttl) in enumerate(zip(keys, kt, ttls)):
            if ttl == -2:
                gone.append(k)
                continue
            tag, res = per_key[i]
            if tag == 'raw':
                val = res[0]
            elif tag == 'hash':
                val = sorted(flat_pairs(res[0]), key=lambda kv: kv[0])
            elif tag == 'set':
                val = sorted(res[0])
            elif tag == 'zpairs':
                z = res[0]; val = [(z[j], z[j+1]) for j in range(0, len(z), 2)]
            elif tag == 'stream':
                entries_raw, groups_raw = res[0], res[1]
                entries = [[eid, [[f[j], f[j+1]] for j in range(0, len(f), 2)]]
                           for eid, f in entries_raw]
                groups = []
                for g in groups_raw:
                    gd = to_dict(g)
                    gname = gd[b'name']
                    d = detail.get(k, {}).get(gname,
                                              {'consumers': [], 'pel': []})
                    groups.append({'name': gname,
                                   'last-delivered-id': gd.get(b'last-delivered-id'),
                                   'entries-read': gd.get(b'entries-read'),
                                   'lag': gd.get(b'lag'),
                                   'group-pending': gd.get(b'pending'),
                                   'consumers': d['consumers'],
                                   'pel': d['pel']})
                val = {'entries': entries, 'groups': groups}
            else:
                raise RuntimeError(tag)
            payload = json.dumps({'type': jd(t), 'value': val, 'pttl': ttl},
                                 default=jd, sort_keys=True,
                                 separators=(',', ':'))
            h.update(payload.encode())
            out.write(json.dumps({'db': db, 'key': jd(k), 'payload': payload},
                                 sort_keys=True, separators=(',', ':')) + '\n')
            total += 1
        if gone:
            print('WARNING: %d keys expired mid-scan in db%d: %r'
                  % (len(gone), db, [x.decode() for x in gone[:5]]),
                  file=sys.stderr)
        summary['dbs'][db] = {'keys': len(keys) - len(gone),
                              'gone_midscan': len(gone),
                              'digest': h.hexdigest()}

    out.close()
    summary['total_records'] = total
    summary['duration_s'] = round(time.time() - t0, 2)
    with open(OUT + '.summary.json', 'w') as f:
        json.dump(summary, f, indent=2)
    print(json.dumps(summary, indent=2))

if __name__ == '__main__':
    main()
PYEOF
python3 -c "import ast; ast.parse(open('/root/migration/fingerprint.py').read()); print('syntax OK')"
bash -c 'ulimit -v 700000; python3 /root/migration/fingerprint.py 6379 /root/migration/source_before.jsonl' 2>&1 | tail -25; echo "exit=$?"

38  $ redis-cli -p 6379 -n 0 XPENDING events:03 workers IDLE 0 - + 1000000 | head -12; echo ---; redis-cli -p 6379 -n 0 XPENDING events:03 workers | head -8; echo ---; redis-cli -p 6379 -n 0 XINFO CONSUMERS events:03 workers

39  $ cd /root/migration && python3 - <<'EOF'
src = open('fingerprint.py').read()
src = src.replace("""def client(db):
    return redis.Redis(host='127.0.0.1', port=PORT, decode_responses=False,
                       db=db, socket_timeout=60)""",
"""def client(db):
    r = redis.Redis(host='127.0.0.1', port=PORT, decode_responses=False,
                    db=db, socket_timeout=60)
    # redis-py's built-in XPENDING parser targets the summary form; we use the
    # extended form and parse rows ourselves.
    r.set_response_callback('XPENDING', lambda x: x)
    return r""")
open('fingerprint.py','w').write(src)
print('patched')
EOF
bash -c 'ulimit -v 700000; python3 /root/migration/fingerprint.py 6379 /root/migration/source_before.jsonl' 2>&1 | tail -25; echo "exit=$?"

40  $ cd /root/migration && python3 - <<'EOF'
src = open('fingerprint.py').read()
src = src.replace("""def flat_pairs(arr):
    return [(arr[i], arr[i+1]) for i in range(0, len(arr), 2)]""",
"""def flat_pairs(arr):
    return [(arr[i], arr[i+1]) for i in range(0, len(arr), 2)]

def as_items(x):
    \"\"\"Hash replies may be dicts (redis-py callbacks) or flat [k1,v1,...];
    return list of (field, value) pairs either way.\"\"\"
    if isinstance(x, dict):
        return list(x.items())
    return flat_pairs(x)""")
src = src.replace("val = sorted(flat_pairs(res[0]), key=lambda kv: kv[0])",
                  "val = sorted(as_items(res[0]), key=lambda kv: kv[0])")
open('fingerprint.py','w').write(src)
print('patched')
EOF
bash -c 'ulimit -v 700000; python3 /root/migration/fingerprint.py 6379 /root/migration/source_before.jsonl' 2>&1 | tail -25; echo "exit=$?"

41  $ cd /root/migration && python3 - <<'EOF'
import redis
r = redis.Redis(host='127.0.0.1', port=6379, decode_responses=False, db=0)
p = r.pipeline(transaction=False)
p.execute_command('ZRANGE', 'leaderboard:033', 0, -1, 'WITHSCORES')
p.execute_command('ZRANGE', 'leaderboard:033', 0, -1, 'WITHSCORES', 'REV')
z = p.execute()
print('fwd:', z[0])
print('rev:', z[1])
EOF

42  $ cd /root/migration && python3 - <<'EOF'
src = open('fingerprint.py').read()
src = src.replace("""def as_items(x):""",
"""def score_pairs(x):
    \"\"\"ZRANGE WITHSCORES may be [(member, float), ...] (redis-py callback)
    or flat [m1, s1, m2, s2, ...]; normalize to [(member, score), ...].\"\"\"
    if not x:
        return []
    if isinstance(x[0], (tuple, list)):
        return [(m, s) for m, s in x]
    return [(x[i], x[i+1]) for i in range(0, len(x), 2)]

def as_items(x):""")
src = src.replace("z = res[0]; val = [(z[j], z[j+1]) for j in range(0, len(z), 2)]",
                  "val = score_pairs(res[0])")
open('fingerprint.py','w').write(src)
print('patched')
EOF
bash -c 'ulimit -v 700000; python3 /root/migration/fingerprint.py 6379 /root/migration/source_before.jsonl' 2>&1 | tail -25; echo "exit=$?"

43  $ cd /root/migration && python3 - <<'EOF'
src = open('fingerprint.py').read()
src = src.replace("""def score_pairs(x):""",
"""def stream_entries(x):
    \"\"\"XRANGE reply -> canonical [[id, [[field, value], ...]], ...].
    Handles redis-py pre-parsed [(id, {field: value}), ...] and the raw flat
    form [(id, [f1, v1, f2, v2...]), ...] / [[id, f1, v1, ...], ...].\"\"\"
    out = []
    for ent in x:
        if isinstance(ent, (tuple, list)) and len(ent) == 2:
            eid, fields = ent
        else:
            eid, fields = ent[0], ent[1:]
        if isinstance(fields, dict):
            pairs = [[k, v] for k, v in fields.items()]
        elif isinstance(fields, (list, tuple)):
            pairs = [[fields[i], fields[i+1]] for i in range(0, len(fields), 2)]
        else:
            raise RuntimeError('odd stream fields %r' % (fields,))
        out.append([eid, pairs])
    return out

def score_pairs(x):""")
src = src.replace("""                entries = [[eid, [[f[j], f[j+1]] for j in range(0, len(f), 2)]]
                           for eid, f in entries_raw]""",
"""                entries = stream_entries(entries_raw)""")
open('fingerprint.py','w').write(src)
print('patched')
EOF
bash -c 'ulimit -v 700000; python3 /root/migration/fingerprint.py 6379 /root/migration/source_before.jsonl' 2>&1 | tail -25; echo "exit=$?"

44  $ cd /root/migration && python3 - <<'EOF'
src = open('fingerprint.py').read()
# hash ttl_flag (presence), not magnitude; keep pttl in JSONL for per-key TTL check
src = src.replace("""            payload = json.dumps({'type': jd(t), 'value': val, 'pttl': ttl},
                                 default=jd, sort_keys=True,
                                 separators=(',', ':'))""",
"""            payload = json.dumps({'type': jd(t), 'value': val,
                                  'ttl_flag': ttl > 0},
                                 default=jd, sort_keys=True,
                                 separators=(',', ':'))""")
src = src.replace("""            out.write(json.dumps({'db': db, 'key': jd(k), 'payload': payload},
                                 sort_keys=True, separators=(',', ':')) + '\\n')""",
"""            out.write(json.dumps({'db': db, 'key': jd(k), 'pttl': ttl,
                                  'payload': payload},
                                 sort_keys=True, separators=(',', ':')) + '\\n')""")
open('fingerprint.py','w').write(src)
print('patched')
EOF
bash -c 'ulimit -v 700000; python3 /root/migration/fingerprint.py 6379 /root/migration/src_run1.jsonl' 2>&1 | python3 -c "import sys,json; d=json.load(sys.stdin); print({k: v['digest'][:16] for k,v in d['dbs'].items()})"
bash -c 'ulimit -v 700000; python3 /root/migration/fingerprint.py 6379 /root/migration/src_run2.jsonl' 2>&1 | python3 -c "import sys,json; d=json.load(sys.stdin); print({k: v['digest'][:16] for k,v in d['dbs'].items()})"
echo '--- record-level determinism (ignoring pttl) ---'
python3 - <<'EOF'
import json
def load(p):
    d = {}
    for line in open(p):
        r = json.loads(line)
        d[(r['db'], r['key'])] = r['payload']
    return d
a, b = load('/root/migration/src_run1.jsonl'), load('/root/migration/src_run2.jsonl')
print('same key sets:', a.keys() == b.keys(), 'same payloads:', a == b)
print('total keys:', len(a))
EOF

45  $ cd /root/migration && python3 - <<'EOF'
import json
def load(p):
    d = {}
    for line in open(p):
        r = json.loads(line)
        d[(r['db'], r['key'])] = r['payload']
    return d
a, b = load('src_run1.jsonl'), load('src_run2.jsonl')
diff = [k for k in a if a[k] != b[k]]
print('differing keys:', len(diff))
for k in diff[:3]:
    print('KEY', k)
    print('  run1:', a[k][:400])
    print('  run2:', b[k][:400])
EOF

46  $ cd /root/migration && python3 - <<'EOF'
import json
def load(p):
    d = {}
    for line in open(p):
        r = json.loads(line)
        d[(r['db'], r['key'])] = r['payload']
    return d
a, b = load('src_run1.jsonl'), load('src_run2.jsonl')
for k in [(0, 'events:03')]:
    ja, jb = json.loads(a[k]), json.loads(b[k])
    va, vb = ja['value'], jb['value']
    print('entries equal:', va['entries'] == vb['entries'])
    ga, gb = va['groups'], vb['groups']
    print('n groups:', len(ga), len(gb))
    for x, y in zip(ga, gb):
        print('group', x['name'], 'name eq:', x['name'] == y['name'],
              '| ldi eq:', x['last-delivered-id'] == y['last-delivered-id'],
              x['last-delivered-id'], y['last-delivered-id'],
              '| entries-read:', x.get('entries-read'), y.get('entries-read'),
              '| lag:', x.get('lag'), y.get('lag'),
              '| group-pending:', x.get('group-pending'), y.get('group-pending'))
        pa, pb = x['pel'], y['pel']
        if pa != pb:
            print('   PEL differs: run1 n=%d run2 n=%d' % (len(pa), len(pb)))
            for i, (p, q) in enumerate(zip(pa, pb)):
                if p != q:
                    print('   first diff at %d: %s vs %s' % (i, p, q))
                    break
        else:
            print('   PEL equal (%d entries)' % len(pa))
        if x['consumers'] != y['consumers']:
            print('   CONSUMERS differ:', x['consumers'], y['consumers'])
EOF

47  $ cd /root/migration && python3 - <<'EOF'
src = open('fingerprint.py').read()

# consumers: keep only structural fields
src = src.replace("""                consumers.append({'name': cd.get(b'name'),
                                  'pending': cd.get(b'pending'),
                                  'idle_ms': cd.get(b'idle'),
                                  'inactive_ms': cd.get(b'inactive')})""",
"""                # idle/inactive are clock-relative -> excluded from digest
                consumers.append({'name': cd.get(b'name'),
                                  'pending': cd.get(b'pending')})""")

# PEL: drop ms_since_delivery (clock-relative)
src = src.replace("""            pel = [{'id': p[0], 'consumer': p[1],
                    'ms_since_delivery': p[2], 'delivery_count': p[3]}
                   for p in pel_raw]""",
"""            # ms_since_delivery is clock-relative -> excluded from digest
            pel = [{'id': p[0], 'consumer': p[1],
                    'delivery_count': p[3]} for p in pel_raw]""")

# add PEXPIRETIME pipeline for absolute TTL verification
src = src.replace("""        ttlp = r.pipeline(transaction=False)
        for k in keys: ttlp.pttl(k)

        raws = vp.execute()
        ttls = ttlp.execute()""",
"""        ttlp = r.pipeline(transaction=False)
        for k in keys: ttlp.pttl(k)
        expp = r.pipeline(transaction=False)
        for k in keys: expp.execute_command('PEXPIRETIME', k)

        raws = vp.execute()
        ttls = ttlp.execute()
        exps = expp.execute()""")

# persist absolute expiry + remaining ttl in JSONL
src = src.replace("""        for i, (k, t, ttl) in enumerate(zip(keys, kt, ttls)):""",
"""        for i, (k, t, ttl) in enumerate(zip(keys, kt, ttls)):
            exp = exps[i]""")
src = src.replace("""            out.write(json.dumps({'db': db, 'key': jd(k), 'pttl': ttl,
                                  'payload': payload},
                                 sort_keys=True, separators=(',', ':')) + '\\n')""",
"""            out.write(json.dumps({'db': db, 'key': jd(k), 'pttl': ttl,
                                  'pexpiretime': exp,
                                  'payload': payload},
                                 sort_keys=True, separators=(',', ':')) + '\\n')""")
open('fingerprint.py','w').write(src)
print('patched')
EOF
bash -c 'ulimit -v 700000; python3 /root/migration/fingerprint.py 6379 /root/migration/src_run1.jsonl' | python3 -c "import sys,json; d=json.load(sys.stdin); print('run1', {k: v['digest'][:16] for k,v in d['dbs'].items()})"
bash -c 'ulimit -v 700000; python3 /root/migration/fingerprint.py 6379 /root/migration/src_run2.jsonl' | python3 -c "import sys,json; d=json.load(sys.stdin); print('run2', {k: v['digest'][:16] for k,v in d['dbs'].items()})"
python3 - <<'EOF'
import json
def load(p):
    d = {}
    for line in open(p):
        r = json.loads(line)
        d[(r['db'], r['key'])] = (r['payload'], r['pexpiretime'])
    return d
a, b = load('/root/migration/src_run1.jsonl'), load('/root/migration/src_run2.jsonl')
print('records:', len(a), '| key sets equal:', a.keys()==b.keys())
print('payloads identical (incl. digest input):', all(a[k][0]==b[k][0] for k in a))
print('PEXPIRETIME identical across runs:', all(a[k][1]==b[k][1] for k in a))
n_ttl = sum(1 for v in a.values() if v[1] is not None and v[1] > 0)
print('keys with absolute expiry:', n_ttl)
EOF

48  $ cd /root/migration && cp src_run1.jsonl source_before.jsonl && cp src_run1.jsonl.summary.json source_before.summary.json && cat source_before.summary.json && echo && echo '=== baseline digests ===' && python3 -c "
import json
d = json.load(open('source_before.summary.json'))
for k, v in d['dbs'].items(): print('db%s: %s (%d keys)' % (k, v['digest'], v['keys']))
" && echo '=== source role/state ===' && redis-cli -p 6379 INFO replication | grep -E '^role|^master_replid:' && redis-cli -p 6379 DBSIZE && redis-cli -p 6379 -n 2 DBSIZE && redis-cli -p 6379 CONFIG GET notify-keyspace-events

49  $ echo '=== target dbsize sweep (all 16 DBs) ==='; for i in $(seq 0 15); do n=$(valkey-cli -p 6380 -n $i DBSIZE); [ "$n" != "0" ] && echo "db$i=$n"; done; echo '(no output above = all empty)'; echo; echo '=== target keyspace ==='; valkey-cli -p 6380 INFO keyspace; echo '=== target role ==='; valkey-cli -p 6380 INFO replication | grep -E '^role'; echo; echo '=== configure target for validated diskless load ==='; valkey-cli -p 6380 CONFIG SET repl-diskless-load swapped key-load-delay 0; valkey-cli -p 6380 CONFIG GET repl-diskless-load key-load-delay; echo; echo '=== source untouched check (config unchanged) ==='; redis-cli -p 6379 CONFIG GET repl-diskless-sync repl-diskless-sync-delay appendonly save | paste - -

50  $ valkey-cli -p 6380 CONFIG SET repl-diskless-load on-empty-db; valkey-cli -p 6380 CONFIG GET repl-diskless-load key-load-delay; echo '=== attach as replica of 6379 ==='; valkey-cli -p 6380 REPLICAOF 127.0.0.1 6379; sleep 2; valkey-cli -p 6380 INFO replication | grep -E 'role|master_host|master_port|master_link_status|master_sync_in_progress|master_repl_offset|slave_repl_offset|loading:'

51  $ for i in $(seq 1 12); do st=$(valkey-cli -p 6380 INFO replication | grep -E '^master_link_status|^master_sync_in_progress|^slave_repl_offset|^role' | tr '\n' ' '); echo "t=$i s: $st"; sleep 1; if echo "$st" | grep -q 'master_link_status:up' && echo "$st" | grep -q 'role:slave'; then break; fi; done; echo; echo '=== source log (replication events) ==='; tail -15 /var/log/redis-old/redis.log

52  $ echo '=== target keyspace after sync ==='; valkey-cli -p 6380 INFO keyspace; echo '=== target replication ==='; valkey-cli -p 6380 INFO replication | grep -E '^role|master_link_status|master_repl_offset|slave_repl_offset|slave_read_repl_offset|slave_priority'; echo '=== target dbsize ==='; valkey-cli -p 6380 DBSIZE; valkey-cli -p 6380 -n 2 DBSIZE; echo '=== target stream group spot-check ==='; valkey-cli -p 6380 -n 0 XINFO GROUPS events:06; valkey-cli -p 6380 -n 0 XPENDING events:06 workers; echo '=== source: repl status + quick sanity ==='; redis-cli -p 6379 INFO replication | grep -E '^role|connected_slaves|slave0'; redis-cli -p 6379 DBSIZE

53  $ cd /root/migration && bash -c 'ulimit -v 700000; python3 fingerprint.py 6380 /root/migration/replica_check.jsonl' 2>&1 | tail -20

54  $ cd /root/migration && python3 - <<'EOF'
import json
def load(p):
    d = {}
    for line in open(p):
        r = json.loads(line)
        d[(r['db'], r['key'])] = r['payload']
    return d
s = load('source_before.jsonl')
t = load('replica_check.jsonl')
print('key sets equal:', s.keys() == t.keys())
diff = [k for k in s if s[k] != t[k]]
print('differing keys:', len(diff))
from collections import Counter
print('by db:', Counter(k[0] for k in diff))
print('by type:', Counter(json.loads(s[k])['type'] for k in diff))
for k in diff[:2]:
    print('\nKEY', k, json.loads(s[k])['type'])
    a, b = json.loads(s[k])['value'], json.loads(t[k])['value']
    if isinstance(a, dict):
        for f in a:
            if a[f] != b.get(f):
                print('  field differs:', f)
                if f == 'groups':
                    for ga, gb in zip(a[f], b[f]):
                        if ga != gb:
                            for ff in ga:
                                if ga[ff] != gb.get(ff):
                                    print('    group', ga.get('name'), ff,
                                          'src:', str(ga[ff])[:100],
                                          'dst:', str(gb.get(ff))[:100])
                else:
                    print('    src:', str(a[f])[:200])
                    print('    dst:', str(b.get(f))[:200])
    elif isinstance(a, list):
        for i, (x, y) in enumerate(zip(a, b)):
            if x != y:
                print('  idx', i, 'src:', str(x)[:100], 'dst:', str(y)[:100])
                break
EOF

55  $ cd /root/migration && python3 - <<'EOF'
src = open('fingerprint.py').read()
# make per-DB digest order-independent: hash each record, combine sorted hashes
src = src.replace("""        h = hashlib.sha256()
        gone = []""",
"""        rec_hashes = []
        gone = []""")
src = src.replace("""            h.update(payload.encode())""",
"""            rec_hashes.append(hashlib.sha256(payload.encode()).hexdigest())""")
src = src.replace("""        summary['dbs'][db] = {'keys': len(keys) - len(gone),
                              'gone_midscan': len(gone),
                              'digest': h.hexdigest()}""",
"""        ch = hashlib.sha256()
        for rh in sorted(rec_hashes):
            ch.update(rh.encode())
        summary['dbs'][db] = {'keys': len(keys) - len(gone),
                              'gone_midscan': len(gone),
                              'digest': ch.hexdigest()}""")
open('fingerprint.py','w').write(src)
print('patched')
EOF
echo '=== re-fingerprint both sides with order-independent digests ==='
bash -c 'ulimit -v 700000; python3 /root/migration/fingerprint.py 6379 /root/migration/source_final.jsonl' > /root/migration/src_summary.txt 2>&1; tail -3 /root/migration/src_summary.txt
bash -c 'ulimit -v 700000; python3 /root/migration/fingerprint.py 6380 /root/migration/target_check.jsonl' > /root/migration/dst_summary.txt 2>&1; tail -3 /root/migration/dst_summary.txt

56  $ cd /root/migration && python3 - <<'EOF'
import json
src = json.load(open('source_final.jsonl.summary.json'))
dst = json.load(open('target_check.jsonl.summary.json'))
print('SOURCE :', {k: v['digest'][:24] for k, v in src['dbs'].items()})
print('TARGET :', {k: v['digest'][:24] for k, v in dst['dbs'].items()})
match = all(src['dbs'][k]['digest'] == dst['dbs'][k]['digest'] for k in src['dbs'])
print('DIGEST MATCH:', match)

# record-level compare including TTLs
def load(p):
    d = {}
    for line in open(p):
        r = json.loads(line)
        d[(r['db'], r['key'])] = (r['payload'], r['pttl'], r['pexpiretime'])
    return d
s, t = load('source_final.jsonl'), load('target_check.jsonl')
print('key sets equal:', s.keys() == t.keys())
pd = [k for k in s if s[k][0] != t[k][0]]
print('payload diffs:', len(pd))
# TTL checks
worst = 10**18; abs_eq = True; tdiff = []
for k in s:
    a, b = s[k], t[k]
    if a[1] > 0 != b[1] > 0:
        tdiff.append(('presence', k)); continue
    if a[1] > 0:
        # absolute expiry instants must match exactly
        if a[2] != b[2]:
            abs_eq = False; tdiff.append(('pexpiretime', k, a[2], b[2]))
        d = abs(a[1] - b[1])
        worst = min(worst, a[1])
print('absolute expiry (PEXPIRETIME) equal for every expiring key:', abs_eq)
print('smallest source PTTL seen:', worst, 'ms')
print('ttl anomalies:', tdiff[:5] if tdiff else 'none')
EOF

57  $ cd /root/migration && python3 - <<'EOF'
import json
odd = []
for line in open('source_final.jsonl'):
    r = json.loads(line)
    if r['pttl'] is None or r['pttl'] > 1e15 or r['pexpiretime'] is None:
        odd.append(r)
print('odd records:', len(odd))
for r in odd[:5]:
    print(r['db'], r['key'], 'pttl=', r['pttl'], 'pexpiretime=', r['pexpiretime'],
          'payload ttl_flag=', json.loads(r['payload']).get('ttl_flag'))
EOF
echo '=== direct queries ==='
for k in session:01636 session:01770 session:01980; do
  echo "--- $k ---"
  echo "src PTTL: $(redis-cli -p 6379 -n 0 PTTL $k) | src PEXPIRETIME: $(redis-cli -p 6379 -n 0 PEXPIRETIME $k) | src TTL: $(redis-cli -p 6379 -n 0 TTL $k)"
  echo "dst PTTL: $(valkey-cli -p 6380 -n 0 PTTL $k) | dst PEXPIRETIME: $(valkey-cli -p 6380 -n 0 PEXPIRETIME $k) | dst TTL: $(valkey-cli -p 6380 -n 0 TTL $k)"
  echo "src EXISTS: $(redis-cli -p 6379 -n 0 EXISTS $k) | dst EXISTS: $(valkey-cli -p 6380 -n 0 EXISTS $k)"
done

58  $ cd /root/migration && python3 - <<'EOF'
import json
def load(p):
    d = {}
    for line in open(p):
        r = json.loads(line)
        d[(r['db'], r['key'])] = (r['payload'], r['pttl'], r['pexpiretime'])
    return d
s, t = load('source_final.jsonl'), load('target_check.jsonl')
print('keys: src=%d dst=%d | key sets equal: %s' % (len(s), len(t), s.keys()==t.keys()))

n_exp = n_per = n_no = 0
max_ttdiff = 0
abs_mismatch = []
pres_mismatch = []
min_pttl = None
for k in s:
    pttl_s, pttl_d = s[k][1], t[k][1]
    exp_s, exp_d = s[k][2], t[k][2]
    has_s, has_d = pttl_s > 0, pttl_d > 0
    if has_s != has_d:
        pres_mismatch.append(k); continue
    if not has_s:
        n_no += 1
        # persistent keys: PEXPIRETIME must be -1 on both
        if exp_s != -1 or exp_d != -1:
            abs_mismatch.append((k, exp_s, exp_d))
        continue
    n_exp += 1
    if exp_s != exp_d:
        abs_mismatch.append((k, exp_s, exp_d))
    else:
        n_per += 1
    d = abs(pttl_s - pttl_d)
    max_ttdiff = max(max_ttdiff, d)
    min_pttl = pttl_s if min_pttl is None else min(min_pttl, pttl_s)

print('persistent keys:', n_no)
print('keys with TTL: %d, identical absolute expiry: %d' % (n_exp, n_per))
print('presence mismatches:', len(pres_mismatch), pres_mismatch[:5])
print('absolute-expiry mismatches:', len(abs_mismatch), abs_mismatch[:5])
print('largest PTTL delta between servers: %d ms (sampling skew)' % max_ttdiff)
print('smallest source PTTL: %d ms' % min_pttl)
EOF

59  $ cd /root/migration && python3 - <<'EOF'
import json
def load(p):
    d = {}
    for line in open(p):
        r = json.loads(line)
        d[(r['db'], r['key'])] = (r['payload'], r['pttl'], r['pexpiretime'])
    return d
before, now = load('source_before.jsonl'), load('source_final.jsonl')
print('source key sets equal (before vs now):', before.keys() == now.keys())
payload_same = all(before[k][0] == now[k][0] for k in before)
expiry_same = all(before[k][2] == now[k][2] for k in before)
print('source payloads unchanged:', payload_same)
print('source absolute expiries unchanged:', expiry_same)
pttl_drift = max(abs(before[k][1] - now[k][1]) for k in before if before[k][1] > 0)
print('source max PTTL drift (time elapsed, expected): ~%d ms' % pttl_drift)
EOF
echo; echo '=== source server state ==='; redis-cli -p 6379 INFO replication | grep -E '^role|connected_slaves'; redis-cli -p 6379 DBSIZE; redis-cli -p 6379 -n 2 DBSIZE

60  $ echo '=== promote 6380 to standalone primary ==='; valkey-cli -p 6380 REPLICAOF NO ONE; sleep 1; valkey-cli -p 6380 INFO replication | grep -E '^role|master_link_status|master_host'; echo; echo '=== keyspaces after promotion ==='; valkey-cli -p 6380 INFO keyspace; echo '=== source after promotion (should have 0 slaves, same data) ==='; redis-cli -p 6379 INFO replication | grep -E '^role|connected_slaves'; redis-cli -p 6379 DBSIZE; redis-cli -p 6379 -n 2 DBSIZE

61  $ echo '=== 6380 current persistence config ==='; valkey-cli -p 6380 CONFIG GET save appendonly; echo; echo '=== 6379 (old, reference) ==='; redis-cli -p 6379 CONFIG GET save appendonly; echo; echo '=== valkey.conf current lines ==='; grep -n 'save' /etc/valkey/valkey.conf

62  $ echo '=== raw /etc/valkey/valkey.conf ==='; cat -A /etc/valkey/valkey.conf | head -20; echo; echo '=== append explicit save policy (same as old server) ==='; grep -q '^save ' /etc/valkey/valkey.conf || printf '\n# RDB snapshot policy (matches previous Redis 7.2 server)\nsave 3600 1 300 100 60 10000\n' >> /etc/valkey/valkey.conf; tail -4 /etc/valkey/valkey.conf

63  $ echo '=== valkey log: sync/load events ==='; grep -E 'DB loaded|checksum|Replica|SYNC|Replication|BGSAVE|Receiving' /var/log/valkey/valkey.log | tail -8; echo; echo '=== write-acceptance test on 6380 (cleaned up immediately) ==='; valkey-cli -p 6380 SET "__migration_write_test__" ok; valkey-cli -p 6380 GET "__migration_write_test__"; valkey-cli -p 6380 DEL "__migration_write_test__"; valkey-cli -p 6380 EXISTS "__migration_write_test__"; echo; echo '=== immediate snapshot on new primary ==='; valkey-cli -p 6380 BGSAVE; sleep 2; ls -la /var/lib/valkey/; valkey-cli -p 6380 INFO persistence | grep -E 'rdb_last_bgsave_status|rdb_last_save_time|rdb_changes_since_last_save'

64  $ echo '=== valkey log around the sync ==='; sed -n '08:37:35,08:38:00p' /var/log/valkey/valkey.log 2>/dev/null || awk '/08:37:3/,/08:38:0/' /var/log/valkey/valkey.log | head -20; echo; echo '=== full recent valkey log ==='; tail -20 /var/log/valkey/valkey.log

65  $ cd /root/migration && bash -c 'ulimit -v 700000; python3 fingerprint.py 6379 /root/migration/source_after.jsonl' >/dev/null 2>&1 && bash -c 'ulimit -v 700000; python3 fingerprint.py 6380 /root/migration/final_target.jsonl' >/dev/null 2>&1; python3 - <<'EOF'
import json
def load(p):
    d = {}
    for line in open(p):
        r = json.loads(line)
        d[(r['db'], r['key'])] = (r['payload'], r['pttl'], r['pexpiretime'])
    return d
s = load('/root/migration/source_after.jsonl')
t = load('/root/migration/final_target.jsonl')
print('=== FINAL STATE COMPARISON (6379 source  vs  6380 new primary) ===')
print('source keys: %d | target keys: %d | same key set: %s' % (len(s), len(t), s.keys()==t.keys()))
print('identical payload for every key:', all(s[k][0] == t[k][0] for k in s))
n_exp = sum(1 for k in s if s[k][1] > 0)
abs_ok = sum(1 for k in s if s[k][1] > 0 and s[k][2] == t[k][2])
print('keys with TTL: %d | identical absolute expiry instant: %d' % (n_exp, abs_ok))
pres = [k for k in s if (s[k][1] > 0) != (t[k][1] > 0)]
print('TTL presence mismatches:', len(pres))
bad = [k for k in s if s[k][1] <= 0 and (s[k][2] != -1 or t[k][2] != -1)]
print('persistent-key anomalies:', len(bad))
# stream deep-check
st = [k for k in s if '"type":"stream"' in s[k][0]]
print('streams compared:', len(st))
import hashlib
for k in st[:0]: pass
ok = all(json.loads(s[k][0]) == json.loads(t[k][0]) for k in st)
print('stream payloads (entries+groups+PEL) identical:', ok)
EOF
echo
echo '=== per-DB digests: source_after vs final_target ==='
python3 -c "
import json
for name, f in [('source_after', '/root/migration/source_after.jsonl.summary.json'), ('final_target', '/root/migration/final_target.jsonl.summary.json')]:
    d = json.load(open(f))
    print(name, {k: v['digest'][:20] for k, v in d['dbs'].items()})
"

66  $ echo '=== events:03 / workers PEL: source (6379) ==='; redis-cli -p 6379 -n 0 XPENDING events:03 workers IDLE 0 - + 100000 | awk 'NR%4==1{id=$0} NR%4==2{c=$0} NR%4==4{print id, "consumer="c, "dlv="$0}' | head -6; echo '=== same PEL: target (6380) ==='; valkey-cli -p 6380 -n 0 XPENDING events:03 workers IDLE 0 - + 100000 | awk 'NR%4==1{id=$0} NR%4==2{c=$0} NR%4==4{print id, "consumer="c, "dlv="$0}' | head -6; echo; echo '=== consumers: 6379 vs 6380 ==='; diff <(redis-cli -p 6379 -n 0 XINFO CONSUMERS events:03 workers) <(valkey-cli -p 6380 -n 0 XINFO CONSUMERS events:03 workers) && echo '(consumers identical)'; echo; echo '=== FINAL STATUS ==='; ps -o pid,etime,comm -p $(pgrep -d, -f 'redis-server|valkey-server'); echo '6379:'; redis-cli -p 6379 INFO replication | grep -E '^role'; redis-cli -p 6379 DBSIZE; echo '6380:'; valkey-cli -p 6380 INFO replication | grep -E '^role'; valkey-cli -p 6380 DBSIZE; valkey-cli -p 6380 INFO persistence | grep rdb_last_bgsave_status

67  $ echo '=== XPENDING extended, source 6379 ==='; redis-cli -p 6379 -n 0 XPENDING events:03 workers IDLE 0 - + 3; echo; echo '=== XPENDING extended, target 6380 ==='; valkey-cli -p 6380 -n 0 XPENDING events:03 workers IDLE 0 - + 3; echo; echo '=== full PEL id+consumer+delivery-count equality across ALL streams ==='; python3 - <<'EOF'
import json
def pel(p):
    d = {}
    for line in open(p):
        r = json.loads(line)
        pl = json.loads(r['payload'])
        if pl['type'] != 'stream': continue
        for g in pl['value']['groups']:
            d[(r['db'], r['key'], g['name'])] = (
                g['pel'], g['consumers'], g['last-delivered-id'], g['group-pending'])
    return d
s = pel('/root/migration/source_after.jsonl')
t = pel('/root/migration/final_target.jsonl')
print('stream+group pairs:', len(s), '->', len(t), '| same set:', s.keys()==t.keys())
mism = [k for k in s if s[k] != t[k]]
print('mismatched groups:', len(mism))
tot_pel = sum(len(v[0]) for v in s.values())
tot_cons = sum(len(v[1]) for v in s.values())
print('total pending entries preserved: %d | total consumers preserved: %d' % (tot_pel, tot_cons))
EOF

{
 "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": "7.2.4",
  "server_name": "valkey",
  "valkey_version": "9.1.2"
 },
 "old_digest_ok": true,
 "old_server": {
  "redis_version": "7.2.16",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

1  $ ps auxww | grep -E "redis-server|valkey-server" | grep -v grep; echo ---PORTS---; (ss -lntp 2>/dev/null || netstat -lntp 2>/dev/null) | grep -E ":(6379|6380)\b"; echo ---BINS---; ls -la /opt/ /opt/redis-7.2/bin 2>/dev/null; echo ---PATH---; command -v redis-cli valkey-cli redis-server valkey-server; ls /usr/bin /usr/local/bin 2>/dev/null | grep -iE "redis|valkey"

2  $ echo ===REDIS-OLD-CONF===; grep -Ev '^\s*(#|$)' /etc/redis-old/redis.conf; echo ===VALKEY-CONF===; grep -Ev '^\s*(#|$)' /etc/valkey/valkey.conf

3  $ echo "=== versions ==="; redis-cli -p 6379 INFO server | grep -E "redis_version|valkey_version|os|process_id"; valkey-cli -p 6380 INFO server | grep -E "redis_version|valkey_version|os|process_id"; echo "=== 6379 keyspace ==="; redis-cli -p 6379 INFO keyspace; echo "=== 6380 keyspace ==="; valkey-cli -p 6380 INFO keyspace; echo "=== 6379 dbsize ==="; for i in 0 1 2 3; do echo -n "db$i: "; redis-cli -p 6379 -n $i dbsize; done; echo "=== 6380 dbsize ==="; for i in 0 1 2 3; do echo -n "db$i: "; valkey-cli -p 6380 -n $i dbsize; done

4  $ echo "=== 6379 replication ==="; redis-cli -p 6379 INFO replication | grep -v "^#"; echo "=== 6380 replication ==="; valkey-cli -p 6380 INFO replication | grep -v "^#"; echo "=== 6380 current role check ==="; valkey-cli -p 6380 ROLE

5  $ valkey-cli -p 6380 REPLICAOF 127.0.0.1 6379; sleep 1; echo ---; valkey-cli -p 6380 INFO replication | grep -E "role|master_host|master_port|master_link_status|master_sync_in_progress|master_sync_last_io_seconds_ago|master_repl_offset|slave_repl_offset"

6  $ command -v python3; python3 -c "import redis; print('redis-py', redis.__version__)" 2>&1; echo ---; ls /opt/kv-grader 2>/dev/null

7  $ tail -n 30 /var/log/valkey/valkey.log; echo "=== repl info now ==="; valkey-cli -p 6380 INFO replication | grep -E "role|master_link_status|master_sync_in_progress|master_repl_offset|slave_repl_offset|master_replid"; echo "=== master side ==="; redis-cli -p 6379 INFO replication | grep -E "connected_slaves|slave0|role|master_repl_offset"

8  $ echo "=== 6380 keyspace ==="; valkey-cli -p 6380 INFO keyspace; echo "=== per-db dbsize ==="; for i in 0 1 2 3; do echo -n "db$i old: "; redis-cli -p 6379 -n $i dbsize; echo -n "     new: "; valkey-cli -p 6380 -n $i dbsize; done; echo "=== stream groups on old ==="; redis-cli -p 6379 --scan | head -4000 | while read k; do t=$(redis-cli -p 6379 type "$k"); if [ "$t" = "stream" ]; then echo "STREAM $k"; redis-cli -p 6379 xinfo groups "$k"; fi; done

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

old = redis.Redis(host='127.0.0.1', port=6379, decode_responses=False)
new = redis.Redis(host='127.0.0.1', port=6380, decode_responses=False)

mismatches = []
type_counts = {}
total = 0

for db in range(16):
    o = redis.Redis(host='127.0.0.1', port=6379, db=db, decode_responses=False)
    n = redis.Redis(host='127.0.0.1', port=6380, db=db, decode_responses=False)
    if o.dbsize() != n.dbsize():
        mismatches.append(f"db{db}: DBSIZE mismatch old={o.dbsize()} new={n.dbsize()}")
    for key in o.scan_iter(count=1000):
        total += 1
        to = o.type(key)
        tn = n.type(key)
        if to != tn:
            mismatches.append(f"db{db} {key!r}: TYPE old={to} new={tn}")
            continue
        type_counts[to.decode() if isinstance(to, bytes) else to] = type_counts.get(to.decode() if isinstance(to, bytes) else to, 0) + 1
        pttl_o = o.pttl(key)
        pttl_n = n.pttl(key)
        if pttl_o != pttl_n:
            mismatches.append(f"db{db} {key!r}: PTTL old={pttl_o} new={pttl_n}")
        try:
            do = o.dump(key)
            dn = n.dump(key)
        except Exception as e:
            mismatches.append(f"db{db} {key!r}: DUMP error {e}")
            continue
        if do != dn:
            mismatches.append(f"db{db} {key!r}: DUMP payload differs (len old={len(do) if do else None} new={len(dn) if dn else None})")

print(f"keys compared: {total}")
print("type distribution:", type_counts)
if mismatches:
    print(f"MISMATCHES: {len(mismatches)}")
    for m in mismatches[:50]:
        print(" -", m)
    sys.exit(1)
print("RESULT: EXACT MATCH (type, PTTL, binary DUMP value) for all keys in all databases")
EOF
python3 /tmp/verify.py

10  $ k=session:01246; echo "=== old ==="; redis-cli -p 6379 --raw DUMP "$k" | xxd | tail -6; echo "=== new ==="; valkey-cli -p 6380 --raw DUMP "$k" | xxd | tail -6; echo "=== GET values ==="; echo -n "old: "; redis-cli -p 6379 --raw GET "$k" | xxd | head -4; echo -n "new: "; valkey-cli -p 6380 --raw GET "$k" | xxd | head -4

11  $ k=leaderboard:005; echo "=== old dump hex ==="; redis-cli -p 6379 --raw DUMP "$k" | xxd | head -20; echo "=== new dump hex ==="; valkey-cli -p 6380 --raw DUMP "$k" | xxd | head -20

12  $ k=session:01246; echo "=== old DUMP hex ==="; redis-cli -p 6379 --raw DUMP "$k" | od -A x -t x1z | head -10; echo "=== new DUMP hex ==="; valkey-cli -p 6380 --raw DUMP "$k" | od -A x -t x1z | head -10

13  $ k=leaderboard:005; echo "=== old DUMP hex ==="; redis-cli -p 6379 --raw DUMP "$k" | od -A x -t x1z | head -25; echo "=== new DUMP hex ==="; valkey-cli -p 6380 --raw DUMP "$k" | od -A x -t x1z | head -25

14  $ cat > /tmp/diffdump.py <<'EOF'
import redis
o = redis.Redis(port=6379, decode_responses=False)
n = redis.Redis(port=6380, decode_responses=False)

# pick a sample key of each type
samples = {}
for k in o.scan_iter(count=1000):
    t = o.type(k)
    if isinstance(t, bytes): t = t.decode()
    if t not in samples:
        samples[t] = k
    if len(samples) >= 6: break

for t, k in samples.items():
    do, dn = o.dump(k), n.dump(k)
    if do == dn:
        print(f"{t:8s} {k.decode():20s} len={len(do)} IDENTICAL")
        continue
    first = next(i for i in range(min(len(do), len(dn))) if do[i] != dn[i])
    # check whether everything before `first` and after some suffix matches
    print(f"{t:8s} {k.decode():20s} len old={len(do)} new={len(dn)} first_diff_offset={first} "
          f"(diff confined to last {len(do)-first} bytes)" if len(do)==len(dn) else f"{t} {k} len differs")

# min PTTL across all dbs (how urgent are expirations?)
mins = []
for db in range(16):
    oo = redis.Redis(port=6379, db=db, decode_responses=False)
    pipe = oo.pipeline()
    keys = list(oo.scan_iter(count=1000))
    for k in keys: pipe.pttl(k)
    for k, p in zip(keys, pipe.execute()):
        if p >= 0: mins.append(p)
mins.sort()
print("keys with TTL:", len(mins), "min PTTL (s):", mins[0]/1000 if mins else None,
      "next 5:", [round(x/1000,1) for x in mins[:6]])
EOF
python3 /tmp/diffdump.py

15  $ cat > /tmp/verify2.py <<'EOF'
import redis, sys, time, json

o_global = redis.Redis(port=6379, decode_responses=False)
n_global = redis.Redis(port=6380, decode_responses=False)
problems = []
total = 0

def eq(a, b, what):
    if a != b:
        problems.append(f"{what}: {a!r} != {b!r}")
        return False
    return True

TYPE_CHECKS = 0
def compare_value(t, o, n, key, ctx):
    global TYPE_CHECKS
    if t == b'string':
        eq(o.get(key), n.get(key), f"{ctx} GET")
    elif t == b'list':
        eq(o.lrange(key, 0, -1), n.lrange(key, 0, -1), f"{ctx} LRANGE")
    elif t == b'set':
        a, b = o.smembers(key), n.smembers(key)
        if a != b: problems.append(f"{ctx} SMEMBERS sets differ (sizes {len(a)}/{len(b)})")
    elif t == b'hash':
        a, b = o.hgetall(key), n.hgetall(key)
        if a != b: problems.append(f"{ctx} HGETALL differ (sizes {len(a)}/{len(b)})")
    elif t == b'zset':
        a = dict(o.zrange(key, 0, -1, withscores=True)); b = dict(n.zrange(key, 0, -1, withscores=True))
        if a != b: problems.append(f"{ctx} ZRANGE differ (sizes {len(a)}/{len(b)})")
        eq(o.zcard(key), n.zcard(key), f"{ctx} ZCARD")
    elif t == b'stream':
        compare_stream(o, n, key, ctx)
    else:
        problems.append(f"{ctx} UNHANDLED TYPE {t}")
    TYPE_CHECKS += 1

def compare_stream(o, n, key, ctx):
    # entries
    a, b = o.xrange(key, min='-', max='+'), n.xrange(key, min='-', max='+')
    if a != b:
        problems.append(f"{ctx} XRANGE entries differ ({len(a)} vs {len(b)} entries)")
    # stream metadata
    for f in (b'length', b'last-generated-id', b'max-deleted-entry-id', b'entries-added', b'recorded-first-entry-id'):
        xo, xn = o.xinfo_stream(key), n.xinfo_stream(key)
        eq(xo.get(f), xn.get(f), f"{ctx} XINFO_STREAM {f.decode()}")
    # groups
    go = {g[b'name']: g for g in o.xinfo_groups(key)}
    gn = {g[b'name']: g for g in n.xinfo_groups(key)}
    eq(sorted(go), sorted(gn), f"{ctx} group names")
    for gname in go:
        if gname not in gn: continue
        for f in (b'last-delivered-id', b'pending', b'consumers', b'entries-read', b'lag'):
            eq(go[gname].get(f), gn[gname].get(f), f"{ctx} group {gname.decode()} {f.decode()}")
        # consumers
        co = sorted([(c[b'name'], c[b'pending']) for c in o.xinfo_consumers(key, gname)])
        cn = sorted([(c[b'name'], c[b'pending']) for c in n.xinfo_consumers(key, gname)])
        eq(co, cn, f"{ctx} group {gname.decode()} consumers(name,pending)")
        # PEL: id, consumer, delivery count must match exactly; delivery time is absolute
        # internally - check via relative idle against wall clock gap
        t0 = time.time(); po = o.xpending(key, gname, min='-', max='+', count=1000000); t1 = time.time()
        pn = n.xpending(key, gname, min='-', max='+', count=1000000); t2 = time.time()
        eq(len(po), len(pn), f"{ctx} group {gname.decode()} PEL size")
        for eo, en in zip(po, pn):
            eq(eo[b'message_id'], en[b'message_id'], f"{ctx} group {gname.decode()} PEL id")
            eq(eo[b'consumer'], en[b'consumer'], f"{ctx} group {gname.decode()} PEL consumer")
            eq(eo[b'times_delivered'], en[b'times_delivered'], f"{ctx} group {gname.decode()} PEL delivery-count")

# ---- run over all dbs ----
old_keysets, new_keysets = {}, {}
for db in range(16):
    o = redis.Redis(port=6379, db=db, decode_responses=False)
    n = redis.Redis(port=6380, db=db, decode_responses=False)
    ok, nk = set(o.scan_iter(count=1000)), set(n.scan_iter(count=1000))
    old_keysets[db], new_keysets[db] = ok, nk
    if ok != nk:
        problems.append(f"db{db}: KEY SETS DIFFER: old-only={sorted(map(bytes.decode, ok-nk))[:10]} new-only={sorted(map(bytes.decode, nk-ok))[:10]}")
    for key in sorted(ok):
        total += 1
        ctx = f"db{db} {key.decode()}"
        t = o.type(key)
        eq(t, n.type(key), f"{ctx} TYPE")
        compare_value(t, o, n, key, ctx)
        # absolute expiry must match exactly
        eq(o.pexpiretime(key), n.pexpiretime(key), f"{ctx} PEXPIRETIME")

print(f"total keys compared: {total}")
print(f"type-aware comparisons run: {TYPE_CHECKS}")
if problems:
    print(f"PROBLEMS: {len(problems)}")
    for p in problems[:40]: print(" -", p)
    sys.exit(1)
print("RESULT: EXACT MATCH — key sets, types, absolute expiries, values, and stream group/consumer/PEL state")
EOF
python3 /tmp/verify2.py

16  $ python3 - <<'EOF'
import redis
o = redis.Redis(port=6379, decode_responses=False)
print("XINFO_STREAM:")
for k, v in o.xinfo_stream('events:19').items(): print("  ", k, "=", repr(v)[:80])
print("XINFO GROUPS:")
for g in o.xinfo_groups('events:19'): print("  ", {k: (repr(v)[:60]) for k, v in g.items()})
print("XINFO CONSUMERS:")
for c in o.xinfo_consumers('events:19', 'workers'): print("  ", {k: (repr(v)[:60]) for k, v in c.items()})
print("XPENDING:")
p = o.xpending('events:19', 'workers', min='-', max='+', count=3)
for e in (p if isinstance(p, list) else p.get('pending', [])): print("  ", {k: (repr(v)[:60]) for k, v in e.items()})
print("XRANGE sample:", o.xrange('events:19', count=2))
EOF

17  $ python3 - <<'EOF'
import redis
o = redis.Redis(port=6379, decode_responses=False)
print("XINFO GROUPS (events:00):")
for g in o.xinfo_groups('events:00'): print("  ", {k: repr(v)[:70] for k, v in g.items()})
print("XINFO CONSUMERS (workers):")
for c in o.xinfo_consumers('events:00', 'workers'): print("  ", {k: repr(v)[:70] for k, v in c.items()})
print("XPENDING range:")
p = o.xpending('events:00', 'workers', min='-', max='+', count=3)
for e in (p if isinstance(p, list) else p.get('pending', [])): print("  ", {k: repr(v)[:70] for k, v in e.items()})
print("XINFO DEBUG (stream internal):")
for k, v in o.execute_command('XINFO', 'DEBUG', 'events:00').items(): print("  ", k, "=", repr(v)[:70])
EOF

18  $ python3 - <<'EOF'
import redis, inspect
o = redis.Redis(port=6379, decode_responses=False)
print(inspect.signature(o.xpending_range))
print("XPENDING_RANGE:")
for e in o.xpending_range('events:00', 'workers', '-', '+', 3): print("  ", {k: repr(v)[:70] for k, v in e.items()})
print("XINFO DEBUG:")
for k, v in o.execute_command('XINFO', 'DEBUG', 'events:00').items(): print("  ", k, "=", repr(v)[:70])
EOF

19  $ cat > /tmp/verify2.py <<'EOF'
import redis, sys, time

problems = []
total = 0

def eq(a, b, what):
    if a != b:
        problems.append(f"{what}: {a!r} != {b!r}")

def compare_stream(o, n, key, ctx):
    a, b = o.xrange(key, min='-', max='+'), n.xrange(key, min='-', max='+')
    if a != b:
        problems.append(f"{ctx} XRANGE entries differ ({len(a)} vs {len(b)})")
    so, sn = o.xinfo_stream(key), n.xinfo_stream(key)
    for f in ('length', 'last-generated-id', 'max-deleted-entry-id', 'entries-added', 'recorded-first-entry-id'):
        eq(so.get(f), sn.get(f), f"{ctx} XINFO_STREAM {f}")
    go = {g['name']: g for g in o.xinfo_groups(key)}
    gn = {g['name']: g for g in n.xinfo_groups(key)}
    eq(sorted(go), sorted(gn), f"{ctx} group names")
    for gname in go:
        if gname not in gn: continue
        for f in ('last-delivered-id', 'pending', 'consumers', 'entries-read', 'lag'):
            eq(go[gname].get(f), gn[gname].get(f), f"{ctx} group {gname.decode()} {f}")
        t0 = time.time()
        co = o.xinfo_consumers(key, gname); t1 = time.time()
        cn = n.xinfo_consumers(key, gname); t2 = time.time()
        elapsed = t2 - t0
        mbo = sorted(c['name'] for c in co); mbn = sorted(c['name'] for c in cn)
        eq(mbo, mbn, f"{ctx} group {gname.decode()} consumer names")
        for coo, cnn in zip(sorted(co, key=lambda c: c['name']), sorted(cn, key=lambda c: c['name'])):
            eq(coo['pending'], cnn['pending'], f"{ctx} group {gname.decode()} consumer {coo['name'].decode()} pending")
            eq(coo['name'], cnn['name'], f"{ctx} group {gname.decode()} consumer name")
            # idle is absolute-delivery-time derived; must only differ by measurement gap
            for f in ('idle', 'inactive'):
                if f in coo and f in cnn:
                    if not (0 <= cnn[f] - coo[f] <= elapsed * 1000 + 100):
                        problems.append(f"{ctx} group {gname.decode()} consumer {coo['name'].decode()} {f} drift {coo[f]} -> {cnn[f]}")
        po = o.xpending_range(key, gname, '-', '+', 1000000); t3 = time.time()
        pn = n.xpending_range(key, gname, '-', '+', 1000000); t4 = time.time()
        elapsed2 = t4 - t0
        eq(len(po), len(pn), f"{ctx} group {gname.decode()} PEL size")
        for eo, en in zip(po, pn):
            eq(eo['message_id'], en['message_id'], f"{ctx} group {gname.decode()} PEL id")
            eq(eo['consumer'], en['consumer'], f"{ctx} group {gname.decode()} PEL consumer")
            eq(eo['times_delivered'], en['times_delivered'], f"{ctx} group {gname.decode()} PEL delivery-count")
            if not (0 <= en['time_since_delivered'] - eo['time_since_delivered'] <= elapsed2 * 1000 + 100):
                problems.append(f"{ctx} group {gname.decode()} PEL id {eo['message_id'].decode()} delivery-time drift")

for db in range(16):
    o = redis.Redis(port=6379, db=db, decode_responses=False)
    n = redis.Redis(port=6380, db=db, decode_responses=False)
    ok, nk = set(o.scan_iter(count=1000)), set(n.scan_iter(count=1000))
    if ok != nk:
        problems.append(f"db{db}: KEY SETS DIFFER old-only={len(ok-nk)} new-only={len(nk-ok)}")
        continue
    for key in sorted(ok):
        total += 1
        ctx = f"db{db} {key.decode()}"
        t = o.type(key)
        eq(t, n.type(key), f"{ctx} TYPE")
        eq(o.pexpiretime(key), n.pexpiretime(key), f"{ctx} PEXPIRETIME")
        if t == b'string':   eq(o.get(key), n.get(key), f"{ctx} GET")
        elif t == b'list':   eq(o.lrange(key, 0, -1), n.lrange(key, 0, -1), f"{ctx} LRANGE")
        elif t == b'set':
            a, b = o.smembers(key), n.smembers(key)
            if a != b: problems.append(f"{ctx} SMEMBERS differ ({len(a)}/{len(b)})")
        elif t == b'hash':
            a, b = o.hgetall(key), n.hgetall(key)
            if a != b: problems.append(f"{ctx} HGETALL differ ({len(a)}/{len(b)})")
        elif t == b'zset':
            a = dict(o.zrange(key, 0, -1, withscores=True)); b = dict(n.zrange(key, 0, -1, withscores=True))
            if a != b: problems.append(f"{ctx} ZRANGE differ ({len(a)}/{len(b)})")
            eq(o.zcard(key), n.zcard(key), f"{ctx} ZCARD")
        elif t == b'stream': compare_stream(o, n, key, ctx)
        else: problems.append(f"{ctx} UNHANDLED TYPE {t}")

print(f"total keys compared: {total}")
if problems:
    print(f"PROBLEMS: {len(problems)}")
    for p in problems[:40]: print(" -", p)
    sys.exit(1)
print("RESULT: EXACT MATCH — key sets, types, absolute expiries, values, stream groups/consumers/PEL")
EOF
python3 /tmp/verify2.py

20  $ valkey-cli -p 6380 REPLICAOF NO ONE; sleep 1; echo "=== 6380 role ==="; valkey-cli -p 6380 ROLE; echo "=== 6380 write test ==="; valkey-cli -p 6380 SET __cutover_write_test__ ok; valkey-cli -p 6380 GET __cutover_write_test__; valkey-cli -p 6380 DEL __cutover_write_test__; echo "=== 6380 keyspace after test ==="; valkey-cli -p 6380 INFO keyspace; echo "=== 6379 still master, untouched? ==="; redis-cli -p 6379 INFO replication | grep -E "role|connected_slaves"; redis-cli -p 6379 INFO keyspace; ps auxww | grep -E "redis-server|valkey-server" | grep -v grep

21  $ python3 /tmp/verify2.py; echo "=== final roles ==="; echo -n "6379: "; redis-cli -p 6379 ROLE | head -1; echo -n "6380: "; valkey-cli -p 6380 ROLE | head -1; echo "=== valkey log tail ==="; tail -n 4 /var/log/valkey/valkey.log

{
 "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": "7.2.4",
  "server_name": "valkey",
  "valkey_version": "9.1.2"
 },
 "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; ls /etc/valkey; ls /etc/redis-old; ps aux | grep -iE 'redis|valkey'

2  $ which valkey-cli redis-cli valkey-server redis-server dump.rdb 2>/dev/null; ls /opt

3  $ redis-cli -p 6379 INFO server | head -30; echo ====; redis-cli -p 6379 INFO keyspace; echo ====; redis-cli -p 6379 CONFIG GET bind; redis-cli -p 6379 CONFIG GET replica-read-only; redis-cli -p 6379 CONFIG GET dir; redis-cli -p 6379 CONFIG GET dbfilename

4  $ valkey-cli -p 6380 INFO server | head -30; echo ====; valkey-cli -p 6380 INFO keyspace; echo ====; cat /etc/valkey/valkey.conf | grep -vE '^\s*#|^\s*$'

5  $ grep -vE '^\s*#|^\s*$' /etc/redis-old/redis.conf; echo ====; valkey-cli -p 6380 CONFIG GET replicaof; valkey-cli -p 6379 CONFIG GET requirepass; valkey-cli -p 6379 CONFIG GET appendonly; valkey-cli -p 6379 CONFIG GET min-replicas-to-write

6  $ valkey-cli -p 6380 CONFIG GET save; valkey-cli -p 6380 CONFIG GET dir; ls -la /var/lib/valkey /var/lib/redis-old 2>&1

7  $ valkey-cli -p 6380 REPLICAOF 127.0.0.1 6379; sleep 2; valkey-cli -p 6380 INFO replication; echo ====; valkey-cli -p 6379 INFO replication | grep -E 'master_repl_offset|role|connected_slaves|slave0'

8  $ sleep 5; valkey-cli -p 6380 INFO replication | grep -E 'role|master_link|sync_in|slave_repl_offset'; echo ====; tail -20 /var/log/valkey/valkey.log

9  $ valkey-cli -p 6380 INFO keyspace; echo ====; valkey-cli -p 6379 INFO keyspace; echo ==== sample; for k in $(valkey-cli -p 6379 --scan | head -5); do echo "key: $k"; valkey-cli -p 6379 --no-raw OBJECT ENCODING "$k" >/dev/null; done; valkey-cli -p 6379 DBSIZE; valkey-cli -p 6380 DBSIZE; valkey-cli -p 6379 -n 2 DBSIZE; valkey-cli -p 6380 -n 2 DBSIZE

10  $ echo "--- streams on master:"; valkey-cli -p 6379 TYPE $(valkey-cli -p 6379 --scan | head -200 | while read k; do t=$(valkey-cli -p 6379 TYPE "$k"); if [ "$t" = stream ]; then echo "$k"; break; fi; done)

11  $ sk=$(valkey-cli -p 6379 --scan | while read k; do t=$(valkey-cli -p 6379 TYPE "$k"); if [ "$t" = stream ]; then echo "$k"; break; fi; done); echo "stream=$sk"; echo "-- master:"; valkey-cli -p 6379 XINFO GROUPS "$sk"; echo "-- replica:"; valkey-cli -p 6380 XINFO GROUPS "$sk"; echo "-- master streams list:"; valkey-cli -p 6379 XINFO STREAM "$sk" | head -8; echo "-- replica:"; valkey-cli -p 6380 XINFO STREAM "$sk" | head -8

12  $ echo "TTL comparison (first 10 expiring keys):"; valkey-cli -p 6379 INFO keyspace >/dev/null; for k in $(valkey-cli -p 6379 --scan | head -200); do m=$(valkey-cli -p 6379 PTTL "$k"); if [ "$m" != "-1" ] && [ "$m" != "-2" ]; then v=$(valkey-cli -p 6380 PTTL "$k"); d=$((m-v)); echo "$k master=$m replica=$v delta=$d"; fi; done | head -15

13  $ for k in $(valkey-cli -p 6379 --scan); do t=$(valkey-cli -p 6379 TYPE "$k"); if [ "$t" = stream ]; then g=$(valkey-cli -p 6379 XINFO GROUPS "$k" | grep -c '^name' || true); echo "$k groups=$g"; fi; done

14  $ echo "master digest:"; valkey-cli -p 6379 DEBUG DIGEST; echo "replica digest:"; valkey-cli -p 6380 DEBUG DIGEST; echo "master digest-value:"; valkey-cli -p 6379 DEBUG DIGEST-VALUE 2>/dev/null | head; echo; echo "per-db:"; valkey-cli -p 6379 -n 2 DEBUG DIGEST; valkey-cli -p 6380 -n 2 DEBUG DIGEST

15  $ fail=0; total=0
for db in 0 2; do
  for k in $(valkey-cli -p 6379 -n $db --scan); do
    total=$((total+1))
    a=$(valkey-cli -p 6379 -n $db DUMP "$k" | sha256sum | cut -d' ' -f1)
    b=$(valkey-cli -p 6380 -n $db DUMP "$k" | sha256sum | cut -d' ' -f1)
    if [ "$a" != "$b" ]; then echo "MISMATCH db$db key=$k"; fail=$((fail+1)); fi
    ta=$(valkey-cli -p 6379 -n $db PTTL "$k"); tb=$(valkey-cli -p 6380 -n $db PTTL "$k")
    if [ "$ta" = "-2" ]; then echo "MISSING on replica db$db key=$k"; fail=$((fail+1)); fi
    if [ "$ta" != "-1" ]; then d=$((ta-tb)); if [ $d -lt -2000 ] || [ $d -gt 2000 ]; then echo "TTL MISMATCH db$db key=$k master=$ta replica=$tb"; fail=$((fail+1)); fi; fi
  done
done
echo "checked=$total failures=$fail"

16  $ for k in events:00 events:01 events:02 events:03 events:04 events:05 events:06 events:07 events:08 events:09; do
  a=$(valkey-cli -p 6379 XINFO GROUPS "$k" | sha256sum | cut -d' ' -f1)
  b=$(valkey-cli -p 6380 XINFO GROUPS "$k" | sha256sum | cut -d' ' -f1)
  a2=$(valkey-cli -p 6379 XINFO STREAM "$k" | grep -A1 '^last-generated-id' | tail -1)
  b2=$(valkey-cli -p 6380 XINFO STREAM "$k" | grep -A1 '^last-generated-id' | tail -1)
  if [ "$a" = "$b" ] && [ "$a2" = "$b2" ]; then echo "$k OK groups_hash match"; else echo "$k MISMATCH"; fi
done
echo; valkey-cli -p 6379 XINFO GROUPS events:00; echo ---; valkey-cli -p 6380 XINFO GROUPS events:00

17  $ k=leaderboard:034; valkey-cli -p 6379 TYPE $k; valkey-cli -p 6380 TYPE $k; echo "-- master dump hex:"; valkey-cli -p 6379 DUMP $k | xxd | head -5; echo "-- replica dump hex:"; valkey-cli -p 6380 DUMP $k | xxd | head -5; echo "-- lengths:"; valkey-cli -p 6379 DUMP $k | wc -c; valkey-cli -p 6380 DUMP $k | wc -c; echo "-- value master:"; valkey-cli -p 6379 GET $k | head -c 200; echo; echo "-- value replica:"; valkey-cli -p 6380 GET $k | head -c 200

18  $ k=leaderboard:034; valkey-cli -p 6379 DUMP $k | sha256sum; valkey-cli -p 6380 DUMP $k | sha256sum; echo; valkey-cli -p 6379 DUMP $k | od -c | head; echo ---; valkey-cli -p 6380 DUMP $k | od -c | head; valkey-cli -p 6379 DUMP $k | base64; valkey-cli -p 6380 DUMP $k | base64

19  $ python3 - <<'EOF'
import socket, hashlib

def resp(sock_file):
    line = sock_file.readline().strip()
    t, rest = line[:1], line[1:]
    if t == b'$':
        n = int(rest)
        data = sock_file.read(n)
        sock_file.read(2)
        return data
    raise Exception(line)

def dump(port, key):
    s = socket.create_connection(('127.0.0.1', port))
    f = s.makefile('rb')
    cmd = f"*2\r\n$4\r\nDUMP\r\n${len(key)}\r\n{key}\r\n".encode()
    s.sendall(cmd)
    d = resp(f)
    s.close()
    return d

for k in ['leaderboard:034', 'session:01412', 'queue:000', 'user:0196']:
    a = dump(6379, k)
    b = dump(6380, k)
    print(k, 'len', len(a), len(b))
    # find first diff
    i = next((i for i in range(min(len(a),len(b))) if a[i]!=b[i]), None)
    print('  first diff at', i, 'of', len(a))
    print('  master tail:', a[-14:].hex())
    print('  replica tail:', b[-14:].hex())
    if i is not None:
        print('  master around:', a[max(0,i-6):i+14].hex())
        print('  replica around:', b[max(0,i-6):i+14].hex())
EOF

20  $ python3 - <<'EOF'
import socket

def resp(f):
    line = f.readline().strip()
    t, rest = line[:1], line[1:]
    if t == b'$':
        n = int(rest); d = f.read(n); f.read(2); return d
    raise Exception(line)

def dump(port, key):
    s = socket.create_connection(('127.0.0.1', port)); f = s.makefile('rb')
    s.sendall(f"*2\r\n$4\r\nDUMP\r\n${len(key)}\r\n{key}\r\n".encode())
    d = resp(f); s.close(); return d

# CRC-64-JONES (redis variant, reflected poly 0x95AC9329AC4BC9B5, init 0, xorout 0)
poly = 0x95AC9329AC4BC9B5
tbl = []
for i in range(256):
    c = i
    for _ in range(8):
        c = (c >> 1) ^ poly if c & 1 else c >> 1
    tbl.append(c)

def crc64_jones(data, crc=0):
    for b in data:
        crc = (crc >> 8) ^ tbl[(crc ^ b) & 0xFF]
    return crc

def crc64_jones_initff(data, crc=0xFFFFFFFFFFFFFFFF):
    for b in data:
        crc = (crc >> 8) ^ tbl[(crc ^ b) & 0xFF]
    return crc ^ 0xFFFFFFFFFFFFFFFF

a = dump(6379, 'leaderboard:034')
b = dump(6380, 'leaderboard:034')
print('a[142:152]', a[142:].hex(), 'b[142:152]', b[142:].hex())

for name, payload in [('master', a), ('replica', b)]:
    pl = payload[:142]
    c0 = crc64_jones(pl)
    c1 = crc64_jones_initff(pl)
    print(name, 'payload-crc jones(init0)  =', c0.to_bytes(8,'little').hex())
    print(name, 'payload-crc jones(initff) =', c1.to_bytes(8,'little').hex())
    print(name, 'raw tail =', payload[142:].hex())
EOF

21  $ curl -s --max-time 10 https://raw.githubusercontent.com/valkey-io/valkey/9.1/src/restore.c | head -80 || echo NOK

22  $ curl -s --max-time 10 https://raw.githubusercontent.com/redis/redis/7.2/src/restore.c | sed -n '1,80p' || echo NOK

23  $ curl -s --max-time 15 https://raw.githubusercontent.com/redis/redis/7.2/src/db.c | grep -n -A30 'verifyDumpPayload' | head -60; echo =====; curl -s --max-time 15 https://raw.githubusercontent.com/redis/redis/7.2/src/rdb.c | grep -n -B2 -A25 'dumpCommand' | head -80

24  $ curl -s --max-time 15 https://raw.githubusercontent.com/valkey-io/valkey/unstable/src/db.c | grep -n -A35 'verifyDumpPayload' | head -70; echo =====; curl -s --max-time 15 https://raw.githubusercontent.com/valkey-io/valkey/unstable/src/rdb.c | grep -n -B2 -A25 'void dumpCommand' | head -70

25  $ for u in https://raw.githubusercontent.com/redis/redis/7.2/src/db.c https://raw.githubusercontent.com/redis/redis/7.2/src/rdb.c https://raw.githubusercontent.com/redis/redis/7.2/src/restore.c; do echo "$u"; curl -s -o /dev/null -w '%{http_code} %{size_download}\n' --max-time 15 "$u"; done; curl -s --max-time 15 "https://api.github.com/repos/redis/redis/git/refs/tags/7.2" | head -5

26  $ for u in https://raw.githubusercontent.com/valkey-io/valkey/9.1/src/db.c https://raw.githubusercontent.com/valkey-io/valkey/unstable/src/db.c https://raw.githubusercontent.com/valkey-io/valkey/9.1.2/src/db.c; do echo "$u"; curl -s -o /dev/null -w '%{http_code} %{size_download}\n' --max-time 15 "$u"; done; curl -s --max-time 15 "https://api.github.com/repos/valkey-io/valkey/tags?per_page=10" | grep '"name"' | head

27  $ cd /tmp && curl -s --max-time 20 -o redis_db.c https://raw.githubusercontent.com/redis/redis/7.2/src/db.c && grep -n 'restoreCommand\|dumpCommand\|verifyDumpPayload\|crc64\|rdbversion\|RDB_VERSION' redis_db.c | head -30

28  $ cd /tmp && curl -s --max-time 20 -o valkey_db.c https://raw.githubusercontent.com/valkey-io/valkey/9.1.2/src/db.c && grep -n 'restoreCommand\|dumpCommand\|verifyDumpPayload\|crc64\|rdbversion\|RDB_VERSION' valkey_db.c | head -30

29  $ cd /tmp && curl -sL --max-time 60 -o redis72.tar.gz https://github.com/redis/redis/archive/refs/tags/7.2.tar.gz && tar xzf redis72.tar.gz && grep -rn 'void dumpCommand\|void restoreCommand\|verifyDumpPayload' redis-7.2/src/ | head

30  $ cd /tmp && curl -sL --max-time 60 -o valkey91.tar.gz https://github.com/valkey-io/valkey/archive/refs/tags/9.1.2.tar.gz && tar xzf valkey91.tar.gz && grep -rn 'void dumpCommand\|void restoreCommand\|verifyDumpPayload' valkey-9.1.2/src/ | head

31  $ sed -n '150,210p' /tmp/valkey-9.1.2/src/cluster.c; echo =====; grep -rn 'RDB_VERSION\b\|#define RDB_VERSION' /tmp/valkey-9.1.2/src/rdb.h

32  $ head -c 300 /tmp/redis72.tar.gz; echo; curl -sIL --max-time 30 https://github.com/redis/redis/archive/refs/tags/7.2.tar.gz | grep -iE 'HTTP|location' | head

33  $ grep -n 'crc64' /tmp/valkey-9.1.2/src/crc64.c | head; sed -n '1,40p' /tmp/valkey-9.1.2/src/crc64.h; grep -rn 'rdbIsVersionAccepted' /tmp/valkey-9.1.2/src/rdb.c | head -3; grep -n -A20 'int rdbIsVersionAccepted' /tmp/valkey-9.1.2/src/rdb.c

34  $ python3 - <<'EOF'
import socket
def resp(f):
    line=f.readline().strip(); t,rest=line[:1],line[1:]
    n=int(rest); d=f.read(n); f.read(2); return d
def dump(port,key):
    s=socket.create_connection(('127.0.0.1',port)); f=s.makefile('rb')
    s.sendall(f"*2\r\n$4\r\nDUMP\r\n${len(key)}\r\n{key}\r\n".encode())
    d=resp(f); s.close(); return d

# crc64 reflected, poly Jones 0x95AC9329AC4BC9B5, init 0, no xorout
poly=0x95AC9329AC4BC9B5
tbl=[]
for i in range(256):
    c=i
    for _ in range(8):
        c=(c>>1)^poly if c&1 else c>>1
    tbl.append(c)
def crc64r(data,crc=0):
    for b in data:
        crc=(crc>>8)^tbl[(crc^b)&0xFF]
    return crc

a=dump(6379,'leaderboard:034')
b=dump(6380,'leaderboard:034')
print('master  ver=',a[142]|a[143]<<8,' crc_stored=',a[144:].hex())
print('replica ver=',b[142]|b[143]<<8,' crc_stored=',b[144:].hex())
print('crc(master payload+ver)=',crc64r(a[:144]).to_bytes(8,'little').hex())
print('crc(replica payload+ver)=',crc64r(b[:144]).to_bytes(8,'little').hex())
print('payload identical:', a[:142]==b[:142])
EOF

35  $ python3 - <<'EOF'
import socket, time

class C:
    def __init__(self, port):
        self.s = socket.create_connection(('127.0.0.1', port))
        self.f = self.s.makefile('rb')
    def cmd(self, *args):
        out = b'*%d\r\n' % len(args)
        for a in args:
            if isinstance(a, str): a = a.encode()
            out += b'$%d\r\n%s\r\n' % (len(a), a)
        self.s.sendall(out)
        return self.read()
    def read(self):
        line = self.f.readline()
        t, rest = line[:1], line[1:].strip()
        if t == b'+': return rest.decode()
        if t == b'-': return rest.decode()
        if t == b':': return int(rest)
        if t == b'$':
            n = int(rest)
            if n == -1: return None
            d = self.f.read(n); self.f.read(2); return d
        if t == b'*':
            n = int(rest)
            if n == -1: return None
            return [self.read() for _ in range(n)]
        raise Exception(line)

m, r = C(6379), C(6380)

# all dbs present
dbs = [int(x.split(b'=')[0][2:]) for x in m.cmd('INFO','keyspace').decode().split() if x.startswith(b'db')]
print('dbs:', dbs)
total = mismatch = missing = 0
t0 = time.time()
for db in dbs:
    m.cmd('SELECT', db); r.cmd('SELECT', db)
    keys = m.cmd('KEYS','*')
    for k in keys:
        total += 1
        a = m.cmd('DUMP', k); b = r.cmd('DUMP', k)
        if b is None:
            missing += 1; print('MISSING', db, k); continue
        if a[:-10] != b[:-10]:
            mismatch += 1
            if mismatch < 10: print('VALUE MISMATCH', db, k)
        # type
        if m.cmd('TYPE', k) != r.cmd('TYPE', k):
            mismatch += 1; print('TYPE MISMATCH', db, k)
        # ttl: both must agree (allow 5s slack for measurement skew)
        ta, tb = m.cmd('PTTL', k), r.cmd('PTTL', k)
        if (ta == -2) != (tb == -2):
            mismatch += 1; print('EXISTS MISMATCH', db, k, ta, tb)
        elif ta > 0 and abs(ta - tb) > 5000:
            mismatch += 1; print('TTL MISMATCH', db, k, ta, tb)
        elif ta == -1 and tb != -1:
            mismatch += 1; print('PERSIST MISMATCH', db, k, tb)
print(f'checked={total} mismatches={mismatch} missing={missing} elapsed={time.time()-t0:.1f}s')

# extra: keys on replica that master doesn't have
extra = 0
for db in dbs:
    m.cmd('SELECT', db); r.cmd('SELECT', db)
    mk = set(m.cmd('KEYS','*')); rk = set(r.cmd('KEYS','*'))
    ex = rk - mk
    if ex: extra += len(ex); print('EXTRA on replica db', db, list(ex)[:10])
print('extra:', extra)

# stream deep-check: groups, consumers, pending, entries
m.cmd('SELECT', 0); r.cmd('SELECT', 0)
streams = [k for k in m.cmd('KEYS','*') if m.cmd('TYPE', k) == b'stream']
print('streams:', len(streams))
gs = 0
for k in streams:
    ga, gb = m.cmd('XINFO','GROUPS',k), r.cmd('XINFO','GROUPS',k)
    if ga != gb:
        print('GROUP MISMATCH', k); mismatch += 1
    for g in ga:
        gname = g[g.index(b'name')+1]
        # compare consumers & pending per group
        ca = m.cmd('XINFO','CONSUMERS',k,gname); cb = r.cmd('XINFO','CONSUMERS',k,gname)
        if ca != cb:
            print('CONSUMER MISMATCH', k, gname); mismatch += 1
        pa = m.cmd('XPENDING',k,gname,'-','+',1000); pb = r.cmd('XPENDING',k,gname,'-','+',1000)
        if pa != pb:
            print('PENDING MISMATCH', k, gname); mismatch += 1
        gs += 1
    # entries
    ea = m.cmd('XRANGE',k,'-','+'); eb = r.cmd('XRANGE',k,'-','+')
    if ea != eb:
        print('ENTRIES MISMATCH', k); mismatch += 1
print('groups checked:', gs, 'total problems:', mismatch + missing + extra)
EOF

36  $ python3 - <<'EOF'
import socket, time

class C:
    def __init__(self, port):
        self.s = socket.create_connection(('127.0.0.1', port))
        self.f = self.s.makefile('rb')
    def cmd(self, *args):
        out = b'*%d\r\n' % len(args)
        for a in args:
            if isinstance(a, str): a = a.encode()
            out += b'$%d\r\n%s\r\n' % (len(a), a)
        self.s.sendall(out)
        return self.read()
    def read(self):
        line = self.f.readline()
        t, rest = line[:1], line[1:].strip()
        if t in (b'+', b'-'): return rest.decode()
        if t == b':': return int(rest)
        if t == b'$':
            n = int(rest)
            if n == -1: return None
            d = self.f.read(n); self.f.read(2); return d
        if t == b'*':
            n = int(rest)
            if n == -1: return None
            return [self.read() for _ in range(n)]
        raise Exception(line)

m, r = C(6379), C(6380)
info = m.cmd('INFO','keyspace')
dbs = [int(x.split('=')[0][2:]) for x in info.split() if x.startswith('db')]
print('dbs:', dbs)
total = mismatch = missing = extra = 0
t0 = time.time()
for db in dbs:
    m.cmd('SELECT', db); r.cmd('SELECT', db)
    keys = m.cmd('KEYS','*')
    for k in keys:
        total += 1
        a = m.cmd('DUMP', k); b = r.cmd('DUMP', k)
        if b is None:
            missing += 1; print('MISSING', db, k); continue
        if a[:-10] != b[:-10]:
            mismatch += 1
            if mismatch < 10: print('VALUE MISMATCH', db, k)
        if m.cmd('TYPE', k) != r.cmd('TYPE', k):
            mismatch += 1; print('TYPE MISMATCH', db, k)
        ta, tb = m.cmd('PTTL', k), r.cmd('PTTL', k)
        if (ta == -2) != (tb == -2):
            mismatch += 1; print('EXISTS MISMATCH', db, k, ta, tb)
        elif ta > 0 and abs(ta - tb) > 5000:
            mismatch += 1; print('TTL MISMATCH', db, k, ta, tb)
        elif ta == -1 and tb != -1:
            mismatch += 1; print('PERSIST MISMATCH', db, k, tb)
    mk = set(keys); rk = set(r.cmd('KEYS','*'))
    ex = rk - mk
    if ex: extra += len(ex); print('EXTRA on replica db', db, list(ex)[:10])
print(f'checked={total} value/type/ttl mismatches={mismatch} missing={missing} extra={extra} elapsed={time.time()-t0:.1f}s')

m.cmd('SELECT', 0); r.cmd('SELECT', 0)
streams = [k for k in m.cmd('KEYS','*') if m.cmd('TYPE', k) == b'stream']
print('streams:', len(streams))
gs = problems = 0
for k in streams:
    ga, gb = m.cmd('XINFO','GROUPS',k), r.cmd('XINFO','GROUPS',k)
    if ga != gb:
        print('GROUP MISMATCH', k); problems += 1
    for g in ga:
        gname = g[g.index(b'name')+1]
        ca = m.cmd('XINFO','CONSUMERS',k,gname); cb = r.cmd('XINFO','CONSUMERS',k,gname)
        if ca != cb:
            print('CONSUMER MISMATCH', k, gname); problems += 1
        pa = m.cmd('XPENDING',k,gname,'-','+',1000); pb = r.cmd('XPENDING',k,gname,'-','+',1000)
        if pa != pb:
            print('PENDING MISMATCH', k, gname); problems += 1
        gs += 1
    ea = m.cmd('XRANGE',k,'-','+'); eb = r.cmd('XRANGE',k,'-','+')
    if ea != eb:
        print('ENTRIES MISMATCH', k); problems += 1
print('groups checked:', gs, 'stream problems:', problems)
EOF

37  $ python3 - <<'EOF'
import socket, time

class C:
    def __init__(self, port):
        self.s = socket.create_connection(('127.0.0.1', port))
        self.f = self.s.makefile('rb')
    def cmd(self, *args):
        out = b'*%d\r\n' % len(args)
        for a in args:
            if isinstance(a, str): a = a.encode()
            out += b'$%d\r\n%s\r\n' % (len(a), a)
        self.s.sendall(out)
        return self.read()
    def read(self):
        line = self.f.readline()
        t, rest = line[:1], line[1:].strip()
        if t in (b'+', b'-'): return rest.decode()
        if t == b':': return int(rest)
        if t == b'$':
            n = int(rest)
            if n == -1: return None
            d = self.f.read(n); self.f.read(2); return d
        if t == b'*':
            n = int(rest)
            if n == -1: return None
            return [self.read() for _ in range(n)]
        raise Exception(line)

m, r = C(6379), C(6380)
info = m.cmd('INFO','keyspace')  # bytes
dbs = [int(x.split(b'=')[0][2:]) for x in info.split() if x.startswith(b'db')]
print('dbs:', dbs)
total = mismatch = missing = extra = 0
t0 = time.time()
for db in dbs:
    m.cmd('SELECT', db); r.cmd('SELECT', db)
    keys = m.cmd('KEYS','*')
    for k in keys:
        total += 1
        a = m.cmd('DUMP', k); b = r.cmd('DUMP', k)
        if b is None:
            missing += 1; print('MISSING', db, k); continue
        if a[:-10] != b[:-10]:
            mismatch += 1
            if mismatch < 10: print('VALUE MISMATCH', db, k)
        if m.cmd('TYPE', k) != r.cmd('TYPE', k):
            mismatch += 1; print('TYPE MISMATCH', db, k)
        ta, tb = m.cmd('PTTL', k), r.cmd('PTTL', k)
        if (ta == -2) != (tb == -2):
            mismatch += 1; print('EXISTS MISMATCH', db, k, ta, tb)
        elif ta > 0 and abs(ta - tb) > 5000:
            mismatch += 1; print('TTL MISMATCH', db, k, ta, tb)
        elif ta == -1 and tb != -1:
            mismatch += 1; print('PERSIST MISMATCH', db, k, tb)
    mk = set(keys); rk = set(r.cmd('KEYS','*'))
    ex = rk - mk
    if ex: extra += len(ex); print('EXTRA on replica db', db, list(ex)[:10])
print(f'checked={total} value/type/ttl mismatches={mismatch} missing={missing} extra={extra} elapsed={time.time()-t0:.1f}s')

m.cmd('SELECT', 0); r.cmd('SELECT', 0)
streams = [k for k in m.cmd('KEYS','*') if m.cmd('TYPE', k) == b'stream']
print('streams:', len(streams))
gs = problems = 0
for k in streams:
    ga, gb = m.cmd('XINFO','GROUPS',k), r.cmd('XINFO','GROUPS',k)
    if ga != gb:
        print('GROUP MISMATCH', k); problems += 1
    for g in ga:
        gname = g[g.index(b'name')+1]
        ca = m.cmd('XINFO','CONSUMERS',k,gname); cb = r.cmd('XINFO','CONSUMERS',k,gname)
        if ca != cb:
            print('CONSUMER MISMATCH', k, gname); problems += 1
        pa = m.cmd('XPENDING',k,gname,'-','+',1000); pb = r.cmd('XPENDING',k,gname,'-','+',1000)
        if pa != pb:
            print('PENDING MISMATCH', k, gname); problems += 1
        gs += 1
    ea = m.cmd('XRANGE',k,'-','+'); eb = r.cmd('XRANGE',k,'-','+')
    if ea != eb:
        print('ENTRIES MISMATCH', k); problems += 1
print('groups checked:', gs, 'stream problems:', problems)
EOF

38  $ python3 - <<'EOF'
import socket, time, re

class C:
    def __init__(self, port):
        self.s = socket.create_connection(('127.0.0.1', port))
        self.f = self.s.makefile('rb')
    def cmd(self, *args):
        out = b'*%d\r\n' % len(args)
        for a in args:
            if isinstance(a, str): a = a.encode()
            out += b'$%d\r\n%s\r\n' % (len(a), a)
        self.s.sendall(out)
        return self.read()
    def read(self):
        line = self.f.readline()
        t, rest = line[:1], line[1:].strip()
        if t in (b'+', b'-'): return rest.decode()
        if t == b':': return int(rest)
        if t == b'$':
            n = int(rest)
            if n == -1: return None
            d = self.f.read(n); self.f.read(2); return d
        if t == b'*':
            n = int(rest)
            if n == -1: return None
            return [self.read() for _ in range(n)]
        raise Exception(line)

m, r = C(6379), C(6380)
info = m.cmd('INFO','keyspace')
dbs = [int(x) for x in re.findall(rb'\bdb(\d+):', info)]
print('dbs:', dbs)
total = mismatch = missing = extra = 0
t0 = time.time()
for db in dbs:
    m.cmd('SELECT', db); r.cmd('SELECT', db)
    keys = m.cmd('KEYS','*')
    for k in keys:
        total += 1
        a = m.cmd('DUMP', k); b = r.cmd('DUMP', k)
        if b is None:
            missing += 1; print('MISSING', db, k); continue
        if a[:-10] != b[:-10]:
            mismatch += 1
            if mismatch < 10: print('VALUE MISMATCH', db, k)
        if m.cmd('TYPE', k) != r.cmd('TYPE', k):
            mismatch += 1; print('TYPE MISMATCH', db, k)
        ta, tb = m.cmd('PTTL', k), r.cmd('PTTL', k)
        if (ta == -2) != (tb == -2):
            mismatch += 1; print('EXISTS MISMATCH', db, k, ta, tb)
        elif ta > 0 and abs(ta - tb) > 5000:
            mismatch += 1; print('TTL MISMATCH', db, k, ta, tb)
        elif ta == -1 and tb != -1:
            mismatch += 1; print('PERSIST MISMATCH', db, k, tb)
    mk = set(keys); rk = set(r.cmd('KEYS','*'))
    ex = rk - mk
    if ex: extra += len(ex); print('EXTRA on replica db', db, list(ex)[:10])
print(f'checked={total} value/type/ttl mismatches={mismatch} missing={missing} extra={extra} elapsed={time.time()-t0:.1f}s')

m.cmd('SELECT', 0); r.cmd('SELECT', 0)
streams = [k for k in m.cmd('KEYS','*') if m.cmd('TYPE', k) == b'stream']
print('streams:', len(streams))
gs = problems = 0
for k in streams:
    ga, gb = m.cmd('XINFO','GROUPS',k), r.cmd('XINFO','GROUPS',k)
    if ga != gb:
        print('GROUP MISMATCH', k); problems += 1
    for g in ga:
        gname = g[g.index(b'name')+1]
        ca = m.cmd('XINFO','CONSUMERS',k,gname); cb = r.cmd('XINFO','CONSUMERS',k,gname)
        if ca != cb:
            print('CONSUMER MISMATCH', k, gname); problems += 1
        pa = m.cmd('XPENDING',k,gname,'-','+',1000); pb = r.cmd('XPENDING',k,gname,'-','+',1000)
        if pa != pb:
            print('PENDING MISMATCH', k, gname); problems += 1
        gs += 1
    ea = m.cmd('XRANGE',k,'-','+'); eb = r.cmd('XRANGE',k,'-','+')
    if ea != eb:
        print('ENTRIES MISMATCH', k); problems += 1
print('groups checked:', gs, 'stream problems:', problems)
EOF

39  $ python3 - <<'EOF'
import socket, time, re

class C:
    def __init__(self, port):
        self.s = socket.create_connection(('127.0.0.1', port))
        self.f = self.s.makefile('rb')
    def cmd(self, *args):
        out = b'*%d\r\n' % len(args)
        for a in args:
            if not isinstance(a, bytes): a = str(a).encode()
            out += b'$%d\r\n%s\r\n' % (len(a), a)
        self.s.sendall(out)
        return self.read()
    def read(self):
        line = self.f.readline()
        t, rest = line[:1], line[1:].strip()
        if t in (b'+', b'-'): return rest.decode()
        if t == b':': return int(rest)
        if t == b'$':
            n = int(rest)
            if n == -1: return None
            d = self.f.read(n); self.f.read(2); return d
        if t == b'*':
            n = int(rest)
            if n == -1: return None
            return [self.read() for _ in range(n)]
        raise Exception(line)

m, r = C(6379), C(6380)
info = m.cmd('INFO','keyspace')
dbs = [int(x) for x in re.findall(rb'\bdb(\d+):', info)]
print('dbs:', dbs)
total = mismatch = missing = extra = 0
t0 = time.time()
for db in dbs:
    m.cmd('SELECT', db); r.cmd('SELECT', db)
    keys = m.cmd('KEYS','*')
    for k in keys:
        total += 1
        a = m.cmd('DUMP', k); b = r.cmd('DUMP', k)
        if b is None:
            missing += 1; print('MISSING', db, k); continue
        if a[:-10] != b[:-10]:
            mismatch += 1
            if mismatch < 10: print('VALUE MISMATCH', db, k)
        if m.cmd('TYPE', k) != r.cmd('TYPE', k):
            mismatch += 1; print('TYPE MISMATCH', db, k)
        ta, tb = m.cmd('PTTL', k), r.cmd('PTTL', k)
        if (ta == -2) != (tb == -2):
            mismatch += 1; print('EXISTS MISMATCH', db, k, ta, tb)
        elif ta > 0 and abs(ta - tb) > 5000:
            mismatch += 1; print('TTL MISMATCH', db, k, ta, tb)
        elif ta == -1 and tb != -1:
            mismatch += 1; print('PERSIST MISMATCH', db, k, tb)
    mk = set(keys); rk = set(r.cmd('KEYS','*'))
    ex = rk - mk
    if ex: extra += len(ex); print('EXTRA on replica db', db, list(ex)[:10])
print(f'checked={total} value/type/ttl mismatches={mismatch} missing={missing} extra={extra} elapsed={time.time()-t0:.1f}s')

m.cmd('SELECT', 0); r.cmd('SELECT', 0)
streams = [k for k in m.cmd('KEYS','*') if m.cmd('TYPE', k) == b'stream']
print('streams:', len(streams))
gs = problems = 0
for k in streams:
    ga, gb = m.cmd('XINFO','GROUPS',k), r.cmd('XINFO','GROUPS',k)
    if ga != gb:
        print('GROUP MISMATCH', k); problems += 1
    for g in ga:
        gname = g[g.index(b'name')+1]
        ca = m.cmd('XINFO','CONSUMERS',k,gname); cb = r.cmd('XINFO','CONSUMERS',k,gname)
        if ca != cb:
            print('CONSUMER MISMATCH', k, gname); problems += 1
        pa = m.cmd('XPENDING',k,gname,'-','+',1000); pb = r.cmd('XPENDING',k,gname,'-','+',1000)
        if pa != pb:
            print('PENDING MISMATCH', k, gname); problems += 1
        gs += 1
    ea = m.cmd('XRANGE',k,'-','+'); eb = r.cmd('XRANGE',k,'-','+')
    if ea != eb:
        print('ENTRIES MISMATCH', k); problems += 1
print('groups checked:', gs, 'stream problems:', problems)
EOF

40  $ python3 - <<'EOF'
import socket, re

class C:
    def __init__(self, port):
        self.s = socket.create_connection(('127.0.0.1', port))
        self.f = self.s.makefile('rb')
    def cmd(self, *args):
        out = b'*%d\r\n' % len(args)
        for a in args:
            if not isinstance(a, bytes): a = str(a).encode()
            out += b'$%d\r\n%s\r\n' % (len(a), a)
        self.s.sendall(out)
        return self.read()
    def read(self):
        line = self.f.readline()
        t, rest = line[:1], line[1:].strip()
        if t in (b'+', b'-'): return rest.decode()
        if t == b':': return int(rest)
        if t == b'$':
            n = int(rest)
            if n == -1: return None
            d = self.f.read(n); self.f.read(2); return d
        if t == b'*':
            n = int(rest)
            if n == -1: return None
            return [self.read() for _ in range(n)]
        raise Exception(line)

m, r = C(6379), C(6380)
info = m.cmd('INFO','keyspace')
dbs = [int(x) for x in re.findall(rb'\bdb(\d+):', info)]
total_groups = problems = streams_n = 0
for db in dbs:
    m.cmd('SELECT', db); r.cmd('SELECT', db)
    streams = [k for k in m.cmd('KEYS','*') if m.cmd('TYPE', k) == 'stream']
    streams_n += len(streams)
    for k in streams:
        ga, gb = m.cmd('XINFO','GROUPS',k), r.cmd('XINFO','GROUPS',k)
        if ga != gb:
            print('GROUP MISMATCH', k); problems += 1
        for g in ga:
            gname = g[g.index(b'name')+1]
            ca = m.cmd('XINFO','CONSUMERS',k,gname); cb = r.cmd('XINFO','CONSUMERS',k,gname)
            if ca != cb: print('CONSUMER MISMATCH', k, gname); problems += 1
            pa = m.cmd('XPENDING',k,gname,'-','+',5000); pb = r.cmd('XPENDING',k,gname,'-','+',5000)
            if pa != pb: print('PENDING MISMATCH', k, gname); problems += 1
            total_groups += 1
        ea = m.cmd('XRANGE',k,'-','+'); eb = r.cmd('XRANGE',k,'-','+')
        if ea != eb: print('ENTRIES MISMATCH', k); problems += 1
print(f'dbs={dbs} streams={streams_n} groups={total_groups} problems={problems}')

# show one full group comparison for the record
m.cmd('SELECT',0); r.cmd('SELECT',0)
print('--- master XINFO GROUPS events:00'); print(m.cmd('XINFO','GROUPS','events:00'))
print('--- valkey XINFO GROUPS events:00'); print(r.cmd('XINFO','GROUPS','events:00'))
EOF

41  $ python3 - <<'EOF'
import socket
class C:
    def __init__(self, port):
        self.s = socket.create_connection(('127.0.0.1', port)); self.f = self.s.makefile('rb')
    def cmd(self, *args):
        out = b'*%d\r\n' % len(args)
        for a in args:
            if not isinstance(a, bytes): a = str(a).encode()
            out += b'$%d\r\n%s\r\n' % (len(a), a)
        self.s.sendall(out); return self.read()
    def read(self):
        line = self.f.readline(); t, rest = line[:1], line[1:].strip()
        if t in (b'+', b'-'): return rest.decode()
        if t == b':': return int(rest)
        if t == b'$':
            n = int(rest)
            if n == -1: return None
            d = self.f.read(n); self.f.read(2); return d
        if t == b'*':
            n = int(rest)
            if n == -1: return None
            return [self.read() for _ in range(n)]

m, r = C(6379), C(6380)
a = m.cmd('XINFO','CONSUMERS','events:07','workers')
b = r.cmd('XINFO','CONSUMERS','events:07','workers')
print('master :', a)
print('valkey :', b)
def strip_idle(lst):
    out=[]
    for c in lst:
        d=dict(zip(c[0::2], c[1::2]))
        d.pop(b'idle', None); d.pop(b'inactive', None)
        out.append(d)
    return out
print('equal ignoring idle/inactive:', strip_idle(a)==strip_idle(b))
EOF

42  $ valkey-cli -p 6380 REPLICAOF NO ONE; sleep 1; valkey-cli -p 6380 INFO replication | grep -E 'role|master_host|slave_read_only|master_replid:|connected_slaves'; echo ====; valkey-cli -p 6380 CONFIG GET replicaof; grep -n 'replicaof\|slaveof' /etc/valkey/valkey.conf || echo "no replicaof in config"

43  $ grep -q '^replicaof' /etc/valkey/valkey.conf || echo 'replicaof no one' >> /etc/valkey/valkey.conf; tail -3 /etc/valkey/valkey.conf; echo ====; valkey-cli -p 6380 CONFIG GET replica-read-only; echo ==== write test; valkey-cli -p 6380 SET __migration_test ok; valkey-cli -p 6380 GET __migration_test; valkey-cli -p 6380 DEL __migration_test; valkey-cli -p 6380 INCR __migration_counter; valkey-cli -p 6380 DEL __migration_counter; echo ==== bgsave; valkey-cli -p 6380 BGSAVE; sleep 2; valkey-cli -p 6380 INFO persistence | grep -E 'rdb_last_bgsave_status|rdb_changes_since_last_save'; ls -la /var/lib/valkey/

44  $ echo "old server still running & data untouched:"; valkey-cli -p 6379 INFO keyspace; valkey-cli -p 6379 INFO replication | grep -E 'role|connected_slaves|slave0'; ps aux | grep -E 'redis-server|valkey-server' | grep -v grep

45  $ valkey-cli -p 6380 CONFIG SET replica-read-only no; grep -q '^replica-read-only' /etc/valkey/valkey.conf || echo 'replica-read-only no' >> /etc/valkey/valkey.conf; python3 - <<'EOF'
import socket, re
class C:
    def __init__(self, port):
        self.s = socket.create_connection(('127.0.0.1', port)); self.f = self.s.makefile('rb')
    def cmd(self, *args):
        out = b'*%d\r\n' % len(args)
        for a in args:
            if not isinstance(a, bytes): a = str(a).encode()
            out += b'$%d\r\n%s\r\n' % (len(a), a)
        self.s.sendall(out); return self.read()
    def read(self):
        line = self.f.readline(); t, rest = line[:1], line[1:].strip()
        if t in (b'+', b'-'): return rest.decode()
        if t == b':': return int(rest)
        if t == b'$':
            n = int(rest)
            if n == -1: return None
            d = self.f.read(n); self.f.read(2); return d
        if t == b'*':
            n = int(rest)
            if n == -1: return None
            return [self.read() for _ in range(n)]

m, r = C(6379), C(6380)
dbs = [int(x) for x in re.findall(rb'\bdb(\d+):', m.cmd('INFO','keyspace'))]
total = bad = 0
for db in dbs:
    m.cmd('SELECT', db); r.cmd('SELECT', db)
    mk = m.cmd('KEYS','*'); rk = set(r.cmd('KEYS','*'))
    for k in mk:
        total += 1
        a, b = m.cmd('DUMP', k), r.cmd('DUMP', k)
        if b is None or a[:-10] != b[:-10] or m.cmd('TYPE',k) != r.cmd('TYPE',k): bad += 1
        ta, tb = m.cmd('PTTL',k), r.cmd('PTTL',k)
        if (ta > 0 and abs(ta-tb) > 5000) or (ta == -1 and tb != -1) or (ta == -2) != (tb == -2): bad += 1
    bad += len(rk - set(mk))
print(f'FINAL: dbs={dbs} checked={total} problems={bad}')
print('valkey role:', r.cmd('INFO','replication').decode().split('role:')[1].split('\n')[0])
print('valkey dbsize per db:', [(db, (r.cmd('SELECT',db), r.cmd('DBSIZE'))[1]) for db in dbs])
EOF
echo; echo "== final config =="; grep -vE '^\s*#|^\s*$' /etc/valkey/valkey.conf; echo "== valkey-cli ping =="; valkey-cli -p 6380 PING

{
 "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": "7.2.4",
  "server_name": "valkey",
  "valkey_version": "9.1.2"
 },
 "old_digest_ok": true,
 "old_server": {
  "redis_version": "7.2.16",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

1  $ echo "=== processes ==="; ps aux | grep -Ei 'redis|valkey' | grep -v grep; echo; echo "=== redis 6379 info server ==="; /opt/redis-7.2/bin/redis-cli -p 6379 info server; echo "=== redis keyspace ==="; /opt/redis-7.2/bin/redis-cli -p 6379 info keyspace; echo "=== redis dbsize ==="; /opt/redis-7.2/bin/redis-cli -p 6379 dbsize

2  $ echo "=== which valkey-cli ==="; command -v valkey-cli redis-cli; echo; echo "=== valkey 6380 info server ==="; valkey-cli -p 6380 info server 2>/dev/null || redis-cli -p 6380 info server; echo "=== valkey keyspace ==="; valkey-cli -p 6380 info keyspace; echo "=== valkey dbsize ==="; valkey-cli -p 6380 dbsize; echo "=== valkey replication info ==="; valkey-cli -p 6380 info replication

3  $ echo "=== redis.conf (relevant) ==="; grep -Ev '^\s*#|^\s*$' /etc/redis-old/redis.conf; echo; echo "=== auth test ==="; /opt/redis-7.2/bin/redis-cli -p 6379 ping; /opt/redis-7.2/bin/redis-cli -p 6379 config get requirepass

4  $ echo "=== valkey.conf (relevant) ==="; grep -Ev '^\s*#|^\s*$' /etc/valkey/valkey.conf; echo "=== auth test ==="; valkey-cli -p 6380 ping; valkey-cli -p 6380 config get requirepass; echo "=== valkey persistence settings ==="; valkey-cli -p 6380 config get save; valkey-cli -p 6380 config get appendonly; valkey-cli -p 6380 config get dir; valkey-cli -p 6380 config get min-replicas-to-write; valkey-cli -p 6380 config get replica-read-only

5  $ echo "=== key type inventory on redis (db0) ==="; /opt/redis-7.2/bin/redis-cli -p 6379 --scan | while read k; do /opt/redis-7.2/bin/redis-cli -p 6379 type "$k"; done | sort | uniq -c; echo "=== db2 ==="; /opt/redis-7.2/bin/redis-cli -p 6379 -n 2 --scan | while read k; do /opt/redis-7.2/bin/redis-cli -p 6379 -n 2 type "$k"; done | sort | uniq -c; echo "=== streams present ==="; /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"); if [ "$t" = stream ]; then echo "db0 stream: $k"; fi; done; /opt/redis-7.2/bin/redis-cli -p 6379 -n 2 --scan | while read k; do t=$(/opt/redis-7.2/bin/redis-cli -p 6379 -n 2 type "$k"); if [ "$t" = stream ]; then echo "db2 stream: $k"; fi; done

6  $ python3 -V; python3 -c "import redis; print('redis-py', redis.__version__)" 2>&1 | head -2; pip3 --version 2>&1 | head -1

7  $ echo "=== sample DUMP compare (string) ==="; k=$(/opt/redis-7.2/bin/redis-cli -p 6379 --scan --pattern '*' | head -1); echo "key=$k"; /opt/redis-7.2/bin/redis-cli -p 6379 dump "$k" | xxd | head -3; echo "--- rdb version bytes (last 3) ---"; /opt/redis-7.2/bin/redis-cli -p 6379 debug rdb-version 2>/dev/null || true; /opt/redis-7.2/bin/redis-cli -p 6379 info persistence | grep -E 'rdb|aof'

8  $ cat > /tmp/snapshot.py <<'EOF'
import json, sys, base64
import redis

host, port, out = sys.argv[1], int(sys.argv[2]), sys.argv[3]
r = redis.Redis(host=host, port=port, decode_responses=False)

def b(x):
    if isinstance(x, bytes): return {"__b64__": base64.b64encode(x).decode()}
    if isinstance(x, (int, float, str)) or x is None: return x
    if isinstance(x, (list, tuple)): return [b(i) for i in x]
    if isinstance(x, dict): return {str(k): b(v) for k, v in x.items()}
    return str(x)

# discover non-empty dbs
dbs = []
for line in r.info("keyspace").values() if False else str(r.info("keyspace")).splitlines():
    pass
info = r.info("keyspace")
for name, val in info.items():
    if name.startswith("db"):
        dbs.append(int(name[2:]))
dbs = sorted(dbs)

snap = {"dbs": {}, "counts": {}}
for db in dbs:
    rc = redis.Redis(host=host, port=port, db=db, decode_responses=False)
    keys = sorted(k.decode() for k in rc.scan_iter(count=1000))
    snap["counts"][f"db{db}"] = len(keys)
    dbdata = {}
    for k in keys:
        t = rc.type(k).decode()
        pttl = rc.pttl(k)
        try:
            dmp = rc.dump(k)
        except Exception as e:
            dmp = None
        ent = {"type": t, "pttl": pttl, "dump": b(dmp)}
        if t == "string":
            ent["val"] = b(rc.get(k))
        elif t == "hash":
            h = rc.hgetall(k)
            ent["val"] = b(sorted([(f, v) for f, v in h.items()]))
        elif t == "list":
            ent["val"] = b(rc.lrange(k, 0, -1))
        elif t == "set":
            ent["val"] = b(sorted(rc.smembers(k)))
        elif t == "zset":
            ent["val"] = b(sorted(rc.zrange(k, 0, -1, withscores=True)))
        elif t == "stream":
            entries = rc.xrange(k, b"-", b"+")
            ent["entries"] = b([[eid, fields] for eid, fields in entries])
            gi = rc.xinfo_groups(k)
            groups = []
            for g in gi:
                gname = g[b"name"]
                pend = rc.xpending(k, gname)
                consumers = []
                for c in rc.xinfo_consumers(k, gname):
                    cp = rc.xpending_range(k, gname, b"-", b"+", count=100000, consumer=c[b"name"])
                    consumers.append({
                        "name": b(c[b"name"]),
                        "pending": b(sorted([[e[b"message_id"], e[b"delivery_count"]] for e in cp])),
                    })
                groups.append({
                    "name": b(gname),
                    "last_id": b(g[b"last-id"]),
                    "pel": b(g[b"pel"]),
                    "pending_ids": b(sorted([e[b"message_id"] for e in rc.xpending_range(k, gname, b"-", b"+", count=100000)])),
                    "consumers": sorted(consumers, key=lambda x: x["name"]["__b64__"] if isinstance(x["name"], dict) else str(x["name"])),
                })
            groups.sort(key=lambda x: x["name"]["__b64__"] if isinstance(x["name"], dict) else str(x["name"]))
            ent["groups"] = groups
            ent["info_len"] = b(rc.xlen(k))
        dbdata[k] = ent
    snap["dbs"][f"db{db}"] = dbdata

with open(out, "w") as f:
    json.dump(snap, f, indent=1, sort_keys=True)
print(f"snapshot written to {out}: dbs={snap['counts']}")
EOF
/opt/redis-7.2/bin/redis-cli -p 6379 info keyspace
python3 /tmp/snapshot.py 127.0.0.1 6379 /tmp/baseline_redis.json

9  $ python3 - <<'EOF'
import redis
r = redis.Redis(port=6379, decode_responses=False)
g = r.xinfo_groups(b"events:00")
print(type(g), g)
c = r.xinfo_consumers(b"events:00", g[0][b"name"] if b"name" in g[0] else list(g[0].values())[0])
print(c)
EOF

10  $ cd /tmp && python3 - <<'EOF'
import re
s = open('/tmp/snapshot.py').read()
s = s.replace('gname = g[b"name"]', 'gname = g["name"]')
s = s.replace('"last_id": b(g[b"last-id"]),', '"last_id": b(g["last-delivered-id"]),')
s = s.replace('"pel": b(g[b"pel"]),', '"pel": b(g["pending"]),')
s = s.replace('"consumers": b(g[b"consumers"]),', '"consumers": b(g["consumers"]),')
s = s.replace('c[b"name"]', 'c["name"]')
s = s.replace('consumer=c[b"name"]', 'consumer=c["name"]')
s = s.replace('e[b"message_id"], e[b"delivery_count"]', 'e["message_id"], e["delivery_count"]')
s = s.replace('e[b"message_id"] for e in rc.xpending_range', 'e["message_id"] for e in rc.xpending_range')
open('/tmp/snapshot.py','w').write(s)
EOF
grep -n 'g\["name"\]\|last-delivered\|"pending"\|c\["name"\]\|message_id' /tmp/snapshot.py; python3 /tmp/snapshot.py 127.0.0.1 6379 /tmp/baseline_redis.json

11  $ python3 - <<'EOF'
import inspect, redis
from redis.commands.core import StreamCommands
print(inspect.signature(StreamCommands.xpending_range))
print(inspect.signature(StreamCommands.xpending))
EOF

12  $ sed -i 's/consumer=c\["name"\]/consumername=c["name"]/' /tmp/snapshot.py && python3 /tmp/snapshot.py 127.0.0.1 6379 /tmp/baseline_redis.json && ls -la /tmp/baseline_redis.json

13  $ python3 - <<'EOF'
import redis
r = redis.Redis(port=6379, decode_responses=False)
cp = r.xpending_range(b"events:00", b"workers", b"-", b"+", count=10, consumername=b"worker-1")
print(cp[:2])
allp = r.xpending_range(b"events:00", b"workers", b"-", b"+", count=10)
print(allp[:2])
EOF

14  $ python3 - <<'EOF'
s = open('/tmp/snapshot.py').read()
s = s.replace('"pending": b(sorted([[e["message_id"], e["delivery_count"]] for e in cp])),',
              '"pending": b(sorted([[e["message_id"], e["consumer"], e["times_delivered"]] for e in cp])),')
open('/tmp/snapshot.py','w').write(s)
EOF
python3 /tmp/snapshot.py 127.0.0.1 6379 /tmp/baseline_redis.json && ls -la /tmp/baseline_redis.json && python3 - <<'EOF'
import json
s = json.load(open('/tmp/baseline_redis.json'))
print("counts:", s["counts"])
db0 = s["dbs"]["db0"]
streams = {k: v for k, v in db0.items() if v["type"] == "stream"}
print("streams:", len(streams))
ex = next(iter(streams.values()))
print("example stream:", json.dumps(ex, indent=1)[:1200])
EOF

15  $ valkey-cli -p 6380 replicaof 127.0.0.1 6379; sleep 2; valkey-cli -p 6380 info replication | grep -E 'role|master_link|master_sync|slave|offset'

16  $ sleep 3; valkey-cli -p 6380 info replication | grep -E 'role|master_link|master_sync|slave_repl_offset'; echo "=== valkey log ==="; tail -30 /var/log/valkey/valkey.log

17  $ valkey-cli -p 6380 dbsize; valkey-cli -p 6380 -n 2 dbsize; valkey-cli -p 6380 info keyspace; valkey-cli -p 6380 info replication | grep -E 'role|master_link|master_sync|slave_repl_offset|master_repl_offset'

18  $ python3 /tmp/snapshot.py 127.0.0.1 6380 /tmp/replica_snap.json

19  $ cat > /tmp/compare.py <<'EOF'
import json, sys, time

a = json.load(open(sys.argv[1]))   # redis baseline
b = json.load(open(sys.argv[2]))   # valkey
TOL_MS = int(sys.argv[3]) if len(sys.argv) > 3 else 30000

errors = []
if a["counts"] != b["counts"]:
    errors.append(f"key counts differ: {a['counts']} vs {b['counts']}")

def isb(x): return isinstance(x, dict) and "__b64__" in x

for db in sorted(set(a["dbs"]) | set(b["dbs"])):
    da, dbv = a["dbs"].get(db, {}), b["dbs"].get(db, {})
    ka, kb = set(da), set(dbv)
    if ka - kb: errors.append(f"{db}: missing keys on valkey: {sorted(ka-kb)[:10]}")
    if kb - ka: errors.append(f"{db}: extra keys on valkey: {sorted(kb-ka)[:10]}")
    same_dump = diff_dump = 0
    for k in sorted(ka & kb):
        ea, eb = da[k], dbv[k]
        if ea["type"] != eb["type"]:
            errors.append(f"{db}:{k}: type {ea['type']} != {eb['type']}"); continue
        pa, pb = ea["pttl"], eb["pttl"]
        if pa == -1 or pb == -1:
            if pa != pb: errors.append(f"{db}:{k}: ttl flag {pa} != {pb}")
        elif abs(pa - pb) > TOL_MS:
            errors.append(f"{db}:{k}: pttl {pa} vs {pb} (diff {pa-pb}ms)")
        if ea.get("val") is not None and ea.get("val") != eb.get("val"):
            errors.append(f"{db}:{k}: value differs ({ea['type']})")
        for f in ("entries", "groups", "info_len"):
            if f in ea and ea[f] != eb.get(f):
                errors.append(f"{db}:{k}: stream field {f} differs")
        da_ = ea.get("dump"); db_ = eb.get("dump")
        if isb(da_) and isb(db_):
            if da_["__b64__"] == db_["__b64__"]:
                same_dump += 1
            else:
                # compare ignoring 3-byte footer (rdb ver + crc) 
                import base64
                xa, xb = base64.b64decode(da_["__b64__"]), base64.b64decode(db_["__b64__"])
                if xa[:-3] == xb[:-3]: same_dump += 1
                else:
                    diff_dump += 1
                    if diff_dump <= 5: errors.append(f"{db}:{k}: DUMP payload differs")
    print(f"{db}: keys compared={len(ka & kb)}, dump identical={same_dump}, dump differs={diff_dump}")

if errors:
    print(f"\n{len(errors)} DIFFERENCES:")
    for e in errors[:50]: print("  -", e)
    sys.exit(1)
print("\nALL CHECKS PASSED: key sets, types, values, TTLs, stream data/groups/PELs, DUMP payloads all match")
EOF
echo "--- snapshotting redis again (fresh) ---"; python3 /tmp/snapshot.py 127.0.0.1 6379 /tmp/after_redis.json; echo "--- comparing redis vs valkey replica ---"; python3 /tmp/compare.py /tmp/after_redis.json /tmp/replica_snap.json 60000

20  $ k=active:00; echo "=== redis dump ==="; /opt/redis-7.2/bin/redis-cli -p 6379 dump "$k" | od -A d -t x1 | head -5; echo "=== valkey dump ==="; valkey-cli -p 6380 dump "$k" | od -A d -t x1 | head -5; echo "=== value ==="; /opt/redis-7.2/bin/redis-cli -p 6379 get "$k"; valkey-cli -p 6380 get "$k"; echo "=== encodings ==="; /opt/redis-7.2/bin/redis-cli -p 6379 object encoding "$k"; valkey-cli -p 6380 object encoding "$k"; echo "=== lengths ==="; /opt/redis-7.2/bin/redis-cli -p 6379 dump "$k" | wc -c; valkey-cli -p 6380 dump "$k" | wc -c

21  $ python3 - <<'EOF'
import json, base64
a = json.load(open('/tmp/after_redis.json'))
b = json.load(open('/tmp/replica_snap.json'))
for k in ['active:00', 'user:0000']:
    if k in a['dbs']['db0'] and k in b['dbs']['db0']:
        xa = base64.b64decode(a['dbs']['db0'][k]['dump']['__b64__'])
        xb = base64.b64decode(b['dbs']['db0'][k]['dump']['__b64__'])
        print(k, 'len', len(xa), len(xb))
        diffs = [i for i in range(min(len(xa), len(xb))) if xa[i] != xb[i]]
        print('  first diff offsets:', diffs[:10], 'total:', len(diffs))
        if diffs:
            i = diffs[0]
            print('  redis  around:', xa[max(0,i-4):i+8].hex())
            print('  valkey around:', xb[max(0,i-4):i+8].hex())
        print('  redis tail:', xa[-6:].hex(), ' valkey tail:', xb[-6:].hex())
EOF

22  $ python3 - <<'EOF'
import json, base64
a = json.load(open('/tmp/after_redis.json'))
b = json.load(open('/tmp/replica_snap.json'))

for dbk, k in [('db0','user:0000'), ('db0','active:00')]:
    ea, eb = a['dbs'][dbk][k], b['dbs'][dbk][k]
    val = ea['val']['__b64__']
    L = len(base64.b64decode(val))
    xa = base64.b64decode(ea['dump']['__b64__'])
    xb = base64.b64decode(eb['dump']['__b64__'])
    print(f"{k}: value len={L}, dump len={len(xa)}")
    # string payload = type(1) + lenenc + value
    # lenenc: <64 ->1; <16384 ->1? actually 14bit uses 1 byte 0x80|..; here just show bytes
    print("  first bytes:", xa[:6].hex())
    print("  redis footer candidates:")
    for pend in range(1+L, min(len(xa), 1+L+6)):
        print(f"    payload_end={pend}: footer={xa[pend:].hex()} ({len(xa)-pend}B)")
    print("  valkey same region:", xb[1+L-1:].hex())
EOF

23  $ python3 - <<'EOF'
import json, base64
a = json.load(open('/tmp/after_redis.json'))
b = json.load(open('/tmp/replica_snap.json'))

def raw(ent, field='val'):
    v = ent.get(field)
    if isinstance(v, dict) and '__b64__' in v:
        return base64.b64decode(v['__b64__'])
    return None

# find a plain string key
k = None
for kk, ent in a['dbs']['db0'].items():
    if ent['type'] == 'string':
        k = kk; break
ea, eb = a['dbs']['db0'][k], b['dbs']['db0'][k]
L = len(raw(ea))
xa = base64.b64decode(ea['dump']['__b64__'])
xb = base64.b64decode(eb['dump']['__b64__'])
print(f"string key={k} value_len={L} dump_len={len(xa)}")
print("header bytes:", xa[:8].hex())
# dump = 1 type + lenenc value + optional LRU/LFU if -1 ttl? no (ttl==-1 only for dump? actually lru only when key has expire? no: DUMP includes expire/lfu? no)
# just show tail from payload end (payload ends at some p; footer: 2B expire? 1B rdbver? 8B crc64)
p0 = 1 + 1 + L   # rough
for p in range(p0-2, p0+8):
    if p < len(xa):
        print(f"  p={p}: redis tail={xa[p:].hex()} ({len(xa)-p}B)  valkey={xb[p:].hex()} ({len(xb)-p}B)")
EOF

24  $ python3 - <<'EOF'
import json, base64
a = json.load(open('/tmp/after_redis.json'))
b = json.load(open('/tmp/replica_snap.json'))
for k in ['active:00', 'user:0000']:
    if k not in a['dbs']['db0']: continue
    xa = base64.b64decode(a['dbs']['db0'][k]['dump']['__b64__'])
    xb = base64.b64decode(b['dbs']['db0'][k]['dump']['__b64__'])
    print(k, 'len', len(xa), len(xb), 'pttl', a['dbs']['db0'][k]['pttl'], b['dbs']['db0'][k]['pttl'])
    print('  redis :', xa.hex())
    print('  valkey:', xb.hex())
    print()
EOF

25  $ python3 - <<'EOF'
import json, base64, sys
a = json.load(open('/tmp/after_redis.json'))
b = json.load(open('/tmp/replica_snap.json'))
FOOTER = 10  # 2B rdb version + 8B crc64
n_same = n_diff = 0
diffs = []
for db in a['dbs']:
    da, dbv = a['dbs'][db], b['dbs'].get(db, {})
    for k, ea in da.items():
        eb = dbv.get(k)
        if eb is None: diffs.append((db,k,'missing')); continue
        xa = base64.b64decode(ea['dump']['__b64__'])
        xb = base64.b64decode(eb['dump']['__b64__'])
        if len(xa) != len(xb): diffs.append((db,k,f'len {len(xa)}!={len(xb)}')); n_diff+=1; continue
        if xa[:-FOOTER] == xb[:-FOOTER]: n_same += 1
        else:
            n_diff += 1
            if len(diffs) < 10:
                i = next(i for i in range(len(xa)-FOOTER) if xa[i]!=xb[i])
                diffs.append((db,k,f'payload differs at {i} (type={ea["type"]})'))
print(f"payload-identical (excluding 10B footer): {n_same}/{n_same+n_diff}")
for d in diffs[:10]: print("  ", d)
EOF

26  $ valkey-cli -p 6380 replicaof no one; sleep 1; echo "=== role ==="; valkey-cli -p 6380 info replication | grep -E 'role|master_link|slave'; echo "=== keyspace ==="; valkey-cli -p 6380 info keyspace; valkey-cli -p 6380 dbsize; valkey-cli -p 6380 -n 2 dbsize; echo "=== config check (no replicaof in file) ==="; grep -Ei 'replicaof|slaveof' /etc/valkey/valkey.conf || echo "none (config clean)"; echo "=== persistence ==="; valkey-cli -p 6380 config get save; valkey-cli -p 6380 config get appendonly; echo "=== write test ==="; valkey-cli -p 6380 set __migration_write_test__ ok; valkey-cli -p 6380 get __migration_write_test__; valkey-cli -p 6380 del __migration_write_test__; valkey-cli -p 6380 exists __migration_write_test__; valkey-cli -p 6380 dbsize

27  $ echo "=== source server still running & untouched ==="; ps -p 9 -o pid,cmd --no-headers; /opt/redis-7.2/bin/redis-cli -p 6379 info replication | grep -E 'role|slave|connected'; /opt/redis-7.2/bin/redis-cli -p 6379 info keyspace; /opt/redis-7.2/bin/redis-cli -p 6379 ping; echo "=== recent redis log ==="; tail -5 /var/log/redis-old/redis.log

28  $ python3 /tmp/snapshot.py 127.0.0.1 6379 /tmp/final_redis.json; python3 /tmp/snapshot.py 127.0.0.1 6380 /tmp/final_valkey.json; python3 /tmp/compare.py /tmp/final_redis.json /tmp/final_valkey.json 45000

29  $ echo "=== trigger snapshot on valkey ==="; valkey-cli -p 6380 bgsave; sleep 4; valkey-cli -p 6380 info persistence | grep -E 'rdb_last_bgsave_status|rdb_changes_since_last_save|rdb_last_save_time|rdb_saves|loading:'; ls -la /var/lib/valkey/; echo "=== stream groups spot-check on valkey ==="; valkey-cli -p 6380 xinfo groups events:00; valkey-cli -p 6380 xinfo consumers events:00 workers; valkey-cli -p 6380 xpending events:00 workers

30  $ python3 - <<'EOF'
s = open('/tmp/compare.py').read()
s = s.replace('FOOTER = 10', 'FOOTER = 10') 
s = s.replace('xa[:-3] == xb[:-3]', 'xa[:-10] == xb[:-10]')
open('/tmp/compare.py','w').write(s)
EOF
python3 /tmp/compare.py /tmp/final_redis.json /tmp/final_valkey.json 45000; echo "exit=$?"

31  $ echo "=== source integrity: baseline (05:40) vs final (05:47) on Redis ==="; python3 - <<'EOF'
import json, base64
a = json.load(open('/tmp/baseline_redis.json'))
b = json.load(open('/tmp/final_redis.json'))
bad = 0
assert a['counts'] == b['counts'], (a['counts'], b['counts'])
max_drift = 0
for db in a['dbs']:
    da, db2 = a['dbs'][db], b['dbs'][db]
    assert set(da) == set(db2)
    for k in da:
        x, y = da[k], db2[k]
        if x['type'] != y['type'] or x.get('val') != y.get('val') or x['dump'] != y['dump'] or x.get('groups') != y.get('groups') or x.get('entries') != y.get('entries'):
            bad += 1
        if x['pttl'] > 0 and y['pttl'] > 0:
            max_drift = max(max_drift, abs((x['pttl'] - y['pttl'])))
print(f"keys={sum(a['counts'].values())}, mismatches={bad}, expected TTL drift over ~7min={max_drift}ms (~420000ms expected)")
EOF
echo "=== final state ==="; valkey-cli -p 6380 info server | grep -E 'valkey_version|tcp_port'; valkey-cli -p 6380 info replication | grep -E 'role|connected_slaves'; valkey-cli -p 6380 config get replicaof; valkey-cli -p 6380 info clients | grep -E 'connected_clients'; /opt/redis-7.2/bin/redis-cli -p 6379 info keyspace; valkey-cli -p 6380 info keyspace; ls -la /var/lib/valkey/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": "7.2.4",
  "server_name": "valkey",
  "valkey_version": "9.1.2"
 },
 "old_digest_ok": true,
 "old_server": {
  "redis_version": "7.2.16",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

1  $ uname -a; cat /etc/os-release | head -3; echo ---; ls /opt/redis-7.2/bin; echo ---; ps aux | grep -E 'redis|valkey' | grep -v grep

2  $ redis-cli -p 6379 INFO server | head -20; echo ===; redis-cli -p 6380 INFO server | head -20; echo ===; which redis-cli valkey-cli; redis-cli --version; valkey-cli --version 2>/dev/null

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

4  $ redis-cli -p 6379 INFO keyspace; echo ===; redis-cli -p 6379 INFO replication; echo ===; redis-cli -p 6380 INFO keyspace; echo ===; redis-cli -p 6380 INFO replication; echo ===; redis-cli -p 6379 CONFIG GET databases; redis-cli -p 6380 CONFIG GET databases; echo ===; redis-cli -p 6379 CONFIG GET maxmemory-policy; redis-cli -p 6380 CONFIG GET maxmemory-policy; redis-cli -p 6379 CONFIG GET maxmemory; redis-cli -p 6380 CONFIG GET maxmemory

5  $ which python3 python; python3 --version 2>/dev/null; redis-cli -p 6379 CONFIG GET save; redis-cli -p 6380 CONFIG GET save; redis-cli -p 6380 CONFIG GET replica-read-only; redis-cli -p 6380 CONFIG GET replica-serve-stale-data; redis-cli -p 6380 CONFIG GET appendonly; redis-cli -p 6379 CONFIG GET appendonly

6  $ for db in 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15; do out=$(redis-cli -n $db DBSIZE); [ "$out" != "0" ] && echo "db$db: $out"; done; echo ===; redis-cli -p 6379 --scan | head -5; echo ===; redis-cli -p 6379 INFO commandstats | head -5

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

8  $ redis-cli -p 6379 --scan | awk '{print}' | sed 's/:.*//' | sort | uniq -c | sort -rn | head -30; echo '=== sample stream keys:'; redis-cli -p 6379 --scan --pattern '*stream*' | head; redis-cli -p 6379 TYPE session:01740

9  $ redis-cli -p 6379 INFO stats | grep -E 'total_connections|instantaneous_ops|total_net_input_bytes|keyspace_hits'; sleep 3; redis-cli -p 6379 INFO stats | grep -E 'total_connections|instantaneous_ops|total_net_input_bytes|keyspace_hits'; redis-cli -p 6379 INFO clients | grep -E 'connected_clients|blocked_clients'; redis-cli -p 6379 CLIENT LIST | head -20; redis-cli -p 6379 CONFIG GET maxmemory-clients 2>/dev/null | head -1; redis-cli -p 6379 MODULE LIST

10  $ redis-cli -p 6379 -n 2 --scan | head -10; echo ===; redis-cli -p 6379 -n 2 --scan | sed 's/:.*//' | sort | uniq -c | sort -rn; echo === keys with ttl sample:; redis-cli -p 6379 --scan --pattern '*' | head -3 | while read k; do redis-cli -p 6379 PTTL "$k"; done

11  $ cat > /tmp/inventory.py <<'EOF'
import sys, json, time, hashlib
import redis

host, port, out = sys.argv[1], int(sys.argv[2]), sys.argv[3]
r = redis.Redis(host=host, port=port, protocol=2)

def digest(*parts):
    h = hashlib.sha256()
    for p in parts:
        if isinstance(p, bytes):
            h.update(p)
        elif isinstance(p, str):
            h.update(p.encode())
        else:
            h.update(repr(p).encode())
        h.update(b'\x00')
    return h.hexdigest()

inv = {"time_ms": int(time.time()*1000), "dbs": {}}
types = {}
for db in range(16):
    rc = redis.Redis(host=host, port=port, db=db, protocol=2)
    keys = sorted(b.decode('utf-8', 'surrogateescape') for b in rc.scan_iter(match='*', count=500))
    if not keys:
        continue
    dbd = {}
    for k in keys:
        t = rc.type(k).decode()
        pttl = rc.pttl(k)
        now = int(time.time()*1000)
        rec = {"type": t, "pttl": pttl, "expire_at": (now + pttl if pttl > 0 else None), "now": now}
        if t == 'string':
            v = rc.get(k)
            rec["digest"] = digest(v)
            rec["len"] = len(v) if v else 0
        elif t == 'list':
            vals = rc.lrange(k, 0, -1)
            rec["digest"] = digest(*vals); rec["len"] = len(vals)
        elif t == 'set':
            vals = sorted(rc.smembers(k))
            rec["digest"] = digest(*vals); rec["len"] = len(vals)
        elif t == 'zset':
            vals = rc.zrange(k, 0, -1, withscores=True)
            flat = []
            for m, s in vals:
                flat.append(m); flat.append(repr(s).encode())
            rec["digest"] = digest(*flat); rec["len"] = len(vals)
        elif t == 'hash':
            hv = rc.hgetall(k)
            flat = []
            for f in sorted(hv):
                flat.append(f); flat.append(hv[f])
            rec["digest"] = digest(*flat); rec["len"] = len(hv)
        elif t == 'stream':
            info = rc.xinfo_stream(k)
            groups = []
            for g in rc.xinfo_groups(k):
                g = {kk: vv for kk, vv in g.items()}
                cname = g['name']
                consumers = []
                for c in rc.xinfo_consumers(k, cname):
                    c = {kk: vv for kk, vv in c.items()}
                    consumers.append({"name": c['name'].decode('utf-8','surrogateescape'), "pending": c['pending']})
                consumers.sort(key=lambda x: x['name'])
                groups.append({
                    "name": cname.decode('utf-8','surrogateescape'),
                    "consumers": g['consumers'], "pending": g['pending'],
                    "last-delivered-id": g['last-delivered-id'].decode(),
                    "entries-read": g.get('entries-read'),
                    "consumer_list": consumers,
                })
            groups.sort(key=lambda x: x['name'])
            entries = rc.xrange(k, min='-', max='+')
            eflat = []
            for eid, fields in entries:
                eflat.append(eid); 
                for f in sorted(fields): eflat.append(f); eflat.append(fields[f])
            rec["digest"] = digest(*eflat)
            rec["stream"] = {
                "length": info[b'length'] if b'length' in info else info['length'],
                "last-generated-id": (info.get(b'last-generated-id') or info.get('last-generated-id')).decode(),
                "groups": groups,
            }
            rec["len"] = rec["stream"]["length"]
        else:
            rec["digest"] = None
        types[t] = types.get(t, 0) + 1
        dbd[k] = rec
    inv["dbs"][str(db)] = dbd
inv["types"] = types
with open(out, 'w') as f:
    json.dump(inv, f, ensure_ascii=False, sort_keys=True, indent=1)
print(f"keys={sum(len(v) for v in inv['dbs'].values())} types={inv['types']} dbs={list(inv['dbs'])}")
EOF
python3 /tmp/inventory.py 127.0.0.1 6379 /tmp/src-before.json

12  $ valkey-cli -p 6380 REPLICAOF 127.0.0.1 6379; sleep 1; for i in $(seq 1 30); do link=$(valkey-cli -p 6380 INFO replication | grep -E 'master_link_status|master_last_io_seconds_ago|slave_repl_offset' | tr '\r' ' ' | paste -sd' '); src=$(redis-cli -p 6379 INFO replication | grep -E 'master_repl_offset' | tr '\r' ' '); echo "$i: $link | src $src"; link_ok=$(echo "$link" | grep -c 'master_link_status:up'); off=$(echo "$link" | sed 's/.*slave_repl_offset:\([0-9]*\).*/\1/'); soff=$(echo "$src" | sed 's/.*master_repl_offset:\([0-9]*\).*/\1/'); if [ "$link_ok" = 1 ] && [ -n "$off" ] && [ "$off" = "$soff" ]; then echo IN_SYNC; break; fi; sleep 1; done; echo ===; valkey-cli -p 6380 INFO keyspace | tr '\r' ' '

13  $ set -e
# 1. Briefly pause writes on the source (15s safety timeout auto-releases it)
redis-cli -p 6379 CLIENT PAUSE 15000 WRITE
# 2. Confirm target link up and offsets identical
for i in $(seq 1 20); do
  t=$(valkey-cli -p 6380 INFO replication | tr '\r' ' ')
  s=$(redis-cli -p 6379 INFO replication | tr '\r' ' ')
  tlink=$(echo "$t" | sed -n 's/.*master_link_status:\([a-z]*\).*/\1/p')
  toff=$(echo "$t" | sed -n 's/.*slave_repl_offset:\([0-9]*\).*/\1/p')
  soff=$(echo "$s" | sed -n 's/.*master_repl_offset:\([0-9]*\).*/\1/p')
  echo "check$i: link=$tlink target_off=$toff source_off=$soff"
  [ "$tlink" = "up" ] && [ "$toff" = "$soff" ] && [ -n "$toff" ] && break
  sleep 0.5
done
# 3. Promote target to standalone primary
valkey-cli -p 6380 REPLICAOF NO ONE
# 4. Resume writes on the source
redis-cli -p 6379 CLIENT UNPAUSE
echo === after cutover
valkey-cli -p 6380 INFO replication | tr '\r' ' ' | grep -E 'role|master_repl_offset|replica_read_only|connected_slaves|slave_repl'
redis-cli -p 6379 INFO replication | tr '\r' ' ' | grep -E 'role|connected_slaves|master_repl_offset'
valkey-cli -p 6380 INFO keyspace | tr '\r' ' '

14  $ cat > /tmp/compare.py <<'EOF'
import json, sys
a = json.load(open(sys.argv[1]))   # source
b = json.load(open(sys.argv[2]))   # target
errs, warns = [], []
tol = int(sys.argv[3]) if len(sys.argv) > 3 else 5000

def dbkeys(inv): return {db: set(d.keys()) for db, d in inv["dbs"].items()}
ak, bk = dbkeys(a), dbkeys(b)
for db in sorted(set(ak) | set(bk), key=int):
    A, B = ak.get(db, set()), bk.get(db, set())
    for k in sorted(A - B): errs.append(f"db{db} MISSING on target: {k}")
    for k in sorted(B - A): errs.append(f"db{db} EXTRA on target: {k}")
    for k in sorted(A & B):
        ra, rb = a["dbs"][db][k], b["dbs"][db][k]
        if ra["type"] != rb["type"]:
            errs.append(f"db{db} {k}: type {ra['type']} != {rb['type']}"); continue
        if ra.get("digest") != rb.get("digest"):
            errs.append(f"db{db} {k} ({ra['type']}): value digest mismatch")
        if ra.get("len") != rb.get("len"):
            errs.append(f"db{db} {k}: len {ra.get('len')} != {rb.get('len')}")
        # TTL
        ea, eb = ra.get("expire_at"), rb.get("expire_at")
        if (ea is None) != (eb is None):
            errs.append(f"db{db} {k}: TTL presence mismatch src={ra['pttl']} tgt={rb['pttl']}")
        elif ea is not None:
            d = abs(ea - eb)
            if d > tol:
                errs.append(f"db{db} {k}: expire_at differs by {d}ms (src pttl {ra['pttl']}, tgt {rb['pttl']})")
            elif d > 0:
                warns.append(f"db{db} {k}: expire_at delta {d}ms")
        # stream structure incl. consumer groups
        if ra["type"] == "stream" and ra.get("stream") != rb.get("stream"):
            errs.append(f"db{db} {k}: stream/groups mismatch\n  src={json.dumps(ra['stream'], sort_keys=True)}\n  tgt={json.dumps(rb['stream'], sort_keys=True)}")
if a.get("types") != b.get("types"):
    errs.append(f"type histogram mismatch: src={a.get('types')} tgt={b.get('types')}")
print(f"source keys={sum(len(v) for v in a['dbs'].values())} target keys={sum(len(v) for v in b['dbs'].values())}")
print(f"source types={a.get('types')}")
print(f"target types={b.get('types')}")
print(f"max expire_at delta in tolerated set: {max((abs(x['expire_at']-y['expire_at']) for db in a['dbs'] for x,y in [(a['dbs'][db][k], b['dbs'][db][k])] if db in b['dbs'] and k in b['dbs'][db] and x.get('expire_at') and y.get('expire_at')), default=0)} ms")
streams = sum(1 for db in a["dbs"] for k,v in a["dbs"][db].items() if v["type"]=="stream")
groups = sum(len(v.get("stream",{}).get("groups",[])) for db in a["dbs"] for v in a["dbs"][db].values() if v["type"]=="stream")
consumers = sum(len(g.get("consumer_list",[])) for db in a["dbs"] for v in a["dbs"][db].values() if v["type"]=="stream" for g in v.get("stream",{}).get("groups",[]))
print(f"streams={streams} groups={groups} consumers={consumers} (all structure-compared)")
if warns: print(f"({len(warns)} sub-tolerance TTL warnings, max {max(int(w.split('delta ')[1].split('ms')[0]) for w in warns)}ms)" if warns else "")
if errs:
    print(f"\n{len(errs)} ERRORS:"); [print("  " + e) for e in errs[:50]]; sys.exit(1)
print("\nOK: exact match (keys, types, values, TTLs, stream groups)")
EOF
python3 /tmp/inventory.py 127.0.0.1 6380 /tmp/tgt-after.json && python3 /tmp/inventory.py 127.0.0.1 6379 /tmp/src-after.json

15  $ echo '=== TARGET vs SOURCE BASELINE ==='; python3 /tmp/compare.py /tmp/src-before.json /tmp/tgt-after.json 5000; echo; echo '=== SOURCE AFTER vs SOURCE BEFORE (source untouched?) ==='; python3 /tmp/compare.py /tmp/src-before.json /tmp/src-after.json 5000

16  $ python3 - <<'EOF'
import re
src = open('/tmp/compare.py').read()
old = [l for l in src.splitlines() if l.startswith('print(f"max expire_at')][0]
new = '''deltas = [abs(ra["expire_at"] - rb["expire_at"]) for db in a["dbs"] if db in b["dbs"] for k, ra in a["dbs"][db].items() if (rb := b["dbs"][db].get(k)) and ra.get("expire_at") and rb.get("expire_at")]
print(f"max expire_at delta across {len(deltas)} keys with TTL: {max(deltas, default=0)} ms")'''
open('/tmp/compare.py','w').write(src.replace(old, new))
EOF
echo '=== TARGET vs SOURCE BASELINE ==='; python3 /tmp/compare.py /tmp/src-before.json /tmp/tgt-after.json 5000; echo "exit=$?"; echo; echo '=== SOURCE AFTER vs SOURCE BEFORE (source untouched?) ==='; python3 /tmp/compare.py /tmp/src-before.json /tmp/src-after.json 5000; echo "exit=$?"

17  $ echo '--- target accepts writes (scratch key, removed after) ---'
valkey-cli -p 6380 SET __migration_write_test ok; valkey-cli -p 6380 GET __migration_write_test; valkey-cli -p 6380 DEL __migration_write_test
valkey-cli -p 6380 INCR __migration_incr_test; valkey-cli -p 6380 DEL __migration_incr_test
echo '--- final key counts on target ---'
valkey-cli -p 6380 DBSIZE; valkey-cli -p 6380 -n 2 DBSIZE
echo '--- target replication/config state ---'
valkey-cli -p 6380 INFO replication | tr '\r' ' ' | grep -E 'role|connected_slaves|slave_repl|replica_read_only|master_repl_offset'
echo "runtime replicaof: [$(valkey-cli -p 6380 CONFIG GET replicaof | tail -1)]"
echo "on-disk replicaof: [$(grep -E '^(replicaof|slaveof)' /etc/valkey/valkey.conf || echo none)]"
grep -nE '^(bind|port|dir)' /etc/valkey/valkey.conf
echo '--- source state ---'
redis-cli -p 6379 INFO replication | tr '\r' ' ' | grep -E 'role|connected_slaves'
redis-cli -p 6379 DBSIZE; redis-cli -p 6379 -n 2 DBSIZE
echo "on-disk source config unchanged:"; grep -E '^(bind|port|dir|save)' /etc/redis-old/redis.conf
echo '--- logs: recent errors? ---'
tail -5 /var/log/valkey/valkey.log 2>/dev/null; echo ...; tail -3 /var/log/redis-old/redis.log 2>/dev/null
ps aux | grep -E 'redis-server|valkey-server' | grep -v grep

{
 "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": "7.2.4",
  "server_name": "valkey",
  "valkey_version": "9.1.2"
 },
 "old_digest_ok": true,
 "old_server": {
  "redis_version": "7.2.16",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}