func (icmp *icmpPlugin) init(results publish.Transactions, config *icmpConfig) error {
icmp.setFromConfig(config)
var err error
icmp.localIps, err = common.LocalIPAddrs()
if err != nil {
logp.Err("icmp", "Error getting local IP addresses: %s", err)
icmp.localIps = []net.IP{}
}
logp.Debug("icmp", "Local IP addresses: %s", icmp.localIps)
var removalListener = func(k common.Key, v common.Value) {
icmp.expireTransaction(k.(hashableIcmpTuple), v.(*icmpTransaction))
}
icmp.transactions = common.NewCacheWithRemovalListener(
icmp.transactionTimeout,
protos.DefaultTransactionHashSize,
removalListener)
icmp.transactions.StartJanitor(icmp.transactionTimeout)
icmp.results = results
return nil
}
func (proc *ProcessesWatcher) Init(config ProcsConfig) error {
proc.procPrefix = ""
proc.portProcMap = make(map[uint16]portProcMapping)
proc.lastMapUpdate = time.Now()
proc.readFromProc = config.Enabled
if proc.readFromProc {
if runtime.GOOS != "linux" {
proc.readFromProc = false
logp.Info("Disabled /proc/ reading because not on linux")
} else {
logp.Info("Process matching enabled")
}
} else {
logp.Info("Process matching disabled")
}
if config.MaxProcReadFreq == 0 {
proc.maxReadFreq = 10 * time.Millisecond
} else {
proc.maxReadFreq = config.MaxProcReadFreq
}
if config.RefreshPidsFreq == 0 {
proc.refreshPidsFreq = 1 * time.Second
} else {
proc.refreshPidsFreq = config.RefreshPidsFreq
}
// Read the local IP addresses
var err error
proc.localAddrs, err = common.LocalIPAddrs()
if err != nil {
logp.Err("Error getting local IP addresses: %s", err)
proc.localAddrs = []net.IP{}
}
if proc.readFromProc {
for _, procConfig := range config.Monitored {
grepper := procConfig.CmdlineGrep
if len(grepper) == 0 {
grepper = procConfig.Process
}
p, err := newProcess(proc, procConfig.Process, grepper, time.Tick(proc.refreshPidsFreq))
if err != nil {
logp.Err("NewProcess: %s", err)
} else {
proc.processes = append(proc.processes, p)
}
}
}
return nil
}
func findMatchingAddress(
addr string,
brokers []string,
) (int, bool) {
debugf("Try to match broker to: %v", addr)
// compare connection address to list of broker addresses
if i, found := indexOf(addr, brokers); found {
return i, true
}
// get connection 'port'
_, port, err := net.SplitHostPort(addr)
if err != nil || port == "" {
port = "9092"
}
// lookup local machines ips for comparing with broker addresses
localIPs, err := common.LocalIPAddrs()
if err != nil || len(localIPs) == 0 {
return -1, false
}
debugf("local machine ips: %v", localIPs)
// try to find broker by comparing the fqdn for each known ip to list of
// brokers
localHosts := lookupHosts(localIPs)
debugf("local machine addresses: %v", localHosts)
for _, host := range localHosts {
debugf("try to match with fqdn: %v (%v)", host, port)
if i, found := indexOf(net.JoinHostPort(host, port), brokers); found {
return i, true
}
}
// try to find broker id by comparing the machines local hostname to
// broker hostnames in metadata
if host, err := os.Hostname(); err == nil {
debugf("try to match with hostname only: %v (%v)", host, port)
tmp := net.JoinHostPort(strings.ToLower(host), port)
if i, found := indexOf(tmp, brokers); found {
return i, true
}
}
// lookup ips for all brokers
debugf("match by ips")
for i, b := range brokers {
debugf("test broker address: %v", b)
bh, bp, err := net.SplitHostPort(b)
if err != nil {
continue
}
// port numbers do not match
if bp != port {
continue
}
// lookup all ips for brokers host:
ips, err := net.LookupIP(bh)
debugf("broker %v ips: %v, %v", bh, ips, err)
if err != nil {
continue
}
debugf("broker (%v) ips: %v", bh, ips)
// check if ip is known
if anyIPsMatch(ips, localIPs) {
return i, true
}
}
return -1, false
}