utils.go

package gotel

import (
	"errors"
	"fmt"
	"math"
	"net"
	"sort"
	"strconv"
	"strings"
	"time"
)

const (
	// Minute is the nubmer of seconds in a minute
	Minute   = 60
	// Hour is the nubmer of seconds in an hour
	Hour     = 60 * Minute
	// Day is the nubmer of seconds in a day
	Day      = 24 * Hour
	// Week is the nubmer of seconds in a week
	Week     = 7 * Day
	// Month is the nubmer of seconds in a 30 day month
	Month    = 30 * Day
	// Year is the nubmer of seconds in almost a year
	Year     = 12 * Month
	// LongTime is the nubmer of seconds in a while
	LongTime = 37 * Year
)

var magnitudes = []struct {
	d      int64
	format string
	divby  int64
}{
	{1, "now", 1},
	{2, "1 second %s", 1},
	{Minute, "%d seconds %s", 1},
	{2 * Minute, "1 minute %s", 1},
	{Hour, "%d minutes %s", Minute},
	{2 * Hour, "1 hour %s", 1},
	{Day, "%d hours %s", Hour},
	{2 * Day, "1 day %s", 1},
	{Week, "%d days %s", Day},
	{2 * Week, "1 week %s", 1},
	{Month, "%d weeks %s", Week},
	{2 * Month, "1 month %s", 1},
	{Year, "%d months %s", Month},
	{18 * Month, "1 year %s", 1},
	{2 * Year, "2 years %s", 1},
	{LongTime, "%d years %s", Year},
	{math.MaxInt64, "a long while %s", 1},
}

// returns the external IP of the machine you're on
func externalIP() (string, error) {
	ifaces, err := net.Interfaces()
	if err != nil {
		return "", err
	}
	for _, iface := range ifaces {
		if iface.Flags&net.FlagUp == 0 {
			continue // interface down
		}
		if iface.Flags&net.FlagLoopback != 0 {
			continue // loopback interface
		}
		addrs, err := iface.Addrs()
		if err != nil {
			return "", err
		}
		for _, addr := range addrs {
			var ip net.IP
			switch v := addr.(type) {
			case *net.IPNet:
				ip = v.IP
			case *net.IPAddr:
				ip = v.IP
			}
			if ip == nil || ip.IsLoopback() {
				continue
			}
			ip = ip.To4()
			if ip == nil {
				continue // not an ipv4 address
			}
			return ip.String(), nil
		}
	}
	return "", errors.New("are you connected to the network?")
}

// RelTime returns the duration between to times, formatted as a string
func RelTime(a, b time.Time, albl, blbl string) string {
	lbl := albl
	diff := b.Unix() - a.Unix()

	after := a.After(b)
	if after {
		lbl = blbl
		diff = a.Unix() - b.Unix()
	}

	n := sort.Search(len(magnitudes), func(i int) bool {
		return magnitudes[i].d > diff
	})

	mag := magnitudes[n]
	args := []interface{}{}
	escaped := false
	for _, ch := range mag.format {
		if escaped {
			switch ch {
			case '%':
			case 's':
				args = append(args, lbl)
			case 'd':
				args = append(args, diff/mag.divby)
			}
			escaped = false
		} else {
			escaped = ch == '%'
		}
	}
	return fmt.Sprintf(mag.format, args...)
}

func (res reservation) formatAlert(format string) string {
	lastCheckin := time.Unix(res.LastCheckin, 0)
	ip, err := externalIP()
	if err != nil {
		ip = "N/A"
	}

	replacer := strings.NewReplacer(
		"{jobid}", strconv.Itoa(res.JobID),
		"{app}", res.App,
		"{component}", res.Component,
		"{owner}", res.Owner,
		"{notify}", res.Notify,
		"{frequency}", strconv.Itoa(res.Frequency) + res.TimeUnits,
		"{last}", time.Unix(res.LastCheckin, 0).Format(time.RFC1123),
		"{since}", RelTime(lastCheckin, time.Now(), "ago", ""),
		"{checkins}", strconv.Itoa(res.NumCheckins),
		"{srv}", ip,
	)

	return replacer.Replace(format)
}