Forem: Sumit Dhaka

Trishul SNMP Suite 2.0.1: Better MIBs, Traps, and SNMP Labs

Sumit Dhaka — Mon, 25 May 2026 16:57:17 +0000

Trishul SNMP Suite is an SNMP lab and operations shell for people who need to simulate devices, walk targets, send and receive traps, browse MIB trees, and manage real vendor MIB corpora from one place.

If you are new to the project, that is the short intro.

If you last saw it around 1.2.5, 2.0.1 is the point where the project stops feeling like “a useful UI with a lot of features” and starts feeling like a cleaner platform with a much stronger core.

That is the real story of this release.

GitHub: github.com/tosumitdhaka/trishul-snmp-suite

What you get today

Compared with the 1.2.x era, Trishul SNMP Suite now gives you:

one FastAPI application serving the UI, API, and WebSocket layer
one in-process SNMP runtime powered by the in-house trishul-snmp library
one bundle-first MIB compilation pipeline powered by the in-house trishul-smi library
SQLite-backed durable state for sessions, settings, bundles, and notification history
one unified /api/... surface instead of split route families
a cleaner single-container deployment path
better MIB inventory handling, smarter exports, richer trap workflows, and a more intuitive browser experience

The pages are still familiar:

Dashboard
Simulator
Walk & Parse
Traps
MIB Browser
MIB Manager
Settings

But the system underneath those pages is much more coherent now.

From 1.2.x to 2.0.1, in one view

I do not want to turn this into a changelog dump, so here is the short version of the journey:

1.2.x established the operator experience: MIB Browser, realtime dashboard behavior, simulator improvements, trap workflows, drag-and-drop MIB upload, auto-validation, and a more usable UI
later 1.x releases hardened the product with better security, better tests, better docs, better deployment, and a single-suite packaging path
2.0.0 rebuilt the core runtime and MIB pipeline around a much cleaner architecture
2.0.1 is the release where that architecture starts paying off in the workflows users touch every day

So the headline is not just “more features since 1.2.5.”

The headline is that the same kind of workflows now run on a much better foundation.

Why I built `trishul-smi` and `trishul-snmp`

This is the part I most wanted to share.

As the project grew, two kinds of friction kept showing up:

MIB compilation and compiled-data usage were too important to remain a loosely connected side concern.
SNMP runtime behavior was too central to keep treating it like a set of worker-style runtime pieces that had to be coordinated from the outside.

I wanted the product to have:

a first-class compiled MIB artifact
a shared in-memory representation that browser, catalog, trap enrichment, and runtime features could all rely on
runtime control that lived inside the application instead of being orchestrated through extra process boundaries
cleaner APIs for the exact behavior the product needed
simpler debugging and testing

That is why I moved core responsibilities into two in-house libraries.

`trishul-smi`

trishul-smi is the MIB compilation side of the platform.

Instead of compiling MIBs and then treating the output as a loose set of files, the app now works with a bundle-first model:

versioned bundle storage
compile metadata
activation state
compile history
one active compiled bundle loaded for queries

That gives Trishul a more reliable answer to questions like:

which modules are active right now?
which modules belong to which source group?
which module is shadowed and why?
what should the browser, trap catalog, and runtime resolve against?

`trishul-snmp`

trishul-snmp is the runtime side of the platform.

It lets the suite run the responder, manager-side operations, notification listener, trap and inform sending, and bundle-backed symbolic behavior inside the app itself.

That means:

no subprocess choreography as the main runtime model
no shell-outs as the normal SNMP execution path
no extra worker coordination just to keep trap, stats, and simulator state aligned
fewer layers between the UI, state, and runtime behavior

This was not “let’s build in-house libraries for the sake of it.”

It was a practical decision: the product had reached a point where better internal control over the MIB pipeline and SNMP runtime would improve both developer velocity and operator experience.

What the architecture looks like now

A comparison table explains the shift better than a diagram:

Area	Earlier line	2.0.1
MIB compilation	pysmi-style compilation and looser generated artifacts around the app.	trishul-smi drives a bundle-first pipeline with versioned bundles, activation, source attribution, and export-friendly metadata.
Catalog query source	Browser and catalog views leaned on generated artifacts and pysnmp mibBuilder-style runtime views.	The active in-memory bundle is the source of truth for browser, catalog, exports, and resolution.
SNMP runtime	Subprocess-based pysnmp workers, with separate simulator and trap receiver processes and UDP loopback coordination.	trishul-snmp runs responder, manager operations, trap send and receive, and symbolic behavior in-process.
App topology	More glue between runtime pieces, route families, and cross-process status updates.	One FastAPI application serves the UI, API, and WebSocket layer.
State and stats	More file-backed and process-coordination-heavy runtime state, including file-based stats flow.	SQLite-backed state now covers settings, sessions, bundles, notification history, and persisted counters.
Deployment	More moving pieces to explain and reason about.	One suite, one app surface, one cleaner container path.

That simplicity matters.

It reduces the amount of glue code needed to keep everything coherent, and it makes features easier to add without creating a larger mess around them.

What users will notice first

All of that architecture work would not matter much if the workflows still felt awkward.

In 2.0.1, they do not.

More trustworthy compiled MIB data

This is one of the biggest practical improvements in the product.

Trishul now handles compiled MIB data with much clearer source attribution and bundle semantics. It distinguishes the deduplicated active runtime view from the per-source-group inventory view. That becomes very important once you load overlapping vendor corpora or want bundle-specific exports instead of a blurred “everything together” view.

The result is a more trustworthy MIB model:

better duplicate and shadowed-module handling
clearer active-versus-source inventory behavior
better failed-module reporting
more reliable compiled data for exports and downstream workflows

This is the kind of improvement that makes operators trust what the app is showing them.

