mirror of
https://github.com/prometheus-community/ipmi_exporter
synced 2024-12-22 22:12:34 +00:00
39622179c4
Add the exporter-toolkit to support TLS and authentication. * Cleanup error throwaway in logging calls. * Bump Go modules. Signed-off-by: SuperQ <superq@gmail.com>
285 lines
7.7 KiB
Go
285 lines
7.7 KiB
Go
// Copyright 2021 The Prometheus Authors
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"io/ioutil"
|
|
"strings"
|
|
"sync"
|
|
|
|
"github.com/go-kit/log/level"
|
|
"github.com/prometheus/client_golang/prometheus"
|
|
|
|
"github.com/prometheus-community/ipmi_exporter/freeipmi"
|
|
|
|
yaml "gopkg.in/yaml.v2"
|
|
)
|
|
|
|
// CollectorName is used for unmarshaling the list of collectors in the yaml config file
|
|
type CollectorName string
|
|
|
|
// ConfiguredCollector wraps an existing collector implementation,
|
|
// potentially altering its default settings.
|
|
type ConfiguredCollector struct {
|
|
collector collector
|
|
command string
|
|
default_args []string
|
|
custom_args []string
|
|
}
|
|
|
|
func (c ConfiguredCollector) Name() CollectorName {
|
|
return c.collector.Name()
|
|
}
|
|
|
|
func (c ConfiguredCollector) Cmd() string {
|
|
if c.command != "" {
|
|
return c.command
|
|
}
|
|
return c.collector.Cmd()
|
|
}
|
|
|
|
func (c ConfiguredCollector) Args() []string {
|
|
args := []string{}
|
|
if c.custom_args != nil {
|
|
// custom args come first, this way it is quite easy to
|
|
// override a collector to use e.g. sudo
|
|
args = append(args, c.custom_args...)
|
|
}
|
|
if c.default_args != nil {
|
|
args = append(args, c.default_args...)
|
|
} else {
|
|
args = append(args, c.collector.Args()...)
|
|
}
|
|
return args
|
|
}
|
|
|
|
func (c ConfiguredCollector) Collect(output freeipmi.Result, ch chan<- prometheus.Metric, target ipmiTarget) (int, error) {
|
|
return c.collector.Collect(output, ch, target)
|
|
}
|
|
|
|
func (c CollectorName) GetInstance() (collector, error) {
|
|
// This is where a new collector would have to be "registered"
|
|
switch c {
|
|
case IPMICollectorName:
|
|
return IPMICollector{}, nil
|
|
case BMCCollectorName:
|
|
return BMCCollector{}, nil
|
|
case SELCollectorName:
|
|
return SELCollector{}, nil
|
|
case DCMICollectorName:
|
|
return DCMICollector{}, nil
|
|
case ChassisCollectorName:
|
|
return ChassisCollector{}, nil
|
|
case SMLANModeCollectorName:
|
|
return SMLANModeCollector{}, nil
|
|
}
|
|
return nil, fmt.Errorf("invalid collector: %s", string(c))
|
|
}
|
|
|
|
func (c CollectorName) IsValid() error {
|
|
_, err := c.GetInstance()
|
|
return err
|
|
}
|
|
|
|
// Config is the Go representation of the yaml config file.
|
|
type Config struct {
|
|
Modules map[string]IPMIConfig `yaml:"modules"`
|
|
|
|
// Catches all undefined fields and must be empty after parsing.
|
|
XXX map[string]interface{} `yaml:",inline"`
|
|
}
|
|
|
|
// SafeConfig wraps Config for concurrency-safe operations.
|
|
type SafeConfig struct {
|
|
sync.RWMutex
|
|
C *Config
|
|
}
|
|
|
|
// IPMIConfig is the Go representation of a module configuration in the yaml
|
|
// config file.
|
|
type IPMIConfig struct {
|
|
User string `yaml:"user"`
|
|
Password string `yaml:"pass"`
|
|
Privilege string `yaml:"privilege"`
|
|
Driver string `yaml:"driver"`
|
|
Timeout uint32 `yaml:"timeout"`
|
|
Collectors []CollectorName `yaml:"collectors"`
|
|
ExcludeSensorIDs []int64 `yaml:"exclude_sensor_ids"`
|
|
WorkaroundFlags []string `yaml:"workaround_flags"`
|
|
CollectorCmd map[CollectorName]string `yaml:"collector_cmd"`
|
|
CollectorArgs map[CollectorName][]string `yaml:"default_args"`
|
|
CustomArgs map[CollectorName][]string `yaml:"custom_args"`
|
|
|
|
// Catches all undefined fields and must be empty after parsing.
|
|
XXX map[string]interface{} `yaml:",inline"`
|
|
}
|
|
|
|
var defaultConfig = IPMIConfig{
|
|
Collectors: []CollectorName{IPMICollectorName, DCMICollectorName, BMCCollectorName, ChassisCollectorName},
|
|
}
|
|
|
|
func checkOverflow(m map[string]interface{}, ctx string) error {
|
|
if len(m) > 0 {
|
|
var keys []string
|
|
for k := range m {
|
|
keys = append(keys, k)
|
|
}
|
|
return fmt.Errorf("unknown fields in %s: %s", ctx, strings.Join(keys, ", "))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// UnmarshalYAML implements the yaml.Unmarshaler interface.
|
|
func (s *Config) UnmarshalYAML(unmarshal func(interface{}) error) error {
|
|
type plain Config
|
|
if err := unmarshal((*plain)(s)); err != nil {
|
|
return err
|
|
}
|
|
if err := checkOverflow(s.XXX, "config"); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// UnmarshalYAML implements the yaml.Unmarshaler interface.
|
|
func (s *IPMIConfig) UnmarshalYAML(unmarshal func(interface{}) error) error {
|
|
*s = defaultConfig
|
|
type plain IPMIConfig
|
|
if err := unmarshal((*plain)(s)); err != nil {
|
|
return err
|
|
}
|
|
if err := checkOverflow(s.XXX, "modules"); err != nil {
|
|
return err
|
|
}
|
|
for _, c := range s.Collectors {
|
|
if err := c.IsValid(); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (c IPMIConfig) GetCollectors() []collector {
|
|
result := []collector{}
|
|
for _, co := range c.Collectors {
|
|
// At this point validity has already been checked
|
|
i, _ := co.GetInstance()
|
|
cc := ConfiguredCollector{
|
|
collector: i,
|
|
command: c.CollectorCmd[i.Name()],
|
|
default_args: c.CollectorArgs[i.Name()],
|
|
custom_args: c.CustomArgs[i.Name()],
|
|
}
|
|
result = append(result, cc)
|
|
}
|
|
return result
|
|
}
|
|
|
|
func (c IPMIConfig) GetFreeipmiConfig() string {
|
|
var b strings.Builder
|
|
if c.Driver != "" {
|
|
fmt.Fprintf(&b, "driver-type %s\n", c.Driver)
|
|
}
|
|
if c.Privilege != "" {
|
|
fmt.Fprintf(&b, "privilege-level %s\n", c.Privilege)
|
|
}
|
|
if c.User != "" {
|
|
fmt.Fprintf(&b, "username %s\n", c.User)
|
|
}
|
|
if c.Password != "" {
|
|
fmt.Fprintf(&b, "password %s\n", freeipmi.EscapePassword(c.Password))
|
|
}
|
|
if c.Timeout != 0 {
|
|
fmt.Fprintf(&b, "session-timeout %d\n", c.Timeout)
|
|
}
|
|
if len(c.WorkaroundFlags) > 0 {
|
|
fmt.Fprintf(&b, "workaround-flags")
|
|
for _, flag := range c.WorkaroundFlags {
|
|
fmt.Fprintf(&b, " %s", flag)
|
|
}
|
|
fmt.Fprintln(&b)
|
|
}
|
|
return b.String()
|
|
}
|
|
|
|
// ReloadConfig reloads the config in a concurrency-safe way. If the configFile
|
|
// is unreadable or unparsable, an error is returned and the old config is kept.
|
|
func (sc *SafeConfig) ReloadConfig(configFile string) error {
|
|
var c = &Config{}
|
|
var config []byte
|
|
var err error
|
|
|
|
if configFile != "" {
|
|
config, err = ioutil.ReadFile(configFile)
|
|
if err != nil {
|
|
level.Error(logger).Log("msg", "Error reading config file", "error", err)
|
|
return err
|
|
}
|
|
} else {
|
|
config = []byte("# use empty file as default")
|
|
}
|
|
|
|
if err = yaml.Unmarshal(config, c); err != nil {
|
|
return err
|
|
}
|
|
|
|
sc.Lock()
|
|
sc.C = c
|
|
sc.Unlock()
|
|
|
|
if configFile != "" {
|
|
level.Info(logger).Log("msg", "Loaded config file", "path", configFile)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// HasModule returns true if a given module is configured. It is concurrency-safe.
|
|
func (sc *SafeConfig) HasModule(module string) bool {
|
|
sc.Lock()
|
|
defer sc.Unlock()
|
|
|
|
_, ok := sc.C.Modules[module]
|
|
return ok
|
|
}
|
|
|
|
// ConfigForTarget returns the config for a given target/module, or the
|
|
// default. It is concurrency-safe.
|
|
func (sc *SafeConfig) ConfigForTarget(target, module string) IPMIConfig {
|
|
sc.Lock()
|
|
defer sc.Unlock()
|
|
|
|
var config IPMIConfig
|
|
var ok = false
|
|
|
|
if module != "default" {
|
|
config, ok = sc.C.Modules[module]
|
|
if !ok {
|
|
level.Error(logger).Log("msg", "Requested module not found, using default", "module", module, "target", targetName(target))
|
|
}
|
|
}
|
|
|
|
// If nothing found, fall back to defaults
|
|
if !ok {
|
|
config, ok = sc.C.Modules["default"]
|
|
if !ok {
|
|
// This is probably fine for running locally, so not making this a warning
|
|
level.Debug(logger).Log("msg", "Needed default config for, but none configured, using FreeIPMI defaults", "target", targetName(target))
|
|
config = defaultConfig
|
|
}
|
|
}
|
|
|
|
return config
|
|
}
|