cdramey
/
alrm
1
0
Fork 0
Code Releases Activity
Browse Source

Changed groups and hosts to use maps in config, reorganized code, cleaned up command line arguments

master
Christopher Ramey 3 years ago
parent
aa1d4d10fa
commit
826564a060
10 changed files with 845 additions and 105 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 8
      alrmrc
  2. 9
      check/check.go
  3. 3
      check/check_ping.go
  4. 660
      check/ping/ping.go
  5. 50
      config.go
  6. 44
      config/config.go
  7. 24
      config/group.go
  8. 27
      config/host.go
  9. 91
      config/parser.go
  10. 34
      main.go

8
alrmrc
View File

@ -1,11 +1,13 @@
set interval 30
monitor host gateway address 10.11.135.100
monitor group webservers
host www1.example.com address 10.11.135.101
check ping
host www2.example.com address 10.11.135.102
check ping
# comments can occur at the beginning
check ping # or the end of a line
check ping # checks are not named, so multiple is okay
monitor host gateway address 10.11.135.100
monitor host database

9
check.go → check/check.go
View File

@ -1,13 +1,18 @@
package main
package check
import (
"fmt"
)
type AlrmCheck interface {
Parse(string) (bool, error)
Check() error
}
func NewCheck(name string, addr string) (AlrmCheck, error) {
switch name {
case "ping":
return &CheckPing{Address: addr}, nil
return &CheckPing{Type: "ping", Address: addr}, nil
default:
return nil, fmt.Errorf("unknown check name \"%s\"", name)
}

3
check_ping.go → check/check_ping.go
View File

@ -1,6 +1,7 @@
package main
package check
type CheckPing struct {
Type string
Address string
}

660
check/ping/ping.go
View File

@ -0,0 +1,660 @@
// Package ping is an ICMP ping library seeking to emulate the unix "ping"
// command.
//
// Here is a very simple example that sends & receives 3 packets:
//
// pinger, err := ping.NewPinger("www.google.com")
// if err != nil {
// panic(err)
// }
//
// pinger.Count = 3
// pinger.Run() // blocks until finished
// stats := pinger.Statistics() // get send/receive/rtt stats
//
// Here is an example that emulates the unix ping command:
//
// pinger, err := ping.NewPinger("www.google.com")
// if err != nil {
// fmt.Printf("ERROR: %s\n", err.Error())
// return
// }
//
// pinger.OnRecv = func(pkt *ping.Packet) {
// fmt.Printf("%d bytes from %s: icmp_seq=%d time=%v\n",
// pkt.Nbytes, pkt.IPAddr, pkt.Seq, pkt.Rtt)
// }
// pinger.OnFinish = func(stats *ping.Statistics) {
// fmt.Printf("\n--- %s ping statistics ---\n", stats.Addr)
// fmt.Printf("%d packets transmitted, %d packets received, %v%% packet loss\n",
// stats.PacketsSent, stats.PacketsRecv, stats.PacketLoss)
// fmt.Printf("round-trip min/avg/max/stddev = %v/%v/%v/%v\n",
// stats.MinRtt, stats.AvgRtt, stats.MaxRtt, stats.StdDevRtt)
// }
//
// fmt.Printf("PING %s (%s):\n", pinger.Addr(), pinger.IPAddr())
// pinger.Run()
//
// It sends ICMP packet(s) and waits for a response. If it receives a response,
// it calls the "receive" callback. When it's finished, it calls the "finish"
// callback.
//
// For a full ping example, see "cmd/ping/ping.go".
//
package ping
import (
"bytes"
"encoding/binary"
"errors"
"fmt"
"math"
"math/rand"
"net"
"runtime"
"sync"
"syscall"
"time"
"golang.org/x/net/icmp"
"golang.org/x/net/ipv4"
"golang.org/x/net/ipv6"
)
const (
timeSliceLength = 8
trackerLength = 8
protocolICMP = 1
protocolIPv6ICMP = 58
)
var (
ipv4Proto = map[string]string{"icmp": "ip4:icmp", "udp": "udp4"}
ipv6Proto = map[string]string{"icmp": "ip6:ipv6-icmp", "udp": "udp6"}
)
// New returns a new Pinger struct pointer.
func New(addr string) *Pinger {
r := rand.New(rand.NewSource(time.Now().UnixNano()))
return &Pinger{
Count: -1,
Interval: time.Second,
RecordRtts: true,
Size: timeSliceLength,
Timeout: time.Second * 100000,
Tracker: r.Int63n(math.MaxInt64),
addr: addr,
done: make(chan bool),
id: r.Intn(math.MaxInt16),
ipaddr: nil,
ipv4: false,
network: "ip",
protocol: "udp",
}
}
// NewPinger returns a new Pinger and resolves the address.
func NewPinger(addr string) (*Pinger, error) {
p := New(addr)
return p, p.Resolve()
}
// Pinger represents a packet sender/receiver.
type Pinger struct {
// Interval is the wait time between each packet send. Default is 1s.
Interval time.Duration
// Timeout specifies a timeout before ping exits, regardless of how many
// packets have been received.
Timeout time.Duration
// Count tells pinger to stop after sending (and receiving) Count echo
// packets. If this option is not specified, pinger will operate until
// interrupted.
Count int
// Debug runs in debug mode
Debug bool
// Number of packets sent
PacketsSent int
// Number of packets received
PacketsRecv int
// If true, keep a record of rtts of all received packets.
// Set to false to avoid memory bloat for long running pings.
RecordRtts bool
// rtts is all of the Rtts
rtts []time.Duration
// OnSend is called when Pinger sends a packet
OnSend func(*Packet)
// OnRecv is called when Pinger receives and processes a packet
OnRecv func(*Packet)
// OnFinish is called when Pinger exits
OnFinish func(*Statistics)
// Size of packet being sent
Size int
// Tracker: Used to uniquely identify packet when non-priviledged
Tracker int64
// Source is the source IP address
Source string
// stop chan bool
done chan bool
ipaddr *net.IPAddr
addr string
ipv4 bool
id int
sequence int
// network is one of "ip", "ip4", or "ip6".
network string
// protocol is "icmp" or "udp".
protocol string
}
type packet struct {
bytes []byte
nbytes int
ttl int
}
// Packet represents a received and processed ICMP echo packet.
type Packet struct {
// Rtt is the round-trip time it took to ping.
Rtt time.Duration
// IPAddr is the address of the host being pinged.
IPAddr *net.IPAddr
// Addr is the string address of the host being pinged.
Addr string
// NBytes is the number of bytes in the message.
Nbytes int
// Seq is the ICMP sequence number.
Seq int
// TTL is the Time To Live on the packet.
Ttl int
}
// Statistics represent the stats of a currently running or finished
// pinger operation.
type Statistics struct {
// PacketsRecv is the number of packets received.
PacketsRecv int
// PacketsSent is the number of packets sent.
PacketsSent int
// PacketLoss is the percentage of packets lost.
PacketLoss float64
// IPAddr is the address of the host being pinged.
IPAddr *net.IPAddr
// Addr is the string address of the host being pinged.
Addr string
// Rtts is all of the round-trip times sent via this pinger.
Rtts []time.Duration
// MinRtt is the minimum round-trip time sent via this pinger.
MinRtt time.Duration
// MaxRtt is the maximum round-trip time sent via this pinger.
MaxRtt time.Duration
// AvgRtt is the average round-trip time sent via this pinger.
AvgRtt time.Duration
// StdDevRtt is the standard deviation of the round-trip times sent via
// this pinger.
StdDevRtt time.Duration
}
// SetIPAddr sets the ip address of the target host.
func (p *Pinger) SetIPAddr(ipaddr *net.IPAddr) {
p.ipv4 = isIPv4(ipaddr.IP)
p.ipaddr = ipaddr
p.addr = ipaddr.String()
}
// IPAddr returns the ip address of the target host.
func (p *Pinger) IPAddr() *net.IPAddr {
return p.ipaddr
}
// Resolve does the DNS lookup for the Pinger address and sets IP protocol.
func (p *Pinger) Resolve() error {
if len(p.addr) == 0 {
return errors.New("addr cannot be empty")
}
ipaddr, err := net.ResolveIPAddr(p.network, p.addr)
if err != nil {
return err
}
p.ipv4 = isIPv4(ipaddr.IP)
p.ipaddr = ipaddr
return nil
}
// SetAddr resolves and sets the ip address of the target host, addr can be a
// DNS name like "www.google.com" or IP like "127.0.0.1".
func (p *Pinger) SetAddr(addr string) error {
oldAddr := p.addr
p.addr = addr
err := p.Resolve()
if err != nil {
p.addr = oldAddr
return err
}
return nil
}
// Addr returns the string ip address of the target host.
func (p *Pinger) Addr() string {
return p.addr
}
// SetNetwork allows configuration of DNS resolution.
// * "ip" will automatically select IPv4 or IPv6.
// * "ip4" will select IPv4.
// * "ip6" will select IPv6.
func (p *Pinger) SetNetwork(n string) {
switch n {
case "ip4":
p.network = "ip4"
case "ip6":
p.network = "ip6"
default:
p.network = "ip"
}
}
// SetPrivileged sets the type of ping pinger will send.
// false means pinger will send an "unprivileged" UDP ping.
// true means pinger will send a "privileged" raw ICMP ping.
// NOTE: setting to true requires that it be run with super-user privileges.
func (p *Pinger) SetPrivileged(privileged bool) {
if privileged {
p.protocol = "icmp"
} else {
p.protocol = "udp"
}
}
// Privileged returns whether pinger is running in privileged mode.
func (p *Pinger) Privileged() bool {
return p.protocol == "icmp"
}
// Run runs the pinger. This is a blocking function that will exit when it's
// done. If Count or Interval are not specified, it will run continuously until
// it is interrupted.
func (p *Pinger) Run() error {
var conn *icmp.PacketConn
var err error
if p.ipaddr == nil {
err = p.Resolve()
}
if err != nil {
return err
}
if p.ipv4 {
if conn, err = p.listen(ipv4Proto[p.protocol]); err != nil {
return err
}
if err = conn.IPv4PacketConn().SetControlMessage(ipv4.FlagTTL, true); runtime.GOOS != "windows" && err != nil {
return err
}
} else {
if conn, err = p.listen(ipv6Proto[p.protocol]); err != nil {
return err
}
if err = conn.IPv6PacketConn().SetControlMessage(ipv6.FlagHopLimit, true); runtime.GOOS != "windows" && err != nil {
return err
}
}
defer conn.Close()
defer p.finish()
var wg sync.WaitGroup
recv := make(chan *packet, 5)
defer close(recv)
wg.Add(1)
//nolint:errcheck
go p.recvICMP(conn, recv, &wg)
err = p.sendICMP(conn)
if err != nil {
return err
}
timeout := time.NewTicker(p.Timeout)
defer timeout.Stop()
interval := time.NewTicker(p.Interval)
defer interval.Stop()
for {
select {
case <-p.done:
wg.Wait()
return nil
case <-timeout.C:
close(p.done)
wg.Wait()
return nil
case <-interval.C:
if p.Count > 0 && p.PacketsSent >= p.Count {
continue
}
err = p.sendICMP(conn)
if err != nil {
// FIXME: this logs as FATAL but continues
fmt.Println("FATAL: ", err.Error())
}
case r := <-recv:
err := p.processPacket(r)
if err != nil {
// FIXME: this logs as FATAL but continues
fmt.Println("FATAL: ", err.Error())
}
}
if p.Count > 0 && p.PacketsRecv >= p.Count {
close(p.done)
wg.Wait()
return nil
}
}
}
func (p *Pinger) Stop() {
close(p.done)
}
func (p *Pinger) finish() {
handler := p.OnFinish
if handler != nil {
s := p.Statistics()
handler(s)
}
}
// Statistics returns the statistics of the pinger. This can be run while the
// pinger is running or after it is finished. OnFinish calls this function to
// get it's finished statistics.
func (p *Pinger) Statistics() *Statistics {
loss := float64(p.PacketsSent-p.PacketsRecv) / float64(p.PacketsSent) * 100
var min, max, total time.Duration
if len(p.rtts) > 0 {
min = p.rtts[0]
max = p.rtts[0]
}
for _, rtt := range p.rtts {
if rtt < min {
min = rtt
}
if rtt > max {
max = rtt
}
total += rtt
}
s := Statistics{
PacketsSent: p.PacketsSent,
PacketsRecv: p.PacketsRecv,
PacketLoss: loss,
Rtts: p.rtts,
Addr: p.addr,
IPAddr: p.ipaddr,
MaxRtt: max,
MinRtt: min,
}
if len(p.rtts) > 0 {
s.AvgRtt = total / time.Duration(len(p.rtts))
var sumsquares time.Duration
for _, rtt := range p.rtts {
sumsquares += (rtt - s.AvgRtt) * (rtt - s.AvgRtt)
}
s.StdDevRtt = time.Duration(math.Sqrt(
float64(sumsquares / time.Duration(len(p.rtts)))))
}
return &s
}
func (p *Pinger) recvICMP(
conn *icmp.PacketConn,
recv chan<- *packet,
wg *sync.WaitGroup,
) error {
defer wg.Done()
for {
select {
case <-p.done:
return nil
default:
bytes := make([]byte, 512)
if err := conn.SetReadDeadline(time.Now().Add(time.Millisecond * 100)); err != nil {
return err
}
var n, ttl int
var err error
if p.ipv4 {
var cm *ipv4.ControlMessage
n, cm, _, err = conn.IPv4PacketConn().ReadFrom(bytes)
if cm != nil {
ttl = cm.TTL
}
} else {
var cm *ipv6.ControlMessage
n, cm, _, err = conn.IPv6PacketConn().ReadFrom(bytes)
if cm != nil {
ttl = cm.HopLimit
}
}
if err != nil {
if neterr, ok := err.(*net.OpError); ok {
if neterr.Timeout() {
// Read timeout
continue
} else {
close(p.done)
return err
}
}
}
select {
case <-p.done:
return nil
case recv <- &packet{bytes: bytes, nbytes: n, ttl: ttl}:
}
}
}
}
func (p *Pinger) processPacket(recv *packet) error {
receivedAt := time.Now()
var proto int
if p.ipv4 {
proto = protocolICMP
} else {
proto = protocolIPv6ICMP
}
var m *icmp.Message
var err error
if m, err = icmp.ParseMessage(proto, recv.bytes); err != nil {
return fmt.Errorf("error parsing icmp message: %s", err.Error())
}
if m.Type != ipv4.ICMPTypeEchoReply && m.Type != ipv6.ICMPTypeEchoReply {
// Not an echo reply, ignore it
return nil
}
outPkt := &Packet{
Nbytes: recv.nbytes,
IPAddr: p.ipaddr,
Addr: p.addr,
Ttl: recv.ttl,
}
switch pkt := m.Body.(type) {
case *icmp.Echo:
// If we are priviledged, we can match icmp.ID
if p.protocol == "icmp" {
// Check if reply from same ID
if pkt.ID != p.id {
return nil
}
}
if len(pkt.Data) < timeSliceLength+trackerLength {
return fmt.Errorf("insufficient data received; got: %d %v",
len(pkt.Data), pkt.Data)
}
tracker := bytesToInt(pkt.Data[timeSliceLength:])
timestamp := bytesToTime(pkt.Data[:timeSliceLength])
if tracker != p.Tracker {
return nil
}
outPkt.Rtt = receivedAt.Sub(timestamp)
outPkt.Seq = pkt.Seq
p.PacketsRecv++
default:
// Very bad, not sure how this can happen
return fmt.Errorf("invalid ICMP echo reply; type: '%T', '%v'", pkt, pkt)
}
if p.RecordRtts {
p.rtts = append(p.rtts, outPkt.Rtt)
}
handler := p.OnRecv
if handler != nil {
handler(outPkt)
}
return nil
}
func (p *Pinger) sendICMP(conn *icmp.PacketConn) error {
var typ icmp.Type
if p.ipv4 {
typ = ipv4.ICMPTypeEcho
} else {
typ = ipv6.ICMPTypeEchoRequest
}
var dst net.Addr = p.ipaddr
if p.protocol == "udp" {
dst = &net.UDPAddr{IP: p.ipaddr.IP, Zone: p.ipaddr.Zone}
}
t := append(timeToBytes(time.Now()), intToBytes(p.Tracker)...)
if remainSize := p.Size - timeSliceLength - trackerLength; remainSize > 0 {
t = append(t, bytes.Repeat([]byte{1}, remainSize)...)
}
body := &icmp.Echo{
ID: p.id,
Seq: p.sequence,
Data: t,
}
msg := &icmp.Message{
Type: typ,
Code: 0,
Body: body,
}
msgBytes, err := msg.Marshal(nil)
if err != nil {
return err
}
for {
if _, err := conn.WriteTo(msgBytes, dst); err != nil {
if neterr, ok := err.(*net.OpError); ok {
if neterr.Err == syscall.ENOBUFS {
continue
}
}
}
handler := p.OnSend
if handler != nil {
outPkt := &Packet{
Nbytes: len(msgBytes),
IPAddr: p.ipaddr,
Addr: p.addr,
Seq: p.sequence,
}
handler(outPkt)
}
p.PacketsSent++
p.sequence++
break
}
return nil
}
func (p *Pinger) listen(netProto string) (*icmp.PacketConn, error) {
conn, err := icmp.ListenPacket(netProto, p.Source)
if err != nil {
close(p.done)
return nil, err
}
return conn, nil
}
func bytesToTime(b []byte) time.Time {
var nsec int64
for i := uint8(0); i < 8; i++ {
nsec += int64(b[i]) << ((7 - i) * 8)
}
return time.Unix(nsec/1000000000, nsec%1000000000)
}
func isIPv4(ip net.IP) bool {
return len(ip.To4()) == net.IPv4len
}
func timeToBytes(t time.Time) []byte {
nsec := t.UnixNano()
b := make([]byte, 8)
for i := uint8(0); i < 8; i++ {
b[i] = byte((nsec >> ((7 - i) * 8)) & 0xff)
}
return b
}
func bytesToInt(b []byte) int64 {
return int64(binary.BigEndian.Uint64(b))
}
func intToBytes(tracker int64) []byte {
b := make([]byte, 8)
binary.BigEndian.PutUint64(b, uint64(tracker))
return b
}

50
config.go
View File

@ -1,50 +0,0 @@
package main
type AlrmConfig struct {
Groups []*AlrmGroup
Interval int
}
func (ac *AlrmConfig) NewGroup() *AlrmGroup {
group := &AlrmGroup{}
ac.Groups = append(ac.Groups, group)
return group
}
type AlrmGroup struct {
Name string
Hosts []*AlrmHost
}
func (ag *AlrmGroup) NewHost() *AlrmHost {
host := &AlrmHost{}
ag.Hosts = append(ag.Hosts, host)
return host
}
type AlrmHost struct {
Name string
Address string
Checks []AlrmCheck
}
func (ah *AlrmHost) GetAddress() string {
if ah.Address != "" {
return ah.Address
}
return ah.Name
}
type AlrmCheck interface {
Parse(string) (bool, error)
Check() error
}
func ReadConfig(fn string) (*AlrmConfig, error) {
parser := &Parser{}
config, err := parser.Parse(fn)
if err != nil {
return nil, err
}
return config, nil
}

44
config/config.go
View File

@ -0,0 +1,44 @@
package config
import (
"fmt"
"strconv"
)
type AlrmConfig struct {
Groups map[string]*AlrmGroup
Interval int
}
func (ac *AlrmConfig) NewGroup(name string) (*AlrmGroup, error) {
if ac.Groups == nil {
ac.Groups = make(map[string]*AlrmGroup)
}
if _, exists := ac.Groups[name]; exists {
return nil, fmt.Errorf("group %s already exists", name)
}
group := &AlrmGroup{Name: name}
ac.Groups[name] = group
return group, nil
}
func (ac *AlrmConfig) SetInterval(val string) error {
interval, err := strconv.Atoi(val)
if err != nil {
return err
}
ac.Interval = interval
return nil
}
func ReadConfig(fn string, debuglvl int) (*AlrmConfig, error) {
parser := &Parser{DebugLevel: debuglvl}
config, err := parser.Parse(fn)
if err != nil {
return nil, err
}
return config, nil
}

24
config/group.go
View File

@ -0,0 +1,24 @@
package config
import (
"fmt"
)
type AlrmGroup struct {
Name string
Hosts map[string]*AlrmHost
}
func (ag *AlrmGroup) NewHost(name string) (*AlrmHost, error) {
if ag.Hosts == nil {
ag.Hosts = make(map[string]*AlrmHost)
}
if _, exists := ag.Hosts[name]; exists {
return nil, fmt.Errorf("host %s already exists", name)
}
host := &AlrmHost{Name: name}
ag.Hosts[name] = host
return host, nil
}

27
config/host.go
View File

@ -0,0 +1,27 @@
package config
import (
"alrm/check"
)
type AlrmHost struct {
Name string
Address string
Checks []check.AlrmCheck
}
func (ah *AlrmHost) GetAddress() string {
if ah.Address != "" {
return ah.Address
}
return ah.Name
}
func (ah *AlrmHost) NewCheck(name string) (check.AlrmCheck, error) {
chk, err := check.NewCheck(name, ah.GetAddress())
if err != nil {
return nil, err
}
ah.Checks = append(ah.Checks, chk)
return chk, nil
}

91
parser.go → config/parser.go
View File

@ -1,10 +1,10 @@
package main
package config
import (
"alrm/check"
"bufio"
"fmt"
"os"
"strconv"
"strings"
)
@ -18,8 +18,12 @@ const (
)
type Parser struct {
Line int
states []int
DebugLevel int
Line int
states []int
lasthost *AlrmHost
lastgroup *AlrmGroup
lastcheck check.AlrmCheck
}
func (p *Parser) Parse(fn string) (*AlrmConfig, error) {
@ -30,9 +34,6 @@ func (p *Parser) Parse(fn string) (*AlrmConfig, error) {
defer file.Close()
config := &AlrmConfig{}
var group *AlrmGroup
var host *AlrmHost
var check AlrmCheck
scan := bufio.NewScanner(file)
scan.Split(p.Split)
@ -61,7 +62,7 @@ func (p *Parser) Parse(fn string) (*AlrmConfig, error) {
value := scan.Text()
switch key {
case "interval":
config.Interval, err = strconv.Atoi(value)
err := config.SetInterval(value)
if err != nil {
return nil, fmt.Errorf(
"invalid number for interval in %s, line %d: \"%s\"",
@ -78,12 +79,9 @@ func (p *Parser) Parse(fn string) (*AlrmConfig, error) {
case TK_MONITOR:
switch strings.ToLower(tk) {
case "host":
group = config.NewGroup()
host = group.NewHost()
p.setState(TK_HOST)
case "group":
group = config.NewGroup()
p.setState(TK_GROUP)
default:
@ -92,33 +90,43 @@ func (p *Parser) Parse(fn string) (*AlrmConfig, error) {
}
case TK_GROUP:
if group == nil {
return nil, fmt.Errorf("group without initialization")
if p.lastgroup == nil {
p.lastgroup, err = config.NewGroup(tk)
if err != nil {
return nil, fmt.Errorf("%s in %s, line %d",
err.Error(), fn, p.Line+1,
)
}
continue
}
switch strings.ToLower(tk) {
case "host":
host = group.NewHost()
p.setState(TK_HOST)
continue
default:
if group.Name == "" {
group.Name = tk
continue
}
p.prevState()
goto stateswitch
}
case TK_HOST:
if host == nil {
return nil, fmt.Errorf("host token without initialization")
// If a host has no group, inherit the host name
if p.lastgroup == nil {
p.lastgroup, err = config.NewGroup(tk)
if err != nil {
return nil, fmt.Errorf("%s in %s, line %d",
err.Error(), fn, p.Line+1,
)
}
}
if host.Name == "" {
host.Name = tk
if p.lasthost == nil {
p.lasthost, err = p.lastgroup.NewHost(tk)
if err != nil {
return nil, fmt.Errorf("%s in %s, line %d",
err.Error(), fn, p.Line+1,
)
}
continue
}
@ -128,10 +136,9 @@ func (p *Parser) Parse(fn string) (*AlrmConfig, error) {
return nil, fmt.Errorf("empty address for host in %s, line %d",
fn, p.Line+1)
}
host.Address = scan.Text()
p.lasthost.Address = scan.Text()
case "check":
check = nil
p.setState(TK_CHECK)
default:
@ -140,23 +147,20 @@ func (p *Parser) Parse(fn string) (*AlrmConfig, error) {
}
case TK_CHECK:
if check == nil {
if host == nil {
return nil, fmt.Errorf("check token without initialization")
}
check, err = NewCheck(strings.ToLower(tk), host.GetAddress())
if p.lastcheck == nil {
p.lastcheck, err = p.lasthost.NewCheck(tk)
if err != nil {
return nil, fmt.Errorf("%s in %s, line %d",
err.Error(), fn, p.Line+1)
}
host.Checks = append(host.Checks, check)
continue
}
cont, err := check.Parse(tk)
cont, err := p.lastcheck.Parse(tk)
if err != nil {
return nil, err
}
if !cont {
p.lastcheck = nil
p.prevState()
goto stateswitch
}
@ -179,9 +183,24 @@ func (p *Parser) state() int {
}
func (p *Parser) setState(state int) {
// fmt.Printf("%s", p.stateName())
switch state {
case TK_SET, TK_MONITOR:
fallthrough
case TK_GROUP:
p.lastgroup = nil
fallthrough
case TK_HOST:
p.lasthost = nil
p.lastcheck = nil
}
if p.DebugLevel > 0 {
fmt.Printf("Parser state: %s", p.stateName())
}
p.states = append(p.states, state)
// fmt.Printf(" -> %s\n", p.stateName())
if p.DebugLevel > 0 {
fmt.Printf(" -> %s\n", p.stateName())
}
}
func (p *Parser) prevState() int {
@ -222,7 +241,7 @@ func (p *Parser) Split(data []byte, atEOF bool) (int, []byte, error) {
for i := 0; i < len(data); i++ {
c := data[i]
// fmt.Printf("%c (%t) (%t)\n", c, started, ignoreline)
// fmt.Printf("%c (%t) (%t)\n", c, started, ignoreline)
switch c {
case '\f', '\n', '\r':
p.Line++

34
main.go
View File

@ -6,43 +6,51 @@ import (
"flag"
"os"
"strings"
"alrm/config"
)
func main() {
configPath := flag.String("config", "", "path to configuration file")
cfgPath := flag.String("c", "", "path to configuration file")
debuglvl := flag.Int("d", 0, "debug level")
flag.Parse()
if *configPath == "" {
if *cfgPath == "" {
if _, err := os.Stat("./alrmrc"); err == nil {
*configPath = "./alrmrc"
*cfgPath = "./alrmrc"
}
if _, err := os.Stat("/etc/alrmrc"); err == nil {
*configPath = "/etc/alrmrc"
*cfgPath = "/etc/alrmrc"
}
if *configPath == "" {
if *cfgPath == "" {
fmt.Fprintf(os.Stderr, "Cannot find configuration\n")
os.Exit(1)
}
}
config, err := ReadConfig(*configPath)
if err != nil {
fmt.Fprintf(os.Stderr, "%s\n", err.Error())
os.Exit(1)
}
command := strings.ToLower(flag.Arg(0))
switch command {
case "json":
o, err := json.MarshalIndent(config, "", " ")
cfg, err := config.ReadConfig(*cfgPath, *debuglvl)
if err != nil {
fmt.Fprintf(os.Stderr, "%s\n", err.Error())
os.Exit(1)
}
o, err := json.MarshalIndent(cfg, "", " ")
if err != nil {
fmt.Fprintf(os.Stderr, "JSON error: %s\n", err.Error())
os.Exit(1)
}
fmt.Fprintf(os.Stdout, "%s", string(o))
fmt.Fprintf(os.Stdout, "%s\n", string(o))
case "", "config":
_, err := config.ReadConfig(*cfgPath, *debuglvl)
if err != nil {
fmt.Fprintf(os.Stderr, "%s\n", err.Error())
os.Exit(1)
}
fmt.Fprintf(os.Stdout, "Config is OK.\n")
os.Exit(0)

Write Preview
Loading…
Cancel
Save