Better trap workflows

Trap handling is also much better in day-to-day use.

The trap flow now supports richer varbind editing, including enum-aware varbind dropdown behavior that makes common notification work more natural. Trap history is also more coherent because stored events preserve the event-time view of resolution data instead of drifting with whatever the current toggle state happens to be.

That means:

better trap varbind authoring
clearer trap history behavior
stronger confidence in what a stored trap event actually represents
better live operator experience around traps

For SNMP tooling, this matters a lot. Trap workflows become frustrating fast when the tool is “almost right.”

A smarter MIB Browser

The MIB Browser was already one of the most visible features in the older line. In 2.0.1, it feels much more intentional.

Search and type filtering work together more naturally. Filtered trees can auto-expand so users can actually see the result immediately. Interaction is also less fussy: larger click targets and smaller browser UX refinements make the tree feel more responsive and less fragile.

That turns into better everyday behavior:

faster drill-down
less hunting through collapsed branches
more intuitive expand and collapse interaction
fewer dead-click moments in the tree

This is exactly the kind of improvement users notice even if they do not name it explicitly.

Better exports and catalog behavior

Exports are now much more aligned with what the user actually selected.

Source-group-scoped exports respect source-group membership instead of collapsing everything into the currently active deduplicated view. Export filenames are more useful. Stats export is also cleaner and does not drag the full runtime OID catalog into every export by default.

That makes exported data feel like a real operational artifact rather than a generic dump.

More stable page-to-page behavior

One quiet but important improvement in the 2.0.x line is that the app relies less on expensive reprocessing when users switch pages.

Because the platform now has clearer persisted state and runtime ownership, dashboard counters, MIB views, and related status panels behave more predictably when moving between screens.

That translates into:

less waiting
fewer stuck loading states
less repeated inventory work
better confidence that the UI reflects the current runtime state

Many smaller UI and UX refinements matter too

Not everything valuable belongs in a release headline.

Some of the improvements in 2.0.1 are small on paper but meaningful in daily use:

broader click targets in browser trees
more intuitive expand and collapse behavior
better filtered auto-expansion
cleaner loading and status feedback
less friction in modal-driven flows
more consistent page-to-page behavior

These are the kinds of changes that make the product feel sharper even when users cannot point to a single “killer feature.”

Why this helps developers too

One of the easiest ways to slow down a tooling project is to keep layering features on top of an architecture that is getting harder and harder to reason about.

Eventually you pay for that in:

state bugs
UI inconsistencies
release risk
painful debugging
slower feature delivery

Moving the platform toward trishul-smi and trishul-snmp changed that for Trishul SNMP Suite.

For developers, the benefits are direct:

fewer layers to mentally unpack
flatter service architecture
clearer boundaries between compile, runtime, and UI concerns
stronger testability
better release validation and observability

For users, the same architecture work shows up as:

better reliability
more predictable workflows
cleaner logs
easier deployment
more trustworthy data in the UI

That is the kind of internal rewrite I like: one that results in visible product quality, not just prettier internal diagrams.

A few snips

One-shot install

If you just want to try the released suite on a Docker host, this is the quickest path:

curl -LfsS -o install-trishul-snmp-suite.sh \
  https://raw.githubusercontent.com/tosumitdhaka/trishul-snmp-suite/v2.0.1/install-trishul-snmp-suite.sh \
  && bash install-trishul-snmp-suite.sh up

Default access after startup:

UI: http://localhost:8980
API docs: http://localhost:8980/docs
default login: admin / admin123

Unified API shape

One part I like in the current release is that the API shape is much easier to explain:

