func bulkStats(snmp *gosnmp.GoSNMP, cfg *SnmpConfig) error {
now := time.Now()
if cfg == nil {
log.Fatal("cfg is nil")
}
if cfg.Influx == nil {
log.Fatal("influx cfg is nil")
}
bps := cfg.Influx.BP()
addPacket := func(pdu gosnmp.SnmpPDU) error {
val := bulkPoint(cfg, pdu)
if val != nil && val.value != nil {
pt := makePoint(cfg.Host, val, now)
bps.Points = append(bps.Points, pt)
}
return nil
}
for i := 0; i < len(cfg.oids); i += 1 {
cfg.incRequests()
if err := snmp.BulkWalk(cfg.oids[i], addPacket); err != nil {
errLog("SNMP (%s) get error: %s\n", cfg.Host, err)
cfg.incErrors()
cfg.LastError = now
return err
}
}
cfg.Influx.Send(bps)
return nil
}
func getDiskUsage(snmp g.GoSNMP) map[int64]float64 {
result, err := snmp.GetBulk([]string{".1.3.6.1.2.1.25.2.3.1.1"}, 64, 64)
if err != nil {
log.Fatalf("Get() err: %v", err)
}
log.Println(result.Variables)
return map[int64]float64{}
}
func getTemperatures(snmp g.GoSNMP) map[int]float64 {
result, err := snmp.Get([]string{".1.3.6.1.4.1.6574.2.1.1.6.0", ".1.3.6.1.4.1.6574.2.1.1.6.1"})
if err != nil {
log.Fatalf("Get() err: %v", err)
}
temps := map[int]float64{}
for i, variable := range result.Variables {
temps[i] = float64(variable.Value.(int))
}
return temps
}
func (p LoadPlugin) FetchData(snmp g.GoSNMP) map[string]float64 {
result, err := snmp.Get([]string{".1.3.6.1.4.1.2021.10.1.5.1", ".1.3.6.1.4.1.2021.10.1.5.2", ".1.3.6.1.4.1.2021.10.1.5.3"})
if err != nil {
log.Fatalf("Get() err: %v", err)
}
return map[string]float64{
"load.shortterm": float64(result.Variables[0].Value.(int)) / 100,
"load.midterm": float64(result.Variables[1].Value.(int)) / 100,
"load.longterm": float64(result.Variables[2].Value.(int)) / 100,
}
}
func snmpStats(snmp *gosnmp.GoSNMP, cfg *SnmpConfig) error {
now := time.Now()
if cfg == nil {
log.Fatal("cfg is nil")
}
if cfg.Influx == nil {
log.Fatal("influx cfg is nil")
}
bps := cfg.Influx.BP()
// we can only get 'maxOids' worth of snmp requests at a time
for i := 0; i < len(cfg.oids); i += maxOids {
end := i + maxOids
if end > len(cfg.oids) {
end = len(cfg.oids)
}
cfg.incRequests()
pkt, err := snmp.Get(cfg.oids[i:end])
if err != nil {
errLog("SNMP (%s) get error: %s\n", cfg.Host, err)
cfg.incErrors()
cfg.LastError = now
return err
}
cfg.incGets()
if verbose {
log.Println("SNMP GET CNT:", len(pkt.Variables))
}
//log.Println("PKT", pkt)
for _, pdu := range pkt.Variables {
val := getPoint(cfg, pdu)
if val == nil {
continue
}
if val.value == nil {
continue
}
//log.Println("VAL", val)
pt := makePoint(cfg.Host, val, now)
//log.Println("PT", pt)
bps.Points = append(bps.Points, pt)
}
}
cfg.Influx.Send(bps)
return nil
}
func sysInterfaces(snmp *gosnmp.GoSNMP) (map[int]sysInterface, error) {
w, err := snmp.WalkAll(".1.3.6.1.2.1.2.2.1")
if err != nil {
return nil, err
}
ids := make(map[int]sysInterface)
for _, v := range w {
switch v.Type {
case gosnmp.OctetString:
switch {
case strings.HasPrefix(v.Name, ".1.3.6.1.2.1.2.2.1.2"):
ids[index(v.Name)] = sysInterface{Name: string(v.Value.([]byte))}
}
}
}
for _, v := range w {
i, ok := ids[index(v.Name)]
if !ok {
continue
}
switch v.Type {
case gosnmp.Integer:
switch {
case strings.HasPrefix(v.Name, ".1.3.6.1.2.1.2.2.1.3"):
i.Type = v.Value.(int)
}
case gosnmp.Counter32:
switch {
case strings.HasPrefix(v.Name, ".1.3.6.1.2.1.2.2.1.10"):
if n := (uint32)(v.Value.(uint)); true {
i.RX = &n
}
case strings.HasPrefix(v.Name, ".1.3.6.1.2.1.2.2.1.16"):
if n := (uint32)(v.Value.(uint)); true {
i.TX = &n
}
}
}
ids[index(v.Name)] = i
}
return ids, nil
}
func getTable(g *gosnmp.GoSNMP, oid string) {
results, err := g.WalkAll(oid)
if err != nil {
log.Fatalf("Get() err: %v", err)
}
for _, variable := range results {
fmt.Printf("oid: %s ", variable.Name[len(oid)+1:])
// the Value of each variable returned by Get() implements
// interface{}. You could do a type switch...
switch variable.Type {
case gosnmp.OctetString:
fmt.Printf("string: %s\n", string(variable.Value.([]byte)))
default:
// ... or often you're just interested in numeric values.
// ToBigInt() will return the Value as a BigInt, for plugging
// into your calculations.
fmt.Printf("number: %d\n", gosnmp.ToBigInt(variable.Value))
}
}
}
func sysObjectID(snmp *gosnmp.GoSNMP) (*string, error) {
r, err := snmp.Get([]string{
".1.3.6.1.2.1.1.2.0",
})
if r == nil || err != nil {
return nil, err
}
var oid *string
for _, v := range r.Variables {
switch v.Type {
case gosnmp.ObjectIdentifier:
switch v.Name {
case ".1.3.6.1.2.1.1.2.0":
if a := v.Value.(string); a != "" {
oid = &a
}
}
}
}
return oid, nil
}
func (p CPUPlugin) FetchData(snmp g.GoSNMP) map[string]float64 {
oids := []string{
".1.3.6.1.4.1.2021.11.50.0",
".1.3.6.1.4.1.2021.11.51.0",
".1.3.6.1.4.1.2021.11.52.0",
".1.3.6.1.4.1.2021.11.53.0",
".1.3.6.1.4.1.2021.11.54.0",
".1.3.6.1.4.1.2021.11.55.0",
".1.3.6.1.4.1.2021.11.56.0",
}
result, err := snmp.Get(oids)
if err != nil {
log.Fatalf("Get() err: %v", err)
}
return map[string]float64{
"cpu-0.cpu-user": float64(result.Variables[0].Value.(uint)),
"cpu-0.cpu-nice": float64(result.Variables[1].Value.(uint)),
"cpu-0.cpu-system": float64(result.Variables[2].Value.(uint)),
"cpu-0.cpu-idle": float64(result.Variables[3].Value.(uint)),
"cpu-0.cpu-wait": float64(result.Variables[4].Value.(uint)),
"cpu-0.cpu-kernel": float64(result.Variables[5].Value.(uint)),
"cpu-0.cpu-interrupt": float64(result.Variables[6].Value.(uint)),
}
}
// configureSNMP sets the various version and auth settings.
func (c Module) configureSNMP(g *gosnmp.GoSNMP) {
switch c.Version {
case 1:
g.Version = gosnmp.Version1
case 2:
g.Version = gosnmp.Version2c
case 3:
g.Version = gosnmp.Version3
}
g.Community = c.Auth.Community
// v3 security settings.
g.SecurityModel = gosnmp.UserSecurityModel
switch c.Auth.SecurityLevel {
case "noAuthNoPriv":
g.MsgFlags = gosnmp.NoAuthNoPriv
case "authNoPriv":
g.MsgFlags = gosnmp.AuthNoPriv
case "authPriv":
g.MsgFlags = gosnmp.AuthPriv
}
usm := &gosnmp.UsmSecurityParameters{
UserName: c.Auth.Username,
AuthenticationPassphrase: c.Auth.Password,
PrivacyPassphrase: c.Auth.PrivPassword,
}
switch c.Auth.AuthProtocol {
case "SHA":
usm.AuthenticationProtocol = gosnmp.SHA
case "MD5":
usm.AuthenticationProtocol = gosnmp.MD5
}
switch c.Auth.PrivProtocol {
case "DES":
usm.PrivacyProtocol = gosnmp.DES
case "AES":
usm.PrivacyProtocol = gosnmp.AES
}
g.SecurityParameters = usm
}
)
var CmdFetchData = func(c *cli.Context) {
diskStation := c.String("ds")
interval := c.Duration("interval")
prefix := c.String("prefix")
carbonHost := c.String("carbon-host")
carbonPort := c.String("carbon-port")
carbonAddr := fmt.Sprintf("%s:%s", carbonHost, carbonPort)
// SNMP Configuration
snmp := g.GoSNMP{
Target: diskStation,
Port: 161,
Community: "public",
Version: g.Version2c,
Timeout: time.Duration(2) * time.Second,
}
// Plugins
plugins := []p.Plugin{p.DiskPlugin{}, p.LoadPlugin{}, p.CPUPlugin{}} //, p.MemoryPlugin{}, p.NetworkPlugin{}}
// Execute plugins every interval
for now := range time.Tick(interval) {
snmp.Connect()
defer snmp.Conn.Close()
for _, plugin := range plugins {
data := plugin.FetchData(snmp)
for key, value := range data {
metric := fmt.Sprintf("%s.%s %v %d\n\r", prefix, key, value, now.Unix())
func ScrapeTarget(target string, config *Module) ([]gosnmp.SnmpPDU, error) {
// Set the options.
snmp := gosnmp.GoSNMP{}
snmp.Retries = 3
snmp.MaxRepetitions = 25
snmp.Timeout = time.Second * 60
snmp.Target = target
snmp.Port = 161
if host, port, err := net.SplitHostPort(target); err == nil {
snmp.Target = host
p, err := strconv.Atoi(port)
if err != nil {
return nil, fmt.Errorf("Error converting port number to int for target %s: %s", target, err)
}
snmp.Port = uint16(p)
}
// Configure auth.
config.configureSNMP(&snmp)
// Do the actual walk.
err := snmp.Connect()
if err != nil {
return nil, fmt.Errorf("Error connecting to target %s: %s", target, err)
}
defer snmp.Conn.Close()
result := []gosnmp.SnmpPDU{}
for _, subtree := range config.Walk {
var pdus []gosnmp.SnmpPDU
if snmp.Version == gosnmp.Version1 {
pdus, err = snmp.WalkAll(subtree)
} else {
pdus, err = snmp.BulkWalkAll(subtree)
}
if err != nil {
return nil, fmt.Errorf("Error walking target %s: %s", snmp.Target, err)
}
result = append(result, pdus...)
}
return result, nil
}