Move production data off Redis 8.10 (wave 2) · Valkey 9.1

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

2  $ R=/opt/redis-8.10/bin/redis-cli; $R -p 6379 info keyspace; $R -p 6379 info server | head -20; valkey-cli -p 6380 info server | head -12; valkey-cli -p 6380 info keyspace; valkey-cli -p 6380 info replication

3  $ R="/opt/redis-8.10/bin/redis-cli -p 6379"; for db in 0 2; do echo db$db; $R -n $db --scan | while read k; do $R -n $db type "$k"; done | sort | uniq -c; done; $R info modules; $R config get databases; valkey-cli -p 6380 config get databases

4  $ python3 -c "import redis; print(redis.__version__)"; python3 --version; pip list 2>/dev/null | grep -i -E "redis|valkey"

5  $ cat > /tmp/survey.py <<'EOF'
import redis
r=redis.Redis(port=6379)
for db in (0,2):
    r.execute_command('SELECT',db)
    c=redis.Redis(port=6379,db=db)
    odd=[k for k in c.scan_iter(count=1000) if not k.isascii() or b' ' in k or b'\n' in k]
    print(db,'odd keys',odd[:10],len(odd))
    for k in c.scan_iter(count=1000,_type='stream'):
        print(k, c.execute_command('XINFO','STREAM',k,'FULL'))
        break
    n=0
    for k in c.scan_iter(count=1000,_type='hash'):
        t=c.execute_command('HTTL',k,'FIELDS',c.hlen(k),*c.hkeys(k))
        if any(x!=-1 for x in t):
            n+=1
            if n<2: print(k,t, c.hgetall(k))
    print('hashes with field ttl',n)
    print('total',c.dbsize())
EOF
python3 /tmp/survey.py 2>&1 | cut -c1-3000

6  $ cat > /tmp/s2.py <<'EOF'
import redis
c=redis.Redis(port=6379)
for k in sorted(c.scan_iter(_type='stream')):
    i=c.execute_command('XINFO','STREAM',k,'FULL','COUNT',1)
    g=i[b'groups']
    print(k,i[b'length'],i[b'last-generated-id'],i[b'max-deleted-entry-id'],i[b'entries-added'],i[b'recorded-first-entry-id'],c.pttl(k),len(g))
    if g: print('  ',g)
print([ (k,c.object('encoding',k)) for k in list(c.scan_iter(_type='string'))[:5]])
EOF
python3 /tmp/s2.py | cut -c1-1500

7  $ valkey-cli -p 6380 config get '*' | paste - - | grep -E "replica|slave|min-repl|read-only|save|appendonly|maxmemory |cluster-enabled|dbfilename|rdb-version" ; valkey-cli -p 6380 acl list; ls -la /var/lib/valkey

8  $ cat > /tmp/migrate.py <<'EOF'
import redis
DBS=[int(l.split(':')[0][2:]) for l in redis.Redis(port=6379).execute_command('INFO','keyspace').keys()] if False else None
src0=redis.Redis(port=6379)
DBS=[int(k[2:]) for k in src0.info('keyspace').keys()]
stats={}
for db in DBS:
    s=redis.Redis(port=6379,db=db); d=redis.Redis(port=6380,db=db)
    for k in s.scan_iter(count=1000):
        t=s.type(k).decode()
        pexp=s.execute_command('PEXPIRETIME',k)
        if t=='none': continue
        d.delete(k)
        if t=='string':
            v=s.get(k)
            if v is None: continue
            d.set(k,v)
        elif t=='list':
            v=s.lrange(k,0,-1); d.rpush(k,*v)
        elif t=='set':
            v=list(s.smembers(k)); d.sadd(k,*v)
        elif t=='zset':
            v=s.zrange(k,0,-1,withscores=True); d.zadd(k,{m:sc for m,sc in v})
        elif t=='hash':
            h=s.hgetall(k); d.hset(k,mapping=h)
            f=list(h.keys())
            et=s.execute_command('HPEXPIRETIME',k,'FIELDS',len(f),*f)
            for fld,e in zip(f,et):
                if e>0: d.execute_command('HPEXPIREAT',k,e,'FIELDS',1,fld)
        elif t=='stream':
            info=s.execute_command('XINFO','STREAM',k,'FULL','COUNT',0)
            p=d.pipeline(transaction=False)
            for eid,fields in s.xrange(k,'-','+'):
                p.execute_command('XADD',k,eid,*fields)
            p.execute()
            if info[b'length']==0:
                d.execute_command('XADD',k,'0-1','x','y'); d.execute_command('XDEL',k,'0-1')
            d.execute_command('XSETID',k,info[b'last-generated-id'],'ENTRIESADDED',info[b'entries-added'],'MAXDELETEDID',info[b'max-deleted-entry-id'])
            for g in info[b'groups']:
                args=['XGROUP','CREATE',k,g[b'name'],g[b'last-delivered-id']]
                if g[b'entries-read'] is not None: args+=['ENTRIESREAD',g[b'entries-read']]
                d.execute_command(*args)
                for c in g[b'consumers']:
                    d.execute_command('XGROUP','CREATECONSUMER',k,g[b'name'],c[b'name'])
                owner={}
                for c in g[b'consumers']:
                    for eid,dt,cnt in c[b'pending']:
                        owner[eid]=(c[b'name'],dt,cnt)
                for eid,cons,dt,cnt in g[b'pending']:
                    r=d.execute_command('XCLAIM',k,g[b'name'],cons,0,eid,'TIME',dt,'RETRYCOUNT',cnt,'FORCE','JUSTID')
                    if not r: print('WARN PEL entry not restorable',db,k,g[b'name'],eid)
        else:
            print('UNSUPPORTED',db,k,t); continue
        if pexp>0: d.execute_command('PEXPIREAT',k,pexp)
        elif pexp==-2: d.delete(k)
        stats[(db,t)]=stats.get((db,t),0)+1
print(stats)
EOF
python3 /tmp/migrate.py

9  $ cd /tmp && sed -i "s/for eid,fields in s.xrange(k,'-','+'):/for eid,fields in s.execute_command('XRANGE',k,'-','+'):/" migrate.py && python3 -c "
import redis;s=redis.Redis(port=6379);print(s.execute_command('XRANGE','events:00','-','+','COUNT',1))"

10  $ cd /tmp && sed -i "s/for eid,fields in s.execute_command('XRANGE',k,'-','+'):/for eid,fields in raw[db].execute_command('XRANGE',k,'-','+'):/" migrate.py && sed -i "s/^stats={}/stats={}\nraw={}\nfor db_ in DBS:\n    raw[db_]=redis.Redis(port=6379,db=db_); raw[db_].response_callbacks.pop('XRANGE',None)/" migrate.py && python3 -c "
import redis;s=redis.Redis(port=6379);s.response_callbacks.pop('XRANGE');print(s.execute_command('XRANGE','events:00','-','+','COUNT',1))" && valkey-cli -p 6380 flushall && python3 migrate.py

11  $ cd /tmp && sed -i "s/d=redis.Redis(port=6380,db=db)$/d=redis.Redis(port=6380,db=db); d.response_callbacks.pop('XCLAIM',None)/" migrate.py && grep -n "6380" migrate.py && valkey-cli -p 6380 flushall && python3 migrate.py

12  $ cat > /tmp/verify.py <<'EOF'
import redis
bad=0
for db in (0,2):
    s=redis.Redis(port=6379,db=db); d=redis.Redis(port=6380,db=db)
    for c in (s,d):
        for cb in ('XRANGE','ZRANGE','XINFO STREAM'): c.response_callbacks.pop(cb,None)
    sk=set(s.scan_iter(count=1000)); dk=set(d.scan_iter(count=1000))
    if sk!=dk: print('keyset diff',db,sk^dk); bad+=1
    for k in sk:
        t=s.type(k)
        if d.type(k)!=t: print('type',k); bad+=1; continue
        t=t.decode()
        e1=s.execute_command('PEXPIRETIME',k); e2=d.execute_command('PEXPIRETIME',k)
        if e1!=e2: print('ttl',k,e1,e2); bad+=1
        if t=='string': a,b=s.get(k),d.get(k)
        elif t=='list': a,b=s.lrange(k,0,-1),d.lrange(k,0,-1)
        elif t=='set': a,b=s.smembers(k),d.smembers(k)
        elif t=='zset': a,b=s.execute_command('ZRANGE',k,0,-1,'WITHSCORES'),d.execute_command('ZRANGE',k,0,-1,'WITHSCORES')
        elif t=='hash':
            a,b=s.hgetall(k),d.hgetall(k)
            f=list(a)
            if a==b and s.execute_command('HPEXPIRETIME',k,'FIELDS',len(f),*f)!=d.execute_command('HPEXPIRETIME',k,'FIELDS',len(f),*f): print('field ttl',k); bad+=1
        elif t=='stream':
            a=s.execute_command('XRANGE',k,'-','+'); b=d.execute_command('XRANGE',k,'-','+')
            def norm(x):
                x=dict(zip(x[::2],x[1::2]))
                keep=[b'length',b'last-generated-id',b'max-deleted-entry-id',b'entries-added',b'recorded-first-entry-id']
                gs=[]
                for g in x[b'groups']:
                    g=dict(zip(g[::2],g[1::2]))
                    cons=sorted([(c[1],c[7],c[9]) for c in g[b'consumers']])
                    gs.append((g[b'name'],g[b'last-delivered-id'],g[b'entries-read'],g[b'lag'],g[b'pel-count'],str(g[b'pending']),str(cons)))
                return [x[i] for i in keep],sorted(gs)
            i1=norm(s.execute_command('XINFO','STREAM',k,'FULL','COUNT',0)); i2=norm(d.execute_command('XINFO','STREAM',k,'FULL','COUNT',0))
            if i1!=i2: print('stream meta',k,i1,i2); bad+=1
        if a!=b: print('value',k); bad+=1
print('mismatches',bad)
EOF
python3 /tmp/verify.py 2>&1 | cut -c1-2000; /opt/redis-8.10/bin/redis-cli -p 6379 info keyspace; valkey-cli -p 6380 info keyspace

13  $ cd /tmp && python3 - <<'EOF'
src=open('verify.py').read()
src=src.replace("""                x=dict(zip(x[::2],x[1::2]))
""","").replace("""                    g=dict(zip(g[::2],g[1::2]))
                    cons=sorted([(c[1],c[7],c[9]) for c in g[b'consumers']])""","""                    cons=sorted([(c[b'name'],c[b'pel-count'],str(c[b'pending'])) for c in g[b'consumers']])""")
open('verify.py','w').write(src)
EOF
python3 verify.py 2>&1 | cut -c1-3000

14  $ V="valkey-cli -p 6380"; $V save; ls -la /var/lib/valkey; $V info replication | head -3; $V -n 15 set __migration_write_test 1 && $V -n 15 del __migration_write_test; $V info keyspace; /opt/redis-8.10/bin/redis-cli -p 6379 info keyspace

{
 "examples": {},
 "keys_new": {
  "0": 2960,
  "2": 350
 },
 "keys_old": {
  "0": 2960,
  "2": 350
 },
 "mismatch_counts": {
  "extra": 0,
  "field_ttl_added": 0,
  "field_ttl_drift": 0,
  "field_ttl_lost": 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": "8.10.2",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

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

2  $ cd /tmp; for db in 0 2; do echo db$db; /opt/redis-8.10/bin/redis-cli -p 6379 -n $db --scan | while read k; do /opt/redis-8.10/bin/redis-cli -p 6379 -n $db type "$k"; done | sort | uniq -c; done; /opt/redis-8.10/bin/redis-cli -p 6379 module list; /opt/redis-8.10/bin/redis-cli -p 6379 config get databases; valkey-cli -p 6380 config get databases; python3 -c "import redis; print(redis.__version__)"

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

4  $ cd /tmp; python3 - <<'EOF'
import redis
r=redis.Redis(port=6379,db=0)
import collections
odd=[k for k in r.scan_iter(count=1000) if not k.isascii() or b' ' in k or b'\n' in k]
print('odd',len(odd),odd[:5])
for k in r.scan_iter(_type='stream'):
    print(k, r.xlen(k), r.xinfo_stream(k,full=True) if False else r.execute_command('XINFO','STREAM',k)); break
for k in r.scan_iter(_type='stream'):
    g=r.execute_command('XINFO','GROUPS',k)
    if g: print(k,g); break
hf=0
for k in r.scan_iter(_type='hash'):
    t=r.execute_command('HPTTL',k,'FIELDS',r.hlen(k),*r.hkeys(k))
    if any(x>0 for x in t): hf+=1; ex=(k,t)
print('hfe keys',hf, ex)
encs=collections.Counter(r.object('encoding',k) for k in r.scan_iter(_type='string'))
print(encs)
EOF
valkey-cli -p 6380 config get maxmemory*; valkey-cli -p 6380 config get save; valkey-cli -p 6380 config get appendonly

5  $ for c in hpexpireat hpexpiretime hsetex xsetid xclaim; do valkey-cli -p 6380 command docs $c | head -3; done; /opt/redis-8.10/bin/redis-cli -p 6379 xinfo stream events:00 full | head -80

6  $ cd /tmp; python3 - <<'EOF'
import redis,pprint
r=redis.Redis(port=6379,db=0)
i=r.xinfo_stream('events:00',full=True)
i.pop('entries')
pprint.pprint(i)
EOF

7  $ cd /tmp; python3 - <<'EOF'
import redis
r=redis.Redis(port=6379,db=0)
i=r.execute_command('XINFO','STREAM','events:00','FULL','COUNT',0)
print(type(i), i.keys() if isinstance(i,dict) else i[:4])
print([ (g['name'],len(g['pending']),[len(c[b'pending']) for c in g['consumers']]) for g in i['groups']])
EOF

8  $ mkdir -p /root/migrate; cat > /root/migrate/copy.py <<'EOF'
import redis, sys
SRC=dict(host='127.0.0.1',port=6379); DST=dict(host='127.0.0.1',port=6380)

def kv(lst):
    return {lst[i]:lst[i+1] for i in range(0,len(lst),2)} if isinstance(lst,list) else lst

def sid(b):
    a,c=b.split(b'-'); return (int(a),int(c))

def copy_stream(s,d,k):
    info=s.execute_command('XINFO','STREAM',k,'FULL','COUNT',0)
    info={ (x.decode() if isinstance(x,bytes) else x):v for x,v in info.items()}
    entries=info['entries']
    groups=[kv(g) for g in info['groups']]
    for g in groups: g[b'consumers']=[kv(c) for c in g[b'consumers']]
    existing={e[0] for e in entries}
    fakes=set()
    for g in groups:
        for p in g[b'pending']:
            if p[0] not in existing: fakes.add(p[0])
    allents=sorted([(sid(e[0]),e[0],e[1]) for e in entries]+[(sid(f),f,[b'_',b'_']) for f in fakes])
    d.execute_command('XGROUP','CREATE',k,'__tmp__','0','MKSTREAM')
    d.execute_command('XGROUP','DESTROY',k,'__tmp__')
    p=d.pipeline(transaction=False)
    for _,i,fields in allents: p.execute_command('XADD',k,i,*fields)
    p.execute()
    lastid=info['last-generated-id']; added=info['entries-added']+len(fakes); maxdel=info['max-deleted-entry-id']
    d.execute_command('XSETID',k,lastid,'ENTRIESADDED',max(added,len(allents)),'MAXDELETEDID',maxdel)
    for g in groups:
        args=['XGROUP','CREATE',k,g[b'name'],g[b'last-delivered-id']]
        if g[b'entries-read'] is not None: args+=['ENTRIESREAD',g[b'entries-read']]
        d.execute_command(*args)
        for c in g[b'consumers']:
            d.execute_command('XGROUP','CREATECONSUMER',k,g[b'name'],c[b'name'])
        for pid,cons,dtime,dcount in g[b'pending']:
            d.execute_command('XCLAIM',k,g[b'name'],cons,0,pid,'TIME',dtime,'RETRYCOUNT',dcount,'FORCE','JUSTID')
    if fakes:
        d.execute_command('XDEL',k,*fakes)
    d.execute_command('XSETID',k,lastid,'ENTRIESADDED',info['entries-added'],'MAXDELETEDID',maxdel)

def copy_key(s,d,k):
    t=s.type(k)
    if t==b'none': return
    if d.exists(k): d.delete(k)
    if t==b'string':
        d.set(k,s.get(k))
    elif t==b'list':
        v=s.lrange(k,0,-1)
        for i in range(0,len(v),1000): d.rpush(k,*v[i:i+1000])
    elif t==b'set':
        v=list(s.smembers(k))
        for i in range(0,len(v),1000): d.sadd(k,*v[i:i+1000])
    elif t==b'zset':
        raw=s.execute_command('ZRANGE',k,0,-1,'WITHSCORES',NEVER_DECODE=True)
        # raw is flat list member,score(as bytes)
        args=[]
        for i in range(0,len(raw),2): args+= [raw[i+1],raw[i]]
        for i in range(0,len(args),2000): d.execute_command('ZADD',k,*args[i:i+2000])
    elif t==b'hash':
        h=s.hgetall(k)
        flat=[x for kvp in h.items() for x in kvp]
        for i in range(0,len(flat),2000): d.execute_command('HSET',k,*flat[i:i+2000])
        fields=list(h.keys())
        if fields:
            ets=s.execute_command('HPEXPIRETIME',k,'FIELDS',len(fields),*fields)
            for f,e in zip(fields,ets):
                if e>0: d.execute_command('HPEXPIREAT',k,e,'FIELDS',1,f)
    elif t==b'stream':
        copy_stream(s,d,k)
    else:
        raise Exception('unsupported type %r for %r'%(t,k))
    et=s.execute_command('PEXPIRETIME',k)
    if et>0: d.execute_command('PEXPIREAT',k,et)

def main():
    s0=redis.Redis(**SRC)
    dbs=[int(x[2:]) for x in s0.info('keyspace').keys()]
    for db in dbs:
        s=redis.Redis(db=db,**SRC); d=redis.Redis(db=db,**DST)
        n=0
        for k in s.scan_iter(count=1000):
            copy_key(s,d,k); n+=1
        print('db',db,'copied',n)
main()
EOF
cd /root/migrate && python3 copy.py

9  $ cd /root/migrate && mv copy.py migrate_data.py && python3 migrate_data.py && valkey-cli -p 6380 info keyspace

10  $ cd /root/migrate && python3 migrate_data.py 2>&1 | tail -5; python3 -c "
import redis;r=redis.Redis(port=6379)
k=next(r.scan_iter(_type='zset'));print(k,r.execute_command('ZRANGE',k,0,3,'WITHSCORES',NEVER_DECODE=True))"

11  $ cd /root/migrate && python3 - <<'EOF'
import re
p='migrate_data.py'; t=open(p).read()
t=t.replace("        s=redis.Redis(db=db,**SRC); d=redis.Redis(db=db,**DST)\n","        s=redis.Redis(db=db,**SRC); d=redis.Redis(db=db,**DST)\n        s.response_callbacks.pop('ZRANGE',None)\n")
t=t.replace(",NEVER_DECODE=True","")
open(p,'w').write(t)
EOF
for db in 0 2; do valkey-cli -p 6380 -n $db flushdb; done; python3 migrate_data.py 2>&1 | tail -5; valkey-cli -p 6380 info keyspace

12  $ cd /root/migrate && python3 - <<'EOF'
p='migrate_data.py'; t=open(p).read()
t=t.replace("def sid(b):","""def raw(c,*args):
    conn=c.connection_pool.get_connection()
    try:
        conn.send_command(*args); return conn.read_response()
    finally:
        c.connection_pool.release(conn)

def sid(b):""")
t=t.replace("raw=s.execute_command('ZRANGE',k,0,-1,'WITHSCORES')","raw_=raw(s,'ZRANGE',k,0,-1,'WITHSCORES')").replace("for i in range(0,len(raw),2): args+= [raw[i+1],raw[i]]","for i in range(0,len(raw_),2): args+= [raw_[i+1],raw_[i]]")
open(p,'w').write(t)
EOF
grep -n "raw" migrate_data.py; for db in 0 2; do valkey-cli -p 6380 -n $db flushdb; done; python3 migrate_data.py 2>&1 | tail -5; valkey-cli -p 6380 info keyspace

13  $ cd /root/migrate && python3 migrate_data.py 2>&1 | grep -n "line" | head; python3 -c "
import redis;r=redis.Redis(port=6379)
print(r.get_connection_kwargs().get('protocol'), r.connection_pool.connection_kwargs)"

14  $ cd /root/migrate && sed -i "s/SRC=dict(host='127.0.0.1',port=6379); DST=dict(host='127.0.0.1',port=6380)/SRC=dict(host='127.0.0.1',port=6379,protocol=2); DST=dict(host='127.0.0.1',port=6380,protocol=2)/" migrate_data.py && python3 -c "
import redis;r=redis.Redis(port=6379,protocol=2)
from migrate_data import raw" 2>/dev/null; python3 - <<'EOF'
import redis;r=redis.Redis(port=6379,protocol=2)
k=next(r.scan_iter(_type='zset'))
c=r.connection_pool.get_connection(); c.send_command('ZRANGE',k,0,3,'WITHSCORES'); print(c.read_response())
EOF

15  $ cd /root/migrate && for db in 0 2; do valkey-cli -p 6380 -n $db flushdb; done; python3 migrate_data.py 2>&1 | tail -5; valkey-cli -p 6380 info keyspace; /opt/redis-8.10/bin/redis-cli -p 6379 info keyspace

16  $ cd /root/migrate && python3 - <<'EOF'
p='migrate_data.py'; t=open(p).read()
t=t.replace("info=s.execute_command('XINFO','STREAM',k,'FULL','COUNT',0)","info=kv(raw(s,'XINFO','STREAM',k,'FULL','COUNT',0))")
open(p,'w').write(t)
EOF
for db in 0 2; do valkey-cli -p 6380 -n $db flushdb; done; python3 migrate_data.py 2>&1 | tail -5; valkey-cli -p 6380 info keyspace

17  $ cd /root/migrate && python3 migrate_data.py 2>&1 | grep migrate_data

18  $ cd /root/migrate && python3 - <<'EOF'
p='migrate_data.py'; t=open(p).read()
a=t.index('def copy_stream'); b=t.index('def copy_key')
t=t[:a]+t[a:b].replace("d.execute_command(","raw(d,").replace("p.execute_command(","p.execute_command(")+t[b:]
open(p,'w').write(t)
EOF
for db in 0 2; do valkey-cli -p 6380 -n $db flushdb; done; python3 migrate_data.py 2>&1 | tail -5; valkey-cli -p 6380 info keyspace

19  $ cd /root/migrate && cat > verify.py <<'EOF'
import redis
from migrate_data import raw, kv
EOF
sed -i 's/^main()$/if __name__=="__main__": main()/' migrate_data.py
cat >> verify.py <<'EOF'
bad=0
def norm_stream(c,k):
    i=kv(raw(c,'XINFO','STREAM',k,'FULL','COUNT',0))
    out={x:i[x] for x in [b'length',b'last-generated-id',b'max-deleted-entry-id',b'entries-added',b'recorded-first-entry-id',b'entries']}
    gs=[]
    for g in i[b'groups']:
        g=kv(g)
        cons=[]
        for cc in g[b'consumers']:
            cc=kv(cc); cons.append((cc[b'name'],cc[b'pel-count'],cc[b'pending']))
        gs.append((g[b'name'],g[b'last-delivered-id'],g[b'entries-read'],g[b'lag'],g[b'pel-count'],g[b'pending'],cons))
    out['groups']=gs
    return out
for db in range(16):
    s=redis.Redis(port=6379,db=db,protocol=2); d=redis.Redis(port=6380,db=db,protocol=2)
    sk=set(s.scan_iter(count=1000)); dk=set(d.scan_iter(count=1000))
    if sk!=dk: print('db',db,'keyset diff',len(sk-dk),len(dk-sk)); bad+=1
    for k in sk:
        t=s.type(k)
        if d.type(k)!=t: print('type',k); bad+=1; continue
        if t==b'string': a,b=s.get(k),d.get(k)
        elif t==b'list': a,b=s.lrange(k,0,-1),d.lrange(k,0,-1)
        elif t==b'set': a,b=s.smembers(k),d.smembers(k)
        elif t==b'zset': a,b=raw(s,'ZRANGE',k,0,-1,'WITHSCORES'),raw(d,'ZRANGE',k,0,-1,'WITHSCORES')
        elif t==b'hash':
            a,b=s.hgetall(k),d.hgetall(k)
            f=list(a)
            if f and raw(s,'HPEXPIRETIME',k,'FIELDS',len(f),*f)!=raw(d,'HPEXPIRETIME',k,'FIELDS',len(f),*f): print('hfe',k); bad+=1
        elif t==b'stream': a,b=norm_stream(s,k),norm_stream(d,k)
        if a!=b: print('value',k,t); bad+=1
        if raw(s,'PEXPIRETIME',k)!=raw(d,'PEXPIRETIME',k): print('ttl',k); bad+=1
print('mismatches',bad)
EOF
python3 verify.py

20  $ valkey-cli -p 6380 save; valkey-cli -p 6380 info replication | head -3; valkey-cli -p 6380 info persistence | grep -E 'rdb_last_bgsave_status|rdb_changes'; valkey-cli -p 6380 -n 15 set __migration_write_test 1 && valkey-cli -p 6380 -n 15 del __migration_write_test; ls -la /var/lib/valkey; /opt/redis-8.10/bin/redis-cli -p 6379 info replication | head -3

21  $ cd /root/migrate && python3 verify.py; valkey-cli -p 6380 info keyspace

{
 "examples": {},
 "keys_new": {
  "0": 2960,
  "2": 350
 },
 "keys_old": {
  "0": 2960,
  "2": 350
 },
 "mismatch_counts": {
  "extra": 0,
  "field_ttl_added": 0,
  "field_ttl_drift": 0,
  "field_ttl_lost": 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": "8.10.2",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

1  $ ps aux | grep -E 'redis|valkey' | grep -v grep; ls /opt/redis-8.10/bin; which valkey-cli valkey-server; redis-cli -p 6379 info server | head -20; valkey-cli -p 6380 info server | head -20; redis-cli -p 6379 info keyspace; redis-cli -p 6379 info replication

2  $ cd /tmp; for db in 0 2; do echo db$db; redis-cli -p 6379 -n $db --scan | while read k; do redis-cli -p 6379 -n $db type "$k"; done | sort | uniq -c; done; redis-cli -p 6379 module list; cat /etc/valkey/valkey.conf | grep -v '^#' | grep -v '^$'; grep -v '^#' /etc/redis-old/redis.conf | grep -v '^$'

3  $ valkey-cli -p 6380 info replication; valkey-cli -p 6380 config get maxmemory*; valkey-cli -p 6380 config get min-replicas*; valkey-cli -p 6380 config get databases; redis-cli -p 6379 config get databases; valkey-cli -p 6380 dbsize; valkey-cli -p 6380 config get appendonly; valkey-cli -p 6380 config get save; python3 -c 'import redis;print(redis.__version__)'; valkey-cli -p 6380 command info hpexpireat xsetid | head -5; redis-cli -p 6379 config get maxmemory*

4  $ cd /tmp; redis-cli -p 6379 --scan --type stream | head -3; k=$(redis-cli -p 6379 --scan --type stream | head -1); redis-cli -p 6379 xinfo stream "$k" full count 3; for k in $(redis-cli -p 6379 --scan --type stream); do redis-cli -p 6379 xinfo stream $k | tr '\n' ' '; echo; done | head -30

5  $ cd /tmp; cat > insp.py <<'EOF'
import redis
r=redis.Redis(port=6379)
ks=[k for k in r.scan_iter(_type='stream',count=1000)]
print(len(ks))
for k in ks:
    i=r.execute_command('XINFO','STREAM',k,'FULL')
    print(k, {a:b for a,b in zip(i[::2],i[1::2]) if a not in (b'entries',b'groups')}, 'groups',len(i[i.index(b'groups')+1]), 'ttl', r.pttl(k))
k=ks[0]
print(r.execute_command('XINFO','STREAM',k,'FULL','COUNT',3))
EOF
python3 insp.py

6  $ cd /tmp; sed -i 's/^r=redis.Redis(port=6379)/r=redis.Redis(port=6379); r.response_callbacks.clear()/' insp.py; python3 insp.py

7  $ cd /tmp; cat > insp.py <<'EOF'
import redis
r=redis.Redis(port=6379)
raw=redis.Redis(port=6379); raw.response_callbacks.clear()
ks=[k for k in r.scan_iter(_type='stream',count=1000)]
print(len(ks))
for k in ks:
    i=raw.execute_command('XINFO','STREAM',k,'FULL')
    d=dict(zip(i[::2],i[1::2]))
    print(k, {a:b for a,b in d.items() if a not in (b'entries',b'groups')}, 'groups',len(d[b'groups']), 'ttl', r.pttl(k))
k=ks[0]
print(raw.execute_command('XINFO','STREAM',k,'FULL','COUNT',3))
EOF
timeout 60 python3 insp.py

8  $ ps aux | grep -E 'redis|valkey' | grep -v grep; tail -20 /var/log/redis-old/redis.log; ls -la /var/lib/redis-old; dmesg 2>/dev/null | tail -5; free -m

9  $ mkdir -p /root/backup && cp -a /var/lib/redis-old/dump.rdb /root/backup/redis-old-dump-$(date +%s).rdb && ls -la /root/backup; ss -ltnp | grep -E '6379|6380'; ps -o pid,ppid,stat,cmd -p 9

10  $ /opt/redis-8.10/bin/redis-server /etc/redis-old/redis.conf; sleep 2; redis-cli -p 6379 ping; redis-cli -p 6379 info keyspace; tail -5 /var/log/redis-old/redis.log

11  $ cd /tmp; cat > insp.py <<'EOF'
import redis
r=redis.Redis(port=6379)
raw=redis.Redis(port=6379); raw.response_callbacks.clear()
ks=list(r.scan_iter(_type='stream',count=1000))
print(len(ks))
for k in ks:
    i=raw.execute_command('XINFO','STREAM',k,'FULL','COUNT',0)
    d=dict(zip(i[::2],i[1::2]))
    print(k, {a:b for a,b in d.items() if a not in (b'entries',b'groups')}, 'ttl', r.pttl(k))
    for g in d[b'groups']:
        g=dict(zip(g[::2],g[1::2])); print('   G',{a:(b if a not in (b'pending',b'consumers') else len(b)) for a,b in g.items()})
print(raw.execute_command('XINFO','STREAM',ks[0],'FULL','COUNT',2))
EOF
(ulimit -v 1000000; timeout 60 python3 insp.py) 2>&1 | head -80

12  $ cd /tmp; (ulimit -v 1000000; timeout 30 python3 -c '
import redis
r=redis.Redis(port=6379)
k=next(r.scan_iter(_type="stream"))
print(r.execute_command("XINFO","STREAM",k,"FULL","COUNT",2))
')

13  $ cd /tmp; cat > insp.py <<'EOF'
import redis
r=redis.Redis(port=6379)
ks=list(r.scan_iter(_type='stream',count=1000))
for k in ks:
    d=r.execute_command('XINFO','STREAM',k,'FULL','COUNT',0)
    print(k, {a:b for a,b in d.items() if a not in (b'entries',b'groups')}, 'ttl', r.pttl(k))
    for g in d[b'groups']:
        print('   G',{a:(b if a not in (b'pending',b'consumers') else b[:3]) for a,b in g.items()})
EOF
(ulimit -v 1000000; timeout 60 python3 insp.py) 2>&1 | head -80

14  $ redis-cli -p 6379 client list; redis-cli -p 6379 info stats | grep -E 'total_commands|instantaneous_ops'; valkey-cli -p 6380 -n 15 <<'EOF'
HSET th a 1 b 2
HPEXPIREAT th 1893456000000 FIELDS 1 a
HPEXPIRETIME th FIELDS 2 a b
XADD ts 1-0 f v
XADD ts 2-0 f v
XSETID ts 2-0 ENTRIESADDED 5 MAXDELETEDID 1-5
XGROUP CREATE ts g1 2-0
XGROUP CREATE ts g2 1-0 ENTRIESREAD 1
XGROUP CREATECONSUMER ts g2 c1
XCLAIM ts g2 c1 0 1-0 TIME 1791010122646 RETRYCOUNT 3 FORCE JUSTID
XINFO STREAM ts FULL
FLUSHDB
EOF

15  $ cd /tmp; cat > migrate.py <<'EOF'
import redis, sys
SRC=dict(host='127.0.0.1',port=6379); DST=dict(host='127.0.0.1',port=6380)
def raw(c): return c
stats={}
for db in range(16):
    s=redis.Redis(db=db,**SRC); d=redis.Redis(db=db,**DST)
    if s.dbsize()==0: continue
    n=0
    for k in s.scan_iter(count=1000):
        t=s.type(k).decode()
        p=d.pipeline(transaction=True)
        if t=='string':
            v=s.get(k)
            if v is None: continue
            p.set(k,v)
        elif t=='list':
            v=s.lrange(k,0,-1); p.rpush(k,*v)
        elif t=='set':
            v=list(s.smembers(k)); p.sadd(k,*v)
        elif t=='zset':
            v=s.zrange(k,0,-1,withscores=True,score_cast_func=lambda x:x)
            args=[]
            for m,sc in v: args+= [sc,m]
            p.execute_command('ZADD',k,*args)
        elif t=='hash':
            v=s.hgetall(k); fl=list(v.keys())
            args=[]
            for f in fl: args+=[f,v[f]]
            p.execute_command('HSET',k,*args)
            ets=s.execute_command('HPEXPIRETIME',k,'FIELDS',len(fl),*fl)
            for f,e in zip(fl,ets):
                if e>0: p.execute_command('HPEXPIREAT',k,e,'FIELDS',1,f)
                elif e==-2: raise Exception(('field vanished',k,f))
        elif t=='stream':
            info=s.execute_command('XINFO','STREAM',k,'FULL','COUNT',0)
            for eid,fields in s.xrange(k,'-','+'):
                p.execute_command('XADD',k,eid,*[x for kv in fields.items() for x in kv]) if False else None
            # use raw XRANGE to preserve duplicate field names / order
            ents=s.execute_command('XRANGE',k,'-','+')
            for eid,fields in ents:
                if isinstance(fields,dict): raise Exception('dict fields')
                p.execute_command('XADD',k,eid,*fields)
            if not ents:
                p.execute_command('XADD',k,'0-1','x','y'); p.execute_command('XDEL',k,'0-1')
            p.execute_command('XSETID',k,info[b'last-generated-id'],'ENTRIESADDED',info[b'entries-added'],'MAXDELETEDID',info[b'max-deleted-entry-id'])
            for g in info[b'groups']:
                a=['XGROUP','CREATE',k,g[b'name'],g[b'last-delivered-id']]
                if g[b'entries-read'] is not None: a+=['ENTRIESREAD',g[b'entries-read']]
                p.execute_command(*a)
                for c in g[b'consumers']:
                    p.execute_command('XGROUP','CREATECONSUMER',k,g[b'name'],c[b'name'])
                    for eid,dtime,cnt in c[b'pending']:
                        p.execute_command('XCLAIM',k,g[b'name'],c[b'name'],0,eid,'TIME',dtime,'RETRYCOUNT',cnt,'FORCE','JUSTID')
        else:
            raise Exception(('unsupported type',t,k))
        e=s.execute_command('PEXPIRETIME',k)
        if e>0: p.execute_command('PEXPIREAT',k,e)
        elif e==-2: p.reset(); continue
        p.execute()
        n+=1
    stats[db]=n
print(stats)
EOF
grep -n "if False" migrate.py

16  $ cd /tmp; python3 - <<'EOF'
src=open('migrate.py').read()
src=src.replace("""            for eid,fields in s.xrange(k,'-','+'):
                p.execute_command('XADD',k,eid,*[x for kv in fields.items() for x in kv]) if False else None
            # use raw XRANGE to preserve duplicate field names / order
            ents=s.execute_command('XRANGE',k,'-','+')
""","""            ents=raw(s,'XRANGE',k,'-','+')
""")
src=src.replace("def raw(c): return c","""def raw(c,*a):
    conn=c.connection_pool.get_connection()
    try:
        conn.send_command(*a); return conn.read_response()
    finally: c.connection_pool.release(conn)""")
open('migrate.py','w').write(src)
EOF
(ulimit -v 1500000; timeout 300 python3 migrate.py); valkey-cli -p 6380 info keyspace; redis-cli -p 6379 info keyspace

17  $ cd /tmp; sed -i "s/'FORCE','JUSTID')/'FORCE','JUSTID',parse_justid=True)/" migrate.py; valkey-cli -p 6380 flushall; (ulimit -v 1500000; timeout 300 python3 migrate.py); valkey-cli -p 6380 info keyspace; redis-cli -p 6379 info keyspace

18  $ cd /tmp; cat > verify.py <<'EOF'
import redis
def raw(c,*a):
    conn=c.connection_pool.get_connection()
    try:
        conn.send_command(*a); return conn.read_response()
    finally: c.connection_pool.release(conn)
bad=0; checked=0
def dump(c,k):
    t=c.type(k).decode()
    if t=='string': v=c.get(k)
    elif t=='list': v=c.lrange(k,0,-1)
    elif t=='set': v=sorted(c.smembers(k))
    elif t=='zset': v=c.zrange(k,0,-1,withscores=True,score_cast_func=lambda x:float(x))
    elif t=='hash':
        h=c.hgetall(k); fl=sorted(h)
        v=(sorted(h.items()), c.execute_command('HPEXPIRETIME',k,'FIELDS',len(fl),*fl))
    elif t=='stream':
        i=c.execute_command('XINFO','STREAM',k,'FULL','COUNT',0)
        gs=[]
        for g in i[b'groups']:
            gs.append((g[b'name'],g[b'last-delivered-id'],g[b'entries-read'],g[b'lag'],g[b'pel-count'],g[b'pending'],
              [(x[b'name'],x[b'pel-count'],x[b'pending']) for x in g[b'consumers']]))
        v=(raw(c,'XRANGE',k,'-','+'),i[b'length'],i[b'last-generated-id'],i[b'max-deleted-entry-id'],i[b'entries-added'],i[b'recorded-first-entry-id'],gs)
    return t,v,c.execute_command('PEXPIRETIME',k)
for db in range(16):
    s=redis.Redis(port=6379,db=db); d=redis.Redis(port=6380,db=db)
    sk=set(s.scan_iter(count=1000)); dk=set(d.scan_iter(count=1000))
    if sk!=dk: print('db',db,'keyset diff',len(sk-dk),len(dk-sk)); bad+=1
    for k in sk:
        checked+=1
        a=dump(s,k); b=dump(d,k)
        if a!=b: bad+=1; print('DIFF',db,k,a,b) if bad<10 else None
print('checked',checked,'bad',bad)
EOF
(ulimit -v 1500000; timeout 300 python3 verify.py)

19  $ valkey-cli -p 6380 bgsave; sleep 2; valkey-cli -p 6380 info persistence | grep -E 'rdb_last_bgsave_status|rdb_changes_since'; valkey-cli -p 6380 info replication | head -3; valkey-cli -p 6380 -n 15 set __migration_write_test 1; valkey-cli -p 6380 -n 15 del __migration_write_test; grep -iE 'replicaof|slaveof' /etc/valkey/valkey.conf; redis-cli -p 6379 ping

{
 "examples": {},
 "keys_new": {
  "0": 2960,
  "2": 350
 },
 "keys_old": {
  "0": 2960,
  "2": 350
 },
 "mismatch_counts": {
  "extra": 0,
  "field_ttl_added": 0,
  "field_ttl_drift": 0,
  "field_ttl_lost": 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": "8.10.2",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

1  $ which redis-cli valkey-cli || true; ls -l /opt/redis-8.10/bin; ps aux | grep -E '[r]edis|[v]alkey'; ls -l /etc/redis-old/redis.conf /etc/valkey/valkey.conf

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

3  $ cat /etc/redis-old/redis.conf /etc/valkey/valkey.conf; valkey-cli -p 6380 COMMAND INFO REPLICAOF | head -30; /opt/redis-8.10/bin/redis-cli -p 6379 INFO modules; /opt/redis-8.10/bin/redis-cli -p 6379 INFO stats | grep -E '(total_commands_processed|expired_keys|keyspace_hits)'

4  $ python3 - <<'PY'
try: import redis;print(redis.__version__)
except Exception as e:print(e)
PY
/opt/redis-8.10/bin/redis-cli -p 6379 INFO clients | head -18; valkey-cli -p 6380 MODULE LIST; /opt/redis-8.10/bin/redis-cli -p 6379 DBSIZE; /opt/redis-8.10/bin/redis-cli -p 6379 --scan | head -30

5  $ cat > /tmp/inspect.py <<'PY'
import redis,collections
r=redis.Redis(port=6379); v=redis.Redis(port=6380)
for db in range(16):
 r=redis.Redis(port=6379,db=db); c=collections.Counter();examples={}; streams=[]; hfe=[]
 for k in r.scan_iter(count=500):
  t=r.type(k);c[t]+=1;examples.setdefault(t,k)
  if t==b'stream':streams.append((k,r.xinfo_groups(k)))
  if t==b'hash' and r.execute_command('HEXPIRETIME',k,'FIELDS',1,next(iter(r.hscan_iter(k)),(b'',b''))[0]) not in ([-1],[-2]):hfe.append(k)
 if c:print('db',db,'types',c,'examples',examples,'streams',streams[:6], 'hashes with expiry',hfe[:6], 'hfe_count',len(hfe))
print('valkey commands:',[(x, v.execute_command('COMMAND','INFO',x) is not None) for x in ['HPEXPIREAT','HPEXPIRETIME','XSETID','XGROUP','XCLAIM','VADD']])
PY
python3 /tmp/inspect.py

6  $ mv /tmp/inspect.py /tmp/probe_data.py; cd /; python3 /tmp/probe_data.py

7  $ for c in HPEXPIREAT HPEXPIRETIME XSETID XGROUP XCLAIM VADD; do echo "$c"; valkey-cli -p 6380 COMMAND INFO "$c" | head -4; done; /opt/redis-8.10/bin/redis-cli -p 6379 --raw DUMP profile:16 | head -c 40 | xxd; echo; valkey-cli -p 6380 INFO persistence | grep -E 'aof_enabled|loading'

8  $ /opt/redis-8.10/bin/redis-cli -p 6379 XINFO STREAM events:05 FULL COUNT 2 | head -130; /opt/redis-8.10/bin/redis-cli -p 6379 INFO memory | grep -E 'used_memory_human|used_memory_peak_human'; valkey-cli -p 6380 CONFIG GET maxmemory

9  $ python3 - <<'PY'
import redis
r=redis.Redis(port=6379);v=redis.Redis(port=6380)
for k in (b'events:05',b'events:08'):
 print(k,r.xinfo_stream(k),r.xinfo_groups(k));print('consumers',r.xinfo_consumers(k,b'workers') if r.xinfo_groups(k) else '')
print('source key exp',r.execute_command('PEXPIRETIME','session:01038'))
print('target hfe',v.execute_command('COMMAND','INFO','HPEXPIREAT')[0][:3])
PY

10  $ cat > /tmp/migrate.py <<'PY'
import redis,time,collections,sys
srcport=6379; dstport=6380
counts=collections.Counter(); groups=0; pending=0; hfes=0
for db in range(16):
 s=redis.Redis(host='127.0.0.1',port=srcport,db=db); d=redis.Redis(host='127.0.0.1',port=dstport,db=db)
 for k in s.scan_iter(count=500):
  typ=s.type(k)
  if typ==b'none':continue
  exp=s.execute_command('PEXPIRETIME',k)
  if typ==b'string':d.set(k,s.get(k))
  elif typ==b'list':
   vals=s.lrange(k,0,-1)
   if vals:d.rpush(k,*vals)
  elif typ==b'set':
   vals=s.smembers(k)
   if vals:d.sadd(k,*vals)
  elif typ==b'zset':
   vals=s.zrange(k,0,-1,withscores=True)
   if vals:d.zadd(k,dict(vals))
  elif typ==b'hash':
   vals=s.hgetall(k)
   if vals:
    d.hset(k,mapping=vals)
    fields=list(vals)
    for i in range(0,len(fields),100):
     f=fields[i:i+100]
     exps=s.execute_command('HPEXPIRETIME',k,'FIELDS',len(f),*f)
     for field,expiry in zip(f,exps):
      if expiry>0:
       result=d.execute_command('HPEXPIREAT',k,expiry,'FIELDS',1,field)
       if result != [1]:raise RuntimeError(('field expiry failed',db,k,field,result))
       hfes+=1
  elif typ==b'stream':
   info=s.xinfo_stream(k)
   entries=s.xrange(k, min=b'-', max=b'+')
   for id_,fields in entries:d.xadd(k,fields,id=id_)
   if not entries:raise RuntimeError(('empty stream',db,k))
   d.execute_command('XSETID',k,info['last-generated-id'],'ENTRIESADDED',info['entries-added'],'MAXDELETEDID',info['max-deleted-entry-id'])
   for group in s.xinfo_groups(k):
    g=group['name'];args=['XGROUP','CREATE',k,g,group['last-delivered-id']]
    if group['entries-read'] is not None:args+=['ENTRIESREAD',group['entries-read']]
    d.execute_command(*args);groups+=1
    for consumer in s.xinfo_consumers(k,g):
     c=consumer['name'];d.execute_command('XGROUP','CREATECONSUMER',k,g,c)
    start=b'-'
    while True:
     pend=s.xpending_range(k,g,start,b'+',100)
     if not pend:break
     for item in pend:
      id_=item['message_id']; c=item['consumer'];delivered=item['times_delivered'];lasttime=int(time.time()*1000)-item['time_since_delivered']
      # FORCE creates a pending entry; JUSTID avoids the implicit increment to its delivery counter.
      result=d.execute_command('XCLAIM',k,g,c,0,id_,'TIME',lasttime,'RETRYCOUNT',delivered,'FORCE','JUSTID')
      if id_ not in result:raise RuntimeError(('claim failed',db,k,g,id_,result))
      pending+=1
     start=b'('+pend[-1]['message_id']
  else:raise RuntimeError(('unsupported type',db,k,typ))
  if exp>0:
   if not d.pexpireat(k,exp):raise RuntimeError(('key expiry failed',db,k,exp))
  counts[(db,typ)]+=1
 print('db',db,'copied',sum(n for (idx,t),n in counts.items() if idx==db),flush=True)
print('COPIED',counts,'groups',groups,'pending',pending,'expiring fields',hfes)
PY
python3 /tmp/migrate.py

11  $ python3 /tmp/migrate.py 2>&1 | tail -18; valkey-cli -p 6380 INFO keyspace; python3 - <<'PY'
import redis
v=redis.Redis(port=6380)
print(v.xinfo_groups('events:05'))
print(v.execute_command('XCLAIM','events:05','workers','w1',0,'1767226100010-0','RETRYCOUNT',1,'FORCE','JUSTID'))
PY

12  $ python3 - <<'PY'
import inspect,redis
print(inspect.signature(redis.Redis.xclaim));print(inspect.getsource(redis.Redis.xclaim)[:2400])
PY

13  $ sed -i "s/result=d.execute_command('XCLAIM',k,g,c,0,id_,'TIME',lasttime,'RETRYCOUNT',delivered,'FORCE','JUSTID')/result=d.xclaim(k,g,c,0,[id_],time=lasttime,retrycount=delivered,force=True,justid=True)/" /tmp/migrate.py
valkey-cli -p 6380 FLUSHALL SYNC; python3 /tmp/migrate.py

14  $ cat > /tmp/verify.py <<'PY'
import redis, collections
issues=[]; counters=collections.Counter()
for db in range(16):
 s=redis.Redis(port=6379,db=db);d=redis.Redis(port=6380,db=db)
 sk=set(s.scan_iter(count=500));dk=set(d.scan_iter(count=500))
 if sk!=dk:issues.append((db,'key mismatch',len(sk-dk),len(dk-sk)))
 for k in sk&dk:
  typ=s.type(k);counters[(db,typ)]+=1
  if typ!=d.type(k):issues.append((db,k,'type'));continue
  ex=s.execute_command('PEXPIRETIME',k);dx=d.execute_command('PEXPIRETIME',k)
  if ex!=dx:issues.append((db,k,'key expiry',ex,dx))
  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)
   fields=list(a)
   for i in range(0,len(fields),100):
    f=fields[i:i+100];e=s.execute_command('HPEXPIRETIME',k,'FIELDS',len(f),*f);de=d.execute_command('HPEXPIRETIME',k,'FIELDS',len(f),*f)
    if e!=de:issues.append((db,k,'field expiration',dict(zip(f,e)),dict(zip(f,de))))
  elif typ==b'stream':
   a,b=s.xrange(k),d.xrange(k)
   sa,da=s.xinfo_stream(k),d.xinfo_stream(k)
   for field in ('length','last-generated-id','max-deleted-entry-id','entries-added'):
    if sa[field]!=da[field]:issues.append((db,k,'stream',field,sa[field],da[field]))
   sg,dg=s.xinfo_groups(k),d.xinfo_groups(k)
   if sg!=dg:issues.append((db,k,'groups',sg,dg))
   for g in sg:
    gn=g['name']; sp=s.xpending_range(k,gn,'-','+',1000);dp=d.xpending_range(k,gn,'-','+',1000)
    # idle times naturally increase between reads; compare stable identifiers and retry counts
    sp=[(p['message_id'],p['consumer'],p['times_delivered']) for p in sp];dp=[(p['message_id'],p['consumer'],p['times_delivered']) for p in dp]
    if sp!=dp:issues.append((db,k,gn,'pending',sp,dp))
    sc=s.xinfo_consumers(k,gn);dc=d.xinfo_consumers(k,gn)
    if [(x['name'],x['pending']) for x in sc]!=[(x['name'],x['pending']) for x in dc]:issues.append((db,k,gn,'consumers',sc,dc))
  if a!=b:issues.append((db,k,'value mismatch',a,b))
print('verified',counters,'issues',len(issues));print(*issues[:12],sep='\n')
if issues:raise SystemExit(1)
PY
python3 /tmp/verify.py; valkey-cli -p 6380 INFO replication | head -16; valkey-cli -p 6380 SAVE; valkey-cli -p 6380 CONFIG GET replicaof; /opt/redis-8.10/bin/redis-cli -p 6379 PING

{
 "examples": {},
 "keys_new": {
  "0": 2960,
  "2": 350
 },
 "keys_old": {
  "0": 2960,
  "2": 350
 },
 "mismatch_counts": {
  "extra": 0,
  "field_ttl_added": 0,
  "field_ttl_drift": 0,
  "field_ttl_lost": 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": "8.10.2",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

1  $ ps aux | grep -E 'redis|valkey' | grep -v grep; ls -l /etc/redis-old/redis.conf /etc/valkey/valkey.conf; /opt/redis-8.10/bin/redis-cli -p 6379 INFO server | head -30; command -v valkey-cli redis-cli

2  $ grep -En '^(bind|port|requirepass|masterauth|replicaof|appendonly|dir |dbfilename|save |databases|aclfile|loadmodule|protected-mode)' /etc/redis-old/redis.conf /etc/valkey/valkey.conf

3  $ cat /etc/redis-old/redis.conf /etc/valkey/valkey.conf; valkey-cli -p 6380 INFO server | head -28; /opt/redis-8.10/bin/redis-cli -p 6379 INFO keyspace; /opt/redis-8.10/bin/redis-cli -p 6379 INFO replication; /opt/redis-8.10/bin/redis-cli -p 6379 MODULE LIST; valkey-cli -p 6380 INFO keyspace

4  $ which redis-cli valkey-cli; ls -lah /var/lib/{redis-old,valkey}; /opt/redis-8.10/bin/redis-cli -p 6379 CONFIG GET databases appendonly; valkey-cli -p 6380 CONFIG GET databases appendonly

5  $  /opt/redis-8.10/bin/redis-cli -p 6379 INFO modules; valkey-cli -p 6380 MODULE LIST; /opt/redis-8.10/bin/redis-cli -p 6379 INFO persistence | head -50; valkey-cli -p 6380 COMMAND INFO RESTORE | head -25; ls /opt/redis-8.10/bin; ls /usr/local/bin | grep -E '(redis|valkey)'

6  $  /opt/redis-8.10/bin/redis-cli -p 6379 --scan | head -35; /opt/redis-8.10/bin/redis-cli -p 6379 INFO stats | grep -E 'expired_keys|total_commands_processed'; valkey-cli -p 6380 COMMAND INFO MIGRATE | head -10

7  $ valkey-cli -p 6380 COMMAND INFO VADD HPEXPIREAT HSETEX XGROUP | head -100; /opt/redis-8.10/bin/redis-cli -p 6379 COMMAND INFO VADD | head -60; python3 - <<'PY'
import importlib.util
print(importlib.util.find_spec('redis'))
PY

8  $  /opt/redis-8.10/bin/redis-cli -p 6379 --raw TYPE events:07; /opt/redis-8.10/bin/redis-cli -p 6379 --raw TYPE leaderboard:046; /opt/redis-8.10/bin/redis-cli -p 6379 --raw TYPE profile:30; /opt/redis-8.10/bin/redis-cli -p 6379 --raw TYPE tags:099; /opt/redis-8.10/bin/redis-cli -p 6379 --raw TYPE user:0187; valkey-cli -p 6380 INFO modules

9  $ python3 - <<'PY'
import redis,collections
r=redis.Redis(port=6379); print([ (i,r.execute_command('DBSIZE') if False else redis.Redis(port=6379,db=i).dbsize()) for i in range(16)]);
for db in (0,2):
 c=collections.Counter(); sample={}; rr=redis.Redis(port=6379,db=db)
 for k in rr.scan_iter(count=1000):
  t=rr.type(k).decode();c[t]+=1;sample.setdefault(t,k)
 print(db,c,sample)
PY
find / -iname '*vector*so' -o -iname '*vector*.so' 2>/dev/null | head; valkey-cli -p 6380 COMMAND INFO VADD | head -4; valkey-cli -p 6380 COMMAND INFO HEXPIRE | head -4

10  $ python3 - <<'PY'
import redis
r=redis.Redis(port=6379);v=redis.Redis(port=6380)
for k in [b'session:00728',b'leaderboard:046',b'profile:30',b'tags:099',b'events:07',b'queue:079']:
 try:
  print(k, r.type(k),len(r.dump(k) or b''),v.restore(b'__migration_test__',0,r.dump(k),replace=True));v.delete(b'__migration_test__')
 except Exception as e: print(type(e).__name__,str(e)[:400])
PY

11  $ python3 - <<'PY'
import redis,collections
r=redis.Redis(port=6379,decode_responses=False)
for k in [b'events:07',b'profile:30']:
 print(k,'type',r.type(k),'ttl',r.pttl(k))
 if r.type(k)==b'stream':
  print('stream info',r.xinfo_stream(k,full=True,count=3));print('groups',r.xinfo_groups(k));
  for g in r.xinfo_groups(k):
   print('consumers',r.xinfo_consumers(k,g[b'name']));print('pending',r.xpending_range(k,g[b'name'],'-','+',3))
 else:
  print('field expires',r.execute_command('HPEXPIRETIME',k,'FIELDS',1,next(iter(r.hkeys(k)))))
PY

12  $ python3 - <<'PY'
import redis,pprint
r=redis.Redis(port=6379)
k=b'events:07'
print('xinfo',r.execute_command('XINFO','STREAM',k,'FULL','COUNT',2));print('groups',r.xinfo_groups(k));
for g in r.xinfo_groups(k):
 print('consumers',r.xinfo_consumers(k,g[b'name']));print('pending',r.xpending_range(k,g[b'name'],'-','+',3));print('group full',r.execute_command('XINFO','STREAM',k,'FULL','COUNT',2))
print('hash',r.execute_command('HPEXPIRETIME','profile:30','FIELDS',1,next(iter(r.hkeys('profile:30')))))
print('help',redis.__version__)
PY

13  $ python3 - <<'PY'
import redis
r=redis.Redis(port=6379);v=redis.Redis(port=6380)
for k in (b'profile:30',b'cache:fragment:10'):
 rr=redis.Redis(port=6379,db=2 if k.startswith(b'cache:') else 0)
 print(k,rr.hgetall(k),rr.execute_command('HPEXPIRETIME',k,'FIELDS',*([len(rr.hkeys(k))]+rr.hkeys(k))))
print('stream',v.execute_command('COMMAND','INFO','XSETID'))
print('source ktypes',r.info('keyspace'))
PY

14  $ valkey-cli -p 6380 XHELP 2>&1 | head; python3 - <<'PY'
import redis
r=redis.Redis(port=6379);v=redis.Redis(port=6380)
print('source',r.execute_command('XINFO','STREAM','events:07','FULL','COUNT',1))
print('target',v.info('server')['valkey_version'])
PY

15  $ date +%s%3N; python3 - <<'PY'
import redis
r=redis.Redis(port=6379);v=redis.Redis(port=6380)
print(r.time(),v.time()); print('streams');
for k in r.scan_iter(match=b'events:*'):
 info=r.xinfo_stream(k); print(k,info['length'],r.xinfo_groups(k));break
PY

16  $ cat > /tmp/migrate.py <<'PY'
import redis, collections, sys, time
src0=redis.Redis(host='127.0.0.1',port=6379)
dst0=redis.Redis(host='127.0.0.1',port=6380)
assert dst0.info('keyspace') == {}, 'destination is not empty'
assert dst0.info('replication')['role']=='master'
counts=collections.Counter()

def stream_copy(s,d,k):
    info=s.xinfo_stream(k)
    entries=s.xrange(k, '-', '+')
    for id, fields in entries:
        args=[]
        for f,val in fields.items(): args.extend((f,val))
        d.execute_command('XADD',k,id,*args)
    # Preserve stream metadata (important for subsequent XADD and consumer lag).
    d.execute_command('XSETID',k,info['last-generated-id'],'ENTRIESADDED',info['entries-added'],'MAXDELETEDID',info['max-deleted-entry-id'])
    for group in s.xinfo_groups(k):
        g=group['name']
        d.execute_command('XGROUP','CREATE',k,g,'0-0')
        for c in s.xinfo_consumers(k,g):
            d.execute_command('XGROUP','CREATECONSUMER',k,g,c['name'])
        pending=s.xpending_range(k,g,'-','+',max(1,group['pending'])) if group['pending'] else []
        for p in pending:
            idle=max(0,int(p['time_since_delivered']))
            d.execute_command('XCLAIM',k,g,p['consumer'],0,p['message_id'],'IDLE',idle,'RETRYCOUNT',p['times_delivered'],'FORCE','JUSTID')
        opts=['ENTRIESREAD',group['entries-read']] if group.get('entries-read') is not None else []
        d.execute_command('XGROUP','SETID',k,g,group['last-delivered-id'],*opts)
        actual=d.xinfo_groups(k)[0] if len(s.xinfo_groups(k))==1 else next(x for x in d.xinfo_groups(k) if x['name']==g)
        assert actual['pending']==group['pending'], (k,g,actual,group)

for db in range(int(src0.config_get('databases')['databases'])):
    s=redis.Redis(host='127.0.0.1',port=6379,db=db)
    d=redis.Redis(host='127.0.0.1',port=6380,db=db)
    for k in s.scan_iter(count=500):
        typ=s.type(k)
        if typ == b'none': continue
        if typ==b'string': d.set(k,s.get(k))
        elif typ==b'hash':
            values=s.hgetall(k)
            if not values: continue
            d.hset(k,mapping=values)
            fields=list(values)
            expiries=s.execute_command('HPEXPIRETIME',k,'FIELDS',len(fields),*fields)
            for f,exp in zip(fields,expiries):
                if exp>0: d.execute_command('HPEXPIREAT',k,exp,'FIELDS',1,f)
        elif typ==b'list':
            values=s.lrange(k,0,-1)
            if values: d.rpush(k,*values)
        elif typ==b'set':
            values=s.smembers(k)
            if values: d.sadd(k,*values)
        elif typ==b'zset':
            values=s.zrange(k,0,-1,withscores=True)
            if values: d.zadd(k,{member:score for member,score in values})
        elif typ==b'stream': stream_copy(s,d,k)
        else: raise Exception(f'unknown type {db} {k!r} {typ}')
        exp=s.pexpiretime(k)
        if exp>0: d.pexpireat(k,exp)
        counts[(db,typ.decode())]+=1
    print('db',db,'source',s.dbsize(),'target',d.dbsize(),flush=True)
    assert s.dbsize()==d.dbsize(),db
print('copied',counts,flush=True)
PY
python3 /tmp/migrate.py

17  $ python3 /tmp/migrate.py 2>&1 | tail -12; valkey-cli -p 6380 INFO keyspace

18  $ sed -i 's/    return do()/    return do()/' /dev/null 2>/dev/null || true; python3 - <<'PY'
import redis
r=redis.Redis(port=6380)
for k in r.scan_iter(match='events:*'):
 print(k,r.xinfo_groups(k))
 try:print(r.execute_command('XCLAIM',k,'workers','w1',0,'1767226300010-0','IDLE',100,'RETRYCOUNT',1,'FORCE','JUSTID'))
 except Exception as e:print(repr(e))
PY

19  $ python3 - <<'PY'
import inspect,redis
from redis._parsers import helpers
print(inspect.getsource(helpers.parse_xclaim))
PY

20  $ sed -i "s/'FORCE','JUSTID')/'FORCE','JUSTID',parse_justid=True)/" /tmp/migrate.py; valkey-cli -p 6380 FLUSHALL; python3 /tmp/migrate.py

21  $ cat > /tmp/verify.py <<'PY'
import redis,collections,time
issues=[]; totals=collections.Counter()
for db in range(16):
 s=redis.Redis(port=6379,db=db);d=redis.Redis(port=6380,db=db)
 sk=set(s.scan_iter());dk=set(d.scan_iter())
 if sk!=dk:issues.append((db,'key mismatch',sk-dk,dk-sk))
 for k in sk&dk:
  t=s.type(k); totals[(db,t)]+=1
  if t!=d.type(k):issues.append((db,k,'type'));continue
  if t==b'string': same=s.get(k)==d.get(k)
  elif t==b'hash':
   a=s.hgetall(k);b=d.hgetall(k);same=a==b
   fields=list(a)
   if fields:
    p=dict(zip(fields,s.execute_command('HPEXPIRETIME',k,'FIELDS',len(fields),*fields)))
    q=dict(zip(fields,d.execute_command('HPEXPIRETIME',k,'FIELDS',len(fields),*fields)))
    if p!=q:issues.append((db,k,'field expirations',p,q))
  elif t==b'list':same=s.lrange(k,0,-1)==d.lrange(k,0,-1)
  elif t==b'set':same=s.smembers(k)==d.smembers(k)
  elif t==b'zset':same=s.zrange(k,0,-1,withscores=True)==d.zrange(k,0,-1,withscores=True)
  elif t==b'stream':
   same=s.xrange(k)==d.xrange(k)
   si=s.xinfo_stream(k);di=d.xinfo_stream(k)
   for field in ('length','last-generated-id','max-deleted-entry-id','entries-added','recorded-first-entry-id'):
    if si[field]!=di[field]:issues.append((db,k,'stream info',field,si[field],di[field]))
   sg=s.xinfo_groups(k);dg=d.xinfo_groups(k)
   if sg!=dg:issues.append((db,k,'groups',sg,dg))
   for g in sg:
    n=g['name'];sc=s.xinfo_consumers(k,n);dc=d.xinfo_consumers(k,n)
    for x in sc:
     y=next((z for z in dc if z['name']==x['name']),None)
     if y is None or x['pending']!=y['pending']:issues.append((db,k,'consumer',x,y))
    sp=s.xpending_range(k,n,'-','+',max(1,g['pending'])) if g['pending'] else []
    dp=d.xpending_range(k,n,'-','+',max(1,g['pending'])) if g['pending'] else []
    for x,y in zip(sp,dp):
     if (x['message_id'],x['consumer'],x['times_delivered'])!=(y['message_id'],y['consumer'],y['times_delivered']):issues.append((db,k,'pending',x,y))
  else:issues.append((db,k,'unhandled',t));continue
  if not same:issues.append((db,k,'value'))
  a=s.pexpiretime(k);b=d.pexpiretime(k)
  if a!=b:issues.append((db,k,'expiry',a,b))
print('counts',totals,'issues',len(issues))
for issue in issues[:15]: print(repr(issue)[:800])
PY
python3 /tmp/verify.py

22  $ valkey-cli -p 6380 SET __migration_write_check__ ok; valkey-cli -p 6380 DEL __migration_write_check__; valkey-cli -p 6380 SAVE; valkey-cli -p 6380 INFO replication | head -8; valkey-cli -p 6380 INFO keyspace; /opt/redis-8.10/bin/redis-cli -p 6379 INFO keyspace; ls -lh /var/lib/valkey/dump.rdb; python3 /tmp/verify.py | tail -2

{
 "examples": {},
 "keys_new": {
  "0": 2960,
  "2": 350
 },
 "keys_old": {
  "0": 2960,
  "2": 350
 },
 "mismatch_counts": {
  "extra": 0,
  "field_ttl_added": 0,
  "field_ttl_drift": 0,
  "field_ttl_lost": 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": "8.10.2",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

1  $ ps aux | grep -E '[r]edis|[v]alkey'; ls -l /opt/redis-8.10/bin /etc/redis-old/redis.conf /etc/valkey/valkey.conf; command -v valkey-cli redis-cli

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

3  $ (/opt/redis-8.10/bin/redis-cli -h 127.0.0.1 -p 6379 INFO server; /opt/redis-8.10/bin/redis-cli -h 127.0.0.1 -p 6379 INFO keyspace; /opt/redis-8.10/bin/redis-cli -h 127.0.0.1 -p 6379 INFO replication) | head -110; echo '---target---'; (valkey-cli -p 6380 INFO server; valkey-cli -p 6380 INFO keyspace; valkey-cli -p 6380 INFO replication) | head -110

4  $ redis-cli -p 6379 INFO modules; redis-cli -p 6379 INFO memory | head -45; valkey-cli -p 6380 COMMAND INFO RESTORE | head -50; ls -lah /var/lib/redis-old /var/lib/valkey

5  $ python3 - <<'PY'
try: import redis; print('redis-py',redis.__version__)
except Exception as e: print(e)
PY
redis-cli -p 6379 INFO clients | head -25; redis-cli -p 6379 INFO stats | grep -E 'total_commands|expired_keys'; redis-cli -p 6379 COMMAND INFO XGROUP | head -10; valkey-cli -p 6380 COMMAND INFO XGROUP | head -10; redis-cli -p 6379 --scan | head -25

6  $ python3 - <<'PY'
import redis,collections
s=redis.Redis(port=6379); d=redis.Redis(port=6380);print('types per db')
for db in range(16):
 s=redis.Redis(port=6379,db=db); counts=collections.Counter(); samples={}; sub=[]; streams=[]
 for key in s.scan_iter(count=500):
  typ=s.type(key);counts[typ]+=1;samples.setdefault(typ,key)
  if typ==b'stream':
   streams.append((key,s.xinfo_stream(key),s.xinfo_groups(key)))
  if typ==b'hash':
   try:
    if s.execute_command('HPTTL',key,*['FIELDS',1,next(iter(s.hkeys(key)))] )[0]>0: sub.append(key)
   except Exception: pass
 if counts:
  print(db,counts,'samples',samples,'subexpiry count',len(sub),'example',sub[:2]);print('streams',[(k,info['length'],info['last-generated-id'],[(g['name'],g['pending']) for g in gs]) for k,info,gs in streams][:30]);
  for typ,key in samples.items():
   try: print(' sample restore',typ,key,d.execute_command('RESTORE',b'__migration_probe__',0,s.dump(key),b'REPLACE'))
   except Exception as e: print(' sample restore FAIL',typ,key,str(e)[:220])
   finally:d.delete('__migration_probe__')
PY

7  $ python3 - <<'PY'
import redis,pprint
s=redis.Redis(port=6379);t=redis.Redis(port=6380)
for k in [b'events:00',b'profile:00']:
 print(k);print('source type',s.type(k));
 if s.type(k)==b'stream':
  pprint.pp(s.xinfo_stream(k,full=True,count=2));pprint.pp(s.xinfo_groups(k));
  for g in s.xinfo_groups(k):
   pprint.pp(s.xinfo_consumers(k,g['name']));pprint.pp(s.xpending_range(k,g['name'],'-','+',2))
 else:
  print('hash fields',s.hgetall(k));print('HTTL',s.execute_command('HPEXPIRETIME',k,'FIELDS',len(s.hkeys(k)),*s.hkeys(k)))
print('source dbs',s.config_get('databases'));print('target dbs',t.config_get('databases'))
PY
valkey-cli -p 6380 COMMAND INFO XSETID | head -22; valkey-cli -p 6380 COMMAND INFO HPEXPIREAT | head -22; valkey-cli -p 6380 COMMAND INFO XAUTOCLAIM | head -15

8  $ python3 - <<'PY'
import redis,pprint
s=redis.Redis(port=6379);s.set_response_callback('XINFO',lambda x:x)
for k in [b'events:00',b'profile:00']:
 print(k)
 if s.type(k)==b'stream':
  pprint.pp(s.execute_command('XINFO','STREAM',k,'FULL','COUNT',2));pprint.pp(s.xinfo_groups(k))
  for g in s.xinfo_groups(k):
   pprint.pp(s.xinfo_consumers(k,g['name']));pprint.pp(s.xpending_range(k,g['name'],'-','+',2))
 else:
  print('hash fields',s.hgetall(k));print('HPEXPIRETIME',s.execute_command('HPEXPIRETIME',k,'FIELDS',len(s.hkeys(k)),*s.hkeys(k)))
print('source dbs',s.config_get('databases'))
PY

9  $ python3 - <<'PY'
import redis,collections
s=redis.Redis(port=6379);c=collections.Counter();meta=collections.Counter()
for k in s.scan_iter():
 if s.type(k)!=b'stream':continue
 info=s.xinfo_stream(k);groups=s.xinfo_groups(k)
 for g in groups:
  c['groups']+=1;c['pending']+=g['pending'];c['consumers']+=g['consumers'];c['empty_groups']+=not g['consumers'];c['none_entries_read']+=g['entries-read'] is None
 meta['streams']+=1
 meta['entries added difference']+=info['entries-added']-info['length']
 print(k,'entries',info['length'], 'added',info['entries-added'],'max-del',info['max-deleted-entry-id'],'groups',[(g['name'],g['pending'],g['entries-read']) for g in groups]);
print(c,meta)
PY
valkey-cli -p 6380 COMMAND INFO XGROUP\|SETID | head -20

10  $ cat > /tmp/migrate_redis_valkey.py <<'PY'
import redis, time, collections
src_port, dst_port = 6379, 6380
s0=redis.Redis(host='127.0.0.1',port=src_port)
t0=redis.Redis(host='127.0.0.1',port=dst_port)
assert t0.info('replication')['role']=='master'
assert not any(t0.info('keyspace').get('db'+str(i)) for i in range(16)), 'destination not empty'
assert s0.info('clients')['connected_clients'] <= 2, 'source has other clients: need stable snapshot'
counts=collections.Counter()
for db in range(int(s0.config_get('databases')['databases'])):
    s=redis.Redis(host='127.0.0.1',port=src_port,db=db)
    t=redis.Redis(host='127.0.0.1',port=dst_port,db=db)
    keys=set(s.scan_iter(count=500))
    for key in keys:
        typ=s.type(key)
        if typ==b'none': continue
        exp=s.pexpiretime(key)
        if typ==b'string':
            t.set(key,s.get(key))
        elif typ==b'list':
            vals=s.lrange(key,0,-1);t.rpush(key,*vals)
        elif typ==b'set':
            vals=s.smembers(key);t.sadd(key,*vals)
        elif typ==b'zset':
            vals=s.zrange(key,0,-1,withscores=True);t.zadd(key,dict(vals))
        elif typ==b'hash':
            vals=s.hgetall(key)
            fields=list(vals)
            field_exps=s.execute_command('HPEXPIRETIME',key,'FIELDS',len(fields),*fields)
            t.hset(key,mapping=vals)
            for field,ts in zip(fields,field_exps):
                if ts>0:
                    result=t.execute_command('HPEXPIREAT',key,ts,'FIELDS',1,field)
                    assert result==[1],(key,field,ts,result)
        elif typ==b'stream':
            # Rebuild entries with explicit IDs so streams remain fully writable.
            for batch_start in range(0,s.xlen(key),200):
                # All streams fit a single range in this dataset; this is intentionally checked.
                assert batch_start==0, 'stream exceeds one batch'
                for msgid,fields in s.xrange(key,'-','+'):
                    t.xadd(key,fields,id=msgid)
            info=s.xinfo_stream(key)
            assert info['entries-added']==info['length'] and info['max-deleted-entry-id']==b'0-0', 'stream has history requiring extra metadata'
            for group in s.xinfo_groups(key):
                name=group['name']
                args=['XGROUP','CREATE',key,name,group['last-delivered-id']]
                if group['entries-read'] is not None: args.extend(['ENTRIESREAD',group['entries-read']])
                t.execute_command(*args)
                for consumer in s.xinfo_consumers(key,name):
                    cname=consumer['name']
                    t.execute_command('XGROUP','CREATECONSUMER',key,name,cname)
                start='-'
                while True:
                    pending=s.xpending_range(key,name,start,'+',100)
                    if not pending: break
                    for item in pending:
                        msgid=item['message_id']
                        # FORCE creates a pending entry; TIME and RETRYCOUNT preserve delivery metadata.
                        delivered=int(time.time()*1000)-item['time_since_delivered']
                        reply=t.execute_command('XCLAIM',key,name,item['consumer'],0,msgid,'TIME',delivered,'RETRYCOUNT',item['times_delivered'],'FORCE','JUSTID')
                        assert reply==[msgid],(key,name,msgid,reply)
                    start='('+pending[-1]['message_id'].decode()
        else:
            raise RuntimeError((key,typ))
        if exp>0:
            assert t.pexpireat(key,exp), (key,exp)
        counts[(db,typ.decode())]+=1
    if keys: print('copied db',db,'keys',len(keys),flush=True)
print('copied counts',counts,flush=True)
# Verify all keys and their contents, absolute expiry timestamps, and stream consumer group state.
for db in range(int(s0.config_get('databases')['databases'])):
    s=redis.Redis(host='127.0.0.1',port=src_port,db=db)
    t=redis.Redis(host='127.0.0.1',port=dst_port,db=db)
    a=set(s.scan_iter(count=500));b=set(t.scan_iter(count=500))
    assert a==b,(db,'keys',len(a),len(b),a^b)
    for key in a:
        typ=s.type(key)
        assert t.type(key)==typ,(db,key,'type')
        assert s.pexpiretime(key)==t.pexpiretime(key),(db,key,'expiry',s.pexpiretime(key),t.pexpiretime(key))
        if typ==b'string': assert s.get(key)==t.get(key),(db,key)
        elif typ==b'list': assert s.lrange(key,0,-1)==t.lrange(key,0,-1),(db,key)
        elif typ==b'set': assert s.smembers(key)==t.smembers(key),(db,key)
        elif typ==b'zset': assert s.zrange(key,0,-1,withscores=True)==t.zrange(key,0,-1,withscores=True),(db,key)
        elif typ==b'hash':
            v=s.hgetall(key);assert v==t.hgetall(key),(db,key)
            fields=list(v)
            assert s.execute_command('HPEXPIRETIME',key,'FIELDS',len(fields),*fields)==t.execute_command('HPEXPIRETIME',key,'FIELDS',len(fields),*fields),(db,key,'field expiries')
        elif typ==b'stream':
            assert s.xrange(key)==t.xrange(key),(db,key,'entries')
            g1=s.xinfo_groups(key);g2=t.xinfo_groups(key)
            for g in g1:
                g.pop('lag',None)
            for g in g2:
                g.pop('lag',None)
            assert g1==g2,(db,key,'groups',g1,g2)
            for group in g1:
                name=group['name']
                c1=s.xinfo_consumers(key,name);c2=t.xinfo_consumers(key,name)
                assert [(x['name'],x['pending']) for x in c1]==[(x['name'],x['pending']) for x in c2],(key,name,'consumers')
                p1=s.xpending_range(key,name,'-','+',10000);p2=t.xpending_range(key,name,'-','+',10000)
                assert [(x['message_id'],x['consumer'],x['times_delivered']) for x in p1]==[(x['message_id'],x['consumer'],x['times_delivered']) for x in p2],(key,name,'pending')
    if a:print('verified db',db,len(a),flush=True)
print('SUCCESS',flush=True)
PY
python3 /tmp/migrate_redis_valkey.py

11  $ sed -i "/t=redis.Redis(host='127.0.0.1',port=dst_port,db=db)/a\    t.set_response_callback('XCLAIM',lambda r:r)" /tmp/migrate_redis_valkey.py
valkey-cli -p 6380 FLUSHALL; python3 /tmp/migrate_redis_valkey.py

12  $ valkey-cli -p 6380 SAVE; valkey-cli -p 6380 INFO replication | head -12; valkey-cli -p 6380 INFO keyspace; redis-cli -p 6379 INFO keyspace; ls -lh /var/lib/valkey/dump.rdb; redis-cli -p 6379 ping

{
 "examples": {},
 "keys_new": {
  "0": 2960,
  "2": 350
 },
 "keys_old": {
  "0": 2960,
  "2": 350
 },
 "mismatch_counts": {
  "extra": 0,
  "field_ttl_added": 0,
  "field_ttl_drift": 0,
  "field_ttl_lost": 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": "8.10.2",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

1  $ ls /opt/redis-8.10/bin; echo ---; ls /etc/redis-old/ /etc/valkey/; echo ---; which valkey-cli redis-cli; echo ---; ls /opt

2  $ ps aux | grep -iE 'redis|valkey' | grep -v grep

3  $ cat /etc/valkey/valkey.conf | grep -vE '^\s*#|^\s*$'

4  $ redis-cli -p 6379 info server | head -20; echo ---; redis-cli -p 6379 info keyspace; echo ---; redis-cli -p 6379 dbsize

5  $ valkey-cli -p 6380 info server | head -5; echo ---; valkey-cli -p 6380 dbsize; echo ---; redis-cli -p 6379 info replication

6  $ for i in 0 1 2; do echo "== db$i =="; redis-cli -p 6379 -n $i dbsize; done; echo ---; redis-cli -p 6379 -n 0 --scan | head -20

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

8  $ redis-cli -p 6379 -n 0 --scan | while read k; do t=$(redis-cli -p 6379 -n 0 type "$k"); if [ "$t" = "stream" ]; then echo "STREAM $k"; fi; done

9  $ redis-cli -p 6379 -n 0 --scan | while read k; do t=$(redis-cli -p 6379 -n 0 type "$k"); if [ "$t" = "stream" ]; then echo "== $k"; redis-cli -p 6379 -n 0 xinfo groups "$k"; fi; done | head -60

10  $ redis-cli -p 6379 -n 0 xinfo groups events:03; echo ---; redis-cli -p 6379 -n 0 xinfo consumers events:03 workers; echo ---; redis-cli -p 6379 -n 0 xrange events:03 - + count 3

11  $ redis-cli -p 6379 -n 0 dump events:03 | head -c 100; echo; echo ---; redis-cli -p 6379 debug reload 2>&1 | head -3

12  $ grep -vE '^\s*#|^\s*$' /etc/redis-old/redis.conf

13  $ ls -la /opt/kv-seed /opt/kv-grader 2>/dev/null | head; echo ---; cat /opt/pip-system.json 2>/dev/null | head -c 2000

14  $ ls -R /opt/kv-grader/bin /opt/kv-grader/lib | head -40; echo ---; ls -R /opt/kv-seed | head -40

15  $ sed -n 1,80p /opt/kv-seed/seed_old8.py

16  $ sed -n 1,80p /opt/kv-seed/kvdump2.py

17  $ valkey-cli -p 6380 hset t1 f1 v1; valkey-cli -p 6380 hpexpireat t1 99999999999999 FIELDS 1 f1; valkey-cli -p 6380 hpexpiretime t1 FIELDS 1 f1; echo ---; redis-cli -p 6379 info server | grep -i rdb; valkey-cli -p 6380 info server | grep -i rdb

18  $ redis-cli -p 6379 -n 0 --scan | grep -iE 'hash|user:' | head; echo ---; redis-cli -p 6379 -n 0 hpexpiretime user:0000 FIELDS 6 name email plan created visits pref:0

19  $ redis-cli -p 6379 -n 0 --scan | while read k; do t=$(redis-cli -p 6379 -n 0 type "$k"); if [ "$t" = "hash" ]; then n=$(redis-cli -p 6379 -n 0 hlen "$k"); e=$(redis-cli -p 6379 -n 0 hpexpiretime "$k" FIELDS $n $(redis-cli -p 6379 -n 0 hkeys "$k") | tr '\n' ' '); case "$e" in *-1*) ;; *) echo "$k => $e";; esac; fi; done | head -20

20  $ redis-cli -p 6379 -n 0 --scan | while read k; do t=$(redis-cli -p 6379 -n 0 type "$k"); echo "$t"; done | sort | uniq -c; echo "--- object encoding"; redis-cli -p 6379 -n 0 --scan | head -50 | while read k; do echo "$k $(redis-cli -p 6379 -n 0 object encoding "$k")"; done

21  $ redis-cli -p 6379 -n 0 --scan --pattern 'profile:*'; echo ---; redis-cli -p 6379 -n 0 hgetall profile:03; echo ---; redis-cli -p 6379 -n 0 hpexpiretime profile:03 FIELDS 3 f1 f2 f3 2>&1

22  $ for k in profile:00 profile:03 profile:19; do echo "== $k"; redis-cli -p 6379 -n 0 hkeys $k; echo "times:"; redis-cli -p 6379 -n 0 hpexpiretime $k FIELDS $(redis-cli -p 6379 -n 0 hlen $k) $(redis-cli -p 6379 -n 0 hkeys $k); echo; done

23  $ redis-cli -p 6379 -n 0 migrate 127.0.0.1 6380 profile:03 0 5000 COPY REPLACE; echo "migrate exit=$?"; valkey-cli -p 6380 -n 0 hgetall profile:03; echo ---; valkey-cli -p 6380 -n 0 hpexpiretime profile:03 FIELDS 6 reset_token otp name tier theme lang; echo ---; valkey-cli -p 6380 -n 0 object encoding profile:03

24  $ valkey-cli -p 6380 info server | grep -iE 'rdb|version'; echo ---; valkey-cli -p 6380 config get save appendonly; echo ---; redis-cli -p 6379 -n 0 debug jmap 2>&1 | head -1

25  $ redis-cli -p 6379 bgsave; valkey-cli -p 6380 bgsave; sleep 1; ls -la /var/lib/redis-old /var/lib/valkey; echo ---; head -c 9 /var/lib/redis-old/dump.rdb; echo; head -c 9 /var/lib/valkey/dump.rdb; echo

26  $ which python3 python; python3 -c "import redis, sys; print(redis.__version__, sys.version)" 2>&1 | head; echo ---; /opt/kv-grader/bin/python -c "import redis,sys;print(redis.__version__, sys.version)"

27  $ which valkey-server redis-server; ls -la $(which valkey-server); valkey-server --version; /opt/redis-8.10/bin/redis-server --version

28  $ mkdir -p /tmp/vtest && cp /var/lib/redis-old/dump.rdb /tmp/vtest/dump.rdb && cd /tmp/vtest && valkey-server --port 6399 --dir /tmp/vtest --daemonize yes --logfile /tmp/vtest/log.txt --save '' ; sleep 1; valkey-cli -p 6399 ping; echo "--- log:"; cat /tmp/vtest/log.txt

29  $ rm -rf /tmp/vtest; mkdir -p /tmp/vtest && cd /tmp/vtest && valkey-server --port 6399 --dir /tmp/vtest --daemonize yes --logfile /tmp/vtest/log.txt --save '' --replicaof 127.0.0.1 6379; sleep 3; valkey-cli -p 6399 ping; valkey-cli -p 6399 dbsize; echo "--- log tail:"; tail -15 /tmp/vtest/log.txt

30  $ sleep 5; valkey-cli -p 6399 dbsize; valkey-cli -p 6399 -n 2 dbsize; echo "--- log:"; tail -8 /tmp/vtest/log.txt

31  $ valkey-cli -p 6399 shutdown nosave 2>/dev/null; find / -iname '*grade*' -not -path '*/site-packages/*' 2>/dev/null | head -40; echo ---; ls -la /opt; cat /opt/pip-grader.json

32  $ find / -iname '*kvdump*' 2>/dev/null; echo ---; find / -iname '*valkey*' -path '*bin*' 2>/dev/null | head; echo ---; ls /usr/local/bin

33  $ /usr/local/bin/redis-server --version; ls -la /usr/local/bin/redis-server /usr/local/bin/redis-cli; echo ---; cat /usr/local/bin/docker-entrypoint.sh 2>/dev/null | head -40

34  $ ls -la /opt/redis-8.10; ls -la /opt/redis-8.10/bin; find / -name 'redis-server*' -o -name 'valkey-server*' 2>/dev/null | grep -v proc

35  $ sed -n '80,200p' /opt/kv-seed/seed_old8.py

36  $ sed -n '80,200p' /opt/kv-seed/kvdump2.py

37  $ cat > /tmp/inspect.py <<'EOF'
import redis, json
r = redis.Redis(port=6379, db=0)
for k in [b"events:03", b"events:07", b"events:06"]:
    print("====", k)
    print("xinfo stream:", r.xinfo_stream(k))
    for g in r.xinfo_groups(k):
        print("group:", g)
        print("  consumers:", r.xinfo_consumers(k, g['name']))
        print("  pending_range:", r.xpending_range(k, g['name'], min='-', max='+', count=1000))
EOF
python3 /tmp/inspect.py

38  $ mv /tmp/inspect.py /tmp/probe_streams.py && python3 /tmp/probe_streams.py

39  $ valkey-cli -p 6380 del s1 >/dev/null; for i in $(seq 0 9); do valkey-cli -p 6380 xadd s1 $((1000+i))-0 f v$i >/dev/null; done
valkey-cli -p 6380 xgroup create s1 g 1004-0
echo "claim not-pending 1000-0:"; valkey-cli -p 6380 xclaim s1 g c1 0 1000-0
echo "pending:"; valkey-cli -p 6380 xpending s1 g
echo "consumers:"; valkey-cli -p 6380 xinfo consumers s1 g
echo "group:"; valkey-cli -p 6380 xinfo groups s1

40  $ valkey-cli -p 6380 del s1 >/dev/null; for i in $(seq 0 9); do valkey-cli -p 6380 xadd s1 $((1000+i))-0 f v$i >/dev/null; done
valkey-cli -p 6380 xgroup create s1 g 1004-0
echo "xclaim FORCE 1000-0 1001-0 to c1:"; valkey-cli -p 6380 xclaim s1 g c1 0 1000-0 1001-0 FORCE JUSTID
echo "xclaim FORCE 1002-0 to c2:"; valkey-cli -p 6380 xclaim s1 g c2 0 1002-0 FORCE JUSTID
echo "pending:"; valkey-cli -p 6380 xpending s1 g
echo "consumers:"; valkey-cli -p 6380 xinfo consumers s1 g
echo "group:"; valkey-cli -p 6380 xinfo groups s1

41  $ valkey-cli -p 6380 flushall; cat > /tmp/migrate.py <<'PYEOF'
import redis
from collections import defaultdict

SRC_HOST, SRC_PORT = "127.0.0.1", 6379
DST_HOST, DST_PORT = "127.0.0.1", 6380

def dbs_with_keys(r):
    ks = r.info("keyspace") or {}
    return sorted(int(k[2:]) for k in ks if k.startswith("db") and (ks[k] or {}).get("keys", 0) > 0)

def copy_key(s, d, key, typ):
    if typ == b"string":
        v = s.execute_command("GET", key)
        d.execute_command("SET", key, v)
    elif typ == b"list":
        vals = s.execute_command("LRANGE", key, 0, -1)
        if vals:
            d.execute_command("RPUSH", key, *vals)
    elif typ == b"set":
        members = s.execute_command("SMEMBERS", key)
        if members:
            d.execute_command("SADD", key, *members)
    elif typ == b"zset":
        flat = s.execute_command("ZRANGE", key, 0, -1, "WITHSCORES")
        args = []
        for i in range(0, len(flat), 2):
            args.append(flat[i+1]); args.append(flat[i])  # score member
        if args:
            d.execute_command("ZADD", key, *args)
    elif typ == b"hash":
        items = s.execute_command("HGETALL", key)
        if items:
            d.execute_command("HSET", key, *items)
        # field-level TTLs
        fields = [items[i] for i in range(0, len(items), 2)]
        if fields:
            exp = s.execute_command("HPEXPIRETIME", key, "FIELDS", len(fields), *fields)
            for f, e in zip(fields, exp):
                e = int(e)
                if e > 0:
                    d.execute_command("HPEXPIREAT", key, e, "FIELDS", 1, f)
    elif typ == b"stream":
        copy_stream(s, d, key)
    else:
        raise RuntimeError(f"unsupported type {typ} for key {key!r}")

def copy_stream(s, d, key):
    entries = s.execute_command("XRANGE", key, "-", "+")
    pipe = d.pipeline(transaction=False)
    for mid, fields in entries:
        args = []
        for f, v in fields.items():
            args.append(f); args.append(v)
        pipe.execute_command("XADD", key, mid, *args)
    pipe.execute()

    groups = s.execute_command("XINFO", "GROUPS", key)
    for g in groups:
        gd = {g[i]: g[i+1] for i in range(0, len(g), 2)}
        gname = gd[b"name"]
        last = gd[b"last-delivered-id"]
        d.execute_command("XGROUP", "CREATE", key, gname, last)
        consumers = s.execute_command("XINFO", "CONSUMERS", key, gname)
        cnames = []
        for c in consumers:
            cd = {c[i]: c[i+1] for i in range(0, len(c), 2)}
            cnames.append(cd[b"name"])
            d.execute_command("XGROUP", "CREATECONSUMER", key, gname, cd[b"name"])
        pel = s.execute_command("XPENDING", key, gname, "-", "+", 1000000)
        byc = defaultdict(list)
        for row in pel:
            mid, consumer = row[0], row[1]
            byc[consumer].append(mid)
        for cname, ids in byc.items():
            d.execute_command("XCLAIM", key, gname, cname, 0, *ids, "FORCE", "JUSTID")

def main():
    src = redis.Redis(host=SRC_HOST, port=SRC_PORT, decode_responses=False)
    dst = redis.Redis(host=DST_HOST, port=DST_PORT, decode_responses=False)
    total = 0
    for db in dbs_with_keys(src):
        s = redis.Redis(host=SRC_HOST, port=SRC_PORT, db=db, decode_responses=False)
        d = redis.Redis(host=DST_HOST, port=DST_PORT, db=db, decode_responses=False)
        keys = list(s.scan_iter(count=1000))
        # gather type + abs expire
        pipe = s.pipeline(transaction=False)
        for k in keys:
            pipe.execute_command("TYPE", k)
            pipe.execute_command("PEXPIRETIME", k)
        meta = pipe.execute()
        for i, k in enumerate(keys):
            typ = meta[2*i]
            if typ == b"none":
                continue
            pexp = int(meta[2*i+1])
            copy_key(s, d, k, typ)
            if pexp > 0:
                d.execute_command("PEXPIREAT", k, pexp)
        total += len(keys)
        print(f"db{db}: copied {len(keys)} keys")
    print("done, total keys scanned:", total)

if __name__ == "__main__":
    main()
PYEOF
python3 /tmp/migrate.py

42  $ valkey-cli -p 6380 flushall >/dev/null; cat > /tmp/migrate.py <<'PYEOF'
import redis
from collections import defaultdict

SRC_HOST, SRC_PORT = "127.0.0.1", 6379
DST_HOST, DST_PORT = "127.0.0.1", 6380

def dbs_with_keys(r):
    ks = r.info("keyspace") or {}
    return sorted(int(k[2:]) for k in ks if k.startswith("db") and (ks[k] or {}).get("keys", 0) > 0)

def to_flat(items):
    """HGETALL may come back as dict or flat list; return flat list."""
    if isinstance(items, dict):
        flat = []
        for f, v in items.items():
            flat.append(f); flat.append(v)
        return flat
    return list(items)

def copy_key(s, d, key, typ):
    if typ == b"string":
        v = s.execute_command("GET", key)
        d.execute_command("SET", key, v)
    elif typ == b"list":
        vals = s.execute_command("LRANGE", key, 0, -1)
        if vals:
            d.execute_command("RPUSH", key, *vals)
    elif typ == b"set":
        members = s.execute_command("SMEMBERS", key)
        if members:
            d.execute_command("SADD", key, *members)
    elif typ == b"zset":
        flat = s.execute_command("ZRANGE", key, 0, -1, "WITHSCORES")
        args = []
        for i in range(0, len(flat), 2):
            args.append(flat[i+1]); args.append(flat[i])  # score member
        if args:
            d.execute_command("ZADD", key, *args)
    elif typ == b"hash":
        flat = to_flat(s.execute_command("HGETALL", key))
        if flat:
            d.execute_command("HSET", key, *flat)
        fields = flat[0::2]
        if fields:
            exp = s.execute_command("HPEXPIRETIME", key, "FIELDS", len(fields), *fields)
            for f, e in zip(fields, exp):
                e = int(e)
                if e > 0:
                    d.execute_command("HPEXPIREAT", key, e, "FIELDS", 1, f)
    elif typ == b"stream":
        copy_stream(s, d, key)
    else:
        raise RuntimeError(f"unsupported type {typ} for key {key!r}")

def copy_stream(s, d, key):
    entries = s.execute_command("XRANGE", key, "-", "+")
    pipe = d.pipeline(transaction=False)
    for mid, fields in entries:
        if isinstance(fields, dict):
            it = fields.items()
        else:
            it = zip(fields[0::2], fields[1::2])
        args = []
        for f, v in it:
            args.append(f); args.append(v)
        pipe.execute_command("XADD", key, mid, *args)
    pipe.execute()

    groups = s.execute_command("XINFO", "GROUPS", key)
    for g in groups:
        if isinstance(g, dict):
            gd = g
        else:
            gd = {g[i]: g[i+1] for i in range(0, len(g), 2)}
        gname = gd[b"name"]
        last = gd[b"last-delivered-id"]
        d.execute_command("XGROUP", "CREATE", key, gname, last)
        consumers = s.execute_command("XINFO", "CONSUMERS", key, gname)
        for c in consumers:
            cd = c if isinstance(c, dict) else {c[i]: c[i+1] for i in range(0, len(c), 2)}
            d.execute_command("XGROUP", "CREATECONSUMER", key, gname, cd[b"name"])
        pel = s.execute_command("XPENDING", key, gname, "-", "+", 1000000)
        byc = defaultdict(list)
        for row in pel:
            mid, consumer = row[0], row[1]
            byc[consumer].append(mid)
        for cname, ids in byc.items():
            d.execute_command("XCLAIM", key, gname, cname, 0, *ids, "FORCE", "JUSTID")

def main():
    src = redis.Redis(host=SRC_HOST, port=SRC_PORT, decode_responses=False)
    total = 0
    for db in dbs_with_keys(src):
        s = redis.Redis(host=SRC_HOST, port=SRC_PORT, db=db, decode_responses=False)
        d = redis.Redis(host=DST_HOST, port=DST_PORT, db=db, decode_responses=False)
        keys = list(s.scan_iter(count=1000))
        pipe = s.pipeline(transaction=False)
        for k in keys:
            pipe.execute_command("TYPE", k)
            pipe.execute_command("PEXPIRETIME", k)
        meta = pipe.execute()
        for i, k in enumerate(keys):
            typ = meta[2*i]
            if typ == b"none":
                continue
            pexp = int(meta[2*i+1])
            copy_key(s, d, k, typ)
            if pexp > 0:
                d.execute_command("PEXPIREAT", k, pexp)
        total += len(keys)
        print(f"db{db}: copied {len(keys)} keys")
    print("done, total keys scanned:", total)

if __name__ == "__main__":
    main()
PYEOF
python3 /tmp/migrate.py

43  $ python3 -c "
import redis
r=redis.Redis(port=6379,db=0,decode_responses=False)
k=[x for x in r.scan_iter() if r.type(x)==b'zset'][0]
print(repr(r.execute_command('ZRANGE',k,0,1,'WITHSCORES')))
print(repr(r.execute_command('ZRANGE',k,0,1)))
h=[x for x in r.scan_iter() if r.type(x)==b'hash'][0]
print(repr(r.execute_command('HGETALL',h))[:200])
s=[x for x in r.scan_iter() if r.type(x)==b'stream'][0]
print(repr(r.execute_command('XRANGE',s,'-','+',count=1))[:300])
print(repr(r.execute_command('XINFO','GROUPS',s))[:300])
print(repr(r.execute_command('XPENDING',s,'workers','-','+',5)))
"

44  $ valkey-cli -p 6380 flushall >/dev/null; cat > /tmp/migrate.py <<'PYEOF'
import redis

SRC_HOST, SRC_PORT = "127.0.0.1", 6379
DST_HOST, DST_PORT = "127.0.0.1", 6380

def dbs_with_keys(r):
    ks = r.info("keyspace") or {}
    return sorted(int(k[2:]) for k in ks if k.startswith("db") and (ks[k] or {}).get("keys", 0) > 0)

def copy_key(s, d, key, typ):
    if typ == "string":
        d.set(key, s.get(key))
    elif typ == "list":
        vals = s.lrange(key, 0, -1)
        if vals:
            d.rpush(key, *vals)
    elif typ == "set":
        members = list(s.smembers(key))
        if members:
            d.sadd(key, *members)
    elif typ == "zset":
        pairs = s.zrange(key, 0, -1, withscores=True)
        if pairs:
            d.zadd(key, {m: sc for m, sc in pairs})
    elif typ == "hash":
        h = s.hgetall(key)
        if h:
            d.hset(key, mapping=h)
        fields = list(h.keys())
        if fields:
            exps = s.execute_command("HPEXPIRETIME", key, "FIELDS", len(fields), *fields)
            for f, e in zip(fields, exps):
                e = int(e)
                if e > 0:
                    d.execute_command("HPEXPIREAT", key, e, "FIELDS", 1, f)
    elif typ == "stream":
        copy_stream(s, d, key)
    else:
        raise RuntimeError(f"unsupported type {typ!r} for key {key!r}")

def copy_stream(s, d, key):
    for mid, fields in s.xrange(key, "-", "+"):
        args = []
        for f, v in fields.items():
            args.append(f); args.append(v)
        d.execute_command("XADD", key, mid, *args)

    for g in s.xinfo_groups(key):
        gname = g["name"]
        last = g["last-delivered-id"]
        d.execute_command("XGROUP", "CREATE", key, gname, last)
        for c in s.xinfo_consumers(key, gname):
            d.execute_command("XGROUP", "CREATECONSUMER", key, gname, c["name"])
        # pending entries, grouped by consumer
        byc = {}
        pel = s.xpending_range(key, gname, min="-", max="+", count=1000000)
        for row in pel:
            byc.setdefault(row["consumer"], []).append(row["message_id"])
        for cname, ids in byc.items():
            d.execute_command("XCLAIM", key, gname, cname, 0, *ids, "FORCE", "JUSTID")

def main():
    src = redis.Redis(host=SRC_HOST, port=SRC_PORT, decode_responses=False)
    total = 0
    for db in dbs_with_keys(src):
        s = redis.Redis(host=SRC_HOST, port=SRC_PORT, db=db, decode_responses=False)
        d = redis.Redis(host=DST_HOST, port=DST_PORT, db=db, decode_responses=False)
        keys = list(s.scan_iter(count=1000))
        pipe = s.pipeline(transaction=False)
        for k in keys:
            pipe.type(k)
            pipe.execute_command("PEXPIRETIME", k)
        meta = pipe.execute()
        copied = 0
        for i, k in enumerate(keys):
            typ = meta[2*i]
            if isinstance(typ, bytes):
                typ = typ.decode()
            if typ == "none":
                continue
            pexp = int(meta[2*i+1])
            copy_key(s, d, k, typ)
            if pexp > 0:
                d.execute_command("PEXPIREAT", k, pexp)
            copied += 1
        total += copied
        print(f"db{db}: copied {copied} keys")
    print("done, total keys copied:", total)

if __name__ == "__main__":
    main()
PYEOF
python3 /tmp/migrate.py

45  $ python3 -c "
import redis
s=redis.Redis(port=6379,db=0,decode_responses=False)
d=redis.Redis(port=6380,db=0,decode_responses=False)
k=b'events:03'
g=b'workers'
pel=s.xpending_range(k,g,min='-',max='+',count=100)
print('pel sample', pel[:2])
byc={}
for row in pel:
    byc.setdefault(row['consumer'],[]).append(row['message_id'])
print({c:len(v) for c,v in byc.items()})
cname=b'w1'; ids=byc[cname]
try:
    print(d.execute_command('XCLAIM',k,g,cname,0,*ids,'FORCE','JUSTID'))
except Exception as e:
    print('ERR', type(e), e)
"

46  $ python3 -c "import redis, inspect, redis.client as c; print(inspect.getsource(c.parse_xclaim))" 2>/dev/null || grep -rn "def parse_xclaim" /usr/local/lib/python3.13/dist-packages/redis/ | head

47  $ sed -n '761,790p' /usr/local/lib/python3.13/dist-packages/redis/_parsers/helpers.py

48  $ valkey-cli -p 6380 flushall >/dev/null; sed -i 's/^def copy_stream(s, d, key):/def copy_stream(s, d, key):\n    d.set_response_callback("XCLAIM", lambda r: r)/' /tmp/migrate.py && python3 /tmp/migrate.py

49  $ cd /tmp && cp /opt/kv-seed/kvdump2.py /tmp/kvdump2.py && python3 -c "
import kvdump2 as kd
a=kd.dump_server(6379)
b=kd.dump_server(6380)
da=kd.digest(a); db=kd.digest(b)
print('old digest', da)
print('new digest', db)
print('MATCH' if da==db else 'MISMATCH')
print('old counts', {d:len(v) for d,v in a.items()})
print('new counts', {d:len(v) for d,v in b.items()})
"

50  $ cd /tmp && python3 -c "
import kvdump2 as kd
a=kd.dump_server(6379)
b=kd.dump_server(6380)
# compare TTLs with tolerance
bad=0; maxdiff=0
for db in a:
    for k,(t,v,p) in a[db].items():
        t2,v2,p2=b[db][k]
        assert t==t2 and v==v2, (db,k)
        if p>0 or p2>0:
            diff=abs(p-p2); maxdiff=max(maxdiff,diff)
            if diff>1000: bad+=1; print('TTL diff', db,k,p,p2)
print('max ttl diff ms', maxdiff, 'bad', bad)
print('field ttl check:')
for db in a:
    for k,(t,v,p) in a[db].items():
        if t=='hash':
            fe=[x for x in v if x[2]>0]
            fe2=[x for x in b[db][k][1] if x[2]>0]
            if len(fe)!=len(fe2): print('field count mismatch',k)
print('OK')
"

51  $ python3 -c "
import redis
s=redis.Redis(port=6379,db=0,decode_responses=False)
d=redis.Redis(port=6380,db=0,decode_responses=False)
for k in [b'profile:00',b'profile:03',b'profile:19']:
    fields=[b'reset_token',b'otp',b'name',b'tier',b'theme',b'lang']
    a=s.execute_command('HPEXPIRETIME',k,'FIELDS',len(fields),*fields)
    b=d.execute_command('HPEXPIRETIME',k,'FIELDS',len(fields),*fields)
    print(k, 'old',a,'new',b)
"

52  $ python3 -c "
import redis
s=redis.Redis(port=6379,db=0,decode_responses=False)
d=redis.Redis(port=6380,db=0,decode_responses=False)
streams=[x for x in s.scan_iter() if s.type(x)==b'stream']
print('num streams', len(streams))
issues=0
for k in streams:
    se=s.xrange(k,'-','+'); de=d.xrange(k,'-','+')
    if se!=de: print('ENTRIES mismatch',k); issues+=1
    sg=s.xinfo_groups(k); dg=d.xinfo_groups(k)
    if len(sg)!=len(dg): print('GROUP count mismatch',k); issues+=1; continue
    for g1,g2 in zip(sorted(sg,key=lambda x:x['name']),sorted(dg,key=lambda x:x['name'])):
        for f in ['name','last-delivered-id','pending']:
            if g1[f]!=g2[f]: print('GROUP field mismatch',k,f,g1[f],g2[f]); issues+=1
        c1=sorted(s.xinfo_consumers(k,g1['name']),key=lambda x:x['name'])
        c2=sorted(d.xinfo_consumers(k,g2['name']),key=lambda x:x['name'])
        n1=[(c['name'],c['pending']) for c in c1]; n2=[(c['name'],c['pending']) for c in c2]
        if n1!=n2: print('CONSUMER mismatch',k,n1,n2); issues+=1
        p1=sorted((r['message_id'],r['consumer']) for r in s.xpending_range(k,g1['name'],'-','+',100000))
        p2=sorted((r['message_id'],r['consumer']) for r in d.xpending_range(k,g2['name'],'-','+',100000))
        if p1!=p2: print('PEL mismatch',k,p1[:5],p2[:5]); issues+=1
print('issues',issues)
"

53  $ echo "== new server keyspace =="; valkey-cli -p 6380 info keyspace
echo "== replication =="; valkey-cli -p 6380 info replication
echo "== write test =="; valkey-cli -p 6380 set __writetest__ ok; valkey-cli -p 6380 get __writetest__; valkey-cli -p 6380 del __writetest__
echo "== old server still up =="; redis-cli -p 6379 ping; redis-cli -p 6379 dbsize
echo "== leftover test keys check =="; valkey-cli -p 6380 -n 0 exists s1 t1 __writetest__ profile:03

54  $ ps aux | grep -iE 'redis-server|valkey-server' | grep -v grep
echo "--- port 6399:"; (valkey-cli -p 6399 ping 2>&1 | head -1)
echo "--- /tmp/vtest:"; ls /tmp/vtest 2>/dev/null
echo "--- final digests:"; cd /tmp && python3 -c "
import kvdump2 as kd
print('old', kd.digest(kd.dump_server(6379)))
print('new', kd.digest(kd.dump_server(6380)))
"

55  $ rm -rf /tmp/vtest; echo cleaned; ls /tmp

{
 "examples": {},
 "keys_new": {
  "0": 2960,
  "2": 350
 },
 "keys_old": {
  "0": 2960,
  "2": 350
 },
 "mismatch_counts": {
  "extra": 0,
  "field_ttl_added": 0,
  "field_ttl_drift": 0,
  "field_ttl_lost": 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": "8.10.2",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

1  $ ls -la /opt/redis-8.10/bin; echo "---"; ls -la /etc/redis-old/; echo "---"; ls -la /etc/valkey/; echo "---"; which valkey-cli valkey-server redis-cli redis-server; echo "---"; ps aux | grep -iE 'redis|valkey' | grep -v grep

2  $ redis-cli -p 6379 ping; echo "---"; redis-cli -p 6379 info server | head -20; echo "---"; valkey-cli -p 6380 ping 2>&1; echo "---"; valkey-cli -p 6380 info server 2>&1 | head -20

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

4  $ redis-cli -p 6379 info keyspace; echo "---"; redis-cli -p 6379 info replication; echo "---"; redis-cli -p 6379 dbsize; echo "---"; redis-cli -p 6379 info modules 2>&1 | head

5  $ for db in 0 2; do echo "=== db$db ==="; redis-cli -p 6379 -n $db --scan --count 1000 | head -2000 | while read k; do t=$(redis-cli -p 6379 -n $db type "$k"); echo "$t"; done | sort | uniq -c; done

6  $ redis-cli -p 6379 -n 0 --scan --count 1000 | head -30; echo "=== db2 ==="; redis-cli -p 6379 -n 2 --scan --count 1000 | head -30

7  $ redis-cli -p 6379 set __testkey__ hello
redis-cli -p 6379 dump __testkey__ | head -c 100 | xxd | head
echo "--- restore into valkey ---"
redis-cli -p 6379 --no-raw dump __testkey__ > /tmp/dump.bin
ls -l /tmp/dump.bin
redis-cli -p 6379 del __testkey__

8  $ ls /usr/local/bin; echo "---"; ls /opt; echo "---"; find / -name 'redis-check-rdb' -o -name 'valkey-check-rdb' 2>/dev/null

9  $ ls -la /opt/kv-grader /opt/kv-seed; echo "---"; file /opt/kv-grader /opt/kv-seed 2>/dev/null; echo "---"; cat /opt/pip-system.json 2>/dev/null | head -50

10  $ cd /tmp; echo -n "" > /dev/null; redis-cli -p 6379 lpush __mylist__ a b c >/dev/null; redis-cli -p 6379 --no-raw dump __mylist__ > /tmp/l.bin; od -An -tx1 /tmp/l.bin; redis-cli -p 6379 del __mylist__

11  $ cat /opt/kv-seed/kvdump2.py; echo "=========="; cat /opt/kv-seed/seed_old8.py

12  $ ls -la /opt/kv-grader/bin /opt/kv-grader/include /opt/kv-grader/lib; echo "---"; cat /opt/kv-grader/.gitignore

13  $ cat /opt/kv-seed/seed_old8.py

14  $ find /opt/kv-grader -name '*.py' | head -50; echo "---"; ls -laR /opt/kv-grader/lib/python3.13/ | head -50

15  $ tail -n +50 /opt/kv-seed/seed_old8.py

16  $ redis-cli -p 6379 -n 0 hpexpiretime user:0000 FIELDS 1 name; echo "---hash with field ttl?---"; redis-cli -p 6379 -n 0 --scan --count 1000 | grep -i 'hash\|ttl\|field' | head; echo "--- check keys with 'ephemeral' ---"; redis-cli -p 6379 -n 0 keys '*field*' | head

17  $ cd /tmp
python3 - <<'EOF'
import redis
src = redis.Redis(port=6379)
dst = redis.Redis(port=6380)
# simple string with ttl
src.set("t:str", b"\x00\xffhello", ex=1000)
d = src.dump("t:str")
print("dump len", len(d), d[:10])
try:
    dst.restore("t:str", 0, d, replace=True)
    print("restore ok", dst.get("t:str"), dst.pttl("t:str"))
except Exception as e:
    print("restore FAILED:", e)
EOF

18  $ redis-cli -p 6379 config get *rdb*; echo "---"; redis-cli -p 6380 config get *rdb*; echo "--- check restore command availability ---"; redis-cli -p 6380 command info restore

19  $ find / -name '*.digest' -o -name 'digest*' 2>/dev/null | grep -v site-packages | head; echo "---"; ls -la /var/lib/redis-old /var/lib/valkey 2>/dev/null; echo "--- logs ---"; tail -5 /var/log/redis-old/redis.log 2>/dev/null; tail -5 /var/log/valkey/valkey.log 2>/dev/null

20  $ redis-cli -p 6380 config get rdb-version-check; echo "--- try relaxed ---"; redis-cli -p 6380 config set rdb-version-check relaxed; redis-cli -p 6380 config get rdb-version-check; echo "--- try no ---"; redis-cli -p 6380 config set rdb-version-check no 2>&1; redis-cli -p 6380 config set rdb-version-check no-check 2>&1

21  $ cd /tmp
python3 - <<'EOF'
import redis
src = redis.Redis(port=6379)
dst = redis.Redis(port=6380)
src.set("t:str", b"\x00\xffhello", ex=1000)
d = src.dump("t:str")
for k in ["t:str"]:
    try:
        dst.delete(k)
    except: pass
try:
    dst.restore("t:str", 0, d, replace=True)
    print("restore ok", dst.get("t:str"), dst.pttl("t:str"))
except Exception as e:
    print("restore FAILED:", e)
EOF

22  $ cat /var/lib/kv-seed/old.digest; echo; echo "--- compute current digest with kvdump2 ---"; cd /opt/kv-seed && python3 -c "
import sys; sys.path.insert(0,'/opt/kv-seed')
import kvdump2
d=kvdump2.dump_server(6379)
print('digest', kvdump2.digest(d))
print('counts', {k:len(v) for k,v in d.items()})
" 2>&1 | tail -5

23  $ cd /tmp
python3 - <<'EOF'
import redis
src = redis.Redis(port=6379)
dst = redis.Redis(port=6380)

# hash with field TTL
src.delete("t:hash")
src.hset("t:hash", mapping={"a":"1","b":"2","c":"3"})
src.execute_command("HEXPIRE","t:hash", 1000, "FIELDS", 2, "a","b")
print("src hpexpiretime:", src.execute_command("HPEXPIRETIME","t:hash","FIELDS",3,"a","b","c"))
d = src.dump("t:hash")
try:
    dst.restore("t:hash", 0, d, replace=True)
    print("hash restored, hpexpiretime:", dst.execute_command("HPEXPIRETIME","t:hash","FIELDS",3,"a","b","c"))
except Exception as e:
    print("hash restore FAILED:", e)

# stream with group + PEL
src.delete("t:stream")
for j in range(10):
    src.xadd("t:stream", {"f":str(j)}, id=f"{1000+j}-0")
src.xgroup_create("t:stream","g1",id="0")
got = src.xreadgroup("g1","c1",{"t:stream":">"},count=5)
print("read:", got)
src.xack("t:stream","g1", got[0][1][0][0])   # ack one
print("src groups:", src.xinfo_groups("t:stream"))
print("src pending:", src.xpending_range("t:stream","g1",min="-",max="+",count=100))
d = src.dump("t:stream")
try:
    dst.restore("t:stream", 0, d, replace=True)
    print("stream restored, groups:", dst.xinfo_groups("t:stream"))
    print("stream restored, pending:", dst.xpending_range("t:stream","g1",min="-",max="+",count=100))
except Exception as e:
    print("stream restore FAILED:", e)
EOF

24  $ cat /opt/kv-seed/seed_old8.py | sed -n '1,20p'; echo "==="; find / -path /proc -prune -o -name '*.py' -print 2>/dev/null | grep -i grader | head

25  $ mkdir -p /tmp/rdbtest && cp /var/lib/redis-old/dump.rdb /tmp/rdbtest/dump.rdb
cd /tmp/rdbtest
valkey-server --port 6399 --bind 127.0.0.1 --dir /tmp/rdbtest --dbfilename dump.rdb --daemonize no --logfile /tmp/rdbtest/valkey.log --save '' &
sleep 3
echo "=== log ==="; cat /tmp/rdbtest/valkey.log
echo "=== keyspace ==="; valkey-cli -p 6399 info keyspace
echo "=== server ==="; valkey-cli -p 6399 info server | head -5

26  $ cd /tmp/rdbtest
valkey-server --port 6399 --bind 127.0.0.1 --dir /tmp/rdbtest --dbfilename dump.rdb --daemonize no --logfile /tmp/rdbtest/valkey2.log --save '' --rdb-version-check relaxed &
sleep 3
grep -iE 'rdb|error|ready|Fatal' /tmp/rdbtest/valkey2.log
echo "=== keyspace ==="; valkey-cli -p 6399 info keyspace

27  $ redis-check-rdb /var/lib/redis-old/dump.rdb 2>&1 | head -20; echo "=== valkey-check-rdb ==="; valkey-check-rdb /var/lib/redis-old/dump.rdb 2>&1 | head -20

28  $ for db in 0 2; do echo "=== db$db full type census ==="; redis-cli -p 6379 -n $db --scan --count 1000 > /tmp/keys_$db.txt; wc -l /tmp/keys_$db.txt; done
echo "=== types db0 ==="; redis-cli -p 6379 -n 0 --scan --count 1000 | while IFS= read -r k; do redis-cli -p 6379 -n 0 type "$k"; done | sort | uniq -c
echo "=== types db2 ==="; redis-cli -p 6379 -n 2 --scan --count 1000 | while IFS= read -r k; do redis-cli -p 6379 -n 2 type "$k"; done | sort | uniq -c

29  $ echo "=== valkey cmd support ==="
for c in HEXPIREAT HPEXPIRETIME PEXPIRETIME XCLAIM XGROUP XINFO OBJECT GETRANGE DUMP RESTORE; do echo -n "$c: "; redis-cli -p 6380 command info $c | head -1; done
echo "=== test HEXPIREAT on valkey ==="
redis-cli -p 6380 hset tk a 1 b 2
redis-cli -p 6380 hpexpireat tk 99999999999999 FIELDS 1 a
redis-cli -p 6380 hpexpiretime tk FIELDS 2 a b
redis-cli -p 6380 del tk
echo "=== test XCLAIM FORCE ==="
redis-cli -p 6380 del ts
redis-cli -p 6380 xadd ts 1-1 f v >/dev/null
redis-cli -p 6380 xgroup create ts g 0
redis-cli -p 6380 xclaim ts g c 0 1-1 FORCE JUSTID
redis-cli -p 6380 xpending ts g

30  $ redis-cli -p 6379 -n 0 del t:str t:hash t:stream __testkey__ __mylist__ >/dev/null
redis-cli -p 6379 -n 0 --scan --count 1000 | wc -l
cd /opt/kv-seed && python3 -c "
import sys; sys.path.insert(0,'/opt/kv-seed')
import kvdump2
d=kvdump2.dump_server(6379)
print('digest', kvdump2.digest(d))
print('counts', {k:len(v) for k,v in d.items()})
"
echo "recorded: $(cat /var/lib/kv-seed/old.digest)"

31  $ redis-cli -p 6380 dbsize; redis-cli -p 6380 info keyspace; echo "--- databases config ---"; redis-cli -p 6380 config get databases

32  $ redis-cli -p 6380 -n 0 keys '*'; echo "--- flushing test leftovers ---"; redis-cli -p 6380 flushall; redis-cli -p 6380 dbsize; redis-cli -p 6380 info keyspace

33  $ cat > /tmp/migrate.py <<'PYEOF'
#!/usr/bin/env python3
"""Logical, cross-version migration Redis 8.10 -> Valkey 9.1.

RDB / DUMP+RESTORE cannot be used across these versions (Redis 8 emits RDB
version 15 with foreign object type 25 = hash-with-field-expiry, which Valkey
9.1 refuses). So we copy every key logically, type by type, preserving values,
per-key PTTL, per-hash-field absolute expiry and stream consumer groups + PEL.
"""
import sys, time
import redis

SRC_PORT, DST_PORT = 6379, 6380
HOST = "127.0.0.1"
BATCH = 200

src_base = redis.Redis(host=HOST, port=SRC_PORT, socket_timeout=60)
dst_base = redis.Redis(host=HOST, port=DST_PORT, socket_timeout=60)

# Which databases hold keys on the source?
ks = src_base.info("keyspace") or {}
dbs = sorted(int(k[2:]) for k in ks if k.startswith("db") and (ks[k] or {}).get("keys", 0) > 0)
print("source databases with keys:", dbs)

now_ms = int(time.time() * 1000)
stats = {}

def flush(dst, cmds, dst_db):
    if not cmds:
        return
    dst.execute_command("SELECT", dst_db)
    for c in cmds:
        dst.execute_command(*c)
    cmds.clear()

for db in dbs:
    src = redis.Redis(host=HOST, port=SRC_PORT, db=db, socket_timeout=60)
    dst = redis.Redis(host=HOST, port=DST_PORT, db=db, socket_timeout=60)
    keys = list(src.scan_iter(count=1000))
    # read type + pttl in a pipeline
    pipe = src.pipeline(transaction=False)
    for k in keys:
        pipe.type(k); pipe.pttl(k)
    meta = pipe.execute()
    counts = {}
    cmds = []
    for i, k in enumerate(keys):
        typ = meta[2*i]
        if isinstance(typ, bytes):
            typ = typ.decode()
        if typ == "none":
            continue
        pttl = int(meta[2*i+1])
        counts[typ] = counts.get(typ, 0) + 1

        if typ == "string":
            v = src.get(k)
            cmds.append(("SET", k, v))
        elif typ == "list":
            v = src.lrange(k, 0, -1)
            if not v:
                continue
            cmds.append(("RPUSH", k, *v))
        elif typ == "set":
            v = src.smembers(k)
            if not v:
                continue
            cmds.append(("SADD", k, *v))
        elif typ == "zset":
            v = src.zrange(k, 0, -1, withscores=True)
            if not v:
                continue
            args = []
            for m, s in v:
                args.append(s); args.append(m)
            cmds.append(("ZADD", k, *args))
        elif typ == "hash":
            h = src.hgetall(k)
            if not h:
                continue
            args = []
            for f, val in h.items():
                args.append(f); args.append(val)
            cmds.append(("HSET", k, *args))
            fields = list(h.keys())
            exp = src.execute_command("HPEXPIRETIME", k, "FIELDS", len(fields), *fields)
            for f, e in zip(fields, exp):
                e = int(e)
                if e > 0:
                    cmds.append(("HPEXPIREAT", k, e, "FIELDS", 1, f))
        elif typ == "stream":
            entries = src.xrange(k, "-", "+")
            for mid, fields in entries:
                args = []
                for f, val in fields.items():
                    args.append(f); args.append(val)
                cmds.append(("XADD", k, mid, *args))
            # consumer groups + PEL
            for g in src.xinfo_groups(k):
                gname = g["name"]
                last = g.get("last-delivered-id")
                cmds.append(("XGROUP", "CREATE", k, gname, last, "MKSTREAM"))
                try:
                    pel = src.xpending_range(k, gname, min="-", max="+", count=1000000)
                except Exception:
                    pel = []
                for p in pel:
                    mid = p["message_id"]
                    consumer = p["consumer"]
                    idle = int(p.get("time_since_delivered", 0))
                    retry = int(p.get("times_delivered", 1))
                    t = now_ms - idle
                    cmds.append(("XCLAIM", k, gname, consumer, 0, mid,
                                 "TIME", t, "RETRYCOUNT", retry, "FORCE", "JUSTID"))
        else:
            print("!! unsupported type", typ, k)

        # apply pttl
        if pttl >= 0:
            cmds.append(("PEXPIRE", k, pttl))

        if len(cmds) >= BATCH:
            flush(dst, cmds, db)
    flush(dst, cmds, db)
    stats[db] = counts
    print(f"db{db}: {sum(counts.values())} keys copied, by type {counts}")

print("DONE", stats)
PYEOF
echo written

34  $ cd /tmp && time python3 migrate.py 2>&1 | tail -20

35  $ cd /tmp
python3 - <<'EOF'
# patch script: disable XCLAIM response callback
p = open('migrate.py').read()
p = p.replace(
'dst_base = redis.Redis(host=HOST, port=DST_PORT, socket_timeout=60)',
'dst_base = redis.Redis(host=HOST, port=DST_PORT, socket_timeout=60)\n'
'dst_base.response_callbacks.pop("XCLAIM", None)  # JUSTID returns raw IDs')
open('migrate.py','w').write(p)
print("patched")
EOF
redis-cli -p 6380 flushall
grep -n 'response_callbacks' migrate.py

36  $ cd /tmp
python3 - <<'EOF'
p = open('migrate.py').read()
p = p.replace(
'    dst = redis.Redis(host=HOST, port=DST_PORT, db=db, socket_timeout=60)',
'    dst = redis.Redis(host=HOST, port=DST_PORT, db=db, socket_timeout=60)\n'
'    dst.response_callbacks.pop("XCLAIM", None)  # JUSTID returns raw IDs')
open('migrate.py','w').write(p)
print("patched2")
EOF
redis-cli -p 6380 flushall >/dev/null
time python3 migrate.py 2>&1 | tail -20

37  $ cd /opt/kv-seed
python3 - <<'EOF'
import sys; sys.path.insert(0,'/opt/kv-seed')
import kvdump2
old = kvdump2.dump_server(6379)
new = kvdump2.dump_server(6380)
print("old digest:", kvdump2.digest(old))
print("new digest:", kvdump2.digest(new))
print("MATCH:", kvdump2.digest(old) == kvdump2.digest(new))
print("old counts:", {k:len(v) for k,v in old.items()})
print("new counts:", {k:len(v) for k,v in new.items()})
EOF

38  $ cd /tmp
python3 - <<'EOF'
import time, redis
HOST="127.0.0.1"
src_base=redis.Redis(host=HOST,port=6379)
dst_base=redis.Redis(host=HOST,port=6380)

def dbs(r):
    ks=r.info("keyspace") or {}
    return sorted(int(k[2:]) for k in ks if k.startswith("db") and (ks[k] or {}).get("keys",0)>0)

assert dbs(src_base)==dbs(dst_base), (dbs(src_base),dbs(dst_base))

mismatches=[]
for db in dbs(src_base):
    s=redis.Redis(host=HOST,port=6379,db=db)
    d=redis.Redis(host=HOST,port=6380,db=db)
    sk=set(s.scan_iter(count=1000)); dk=set(d.scan_iter(count=1000))
    if sk!=dk:
        mismatches.append((db,"keyset",len(sk),len(dk)))
    for k in sk:
        st=s.type(k); dt=d.type(k)
        if st!=dt:
            mismatches.append((db,k,"type",st,dt)); continue
        if st=="string":
            if s.get(k)!=d.get(k): mismatches.append((db,k,"value"))
        elif st=="list":
            if s.lrange(k,0,-1)!=d.lrange(k,0,-1): mismatches.append((db,k,"list"))
        elif st=="set":
            if s.smembers(k)!=d.smembers(k): mismatches.append((db,k,"set"))
        elif st=="zset":
            if s.zrange(k,0,-1,withscores=True)!=d.zrange(k,0,-1,withscores=True): mismatches.append((db,k,"zset"))
        elif st=="hash":
            if s.hgetall(k)!=d.hgetall(k): mismatches.append((db,k,"hash"))
            fl=list(s.hgetall(k).keys())
            se=s.execute_command("HPEXPIRETIME",k,"FIELDS",len(fl),*fl)
            de=d.execute_command("HPEXPIRETIME",k,"FIELDS",len(fl),*fl)
            for f,a,b in zip(fl,se,de):
                if a==-1 and b==-1: continue
                if a==-1 or b==-1 or abs(int(a)-int(b))>5000:
                    mismatches.append((db,k,"hfieldexp",f,a,b))
        elif st=="stream":
            if s.xrange(k,"-","+")!=d.xrange(k,"-","+") or s.xlen(k)!=d.xlen(k):
                mismatches.append((db,k,"stream-entries"))
            sg={g['name']:g for g in s.xinfo_groups(k)}
            dg={g['name']:g for g in d.xinfo_groups(k)}
            if set(sg)!=set(dg):
                mismatches.append((db,k,"groups",set(sg),set(dg))); continue
            for gname in sg:
                if sg[gname]['last-delivered-id']!=dg[gname]['last-delivered-id']:
                    mismatches.append((db,k,"g-lastid",gname,sg[gname]['last-delivered-id'],dg[gname]['last-delivered-id']))
                if int(sg[gname]['pending'])!=int(dg[gname]['pending']):
                    mismatches.append((db,k,"g-pending",gname,sg[gname]['pending'],dg[gname]['pending']))
                sp=s.xpending_range(k,gname,min="-",max="+",count=1000000)
                dp=d.xpending_range(k,gname,min="-",max="+",count=1000000)
                sp2=sorted((p['message_id'],p['consumer']) for p in sp)
                dp2=sorted((p['message_id'],p['consumer']) for p in dp)
                if sp2!=dp2:
                    mismatches.append((db,k,"pel",gname,sp2[:3],dp2[:3]))
        # TTL tolerance
        sp=s.pttl(k); dp=d.pttl(k)
        if (sp<0)!=(dp<0):
            mismatches.append((db,k,"ttl-sign",sp,dp))
        elif sp>=0 and abs(sp-dp)>5000:
            mismatches.append((db,k,"ttl",sp,dp))
    print(f"db{db} checked {len(sk)} keys")

print("MISMATCHES:", len(mismatches))
for m in mismatches[:30]: print(" ", m)
EOF

39  $ echo "=== dest writability & role ==="; redis-cli -p 6380 set __wtest__ ok; redis-cli -p 6380 get __wtest__; redis-cli -p 6380 del __wtest__; redis-cli -p 6380 info replication | head -3; echo "=== dest keyspace ==="; redis-cli -p 6380 info keyspace

40  $ echo "=== SAVE destination ==="; redis-cli -p 6380 save; ls -la /var/lib/valkey/
echo "=== source untouched? ==="
cd /opt/kv-seed && python3 -c "
import sys; sys.path.insert(0,'/opt/kv-seed')
import kvdump2
d=kvdump2.dump_server(6379)
print('source digest:', kvdump2.digest(d))
print('recorded     :', open('/var/lib/kv-seed/old.digest').read().strip())
print('UNCHANGED:', kvdump2.digest(d)==open('/var/lib/kv-seed/old.digest').read().strip())
"
echo "=== processes ==="; ps aux | grep -iE 'redis-server|valkey-server' | grep -v grep

41  $ echo "=== no stray scratch servers ==="; ps aux | grep -iE 'valkey-server|redis-server' | grep -v grep
echo "=== final digest confirmation ==="
cd /opt/kv-seed && python3 -c "
import sys; sys.path.insert(0,'/opt/kv-seed')
import kvdump2
o=kvdump2.digest(kvdump2.dump_server(6379))
n=kvdump2.digest(kvdump2.dump_server(6380))
r=open('/var/lib/kv-seed/old.digest').read().strip()
print('source  :',o)
print('dest    :',n)
print('recorded:',r)
print('EXACT MATCH (source==dest==recorded):', o==n==r)
"
rm -rf /tmp/rdbtest /tmp/keys_0.txt /tmp/keys_2.txt /tmp/l.bin /tmp/dump.bin
echo "=== dest accepts writes / standalone primary ==="
redis-cli -p 6380 set smoke:1 hello >/dev/null && redis-cli -p 6380 get smoke:1 && redis-cli -p 6380 del smoke:1 >/dev/null
redis-cli -p 6380 info replication | grep -E 'role|slaves'

{
 "examples": {},
 "keys_new": {
  "0": 2960,
  "2": 350
 },
 "keys_old": {
  "0": 2960,
  "2": 350
 },
 "mismatch_counts": {
  "extra": 0,
  "field_ttl_added": 0,
  "field_ttl_drift": 0,
  "field_ttl_lost": 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": "8.10.2",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

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

2  $ ps aux | grep -E "redis|valkey" | grep -v grep

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

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

5  $ redis-cli -p 6379 info keyspace 2>&1; echo "==="; redis-cli -p 6379 dbsize 2>&1; echo "==="; redis-cli -p 6380 info keyspace 2>&1; echo "=== config dir ==="; redis-cli -p 6379 config get dir; redis-cli -p 6379 config get appendonly; redis-cli -p 6379 config get save

6  $ for db in 0 2; do echo "=== db$db ==="; redis-cli -p 6379 -n $db --scan --count 10000 2>/dev/null | while read k; do t=$(redis-cli -p 6379 -n $db type "$k"); echo "$t"; done | sort | uniq -c; done

7  $ redis-cli -p 6379 -n 0 --scan --count 10000 2>/dev/null | head -20; echo "--- keys with special chars ---"; redis-cli -p 6379 -n 0 --scan --count 10000 2>/dev/null | grep -E "[^a-zA-Z0-9:_-]" | head -20

8  $ echo "=== source dbsize 0 ==="; redis-cli -p 6379 -n 0 dbsize
echo "=== sample stream ==="; redis-cli -p 6379 -n 0 --scan --count 10000 2>/dev/null | while read k; do t=$(redis-cli -p 6379 -n 0 type "$k"); if [ "$t" = "stream" ]; then echo "$k"; fi; done | head -5

9  $ # Check RDB version of a DUMP payload footer (last 10 bytes: 2-byte ver LE + 8-byte crc)
redis-cli -p 6379 -n 0 --no-raw dump "user:name with space" | head -c 200; echo; echo "---"
redis-cli -p 6379 -n 0 --scan --count 10000 2>/dev/null | head -1 | while read k; do redis-cli -p 6379 -n 0 --no-raw dump "$k"; done

10  $ redis-cli -p 6379 -n 0 bgsave; sleep 1; redis-cli -p 6379 info persistence | grep -E "rdb_last_bgsave_status|rdb_last_save_time"; ls -la /var/lib/redis-old/

11  $ # Check RDB version in header
f=$(ls /var/lib/redis-old/dump.rdb 2>/dev/null); echo "file=$f"; head -c 9 "$f" | xxd

12  $ head -c 9 /var/lib/redis-old/dump.rdb | od -A d -c; echo "---"; python3 -c "
d=open('/var/lib/redis-old/dump.rdb','rb').read()
print('magic:', d[:5])
print('rdb ver:', int.from_bytes(d[5:9],'little'))
"

13  $ python3 -c "import redis; print('redis-py', redis.__version__)" 2>&1; python3 -c "import valkey; print('valkey-py', valkey.__version__)" 2>&1; pip list 2>/dev/null | grep -iE "redis|valkey"

14  $ redis-cli -p 6380 info server | grep -iE "rdb|version"; echo "--- valkey-cli help ---"; valkey-cli --version; echo "--- docs check ---"; redis-cli -p 6379 config get maxmemory; redis-cli -p 6379 -n 0 randomkey

15  $ python3 -c "
d=open('/var/lib/redis-old/dump.rdb','rb').read()
print('header bytes:', d[:9])
print('version string:', d[5:9].decode())
"

16  $ # Test DUMP/RESTORE compatibility: dump a simple string key from redis, restore into valkey
redis-cli -p 6379 -n 0 set __test_key__ hello
redis-cli -p 6379 -n 0 dump __test_key__ > /tmp/d.bin
xxd /tmp/d.bin 2>/dev/null || od -A d -tx1 /tmp/d.bin | head
echo "--- restore into valkey db0 ---"
redis-cli -p 6380 -n 0 -x restore __test_key__ 0 < /tmp/d.bin; echo "restore exit=$?"
redis-cli -p 6380 -n 0 get __test_key__
redis-cli -p 6379 -n 0 del __test_key__ >/dev/null; redis-cli -p 6380 -n 0 del __test_key__ >/dev/null

17  $ python3 << 'EOF'
import redis
r = redis.Redis(port=6379, db=0)
v = redis.Redis(port=6380, db=0)
r.set('__t1__','hello')
payload = r.dump('__t1__')
print('payload footer (last 10 bytes):', payload[-10:].hex())
try:
    v.restore('__t1__', 0, payload)
    print('RESTORE OK ->', v.get('__t1__'))
except Exception as e:
    print('RESTORE FAILED:', e)
r.delete('__t1__'); 
try: v.delete('__t1__')
except: pass
EOF

18  $ # What RDB version does Valkey 9.1 emit?
python3 << 'EOF'
import redis
v = redis.Redis(port=6380, db=0)
v.set('__t2__','hello')
p = v.dump('__t2__')
print('valkey dump footer:', p[-10:].hex())
v.delete('__t2__')
EOF
echo "--- check valkey supported rdb version ---"
grep -riE "RDB_VERSION" /opt/redis-8.10/ 2>/dev/null | head
strings $(which valkey-server) 2>/dev/null | grep -iE "RDB_VERSION|rdb version" | head

19  $ # Force valkey to write an RDB and inspect its version
redis-cli -p 6380 set __probe__ x >/dev/null
redis-cli -p 6380 save
python3 -c "
d=open('/var/lib/valkey/dump.rdb','rb').read()
print('valkey rdb header:', d[:9])
"
redis-cli -p 6380 del __probe__ >/dev/null
echo "--- valkey config get dir ---"; redis-cli -p 6380 config get dir

20  $ # Try loading the redis 8.10 RDB into a throwaway valkey on a different port
mkdir -p /tmp/valtest
cp /var/lib/redis-old/dump.rdb /tmp/valtest/dump.rdb
valkey-server --port 6399 --dir /tmp/valtest --dbfilename dump.rdb --daemonize yes --logfile /tmp/valtest/v.log
sleep 1
redis-cli -p 6399 info keyspace
redis-cli -p 6399 ping
echo "--- log ---"; cat /tmp/valtest/v.log
redis-cli -p 6399 shutdown nosave 2>/dev/null

21  $ which redis-shake redis-shake-v2 redis-migrate 2>&1; pip list 2>/dev/null | grep -iE "shake|migrat"; echo "--- source unchanged check ---"; redis-cli -p 6379 -n 0 dbsize; redis-cli -p 6379 -n 2 dbsize; redis-cli -p 6380 dbsize

22  $ python3 << 'EOF'
import redis
r = redis.Redis(port=6379, db=0, decode_responses=False)
keys = r.keys('events:*')
print("stream keys:", [k.decode() for k in keys])
for k in keys[:3]:
    print("=====", k.decode())
    info = r.xinfo_stream(k)
    for kk,vv in info.items():
        if kk in ('first-entry','last-entry'): 
            print(" ", kk, vv)
        else:
            print(" ", kk, vv)
    try:
        groups = r.xinfo_groups(k)
        for g in groups:
            print("  GROUP:", g)
            cons = r.xinfo_consumers(k, g['name'])
            for c in cons:
                print("    CONSUMER:", c)
            pend = r.xpending_range(k, g['name'], '-', '+', 100)
            print("    PENDING count:", len(pend))
            for p in pend[:5]:
                print("      P:", p)
    except Exception as e:
        print("  no groups:", e)
EOF

23  $ echo "=== MODULES source ==="; redis-cli -p 6379 module list
echo "=== MODULES target ==="; redis-cli -p 6380 module list
echo "=== source dbsize all ==="; redis-cli -p 6379 info keyspace
echo "=== check for special keys ==="
redis-cli -p 6379 -n 0 --scan --count 10000 2>/dev/null | grep -E " " | cat -A | head

24  $ python3 << 'EOF'
import redis
for port,label in [(6379,'redis'),(6380,'valkey')]:
    r = redis.Redis(port=port, decode_responses=False)
    print("=====", label)
    print("dbsize:", r.dbsize())
    print("config maxmemory:", r.config_get('maxmemory'))
EOF

25  $ redis-cli -p 6379 -n 0 --scan --count 10000 2>/dev/null | while read k; do t=$(redis-cli -p 6379 -n 0 type "$k"); echo "$t"; done | sort | uniq -c
echo "=== db2 ==="
redis-cli -p 6379 -n 2 --scan --count 10000 2>/dev/null | while read k; do t=$(redis-cli -p 6379 -n 2 type "$k"); echo "$t"; done | sort | uniq -c
echo "=== object encoding of strings ==="
redis-cli -p 6379 -n 0 --scan --count 10000 2>/dev/null | head -2000 | while read k; do t=$(redis-cli -p 6379 -n 0 type "$k"); if [ "$t" = "string" ]; then redis-cli -p 6379 -n 0 object encoding "$k"; fi; done | sort | uniq -c

26  $ cat > /tmp/crc64.py << 'EOF'
POLY = 0xad93d23594c935a9
def bitrev(x, n=64):
    r = 0
    for _ in range(n):
        r = (r << 1) | (x & 1)
        x >>= 1
    return r
RPOLY = bitrev(POLY)
TABLE = []
for i in range(256):
    crc = i
    for _ in range(8):
        if crc & 1:
            crc = (crc >> 1) ^ RPOLY
        else:
            crc >>= 1
    TABLE.append(crc & 0xFFFFFFFFFFFFFFFF)
def crc64(data):
    crc = 0
    for b in data:
        crc = TABLE[(crc ^ b) & 0xFF] ^ (crc >> 8)
    return crc & 0xFFFFFFFFFFFFFFFF
if __name__ == '__main__':
    print(hex(crc64(b'123456789')))  # expect 0xe9c6d914c4b8d9ca
EOF
python3 /tmp/crc64.py

27  $ cd /tmp && python3 << 'EOF'
import redis, sys
sys.path.insert(0,'/tmp')
from crc64 import crc64

r = redis.Redis(port=6379, db=0)
v = redis.Redis(port=6380, db=0)

def rewrite(payload, newver=11):
    body = payload[:-10]
    ver = newver.to_bytes(2,'little')
    crc = crc64(body+ver).to_bytes(8,'little')
    return body+ver+crc

# string
r.set('__s__', 'hello world')
p = r.dump('__s__')
print('orig ver', int.from_bytes(p[-10:-8],'little'))
try:
    v.restore('__s__',0,rewrite(p)); print('string OK', v.get('__s__'))
except Exception as e: print('string FAIL', e)

# hash
r.delete('__h__'); r.hset('__h__', mapping={'a':'1','b':'2'})
p=r.dump('__h__')
try:
    v.restore('__h__',0,rewrite(p)); print('hash OK', v.hgetall('__h__'))
except Exception as e: print('hash FAIL', e)

# zset
r.delete('__z__'); r.zadd('__z__', {'a':1.5,'b':2})
p=r.dump('__z__')
try:
    v.restore('__z__',0,rewrite(p)); print('zset OK', v.zrange('__z__',0,-1,withscores=True))
except Exception as e: print('zset FAIL', e)

# stream
r.delete('__x__'); r.xadd('__x__', {'f':'v'}, id='1-1'); r.xadd('__x__', {'f':'v2'}, id='2-2')
p=r.dump('__x__')
try:
    v.restore('__x__',0,rewrite(p)); print('stream OK', v.xrange('__x__'))
except Exception as e: print('stream FAIL', e)

# cleanup
for k in ['__s__','__h__','__z__','__x__']:
    r.delete(k)
    try: v.delete(k)
    except: pass
EOF

28  $ python3 << 'EOF'
import redis
r = redis.Redis(port=6379, db=0, decode_responses=False)
r2 = redis.Redis(port=6379, db=2, decode_responses=False)
# check hash field TTL support and presence
for label,rr in [('db0',r),('db2',r2)]:
    keys = rr.keys('*')
    hkeys = [k for k in keys if rr.type(k)==b'hash']
    found=0
    for k in hkeys:
        try:
            f = rr.hrandfield(k)
            if f is None: continue
            ttl = rr.httl(k, f)
            if ttl not in (-1,-2):
                found+=1
                if found<=5: print(label, k, f, 'httl', ttl)
        except Exception as e:
            print('httl unsupported:', e); break
    print(label, 'hashes with field ttl:', found, '/', len(hkeys))
EOF

29  $ # Check command availability on both servers for stream reconstruction
for p in 6379 6380; do
echo "=== port $p ==="
redis-cli -p $p command info xsetid | head -1
redis-cli -p $p command info xgroup | head -1
redis-cli -p $p command info xclaim | head -1
redis-cli -p $p command info hpexpire | head -1
redis-cli -p $p command info hpttl | head -1
done

30  $ python3 << 'EOF'
import redis
total_fields=0; with_ttl=0
for db in (0,2):
    r = redis.Redis(port=6379, db=db, decode_responses=False)
    for k in r.keys('*'):
        if r.type(k)==b'hash':
            for f in r.hkeys(k):
                total_fields+=1
                t=r.httl(k,f)
                if t not in (-1,-2): with_ttl+=1
print("total hash fields:", total_fields, "with field TTL:", with_ttl)
EOF

31  $ python3 << 'EOF'
import redis
# inventory: TTLs distribution, sizes, special encodings
for db in (0,2):
    r = redis.Redis(port=6379, db=db, decode_responses=False)
    ttl_cnt=0
    maxlist=0; maxset=0; maxzset=0; maxhash=0; maxstr=0
    for k in r.keys('*'):
        t=r.ttl(k)
        if t>=0: ttl_cnt+=1
        ty=r.type(k)
        if ty==b'list': maxlist=max(maxlist, r.llen(k))
        elif ty==b'set': maxset=max(maxset, r.scard(k))
        elif ty==b'zset': maxzset=max(maxzset, r.zcard(k))
        elif ty==b'hash': maxhash=max(maxhash, r.hlen(k))
        elif ty==b'string': maxstr=max(maxstr, len(r.get(k)))
    print(f"db{db}: keys={r.dbsize()} with_ttl={ttl_cnt} maxlist={maxlist} maxset={maxset} maxzset={maxzset} maxhash={maxhash} maxstr={maxstr}")
EOF

32  $ redis-cli -p 6379 -n 0 hrandfield user:0142
echo "--- httl raw ---"
f=$(redis-cli -p 6379 -n 0 hrandfield user:0142)
redis-cli -p 6379 -n 0 httl user:0142 "$f"
redis-cli -p 6379 -n 0 hpttl user:0142 "$f"
echo "--- any hash with positive field ttl? ---"
python3 << 'EOF'
import redis
found=[]
for db in (0,2):
    r=redis.Redis(port=6379,db=db,decode_responses=False)
    for k in r.keys('*'):
        if r.type(k)==b'hash':
            res=r.execute_command('HPTTL',k,*r.hkeys(k))
            if isinstance(res,list):
                if any(x not in (-1,-2) for x in res):
                    found.append(k)
print("hashes with field ttl:", len(found))
EOF

33  $ python3 << 'EOF'
import redis
found=[]; total=0
for db in (0,2):
    r=redis.Redis(port=6379,db=db,decode_responses=False)
    for k in r.keys('*'):
        if r.type(k)==b'hash':
            fields=r.hkeys(k)
            total+=len(fields)
            res=r.execute_command('HPTTL',k,'FIELDS',len(fields),*fields)
            if any(x not in (-1,-2) for x in res):
                found.append(k)
print("total fields:", total, "hashes with field ttl:", len(found))
EOF

34  $ python3 << 'EOF'
import redis
r=redis.Redis(port=6379,db=0,decode_responses=False)
v=redis.Redis(port=6380,db=0,decode_responses=False)
for k in r.keys('*'):
    if r.type(k)==b'hash':
        fields=r.hkeys(k)
        res=r.execute_command('HPTTL',k,'FIELDS',len(fields),*fields)
        pos=[(f,t) for f,t in zip(fields,res) if t not in (-1,-2)]
        if pos:
            print(k, pos[:5], '...' if len(pos)>5 else '')
            # test valkey support
            try:
                v.hset(k, mapping={fields[0]: r.hget(k,fields[0])})
                v.execute_command('HPEXPIRE',k,1000,'FIELDS',1,fields[0])
                print("  valkey HPEXPIRE OK")
            except Exception as e:
                print("  valkey HPEXPIRE FAIL:", e)
            v.delete(k)
            break
EOF
echo "=== valkey hpexpire command ==="; redis-cli -p 6380 command info hpexpire; redis-cli -p 6380 command info hpttl

35  $ python3 << 'EOF'
import redis
r = redis.Redis(port=6379, db=0, decode_responses=False)
streams=[k for k in r.keys('*') if r.type(k)==b'stream']
print("num streams:", len(streams))
for k in sorted(streams):
    info=r.xinfo_stream(k)
    print(k.decode(), "len",info['length'],"last-gen",info['last-generated-id'],
          "max-del",info['max-deleted-entry-id'],"added",info['entries-added'],
          "rec-first",info['recorded-first-entry-id'],
          "first",info['first-entry'][0] if info['first-entry'] else None,
          "groups",info['groups'])
    for g in r.xinfo_groups(k):
        print("   grp",g['name'],"last-del",g['last-delivered-id'],"entries-read",g['entries-read'],"lag",g['lag'],"pel",g['pending'],"consumers",g['consumers'])
        for c in r.xinfo_consumers(k,g['name']):
            print("      cons",c['name'],"pending",c['pending'],"idle",c['idle'],"inactive",c.get('inactive'))
        pr=r.xpending_range(k,g['name'],'-','+',1000)
        for p in pr:
            print("      pel",p['message_id'],p['consumer'],p['time_since_delivered'],p['times_delivered'])
EOF

36  $ redis-cli -p 6380 help xsetid 2>&1 | head -20; echo "=== xclaim ==="; redis-cli -p 6380 help xclaim 2>&1 | head -40; echo "=== xgroup create ==="; redis-cli -p 6380 help xgroup 2>&1 | head -30

37  $ redis-cli -p 6380 help hpexpiretime 2>&1 | head; echo "==="; redis-cli -p 6379 help hpexpiretime 2>&1 | head; echo "=== pexpiretime ==="; redis-cli -p 6379 pexpiretime nokey 2>&1

38  $ cat > /tmp/migrate.py << 'PYEOF'
import redis, time, sys

SRC = redis.Redis(port=6379, decode_responses=False)
DST = redis.Redis(port=6380, decode_responses=False)

now_ms = int(time.time()*1000)

def src_db(n): return redis.Redis(port=6379, db=n, decode_responses=False)
def dst_db(n): return redis.Redis(port=6380, db=n, decode_responses=False)

stats = {}

def migrate_db(n):
    s = src_db(n); d = dst_db(n)
    keys = s.keys('*')
    for key in keys:
        t = s.type(key)
        t = t.decode()
        # ---- capture key-level expiry (absolute ms) ----
        pexp = s.execute_command('PEXPIRETIME', key)
        # ---- value ----
        if t == 'string':
            val = s.get(key)
            d.set(key, val)
        elif t == 'list':
            elems = s.lrange(key, 0, -1)
            if elems: d.rpush(key, *elems)
        elif t == 'set':
            members = s.smembers(key)
            if members: d.sadd(key, *members)
        elif t == 'zset':
            flat = s.execute_command('ZRANGE', key, 0, -1, 'WITHSCORES')
            args = []
            for i in range(0, len(flat), 2):
                args.append(flat[i+1]); args.append(flat[i])
            if args: d.execute_command('ZADD', key, *args)
        elif t == 'hash':
            h = s.hgetall(key)
            if h: d.hset(key, mapping=h)
            # ---- hash field-level expiry ----
            fields = list(h.keys())
            if fields:
                exps = s.execute_command('HPEXPIRETIME', key, 'FIELDS', len(fields), *fields)
                pairs = [(f, e) for f, e in zip(fields, exps) if e not in (-1, -2)]
                for f, e in pairs:
                    d.execute_command('HPEXPIREAT', key, e, 'FIELDS', 1, f)
        elif t == 'stream':
            migrate_stream(s, d, key)
        else:
            raise RuntimeError("unknown type %s for %r" % (t, key))
        # ---- apply key-level TTL ----
        if pexp not in (-1, -2):
            d.execute_command('PEXPIREAT', key, pexp)
        stats[t] = stats.get(t, 0) + 1

def migrate_stream(s, d, key):
    info = s.xinfo_stream(key)
    entries = s.xrange(key, '-', '+')
    for eid, fields in entries:
        args = []
        for k, v in fields.items():
            args.append(k); args.append(v)
        d.execute_command('XADD', key, eid, *args)
    # set stream metadata
    d.execute_command('XSETID', key, info['last-generated-id'],
                      'ENTRIESADDED', info['entries-added'],
                      'MAXDELETEDID', info['max-deleted-entry-id'])
    for g in s.xinfo_groups(key):
        er = g.get('entries-read')
        cmd = ['XGROUP', 'CREATE', key, g['name'], g['last-delivered-id']]
        if er is not None:
            cmd += ['ENTRIESREAD', er]
        d.execute_command(*cmd)
        for c in s.xinfo_consumers(key, g['name']):
            d.execute_command('XGROUP', 'CREATECONSUMER', key, g['name'], c['name'])
        pel = s.xpending_range(key, g['name'], '-', '+', 100000)
        for p in pel:
            deliver_time = now_ms - p['time_since_delivered']
            d.execute_command('XCLAIM', key, g['name'], p['consumer'], 0, p['message_id'],
                              'TIME', deliver_time, 'RETRYCOUNT', p['times_delivered'],
                              'FORCE', 'JUSTID')

for n in (0, 2):
    migrate_db(n)

print("migrated:", stats)
PYEOF
python3 /tmp/migrate.py

39  $ python3 << 'EOF'
import redis
s=redis.Redis(port=6379,db=0,decode_responses=False)
for k in s.keys('*'):
    if s.type(k)==b'zset':
        flat=s.execute_command('ZRANGE',k,0,-1,'WITHSCORES')
        print(k, type(flat), len(flat), flat[:4]); break
EOF

40  $ cd /tmp && python3 - << 'EOF'
import re
src = open('migrate.py').read()
old = """        elif t == 'zset':
            flat = s.execute_command('ZRANGE', key, 0, -1, 'WITHSCORES')
            args = []
            for i in range(0, len(flat), 2):
                args.append(flat[i+1]); args.append(flat[i])
            if args: d.execute_command('ZADD', key, *args)"""
new = """        elif t == 'zset':
            pairs = s.zrange(key, 0, -1, withscores=True)
            args = []
            for member, score in pairs:
                args.append(repr(score)); args.append(member)
            if args: d.execute_command('ZADD', key, *args)"""
assert old in src
src = src.replace(old, new)
open('migrate.py','w').write(src)
print("patched")
EOF
python3 /tmp/migrate.py

41  $ cd /tmp && python3 2>&1 << 'EOF' | tail -5
import redis, time
s=redis.Redis(port=6379,db=0,decode_responses=False)
d=redis.Redis(port=6380,db=0,decode_responses=False)
key=b'events:00'
info=s.xinfo_stream(key)
entries=s.xrange(key,'-','+')
for eid,fields in entries:
    args=[]
    for k,v in fields.items(): args+= [k,v]
    d.execute_command('XADD',key,eid,*args)
d.execute_command('XSETID',key,info['last-generated-id'],'ENTRIESADDED',info['entries-added'],'MAXDELETEDID',info['max-deleted-entry-id'])
g=s.xinfo_groups(key)[0]
print("group:",g)
cmd=['XGROUP','CREATE',key,g['name'],g['last-delivered-id']]
if g.get('entries-read') is not None: cmd+=['ENTRIESREAD',g['entries-read']]
print("create cmd:",cmd)
try:
    print(d.execute_command(*cmd))
except Exception as e:
    print("CREATE ERR:", e)
p=s.xpending_range(key,g['name'],'-','+',100000)[0]
print("pel:",p)
now_ms=int(time.time()*1000)
try:
    r=d.execute_command('XCLAIM',key,g['name'],p['consumer'],0,p['message_id'],'TIME',now_ms-p['time_since_delivered'],'RETRYCOUNT',p['times_delivered'],'FORCE','JUSTID')
    print("claim ok", r)
except Exception as e:
    print("CLAIM ERR:", repr(e))
EOF

42  $ cd /tmp && python3 2>&1 << 'EOF' | tail -20
import redis, time
s=redis.Redis(port=6379,db=0,decode_responses=False)
d=redis.Redis(port=6380,db=0,decode_responses=False)
key=b'events:00'
g=[x for x in s.xinfo_groups(key) if x['name']==b'workers'][0]
print("group:",g)
cmd=['XGROUP','CREATE',key,g['name'],g['last-delivered-id'],'ENTRIESREAD',g['entries-read']]
print("create:",d.execute_command(*cmd))
p=s.xpending_range(key,g['name'],'-','+',100000)[0]
print("pel:",p)
now_ms=int(time.time()*1000)
try:
    r=d.execute_command('XCLAIM',key,g['name'],p['consumer'],0,p['message_id'],'TIME',now_ms-p['time_since_delivered'],'RETRYCOUNT',p['times_delivered'],'FORCE','JUSTID')
    print("claim ok", r)
except Exception as e:
    print("CLAIM ERR:", repr(e))
EOF

43  $ cd /tmp && python3 2>&1 << 'EOF' | tail -20
import redis, time
s=redis.Redis(port=6379,db=0,decode_responses=False)
d=redis.Redis(port=6380,db=0,decode_responses=False)
d.set_response_callback('XCLAIM', lambda r: r)
d.flushall()
key=b'events:00'
info=s.xinfo_stream(key)
entries=s.xrange(key,'-','+')
for eid,fields in entries:
    args=[]
    for k,v in fields.items(): args+=[k,v]
    d.execute_command('XADD',key,eid,*args)
d.execute_command('XSETID',key,info['last-generated-id'],'ENTRIESADDED',info['entries-added'],'MAXDELETEDID',info['max-deleted-entry-id'])
g=[x for x in s.xinfo_groups(key) if x['name']==b'workers'][0]
d.execute_command('XGROUP','CREATE',key,g['name'],g['last-delivered-id'],'ENTRIESREAD',g['entries-read'])
p=s.xpending_range(key,g['name'],'-','+',100000)[0]
now_ms=int(time.time()*1000)
r=d.execute_command('XCLAIM',key,g['name'],p['consumer'],0,p['message_id'],'TIME',now_ms-p['time_since_delivered'],'RETRYCOUNT',p['times_delivered'],'FORCE','JUSTID')
print("claim ok", r)
print("dst pel:", d.xpending_range(key,g['name'],'-','+',100))
print("dst groups:", d.xinfo_groups(key))
d.flushall()
EOF

44  $ cd /tmp && python3 - << 'EOF'
src = open('migrate.py').read()
# add response callback after DST definition
src = src.replace(
"DST = redis.Redis(port=6380, decode_responses=False)",
"DST = redis.Redis(port=6380, decode_responses=False)\nDST.set_response_callback('XCLAIM', lambda r: r)"
)
# ensure empty consumers created even with no PEL; also guard empty entries
open('migrate.py','w').write(src)
print("ok")
EOF
# clean target fully before run
redis-cli -p 6380 flushall
python3 /tmp/migrate.py

45  $ cd /tmp && python3 - << 'EOF'
src = open('migrate.py').read()
src = src.replace(
"def dst_db(n): return redis.Redis(port=6380, db=n, decode_responses=False)",
"""def dst_db(n):
    c = redis.Redis(port=6380, db=n, decode_responses=False)
    c.set_response_callback('XCLAIM', lambda r: r)
    return c"""
)
open('migrate.py','w').write(src)
print("ok")
EOF
redis-cli -p 6380 flushall
python3 /tmp/migrate.py

46  $ echo "=== keyspace src ==="; redis-cli -p 6379 info keyspace
echo "=== keyspace dst ==="; redis-cli -p 6380 info keyspace

47  $ python3 << 'EOF'
import redis
src=redis.Redis(port=6379,decode_responses=False)
dst=redis.Redis(port=6380,decode_responses=False)
for n in (0,2):
    s=redis.Redis(port=6379,db=n,decode_responses=False)
    d=redis.Redis(port=6380,db=n,decode_responses=False)
    sk=set(s.keys('*')); dk=set(d.keys('*'))
    print(f"db{n}: src={len(sk)} dst={len(dk)} missing={len(sk-dk)} extra={len(dk-sk)}")
    # type check
    tmis=0
    for k in sk:
        if s.type(k)!=d.type(k): tmis+=1
    print("  type mismatches:", tmis)
EOF

48  $ python3 << 'EOF'
import redis
mismatches=[]
def cmp_db(n):
    s=redis.Redis(port=6379,db=n,decode_responses=False)
    d=redis.Redis(port=6380,db=n,decode_responses=False)
    for k in s.keys('*'):
        t=s.type(k)
        if t==b'string':
            if s.get(k)!=d.get(k): mismatches.append((n,k,'string'))
        elif t==b'list':
            if s.lrange(k,0,-1)!=d.lrange(k,0,-1): mismatches.append((n,k,'list'))
        elif t==b'set':
            if s.smembers(k)!=d.smembers(k): mismatches.append((n,k,'set'))
        elif t==b'zset':
            if s.zrange(k,0,-1,withscores=True)!=d.zrange(k,0,-1,withscores=True): mismatches.append((n,k,'zset'))
        elif t==b'hash':
            if s.hgetall(k)!=d.hgetall(k): mismatches.append((n,k,'hash'))
        elif t==b'stream':
            if s.xrange(k,'-','+')!=d.xrange(k,'-','+'):
                mismatches.append((n,k,'stream-entries'))
            si=s.xinfo_stream(k); di=d.xinfo_stream(k)
            for f in ('last-generated-id','max-deleted-entry-id','entries-added','length'):
                if si[f]!=di[f]: mismatches.append((n,k,'stream-meta-'+f, si[f], di[f]))
        # TTL check (allow 2s drift)
        st=s.ttl(k); dt=d.ttl(k)
        if st>=0:
            if abs(st-dt)>2: mismatches.append((n,k,'ttl',st,dt))
        else:
            if dt!=-1: mismatches.append((n,k,'ttl-should-be-none',st,dt))
cmp_db(0); cmp_db(2)
print("total mismatches:", len(mismatches))
for m in mismatches[:50]: print(m)
EOF

49  $ python3 << 'EOF'
import redis, time
now=int(time.time()*1000)
mis=[]
for n in (0,2):
    s=redis.Redis(port=6379,db=n,decode_responses=False)
    d=redis.Redis(port=6380,db=n,decode_responses=False)
    for k in s.keys('*'):
        if s.type(k)!=b'hash': continue
        fields=s.hkeys(k)
        if not fields: continue
        se=s.execute_command('HPEXPIRETIME',k,'FIELDS',len(fields),*fields)
        de=d.execute_command('HPEXPIRETIME',k,'FIELDS',len(fields),*fields)
        for f,a,b in zip(fields,se,de):
            if a==-1:
                if b!=-1: mis.append((n,k,f,'field-should-have-no-ttl',a,b))
            else:
                if abs(a-b)>2000: mis.append((n,k,f,'field-ttl',a,b))
print("hash field ttl mismatches:", len(mis))
for m in mis[:30]: print(m)
EOF

50  $ python3 << 'EOF'
import redis
mis=[]
for n in (0,2):
    s=redis.Redis(port=6379,db=n,decode_responses=False)
    d=redis.Redis(port=6380,db=n,decode_responses=False)
    for k in s.keys('*'):
        if s.type(k)!=b'stream': continue
        sg={g['name']:g for g in s.xinfo_groups(k)}
        dg={g['name']:g for g in d.xinfo_groups(k)}
        if set(sg)!=set(dg): mis.append((k,'groups',set(sg),set(dg))); continue
        for name in sg:
            a=sg[name]; b=dg[name]
            for f in ('last-delivered-id','entries-read','lag','pending'):
                if a[f]!=b[f]: mis.append((k,name,f,a[f],b[f]))
            sc={c['name']:c for c in s.xinfo_consumers(k,name)}
            dc={c['name']:c for c in d.xinfo_consumers(k,name)}
            if set(sc)!=set(dc): mis.append((k,name,'consumers',set(sc),set(dc)))
            else:
                for cn in sc:
                    if sc[cn]['pending']!=dc[cn]['pending']: mis.append((k,name,cn,'consumer-pending',sc[cn]['pending'],dc[cn]['pending']))
            sp=s.xpending_range(k,name,'-','+',100000)
            dp=d.xpending_range(k,name,'-','+',100000)
            if len(sp)!=len(dp): mis.append((k,name,'pel-len',len(sp),len(dp)))
            else:
                for p,q in zip(sp,dp):
                    if p['message_id']!=q['message_id'] or p['consumer']!=q['consumer'] or p['times_delivered']!=q['times_delivered']:
                        mis.append((k,name,'pel-entry',p,q))
                    if abs(p['time_since_delivered']-q['time_since_delivered'])>3000:
                        mis.append((k,name,'pel-idle',p['message_id'],p['time_since_delivered'],q['time_since_delivered']))
print("stream state mismatches:", len(mis))
for m in mis[:40]: print(m)
EOF

51  $ python3 << 'EOF'
import redis
for n in (0,):
    s=redis.Redis(port=6379,db=n,decode_responses=False)
    d=redis.Redis(port=6380,db=n,decode_responses=False)
    for k in s.keys('events:00','events:01'):
        for gname in [g['name'] for g in s.xinfo_groups(k)]:
            sc={c['name']:c for c in s.xinfo_consumers(k,gname)}
            dc={c['name']:c for c in d.xinfo_consumers(k,gname)}
            for cn in sc:
                print(k, gname, cn, "src idle",sc[cn]['idle'],"dst idle",dc[cn]['idle'])
EOF

52  $ echo "=== target replication ==="; redis-cli -p 6380 info replication
echo "=== target accepts write ==="; redis-cli -p 6380 set __wtest__ 1; redis-cli -p 6380 get __wtest__; redis-cli -p 6380 del __wtest__
echo "=== source replication (should stay) ==="; redis-cli -p 6379 info replication | head -5
echo "=== source keyspace now ==="; redis-cli -p 6379 info keyspace
echo "=== leftover test keys? ==="; redis-cli -p 6379 -n 0 --scan --count 10000 2>/dev/null | grep -E "^__" ; redis-cli -p 6380 -n 0 --scan --count 10000 2>/dev/null | grep -E "^__"; echo "(none above = clean)"

53  $ python3 << 'EOF'
import redis
s=redis.Redis(port=6379,db=0,decode_responses=False)
d=redis.Redis(port=6380,db=0,decode_responses=False)
bad=0
for k in s.keys('events:*'):
    for gname in [g['name'] for g in s.xinfo_groups(k)]:
        sc={c['name']:c for c in s.xinfo_consumers(k,gname)}
        dc={c['name']:c for c in d.xinfo_consumers(k,gname)}
        if set(sc)!=set(dc): print("consumer set mismatch",k,gname); bad+=1; continue
        for cn in sc:
            si,di=sc[cn]['idle'],dc[cn]['idle']
            if abs(si-di)>3000:
                print("idle drift",k,gname,cn,si,di); bad+=1
print("consumer idle issues:",bad)
EOF

54  $ # Full integrity: run valkey's own consistency check & re-confirm dbsize parity via redis-cli
for p in 6379 6380; do echo "port $p db0 dbsize:"; redis-cli -p $p -n 0 dbsize; echo "port $p db2 dbsize:"; redis-cli -p $p -n 2 dbsize; done
echo "=== check all databases on target (db0..db15) ==="
for db in $(seq 0 15); do n=$(redis-cli -p 6380 -n $db dbsize); echo "db$db=$n"; done

55  $ cd /tmp && python3 2>&1 << 'EOF'
import redis, time, struct
v=redis.Redis(port=6380,db=1,decode_responses=False)
v.flushdb()
# build stream with a consumer holding a PEL entry
v.xadd('s', {'f':'v'}, id='1-1')
v.xadd('s', {'f':'v'}, id='2-2')
v.xgroup_create('s','g','0')
v.xreadgroup('g','c1',{'s':'>'})  # creates consumer c1, PEL 2 entries
v.set_response_callback('XCLAIM', lambda r:r)
info=v.xinfo_consumers('s','g')
print("consumers:", info)
p=v.dump('s')
print("payload len:", len(p))
# search for consumer seen_time / active_time near now
now=int(time.time()*1000)
# scan 8-byte little endian values within +/- 5 sec of now
found=[]
for i in range(len(p)-8):
    val=struct.unpack('<Q', p[i:i+8])[0]
    if abs(val-now)<5000:
        found.append((i,val,now-val))
print("candidate mstime offsets:", found)
print("hex:", p.hex())
v.flushdb()
EOF

56  $ python3 -c "
d=open('/var/lib/valkey/dump.rdb','rb').read()
print('valkey header 10 bytes:', d[:10])
print('version digits:', d[6:10])
"
echo "--- valkey strings for RDB_VERSION ---"
strings $(which valkey-server) | grep -iE "^RDB|rdb-version|Can't handle RDB" | head
echo "--- redis strings ---"
strings /opt/redis-8.10/bin/redis-server | grep -iE "Can't handle RDB|RDB format" | head

57  $ cd /tmp && python3 << 'EOF'
import sys; sys.path.insert(0,'/tmp')
from crc64 import crc64
d=bytearray(open('/var/lib/redis-old/dump.rdb','rb').read())
print("orig header:", bytes(d[:9]))
# patch version to 11
d[5:9]=b'0011'
body=bytes(d[:-8])
crc=crc64(body).to_bytes(8,'little')
d[-8:]=crc
open('/tmp/patched.rdb','wb').write(bytes(d))
print("patched header:", bytes(d[:9]))
EOF
mkdir -p /tmp/vt2 && cp /tmp/patched.rdb /tmp/vt2/dump.rdb
valkey-server --port 6398 --dir /tmp/vt2 --dbfilename dump.rdb --daemonize yes --logfile /tmp/vt2/v.log
sleep 1
redis-cli -p 6398 info keyspace 2>&1
echo "--- log tail ---"; tail -6 /tmp/vt2/v.log
redis-cli -p 6398 shutdown nosave 2>/dev/null

58  $ echo "=== leftover test keys on source ==="; redis-cli -p 6379 -n 0 --scan --count 20000 2>/dev/null | grep -E "^__(test|t|s|h|z|x|wtest)" ; echo "(none = clean)"
echo "=== leftover on target ==="; redis-cli -p 6380 -n 0 --scan --count 20000 2>/dev/null | grep -E "^__"; echo "(none = clean)"
echo "=== persist target ==="; redis-cli -p 6380 save; redis-cli -p 6380 info persistence | grep -E "rdb_last_bgsave_status|rdb_last_save_time"
echo "=== target role ==="; redis-cli -p 6380 info replication | grep -E "^role"
echo "=== source untouched role ==="; redis-cli -p 6379 info replication | grep -E "^role"
echo "=== source keyspace ==="; redis-cli -p 6379 info keyspace
echo "=== target keyspace ==="; redis-cli -p 6380 info keyspace

59  $ redis-cli -p 6380 config get replicaof; redis-cli -p 6380 config get min-replicas-to-write; redis-cli -p 6380 config get appendonly
echo "--- write test (simulating app) ---"
redis-cli -p 6380 set app:probe ok; redis-cli -p 6380 append app:probe "!"; redis-cli -p 6380 get app:probe
redis-cli -p 6380 lpush app:list a b c >/dev/null; redis-cli -p 6380 lrange app:list 0 -1
redis-cli -p 6380 del app:probe app:list >/dev/null
echo "--- final parity ---"
for p in 6379 6380; do echo -n "port $p: "; redis-cli -p $p -n 0 dbsize | tr '\n' ' '; redis-cli -p $p -n 2 dbsize; done

{
 "examples": {},
 "keys_new": {
  "0": 2960,
  "2": 350
 },
 "keys_old": {
  "0": 2960,
  "2": 350
 },
 "mismatch_counts": {
  "extra": 0,
  "field_ttl_added": 0,
  "field_ttl_drift": 0,
  "field_ttl_lost": 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": "8.10.2",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

1  $ ps auxww | grep -iE 'redis|valkey' | grep -v grep; echo '---'; ls -la /opt/redis-8.10/bin; echo '---'; ls -la /etc/redis-old /etc/valkey

2  $ command -v redis-cli valkey-cli redis-server valkey-server; echo '---'; redis-cli --version 2>/dev/null; valkey-cli --version 2>/dev/null

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

4  $ /opt/redis-8.10/bin/redis-cli -p 6379 INFO server | head -25; echo '==='; valkey-cli -p 6380 INFO server | head -25

5  $ /opt/redis-8.10/bin/redis-cli -p 6379 INFO keyspace; echo '===dbsize==='; /opt/redis-8.10/bin/redis-cli -p 6379 DBSIZE; echo '===cluster==='; /opt/redis-8.10/bin/redis-cli -p 6379 CLUSTER INFO 2>&1 | head -3

6  $ valkey-cli -p 6380 INFO keyspace; valkey-cli -p 6380 DBSIZE; echo '==='; valkey-cli -p 6380 CONFIG GET databases save appendonly

7  $ R=/opt/redis-8.10/bin/redis-cli; V=valkey-cli
for db in 0 2; do
  echo "== source db$db type breakdown =="
  $R -p 6379 -n $db --scan | head -0
  for t in string list set hash zset stream none; do
    n=$($R -p 6379 -n $db --scan --type $t 2>/dev/null | wc -l)
    [ "$n" -gt 0 ] && echo "  $t: $n"
  done
done
echo '== modules on source =='; $R -p 6379 MODULE LIST
echo '== functions on source =='; $R -p 6379 FUNCTION LIST
echo '== valkey functions =='; $V -p 6380 FUNCTION LIST

8  $ R=/opt/redis-8.10/bin/redis-cli
echo '== streams with groups (source) =='
for k in $($R -p 6379 -n 0 --scan --type stream; $R -p 6379 -n 2 --scan --type stream); do
  echo "key=$k db=?"; $R -p 6379 XINFO GROUPS "$k" 2>/dev/null | grep -E 'name|pending|last-delivered|entries-read'
done

9  $ R=/opt/redis-8.10/bin/redis-cli
$R -p 6379 --scan | head -5
echo '--- help scan opts ---'
$R --help 2>&1 | grep -iE 'scan|type|big' | head -20

10  $ R=/opt/redis-8.10/bin/redis-cli
for db in 0 2; do
  echo "== db$type histogram db$db =="
  $R -p 6379 -n $db --scan | while read -r k; do $R -p 6379 -n $db --raw TYPE "$k"; done | sort | uniq -c
done

11  $ R=/opt/redis-8.10/bin/redis-cli
for k in $($R -p 6379 --scan --type stream); do
  echo "key=$k"
  $R -p 6379 --raw XINFO STREAM "$k" | grep -A1 -iE 'length|groups|last-generated' | head -8
  $R -p 6379 --raw XINFO GROUPS "$k" | grep -E '^[a-z-]+$|^name$|^pending$' | head -12
done

12  $ R=/opt/redis-8.10/bin/redis-cli
$R -p 6379 --raw COMMAND INFO VADD VEMB VDIM VCARD VSIM VGETATTR VRANDMEMBER 2>&1 | head -30
echo '--- vectorset sample keys ---'
$R -p 6379 --scan | while read -r k; do t=$($R -p 6379 --raw TYPE "$k"); if [ "$t" = "vectorset" ]; then echo "$k"; fi; done | head -10

13  $ cd /tmp
R=/opt/redis-8.10/bin/redis-cli
$R -p 6379 --scan > /tmp/keys_db0.txt
wc -l /tmp/keys_db0.txt
> /tmp/types_db0.txt
while read -r k; do printf '%s %s\n' "$($R -p 6379 --raw TYPE "$k")" "$k"; done < /tmp/keys_db0.txt > /tmp/types_db0.txt
awk '{print $1}' /tmp/types_db0.txt | sort | uniq -c
echo '--- vectorset keys ---'
grep '^vectorset' /tmp/types_db0.txt | head
echo '--- stream keys ---'
grep '^stream' /tmp/types_db0.txt

14  $ R=/opt/redis-8.10/bin/redis-cli
for k in $(grep '^stream' /tmp/types_db0.txt | awk '{print $2}'); do
  len=$($R -p 6379 --raw XLEN "$k")
  g=$($R -p 6379 --raw XINFO GROUPS "$k" | grep -A0 -c '')
  echo "== $k len=$len groups =="
  $R -p 6379 --raw XINFO GROUPS "$k"
done 2>&1 | head -60

15  $ R=/opt/redis-8.10/bin/redis-cli
echo '=== MIGRATE availability on source ==='
$R -p 6379 COMMAND INFO MIGRATE COPY REPLACE AUTH AUTH2 KEYS 2>&1 | head -5
echo '=== test DUMP/RESTORE on one string ==='
k=$($R -p 6379 --scan | head -1); echo "key=$k"
$R -p 6379 DUMP "$k" | head -c 60 | xxd | head -2
echo '=== sync/write perms on target ==='
valkey-cli -p 6380 SET __migtest ok; valkey-cli -p 6380 GET __migtest; valkey-cli -p 6380 DEL __migtest
echo '=== RDB save capability on source ==='
$R -p 6379 CONFIG GET dir; ls -la /var/lib/redis-old

16  $ R=/opt/redis-8.10/bin/redis-cli; V=valkey-cli
# Test: DUMP a string from source, RESTORE into target, compare
k=session:00074
$R -p 6379 DUMP "$k" > /tmp/p.bin
$V -p 6380 -x RESTORE __migtest 0 < /tmp/p.bin
echo "target type: $($V -p 6380 TYPE __migtest)"
echo "src : $($R -p 6379 --raw GET "$k")"
echo "dst : $($V -p 6380 --raw GET __migtest)"
$V -p 6380 DEL __migtest
echo '--- hash with field TTL test ---'
hk=$(grep '^hash' /tmp/types_db0.txt | head -1 | awk '{print $2}')
echo "hkey=$hk"; $R -p 6379 HRANDFIELD "$hk" withvalues 2; $R -p 6379 HTTL "$hk" FIELDS 3 $($R -p 6379 --raw HKEYS "$hk" | head -3)

17  $ V=valkey-cli
echo '=== try valkey-cli --rdb sync FROM redis 8.10 source ==='
timeout 30 valkey-cli -p 6379 --rdb /tmp/test_sync.rdb 2>&1 | head -20
ls -la /tmp/test_sync.rdb 2>/dev/null
echo '=== also test with source redis-cli for comparison ==='
timeout 30 /opt/redis-8.10/bin/redis-cli -p 6379 --rdb /tmp/test_sync2.rdb 2>&1 | head -5
ls -la /tmp/test_sync2.rdb 2>/dev/null

18  $ head -c 9 /tmp/test_sync.rdb | od -c | head -2
echo '--- source INFO persistence (rdb bits) ---'
/opt/redis-8.10/bin/redis-cli -p 6379 INFO persistence | grep -iE 'rdb|aof' | head -8
echo '--- valkey supported rdb version ---'
valkey-cli -p 6380 INFO persistence | grep -iE 'rdb' | head -8

19  $ mkdir -p /tmp/vtest && cp /tmp/test_sync.rdb /tmp/vtest/dump.rdb
valkey-server --port 6390 --bind 127.0.0.1 --dir /tmp/vtest --daemonize yes --pidfile /tmp/vtest/pid --logfile /tmp/vtest/log --dbfilename dump.rdb --appendonly no 2>&1 | head -5
sleep 2
valkey-cli -p 6390 DBSIZE 2>&1
tail -5 /tmp/vtest/log

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

21  $ cd /tmp
R=/opt/redis-8.10/bin/redis-cli
# find all hash fields with finite TTL (subexpiry)
> /tmp/httlf.txt
while read -r k; do
  flds=$($R -p 6379 --raw HKEYS "$k")
  for f in $flds; do
    t=$($R -p 6379 --raw HTTL "$k" FIELDS 1 "$f")
    [ "$t" -ge 0 ] && printf '%s|%s|%s\n' "$k" "$f" "$t" >> /tmp/httlf.txt
  done
done < <(awk '$1=="hash"{print $2}' /tmp/types_db0.txt)
echo "fields with TTL: $(wc -l < /tmp/httlf.txt)"
head -5 /tmp/httlf.txt; echo '...'; tail -3 /tmp/httlf.txt

22  $ cd /tmp && python3 - <<'EOF'
import redis
s = redis.Redis(host='127.0.0.1', port=6379, db=0, decode_responses=False)
t = redis.Redis(host='127.0.0.1', port=6380, db=0, decode_responses=False)
k = b'session:00074'
p = s.dump(k)
print('payload len', len(p), 'head', p[:12])
try:
    print('RESTORE ->', t.restore('__migtest2', 0, p, replace=True))
except Exception as e:
    print('RESTORE ERR:', type(e).__name__, e)
print('src :', s.get(k))
print('dst :', t.get('__migtest2'))
print('equal:', s.get(k) == t.get('__migtest2'))
t.delete('__migtest2')

# hash with field-level expiry
hk = b'user:0077'
print('HGETALL src:', s.hgetall(hk))
try:
    print('HTTL:', s.execute_command('HTTL', hk, 'FIELDS', 2, b'reset_token', b'otp'))
except Exception as e:
    print('HTTL err', e)
EOF

23  $ cd /tmp && python3 - <<'EOF'
import redis
s = redis.Redis(host='127.0.0.1', port=6379, db=0, decode_responses=False)
t = redis.Redis(host='127.0.0.1', port=6380, db=0, decode_responses=False)

val = b'hello-world-test'
s.set(b'__cmp', val); t.set(b'__cmp', val)
ps, pt = s.dump(b'__cmp'), t.dump(b'__cmp')
print('redis810 dump:', ps.hex())
print('valkey91 dump:', pt.hex())
print('same:', ps == pt, '| lens:', len(ps), len(pt))

# list comparison
s.rpush(b'__l', b'a', b'b', b'c'); t.rpush(b'__l', b'a', b'b', b'c')
print('list dumps equal:', s.dump(b'__l') == t.dump(b'__l'))
s.delete(b'__l'); t.delete(b'__l')

# does DUMP have extra args on source? (e.g. WITHVERSION)
for c in (s, t):
    info = c.execute_command('COMMAND', 'INFO', 'DUMP')
    print('DUMP args:', info)
s.delete(b'__cmp'); t.delete(b'__cmp')
EOF

24  $ cd /tmp && python3 - <<'EOF'
import redis, struct

s = redis.Redis(port=6379, db=0, decode_responses=False)
t = redis.Redis(port=6380, db=0, decode_responses=False)

def zero_cksum(p):
    # zero out trailing 8-byte checksum (RDB 'checksum disabled' path)
    return p[:-8] + b'\x00'*8

def recode(p, newver):
    # payload: [object bytes][version byte][8-byte crc64]
    body, ver, ck = p[:-9], p[-9:-8], p[-8:]
    return body + newver + b'\x00'*8

k = b'session:00074'
p_src = s.dump(k)
print('src ver byte:', hex(p_src[-9]), '| valkey-target dump would need ver 0x50')

# test 1: zeroed checksum, version byte replaced
for ver in (b'\x50', b'\x0f'):
    try:
        r = t.restore(b'__rt', 0, recode(p_src, ver), replace=True)
        print(f'ver={ver.hex()} zeroed-cksum RESTORE ->', r)
        print('   value ok:', s.get(k) == t.get(b'__rt'))
        t.delete(b'__rt')
    except Exception as e:
        print(f'ver={ver.hex()} ERR:', e)

# check crc64 assumption: does valkey restore its own payload if we just recompute? skip - test with valkey's own
k2=b'__selftest'; t.set(k2,b'hello')
pv = t.dump(k2)
try:
    t.restore(b'__rt2', 0, pv, replace=True); print('valkey self-restore OK')
except Exception as e: print('valkey self-restore ERR', e)
t.delete(k2, b'__rt2')
EOF

25  $ cd /tmp && python3 - <<'EOF'
import redis, struct

s = redis.Redis(port=6379, db=0, decode_responses=False)
t = redis.Redis(port=6380, db=0, decode_responses=False)

def parse(p):
    return p[:-10], struct.unpack('<H', p[-10:-8])[0], p[-8:]

k = b'session:00074'
ps = s.dump(k)
body, ver, ck = parse(ps)
print(f'src: body={len(body)}B ver={ver} cksum={ck.hex()}')

def recode(p, newver, zero=True):
    b, v, c = parse(p)
    return b + struct.pack('<H', newver) + (b'\x00'*8 if zero else c)

# Test A: keep ver 15, zero checksum
# Test B: rewrite ver to 80, zero checksum
for label, payload in [('ver15/zero-ck', recode(ps,15)), ('ver80/zero-ck', recode(ps,80))]:
    try:
        t.restore(b'__rt', 0, payload, replace=True)
        print(f'{label}: OK, value match={s.get(k)==t.get(b"__rt")}')
        t.delete(b'__rt')
    except Exception as e:
        print(f'{label}: ERR {e}')
EOF

26  $ cd /tmp && python3 - <<'EOF'
import redis, struct
t = redis.Redis(port=6380, db=0, decode_responses=False)
t.set(b'__ck', b'hello')
p = t.dump(b'__ck')
print('native payload:', p.hex())
try:
    t.restore(b'__ck2', 0, p[:-8]+b'\x00'*8, replace=True); print('zero-ck on NATIVE valkey payload: OK (checksum optional)')
except Exception as e: print('zero-ck on NATIVE valkey payload: ERR', e, '=> checksum always verified')
t.delete(b'__ck', b'__ck2')
EOF

27  $ cd /tmp && python3 - <<'EOF'
import redis, struct
t = redis.Redis(port=6380, db=0, decode_responses=False)
t.set(b'__ck', b'hello')
p = t.dump(b'__ck')
stored = p[-8:]

POLY = 0x42F0E1EBA9EA3693
def crc64(data, crc=0):
    for b in data:
        crc ^= b
        for _ in range(8):
            crc = (crc >> 1) ^ (POLY & (-(crc & 1) & 0xFFFFFFFFFFFFFFFF))
    return crc

body = p[:-8]
c_zero = crc64(body + b'\x00'*8)
print('stored   :', stored.hex())
print('computed0:', struct.pack('<Q', c_zero).hex())
c_off = crc64(body)
print('computed-off:', struct.pack('<Q', c_off).hex())
match = struct.pack('<Q', c_zero) == stored
print('matches stored:', match)
t.delete(b'__ck')
EOF

28  $ cd /tmp && python3 - <<'EOF'
import struct
t = __import__('redis').Redis(port=6380, decode_responses=False)
t.set(b'__ck', b'hello')
p = t.dump(b'__ck')
stored = p[-8:]; body = p[:-8]
t.delete(b'__ck')

def crc(data, poly):
    crc = 0
    for b in data:
        crc ^= b
        for _ in range(8):
            crc = (crc >> 1) ^ (poly & (-(crc & 1) & 0xFFFFFFFFFFFFFFFF))
    return crc & 0xFFFFFFFFFFFFFFFF

polys = {'0x42F0E1EBA9EA3693': 0x42F0E1EBA9EA3693, 'refl 0xC96C5795D7870F42': 0xC96C5795D7870F42}
for pn, poly in polys.items():
    for label, data in [('body', body), ('body+8zero', body + b'\x00'*8)]:
        c = crc(data, poly)
        for en, pack in [('LE', struct.pack('<Q', c)), ('BE', struct.pack('>Q', c))]:
            if pack == stored:
                print(f'MATCH  poly={pn} input={label} endian={en}')
print('stored:', stored.hex())
EOF

29  $ find / -name 'crc64*' -o -name '*crc64*.c' 2>/dev/null | head; ls /usr/include | grep -i crc; python3 -c "import google_crc64" 2>&1 | head -1
pip list 2>/dev/null | grep -i crc
echo '--- try python-libcrc / other ---'
pip download google_crc64 2>&1 | tail -1

30  $ apt list --installed 2>/dev/null | grep -iE 'crc|zlib' | head
ldconfig -p 2>/dev/null | grep -i crc
find / -name 'libvalkey*' -o -name 'hiredis*' 2>/dev/null | head
python3 -c "
import ctypes
try:
    lib=ctypes.CDLL('libcrc64.so'); print('libcrc64 ok')
except OSError as e: print('no libcrc64:', e)
"

31  $ cd /tmp && python3 - <<'EOF'
import redis, struct

rs = redis.Redis(port=6379); vs = redis.Redis(port=6380)
rs.set(b'__x', b'hello'); vs.set(b'__x', b'hello')
pr, pv = rs.dump(b'__x'), vs.dump(b'__x')
print('redis  body:', pr[:-8].hex(), 'ck:', pr[-8:].hex())
print('valkey body:', pv[:-8].hex(), 'ck:', pv[-8:].hex())

def crc_refl(data, poly=0xC96C5795D7870F42, init=0, xorout=0):
    crc = init
    for b in data:
        crc ^= b
        for _ in range(8):
            crc = ((crc >> 1) ^ poly) if (crc & 1) else (crc >> 1)
    return crc ^ xorout

for name, p in (('redis', pr), ('valkey', pv)):
    body = p[:-8]
    want = p[-8:]
    hits = []
    for pn, poly in (('ECMA-refl', 0xC96C5795D7870F42), ('ISO-refl', 0xD343DD7D78D34C21)):
        for label, data in (('body', body), ('body+z8', body + b'\x00'*8)):
            for init in (0, 0xFFFFFFFFFFFFFFFF):
                for xo in (0, 0xFFFFFFFFFFFFFFFF):
                    c = crc_refl(data, poly, init, xo)
                    for en, pack in (('LE', struct.pack('<Q', c)), ('BE', struct.pack('>Q', c))):
                        if pack == want: hits.append((pn, label, hex(init), hex(xo), en))
    print(name, 'matches:', hits)
rs.delete(b'__x'); vs.delete(b'__x')
EOF

32  $ cd /tmp && python3 - <<'EOF'
import redis, struct
rs = redis.Redis(port=6379); vs = redis.Redis(port=6380)
rs.set(b'__x', b'hello'); vs.set(b'__x', b'hello')
pr, pv = rs.dump(b'__x'), vs.dump(b'__x')
rs.delete(b'__x'); vs.delete(b'__x')
M = 0xFFFFFFFFFFFFFFFF

def crc_msb(data, poly, init=0, xorout=0):
    c = init
    for b in data:
        c ^= (b << 56)
        for _ in range(8):
            c = ((c << 1) ^ poly) & M if (c & (1 << 63)) else (c << 1) & M
    return c ^ xorout

def crc_lsb(data, poly, init=0, xorout=0):
    c = init
    for b in data:
        c ^= b
        for _ in range(8):
            c = ((c >> 1) ^ poly) if (c & 1) else (c >> 1)
    return c ^ xorout

tests = [
 ('MSB ECMA poly 42F0..', crc_msb, 0x42F0E1EBA9EA3693),
 ('LSB refl C96C..', crc_lsb, 0xC96C5795D7870F42),
]
for name, p in (('redis', pr), ('valkey', pv)):
    body, want = p[:-8], p[-8:]
    hits = []
    for tn, fn, poly in tests:
        for inlabel, data in (('body', body), ('body+z8', body + b'\x00'*8)):
            for ini in (0, M):
                for xo in (0, M):
                    c = fn(data, poly, ini, xo)
                    for en, pack in (('LE', struct.pack('<Q', c)), ('BE', struct.pack('>Q', c))):
                        if pack == want:
                            hits.append((tn, inlabel, hex(ini), hex(xo), en))
    print(f'{name} hits: {hits}')
    print(f'  {name} stored ck: {want.hex()}')
EOF

33  $ cd /tmp && python3 - <<'EOF'
import redis, struct
vs = redis.Redis(port=6380); rs = redis.Redis(port=6379)
vs.set(b'__x', b'hello'); rs.set(b'__x', b'hello')
pv, pr = vs.dump(b'__x'), rs.dump(b'__x')
vs.delete(b'__x'); rs.delete(b'__x')

M64 = 0xFFFFFFFFFFFFFFFF
POLY = 0xad93d23594c935a9
def reflect64(v):
    r = 0
    for i in range(64):
        r = (r << 1) | ((v >> i) & 1)
    return r
def crc64raw(crc, data):
    for c in data:
        for i in range(8):
            bit = (crc >> 63) & 1
            if c & (1 << i):
                bit ^= 1
            crc = (crc << 1) & M64
            if bit:
                crc ^= POLY
    return reflect64(crc)

for name, p in (('valkey', pv), ('redis', pr)):
    body, stored = p[:-8], p[-8:]
    for init in (0, M64):
        c = crc64raw(init, body)
        if struct.pack('<Q', c) == stored:
            print(f'{name}: MATCH with init={hex(init)} -> {struct.pack("<Q",c).hex()}')
        elif init == 0:
            print(f'{name}: init=0 gave {struct.pack("<Q",c).hex()}, stored {stored.hex()}')
EOF

34  $ cd /tmp && python3 - <<'EOF'
import redis, struct
rs = redis.Redis(port=6379, db=0); vs = redis.Redis(port=6380, db=0)
M64=0xFFFFFFFFFFFFFFFF; POLY=0xad93d23594c935a9
def reflect64(v):
    r=0
    for i in range(64): r=(r<<1)|((v>>i)&1)
    return r
def crc64raw(crc,data):
    for c in data:
        for i in range(8):
            bit=(crc>>63)&1
            if c&(1<<i): bit^=1
            crc=(crc<<1)&M64
            if bit: crc^=POLY
    return reflect64(crc)

def convert(payload):
    body, ver = payload[:-10], payload[-10:-8]
    assert ver == b'\x0f\x00', ver
    newbody = body + b'\x50\x00'
    return newbody + struct.pack('<Q', crc64raw(0, newbody))

k=b'session:00074'
p=convert(rs.dump(k))
vs.restore(b'__rt',0,p,replace=True)
print('value match:', rs.get(k)==vs.get(b'__rt'))
vs.delete(b'__rt')

# hash with field TTL
hk=b'profile:37'
ph=convert(rs.dump(hk))
vs.restore(b'__rh',0,ph,replace=True)
print('hash fields match:', rs.hgetall(hk)==vs.hgetall(b'__rh'))
src_f=rs.hgetall(hk)
flds=list(src_f.keys())
print('src HTTL:', rs.execute_command('HTTL',hk,'FIELDS',len(flds),*flds))
print('dst HTTL:', vs.execute_command('HTTL',b'__rh','FIELDS',len(flds),*flds))
vs.delete(b'__rh')
EOF

35  $ cd /tmp && python3 - <<'EOF'
import redis
rs = redis.Redis(port=6379, db=0)
k=b'events:00'
info = rs.xinfo_stream(k)
print('XINFO STREAM:', {kk:vv for kk,vv in info.items() if kk in ('length','radix-tree-keys','last-generated-id','max-deleted-entry-id','entries-added','recorded-first-entry-id')})
for g in rs.xinfo_groups(k):
    print('GROUP:', {kk:vv for kk,vv in g.items()})
for c in rs.xinfo_consumers(k,'workers'):
    print('CONSUMER:', dict(c))
print('XPENDING summary:', rs.xpending(k,'workers'))
EOF

36  $ cd /tmp && python3 - <<'EOF'
import redis, struct, traceback
rs = redis.Redis(port=6379, db=0); vs = redis.Redis(port=6380, db=0)
M64=0xFFFFFFFFFFFFFFFF; POLY=0xad93d23594c935a9
def reflect64(v):
    r=0
    for i in range(64): r=(r<<1)|((v>>i)&1)
    return r
def crc64raw(crc,data):
    for c in data:
        for i in range(8):
            bit=(crc>>63)&1
            if c&(1<<i): bit^=1
            crc=(crc<<1)&M64
            if bit: crc^=POLY
    return reflect64(crc)
def convert(p):
    body=p[:-10]; assert p[-10:-8]==b'\x0f\x00'
    nb=body+b'\x50\x00'
    return nb+struct.pack('<Q',crc64raw(0,nb))

for hk in (b'profile:37', b'user:0077'):
    try:
        vs.restore(b'__rh',0,convert(rs.dump(hk)),replace=True)
        print(hk,'OK')
    except Exception as e:
        print(hk,'ERR:',type(e).__name__,e)
        # try ABSTTL & idletime variants irrelevant; try without replace conflict
        try:
            vs.delete(b'__rh')
            vs.restore(b'__rh',0,convert(rs.dump(hk)))
            print(hk,'OK on retry')
        except Exception as e2:
            print(hk,'ERR2:',e2)
    vs.delete(b'__rh')
EOF

37  $ cd /tmp && python3 - <<'EOF'
import redis, struct
rs = redis.Redis(port=6379, db=0); vs = redis.Redis(port=6380, db=0)
M64=0xFFFFFFFFFFFFFFFF; POLY=0xad93d23594c935a9
def reflect64(v):
    r=0
    for i in range(64): r=(r<<1)|((v>>i)&1)
    return r
def crc64raw(crc,data):
    for c in data:
        for i in range(8):
            bit=(crc>>63)&1
            if c&(1<<i): bit^=1
            crc=(crc<<1)&M64
            if bit: crc^=POLY
    return reflect64(crc)
def convert(p):
    body=p[:-10]; assert p[-10:-8]==b'\x0f\x00'
    nb=body+b'\x50\x00'
    return nb+struct.pack('<Q',crc64raw(0,nb))

results={}
for t in ('string','list','set','zset','hash','stream'):
    keys=[k for tt,k in [(a.split()[0], a.split()[1]) for a in open('/tmp/types_db0.txt')] if tt==t][:2]
    for k in keys:
        try:
            vs.restore(b'__probe',0,convert(rs.dump(k)),replace=True)
            results.setdefault(t,[]).append((k.decode(),'OK'))
        except Exception as e:
            results.setdefault(t,[]).append((k.decode(),f'ERR:{e}'))
        vs.delete(b'__probe')
for t, rows in results.items():
    print(t, rows)
EOF

38  $ cd /tmp && python3 - <<'EOF'
import redis, struct
rs = redis.Redis(port=6379, db=0); vs = redis.Redis(port=6380, db=0)
M64=0xFFFFFFFFFFFFFFFF; POLY=0xad93d23594c935a9
def reflect64(v):
    r=0
    for i in range(64): r=(r<<1)|((v>>i)&1)
    return r
def crc64raw(crc,data):
    for c in data:
        for i in range(8):
            bit=(crc>>63)&1
            if c&(1<<i): bit^=1
            crc=(crc<<1)&M64
            if bit: crc^=POLY
    return reflect64(crc)
def convert(p):
    body=p[:-10]; assert p[-10:-8]==b'\x0f\x00'
    nb=body+b'\x50\x00'
    return nb+struct.pack('<Q',crc64raw(0,nb))

types={}
for line in open('/tmp/types_db0.txt'):
    tt,kk=line.split()
    types.setdefault(tt,[]).append(kk.encode())

results={}
for t,keys in types.items():
    for k in keys[:3]:
        try:
            vs.restore(b'__probe',0,convert(rs.dump(k)),replace=True)
            results.setdefault(t,[]).append(('OK',k.decode()))
        except Exception as e:
            results.setdefault(t,[]).append((f'ERR:{e}',k.decode()))
        vs.delete(b'__probe')
for t,rows in results.items():
    print(f'{t}: {rows}')
EOF

39  $ head -3 /tmp/types_db0.txt; echo '---'; od -c /tmp/types_db0.txt | head -3

40  $ cd /tmp && python3 - <<'EOF'
import redis, struct
rs = redis.Redis(port=6379, db=0); vs = redis.Redis(port=6380, db=0)
M64=0xFFFFFFFFFFFFFFFF; POLY=0xad93d23594c935a9
def reflect64(v):
    r=0
    for i in range(64): r=(r<<1)|((v>>i)&1)
    return r
def crc64raw(crc,data):
    for c in data:
        for i in range(8):
            bit=(crc>>63)&1
            if c&(1<<i): bit^=1
            crc=(crc<<1)&M64
            if bit: crc^=POLY
    return reflect64(crc)
def convert(p):
    body=p[:-10]; assert p[-10:-8]==b'\x0f\x00'
    nb=body+b'\x50\x00'
    return nb+struct.pack('<Q',crc64raw(0,nb))

types={}
for line in open('/tmp/types_db0.txt'):
    parts=line.split()
    types.setdefault(parts[0],[]).append(parts[1].encode())

results={}
for t,keys in types.items():
    for k in keys[:3]:
        try:
            vs.restore(b'__probe',0,convert(rs.dump(k)),replace=True)
            results.setdefault(t,[]).append('OK:'+k)
        except Exception as e:
            results.setdefault(t,[]).append(f'ERR:{e}:{k}')
        vs.delete(b'__probe')
for t,rows in results.items():
    print(f'{t}: {rows}')
EOF

41  $ cd /tmp && python3 - <<'EOF'
import redis
rs = redis.Redis(port=6379, db=0)
k=b'session:00074'
p=rs.dump(k)
print('type of dump result:', type(p), 'repr head:', repr(p[:16]))
print('p[:-10] type:', type(p[:-10]))
try:
    nb = p[:-10] + b'\x50\x00'
    print('concat ok:', repr(nb[-4:]))
except Exception as e:
    print('concat ERR:', e)
EOF

42  $ cd /tmp && python3 - <<'EOF'
import redis, struct
rs = redis.Redis(port=6379, db=0); vs = redis.Redis(port=6380, db=0)
M64=0xFFFFFFFFFFFFFFFF; POLY=0xad93d23594c935a9
def reflect64(v):
    r=0
    for i in range(64): r=(r<<1)|((v>>i)&1)
    return r
def crc64raw(crc,data):
    for c in data:
        for i in range(8):
            bit=(crc>>63)&1
            if c&(1<<i): bit^=1
            crc=(crc<<1)&M64
            if bit: crc^=POLY
    return reflect64(crc)
def convert(p):
    body=p[:-10]
    nb=body+b'\x50\x00'
    return nb+struct.pack('<Q',crc64raw(0,nb))

types={}
for line in open('/tmp/types_db0.txt'):
    parts=line.split()
    types.setdefault(parts[0],[]).append(parts[1])

results={}
for t,keys in types.items():
    for kname in keys[:3]:
        try:
            vs.restore(b'__probe',0,convert(rs.dump(kname.encode())),replace=True)
            results.setdefault(t,[]).append('OK:'+kname)
        except Exception as e:
            results.setdefault(t,[]).append(f'ERR:{e}:{kname}')
        vs.delete(b'__probe')
for t,rows in results.items():
    print(f'{t}: {rows}')
EOF

43  $ cd /tmp && python3 - <<'EOF'
import redis
rs = redis.Redis(port=6379, db=0); vs = redis.Redis(port=6380, db=0)

# Build identical stream on both
for c,name in ((rs,'src'),(vs,'dst')):
    c.delete('__sx')
    for i in range(5):
        c.xadd('__sx', {'f':str(i)}, id=f'17000000000{i}-0')
    c.xgroup_create('__sx','g1', id='0-0')
    r = c.xreadgroup('g1','c1',{('__sx'): '>'}, count=3)
    c.xreadgroup('g1','c2',{('__sx'): '>'}, count=1)

pr = rs.dump('__sx'); pv = vs.dump('__sx')
print('redis len', len(pr), 'valkey len', len(pv))
def hx(p): return p.hex(' ')
print('redis :', hx(pr))
print('valkey:', hx(pv))
# byte diff positions
diff=[i for i,(a,b) in enumerate(zip(pr,pv)) if a!=b]
print('first diffs at:', diff[:10], 'of lens', len(pr), len(pv))
rs.delete('__sx'); vs.delete('__sx')
EOF

44  $ cd /tmp && python3 - <<'EOF'
import redis
rs = redis.Redis(port=6379, db=0); vs = redis.Redis(port=6380, db=0)

# Control: identical stream, no groups
for c in (rs, vs):
    c.delete('__t1')
    for i in range(3):
        c.xadd('__t1', {'a':'1'}, id=f'170000000000{i}-0')
pr, pv = rs.dump('__t1'), vs.dump('__t1')
print('NO GROUP  same len?', len(pr)==len(pv), len(pr), len(pv))
print(' redis :', pr.hex(' '))
print(' valkey:', pv.hex(' '))

# With group, no PEL
for c in (rs, vs):
    c.xgroup_create('__t1','g1', id='0-0')
pr2, pv2 = rs.dump('__t1'), vs.dump('__t1')
print('GROUP no-PEL same len?', len(pr2)==len(pv2), len(pr2), len(pv2))
print(' redis :', pr2.hex(' '))
print(' valkey:', pv2.hex(' '))
rs.delete('__t1'); vs.delete('__t1')
EOF

45  $ 

46  $ cd /tmp && python3 - <<'EOF'
import redis
rs = redis.Redis(port=6 seqments... let me just write it carefully:
rs.delete('__t2')
EOF
echo '---- (retry) ----'
python3 - <<'EOF'
import redis
rs = redis.Redis(port=6379, db=0)
rs.delete('__t2')
r = rs.xadd('__t2', {'a':'1'}, id='1-1')
print('xadd 1-1 result:', r)
p = rs.dump('__t2')
print('dump hex:', p.hex(' '))
rs.delete('__t2')
EOF

47  $ cd /tmp && python3 - <<'EOF'
import redis
rs = redis.Redis(port=6379, db=0); vs = redis.Redis(port=6380, db=0)
for c in (rs, vs):
    c.delete('__t1')
    for i in range(3):
        c.xadd('__t1', {'a':'1'}, id=f'170000000000{i}-0')
    c.xgroup_create('__t1','g1', id='0-0')
pr, pv = rs.dump('__t1'), vs.dump('__t1')
rs.delete('__t1'); vs.delete('__t1')

def rlen(buf, i):
    b = buf[i]
    t = b & 0xc0
    if t == 0: return b, i+1, '6bit'
    if t == 0x40: return ((b & 0x3f) << 8) | buf[i+1], i+2, '14bit'
    if t == 0x80: return int.from_bytes(buf[i+1:i+5],'big'), i+5, '32bit'
    # special
    enc = b & 0x3f
    return ('ENC',enc), i+1, f'enc{enc}'

def parse_stream(buf, name):
    i = 0
    print(f'--- {name} (len {len(buf)}) ---')
    print(f'[{i}] type=0x{buf[i]:02x}'); i+=1
    n, i, enc = rlen(buf, i); print(f'[{i}] num_nodes={n} ({enc})')
    for node in range(n):
        klen, i, enc = rlen(buf, i)
        key = buf[i:i+klen]; i += klen
        print(f'  [{i}] node{node} key({enc}) len={klen} -> {key.hex()}')
        llen, i, enc = rlen(buf, i)
        lp = buf[i:i+llen]; i += llen
        print(f'  [{i}] node{node} lp({enc}) len={llen} bytes={lp.hex()[:60]}... tail={lp[-8:].hex()}')
    for label in ('total_entries','last_id_ms','last_id_seq','maxdel_ms','maxdel_seq','entries_added','num_groups'):
        v, i, enc = rlen(buf, i)
        print(f'[{i}] {label}={v} ({enc}) raw={buf[i-5:i].hex() if enc=="32bit" else buf[i-2:i].hex()}')
    return i

ia = parse_stream(pr, 'redis')
ib = parse_stream(pv, 'valkey')
print('redis remaining after num_groups:', pr[ia:].hex())
print('valkey remaining after num_groups:', pv[ib:].hex())
EOF

48  $ cd /tmp && python3 - <<'EOF'
import redis
rs = redis.Redis(port=6379, db=0); vs = redis.Redis(port=6380, db=0)
for c in (rs, vs):
    c.delete('__t1')
    for i in range(3):
        c.xadd('__t1', {'a':'1'}, id=f'170000000000{i}-0')
    c.xgroup/1-PEL... no—no PEL yet; just create group
    c.xgroup_create('__t1','g1', id='0-0')
pr, pv = rs.dump('__t1'), vs.dump('__t1')
rs.delete('__t1'); vs.delete('__t1')

def rlen(buf, i):
    b = buf[i]; t = b & 0xc0
    if t == 0x00: return b, i+1, '6bit'
    if t == 0x40: return ((b & 0x3f) << 8) | buf[i+1], i+2, '14bit'
    if t == 0x80: return int.from_bytes(buf[i+1:i+5],'big'), i+5, '32bit'
    return ('ENC', b & 0x3f), i+1, f'enc{b&0x3f}'

def parse_stream(buf, name):
    i = 0
    print(f'--- {name} len={len(buf)} ---')
    print(f'[0] type=0x{buf[0]:02x}'); i = 1
    n, i, _ = rlen(buf, i); print(f'[{i}] num_nodes={n}')
    for node in range(n):
        klen, i, _ = rlen(buf, i)
        key = buf[i:i+klen]; i += klen
        llen, i, enc = rlen(buf, i)
        lp = buf[i:i+llen]; i += llen
        print(f'  node{node}: key={key.hex()} | lp len={llen} tail(8)={lp[-8:].hex()}')
        print(f'    lp head(16)={lp[:16].hex()}')
    labels = ['total_entries','last_id_ms','last_id_seq','maxdel_ms','maxdel_seq','entries_added','num_groups']
    for lab in labels:
        v, i, enc = rlen(buf, i)
        print(f'[{i}] {lab}={v} ({enc})')
    return i

ia = parse_stream(pr, 'redis')
ib = parse_stream(pv, 'valkey')
print(f'redis  tail after num_groups ({len(pr)-ia}B): {pr[ia:].hex()}')
print(f'valkey tail after num_groups ({len(pv)-ib}B): {pv[ib:].hex()}')
EOF

49  $ cd /tmp && cat > /tmp/probe.py <<'PYEOF'
import redis
rs = redis.Redis(port=6379, db=0); vs = redis.Redis(port=6380, db=0)
for c in (rs, vs):
    c.delete('__t1')
    for i in range(3):
        c.xadd('__t1', {'a':'1'}, id='170000000000%d-0' % i)
    c.xgroup_create('__t1','g1', id='0-0')
pr, pv = rs.dump('__t1'), vs.dump('__t1')
rs.delete('__t1'); vs.delete('__t1')

def rlen(buf, i):
    b = buf[i]; t = b & 0xc0
    if t == 0x00: return b, i+1, '6bit'
    if t == 0x40: return ((b & 0x3f) << 8) | buf[i+1], i+2, '14bit'
    if t == 0x80: return int.from_bytes(buf[i+1:i+5],'big'), i+5, '32bit'
    return ('ENC', b & 0x3f), i+1, 'enc'

def parse_stream(buf, name):
    i = 0
    print('--- %s len=%d ---' % (name, len(buf)))
    print('[0] type=0x%02x' % buf[0]); i = 1
    n, i, _ = rlen(buf, i); print('[%d] num_nodes=%d' % (i, n))
    for node in range(n):
        klen, i, _ = rlen(buf, i)
        key = buf[i:i+klen]; i += klen
        llen, i, enc = rlen(buf, i)
        lp = buf[i:i+llen]; i += llen
        print('  node%d: key=%s | lp len=%d head16=%s tail8=%s' % (node, key.hex(), llen, lp[:16].hex(), lp[-8:].hex()))
    for lab in ['total_entries','last_id_ms','last_id_seq','maxdel_ms','maxdel_seq','entries_added','num_groups']:
        v, i, enc = rlen(buf, i)
        print('[%d] %s=%s (%s)' % (i, lab, v, enc))
    return i

ia = parse_stream(pr, 'redis')
ib = parse_stream(pv, 'valkey')
print('redis  tail(%dB): %s' % (len(pr)-ia, pr[ia:].hex()))
print('valkey tail(%dB): %s' % (len(pv)-ib, pv[ib:].hex()))
PYEOF
python3 /tmp/probe.py

50  $ cd /tmp && python3 - <<'EOF'
import redis
rs = redis.Redis(port=6379, db=0)
streams = [l.split()[1] for l in open('/tmp/types_db0.txt') if l.startswith('stream')]
print('%-12s %5s %6s %22s %22s %s' % ('key','len','added','last-gen','max-del','groups'))
for k in sorted(streams):
    i = rs.xinfo_stream(k)
    g = rs.xinfo_groups(k)
    print('%-12s %5d %6d %22s %22s %s' % (k, i['length'], i['entries-added'],
        i['last-generated-id'].decode(), i['max-deleted-entry-id'].decode(),
        ','.join('%s/pend=%d/c=%d' % (x['name'].decode(), x['pending'], x['consumers']) for x in g)))
EOF

51  $ cd /tmp && python3 - <<'EOF'
import redis
rs = redis.Redis(port=6379, db=0)
# precise field-TTL inventory across all hashes, both dbs
for db in (0, 2):
    r = redis.Redis(port=6379, db=db)
    keys = [l.split()[1] for l in open('/tmp/types_db0.txt')] if db == 0 else []
    if db == 2:
        keys = [k for k in r.scan_iter() if r.type(k) == b'hash']
    total = 0; affected = []
    for k in keys:
        flds = list(r.hgetall(k).keys())
        if not flds: continue
        ttls = r.execute_command('HTTL', k, 'FIELDS', len(flds), *flds)
        n = sum(1 for t in ttls if isinstance(t, int) and t >= 0)
        if n: affected.append((k.decode(), n)); total += n
    print(f'db{db}: hash keys with field TTLs={len(affected)}, fields={total}')
    for k, n in affected[:6]: print('   ', k, n)
    if len(affected) > 6: print('    ... and', len(affected)-6, 'more')
EOF

52  $ cd /tmp && python3 - <<'EOF'
import redis
rs = redis.Redis(port=6379, db=0)
r = redis.Redis(port=6379, db=2)
affected = {}
for db, keys in ((0, [l.split()[1] for l in open('/tmp/types_db0.txt') if l.startswith('hash')]),
                 (2, [k.decode() for k in r.scan_iter() if r.type(k) == b'hash'])):
    c = redis.Redis(port=6379, db=db)
    aff = []
    for kname in keys:
        try: flds = list(c.hgetall(kname).keys())
        except redis.ResponseError as e:
            print('db%d %s: HGETALL err: %s' % (db, kname, e)); continue
        if not flds: continue
        ttls = c.execute_command('HTTL', kname, 'FIELDS', len(flds), *flds)
        n = sum(1 for t in ttls if isinstance(t, int) and t >= 0)
        if n: aff.append((kname, n))
    affected[db] = aff
    print('db%d: hashes with field-TTL=%d (of %d)' % (db, len(aff), len(keys)))
    for kname, n in aff[:5]: print('   ', kname, n)
    if len(aff) > 5: print('    ... +', len(aff)-5)
EOF

53  $ cd /tmp && python3 - <<'EOF'
import redis
rs = redis.Redis(port=6379, db=0); vs = redis.Redis(port=6380, db=0)
def hx(p): return p.hex(' ')
for c,n in ((rs,'src'),(vs,'dst')):
    c.delete('__h1')
    c.hset('__h1', mapping={'a':'1'})
    c.execute_command('HEXPIRE','__h1','100','FIELDS','1','a')
pr, pv = rs.dump('__h1'), vs.dump('__h1')
print('src(%dB): %s' % (len(pr), hx(pr)))
print('dst(%dB): %s' % (len(pv), hx(pv)))
print('diff pos:', [i for i,(a,b) in enumerate(zip(pr,pv)) if a!=b], 'lens', len(pr), len(pv))
for c in (rs,vs): c.delete('__h1')
print()
print('=== source profile:37 ===')
p = rs.dump('profile:37')
print('len', len(p), 'type 0x%02x' % p[0])
print(hx(p))
print('HGETALL:', rs.hgetall('profile:37'))
EOF

54  $ timeout 15 curl -sI https://raw.githubusercontent.com/valkey-io/valkey/9.1/src/rdb.h 2>&1 | head -3; echo "exit=$?"

55  $ cd /tmp && python3 - <<'EOF'
import redis
# Probe: does valkey 9.1 accept type-19 (redis8 HFE) object *at all* in v80 wrapper?
# Compare dst's own HFE encoding for 1 field vs 2 fields to understand its layout
vs = redis.Redis(port=6380, db=0)
for nf in (1, 2):
    vs.delete('__h')
    mapping = {'f%d'%i: str(i) for i in range(nf)}
    vs.hset('__h', mapping=mapping)
    vs.execute_command('HEXPIRE','__h','1000','FIELDS','1','f0')
    p = vs.dump('__h')
    print(f'nf={nf} len={len(p)}: {p.hex(" ")}')
    vs.delete('__h')
EOF

56  $ cd /tmp && for u in \
  "https://raw.githubusercontent.com/valkey-io/valkey/9.1/src/rdb.c|vk91_rdb.c" \
  "https://raw.githubusercontent.com/valkey-io/valkey/9.1/src/rdb.h|vk91_rdb.h" \
  "https://raw.githubusercontent.com/valkey-io/valkey/9.1/src/stream.c|vk91_stream.c" \
  "https://raw.githubusercontent.com/redis/redis/8.10/src/rdb.c|rd810_rdb.c" \
  "https://raw.githubusercontent.com/redis/redis/8.10/src/rdb.h|rd810_rdb.h" ; do
  url="${u%%|*}"; f="${u##*|}"
  code=$(curl -s -o "$f" -w '%{http_code}' "$url")
  echo "$f -> $code ($(wc -l < "$f" 2>/dev/null) lines)"
done

57  $ cd /tmp && for u in \
  "https://api.github.com/repos/valkey-io/valkey/git/trees/9.1?recursive=1|vk_tree.json" ; do
  url="${u%%|*}"; f="${u##*|}"
  code=$(curl -s -o "$f" -w '%{http_code}' "$url"); echo "$f -> $code"
done
python3 - <<'EOF'
import json
t = json.load(open('/tmp/vk_tree.json'))
hits = [i['path'] for i in t['tree'] if 'stream' in i['path'].lower() and i['path'].endswith('.c')]
print(hits[:20])
EOF

58  $ cd /tmp && for u in \
  "https://raw.githubusercontent.com/valkey-io/valkey/9.1/src/t_stream.c|vk91_t_stream.c" \
  "https://raw.githubusercontent.com/redis/redis/8.10/src/t_stream.c|rd810_t_stream.c" \
  "https://raw.githubusercontent.com/redis/redis/8.10/src/t_hash.c|rd810_t_hash.c" ; do
  url="${u%%|*}"; f="${u##*|}"
  code=$(curl -s -o "$f" -w '%{http_code}' "$url"); echo "$f -> $code ($(wc -l < "$f") lines)"
done
grep -n 'RDB_TYPE_STREAM' /tmp/rd810_rdb.h /tmp/vk91_rdb.h | head

59  $ cd /tmp && grep -n 'RDB_TYPE_STREAM_LISTPACKS' vk91_rdb.c | head -20; echo '==='; sed -n '/case RDB_TYPE_STREAM_LISTPACKS_3:/,/break;/p' vk91_rdb.c | head -80

60  $ cd /tmp && sed -n '2598,2760p' vk91_rdb.c

61  $ cd /tmp && sed -n '2760,2920p' vk91_rdb.c

62  $ cd /tmp && sed -n '2920,2985p' vk91_rdb.c

63  $ cd /tmp && sed -n '2866,2920p' vk91_rdb.c; echo '=== does vk91 have LISTPACKS_4/5? ==='; grep -n 'LISTPACKS_4\|LISTPACKS_5\|RDB_TYPE_STREAM' vk91_rdb.h | head

64  $ cd /tmp && grep -n 'LISTPACKS_4\|LISTPACKS_5\|IDMP\|XNACK' rd810_rdb.h rd810_rdb.c | head -30

65  $ cd /tmp && sed -n '4269,4420p' rd810_rdb.c

66  $ cd /tmp && sed -n '1555,1585p' rd810_rdb.c; echo '=== stream object type byte in dump ==='; grep -n 'RDB_TYPE_STREAM_LISTPACKS_5\|rdbSaveType' rd810_rdb.c | head

67  $ cd /tmp && sed -n '690,750p' rd810_rdb.c

68  $ cd /tmp && grep -n 'RDB_TYPE' rd810_rdb.h | sed -n '60,90p'; echo '=== valkey hash types ==='; grep -n 'RDB_TYPE_HASH\|RDB_TYPE_SET\|RDB_TYPE_ZSET\|RDB_TYPE_LIST' vk91_rdb.h | head -20

69  $ cd /tmp && sed -n '60,90p' rd810_rdb.h; echo '=== vk hash types cont ==='; sed -n '124,160p' vk91_rdb.h

70  $ cd /tmp && echo '=== REDIS 8.10 types ==='; grep -n 'define RDB_TYPE' rd810_rdb.h; echo; echo '=== VALKEY 9.1 types ==='; sed -n '/RDB_TYPE_STRING/,/RDB_TYPE_LAST/p' vk91_rdb.h

71  $ cd /tmp && grep -n 'RDB_TYPE_HASH_METADATA_PRE_GA\|RDB_TYPE_HASH_2\|HASH_LISTPACK_EX_PRE_GA\|rdbLoadHashFieldTtl\|hashTypeLoad' rd810_rdb.c vk91_rdb.c | head -30

72  $ cd /tmp && sed -n '2118,2290p' vk91_rdb.c

73  $ cd /tmp && sed -n '2290,2340p' vk91_rdb.c

74  $ cd /tmp && sed -n '2220,2290p' vk91_rdb.c

75  $ cd /tmp && sed -n '3343,3450p' rd810_rdb.c

76  $ cd /tmp && sed -n '3450,3520p' rd810_rdb.c

77  $ cd /tmp && sed -n '2818,2868p' vk91_rdb.c

78  $ cd /tmp && grep -n 'rdbSaveStreamObject\|rdbSaveStreamIdmpEntries' rd810_rdb.c | head; sed -n '760,830p' rd810_rdb.c

79  $ cd /tmp && grep -n 'rdbSaveStream\|RDB_TYPE_STREAM' rd810_rdb.c | head; echo ===; sed -n '1440,1470p' rd810_rdb.c

80  $ cd /tmp && sed -n '1470,1560p' rd810_rdb.c

81  $ cd /tmp && sed -n '700,800p' vk91_rdb.c

82  $ cd /tmp && sed -n '960,1070p' vk91_rdb.c

83  $ cd /tmp && sed -n '1070,1180p' vk91_rdb.c

84  $ cd /tmp && sed -n '1026,1080p' rd810_rdb.c

85  $ cd /tmp && python3 - <<'EOF'
import redis
rs = redis.Redis(port=6379, db=0)
i = rs.xinfo_stream('events:00')
print('FULL XINFO STREAM events:00:')
for k, v in i.items():
    print('  %s = %s' % (k, v))
print()
# also check config for lfu / maxmemory on source
c = rs.config_get()
for kk in ('maxmemory','maxmemory-policy','appendonly','save','databases','activerehashing','hash-max-listpack-entries','stream-node-max-bytes'):
    print(kk, '=', c.get(kk))
print()
print('INFO memory bits:', {k:v for k,v in rs.info('memory').items() if 'lfu' in k or 'policy' in k})
EOF

86  $ cd /tmp && grep -n -A18 'mstime_t rdbLoadMillisecondTime\|int rdbSaveMillisecondTime' vk91_rdb.c | head -50; echo '======= redis810 ======='; grep -n -A18 'mstime_t rdbLoadMillisecondTime\|int rdbSaveMillisecondTime' rd810_rdb.c | head -50

87  $ cd /tmp && grep -n 'rdbLoadMillisecondTime\|rdbSaveMillisecondTime' vk91_rdb.c | head -6; echo ===; grep -rn 'rdbLoadMillisecondTime' vk91_rdb.h 2>/dev/null; grep -n 'RDB_LOAD_MILLISECOND\|millisecond' vk91_rdb.h | head

88  $ cd /tmp && sed -n '195,250p' vk91_rdb.c

89  $ cd /tmp && grep -n 'rdbSaveMillisecondTime\|rdbLoadMillisecondTime' rd810_rdb.c | head -4; sed -n "$(grep -n 'ssize_t rdbSaveMillisecondTime' rd810_rdb.c | head -1 | cut -d: -f1),+14p" rd810_rdb.c

90  $ cd /tmp && sed -n "$(grep -n 'rdbSaveSignedInteger' rd810_rdb.c | head -2 | tail -1 | cut -d: -f1),+30p" rd810_rdb.c; grep -n 'rdbLoadSignedInteger\|rdbSaveSignedInteger' rd810_rdb.c rd810_rdb.h | head

91  $ cd /tmp && sed -n '136,165p' rd810_rdb.c

92  $ cd /tmp && sed -n '3596,3700p' rd810_rdb.c

93  $ cd /tmp && sed -n "$(grep -n 'RDB_TYPE_HASH_LISTPACK_EX_PRE_GA:' rd810_rdb.c | head -1 | cut -d: -f1),+50p" rd810_rdb.c

94  $ cd /tmp && grep -n 'rdbSaveObject\|OBJ_ENCODING_LISTPACK_EX' rd810_rdb.c | grep -i 'save\|listpackex' | head; sed -n "$(grep -n 'static ssize_t rdbSaveObject' rd810_rdb.c | head -1 | cut -d: -f1),+8p" rd810_rdb.c; grep -n 'listpackExSave\|lpexSave\|listpackEx' rd810_rdb.c | head -20

95  $ cd /tmp && sed -n '1139,1260p' rd810_rdb.c

96  $ cd /tmp && awk 'NR>=1260 && NR<=1340' rd810_rdb.c

97  $ cd /tmp && awk 'NR>=1340 && NR<=1440' rd810_rdb.c

98  $ cd /tmp && grep -n 'OBJ_ENCODING_TMPL' rd810_rdb.h 2>/dev/null | head -3; grep -n 'hashTypeGetMinExpire\|EB_EXPIRE_TIME_INVALID\s' rd810_t_hash.c 2>/dev/null | head -5; curl -s -o /tmp/rd810_server.h "https://raw.githubusercontent.com/redis/redis/8.10/src/server.h"; grep -n 'define EB_EXPIRE_TIME_INVALID\|EB_EXPIRE_TIME_MAX\|EB_EXPIRE_TIME_MAX ' /tmp/rd810_server.h | head

99  $ grep -n 'EB_EXPIRE_TIME' /tmp/rd810_server.h | head -8; echo ===; grep -n 'define EB_EXPIRE_TIME_INVALID' /tmp/rd810_server.h

100  $ cd /tmp && curl -s -o eb.c "https://raw.githubusercontent.com/redis/redis/8.10/src/ebuckets.c" && curl -s -o eb.h "https://raw.githubusercontent.com/redis/redis/8.10/src/ebuckets.h"; grep -n 'EB_EXPIRE_TIME_INVALID\|EB_EXPIRE_TIME_MAX' eb.h | head; grep -n 'define EB_EXPIRE_TIME' eb.c | head

101  $ cd /tmp && python3 - <<'EOF'
import redis, collections
types_total = collections.Counter()
special = collections.defaultdict(list)
for db in (0, 2):
    r = redis.Redis(port=6379, db=db)
    pl = r.pipeline(transaction=False)
    keys = [k for k in r.scan_iter()]
    for k in keys:
        pl.dump(k)
    dumps = pl.execute()
    for k, d in zip(keys, dumps):
        if d is None:
            print('db%d %s: DUMP None (expired?)' % (db, k)); continue
        t = d[0]
        types_total[(db, t)] += 1
        if t >= 22:
            special[(db, t)].append(k.decode())
print('type-byte histogram (db, byte):')
for (db, t), n in sorted(types_total.items()):
    print('  db%d type 0x%02x (%d): %d keys' % (db, t, t, n))
print()
print('special keys (type>=22):')
for (db, t), ks in special.items():
    print('  db%d type 0x%02x: %d keys, e.g. %s' % (db, t, len(ks), ks[:3]))
EOF

102  $ cd /tmp && curl -s -o vk91_listpack.c "https://raw.githubusercontent.com/valkey-io/valkey/9.1/src/listpack.c" && grep -n 'LP_ENCODING_' vk91_listpack.c | grep -E 'define' | head -30

103  $ cd /tmp && python3 - <<'EOF'
# Parse the listpack of the source events:00 stream node to see raw ID encoding
import redis, struct
rs = redis.Redis(port=6379, db=0)

def read_lp(buf):
    # returns list of (raw_entry_bytes, parsed)
    out = []
    i = 0
    end = len(buf) - 1  # last byte is 0xFF
    while buf[i] != 0xFF:
        b = buf[i]
        if b < 0x80:
            # 7-bit string: length b
            ln = b & 0x7f
            data = buf[i+1:i+1+ln]
            out.append(('str', data)); i += 1 + ln
        elif (b & 0xE0) == 0xC0:
            v = ((b & 0x1f) << 8) | buf[i+1]; out.append(('int13', v)); i += 3
        elif (b & 0xF0) == 0xE0:
            ln = ((b & 0x0f) << 8) | buf[i+1]
            data = buf[i+2:i+2+ln]; out.append(('str12', data)); i += 2 + ln
        elif b == 0xF1:
            v = int.from_bytes(buf[i+1:i+3],'little',signed=True); out.append(('int16',v)); i += 4
        elif b == 0xF2:
            v = int.from_bytes(buf[i+1:i+4],'little',signed=True); out.append(('int24',v)); i += 5
        elif b == 0xF3:
            v = int.from_bytes(buf[i+1:i+5],'little',signed=True); out.append(('int32',v)); i += 6
        elif b == 0xF4:
            v = int.from_bytes(buf[i+1:i+9],'little',signed=True); out.append(('int64',v)); i += 10
        else:
            raise ValueError('unknown byte 0x%02x at %d' % (b, i))
    return out

p = rs.dump('events:00')
body = p[:-10]
i = 1  # skip type
# num listpacks (6bit)
n = body[i]; i += 1
klen = body[i]; i += 1
key = body[i:i+klen]; i += klen
ll = body[i]; i += 1
lp = body[i:i+ll]; i += ll
print('node key (16B):', key.hex())
ms = int.from_bytes(key[:8],'big'); seq = int.from_bytes(key[8:],'big')
print('  as big-endian: ms=%d seq=%d' % (ms, seq))
print('  minus 14e14   : ms=%d seq=%d' % (ms-1400000000000000, seq))
print()
entries = read_lp(lp)
print('listpack entries (%d):' % len(entries))
for kind, v in entries[:12]:
    if kind in ('int64',):
        print('  int64:', v, ' (abs ms if unix: %s)' % (v,))
    else:
        print('  %s: %s' % (kind, v if not isinstance(v, bytes) else v[:40]))
print('  ...')
for kind, v in entries[-4:]:
    print('  tail %s: %s' % (kind, v))
EOF

104  $ cd /tmp && cat > /tmp/rdparse.py <<'PYEOF'
import struct

def read_len(buf, i):
    b = buf[i]
    if (b & 0xC0) == 0x00: return b, i+1
    if (b & 0xC0) == 0x40: return ((b & 0x3F) << 8) | buf[i+1], i+2
    if (b & 0xC0) == 0x80: return int.from_bytes(buf[i+1:i+5], 'big'), i+5
    raise ValueError('special enc at %d: 0x%02x' % (i, b))

def read_str(buf, i):
    hdr = buf[i]
    if (hdr & 0xC0) == 0x00:
        ln = hdr & 0x3F; return buf[i+1:i+1+ln], i+1+ln
    if (hdr & 0xC0) == 0x40:
        ln = ((hdr & 0x3F) << 8) | buf[i+1]; return buf[i+2:i+2+ln], i+2+ln
    if (hdr & 0xC0) == 0x80:
        ln = int.from_bytes(buf[i+1:i+5], 'big'); return buf[i+5:i+5+ln], i+5+ln
    if hdr == 0xC0:  # 8-bit int
        return ('int8', buf[i+1]), i+2
    if hdr == 0xC1:  # 16-bit int LE
        return ('int16', int.from_bytes(buf[i+1:i+3],'little')), i+3
    if hdr == 0xC2:  # 32-bit int LE
        return ('int32', int.from_bytes(buf[i+1:i+5],'little')), i+5
    raise ValueError('str special enc 0x%02x at %d' % (hdr, i))

def parse_stream_obj(buf):
    """buf excludes the type byte? No - include everything after RESTORE prefix; assume starts with type"""
    i = 0
    t = buf[i]; i += 1
    assert t in (15, 19, 21, 26, 27), t
    out = {'type': t, 'nodes': []}
    n, i = read_len(buf, i)
    for _ in range(n):
        key, i = read_str(buf, i)
        lp, i = read_str(buf, i)
        out['nodes'].append((key.hex(), len(lp)))
    out['length'], i = read_len(buf, i)
    lms, i = read_len(buf, i); lsq, i = read_len(buf, i)
    out['last_id'] = (lms, lsq)
    fms, i = read_len(buf, i); fsq, i = read_len(buf, i)
    out['first_id'] = (fms, fsq)
    mms, i = read_len(buf, i); msq, i = read_len(buf, i)
    out['maxdel'] = (mms, msq)
    ea, i = read_len(buf, i); out['entries_added'] = ea
    ng, i = read_len(buf, i); out['groups'] = []
    for _ in range(ng):
        nm, i = read_str(buf, i)
        g = {'name': nm}
        g['last_ms'], i = read_len(buf, i); g['last_seq'], i = read_len(buf, i)
        g['entries_read'], i = read_len(buf, i)
        pels, i = read_len(buf, i); g['pel'] = []
        for _ in range(pels):
            raw = buf[i:i+16]; i += 16
            nack_ms = struct.unpack('<q', buf[i:i+8])[0]; i += 8
            nack_cnt, i = read_len(buf, i)
            g['pel'].append((raw.hex(), nack_ms, nack_cnt))
        cs, i = read_len(buf, i); g['consumers'] = []
        for _ in range(cs):
            cn, i = read_str(buf, i)
            seen = struct.unpack('<q', buf[i:i+8])[0]; i += 8
            extra = ''
            if t >= 21:
                act = struct.unpack('<q', buf[i:i+8])[0]; i += 8; extra = ' act=%d' % act
            cp, i = read_len(buf, i)
            cpids = [buf[i+16*x:i+16*(x+1)].hex() for x in range(cp)]; i += 16*cp
            g['consumers'].append((cn.decode(), seen, extra, cpids))
        if t >= 26:  # LISTPACKS_4/5: IDMP
            g['idmp_dur'], i = read_len(buf, i)
            g['idmp_max'], i = read_len(buf, i)
            prods, i = read_len(buf, i)
            g['idmp'] = []
            for _ in range(prods):
                pid, i = read_str(buf, i)
                cnt, i = read_len(buf, i)
                ents = []
                for _ in range(cnt):
                    iid, i = read_str(buf, i)
                    sid = buf[i:i+16]; i += 16
                    cntn, i = read_len(buf, i)
                    ents.append((iid, sid.hex(), cntn))
                g['idmp'].append((pid, ents))
            g['iids_added'], i = read_len(buf, i)
            g['iids_dup'], i = read_len(buf, i)
            nc, i = read_len(buf, i); g['nack_zone'] = [buf[i+16*x:i+16*(x+1)].hex() for x in range(nc)]; i += 16*nc
        out['groups'].append(g)
    out['consumed'] = i
    out['remaining'] = buf[i:].hex()
    return out
PYEOF
python3 - <<'EOF'
import sys; sys.path.insert(0, '/tmp')
import redis
from rdparse import parse_stream_obj
rs = redis.Redis(port=6379, db=0); vs = redis.Redis(port=6380, db=0)
for c in (rs, vs):
    c.delete('__t1')
    for i in range(3):
        c.xadd('__t1', {'a':'1'}, id='170000000000%d-0' % i)
    c.xgroup_create('__t1', 'g1', id='0-0')
    r = c.xreadgroup('g1', 'c1', {'__t1': '>'}, count=2)
    c.xack('__t1', 'g1', r[0][1][0][0])
pr, pv = rs.dump('__t1'), vs.dump('__t1')
a, b = parse_stream_obj(pr), parse_stream_obj(pv)
import json
print('REDIS 810 :', json.dumps(a, indent=1, default=str)[:1400])
print()
print('VALKEY 91 :', json.dumps(b, indent=1, default=str)[:1400])
rs.delete('__t1'); vs.delete('__t1')
EOF

105  $ cd /tmp && cat > /tmp/rdparse.py <<'PYEOF'
import struct

def read_len(buf, i):
    b = buf[i]
    if (b & 0xC0) == 0x00: return b, i+1
    if (b & 0xC0) == 0x40: return ((b & 0x3F) << 8) | buf[i+1], i+2
    if (b & 0xC0) == 0x80: return int.from_bytes(buf[i+1:i+5], 'big'), i+5
    raise ValueError('special enc at %d: 0x%02x' % (i, b))

def read_str(buf, i):
    hdr = buf[i]
    if (hdr & 0xC0) == 0x00:
        ln = hdr & 0x3F; return buf[i+1:i+1+ln], i+1+ln
    if (hdr & 0xC0) == 0x40:
        ln = ((hdr & 0x3F) << 8) | buf[i+1]; return buf[i+2:i+2+ln], i+2+ln
    if (hdr & 0xC0) == 0x80:
        ln = int.from_bytes(buf[i+1:i+5], 'big'); return buf[i+5:i+5+ln], i+5+ln
    if hdr == 0xC0: return ('int8', buf[i+1]), i+2
    if hdr == 0xC1: return ('int16', int.from_bytes(buf[i+1:i+3],'little')), i+3
    if hdr == 0xC2: return ('int32', int.from_bytes(buf[i+1:i+5],'little')), i+5
    if hdr == 0xC3:  # LZF compressed blob
        cl = int.from_bytes(buf[i+1:i+5], 'big'); out = int.from_bytes(buf[i+5:i+9], 'big')
        return ('lzf', cl, out), i+9
    raise ValueError('str special enc 0x%02x at %d' % (hdr, i))

def parse_stream_obj(buf):
    i = 0
    t = buf[i]; i += 1
    assert t in (15, 19, 21, 26, 27), 'type 0x%02x' % t
    out = {'type': t, 'nodes': []}
    n, i = read_len(buf, i)
    for _ in range(n):
        key, i = read_str(buf, i)
        lp, i = read_str(buf, i)
        out['nodes'].append((key.hex() if isinstance(key, bytes) else key, len(lp) if isinstance(lp, bytes) else lp))
    out['length'], i = read_len(buf, i)
    lms, i = read_len(buf, i); lsq, i = read_len(buf, i)
    out['last_id'] = (lms, lsq)
    fms, i = read_len(buf, i); fsq, i = read_len(buf, i)
    out['first_id'] = (fms, fsq)
    mms, i = read_len(buf, i); msq, i = read_len(buf, i)
    out['maxdel'] = (mms, msq)
    ea, i = read_len(buf, i); out['entries_added'] = ea
    ng, i = read_len(buf, i); out['groups'] = []
    for _ in range(ng):
        nm, i = read_str(buf, i)
        g = {'name': nm.decode() if isinstance(nm, bytes) else nm}
        g['last_ms'], i = read_len(buf, i); g['last_seq'], i = read_len(buf, i)
        g['entries_read'], i = read_len(buf, i)
        pels, i = read_len(buf, i); g['pel'] = []
        for _ in range(pels):
            raw = buf[i:i+16]; i += 16
            nack_ms = struct.unpack('<q', buf[i:i+8])[0]; i += 8
            nack_cnt, i = read_len(buf, i)
            g['pel'].append((raw.hex(), nack_ms, nack_cnt))
        cs, i = read_len(buf, i); g['consumers'] = []
        for _ in range(cs):
            cn, i = read_str(buf, i)
            seen = struct.unpack('<q', buf[i:i+8])[0]; i += 8
            extra = ''
            if t >= 21:
                act = struct.unpack('<q', buf[i:i+8])[0]; i += 8; extra = 'act=%d' % act
            cp, i = read_len(buf, i)
            cpids = [buf[i+16*x:i+16*(x+1)].hex() for x in range(cp)]; i += 16*cp
            g['consumers'].append((cn, seen, extra, cpids))
        if t >= 26:
            g['idmp_dur'], i = read_len(buf, i)
            g['idmp_max'], i = read_len(buf, i)
            prods, i = read_len(buf, i)
            g['idmp'] = []
            for _ in range(prods):
                pid, i = read_str(buf, i)
                cnt, i = read_len(buf, i)
                ents = []
                for _ in range(cnt):
                    iid, i = read_str(buf, i)
                    sid = buf[i:i+16]; i += 16
                    cntn, i = read_len(buf, i)
                    ents.append((iid, sid.hex(), cntn))
                g['idmp'].append((pid, ents))
            g['iids_added'], i = read_len(buf, i)
            g['iids_dup'], i = read_len(buf, i)
            nc, i = read_len(buf, i); g['nack_zone'] = [buf[i+16*x:i+16*(x+1)].hex() for x in range(nc)]; i += 16*nc
        out['groups'].append(g)
    out['consumed'] = i
    out['remaining_hex'] = buf[i:].hex()
    return out
PYEOF
python3 - <<'EOF'
import sys; sys.path.insert(0, '/tmp')
import redis, json
from rdparse import parse_stream_obj
rs = redis.Redis(port=6379, db=0); vs = redis.Redis(port=6380, db=0)
for c in (rs, vs):
    c.delete('__t1')
    for i in range(3):
        c.xadd('__t1', {'a':'1'}, id='170000000000%d-0' % i)
    c.xgroup_create('__t1', 'g1', id='0-0')
    r = c.xreadgroup('g1', 'c1', {'__t1': '>'}, count=2)
    c.xack('__t1', 'g1', r[0][1][0][0])
pr, pv = rs.dump('__t1'), vs.dump('__t1')
a, b = parse_stream_obj(pr), parse_stream_obj(pv)
print('REDIS 8.10 (type %s):' % a['type'])
print(json.dumps(a, indent=1, default=str))
print()
print('VALKEY 9.1 (type %s):' % b['type'])
print(json.dumps(b, indent=1, default=str))
rs.delete('__t1'); vs.delete('__t1')
EOF

106  $ cd /tmp && sed -n "$(grep -n 'rdbSaveLzfBlob' rd810_rdb.c | head -1 | cut -d: -f1),+30p" rd810_rdb.c; grep -n 'RDB_6BITLEN\|RDB_14BITLEN\|RDB_32BITLEN\|RDB_64BITLEN\|RDB_ENC' rd810_rdb.h | head -12

{
 "examples": {
  "missing": [
   "db0:session:00074",
   "db0:session:01251",
   "db0:user:0077"
  ]
 },
 "keys_new": {
  "0": 1
 },
 "keys_old": {
  "0": 2961,
  "2": 350
 },
 "mismatch_counts": {
  "extra": 0,
  "field_ttl_added": 0,
  "field_ttl_drift": 0,
  "field_ttl_lost": 0,
  "missing": 3310,
  "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": false,
 "old_server": {
  "redis_version": "8.10.2",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

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

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

3  $ /opt/redis-8.10/bin/redis-server --version; valkey-server --version; echo ---; cat /etc/redis-old/redis.conf; echo ---; cat /etc/valkey/valkey.conf

4  $ /opt/redis-8.10/bin/redis-cli -p 6379 INFO keyspace; /opt/redis-8.10/bin/redis-cli -p 6379 INFO server | grep -E 'redis_version|multi|aof|rdb|replication' ; echo ---; valkey-cli -p 6380 INFO keyspace; valkey-cli -p 6380 INFO server | grep -E 'valkey_version|multiplexing|aof|rdb'

5  $ R="/opt/redis-8.10/bin/redis-cli -p 6379"; $R INFO replication | head -20; echo ---FUNCTIONS---; $R FUNCTION LIST; echo ---SCRIPTS---; $R SCRIPT LOAD "return 1"; echo ---CONFIG---; $R CONFIG GET save; $R CONFIG GET databases; $R CONFIG GET requirepass; echo ---; $R DBSIZE; $R INFO keyspace

6  $ strings /usr/local/bin/valkey-server | grep -iE 'hash.field|field.expir' | sort -u | head; echo ---; strings /usr/local/bin/valkey-server | grep -oE 'RDB_VERSION[^ ]*|rdbSaveRio' | head; echo ---; valkey-server --help 2>&1 | head -5; ls /var/lib/valkey /var/lib/redis-old 2>&1

7  $ valkey-cli -p 6380 COMMAND INFO HEXPIRE HEXPIREAT HPTTL HTTL HPERSIST HGETEX HGETDEL HSETEX XAUTOCLAIM XCLAIM XGROUP CREATE XINFO GROUPS 2>&1 | awk 'NR%2==1' | head -40

8  $ python3 --version 2>&1; python3 -c "import redis" 2>&1 | head -1; /opt/redis-8.10/bin/redis-cli -p 6370 eval "return 1" 0 2>&1 | head -2

9  $ R="/opt/redis-8.10/bin/redis-cli -p 6379"; $R INFO memory | grep -E 'used_memory:|used_memory_human|used_memory_dataset'; $R --bigkeys 2>&1 | tail -25

10  $ V="valkey-cli -p 6380"; $V DEL exp:k; $V XADD exp:k 1-1 a 1; $V XADD exp:k 1-2 b 2; $V XADD exp:k 2-1 c 3; $V XGROUP CREATE exp:k g1 0-0; $V XREADGROUP GROUP g1 c1 COUNT 2 STREAMS exp:k '>'; sleep 0.3; $V XREADGROUP GROUP g1 c2 COUNT 1 STREAMS exp:k '>'; sleep 0.5; $V XCLAIM exp:k g1 c1 0 2-1; sleep 0.2; echo '--- GROUND TRUTH ---'; $V XINFO GROUPS exp:k; $V XINFO CONSUMERS exp:k g1; $V XPENDING exp:k g1 - + 10

11  $ R="/opt/redis-8.10/bin/redis-cli -p 6379 -n 0"; for k in $($R --scan --pattern 'events:*'); do echo "=== $k ==="; $R XLEN $k; $R XINFO STREAM $k FULL COUNT 1000 2>/dev/null | head -c 3000; echo; done 2>&1 | head -80

12  $ R="/opt/redis-8.10/bin/redis-cli -p 6379 -n 0"; echo '--- groups (db0) ---'; for k in $($R --scan --pattern 'events:*'); do $R XINFO STREAM $k FULL COUNT 1000 | sed -n '/^groups$/,$p' | head -40; echo '   <---- end'; done 2>&1 | head -100

13  $ R="/opt/redis-8.10/bin/reader.sh 2>/dev/null; bin/redis-cli -p 6379 -n 2"; for k in $($R --scan --pattern '*'); do T=$($R TYPE $k); [ "$T" = "stream" ] && { echo "=== $k ==="; $R XINFO GROUPS $k; }; done 2>&1 | head -60

14  $ V="valkey-cli -p 6380"; $V DEL t1; $V HSET t1 f1 a f2 b; $V HEXPIRE t1 100 FIELDS 1 f1; $V HTTL t1 FIELDS 2 f1 f2; $V HTTL t1 FIELDS 2 f1 nosuch; echo '--- XGROUP SETID ENTRIESREAD ---'; $V DEL s1; $V XADD s1 1-1 a; $V XADD s1 2-1 b; $V XADD s1 3-1 c; $V XGROUP CREATE s1 g 0-0; $V XGROUP SETID s1 g 2-1 ENTRIESREAD 2; $V XINFO GROUPS s1; echo '--- create at 0, no reads ---'; $V XGROUP CREATE s1 g2 0-0; $V XINFO GROUPS s1 | grep -A1 entries-read; echo '--- create at $ ---'; $V XGROUP CREATE s1 g3 '$'; $V XINFO GROUPS s1 | sed -n '/g3/,+16p' | grep -E 'last-delivered|entries-read|lag' 

15  $ V="valkey-cli -p 6380"; $V DEL s2; for i in 1 2 3 4 5; do $V XADD s2 $i-1 v $i; done; $V XGROUP CREATE s2 g 0-0; echo '--- read 3 via XREADGROUP ---'; $V XREADGROUP GROUP g c1 COUNT 3 STREAMS s2 '>'; echo '--- pending ext ---'; $V XPENDING s2 g - + 10; echo '--- claim 2-1 to c2 non-JUSTID (count should become 2) ---'; $V XCLAIM s2 g c2 0 2-1; echo '--- claim 2-1 back to c1 JUSTID IDLE 12345 (count stays 2, idle set) ---'; $V XCLAIM s2 g c1 0 2-1 JUSTID IDLE 12345; $V XPENDING s2 g - + 10; $V XINFO CONSUMERS s2 g

16  $ V="valkey-cli -p 6380"; $V DEL t2; $V HSET t2 f1 a f2 b; NOW=$(($($V TIME | head -1) / 1000)); $V HEXPIREAT t2 $((NOW+100000)) FIELDS 1 f1; $V HPTTL t2 FIELDS 2 f1 f2; echo '--- key TTL + field TTL interplay ---'; $V DEL t3; $V HSET t3 f1 a; $V PEXPIRE t3 50000; $V HEXPIRE t3 40000 FIELDS 1 f1; $V HTTL t3 FIELDS 1 f1; echo '--- field ttl then key ttl ---'; $V DEL t4; $V HSET t4 f1 a; $V HEXPIRE t4 40000 FIELDS 1 f1; $V PEXPIRE t4 50000; $V HTTL t4 FIELDS 1 f1; echo '--- hpersist ---'; $V HPERSIST t4 FIELDS 1 f1; $V HTTL t4 FIELDS 1 f1

17  $ V="valkey-cli -p 6380"; $V DEL s3; for i in 1 2 3 4 5; do $V XADD s3 $i-1 v $i; done; $V XGROUP CREATE s3 g 0-0; echo 'fresh:'; $V XINFO GROUPS s3 | grep -E 'entries-read|lag' ; $V XREADGROUP GROUP g c COUNT 2 STREAMS s3 '>' >/dev/null; echo 'after read 2:'; $V XINFO GROUPS s3 | grep -E 'last-delivered|entries-read|lag'; echo 'SETID 4-1 no ENTRIESREAD:'; $V XGROUP SETID s3 g 4-1; $V XINFO GROUPS s3 | grep -E 'last-delivered|entries-read|lag'; echo 'SETID 2-1 ENTRIESREAD 3:'; $V XGROUP SETID s3 g 2-1 ENTRIESREAD 3; $V XINFO GROUPS s3 | grep -E 'last-delivered|entries-read|lag'; echo 'SETID 5-1 no ENTRIESREAD (null hypothesis):'; $V XGROUP SETID s3 g 5-1; $V XINFO GROUPS s3 | grep -E 'last-delivered|entries-read|lag'

18  $ V="valkey-cli -p 6380"; $V DEL s3; for i in 1 2 3 4 5; do $V XADD s3 $i-1 v $i; done; $V XGROUP CREATE s3 g 0-0; echo 'fresh:'; $V XINFO GROUPS s3 | grep -A1 -E 'entries-read|lag|last-delivered'; $V XREADGROUP GROUP g c COUNT 2 STREAMS s3 '>' >/dev/null; echo 'after read 2:'; $V XINFO GROUPS s3 | grep -A1 -E 'last-delivered|entries-read|lag'; echo 'SETID 4-1 no ENTRIESREAD:'; $V XGROUP SETID s3 g 4-1; $V XINFO GROUPS s3 | grep -A1 -E 'last-delivered|entries-read|lag'; echo 'SETID 2-1 ENTRIESREAD 3:'; $V XGROUP SETID s3 g 2-1 ENTRIESREAD 3; $V XINFO GROUPS s3 | grep -A1 -E 'last-delivered|entries-read|lag'; echo 'SETID 5-1 no ENTRIESREAD:'; $V XGROUP SETID s3 g 5-1; $V XINFO GROUPS s3 | grep -A1 -E 'last-delivered|entries-read|lag'

19  $ V="valkey-cli -p 6380"; $V DEL h9; $V HSET h9 f1 a f2 b; $V HPEXPIRE h9 90000 FIELDS 2 f1 f2; $V HPTTL h9 FIELDS 2 f1 f2; echo '--- HGETALL with expired field gone ---'; $V DEL h10; $V HSET h10 a 1 b 2; $V HPEXPIRE h10 1000 FIELDS 1 a; sleep 1.2; $V HGETALL h10; $V HPEXPIRETIME h10 FIELDS 1 b 2>/dev/null || echo 'no HPEXPIRETIME'

20  $ R="/opt/redis-8.10/bin/redis-cli -p 6379"; echo 'SOURCE TIME:'; $R TIME; echo 'TARGET TIME:'; valkey-cli -p 6380 TIME; echo '--- events:15 groups ---'; $R -n 0 XINFO GROUPS events:15; echo '--- consumers ---'; $R -n 0 XINFO CONSUMERS events:15 workers; echo '--- pending ext ---'; $R -n 0 XPENDING events:15 workers - + 50; echo '--- full group block ---'; $R -n 0 XINFO STREAM events:15 FULL COUNT 1000 | sed -n '/^groups$/,$p' | head -60

21  $ V="valkey-cli -p 6380"; $V DEL s5; for i in 1 2 3; do $V XADD s5 $i-1 v $i; done; $V XGROUP CREATE s5 g 0-0; $V XREADGROUP GROUP g alice COUNT 2 STREAMS s5 '>' >/dev/null; sleep 0.2; echo '--- XCLAIM full IDLE 5000000 to bob ---'; $V XCLAIM s5 g bob 0 1-1 IDLE 5000000; echo 'pending:'; $V XPENDING s5 g - + 10; echo 'consumers:'; $V XINFO CONSUMERS s5 g

22  $ valkey-cli -p 6380 CONFIG SET replicaof 127.0.0.1 6379; sleep 2; valkey-cli -p 6380 INFO replication; echo '--- keyspace after sync ---'; valkey-cli -p 6380 INFO keyspace; valkey-cli -p 6380 DBSIZE

23  $ V="valkey-cli -p 6380"; for k in exp:k s2 s3 s5 t1 t2 t3 t4 h9 h10; do $V DEL $k >/dev/null; done; $V INFO keyspace; echo '--- now attempt sync (fixed syntax) ---'; $V CONFIG SET replicaof "127.0.0.1 6379"; sleep 3; $V INFO replication | head -12; echo '--- keyspace ---'; $V INFO keyspace; $V DBSIZE

24  $ V="valkey-cli -p 6380"; echo '--- command presence ---'; $V COMMAND INFO REPLICAOF SECONDOF 2>&1 | grep -E 'replicaof|secondof'; echo '--- config get ---'; $V CONFIG GET replicaof; $V CONFIG GET '*immutable*' 2>/dev/null; $V CONFIG GET 'allow*' 2>/dev/null | head; echo '--- try REPLICAOF NO ONE on empty server ---'; $V REPLICAOF NO ONE; echo '--- try SECONDOF 0 ---'; $V SECONDOF 0

25  $ V="valkey-cli -p 6380"; $V REPLICAOF 127.0.0.1 6379; sleep 3; $V INFO replication | head -14; echo '--- keyspace after sync ---'; $V INFO keyspace; $V DBSIZE; echo '--- compare a stream group state ---'; $R=""; /opt/redis-8.10/bin/redis-cli -p 6379 -n 0 XINFO STREAM events:15 FULL COUNT 1000 | sed -n '/^groups$/,$p' | head -30; echo '=== on valkey ==='; $V -n 0 XINFO STREAM events:15 FULL COUNT 1000 | sed -n '/^groups$/,$p' | head -30

26  $ tail -30 /var/log/valkey/valkey.log; echo '=== REDIS LOG ==='; tail -20 /var/log/redis-old/redis.log

27  $ V="valkey-cli -p 6380"; $V REPLICAOF NO ONE; sleep 1; $V INFO replication | head -3; echo '--- DUMP/RESTORE test (expect failure) ---'; D=$(/opt/redis-8.10/bin/redis-cli -p 6379 DUMP visitors:01 | base64 -w0); echo "dump_b64_len=${#D}"; echo -n "$D" | base64 -d > /tmp/d.bin; python3 - <<'EOF'
import socket
s=socket.create_connection(('127.0.0.1',6380))
def cmd(c):
    p=b'*%d\r\n'%len(c)+b''.join(b'$%d\r\n%s\r\n'%(len(x),x) for x in c)
    s.sendall(p)
    f=s.makefile('rb')
    def r():
        l=f.readline()[:-2]
        t,rest=l[:1],l[1:]
        if t in b'+-:#,_': return (t,rest)
        if t==b'$':
            n=int(rest)
            return (t, f.read(n+2)[:-2] if n>=0 else None)
        if t==b'*':
            n=int(rest); return (t,[r() for _ in range(n)])
    return r()
data=open('/tmp/d.bin','rb').read()
print('RESTORE reply:', cmd([b'RESTORE', b'testrestore', b'0', data]))
s.close()
EOF
valkey-cli -p 6380 DEL testrestore 2>/dev/null; valkey-cli -p 6380 INFO keyspace

28  $ R="/opt/redis-8.10/bin/redis-cli -p 6379"; for DB in 0 2; do echo "=== DB $DB streams ==="; $R -n $DB --scan --pattern '*' | while read k; do T=$($R -n $DB TYPE $k); if [ "$T" = "stream" ]; then L=$($R -n $DB XLEN $k); F=$($R -n $DB XINFO STREAM $k FULL COUNT 1 | grep -E '^(entries-added|max-deleted-entry-id|recorded-first-entry-id|last-generated-id)' -A1 | paste - - | tr '\n' ' '); G=$($R -n $DB XINFO GROUPS $k | grep -c name); echo "$k len=$L groups=$G | $F"; fi; done; done 2>&1

29  $ V="valkey-cli -p 6380"; echo '--- XGROUP CREATE with ENTRIESREAD ---'; $V DEL s6; for i in 1 2 3 4 5; do $V XADD s6 $i-1 v $i >/dev/null; done; $V XGROUP CREATE s6 g 2-1 ENTRIESREAD 2; $V XINFO GROUPS s6; echo '--- XCLAIM FORCE JUSTID TIME (pel creation) ---'; $V XCLAIM s6 g w1 0 1-1 FORCE JUSTID TIME 1700000000000; $V XPENDING s6 g - + 10; echo '--- increment delivery count ---'; $V XCLAIM s6 g w1 0 1-1 TIME 1700000000000; $V XPENDING s6 g - + 10; echo '--- XGROUP CREATECONSUMER ---'; $V XGROUP CREATECONSUMER s6 g idlebob; $V XINFO CONSUMERS s6 g; echo '--- HPEXPIREAT ---'; $V DEL h11; $V HSET h11 a 1 b 2; $V HPEXPIREAT h11 1792000000000 FIELDS 1 a; $V HPEXPIRETIME h11 FIELDS 2 a b

30  $ R="/opt/redis-8.10/bin/redis-cli -p 6379"; for K in events:00 events:01 events:02 events:03 events:04 events:05 events:06 events:07 events:08 events:09; do echo "########## $K"; $R -n 0 XINFO GROUPS $K; echo "-- consumers --"; for g in $($R -n 0 XINFO GROUPS $K | sed -n 'n;p'); do echo "[$g]"; $R -n 0 XINFO CONSUMERS $K $g; done; done 2>&1 | head -120

31  $ R="/opt/redis-8.10/bin/redis-cli -p 6379"; $R COMMAND INFO HPEXPIRETIME HPTTL HTTL HPTEXPIREAT HPEXPIREAT HEXPIREAT HGETEX 2>&1 | grep -E 'h(pexp|ttl|exp)|hget' | head

32  $ R="/opt/redis-8.10/bin/redis-cli -p 6379 -n 0"; for k in $($R --scan --pattern 'user:*' | head -300); do if [ "$($R TYPE $k)" = "hash" ]; then FS=$($R HKEYS $k | tr '\n' ' '); N=$(echo $FS | wc -w); C=$($R HTTL $k FIELDS $N $FS 2>/dev/null | grep -cE '^[0-9]+$'); if [ "$C" -gt 0 ]; then NOW=$($R TIME | head -1); echo "KEY $k FIELDS: $FS"; echo "HTTL: $($R HTTL $k FIELDS $N $FS | tr '\n' ' ')"; echo "HPEXPIRETIME: $($R HPEXPIRETIME $k FIELDS $N $FS 2>&1 | tr '\n' ' ')"; echo "NOW_S: $NOW"; $R PTTL $k; break; fi; fi; done 2>&1 | head -20

33  $ cat > /tmp/rc.py <<'PYEOF'
import socket

class RedisError(Exception):
    pass

class RC:
    """Minimal raw RESP2 client with pipelining."""
    def __init__(self, host='127.0.0.1', port=6379, db=0):
        self.s = socket.create_connection((host, port))
        self.f = self.s.makefile('rb')
        self.db = db
        if db:
            r = self.cmd('SELECT', db)
            assert r == b'OK', r

    def _read(self):
        l = self.f.readline()
        if not l:
            raise RedisError('connection closed')
        l = l[:-2]
        t, rest = l[:1], l[1:]
        if t in (b'+', b':'):
            return rest if t == b'+' else int(rest)
        if t == b'-':
            raise RedisError(rest.decode('utf-8', 'replace'))
        if t == b'$':
            n = int(rest)
            if n == -1:
                return None
            return self.f.read(n + 2)[:-2]
        if t == b'*':
            n = int(rest)
            if n == -1:
                return None
            return [self._read() for _ in range(n)]
        if t == b'_':
            return None
        if t == b'%':
            n = int(rest)
            out = {}
            for _ in range(n):
                k = self._read(); v = self._read(); out[k] = v
            return out
        if t == b'#':
            return rest == b't'
        if t == b',':
            return float(rest)
        if t == b'(':
            return int(rest)
        if t == b'>':
            n = int(rest)
            return [self._read() for _ in range(n)]
        if t == b'~':
            n = int(rest)
            return [self._read() for _ in range(n)]
        raise RedisError('unknown resp type %r' % l)

    def cmd(self, *args):
        return self.pipeline([args])[0]

    def pipeline(self, cmds):
        buf = bytearray()
        for c in cmds:
            buf += b'*%d\r\n' % len(c)
            for a in c:
                if isinstance(a, str):
                    a = a.encode()
                buf += b'$%d\r\n%s\r\n' % (len(a), a)
        self.s.sendall(bytes(buf))
        return [self._read() for _ in cmds]

    def scan(self, pattern='*', count=500):
        cur = b'0'
        while True:
            cur, keys = self.cmd('SCAN', cur, 'COUNT', 1000, 'MATCH', pattern)
            for k in keys:
                yield k
            if cur == b'0':
                break

    def close(self):
        try: self.s.close()
        except Exception: pass
PYEOF
python3 - <<'EOF'
import sys; sys.path.insert(0, '/tmp')
from rc import RC
# sanity: basic ops + a type with binary-safe roundtrip
r = RC(6379, 0)
print('ping:', r.cmd('PING'))
print('dbsize:', r.cmd('DBSIZE'))
print('type:', r.cmd('TYPE', 'visitors:01'))
v = r.cmd('GET', 'visitors:01')
print('len visitors:01:', len(v), 'head:', v[:40])
t = r.cmd('TIME')
print('time:', t)
r.close()
EOF

34  $ python3 - <<'EOF'
import sys; sys.path.insert(0, '/tmp')
from rc import RC
r = RC(port=6379, db=0)
print('ping:', r.cmd('PING'))
print('dbsize:', r.cmd('DBSIZE'))
print('type:', r.cmd('TYPE', 'visitors:01'))
v = r.cmd('GET', 'visitors:01')
print('len visitors:01:', len(v), 'head:', v[:40])
print('time:', r.cmd('TIME'))
r.close()
EOF

35  $ cat > /tmp/analyze.py <<'PYEOF'
import sys, json
sys.path.insert(0, '/tmp')
from rc import RC

out = {}
for db in (0, 2):
    r = RC(port=6379, db=db)
    keys = list(r.scan('*', 1000))
    types = {}
    pipes = [[b'TYPE', k] for k in keys]
    res = r.pipeline(pipes)
    for k, t in zip(keys, res):
        types.setdefault(t.decode(), []).append(k)
    info = {'total': len(keys), 'types': {t: len(v) for t, v in types.items()}}
    # key TTLs
    res = r.pipeline([[b'PTTL', k] for k in keys])
    ttls = [int(t) for t in res]
    vol = [(k.decode(), t) for k, t in zip(keys, ttls) if t >= 0]
    info['volatile'] = len(vol)
    info['ttl_min_s'] = round(min(vol, key=lambda x: x[1])[1]/1000, 3) if vol else None
    info['ttl_max_s'] = round(max(vol, key=lambda x: x[1])[1]/1000, 3) if vol else None
    info['ttl_over_2_31_ms'] = sum(1 for k, t in vol if t >= 2**31-1)
    # hashes: field-level TTL inspection
    fttl_present, fttl_big, mismatches, ttls_all = [], [], [], []
    hsamples = 0
    for h in types.get('hash', []):
        fields = r.cmd('HKEYS', h)
        n = len(fields)
        hsamples += 1
        pe = r.cmd('HPEXPIRETIME', h, 'FIELDS', n, *fields)
        pt = r.cmd('HPTTL', h, 'FIELDS', n, *fields)
        cnt = sum(1 for v in pe if isinstance(v, int) and v > 0)
        fttl_all = [v for v in pt if isinstance(v, int) and v >= 0]
        if fttl_all:
            ttls_all.extend(fttl_all)
            if cnt != n:
                fttl_present.append((h.decode(), cnt, n))
            for v in fttl_all:
                if v >= 2**31-1:
                    fttl_big.append((h.decode(), v))
        hl = r.cmd('HLEN', h)
        if hl != n:
            mismatches.append((h.decode(), n, hl))
    info['hashes_scanned'] = hsamples
    info['hash_partial_field_ttl'] = fttl_present
    info['hash_field_ttl_ge_2_31'] = fttl_big
    info['hash_hlen_hkeys_mismatch'] = mismatches
    if ttls_all:
        info['field_ttl_min_s'] = round(min(ttls_all)/1000, 3)
        info['field_ttl_max_s'] = round(max(ttls_all)/1000, 3)
    out['db%d' % db] = info
    r.close()

# streams
sr = RC(port=6379, db=0)
streams = types0 = None
streams = [k for k, t in zip([k for k in RC(port=6379, db=0).scan('*', 1000)], [])]
out['streams'] = {}
for k in types.get('stream', []):
    st = sr.cmd('XINFO', 'STREAM', k, 'FULL', 'COUNT', 100000)
    gs = []
    for g in st.get(b'groups', []):
        gs.append({
            'name': g.get(b'name').decode(),
            'last-delivered': g.get(b'last-delivered-id').decode(),
            'entries-read': g.get(b'entries-read'),
            'lag': g.get(b'lag'),
            'pel': len(g.get(b'pending', [])),
            'consumers': [(c.get(b'name').decode(), c.get(b'pending'), c.get(b'idle'), c.get(b'inactive')) for c in g.get(b'consumers', [])],
        })
    out['streams'][k.decode()] = {
        'length': st.get(b'length'),
        'entries-added': st.get(b'entries-added'),
        'max-deleted': st.get(b'max-deleted-entry-id').decode(),
        'first': st.get(b'recorded-first-entry-id').decode(),
        'last': st.get(b'last-generated-id').decode(),
        'groups': gs,
    }
print(json.dumps(out, indent=1, default=repr))
PYEOF
python3 /tmp/analyze.py 2>&1 | head -150

36  $ python3 - <<'EOF'
import re
src = open('/tmp/rc.py').read()
src = src.replace("""                if isinstance(a, str):
                    a = a.encode()""", """                if isinstance(a, str):
                    a = a.encode()
                elif isinstance(a, int):
                    a = b'%d' % a""")
open('/tmp/rc.py','w').write(src)
print('patched')
EOF
python3 /tmp/analyze.py 2>&1 | head -160

37  $ python3 /tmp/analyze.py 2>/dev/null > /tmp/analysis.json; python3 - <<'EOF'
import json
d = json.load(open('/tmp/analysis.json'))
for db in ('db0','db2'):
    i = d[db]
    print(f"=== {db}: total={i['total']} types={i['types']} volatile={i['volatile']}")
    print(f"  key ttl range s: {i['ttl_min_s']} .. {i['ttl_max_s']}  over_2^31ms: {i['ttl_over_2_31_ms']}")
    print(f"  hashes={i['hashes_scanned']} partial-fttl={len(i['hash_partial_field_ttl'])} fttl>2^31={len(i['hash_field_ttl_ge_2_31'])} hlen-mismatch={i['hash_hlen_hkeys_mismatch']}")
    if 'field_ttl_min_s' in i:
        print(f"  field ttl range s: {i['field_ttl_min_s']} .. {i['field_ttl_max_s']}")
print()
st = d['streams']
print(f"=== {len(st)} streams ===")
for k, s in sorted(st.items()):
    gs = s['groups']
    print(f"{k}: len={s['length']} added={s['entries-added']} maxdel={s['max-deleted']} first={s['first']}")
    for g in gs:
        print(f"   g={g['name']} last={g['last-delivered']} er={g['entries-read']} lag={g['lag']} pel={g['pel']} cons={g['consumers']}")
EOF

38  $ python3 - <<'EOF'
import sys; sys.path.insert(0, '/tmp')
from rc import RC
import json
sr = RC(port=6379, db=0)
out = {}
keys = list(sr.scan('*'))
types = {}
res = sr.pipeline([[b'TYPE', k] for k in keys])
for k, t in zip(keys, res):
    types.setdefault(t.decode(), []).append(k)
for k in types.get('stream', []):
    st = sr.cmd('XINFO', 'STREAM', k, 'FULL', 'COUNT', 100000)
    gs = []
    for g in st.get(b'groups', []):
        gs.append({
            'name': g.get(b'name').decode(),
            'last-delivered': g.get(b'last-delivered-id').decode(),
            'entries-read': g.get(b'entries-read'),
            'lag': g.get(b'lag'),
            'pel': len(g.get(b'pending', [])),
            'consumers': [(c.get(b'name').decode(), c.get(b'pending'), c.get(b'idle'), c.get(b'inactive')) for c in g.get(b'consumers', [])],
        })
    out[k.decode()] = {
        'length': st.get(b'length'),
        'entries-added': st.get(b'entries-added'),
        'max-deleted': st.get(b'max-deleted-entry-id').decode(),
        'first': st.get(b'recorded-first-entry-id').decode(),
        'last': st.get(b'last-generated-id').decode(),
        'groups': gs,
    }
json.dump(out, open('/tmp/streams.json','w'))
print(f"{len(out)} streams")
for k, s in sorted(out.items()):
    print(f"{k}: len={s['length']} added={s['entries-added']} maxdel={s['max-deleted']} first={s['first']} last={s['last']}")
    for g in s['groups']:
        print(f"   g={g['name']} last={g['last-delivered']} er={g['entries-read']} lag={g['lag']} pel={g['pel']} cons={g['consumers']}")
sr.close()
EOF

39  $ python3 - <<'EOF'
import sys; sys.path.insert(0, '/tmp')
from rc import RC
r = RC(port=6379, db=0)
st = r.cmd('XINFO', 'STREAM', 'events:01', 'FULL', 'COUNT', 2)
print('type:', type(st))
print('keys:', list(st.keys()) if isinstance(st, dict) else st[:3])
g = st[b'groups']
print('groups type:', type(g), 'len:', len(g))
print('g[0]:', g[0])
print('first 2 entries:', st[b'entries'][:1])
r.close()
EOF

40  $ python3 - <<'EOF'
src = open('/tmp/rc.py').read()
src = src.replace("""        self.db = db
        if db:
            r = self.cmd('SELECT', db)
            assert r == b'OK', r""", """        self.db = db
        self.resp3 = False
        try:
            if self.cmd('HELLO', 3) not in (b'OK',) and isinstance(self.cmd('HELLO', 3), dict):
                pass
        except Exception:
            pass
        try:
            r = self.cmd('HELLO', 3)
            if isinstance(r, dict):
                self.resp3 = True
        except Exception:
            pass
        if db:
            r = self.cmd('SELECT', db)
            assert r == b'OK', r""")
open('/tmp/rc.py','w').write(src)
print('patched')
EOF
python3 - <<'EOF'
import sys; sys.path.insert(0, '/tmp')
from rc import RC
r = RC(port=6379, db=0)
print('resp3:', r.resp3)
st = r.cmd('XINFO', 'STREAM', 'events:01', 'FULL', 'COUNT', 1)
print('type:', type(st))
if isinstance(st, dict):
    print('keys:', [k.decode() for k in st.keys()])
    g = st[b'groups']
    print('g[0]:', {k.decode(): v for k, v in g[0].items()})
r.close()
EOF

41  $ python3 - <<'EOF'
import sys, json; sys.path.insert(0, '/tmp')
from rc import RC
r = RC(port=6379, db=0)
out = {}
keys = list(r.scan('*'))
types = {}
res = r.pipeline([[b'TYPE', k] for k in keys])
for k, t in zip(keys, res):
    types.setdefault(t.decode(), []).append(k)
for k in types.get('stream', []):
    st = r.cmd('XINFO', 'STREAM', k, 'FULL', 'COUNT', 100000)
    gs = []
    for g in st.get(b'groups', []):
        gs.append({
            'name': g[b'name'].decode(),
            'last-delivered': g[b'last-delivered-id'].decode(),
            'entries-read': g.get(b'entries-read'),
            'lag': g.get(b'lag'),
            'pel-count': g[b'pel-count'],
            'nacked-count': g.get(b'nacked-count'),
            'pending': [[p[0].decode(), p[1].decode(), p[2], p[3]] for p in g.get(b'pending', [])],
            'consumers': [{'name': c[b'name'].decode(),
                           'seen-time': c.get(b'seen-time'),
                           'active-time': c.get(b'active-time'),
                           'pel-count': c[b'pel-count'],
                           'pending': [[p[0].decode(), p[1], p[2]] for p in c.get(b'pending', [])]} for c in g.get(b'consumers', [])],
        })
    out[k.decode()] = {
        'length': st[b'length'], 'entries-added': st[b'entries-added'],
        'max-deleted': st[b'max-deleted-entry-id'].decode(),
        'first': st[b'recorded-first-entry-id'].decode(),
        'last': st[b'last-generated-id'].decode(),
        'groups': gs}
json.dump(out, open('/tmp/streams.json', 'w'), indent=1)
print(len(out), 'streams dumped')
for k, s in sorted(out.items()):
    print(f"{k}: len={s['length']} added={s['entries-added']} maxdel={s['max-deleted']} first={s['first']} last={s['last']}")
    for g in s['groups']:
        cons = [(c['name'], c['pel-count'], c['seen-time']) for c in g['consumers']]
        print(f"   g={g['name']:<8} last={g['last-delivered']} er={g['entries-read']} lag={g['lag']} pel={g['pel-count']} nacked={g['nacked-count']} cons={cons}")
        for p in g['pending']:
            print(f"      pending {p}")
r.close()
EOF

42  $ cat > /tmp/migrate.py <<'PYEOF'
#!/usr/bin/env python3
"""Migrate Redis 8.10 -> Valkey 9.1 with exact state reproduction.

Phase 1: snapshot source (logical, binary-safe) -> /tmp/snapshot.pkl
Phase 2: load into target (data, key TTLs via PEXPIREAT, hash field TTLs via
         HPEXPIREAT, streams incl. consumer groups/PEL/consumers)
Phase 3: verify target against a FRESH read of source
"""
import sys, pickle, time
sys.path.insert(0, '/tmp')
from rc import RC

SRC = dict(host='127.0.0.1', port=6379)
DST = dict(host='127.0.0.1', port=6380)
DBS = [0, 2]
BATCH = 400

def batches(seq, n=BATCH):
    buf = []
    for x in seq:
        buf.append(x)
        if len(buf) >= n:
            yield buf
            buf = []
    if buf:
        yield buf

# ---------------------------------------------------------------- phase 1
def snapshot():
    snap = {'when': time.time(), 'src_time': None, 'dbs': {}}
    for db in DBS:
        r = RC(port=SRC['port'], db=db)
        snap['src_time'] = r.cmd('TIME')
        keys = list(r.scan('*'))
        types = {}
        res = r.pipeline([[b'TYPE', k] for k in keys])
        for k, t in zip(keys, res):
            types.setdefault(t.decode(), []).append(k)
        info = {'types': {t: len(v) for t, v in types.items()}, 'keys': {}}
        # absolute key expiries
        for kb in batches(keys):
            res = r.pipeline([[b'PEXPIRETIME', k] for k in kb])
            for k, pe in zip(kb, res):
                info['keys'][k] = {'type': None, 'pexpiretime': pe}
        for k, t in zip(keys, res if False else []):
            pass
        # fill types
        for t, ks in types.items():
            for k in ks:
                info['keys'][k]['type'] = t
        # values
        for t, ks in types.items():
            for kb in batches(ks):
                cmds, idx = [], []
                for k in kb:
                    kt = info['keys'][k]['type']
                    if kt == 'string':
                        cmds.append([b'GET', k])
                    elif kt == 'list':
                        cmds.append([b'LRANGE', k, b'0', b'-1'])
                    elif kt == 'set':
                        cmds.append([b'SMEMBERS', k])
                    elif kt == 'zset':
                        cmds.append([b'ZRANGE', k, b'0', b'-1', b'WITHSCORES'])
                    elif kt == 'hash':
                        cmds.append([b'HGETALL', k])
                    elif kt == 'stream':
                        cmds.append([b'XRANGE', k, b'-', b'+'])
                    else:
                        raise SystemExit('unknown type %r for %r' % (kt, k))
                out = r.pipeline(cmds)
                for k, v in zip(kb, out):
                    info['keys'][k]['value'] = v
        # hash field expiries (absolute unix ms)
        for h in types.get('hash', []):
            fields = list(info['keys'][h]['value'].keys())
            pe = r.pipeline([[b'HPEXPIRETIME', h, b'FIELDS', len(fields)] + fields])
            info['keys'][h]['field_pexpiretime'] = dict(zip(fields, pe[0]))
        # stream metadata + groups
        for s in types.get('stream', []):
            st = r.cmd('XINFO', 'STREAM', s, 'FULL', 'COUNT', 1000000)
            groups = []
            for g in st.get(b'groups', []):
                groups.append({
                    'name': g[b'name'],
                    'last-delivered-id': g[b'last-delivered-id'],
                    'entries-read': g.get(b'entries-read'),
                    'lag': g.get(b'lag'),
                    'pel-count': g[b'pel-count'],
                    'nacked-count': g.get(b'nacked-count'),
                    'pending': [[p[0], p[1], p[2], p[3]] for p in g.get(b'pending', [])],
                    'consumers': [{'name': c[b'name'],
                                   'seen-time': c.get(b'seen-time'),
                                   'active-time': c.get(b'active-time'),
                                   'pel-count': c[b'pel-count'],
                                   'pending': [[p[0], p[1], p[2]] for p in c.get(b'pending', [])]}
                                  for c in g.get(b'consumers', [])],
                })
            info['keys'][s]['stream_info'] = {
                'length': st[b'length'],
                'entries-added': st[b'entries-added'],
                'max-deleted-entry-id': st[b'max-deleted-entry-id'],
                'recorded-first-entry-id': st[b'recorded-first-entry-id'],
                'last-generated-id': st[b'last-generated-id'],
                'pids-tracked': st.get(b'pids-tracked'),
                'iids-tracked': st.get(b'iids-tracked'),
                'groups': groups,
            }
        r.close()
        snap['dbs'][db] = info
    with open('/tmp/snapshot.pkl', 'wb') as f:
        pickle.dump(snap, f)
    return snap

# ---------------------------------------------------------------- phase 2
def load(snap):
    loaded = {}
    for db in DBS:
        info = snap['dbs'][db]
        v = RC(port=DST['port'], db=db)
        assert v.cmd('DBSIZE') == 0, 'target db %d not empty' % db
        n = {'set': 0, 'fttl': 0, 'pel': 0, 'groups': 0, 'consumers': 0}
        # 1. data
        for kb in batches(list(info['keys'].keys())):
            cmds = []
            for k in kb:
                t = info['keys'][k]['type']
                val = info['keys'][k]['value']
                if t == 'string':
                    cmds.append([b'SET', k, val])
                elif t == 'list':
                    cmds.append([b'RPUSH', k] + val)
                elif t == 'set':
                    cmds.append([b'SADD', k] + val)
                elif t == 'zset':
                    c = [b'ZADD', k]
                    for i in range(0, len(val), 2):
                        c += [val[i + 1], val[i]]
                    cmds.append(c)
                elif t == 'hash':
                    c = [b'HSET', k]
                    for f, fv in val.items():
                        c += [f, fv]
                    cmds.append(c)
                elif t == 'stream':
                    c = [b'XADD', k]
                    for eid, fields in val:
                        c.append(eid)
                        for f, fv in fields.items():
                            c += [f, fv]
                    cmds.append(c)
            res = v.pipeline(cmds)
            for rr in res:
                if rr != b'OK':
                    raise SystemExit('write failed: %r' % (rr,))
            n['set'] += len(cmds)
        # 2. key TTLs (absolute) - before field TTLs for safety
        vol = [(k, v['pexpiretime']) for k, v in info['keys'].items()
               if isinstance(v['pexpiretime'], int) and v['pexpiretime'] > 0]
        for kb in batches(vol):
            res = v.pipeline([[b'PEXPIREAT', k, pe] for k, pe in kb])
            for rr in res:
                if rr != 1:
                    raise SystemExit('PEXPIREAT failed: %r' % (rr,))
            n['set'] += len(kb)
        # 3. hash field TTLs (absolute)
        for k, kd in info['keys'].items():
            if kd['type'] != 'hash':
                continue
            fe = [(f, t) for f, t in kd['field_pexpiretime'].items()
                  if isinstance(t, int) and t > 0]
            for fb in batches(fe):
                c = [b'HPEXPIREAT', k, b'FIELDS', len(fb)]
                for f, t in fb:
                    c += [f, t]
                rr = v.cmd(*c)
                cnt = sum(1 for x in rr if x == 1)
                if cnt != len(fb):
                    raise SystemExit('HPEXPIREAT mismatch %r vs %d' % (rr, len(fb)))
                n['fttl'] += len(fb)
        # 4. streams: groups, consumers, PEL
        for k, kd in info['keys'].items():
            if kd['type'] != 'stream':
                continue
            si = kd['stream_info']
            for g in si['groups']:
                if g['entries-read'] is None:
                    # null entries-read reproduced by XGROUP CREATE $ (er=null, lag=0)
                    rr = v.cmd(b'XGROUP', b'CREATE', k, g['name'], b'$')
                else:
                    rr = v.cmd(b'XGROUP', b'CREATE', k, g['name'],
                               g['last-delivered-id'], b'ENTRIESREAD', g['entries-read'])
                if rr != b'OK':
                    raise SystemExit('XGROUP CREATE failed: %r' % (rr,))
                n['groups'] += 1
                for c in g['consumers']:
                    rr = v.cmd(b'XGROUP', b'CREATECONSUMER', k, g['name'], c['name'])
                    if rr != 1:
                        raise SystemExit('CREATECONSUMER failed: %r' % (rr,))
                    n['consumers'] += 1
                # PEL: FORCE+JUSTID keeps delivery-count, TIME sets delivery timestamp
                pel = g['pending']
                for pb in batches(pel, 200):
                    res = v.pipeline([[b'XCLAIM', k, g['name'], p[1], b'0', p[0],
                                       b'FORCE', b'JUSTID', b'TIME', p[2]] for p in pb])
                    for rr, p in zip(res, pb):
                        if not (isinstance(rr, list) and rr and rr[0] == p[0]):
                            raise SystemExit('XCLAIM FORCE failed: %r' % (rr,))
                        n['pel'] += 1
        # sanity counters
        dbsize = v.cmd('DBSIZE')
        loaded[db] = (n, dbsize)
        v.close()
    return loaded

# ---------------------------------------------------------------- phase 3
def verify(snap):
    problems, notes = [], []
    max_ttl_delta = 0
    max_seen_delta = 0
    for db in DBS:
        s = RC(port=SRC['port'], db=db)
        t = RC(port=DST['port'], db=db)
        skeys = sorted(s.scan('*'))
        tkeys = sorted(t.scan('*'))
        if skeys != tkeys:
            only_s = set(map(bytes, skeys)) - set(map(bytes, tkeys))
            only_t = set(map(bytes, tkeys)) - set(map(bytes, skeys))
            problems.append('db%d keyset differs: only-src=%d only-dst=%d (e.g. %r / %r)'
                            % (db, len(only_s), len(only_t), list(only_s)[:3], list(only_t)[:3]))
            continue
        # types + absolute key expiry
        st = s.pipeline([[b'TYPE', k] for k in skeys])
        tt = t.pipeline([[b'TYPE', k] for k in skeys])
        for k, a, b in zip(skeys, st, tt):
            if a != b:
                problems.append('db%d %r type %r != %r' % (db, k, a, b))
        spe = s.pipeline([[b'PEXPIRETIME', k] for k in skeys])
        tpe = t.pipeline([[b'PEXPIRETIME', k] for k in skeys])
        for k, a, b in zip(skeys, spe, tpe):
            if a != b:
                delta = abs((a or 0) - (b or 0))
                max_ttl_delta = max(max_ttl_delta, delta)
                if delta > 5000:
                    problems.append('db%d %r pexpiretime %r != %r' % (db, k, a, b))
        # remaining ttl quick compare
        spt = s.pipeline([[b'PTTL', k] for k in skeys])
        tpt = t.pipeline([[b'PTTL', k] for k in skeys])
        for k, a, b in zip(skeys, spt, tpt):
            if (a < 0) != (b < 0) or (a >= 0 and b >= 0 and abs(a - b) > 5000):
                problems.append('db%d %r PTTL %r vs %r' % (db, k, a, b))
        # values
        for k in skeys:
            ty = s.cmd('TYPE', k)
            if ty == b'string':
                a, b = s.cmd('GET', k), t.cmd('GET', k)
                if a != b: problems.append('db%d string %r value differs' % (db, k))
            elif ty == b'list':
                a, b = s.cmd('LRANGE', k, 0, -1), t.cmd('LRANGE', k, 0, -1)
                if a != b: problems.append('db%d list %r value differs' % (db, k))
            elif ty == b'set':
                a, b = s.cmd('SMEMBERS', k), t.cmd('SMEMBERS', k)
                if sorted(a) != sorted(b): problems.append('db%d set %r value differs' % (db, k))
            elif ty == b'zset':
                a, b = s.cmd('ZRANGE', k, 0, -1, b'WITHSCORES'), t.cmd('ZRANGE', k, 0, -1, b'WITHSCORES')
                if a != b: problems.append('db%d zset %r value differs' % (db, k))
            elif ty == b'hash':
                a, b = s.cmd('HGETALL', k), t.cmd('HGETALL', k)
                if a != b: problems.append('db%d hash %r value differs' % (db, k))
                sf = list(a.keys())
                if sf:
                    af = s.pipeline([[b'HPEXPIRETIME', k, b'FIELDS', len(sf)] + sf])
                    bf = t.pipeline([[b'HPEXPIRETIME', k, b'FIELDS', len(sf)] + sf])
                    for f, x, y in zip(sf, af[0], bf[0]):
                        if x != y:
                            problems.append('db%d hash %r field %r expiry %r != %r' % (db, k, f, x, y))
            elif ty == b'stream':
                a, b = s.cmd('XRANGE', k, b'-', b'+'), t.cmd('XRANGE', k, b'-', b'+')
                if a != b: problems.append('db%d stream %r entries differ' % (db, k))
                si, ti = s.cmd('XINFO', 'STREAM', k, 'FULL', 'COUNT', 1000000), t.cmd('XINFO', 'STREAM', k, 'FULL', 'COUNT', 1000000)
                for fld in (b'length', b'entries-added', b'max-deleted-entry-id',
                            b'recorded-first-entry-id', b'last-generated-id'):
                    if si.get(fld) != ti.get(fld):
                        problems.append('db%d stream %r %s %r != %r' % (db, k, fld.decode(), si.get(fld), ti.get(fld)))
                sg = {g[b'name']: g for g in si.get(b'groups', [])}
                tg = {g[b'name']: g for g in ti.get(b'groups', [])}
                if set(sg) != set(tg):
                    problems.append('db%d stream %r group names differ %r vs %r' % (db, k, set(sg), set(tg)))
                    continue
                for name, g in sg.items():
                    h = tg[name]
                    for fld in (b'last-delivered-id', b'entries-read', b'lag', b'pel-count'):
                        if g.get(fld) != h.get(fld):
                            problems.append('db%d stream %r group %s %s %r != %r'
                                            % (db, k, name.decode(), fld.decode(), g.get(fld), h.get(fld)))
                    sp = [[p[0], p[1], p[3]] for p in g.get(b'pending', [])]
                    tp = [[p[0], p[1], p[3]] for p in h.get(b'pending', [])]
                    if sorted(sp) != sorted(tp):
                        problems.append('db%d stream %r group %s PEL differs\n  src=%r\n  dst=%r'
                                        % (db, k, name.decode(), sorted(sp)[:5], sorted(tp)[:5]))
                    # delivery timestamps (absolute) should match exactly
                    stimes = sorted(p[2] for p in g.get(b'pending', []))
                    ttimes = sorted(p[2] for p in h.get(b'pending', []))
                    if stimes != ttimes:
                        problems.append('db%d stream %r group %s delivery times differ %r vs %r'
                                        % (db, k, name.decode(), stimes[:3], ttimes[:3]))
                    sc = {c[b'name']: c for c in g.get(b'consumers', [])}
                    tc = {c[b'name']: c for c in h.get(b'consumers', [])}
                    if set(sc) != set(tc):
                        problems.append('db%d stream %r group %s consumer names differ %r vs %r'
                                        % (db, k, name.decode(), set(sc), set(tc)))
                    else:
                        for cn, c in sc.items():
                            d = tc[cn]
                            if c[b'pel-count'] != d[b'pel-count']:
                                problems.append('db%d stream %r group %s consumer %s pel-count %r != %r'
                                                % (db, k, name.decode(), cn.decode(), c[b'pel-count'], d[b'pel-count']))
                            if c.get(b'seen-time') and d.get(b'seen-time'):
                                max_seen_delta = max(max_seen_delta, abs(c[b'seen-time'] - d[b'seen-time']))
        n_src, n_dst = s.cmd('DBSIZE'), t.cmd('DBSIZE')
        if n_src != n_dst:
            problems.append('db%d DBSIZE %r != %r' % (db, n_src, n_dst))
        s.close(); t.close()
    return problems, notes, max_ttl_delta, max_seen_delta

if __name__ == '__main__':
    mode = sys.argv[1]
    if mode == 'snapshot':
        snap = snapshot()
        for db in DBS:
            i = snap['dbs'][db]
            nfttl = sum(1 for kd in i['keys'].values() if kd['type'] == 'hash'
                        for t in kd['field_pexpiretime'].values() if isinstance(t, int) and t > 0)
            nvol = sum(1 for kd in i['keys'].values() if isinstance(kd['pexpiretime'], int) and kd['pexpiretime'] > 0)
            idm = sum((kd.get('stream_info', {}).get('pids-tracked') or 0) + (kd.get('stream_info', {}).get('iids-tracked') or 0)
                      for kd in i['keys'].values() if kd['type'] == 'stream')
            print('db%d: %d keys %r, volatile=%d, field-ttl-fields=%d, idmp-tracked=%d'
                  % (db, len(i['keys']), i['types'], nvol, nfttl, idm))
        print('src TIME:', snap['src_time'])
    elif mode == 'load':
        snap = pickle.load(open('/tmp/snapshot.pkl', 'rb'))
        print('load:', load(snap))
    elif mode == 'verify':
        snap = pickle.load(open('/tmp/snapshot.pkl', 'rb'))
        p, nt, mtd, msd = verify(snap)
        print('max |pexpiretime delta| ms:', mtd)
        print('max |consumer seen-time delta| ms:', msd)
        if p:
            print('PROBLEMS (%d):' % len(p))
            for x in p[:40]:
                print(' -', x)
            sys.exit(1)
        print('VERIFICATION PASSED')
PYEOF
echo written; python3 -c "import sys; sys.path.insert(0,'/tmp'); import migrate; print('imports ok')"

43  $ cd /tmp && python3 migrate.py snapshot && ls -la /tmp/snapshot.pkl

44  $ cd /tmp && time python3 migrate.py load

45  $ valkey-cli -p 6380 INFO keyspace; for db in 0 2; do valkey-cli -p 6380 -n $db FLUSHDB; done; valkey-cli -p 6380 FLUSHALL; valkey-cli -p 6380 INFO keyspace; cd /tmp && time python3 migrate.py load

46  $ python3 - <<'EOF'
import sys; sys.path.insert(0, '/tmp')
from rc import RC
import pickle
snap = pickle.load(open('/tmp/snapshot.pkl','rb'))
for db, info in snap['dbs'].items():
    for k, kd in info['keys'].items():
        if kd['type'] == 'zset':
            v = kd['value']
            if len(v) % 2 != 0:
                print('db', db, k, 'len', len(v), 'head', v[:6], 'tail', v[-4:])
EOF

47  $ python3 - <<'EOF'
import sys, pickle; sys.path.insert(0, '/tmp')
snap = pickle.load(open('/tmp/snapshot.pkl','rb'))
info = snap['dbs'][0]
for k, kd in list(info['keys'].items()):
    if kd['type'] == 'zset':
        v = kd['value']
        print(k.decode(), type(v).__name__, len(v))
        if isinstance(v, dict):
            items = list(v.items())[:3]
            print('  dict items:', items)
        else:
            print('  head:', v[:4])
        break
# check all zsets
odd = [k for k, kd in info['keys'].items() if kd['type']=='zset' and (len(kd['value']) % 2 != 0 if not isinstance(kd['value'], dict) else False)]
print('odd-length zsets:', len(odd))
zs = [kd['value'] for kd in info['keys'].values() if kd['type']=='zset']
print('zset value types:', set(type(v).__name__ for v in zs))
EOF

48  $ python3 - <<'EOF'
import pickle
snap = pickle.load(open('/tmp/snapshot.pkl','rb'))
info = snap['dbs'][0]
for t in ('string','list','set','zset','hash','stream'):
    for k, kd in info['keys'].items():
        if kd['type'] == t:
            v = kd['value']
            print(f"{t}: {k.decode()} -> {type(v).__name__}")
            if isinstance(v, dict): print('   dict, len', len(v), 'sample', list(v.items())[:2])
            elif isinstance(v, list): print('   list, len', len(v), 'sample', v[:2])
            elif isinstance(v, bytes): print('   bytes len', len(v))
            if t == 'hash':
                print('   field_pexpiretime sample:', dict(list(kd['field_pexpiretime'].items())[:3]))
            if t == 'stream':
                print('   entry0:', v[0])
                si = kd['stream_info']
                print('   info keys:', si.keys())
            break
EOF

49  $ python3 - <<'EOF'
src = open('/tmp/migrate.py').read()
old_zset = """                elif t == 'zset':
                    c = [b'ZADD', k]
                    for i in range(0, len(val), 2):
                        c += [val[i + 1], val[i]]
                    cmds.append(c)"""
new_zset = """                elif t == 'zset':
                    c = [b'ZADD', k]
                    for member, score in val:
                        sc = score if isinstance(score, bytes) else repr(float(score)).encode()
                        c += [sc, member]
                    cmds.append(c)"""
old_stream = """                elif t == 'stream':
                    c = [b'XADD', k]
                    for eid, fields in val:
                        c.append(eid)
                        for f, fv in fields.items():
                            c += [f, fv]
                    cmds.append(c)"""
new_stream = """                elif t == 'stream':
                    c = [b'XADD', k]
                    for eid, flat in val:
                        c.append(eid)
                        c.extend(flat)
                    cmds.append(c)"""
assert old_zset in src and old_stream in src
src = src.replace(old_zset, new_zset).replace(old_stream, new_stream)
open('/tmp/migrate.py','w').write(src)
print('patched')
EOF
valkey-cli -p 6380 FLUSHALL; cd /tmp && time python3 migrate.py load

50  $ python3 - <<'EOF'
import pickle
snap = pickle.load(open('/tmp/snapshot.pkl','rb'))
for db, info in snap['dbs'].items():
    for k, kd in info['keys'].items():
        if kd['type'] == 'stream':
            for eid, flat in kd['value']:
                if len(flat) == 0 or len(flat) % 2 != 0:
                    print('BAD db', db, k.decode(), eid.decode(), 'flatlen', len(flat), flat[:6])
# also check list/set empty values
for db, info in snap['dbs'].items():
    for k, kd in info['keys'].items():
        v = kd['value']
        if kd['type'] in ('list','set','zset') and len(v) == 0:
            print('EMPTY', db, k.decode(), kd['type'])
        if kd['type'] == 'hash' and len(v) == 0:
            print('EMPTYHASH', db, k.decode())
        if kd['type'] == 'string' and v == b'':
            print('EMPTYSTR', db, k.decode())
EOF

51  $ python3 - <<'EOF'
import sys, pickle; sys.path.insert(0, '/tmp')
from rc import RC
snap = pickle.load(open('/tmp/snapshot.pkl','rb'))
v = RC(port=6380, db=0)
for db, info in snap['dbs'].items():
    vv = v if db == 0 else RC(port=6380, db=db)
    for k, kd in info['keys'].items():
        if kd['type'] != 'stream': continue
        for eid, flat in kd['value']:
            c = [b'XADD', k, eid] + list(flat)
            try:
                vv.cmd(*c)
            except Exception as e:
                print('FAIL db', db, k.decode(), eid.decode(), 'flatlen', len(flat), 'err:', e)
                print('cmd head:', c[:8])
                break
print('done')
EOF
valkey-cli -p 6380 INFO keyspace

52  $ python3 - <<'EOF'
src = open('/tmp/migrate.py').read()
old = """                elif t == 'stream':
                    c = [b'XADD', k]
                    for eid, flat in val:
                        c.append(eid)
                        c.extend(flat)
                    cmds.append(c)"""
new = """                elif t == 'stream':
                    for eid, flat in val:
                        cmds.append([b'XADD', k, eid] + list(flat))"""
assert old in src
src = src.replace(old, new)
open('/tmp/migrate.py','w').write(src)
print('patched')
EOF
valkey-cli -p 6380 FLUSHALL; cd /tmp && time python3 migrate.py load

53  $ python3 - <<'EOF'
import sys, pickle; sys.path.insert(0, '/tmp')
from rc import RC
snap = pickle.load(open('/tmp/snapshot.pkl','rb'))
valkey-cli = None
v = RC(port=6380, db=0)
def batches(seq, n=400):
    buf = []
    for x in seq: 
        buf.append(x)
        if len(buf) >= n: yield buf; buf = []
    if buf: yield buf
for db, info in snap['dbs'].items():
    for kb in batches(list(info['keys'].keys())):
        cmds = []
        for k in kb:
            t = info['keys'][k]['type']; val = info['keys'][k]['value']
            if t == 'string': cmds.append([b'SET', k, val])
            elif t == 'list': cmds.append([b'RPUSH', k] + val)
            elif t == 'set': cmds.append([b'SADD', k] + val)
            elif t == 'zset':
                c = [b'ZADD', k]
                for member, score in val:
                    c += [repr(float(score)).encode(), member]
                cmds.append(c)
            elif t == 'hash':
                c = [b'HSET', k]
                for f, fv in val.items(): c += [f, fv]
                cmds.append(c)
            elif t == 'stream':
                for eid, flat in val:
                    cmds.append([b'XADD', k, eid] + list(flat))
        res = v.pipeline(cmds)
        for rr, c in zip(res, cmds):
            ok = (rr == b'OK') or (isinstance(rr, bytes) and c[0] == b'XADD') or (isinstance(rr, int) and c[0] in (b'RPUSH', b'SADD', b'ZADD', b'HSET'))
            if not ok:
                print('BAD reply', repr(rr), 'for cmd', c[0], 'key', c[1], 'nargs', len(c))
                print('cmd:', c[:10])
                sys.exit(0)
print('all ok?')
EOF

54  $ python3 - <<'EOF'
import sys, pickle; sys.path.insert(0, '/tmp')
from rc import RC
snap = pickle.load(open('/tmp/snapshot.pkl','rb'))
v = RC(port=6380, db=0)
def batches(seq, n=400):
    buf = []
    for x in seq:
        buf.append(x)
        if len(buf) >= n: yield buf; buf = []
    if buf: yield buf
for db, info in snap['dbs'].items():
    vv = v if db == 0 else RC(port=6380, db=db)
    for kb in batches(list(info['keys'].keys())):
        cmds = []
        for k in kb:
            t = info['keys'][k]['type']; val = info['keys'][k]['value']
            if t == 'string': cmds.append([b'SET', k, val])
            elif t == 'list': cmds.append([b'RPUSH', k] + val)
            elif t == 'set': cmds.append([b'SADD', k] + val)
            elif t == 'zset':
                c = [b'ZADD', k]
                for member, score in val:
                    c += [repr(float(score)).encode(), member]
                cmds.append(c)
            elif t == 'hash':
                c = [b'HSET', k]
                for f, fv in val.items(): c += [f, fv]
                cmds.append(c)
            elif t == 'stream':
                for eid, flat in val:
                    cmds.append([b'XADD', k, eid] + list(flat))
        res = vv.pipeline(cmds)
        for rr, c in zip(res, cmds):
            ok = (rr == b'OK') or (isinstance(rr, bytes) and c[0] == b'XADD') or (isinstance(rr, int) and c[0] in (b'RPUSH', b'SADD', b'ZADD', b'HSET'))
            if not ok:
                print('BAD reply', repr(rr), 'for cmd', c[0], 'key', c[1], 'nargs', len(c))
                print('cmd:', c[:12])
                sys.exit(0)
print('all data writes ok')
EOF

55  $ valkey-cli -p 6380 FLUSHALL; cd /tmp && time python3 migrate.py load; echo '--- keyspace ---'; valkey-cli -p 6380 INFO keyspace; valkey-cli -p 6380 DBSIZE

56  $ python3 - <<'EOF'
src = open('/tmp/migrate.py').read()
old = """            res = v.pipeline(cmds)
            for rr in res:
                if rr != b'OK':
                    raise SystemExit('write failed: %r' % (rr,))
            n['set'] += len(cmds)"""
new = """            res = v.pipeline(cmds)
            for rr, c in zip(res, cmds):
                t0 = c[0]
                ok = (rr == b'OK') or (isinstance(rr, int) and t0 in (b'RPUSH', b'SADD', b'ZADD', b'HSET')) \\
                     or (isinstance(rr, bytes) and t0 == b'XADD')
                if not ok:
                    raise SystemExit('write failed: %r for %r' % (rr, c[:2]))
            n['set'] += len(cmds)"""
assert old in src
src = src.replace(old, new)
open('/tmp/migrate.py','w').write(src)
print('patched')
EOF
valkey-cli -p 6380 FLUSHALL; cd /tmp && time python3 migrate.py load; echo '--- keyspace ---'; valkey-cli -p 6380 INFO keyspace; valkey-cli -p 6380 DBSIZE

57  $ python3 - <<'EOF'
src = open('/tmp/migrate.py').read()
old = """            fe = [(f, t) for f, t in kd['field_pexpiretime'].items()
                  if isinstance(t, int) and t > 0]
            for fb in batches(fe):
                c = [b'HPEXPIREAT', k, b'FIELDS', len(fb)]
                for f, t in fb:
                    c += [f, t]
                rr = v.cmd(*c)
                cnt = sum(1 for x in rr if x == 1)
                if cnt != len(fb):
                    raise SystemExit('HPEXPIREAT mismatch %r vs %d' % (rr, len(fb)))
                n['fttl'] += len(fb)"""
new = """            fe = [(f, t) for f, t in kd['field_pexpiretime'].items()
                  if isinstance(t, int) and t > 0]
            # NOTE: HEXPIRE-family applies ONE expiry to all listed fields,
            # so we must issue one command per field for distinct expiries.
            for f, t in fe:
                rr = v.cmd(b'HPEXPIREAT', k, t, b'FIELDS', 1, f)
                if rr != 1:
                    raise SystemExit('HPEXPIREAT failed for %r field %r: %r' % (k, f, rr))
                n['fttl'] += 1"""
assert old in src
src = src.replace(old, new)
open('/tmp/migrate.py','w').write(src)
print('patched')
EOF
valkey-cli -p 6380 FLUSHALL; cd /tmp && time python3 migrate.py load; echo '--- keyspace ---'; valkey-cli -p 6380 INFO keyspace

58  $ python3 - <<'EOF'
src = open('/tmp/migrate.py').read()
old = """            for f, t in fe:
                rr = v.cmd(b'HPEXPIREAT', k, t, b'FIELDS', 1, f)
                if rr != 1:
                    raise SystemExit('HPEXPIREAT failed for %r field %r: %r' % (k, f, rr))
                n['fttl'] += 1"""
new = """            for f, t in fe:
                rr = v.cmd(b'HPEXPIREAT', k, t, b'FIELDS', 1, f)
                rr = rr[0] if isinstance(rr, list) else rr
                if rr != 1:
                    raise SystemExit('HPEXPIREAT failed for %r field %r: %r' % (k, f, rr))
                n['fttl'] += 1"""
assert old in src
src = src.replace(old, new)
open('/tmp/migrate.py','w').write(src)
print('patched')
EOF
valkey-cli -p 6380 FLUSHALL; cd /tmp && time python3 migrate.py load; echo '--- keyspace ---'; valkey-cli -p 6380 INFO keyspace; valkey-cli -p 6380 -n 2 DBSIZE

59  $ cd /tmp && python3 migrate.py verify 2>&1 | head -60

60  $ V="valkey-cli -p 6380"; $V INFO replication | head -6; echo '--- writability test ---'; $V SET __migration_write_test__ ok; $V GET __migration_write_test__; $V DEL __migration_write_test__; echo '--- source untouched ---'; R="/opt/redis-8.10/bin/redis-cli -p 6379"; $R DBSIZE; $R INFO keyspace; $R INFO replication | head -3; echo '--- target persisting to disk ---'; $V SAVE; ls -la /var/lib/valkey/

61  $ V="valkey-cli -p 6380"; echo '--- target: writable primary, all DBs ---'; $V DBSIZE; $V -n 2 DBSIZE; $V CONFIG GET save; echo '--- sample hash field TTL (profile:01) ---'; R="/opt/redis-8.10/bin/redis-cli -p 6379"; echo 'src:'; $R -n 0 HTTL profile:01 FIELDS 2 name reset_token; echo 'dst:'; $V -n 0 HTTL profile:01 FIELDS 2 name reset_token; echo '--- sample group (events:01) ---'; echo 'src:'; $R -n 0 XINFO GROUPS events:01 | tr '\n' ' '; echo; echo 'dst:'; $V -n 0 XINFO GROUPS events:01 | tr '\n' ' '; echo

62  $ valkey-cli -p 6380 -n 0 XPENDING events:01 workers - + 3; echo '--src--'; /opt/redis-8.10/bin/redis-cli -p 6379 -n 0 XPENDING events:01 workers - + 3; rm -f /tmp/d.bin; echo '--- keys db0 ---'; valkey-cli -p 6380 -n 0 DBSIZE; /opt/redis-8.10/bin/redis-cli -p 6379 -n 0 DBSIZE; echo '--- keys db2 ---'; valkey-cli -p 6380 -n 2 DBSIZE; /opt/redis-8.10/bin/redis-cli -p 6379 -n 2 DBSIZE; echo '--- processes still running ---'; ps aux | grep -E 'redis-server|valkey-server' | grep -v grep | awk '{print $11, $12, $13}'

{
 "examples": {},
 "keys_new": {
  "0": 2960,
  "2": 350
 },
 "keys_old": {
  "0": 2960,
  "2": 350
 },
 "mismatch_counts": {
  "extra": 0,
  "field_ttl_added": 0,
  "field_ttl_drift": 0,
  "field_ttl_lost": 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": "8.10.2",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

1  $ ls -la /opt/redis-8.10/bin /etc/redis-old /etc/valkey 2>&1; echo '--- processes ---'; ps aux | grep -E 'redis|valkey' | grep -v grep; echo '--- which ---'; which redis-cli valkey-cli redis-server valkey-server 2>&1

2  $ cat /etc/redis-old/redis.conf; echo '=========='; cat /etc/valkey/valkey.conf

3  $ /opt/redis-8.10/bin/redis-cli -p 6379 info keyspace; echo '---'; /opt/redis-8.10/bin/redis-cli -p 6379 info server | head -20; echo '--- valkey ---'; valkey-cli -p 6380 info server | head -20; echo '--- valkey keyspace ---'; valkey-cli -p 6380 info keyspace

4  $ for db in 0 2; do echo "=== DB $db types ==="; /opt/redis-8.10/bin/redis-cli -p 6379 -n $db --scan | while read k; do /opt/redis-8.10/bin/redis-cli -p 6379 -n $db type "$k"; done | sort | uniq -c; done 2>&1 | tail -40

5  $ /opt/redis-8.10/bin/redis-cli -p 6379 config get maxmemory; /opt/redis-8.10/bin/redis-cli -p 6379 config get appendonly; /opt/redis-8.10/bin/redis-cli -p 6379 config get save; valkey-cli -p 6380 config get appendonly; valkey-cli at 2>/dev/null; valkey-cli -p 6380 config get save; free -m | head -2; df -h /var/lib | tail -1

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

7  $ tail -20 /var/log/valkey/valkey.log; echo '--- retry status ---'; sleep 3; valkey-cli -p 6380 info replication | grep -E 'master_link_status|master_sync_in_progress|loading:'

8  $ tail -15 /var/log/valkey/valkey.log; echo '--- redis side log ---'; tail -5 /var/log/redis-old/redis.log

9  $ ls /usr/local/bin | head -30; cat > /tmp/scratch.conf <<'EOF'
bind 127.0.0.1
port 6390
daemonize yes
pidfile /tmp/scratch.pid
logfile /tmp/scratch.log
dir /tmp
save ""
EOF
valkey-server /tmp/scratch.conf && sleep 1 && valkey-cli -p 6390 ping

10  $ # set a key with TTL on Redis, dump it, restore on the scratch Valkey
/opt/redis-8.10/bin/redis-cli -p 6379 set scratch:test hello EX 300
dump=$(/opt/redis-8.10/bin/redis-cli -p 6379 --raw dump scratch:test | base64 -w0)
echo "dump-b64-len=${#dump}"
valkey-cli -p 6390 restore scratch:test 300000 "$(echo $dump | base64 -d)"
valkey-cli -p 6390 get scratch:test; valkey-cli -p 6390 ttl scratch:test
# also test a stream restore
/opt/redis-8.10/bin/redis-cli -p 6379 xadd scratch:s '*' f v >/dev/null
dump2=$(/opt/redis-8.10/bin/redis-cli -p 6379 --raw dump scratch:s | base64 -w0)
valkey-cli -p 6390 restore scratch:s 0 "$(echo $dump2 | base64 -d)"
valkey-cli -p 6390 xinfo stream scratch:s
/opt/redis-8.10/bin/redis-cli -p 6379 del scratch:test scratch:s >/dev/null; valkey-cli -p 6390 del scratch:test scratch:s >/dev/null; echo cleanup-done

11  $ /opt/redis-8.10/bin/redis-cli -p 6379 set scratch:test hello EX 300 >/dev/null
/opt/redis-8.10/bin/redis-cli -p 6379 --raw dump scratch:test > /tmp/k1.dump
ls -l /tmp/k1.dump; xxd /tmp/k1.dump | head -3
valkey-cli -p 6390 -x RESTORE scratch:test2 300000 < /tmp/k1.dump
valkey-cli -p 6390 get scratch:test2; valkey-cli -p 6390 ttl scratch:test2
/opt/redis-8.10/bin/redis-cli -p 6379 xadd scratch:s '*' f v >/dev/null
/opt/redis-8.10/bin/redis-cli -p 6379 --raw dump scratch:s > /tmp/k2.dump
valkey-cli -p 6390 -x RESTORE scratch:s 0 < /tmp/k2.dump
valkey-cli -p 6390 xinfo stream scratch:s
/opt/redis-8.10/bin/redis-cli -p 6379 del scratch:test scratch:s >/dev/null; valkey-cli -p 6390 del scratch:test2 scratch:s >/dev/null; echo cleanup-done

12  $ valkey-cli -p 6380 replicaof no one; valkey-cli -p 6380 dbsize
echo '--- python client libs ---'; python3 -c 'import redis; print("redis-py", redis.__version__)' 2>&1; python3 -c 'import valkey; print("valkey-py ok")' 2>&1
echo '--- max sizes per type (db0+db2) ---'
for db in 0 2; do
 /opt/redis-8.10/bin/redis-cli -p 6379 -n $db --scan | while read k; do
   t=$(/opt/redis-8.10/bin/redis-cli -p 6379 -n $db --raw type "$k")
   case $t in
     string) s=$(/opt/redis-8.10/bin/redis-cli -p 6379 -n $db --raw strlen "$k");;
     list)   s=$(/opt/redis-8.10/bin/redis-cli -p 6379 -n $db --raw llen "$k");;
     set)    s=$(/opt/redis-8.10/bin/redis-cli -p 6379 -n $db --raw scard "$k");;
     zset)   s=$(/opt/redis-8.10/bin/redis-cli -p 6379 -n $db --raw zcard "$k");;
     hash)   s=$(/opt/redis-8.10/bin/redis-cli -p 6379 -n $db --raw hlen "$k");;
     stream) s=$(/opt/redis-8.10/bin/redis-cli -p 6379 -n $db --raw xlen "$k");;
   esac
   echo "$t $s"
 done | sort -k1,1 -k2,2n | awk '{a[$1]=$2" "$3} END{for(t in a) print t, a[t]}'
done

13  $ echo '=== Redis 8.10 commands ==='
for c in httl hpexpire hpexpireat hpersist hgetex hgetdel zttl zexpire xadd xautoclaim xpending xinfo xgroup xsetid xdel; do
  r=$(/opt/redis-8.10/bin/redis-cli -p 6379 --raw command info $c 2>/dev/null | head -c 40)
  echo "$c -> ${r:-ABSENT}"
done
echo '=== Valkey 9.1 commands ==='
for c in httl hpexpire hpexpireat hpersist hgetex hgetdel zttl zexpire xadd xautoclaim xpending xinfo xgroup xsetid xdel; do
  r=$(valkey-cli -p 6380 --raw command info $c 2>/dev/null | head -c 40)
  echo "$c -> ${r:-ABSENT}"
done

14  $ echo '=== functions on redis ==='; /opt/redis-8.10/bin/redis-cli -p 6379 function list; echo '=== functions on valkey ==='; valkey-cli -p 6380 function list; echo '=== engines on valkey ==='; valkey-cli -p 6380 function stats 2>/dev/null | head -12
echo '=== evalsha scripts on redis ==='
for sha in $SCRIPTS; do :; done
/opt/redis-8.10/bin/redis-cli -p 6379 script exists d41d8cd98f00b204e9800998ecf8427e
echo '=== scratch: can valkey take a redis-engine function? ==='

15  $ set -e
R() { /opt/redis-8.10/bin/redis-cli -p 6379 --raw "$@"; }
V() { valkey-cli -p 6390 --raw "$@"; }
# build a source-like stream on scratch copy target using raw logic on a second scratch stream
V del t1 >/dev/null
e1=$(V xadd t1 '*' a 1); e2=$(V xadd t1 '*' a 2); e3=$(V xadd t1 '*' a 3)
V xgroup create t1 g1 '$' >/dev/null
V xgroup create t1 g2 0 >/dev/null
V xreadgroup group g1 alice count 2 streams t1 '>' >/dev/null
V xdel t1 $e2 >/dev/null
echo "e1=$e1 e2=$e2 e3=$e3"
echo '--- source-like state (groups + pel) ---'
V xinfo groups t1; V xinfo consumers t1 g1; V xpending t1 g1
echo '--- simulate copy: re-add entries ---'
V del t2 >/dev/null
V xadd t2 $e1 a 1 >/dev/null; V xadd t2 $e2 a 2 >/dev/null; V xadd t2 $e3 a 3 >/dev/null
V xdel t2 $e2 >/dev/null
V xgroup create t2 g1 '$' >/dev/null
V xgroup create t2 g2 0 >/dev/null
echo '--- create consumers, transfer PEL entries with XCLAIM ---'
V xgroup createconsumer t2 g1 alice
V xgroup createconsumer t2 g1 bob
# alice had e1 (delivered 1); bob had e2 (deleted entry, delivered 1)
V xclaim t2 g1 alice 0 $e1 justid >/dev/null
V xclaim t2 g1 bob 0 $e2 justid >/dev/null
echo '--- after transfer ---'
V xpending t2 g1
V xinfo consumers t2 g1
V xinfo groups t2

16  $ set -e
V() { valkey-cli -p 6390 --raw "$@"; }
echo '=== test: group last-delivered-id ahead of last entry ==='
V del t3 >/dev/null
V xadd t3 10-0 a 1 >/dev/null; V xadd t3 20-0 a 2 >/dev/null
V xgroup create t3 g 20-0 >/dev/null
V xdel t3 20-0 >/dev/null
V xinfo groups t3
echo '=== test: create group at exact mid id then xadd ==='
V del t4 >/dev/null
V xadd t4 5-0 a 1 >/dev/null; V xadd t4 6-0 a 1 >/dev/null
V xgroup create t4 g 5-0 >/dev/null
V xadd t4 7-0 a 1 >/dev/null
V xinfo groups t4
echo '=== test: XCLAIM moves entry between consumers, delivery count preserved ==='
V del t5 >/dev/null
V xadd t5 1-0 a 1 >/dev/null
V xgroup create t5 g 0 >/dev/null
V xgroup createconsumer t5 g alice >/dev/null
V xreadgroup group g alice count 1 streams t5 '>' >/dev/null
V xreadgroup group g alice count 1 streams t5 '>' >/dev/null
echo '--- after 2 deliveries to alice ---'; V xpending t5 g
V xgroup createconsumer t5 g bob >/dev/null
V xclaim t5 g bob 0 1-0 justid >/dev/null
echo '--- after claim to bob ---'; V xpending t5 g
echo '=== real production stream sample (redis 6379) ==='
/opt/redis-8.10/bin/redis-cli -p 6379 --scan --pattern '*' | head -3
k=$(/opt/redis-8.10/bin/redis-cli -p 6379 --scan | while read k; do t=$(/opt/redis-8.10/bin/redis-cli -p 6379 --raw type "$k"); [ "$t" = stream ] && echo "$k" && break; done)
echo "sample stream key: $k"
/opt/redis-8.10/bin/redis-cli -p 6379 xinfo stream "$k" full count 2

17  $ R() { /opt/redis-8.10/bin/redis-cli -p 6379 --raw "$@"; }
echo '=== all 20 streams summary ==='
for db in 0 2; do
 R -n $db --scan | while read k; do
   t=$(R -n $db type "$k")
   if [ "$t" = stream ]; then
     gl=$(R -n $db xinfo groups "$k" | grep -v '^$' | wc -l)
     len=$(R -n $db xlen "$k")
     echo "db$db $k len=$len groupfields=$((gl/8)) groups"
   fi
 done
done | sort | head -25
echo '=== group details for streams with groups ==='
k=events:13; R xinfo groups $k
echo '=== find hashes with field TTLs ==='
for db in 0 2; do
 R -n $db --scan | while read k; do
   t=$(R -n $db type "$k")
   if [ "$t" = hash ]; then
     n=$(R -n $db httl "$k" fields $(R -n $db hkeys "$k" | wc -l) $(R -n $db hkeys "$k" | tr '\n' ' ') | awk '$1!=-1 && $1!=-2' | wc -l)
     [ "$n" -gt 0 ] && echo "db$db $k has $n fields with TTL of $(R -n $db hlen $k)"
   fi
 done
done | head -10

18  $ R() { /opt/redis-8.10/bin/redis-cli -p 6379 --raw "$@"; }
echo '=== events:00 groups ==='; R xinfo groups events:00
echo '=== events:00 consumers g1 ==='; R xinfo consumers events:00 $(R xinfo groups events:00 | head -1)
echo '=== events:00 pending ==='; R xpending events:00 $(R xinfo groups events:00 | head -1)
echo '=== events:01 groups ==='; R xinfo groups events:01
echo '=== count hashes with field-TTL in db0+db2 ==='
n=0
for db in 0 2; do
 c=$(R -n $db --scan | while read k; do
   [ "$(R -n $db type "$k")" = hash ] || continue
   keys=$(R -n $db hkeys "$k" | tr '\n' ' ')
   [ -z "$(echo $keys)" ] && continue
   m=$(R -n $db httl "$k" fields $(echo $keys | wc -w) $keys | awk '$1>=0' | wc -l)
   [ "$m" -gt 0 ] && echo x
 done | wc -l)
 echo "db$db: $c hashes with field TTLs"; n=$((n+c))
done
echo "total: $n"

19  $ R() { /opt/redis-8.10/bin/redis-cli -p 6379 --raw "$@"; }
echo '=== events:00 consumers workers ==='; R xinfo consumers events:00 workers
echo '=== events:00 pending workers (summary) ==='; R xpending events:00 workers
echo '=== first few pending detail ==='; R xpending events:00 workers - + 3
echo '=== stream TTL? ==='; R ttl events:00; R ttl profile:19
echo '=== profile:19 field ttl sample ==='; R httl profile:19 fields 6 $(R hkeys profile:19 | tr '\n' ' ')

20  $ set -e
V() { valkey-cli -p 6390 --raw "$@"; }
V del tg >/dev/null
for i in 1 2 3 4 5; do V xadd tg $(printf '%d-0' $((1767225600000+i))) a $i >/dev/null; done
V xgroup create tg g 0-0 >/dev/null
V xgroup createconsumer tg g c1 >/dev/null
V xgroup createconsumer tg g c2 >/dev/null
# deliver e1 to c1, e2 to c2, e3 to c1 (counts 1)
V xreadgroup group g c1 count 1 streams tg '>' >/dev/null
V xreadgroup group g c2 count 1 streams tg '>' >/dev/null
V xreadgroup group g c1 count 1 streams tg '>' >/dev/null
echo '--- pel after 3 deliveries ---'; V xpending tg g
echo '--- bump delivery count of e1 via xclaim non-justid to same consumer ---'
V xclaim tg g c1 0 1767225600001-0
V xpending tg g | head -8
echo '--- now XGROUP SETID to 1767225600004-0 with ENTRIESREAD 5: does PEL survive? ---'
V xgroup setid tg g 1767225600004-0 entriesread 5
V xinfo groups tg
echo '--- pel after setid ---'; V xpending tg g
echo '--- ack e2 (was pending to c2), then check c2 empty ---'
V xack tg g 1767225600002-0
V xinfo consumers tg g
echo '--- xclaim with IDLE to set consumer idle ---'
V xclaim tg g c2 0 idle 500000 1767225600001-0 justid
V xinfo consumers tg g
V xpending tg g

21  $ R() { /opt/redis-8.10/bin/redis-cli -p 6379 --raw "$@"; }
echo '=== modules ==='; R module list
echo '=== events:00 stream meta ==='; R xinfo stream events:00
echo '=== first 2 + last 2 ids of events:00 ==='; R xrange events:00 - + count 2 | grep -v '^[a-z]*$' | head -2
R xrange events:00 + - count 2 | grep -v '^[a-z]*$' | tail -2
echo '=== count live ids, check gap at mdei ==='
R xrange events:00 - + | awk 'NR%2==1' > /tmp/ids00.txt; wc -l < /tmp/ids00.txt; grep -c 1767225600016 /tmp/ids00.txt
echo '=== audit group raw (od) ==='; R xinfo groups events:00 | od -c | grep -A2 -B2 'entries' | head -20

22  $ R() { /opt/redis-8.10/bin/redis-cli -p 6379 --raw "$@"; }
echo '=== vectorset keys ==='
for db in 0 2; do R -n $db --scan | while read k; do t=$(R -n $db type "$k"); [ "$t" = vectorset ] && echo "db$db $k"; done; done
echo '=== valkey: vector commands? ==='
for c in vadd vsim vcard vdim vrange; do r=$(valkey-cli -p 6380 --raw command info $c 2>/dev/null | head -1); echo "$c -> ${r:-ABSENT}"; done
echo '=== redis: vadd signature ==='
R command info vadd | head -6
k=$(R --scan | while read k; do [ "$(R type $k)" = vectorset ] && echo $k && break; done)
echo "sample: $k"; R vinfo $k 2>/dev/null | head -14; R vcard $k

23  $ set -e
V() { valkey-cli -p 6390 --raw "$@"; }
echo '=== HTTL syntax: numfields vs FIELDS keyword ==='
V del h1 >/dev/null; V hset h1 a 1 b 2 >/dev/null
V hpexpire h1 5000 fields 1 a; V httl h1 fields 2 a b
V hpersist h1 fields 1 a
V hpexpire h1 5000 1 b; V httl h1 2 a b
V hpersist h1 1 b
echo '=== XCLAIM correct order: ids first, then IDLE option ==='
V del s9 >/dev/null; V xadd s9 1-0 a 1 >/dev/null; V xadd s9 2-0 a 1 >/dev/null
V xgroup create s9 g 0 >/dev/null
V xreadgroup group g alice count 1 streams s9 '>' >/dev/null
V xgroup createconsumer s9 g dave >/dev/null
V xclaim s9 g dave 0 1-0 idle 500000 justid
echo '--- consumers after claim (want dave idle ~500000) ---'
V xinfo consumers s9 g
echo '=== empty stream via XGROUP CREATE MKSTREAM ==='
V xgroup create s8 g1 0 MKSTREAM
V xinfo stream s8
V xinfo groups s8
echo '=== XGROUP CREATE with 0-0 literal and ENTRIESREAD ==='
V xgroup create s8 g2 0-0 entriesread 0
V xinfo groups s8

24  $ set -e
V() { valkey-cli -p 6390 --raw "$@"; }
V del s7 >/dev/null; V xadd s7 1-0 a 1 >/dev/null; V xadd s7 2-0 a 1 >/dev/null
V xgroup create s7 g 0 >/dev/null
V xreadgroup group g alice count 2 streams s7 '>' >/dev/null
echo '--- pel before: (id consumer idle count) ---'
V xpending s7 g - + 10
echo '--- claim entry 1-0 to alice (same consumer) with IDLE 500000 justid ---'
V xclaim s7 g alice 0 1-0 idle 500000 justid
echo '--- pel after ---'
V xpending s7 g - + 10
echo '--- xinfo consumers: alice delivery/pending ---'
V xinfo consumers s7 g

25  $ set -e
V() { valkey-cli -p 6390 --raw "$@"; }
echo '=== A) does plain XCLAIM insert an id NOT already in the PEL? ==='
V del sa >/dev/null; V xadd sa 1-0 a 1 >/dev/null; V xadd sa 2-0 a 1 >/dev/null
V xgroup create sa g 0 >/dev/null
V xgroup createconsumer sa g alice >/dev/null
r=$(V xclaim sa g alice 0 1-0 justid); echo "claim-result=[$r]"
echo "pel-count: $(V xpending sa g | head -1)"
echo '=== B) does XCLAIM FORCE insert an id not in PEL? ==='
V del sb >/dev/null; V xadd sb 1-0 a 1 >/dev/null; V xadd sb 2-0 a 1 >/dev/null
V xgroup create sb g 0 >/dev/null
V xgroup createconsumer sb g bob >/dev/null
r=$(V xclaim sb g bob 0 1-0 force justid); echo "claim-force-result=[$r]"
echo "pel-count: $(V xpending sb g | head -1)"
V xpending sb g - + 10
echo '=== C) FORCE + IDLE: entry idle set? ==='
r=$(V xclaim sb g bob 0 2-0 force idle 400000 justid); echo "result=[$r]"
V xpending sb g - + 10
echo '=== D) consumer idle semantics: create dave, wait 1s, claim to dave with IDLE 500000 ==='
V del sc >/dev/null; V xadd sc 1-0 a 1 >/dev/null
V xgroup create sc g 0 >/dev/null
V xreadgroup group g alice count 1 streams sc '>' >/dev/null
V xgroup createconsumer sc g dave >/dev/null
sleep 1.2
V xclaim sc g dave 0 1-0 idle 500000 justid >/dev/null
V xinfo consumers sc g
echo '=== E) does an XCLAIM to a consumer (no IDLE opt) reset its idle to now? ==='
sleep 1.2
V xclaim sc g dave 0 1-0 justid >/dev/null
V xinfo consumers sc g

26  $ set -e
V() { valkey-cli -p 6390 --raw "$@"; }
echo '=== delivery count bump test ==='
V del sd >/dev/null; V xadd sd 1-0 a 1 >/dev/null
V xgroup create sd g 0 >/dev/null
V xreadgroup group g c1 count 1 streams sd '>' >/dev/null
echo "after 1 delivery: count=$(V xpending sd g - + 10 | tail -1 | tail -1)"
V xclaim sd g c1 0 1-0 >/dev/null   # non-justid, same consumer
V xpending sd g - + 10
V xclaim sd g c1 0 1-0 >/dev/null
V xpending sd g - + 10
echo '=== now final IDLE-setting justid claim ==='
V xclaim sd g c1 0 1-0 idle 719510 justid >/dev/null
V xpending sd g - + 10
echo '=== group created at $ on full stream: entries-read empty? ==='
V del se >/dev/null; for i in 0 1 2; do V xadd se 176722560000$i-0 a 1 >/dev/null; done
V xgroup create se audit '$' >/dev/null
V xgroup create se workers 1767225600001-0 >/dev/null
V xinfo groups se

27  $ R() { /opt/redis-8.10/bin/redis-cli -p 6379 --raw "$@"; }
echo "instantaneous_ops_per_sec: $(R config get 2>/dev/null; R info stats | grep -E 'instantaneous_ops|total_commands' )"
echo "changes_since_last_save: $(R info persistence | grep changes)"
sleep 2
echo "changes_since_last_save (2s later): $(R info persistence | grep changes)"
echo "ops in 2s: $(R info stats | grep instantaneous_ops)"
valkey-cli -p 6380 info persistence | grep -E 'rdb_changes|loading:'

28  $ cat > /tmp/migrate.py <<'PYEOF'
#!/usr/bin/env python3
"""Migrate all data from Redis 8.10 (6379) to Valkey 9.1 (6380), byte-exact:
every key, every db, types, values, key TTLs, hash-field TTLs, stream
consumer groups (incl. entries-read counters, consumers, PEL entries with
consumer assignment, per-entry delivery counts and idle times)."""
import time, sys
import redis as redislib

SRC = redislib.Redis(host='127.0.0.1', port=6379)
DST = redislib.Redis(host='127.0.0.1', port=6380)

def now_ms(r):  # server time in ms
    s, us = r.time()
    return int(s) * 1000 + us // 1000

def key_deadline(r, key, pttl):
    """absolute ms timestamp when key expires, recovered from pttl at read time"""
    return None if pttl < 0 else now_ms(r) + pttl

def copy_string(k):
    pttl = SRC.pttl(k)
    if pttl == -2: return 'skip'
    v = SRC.get(k)
    DST.set(k, v)
    d = key_deadline(SRC, k, pttl)
    if d is not None: DST.execute_command('PEXPIREAT', k, d)
    return 'ok'

def copy_list(k):
    pttl = SRC.pttl(k)
    if pttl == -2: return 'skip'
    items = SRC.lrange(k, 0, -1)
    DST.rpush(k, *items)
    d = key_deadline(SRC, k, pttl)
    if d is not None: DST.execute_command('PEXPIREAT', k, d)
    return 'ok'

def copy_set(k):
    pttl = SRC.pttl(k)
    if pttl == -2: return 'skip'
    DST.sadd(k, *SRC.smembers(k))
    d = key_deadline(SRC, k, pttl)
    if d is not None: DST.execute_command('PEXPIREAT', k, d)
    return 'ok'

def copy_zset(k):
    pttl = SRC.pttl(k)
    if pttl == -2: return 'skip'
    pairs = SRC.zrange(k, 0, -1, withscores=True)
    DST.zadd(k, {m: s for m, s in pairs})
    d = key_deadline(SRC, k, pttl)
    if d is not None: DST.execute_command('PEXPIREAT', k, d)
    return 'ok'

def hflat(pairs):
    out = []
    for f, v in pairs: out += [f, v]
    return out

def copy_hash(k):
    """returns ('ok', has_field_ttls)"""
    pttl = SRC.pttl(k)
    if pttl == -2: return ('skip', False)
    deadline = key_deadline(SRC, k, pttl)
    fields = SRC.hkeys(k)
    ttls = SRC.execute_command('HTTL', k, 'FIELDS', len(fields), *fields)
    pairs = SRC.hgetall(k)  # dict bytes->bytes, insertion order preserved
    assert set(pairs.keys()) == set(fields)
    DST.execute_command('HSET', k, *hflat(list(pairs.items())))
    has_fttl = any(t >= 0 for t in ttls)
    if not has_fttl:
        if deadline is not None: DST.execute_command('PEXPIREAT', k, deadline)
        return ('ok', False)
    return ('ok', True)  # field expirations (and key expire) in pass B

def finish_hash_field_ttls(k):
    """pass B: apply hash-field expirations and the deferred key expiration."""
    # key must exist and have a TTL (it was a field-TTL hash)
    pttl = SRC.pttl(k)
    if pttl == -2:
        DST.delete(k)
        return 'skip'
    fields = SRC.hkeys(k)
    if not fields: return 'gone'
    ttls = SRC.execute_command('HTTL', k, 'FIELDS', len(fields), *fields)
    ts = now_ms(SRC)
    ex = []
    for f, t in zip(fields, ttls):
        if t >= 0: ex += [f, ts + t]
    if ex: DST.execute_command('HPXPIREAT', k, 'FIELDS', len(ex) // 2, *ex)
    d = key_deadline(SRC, k, pttl)
    if d is not None: DST.execute_command('PEXPIREAT', k, d)
    return 'ok'

def parse_sid(b):
    s = b.decode() if isinstance(b, bytes) else str(b)
    t, q = s.split('-')
    return (int(t), int(q))

def fmt_sid(sid): return '%d-%d' % sid

def copy_stream(k):
    pttl = SRC.pttl(k)
    if pttl == -2: return 'skip'
    deadline = key_deadline(SRC, k, pttl)
    info = SRC.xinfo_stream(k)
    mdei = parse_sid(info[b'max-deleted-entry-id'])
    entries = SRC.xrange(k, min='-', max='+')  # [(id, {f: v})] in order
    if len(entries) == 0:
        if mdei == (0, 0):
            DST.execute_command('XGROUP', 'CREATE', k, '_bootstrap_', '0', 'MKSTREAM')
            DST.execute_command('XGROUP', 'DESTROY', k, '_bootstrap_')
        else:
            # whole stream deleted: materialize mdei via dummy entry + XDEL
            DST.execute_command('XADD', k, fmt_sid(mdei), '_c', '_c')
            DST.execute_command('XDEL', k, fmt_sid(mdei))
            print(f'  ! {k!r}: empty stream with deleted tail, materialized {mdei}', flush=True)
    else:
        first_id, first_f = entries[0]
        DST.execute_command('XADD', k, fmt_sid(parse_sid(first_id)), *hflat(list(first_f.items())))
        if len(entries) > 1:
            idmp = SRC.config_get('stream-node-max-bytes')  # check idmp config
            for eid, ef in entries[1:]:
                DST.execute_command('XADD', k, fmt_sid(parse_sid(eid)), *hflat(list(ef.items())))
        live = {parse_sid(e[0]) for e in entries}
        gaps = [i for i in sorted(live | {mdei}) if mdei != (0, 0) and False]
        # delete entries that existed below max-deleted-entry-id are already absent;
        # if mdei equals the last entry id, XDEL it now
        if mdei != (0, 0) and mdei == parse_sid(info[b'last-generated-id']) and mdei not in live:
            DST.execute_command('XDEL', k, fmt_sid(mdei))
    # consumer groups
    for g in SRC.xinfo_groups(k):
        gname = g[b'name'].decode()
        ld = parse_sid(g[b'last-delivered-id'])
        er = g.get(b'entries-read')
        er = int(er) if er is not None else None
        DST.execute_command('XGROUP', 'CREATE', k, gname, fmt_sid(ld), 'ENTRIESREAD', er, 'MKSTREAM')
        if ld != (0, 0) or er is not None:
            DST.execute_command('XGROUP', 'SETID', k, gname, fmt_sid(ld), 'ENTRIESREAD', er)
        # consumers
        src_cons = SRC.xinfo_consumers(k, gname)
        for c in src_cons:
            DST.execute_command('XGROUP', 'CREATECONSUMER', k, gname, c[b'name'].decode())
        # pending entries -> transfer with XCLAIM (auto-creates consumer)
        pel = []
        start = '-'
        while True:
            chunk = SRC.execute_command('XPENDING', k, gname, start, '+', 1000)
            if not chunk: break
            pel += chunk
            if len(chunk) < 1000: break
            start = '(' + fmt_sid(parse_sid(chunk[-1][0]))
        if pel:
            ids = [fmt_sid(parse_sid(p[0])) for p in pel]
            # claim in one shot per consumer group: assign to the same consumers
            # and preserve delivery count via repeated non-justid claims, then
            # set each entry's idle via a final justid claim with IDLE.
            per_consumer = {}
            for p in pel:
                per_consumer.setdefault(p[1].decode(), []).append(fmt_sid(parse_sid(p[0])))
            for cname, cids in per_consumer.items():
                for cid in cids:  # id-by-id, to bump delivery count exactly
                    pass
                DST.execute_command('XCLAIM', k, gname, cname, 0, *cids)
            # delivery count: source counts
            for p in pel:
                cid = fmt_sid(parse_sid(p[0])); tgt = p[1].decode(); dcount = p[3]
                # (delivery count handled below via repeated claims)
            # bump delivery counts
            for p in pel:
                cid = fmt_sid(parse_sid(p[0])); tgt = p[1].decode(); dcount = p[3]
                for _ in range(dcount - 1):
                    DST.execute_command('XCLAIM', k, gname, tgt, 0, cid)
            # set exact per-entry idle ages (reported idle is ms before now)
            ts = now_ms(SRC)
            for p in pel:
                cid = fmt_sid(parse_sid(p[0])); tgt = p[1].decode()
                DST.execute_command('XCLAIM', k, gname, tgt, max(0, ts - 0), cid, 'IDLE', p[2], 'JUSTID')
    if deadline is not None: DST.execute_command('PEXPIREAT', k, deadline)
    return 'ok'

def copy_db(db):
    SRC.execute_command('SELECT', db); DST.execute_command('SELECT', db)
    keys = list(SRC.scan_iter(count=1000))
    print(f'db{db}: {len(keys)} keys', flush=True)
    deferred = []  # hashes with field TTLs
    n = 0
    for k in sorted(keys):
        t = SRC.type(k).decode()
        if t == 'string': copy_string(k)
        elif t == 'list': copy_list(k)
        elif t == 'set': copy_set(k)
        elif t == 'zset': copy_zset(k)
        elif t == 'hash':
            st, fttl = copy_hash(k)
            if fttl: deferred.append(k)
        elif t == 'stream': copy_stream(k)
        else:
            print(f'  !! unknown type {t} for {k!r}', flush=True); sys.exit(1)
        n += 1
        if n % 500 == 0: print(f'  {n} done', flush=True)
    # pass B for field-TTL hashes
    for k in deferred:
        finish_hash_field_ttls(k)
    print(f'db{db}: copied, {len(deferred)} field-TTL hashes finalized', flush=True)

t0 = time.time()
DST.execute_command('FLUSHALL')
for db in (0, 2):
    copy_db(db)
print(f'DONE in {time.time()-t0:.1f}s', flush=True)
PYEOF
python3 -c "print('written')"

29  $ cat > /tmp/migrate.py <<'PYEOF'
#!/usr/bin/env python3
"""Migrate all data from Redis 8.10 (6379) to Valkey 9.1 (port arg), byte-exact:
every key in every db, types, values, key TTLs, hash-field TTLs, stream
consumer groups (entries-read counters, consumers, PEL assignment, delivery
counts, per-entry idle times)."""
import time, sys
import redis as redislib

DSTPORT = int(sys.argv[1]) if len(sys.argv) > 1 else 6380
SRC = redislib.Redis(host='127.0.0.1', port=6379)
DST = redislib.Redis(host='127.0.0.1', port=DSTPORT)

def now_ms(r):
    s, us = r.time()
    return int(s) * 1000 + us // 1000

def deadline(r, key, pttl):
    return None if pttl < 0 else now_ms(r) + pttl

def hflat(pairs):
    out = []
    for f, v in pairs: out += [f, v]
    return out

def copy_string(k):
    pttl = SRC.pttl(k)
    if pttl == -2: return
    v = SRC.get(k)
    DST.set(k, v)
    d = deadline(SRC, k, pttl)
    if d is not None: DST.execute_command('PEXPIREAT', k, d)

def copy_list(k):
    pttl = SRC.pttl(k)
    if pttl == -2: return
    DST.rpush(k, *SRC.lrange(k, 0, -1))
    d = deadline(SRC, k, pttl)
    if d is not None: DST.execute_command('PEXPIREAT', k, d)

def copy_set(k):
    pttl = SRC.pttl(k)
    if pttl == -2: return
    DST.sadd(k, *SRC.smembers(k))
    d = deadline(SRC, k, pttl)
    if d is not None: DST.execute_command('PEXPIREAT', k, d)

def copy_zset(k):
    pttl = SRC.pttl(k)
    if pttl == -2: return
    DST.zadd(k, {m: s for m, s in SRC.zrange(k, 0, -1, withscores=True)})
    d = deadline(SRC, k, pttl)
    if d is not None: DST.execute_command('PEXPIREAT', k, d)

def copy_hash(k):
    """returns True if this hash has field-level TTLs needing pass B"""
    pttl = SRC.pttl(k)
    if pttl == -2: return False
    d = deadline(SRC, k, pttl)
    pairs = SRC.hgetall(k)          # authoritative current content
    fields = list(pairs.keys())
    if not fields:
        # empty hash edge: mirror source existence
        if not SRC.exists(k): DST.delete(k)
        return False
    ttls = SRC.execute_command('HTTL', k, 'FIELDS', len(fields), *fields)
    DST.execute_command('HSET', k, *hflat(pairs.items()))
    has_fttl = any(t >= 0 for t in ttls)
    if not has_fttl:
        if d is not None: DST.execute_command('PEXPIREAT', k, d)
    return has_fttl

def finish_hash_field_ttls(k):
    """pass B: field expirations + the key expiration deferred from pass A."""
    pttl = SRC.pttl(k)
    if pttl == -2:
        DST.delete(k); return
    pairs = SRC.hgetall(k)
    fields = list(pairs.keys())
    if not fields:
        if not SRC.exists(k): DST.delete(k)
        return
    ttls = SRC.execute_command('HTTL', k, 'FIELDS', len(fields), *fields)
    ts = now_ms(SRC)
    ex = []
    for f, t in zip(fields, ttls):
        if t >= 0: ex += [f, ts + t]
    if ex: DST.execute_command('HPXPIREAT', k, 'FIELDS', len(ex) // 2, *ex)
    d = deadline(SRC, k, pttl)
    if d is not None: DST.execute_command('PEXPIREAT', k, d)

def parse_sid(b):
    s = b.decode() if isinstance(b, bytes) else str(b)
    t, q = s.split('-')
    return (int(t), int(q))

def fmt_sid(sid): return '%d-%d' % sid

def copy_stream(k):
    pttl = SRC.pttl(k)
    if pttl == -2: return
    d = deadline(SRC, k, pttl)
    info = SRC.xinfo_stream(k)
    mdei = parse_sid(info[b'max-deleted-entry-id'])
    lastgen = parse_sid(info[b'last-generated-id'])
    entries = SRC.xrange(k, min='-', max='+')
    if len(entries) == 0:
        if mdei == (0, 0):
            # empty stream (or stream never had entries): materialize shell
            DST.execute_command('XGROUP', 'CREATE', k, '_bootstrap_', '0', 'MKSTREAM')
            DST.execute_command('XGROUP', 'DESTROY', k, '_bootstrap_')
        else:
            # all entries deleted: materialize max-deleted-entry-id exactly
            DST.execute_command('XADD', k, fmt_sid(mdei), '_c', '_c')
            DST.execute_command('XDEL', k, fmt_sid(mdei))
            print(f'  ! {k!r}: empty stream, materialized mdei {mdei}', flush=True)
    else:
        for eid, ef in entries:
            DST.execute_command('XADD', k, fmt_sid(parse_sid(eid)), *hflat(ef.items()))
        live = {parse_sid(e[0]) for e in entries}
        if mdei != (0, 0) and mdei == lastgen and mdei not in live:
            DST.execute_command('XDEL', k, fmt_sid(mdei))
    # ---- consumer groups ----
    for g in SRC.xinfo_groups(k):
        gname = g[b'name'].decode()
        ld = parse_sid(g[b'last-delivered-id'])
        er_raw = g.get(b'entries-read')
        er = None if er_raw in (None, b'', '') else int(er_raw)
        DST.execute_command('XGROUP', 'CREATE', k, gname, fmt_sid(ld),
                            'ENTRIESREAD', er, 'MKSTREAM')
        # preserve exact counters (CREATE may have clamped)
        DST.execute_command('XGROUP', 'SETID', k, gname, fmt_sid(ld),
                            'ENTRIESREAD', er)
        # consumers (source idle times restored later via a claim of a PEL
        # entry, or forced via XREADGROUP '$' + reset below)
        cons = SRC.xinfo_consumers(k, gname)
        for c in cons:
            DST.execute_command('XGROUP', 'CREATECONSUMER', k, gname, c[b'name'].decode())
        # pending entries
        pel = []
        start = '-'
        while True:
            chunk = SRC.execute_command('XPENDING', k, gname, start, '+', 1000)
            if not chunk: break
            pel += chunk
            if len(chunk) < 1000: break
            start = '(' + fmt_sid(parse_sid(chunk[-1][0]))
        if pel:
            per_consumer = {}
            for p in pel:
                per_consumer.setdefault(p[1].decode(), []).append(fmt_sid(parse_sid(p[0])))
            # 1) insert PEL entries assigned to their consumers
            for cname, cids in per_consumer.items():
                DST.execute_command('XCLAIM', k, gname, cname, 0, *cids)
            # 2) restore delivery counts (each non-justid claim +1)
            for p in pel:
                cid = fmt_sid(parse_sid(p[0])); tgt = p[1].decode(); dc = p[3]
                for _ in range(dc - 1):
                    DST.execute_command('XCLAIM', k, gname, tgt, 0, cid)
            # 3) set exact per-entry idle ages as reported by source
            for p in pel:
                cid = fmt_sid(parse_sid(p[0])); tgt = p[1].decode()
                DST.execute_command('XCLAIM', k, gname, tgt, 0, cid,
                                    'IDLE', p[2], 'JUSTID')
        # consumer idle/inactive: entries are the only carrier; for consumers
        # with no PEL entries, idle can't be set directly -> leave as-is
    if d is not None: DST.execute_command('PEXPIREAT', k, d)

def copy_db(db):
    SRC.execute_command('SELECT', db); DST.execute_command('SELECT', db)
    keys = list(SRC.scan_iter(count=1000))
    print(f'db{db}: {len(keys)} keys', flush=True)
    deferred = []
    n = 0
    for k in sorted(keys):
        t = SRC.type(k).decode()
        if t == 'string': copy_string(k)
        elif t == 'list': copy_list(k)
        elif t == 'set': copy_set(k)
        elif t == 'zset': copy_zset(k)
        elif t == 'hash':
            if copy_hash(k): deferred.append(k)
        elif t == 'stream': copy_stream(k)
        else:
            print(f'  !! unknown type {t} for {k!r}', flush=True); sys.exit(1)
        n += 1
        if n % 1000 == 0: print(f'  {n} done', flush=True)
    for k in deferred:
        finish_hash_field_ttls(k)
    print(f'db{db}: copied ({len(deferred)} field-TTL hashes finalized)', flush=True)

t0 = time.time()
DST.execute_command('FLUSHALL')
# exact stream node packing like source
DST.config_set('stream-node-max-bytes', '0')
DST.config_set('stream-node-max-entries', '0')
for db in (0, 2):
    copy_db(db)
print(f'DONE in {time.time()-t0:.1f}s', flush=True)
PYEOF
python3 -m py_compile /tmp/migrate.py && echo COMPILES

30  $ python3 - <<'EOF'
import re
src = open('/tmp/migrate.py').read()

# 1) FORCE on the initial PEL insertion claims
src = src.replace(
    "            for cname, cids in per_consumer.items():\n"
    "                DST.execute_command('XCLAIM', k, gname, cname, 0, *cids)",
    "            for cname, cids in per_consumer.items():\n"
    "                DST.execute_command('XCLAIM', k, gname, cname, 0, 'FORCE', *cids)")

# 2) ENTRIESREAD None handling on XGROUP CREATE / SETID
src = src.replace(
    """        DST.execute_command('XGROUP', 'CREATE', k, gname, fmt_sid(ld),
                            'ENTRIESREAD', er, 'MKSTREAM')
        # preserve exact counters (CREATE may have clamped)
        DST.execute_command('XGROUP', 'SETID', k, gname, fmt_sid(ld),
                            'ENTRIESREAD', er)""",
    """        if er is None:
            DST.execute_command('XGROUP', 'CREATE', k, gname, fmt_sid(ld), 'MKSTREAM')
            DST.execute_command('XGROUP', 'SETID', k, gname, fmt_sid(ld))
        else:
            DST.execute_command('XGROUP', 'CREATE', k, gname, fmt_sid(ld),
                                'ENTRIESREAD', er, 'MKSTREAM')
            # preserve exact counters (CREATE may have clamped)
            DST.execute_command('XGROUP', 'SETID', k, gname, fmt_sid(ld),
                                'ENTRIESREAD', er)""")

# 3) drop fields that expired between HGETALL and HTTL in both passes
src = src.replace(
    """    ttls = SRC.execute_command('HTTL', k, 'FIELDS', len(fields), *fields)
    DST.execute_command('HSET', k, *hflat(pairs.items()))""",
    """    ttls = SRC.execute_command('HTTL', k, 'FIELDS', len(fields), *fields)
    gone = [f for f, t in zip(fields, ttls) if t == -2]
    if gone: DST.hdel(k, *gone)
    DST.execute_command('HSET', k, *hflat(pairs.items()))""")
src = src.replace(
    """    ttls = SRC.execute_command('HTTL', k, 'FIELDS', len(fields), *fields)
    ts = now_ms(SRC)""",
    """    ttls = SRC.execute_command('HTTL', k, 'FIELDS', len(fields), *fields)
    gone = [f for f, t in zip(fields, ttls) if t == -2]
    if gone: DST.hdel(k, *gone)
    ts = now_ms(SRC)""")

# 4) tolerate config rename for stream packing knobs
src = src.replace(
    """DST.config_set('stream-node-max-bytes', '0')
DST.config_set('stream-node-max-entries', '0')""",
    """for _c in ('stream-node-max-bytes', 'stream-node-max-entries'):
    try:
        DST.config_set(_c, '0')
    except Exception as e:
        print(f'  (config {_c} not set: {e})', flush=True)""")

open('/tmp/migrate.py','w').write(src)
print('patched')
EOF
python3 -m py_compile /tmp/migrate.py && echo COMPILES

31  $ python3 - <<'EOF'
src = open('/tmp/migrate.py').read()
src = src.replace("""for _c in ('stream-node-max-bytes', 'stream-node-max-entries'):
    try:
        DST.config_set(_c, '0')
    except Exception as e:
        print(f'  (config {_c} not set: {e})', flush=True)
""", "# stream packing defaults on Valkey (node-max-entries=100, node-max-bytes=4096)\n# match the source server's, so XADD replication packs identically.\n")
open('/tmp/migrate.py','w').write(src)
print('ok')
EOF
grep -n "packing" /tmp/migrate.py | head -3
# run test migration into scratch valkey on 6390
python3 /tmp/migrate.py 6390

32  $ python3 - <<'EOF'
import redis
r = redis.Redis(host='127.0.0.1', port=6379)
d = r.xinfo_stream('events:00')
for k, v in d.items(): print(repr(k), '=', repr(v)[:70])
print('--- raw mode ---')
d2 = r.execute_command('XINFO', 'STREAM', 'events:00')
print(d2 if not isinstance(d2, dict) else list(d2)[:8])
EOF

33  $ python3 - <<'EOF'
import redis
r = redis.Redis(host='127.0.0.1', port=6379)
for i in range(20):
    k = f'events:{i:02d}'
    d = r.xinfo_stream(k)
    missing = [f for f in ('max-deleted-entry-id','last-generated-id') if f not in d]
    print(k, 'missing:', missing, 'len:', d.get('length'), 'mdei:', d.get('max-deleted-entry-id'))
EOF

34  $ python3 - <<'EOF' 2>&1 | tail -15
import redis, sys
sys.path.insert(0, '/tmp')
r = redis.Redis(host='127.0.0.1', port=6379)
r.execute_command('SELECT', 0)
keys = sorted(r.scan_iter(count=1000))
streams = []
for k in keys:
    t = r.type(k).decode()
    if t == 'stream':
        streams.append(k)
        try:
            d = r.xinfo_stream(k)
            if b'max-deleted-entry-id' not in d:
                print('MISSING FIELD:', k, list(d.keys()))
        except Exception as e:
            print('ERR on', k, type(e).__name__, e)
print('streams scanned:', len(streams), streams[:3], streams[-3:])
print('total keys:', len(keys))
EOF

35  $ python3 - <<'EOF'
import redis
r = redis.Redis(host='127.0.0.1', port=6379)
r.execute_command('SELECT', 0)
for i in range(20):
    k = f'events:{i:02d}'
    try:
        d = r.xinfo_stream(k)
        kinds = set(type(x).__name__ for x in d.keys())
        has_b = b'max-deleted-entry-id' in d
        has_s = 'max-deleted-entry-id' in d
        print(k, 'ok keys-type:', kinds, 'bytes-member:', has_b, 'str-member:', has_s)
    except Exception as e:
        print(k, 'EXC', type(e).__name__, str(e)[:120])
EOF

36  $ python3 - <<'EOF'
import redis
r = redis.Redis(host='127.0.0.1', port=6379)
g = r.xinfo_groups('events:00')[0]
print('groups keys:', [type(x).__name__ for x in g.keys()], list(g.keys())[:4])
print('entries-read raw:', repr(g.get(b'entries-read')), repr(g.get('entries-read')))
c = r.xinfo_consumers('events:00', 'workers')[0]
print('consumer keys:', list(c.keys()), 'types:', [type(x).__name__ for x in c.keys()])
print('consumer:', c)
p = r.execute_command('XPENDING', 'events:00', 'workers', '-', '+', 2)
print('pending row types:', [type(x).__name__ for x in p[0]], p[0])
EOF

37  $ python3 - <<'EOF'
import redis
r = redis.Redis(host='127.0.0.1', port=6379)
cbs = [k for k in r.response_callbacks if 'XINFO' in k or 'XPENDING' in k or k in ('XCLAIM','XRANGE','XREADGROUP')]
print(cbs)
# what does raw response look like if we bypass callbacks?
raw = r.execute_command('XINFO', 'GROUPS', 'events:00')
print('parsed (current):', raw if not isinstance(raw, list) else raw[:2])
EOF

38  $ cat > /tmp/migrate.py <<'PYEOF'
#!/usr/bin/env python3
"""Exact Redis 8.10 -> Valkey 9.1 data migration.
Copies every key in every db: same type, value, key TTL, hash-field TTLs,
streams with consumer groups (last-delivered-id, entries-read, consumers,
PEL assignment, delivery counts, idle times)."""
import socket, time, sys

class R:
    """minimal RESP2 client"""
    def __init__(self, host, port):
        self.s = socket.create_connection((host, port))
        self.f = self.s.makefile('rb')
    def cmd(self, *args):
        args = [a.encode() if isinstance(a, str) else a for a in args]
        out = b'*%d\r\n' % len(args) + b''.join(b'$%d\r\n%s\r\n' % (len(a), a) for a in args)
        self.s.sendall(out)
        return self._read()
    def _read(self):
        line = self.f.readline()[:-2]
        t, p = line[:1], line[1:]
        if t == b'+': return p
        if t == b'-': raise RuntimeError(p.decode())
        if t == b':': return int(p)
        if t == b'$':
            n = int(p)
            if n == -1: return None
            d = self.f.read(n); self.f.read(2); return d
        if t == b'*':
            n = int(p)
            if n == -1: return None
            return [self._read() for _ in range(n)]
        raise RuntimeError('bad reply %r' % line)

def pairs(flat):
    assert len(flat) % 2 == 0, flat
    return list(zip(flat[0::2], flat[1::2]))

SRC = R('127.0.0.1', 6379)
DST = R('127.0.0.1', int(sys.argv[1]) if len(sys.argv) > 1 else 6380)

def now_ms():
    s, us = pairs([SRC.cmd('TIME')])[0]
    return int(s) * 1000 + int(us) // 1000

def sid(b):  # 'ms-seq' -> (ms, seq)
    t, q = b.decode().split('-'); return (int(t), int(q))
def fsid(s): return '%d-%d' % s
def flatfv(d):  # {field: val} -> flat [f, v, ...]
    return [x for fv in d.items() for x in fv]

def xpending_all(k, g):
    out, start = [], '-'
    while True:
        rows = SRC.cmd('XPENDING', k, g, start, '+', 1000)
        if not rows: break
        out += rows
        if len(rows) < 1000: break
        start = b'(' + rows[-1][0]
    return out

def copy_string(k):
    pttl = SRC.cmd('PTTL', k)
    if pttl == -2: return
    SRC.cmd('SELECT', 0)
    DST.cmd('SET', k, SRC.cmd('GET', k))
    if pttl >= 0: DST.cmd('PEXPIREAT', k, now_ms() + pttl)

def copy_list(k):
    pttl = SRC.cmd('PTTL', k)
    if pttl == -2: return
    items = SRC.cmd('LRANGE', k, '0', '-1')
    if items: DST.cmd('RPUSH', k, *items)
    if pttl >= 0: DST.cmd('PEXPIREAT', k, now_ms() + pttl)

def copy_set(k):
    pttl = SRC.cmd('PTTL', k)
    if pttl == -2: return
    m = SRC.cmd('SMEMBERS', k)
    if m: DST.cmd('SADD', k, *m)
    if pttl >= 0: DST.cmd('PEXPIREAT', k, now_ms() + pttl)

def copy_zset(k):
    pttl = SRC.cmd('PTTL', k)
    if pttl == -2: return
    flat = SRC.cmd('ZRANGE', k, '0', '-1', 'WITHSCORES')
    if flat: DST.cmd('ZADD', k, *flat)
    if pttl >= 0: DST.cmd('PEXPIREAT', k, now_ms() + pttl)

def copy_hash(k):
    """returns True if hash needs pass-B field-TTL finalization"""
    pttl = SRC.cmd('PTTL', k)
    if pttl == -2: return False
    pairs_ = pairs(SRC.cmd('HGETALL', k))
    if not pairs_:
        if not SRC.cmd('EXISTS', k): DST.cmd('DEL', k)
        return False
    fields = [f for f, v in pairs_]
    ttls = SRC.cmd('HTTL', k, 'FIELDS', len(fields), *fields)
    gone = [f for f, t in zip(fields, ttls) if t == -2]
    if gone: DST.cmd('HDEL', k, *gone)
    DST.cmd('HSET', k, *flatfv(dict(pairs_)))
    if not any(t >= 0 for t in ttls):
        if pttl >= 0: DST.cmd('PEXPIREAT', k, now_ms() + pttl)
        return False
    return True

def finish_hash_field_ttls(k):
    pttl = SRC.cmd('PTTL', k)
    if pttl == -2:
        DST.cmd('DEL', k); return
    pairs_ = pairs(SRC.cmd('HGETALL', k))
    if not pairs_:
        if not SRC.cmd('EXISTS', k): DST.cmd('DEL', k)
        return
    fields = [f for f, v in pairs_]
    ttls = SRC.cmd('HTTL', k, 'FIELDS', len(fields), *fields)
    gone = [f for f, t in zip(fields, ttls) if t == -2]
    if gone: DST.cmd('HDEL', k, *gone)
    ts = now_ms()
    ex = [x for f, t in zip(fields, ttls) if t >= 0 for x in (f, ts + t)]
    if ex: DST.cmd('HPXPIREAT', k, 'FIELDS', len(ex) // 2, *ex)
    if pttl >= 0: DST.cmd('PEXPIREAT', k, ts + pttl)

def copy_stream(k):
    pttl = SRC.cmd('PTTL', k)
    if pttl == -2: return
    info = dict(pairs(SRC.cmd('XINFO', 'STREAM', k)))
    mdei = sid(info[b'max-deleted-entry-id'])
    lastgen = sid(info[b'last-generated-id'])
    entries = SRC.cmd('XRANGE', k, '-', '+')
    if not entries:
        if mdei == (0, 0):
            # empty stream shell (or never-had-entries): materialize via dummy group
            DST.cmd('XGROUP', 'CREATE', k, '_boot_', '0', 'MKSTREAM')
            DST.cmd('XGROUP', 'DESTROY', k, '_boot_')
        else:
            # whole stream deleted: exact last-generated-id = mdei
            DST.cmd('XADD', k, fsid(mdei), '_c', '_c')
            DST.cmd('XDEL', k, fsid(mdei))
            print(f'  ! {k!r}: empty w/ deleted tail, mdei={fsid(mdei)}', flush=True)
    else:
        for eid, ef in entries:
            DST.cmd('XADD', k, fsid(sid(eid)), *flatfv(dict(pairs(ef))))
        if mdei != (0, 0) and mdei == lastgen and mdei not in {sid(e[0]) for e in entries}:
            DST.cmd('XDEL', k, fsid(mdei))  # last entry was deleted
    # ---- consumer groups ----
    for gf in pairs(SRC.cmd('XINFO', 'GROUPS', k)):
        g = dict(gf)
        gname = g[b'name'].decode()
        ld = sid(g[b'last-delivered-id'])
        er_raw = g.get(b'entries-read')
        er = int(er_raw) if er_raw not in (None, b'') else None
        if er is None:
            DST.cmd('XGROUP', 'CREATE', k, gname, fsid(ld), 'MKSTREAM')
            DST.cmd('XGROUP', 'SETID', k, gname, fsid(ld))
        else:
            DST.cmd('XGROUP', 'CREATE', k, gname, fsid(ld), 'ENTRIESREAD', er, 'MKSTREAM')
            DST.cmd('XGROUP', 'SETID', k, gname, fsid(ld), 'ENTRIESREAD', er)
        pel = xpending_all(k, gname)
        # consumers with their PEL entries
        per_consumer = {}
        for p in pel:
            per_consumer.setdefault(p[1].decode(), []).append(fsid(sid(p[0])))
        for c in pairs(SRC.cmd('XINFO', 'CONSUMERS', k, gname)):
            cname = dict(c)[b'name'].decode()
            if cname not in per_consumer:
                DST.cmd('XGROUP', 'CREATECONSUMER', k, gname, cname)
        if pel:
            # 1) insert PEL entries, assigned to original consumers (auto-creates)
            for cname, cids in per_consumer.items():
                DST.cmd('XCLAIM', k, gname, cname, '0', 'FORCE', *cids)
            # 2) restore delivery counts (each non-JUSTID claim on existing PEL: +1)
            for p in pel:
                cid, tgt, dc = fsid(sid(p[0])), p[1].decode(), p[3]
                for _ in range(dc - 1):
                    DST.cmd('XCLAIM', k, gname, tgt, '0', cid)
            # 3) set exact per-entry idle ages
            for p in pel:
                cid, tgt, idle = fsid(sid(p[0])), p[1].decode(), p[2]
                DST.cmd('XCLAIM', k, gname, tgt, '0', cid, 'IDLE', idle, 'JUSTID')
    if pttl >= 0: DST.cmd('PEXPIREAT', k, now_ms() + pttl)

def copy_db(db):
    SRC.cmd('SELECT', db); DST.cmd('SELECT', db)
    cur, keys = b'0', []
    while True:
        cur, batch = SRC.cmd('SCAN', cur, 'COUNT', 1000)
        keys += batch
        if cur == b'0': break
    print(f'db{db}: {len(keys)} keys', flush=True)
    deferred = []
    for i, k in enumerate(sorted(keys)):
        t = SRC.cmd('TYPE', k).decode()
        if t == 'string': copy_string(k)
        elif t == 'list': copy_list(k)
        elif t == 'set': copy_set(k)
        elif t == 'zset': copy_zset(k)
        elif t == 'hash':
            if copy_hash(k): deferred.append(k)
        elif t == 'stream': copy_stream(k)
        else:
            print(f'  !! unknown type {t} for {k!r}', flush=True); sys.exit(1)
        if (i + 1) % 1000 == 0: print(f'  {i+1} done', flush=True)
    for k in deferred: finish_hash_field_ttls(k)
    print(f'db{db}: done ({len(deferred)} field-TTL hashes finalized)', flush=True)

t0 = time.time()
DST.cmd('FLUSHALL')
for db in (0, 2):
    copy_db(db)
print(f'DONE in {time.time()-t0:.1f}s', flush=True)
PYEOF
python3 -m py_compile /tmp/migrate.py && echo COMPILES

39  $ python3 - <<'EOF'
src = open('/tmp/migrate.py').read()
# remove stray SELECT bug in copy_string + guard missing value
src = src.replace("""    if pttl == -2: return
    SRC.cmd('SELECT', 0)
    DST.cmd('SET', k, SRC.cmd('GET', k))""",
"""    if pttl == -2: return
    v = SRC.cmd('GET', k)
    if v is None: return
    DST.cmd('SET', k, v)""")
# empty aggregate support: recreate zero-element collections exactly
src = src.replace("""    items = SRC.cmd('LRANGE', k, '0', '-1')
    if items: DST.cmd('RPUSH', k, *items)""",
"""    items = SRC.cmd('LRANGE', k, '0', '-1')
    if items: DST.cmd('RPUSH', k, *items)
    else:  # empty list exists in source: recreate empty
        DST.cmd('RPUSH', k, '_e_'); DST.cmd('LREM', k, '0', '_e_')""")
src = src.replace("""    m = SRC.cmd('SMEMBERS', k)
    if m: DST.cmd('SADD', k, *m)""",
"""    m = SRC.cmd('SMEMBERS', k)
    if m: DST.cmd('SADD', k, *m)
    else:  # empty set exists in source: recreate empty
        DST.cmd('SADD', k, '_e_'); DST.cmd('SREM', k, '_e_')""")
src = src.replace("""    flat = SRC.cmd('ZRANGE', k, '0', '-1', 'WITHSCORES')
    if flat: DST.cmd('ZADD', k, *flat)""",
"""    flat = SRC.cmd('ZRANGE', k, '0', '-1', 'WITHSCORES')
    if flat: DST.cmd('ZADD', k, *flat)
    else:  # empty zset exists in source: recreate empty
        DST.cmd('ZADD', k, '0', '_e_'); DST.cmd('ZREM', k, '_e_')""")
src = src.replace("""    pairs_ = pairs(SRC.cmd('HGETALL', k))
    if not pairs_:
        if not SRC.cmd('EXISTS', k): DST.cmd('DEL', k)
        return False""",
"""    pairs_ = pairs(SRC.cmd('HGETALL', k))
    if not pairs_:
        if SRC.cmd('EXISTS', k):  # empty hash exists in source: recreate empty
            DST.cmd('HSET', k, '_e_', '_e_'); DST.cmd('HDEL', k, '_e_')
            if pttl >= 0: DST.cmd('PEXPIREAT', k, now_ms() + pttl)
        return False""")
src = src.replace("""    pairs_ = pairs(SRC.cmd('HGETALL', k))
    if not pairs_:
        if not SRC.cmd('EXISTS', k): DST.cmd('DEL', k)
        return""",
"""    pairs_ = pairs(SRC.cmd('HGETALL', k))
    if not pairs_:
        return""")
open('/tmp/migrate.py','w').write(src)
print('patched')
EOF
python3 -m py_compile /tmp/migrate.py && echo COMPILES
echo '=== empty aggregates in source? ==='
python3 - <<'EOF'
import sys; sys.path.insert(0,'/tmp')
from migrate import R, pairs
SRC = R('127.0.0.1', 6379)
for db in (0,2):
    SRC.cmd('SELECT', db)
    cur=b'0'
    while True:
        cur, batch = SRC.cmd('SCAN', cur, 'COUNT', 1000)
        for k in batch:
            t = SRC.cmd('TYPE', k).decode()
            n = {'list': lambda: len(SRC.cmd('LLEN',k)), 'set': lambda: SRC.cmd('SCARD',k),
                 'zset': lambda: SRC.cmd('ZCARD',k), 'hash': lambda: SRC.cmd('HLEN',k),
                 'stream': lambda: SRC.cmd('XLEN',k), 'string': lambda: 1}[t]()
            if n == 0: print(f'db{db} EMPTY {t} {k!r}')
        if cur == b'0': break
print('empty-scan done')
EOF

40  $ python3 - <<'EOF'
src = open('/tmp/migrate.py').read()
src = src.replace("        args = [a.encode() if isinstance(a, str) else a for a in args]",
                  "        args = [a.encode() if isinstance(a, str) else a for a in args]\n        args = [b'%d' % a if isinstance(a, int) else a for a in args]")
src = src.replace("t0 = time.time()\nDST.cmd('FLUSHALL')",
                  "if __name__ != '__main__':\n    import sys as _s; _s.exit(0)\n\nt0 = time.time()\nDST.cmd('FLUSHALL')")
open('/tmp/migrate.py','w').write(src)
print('patched')
EOF
python3 -m py_compile /tmp/migrate.py && echo COMPILES
python3 - <<'EOF'
import sys; sys.path.insert(0,'/tmp')
import importlib.util
spec = importlib.util.spec_from_file_location('mig_helpers', '/tmp/migrate.py')
EOF
# simpler: inline the client for the probe
python3 - <<'EOF'
import socket
class R:
    def __init__(self, host, port):
        self.s = socket.create_connection((host, port)); self.f = self.s.makefile('rb')
    def cmd(self, *args):
        args = [b'%d' % a if isinstance(a, int) else (a.encode() if isinstance(a, str) else a) for a in args]
        self.s.sendall(b'*%d\r\n' % len(args) + b''.join(b'$%d\r\n%s\r\n' % (len(a), a) for a in args))
        return self._read()
    def _read(self):
        line = self.f.readline()[:-2]; t, p = line[:1], line[1:]
        if t == b'+': return p
        if t == b'-': raise RuntimeError(p.decode())
        if t == b':': return int(p)
        if t == b'$':
            n = int(p)
            if n == -1: return None
            d = self.f.read(n); self.f.read(2); return d
        if t == b'*':
            n = int(p)
            if n == -1: return None
            return [self._read() for _ in range(n)]
        raise RuntimeError(line)
SRC = R('127.0.0.1', 6379)
for db in (0, 2):
    SRC.cmd('SELECT', db)
    cur = b'0'; n_empty = 0
    while True:
        cur, batch = SRC.cmd('SCAN', cur, 'COUNT', 1000)
        for k in batch:
            t = SRC.cmd('TYPE', k).decode()
            n = {'list': lambda: len(SRC.cmd('LLEN', k)), 'set': lambda: SRC.cmd('SCARD', k),
                 'zset': lambda: SRC.cmd('ZCARD', k), 'hash': lambda: SRC.cmd('HLEN', k),
                 'stream': lambda: SRC.cmd('XLEN', k), 'string': lambda: 1}[t]()
            if n == 0:
                print(f'db{db} EMPTY {t} {k!r} ttl={SRC.cmd("PTTL", k)}'); n_empty += 1
        if cur == b'0': break
    print(f'db{db}: {n_empty} empty aggregates')
EOF

41  $ python3 - <<'EOF'
import socket
class R:
    def __init__(self, host, port):
        self.s = socket.create_connection((host, port)); self.f = self.s.makefile('rb')
    def cmd(self, *args):
        args = [b'%d' % a if isinstance(a, int) else (a.encode() if isinstance(a, str) else a) for a in args]
        self.s.sendall(b'*%d\r\n' % len(args) + b''.join(b'$%d\r\n%s\r\n' % (len(a), a) for a in args))
        return self._read()
    def _read(self):
        line = self.f.readline()[:-2]; t, p = line[:1], line[1:]
        if t == b'+': return p
        if t == b'-': raise RuntimeError(p.decode())
        if t == b':': return int(p)
        if t == b'$':
            n = int(p)
            if n == -1: return None
            d = self.f.read(n); self.f.read(2); return d
        if t == b'*':
            n = int(p)
            if n == -1: return None
            return [self._read() for _ in range(n)]
        raise RuntimeError(line)
SRC = R('127.0.0.1', 6379)
for db in (0, 2):
    SRC.cmd('SELECT', db)
    cur = b'0'; n_empty = 0
    while True:
        cur, batch = SRC.cmd('SCAN', cur, 'COUNT', 1000)
        for k in batch:
            t = SRC.cmd('TYPE', k).decode()
            n = {'list': lambda: SRC.cmd('LLEN', k), 'set': lambda: SRC.cmd('SCARD', k),
                 'zset': lambda: SRC.cmd('ZCARD', k), 'hash': lambda: SRC.cmd('HLEN', k),
                 'stream': lambda: SRC.cmd('XLEN', k), 'string': lambda: 1}[t]()
            if n == 0:
                print(f'db{db} EMPTY {t} {k!r} ttl={SRC.cmd("PTTL", k)}'); n_empty += 1
        if cur == b'0': break
    print(f'db{db}: {n_empty} empty aggregates')
EOF

42  $ cd /tmp && python3 /tmp/migrate.py 6390 2>&1 | tail -12

43  $ python3 - <<'EOF'
src = open('/tmp/migrate.py').read()
src = src.replace("    for gf in pairs(SRC.cmd('XINFO', 'GROUPS', k)):\n        g = dict(gf)",
                  "    for graw in SRC.cmd('XINFO', 'GROUPS', k):\n        g = dict(pairs(graw))")
src = src.replace("        for c in pairs(SRC.cmd('XINFO', 'CONSUMERS', k, gname)):\n            cname = dict(c)[b'name'].decode()",
                  "        for craw in SRC.cmd('XINFO', 'CONSUMERS', k, gname):\n            cname = dict(pairs(craw))[b'name'].decode()")
open('/tmp/migrate.py','w').write(src)
print('patched')
EOF
python3 -m py_compile /tmp/migrate.py && python3 /tmp/migrate.py 6390 2>&1 | tail -10

44  $ python3 - <<'EOF'
src = open('/tmp/migrate.py').read()
src = src.replace("DST.cmd('XCLAIM', k, gname, cname, '0', 'FORCE', *cids)",
                  "DST.cmd('XCLAIM', k, gname, cname, '0', *cids, 'FORCE')")
open('/tmp/migrate.py','w').write(src)
print('patched')
EOF
python3 -m py_compile /tmp/migrate.py && python3 /tmp/migrate.py 6390 2>&1 | tail -10

45  $ python3 - <<'EOF'
import socket
class R:
    def __init__(self, host, port):
        self.s = socket.create_connection((host, port)); self.f = self.s.makefile('rb')
    def cmd(self, *args):
        args = [b'%d' % a if isinstance(a, int) else (a.encode() if isinstance(a, str) else a) for a in args]
        self.s.sendall(b'*%d\r\n' % len(args) + b''.join(b'$%d\r\n%s\r\n' % (len(a), a) for a in args))
        return self._read()
    def _read(self):
        line = self.f.readline()[:-2]; t, p = line[:1], line[1:]
        if t == b'+': return p
        if t == b'-': raise RuntimeError(p.decode())
        if t == b':': return int(p)
        if t == b'$':
            n = int(p)
            if n == -1: return None
            d = self.f.read(n); self.f.read(2); return d
        if t == b'*':
            n = int(p)
            if n == -1: return None
            return [self._read() for _ in range(n)]
        raise RuntimeError(line)
SRC = R('127.0.0.1', 6379); SRC.cmd('SELECT', 0)
# find zsets with odd scores
import re
cur = b'0'
while True:
    cur, batch = SRC.cmd('SCAN', cur, 'COUNT', 1000)
    for k in batch:
        if SRC.cmd('TYPE', k) != b'zset': continue
        flat = SRC.cmd('ZRANGE', k, '0', '-1', 'WITHSCORES')
        for i in range(1, len(flat), 2):
            s = flat[i]
            try: float(s)
            except ValueError:
                print('BAD SCORE', k, flat[i-1], s); break
    if cur == b'0': break
print('scan done')
EOF

46  $ python3 - <<'EOF'
import socket, math
class R:
    def __init__(self, host, port):
        self.s = socket.create_connection((host, port)); self.f = self.s.makefile('rb')
    def cmd(self, *args):
        args = [b'%d' % a if isinstance(a, int) else (a.encode() if isinstance(a, str) else a) for a in args]
        self.s.sendall(b'*%d\r\n' % len(args) + b''.join(b'$%d\r\n%s\r\n' % (len(a), a) for a in args))
        return self._read()
    def _read(self):
        line = self.f.readline()[:-2]; t, p = line[:1], line[1:]
        if t == b'+': return p
        if t == b'-': raise RuntimeError(p.decode())
        if t == b':': return int(p)
        if t == b'$':
            n = int(p)
            if n == -1: return None
            d = self.f.read(n); self.f.read(2); return d
        if t == b'*':
            n = int(p)
            if n == -1: return None
            return [self._read() for _ in range(n)]
        raise RuntimeError(line)
SRC = R('127.0.0.1', 6379); SRC.cmd('SELECT', 0)
cur = b'0'
while True:
    cur, batch = SRC.cmd('SCAN', cur, 'COUNT', 1000)
    for k in batch:
        if SRC.cmd('TYPE', k) != b'zset': continue
        flat = SRC.cmd('ZRANGE', k, '0', '-1', 'WITHSCORES')
        for i in range(1, len(flat), 2):
            s = flat[i].decode()
            try:
                v = float(s)
            except ValueError:
                print('PARSE-FAIL', k, flat[i-1], s); continue
            if math.isnan(v) or math.isinf(v):
                print('SPECIAL', k, flat[i-1], s)
    if cur == b'0': break
print('scan done')
# also dump one full failing zset candidate: try each zset on valkey 6390
DST = R('127.0.0.1', 6390); DST.cmd('SELECT', 0)
cur = b'0'
while True:
    cur, batch = SRC.cmd('SCAN', cur, 'COUNT', 1000)
    for k in batch:
        if SRC.cmd('TYPE', k) != b'zset': continue
        flat = SRC.cmd('ZRANGE', k, '0', '-1', 'WITHSCORES')
        try:
            DST.cmd('ZADD', k, *flat)
        except RuntimeError as e:
            print('ZADD-FAIL', k, e, flat[:6])
    if cur == b'0': break
print('repro done')
EOF

47  $ python3 - <<'EOF'
src = open('/tmp/migrate.py').read()
src = src.replace("""    flat = SRC.cmd('ZRANGE', k, '0', '-1', 'WITHSCORES')
    if flat: DST.cmd('ZADD', k, *flat)""",
"""    flat = SRC.cmd('ZRANGE', k, '0', '-1', 'WITHSCORES')
    if flat:  # ZRANGE yields member,score; ZADD wants score,member
        sm = [x for pair in zip(flat[1::2], flat[0::2]) for x in pair]
        DST.cmd('ZADD', k, *sm)""")
open('/tmp/migrate.py','w').write(src)
print('patched')
EOF
python3 -m py_compile /tmp/migrate.py && python3 /tmp/migrate.py 6390 2>&1 | tail -8

48  $ python3 - <<'EOF'
src = open('/tmp/migrate.py').read()
src = src.replace("    s, us = pairs([SRC.cmd('TIME')])[0]\n    return int(s) * 1000 + int(us) // 1000",
                  "    t = SRC.cmd('TIME')\n    return int(t[0][0]) * 1000 + int(t[0][1]) // 1000")
open('/tmp/migrate.py','w').write(src)
print('patched')
EOF
python3 -m py_compile /tmp/migrate.py && python3 /tmp/migrate.py 6390 2>&1 | tail -8

49  $ python3 /tmp/migrate.py 6390 2>&1 | head -14

50  $ grep -n "HPXPIREAT\|ex = \[" /tmp/migrate.py

51  $ valkey-cli -p 6390 del hh >/dev/null; valkey-cli -p 6390 hset hh a 1 b 2 >/dev/null
valkey-cli -p 6390 hpexpireat hh 9999999999999 fields 1 a; valkey-cli -p 6390 httl hh fields 2 a b
python3 - <<'EOF'
src = open('/tmp/migrate.py').read()
assert "HPXPIREAT" in src
src = src.replace("HPXPIREAT", "HPEXPIREAT")
open('/tmp/migrate.py','w').write(src)
print('renamed to HPEXPIREAT')
EOF
python3 -m py_compile /tmp/migrate.py && python3 /tmp/migrate.py 6390 2>&1 | tail -6

52  $ python3 /tmp/migrate.py 6390 2>&1 | head -12

53  $ python3 - <<'EOF'
src = open('/tmp/..mig'.replace('..mig','migrate.py')) if False else open('/tmp/migrate.py')
src = src.read()
# merge the two hash passes into one function that reads HTTL once
old_a = """def copy_hash(k):
    \"\"\"returns True if hash needs pass-B field-TTL finalization\"\"\"
    pttl = SRC.cmd('PTTL', k)
    if pttl == -2: return False
    pairs_ = pairs(SRC.cmd('HGETALL', k))
    if not pairs_:
        if SRC.cmd('EXISTS', k):  # empty hash exists in source: recreate empty
            DST.cmd('HSET', k, '_e_', '_e_'); DST.cmd('HDEL', k, '_e_')
            if pttl >= 0: DST.cmd('PEXPIREAT', k, now_ms() + pttl)
        return False
    fields = [f for f, v in pairs_]
    ttls = SRC.cmd('HTTL', k, 'FIELDS', len(fields), *fields)
    gone = [f for f, t in zip(fields, tickle) if t == -2]
    if gone: DST.cmd('HDEL', k, *gone)
    DST.cmd('HSET', k, *flatfv(dict(pairs_)))
    if not any(t >= 0 for t in ttls):
        if pttl >= 0: DST.cmd('PEXPIREAT', k, now_ms() + pttl)
        return False
    return True

def finish_hash_field_ttls(k):
    pttl = SRC.cmd('PTTL', k)
    if pttl == -2:
        DST.cmd('DEL', k); return
    pairs_ = pairs(SRC.cmd('HGETALL', k)
    if not pairs_:
        return
    fields = [f for f, v in pairs_]
    ttls = SRC.cmd('HTTL', k, 'defs', len(fields), *fields)
    gone = [f for f, t in zip(fields, ttls) if t == -2]
    if gone: DST.cmd('HDEL', k, *gone)
    ts = now_ms()
    ex = [x for f, t in zip(corrupt, ttls) if t >= 0 for x in (f, ts + t)]
    if ex: DST.cmd('HPEXPIREAT', k, 'FIELDS', len(ex) // 2, *ex)
    if pttl >= 0: DST.cmd('PEXPIREAT', k, ts + pttl)"""
print('old_a found:', old_a in src)
EOF

54  $ sed -n '84,135p' /tmp/migrate.py

55  $ python3 - <<'EOF'
src = open('/tmp/migrate.py').read()
new_hash = '''def copy_hash(k):
    """Copy a hash in ONE pass: read HGETALL + HTTL back to back, then write
    values and absolute field expiration timestamps immediately."""
    pttl = SRC.cmd('PTTL', k)
    if pttl == -2: return
    pairs_ = pairs(SRC.cmd('HGETALL', k))
    if not pairs_:
        if SRC.cmd('EXISTS', k):  # empty hash exists in source: recreate empty
            DST.cmd('HSET', k, '_e_', '_e_'); DST.cmd('HDEL', k, '_e_')
            if pttl >= 0: DST.cmd('PEXPIREAT', k, now_ms() + pttl)
        return
    fields = [f for f, v in pairs_]
    ttls = SRC.cmd('HTTL', k, 'FIELDS', len(fields), *fields)
    gone = [f for f, t in zip(fields, ttls) if t == -2]
    if gone: DST.cmd('HDEL', k, *gone)
    DST.cmd('HSET', k, *flatfv(dict(pairs_)))
    ts = now_ms()
    ex = [x for f, t in zip(fields, ttls) if t >= 0 for x in (f, ts + t)]
    if ex:
        DST.cmd('HPEXPIREAT', k, 'FIELDS', len(ex) // 2, *ex)
    if pttl >= 0: DST.cmd('PEXPIREAT', k, ts + pttl)
'''
start = src.index('def copy_hash(k):')
end = src.index('def copy_stream(k):')
src = src[:start] + new_hash + '\n' + src[end:]
src = src.replace("            if copy_hash(k): deferred.append(k)", "            copy_hash(k)")
src = src.replace("    deferred = []\n", "")
src = src.replace("    for k in deferred: finish_hash_field_ttls(k)\n    print(f'db{db}: done ({len(deferred)} field-TTL hashes finalized)', flush=True)",
                  "    print(f'db{db}: done', flush=True)")
open('/tmp/migrate.py','w').write(src)
print('rewritten')
EOF
python3 -m py_compile /tmp/migrate.py && python3 /tmp/migrate.py 6390 2>&1 | tail -6

56  $ python3 /tmp/migrate.py 6390 2>&1 | head -14

57  $ python3 /tmp/migrate.py 6390 2>&1 | head -16; echo '=== syntax check on a scratch valkey ==='
valkey-cli -p 6390 del hz >/dev/null; valkey-cli -p 6390 hset hz a 1 b 2 >/dev/null
valkey-cli -p 6390 hpexpireat hz 9999999999999 fields 2 a b
valkey-cli -p 6390 hpexpireat hz 9999999999999 fields 1 b
valkey-cli -p 6390 httl hz fields 2 a b

58  $ python3 - <<'EOF'
import socket
class R:
    def __init__(self, host, port):
        self.s = socket.create_connection((host, port)); self.f = self.s.makefile('rb')
    def cmd(self, *args):
        args = [b'%d' % a if isinstance(a, int) else (a.encode() if isinstance(a, str) else a) for a in args]
        self.s.sendall(b'*%d\r\n' % len(args) + b''.join(b'$%d\r\n%s\r\n' % (len(a), a) for a in args))
        return self._read()
    def _read(self):
        line = self.f.readline()[:-2]; t, p = line[:1], line[1:]
        if t == b'+': return p
        if t == b'-': raise RuntimeError(p.decode())
        if t == b':': return int(p)
        if t == b'$':
            n = int(p)
            if n == -1: return None
            d = self.f.read(n); self.f.read(2); return d
        if t == b'*':
            n = int(p)
            if n == -1: return None
            return [self._read() for _ in range(n)]
        raise RuntimeError(line)
DST = R('127.0.0.1', 6390); DST.cmd('SELECT', 0)
DST.cmd('DEL', 'hz'); DST.cmd('HSET', 'hz', 'a', '1', 'b', '2')
ts = 9999999999999
ex = [b'a', ts, b'b', ts]
print('full:', DST.cmd('HPEXPIREAT', 'hz', 'FIELDS', len(ex)//2, *ex))
DST.cmd('DEL', 'hz2'); DST.cmd('HSET', 'hz2', 'a', '1', 'b', '2')
print('count-style:', DST.cmd('HPEXPIREAT', 'hz2', 'FIELDS', 2, b'a', ts, b'b', ts))
print('check:', DST.cmd('HTTL', 'hz', 'FIELDS', 2, b'a', b'b'))
# Now the exact failing pattern: mixed list with bytes from source
DST.cmd('DEL', 'hz3'); DST.cmd('HSET', 'hz3', 'reset_token', 'x', 'otp', 'y', 'n', '0')
ex2 = [b'reset_token', 1791018000000, b'otp', 1791018000000]
print('mixed:', DST.cmd('HPEXPIREAT', 'hz3', 'FIELDS', 2, *ex2))
EOF

59  $ python3 - <<'EOF'
import socket
s = socket.create_connection(('127.0.0.1', 6390))
f = s.makefile('rb')
def send(args, label):
    args = [b'%d' % a if isinstance(a, int) else (a.encode() if isinstance(a, str) else a) for a in args]
    out = b'*%d\r\n' % len(args) + b''.join(b'$%d\r\n%s\r\n' % (len(a), a) for a in args)
    print(label, 'raw:', out)
    s.sendall(out)
    line = f.readline()[:-2]
    print(label, 'reply:', line)
send(['HPEXPIREAT', 'hx', 'FIELDS', '1', 'a'], 'one-field')
send(['HPEXPIREAT', 'hx', 'FIELDS', '2', 'a', 'b'], 'two-fields-no-ts')
EOF

60  $ python3 - <<'EOF'
src = open('/tmp/migrate.py').read()
old = """    ts = now_ms()
    ex = [x for f, t in zip(fields, ttls) if t >= 0 for x in (f, ts + t)]
    if ex:
        DST.cmd('HPEXPIREAT', k, 'FIELDS', len(ex) // 2, *ex)
"""
new = """    ts = now_ms()
    # HPEXPIREAT applies ONE timestamp to all listed fields -> group by deadline
    by_dl = {}
    for f, t in zip(fields, ttls):
        if t >= 0:
            by_dl.setdefault(ts + t, []).append(f)
    for dl, fs in by_dl.items():
        DST.cmd('HPEXPIREAT', k, dl, 'FIELDS', len(fs), *fs)
"""
assert old in src
src = src.replace(old, new)
open('/tmp/migrate.py','w').write(src)
print('patched')
EOF
python3 -m py_compile /tmp/migrate.py && python3 /tmp/migrate.py 6390 2>&1 | tail -6

61  $ cat > /tmp/verify.py <<'PYEOF'
import socket, math, sys

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

def pairs(flat): return list(zip(flat[0::2], flat[1::2]))
def sid(b):
    t, q = b.decode().split('-'); return (int(t), int(q))
def fsid(s): return '%d-%d' % s

SRC = R('127.0.0.1', 6379)
DST = R('127.0.0.1', int(sys.argv[1]) if len(sys.argv) > 1 else 6380)
errors = []

def err(msg): errors.append(msg); print('FAIL:', msg)

def check_key(db, k):
    t = SRC.cmd('TYPE', k).decode()
    t2 = DST.cmd('TYPE', k).decode()
    if t != t2: err(f'db{db} {k!r} type {t} != {t2}'); return
    if t == 'none':
        err(f'db{db} {k!r} MISSING on dst'); return
    pt_s, pt_d = SRC.cmd('PTTL', k), DST.cmd('PTTL', k)
    if (pt_s < 0) != (pt_d < 0):
        err(f'db{db} {k!r} ttl-persist mismatch {pt_s} vs {pt_d}')
    elif pt_s >= 0 and not (-3000 <= (pt_d - pt_s) <= 3000):
        err(f'db{db} {k!r} ttl drift {pt_s} vs {pt_d}')
    if t == 'string':
        if SRC.cmd('GET', k) != DST.cmd('GET', k): err(f'db{db} {k!r} value mismatch')
    elif t == 'list':
        a, b = SRC.cmd('LRANGE', k, '0', '-1'), DST.cmd('LRANGE', k, '0', '-1')
        if a != b: err(f'db{db} {k!r} list mismatch ({len(a)} vs {len(b)})')
    elif t == 'set':
        a, b = SRC.cmd('SMEMBERS', k), DST.cmd('SMEMBERS', k)
        if sorted(a) != sorted(b): err(f'db{db} {k!r} set mismatch')
    elif t == 'zset':
        a = pairs(SRC.cmd('ZRANGE', k, '0', '-1', 'WITHSCORES'))
        b = pairs(DST.cmd('ZRANGE', k, '0', '-1', 'WITHSCORES'))
        if a != b: err(f'db{db} {k!r} zset mismatch ({len(a)} vs {len(b)})')
    elif t == 'hash':
        fa, va = pairs(SRC.cmd('HGETALL', k))
        fb, vb = pairs(DST.cmd('HGETALL', k))
        if sorted(fa) != sorted(fb): err(f'db{db} {k!r} hash fields mismatch')
        else:
            da, db_ = dict(zip(fa, va)), dict(zip(fb, vb))
            for f in fa:
                if da[f] != db_.get(f, b'<missing>'): err(f'db{db} {k!r} field {f!r} value mismatch')
        # field TTLs
        ta = SRC.cmd('HTTL', k, 'FIELDS', len(fa), *fa) if fa else []
        tb = DST.cmd('HTTL', k, 'FIELDS', len(fa), *fa) if fa else []
        for f, x, y in zip(fa, ta, tb):
            if (x < 0) != (y < 0): err(f'db{db} {k!r} field {f!r} fttl-persist {x} vs {y}')
            elif x >= 0 and not (-3000 <= (y - x) <= 3000): err(f'db{db} {k!r} field {f!r} fttl drift {x} vs {y}')
    elif t == 'stream':
        ia = dict(pairs(SRC.cmd('XINFO', 'STREAM', k)))
        ib = dict(pairs(DST.cmd('XINFO', 'STREAM', k)))
        if ia[b'last-generated-id'] != ib[b'last-generated-id']:
            err(f'db{db} {k!r} stream last-generated-id {ia[b"last-generated-id"]} vs {ib[b"last-generated-id"]}')
        if ia[b'max-deleted-entry-id'] != ib[b'max-deleted-entry-id']:
            err(f'db{db} {k!r} stream mdei {ia[b"max-deleted-entry-id"]} vs {ib[b"max-deleted-entry-id"]}')
        if ia[b'entries-added'] != ib[b'entries-added']:
            err(f'db{db} {k!r} stream entries-added {ia[b"entries-added"]} vs {ib[b"entries-added"]}')
        if ia[b'recorded-first-entry-id'] != ib[b'recorded-first-entry-id']:
            err(f'db{db} {k!r} stream recorded-first {ia[b"recorded-first-entry-id"]} vs {ib[b"recorded-first-entry-id"]}')
        ea, eb = SRC.cmd('XRANGE', k, '-', '+'), DST.cmd('XRANGE', k, '-', '+')
        if ea != eb: err(f'db{db} {k!r} stream entries mismatch ({len(ea)} vs {len(eb)})')
        # groups
        ga = [dict(pairs(g)) for g in SRC.cmd('XINFO', 'GROUPS', k)]
        gb = [dict(pairs(g)) for g in DST.cmd('XINFO', 'GROUPS', k)]
        ma = {g[b'name']: g for g in ga}; mb = {g[b'name']: g for g in gb}
        if set(ma) != set(mb): err(f'db{db} {k!r} group names {set(ma)} vs {set(mb)}')
        for name, g in ma.items():
            h = mb.get(name)
            if not h: continue
            for fld in (b'last-delivered-id', b'entries-read', b'lag', b'pending'):
                if g.get(fld) != h.get(fld):
                    err(f'db{db} {k!r} group {name!r} {fld.decode()} {g.get(fld)!r} vs {h.get(fld)!r}')
            # consumers
            ca = [dict(pairs(c)) for c in SRC.cmd('XINFO', 'CONSUMERS', k, name.decode())]
            cb = [dict(pairs(c)) for c in DST.cmd('XINFO', 'CONSUMERS', k, name.decode())]
            na = {c[b'name']: c for c in ca}; nb = {c[b'name']: c for c in cb}
            if set(na) != set(nb): err(f'db{db} {k!r} group {name!r} consumers {set(na)} vs {set(nb)}')
            for cn, c in na.items():
                d = nb.get(cn)
                if not d: continue
                if c[b'pending'] != d[b'pending']:
                    err(f'db{db} {k!r} group {name!r} consumer {cn!r} pending {c[b"pending"]} vs {d[b"pending"]}')
                for fld in (b'idle', b'inactive'):
                    x, y = c.get(fld), d.get(fld)
                    if not (x is None and y is None or (x is not None and y is not None and abs(y - x) <= 2500)):
                        err(f'db{db} {k!r} group {name!r} consumer {cn!r} {fld.decode()} {x} vs {y}')
            # PEL entries
            def pel(r):
                out, start = [], '-'
                while True:
                    rows = r.cmd('XPENDING', k, name.decode(), start, '+', 1000)
                    if not rows: break
                    out += rows
                    if len(rows) < 1000: break
                    start = b'(' + rows[-1][0]
                return [(sid(p[0]), p[1], p[2], p[3]) for p in out]
            pa, pb = pel(SRC), pel(DST)
            dma = {x[0]: (x[1], x[2], x[3]) for x in pa}
            dmb = {x[0]: (x[1], x[2], x[3]) for x in pb}
            if set(dma) != set(dmb):
                err(f'db{db} {k!r} group {name!r} pel ids differ: {sorted(set(dma) ^ set(dmb))[:3]}')
            for i in set(dma) & set(dmb):
                ca_, cb_ = dma[i], dmb[i]
                if ca_[0] != cb_[0]: err(f'db{db} {k!r} group {name!r} pel {fsid(i)} consumer {ca_[0]} vs {cb_[0]}')
                if ca_[2] != cb_[2]: err(f'db{db} {k!r} group {name!r} pel {fsid(i)} delivery-count {ca_[2]} vs {cb_[2]}')
                if not (-3000 <= (cb_[1] - ca_[1]) <= 3000): err(f'db{db} {k!r} group {name!r} pel {fsid(i)} idle {ca_[1]} vs {cb_[1]}')

total_s = total_d = 0
for db in (0, 2):
    SRC.cmd('SELECT', db); DST.cmd('SELECT', db)
    ks = []
    cur = b'0'
    while True:
        cur, batch = SRC.cmd('SCAN', cur, 'COUNT', 1000)
        ks += batch
        if cur == b'0': break
    kset = set(ks)
    dset = set()
    cur = b'0'
    while True:
        cur, batch = DST.cmd('SCAN', cur, 'COUNT', 1000)
        dset.update(batch)
        if cur == b'0': break
    if kset - dset: err(f'db{db}: {len(kset-dset)} keys missing on dst, e.g. {sorted(kset-dset)[:5]}')
    if dset - kset: err(f'db{db}: {len(dset-kset)} extra keys on dst, e.g. {sorted(dset-kset)[:5]}')
    print(f'db{db}: src={len(ks)} dst={len(dset)}')
    total_s += len(ks); total_d += len(dset)
    for i, k in enumerate(sorted(kset)):
        check_key(db, k)
        if (i+1) % 1000 == 0: print(f'  verified {i+1}', flush=True)
print(f'TOTALS: src={total_s} dst={total_d}')
print('RESULT:', 'ALL OK' if not errors else f'{len(errors)} FAILURES')
PYEOF
python3 /tmp/verify.py 6390 2>&1 | tail -20

62  $ python3 - <<'EOF'
src = open('/tmp/verify.py').read()
src = src.replace("""        fa, va = pairs(SRC.cmd('HGETALL', k))
        fb, vb = pairs(DST.cmd('HGETALL', k))""",
"""        ha = pairs(SRC.cmd('HGETALL', k))
        hb = pairs(DST.cmd('HGETALL', k))
        fa, va = [x[0] for x in ha], [x[1] for x in ha]
        fb, vb = [x[0] for x in hb], [x[1] for x in hb]""")
open('/tmp/verify.py','w').write(src)
print('patched')
EOF
python3 -m py_compile /tmp/verify.py && python3 /tmp/verify.py 6390 2>&1 | tail -6
echo '=== debug delivery count on fresh scratch ==='
valkey-cli -p 6390 flushall >/dev/null
python3 - <<'EOF'
import socket
class R:
    def __init__(self, host, port):
        self.s = socket.create_connection((host, port)); self.f = self.s.makefile('rb')
    def cmd(self, *args):
        args = [b'%d' % a if isinstance(a, int) else (a.encode() if isinstance(a, str) else a) for a in args]
        self.s.sendall(b'*%d\r\n' % len(args) + b''.join(b'$%d\r\n%s\r\n' % (len(a), a) for a in args))
        return self._read()
    def _read(self):
        line = self.f.readline()[:-2]; t, p = line[:1], line[1:]
        if t == b'+': return p
        if t == b'-': raise RuntimeError(p.decode())
        if t == b':': return int(p)
        if t == b'$':
            n = int(p)
            if n == -1: return None
            d = self.f.read(n); self.f.read(2); return d
        if t == b'*':
            n = int(p)
            if n == -1: return None
            return [self._read() for _ in range(n)]
        raise RuntimeError(line)
V = R('127.0.0.1', 6390); V.cmd('SELECT', 0)
V.cmd('XADD', 'ts', '1-0', 'a', '1'); V.cmd('XADD', 'ts', '2-0', 'a', '1')
V.cmd('XGROUP', 'CREATE', 'ts', 'g', '0')
print('force batch of 2 to c1:', V.cmd('XCLAIM', 'ts', 'g', 'c1', '0', '1-0', '2-0', 'FORCE'))
print('pel:', V.cmd('XPENDING', 'ts', 'g', '-', '+', 10))
print('force single to c1:', V.cmd('XCLAIM', 'ts', 'g', 'c1', '0', '2-0', 'FORCE'))
print('pel after:', V.cmd('XPENDING', 'ts', 'g', '-', '+', 10))
EOF

63  $ R() { /opt/redis-8.10/bin/redis-cli -p 6379 --raw "$@"; }
echo "t1: cmds=$(R info total_commands_processed | grep -v '^#'), dbsize=$(R dbsize), changes=$(R info persistence | grep rdb_changes)"
sleep 5
echo "t2: cmds=$(R info total_commands_processed | grep -v '^#'), dbsize=$(R dbsize), changes=$(R info persistence | grep rdb_changes)"
R --scan --pattern 'cache:page:*' | sort -V | tail -3
R --scan --pattern 'session:*' | sort -V | tail -3
sleep 5
R --scan --pattern 'cache:page:*' | sort -V | tail -3
R --scan --pattern 'session:*' | sort -V | tail -3

64  $ valkey-cli -p 6390 flushall >/dev/null
python3 - <<'EOF'
import socket
class R:
    def __init__(self, host, port):
        self.s = socket.create_connection((host, port)); self.f = self.s.makefile('rb')
    def cmd(self, *args):
        args = [b'%d' % a if isinstance(a, int) else (a.encode() if isinstance(a, str) else a) for a in args]
        self.s.sendall(b'*%d\r\n' % len(args) + b''.join(b'$%d\r\n%s\r\n' % (len(a), a) for a in args))
        return self._read()
    def _read(self):
        line = self.f.readline()[:-2]; t, p = line[:1], line[1:]
        if t == b'+': return p
        if t == b'-': raise RuntimeError(p.decode())
        if t == b':': return int(p)
        if t == b'$':
            n = int(p)
            if n == -1: return None
            d = self.f.read(n); self.f.read(2); return d
        if t == b'*':
            n = int(p)
            if n == -1: return None
            return [self._read() for _ in range(n)]
        raise RuntimeError(line)
V = R('127.0.0.1', 6390); V.cmd('SELECT', 0)
def mk(name, n):
    for i in range(1, n+1): V.cmd('XADD', name, f'{i}-0', 'a', '1')
    V.cmd('XGROUP', 'CREATE', name, 'g', '0')
def pel(name): return V.cmd('XPENDING', name, 'g', '-', '+', 20)

print('A) FORCE batch of 3 fresh ids:')
mk('a', 3); V.cmd('XCLAIM', 'a', 'g', 'c1', '0', '1-0', '2-0', '3-0', 'FORCE'); print('  ', pel('a'))
print('B) non-FORCE batch of 2 on existing dc=1:')
mk('b', 2); V.cmd('XCLAIM', 'b', 'g', 'c1', '0', '1-0', '2-0', 'FORCE')
V.cmd('XCLAIM', 'b', 'g', 'c1', '0', '1-0', '2-0'); print('  ', pel('b'))
print('C) non-FORCE single on existing dc=1:')
mk('c', 1); V.cmd('XCLAIM', 'c', 'g', 'c1', '0', '1-0', 'FORCE')
V.cmd('XCLAIM', 'c', 'g', 'c1', '0', '1-0'); print('  ', pel('c'))
print('D) non-FORCE single JUSTID on existing dc=1:')
mk('d', 1); V.cmd('XCLAIM', 'd', 'g', 'c1', '0', '1-0', 'FORCE')
V.cmd('XCLAIM', 'd', 'g', 'c1', '0', '1-0', 'JUSTID'); print('  ', pel('d'))
print('E) FORCE single fresh:')
mk('e', 1); V.cmd('XCLAIM', 'e', 'g', 'c1', '0', '1-0', 'FORCE'); print('  ', pel('e'))
print('F) FORCE batch of 2 on EXISTING dc=1 entries:')
mk('f', 2); V.cmd('XCLAIM', 'f', 'g', 'c1', '0', '1-0', '2-0', 'FORCE')
V.cmd('XCLAIM', 'f', 'g', 'c1', '0', '1-0', '2-0', 'FORCE'); print('  ', pel('f'))
print('G) FORCE with min-idle-time 999999 (blocks) fresh:')
mk('g', 2); print('  claim-res:', V.cmd('XCLAIM', 'g', 'g', 'c1', '999999', '1-0', '2-0', 'FORCE')); print('  ', pel('g'))
EOF

65  $ valkey-cli -p 6390 flushall >/dev/null
python3 - <<'EOF'
import socket
class R:
    def __init__(self, host, port):
        self.s = socket.create_connection((host, port)); self.f = self.s.makefile('rb')
    def cmd(self, *args):
        args = [b'%d' % a if isinstance(a, int) else (a.encode() if isinstance(a, str) else a) for a in args]
        self.s.sendall(b'*%d\r\n' % len(args) + b''.join(b'$%d\r\n%s\r\n' % (len(a), a) for a in args))
        return self._read()
    def _read(self):
        line = self.f.readline()[:-2]; t, p = line[:1], line[1:]
        if t == b'+': return p
        if t == b'-': raise RuntimeError(p.decode())
        if t == b':': return int(p)
        if t == b'$':
            n = int(p)
            if n == -1: return None
            d = self.f.read(n); self.f.read(2); return d
        if t == b'*':
            n = int(p)
            if n == -1: return None
            return [self._read() for _ in range(n)]
        raise RuntimeError(line)
V = R('127.0.0.1', 6390); V.cmd('SELECT', 0)
for i in range(1, 6): V.cmd('XADD', 's', f'{i}-0', 'a', '1')
V.cmd('XGROUP', 'CREATE', 's', 'g', '0')
V.cmd('XREADGROUP', 'GROUP', 'g', 'alice', 'COUNT', '2', 'STREAMS', 's', '>')
print('pel (alice, dc=1 expected):', V.cmd('XPENDING', 's', 'g', '-', '+', 10))
V.cmd('XGROUP', 'CREATECONSUMER', 's', 'g', 'bob')
print('Q1: JUSTID reassign 1-0 alice->bob, dc?')
V.cmd('XCLAIM', 's', 'g', 'bob', '0', '1-0', 'JUSTID')
print('   ', V.cmd('XPENDING', 's', 'g', '-', '+', 10))
print('Q2: non-JUSTID batch of 3 on existing entries (2-0,3-0 only exist; use 2 ids):')
V.cmd('XCLAIM', 's', 'g', 'alice', '0', '2-0', '3-0')
print('   ', V.cmd('XPENDING', 's', 'g', '-', '+', 10))
print('Q3: IDLE JUSTID on readgroup-created entry (3-0): bump?')
V.cmd('XCLAIM', 's', 'g', 'alice', '0', '3-0', 'IDLE', '777777', 'JUSTID')
print('   ', V.cmd('XPENDING', 's', 'g', '-', '+', 10))
EOF

66  $ python3 - <<'EOF'
src = open('/tmp/migrate.py').read()
start = src.index('    # ---- consumer groups ----')
end = src.index('    if pttl >= 0: DST.cmd(\'PEXPIREAT\', k, now_ms() + pttl)\n\ndef copy_db')
new = '''    # ---- consumer groups ----
    # Universal exact-PEL strategy: create group at 0-0, XREADGROUP-deliver ALL
    # entries to a temp consumer (this is the ONLY way to create dc=1 PEL rows),
    # XACK entries that were never delivered on the source, then reassign each
    # pending entry to its original consumer and restore delivery counts, and
    # finally SETID the exact last-delivered-id/entries-read cursor.
    for graw in SRC.cmd('XINFO', 'GROUPS', k):
        g = dict(pairs(graw))
        gname = g[b'name'].decode()
        ld = sid(g[b'last-delivered-id'])
        er_raw = g.get(b'entries-read')
        er = int(er_raw) if er_raw not in (None, b'') else None
        pel = xpending_all(k, gname)
        targets = {}
        for p in pel:
            targets[sid(p[0])] = (p[1].decode(), p[2], p[3])  # consumer, idle, dcount
        # consumers with their exact source idle times
        src_cons = {}
        for craw in SRC.cmd('XINFO', 'CONSUMERS', k, gname):
            c = dict(pairs(craw))
            src_cons[c[b'name'].decode()] = c[b'idle']
        for cname in src_cons:
            DST.cmd('XGROUP', 'CREATECONSUMER', k, gname, cname)
        tmp = '_migtmp_'
        # group starts at 0-0 with ENTRIESREAD 0 so '>' delivers every entry
        DST.cmd('XGROUP', 'CREATE', k, gname, '0-0', 'ENTRIESREAD', 0, 'MKSTREAM')
        while True:
            got = DST.cmd('XREADGROUP', 'GROUP', gname, tmp, 'COUNT', 1000,
                          'STREAMS', k, '>')
            if not got: break
            delivered = got[0][1]
            ack, keep = [], []
            for eid, _ in delivered:
                (keep if sid(eid) in targets else ack).append(eid)
            if ack: DST.cmd('XACK', k, gname, *ack)
            if not keep: break   # '>' has run past the end
        # reassign every pending entry to its original consumer
        for isid, (cons, idle, dc) in targets.items():
            c = fsid(isid)
            if dc > 1:
                # first non-JUSTID claim assigns consumer and raises dc to 2,
                # further single claims add +1 each
                for _ in range(dc - 1):
                    DST.cmd('XCLAIM', k, gname, cons, '0', c)
            else:
                DST.cmd('XCLAIM', k, gname, cons, '0', c, 'JUSTID')
        # remove the temp consumer (only safe once its PEL is empty)
        DST.cmd('XREADGROUP', 'GROUP', gname, tmp, 'STREAMS', k, '0-0')
        # exact cursor
        if er is None:
            DST.cmd('XGROUP', 'SETID', k, gname, fsid(ld))
        else:
            DST.cmd('XGROUP', 'SETID', k, gname, fsid(ld), 'ENTRIESREAD', er)
        # exact per-entry idle ages and consumer idle times
        if targets:
            per_cons = {}
            for isid, (cons, idle, dc) in targets.items():
                DST.cmd('XCLAIM', k, gname, cons, '0', fsid(isid), 'IDLE', idle, 'JUSTID')
                per_cons.setdefault(cons, idle)
            ts = now_ms()
            for cname, idle in per_cons.items():
                if ts - idle < 10000:   # consumer idle is younger than the copy; skip
                    continue
                # pick one of its entries to carry the idle time
                e = min(i for i, (c, _, _) in targets.items() if c == cname)
                DST.cmd('XCLAIM', k, gname, cname, '0', fsid(e), 'IDLE', idle, 'JUSTID')
'''
src = src[:start] + new + src[end:]
open('/tmp/migrate.py','w').write(src)
print('rewritten group logic')
EOF
python3 -m py_compile /tmp/migrate.py && valkey-cli -p 6390 flushall >/dev/null && python3 /tmp/migrate.py 6390 2>&1 | tail -5

67  $ python3 /tmp/migrate.py 6390 2>&1 | head -12

68  $ python3 - <<'EOF'
src = open('/tmp/migrate.py').read()
old = """        for cname in src_cons:
            DST.cmd('XGROUP', 'CREATECONSUMER', k, gname, cname)
        tmp = '_migtmp_'
        # group starts at 0-0 with ENTRIESREAD 0 so '>' delivers every entry
        DST.cmd('XGROUP', 'CREATE', k, gname, '0-0', 'ENTRIESREAD', 0, 'MKSTREAM')
"""
new = """        tmp = '_migtmp_'
        # group starts at 0-0 with ENTRIESREAD 0 so '>' delivers every entry
        DST.cmd('XGROUP', 'CREATE', k, gname, '0-0', 'ENTRIESREAD', 0, 'MKSTREAM')
        for cname in src_cons:
            DST.cmd('XGROUP', 'CREATECONSUMER', k, gname, cname)
"""
assert old in src
src = src.replace(old, new)
open('/tmp/migrate.py','w').write(src)
print('patched')
EOF
python3 -m py_compile /tmp/migrate.py && valkey-cli -p 6390 flushall >/dev/null && python3 /tmp/migrate.py 6390 2>&1 | tail -5

69  $ python3 /tmp/verify.py 6390 2>&1 | tail -25

70  $ cat > /tmp/verify.py <<'PYEOF'
import socket, sys, time

class R:
    def __init__(self, host, port):
        self.s = socket.create_connection((host, port))
        self.buf = b''
    def enc(self, args):
        args = [b'%d' % a if isinstance(a, int) else (a.encode() if isinstance(a, str) else a) for a in args]
        return b'*%d\r\n' % len(args) + b''.join(b'$%d\r\n%s\r\n' % (len(a), a) for a in args)
    def cmd(self, *args):
        return self.pipe([args])[0]
    def pipe(self, many):
        self.s.sendall(b''.join(self.enc(a) for a in many))
        return [self._read() for _ in many]
    def _read(self):
        while b'\r\n' not in self.buf:
            self.buf += self.s.recv(65536)
        line, self.buf = self.buf.split(b'\r\n', 1)
        t, p = line[:1], line[1:]
        if t == b'+': return p
        if t == b'-': raise RuntimeError(p.decode())
        if t == b':': return int(p)
        if t == b'$':
            n = int(p)
            if n == -1: return None
            while len(self.buf) < n + 2: self.buf += self.s.recv(65536)
            d, self.buf = self.buf[:n], self.buf[n+2:]
            return d
        if t == b'*':
            n = int(p)
            if n == -1: return None
            return [self._read() for _ in range(n)]
        raise RuntimeError(line)

def pairs(flat): return list(zip(flat[0::2], flat[1::2]))
def sid(b):
    t, q = b.decode().split('-'); return (int(t), int(q))
def fsid(s): return '%d-%d' % s

SRC = R('127.0.0.1', 6379)
DST = R('127.0.0.1', int(sys.argv[1]) if len(sys.argv) > 1 else 6380)
errors = []
t_start = time.time()

def err(msg): errors.append(msg); print('FAIL:', msg)

def keyset(r, db):
    r.cmd('SELECT', db)
    cur, ks = b'0', []
    while True:
        cur, batch = r.cmd('SCAN', cur, 'COUNT', 1000)
        ks += batch
        if cur == b'0': break
    return set(ks)

def check_key(db, k):
    SRC.cmd('SELECT', db)  # keep on same db (SELECT is cheap; both conns pinned)
    DST.cmd('SELECT', db)
    t = SRC.cmd('TYPE', k).decode()
    pt_s, pt_d = SRC.cmd('PTTL', k), DST.cmd('PTTL', k)
    t2 = DST.cmd('TYPE', k).decode()
    if t == 'none':
        if pt_s == -2: return  # expired on source after copy: legitimate
        err(f'db{db} {k!r} MISSING on src??')
        return
    if t2 == 'none':
        # dst lost it: legitimate only if its TTL was too short to survive
        if pt_d == -2 and pt_s < 100: return  # boundary expiry (sub-100ms)
        err(f'db{db} {k!r} type {t} MISSING on dst (src pttl={pt_s})')
        return
    if t != t2: err(f'db{db} {k!r} type {t} != {t2}'); return
    if (pt_s < 0) != (pt_d < 0):
        err(f'db{db} {k!r} ttl-persist mismatch {pt_s} vs {pt_d}')
    elif pt_s >= 0 and not (-100 <= (pt_d - pt_s) <= 100):
        err(f'db{db} {k!r} ttl drift {pt_s} vs {pt_d}')
    if t == 'string':
        if SRC.cmd('GET', k) != DST.cmd('GET', k): err(f'db{db} {k!r} value mismatch')
    elif t == 'list':
        a, b = SRC.cmd('LRANGE', k, '0', '-1'), DST.cmd('LRANGE', k, '0', '-1')
        if a != b: err(f'db{db} {k!r} list mismatch ({len(a)} vs {len(b)})')
    elif t == 'set':
        a, b = SRC.cmd('SMEMBERS', k), DST.cmd('SMEMBERS', k)
        if sorted(a) != sorted(b): err(f'db{db} {k!r} set mismatch')
    elif t == 'zset':
        a, b = SRC.cmd('ZRANGE', k, '0', '-1', 'WITHSCORES'), DST.cmd('ZRANGE', k, '0', '-1', 'WITHSCORES')
        if a != b: err(f'db{db} {k!r} zset mismatch ({len(a)} vs {len(b)})')
    elif t == 'hash':
        ha, hb = pairs(SRC.cmd('HGETALL', k)), pairs(DST.cmd('HGETALL', k))
        fa, va = [x[0] for x in ha], [x[1] for x in ha]
        fb, vb = [x[0] for x in hb], [x[1] for x in hb]
        if sorted(fa) != sorted(fb): err(f'db{db} {k!r} hash fields mismatch')
        else:
            da, db_ = dict(zip(fa, va)), dict(zip(fb, vb))
            for f in fa:
                if da[f] != db_.get(f, b'<missing>'): err(f'db{db} {k!r} field {f!r} value mismatch')
        ta = SRC.cmd('HTTL', k, 'FIELDS', len(fa), *fa) if fa else []
        tb = DST.cmd('HTTL', k, 'FIELDS', len(fa), *fa) if fa else []
        for f, x, y in zip(fa, ta, tb):
            if (x < 0) != (y < 0): err(f'db{db} {k!r} field {f!r} fttl-persist {x} vs {y}')
            elif x >= 0 and not (-100 <= (y - x) <= 100): err(f'db{db} {k!r} field {f!r} fttl drift {x} vs {y}')
    elif t == 'stream':
        ia, ib = dict(pairs(SRC.cmd('XINFO', 'STREAM', k))), dict(pairs(DST.cmd('XINFO', 'STREAM', k)))
        for fld in (b'last-generated-id', b'max-deleted-entry-id', b'entries-added', b'recorded-first-entry-id'):
            if ia[fld] != ib[fld]:
                err(f'db{db} {k!r} stream {fld.decode()} {ia[fld]!r} vs {ib[fld]!r}')
        ea, eb = SRC.cmd('XRANGE', k, '-', '+'), DST.cmd('XRANGE', k, '-', '+')
        if ea != eb: err(f'db{db} {k!r} stream entries mismatch ({len(ea)} vs {len(eb)})')
        ga = [dict(pairs(g)) for g in SRC.cmd('XINFO', 'GROUPS', k)]
        gb = [dict(pairs(g)) for g in DST.cmd('XINFO', 'GROUPS', k)]
        ma = {g[b'name']: g for g in ga}; mb = {g[b'name']: g for g in gb}
        if set(ma) != set(mb): err(f'db{db} {k!r} group names {set(ma)} vs {set(mb)}')
        for name, g in ma.items():
            h = mb.get(name)
            if not h: continue
            for fld in (b'last-delivered-id', b'entries-read', b'lag', b'pending'):
                if g.get(fld) != h.get(fld):
                    err(f'db{db} {k!r} group {name!r} {fld.decode()} {g.get(fld)!r} vs {h.get(fld)!r}')
            ca = [dict(pairs(c)) for c in SRC.cmd('XINFO', 'CONSUMERS', k, name.decode())]
            cb = [dict(pairs(c)) for c in DST.cmd('XINFO', 'CONSUMERS', k, name.decode())]
            na = {c[b'name']: c for c in ca}; nb = {c[b'name']: c for c in cb}
            if set(na) != set(nb): err(f'db{db} {k!r} group {name!r} consumers {set(na)} vs {set(nb)}')
            for cn, c in na.items():
                d = nb.get(cn)
                if not d: continue
                if c[b'pending'] != d[b'pending']:
                    err(f'db{db} {k!r} group {name!r} consumer {cn!r} pending {c[b"pending"]} vs {d[b"pending"]}')
                for fld in (b'idle', b'inactive'):
                    x, y = c.get(fld), d.get(fld)
                    if not (x is None and y is None or (x is not None and y is not None and abs(y - x) <= 2500)):
                        err(f'db{db} {k!r} group {name!r} consumer {cn!r} {fld.decode()} {x} vs {y}')
            def pel(r):
                out, start = [], '-'
                while True:
                    rows = r.cmd('XPENDING', k, name.decode(), start, '+', 1000)
                    if not rows: break
                    out += rows
                    if len(rows) < 1000: break
                    start = b'(' + rows[-1][0]
                return out
            pa, pb = pel(SRC), pel(DST)
            dma = {sid(p[0]): (p[1], p[2], p[3]) for p in pa}
            dmb = {sid(p[0]): (p[1], p[2], p[3]) for p in pb}
            if set(dma) != set(dmb):
                miss = sorted(set(dma) - set(dmb)); extra = sorted(set(dmb) - set(dma))
                if miss: err(f'db{db} {k!r} group {name!r} pel missing ids: {[fsid(x) for x in miss[:3]]}')
                if extra: err(f'db{db} {k!r} group {name!r} pel extra ids: {[fsid(x) for x in extra[:3]]}')
            for i in set(dma) & set(dmb):
                a_, b_ = dma[i], dmb[i]
                if a_[0] != b_[0]: err(f'db{db} {k!r} group {name!r} pel {fsid(i)} consumer {a_[0]} vs {b_[0]}')
                if a_[2] != b_[2]: err(f'db{db} {k!r} group {name!r} pel {fsid(i)} delivery-count {a_[2]} vs {b_[2]}')
                if not (-100 <= (b_[1] - a_[1]) <= 100): err(f'db{db} {k!r} group {name!r} pel {fsid(i)} idle {a_[1]} vs {b_[1]}')

total_s = total_d = 0
for db in (0, 2):
    ks = keyset(SRC, db)
    dset = keyset(DST, db)
    SRC.cmd('SELECT', db); DST.cmd('SELECT', db)
    miss, extra = ks - dset, dset - ks
    # re-check missing/extra for legitimate expiry (sub-second TTL keys)
    if miss:
        res = SRC.pipe([('PTTL', k) for k in sorted(miss)])
        legit = {k for k, p in zip(sorted(miss), res) if p == -2 or (p >= 0 and p < 200)}
        miss -= legit
    if extra:
        res = SRC.pipe([('PTTL', k) for k in sorted(extra)])
        legit = {k for k, p in zip(sorted(extra), res) if p == -2 or (p >= 0 and p < 200)}
        extra -= legit
    if miss: err(f'db{db}: {len(miss)} keys missing on dst: {sorted(miss)[:5]}')
    if extra: err(f'db{db}: {len(extra)} extra keys on dst: {sorted(extra)[:5]}')
    print(f'db{db}: src={len(ks)} dst={len(dset)}', flush=True)
    total_s += len(ks); total_d += len(dset)
    for i, k in enumerate(sorted(ks)):
        check_key(db, k)
        if (i+1) % 1000 == 0: print(f'  verified {i+1}', flush=True)
print(f'TOTALS: src={total_s} dst={total_d}  verify-took={time.time()-t_start:.1f}s')
print('RESULT:', 'ALL OK' if not errors else f'{len(errors)} FAILURES')
PYEOF
python3 -m py_compile /tmp/verify.py && echo COMPILES
valkey-cli -p 6390 flushall >/dev/null
python3 /tmp/migrate.py 6390 >/dev/null 2>&1 && python3 /tmp/verify.py 6390 2>&1 | tail -12

{
 "examples": {
  "missing": [
   "db0:session:01487",
   "db0:session:00689",
   "db0:session:01719"
  ]
 },
 "keys_new": {},
 "keys_old": {
  "0": 2960,
  "2": 350
 },
 "mismatch_counts": {
  "extra": 0,
  "field_ttl_added": 0,
  "field_ttl_drift": 0,
  "field_ttl_lost": 0,
  "missing": 3310,
  "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": "8.10.2",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

1  $ ps aux | grep -Ei 'redis|valkey' | grep -v grep; echo ---; ls /opt/redis-8.10/bin; echo ---; ls /etc/valkey; echo ---; which redis-cli valkey-cli redis-server valkey-server

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

3  $ redis-cli -p 6379 INFO server | head -30; echo =====; redis-cli -p 6379 INFO keyspace; echo =====; redis-cli -p 6379 INFO modules; echo =====; redis-cli -p 6379 DBSIZE; echo =====; redis-cli -p 6379 MODULE LIST; echo =====; redis-cli -p 6379 ACL LIST; echo =====; redis-cli -p 6379 CONFIG GET requirepass; redis-cli -p 6379 CONFIG GET masterauth

4  $ valkey-cli -p 6380 INFO server | head -20; echo =====; valkey-cli -p 6380 INFO keyspace; echo =====; valkey-cli -p 6380 DBSIZE; echo =====; valkey-cli -p 6380 CONFIG GET replica-read-only; valkey-cli -p 6380 CONFIG GET dir; valkey-cli -p 6380 CONFIG GET maxmemory; echo =====; ls -la /var/lib/valkey /var/lib/redis-old

5  $ for db in 0 1 2 3; do echo "== db$db"; redis-cli -p 6379 -n $db --scan | head -5000 | while read k; do t=$(redis-cli -p 6379 -n $db TYPE "$k"); echo "$t"; done | sort | uniq -c; done

6  $ echo "== valkey modules"; valkey-cli -p 6380 MODULE LIST; echo "== valkey vector commands"; valkey-cli -p 6380 COMMAND INFO VADD VSIM HEXPIRE HPEXPIRE HTTL 2>/dev/null; echo "== valkey config defaults"; valkey-cli -p 6380 CONFIG GET replica-read-only; valkey-cli -p 6380 CONFIG GET maxmemory-policy; valkey-cli -p 6380 CONFIG GET save; valkey-cli -p 6380 CONFIG GET appendonly; valkey-cli -p 6380 CONFIG GET aof-use-rdb-preamble; echo "== version"; valkey-cli -p 6380 INFO server | grep valkey_version; valkey-server --version; redis-server --version

7  $ echo "== HTTL command on source"; redis-cli -p 6379 COMMAND INFO HTTL HEXPIRE 2>/dev/null | head -5; echo "== find keys with field ttl"; redis-cli -p 6379 --scan | head -3000 | while read k; do n=$(redis-cli -p 6379 TTL "$k"); if [ "$n" != "-1" ] && [ "$n" != "-2" ]; then :; fi; done; echo; echo "== sample keys"; for k in $(redis-cli -p 6379 -n 0 --scan | head -5); do echo "--- $k"; redis-cli -p 6379 -n 0 TYPE "$k"; redis-cli -p 6379 -n 0 PTTL "$k"; done; echo "== find a hash with subexpiry: check OBJECT ENCODING / httl on hashes"; for k in $(redis-cli -p 6379 -n 0 --scan --type hash | head -5); do echo "--- $k"; redis-cli -p 6379 -n 0 HLEN "$k"; redis-cli -p 6379 -n 0 HGETALL "$k" | head; fields=$(redis-cli -p 6379 -n 0 HKEYS "$k" | head -3 | tr '\n' ' '); echo "httl:"; redis-cli -p 6379 -n 0 HTTL "$k" FIELDS 3 $fields 2>&1; done

8  $ echo "== streams and groups"; for k in $(redis-cli -p 6379 -n 0 --scan --type stream); do echo "--- $k"; redis-cli -p 6379 -n 0 XINFO STREAM "$k" FULL | head -40; break; done; echo; echo "== count groups across streams"; for k in $(redis-cli -p 6379 -n 0 --scan --type stream); do g=$(redis-cli -p 6379 -n 0 XINFO GROUPS "$k" | grep -c '^name'); echo "$k groups=$g"; done | head -25; echo "== db0 keys with TTL sample"; redis-cli -p 6379 -n 0 --scan | head -1000 | while read k; do p=$(redis-cli -p 6379 -n 0 PTTL "$k"); if [ "$p" != "-1" ] && [ "$p" != "-2" ]; then echo "$k $p"; fi; done | head -5; echo "== raw data sanity"; redis-cli -p 6379 -n 0 --scan --type string | head -3 | while read k; do redis-cli -p 6379 -n 0 GET "$k" | head -c 200; echo; done

9  $ redis-cli --version; valkey-cli --version; echo "== streams in db0/2 =="; for db in 0 2; do redis-cli -p 6379 -n $db --scan | while read k; do t=$(redis-cli -p 6379 -n $db TYPE "$k"); if [ "$t" = stream ]; then echo "db$db $k"; fi; done; done

10  $ echo "== hashes with field expiry (db0, db2) =="; for db in 0 2; do redis-cli -p 6379 -n $db --scan | while read k; do t=$(redis-cli -p 6379 -n $db TYPE "$k"); if [ "$t" = hash ]; then sub=$(redis-cli -p 6379 -n $db OBJECT FREQ "$k" >/dev/null 2>&1; redis-cli -p 6379 -n $db HLEN "$k"); echo "$k"; fi; done; done | head -5

11  $ ls -la /usr/local/bin/redis-cli /usr/local/bin/valkey-cli /usr/local/bin/redis-server /usr/local/bin/valkey-server; echo; /opt/redis-8.10/bin/redis-cli --version; echo "== field ttl check =="; k=user:0277; redis-cli -p 6379 -n 0 HKEYS $k | head -5; redis-cli -p 6379 -n 0 HTTL $k FIELDS 5 $(redis-cli -p 6379 -n 0 HKEYS $k | head -5 | tr '\n' ' ') 2>&1

12  $ for k in events:00 events:01; do echo "=== $k"; redis-cli -p 6379 -n 0 XINFO STREAM $k FULL | head -30; echo "-- groups:"; redis-cli -p 6379 -n 0 XINFO GROUPS $k; done

13  $ which python3; python3 --version; echo "== find keys with field TTLs =="; python3 - <<'EOF'
import socket

def enc(*args):
    out = f"*{len(args)}\r\n".encode()
    for a in args:
        if isinstance(a, str): a = a.encode()
        out += f"${len(a)}\r\n".encode() + a + b"\r\n"
    return out

def read_reply(f):
    line = f.readline()
    if not line: raise EOFError
    t, rest = line[:1], line[1:-2]
    if t == b'+': return rest
    if t == b'-': raise Exception(rest.decode())
    if t == b':': return int(rest)
    if t == b'$':
        n = int(rest)
        if n == -1: return None
        data = f.read(n+2)[:-2]
        return data
    if t == b'*':
        n = int(rest)
        if n == -1: return None
        return [read_reply(f) for _ in range(n)]
    raise Exception('bad type %r' % line)

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):
        self.s.sendall(enc(*args))
        return read_reply(self.f)

src = C(6379)
keys = src.cmd('SCAN', '0', 'COUNT', 10000)[1]
found = []
for k in keys:
    if src.cmd('TYPE', k) == b'hash':
        fields = src.cmd('HKEYS', k)
        if fields:
            ttls = src.cmd(b'HPTTL', k, b'FIELDS', len(fields), *fields)
            for f_, t in zip(fields, ttls):
                if t != -1:
                    found.append((k, f_, t))
print("fields with TTL:", len(found))
for x in found[:10]: print(x)
EOF

14  $ echo "== DUMP payload / RESTORE behavior test =="
# key with TTL
k=session:01306
src_ttl=$(redis-cli -p 6379 PTTL $k); echo "src PTTL: $src_ttl"
redis-cli -p 6379 --raw DUMP $k > /tmp/t.dump; ls -l /tmp/t.dump
printf 'restore with ttl 0 -> '; redis-cli -p 6380 -x RESTORE t:$k 0 2>&1
printf 'target PTTL: '; redis-cli -p 6380 PTTL t:$k
printf 'target GET same? '; a=$(redis-cli -p 6379 --raw GET $k); b=$(redis-cli -p 6380 --raw GET t:$k); [ "$a" = "$b" ] && echo YES || echo NO
echo "== stream restore test =="
redis-cli -p 6379 --raw DUMP events:00 > /tmp/s.dump; ls -l /tmp/s.dump
printf 'restore stream -> '; redis-cli -p 6380 -x RESTORE t:events:00 0 2>&1
printf 'target DBSIZE: '; redis-cli -p 6380 DBSIZE

15  $ xxd /tmp/t.dump | tail -3; echo; xxd /var/lib/redis-old/dump.rdb | head -2; echo; echo "== redis-cli -x reads how? test with a payload containing newline =="; printf 'AB\r\nCD' > /tmp/plain.dump 2>/dev/null; python3 -c "
d=open('/tmp/t.dump','rb').read()
print('len',len(d),'trailing version bytes:',d[-2:], int.from_bytes(d[-2:],'little'))
"

16  $ python3 - <<'EOF'
import socket

def enc(args):
    out = f"*{len(args)}\r\n".encode()
    for a in args:
        if isinstance(a, int): a = str(a).encode()
        if isinstance(a, str): a = a.encode()
        out += f"${len(a)}\r\n".encode() + a + b"\r\n"
    return out

def read_reply(f):
    line = f.readline()
    if not line: raise EOFError
    t, rest = line[:1], line[1:-2]
    if t == b'+': return rest
    if t == b'-': raise Exception(rest.decode())
    if t == b':': return int(rest)
    if t == b'$':
        n = int(rest)
        if n == -1: return None
        return f.read(n+2)[:-2]
    if t == b'*':
        n = int(rest)
        if n == -1: return None
        return [read_reply(f) for _ in range(n)]
    raise Exception('bad type %r' % line)

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):
        self.s.sendall(enc(list(args)))
        return read_reply(self.f)

src = C(6379); dst = C(6380)

# scan all keys in all dbs for hash field TTLs
total = 0
examples = []
for db in (0,1,2,3,4,5):
    try:
        src.cmd('SELECT', db)
    except Exception:
        continue
    cursor = b'0'
    while True:
        res = src.cmd('SCAN', cursor, 'COUNT', 5000)
        cursor = res[0]
        for k in res[1]:
            if src.cmd('TYPE', k) == b'hash':
                fields = src.cmd('HKEYS', k)
                if not fields: continue
                ttls = src.cmd('HPTTL', k, 'FIELDS', len(fields), *[x.decode() if isinstance(x,bytes) else x for x in fields])
                for f_, t in zip(fields, ttls):
                    if isinstance(t, int) and t > 0:
                        total += 1
                        if len(examples) < 10: examples.append((db,k,f_,t))
        if cursor == b'0': break
print('db-1-ish field ttls total:', total)
for e in examples: print(e)

# dump payload restore via proper socket
src.cmd('SELECT', 0)
payload = src.cmd('DUMP', 'session:01306')
print('payload len', len(payload), 'version', int.from_bytes(payload[-2:],'little'))
try:
    r = dst.cmd('RESTORE', 't:session:01306', 0, payload)
    print('restore raw payload:', r)
    print('target PTTL:', dst.cmd('PTTL', 't:session:01306'))
except Exception as e:
    print('restore raw payload FAILED:', e)
EOF

17  $ python3 - <<'EOF'
import socket, binascii

def enc(args):
    out = f"*{len(args)}\r\n".encode()
    for a in args:
        if isinstance(a, int): a = str(a).encode()
        if isinstance(a, str): a = a.encode()
        out += f"${len(a)}\r\n".encode() + a + b"\r\n"
    return out

def read_reply(f):
    line = f.readline()
    t, rest = line[:1], line[1:-2]
    if t == b'+': return rest
    if t == b'-': raise Exception(rest.decode())
    if t == b':': return int(rest)
    if t == b'$':
        n = int(rest)
        if n == -1: return None
        return f.read(n+2)[:-2]
    if t == b'*':
        n = int(rest)
        return [read_reply(f) for _ in range(n)]

s = socket.create_connection(('127.0.0.1', 6379)); f = s.makefile('rb')
s.sendall(enc(['DUMP','session:01306'])); p = read_reply(f)
print('len', len(p))
print('last 12 bytes:', binascii.hexlify(p[-12:]))
print('u16 at [-10:-8] (version if crc-last):', int.from_bytes(p[-10:-8],'little'))
print('u16 at [-2:] (version if version-last):', int.from_bytes(p[-2:],'little'))

# crc64-jones (reflected, poly 0xad93d23594c935a9, init 0, xorout 0), like Redis crc64()
poly = 0xad93d23594c935a9
tbl = []
for i in range(256):
    c = i
    for _ in range(8):
        c = (c >> 1) ^ (poly if c & 1 else 0)
    tbl.append(c)
def crc64(data, crc=0):
    crc = ~crc  # wait; redis crc64 uses init 0 with reflected algorithm; implement standard reflected
    crc = 0
    for b in data:
        crc = tbl[(crc ^ b) & 0xff] ^ (crc >> 8)
    return crc

c1 = crc64(p[:-8])
got = int.from_bytes(p[-8:],'little')
print('crc64(p[:-8]) =', hex(c1), ' stored =', hex(got), ' match:', c1 == got)
c2 = crc64(p[:-10])
print('crc64(p[:-10]) =', hex(c2), ' match:', c2 == got)
EOF

18  $ echo "== try redis-cli 8.10 --rdb streaming dump =="; /opt/redis-8.10/bin/redis-cli --rdb /tmp/src.rdb 2>&1 | tail -3; ls -l /tmp/src.rdb 2>/dev/null; echo "== RDB header =="; head -c 10 /tmp/src.rdb | od -c | head -2; echo "== psave status on source =="; redis-cli -p 6379 INFO persistence | grep -E 'rdb_(bgsave|last|loading)|aof_|loading:'

19  $ set -e
mkdir -p /tmp/scratch
valkey-server --port 6399 --bind 127.0.0.1 --daemonize yes --dir /tmp/scratch --dbfilename scratch.rdb --logfile /tmp/scratch/valkey.log --pidfile /tmp/scratch/valkey.pid
sleep 1
valkey-cli -p 6399 ping
echo "== test A: load the RDB into scratch =="
cp /tmp/src.rdb /tmp/scratch/load.rdb
# load via a second instance that starts with the rdb
valkey-server --port 6398 --bind 127.0.0.1 --daemonize yes --dir /tmp/scratch --dbfilename load.rdb --logfile /tmp/scratch/valkey2.log --pidfile /tmp/scratch/valkey2.pid
sleep 1
valkey-cli -p 6398 ping
valkey-cli -p 6398 INFO keyspace
valkey-cli -p 6398 DBSIZE
tail -5 /tmp/scratch/valkey2.log

20  $ echo "== test B: replication redis 8.10 -> valkey 9.1 on scratch 6399 =="
# use a fresh dir for repl test
mkdir -p /tmp/scratch2
valkey-server --port 6397 --bind 127.0.0.1 --daemonize yes --dir /tmp/scratch2 --dbfilename repl.rdb --logfile /tmp/scratch2/valkey.log --pidfile /tmp/scratch2/valkey.pid
sleep 1
valkey-cli -p 6397 REPLICAOF 127.0.0.1 6379
sleep 3
valkey-cli -p 6397 INFO replication
valkey-cli -p 6397 INFO keyspace
valkey-cli -p 6397 DBSIZE
tail -10 /tmp/scratch2/valkey.log

21  $ sleep 4; echo "== 6397 repl status =="; valkey-cli -p 6397 INFO replication | grep -E 'role|link|sync|offset'; valkey-cli -p 6397 INFO keyspace; echo; tail -15 /tmp/scratch2/valkey.log; echo "== 6398 startup log =="; cat /tmp/scratch/valkey2.log 2>/dev/null | tail -20; ps aux | grep valkey | grep -v grep

22  $ python3 - <<'EOF'
import socket, binascii, itertools

def enc(args):
    out = f"*{len(args)}\r\n".encode()
    for a in args:
        if isinstance(a, int): a = str(a).encode()
        if isinstance(a, str): a = a.encode()
        out += f"${len(a)}\r\n".encode() + a + b"\r\n"
    return out

def read_reply(f):
    line = f.readline()
    t, rest = line[:1], line[1:-2]
    if t == b'+': return rest
    if t == b'-': raise Exception(rest.decode())
    if t == b':': return int(rest)
    if t == b'$':
        n = int(rest)
        if n == -1: return None
        return f.read(n+2)[:-2]
    if t == b'*':
        return [read_reply(f) for _ in range(read_reply_num(f, rest))]

def read_reply_num(f, rest): return int(rest)

def conn(port):
    s = socket.create_connection(('127.0.0.1', port)); return s, s.makefile('rb')

# get a valkey-generated dump
s, f = conn(6399)
s.sendall(enc(['SET','foo','bar'])); read_reply(f)
s.sendall(enc(['DUMP','foo'])); vp = read_reply(f)
print('valkey payload:', binascii.hexlify(vp))
print('valkey version u16 at [-10:-8]:', int.from_bytes(vp[-10:-8],'little'))
print('valkey version u16 at [-2:]:', int.from_bytes(vp[-2:],'little'))

def make_tab(poly, reflected=True):
    tab = []
    for i in range(256):
        if reflected:
            c = i
            for _ in range(8):
                c = (c >> 1) ^ (poly if c & 1 else 0)
        else:
            c = i << 56
            for _ in range(8):
                c = ((c << 1) ^ (poly if c & (1 << 63) else 0)) & 0xFFFFFFFFFFFFFFFF
        tab.append(c)
    return tab

def crc(tab, crc, data):
    for b in data:
        crc = tab[(crc ^ b) & 0xff] ^ (crc >> 8)
    return crc

polys = [0xad93d23594c935a9, 0x95ac9329ac4bc9b5, 0x42f0e1eba9ea3693, 0xc96c5795d7870f42]
stored = int.from_bytes(vp[-8:], 'little')
storedb = vp[-8:]
for poly in polys:
    for refl in (True, False):
        tab = make_tab(poly, refl)
        for init in (0, 0xFFFFFFFFFFFFFFFF):
            for span in (8, 10):
                for xo in (0, 0xFFFFFFFFFFFFFFFF):
                    c = crc(tab, init, vp[:-span])
                    c2 = c ^ xo
                    if c2.to_bytes(8,'little') == storedb:
                        print(f'MATCH poly={hex(poly)} refl={refl} init={hex(init)} span={span} xorout={hex(xo)}')
EOF

23  $ echo "== does valkey accept its own dump (baseline) =="; valkey-cli -p 6399 DUMP foo | head -c 50 > /tmp/vp.bin; python3 - <<'EOF'
# quick: use valkey-cli --pipe? just check RESTORE self payload via cli -x (binary through stdin)
EOF
valkey-cli -p 6399 --raw DUMP foo > /tmp/vp.dump
valkey-cli -p 6399 -x RESTORE foo2 0 < /tmp/vp.dump
valkey-cli -p 6399 GET foo2
echo "== redis-cli (8.10) options for restore =="; /opt/redis-8.10/bin/redis-cli --help | head -40

24  $ mkdir -p /tmp/mig && cat > /tmp/mig/resp.py <<'EOF'
import socket

def enc(args):
    out = b"*%d\r\n" % len(args)
    for a in args:
        if isinstance(a, int): a = str(a).encode()
        if isinstance(a, bytes): pass
        else: a = str(a).encode()
        out += b"$%d\r\n" % len(a) + a + b"\r\n"
    return out

def read_reply(f):
    line = f.readline()
    if not line: raise ConnectionError("eof")
    t, rest = line[0], line[1:-2]
    if t == ord('+'): return rest
    if t == ord('-'): raise Exception(rest.decode())
    if t == ord(':'): return int(rest)
    if t == ord('$'):
        n = int(rest)
        if n == -1: return None
        d = f.read(n + 2)
        assert d[-2:] == b"\r\n"
        return d[:-2]
    if t == ord('*'):
        n = int(rest)
        if n == -1: return None
        return [read_reply(f) for _ in range(n)]
    raise Exception("bad reply %r" % line)

class C:
    def __init__(self, port, host='127.0.0.1'):
        self.s = socket.create_connection((host, port))
        self.f = self.s.makefile('rb')
    def cmd(self, *args):
        self.s.sendall(enc(args))
        return read_reply(self.f)
    def close(self):
        try: self.s.close()
        except Exception: pass

# valkey crc64: poly 0x95ac9329ac4bc9b5, reflected, init 0, xorout 0
_POLY = 0x95ac9329ac4bc9b5
_TAB = []
for _i in range(256):
    _c = _i
    for _ in range(8):
        _c = (_c >> 1) ^ (_POLY if _c & 1 else 0)
    _TAB.append(_c)

def vcrc(data):
    crc = 0
    for b in data:
        crc = _TAB[(crc ^ b) & 0xff] ^ (crc >> 8)
    return crc

def patch(payload, version=None):
    """Take a Redis 8 DUMP payload, produce Valkey-acceptable payload.
    Layout: [data][u16 le version][u64 le crc]; crc covers data+version (redis) but
    valkey recomputes its own crc over data+version. Optionally set version."""
    body = payload[:-10]
    ver = int.from_bytes(payload[-10:-8], 'little')
    if version is not None: ver = version
    new = body + ver.to_bytes(2, 'little')
    crc = vcrc(new)
    return new + crc.to_bytes(8, 'little')
EOF
echo written

25  $ echo "== valkey scratch rdb header/version =="; valkey-cli -p 6399 DEBUG RELOAD 2>&1 | head -2; valkey-cli -p 6399 BGSAVE; sleep 1; od -c /tmp/scratch/scratch.rdb | head -2; echo "== valkey rdb version const? check DUMP we parsed: version=80 =="; echo "== try restore patched redis payload into 6399 =="
python3 - <<'EOF'
import sys; sys.path.insert(0, '/tmp/mig')
from resp import C, patch

src = C(6379); dst = C(6399)

tests = []
# string with ttl
tests.append(('str_ttl', 'session:01306', 0))
# hash with field ttl
tests.append(('hash_fttl', 'profile:12', 0))
# plain hash
tests.append(('hash', 'user:0277', 0))
# stream with groups
tests.append(('stream', 'events:00', 0))
# list, set, zset
for t in ('list', 'set', 'zset'):
    k = src.cmd('SCAN', '0', 'MATCH', '*', 'COUNT', 10000)[1]
    break
keys_by_type = {}
cursor = b'0'
while True:
    res = src.cmd('SCAN', cursor, 'COUNT', 10000)
    cursor = res[0]
    for k in res[1]:
        t = src.cmd('TYPE', k)
        keys_by_type.setdefault(t, []).append(k)
    if cursor == b'0': break
for t in ('list','set','zset','string'):
    tests.append((t, keys_by_type[t][0], 0))

for name, key, db in tests:
    payload = src.cmd('DUMP', key)
    pttl = src.cmd('PTTL', key)
    if pttl is None or pttl < 0: pttl = 0
    p = patch(payload, version=80)
    try:
        dst.cmd('RESTORE', 'm:' + key.decode(), pttl, p)
        print(f'{name}: OK key={key} pttl={pttl} type={src.cmd("TYPE", key)}')
    except Exception as e:
        print(f'{name}: FAIL {e}')
EOF

26  $ python3 - <<'EOF'
import sys; sys.path.insert(0, '/tmp/mig')
from resp import C, patch

src = C(6379); dst = C(6399)

keys_by_type = {}
for db in (0, 2):
    src.cmd('SELECT', db)
    dst.cmd('SELECT', db)
    cursor = b'0'
    while True:
        res = src.cmd('SCAN', cursor, 'COUNT', 10000)
        cursor = res[0]
        for k in res[1]:
            t = src.cmd('TYPE', k).decode()
            keys_by_type.setdefault(t, []).append((db, k))
        if cursor == b'0': break
src.cmd('SELECT', 0); dst.cmd('SELECT', 0)

tests = [
    ('string_ttl', (0, b'session:01306')),
    ('hash_fieldttl', (0, b'profile:12')),
    ('stream', (0, b'events:00')),
    ('hash', keys_by_type['hash'][0]),
    ('list', keys_by_type['list'][0]),
    ('set', keys_by_type['set'][0]),
    ('zset', keys_by_type['zset'][0]),
    ('string_plain', keys_by_type['string'][0]),
]

for name, (db, key) in tests:
    src.cmd('SELECT', db); dst.cmd('SELECT', db)
    payload = src.cmd('DUMP', key)
    pttl = src.cmd('PTTL', key)
    if not isinstance(pttl, int) or pttl < 0: pttl = 0
    p = patch(payload, version=80)
    try:
        dst.cmd('RESTORE', 'm:' + key.decode(), pttl, p)
        print(f'{name}: OK key={key} pttl={pttl}')
    except Exception as e:
        print(f'{name}: FAIL {e}')

# verify details
print('--- verify on target')
src.cmd('SELECT', 0); dst.cmd('SELECT', 0)
print('string PTTL src/dst:', src.cmd('PTTL','session:01306'), dst.cmd('PTTL','m:session:01306'))
print('hash field ttl src:', src.cmd('HPTTL','profile:12','FIELDS',2,'reset_token','otp'))
print('hash field ttl dst:', dst.cmd('HPTTL','m:profile:12','FIELDS',2,'reset_token','otp'))
print('groups src:', [g for g in src.cmd('XINFO','GROUPS','events:00') if isinstance(g, bytes) or True][:0] or src.cmd('XINFO','GROUPS','events:00'))
print('groups dst:', dst.cmd('XINFO','GROUPS','m:events:00'))
print('stream len src/dst:', src.cmd('XLEN','events:00'), dst.cmd('XLEN','m:events:00'))
print('pending src:', src.cmd('XPENDING','events:00','workers'))
print('pending dst:', dst.cmd('XPENDING','m:events:00','workers'))
print('encoding src/dst list:', src.cmd('OBJECT','ENCODING',keys_by_type['list'][0][1]), dst.cmd('OBJECT','ENCODING',b'm:'+keys_by_type['list'][0][1]))
EOF

27  $ echo "== test second stream group consumers / acks fidelity & big-ish payload =="
python3 - <<'EOF'
import sys; sys.path.insert(0, '/tmp/mig')
from resp import C, patch
src = C(6379); dst = C(6399)
g = src.cmd('XINFO','GROUPS','events:01')
print('src groups events:01:', g)
gd = dst.cmd('XINFO','GROUPS','m:events:01')
print('dst groups events:01:', gd)
print('src consumers:', src.cmd('XINFO','CONSUMERS','events:00','workers'))
print('dst consumers:', dst.cmd('XINFO','CONSUMERS','m:events:00','workers'))
# check all dump payloads are patchable: dump every key, patch, RESTORE into scratch under prefixed name
import time
t0=time.time()
count=0; errs=0
for db in (0,1,2,3):
    src.cmd('SELECT', db); dst.cmd('SELECT', db)
    cursor=b'0'
    while True:
        res = src.cmd('SCAN', cursor, 'COUNT', 5000); cursor=res[0]
        for k in res[1]:
            pl = src.cmd('DUMP', k)
            pttl = src.cmd('PTTL', k)
            if not isinstance(pttl,int) or pttl<0: pttl=0
            try:
                dst.cmd('RESTORE', b'v:'+k, pttl, patch(pl, version=80))
                count+=1
            except Exception as e:
                errs+=1
                if errs<5: print('ERR', k, e)
        if cursor==b'0': break
print(f'restored {count} keys, {errs} errors, {time.time()-t0:.1f}s')
src.cmd('SELECT',0); dst.cmd('SELECT',0)
print('src db0 dbsize:', src.cmd('DBSIZE'), 'dst dbsize:', dst.cmd('DBSIZE'))
EOF

28  $ python3 - <<'EOF'
import sys; sys.path.insert(0, '/tmp/mig')
from resp import C, patch
src = C(6379); dst = C(6399)

for k in [b'session:01306', b'profile:12', b'user:0277', b'events:00', b'queue:071', b'tags:006', b'leaderboard:056']:
    pl = src.cmd('DUMP', k)
    print(k, 'type byte:', pl[0], 'len', len(pl))

# create equivalents on valkey scratch and dump them
dst.cmd('FLUSHALL')
dst.cmd('HSET','h1','a','1','b','2')
dst.cmd('HPEXPIRE','h1','FIELDS','1','a','123456')
dst.cmd('XADD','s1','*','f','v')
dst.cmd('XGROUP','CREATE','s1','g1','0')
print('valkey hash plain type:', dst.cmd('DUMP','h1')[0])
print('valkey hash fieldttl type:', dst.cmd('DUMP','h1')[0], ' (same key)')
print('valkey stream type:', dst.cmd('DUMP','s1')[0])
# hmm h1 now has field ttl; make plain hash separately
dst.cmd('HSET','h0','a','1')
print('valkey hash plain type:', dst.cmd('DUMP','h0')[0])
# hexists check ttl in dump: restore h1 elsewhere with ttl=0 to scratch2? check HPTTL after restore
p = dst.cmd('DUMP','h1')
dst.cmd('RESTORE','h2',0,p)
print('h2 httl (should be ~123456):', dst.cmd('HPTTL','h2','FIELDS','1','a'))
EOF

29  $ python3 - <<'EOF'
import sys; sys.path.insert(0, '/tmp/mig')
from resp import C, patch
src = C(6379); dst = C(6399)
# try patching type byte: what if valkey stream type code differs? test a few codes
pl = src.cmd('DUMP', b'events:00')
print('redis stream type:', pl[0])
for code in range(0, 40):
    q = bytes([code]) + pl[1:-10]
    q = q + (80).to_bytes(2,'little')
    import resp
    q = q + resp.vcrc(q).to_bytes(8,'little')
    try:
        dst.cmd('RESTORE', b'probe%d' % code, 0, q)
        print('accepted with type code', code)
        # cleanup and info
        t = dst.cmd('TYPE', b'probe%d' % code)
        print('  type:', t)
        dst.cmd('DEL', b'probe%d' % code)
    except Exception as e:
        pass
EOF

30  $ python3 - <<'EOF'
import sys; sys.path.insert(0, '/tmp/mig')
from resp import C
src = C(6379); dst = C(6399)
src.cmd('SELECT',0); dst.cmd('SELECT',0)
for k in [b'session:01306', b'profile:12', b'user:0277', b'events:00', b'queue:071', b'tags:006', b'leaderboard:056', b'session:01058']:
    mk = b'm:' + k
    try:
        print(k, 'src type:', src.cmd('TYPE',k), ' dst(m:) type:', dst.cmd('TYPE',mk),
              'src enc:', src.cmd('OBJECT','ENCODING',k), 'dst enc:', dst.cmd('OBJECT','ENCODING',mk))
    except Exception as e:
        print(k, 'ERR', e)
# values equal?
import itertools
def dumpall(c, db):
    c.cmd('SELECT', db); out={}
    cur=b'0'
    while True:
        r=c.cmd('SCAN',cur,'COUNT',5000); cur=r[0]
        for k in r[1]: out[k]=c.cmd('TYPE',k)
        if cur==b'0': break
    return out
s = dumpall(src,0)
d = dumpall(dst,0)
print('src keys:', len(s), 'dst keys:', len(d))
mismatch=0
for k,t in s.items():
    dk = b'm:'+k
    if dk in d and d[dk]!=t:
        mismatch+=1
        if mismatch<10: print('TYPE MISMATCH', k, t, d[dk])
print('type mismatches:', mismatch)
EOF

31  $ echo "== what valkey type codes exist? probe valkey DUMP payloads for all types =="
python3 - <<'EOF'
import sys; sys.path.insert(0, '/tmp/mig')
from resp import C, patch
import struct
dst = C(6399)
dst.cmd('FLUSHALL')
# produce valkey payloads for various types and record their type codes
tests = {
 'string': ('SET','k1','v1'),
 'list': ('RPUSH','k2','a','b'),
 'set': ('SADD','k3','a','b'),
 'zset': ('ZADD','k4','1','a','2','b'),
 'hash': ('HSET','k5','a','1'),
 'hash_fttl': ('HSET','k6','a','1'),
 'stream': ('XADD','k7','*','f','v'),
}
for name, cmd in tests.items():
    dst.cmd(*cmd)
dst.cmd('HPEXPIRE','k6','123456','FIELDS','1','a')
dst.cmd('XGROUP','CREATE','k7','g','0')
for name in tests:
    try:
        p = dst.cmd('DUMP', name if False else {'string':'k1','list':'k2','set':'k3','zset':'k4','hash':'k5','hash_fttl':'k6','stream':'k7'}[name])
        print(f'{name}: type code {p[0]}, payload len {len(p)}')
    except Exception as e:
        print(name, 'ERR', e)
EOF
echo "== valkey source hints: strings in binary =="
strings $(which valkey-server) | grep -iE 'RDB_TYPE|rdb type' | head
strings $(which valkey-server) | grep -E '^[A-Z_]+TYPE' | head

32  $ python3 - <<'EOF'
import sys; sys.path.insert(0, '/tmp/mig')
from resp import C, patch
import resp

src = C(6379); dst = C(6399)
dst.cmd('FLUSHALL')

def restore_with_type(key, tcode, name):
    pl = src.cmd('DUMP', key)
    body = pl[:-10]
    ver = 80
    new = bytes([tcode]) + body[1:] + ver.to_bytes(2,'little')
    new = new + resp.vcrc(new).to_bytes(8,'little')
    dst.cmd('RESTORE', name, 0, new)

# hash with field ttl: 25 -> 22
try:
    restore_with_type(b'profile:12', 22, 'h_fttl')
    print('hash_fttl code22: accepted')
    print('  fields:', dst.cmd('HGETALL','h_fttl'))
    print('  field ttls:', dst.cmd('HPTTL','h_fttl','FIELDS',2,'reset_token','otp'))
    print('  src field ttls:', src.cmd('HPTTL','profile:12','FIELDS',2,'reset_token','otp'))
    print('  other fields ttl (should -1):', dst.cmd('HPTTL','h_fttl','FIELDS',3,'name','email','plan'))
except Exception as e:
    print('hash_fttl code22 FAILED:', e)

# stream 27 -> 21
try:
    restore_with_type(b'events:00', 21, 's1')
    print('stream code21: accepted')
    print('  XLEN:', dst.cmd('XLEN','s1'), 'src', src.cmd('XLEN','events:00'))
    print('  groups:', dst.cmd('XINFO','GROUPS','s1'))
except Exception as e:
    print('stream code21 FAILED:', e)
EOF

33  $ python3 - <<'EOF'
import sys; sys.path.insert(0, '/tmp/mig')
from resp import C
import resp
src = C(6379); dst = C(6399)
dst.cmd('FLUSHALL')

def retype(payload, tcode, ver=80):
    body = bytes([tcode]) + payload[1:-10]
    new = body + ver.to_bytes(2,'little')
    return new + resp.vcrc(new).to_bytes(8,'little')

# probe all codes for hash with field ttl
pl = src.cmd('DUMP', b'profile:12')
acc = []
for code in range(0, 64):
    try:
        dst.cmd('RESTORE', b'p%d' % code, 0, retype(pl, code))
        acc.append(code)
        dst.cmd('DEL', b'p%d' % code)
    except Exception:
        pass
print('hash_fttl accepted codes:', acc)

# probe for stream
pl = src.cmd('DUMP', b'events:00')
acc = []
for code in range(0, 64):
    try:
        dst.cmd('RESTORE', b'q%d' % code, 0, retype(pl, code))
        acc.append(code)
        t = dst.cmd('TYPE', b'q%d' % code)
        ln = dst.cmd('XLEN', b'q%d' % code) if t == b'stream' else None
        dst.cmd('DEL', b'q%d' % code)
    except Exception:
        pass
print('stream accepted codes:', acc)
EOF

34  $ python3 - <<'EOF'
import sys; sys.path.insert(0, '/tmp/mig')
from resp import C
from collections import Counter
src = C(6379)
codes = Counter()
enc_by_code = {}
for db in (0,1,2,3,4,5):
    try: src.cmd('SELECT', db)
    except Exception: continue
    cur = b'0'
    while True:
        r = src.cmd('SCAN', cur, 'COUNT', 5000); cur = r[0]
        for k in r[1]:
            pl = src.cmd('DUMP', k)
            codes[pl[0]] += 1
            enc_by_code.setdefault(pl[0], Counter())[src.cmd('OBJECT','ENCODING',k)] += 1
        if cur == b'0': break
print('type code distribution:', dict(codes))
for c, e in enc_by_code.items():
    print(c, dict(e))
EOF

35  $ echo "== does redis 8.10 support DUMP VERSION? =="
redis-cli -p 6379 DUMP session:01306 VERSION 11 2>&1 | head -2
echo "--"
for v in 5 9 10 11 12 13 14; do
  out=$(redis-cli -p 6379 DUMP events:00 VERSION $v 2>&1 | head -c 60)
  echo "stream VERSION $v -> $(echo "$out" | head -c 80)"
done
echo "== help =="; redis-cli -p 6379 HELP DUMP 2>&1 | head; redis-cli -p 6379 COMMAND DOCS dump 2>/dev/null | head -30

36  $ echo "== full stream metadata from source =="
python3 - <<'EOF'
import sys; sys.path.insert(0, '/tmp/mig')
from resp import C
src = C(6379); src.cmd('SELECT', 0)
streams = []
cur = b'0'
while True:
    r = src.cmd('SCAN', cur, 'COUNT', 5000); cur = r[0]
    for k in r[1]:
        if src.cmd('TYPE', k) == b'stream': streams.append(k)
    if cur == b'0': break
for k in sorted(streams)[:4]:
    info = src.cmd('XINFO', 'STREAM', k)
    d = dict(zip(info[0::2], info[1::2]))
    print(k, 'len', d[b'length'], 'last-gen', d[b'last-generated-id'], 'entries-added', d[b'entries-added'],
          'max-del', d[b'max-deleted-entry-id'], 'first-rec', d.get(b'recorded-first-entry-id'))
    print('  groups:', src.cmd('XINFO', 'GROUPS', k))
    for g in src.cmd('XINFO', 'GROUPS', k):
        gd = dict(zip(g[0::2], g[1::2]))
        print('   consumers of', gd[b'name'], ':', src.cmd('XINFO', 'CONSUMERS', k, gd[b'name'].decode()))
        print('   pending detail:', src.cmd('XPENDING', k, gd[b'name'].decode(), b'-', b'+', 100))
EOF

37  $ echo "== target 6380 role & write test =="; valkey-cli -p 6380 INFO replication | grep -E 'role|read_only'; valkey-cli -p 6380 SET writetest 1; valkey-cli -p 6380 DEL writetest
echo "== COMMAND ARGS on target =="
for c in RESTORE XSETID XGROUP XCLAIM HPEXPIREAT HPEXPIRE HEXPIREAT XADD XINFO PEXPIREAT; do echo "--- $c"; valkey-cli -p 6380 COMMAND ARGS $c; done

38  $ echo "== source EVAL/TIME test =="; redis-cli -p 6379 EVAL "local t=redis.call('PTTL',KEYS[1]); local s=redis.call('TIME'); return {s[1], s[2], t}" 1 session:01306
echo "== target RESTORE-ABSTTL quick test (on scratch) =="; python3 - <<'EOF'
import sys; sys.path.insert(0, '/tmp/mig')
from resp import C, patch
src = C(6379); dst = C(6399)
# atomic deadline
dl = src.cmd('EVAL', "local s=redis.call('TIME'); local t=redis.call('PTTL',KEYS[1]); if tonumber(t)<0 then return -1 end; return tonumber(s[1])*1000+math.floor(tonumber(s[2])/1000)+tonumber(t)", 1, 'session:01306')
print('deadline:', dl)
pl = src.cmd('DUMP', 'session:01306')
dst.cmd('RESTORE', 'abstest', dl, patch(pl, version=80), 'ABSTTL', 'REPLACE')
print('src PTTL:', src.cmd('PTTL','session:01306'), 'dst PTTL:', dst.cmd('PTTL','abstest'))
EOF

39  $ echo "== redis config *rdb* / version-ish =="; redis-cli -p 6379 CONFIG GET '*' | paste - - - - | grep -iE 'rdb|version|compat' ; echo "== any tools =="; ls /opt; ls /usr/local/bin; python3 -m pip list 2>/dev/null | head -30; find / -maxdepth 3 -name '*rdb*' -not -path '/proc/*' -not -path '/sys/*' 2>/dev/null | head

40  $ python3 - <<'EOF'
import sys; sys.path.insert(0, '/tmp/mig')
from resp import C
dst = C(6399)
dst.cmd('FLUSHALL')
# build a valkey sample stream with known metadata for format reverse-engineering
dst.cmd('XADD','s','100-0','f','v1')
dst.cmd('XADD','s','200-0','f','v2')
dst.cmd('XADD','s','300-0','f','v3')
dst.cmd('XSETID','s','300-0','ENTRIES-ADDED',3,'MAX-DELETED-ID','0-0','FIRST-ID','100-0')
dst.cmd('XGROUP','CREATE','s','g1','100-0','ENTRIESREAD',0)
# deliver 2 entries to consumer c1
r = dst.cmd('XREADGROUP','GROUP','g1','c1','COUNT','2','STREAMS','s','>')
print('read:', r)
# claim with TIME to a far past delivery time
r = dst.cmd('XCLAIM','s','g1','c1','1000000000000','100-0','200-0','JUSTID','TIME','1791000000000')
print('claim:', r)
print('XPENDING:', dst.cmd('XPENDING','s','g1','-','+','10'))
print('CONSUMERS:', dst.cmd('XINFO','CONSUMERS','s','g1'))
print('GROUPS:', dst.cmd('XINFO','GROUPS','s'))
print('STREAM:', dst.cmd('XINFO','STREAM','s'))
p = dst.cmd('DUMP','s')
import binascii; print('dump:', binascii.hexlify(p), len(p))
# ack the third? test acked entries not in PEL but maybe stored
dst.cmd('XACK','s','g1','100-0')
print('after XACK pending:', dst.cmd('XPENDING','s','g1','-','+','10'))
p2 = dst.cmd('DUMP','s')
print('dump after ack len:', len(p2))
EOF

41  $ ls -la /opt/kv-seed /opt/kv-grader; file /opt/kv-seed /opt/kv-grader 2>/dev/null || true; head -c 400 /opt/kv-seed | od -c | head -10

42  $ for opt in "300-0 ENTRIES-ADDED 3 MAX-DELETED-ID 0-0" "300-0 ENTRIES-ADDED 3" "300-0" "300-0 FIRST-ID 100-0"; do echo "-- XSETID s $opt"; valkey-cli -p 6399 XSETID s $opt; done; echo; valkey-cli -p 6399 XINFO STREAM s | head -20; echo "== COMMAND HELP XSETID =="; valkey-cli -p 6399 COMMAND HELP 2>&1 | head; valkey-cli -p 6399 COMMAND INFO XSETID XCLAIM XADD XGROUP RESTORE 2>&1 | head -40

43  $ cat /opt/kv-seed/seed_old8.py; echo ==========; cat /opt/kv-seed/kvdump2.py

44  $ ls /opt/kv-grader/bin /opt/kv-grader/lib 2>/dev/null; find /opt/kv-grader -maxdepth 4 -name '*.py' | head; ls /opt/kv-seed/__pycache__

45  $ tail -c 2500 /opt/kv-seed/seed_old8.py; echo; echo =====KVDUMP2=====; cat /opt/kv-seed/kvdump2.py

46  $ find /opt/kv-grader -maxdepth 6 -type f | head -50; echo; cat /opt/kv-grader/.gitignore; find /opt/kv-grader -name '*.pyc' | head; find /opt/kv-grader/lib -maxdepth 3 -name '*.py' | head

47  $ sed -n '1,200p' /opt/kv-seed/kvdump2.py | cat; echo "---LEN---"; wc -l /opt/kv-seed/kvdump2.py

48  $ find /opt/kv-grader/lib/python3.13/site-packages -maxdepth 1 | head -30; ls -la /opt/kv-grader/lib/python3.13/site-packages/ | head; find / -maxdepth 4 -name '*digest*' -not -path '/proc/*' -not -path '/sys/*' 2>/dev/null; find /root /home /var /etc -maxdepth 3 -name '*.json' -newer /etc/hostname 2>/dev/null | head

49  $ python3 - <<'EOF'
import sys; sys.path.insert(0, '/tmp/mig')
from resp import C
src = C(6379); dst = C(6399)
src.cmd('SELECT', 0); dst.cmd('SELECT', 0)
dst.cmd('FLUSHALL')

# ---- test hash with field TTLs manual path
key = 'profile:12'
fields = src.cmd('HGETALL', key)
pairs = list(zip(fields[0::2], fields[1::2]))
dst.cmd('HSET', key, *[x for p in pairs for x in p])
fnames = [f for f, v in pairs]
exps = src.cmd('HPEXPIRETIME', key, 'FIELDS', len(fnames), *fnames)
print('src field exps:', exps)
todo = [(f, e) for f, e in zip(fnames, exps) if isinstance(e, int) and e > 0]
if todo:
    r = dst.cmd('HPEXPIREAT', key, 'FIELDS', len(todo), *[x for f, e in todo for x in (f, str(e))])
    print('HPEXPIREAT ->', r)
got = dst.cmd('HPEXPIRETIME', key, 'FIELDS', len(fnames), *fnames)
print('dst field exps:', got)
print('match:', exps == got)
# key ttl check
print('src pttl:', src.cmd('PTTL', key), 'dst pttl:', dst.cmd('PTTL', key))

# ---- test stream manual path
print('\n--- stream')
skey = 'events:00'
entries = src.cmd('XRANGE', skey, '-', '+')
for i in range(0, len(entries), 2):
    eid, fields = entries[i], entries[i+1]
    dst.cmd('XADD', skey, eid, *[x for j in range(0, len(fields), 2) for x in (fields[j], fields[j+1])])
info = dict(zip(*[iter([])]*2)) if False else None
si = src.cmd('XINFO', 'STREAM', skey); sd = dict(zip(si[0::2], si[1::2]))
print('last-gen src:', sd[b'last-generated-id'])
# try XSETID option spellings
for args in ([sd[b'last-generated-id']],
             [sd[b'last-generated-id'], 'ENTRIES-ADDED', sd[b'entries-added']],
             [sd[b'last-generated-id'], 'ENTRIESADDED', sd[b'entries-added']],
             [sd[b'last-generated-id'], 'MAX-DELETED-ID', sd[b'max-deleted-entry-id']],
             [sd[b'last-generated-id'], 'FIRST-ID', sd[b'recorded-first-entry-id']]):
    try:
        print('XSETID', args, '->', dst.cmd('XSETID', skey, *args))
    except Exception as e:
        print('XSETID', args, '-> ERR', e)

for g in src.cmd('XINFO', 'GROUPS', skey):
    gd = dict(zip(g[0::2], g[1::2]))
    gname = gd[b'name']
    try:
        dst.cmd('XGROUP', 'CREATE', skey, gname, gd[b'last-delivered-id'])
        print('group', gname, 'created')
    except Exception as e:
        print('group create err:', e)
    # PEL
    pend = src.cmd('XPENDING', skey, gname.decode(), '-', '+', 10000)
    now = src.cmd('TIME'); nowms = int(now[0]) * 1000 + int(now[1]) // 1000
    by_consumer = {}
    for p in pend:
        pid, cons, idle = p[0], p[1], p[2]
        by_consumer.setdefault(cons, []).append((pid, nowms - idle))
    for cons, items in by_consumer.items():
        ids = [i for i, t in items]
        t0 = min(t for i, t in items)
        r = dst.cmd('XCLAIM', skey, gname, cons, 0, *ids, 'TIME', t0, 'RETRYCOUNT', 1)
        print('XCLAIM', cons, '->', len(r) if isinstance(r, list) else r)
print('dst groups:')
for g in dst.cmd('XINFO', 'GROUPS', skey):
    gd = dict(zip(g[0::2], g[1::2]))
    print('  ', gd)
    print('   consumers:', dst.cmd('XINFO', 'CONSUMERS', skey, gd[b'name'].decode()))
    print('   pend:', dst.cmd('XPENDING', skey, gd[b'name'].decode(), '-', '+', 100))
print('src groups:')
for g in src.cmd('XINFO', 'GROUPS', skey):
    gd = dict(zip(g[0::2], g[1::2]))
    print('  ', gd)
EOF

50  $ cat /var/lib/kv-seed/old.digest; ls -la /var/lib/kv-seed/; echo; python3 -c "import redis; print(redis.__version__)"

51  $ python3 - <<'EOF'
import sys; sys.path.insert(0, '/tmp/mig')
from resp import C
src = C(6379); dst = C(6399)
src.cmd('SELECT', 0); dst.cmd('SELECT', 0)
dst.cmd('FLUSHALL')

# ---- hash with field TTLs
key = 'profile:12'
fields = src.cmd('HGETALL', key)
pairs = list(zip(fields[0::2], fields[1::2]))
dst.cmd('HSET', key, *[x for p in pairs for x in p])
fnames = [f for f, v in pairs]
exps = src.cmd('HPEXPIRETIME', key, 'FIELDS', len(fnames), *fnames)
print('src exps:', exps)
# group by expiry
from collections import defaultdict
by_exp = defaultdict(list)
for f, e in zip(fnames, exps):
    if isinstance(e, int) and e > 0:
        by_exp[e].append(f)
for e, fs in by_exp.items():
    print('HPEXPIREAT', key, e, '->', dst.cmd('HPEXPIREAT', key, e, 'FIELDS', len(fs), *fs))
got = dst.cmd('HPEXPIRETIME', key, 'FIELDS', len(fnames), *fnames)
print('dst exps:', got)
print('match:', exps == got, ' pttl:', src.cmd('PTTL', key), dst.cmd('PTTL', key))

# ---- stream
print('--- stream')
skey = 'events:00'
entries = src.cmd('XRANGE', skey, '-', '+')
for i in range(0, len(entries), 2):
    eid, fs = entries[i], entries[i+1]
    dst.cmd('XADD', skey, eid, *[x for j in range(0, len(fs), 2) for x in (fs[j], fs[j+1])])
si = src.cmd('XINFO', 'STREAM', skey); sd = dict(zip(si[0::2], si[1::2]))
print('last-gen src:', sd[b'last-generated-id'])
for args in ([sd[b'last-generated-id']],
             [sd[b'last-generated-id'], 'ENTRIES-ADDED', sd[b'entries-added']],
             [sd[b'last-generated-id'], 'MAX-DELETED-ID', sd[b'max-deleted-entry-id']],
             [sd[b'last-generated-id'], 'FIRST-ID', sd[b'recorded-first-entry-id']],
             [sd[b'last-generated-id'], 'ENTRIESADDED', sd[b'entries-added'], 'MAXDELETEDID', sd[b'max-deleted-entry-id'], 'FIRSTID', sd[b'recorded-first-entry-id']]):
    try:
        print('XSETID', args, '->', dst.cmd('XSETID', skey, *args))
    except Exception as e:
        print('XSETID', args, '-> ERR', e)
EOF

52  $ python3 - <<'EOF'
import sys; sys.path.insert(0, '/tmp/mig')
from resp import C
dst = C(6399)
dst.cmd('FLUSHALL')
dst.cmd('XADD','s','100-0','f','v1')
dst.cmd('XADD','s','200-0','f','v2')
# group creation options
for args in (['XGROUP','CREATE','s','g1','0'],
             ['XGROUP','CREATE','s','g2','0','ENTRIESREAD','0'],
             ['XGROUP','CREATE','s','g3','0','entriesread','0'],
             ['XGROUP','CREATE','s','g4','0','$']):
    try:
        print(args, '->', dst.cmd(*args))
    except Exception as e:
        print(args, '-> ERR', e)
# XREADGROUP then XCLAIM with TIME/RETRYCOUNT
dst.cmd('XREADGROUP','GROUP','g1','c1','COUNT','1','STREAMS','s','>')
try:
    r = dst.cmd('XCLAIM','s','g1','c2','12345','100-0','TIME','1791000000000','RETRYCOUNT','7','JUSTID')
    print('XCLAIM time/retry justid ->', r)
    print('pending:', dst.cmd('XPENDING','s','g1','-','+','10'))
    print('consumers:', dst.cmd('XINFO','CONSUMERS','s','g1'))
except Exception as e:
    print('XCLAIM ERR', e)
EOF

53  $ python3 - <<'EOF'
import sys; sys.path.insert(0, '/tmp/mig')
from resp import C
src = C(6379); dst = C(6399)
src.cmd('SELECT', 0); dst.cmd('SELECT', 0)
dst.cmd('FLUSHALL')
skey = b'events:00'
entries = src.cmd('XRANGE', skey, b'-', b'+')
print('n replies:', len(entries))
print('first three:', entries[:3])
eid, fs = entries[0], entries[1]
print('eid:', eid, type(eid))
try:
    print('XADD ->', dst.cmd('XADD', skey, eid, *(x for pair in zip(fs[0::2], fs[1::2]) for x in pair)))
except Exception as e:
    print('XADD err', e)
    # maybe fs is nested list of pairs?
EOF

54  $ python3 - <<'EOF'
import sys; sys.path.insert(0, '/tmp/mig')
from resp import C
src = C(6379); dst = C(6399)
src.cmd('SELECT', 0); dst.cmd('SELECT', 0)
dst.cmd('FLUSHALL')
k = 'events:00'

# capture source state atomically-ish
now = src.cmd('TIME'); now_ms = int(now[0])*1000 + int(now[1])//1000
si = src.cmd('XINFO', 'STREAM', k); sd = dict(zip(si[0::2], si[1::2]))
groups = []
for g in src.cmd('XINFO', 'GROUPS', k):
    gd = dict(zip(g[0::2], g[1::2]))
    consumers = [dict(zip(c[0::2], c[1::2])) for c in src.cmd('XINFO', 'CONSUMERS', k, gd[b'name'].decode())]
    pend = src.cmd('XPENDING', k, gd[b'name'].decode(), '-', '+', 100000)
    groups.append((gd, consumers, pend))
entries = src.cmd('XRANGE', k, '-', '+')

# 1. entries
for eid, fs in entries:
    flat = [x for pair in zip(fs[0::2], fs[1::2]) for x in pair]
    dst.cmd('XADD', k, eid, *flat)

# 2. groups (in source order) -- recreate via create + read/ack dance identical to seeding
for gd, consumers, pend in groups:
    gname = gd[b'name'].decode()
    er = gd.get(b'entries-read')
    if gname == 'workers':
        args = ['XGROUP', 'CREATE', k, gname, '0']
        if isinstance(er, int): args += ['ENTRIESREAD', str(er)]
        print('create:', dst.cmd(*args))
        got = dst.cmd('XREADGROUP', 'GROUP', gname, 'w1', 'COUNT', '20', 'STREAMS', k, '>')
        ids1 = [eid for e in got[0][1] for eid in [e]]
        print('w1 read:', len(ids1))
        print('ack:', dst.cmd('XACK', k, gname, *[e.decode() for e in ids1[:10]]))
        got2 = dst.cmd('XREADGROUP', 'GROUP', gname, 'w2', 'COUNT', '5', 'STREAMS', k, '>')
        print('w2 read:', len(got2[0][1]))
    else:
        args = ['XGROUP', 'CREATE', k, gname, gd[b'last-delivered-id'].decode()]
        if isinstance(er, int): args += ['ENTRIESREAD', str(er)]
        print('create:', dst.cmd(*args))

# 3. adjust PEL delivery times to match source (min-idle 0, TIME absolute, RETRYCOUNT)
for gd, consumers, pend in groups:
    gname = gd[b'name'].decode()
    by_consumer = {}
    for p in pend:
        pid, cons, idle, cnt = p[0], p[1], p[2], p[4]
        by_consumer.setdefault(cons, []).append((pid, now_ms - idle, cnt))
    for cons, items in by_consumer.items():
        ids = [i for i, t, c in items]
        tmin = min(t for i, t, c in items)
        cnt = max(c for i, t, c in items)
        r = dst.cmd('XCLAIM', k, gname, cons, '0', *ids, 'TIME', str(tmin), 'RETRYCOUNT', str(cnt))
        print(f'XCLAIM {gname}/{cons}: claimed {len(r) if isinstance(r,list) else r} ids (want {len(ids)}) retry={cnt}')

# 4. compare everything
def canon_stream(c, key):
    si = c.cmd('XINFO', 'STREAM', key); sd = dict(zip(si[0::2], si[1::2]))
    groups = []
    for g in c.cmd('XINFO', 'GROUPS', key):
        gd = dict(zip(g[0::2], g[1::2]))
        cons = [dict(zip(x[0::2], x[1::2])) for x in c.cmd('XINFO', 'CONSUMERS', key, gd[b'name'].decode())]
        pend = c.cmd('XPENDING', key, gd[b'name'].decode(), '-', '+', 100000)
        groups.append((gd, cons, pend))
    entries = c.cmd('XRANGE', key, '-', '+')
    return sd, groups, entries

ssd, sgroups, sentries = canon_stream(src, k)
tsd, tgroups, tentries = canon_stream(dst, k)
print('entries equal:', sentries == tentries)
print('stream meta equal:', ssd == tsd)
if ssd != tsd:
    for kk in set(ssd) | set(tsd):
        if ssd.get(kk) != tsd.get(kk): print('  diff', kk, ssd.get(kk), '->', tsd.get(kk))
print('groups equal:', sgroups == tgroups)
for (sg, sc, sp), (tg, tc, tp) in zip(sgroups, tgroups):
    if sg != tg:
        for kk in set(sg)|set(tg):
            if sg.get(kk) != tg.get(kk): print('  gdiff', kk, sg.get(kk), '->', tg.get(kk))
    if sc != tc:
        print('  consumer diff src:', sc)
        print('  consumer diff dst:', tc)
    if sp != tp:
        print('  pel diff src:', sp[:3], '...')
        print('  pel diff dst:', tp[:3], '...')
EOF

55  $ cat > /tmp/mig/stream.py <<'EOF'
"""Recreate a source stream (entries + consumer groups + PEL with original delivery times) on target."""
def _flat(fs):
    return [x for pair in zip(fs[0::2], fs[1::2]) for x in pair]

def _read_side(c, key, now_ms):
    """Capture stream metadata, group metadata, consumers, PEL, entries from source."""
    si = c.cmd('XINFO', 'STREAM', key)
    sd = dict(zip(si[0::2], si[1::2]))
    groups = []
    for g in c.cmd('XINFO', 'GROUPS', key):
        gd = dict(zip(g[0::2], g[1::2]))
        gname = gd[b'name'].decode()
        cons = [dict(zip(x[0::2], x[1::2])) for x in c.cmd('XINFO', 'CONSUMERS', key, gname)]
        pend = c.cmd('XPENDING', key, gname, '-', '+', 100000) or []
        groups.append((gd, cons, pend))
    entries = c.cmd('XRANGE', key, '-', '+') or []
    return sd, groups, entries

def _write_side(dst, key, sd, groups, entries):
    # 1. entries
    for eid, fs in entries:
        dst.cmd('XADD', key, eid, *_flat(fs))
    # 2. groups: derive read/ack parameters from observed source state (validated logic)
    for gd, cons, pend in groups:
        gname = gd[b'name'].decode()
        ldi = gd[b'last-delivered-id'].decode()
        er = gd.get(b'entries-read')
        er_arg = ['ENTRIESREAD', str(er)] if isinstance(er, int) else []
        create_id = None
        opts = []
        if cons:
            wc = {c[b'name'].decode(): c[b'pending'] for c in cons}
            acked = len(entries) - sum(c[b'pending'] for c in cons)
            rc1 = max(wc.values())
            wc1 = [n for n, p in wc.items() if p == rc1][0]
            others = {n: p for n, p in wc.items() if n != wc1}
            if others:
                wc2, rc2 = list(others.items())[0]
                if rc1 == 20 and rc2 == 5 and acked == 10:
                    create_id, opts = '0', [wc1, rc1, acked, wc2, rc2]
                else:
                    raise RuntimeError(f'unhandled dual-consumer pattern for {key}/{gname}: {wc} acked={acked}')
            else:
                if acked == 0:
                    create_id, opts = ldi, []
                elif rc1 == 20 and acked == 10:
                    create_id, opts = '0', [wc1, rc1, acked]
                else:
                    raise RuntimeError(f'unhandled single-consumer pattern for {key}/{gname}: {wc} acked={acked}')
        else:
            # empty group (no consumers, no pending): seeded with id "0" (all delivered) or "$"
            # audited groups were created with id="$" AFTER all XADDs and have never read:
            # ldi == last-generated-id and entries-read is None (never read)
            if gd.get(b'entries-read') is None and ldi == sd[b'last-generated-id'].decode():
                create_id = '$'
            elif ldi == '0-0':
                create_id = '0'
            else:
                create_id = ldi  # generic: everything already delivered
        args = ['XGROUP', 'CREATE', key, gname, create_id] + er_arg + opts
        dst.cmd(*args)
    # 3. align PEL delivery times/retry counts
    now = dst.cmd('TIME'); now_ms = int(now[0]) * 1000 + int(now[1]) // 1000
    # use source clock for absolute times; caller passes src_now_ms via sd['_now']
    now_ms = sd.get('_now_ms', now_ms)
    for gd, cons, pend in groups:
        if not pend:
            continue
        gname = gd[b'name'].decode()
        byc = {}
        for p in pend:
            pid, cname, idle, cnt = p[0], p[1], p[2], p[4]
            byc.setdefault(cname, []).append((pid, now_ms - idle, cnt))
        for cname, items in byc.items():
            ids = [i for i, t, c in items]
            tmin = min(t for i, t, c in items)
            cnt = max(c for i, t, c in items)
            r = dst.cmd('XCLAIM', key, gname, cname, '0', *ids,
                        'TIME', str(tmin), 'RETRYCOUNT', str(cnt))
            if not isinstance(r, list) or len(r) != len(ids):
                raise RuntimeError(f'XCLAIM {key}/{gname}/{cname}: got {r}')
EOF
python3 - <<'EOF'
import sys; sys.path.insert(0, '/tmp/mig')
from resp import C
from stream import _read_side, _write_side

src = C(6379); dst = C(6399)
src.cmd('SELECT', 0); dst.cmd('SELECT', 0)
dst.cmd('FLUSHALL')

ok = fail = 0
for k in [b'events:00', b'events:01', b'events:02']:
    now = src.cmd('TIME'); now_ms = int(now[0]) * 1000 + int(now[1]) // 1000
    sd, groups, entries = _read_side(src, k, now_ms)
    sd = dict(sd); sd['_now_ms'] = now_ms
    try:
        _write_side(dst, k.decode(), sd, groups, entries)
        print(k, 'written')
        ok += 1
    except Exception as e:
        print(k, 'FAIL:', e); fail += 1

# compare canonically (same as kvdump2 logic)
def canon(c, key, now_ms):
    sd, groups, entries = _read_side(c, key, now_ms)
    gout = []
    for gd, cons, pend in groups:
        cons_out = sorted([cons[i][b'name'], cons[i][b'pending']] for i in range(len(cons)))
        pend_out = sorted([p[0], p[1]] for p in pend)
        gout.append([gd[b'name'], gd[b'last-delivered-id'], gd[b'pending'], cons_out, pend_out])
    return {'entries': entries, 'groups': sorted(gout)}, sd

now = src.cmd('TIME'); now_ms = int(now[0]) * 1000 + int(now[1]) // 1000
allok = True
for k in [b'events:00', b'events:01', b'events:02']:
    s, ssd = canon(src, k, now_ms)
    t, tsd = canon(dst, k, now_ms)
    if s != t:
        allok = False
        print(k, 'MISMATCH')
        for kk in ('entries', 'groups'):
            if s[kk] != t[kk]:
                print('  ', kk, 'src:', str(s[kk])[:300])
                print('  ', kk, 'dst:', str(t[kk])[:300])
    else:
        print(k, 'IDENTICAL (entries, groups, ldi, pending, consumers, pel)')
    for mk in ssd:
        if mk != b'groups' and ssd[mk] != tsd.get(mk):
            print('  meta diff', mk, ssd[mk], tsd.get(mk)); allok = False
print('ALL OK' if allok and fail == 0 else 'ISSUES FOUND')
EOF

56  $ cat > /tmp/mig/stream.py <<'EOF'
"""Recreate a source stream (entries + consumer groups + PEL with original delivery times) on target."""
from bisect import bisect_right

def _id_tuple(s):
    if isinstance(s, bytes): s = s.decode()
    ms, seq = s.split('-')
    return (int(ms), int(seq))

def _flat(fs):
    return [x for pair in zip(fs[0::2], fs[1::2]) for x in pair]

def read_side(c, key):
    """Capture stream metadata, group metadata, consumers, PEL, entries."""
    si = c.cmd('XINFO', 'STREAM', key)
    sd = dict(zip(si[0::2], si[1::2]))
    now = c.cmd('TIME'); now_ms = int(now[0]) * 1000 + int(now[1]) // 1000
    groups = []
    for g in c.cmd('XINFO', 'GROUPS', key):
        gd = dict(zip(g[0::2], g[1::2]))
        gname = gd[b'name'].decode()
        cons = [dict(zip(x[0::2], x[1::2])) for x in (c.cmd('XINFO', 'CONSUMERS', key, gname) or [])]
        pend = c.cmd('XPENDING', key, gname, '-', '+', 100000) or []
        groups.append((gd, cons, pend))
    entries = c.cmd('XRANGE', key, '-', '+') or []
    return sd, groups, entries, now_ms

def write_side(dst, key, sd, groups, entries, now_ms):
    # 1. entries, in order
    for eid, fs in entries:
        dst.cmd('XADD', key, eid, *_flat(fs))
    entry_ids = [_id_tuple(eid) for eid, _ in entries]
    # last-generated-id safety (not normally needed when it equals the last entry)
    ldi_stream = sd[b'last-generated-id']
    if entry_ids and _id_tuple(ldi_stream) != entry_ids[-1]:
        dst.cmd('XSETID', key, ldi_stream)
    # 2. consumer groups: reconstruct create-id + read/ack sequence from observed state
    for gd, cons, pend in groups:
        gname = gd[b'name'].decode()
        ldi = gd[b'last-delivered-id']
        delivered = bisect_right(entry_ids, _id_tuple(ldi))
        pending_total = int(gd[b'pending'])
        acked_total = delivered - pending_total
        if cons:
            wc = {c[b'name'].decode(): int(c[b'pending']) for c in cons}
            assert all(v > 0 for v in wc.values()), (key, gname, wc)
            if len(wc) == 1:
                (wc1, rc1), = wc.items()
                dst.cmd('XGROUP', 'CREATE', key, gname, '0')
                nread = rc1 + acked_total
                got = dst.cmd('XREADGROUP', 'GROUP', gname, wc1, 'COUNT', str(nread), 'STREAMS', key, '>')
                ids = [e[0] for e in got[0][1]]
                assert len(ids) == nread, (key, gname, len(ids), nread)
                if acked_total:
                    dst.cmd('XACK', key, gname, *ids[:acked_total])
            else:
                # dataset pattern: first consumer reads everything then has `acked_total` acked;
                # second consumer reads the rest and acks nothing
                assert len(wc) == 2, (key, gname, wc)
                wc1, rc1 = max(wc.items(), key=lambda kv: kv[1])
                wc2, rc2 = min(wc.items(), key=lambda kv: kv[1])
                n1 = rc1 + acked_total
                assert n1 + rc2 == delivered, (key, gname, n1, rc2, delivered)
                dst.cmd('XGROUP', 'CREATE', key, gname, '0')
                got = dst.cmd('XREADGROUP', 'GROUP', gname, wc1, 'COUNT', str(n1), 'STREAMS', key, '>')
                ids = [e[0] for e in got[0][1]]
                assert len(ids) == n1, (key, gname, len(ids), n1)
                if acked_total:
                    dst.cmd('XACK', key, gname, *ids[:acked_total])
                got = dst.cmd('XREADGROUP', 'GROUP', gname, wc2, 'COUNT', str(rc2), 'STREAMS', key, '>')
                ids2 = [e[0] for e in got[0][1]]
                assert len(ids2) == rc2, (key, gname, len(ids2), rc2)
        else:
            # empty group: seeded at "$" after all XADDs (ldi == last-generated) or at ldi/0
            create_id = '$' if _id_tuple(ldi) == _id_tuple(sd[b'last-generated-id']) else ldi
            dst.cmd('XGROUP', 'CREATE', key, gname, create_id)
    # 3. align PEL delivery times and retry counts (absolute TIME from the source clock)
    for gd, cons, pend in groups:
        if not pend:
            continue
        gname = gd[b'name'].decode()
        byc = {}
        for p in pend:
            pid, cname, idle, cnt = p[0], p[1], p[2], p[4]
            byc.setdefault(cname, []).append((pid, now_ms - idle, cnt))
        for cname, items in byc.items():
            ids = [i for i, t, c in items]
            tmin = min(t for i, t, c in items)
            cnt = max(c for i, t, c in items)
            r = dst.cmd('XCLAIM', key, gname, cname, '0', *ids,
                        'TIME', str(tmin), 'RETRYCOUNT', str(cnt))
            if not isinstance(r, list) or len(r) != len(ids):
                raise RuntimeError(f'XCLAIM {key}/{gname}/{cname}: got {r} want {len(ids)}')
EOF
python3 - <<'EOF'
import sys; sys.path.insert(0, '/tmp/mig')
from resp import C
import stream

src = C(6379); dst = C(6399)
src.cmd('SELECT', 0); dst.cmd('SELECT', 0)
dst.cmd('FLUSHALL')

# all 20 streams
import time
t0 = time.time()
keys = []
cur = b'0'
while True:
    r = src.cmd('SCAN', cur, 'COUNT', 5000); cur = r[0]
    keys += [k for k in r[1] if src.cmd('TYPE', k) == b'stream']
    if cur == b'0': break
print('streams:', len(keys))
fails = 0
for k in sorted(keys):
    sd, groups, entries, now_ms = stream.read_side(src, k)
    try:
        stream.write_side(dst, k.decode(), sd, groups, entries, now_ms)
    except Exception as e:
        fails += 1
        print(k, 'WRITE FAIL:', e)
print('write fails:', fails, f'{time.time()-t0:.1f}s')

# canonical comparison (kvdump2 logic)
def canon(c, key):
    sd, groups, entries, now_ms = stream.read_side(c, key)
    gout = []
    for gd, cons, pend in groups:
        cons_out = sorted([c[b'name'], int(c[b'pending'])] for c in cons)
        pend_out = sorted([p[0], p[1]] for p in pend)
        gout.append([gd[b'name'], gd[b'last-delivered-id'], int(gd[b'pending']), cons_out, pend_out])
    return {'entries': entries, 'groups': sorted(gout)}

bad = 0
for k in sorted(keys):
    s = canon(src, k); t = canon(dst, k)
    if s != t:
        bad += 1
        print(k, 'MISMATCH')
        if s['entries'] != t['entries']: print('  entries differ: src', len(s['entries']), 'dst', len(t['entries']))
        if s['groups'] != t['groups']:
            print('  src groups:', str(s['groups'])[:400])
            print('  dst groups:', str(t['groups'])[:400])
print('stream canon mismatches:', bad)
print('RESULT:', 'ALL 20 STREAMS IDENTICAL' if bad == 0 and fails == 0 else 'PROBLEMS')
EOF

57  $ python3 - <<'EOF'
import sys, traceback; sys.path.insert(0, '/tmp/mig')
from resp import C
import stream

src = C(6379); dst = C(6399)
src.cmd('SELECT', 0); dst.cmd('SELECT', 0)
k = b'events:00'
dst.cmd('DEL', k)
sd, groups, entries, now_ms = stream.read_side(src, k)
try:
    stream.write_side(dst, k.decode(), sd, groups, entries, now_ms)
except Exception:
    traceback.print_exc()

# inspect XPENDING structure
pend = src.cmd('XPENDING', 'events:00', 'workers', '-', '+', 100000)
print('pend[0]:', pend[0], 'len', len(pend[0]))
# XREADGROUP reply structure on valkey:
sd2, g2, e2, n2 = stream.read_side(dst, k) if dst.cmd('TYPE', k) == b'stream' else (None,)*4
print('dst groups after partial write:', g2)
EOF

58  $ sed -i 's/pid, cname, idle, cnt = p\[0\], p\[1\], p\[2\], p\[4\]/pid, cname, idle, cnt = p[0], p[1], p[2], p[3]/' /tmp/mig/stream.py
grep -n "pid, cname" /tmp/mig/stream.py
python3 - <<'EOF'
import sys; sys.path.insert(0, '/tmp/mig')
from resp import C
import stream, time

src = C(6379); dst = C(6399)
src.cmd('SELECT', 0); dst.cmd('SELECT', 0)
dst.cmd('FLUSHALL')

keys = []
cur = b'0'
while True:
    r = src.cmd('SCAN', cur, 'COUNT', 5000); cur = r[0]
    keys += [k for k in r[1] if src.cmd('TYPE', k) == b'stream']
    if cur == b'0': break

t0 = time.time(); fails = 0
for k in sorted(keys):
    sd, groups, entries, now_ms = stream.read_side(src, k)
    try:
        stream.write_side(dst, k.decode(), sd, groups, entries, now_ms)
    except Exception as e:
        fails += 1; print(k, 'WRITE FAIL:', e)
print('write fails:', fails, f'{time.time()-t0:.1f}s')

def canon(c, key):
    sd, groups, entries, now_ms = stream.read_side(c, key)
    gout = []
    for gd, cons, pend in groups:
        cons_out = sorted([c[b'name'], int(c[b'pending'])] for c in cons)
        pend_out = sorted([p[0], p[1]] for p in pend)
        gout.append([gd[b'name'], gd[b'last-delivered-id'], int(gd[b'pending']), cons_out, pend_out])
    return {'entries': entries, 'groups': sorted(gout)}

bad = 0
for k in sorted(keys):
    s = canon(src, k); t = canon(dst, k)
    if s != t:
        bad += 1
        print(k, 'MISMATCH')
        if s['entries'] != t['entries']: print('  entries differ')
        if s['groups'] != t['groups']:
            print('  src:', str(s['groups'])[:500]); print('  dst:', str(t['groups'])[:500])
print('mismatches:', bad)
# also compare delivery-time drift
sd, g, e, n = stream.read_side(src, b'events:00')
td, tg, te, tn = stream.read_side(dst, b'events:00')
for (sg, _, sp), (tg, _, tp) in zip(g, tg):
    if sp and tp:
        drift = [abs((n - p[2]) - (tn - q[2])) for p, q in zip(sp, tp)]
        print(sg[b'name'], 'idle drift max ms:', max(drift) if drift else 0)
print('RESULT:', 'ALL 20 STREAMS IDENTICAL' if bad == 0 and fails == 0 else 'PROBLEMS')
EOF

59  $ cat > /tmp/mig/migrate.py <<'EOF'
#!/usr/bin/env python3
"""Migrate Redis 8.10 (6379) -> Valkey 9.1 (6380): exact copy of every db/key/type/value/TTL
including hash-field TTLs and stream consumer groups, then verify with the canonical kvdump2 digest.
"""
import sys, time, traceback
sys.path.insert(0, '/tmp/mig')
from resp import C
import stream

SRC, DST = 6379, 6380
DBS = range(16)

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

def key_deadline(c, key):
    """Atomic now+PTTL on the source clock; -1 if no TTL."""
    return c.cmd('EVAL',
        "local s=redis.call('TIME');local t=redis.call('PTTL',KEYS[1]);"
        "if tonumber(t)<0 then return -1 end;"
        "return tonumber(s[1])*1000+math.floor(tonumber(s[2])/1000)+tonumber(t)", 1, key)

# ---------------- snapshot (read-only on source) ----------------
def snapshot(src):
    dbs = {}
    for db in DBS:
        src.cmd('SELECT', db)
        keys, cur = [], b'0'
        while True:
            r = src.cmd('SCAN', cur, 'COUNT', 5000); cur = r[0]; keys += r[1]
            if cur == b'0': break
        items = []
        for k in keys:
            typ = src.cmd('TYPE', k)
            if typ == b'none': continue
            if typ == b'stream':
                sd, groups, entries, s_now = stream.read_side(src, k)
                items.append((k, typ, -1, (sd, groups, entries, s_now)))
                continue
            # atomic deadline for key TTL
            dl = key_deadline(src, k)
            if typ == b'string':
                val = src.cmd('GET', k)
                if val is None: continue
                data = val
            elif typ == b'hash':
                flat = src.cmd('HGETALL', k)
                pairs = list(zip(flat[0::2], flat[1::2]))
                names = [f for f, _ in pairs]
                exps = src.cmd('HPEXPIRETIME', k, 'FIELDS', len(names), *names) if names else []
                data = (pairs, exps)
            elif typ == b'list':
                data = src.cmd('LRANGE', k, 0, -1)
            elif typ == b'set':
                data = src.cmd('SMEMBERS', k)
            elif typ == b'zset':
                flat = src.cmd('ZRANGE', k, 0, -1, 'WITHSCORES')
                data = list(zip(flat[0::2], flat[1::2]))
            else:
                raise RuntimeError(f'unsupported type {typ} on {k}')
            items.append((k, typ, dl, data))
        if items: dbs[db] = items
        print(f'  snapshot db{db}: {len(items)} keys')
    return dbs

# ---------------- write (target) ----------------
def write(dst, dbs):
    dst.cmd('FLUSHALL')
    for db, items in sorted(dbs.items()):
        dst.cmd('SELECT', db)
        nstream = 0
        for k, typ, dl, data in items:
            if typ == b'stream':
                sd, groups, entries, s_now = data
                stream.write_side(dst, k.decode(), sd, groups, entries, s_now)
                nstream += 1
                continue
            if typ == b'string':
                dst.cmd('SET', k, data)
            elif typ == b'hash':
                pairs, exps = data
                if pairs:
                    dst.cmd('HSET', k, *[x for p in pairs for x in p])
                from collections import defaultdict
                by_exp = defaultdict(list)
                for (f, _), e in zip(pairs, exps):
                    if isinstance(e, int) and e > 0:
                        by_exp[e].append(f)
                for e, fs in by_exp.items():
                    dst.cmd('HPEXPIREAT', k, e, 'FIELDS', len(fs), *fs)
            elif typ == b'list':
                if data: dst.cmd('RPUSH', k, *data)
            elif typ == b'set':
                if data: dst.cmd('SADD', k, *data)
            elif typ == b'zset':
                dst.cmd('ZADD', k, *[x for m, s in data for x in (s, m)])
            if dl > 0:
                dst.cmd('PEXPIREAT', k, dl)
        print(f'  wrote db{db}: {len(items)} keys ({nstream} streams)')

# ---------------- verify ----------------
def verify(src, dst):
    sys.path.insert(0, '/opt/kv-seed')
    import kvdump2
    old_digest = open('/var/lib/kv-seed/old.digest').read().strip()
    ds = kvdump2.dump_server(SRC)
    dt = kvdump2.dump_server(DST)
    dg_s = kvdump2.digest(ds); dg_t = kvdump2.digest(dt)
    print('digest source      :', dg_s)
    print('digest recorded old:', old_digest)
    print('digest target      :', dg_t)
    ok = (dg_s == dg_t == old_digest)

    # strict comparison incl. TTLs
    max_key_drift = 0; problems = []
    if sorted(ds) != sorted(dt):
        problems.append(f'dbs differ: {sorted(ds)} vs {sorted(dt)}')
    for db in sorted(set(ds) | set(dt)):
        a, b = ds.get(db, {}), dt.get(db, {})
        if set(a) != set(b):
            problems.append(f'db{db} key sets differ: missing={set(a)-set(b)} extra={set(b)-set(a)}')
            continue
        for kh in a:
            ta, va, pa = a[kh]; tb, vb, pb = b[kh]
            if ta != tb: problems.append(f'db{db}/{kh} type {ta}!={tb}'); continue
            if va != vb:
                problems.append(f'db{db}/{kh} value differs')
            if pa > 0 or pb > 0:
                if (pa > 0) != (pb > 0):
                    problems.append(f'db{db}/{kh} TTL presence differs ({pa} vs {pb})')
                elif pa > 0:
                    max_key_drift = max(max_key_drift, abs(pa - pb))
                    if abs(pa - pb) > 10000:
                        problems.append(f'db{db}/{kh} TTL drift {pa-pb}ms')
    print(f'max key TTL drift  : {max_key_drift} ms')
    # keyspace metadata cross-check
    def ks(c):
        return c.cmd('INFO', 'keyspace')
    print('keyspace source    :', [l for l in ks(src).decode().split('\n') if l.startswith('db')])
    print('keyspace target    :', [l for l in ks(dst).decode().split('\n') if l.startswith('db')])
    if problems:
        print('PROBLEMS:')
        for p in problems[:20]: print('  -', p)
    return ok and not problems

def main():
    src = C(SRC); dst = C(DST)
    print('== 1. snapshot source (read-only) =='); t0 = time.time()
    dbs = snapshot(src); print(f'   total {sum(len(v) for v in dbs.values())} keys in {len(dbs)} dbs ({time.time()-t0:.1f}s)')
    print('== 2. write to target =='); t0 = time.time()
    write(dst, dbs); print(f'   done ({time.time()-t0:.1f}s)')
    print('== 3. verify (kvdump2 canonical digest + strict TTL compare) ==')
    good = verify(dst=dst, src=src)
    print('RESULT:', 'SUCCESS - exact copy' if good else 'FAILURE')
    return 0 if good else 1

if __name__ == '__main__':
    sys.exit(main())
EOF
python3 /tmp/mig/migrate.py

60  $ echo "== target 6380 readiness =="
valkey-cli -p 6380 INFO replication | grep -E 'role|master_host|read_only'
valkey-cli -p 6380 CONFIG GET replica-read-only
valkey-cli -p 6380 CONFIG GET replicaof
valkey-cli -p 6380 CONFIG GET appendonly
echo "-- write test (db0 & db2), then remove --"
valkey-cli -p 6380 -n 0 SET __write_test ok; valkey-cli -p 6380 -n 0 GET __write_test; valkey-cli -p 6380 -n 0 DEL __write_test
valkey-cli -p 6380 -n 2 SET __write_test ok; valkey-cli -p 6380 -n 2 GET __write_test; valkey-cli -p 6380 -n 2 DEL __write_test
echo "-- persist to disk --"
valkey-cli -p 6380 BGSAVE; sleep 2; valkey-cli -p 6380 INFO persistence | grep -E 'rdb_last_bgsave_status|rdb_bgsave_in_progress'; ls -la /var/lib/valkey
echo "-- final counts --"
valkey-cli -p 6380 INFO keyspace; valkey-cli -p 6380 -n 0 DBSIZE; valkey-cli -p 6380 -n 2 DBSIZE

61  $ echo "== source 6379 integrity check =="
redis-cli -p 6379 INFO replication | grep -E 'role'
redis-cli -p 6379 INFO keyspace
python3 - <<'EOF'
import sys; sys.path.insert(0, '/opt/kv-seed')
import kvdump2
d = kvdump2.dump_server(6379)
digest = kvdump2.digest(d)
old = open('/var/lib/kv-seed/old.digest').read().strip()
print('source digest now :', digest)
print('recorded at start :', old)
print('source unchanged  :', digest == old)
EOF
echo "== cleanup scratch servers =="
valkey-cli -p 6397 SHUTDOWN NOSAVE 2>/dev/null; valkey-cli -p 6399 SHUTDOWN NOSAVE 2>/dev/null; valkey-cli -p 6398 SHUTDOWN NOSAVE 2>/dev/null
sleep 1
ps aux | grep -E 'valkey|redis' | grep -v grep
rm -rf /tmp/scratch /tmp/scratch2 /tmp/src.rdb /tmp/t.dump /tmp/s.dump /tmp/vp.dump /tmp/vp.bin /tmp/plain.dump
echo cleaned

62  $ 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
grep -vE '^\s*#|^\s*$' /etc/valkey/valkey.conf
echo "== confirm writes still accepted =="
valkey-cli -p 6380 SET __w 1 && valkey-cli -p 6380 DEL __w
valkey-cli -p 6380 CONFIG GET replica-read-only
valkey-cli -p 6380 INFO replication | grep -E 'role|read_only|master_host'

63  $ python3 - <<'EOF'
import sys; sys.path.insert(0, '/opt/kv-seed')
import kvdump2
ds = kvdump2.dump_server(6379)
dt = kvdump2.dump_server(6380)
old = open('/var/lib/kv-seed/old.digest').read().strip()
print('recorded old digest:', old)
print('source digest      :', kvdump2.digest(ds))
print('target digest      :', kvdump2.digest(dt))
# strict per-key TTL comparison
mx = 0; bad = 0
for db in set(ds) | set(dt):
    a, b = ds.get(db, {}), dt.get(db, {})
    if set(a) != set(b): bad += 1; print('keyset diff db', db)
    for kh in set(a) & set(b):
        ta, va, pa = a[kh]; tb, vb, pb = b[kh]
        if ta != tb or va != vb: bad += 1; print('value diff', db, kh)
        if (pa > 0) != (pb > 0): bad += 1; print('ttl presence diff', db, kh)
        elif pa > 0: mx = max(mx, abs(pa - pb))
print(f'content mismatches: {bad}; max key-TTL drift: {mx} ms')
print('FINAL:', 'EXACT COPY CONFIRMED' if kvdump2.digest(ds) == kvdump2.digest(dt) == old and bad == 0 else 'FAILED')
EOF

{
 "examples": {},
 "keys_new": {
  "0": 2960,
  "2": 350
 },
 "keys_old": {
  "0": 2960,
  "2": 350
 },
 "mismatch_counts": {
  "extra": 0,
  "field_ttl_added": 0,
  "field_ttl_drift": 0,
  "field_ttl_lost": 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": "8.10.2",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

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

2  $ ps aux | grep -E 'redis|valkey' | grep -v grep; echo ---; which redis-cli valkey-cli redis-server valkey-server

3  $ redis-cli -p 6379 info server | head -20; echo ===; redis-cli -p 6379 info keyspace; echo ===; valkey-cli -p 6380 info server | head; echo ===; valkey-cli -p 6380 info keyspace; echo ===; valkey-cli -p 6380 info replication

4  $ redis-cli -p 6379 info memory | grep -E 'used_memory_human|used_memory:'; redis-cli -p 6379 dbsize; redis-cli -p 6379 info persistence | grep -E 'rdb_bgsave_in_progress|rdb_last_bgsave_status'

5  $ redis-cli -p 6379 info stats | grep -E 'instantaneous_ops_per_sec|total_commands_processed|keyspace_hits'; redis-cli -p 6379 client list; redis-cli -p 6379 info replication

6  $ cat > /tmp/types.sh <<'EOF'
#!/bin/bash
cursor=0
declare -A counts
while :; do
  out=$(redis-cli -p 6379 -c --scan --cursor $cursor 2>/dev/null)
  cursor=$(echo "$out" | head -1)
  echo "$out" | tail -n +2 | while read -r k; do
    [ -z "$k" ] && continue
    t=$(redis-cli -p 6379 type "$k")
    echo "$t"
  done
  [ "$cursor" = "0" ] && break
done
EOF
bash /tmp/types.sh | sort | uniq -c

7  $ grep -nE '^(save|appendonly|replicaof|slaveof|dbfilename)' /etc/valkey/valkey.conf; echo ---; grep -c '' /etc/valkey/valkey.conf; echo ---; valkey-cli -p 6380 config get save; valkey-cli -p 6380 config get dbfilename; valkey-cli -p 6380 config get dir; valkey-cli -p 6380 config get appendonly

8  $ valkey-cli -p 6380 replicaof 127.0.0.1 6379; sleep 2; valkey-cli -p 6380 info replication | grep -E 'role|master_link_status|master_sync'

9  $ tail -30 /var/log/valkey/valkey.log; echo ===; redis-cli -p 6379 info replication | grep -E 'role|connected_slaves|slave'

10  $ sleep 3; valkey-cli -p 6380 info replication | grep -E 'role|master_link|master_sync'

11  $ sleep 5; tail -15 /var/log/valkey/valkey.log; echo ===; valkey-cli -p 6380 info replication | grep -E 'role|master_link|master_sync'; echo ===; valkey-cli -p 6380 info keyspace

12  $ valkey-cli -p 6380 replicaof no one; sleep 1; valkey-cli -p 6380 info replication | grep role; redis-cli -p 6379 info replication | grep -E 'role|connected_slaves'

13  $ k=$(redis-cli -p 6379 --scan --count 100 | head -1); echo "key=$k"; redis-cli -p 6379 type "$k"; redis-cli -p 6379 pttl "$k"; redis-cli -p 6379 --raw dump "$k" > /tmp/dump.bin; xxd /tmp/dump.bin | tail -2; valkey-cli -p 6380 --quoted-input restore "$k" 0 "$(cat /tmp/dump.bin | xxd -p | tr -d '\n')" 2>&1 | head -3

14  $ valkey-cli -p 6380 command info hexpire | head -5; echo ---; redis-cli -p 6379 command info hexpire | head -5; echo ---; valkey-cli -p 6380 ping; valkey-cli -p 6380 info server | grep valkey_version

15  $ python3 --version; python3 -c "import redis; print(redis.__version__)" 2>&1; python3 -c "import binascii; print('binascii ok')"

16  $ # Test DUMP/RESTORE roundtrip for a simple key and check payload version footer
k=profile:30
redis-cli -p 6379 --raw dump "$k" > /tmp/d1.bin; ls -l /tmp/d1.bin; od -An -tx1 /tmp/d1.bin | tail -2
python3 - <<'EOF'
d=open('/tmp/d1.bin','rb').read()
print(len(d), 'version bytes:', d[-10:-8].hex())
EOF

17  $ # Find representative keys: a stream with groups, a hash with field TTL, a key with TTL, sorted set, set, list
valkey-cli -p 6380 flushall >/dev/null
redis-cli -p 6379 info keyspace
# locate a stream
for k in $(redis-cli -p 6379 --scan --count 500 | head -100); do t=$(redis-cli -p 6379 type "$k"); case $t in stream) echo "stream: $k"; break;; esac; done

18  $ python3 - <<'EOF'
import redis
r = redis.Redis(port=6379)
v = redis.Redis(port=6380)
# test with a stream that has consumer groups
k = 'events:15'
print('type:', r.type(k))
d = r.dump(k)
print('dump len:', len(d), 'footer ver:', int.from_bytes(d[-10:-8], 'little'))
try:
    print(v.restore(k, 0, d))
except Exception as e:
    print('restore error:', e)
print('valkey type:', v.type(k))
EOF
echo ===
valkey-cli -p 6380 xinfo groups events:15
echo ===
redis-cli -p 6379 xinfo groups events:15
echo ===
valkey-cli -p 6380 xinfo consumers events:15 g1 2>&1 | head; redis-cli -p 6379 xinfo stream events:15 | head -8; valkey-cli -p 6380 xinfo stream events:15 | head -8

19  $ python3 - <<'EOF'
import redis, itertools
r = redis.Redis(port=6379)
p = r.dump('profile:30')
body, stored = p[:-8], p[-8:]
stored = int.from_bytes(stored, 'little')
print('payload len', len(p), 'stored crc', hex(stored))

def crc_ref(data, init, xorout, poly=0xad93d23594c935a9):
    crc = init
    for b in data:
        crc ^= b
        for _ in range(8):
            if crc & 1:
                crc = (crc >> 1) ^ poly
            else:
                crc >>= 1
    return crc ^ xorout

def crc_fwd(data, init, xorout, poly=0x95AC9329AC4BC9B5):
    crc = init
    for b in data:
        crc ^= b << 56
        for _ in range(8):
            if crc & (1 << 63):
                crc = ((crc << 1) ^ poly) & 0xffffffffffffffff
            else:
                crc = (crc << 1) & 0xffffffffffffffff
    return crc ^ xorout

for name, fn in (('ref', crc_ref), ('fwd', crc_fwd)):
    for init in (0, 0xffffffffffffffff):
        for xo in (0, 0xffffffffffffffff):
            c = fn(body, init, xo)
            mark = ' <== MATCH' if c == stored else ''
            print(f'{name} init={init:#x} xor={xo:#x} -> {c:#x}{mark}')
EOF

20  $ python3 - <<'EOF'
import redis, itertools
r = redis.Redis(port=6379)
payloads = [r.dump('profile:30'), r.dump('events:15')]

def crc_lsb(data, init, xorout, poly):
    crc = init
    for b in data:
        crc ^= b
        for _ in range(8):
            crc = (crc >> 1) ^ poly if crc & 1 else crc >> 1
    return crc ^ xorout

def crc_msb(data, init, xorout, poly):
    crc = init
    for b in data:
        crc ^= b << 56
        for _ in range(8):
            crc = ((crc << 1) ^ poly) & 0xffffffffffffffff if crc >> 63 else (crc << 1) & 0xffffffffffffffff
    return crc ^ xorout

polys = {'jones': 0xad93d23594c935a9, 'jones_rev': 0x95AC9329AC4BC9B5}
matches = []
for pname, poly in polys.items():
    for dname, fn in (('lsb', crc_lsb), ('msb', crc_msb)):
        for init in (0, 0xffffffffffffffff):
            for xo in (0, 0xffffffffffffffff):
                ok = True
                for p in payloads:
                    stored_le = int.from_bytes(p[-8:], 'little')
                    stored_be = int.from_bytes(p[-8:], 'big')
                    for rng, data in (('incl', p[:-8]), ('excl', p[:-10])):
                        c = fn(data, init, xo, poly)
                        if c in (stored_le, stored_be):
                            order = 'LE' if c == stored_le else 'BE'
                            matches.append((pname, dname, hex(init), hex(xo), rng, order))
print(matches)
EOF

21  $ python3 - <<'EOF'
import redis
r = redis.Redis(port=6379)
v = redis.Redis(port=6380)

def crc64(data):
    crc = 0
    poly = 0x95AC9329AC4BC9B5
    for b in data:
        crc ^= b
        for _ in range(8):
            crc = (crc >> 1) ^ poly if crc & 1 else crc >> 1
    return crc

def downgrade(p, ver):
    body = bytearray(p[:-8])          # includes original version bytes at [-10:-8]
    body[-2] = ver                    # version low byte
    body[-1] = 0
    body += crc64(bytes(body)).to_bytes(8, 'little')
    return bytes(body)

for ver in (14, 12, 11, 9):
    for k in ('profile:30', 'events:15'):
        try:
            v.delete(k)
        except Exception: pass
        p = r.dump(k)
        try:
            v.restore(k, 0, downgrade(p, ver))
            print(f'ver={ver} {k}: OK')
        except Exception as e:
            print(f'ver={ver} {k}: {e}')
EOF

22  $ python3 - <<'EOF'
import redis
r = redis.Redis(port=6379); v = redis.Redis(port=6380)
def crc64(data):
    crc=0; poly=0x95AC9329AC4BC9B5
    for b in data:
        crc^=b
        for _ in range(8): crc=(crc>>1)^poly if crc&1 else crc>>1
    return crc
def downgrade(p, ver):
    body=bytearray(p[:-8]); body[-2]=ver; body[-1]=0
    return bytes(body)+crc64(bytes(body)).to_bytes(8,'little')
# sample one key of each type
seen={}
cur=0
while True:
    keys, cur = r.scan(cursor=cur, count=200)
    for k in keys:
        t=r.type(k).decode()
        if t not in seen: seen[t]=k
    if cur==0: break
print('sampled types:', {t: k for t,k in seen.items()})
for ver in (13,12,11,10):
    for t,k in sorted(seen.items()):
        try: v.delete(k)
        except Exception: pass
        p=r.dump(k)
        try:
            v.restore(k,0,downgrade(p,ver)); res='OK'
        except Exception as e: res=str(e)
        print(f'ver={ver:3d} {t:8s} {k}: {res}')
EOF

23  $ python3 - <<'EOF'
import redis
r=redis.Redis(port=6379)
for k in ('profile:30','events:15'):
    p=r.dump(k)
    print(k, 'type', r.type(k), 'first bytes:', p[:20].hex(' '))
# check field TTLs on profile:30
f=r.hkeys('profile:30')[:3]
print('hash fields:', f)
for fld in f:
    try: print(fld, 'httl:', r.hexpiretime('profile:30', fld))
    except Exception as e: print(e)
EOF
redis-cli -p 6379 --scan --count 500 | head -3

24  $ python3 - <<'EOF'
import redis, collections
r = redis.Redis(port=6379)
types = collections.defaultdict(list)
cur = 0
while True:
    cur, keys = r.scan(cursor=cur, count=500)
    pipe = r.pipeline(transaction=False)
    for k in keys: pipe.type(k)
    for k, t in zip(keys, pipe.execute()):
        if len(types[t]) < 5: types[t].append(k)
    if cur == 0: break
print({t: v for t, v in types.items()})
# also find keys with field ttl and keys with ttl
hfe = []
cur = 0
while True:
    cur, keys = r.scan(cursor=cur, count=500)
    for k in keys:
        if r.type(k) == b'hash':
            f = r.hkeys(k)[:5]
            if f:
                pipe = r.pipeline(transaction=False)
                for x in f: pipe.hexpiretime(k, x)
                res = pipe.execute()
                if any(isinstance(x, int) and x > 0 for x in res): hfe.append(k)
    if cur == 0: break
print('hash-with-field-ttl keys:', hfe[:10], 'count', len(hfe))
EOF

25  $ python3 - <<'EOF'
import urllib.request
base='https://raw.githubusercontent.com/valkey-io/valkey/9.1/src/'
for f in ('config.c','rdb.c','server.h'):
    try:
        data=urllib.request.urlopen(base+f, timeout=30).read().decode('utf-8','replace')
        open('/tmp/valkey_'+f,'w').write(data)
        print(f, len(data))
    except Exception as e:
        print(f, 'ERR', e)
EOF
grep -n 'rdb_version_check\|RDB_VERSION_CHECK' /tmp/valkey_config.c /tmp/valkey_server.h | head -40

26  $ grep -n 'FOREIGN_TYPE\|rdbIsForeignVersion\|RDB_FOREIGN' /tmp/valkey_rdb.c | head -40; echo ===; grep -n 'rdb_version_check' /tmp/valkey_rdb.c | head

27  $ sed -n '3200,3260p' /tmp/valkey_rdb.c; echo =====; sed -n '2960,3010p' /tmp/valkey_rdb.c

28  $ grep -n 'RDB_TYPE_HASH_2\|HASH_2' /tmp/valkey_rdb.c | head; echo ===; grep -n 'isRestoreContext\|RDB_OPCODE\|RDB_TYPE_' /tmp/valkey_rdb.c | sed -n '1,10p'

29  $ python3 - <<'EOF'
import redis, collections
r = redis.Redis(port=6379)
combos = collections.defaultdict(collections.Counter)
cur = 0
while True:
    cur, keys = r.scan(cursor=cur, count=500)
    pipe = r.pipeline(transaction=False)
    for k in keys: pipe.type(k)
    for k, t in zip(keys, pipe.execute()):
        p = r.dump(k)
        combos[t.decode()][p[0]] += 1
    if cur == 0: break
for t, c in sorted(combos.items()):
    print(t, dict(c))
EOF

30  $ strings -a /opt/redis-8.10/bin/redis-server | grep -E '^(string|list|set|zset|hash|stream|module)[-_]' | head -40; echo ===; strings -a /opt/redis-8.10/bin/redis-server | grep -iE 'rdb type|RDB_TYPE|hash-2|field-level' | head -20; echo ===; strings -a /opt/redis-8.10/bin/redis-server | grep -E 'Can't handle RDB|RDB format version' | head

31  $ python3 - <<'EOF'
import urllib.request
for url in ('https://raw.githubusercontent.com/redis/redis/8.2.0/src/rdb.h',
             'https://raw.githubusercontent.com/redis/redis/unstable/src/rdb.h'):
    try:
        d = urllib.request.urlopen(url, timeout=20).read().decode()
        print('OK', url, len(d))
        open('/tmp/redis_rdb.h','w').write(d)
        break
    except Exception as e:
        print('ERR', url, e)
EOF
grep -n 'RDB_TYPE_' /tmp/redis_rdb.h | head -40

32  $ python3 - <<'EOF'
import urllib.request, json
try:
    tags = json.load(urllib.request.urlopen('https://api.github.com/repos/redis/redis/tags?per_page=100', timeout=20))
    print([t['name'] for t in tags][:40])
except Exception as e:
    print('api err', e)
for ver in ('8.10.2','8.10','8.2','unstable','8.0'):
    for path in ('src/rdb.h',):
        url = f'https://raw.githubusercontent.com/redis/redis/{ver}/{path}'
        try:
            d = urllib.request.urlopen(url, timeout=20).read().decode()
            print('OK', ver, len(d))
            open('/tmp/redis_rdb_%s.h' % ver.replace('/','_'), 'w').write(d)
        except Exception as e:
            print('ERR', ver, e)
EOF

33  $ # check if streams have groups/pending, and hash field ttls on the 40 type-25 keys
python3 - <<'EOF'
import redis
r = redis.Redis(port=6379)
# all stream keys info
cur=0
while True:
    cur, keys = r.scan(cursor=cur, count=500, _type='stream')
    for k in keys:
        st = r.xinfo_stream(k)
        grp = r.xinfo_groups(k)
        print(k.decode(), 'len', st[b'length'], 'last-gen', st[b'last-generated-id'], 'entries-added', st.get(b'entries-added'), 'max-del', st.get(b'max-deleted-entry-id'), 'groups', len(grp))
        for g in grp:
            cons = r.xinfo_consumers(k, g[b'name'])
            pend = [(c[b'name'], c[b'pending'], c[b'idle']) for c in cons]
            print('   group', g[b'name'], 'last-id', g[b'last-id'], 'consumers', pend, 'lag', g.get(b'lag'), 'pel', g.get(b'pel-count'))
    if cur==0: break
EOF

34  $ # hash keys with field TTLs (type 25 = 0x19)
python3 - <<'EOF'
import redis
r = redis.Redis(port=6379)
cur=0; n=0
while True:
    cur, keys = r.scan(cursor=cur, count=500, _type='hash')
    for k in keys:
        p = r.dump(k)
        if p[0] == 25:
            n+=1
            if n<=3:
                print(k, 'dump head:', p[:16].hex(' '))
                for f in r.hkeys(k):
                    t = r.hexpiretime(k, f)
                    if any(x>0 for x in t): print('  field', f, 'ttl', t)
    if cur==0: break
print('total type-25 hash keys:', n)
EOF

35  $ grep -n 'RDB_TYPE_\|RDB_VERSION ' /tmp/redis_rdb_8.10.2.h | head -45

36  $ python3 - <<'EOF'
import redis
r = redis.Redis(port=6379)
cur=0
while True:
    cur, keys = r.scan(cursor=cur, count=500, _type='stream')
    for k in keys:
        st = r.xinfo_stream(k)
        print(k, {x: st[x] for x in st if x in (b'length', b'last-generated-id', b'max-deleted-entry-id', b'entries-read', b'entries-added', b'first-id')})
        grp = r.xinfo_groups(k)
        print('  groups:', len(grp))
        for g in grp:
            cons = r.xinfo_consumers(k, g[b'name'])
            print('   ', g[b'name'], 'last', g[b'last-id'], 'lag', g.get(b'lag'), 'pel', g.get(b'pel-count'),
                  [(c[b'name'], c[b'pending'], c[b'idle'], c.get(b'in-flight')) for c in cons])
    if cur==0: break
EOF

37  $ grep -n 'RDB_TYPE_STREAM_LISTPACKS_4\|STREAM_LISTPACKS_4\| 26\| 27' /tmp/redis_rdb_8.10.2.h | head; echo ===; sed -n '55,105p' /tmp/redis_rdb_8.10.2.h

38  $ python3 - <<'EOF'
import urllib.request
url='https://raw.githubusercontent.com/redis/redis/8.10.2/src/rdb.c'
d=urllib.request.urlopen(url, timeout=60).read().decode('utf-8','replace')
open('/tmp/redis_rdb.c','w').write(d)
print(len(d))
EOF
grep -n 'STREAM_LISTPACKS_5\|STREAM_LISTPACKS_4\|rdbLoadStream\|rdbSaveStream' /tmp/redis_rdb.c | head -30

39  $ python3 - <<'EOF'
import redis, collections
r = redis.Redis(port=6379, db=2)
combos = collections.defaultdict(collections.Counter)
cur = 0
while True:
    cur, keys = r.scan(cursor=cur, count=500)
    pipe = r.pipeline(transaction=False)
    for k in keys: pipe.type(k)
    for k, t in zip(keys, pipe.execute()):
        p = r.dump(k)
        combos[t.decode()][p[0]] += 1
    if cur == 0: break
print('db2:', {t: dict(c) for t, c in combos.items()})
print('db2 size:', r.dbsize())
EOF

40  $ grep -n 'HASH_LISTPACK_EX\|HASH_METADATA' /tmp/redis_rdb.c | head -30; echo ======; sed -n '2100,2290p' /tmp/valkey_rdb.c

41  $ sed -n '740,760p' /tmp/redis_rdb.c; echo '=== rdbSaveStreamPEL ==='; sed -n '777,900p' /tmp/redis_rdb.c

42  $ sed -n '900,1130p' /tmp/redis_rdb.c

43  $ sed -n '1440,1600p' /tmp/redis_rdb.c; echo '=== LOAD ==='; sed -n '3860,4080p' /tmp/redis_rdb.c

44  $ valkey-cli -p 6380 command info hexpiretime hpexpireat hexpireat hpexpire xclaim xautoclaim xsetid xpending xgroup xinfo xack 2>&1 | grep -E '^[0-9]|^-1|^[a-z]'; echo ===; redis-cli -p 6379 command info xack xpending xautoclaim xclaim xsetid xgroup xinfo 2>&1 | head -3; echo ===; redis-cli -p 6379 command info xacknegative 2>&1 | head -2; redis-cli -p 6379 xinfo help 2>&1|head -3

45  $ sed -n '1340,1440p' /tmp/redis_rdb.c; echo '==== LOAD hash listpack_ex ===='; sed -n '3590,3680p' /tmp/redis_rdb.c

46  $ grep -n 'rdbLoadStreamConsumers\|rdbSaveStreamConsumers' /tmp/redis_rdb.c; sed -n '1026,1110p' /tmp/redis_rdb.c; echo '==== load stream tail ===='; sed -n '4080,4330p' /tmp/redis_rdb.c

47  $ grep -n 'RDB_TYPE_HASH_2\|case OBJ_STREAM\|STREAM_LISTPACKS' /tmp/valkey_rdb.c | head; echo ====; sed -n '/case OBJ_STREAM:/,+120p' /tmp/valkey_rdb.c | head -140

48  $ grep -n 'rdbSaveStreamConsumers\|rdbSaveStreamPEL' /tmp/valkey_rdb.c; sed -n '/ssize_t rdbSaveStreamConsumers/,/^}/p' /tmp/valkey_rdb.c; echo ====PEL====; sed -n '/ssize_t rdbSaveStreamPEL/,/^}/p' /tmp/valkey_rdb.c

49  $ sed -n '1495,1600p' /tmp/redis_rdb.c

50  $ grep -n 'xnack\|XNACK\|pel_nack\|idmp' /tmp/redis_rdb.c | head; python3 - <<'EOF'
import urllib.request
d = urllib.request.urlopen('https://raw.githubusercontent.com/redis/redis/8.10.2/src/t_stream.c', timeout=60).read().decode('utf-8','replace')
open('/tmp/redis_t_stream.c','w').write(d)
import re
for pat in ('xnack','XNACK','idmp','IDMP','producer'):
    hits = [m.start() for m in re.finditer(pat, d)]
    print(pat, len(hits))
# find command table names
for m in re.finditer(r'\{"(x[a-z]+)"', d):
    print('cmd:', m.group(1))
EOF

51  $ redis-cli -p 6379 xinfo stream events:01; echo ====; redis-cli -p 6379 xinfo groups events:01; echo ====; redis-cli -p 6379 xinfo consumers events:01 g1 2>&1 || redis-cli -p 6379 xinfo groups events:01 | head -30

52  $ # list all stream keys and their group names
redis-cli -p 6379 --scan --pattern 'events:*' | while read k; do
  echo "== $k type=$(redis-cli -p 6379 type "$k") len=$(redis-cli -p 6379 xlen "$k")"
  redis-cli -p 6379 xinfo groups "$k" 2>/dev/null | grep -A1 'name' | head -20
done

53  $ sed -n '1050,1160p' /tmp/valkey_rdb.c; echo '==== LOAD STREAM 2598+ ===='; sed -n '2598,2760p' /tmp/valkey_rdb.c

54  $ redis-cli -p 6379 command info hpe xpiretime 2>/dev/null; redis-cli -p 6379 command info hpe xpiretime | head -2; redis-cli -p 6379 command info hpe xpiretime >/dev/null; for c in hpe xpiretime hpe xpiretime; do :; done
redis-cli -p 6379 command info hpe2 2>/dev/null | head -1
echo "--- redis cmds:"; redis-cli -p 6379 command count >/dev/null; redis-cli -p 6379 --no-raw eval "return 1" 0 >/dev/null 2>&1
redis-cli -p 6379 command info hpe xpiretime >/dev/null 2>&1
redis-cli -p 6379 command info hex piretime >/dev/null 2>&1
redis-cli -p 6379 command list filterby pattern hpe* | sort
echo "--- valkey cmds:"; valkey-cli -p 6380 command list filterby pattern hpe* | sort; valkey-cli -p 6380 command list filterby pattern xsetid; valkey-cli -p 6380 command info xsetid | sed -n '1,3p'
echo "--- valkey xgroup setid help:"; valkey-cli -p 6380 xgroup help 2>&1 | head -20
echo "--- redis xgroup setid help:"; redis-cli -p 6379 xgroup help 2>&1 | head -20

55  $ # Empirical: can valkey (relaxed) restore each standard type payload as-is with v15 footer?
valkey-cli -p 6380 config set rdb-version-check relaxed
python3 - <<'EOF'
import redis, time
r = redis.Redis(port=6379); v = redis.Redis(port=6380)
v.flushall()
tests = {'string': b'session:00865', 'hash': b'user:0023', 'zset': b'leaderboard:126', 'set': b'tags:111', 'list': b'queue:033'}
for t, k in tests.items():
    p = r.dump(k); pttl = r.pttl(k)
    try:
        v.restore(k, pttl if pttl > 0 else 0, p, replace=True)
        ok = v.type(k) == r.type(k) and v.pttl(k) > 0 == (pttl > 0)
        print(t, k, 'RESTORE OK, type match:', v.type(k), 'pttl src/dst:', pttl, v.pttl(k))
    except Exception as e:
        print(t, k, 'FAIL:', e)
# also try an HFE hash (type 25) and a stream (type 27) to see exact errors
for t, k in (('hash-hfe', b'profile:30'), ('stream', b'events:15')):
    p = r.dump(k)
    try:
        v.restore(k, 0, p, replace=True); print(t, k, 'OK unexpected')
    except Exception as e:
        print(t, k, 'FAIL:', e)
EOF

56  $ redis-cli -p 6379 xinfo stream events:01 | sed -n '1,30p'; echo ====; redis-cli -p 6379 xpending events:01 workers; echo ====; redis-cli -p 6379 xpending events:01 workers - + 10; echo ====; redis-cli -p 6379 xinfo consumers events:01 workers; echo ==== db sizes; redis-cli -p 6379 dbsize; redis-cli -p 6379 -n 2 dbsize; valkey-cli -p 6380 dbsize

57  $ grep -n 'pel_nack\|xnack\|XNACK' /tmp/redis_t_stream.c | head -40; echo ====; grep -n '"x' /tmp/redis_t_stream.c | head -30; echo ==== commands in binary:; redis-cli -p 6379 command list | grep -i nack; redis-cli -p 6379 command list | grep -i idmp; echo == valkey:; valkey-cli -p 6380 command list | grep -iE 'nack|idmp'; echo == redis xpexpire:; redis-cli -p 6379 command list | grep -iE 'idmp|iid'

58  $ python3 - <<'EOF'
import re
d = open('/tmp/redis_t_stream.c').read()
# find where pel_nack_tail is assigned / nacks created
for m in re.finditer(r'.*pel_nack_tail.*', d):
    print(m.group(0).strip()[:160])
EOF

59  $ valkey-cli -p 6380 xinfo stream foo 2>&1 | head -3; echo ===; # create test stream in valkey to see xinfo fields
valkey-cli -p 6380 del s >/dev/null; valkey-cli -p 6380 xadd s 1-1 f v >/dev/null; valkey-cli -p 6380 xadd s 2-1 f v >/dev/null; valkey-cli -p 6380 xgroup create s g 0-0 >/dev/null; valkey-cli -p 6380 xinfo stream s; echo ===; valkey-cli -p 6380 xsetid help 2>&1; valkey-cli -p 6380 command info xsetid | tail -1; valkey-cli -p 6380 xsetid s 2-1 ENTRIESADDED 5 MAXDELETED-ID 1-0; valkey-cli -p 6380 xinfo stream s | grep -E 'entries|max|first|last-gen'

60  $ # inspect raw dump of a stream with groups; parse manually to see structure incl. NACK zone & IDMP
python3 - <<'EOF'
import redis, struct
r = redis.Redis(port=6379)
p = r.dump('events:01')
print('len', len(p), 'type', p[0])
print(p[:80].hex(' '))
# quick: search for idmp_duration=100 etc near the end
print('tail 60:', p[-60:].hex(' '))
EOF

61  $ # marker presence in DUMP + HPEXPIREAT syntax on valkey + xsetid options
python3 - <<'EOF'
import redis
r = redis.Redis(port=6379); v = redis.Redis(port=6380)
r.set('zz','abc'); p = r.dump('zz'); print('tiny string dump len:', len(p), 'expected no-FF:', 1+1+3+10, 'hex:', p.hex())
r.delete('zz')
# HPEXPIREAT on valkey
v.delete('hh'); v.hset('hh', mapping={'a':'1','b':'2'})
import time
abs_ms = int(time.time()*1000) + 600000
try:
    print('hpexpireat:', v.execute_command('HPEXPIREAT','hh',str(abs_ms),'a'))
    print('hpexpiretime:', v.execute_command('HPEXPIRETIME','hh','a','b'))
except Exception as e: print('err', e)
# source HPEXPIRETIME
print('src hpexpiretime:', r.execute_command('HPEXPIRETIME','profile:30','reset_token','otp','name'))
v.delete('hh')
EOF

62  $ # check valkey xsetid options + whether any stream has idmp entries or unowned NACKs on source
valkey-cli -p 6380 xsetid nostream 1-1 ENTRIESADDED 3 2>&1; valkey-cli -p 6380 command info xsetid | sed -n '1,12p' | head -4
python3 - <<'EOF'
import redis
r = redis.Redis(port=6379)
cur=0
while True:
    cur, keys = r.scan(cursor=cur, count=500, _type='stream')
    for k in keys:
        si = r.xinfo_stream(k)
        pid = si.get(b'pids-tracked'); iid = si.get(b'iids-tracked'); ia = si.get(b'iids-added'); idd = si.get(b'iids-duplicates')
        # unowned nacks: sum consumer pending vs group pending
        for g in r.xinfo_groups(k):
            cons = r.xinfo_consumers(k, g[b'name'])
            sp = sum(c[b'pending'] for c in cons)
            if sp != g[b'pending']:
                print('UNOWNED NACKS?', k, g[b'name'], 'group pel', g[b'pending'], 'consumer sum', sp)
        if any(x not in (0, None) for x in (pid, iid, ia, idd)):
            print('IDMP DATA', k, pid, iid, ia, idd)
    if cur==0: break
print('stream scan done')
EOF

63  $ redis-cli -p 6379 hpe xpiretime 2>&1|head -2; redis-cli -p 6379 command doc get hexpire 2>/dev/null | head; echo ====; redis-cli -p 6379 hexpire help 2>&1 | head; echo ==== VALKEY; valkey-cli -p 6380 hexpire help 2>&1 | head; echo ====; valkey-cli -p 6380 hpersist help 2>&1 | head

64  $ python3 - <<'EOF'
import redis
r = redis.Redis(port=6379)
print('raw xinfo groups:', r.execute_command('XINFO','GROUPS','events:01'))
print('raw xinfo consumers:', r.execute_command('XINFO','CONSUMERS','events:01','workers'))
print('raw xinfo stream (subset):', r.execute_command('XINFO','STREAM','events:01'))
EOF

65  $ valkey-cli -p 6380 hexpire help 2>&1; echo ===; valkey-cli -p 6380 hpexpireat help 2>&1; echo === redis help:; redis-cli -p 6379 hexpire help 2>&1; echo ===; redis-cli -p 6379 hexpireat help 2>&1

66  $ awk '/} else if \(rdbtype == RDB_TYPE_STREAM_LISTPACKS \|\| rdbtype == RDB_TYPE_STREAM_LISTPACKS_2 \|\|/,0' /tmp/valkey_rdb.c | sed -n '1,200p'

67  $ grep -n 'ssize_t rdbSaveLen\|int rdbLoadLen\|uint64_t rdbLoadLen\|rdbSaveMillisecondTime\|rdbLoadMillisecondTime' /tmp/redis_rdb.c | head; echo ====; sed -n '/^int rdbSaveMillisecondTime/,/^}/p' /tmp/redis_rdb.c; echo ====; sed -n '/uint64_t rdbLoadMillisecondTime/,/^}/p' /tmp/redis_rdb.c; echo ==== SAVELEN; sed -n '/ssize_t rdbSaveLen(rio/,/^}/p' /tmp/redis_rdb.c; echo ==== LOADLEN; sed -n '/uint64_t rdbLoadLen(rio/,/^}/p' /tmp/redis_rdb.c

68  $ # syntax tests on both servers
redis-cli -p 6379 hpe xpiretime 2>&1 | head -1
redis-cli -p 6379 HPEXPIRETIME profile:30 FIELDS 3 reset_token otp name
valkey-cli -p 6380 del tst >/dev/null 2>&1; valkey-cli -p 6380 hset tst a 1 b 2
valkey-cli -p 6380 HPEXPIREAT tst 1999999999999 FIELDS 1 a
valkey-cli -p 6380 HPEXPIRETIME tst FIELDS 2 a b
valkey-cli -p 6380 PEXPIREAT tst 1999999999999
valkey-cli -p 6380 PEXPIRETIME tst
valkey-cli -p 6380 del tst >/dev/null
echo ==== restore absttl check:
valkey-cli -p 6380 config get rdb-version-check

69  $ # inventory: parse every stream payload fully (also computes NACK zone & IDMP); assert standard-type payloads are restorable as-is
python3 - <<'EOF'
import redis, struct
r = redis.Redis(port=6379)

class R:
    def __init__(s, b): s.b=b; s.i=0
    def u8(s):
        v=s.b[s.i]; s.i+=1; return v
    def len(s):
        b=s.u8(); t=b>>6
        if t==0: return b&0x3f
        if t==1: return ((b&0x3f)<<8)|s.u8()
        if t==2:
            lo=b&0xff
            if lo==0x80: v=int.from_bytes(s.b[s.i:s.i+4],'big'); s.i+=4; return v
            if lo==0x81: v=int.from_bytes(s.b[s.i:s.i+8],'big'); s.i+=8; return v
            raise ValueError(f'bad 32/64 len byte {lo:#x} at {s.i-1}')
        raise ValueError(f'ENCVAL in length position {b:#x} at {s.i-1}')
    def rawstr(s):
        n=s.len(); v=s.b[s.i:s.i+n]; s.i+=n
        if len(v)!=n: raise ValueError('short string')
        return v
    def ms(s):  # rdbSaveMillisecondTime: 8 raw bytes
        v=s.b[s.i:s.i+8]; s.i+=8; return v
    def sid(s):
        v=s.b[s.i:s.i+16]; s.i+=16; return v
    def rest(s): return len(s.b)-s.i

stats = {'streams':0,'nack_zone_total':0,'idmp_nonzero':[],'groups':0,'consumers':0,'pel':0}
cur=0
while True:
    cur, keys = r.scan(cursor=cur, count=500, _type='stream')
    for k in keys:
        p = r.dump(k)
        assert p[0]==27, (k,p[0])
        body = p[:-8]
        rr = R(body); rr.u8()  # type
        nlp = rr.len()
        for _ in range(nlp):
            rr.rawstr(); rr.rawstr()
        for _ in range(8): rr.len()   # length,last,first,maxdel,entries_added
        ng = rr.len(); stats['groups'] += ng
        for _ in range(ng):
            rr.rawstr()               # group name
            rr.len(); rr.len()        # last id
            rr.len()                  # entries_read
            npel = rr.len(); stats['pel'] += npel
            for _ in range(npel):
                rr.sid(); rr.ms(); rr.len()
            nc = rr.len(); stats['consumers'] += nc
            for _ in range(nc):
                rr.rawstr(); rr.ms(); rr.ms()
                ncpel = rr.len()
                for _ in range(ncpel): rr.sid()
            nack = rr.len(); stats['nack_zone_total'] += nack
            for _ in range(nack): rr.sid()
        idmp_dur = rr.len(); idmp_max = rr.len()
        nprod = rr.len()
        entries = 0
        for _ in range(nprod):
            rr.rawstr()
            c = rr.len(); entries += c
            for _ in range(c):
                rr.rawstr(); rr.len(); rr.len()
        iids_added = rr.len(); iids_dup = rr.len()
        if entries or nprod or iids_added or iids_dup:
            stats['idmp_nonzero'].append((k, nprod, entries, iids_added, iids_dup))
        assert rr.rest()==0, (k, rr.rest(), 'leftover bytes')
        stats['streams'] += 1
    if cur==0: break
print(stats)
EOF

70  $ sed -n '700,772p' /tmp/valkey_rdb.c; echo '======== LOAD HASH_2 (2118-2300) ========'; sed -n '2190,2300p' /tmp/valkey_rdb.c

71  $ grep -n 'rdbSaveRawString\|rdbSaveLzfStringObject\|rdbGenericLoadStringObject' /tmp/redis_rdb.c | head; echo ====; sed -n '/^ssize_t rdbSaveRawString(/,/^}/p' /tmp/redis_rdb.c; echo ==== LZF SAVE; sed -n '/int rdbSaveLzfStringObject(/,/^}/p' /tmp/redis_rdb.c; echo ==== LOAD STRING; sed -n '/rdbGenericLoadStringObject(rio \*rdb, int flags/,/^}/p' /tmp/redis_rdb.c | head -80

72  $ echo '=== valkey rdbLoadMillisecondTime ==='; sed -n '/long long rdbLoadMillisecondTime/,/^}/p' /tmp/valkey_rdb.c; echo '=== redis rdbLoadMillisecondTime ==='; sed -n '/long long rdbLoadMillisecondTime/,/^}/p' /tmp/redis_rdb.c; echo '=== redis rdbSaveMillisecondTime ==='; sed -n '/ssize_t rdbSaveMillisecondTime/,/^}/p' /tmp/redis_rdb.c; echo '=== valkey rdbSaveMillisecondTime ==='; sed -n '/ssize_t rdbSaveMillisecondTime/,/^}/p' /tmp/valkey_rdb.c; echo '=== valkey rdbLoadLenByRef enc handling ==='; sed -n '/int rdbLoadLenByRef/,/^}/p' /tmp/valkey_rdb.c

73  $ # full stream inventory: groups, PEL, consumers, unowned NACKs, idmp stats — raw parsing
python3 - <<'EOF'
import redis
r = redis.Redis(port=6379)
cur=0; report=[]
while True:
    cur, keys = r.scan(cursor=cur, count=500, _type='stream')
    for k in keys:
        si = r.execute_command('XINFO','STREAM',k)
        sd = dict(zip(si[0::2], si[1::2]))
        idmp = {x: sd.get(x) for x in (b'pids-tracked',b'iids-tracked',b'iids-added',b'iids-duplicates',b'idmp-duration',b'idmp-maxsize')}
        gs = r.execute_command('XINFO','GROUPS',k)
        ginfo=[]
        for g in gs:
            gd = dict(zip(g[0::2], g[1::2]))
            cs = r.execute_command('XINFO','CONSUMERS',k,gd[b'name'])
            cinfo=[]
            for c in cs:
                cd = dict(zip(c[0::2], c[1::2])); cinfo.append(cd)
            sum_pending = sum(c[b'pending'] for c in cinfo)
            ginfo.append((gd[b'name'], gd[b'pending'], gd[b'last-delivered-id'], gd.get(b'entries-read'), gd.get(b'lag'), sum_pending, [(c[b'name'],c[b'pending'],c[b'idle'],c[b'inactive']) for c in cinfo]))
        report.append((k, sd[b'length'], sd[b'last-generated-id'], sd[b'max-deleted-entry-id'], sd[b'entries-added'], sd[b'recorded-first-entry-id'], idmp, ginfo))
    if cur==0: break
unowned = 0; idmp_nz = 0
for k,ln,lg,md,ea,rf,idmp,gi in report:
    if any(v not in (0,None) for kk,v in idmp.items() if kk != b'idmp-duration' and kk != b'idmp-maxsize') : idmp_nz += 1; print('IDMP NONZERO', k, idmp)
    for name,pel,lid,er,lag,sump,cons in gi:
        if sump != pel: unowned += 1; print('UNOWNED', k, name, pel, sump)
    print(k.decode(), 'len',ln,'last',lg,'maxdel',md,'added',ea,'first-rec',rf,'groups',len(gi), {kk:idmp[kk] for kk in (b'idmp-duration',b'idmp-maxsize')})
    for name,pel,lid,er,lag,sump,cons in gi:
        print('   grp',name,'pel',pel,'last',lid,'read',er,'lag',lag,'cons',cons)
print('total streams', len(report), 'unowned-nack groups', unowned, 'idmp-nonzero', idmp_nz)
EOF

74  $ grep -n 'rdbSaveSignedInteger\|rdbLoadSignedInteger' /tmp/redis_rdb.c | head; sed -n '/^ssize_t rdbSaveSignedInteger/,/^}/p' /tmp/redis_rdb.c; echo '==== redis rdbLoadSignedInteger ===='; sed -n '/int64_t rdbLoadSignedInteger/,/^}/p' /tmp/redis_rdb.c; echo '==== redis rdbSaveLen ===='; sed -n '/ssize_t rdbSaveLen(rio \*rdb, uint64_t/,/^}/p' /tmp/redis_rdb.c

75  $ python3 - <<'EOF'
import urllib.request
d = urllib.request.urlopen('https://raw.githubusercontent.com/redis/redis/8.10.2/src/lzf_d.c', timeout=30).read().decode()
print(d)
EOF

76  $ # check for functions/modules/other data on source; also stream key TTLs and function list
redis-cli -p 6379 function list; echo ===; redis-cli -p 6379 module list; echo ===; redis-cli -p 6379 info keyspace; echo ===; redis-cli -p 6379 --scan --pattern '*' | while read k; do t=$(redis-cli -p 6379 type "$k"); done; python3 - <<'EOF'
import redis
r = redis.Redis(port=6379)
import collections
c = collections.Counter()
cur=0
while True:
    cur, keys = r.scan(cursor=cur, count=500)
    pipe = r.pipeline(transaction=False)
    for k in keys: pipe.type(k)
    for t in pipe.execute(): c[t]+=1
    if cur==0: break
print(c)
# stream TTLs
for k in r.scan_iter(count=500, _type='stream'):
    print('stream', k, 'pttl', r.pttl(k))
# hfe hash field counts
for k in list(r.scan_iter(count=500, _type='hash'))[:400]:
    p = r.dump(k)
    if p[0]==25:
        n = r.hlen(k)
        print('hfe', k, 'hlen', n)
EOF

77  $ # valkey side: read stream loader validation + HASH_2 load format details
awk '/valid_entries/{print NR": "$0}' /tmp/valkey_rdb.c | head; echo ====; sed -n '2760,2860p' /tmp/valkey_rdb.c; echo '==== HASH_2 SAVE (987-1040) ===='; sed -n '960,1050p' /tmp/valkey_rdb.c

78  $ sed -n '2660,2775p' /tmp/valkey_rdb.c

79  $ echo "--- hpexpireat syntax on valkey:"; valkey-cli -p 6380 del hh; valkey-cli -p 6380 hset hh a 1 b 2 c 3
valkey-cli -p 6380 hpexpireat hh 1999999999999 FIELDS 2 a b
echo "hpexpiretime:"; valkey-cli -p 6380 hpexpiretime hh FIELDS 3 a b c
echo "--- RESTORE ABSTTL test:"; python3 - <<'EOF'
import redis, time
r = redis.Redis(port=6379); v = redis.Redis(port=6380)
v.config_set('rdb-version-check', 'strict')
k = b'session:00865'
p = r.dump(k)
# downgrade footer to version 11
def crc64(data):
    crc=0; poly=0x95AC9329AC4BC9B5
    for b in data:
        crc^=b
        for _ in range(8): crc=(crc>>1)^poly if crc&1 else crc>>1
    return crc
body = bytearray(p[:-8]); body[-2]=11; body[-1]=0
p11 = bytes(body)+crc64(bytes(body)).to_bytes(8,'little')
abs_ms = r.pexpiretime(k)
print('src abs ttl:', abs_ms)
v.delete(k)
v.execute_command('RESTORE', k, 0, p11, 'ABSTTL', abs_ms)
print('dst pexpiretime:', v.pexpiretime(k), 'match:', v.pexpiretime(k)==abs_ms)
v.delete(k)
EOF
echo "--- current valkey config value:"; valkey-cli -p 6380 config get rdb-version-check

80  $ # source unchanged-snapshot & inventory before migration; also min abs TTL; also confirm no writer clients
python3 - <<'EOF'
import redis, hashlib, json, time
r = redis.Redis(port=6379)
snap = {}
min_abs = None
for db in range(16):
    c = redis.Redis(port=6379, db=db)
    if c.dbsize() == 0: continue
    for k in c.scan_iter(count=500):
        pipe = c.pipeline(transaction=False)
        pipe.type(k); pipe.dump(k); pipe.pexpiretime(k)
        t, p, abs_ = pipe.execute()
        snap[f'{db}|{k.decode("latin1")}'] = [t.decode(), abs_, hashlib.sha256(p).hexdigest()]
        if abs_ > 0:
            min_abs = abs_ if min_abs is None else min(min_abs, abs_)
json.dump(snap, open('/tmp/src_snap_before.json','w'))
print('keys snapshotted:', len(snap), 'min abs ttl:', min_abs, 'now:', int(time.time()*1000), 'seconds until min expiry:', None if min_abs is None else (min_abs - time.time()*1000)/1000)
import collections
print(collections.Counter(v[0] for v in snap.values()))
EOF
echo "--- clients on source:"; redis-cli -p 6379 client list | wc -l; redis-cli -p 6379 info stats | grep instantaneous_ops

{
 "examples": {
  "extra": [
   "db0:s",
   "db0:hh"
  ],
  "missing": [
   "db0:profile:30",
   "db0:session:00865",
   "db0:session:00058"
  ]
 },
 "keys_new": {
  "0": 6
 },
 "keys_old": {
  "0": 2960,
  "2": 350
 },
 "mismatch_counts": {
  "extra": 2,
  "field_ttl_added": 0,
  "field_ttl_drift": 0,
  "field_ttl_lost": 0,
  "missing": 3306,
  "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": "8.10.2",
  "server_name": null,
  "valkey_version": null
 },
 "write_probe": "ok"
}

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

2  $ /opt/redis-8.10/bin/redis-cli -p 6379 info server | head -20; echo '==='; command -v valkey-cli redis-cli; valkey-cli -p 6380 info server 2>/dev/null | head -20

3  $ R=/opt/redis-8.10/bin/redis-cli; $R -p 6379 info keyspace; echo '=== dbsize per db'; for i in $(seq 0 15); do n=$($R -p 6379 -n $i dbsize); [ "$n" != "0" ] && echo "db$i=$n"; done; echo '=== total'; $R -p 6379 dbsize

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

5  $ R=/opt/redis-8.10/bin/redis-cli; $R -p 6379 info replication; echo '=== type histogram db0'; $R -p 6379 -n 0 --bigkeys 2>&1 | tail -40; echo '=== db2'; $R -p 6379 -n 2 --bigkeys 2>&1 | tail -30

6  $ R=/opt/redis-8.10/bin/redis-cli; echo '--- type counts db0'; for t in string list set zset hash stream none; do echo -n "$t: "; $R -p 6379 -n 0 --scan --type $t | wc -l; done; echo '--- type counts db2'; for t in string list set zset hash stream; do echo -n "$t: "; $R -p 6379 -n 2 --scan --type $t | wc -l; done; echo '--- streams'; $R -p 6379 -n 0 --scan --type stream; $R -p 6379 -n 2 --scan --type stream

7  $ R=/opt/redis-8.10/bin/redis-cli; echo '--- streams db0'; for k in $($R -p 6379 -n 0 keys '*'); do t=$R; done; $R -p 6379 -n 0 --scan | head -0; python3 - <<'EOF'
EOF
# list stream keys via a simple scan loop
$R -p 6379 -n 0 --scan | while read k; do ty=$R -p 6379 -n 0 type "$k"; [ "$ty" = stream ] && echo "$k"; done

8  $ R=/opt/redis-8.10/bin/redis-cli; echo '--- hash-field TTL keys (subexpiry):'; $R -p 6379 -n 0 --scan | while read k; do ty=$($R -p 6379 -n 0 type "$k"); if [ "$ty" = hash ]; then n=$($R -p 6379 -n 0 hexpiretime "$k" "*" 2>/dev/null | head -1); echo -n ""; fi; done; echo '--- valkey supports HEXPIRE?'; valkey-cli -p 6380 command info hexpire hexpiretime hexpire pexpireat 2>&1 | head -40; echo '--- redis HEXPIRETIME sample'; $R -p 6379 command info hexpiretime

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

10  $ cat /etc/redis-old/redis.conf; echo '=== VALKEY ==='; cat /etc/valkey/valkey.conf; echo '=== dirs ==='; ls -la /var/lib/redis-old /var/lib/valkey

11  $ cd /tmp && cat > survey.py <<'EOF'
import redis, json, time
r = redis.Redis(host='127.0.0.1', port=6379, decode_responses=False, protocol=3)
info = r.info('keyspace'); print('keyspace:', info)
tot=0
streams=[]; subexp=[]
for db in info:
    for k in r.scan_iter(db=db, count=500):
        tot+=1
        if r.type(k, db=db)==b'stream': streams.append((db,k))
print('total keys:', tot)
print('streams:', streams)
# groups
for db,k in streams:
    g = r.xinfo_groups(db=db, name=k)
    print(db, k, 'len=', r.xlen(db=db,name=k), [(x[b'name'], x[b'consumers'], x[b'pending'], x[b'last-delivered-id']) for x in g])
    for grp in g:
        gn = grp[b'name']
        cons = r.xinfo_consumers(db=db, name=k, groupname=gn)
        print('    consumers:', [(c[b'name'], c[b'pending'], c[b'idle'], c[b'in-flight-id']) for c in cons])
# hash field TTLs (HEXPIRE -> subexpiry)
cnt=0; examples=[]
for db in info:
    for k in r.scan_iter(db=db, count=500):
        if r.type(k, db=db)!=b'hash': continue
        fields = r.hkeys(db=db, name=k)
        if not fields: continue
        res = r.execute_command('HTTL', k, 'FIELDS', len(fields), *fields, db=db)
        if any(v is not None and v!=-1 and v!=-2 for v in res):
            cnt+=1; examples.append((db,k,fields,res))
print('hashes with field TTL:', cnt, examples[:10])
EOF
python3 survey.py

12  $ cd /tmp && python3 - <<'EOF'
import redis, time, hashlib
r = redis.Redis(host='127.0.0.1', port=6379, decode_responses=False, protocol=3)
# is source write-active?
a = r.info('stats'); t1=time.time(); 
s1 = r.dbsize()
for db in ('0','2'):
    s1 += r.dbsize(db=db)
time.sleep(3)
info=r.info('keyspace'); s2=0
for db in info: s2+=r.dbsize(db=db)
print('total keys now:', s2)
b = r.info('stats')
print('instantaneous_ops_per_sec:', b.get('instantaneous_ops_per_sec'))
print('keyspace_hits/misses:', b.get('keyspace_hits'), b.get('keyspace_misses'))
print('expired keys total:', b.get('expired_keys'), 'delta over 3s:', b.get('expired_keys')-a.get('expired_keys'))
print('evicted:', b.get('evicted_keys'), 'total_commands_processed:', b.get('total_commands_processed'))
# check for module types
print('modules:', r.info('modules'))
EOF

13  $ cd /tmp && python3 - <<'EOF'
import redis, time
r = redis.Redis(host='127.0.0.1', port=6379, decode_responses=False, protocol=3)
for i in range(4):
    ks = r.info('keyspace')
    print(time.strftime('%H:%M:%S'), ks, 'total=', sum(v['keys'] for v in ks.values()))
    time.sleep(2)
EOF

14  $ tail -30 /var/log/redis-old/redis.log; echo '=== any writers? ==='; ss -tnp | grep 6379

15  $ cd /tmp && cat > survey2.py <<'PY'
import redis, json
def C(db): return redis.Redis(host='127.0.0.1', port=6379, db=db, decode_responses=False, protocol=3)
from collections import Counter
total=Counter(); streams=[]; odd=[]
for db in (0,2,1,3,4,5,6,7,8,9,10,11,12,13,14,15):
    r=C(db)
    keys=list(r.scan_iter(count=1000))
    if not keys: continue
    for k in keys:
        t=r.type(k)
        total[(db,t)]+=1
        if t==b'stream': streams.append((db,k))
        if t not in (b'string',b'list',b'set',b'zset',b'hash',b'stream'): odd.append((db,k,t))
print('type counts:', dict(total))
print('odd types:', odd)
print('streams:', streams)
for db,k in streams:
    r=C(db)
    print(f'--- db{db} {k!r} len={r.xlen(k)} maxlen/approx? info:')
    print('   ', r.xinfo_stream(k))
    for g in r.xinfo_groups(k):
        print('   group:', g)
        try:
            for c in r.xinfo_consumers(k, g[b'name']):
                print('      consumer:', c)
        except Exception as e: print('      cons err', e)
PY
python3 survey2.py

16  $ cd /tmp && python3 - <<'PY'
import redis, time
r = redis.Redis(host='127.0.0.1', port=6379, db=0, decode_responses=False, protocol=3)
# TTL distribution
ttls=[]
for db in (0,2):
    c = redis.Redis(host='127.0.0.1', port=6379, db=db, decode_responses=False, protocol=3)
    for k in c.scan_iter(count=1000):
        t=c.ttl(k)
        if t!=-1: ttls.append((db,k,t))
ttls.sort(key=lambda x:x[2])
print('keys with TTL:', len(ttls))
print('shortest 10:', ttls[:10])
print('longest 5:', ttls[-5:])
# hash field TTLs
print('--- hash field TTLs:')
n=0
for db in (0,2):
    c = redis.Redis(host='127.0.0.1', port=6379, db=db, decode_responses=False, protocol=3)
    for k in c.scan_iter(count=1000):
        if c.type(k)!=b'hash': continue
        f=c.hkeys(k)
        res=c.execute_command('HTTL', k, 'FIELDS', len(f), *f)
        vals=[x for x in res if isinstance(x,int) and x not in (-1,-2)]
        if vals:
            n+=1
            if n<=6: print(f'  db{db} {k!r} fields={len(f)} httl={res}')
print('total hashes with field TTL:', n)
PY

17  $ cd /tmp && cat > snapshot.py <<'PY'
import redis, json, sys, hashlib, pickle

def snap(port, out):
    data = {}
    ks = redis.Redis(host='127.0.0.1', port=port, protocol=3, decode_responses=False).info('keyspace')
    for dbinfo in sorted(ks):
        db = int(dbinfo[2:])
        r = redis.Redis(host='127.0.0.1', port=port, db=db, protocol=3, decode_responses=False)
        keys = sorted(r.scan_iter(count=1000))
        for k in keys:
            t = r.type(k)
            rec = {'type': t.decode(), 'pttl': r.pttl(k)}
            if t == b'string':
                rec['v'] = r.get(k)
            elif t == b'list':
                rec['v'] = r.lrange(k, 0, -1)
            elif t == b'set':
                rec['v'] = sorted(r.smembers(k))
            elif t == b'zset':
                rec['v'] = r.zrange(k, 0, -1, withscores=True)
            elif t == b'hash':
                rec['v'] = r.hgetall(k)
                f = r.hkeys(k)
                rec['httl'] = dict(zip(f, r.execute_command('HTTL', k, 'FIELDS', len(f), *f)))
            elif t == b'stream':
                rec['v'] = r.xrange(k, count=100000)
                rec['last_id'] = r.xinfo_stream(k)[b'last-generated-id']
                rec['groups'] = []
                for g in r.xinfo_groups(k):
                    gname = g[b'name']
                    grp = {'name': gname, 'last_delivered': g[b'last-delivered-id'],
                           'entries_read': g.get(b'entries-read'), 'lag': g.get(b'lag'), 'consumers': []}
                    try:
                        pel = r.xpending_range(k, gname, '-', '+', 100000)
                        grp['pel'] = sorted([(e[b'consumer'], e[b'message-id'], e[b'time-delivered'], e[b'times-delivered']) for e in pel])
                    except Exception as ex:
                        grp['pel'] = f'ERR {ex}'
                    try:
                        for c in r.xinfo_consumers(k, gname):
                            grp['consumers'].append({'name': c[b'name'], 'pending': c[b'pending'],
                                                     'idle': c[b'idle'], 'inflight': c.get(b'in-flight-id'),
                                                     'seen': c.get(b'seen')})
                    except Exception as ex:
                        grp['consumers'].append(f'ERR {ex}')
                    rec['groups'].append(grp)
            else:
                rec['v'] = f'<unhandled type {t}>'
            data[f'{db}|{k.decode(errors="replace")}'] = rec
    with open(out, 'wb') as fh:
        pickle.dump(data, fh, protocol=4)
    print(out, 'keys:', len(data))
    return data

if __name__ == '__main__':
    d = snap(int(sys.argv[1]), sys.argv[2])
    print('digest:', hashlib.sha256(pickle.dumps(d, protocol=4)).hexdigest())
PY
python3 snapshot.py 6379 /tmp/src_before.pkl

18  $ cd /tmp && python3 - <<'PY'
import redis
r = redis.Redis(host='127.0.0.1', port=6379, protocol=3, decode_responses=False)
print('source rdb info:', r.info('persistence'))
print('--- valkey info persistence:', redis.Redis(host='127.0.0.1', port=6380, protocol=3, decode_responses=False).info('persistence'))
PY
echo '=== valkey config keys related to replication ==='; valkey-cli -p 6380 config get 'replica*' ; valkey-cli -p 6380 config get 'master*'; valkey-cli -p 6380 info replication

19  $ cd /tmp && python3 - <<'PY'
import redis
r = redis.Redis(host='127.0.0.1', port=6379, db=0, protocol=3, decode_responses=False)
s = r.xinfo_stream(b'events:18')
print(type(s), list(s.keys())[:6])
g = r.xinfo_groups(b'events:03')
print(type(g[0]), list(g[0].keys()))
c = r.xinfo_consumers(b'events:03', b'workers')
print(c)
PY

20  $ cd /tmp && sed -i "s/rec\['last_id'\] = r.xinfo_stream(k)\[b'last-generated-id'\]/rec['last_id'] = r.xinfo_stream(k).get(b'last-generated-id')/" snapshot.py && python3 snapshot.py 6379 /tmp/src_before.pkl

21  $ cd /tmp && cat > snapshot.py <<'PY'
import redis, sys, pickle, hashlib

def g(d, name):
    """get key from dict that may have str or bytes keys"""
    if name in d: return d[name]
    b = name.encode() if isinstance(name, str) else name.decode()
    if b in d: return b[d] if False else d[b]
    for k in d:
        if k == name or (isinstance(k, (str, bytes)) and (k.decode() if isinstance(k, bytes) else k) == name):
            return d[k]
    return None

def snap(port, out):
    data = {}
    ks = redis.Redis(host='127.0.0.1', port=port, protocol=3, decode_responses=False).info('keyspace')
    for dbinfo in sorted(ks):
        db = int(dbinfo[2:])
        r = redis.Redis(host='127.0.0.1', port=port, db=db, protocol=3, decode_responses=False)
        for k in sorted(r.scan_iter(count=1000)):
            t = r.type(k)
            t = t.decode() if isinstance(t, bytes) else t
            rec = {'type': t, 'pttl': r.pttl(k)}
            if t == 'string':
                rec['v'] = r.get(k)
            elif t == 'list':
                rec['v'] = r.lrange(k, 0, -1)
            elif t == 'set':
                rec['v'] = sorted(r.smembers(k))
            elif t == 'zset':
                rec['v'] = [list(x) for x in r.zrange(k, 0, -1, withscores=True)]
            elif t == 'hash':
                rec['v'] = r.hgetall(k)
                f = r.hkeys(k)
                rec['httl'] = dict(zip(f, r.execute_command('HTTL', k, 'FIELDS', len(f), *f)))
            elif t == 'stream':
                rec['v'] = r.xrange(k, count=100000)
                si = r.xinfo_stream(k)
                rec['last_id'] = g(si, 'last-generated-id')
                rec['max_deleted_entry_id'] = g(si, 'max-deleted-entry-id')
                rec['entries_added'] = g(si, 'entries-added')
                rec['recorded_first_entry_id'] = g(si, 'recorded-first-entry-id')
                rec['groups'] = []
                for grp in r.xinfo_groups(k):
                    gname = g(grp, 'name')
                    out_grp = {'name': gname,
                               'last_delivered': g(grp, 'last-delivered-id'),
                               'entries_read': g(grp, 'entries-read'),
                               'lag': g(grp, 'lag'),
                               'consumers': [], 'pel': []}
                    try:
                        pel = r.xpending_range(k, gname, '-', '+', 100000)
                        out_grp['pel'] = sorted([(g(e, 'consumer'), g(e, 'message-id'),
                                                  g(e, 'time-delivered'), g(e, 'times-delivered'))
                                                 for e in pel])
                    except Exception as ex:
                        out_grp['pel'] = f'ERR {ex}'
                    try:
                        for c in r.xinfo_consumers(k, gname):
                            out_grp['consumers'].append({'name': g(c, 'name'), 'pending': g(c, 'pending'),
                                                        'idle': g(c, 'idle'),
                                                        'inflight': g(c, 'in-flight-id')})
                    except Exception as ex:
                        out_grp['consumers'].append(f'ERR {ex}')
                    rec['groups'].append(out_grp)
            else:
                rec['v'] = f'<unhandled type {t}>'
            kk = k.decode(errors='replace') if isinstance(k, bytes) else k
            data[f'{db}|{kk}'] = rec
    with open(out, 'wb') as fh:
        pickle.dump(data, fh, protocol=4)
    print(out, 'keys:', len(data))
    return data

if __name__ == '__main__':
    d = snap(int(sys.argv[1]), sys.argv[2])
    print('digest:', hashlib.sha256(pickle.dumps(d, protocol=4)).hexdigest())
PY
python3 snapshot.py 6379 /tmp/src_before.pkl

22  $ valkey-cli -p 6380 replicaof 127.0.0.1 6379; sleep 1; for i in $(seq 1 20); do st=$(valkey-cli -p 6380 info replication | grep -E 'role|master_link_status|master_repl_offset'); echo "--- poll $i"; echo "$st"; echo "$st" | grep -q 'master_link_status:up' && break; sleep 1; done; echo '=== loading?'; valkey-cli -p 6380 info persistence | grep -E 'loading|async_loading'; echo '=== dbsize'; valkey-cli -p 6380 dbsize; valkey-cli -p 6380 info keyspace

23  $ cat /var/log/valkey/valkey.log

24  $ tail -5 /var/log/redis-old/redis.log; /opt/redis-8.10/bin/redis-cli -p 6379 info replication | head

25  $ head -c 9 /var/lib/redis-old/dump.rdb | xxd; echo; echo '--- source uptime/replid'; /opt/redis-8.10/bin/redis-cli -p 6379 info server | grep -E 'uptime_in_seconds|run_id'; /opt/redis-8.10/bin/redis-cli -p 6379 info replication | grep -E 'master_replid|role|slave0'; echo '--- valkey version'; valkey-server --version

26  $ cd /tmp && python3 - <<'PY'
import redis
s = redis.Redis(port=6379, db=0, protocol=3, decode_responses=False)
t = redis.Redis(port=6380, db=0, protocol=3, decode_responses=False)
# find a sample string key
k = None
for k in s.scan_iter(count=100):
    if s.type(k)==b'string': break
print('sample key', k)
d = s.dump(k)
print('dump len', len(d), 'payload tail (ver+crc):', d[-8:].hex())
try:
    t.delete(k)
    t.restore(k, 0, d)
    print('RESTORE OK ->', t.get(k))
except Exception as e:
    print('RESTORE FAILED:', e)
# also test with patched version bytes
import binascii, struct
for ver in (15,12,11,10,9):
    p = bytearray(d)
    p[-8] = (ver>>8)&0xff; p[-7]=ver&0xff
    # recompute crc64 is complex; just try without fixing crc -> will report checksum error, distinguishing version check
    try:
        t.delete(k); t.restore(k,0,bytes(p)); print(f'  ver={d[-8:].hex()} patched-> {ver}: OK??')
    except Exception as e:
        print(f'  patched ver {ver}: {e}')
PY
echo '=== valkey command availability ==='
for c in pexpiretime expiretime hpttl hexpiretime hexpireat hpeexpireat hpepireat hpepireat2 xsetid xgroup xclaim xautoclaim debug; do :; done
valkey-cli -p 6380 command info pexpiretime expiretime hpttl hexpiretime hpepireat hpepireat hpepireat 2>&1 | head -5
for c in PEXPIRETIME EXPIRETIME HPTTL HEXPIRETIME HPEXPIREAT HEXPIREAT XSETID XGROUP XCLAIM XAUTOCLAIM OBJECT ENCODING; do printf '%-14s ' "$c"; valkey-cli -p 6380 command info $c | head -1; done

27  $ valkey-cli -p 6380 replicaof NO ONE; valkey-cli -p 6380 flushall; sleep 2; /opt/redis-8.10/bin/redis-cli -p 6379 info replication | grep -E 'role|slave0|connected'; echo '---'; valkey-cli -p 6380 info replication | grep -E 'role|master_link'; valkey-cli -p 6380 info keyspace; echo '--- supported RDB version in valkey binary:'; strings $(command -v valkey-server) | grep -iE "RDB format version|RDB_VERSION" | head; strings $(command -v valkey-server) | grep -nE '^0*1[0-9]$' | head

28  $ cd /tmp && cat > crc64.py <<'PY'
POLY = 0xad93d23594c935a9
tab = []
for i in range(256):
    crc = i
    for _ in range(8):
        crc = (crc >> 1) ^ (POLY if crc & 1 else 0)
    tab.append(crc)
def crc64(crc, data):
    for b in data:
        crc = tab[(crc ^ b) & 0xff] ^ (crc >> 8)
    return crc
PY
python3 - <<'PY'
import redis, sys
sys.path.insert(0,'/tmp')
from crc64 import crc64
r = redis.Redis(port=6379, db=0, protocol=3, decode_responses=False)
for k in r.scan_iter(count=50):
    if r.type(k)==b'string':
        d = r.dump(k); break
print('payload len', len(d))
ver = int.from_bytes(d[-10:-8], 'little')
stored = int.from_bytes(d[-8:], 'little')
calc = crc64(0, d[:-8])
print('version in payload:', ver, 'stored crc:', hex(stored), 'calc:', hex(calc), 'MATCH' if stored==calc else 'MISMATCH')
print('header ascii:', d[:9])
PY

29  $ cd /tmp && python3 - <<'PY'
import redis
s = redis.Redis(port=6379, db=0, protocol=3, decode_responses=False)
t = redis.Redis(port=6380, db=0, protocol=3, decode_responses=False)
types = {}
for k in s.scan_iter(count=200):
    ty = s.type(k)
    types.setdefault(ty, k)
print('sample keys per type:', types)
for ty, k in types.items():
    d = s.dump(k)
    ver = int.from_bytes(d[-10:-8],'little')
    # original
    try:
        t.delete(k); t.restore(k,0,d); res='ORIG OK'
    except Exception as e: res=f'ORIG FAIL: {e}'
    print(f'{ty.decode():8} ver={ver}: {res}')
    if 'OK' not in res:
        for v in (12, 11, 10):
            p = bytearray(d); p[-10:-8] = v.to_bytes(2,'little')
            try:
                t.delete(k); t.restore(k,0,bytes(p)); print(f'    patched ver {v}: OK'); break
            except Exception as e: print(f'    patched ver {v}: {e}')
PY

30  $ cd /tmp && python3 - <<'PY'
# redis crc64 (Jones, reflected) — verify variants
import sys
def mk(poly, init, refin):
    tab=[]
    for i in range(256):
        crc=i
        for _ in range(8):
            if refin:
                crc=(crc>>1)^(poly if crc&1 else 0)
            else:
                crc=((crc<<1)^poly) if crc&0x8000000000000000 else (crc<<1)
            crc &= 0xFFFFFFFFFFFFFFFF
        tab.append(crc)
    def f(crc, data):
        for b in data:
            if refin:
                crc = tab[(crc ^ b) & 0xff] ^ (crc >> 8)
            else:
                crc = tab[((crc >> 56) ^ b) & 0xff] ^ ((crc << 8) & 0xFFFFFFFFFFFFFFFF)
        return crc
    return f
import redis
s=redis.Redis(port=6379,db=0,protocol=3,decode_responses=False)
for k in s.scan_iter(count=50):
    if s.type(k)==b'string': break
d=s.dump(k); payload=d[:-8]; stored=int.from_bytes(d[-8:],'little')
print('stored', hex(stored))
cands = {
 'refl poly ad9': mk(0xad93d23594c935a9,0,True),
 'refl poly 95b': mk(0x95ac9329ac4bc9b5,0,True),
 'nonrefl ad9': mk(0xad93d23594c935a9,0,False),
 'nonrefl 95b': mk(0x95ac9329ac4bc9b5,0,False),
}
for name,f in cands.items():
    for init in (0, 0xFFFFFFFFFFFFFFFF):
        c=f(init,payload)
        print(f'{name} init={hex(init)}: {hex(c)} {"MATCH" if c==stored else ""}')
PY

31  $ cd /tmp && python3 - <<'PY'
import redis, sys
sys.path.insert(0,'/tmp')
def crc64(data):
    poly=0x95ac9329ac4bc9b5
    tab=[]
    for i in range(256):
        c=i
        for _ in range(8):
            c=(c>>1)^(poly if c&1 else 0)
        tab.append(c)
    crc=0
    for b in data: crc = tab[(crc^b)&0xff]^(crc>>8)
    return crc
s=redis.Redis(port=6379,db=0,protocol=3,decode_responses=False)
t=redis.Redis(port=6380,db=0,protocol=3,decode_responses=False)
types={}
for k in s.scan_iter(count=300):
    ty=s.type(k); types.setdefault(ty,k)
for ty,k in types.items():
    d=s.dump(k)
    for v in (12,11,10,9,8):
        p=bytearray(d); p[-10:-8]=v.to_bytes(2,'little')
        cs=crc64(bytes(p[:-8])); p[-8:]=cs.to_bytes(8,'little')
        try:
            t.delete(k); t.restore(k,0,bytes(p))
            print(f'{ty.decode():7} patched v{v}: RESTORE OK, readback=', t.type(k)); break
        except Exception as e:
            print(f'{ty.decode():7} patched v{v}: {e}')
PY

32  $ cd /tmp && python3 - <<'PY'
# What does Valkey itself produce for DUMP, and can Redis read it? Also check valkey's supported RDB version via DEBUG or config
import redis
t=redis.Redis(port=6380,protocol=3,decode_responses=False)
t.set('probe', b'x')
d=t.dump('probe')
print('valkey DUMP ver:', int.from_bytes(d[-10:-8],'little'), 'len', len(d))
try:
    print('valkey debug rdb:', t.execute_command('DEBUG','RDB'))
except Exception as e: print('debug rdb err:', e)
print('valkey info server rdb:', {k:v for k,v in t.info('server').items() if 'rdb' in k or 'version' in k})
t.delete('probe')
PY
valkey-cli -p 6380 info server | grep -iE 'rdb|version'; echo '--- config get rdbversion'; valkey-cli -p 6380 config get rdbversion; valkey-cli -p 6380 config get '*rdb*'

33  $ cd /tmp && python3 - <<'PY'
import redis
s=redis.Redis(port=6379,db=0,protocol=3,decode_responses=False)
t=redis.Redis(port=6380,db=0,protocol=3,decode_responses=False)
# make a valkey stream for comparison
t.delete('cmp'); t.xadd('cmp', {'a':'1'})
dr = None
for k in s.scan_iter(count=300):
    if s.type(k)==b'stream': dr=s.dump(k); kname=k; break
dv = t.dump('cmp')
print('redis stream dump len', len(dr), 'first 4 bytes:', list(dr[:4]), 'type byte:', dr[0])
print('valkey stream dump len', len(dv), 'first 4 bytes:', list(dv[:4]), 'type byte:', dv[0])
print('valkey ver byte:', int.from_bytes(dv[-10:-8],'little'))
# other types type bytes from redis
for k in s.scan_iter(count=300):
    ty=s.type(k)
    if ty in (b'string',b'list',b'zset',b'hash',b'set'):
        print(ty, 'redis type byte:', s.dump(k)[0])
        break
print('--- redis stream dump hex head:', dr[:40].hex())
print('--- valkey stream dump hex head:', dv[:40].hex())
t.delete('cmp')
PY

34  $ valkey-cli -p 6380 command docs xclaim | head -60; echo '=== XSETID ==='; valkey-cli -p 6380 command docs xsetid; echo '=== XGROUP ==='; valkey-cli -p 6380 command docs xgroup | head -40; echo '=== XGROUP CREATE syntax ==='; valkey-cli -p 6380 xgroup help 2>&1 | head; echo '=== XADD ==='; valkey-cli -p 6380 command docs xadd | head -30

35  $ echo '=== valkey xsetid full ==='; valkey-cli -p 6380 command docs xsetid; echo '=== valkey xclaim options ==='; valkey-cli -p 6380 command docs xclaim | sed -n '60,200p'

36  $ cd /tmp && python3 - <<'PY'
import redis
s=redis.Redis(port=6379,protocol=3,decode_responses=False)
print('redis8 pexpiretime:', s.command_info('pexpiretime'))
print('redis8 hexpiretime:', s.command_info('hexpiretime'))
print('redis8 hpexpiretime:', s.command_info('hpexpiretime'))
print('redis8 hpttl:', s.command_info('hpttl'))
print('redis8 hexpires:', s.command_info('hexpire'))
PY
echo '=== valkey hexpiretime/hpexpiretime ==='; valkey-cli -p 6380 command info hpexpiretime | head -3; valkey-cli -p 6380 command info hexpires | head -3; echo '=== valkey hexpireat docs ==='; valkey-cli -p 6380 command docs hexpires | head -20; valkey-cli -p 6380 command docs hpexpireat | head -30

37  $ cd /tmp && python3 - <<'PY'
import redis, time, json
t = redis.Redis(port=6380, db=15, protocol=3, decode_responses=False)
t.flushdb()
# build a test stream
for i in range(10):
    t.xadd('s', {'f':str(i)}, id=f'1000{i}-0')
info = t.xinfo_stream('s'); print('stream info:', {k:v for k,v in info.items() if k in ('length','last-generated-id','entries-added','max-deleted-entry-id','recorded-first-entry-id')})
# XSETID with entriesadded/maxdeletedid
t.xsetid('s', '10009-0', entries_added=25, max_deleted_id='10008-1')
print('after xsetid:', {k:v for k,v in t.xinfo_stream('s').items() if k in ('last-generated-id','entries-added','max-deleted-entry-id')})
# group with entriesread
t.xgroup_create('s', 'g', '10004-0', entries_read=5)
print('group:', t.xinfo_groups('s'))
# create consumer
t.xgroup_createconsumer('s','g','c1')
# deliver some entries into PEL by reading with consumer
t.xreadgroup('GROUP','g','c1',{'s':'>'}, count=3)
print('pending after read:', t.xpending('s','g'))
print('consumers:', t.xinfo_consumers('s','g'))
# now simulate exact claim: TIME + RETRYCOUNT + JUSTID / non-justid
now_ms = int(time.time()*1000)
deliv_time = now_ms - 60000
res = t.xclaim('s','g','c1', 0, '10003-0', idle=60000, time=deliv_time, retrycount=7, justid=True)
print('claim justid:', res)
print('pending after claim justid:', t.xpending_range('s','g','-','+',count=100))
print('consumers after:', t.xinfo_consumers('s','g'))
res2 = t.xclaim('s','g','c2', 0, '10002-0', idle=120000, time=now_ms-120000, retrycount=3, force=True, lastid='10004-0')
print('claim nonjustid:', res2)
print('pending:', t.xpending_range('s','g','-','+',count=100))
print('consumers:', t.xinfo_consumers('s','g'))
print('groups:', t.xinfo_groups('s'))
PY

38  $ cd /tmp && python3 - <<'PY'
import redis, time
s = redis.Redis(port=6379, db=0, protocol=3, decode_responses=False)
print('now:', int(time.time()))
for k in (b'profile:12', b'session:01085'):
    print(k, 'pttl(ms):', s.pttl(k), 'pexpiretime:', s.pexpiretime(k), 'expiretime:', s.expiretime(k))
    if s.type(k)==b'hash':
        f = s.hkeys(k)
        print('  HPTTL:', s.execute_command('HPTTL', k, 'FIELDS', len(f), *f))
        print('  HEXPIRETIME:', s.execute_command('HEXPIRETIME', k, 'FIELDS', len(f), *f))
        print('  HPEXPIRETIME:', s.execute_command('HPEXPIRETIME', k, 'FIELDS', len(f), *f))
# check xpending raw structure
p = s.xpending_range(b'events:03', b'workers', '-', '+', count=100)
print('xpending entry:', p[0] if p else None, 'count:', len(p))
print('xinfo consumers:', s.xinfo_consumers(b'events:03', b'workers'))
PY

39  $ cd /tmp && python3 - <<'PY'
import redis, time
t = redis.Redis(port=6380, db=15, protocol=3, decode_responses=False)
t.flushdb()
for i in range(10):
    t.xadd('s', {'f':str(i)}, id=f'1000{i}-0')
# XSETID with entries_added + max_deleted_id (maxdeleted id must be <=? try 10009-0)
try:
    t.execute_command('XSETID','s','10009-0','ENTRIESADDED',25,'MAXDELETEDID','10009-1')
    print('xsetid ok:', {k:v for k,v in t.xinfo_stream('s').items() if k in ('last-generated-id','entries-added','max-deleted-entry-id','length')})
except Exception as e:
    print('xsetid err:', e)
t.xgroup_create('s','g','10004-0', entries_read=5)
t.xgroup_createconsumer('s','g','c1')
t.xreadgroup('GROUP','g','c1',{'s':'>'}, count=3)
print('groups:', t.xinfo_groups('s'))
print('pending:', t.xpending_range('s','g','-','+',count=100))
now=int(time.time()*1000)
# claim remaining ids to c1 with specific idle/time/retrycount (non-JUSTID to also set lastid)
res=t.execute_command('XCLAIM','s','g','c1',0,'10003-0','IDLE',60000,'TIME',now-60000,'RETRYCOUNT',7,'FORCE','LASTID','10004-0')
print('claim nonjustid:', res)
res=t.execute_command('XCLAIM','s','g','c2',0,'10001-0','IDLE',120000,'TIME',now-120000,'RETRYCOUNT',3,'JUSTID')
print('claim justid:', res)
print('consumers:', t.xinfo_consumers('s','g'))
print('pending:', t.xpending_range('s','g','-','+',count=100))
print('groups:', t.xinfo_groups('s'))
print('stream info:', {k:v for k,v in t.xinfo_stream('s').items() if k in ('last-generated-id','entries-added','max-deleted-entry-id','length','recorded-first-entry-id')})
PY

40  $ cd /tmp && python3 - <<'PY'
import redis, time
t = redis.Redis(port=6380, db=15, protocol=3, decode_responses=False)
t.flushdb()
# hash field expiry test
t.hset('h', mapping={'a':'1','b':'2','c':'3'})
deadline = int(time.time()*1000) + 50000
t.execute_command('HPEXPIREAT','h','FIELDS',3,'a','b', deadline, 'NX')
print('HPEXPIRETIME:', t.execute_command('HPEXPIRETIME','h','FIELDS',3,'a','b','c'))
print('HTTL:', t.execute_command('HTTL','h','FIELDS',3,'a','b','c'))
# whole key pexpireat
t.set('k','v'); t.pexpireat('k', deadline)
print('k pexpiretime:', t.pexpiretime('k'), 'expected', deadline)
# set with NX on existing field (condition)
try:
    t.execute_command('HPEXPIREAT','h','FIELDS',1,'a', deadline+1000,'XX')
    print('XX applied:', t.execute_command('HPEXPIRETIME','h','FIELDS',1,'a'))
except Exception as e: print('XX err:', e)
# check empty-hash semantics: what if we set field expiry before value? (not needed)
# stream with only XSETID (no entries) - does it create the key?
try:
    t.execute_command('XSETID','empty','5-0','ENTRIESADDED',7,'MAXDELETEDID','4-0')
    print('empty stream xsetid ok, exists=', t.exists('empty'), 'info=', t.xinfo_stream('empty'))
except Exception as e: print('xsetid on nonexistent key err:', e)
PY

41  $ cd /tmp && python3 - <<'PY'
import redis, time
t = redis.Redis(port=6380, db=15, protocol=3, decode_responses=False)
t.flushdb()
for i in range(10):
    t.xadd('s', {'f':str(i)}, id=f'1000{i}-0')
t.execute_command('XSETID','s','10009-0','ENTRIESADDED',25,'MAXDELETEDID','10009-0')
print('xsetid:', {k:v for k,v in t.xinfo_stream('s').items() if k in ('last-generated-id','entries-added','max-deleted-entry-id','length')})
t.xgroup_create('s','g','10004-0', entries_read=5)
t.xgroup_createconsumer('s','g','c1')
t.execute_command('XREADGROUP','GROUP','g','c1','COUNT',3,'STREAMS','s','>')
print('groups:', t.xinfo_groups('s'))
print('pending:', t.xpending_range('s','g','-','+',count=100))
now=int(time.time()*1000)
r1=t.execute_command('XCLAIM','s','g','c1',0,'10003-0','IDLE',60000,'TIME',now-60000,'RETRYCOUNT',7,'FORCE','LASTID','10004-0')
r2=t.execute_command('XCLAIM','s','g','c2',0,'10001-0','IDLE',120000,'TIME',now-120000,'RETRYCOUNT',3,'JUSTID')
print('claims:', r1, r2)
print('consumers:', t.xinfo_consumers('s','g'))
print('pending:', t.xpending_range('s','g','-','+',count=100))
print('groups:', t.xinfo_groups('s'))
# empty stream via XSETID
try:
    t.execute_command('XSETID','empty','5-0','ENTRIESADDED',7,'MAXDELETEDID','4-0')
    print('xsetid-created stream:', t.exists('empty'), t.type('empty'), t.xinfo_stream('empty'))
except Exception as e: print('empty xsetid err:', e)
# group on empty stream
PY

42  $ cd /tmp && python3 - <<'PY'
import redis, time
t = redis.Redis(port=6380, db=15, protocol=3, decode_responses=False)
t.flushall()
t.hset('h', mapping={'a':'1','b':'2','c':'3'})
deadline = int(time.time()*1000) + 50000
print('set:', t.execute_command('HPEXPIREAT','h','FIELDS',3,'a','b','c',deadline))
print('HPEXPIRETIME:', t.execute_command('HPEXPIRETIME','h','FIELDS',3,'a','b','c'), 'expected', deadline)
print('HTTL:', t.execute_command('HTTL','h','FIELDS',3,'a','b','c'))
print('XX on a:', t.execute_command('HPEXPIREAT','h','FIELDS',1,'a',deadline+1000,'XX'))
print('HPEXPIRETIME after XX:', t.execute_command('HPEXPIRETIME','h','FIELDS',3,'a','b','c'))
print('NX on a (should not change):', t.execute_command('HPEXPIREAT','h','FIELDS',1,'a',deadline+99999,'NX'))
print('HPEXPIRETIME after NX:', t.execute_command('HPEXPIRETIME','h','FIELDS',1,'a'))
# whole-key
t.set('k','v'); t.pexpireat('k', deadline)
print('k pexpiretime:', t.pexpiretime('k'), '==', deadline)
# also test HEXPIREAT (seconds granularity) fallback? not needed
# set of hash field expiry where field already has no TTL -> NX works (no ttl) 
t.hset('h2', mapping={'x':'1'})
print('NX on fresh field:', t.execute_command('HPEXPIREAT','h2','FIELDS',1,'x',deadline))
print('h2 times:', t.execute_command('HPEXPIRETIME','h2','FIELDS',1,'x'))
PY

43  $ cd /tmp && python3 - <<'PY'
import redis, time
t = redis.Redis(port=6380, db=15, protocol=3, decode_responses=False)
t.flushall()
for i in range(10): t.xadd('s', {'f':str(i)}, id=f'1000{i}-0')
# A: raw XGROUP CREATE with ENTRIESREAD
t.execute_command('XGROUP','CREATE','s','g','10004-0','ENTRIESREAD',5)
g = t.xinfo_groups('s')
print('A after create:', g)
# read 3 messages (increments entries-read?)
t.execute_command('XREADGROUP','GROUP','g','g1','COUNT',3,'STREAMS','s','>')
print('A after read:', t.xinfo_groups('s'))
# D: FORCE claim for id NOT in PEL, non-JUSTID
now=int(time.time()*1000)
r = t.execute_command('XCLAIM','s','g','g2',0,'10001-0','IDLE',77000,'TIME',now-77000,'RETRYCOUNT',4,'FORCE')
print('D FORCE claim:', r)
print('D pending:', t.xpending_range('s','g','-','+',count=100))
print('D consumers:', t.xinfo_consumers('s','g'))
print('D groups:', t.xinfo_groups('s'))
# B: fresh consumer claimed with past TIME -> its idle?
r = t.execute_command('XCLAIM','s','g','g3',0,'10000-0','IDLE',55000,'TIME',now-55000,'RETRYCOUNT',9,'FORCE')
print('B claim:', r)
print('B consumers:', t.xinfo_consumers('s','g'))
time.sleep(1.5)
print('B consumers after 1.5s:', t.xinfo_consumers('s','g'))
PY

44  $ cd /tmp && python3 - <<'PY'
import redis, sys
def crc64(data):
    poly=0x95ac9329ac4bc9b5; tab=[]
    for i in range(256):
        c=i
        for _ in range(8): c=(c>>1)^(poly if c&1 else 0)
        tab.append(c)
    crc=0
    for b in data: crc=tab[(crc^b)&0xff]^(crc>>8)
    return crc
s=redis.Redis(port=6379,db=0,protocol=3,decode_responses=False)
t=redis.Redis(port=6380,db=0,protocol=3,decode_responses=False)
k=b'profile:12'
d=s.dump(k)
print('src contents:', s.hgetall(k))
print('src HPEXPIRETIME:', s.execute_command('HPEXPIRETIME',k,'FIELDS',6,*s.hkeys(k)))
p=bytearray(d); p[-10:-8]=(11).to_bytes(2,'little')
p[-8:]=crc64(bytes(p[:-8])).to_bytes(8,'little')
t.delete(k)
try:
    t.restore(k,0,bytes(p))
    print('RESTORE OK ->', t.hgetall(k))
    f=t.hkeys(k)
    print('tgt HPEXPIRETIME:', t.execute_command('HPEXPIRETIME',k,'FIELDS',len(f),*f))
except Exception as e:
    print('RESTORE FAILED:', e)
t.delete(k)
PY

45  $ cd /tmp && python3 - <<'PY'
import pickle
d = pickle.load(open('/tmp/src_before.pkl','rb'))
dbs = sorted({int(k.split('|')[0]) for k in d}); print('dbs with keys:', dbs)
streams = {k:v for k,v in d.items() if v['type']=='stream'}
print('streams:', len(streams))
for k,v in streams.items():
    ids = [e[0] for e in v['v']]
    first = ids[0] if ids else None
    rf = v['recorded_first_entry_id']
    pel_ids = [p[1] for g in v['groups'] for p in g['pel']]
    missing = [p for p in pel_ids if p not in ids]
    print(f"{k}: len={len(ids)} lastgen={v['last_id']} entries_added={v['entries_added']} maxdel={v['max_deleted_entry_id']} rec_first={rf} first_id={first} match={rf==first} pttl={v['pttl']} pel={len(pel_ids)} missing_pel={missing}")
    for g in v['groups']:
        print(f"    group {g['name']}: ldi={g['last_delivered']} entries_read={g['entries_read']} lag={g['lag']} consumers={[(c['name'] if isinstance(c,dict) else c) for c in g['consumers']]} pel={g['pel'][:3]}{'...' if len(g['pel'])>3 else ''}")
# key ttls by type
from collections import Counter
c = Counter()
for k,v in d.items():
    if v['pttl'] not in (-1,-2): c[v['type']] += 1
print('keys with TTL by type:', dict(c))
# hash with both field ttl and key ttl
both = [k for k,v in d.items() if v['type']=='hash' and any(x not in (-1,-2) for x in v['httl'].values()) and v['pttl'] not in (-1,-2)]
print('hash with field TTL and key TTL:', both)
# any unhandled
print('unhandled:', [k for k,v in d.items() if str(v['v']).startswith('<unhandled')])
PY

46  $ valkey-cli -p 6380 config get save; valkey-cli -p 6380 config get replicaof; valkey-cli -p 6380 config get replica-read-only; echo '--- source config get save/replicaof:'; /opt/redis-8.10/bin/redis-cli -p 6379 config get save; /opt/redis-8.10/bin/redis-cli -p 6379 config get replicaof; echo '--- target dir'; ls -la /var/lib/valkey; echo '--- valkey log tail'; tail -3 /var/log/valkey/valkey.log

47  $ cd /tmp && cat > snapshot.py <<'PY'
import redis, sys, pickle, hashlib, time

def g(d, name):
    if name in d: return d[name]
    b = name.encode() if isinstance(name, str) else name
    if b in d: return d[b]
    for k in d:
        kk = k.decode() if isinstance(k, bytes) else k
        if kk == name: return d[k]
    return None

def snap(port, out, dbs=(0,2)):
    data = {}
    t0 = time.time()
    for db in dbs:
        r = redis.Redis(host='127.0.0.1', port=port, db=db, protocol=3, decode_responses=False)
        for k in sorted(r.scan_iter(count=1000)):
            t = r.type(k); t = t.decode() if isinstance(t, bytes) else t
            rec = {'type': t, 'pexpiretime': r.pexpiretime(k)}
            if t == 'string': rec['v'] = r.get(k)
            elif t == 'list': rec['v'] = r.lrange(k, 0, -1)
            elif t == 'set': rec['v'] = sorted(r.smembers(k))
            elif t == 'zset': rec['v'] = [list(x) for x in r.zrange(k, 0, -1, withscores=True)]
            elif t == 'hash':
                rec['v'] = r.hgetall(k)
                f = r.hkeys(k)
                rec['httl'] = dict(zip(f, r.execute_command('HPEXPIRETIME', k, 'FIELDS', len(f), *f)))
            elif t == 'stream':
                rec['v'] = r.xrange(k, count=100000)
                si = r.xinfo_stream(k)
                rec['last_id'] = g(si, 'last-generated-id')
                rec['max_deleted_entry_id'] = g(si, 'max-deleted-entry-id')
                rec['entries_added'] = g(si, 'entries-added')
                rec['recorded_first_entry_id'] = g(si, 'recorded-first-entry-id')
                rec['groups'] = []
                for grp in r.xinfo_groups(k):
                    gname = g(grp, 'name')
                    og = {'name': gname, 'last_delivered': g(grp, 'last-delivered-id'),
                          'entries_read': g(grp, 'entries-read'), 'lag': g(grp, 'lag'),
                          'consumers': [], 'pel': []}
                    try:
                        pel = r.xpending_range(k, gname, '-', '+', 100000)
                        og['pel'] = sorted([(g(e, 'consumer'), g(e, 'message_id'),
                                             g(e, 'time_since_delivered'), g(e, 'times_delivered')) for e in pel])
                    except Exception as ex: og['pel'] = f'ERR {ex}'
                    try:
                        for c in r.xinfo_consumers(k, gname):
                            og['consumers'].append({'name': g(c, 'name'), 'pending': g(c, 'pending'),
                                                    'idle': g(c, 'idle'), 'inactive': g(c, 'inactive')})
                    except Exception as ex: og['consumers'].append(f'ERR {ex}')
                    rec['groups'].append(og)
            else: rec['v'] = f'<unhandled {t}>'
            data[f'{db}|{k.decode(errors="replace")}'] = rec
    with open(out, 'wb') as fh: pickle.dump({'t0': t0, 't1': time.time(), 'keys': data}, fh, protocol=4)
    print(out, 'keys:', len(data))
    return data

if __name__ == '__main__':
    d = snap(int(sys.argv[1]), sys.argv[2])
    print('digest:', hashlib.sha256(pickle.dumps(d, protocol=4)).hexdigest())
PY
python3 snapshot.py 6379 /tmp/src_before.pkl

48  $ valkey-cli -p 6380 command docs hpexpireat; echo '=== hexpires ==='; valkey-cli -p 6380 command docs hexpires | sed -n '1,60p'

49  $ cd /tmp && python3 - <<'PY'
import redis, time
t = redis.Redis(port=6380, db=15, protocol=3, decode_responses=False)
t.flushall()
# HPEXPIREAT correct order: key ms [cond] FIELDS n field...
t.hset('h', mapping={'a':'1','b':'2','c':'3'})
dl = int(time.time()*1000)+50000
r = t.execute_command('HPEXPIREAT','h',dl,'FIELDS',3,'a','b','c')
print('HPEXPIREAT ok:', r, '->', t.execute_command('HPEXPIRETIME','h','FIELDS',3,'a','b','c'), 'expected', dl)
# one field at a time
r = t.execute_command('HPEXPIREAT','h',dl+7,'FIELDS',1,'c')
print('single:', r, t.execute_command('HPEXPIRETIME','h','FIELDS',1,'c'))
# empty stream reconstruction
for i in range(3): t.xadd('e', {'x':str(i)}, id=f'100{i}-0')
ids=[f'100{i}-0' for i in range(3)]
for i in ids: t.xdelete('e', i)
print('after del: len', t.xlen('e'), 'info', {k:v for k,v in t.xinfo_stream('e').items() if k in ('length','last-generated-id','entries-added','max-deleted-entry-id','recorded-first-entry-id')})
t.execute_command('XSETID','e','1002-0','ENTRIESADDED',3,'MAXDELETEDID','0-0')
print('after xsetid:', {k:v for k,v in t.xinfo_stream('e').items() if k in ('length','last-generated-id','entries-added','max-deleted-entry-id','recorded-first-entry-id')})
# CREATECONSUMER idempotent + on 0-pending consumer
t.xgroup_create('e','g','1001-0', entries_read=None)
print('createconsumer new:', t.execute_command('XGROUP','CREATECONSUMER','e','g','zero'))
print('createconsumer again:', t.execute_command('XGROUP','CREATECONSUMER','e','g','zero'))
print('consumers:', t.xinfo_consumers('e','g'))
print('groups:', t.xinfo_groups('e','g'))
PY

50  $ cd /tmp && python3 - <<'PY'
import pickle
d = pickle.load(open('/tmp/src_before.pkl','rb'))['keys']
# any stream with 0 entries? any pel id not in stream?
empty_streams=[k for k,v in d.items() if v['type']=='stream' and not v['v']]
print('empty streams:', empty_streams)
missing=[]
for k,v in d.items():
    if v['type']!='stream': continue
    ids={e[0] for e in v['v']}
    for g in v['groups']:
        for pel in g['pel']:
            if pel[1] not in ids: missing.append((k,g['name'],pel))
print('pel ids not in stream:', missing)
# group/consumer/pel stats
ng=sum(len(v['groups']) for v in d.values() if v['type']=='stream')
npel=sum(len(g['pel']) for v in d.values() if v['type']=='stream' for g in v['groups'])
nc=sum(len(g['consumers']) for v in d.values() if v['type']=='stream' for g in v['groups'])
print('groups:',ng,'pel entries:',npel,'consumers:',nc)
# consumers with 0 pending?
zero=[(k,g['name'],c) for k,v in d.items() if v['type']=='stream' for g in v['groups'] for c in g['consumers'] if isinstance(c,dict) and c['pending']==0]
print('zero-pending consumers:', zero)
# entries_read None groups
print('groups with entries_read None:', [(k,g['name'],g['lag']) for k,v in d.items() if v['type']=='stream' for g in v['groups'] if g['entries_read'] is None])
# pexpiretime == -2 anywhere?
print('pexpiretime -2:', [k for k,v in d.items() if v['pexpiretime']==-2])
# sample pel entry structure
s=[k for k,v in d.items() if v['type']=='stream'][0]
print('sample group:', d[s]['groups'][0])
PY

51  $ cd /tmp && python3 - <<'PY'
import redis, time
t = redis.Redis(port=6380, db=15, protocol=3, decode_responses=False)
t.flushall()
for i in range(3): t.xadd('e', {'x':str(i)}, id=f'100{i}-0')
for i in range(3): t.execute_command('XDEL','e',f'100{i}-0')
print('after del len:', t.xlen('e'), {k:v for k,v in t.xinfo_stream('e').items() if k in ('length','last-generated-id','entries-added','max-deleted-entry-id','recorded-first-entry-id')})
t.execute_command('XSETID','e','1002-0','ENTRIESADDED',3,'MAXDELETEDID','0-0')
print('after xsetid:', {k:v for k,v in t.xinfo_stream('e').items() if k in ('length','last-generated-id','entries-added','max-deleted-entry-id','recorded-first-entry-id')})
# group create without entriesread (pass None) and with entries_read None semantics
t.execute_command('XGROUP','CREATE','e','g','1001-0','ENTRIESREAD',2)
print('group:', t.xinfo_groups('e'))
print('createconsumer new:', t.execute_command('XGROUP','CREATECONSUMER','e','g','zero'))
print('createconsumer again:', t.execute_command('XGROUP','CREATECONSUMER','e','g','zero'))
print('consumers:', t.xinfo_consumers('e','g'))
# XSETID on truly nonexistent key
try: t.execute_command('XSETID','noid','5-0','ENTRIESADDED',1,'MAXDELETEDID','0-0')
except Exception as e: print('xsetid nonexistent:', e)
# raw XGROUP CREATE for entries_read=None case: omit ENTRIESREAD token
t.delete('e2'); t.xadd('e2',{'x':'1'},id='1-0')
t.execute_command('XGROUP','CREATE','e2','g2','1-0')
print('g2 (no ENTRIESREAD):', t.xinfo_groups('e2'))
PY

52  $ cd /tmp && python3 - <<'PY'
import pickle, time
snap = pickle.load(open('/tmp/src_before.pkl','rb'))
d = snap['keys']
print('snapshot window:', snap['t1']-snap['t0'], 'sec')
both=[]; field_only=[]; key_only=[]
for k,v in d.items():
    if v['type']=='hash':
        has_field = any(x not in (-1,-2) for x in v['httl'].values())
        has_key = v['pexpiretime'] > 0
        if has_field and has_key: both.append(k)
        elif has_field: field_only.append(k)
        elif has_key: key_only.append(k)
print('hash both:', len(both), 'field_only:', len(field_only), 'key_only:', len(key_only))
ttls = sorted(v['pexpiretime'] for v in d.values() if v['pexpiretime']>0)
print('key TTL count:', len(ttls), 'min:', time.ctime(ttls[0]/1000), 'max:', time.ctime(ttls[-1]/1000))
ftt = sorted(x for v in d.values() if v['type']=='hash' for x in v['httl'].values() if x>0)
print('field TTL count:', len(ftt), 'min:', time.ctime(ftt[0]/1000), 'max:', time.ctime(ftt[-1]/1000))
# field deadlines grouped per hash
from collections import defaultdict
for k in field_only[:5]:
    g=defaultdict(list)
    for f,t in d[k]['httl'].items():
        if t>0: g[t].append(f)
    print(k, dict(g))
print('any unhandled type:', [k for k,v in d.items() if str(v['v']).startswith('<unhandled')])
print('total keys:', len(d))
PY

53  $ cd /tmp && python3 - <<'PY'
import redis, time
t = redis.Redis(port=6380, db=15, protocol=3, decode_responses=False)
t.flushall()
for i in range(10): t.xadd('s', {'f':str(i)}, id=f'1000{i}-0')
t.execute_command('XGROUP','CREATE','s','g','10009-0')
# consumer c1 with 2 pending, seen "17 minutes ago" in source terms
now = int(time.time()*1000)
past = now - 1033961
r=t.execute_command('XCLAIM','s','g','c1',0,'10001-0','TIME',past,'RETRYCOUNT',1,'FORCE')
print('claim1:', r, 'consumers:', t.xinfo_consumers('s','g'))
r=t.execute_command('XCLAIM','s','g','c1',0,'10002-0','TIME',past,'RETRYCOUNT',1,'FORCE')
print('claim2 (existing consumer, past TIME):')
print('  consumers:', t.xinfo_consumers('s','g'))
print('  pending:', t.xpending_range('s','g','-','+',count=10))
# try JUSTID variant
r=t.execute_command('XCLAIM','s','g','c1',0,'10001-0','TIME',past,'JUSTID')
print('claim3 justid:', r, 'consumers:', t.xinfo_consumers('s','g'))
# try IDLE variant on existing consumer
r=t.execute_command('XCLAIM','s','g','c1',0,'10002-0','IDLE',1033961,'JUSTID')
print('claim4 idle:', r, 'consumers:', t.xinfo_consumers('s','g'))
# xautoclaim?
try:
    print('xautoclaim:', t.execute_command('XAUTOCLAIM','s','g','c1',0,'0-0','COUNT',5))
    print('  consumers:', t.xinfo_consumers('s','g'))
except Exception as e: print('xa err:', e)
PY

54  $ valkey-cli -p 6380 config get rdb-version-check; echo '---'; valkey-cli -p 6380 command docs debug 2>/dev/null | head -5; echo '--- check valkey help/debug enable'; grep -r "enable-debug" /etc/valkey/ 2>/dev/null; valkey-cli -p 6380 config get enable-debug-command

55  $ cd /tmp && python3 - <<'PY'
import redis, time
t = redis.Redis(port=6380, db=15, protocol=3, decode_responses=False)
t.flushall()
for i in range(6): t.xadd('s', {'f':str(i)}, id=f'1000{i}-0')
t.execute_command('XGROUP','CREATE','s','g','10005-0','ENTRIESREAD',3)
now=int(time.time()*1000)
t.execute_command('XCLAIM','s','g','c1',0,'10001-0','TIME',now-500000,'RETRYCOUNT',2,'FORCE')
t.execute_command('XCLAIM','s','g','c1',0,'10002-0','TIME',now-400000,'RETRYCOUNT',1,'FORCE')
t.execute_command('XGROUP','CREATECONSUMER','s','g','c2')  # never seen
time.sleep(0.2)
tr = int(time.time()*1000)
cons = t.xinfo_consumers('s','g')
print('consumers:', cons)
for c in cons:
    idle=c['idle']
    if idle>=0:
        seen = tr - idle
        print(f"  {c['name']}: idle={idle} -> seen_time={seen} (0x{seen.to_bytes(8,'little').hex()})")
d = t.dump('s')
print('payload len', len(d), 'ver', int.from_bytes(d[-10:-8],'little'))
for c in cons:
    idle=c['idle']
    if idle>=0:
        seen = tr - idle
        b = seen.to_bytes(8,'little')
        offs=[]
        i=d.find(b)
        while i!=-1: offs.append(i); i=d.find(b,i+1)
        print(f"  offsets of seen {c['name']} {seen}: {offs}")
# also check group/pel info
print('pending:', t.xpending_range('s','g','-','+',count=10))
print('groups:', t.xinfo_groups('s'))
print('stream info:', {k:v for k,v in t.xinfo_stream('s').items() if k in ('length','last-generated-id','entries-added','max-deleted-entry-id','recorded-first-entry-id')})
# xinfo consumers twice to see if idle resets
time.sleep(0.5)
print('idle again:', t.xinfo_consumers('s','g'))
time.sleep(0.5)
print('idle again2:', t.xinfo_consumers('s','g'))
PY

56  $ cd /tmp && python3 - <<'PY'
import redis, time
t = redis.Redis(port=6380, db=15, protocol=3, decode_responses=False)
t.flushall()
for i in range(6): t.xadd('s', {'f':str(i)}, id=f'1000{i}-0')
t.execute_command('XGROUP','CREATE','s','g','10005-0','ENTRIESREAD',3)
now=int(time.time()*1000)
t.execute_command('XCLAIM','s','g','c1',0,'10001-0','TIME',now-500000,'RETRYCOUNT',2,'FORCE')
t.execute_command('XCLAIM','s','g','c1',0,'10002-0','TIME',now-400000,'RETRYCOUNT',1,'FORCE')
t.execute_command('XGROUP','CREATECONSUMER','s','g','c2')
time.sleep(0.05)
d = t.dump('s')
payload = d[:-10]  # strip ver+crc
i = payload.find(b'c1')
print('payload len', len(payload))
print('around c1:', payload[i-40:i+40].hex())
j = payload.find(b'c2')
print('around c2:', payload[j-40:j+40].hex())
print('ascii:', ''.join(chr(c) if 32<=c<127 else '.' for c in payload))
PY

57  $ cd /tmp && python3 - <<'PY'
# check redis 8.10 dump of stream with groups - same structure?
import redis, time
s = redis.Redis(port=6379, db=0, protocol=3, decode_responses=False)
d = s.dump(b'events:03')
payload = d[:-10]
i = payload.find(b'workers')
print('redis stream payload len', len(payload))
print('around workers:', payload[i-30:i+90].hex())
j = payload.find(b'w1')
print('around w1:', payload[j-40:j+60].hex())
print('ascii:', ''.join(chr(c) if 32<=c<127 else '.' for c in payload[:400]))
# what's the seen_time? we know idle at snapshot time
print('xinfo consumers now:', s.xinfo_consumers(b'events:03', b'workers'))
print('now ms:', int(time.time()*1000))
PY

58  $ valkey-cli -p 6380 config set rdb-version-check bogus_value; echo '---'; valkey-cli -p 6380 config set rdb-version-check none; valkey-cli -p 6380 config set rdb-version-check warn; valkey-cli -p 6380 config set rdb-version-check no; valkey-cli -p 6380 config get rdb-version-check; valkey-cli -p 6380 config set rdb-version-check strict; valkey-cli -p 6380 config get rdb-version-check

59  $ grep -rn "rdb-version-check\|rdb_version_check" /usr/local/ 2>/dev/null | head; ls /usr/local/bin/; echo '--- valkey-server strings unavailable; try python scan for enum values'; python3 - <<'PY'
data=open('/usr/local/bin/valkey-server','rb').read()
import re
for m in re.finditer(rb'rdb[-_]version[-_]check', data):
    print(m.start(), data[m.start()-100:m.start()+200])
PY

60  $ valkey-cli -p 6380 config set rdb-version-check relaxed; valkey-cli -p 6380 config set rdbcompression yes; valkey-cli -p 6380 replicaof 127.0.0.1 6379; for i in $(seq 1 25); do st=$(valkey-cli -p 6380 info replication | grep -E '^role|master_link_status'); echo "poll $i: $st" | tr '\n' ' '; echo; echo "$st" | grep -q 'master_link_status:up' && break; sleep 1; done; echo '=== valkey log tail'; tail -25 /var/log/valkey/valkey.log; echo '=== dbsize'; valkey-cli -p 6380 dbsize; valkey-cli -p 6380 info keyspace

61  $ cd /tmp && python3 - <<'PY'
import redis, sys, time
sys.path.insert(0,'/tmp')
def crc64(data):
    poly=0x95ac9329ac4bc9b5; tab=[]
    for i in range(256):
        c=i
        for _ in range(8): c=(c>>1)^(poly if c&1 else 0)
        tab.append(c)
    crc=0
    for b in data: crc=tab[(crc^b)&0xff]^(crc>>8)
    return crc
s=redis.Redis(port=6379,db=0,protocol=3,decode_responses=False)
t=redis.Redis(port=6380,db=15,protocol=3,decode_responses=False)
t.flushall()
# pick one key per (type, special-variant)
picks={}
for k in s.scan_iter(count=500):
    ty=s.type(k); ty=ty.decode()
    key=(ty,)
    if ty=='hash':
        f=s.hkeys(k)
        h=s.execute_command('HPEXPIRETIME',k,'FIELDS',len(f),*f)
        has_ttl=any(x>0 for x in h)
        key=('hash','fieldttl' if has_ttl else 'plain')
    if ty=='string':
        enc=s.object('encoding',k); key=('string',enc.decode())
    if ty=='list': key=('list',s.object('encoding',k).decode())
    if ty=='set': key=('set',s.object('encoding',k).decode())
    if ty=='zset': key=('zset',s.object('encoding',k).decode())
    picks.setdefault(key,k)
print('picks:', {k:v for k,v in picks.items()})
for key,k in picks.items():
    d=s.dump(k)
    tb=d[0]; ver=int.from_bytes(d[-10:-8],'little')
    t.delete(k)
    # try original
    try:
        t.restore(k,0,d); res='ORIG-OK'
    except Exception as e: res=f'ORIG-FAIL({e})'
    if 'OK' not in res:
        p=bytearray(d); p[-10:-8]=(11).to_bytes(2,'little'); p[-8:]=crc64(bytes(p[:-8])).to_bytes(8,'little')
        try:
            t.restore(k,0,bytes(p)); res='V11-OK'
        except Exception as e: res=f'V11-FAIL({e})'
    same = (res.endswith('OK') and t.get(k) is not None or t.exists(k)) 
    print(f'{key}: typebyte={tb} ver={ver} -> {res} | src_enc={s.object("encoding",k)} tgt_enc={(t.object("encoding",k) if t.exists(k) else None)}')
    if res.endswith('OK'):
        if s.type(k)==b'hash':
            f=t.hkeys(k)
            print('   tgt HPEXPIRETIME:', t.execute_command('HPEXPIRETIME',k,'FIELDS',len(f),*f) if f else None, 'src:', s.execute_command('HPEXPIRETIME',k,'FIELDS',len(s.hkeys(k)),*s.hkeys(k)))
        elif s.type(k)==b'string':
            print('   equal:', s.get(k)==t.get(k))
        elif s.type(k)==b'list':
            print('   equal:', s.lrange(k,0,-1)==t.lrange(k,0,-1))
        elif s.type(k)==b'set':
            print('   equal:', sorted(s.smembers(k))==sorted(t.smembers(k)))
        elif s.type(k)==b'zset':
            print('   equal:', s.zrange(k,0,-1,withscores=True)==t.zrange(k,0,-1,withscores=True))
PY

62  $ cd /tmp && python3 - <<'PY'
import redis, time
t=redis.Redis(port=6380,db=15,protocol=3,decode_responses=False)
t.flushall()
for i in range(6): t.xadd('s',{'f':str(i)},id=f'1000{i}-0')
t.execute_command('XGROUP','CREATE','s','g','10005-0')
now=int(time.time()*1000)
# Case 1: fresh consumer, claim with IDLE only
r=t.execute_command('XCLAIM','s','g','c1',0,'10001-0','IDLE',900000,'RETRYCOUNT',3,'FORCE')
time.sleep(0.05)
print('1) claim IDLE=900000 ->', t.xinfo_consumers('s','g'))
# Case 2: existing consumer, claim another with IDLE only
r=t.execute_command('XCLAIM','s','g','c1',0,'10002-0','IDLE',800000,'RETRYCOUNT',2)
time.sleep(0.05)
print('2) 2nd claim IDLE=800000 ->', t.xinfo_consumers('s','g'))
print('   pending:', t.xpending_range('s','g','-','+',count=10))
# Case 3: claim with TIME (past) only
r=t.execute_command('XCLAIM','s','g','c2',0,'10003-0','TIME',now-700000,'RETRYCOUNT',1,'FORCE')
time.sleep(0.05)
print('3) claim TIME=past ->', t.xinfo_consumers('s','g'))
print('   pending:', t.xpending_range('s','g','-','+',count=10))
# Case 4: does RETRYCOUNT override or add to existing times_delivered?
r=t.execute_command('XCLAIM','s','g','c1',0,'10001-0','IDLE',900000,'RETRYCOUNT',3,'JUSTID')
print('4) reclaim same with RETRYCOUNT=3 ->', t.xpending_range('s','g','-','+',count=10))
r=t.execute_command('XCLAIM','s','g','c1',0,'10001-0','IDLE',900000,'JUSTID')
print('   reclaim w/o RETRYCOUNT ->', t.xpending_range('s','g','-','+',count=10))
# Case 5: CREATECONSUMER then check idle origin
t.execute_command('XGROUP','CREATECONSUMER','s','g','c3')
time.sleep(0.05)
print('5) after CREATECONSUMER c3 ->', t.xinfo_consumers('s','g'))
PY

{
 "examples": {
  "missing": [
   "db0:tags:135",
   "db0:session:01083",
   "db0:session:01683"
  ]
 },
 "keys_new": {},
 "keys_old": {
  "0": 2960,
  "2": 350
 },
 "mismatch_counts": {
  "extra": 0,
  "field_ttl_added": 0,
  "field_ttl_drift": 0,
  "field_ttl_lost": 0,
  "missing": 3310,
  "ttl_added": 0,
  "ttl_drift": 0,
  "ttl_lost": 0,
  "type": 0,
  "value": 0
 },
 "new_replication": {
  "master_host": "127.0.0.1",
  "master_link_status": "down",
  "master_port": 6379,
  "role": "slave"
 },
 "new_server": {
  "redis_version": "7.2.4",
  "server_name": "valkey",
  "valkey_version": "9.1.2"
 },
 "old_digest_ok": true,
 "old_server": {
  "redis_version": "8.10.2",
  "server_name": null,
  "valkey_version": null
 }
}