/api/meta
/api/health
/api/ws
/api/settings/*
/api/stats/*
/api/simulator/*
/api/walk/*
/api/traps/*
/api/mibs/*

It is a small thing, but it makes the product easier to understand for both developers and operators.

Trap send example

The current trap flow is also easier to demonstrate with one clean request:

{
  "target": "127.0.0.1",
  "port": 1162,
  "community": "public",
  "oid": "IF-MIB::linkDown",
  "varbinds": [
    { "oid": "1.3.6.1.2.1.2.2.1.1.1", "type": "Integer", "value": 1 }
  ]
}

That kind of simple, direct workflow is exactly what I wanted the platform to support better.

Why `2.0.1` matters

I do not think 2.0.1 should be read as “just the next point release.”

2.0.0 did the heavy architectural lift. 2.0.1 is where the system starts feeling polished enough that the benefits are obvious:

more reliable compiled data
better source-aware inventory and exports
richer trap authoring
smarter browsing
quieter and more useful logs
cleaner install and runtime defaults

That combination is what makes the release interesting.

Closing

If you are new to Trishul SNMP Suite, 2.0.1 is a good point to try it because the platform is now much easier to understand:

one app
one runtime
one MIB pipeline
one installer path
familiar operator pages

If you knew the older 1.2.x line, 2.0.1 is where the project starts paying off the deeper work behind the scenes.

The UI is better. The MIB data is more trustworthy. Trap workflows are better. The browser is more intuitive. The deployment story is simpler. And the in-house trishul-smi and trishul-snmp foundation gives the project a much stronger path forward.

That is the release I wanted to ship.

If you work with SNMP labs, MIB-heavy device testing, or trap-driven workflows, I would love to know what you would want to see next: deeper bundle controls, richer browser/catalog features, stronger simulator behavior, or more advanced trap tooling.

[Boost]

Sumit Dhaka — Sun, 22 Feb 2026 13:02:51 +0000

Sumit Dhaka

Feb 22

I Built a Free, Self-Hosted SNMP Toolkit — Now With Real-Time WebSocket Push

#networking #python #devops #opensource

Comments

4 min read

I Built a Free, Self-Hosted SNMP Toolkit — Now With Real-Time WebSocket Push

Sumit Dhaka — Sun, 22 Feb 2026 13:01:01 +0000

If you've ever worked with SNMP — testing NMS integrations, debugging trap handlers, or validating MIB structures — you know the pain. You end up juggling Net-SNMP CLI commands you can never remember, snmptrapd configs scattered everywhere, and a $500 MIB browser that still looks like it was designed in 2003.

I built Trishul SNMP Suite to fix that. One Docker container. Browser-based. Free.

This post covers what's new in v1.2.4 — the biggest update yet — and why I built it this way.

What Is Trishul SNMP Suite?

It's a self-hosted SNMP dev toolkit that combines five tools into one clean web UI:

What	Instead of
SNMP Simulator (UDP agent)	`snmpsim` + CLI config
Walk & Parse → JSON	`snmpwalk` + manual OID lookup
Trap Sender + Receiver	`snmptrap` + `snmptrapd`
MIB Browser (tree view)	iReasoning MIB Browser ($500+)
MIB Manager (upload/validate)	Text editor + manual dependency hell

Stack: Python 3.11, FastAPI, pysnmp, pysmi, Bootstrap 5, Docker.

# Install in one command
curl -fsSL https://raw.githubusercontent.com/tosumitdhaka/trishul-snmp-suite/main/install-trishul-snmp-suite.sh | bash

Then open http://localhost:8080. Default login: admin / admin123 — change it immediately in Settings.

What's New in v1.2.4

⚡ Real-Time WebSocket Push — Polling Is Dead

The biggest architectural change: the entire frontend is now event-driven.

Before: Every page polled the backend on a setInterval — dashboard every 30s, simulator every 5s. Stale data was common. Switching pages caused spinners.

After: A single persistent WebSocket connection at /api/ws. The backend broadcasts state changes the moment they happen. Dashboard, Simulator status, and Trap Receiver all update instantly — no refresh needed.

Browser ←──── WS push ────── FastAPI /api/ws
                                    │
                              broadcasts on:
                              - trap received
                              - simulator start/stop
                              - MIB uploaded
                              - stats change

The navbar shows a live green dot when the WebSocket is healthy. On reconnect, the backend sends a full_state message to re-seed everything — so you never see stale data after a network hiccup.

Why this matters for devs: If you're building a trap handler and sending test traps from the UI, you now see the counter increment on the dashboard in real time. No F5 needed.

📊 Live Activity Stats Dashboard

A new 8-counter row on the dashboard shows everything happening in your session:

SNMP Requests — Total polls served by the simulator
OIDs Loaded — OIDs currently in memory across all loaded MIBs
Traps Received / Sent — Live trap counters
Walks Executed — How many SNMP walks you've run
OIDs Returned — Total OIDs returned across all walks
MIBs Uploaded / Times Reloaded — MIB management activity

All counters update via WebSocket push. They're also file-backed — they survive container restarts so you don't lose your session history.

⚙️ Settings — Three New Cards

App Behaviour

Two toggles: auto-start Simulator and auto-start Trap Receiver on container boot. Plus a configurable session timeout (60s–86400s). Settings persist to app_settings.json and take effect on next restart.

Stats Management

Export all counters as JSON (useful for logging test session results) or reset to zero for a clean baseline before a test run.

About

Version, author, and description pulled live from the backend — always in sync with what's actually deployed.

🐛 Notable Fixes

Timestamp bug: The Trap Receiver was showing 1970 for Last Received when the backend returned a Unix epoch 0. Now guarded and shown as --.

Traps Sent undercount: Stats were only incremented in the frontend — if you sent traps via API directly, the counter never moved. Fixed by broadcasting stats from the backend after every successful trap send.

Dashboard spinners on page switch: The WS full_state event fires before DashboardModule.init() registers its listener on page switch, so status tiles stayed as spinners until the next reconnect. Fixed by always seeding via REST on init, regardless of WS state.

MIB Browser state conflict: Navigating to the Browser from Walk & Parse (with a pre-filled OID) would sometimes log Could not find node because the previous session's pending tree state conflicted. Fixed by clearing pendingSelectedOid and pendingExpandedNodes when a programmatic OID search is present.

Who Is This For?

NMS / backend developers who need a real SNMP agent to poll without actual hardware, or need to fire specific trap OIDs to validate their handler code.

DevOps / integration engineers who need to test SNMP monitoring integrations in CI/staging environments.

Network engineers who want to explore MIB structures interactively — search by OID, by name, or by description — and understand what traps a device can fire before it's on the floor.

What It's NOT For

Production 24/7 monitoring → use Zabbix, LibreNMS, PRTG
Enterprise NMS → use SolarWinds, Cisco Prime
High-availability trap collection at scale → use dedicated platforms

Trishul is a developer and testing tool, not a production monitoring system.

Quick Architecture

Browser (8080)
    │ HTTP + WebSocket
    ▼
Nginx (static files + reverse proxy)
    │ REST + WS
    ▼
FastAPI Backend (8000)
    ├── MIB Service (parse, validate, search)
    ├── SNMP Simulator (UDP 1061)
    ├── Trap Manager (send + receive on UDP 1162)
    ├── Walker (SNMP walk client)
    └── WebSocket hub (/api/ws)

Everything runs in Docker with host network mode so the SNMP UDP ports (1061, 1162) are accessible directly from your local machine or test devices.

Try It

# One-command install
curl -fsSL https://raw.githubusercontent.com/tosumitdhaka/trishul-snmp-suite/main/install-trishul-snmp-suite.sh | bash

# Access at
http://localhost:8080

If it's useful, a ⭐ on GitHub goes a long way — it helps other devs find the project.

Happy to answer questions in the comments about architecture decisions, the pysnmp/pysmi integration, or the WebSocket implementation. 🔱

Created OpenSource SNMP dev/testing tool for devs, please checkout and help improving it.

Sumit Dhaka — Sun, 22 Feb 2026 12:40:19 +0000

Sumit Dhaka

Feb 22

I Built a Free, Self-Hosted SNMP Toolkit — Now With Real-Time WebSocket Push

#networking #python #devops #opensource

Comments

4 min read

[Boost]

Sumit Dhaka — Sun, 22 Feb 2026 12:38:49 +0000

Sumit Dhaka

Feb 10

Building Trishul-SNMP-Suite: A Modern Web-Based SNMP Toolkit to Replace $500 Commercial Tools

#snmp #networking #opensource #python

Comments

8 min read

I Built a Free, Self-Hosted SNMP Toolkit — Now With Real-Time WebSocket Push

Sumit Dhaka — Sun, 22 Feb 2026 12:38:22 +0000

I built Trishul SNMP Studio to fix that. One Docker container. Browser-based. Free.

This post covers what's new in v1.2.4 — the biggest update yet — and why I built it this way.

What Is Trishul SNMP Studio?

It's a self-hosted SNMP dev toolkit that combines five tools into one clean web UI:

What	Instead of
SNMP Simulator (UDP agent)	`snmpsim` + CLI config
Walk & Parse → JSON	`snmpwalk` + manual OID lookup
Trap Sender + Receiver	`snmptrap` + `snmptrapd`
MIB Browser (tree view)	iReasoning MIB Browser ($500+)
MIB Manager (upload/validate)	Text editor + manual dependency hell

Stack: Python 3.11, FastAPI, pysnmp, pysmi, Bootstrap 5, Docker.

# Install in one command
curl -fsSL https://raw.githubusercontent.com/tosumitdhaka/trishul-snmp/main/install-trishul-snmp.sh | bash

Then open http://localhost:8080. Default login: admin / admin123 — change it immediately in Settings.

What's New in v1.2.4

⚡ Real-Time WebSocket Push — Polling Is Dead

The biggest architectural change: the entire frontend is now event-driven.

Before: Every page polled the backend on a setInterval — dashboard every 30s, simulator every 5s. Stale data was common. Switching pages caused spinners.

Browser ←──── WS push ────── FastAPI /api/ws
                                    │
                              broadcasts on:
                              - trap received
                              - simulator start/stop
                              - MIB uploaded
                              - stats change

The navbar shows a live green dot when the WebSocket is healthy. On reconnect, the backend sends a full_state message to re-seed everything — so you never see stale data after a network hiccup.

Why this matters for devs: If you're building a trap handler and sending test traps from the UI, you now see the counter increment on the dashboard in real time. No F5 needed.

📊 Live Activity Stats Dashboard

A new 8-counter row on the dashboard shows everything happening in your session:

SNMP Requests — Total polls served by the simulator
OIDs Loaded — OIDs currently in memory across all loaded MIBs
Traps Received / Sent — Live trap counters
Walks Executed — How many SNMP walks you've run
OIDs Returned — Total OIDs returned across all walks
MIBs Uploaded / Times Reloaded — MIB management activity

All counters update via WebSocket push. They're also file-backed — they survive container restarts so you don't lose your session history.

⚙️ Settings — Three New Cards

App Behaviour

Stats Management

Export all counters as JSON (useful for logging test session results) or reset to zero for a clean baseline before a test run.

About

Version, author, and description pulled live from the backend — always in sync with what's actually deployed.

🐛 Notable Fixes

Timestamp bug: The Trap Receiver was showing 1970 for Last Received when the backend returned a Unix epoch 0. Now guarded and shown as --.

Who Is This For?

NMS / backend developers who need a real SNMP agent to poll without actual hardware, or need to fire specific trap OIDs to validate their handler code.

DevOps / integration engineers who need to test SNMP monitoring integrations in CI/staging environments.

Network engineers who want to explore MIB structures interactively — search by OID, by name, or by description — and understand what traps a device can fire before it's on the floor.

What It's NOT For

Production 24/7 monitoring → use Zabbix, LibreNMS, PRTG
Enterprise NMS → use SolarWinds, Cisco Prime
High-availability trap collection at scale → use dedicated platforms

Trishul is a developer and testing tool, not a production monitoring system.

Quick Architecture

Browser (8080)
    │ HTTP + WebSocket
    ▼
Nginx (static files + reverse proxy)
    │ REST + WS
    ▼
FastAPI Backend (8000)
    ├── MIB Service (parse, validate, search)
    ├── SNMP Simulator (UDP 1061)
    ├── Trap Manager (send + receive on UDP 1162)
    ├── Walker (SNMP walk client)
    └── WebSocket hub (/api/ws)

Everything runs in Docker with host network mode so the SNMP UDP ports (1061, 1162) are accessible directly from your local machine or test devices.

Try It

# One-command install
curl -fsSL https://raw.githubusercontent.com/tosumitdhaka/trishul-snmp/main/install-trishul-snmp.sh | bash

# Access at
http://localhost:8080

If it's useful, a ⭐ on GitHub goes a long way — it helps other devs find the project.

Happy to answer questions in the comments about architecture decisions, the pysnmp/pysmi integration, or the WebSocket implementation. 🔱

Building Trishul-SNMP-Suite: A Modern Web-Based SNMP Toolkit to Replace $500 Commercial Tools

Sumit Dhaka — Tue, 10 Feb 2026 08:45:14 +0000

Building Trishul SNMP Suite: A Modern Web-Based SNMP Toolkit

I built Trishul SNMP Suite 🔱, a free open-source web-based SNMP toolkit that replaces 5+ commercial tools. It includes an SNMP simulator, walker, trap manager, MIB browser, and more—all in one unified platform.

🔗 GitHub: https://github.com/tosumitdhaka/trishul-snmp-suite

⭐ Star it if you find it useful!

The Problem: SNMP Tooling is Stuck in the Past

As a network engineer, I was frustrated with the state of SNMP tooling:

What's Available Today:

Net-SNMP 🐌

Powerful but CLI-only
Steep learning curve
Need to memorize commands
No visual feedback

iReasoning MIB Browser 💰

Great GUI but costs $500+
Desktop app (not web-based)
No trap receiver
Closed source

snmpsim 🔧

Good simulator but no web interface
CLI configuration
Limited features

Custom Scripts 📝

Scattered across repos
Hard to maintain
No unified workflow

What I Needed:

✅ Web-based (access from anywhere)

✅ Free & open source (no $500 license)

✅ Unified platform (one tool for everything)

✅ Modern UI (not from 2005)

✅ Easy deployment (Docker one-liner)

So I built it. 🔱

Introducing Trishul SNMP Suite

A web-based SNMP toolkit with 6 integrated components:

🖥️ 1. SNMP Simulator (Server Mode)

Test SNMP agent responses without real hardware.

# Start simulator with custom OIDs
curl -X POST http://localhost:8000/api/simulator/start \
  -H "Content-Type: application/json" \
  -d '{
    "port": 1061,
    "community": "public",
    "oids": {
      "1.3.6.1.2.1.1.1.0": "Test Device v1.0",
      "1.3.6.1.2.1.1.3.0": "12345"
    }
  }'

Use case: Simulate devices for NMS development and testing.

🚶 2. Walk & Parse (Client Mode)

Test SNMP queries with automatic MIB resolution.

# Walk a device
curl -X POST http://localhost:8000/api/walker/walk \
  -H "Content-Type: application/json" \
  -d '{
    "host": "192.168.1.1",
    "community": "public",
    "oid": "1.3.6.1.2.1.1",
    "version": "2c"
  }'

Features:

Automatic OID → name resolution
Export to JSON/CSV
Bulk operations (GETBULK)
Walk history

Use case: Test SNMP agent responses, validate walk implementations.

📡 3. Trap Manager (Client + Server)

Send Test Traps (Client):

# Send trap to test receiver
curl -X POST http://localhost:8000/api/traps/send \
  -H "Content-Type: application/json" \
  -d '{
    "target": "192.168.1.100",
    "port": 162,
    "community": "public",
    "trap_oid": "1.3.6.1.6.3.1.1.5.3",
    "varbinds": [
      {"oid": "1.3.6.1.2.1.1.3.0", "value": "12345"}
    ]
  }'

Receive Test Traps (Server):

Real-time display on UDP 1162
Automatic OID resolution
Trap library with 24+ traps

Use case: Validate trap format/syntax for NMS development.

📚 4. MIB Manager

Upload and validate MIB files with dependency checking.

Features:

Drag-and-drop upload
Syntax validation
Dependency resolution
Trap enumeration
Statistics (objects, imports, traps)

Use case: Validate MIBs before deployment, centralized MIB library.

🌳 5. MIB Browser (NEW in v1.2.0!)

Interactive tree explorer for MIB structures.

Features:

Dual views: By module or OID hierarchy
Real-time search: Find OIDs by name, numeric OID, or description
Smart filtering: By module and type (scalars, tables, notifications)
Tree navigation: Expandable with configurable depth (1-5 levels)
Details panel: Full metadata, descriptions, varbinds
Integration: Jump to Walker/Trap Sender with pre-filled data
State persistence: Remembers your position

Use case: Explore MIB structures, understand OID relationships, find traps.

🔐 6. Settings

Manage authentication and preferences.

Architecture: How It Works

┌─────────────────────────────────────────────────────────────────────┐
│                      Web Browser (Port 8080)                        │
│                                                                     │
│  ┌──────────┐ ┌──────────┐ ┌───────┐ ┌──────┐ ┌────────┐ ┌─────┐    │
│  │Dashboard │ │Simulator │ │Walker │ │Traps │ │Browser │ │MIBs │    │
│  └──────────┘ └──────────┘ └───────┘ └──────┘ └────────┘ └─────┘    │
└────────────────────────────┬────────────────────────────────────────┘
                             │ HTTP
                             │
              ┌──────────────▼──────────────┐
              │   Nginx (Frontend)          │
              │   • Serves static files     │
              │   • Reverse proxy to API    │
              └──────────────┬──────────────┘
                             │ REST API
                             │
┌────────────────────────────▼────────────────────────────────────────┐
│                  FastAPI Backend (Port 8000)                        │
│                                                                     │
│  ┌───────────────────────────────────────────────────────────────┐  │
│  │                      API Endpoints                            │  │
│  │  /api/simulator/*  /api/walker/*   /api/traps/*               │  │
│  │  /api/mibs/*       /api/browser/*  /api/settings/*            │  │
│  └───────────────────────────────────────────────────────────────┘  │
│                                                                     │
│  ┌───────────────────────────────────────────────────────────────┐  │
│  │                    Service Layer                              │  │
│  │                                                               │  │
│  │  ┌─────────────────────────────────────────────────────────┐  │  │
│  │  │              MIB Service (pysmi/pysnmp)                 │  │  │
│  │  │  • Parse & validate MIB files                           │  │  │
│  │  │  • Check syntax & dependencies                          │  │  │
│  │  │  • Build OID tree (module/hierarchy views)              │  │  │
│  │  │  • Resolve OID names ↔ numeric OIDs                     │  │  │
│  │  │  • Enumerate traps (24: 19 loaded + 5 system)           │  │  │
│  │  │  • Search & filter (name, OID, type, module)            │  │  │
│  │  └─────────────────────────────────────────────────────────┘  │  │
│  │                                                               │  │
│  │  ┌─────────────────────────────────────────────────────────┐  │  │
│  │  │              SNMP Service (pysnmp)                      │  │  │
│  │  │  • Simulator: Test SNMP agent responses                 │  │  │
│  │  │  • Walker: Test SNMP client queries                     │  │  │
│  │  │  • Trap Sender: Send test traps (client)                │  │  │
│  │  │  • Trap Receiver: Receive test traps (server)           │  │  │
│  │  └─────────────────────────────────────────────────────────┘  │  │
│  │                                                               │  │
│  │  ┌─────────────────────────────────────────────────────────┐  │  │
│  │  │              Auth Service                               │  │  │
│  │  │  • Session management (token-based)                     │  │  │
│  │  │  • User authentication                                  │  │  │
│  │  └─────────────────────────────────────────────────────────┘  │  │
│  └───────────────────────────────────────────────────────────────┘  │
│                                                                     │
│  ┌───────────────────────────────────────────────────────────────┐  │
│  │                    SNMP Network Layer                         │  │
│  │                                                               │  │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐       │  │
│  │  │Simulator │  │  Sender  │  │ Receiver │  │  Walker  │       │  │
│  │  │  (SVR)   │  │  (CLI)   │  │  (SVR)   │  │  (CLI)   │       │  │
│  │  │UDP: 1061 │  │ Dynamic  │  │UDP: 1162 │  │ Dynamic  │       │  │
│  │  │          │  │          │  │          │  │          │       │  │
│  │  │Test SNMP │  │Send test │  │Receive   │  │Test SNMP │       │  │
│  │  │agent     │  │traps to  │  │test traps│  │queries   │       │  │
│  │  │responses │  │dev/test  │  │from dev/ │  │to dev/   │       │  │
│  │  │          │  │targets   │  │test env  │  │test env  │       │  │
│  │  └────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬─────┘       │  │
│  │       │             │             │             │             │  │
│  └───────┼─────────────┼─────────────┼─────────────┼─────────────┘  │
│          │             │             │             │                │
│  ┌───────▼─────────────▼─────────────▼─────────────▼─────────────┐  │
│  │              Data Storage (Docker Volume)                     │  │
│  │  /app/data/                                                   │  │
│  │    ├── mibs/           (MIB files for validation)             │  │
│  │    ├── sessions.json   (Auth tokens)                          │  │
│  │    └── settings.json   (User config)                          │  │
│  └───────────────────────────────────────────────────────────────┘  │
│                                                                     │
└───────────────────────────┬─────────────────────────────────────────┘
                            │ SNMP Protocol (UDP)
                            │ Host Network Mode
                            │
             ┌──────────────┴──────────────┐
             │                             │
     ┌───────▼────────┐           ┌────────▼────────┐
     │ Test SNMP      │           │  Test Trap      │
     │ Clients/Agents │           │  Receivers      │
     │ (Dev/Test Env) │           │  (Dev/Test Env) │
     │                │           │                 │
     │ • Your NMS     │           │ • Your NMS      │
     │ • Custom apps  │           │ • Trap parsers  │
     │ • Test devices │           │ • Log servers   │
     │ • Simulators   │           │ • Test apps     │
     └────────────────┘           └─────────────────┘

Tech Stack:

Backend: Python 3.11, FastAPI, pysnmp, pysmi
Frontend: Vanilla JS, Bootstrap 5
Deployment: Docker Compose, Nginx
Storage: Docker volumes for persistence

Key Technical Decisions

1. Host Network Mode for SNMP

Challenge: SNMP uses dynamic UDP ports. Traps can come from any port, not just 162.

Solution: Use Docker's host network mode.

# docker-compose.yml
services:
  backend:
    network_mode: "host"
    ports:
      - "8000:8000"  # API
      - "1061:1061/udp"  # Simulator
      - "1162:1162/udp"  # Trap receiver

Trade-off: Less isolation, but necessary for SNMP's dynamic nature.

2. MIB Parsing with pysmi

Challenge: MIBs have complex dependencies (IMPORTS clause).

Solution: Use pysmi's MibBuilder with custom sources.

from pysmi.reader import FileReader
from pysmi.searcher import StubSearcher
from pysnmp.smi import builder, view

# Initialize MIB builder
mib_builder = builder.MibBuilder()

# Add custom MIB directory
mib_builder.addMibSources(
    FileReader('/app/data/mibs')
)

# Load MIB with automatic dependency resolution
mib_builder.loadModules('IF-MIB')

# Access MIB objects
mib_view = view.MibViewController(mib_builder)

Result: Automatic dependency resolution—upload IF-MIB, and it automatically finds SNMPv2-SMI, SNMPv2-TC, etc.

3. State Persistence Across Pages

Challenge: Users lose context when switching between components (e.g., Browser → Walker).

Solution: SessionStorage for UI state.

// Save state when leaving page
sessionStorage.setItem('browserState', JSON.stringify({
    view: 'module',
    module: 'IF-MIB',
    searchTerm: 'ifDescr',
    expandedNodes: ['1.3.6.1.2.1.2'],
    selectedOid: '1.3.6.1.2.1.2.2.1.2'
}));

// Restore state on page load
window.addEventListener('DOMContentLoaded', () => {
    const state = JSON.parse(sessionStorage.getItem('browserState'));
    if (state) {
        // Restore view, search, expanded nodes, selection
        restoreState(state);
    }
});

Result: Seamless navigation. Browse a trap in MIB Browser → click "Send this Trap" → Trap Sender opens with trap pre-filled → click "Browse" → returns to same position in tree.

4. Performance: Backend Caching

Challenge: Listing 24 traps on every dashboard load is slow (parses all MIBs).

Solution: In-memory cache with 60-second TTL.

from time import time

class MibService:
    def __init__(self):
        self._trap_cache = None
        self._trap_cache_time = 0
        self._trap_cache_ttl = 60  # seconds

    def list_traps(self):
        current_time = time()

        # Return cached data if fresh
        if self._trap_cache and (current_time - self._trap_cache_time) < self._trap_cache_ttl:
            return self._trap_cache

        # Build fresh list
        traps = self._build_trap_list()

        # Update cache
        self._trap_cache = traps
        self._trap_cache_time = current_time

        return traps

Result: Dashboard load time reduced from 2s → 0.2s (10x faster).

5. Lazy Loading for MIB Tree

Challenge: Rendering 1000+ OIDs at once freezes the browser.

Solution: Load children on-demand with configurable depth.

async expandNodeRecursively(nodeEl, depth) {
    if (depth <= 0) return;

    const oid = nodeEl.dataset.oid;

    // Load only immediate children
    const res = await fetch(`/api/mibs/browse/tree/oid?root_oid=${oid}&depth=1`);
    const data = await res.json();

    // Render children
    const childrenContainer = nodeEl.querySelector('.tree-children');
    childrenContainer.innerHTML = data.children.map(child => 
        this.buildTreeNodeHtml(child, 0)
    ).join('');

    // Recursively expand if depth > 1
    if (depth > 1) {
        const childNodes = childrenContainer.querySelectorAll('.tree-node');
        for (const childNode of childNodes) {
            await this.expandNodeRecursively(childNode, depth - 1);
        }
    }
}

Features:

User selects depth: 1-5 levels (default: 3)
Only visible nodes rendered
Smooth expansion even with large MIBs

Result: Can handle MIBs with 5000+ objects without lag.

Challenges & Solutions

Challenge 1: Trap Count Inconsistency

Problem: Dashboard showed 24 traps, MIB Manager showed 19.

Root cause: System MIBs (SNMPv2-MIB, RMON-MIB) are built into pysnmp but not in the "loaded MIB" list.

Solution: Visual distinction with badges.

const knownSystemMibs = ['SNMPv2-MIB', 'RMON-MIB', 'IF-MIB'];
const loadedModules = new Set(loadedMibs.map(m => m.module));

traps.forEach(trap => {
    const isSystemMib = knownSystemMibs.includes(trap.module) 
                        && !loadedModules.has(trap.module);

    // Gray badge for system MIBs, blue for loaded
    const badge = `
        <span class="badge ${isSystemMib ? 'bg-secondary' : 'bg-primary'}">
            ${trap.module}
        </span>
        ${isSystemMib ? '<span class="badge bg-secondary">System</span>' : ''}
    `;
});

Result: Clear distinction—users understand which MIBs are built-in vs. uploaded.

Challenge 2: Docker Image Size

Problem: Initial image was 1.2GB (too large for quick pulls).

Solution: Multi-stage builds + Alpine base.

# Build stage
FROM python:3.11-slim as builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --user --no-cache-dir -r requirements.txt

# Runtime stage
FROM python:3.11-alpine
WORKDIR /app

# Copy only installed packages
COPY --from=builder /root/.local /root/.local

# Copy application
COPY . .

# Set PATH
ENV PATH=/root/.local/bin:$PATH

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Result: Image size reduced to 350MB (70% smaller).

Challenge 3: MIB Browser Tree Performance

Problem: Expanding large MIBs (e.g., CISCO-SMI with 3000+ objects) caused browser freeze.

Solutions implemented:

Lazy loading: Load children only when node is expanded
Depth control: User chooses 1-5 levels (prevents over-expansion)
Debounced search: 500ms delay to avoid excessive API calls
Virtual scrolling: Only render visible nodes (future enhancement)

// Debounced search
let searchTimeout;
searchInput.addEventListener('input', (e) => {
    clearTimeout(searchTimeout);
    searchTimeout = setTimeout(() => {
        performSearch(e.target.value);
    }, 500);  // Wait 500ms after user stops typing
});

Result: Smooth navigation even with 5000+ object MIBs.

Lessons Learned

1. Start with MVP, Iterate Based on Feedback

v1.0.0 (June 2025):

4 components: Simulator, Walker, Traps, MIB Manager
Basic functionality

v1.2.0 (Feb 2026):

Added MIB Browser (most requested feature)
Enhanced trap management
State persistence

Lesson: Ship early, listen to users, add features they actually need.

2. Documentation is as Important as Code

I spent 20% of development time on documentation:

Comprehensive README
Architecture diagrams
API documentation (FastAPI auto-docs)
Code comments
Contributing guidelines

3. One-Command Install is Crucial

Users won't read complex setup instructions.

Bad:

# Clone repo
git clone ...
cd trishul-snmp

# Install dependencies
pip install -r requirements.txt
npm install

# Configure
cp .env.example .env
vim .env

# Build
docker-compose build

# Run
docker-compose up -d

Good:

curl -fsSL https://raw.githubusercontent.com/tosumitdhaka/trishul-snmp-suite/main/install-trishul-snmp-suite.sh | bash

Result: Lower barrier to entry = more users trying it.

4. Open Source ≠ Free Labor

Be clear about support expectations:

✅ Added:

Code of Conduct
Contributing guidelines
Issue templates
Pull request template
License (MIT)

✅ Set boundaries:

Response time: "Best effort, usually within 48 hours"
Feature requests: "Vote on issues, no guarantees"
Support: "Community-driven, use Discussions"

Lesson: Protect your time while being welcoming.

5. Community Matters

What worked:

GitHub Discussions for Q&A
Twitter/LinkedIn posts
Dev.to articles (like this one!)
Responding to every comment/issue

What didn't:

Discord server (too early, not enough users)
Weekly newsletters (too much overhead)

Lesson: Focus on platforms where your users already are.

Results (2 Months After Launch)

⭐ 19+ GitHub stars
🍴 2+ forks
🐳 100+ Docker pulls

What's Next? v1.3.0 Roadmap

🚧 In Progress:

🔐 SNMPv3 authentication (MD5, SHA, AES encryption)
⏰ Scheduled SNMP walks (cron-like syntax)
📧 Notifications (Email/Slack/Webhook for traps)

📋 Planned:

📊 Custom dashboards (drag-and-drop widgets)
🔑 API keys (rate limiting, authentication)
📦 Bulk device management (import/export CSV)
📈 Historical data (time-series graphs)
🌙 Dark mode
🌍 Multi-language support (i18n)

Vote on features: https://github.com/tosumitdhaka/trishul-snmp/issues

Try It Yourself

Quick Start:

curl -fsSL https://raw.githubusercontent.com/tosumitdhaka/trishul-snmp-suite/main/install-trishul-snmp-suite.sh | bash

Access:

Frontend: http://localhost:8080
Default login: admin / admin123

Explore:

Upload a MIB file (try IF-MIB)
Browse the MIB tree
Walk a device (or use the simulator)
Send a test trap
Explore trap library

Contributing

Trishul-SNMP-Suite is 100% open source (MIT License).

Ways to contribute:

⭐ Star the repo
🐛 Report bugs
💡 Suggest features
🔧 Submit PRs
📝 Write tutorials
💰 Sponsor development

GitHub: https://github.com/tosumitdhaka/trishul-snmp-suite

Conclusion

Building Trishul-SNMP-Suite taught me:

Modern web tech can revitalize old protocols - SNMP is from 1988, but a good UI makes it accessible
Open source is about community, not just code - Documentation, support, and engagement matter
Good UX matters, even for network tools - Engineers appreciate beautiful, intuitive interfaces too
Start small, iterate fast - MVP → feedback → features users actually want

If you work with SNMP, give it a try. If you find it useful, star the repo and share it!

Questions? Comments? Drop them below or open a GitHub Discussion.

About the Author

I'm Sumit Dhaka, a devops & integration engineer who loves building tools that make life easier.

Connect with me:

🐙 GitHub: @tosumitdhaka
💼 LinkedIn: Sumit Dhaka
📧 Email: sumitdhaka@zohomail.in

Note: Its an AI generated article and may have some inconsistency.

Tags: #snmp #networking #opensource #python #fastapi #docker #devops #webdev #mib #networkengineering

Forem: Sumit Dhaka

Trishul SNMP Suite 2.0.1: Better MIBs, Traps, and SNMP Labs

What you get today

From 1.2.x to 2.0.1, in one view

Why I built trishul-smi and trishul-snmp

trishul-smi

trishul-snmp

What the architecture looks like now

What users will notice first

More trustworthy compiled MIB data

Better trap workflows

A smarter MIB Browser

Better exports and catalog behavior

More stable page-to-page behavior

Many smaller UI and UX refinements matter too

Why this helps developers too

A few snips

One-shot install

Unified API shape

Trap send example

Why 2.0.1 matters

Closing

[Boost]

I Built a Free, Self-Hosted SNMP Toolkit — Now With Real-Time WebSocket Push

I Built a Free, Self-Hosted SNMP Toolkit — Now With Real-Time WebSocket Push

What Is Trishul SNMP Suite?

What's New in v1.2.4

⚡ Real-Time WebSocket Push — Polling Is Dead

📊 Live Activity Stats Dashboard

⚙️ Settings — Three New Cards

🐛 Notable Fixes

Who Is This For?

What It's NOT For

Quick Architecture

Try It

Created OpenSource SNMP dev/testing tool for devs, please checkout and help improving it.

I Built a Free, Self-Hosted SNMP Toolkit — Now With Real-Time WebSocket Push

[Boost]

Building Trishul-SNMP-Suite: A Modern Web-Based SNMP Toolkit to Replace $500 Commercial Tools

I Built a Free, Self-Hosted SNMP Toolkit — Now With Real-Time WebSocket Push

What Is Trishul SNMP Studio?

What's New in v1.2.4

⚡ Real-Time WebSocket Push — Polling Is Dead

📊 Live Activity Stats Dashboard

⚙️ Settings — Three New Cards

🐛 Notable Fixes

Who Is This For?

What It's NOT For

Quick Architecture

Try It

Building Trishul-SNMP-Suite: A Modern Web-Based SNMP Toolkit to Replace $500 Commercial Tools

Building Trishul SNMP Suite: A Modern Web-Based SNMP Toolkit

The Problem: SNMP Tooling is Stuck in the Past

What's Available Today:

What I Needed:

Introducing Trishul SNMP Suite

🖥️ 1. SNMP Simulator (Server Mode)

🚶 2. Walk & Parse (Client Mode)

📡 3. Trap Manager (Client + Server)

📚 4. MIB Manager

🌳 5. MIB Browser (NEW in v1.2.0!)

🔐 6. Settings

Architecture: How It Works

Tech Stack:

Key Technical Decisions

1. Host Network Mode for SNMP

2. MIB Parsing with pysmi

3. State Persistence Across Pages

4. Performance: Backend Caching

5. Lazy Loading for MIB Tree

Challenges & Solutions

Challenge 1: Trap Count Inconsistency

Challenge 2: Docker Image Size

Challenge 3: MIB Browser Tree Performance

Lessons Learned

1. Start with MVP, Iterate Based on Feedback

2. Documentation is as Important as Code

3. One-Command Install is Crucial

4. Open Source ≠ Free Labor

5. Community Matters

Why I built `trishul-smi` and `trishul-snmp`

`trishul-smi`

`trishul-snmp`

Why `2.0.1` matters