Metadata-Version: 2.1
Name: gosnmp-traps-python
Version: 0.91
Summary: GoSNMP Traps Python
Home-page: https://github.com/ftpsolutions/gosnmp-traps-python
Author: Edward @ FTP Technologies
Author-email: edward.beech@ftpsolutions.com.au
License: MIT
Description: ## gosnmp-traps-python
        
        The purpose of this module is to provide a Python interface to the Golang [gosnmp](https://github.com/soniah/gosnmp) module (but only for
        the SNMP traps side of that library and with a few tweaks).
        
        It was made very easy with the help of the Golang [gopy](https://github.com/go-python/gopy) module.
        
        #### Versions
        
        This version (0.91) is the last version to support Python 2; all versions after this have been subject to a refactor and support Python 3
        only.
        
        #### Limitations
        
        * Python command needs to be prefixed with GODEBUG=cgocheck=0 (or have that in the environment)
        * I've not implemented walk (as I didn't need it for my use-case, I just use get_next with Python)
        * Seems to have some odd memory problems with PyPy (via CFFI); lots of locks and stuff to try and alleviate that
        
        #### How do I make use of this?
        
        Right now I'm still working on how to put it all together as a Python module, so here are the raw steps.
        
        #### Prerequisites
        
        * Go 1.13
        * Python 2.7+
        * pip
        * virtualenvwrapper
        * pkgconfig/pkg-config
        
        #### Installation (from PyPI)
        
        * ```python -m pip install gosnmp-traps-python```
        
        #### Installation (for prod)
        
        * ```python setup.py install```
        
        #### Making a python wheel install file (for distribution)
        
        * ```python setup.py bdist_wheel```
        
        #### Setup (for dev)
        
        * ```mkvirtualenvwrapper -p (/path/to/pypy) gosnmp-traps-python```
        * ```pip install -r requirements-dev.txt```
        * ```./build.sh```
        * ```GODEBUG=cgocheck=0 py.test -v```
        
        #### What's worth knowing if I want to further the development?
        
        * gopy doesn't like Go interfaces; so make sure you don't have any public (exported) interfaces
            * this includes a struct with a public property that may eventually lead to an interface
        
        #### Example Go RPCSession usage (simple session ID, calls return JSON)
        
        The only reason you'd want to use this (in Golang) is if you wanted to listen on a single port for multiple different SNMP configurations.
        
        ```
        package main
        
        import (
        	"bufio"
        	"fmt"
        	"gosnmp_traps_python"
        	"log"
        	"os"
        )
        
        func main() {
        	// we need this because without it, we'll try and manipulate the Python GIL (which may not be present)
        	gosnmp_traps_python.SetPyPy()
        
        	// define both an SNMPv2c and SNMPv3 trap configurations
        	paramsJSON := `
        	[
        		{
        			"Community": "public"
        		},
        		{
        			"SecurityLevel": "authPriv",
        			"SecurityUsername": "some_username",
        			"AuthenticationProtocol": "SHA",
        			"AuthenticationPassword": "some_auth_password",
        			"PrivacyProtocol": "AES",
        			"PrivacyPassword": "some_priv_password"
        		}
        	]
        	`
        
        	sessionID, err := gosnmp_traps_python.NewRPCSession(
        		"0.0.0.0",
        		162,
        		5,
        		paramsJSON,
        	)
        	if err != nil {
        		log.Fatal(err)
        	}
        
        	err = gosnmp_traps_python.RPCConnect(sessionID)
        	if err != nil {
        		log.Fatal(err)
        	}
        
        	fmt.Print("Press enter to quit...")
        	bufio.NewReader(os.Stdin).ReadBytes('\n')
        
        	result, err := gosnmp_traps_python.RPCGetNoWait(sessionID)
        	if err != nil {
        		log.Fatal(err)
        	}
        
        	fmt.Println(result)
        
        	gosnmp_traps_python.RPCClose(sessionID)
        }
        ```
        
        #### Example Python usage (uses RPCSession underneath because of memory leaks between Go and Python with structs)
        
        The example belows shows how to define the same two listeners we defined above (using the `SNMPv2cParams` and `SNMPv3Params`)
        
        ```
        import pprint
        import time
        from Queue import Empty
        
        from gosnmp_traps_python.rpc_session import SNMPv2cParams, SNMPv3Params, create_session
        
        session = create_session(
            params_list=[
                SNMPv2cParams(
                    community_string='public',
                ),
                SNMPv3Params(
                    security_username='some_username',
                    security_level='authPriv',
                    auth_protocol='SHA',
                    auth_password='some_auth_password',
                    privacy_protocol='AES',
                    privacy_password='some_priv_password',
                )
            ]
        )
        
        session.connect()
        
        print 'CTRL + C to quit'
        
        while 1:
            try:
                time.sleep(1)
            except KeyboardInterrupt:
                break
        
        print ''
        
        try:
            received_traps = session.get_nowait()
        except Empty as e:
            print 'No traps received'
            received_traps = []
        
        pprint.pprint(received_traps)
        
        session.close()
        ```
        
        If we run the above code and then send some SNMP traps to this listener (in my example, I configured a Cisco switch to export traps and ran
        the "conf t" command) then we'll get some output similar to the below:
        
        ```
        [
            ReceivedTrap(
                timestamp=datetime.datetime(2018, 8, 8, 9, 57, 42, 574456, tzinfo=tzoffset(None, 28800)), 
                source_ip=u'10.10.0.2', 
                source_port=54199, 
                variables=[
                    SNMPVariable(
                        oid=u'.1.3.6.1.2.1.1.3', 
                        oid_index=0, 
                        snmp_type=u'int', 
                        value=206412043
                    ), 
                    SNMPVariable(
                        oid=u'.1.3.6.1.6.3.1.1.4.1', 
                        oid_index=0, 
                        snmp_type=u'string', 
                        value=u'.1.3.6.1.4.1.9.9.43.2.0.1'
                    ), 
                    SNMPVariable(
                        oid=u'.1.3.6.1.4.1.9.9.43.1.1.6.1.3', 
                        oid_index=223, 
                        snmp_type=u'int', 
                        value=1
                    ), 
                    SNMPVariable(
                        oid=u'.1.3.6.1.4.1.9.9.43.1.1.6.1.4', 
                        oid_index=223, 
                        snmp_type=u'int', 
                        value=2
                    ), 
                    SNMPVariable(
                        oid=u'.1.3.6.1.4.1.9.9.43.1.1.6.1.5', 
                        oid_index=223, 
                        snmp_type=u'int', 
                        value=3
                    )
                ]
            )
        ]
        ```
        
        So to summarise, each call to `get_nowait()` will either raise `Queue.Empty` or return a list of `ReceivedTrap` objects.
        
        The SNMPVariable object is meant to feel like [easysnmp](https://github.com/kamakazikamikaze/easysnmp).
        
        ## To run test container
        
            ./test.sh
        
        ## To develop
        
            MOUNT_WORKSPACE=1 ./test.sh bash
            ./build.sh
            py.test -s
        
Platform: UNKNOWN
Classifier: Development Status :: 7 - Inactive
Classifier: Intended Audience :: Developers
Classifier: Programming Language :: Python :: 2.7
Classifier: Operating System :: POSIX
Classifier: Operating System :: Unix
Classifier: Operating System :: MacOS
Description-Content-Type: text/markdown
