Golang gosnmp.GoSNMP类代码示例

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
}