Fix migration mode (#21)

*  improve redis migration and add more docs

Author: eclipsevortex

scripts/miner/README.md

@@ -25,6 +25,7 @@ This guide explains how to **install** and **uninstall** manually the Miner.
 - [Available Components](#available-components)
 - [Monitoring & Logs](#monitoring-and-logs)
 - [Quick Restart](#quick-restart)
+- [View Scores on Wandb](#neuron-wandb-scores)
 - [Per-Component](#per-component)
   - [Redis](#redis)
   - [Metagraph](#metagraph)
@@ -163,6 +164,25 @@ It will restart the Miner's components using the `EXECUTION_METHOD`, which defau
 
 <br />
 
+# 🔬 View Scores on Wandb <a id="neuron-wandb-scores"></a>
+
+In addition to checking local logs, you can also view your Neuron’s challenge scores and activity in the **Wandb dashboards** maintained by the validators.
+
+## 🛰️ Validator Dashboard Table
+
+Browse the full list of validators and their submissions here:  
+👉 [SubVortex Validator Table on Wandb](https://wandb.ai/eclipsevortext/subvortex-team/table?nw=nwusereclipsevortext)
+
+## 🔍 View Detailed Validator Run
+
+To dive into individual challenge sessions, open a specific validator’s run:  
+👉 [Example Validator Run](https://wandb.ai/eclipsevortext/subvortex-team/runs/ewiaytb4?nw=nwuser0xtkd)
+
+> 💡 Scores in Wandb are updated when validators successfully receive, evaluate, and upload challenge results.  
+> If your UID doesn't appear, make sure your node is reachable and correctly emitting events.
+
+ <br />
+
 # Per-Component <a id="per-component"></a>
 
 ## Redis <a id="redis"></a>
@@ -334,3 +354,96 @@ To uninstall Neuron for the Miner:
 
 Need help or want to chat with other SubVortex users?  
 Join us on [Discord](https://discord.gg/bittensor)!
+
+### ✅ Connectivity Checklist <a id="neuron-connectivity-check"></a>
+
+After installing and starting the Neuron, it's essential to verify that your Miner is **externally reachable**. Validators need to connect to both your **Miner** and your **Subtensor** node to send challenges and record results.
+
+#### 🔌 1. Check Miner Port Accessibility
+
+Verify that port `8091` (used for challenge handling) is accessible from the public internet.
+
+From a **remote machine** (not the miner host), run:
+
+```bash
+nc -zv <YOUR_MINER_PUBLIC_IP> 8091
+```
+
+✅ Expected output:
+
+```
+Connection to <YOUR_MINER_PUBLIC_IP> port 8091 [tcp/*] succeeded!
+```
+
+> ⚠️ If this fails, check for:
+>
+> - Blocked ports in `ufw`, `iptables`, or cloud security groups
+> - NAT/router not forwarding the port correctly
+> - Misconfigured HAProxy or service not running
+
+---
+
+#### 🔌 2. Check Subtensor Node WebSocket Accessibility
+
+Make sure your Subtensor node exposes a WebSocket at port `9944`.
+
+Run this from an external machine:
+
+```bash
+wscat -c ws://<YOUR_SUBTENSOR_PUBLIC_IP>:9944
+```
+
+✅ Expected output:
+
+```
+Connected (press CTRL+C to quit)
+>
+```
+
+> 📦 You can install `wscat` via:
+>
+> ```bash
+> npm install -g wscat
+> ```
+
+---
+
+#### 📡 3. Confirm the Neuron is Receiving Challenges
+
+After startup, check your logs to confirm that scores are reaching your neuron:
+
+- `service` (systemd)
+
+```bash
+tail -f /var/log/subvortex-miner/subvortex-miner-neuron.log | grep Score
+```
+
+- `process` (PM2)
+
+```bash
+pm2 log subvortex-miner-neuron | grep Score
+```
+
+- `container` (Docker)
+
+```bash
+docker logs subvortex-miner-neuron -f | grep Score
+```
+
+Look for lines like:
+
+```
+247|subvortex-miner-neuron  | 2025-05-24 21:36:12.185 |       INFO       | [20] Availability score 1.0
+247|subvortex-miner-neuron  | 2025-05-24 21:36:12.185 |       INFO       | [20] Latency score 1.0
+247|subvortex-miner-neuron  | 2025-05-24 21:36:12.185 |       INFO       | [20] Reliability score 0.8558733500690666
+247|subvortex-miner-neuron  | 2025-05-24 21:36:12.185 |       INFO       | [20] Distribution score 1.0
+247|subvortex-miner-neuron  | 2025-05-24 21:36:12.185 |     SUCCESS      | [20] Score 0.9711746700138133
+```
+
+---
+
+If you're not receiving challenges:
+
+- ✅ Double-check that Metagraph and Redis are correctly synced.
+- ✅ Confirm your neuron is registered and emitting correctly on-chain.
+- ✅ Verify your challenge port and WebSocket endpoint are **publicly reachable**.

subvortex/auto_upgrader/src/migrations/redis_migrations.py

@@ -139,25 +139,25 @@ async def apply(self):
                 prefix=sauc.SV_LOGGER_NAME,
             )
 
-            # Determine the highest revions
-            highest_revision = (
+            # Determine the highest revision
+            next_revision = (
                 sorted(new_revisions, key=lambda v: Version(v))[-1]
-                if len(new_revisions) > 0
+                if new_revisions
                 else "0.0.0"
             )
 
             revision = current_version
-            if Version(current_version) < Version(highest_revision):
+            if Version(current_version) < Version(next_revision):
                 revision = await self._upgrade(
                     database=database,
                     revisions=new_revisions,
                     current_version=current_version,
                 )
-            elif Version(current_version) > Version(highest_revision):
+            elif Version(current_version) > Version(next_revision):
                 revision = await self._downgrade(
                     database=database,
                     revisions=old_revisions,
-                    current_version=highest_revision,
+                    next_version=next_revision,
                 )
             else:
                 btul.logging.info(
@@ -198,6 +198,9 @@ async def rollback(self):
             prefix=sauc.SV_LOGGER_NAME,
         )
 
+        # Final rollback target is the down_revision of the last applied revision
+        final_version = self.graph.get(self.applied_revisions[0]) or "0.0.0"
+
         try:
             # Rollback in reverse order
             for rev in reversed(self.applied_revisions):
@@ -213,28 +216,24 @@ async def rollback(self):
                 await database.set(f"migration_mode:{rev}", "dual")
 
                 btul.logging.trace(
-                    f"[Rev {rev}] Executing rollback step", prefix=sauc.SV_LOGGER_NAME
+                    f"[Rev {rev}] Executing rollback step",
+                    prefix=sauc.SV_LOGGER_NAME,
                 )
                 await self.modules[rev].rollback(database)
 
-                # Get the parent revision
-                parent_version = self.graph.get(rev) or "0.0.0"
-
                 btul.logging.trace(
-                    f"[Rev {rev}] Finalizing migration — setting mode to 'new' and version to '{parent_version}'",
+                    f"[Rev {rev}] Deleting migration_mode:{rev}",
                     prefix=sauc.SV_LOGGER_NAME,
                 )
-                if parent_version:
-                    await database.set("version", parent_version)
-                    await database.set(f"migration_mode:{parent_version}", "legacy")
-                else:
-                    await database.set("version", parent_version)
+                await database.delete(f"migration_mode:{rev}")
 
-            # Clear applied revisions after rollback
             self.applied_revisions.clear()
 
         finally:
             if database:
+                # Set final rollback version and its migration_mode
+                await database.set("version", final_version)
+                await database.set(f"migration_mode:{final_version}", "new")
                 await database.close()
 
     async def _upgrade(self, database, revisions, current_version):
@@ -244,66 +243,85 @@ async def _upgrade(self, database, revisions, current_version):
         )
 
         # Sort correctly
-        started = current_version == "0.0.0"
+        skip = current_version == "0.0.0"
+        previous_rev = current_version
         for rev in sorted(revisions, key=lambda v: Version(v)):
-            if not started:
-                if rev == current_version:
-                    started = True
+            if not skip:
+                if Version(rev) <= Version(current_version):
+                    continue
 
-                continue  # skip until current_version is reached
+                skip = False
 
             btul.logging.info(
                 f"⬆️  Applying migration for {self.service_name}: {rev}",
                 prefix=sauc.SV_LOGGER_NAME,
             )
 
+            # Flag the version as dual
             btul.logging.trace(
                 f"[Rev {rev}] Setting migration mode: dual",
                 prefix=sauc.SV_LOGGER_NAME,
             )
             await database.set(f"migration_mode:{rev}", "dual")
 
+            # Rollout the version
             btul.logging.trace(
                 f"[Rev {rev}] Executing rollout step", prefix=sauc.SV_LOGGER_NAME
             )
             await self.modules[rev].rollout(database)
 
+            # Flag the version as new
             btul.logging.trace(
                 f"[Rev {rev}] Finalizing migration — setting mode to 'new' and version to '{rev}'",
                 prefix=sauc.SV_LOGGER_NAME,
             )
             await database.set("version", rev)
             await database.set(f"migration_mode:{rev}", "new")
 
+            # Remove the previous version
+            if previous_rev:
+                await database.delete(f"migration_mode:{previous_rev}")
+
+            previous_rev = rev
             self.applied_revisions.append(rev)
 
         return rev or "0.0.0"
 
-    async def _downgrade(self, database, revisions, current_version):
+    async def _downgrade(self, database, revisions, next_version):
         btul.logging.info(
             f"⬇️  Running downgrade migrations for {self.service_name}...",
             prefix=sauc.SV_LOGGER_NAME,
         )
 
-        parent_version = "0.0.0"
         for rev in sorted(revisions, key=lambda v: Version(v), reverse=True):
-            if Version(rev) <= Version(current_version):
+            if Version(rev) <= Version(next_version):
                 break
-
             btul.logging.info(
                 f"⬇️  Rolling back migration for {self.service_name}: {rev}",
                 prefix=sauc.SV_LOGGER_NAME,
             )
+
+            # Flag the version as dual before rollback
+            btul.logging.trace(
+                f"[Rev {rev}] Setting migration mode: dual",
+                prefix=sauc.SV_LOGGER_NAME,
+            )
             await database.set(f"migration_mode:{rev}", "dual")
+
+            # Execute the rollback step
+            btul.logging.trace(
+                f"[Rev {rev}] Executing rollback step",
+                prefix=sauc.SV_LOGGER_NAME,
+            )
             await self.modules[rev].rollback(database)
 
-            parent_version = self.graph.get(rev)
-            if parent_version:
-                await database.set("version", parent_version)
-                await database.set(f"migration_mode:{parent_version}", "legacy")
-            else:
-                await database.set("version", "0.0.0")
+            # Set parent version if available
+            parent_version = self.graph.get(rev, "0.0.0") or "0.0.0"
+            await database.set("version", parent_version)
+            await database.set(f"migration_mode:{parent_version}", "new")
+            await database.delete(f"migration_mode:{rev}")
 
+            # Track successful rollback
             self.applied_revisions.append(rev)
 
         return parent_version

tests/unit_tests/auto_upgrader/test_container_orchestrator.py

@@ -79,6 +79,7 @@ def orchestrator():
     # Mock internal steps in run_plan
     # orch._get_current_version = mock.MagicMock()
     # orch._get_latest_version = mock.MagicMock()
+    orch._switch_services = mock.MagicMock()
     orch._pull_current_assets = mock.MagicMock()
     orch._pull_latest_assets = mock.MagicMock()
     orch._load_current_services = mock.MagicMock()
@@ -442,7 +443,7 @@ async def test_run_plan_when_no_new_version_should_execute_until_check_versions_
 
 
 @pytest.mark.asyncio
-async def test_run_plan_when_migrate_for_the_first_time_after_releasing_auto_upragder(
+async def test_run_plan_when_migrate_for_the_first_time_after_releasing_auto_upragder2(
     orchestrator,
 ):
     # Arrange

tests/unit_tests/auto_upgrader/test_process_orchestrator.py

@@ -79,6 +79,7 @@ def orchestrator():
     # Mock internal steps in run_plan
     # orch._get_current_version = mock.MagicMock()
     # orch._get_latest_version = mock.MagicMock()
+    orch._switch_services = mock.MagicMock()
     orch._pull_current_assets = mock.MagicMock()
     orch._pull_latest_assets = mock.MagicMock()
     orch._load_current_services = mock.MagicMock()