Gufo SNMP Example: Fetch
We have mastered the iteration of the MIB view
in our getnext and getbulk examples.
Gufo SNMP also offers a convenient wrapper to combine
them into the single .fetch() wrapper. This may be useful
when the application combines SNMP v1 and SNMP v2c queries
and it is desirable to hide such implementation details.
fetch.py import asyncio
import sys
from gufo.snmp import SnmpSession
async def main ( addr : str , community : str , oid : str ) -> None :
async with SnmpSession (
addr = addr , community = community , allow_bulk = True
) as session :
async for k , v in session . fetch ( oid ):
print ( f " { k } : { v } " )
asyncio . run ( main ( sys . argv [ 1 ], sys . argv [ 2 ], sys . argv [ 3 ]))
Let's see the details.
fetch.py import asyncio
import sys
from gufo.snmp import SnmpSession
async def main ( addr : str , community : str , oid : str ) -> None :
async with SnmpSession (
addr = addr , community = community , allow_bulk = True
) as session :
async for k , v in session . fetch ( oid ):
print ( f " { k } : { v } " )
asyncio . run ( main ( sys . argv [ 1 ], sys . argv [ 2 ], sys . argv [ 3 ]))
Gufo SNMP is an async library. In our case
we should run the client from our synchronous script,
so we need to import asyncio to use asyncio.run().
fetch.py import asyncio
import sys
from gufo.snmp import SnmpSession
async def main ( addr : str , community : str , oid : str ) -> None :
async with SnmpSession (
addr = addr , community = community , allow_bulk = True
) as session :
async for k , v in session . fetch ( oid ):
print ( f " { k } : { v } " )
asyncio . run ( main ( sys . argv [ 1 ], sys . argv [ 2 ], sys . argv [ 3 ]))
sys module to parse the CLI argument.
Warning
We use sys.argv only for demonstration purposes. Use argsparse or alternatives
in real-world applications.
fetch.py import asyncio
import sys
from gufo.snmp import SnmpSession
async def main ( addr : str , community : str , oid : str ) -> None :
async with SnmpSession (
addr = addr , community = community , allow_bulk = True
) as session :
async for k , v in session . fetch ( oid ):
print ( f " { k } : { v } " )
asyncio . run ( main ( sys . argv [ 1 ], sys . argv [ 2 ], sys . argv [ 3 ]))
SnmpSession object holds all necessary API, so import it from gufo.snmp.
fetch.py import asyncio
import sys
from gufo.snmp import SnmpSession
async def main ( addr : str , community : str , oid : str ) -> None :
async with SnmpSession (
addr = addr , community = community , allow_bulk = True
) as session :
async for k , v in session . fetch ( oid ):
print ( f " { k } : { v } " )
asyncio . run ( main ( sys . argv [ 1 ], sys . argv [ 2 ], sys . argv [ 3 ]))
Asynchronous code must be executed in the asynchronous functions or coroutines.
So we define our function as async. We expect the following arguments:
Address of the agent.
SNMP community to authorize.
Base OID to query.
fetch.py import asyncio
import sys
from gufo.snmp import SnmpSession
async def main ( addr : str , community : str , oid : str ) -> None :
async with SnmpSession (
addr = addr , community = community , allow_bulk = True
) as session :
async for k , v in session . fetch ( oid ):
print ( f " { k } : { v } " )
asyncio . run ( main ( sys . argv [ 1 ], sys . argv [ 2 ], sys . argv [ 3 ]))
First, we need to create SnmpSession object which wraps the client's session.
The SnmpSession may be used as an instance directly or operated as async context manager
with the async with clause. When used as a context manager,
the client automatically closes all connections on the exit of context,
so its lifetime is defined explicitly.
We can use allow_bulk parameter to enable bulk requests whenever the protocol
version allows it or to deny bulk requests in any case.
Version
False
True
v1
getnext
getnext
v2c
getnext
getbulk
v3
getnext
getbulk
SnmpSession constructor offers lots of configuration variables for fine-tuning. Refer to the
SnmpSession reference
for further details. In our example, we set the agent's address and SNMP community
to the given values.
fetch.py import asyncio
import sys
from gufo.snmp import SnmpSession
async def main ( addr : str , community : str , oid : str ) -> None :
async with SnmpSession (
addr = addr , community = community , allow_bulk = True
) as session :
async for k , v in session . fetch ( oid ):
print ( f " { k } : { v } " )
asyncio . run ( main ( sys . argv [ 1 ], sys . argv [ 2 ], sys . argv [ 3 ]))
We use SnmpSession.fetch() function to iterate within base OID just like the
SnmpSession.getnext() and SnmpSession.getbulk().
The function is an asynchronous
iterator returning pairs of (OID, value), so we use async for construction to iterate over the values.
See SnmpSession.getbulk() reference
for further details.
fetch.py import asyncio
import sys
from gufo.snmp import SnmpSession
async def main ( addr : str , community : str , oid : str ) -> None :
async with SnmpSession (
addr = addr , community = community , allow_bulk = True
) as session :
async for k , v in session . fetch ( oid ):
print ( f " { k } : { v } " )
asyncio . run ( main ( sys . argv [ 1 ], sys . argv [ 2 ], sys . argv [ 3 ]))
It is up to the application how to deal with the result.
In our example we just print it.
fetch.py import asyncio
import sys
from gufo.snmp import SnmpSession
async def main ( addr : str , community : str , oid : str ) -> None :
async with SnmpSession (
addr = addr , community = community , allow_bulk = True
) as session :
async for k , v in session . fetch ( oid ):
print ( f " { k } : { v } " )
asyncio . run ( main ( sys . argv [ 1 ], sys . argv [ 2 ], sys . argv [ 3 ]))
Lets run our asynchronous main() function via asyncio.run
and pass first command-line parameters as address, community, and oid.
Running
Let's check our script. Run example as: