harvester/parse.go - maas - Gitiles

 // Copyright 2016 Open Networking Laboratory
 //
 // 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 (
 	"bufio"
 	"bytes"
 	"fmt"
 	"net"
 	"os"
 	"os/exec"
 	"strconv"
 	"strings"
 	"text/tabwriter"
 	"time"
 )

 // leaseFilterFunc provides a mechanism to filter which leases are returned by lease file parser
 type leaseFilterFunc func(lease *Lease) bool

 const (
 	// returns if a parse requests is processed or denied because of quiet period
 	responseQuiet uint = 0
 	responseOK    uint = 1

 	// time format for parsing time stamps in lease file
 	dateTimeLayout = "2006/1/2 15:04:05"

 	bindFileFormat = "{{.ClientHostname}}\tIN A {{.IPAddress}}\t; {{.HardwareAddress}}"
 )

 // generateClientHostname generates a client name based on hardware address
 func (app *application) generateClientHostname(lease *Lease) string {
 	var buf bytes.Buffer

 	app.log.Debugf("Generating client-hostname for MAC '%s'", lease.HardwareAddress.String())

 	err := app.clientNameTemplate.Execute(&buf, lease)
 	if err != nil {
 		app.log.Errorf("Unable to generate client host name for lease with HW address '%s' : %s",
 			lease.HardwareAddress.String(), err)
 		return strings.ToUpper("UNK-" +
 			strings.Replace(lease.HardwareAddress.String(), ":", "", -1))
 	}

 	return buf.String()
 }

 // parseLease parses a single lease from the lease file
 func (app *application) parseLease(scanner *bufio.Scanner, lease *Lease) error {
 	var err error
 	for scanner.Scan() {
 		fields := strings.Fields(scanner.Text())
 		if len(fields) > 0 {
 			switch fields[0] {
 			case "}":
 				// If no client-hostname was specified, generate one
 				if len(lease.ClientHostname) == 0 {
 					lease.ClientHostname = app.generateClientHostname(lease)
 				}
 				return nil
 			case "client-hostname":
 				lease.ClientHostname = strings.Trim(fields[1], "\";")

 				// Validate client-hostname
 				if _, ok := app.badClientNames[lease.ClientHostname]; ok {
 					lease.ClientHostname = app.generateClientHostname(lease)
 				}
 			case "hardware":
 				lease.HardwareAddress, err = net.ParseMAC(strings.Trim(fields[2], ";"))
 				if err != nil {
 					return err
 				}
 			case "binding":
 				lease.BindingState, err = parseBindingState(strings.Trim(fields[2], ";"))
 				if err != nil {
 					return err
 				}
 			case "starts":
 				lease.Starts, err = time.Parse(dateTimeLayout,
 					fields[2]+" "+strings.Trim(fields[3], ";"))
 				if err != nil {
 					return err
 				}
 			case "ends":
 				lease.Ends, err = time.Parse(dateTimeLayout,
 					fields[2]+" "+strings.Trim(fields[3], ";"))
 				if err != nil {
 					return err
 				}
 			}
 		}
 	}
 	return nil
 }

 // parseLeaseFile parses the entire lease file
 func (app *application) parseLeaseFile(filename string, filterFunc leaseFilterFunc) (map[string]*Lease, error) {
 	leases := make(map[string]*Lease)

 	file, err := os.Open(filename)
 	if err != nil {
 		return nil, err
 	}
 	defer file.Close()

 	scanner := bufio.NewScanner(file)
 	scanner.Split(bufio.ScanLines)
 	for scanner.Scan() {
 		fields := strings.Fields(scanner.Text())
 		if len(fields) > 0 && fields[0] == "lease" {
 			lease := Lease{}
 			lease.IPAddress = net.ParseIP(fields[1])
 			app.parseLease(scanner, &lease)
 			if filterFunc(&lease) {
 				leases[lease.IPAddress.String()] = &lease
 			}
 		}
 	}

 	if err = scanner.Err(); err != nil {
 		return nil, err
 	}

 	return leases, nil
 }

 // parseReservation parses a single reservation entry
 func (app *application) parseReservation(scanner *bufio.Scanner, lease *Lease) error {
 	var err error
 	for scanner.Scan() {
 		fields := strings.Fields(scanner.Text())
 		if len(fields) > 0 {
 			switch fields[0] {
 			case "}":
 				// If not IP or MAC specified then return error
 				if len(lease.HardwareAddress) == 0 {
 					return fmt.Errorf("Reservation requires hardware address")
 				}
 				if len(lease.IPAddress) == 0 {
 					return fmt.Errorf("Reservation requires IP address")
 				}
 				return nil
 			case "hardware":
 				lease.HardwareAddress, err = net.ParseMAC(strings.Trim(fields[2], ";"))
 				if err != nil {
 					return err
 				}
 			case "fixed-address":
 				lease.IPAddress = net.ParseIP(strings.Trim(fields[1], ";"))
 				if lease.IPAddress == nil {
 					return fmt.Errorf("Invalid IP Address")
 				}
 			}
 		}
 	}
 	return nil
 }

 // parseReservationFile parses the reservation file to include reservation IPs in IP information
 func (app *application) parseReservationFile(filename string, leases map[string]*Lease) (map[string]*Lease, error) {
 	// If no filename was specified, nothing to parse
 	if len(filename) == 0 {
 		return leases, nil
 	}

 	file, err := os.Open(filename)
 	if err != nil {
 		return nil, err
 	}
 	defer file.Close()

 	scanner := bufio.NewScanner(file)
 	scanner.Split(bufio.ScanLines)
 	for scanner.Scan() {
 		fields := strings.Fields(scanner.Text())
 		if len(fields) > 0 && fields[0] == "host" {
 			lease := Lease{}
 			lease.ClientHostname = fields[1]
 			app.parseReservation(scanner, &lease)
 			leases[lease.IPAddress.String()] = &lease
 		}
 	}

 	if err = scanner.Err(); err != nil {
 		return nil, err
 	}

 	return leases, nil
 }

 // syncRequestHandler accepts requests to parse the lease file and either processes or ignores because of quiet period
 func (app *application) syncRequestHandler(requests chan *chan uint) {

 	// track the last time file was processed to enforce quiet period
 	var last *time.Time = nil

 	// process requests on the channel
 	for response := range requests {
 		now := time.Now()

 		// if the request is made during the quiet period then drop the request to prevent
 		// a storm
 		if last != nil && now.Sub(*last) < app.QuietPeriod {
 			app.log.Warn("Request received during query quiet period, will not harvest")
 			if response != nil {
 				*response <- responseQuiet
 			}
 			continue
 		}

 		// process the lease database
 		app.log.Infof("Synchronizing DHCP lease database")
 		leases, err := app.parseLeaseFile(app.DHCPLeaseFile,
 			func(lease *Lease) bool {
 				return lease.BindingState != Free &&
 					lease.Ends.After(now) &&
 					lease.Starts.Before(now)
 			})
 		if err != nil {
 			app.log.Errorf("Unable to parse DHCP lease file at '%s' : %s",
 				app.DHCPLeaseFile, err)
 		} else {
 			leaseCount := len(leases)
 			app.log.Infof("Read %d leases from lease file", leaseCount)
 			// Process the reservation file, if specified
 			app.log.Info("Synchronizing DHCP reservation file")
 			leases, err = app.parseReservationFile(app.DHCPReservationFile, leases)
 			if err != nil {
 				app.log.Errorf("Unable to parse reservation file '%s' : '%s'",
 					app.DHCPReservationFile, err)
 			} else {
 				app.log.Infof("Read %d reservations from reservation file",
 					len(leases)-leaseCount)
 				// if configured to verify leases with a ping do so
 				if app.VerifyLeases {
 					app.log.Infof("Verifing %d discovered leases", len(leases))
 					_, err := app.verifyLeases(leases)
 					if err != nil {
 						app.log.Errorf("unexpected error while verifing leases : %s", err)
 						app.log.Infof("Discovered %d active, not verified because of error, DHCP leases",
 							len(leases))
 					} else {
 						app.log.Infof("Discovered %d active and verified DHCP leases", len(leases))
 					}
 				} else {
 					app.log.Infof("Discovered %d active, not not verified, DHCP leases", len(leases))
 				}

 				// if configured to output the lease information to a file, do so
 				if len(app.OutputFile) > 0 {
 					app.log.Infof("Writing lease information to file '%s'", app.OutputFile)
 					out, err := os.Create(app.OutputFile)
 					if err != nil {
 						app.log.Errorf(
 							"unexpected error while attempting to open file `%s' for output : %s",
 							app.OutputFile, err)
 					} else {
 						table := tabwriter.NewWriter(out, 1, 0, 4, ' ', 0)
 						for _, lease := range leases {
 							if err := app.outputTemplate.Execute(table, lease); err != nil {
 								app.log.Errorf(
 									"unexpected error while writing leases to file '%s' : %s",
 									app.OutputFile, err)
 								break
 							}
 							fmt.Fprintln(table)
 						}
 						table.Flush()
 					}
 					out.Close()
 				}

 				// if configured to reload the DNS server, then use the RNDC command to do so
 				if app.RNDCUpdate {
 					cmd := exec.Command("rndc", "-s", app.RNDCAddress, "-p", strconv.Itoa(app.RNDCPort),
 						"-c", app.RNDCKeyFile, "reload", app.RNDCZone)
 					err := cmd.Run()
 					if err != nil {
 						app.log.Errorf("Unexplected error while attempting to reload zone '%s' on DNS server '%s:%d' : %s", app.RNDCZone, app.RNDCAddress, app.RNDCPort, err)
 					} else {
 						app.log.Infof("Successfully reloaded DNS zone '%s' on server '%s:%d' via RNDC command",
 							app.RNDCZone, app.RNDCAddress, app.RNDCPort)
 					}
 				}

 				// process the results of the parse to internal data structures
 				app.interchange.Lock()
 				app.leases = leases
 				app.byHostname = make(map[string]*Lease)
 				app.byHardware = make(map[string]*Lease)
 				for _, lease := range leases {
 					app.byHostname[lease.ClientHostname] = lease
 					app.byHardware[lease.HardwareAddress.String()] = lease
 				}
 				leases = nil
 				app.interchange.Unlock()
 			}
 		}
 		if last == nil {
 			last = &time.Time{}
 		}
 		*last = time.Now()

 		if response != nil {
 			*response <- responseOK
 		}
 	}
 }

 // syncFromDHCPLeaseFileLoop periodically request a lease file processing
 func (app *application) syncFromDHCPLeaseFileLoop(requests chan *chan uint) {
 	responseChan := make(chan uint)
 	for {
 		requests <- &responseChan
 		select {
 		case _ = <-responseChan:
 			// request completed
 		case <-time.After(app.RequestTimeout):
 			app.log.Error("request to process DHCP lease file timed out")
 		}
 		time.Sleep(app.QueryPeriod)
 	}
 }
	// Copyright 2016 Open Networking Laboratory
	//
	// 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 (
	"bufio"
	"bytes"
	"fmt"
	"net"
	"os"
	"os/exec"
	"strconv"
	"strings"
	"text/tabwriter"
	"time"
	)

	// leaseFilterFunc provides a mechanism to filter which leases are returned by lease file parser
	type leaseFilterFunc func(lease *Lease) bool

	const (
	// returns if a parse requests is processed or denied because of quiet period
	responseQuiet uint = 0
	responseOK uint = 1

	// time format for parsing time stamps in lease file
	dateTimeLayout = "2006/1/2 15:04:05"

	bindFileFormat = "{{.ClientHostname}}\tIN A {{.IPAddress}}\t; {{.HardwareAddress}}"
	)

	// generateClientHostname generates a client name based on hardware address
	func (app application) generateClientHostname(lease Lease) string {
	var buf bytes.Buffer

	app.log.Debugf("Generating client-hostname for MAC '%s'", lease.HardwareAddress.String())

	err := app.clientNameTemplate.Execute(&buf, lease)
	if err != nil {
	app.log.Errorf("Unable to generate client host name for lease with HW address '%s' : %s",
	lease.HardwareAddress.String(), err)
	return strings.ToUpper("UNK-" +
	strings.Replace(lease.HardwareAddress.String(), ":", "", -1))
	}

	return buf.String()
	}

	// parseLease parses a single lease from the lease file
	func (app application) parseLease(scanner bufio.Scanner, lease *Lease) error {
	var err error
	for scanner.Scan() {
	fields := strings.Fields(scanner.Text())
	if len(fields) > 0 {
	switch fields[0] {
	case "}":
	// If no client-hostname was specified, generate one
	if len(lease.ClientHostname) == 0 {
	lease.ClientHostname = app.generateClientHostname(lease)
	}
	return nil
	case "client-hostname":
	lease.ClientHostname = strings.Trim(fields[1], "\";")

	// Validate client-hostname
	if _, ok := app.badClientNames[lease.ClientHostname]; ok {
	lease.ClientHostname = app.generateClientHostname(lease)
	}
	case "hardware":
	lease.HardwareAddress, err = net.ParseMAC(strings.Trim(fields[2], ";"))
	if err != nil {
	return err
	}
	case "binding":
	lease.BindingState, err = parseBindingState(strings.Trim(fields[2], ";"))
	if err != nil {
	return err
	}
	case "starts":
	lease.Starts, err = time.Parse(dateTimeLayout,
	fields[2]+" "+strings.Trim(fields[3], ";"))
	if err != nil {
	return err
	}
	case "ends":
	lease.Ends, err = time.Parse(dateTimeLayout,
	fields[2]+" "+strings.Trim(fields[3], ";"))
	if err != nil {
	return err
	}
	}
	}
	}
	return nil
	}

	// parseLeaseFile parses the entire lease file
	func (app application) parseLeaseFile(filename string, filterFunc leaseFilterFunc) (map[string]Lease, error) {
	leases := make(map[string]*Lease)

	file, err := os.Open(filename)
	if err != nil {
	return nil, err
	}
	defer file.Close()

	scanner := bufio.NewScanner(file)
	scanner.Split(bufio.ScanLines)
	for scanner.Scan() {
	fields := strings.Fields(scanner.Text())
	if len(fields) > 0 && fields[0] == "lease" {
	lease := Lease{}
	lease.IPAddress = net.ParseIP(fields[1])
	app.parseLease(scanner, &lease)
	if filterFunc(&lease) {
	leases[lease.IPAddress.String()] = &lease
	}
	}
	}

	if err = scanner.Err(); err != nil {
	return nil, err
	}

	return leases, nil
	}

	// parseReservation parses a single reservation entry
	func (app application) parseReservation(scanner bufio.Scanner, lease *Lease) error {
	var err error
	for scanner.Scan() {
	fields := strings.Fields(scanner.Text())
	if len(fields) > 0 {
	switch fields[0] {
	case "}":
	// If not IP or MAC specified then return error
	if len(lease.HardwareAddress) == 0 {
	return fmt.Errorf("Reservation requires hardware address")
	}
	if len(lease.IPAddress) == 0 {
	return fmt.Errorf("Reservation requires IP address")
	}
	return nil
	case "hardware":
	lease.HardwareAddress, err = net.ParseMAC(strings.Trim(fields[2], ";"))
	if err != nil {
	return err
	}
	case "fixed-address":
	lease.IPAddress = net.ParseIP(strings.Trim(fields[1], ";"))
	if lease.IPAddress == nil {
	return fmt.Errorf("Invalid IP Address")
	}
	}
	}
	}
	return nil
	}

	// parseReservationFile parses the reservation file to include reservation IPs in IP information
	func (app application) parseReservationFile(filename string, leases map[string]Lease) (map[string]*Lease, error) {
	// If no filename was specified, nothing to parse
	if len(filename) == 0 {
	return leases, nil
	}

	file, err := os.Open(filename)
	if err != nil {
	return nil, err
	}
	defer file.Close()

	scanner := bufio.NewScanner(file)
	scanner.Split(bufio.ScanLines)
	for scanner.Scan() {
	fields := strings.Fields(scanner.Text())
	if len(fields) > 0 && fields[0] == "host" {
	lease := Lease{}
	lease.ClientHostname = fields[1]
	app.parseReservation(scanner, &lease)
	leases[lease.IPAddress.String()] = &lease
	}
	}

	if err = scanner.Err(); err != nil {
	return nil, err
	}

	return leases, nil
	}

	// syncRequestHandler accepts requests to parse the lease file and either processes or ignores because of quiet period
	func (app application) syncRequestHandler(requests chan chan uint) {

	// track the last time file was processed to enforce quiet period
	var last *time.Time = nil

	// process requests on the channel
	for response := range requests {
	now := time.Now()

	// if the request is made during the quiet period then drop the request to prevent
	// a storm
	if last != nil && now.Sub(*last) < app.QuietPeriod {
	app.log.Warn("Request received during query quiet period, will not harvest")
	if response != nil {
	*response <- responseQuiet
	}
	continue
	}

	// process the lease database
	app.log.Infof("Synchronizing DHCP lease database")
	leases, err := app.parseLeaseFile(app.DHCPLeaseFile,
	func(lease *Lease) bool {
	return lease.BindingState != Free &&
	lease.Ends.After(now) &&
	lease.Starts.Before(now)
	})
	if err != nil {
	app.log.Errorf("Unable to parse DHCP lease file at '%s' : %s",
	app.DHCPLeaseFile, err)
	} else {
	leaseCount := len(leases)
	app.log.Infof("Read %d leases from lease file", leaseCount)
	// Process the reservation file, if specified
	app.log.Info("Synchronizing DHCP reservation file")
	leases, err = app.parseReservationFile(app.DHCPReservationFile, leases)
	if err != nil {
	app.log.Errorf("Unable to parse reservation file '%s' : '%s'",
	app.DHCPReservationFile, err)
	} else {
	app.log.Infof("Read %d reservations from reservation file",
	len(leases)-leaseCount)
	// if configured to verify leases with a ping do so
	if app.VerifyLeases {
	app.log.Infof("Verifing %d discovered leases", len(leases))
	_, err := app.verifyLeases(leases)
	if err != nil {
	app.log.Errorf("unexpected error while verifing leases : %s", err)
	app.log.Infof("Discovered %d active, not verified because of error, DHCP leases",
	len(leases))
	} else {
	app.log.Infof("Discovered %d active and verified DHCP leases", len(leases))
	}
	} else {
	app.log.Infof("Discovered %d active, not not verified, DHCP leases", len(leases))
	}

	// if configured to output the lease information to a file, do so
	if len(app.OutputFile) > 0 {
	app.log.Infof("Writing lease information to file '%s'", app.OutputFile)
	out, err := os.Create(app.OutputFile)
	if err != nil {
	app.log.Errorf(
	"unexpected error while attempting to open file `%s' for output : %s",
	app.OutputFile, err)
	} else {
	table := tabwriter.NewWriter(out, 1, 0, 4, ' ', 0)
	for _, lease := range leases {
	if err := app.outputTemplate.Execute(table, lease); err != nil {
	app.log.Errorf(
	"unexpected error while writing leases to file '%s' : %s",
	app.OutputFile, err)
	break
	}
	fmt.Fprintln(table)
	}
	table.Flush()
	}
	out.Close()
	}

	// if configured to reload the DNS server, then use the RNDC command to do so
	if app.RNDCUpdate {
	cmd := exec.Command("rndc", "-s", app.RNDCAddress, "-p", strconv.Itoa(app.RNDCPort),
	"-c", app.RNDCKeyFile, "reload", app.RNDCZone)
	err := cmd.Run()
	if err != nil {
	app.log.Errorf("Unexplected error while attempting to reload zone '%s' on DNS server '%s:%d' : %s", app.RNDCZone, app.RNDCAddress, app.RNDCPort, err)
	} else {
	app.log.Infof("Successfully reloaded DNS zone '%s' on server '%s:%d' via RNDC command",
	app.RNDCZone, app.RNDCAddress, app.RNDCPort)
	}
	}

	// process the results of the parse to internal data structures
	app.interchange.Lock()
	app.leases = leases
	app.byHostname = make(map[string]*Lease)
	app.byHardware = make(map[string]*Lease)
	for _, lease := range leases {
	app.byHostname[lease.ClientHostname] = lease
	app.byHardware[lease.HardwareAddress.String()] = lease
	}
	leases = nil
	app.interchange.Unlock()
	}
	}
	if last == nil {
	last = &time.Time{}
	}
	*last = time.Now()

	if response != nil {
	*response <- responseOK
	}
	}
	}

	// syncFromDHCPLeaseFileLoop periodically request a lease file processing
	func (app application) syncFromDHCPLeaseFileLoop(requests chan chan uint) {
	responseChan := make(chan uint)
	for {
	requests <- &responseChan
	select {
	case _ = <-responseChan:
	// request completed
	case <-time.After(app.RequestTimeout):
	app.log.Error("request to process DHCP lease file timed out")
	}
	time.Sleep(app.QueryPeriod)
	}
	}