accept more noauth codes from ntg

broker/job.go

@@ -2,6 +2,7 @@ package broker
 
 import (
 	"fmt"
+	"local/truckstop/config"
 	"time"
 )
 
@@ -37,7 +38,8 @@ func (j JobLocation) String() string {
 
 func (j Job) FormatMultilineText() string {
 	return fmt.Sprintf(
-		"--- %s => %s ---\nPickup: %s\nDropoff: %s\nNotes: %d lbs, %d miles, %s",
+		"--- %s: %s => %s ---\nPickup: %s\nDropoff: %s\nNotes: %d lbs, %d miles, %s",
+		config.Get().Name,
 		j.Pickup.State,
 		j.Dropoff.State,
 		j.Pickup.String(),

broker/ntgvision.go

@@ -146,7 +146,7 @@ func (ntg NTGVision) _search(states []config.State) (io.ReadCloser, error) {
 	if resp.StatusCode != http.StatusOK {
 		b, _ := ioutil.ReadAll(resp.Body)
 		resp.Body.Close()
-		if resp.StatusCode > 400 && resp.StatusCode < 404 {
+		if resp.StatusCode > 400 && resp.StatusCode < 500 && resp.StatusCode != 404 && resp.StatusCode != 410 {
 			return nil, ErrNoAuth
 		}
 		return nil, fmt.Errorf("bad status searching ntg: %d: %s", resp.StatusCode, b)

config.json

@@ -1,5 +1,10 @@
 {
-   "Interval": "6h0m0s",
+   "Name": "pa",
+   "Interval": {
+      "OK": "6h0m0s",
+      "Error": "6h",
+      "Email": "15m"
+   },
    "States": [
       "GA"
    ],

config/config.go

@@ -10,7 +10,12 @@ import (
 )
 
 type Config struct {
-	Interval Duration
+	Name     string
+	Interval struct {
+		Email Duration
+		OK    Duration
+		Error Duration
+	}
 	States  []State
 	Storage []string
 	Client  string

config/duration.go

@@ -2,17 +2,29 @@ package config
 
 import (
 	"encoding/json"
+	"errors"
+	"math/rand"
+	"strings"
 	"time"
 )
 
-type Duration time.Duration
+type Duration struct {
+	least time.Duration
+	most  time.Duration
+}
 
 func (d Duration) Get() time.Duration {
-	return time.Duration(d)
+	jitter := d.most - d.least
+	if jitter >= time.Second {
+		jitter = time.Second * time.Duration(rand.Int()%int(jitter.Seconds()))
+	} else {
+		jitter = 0
+	}
+	return time.Duration(d.least + jitter)
 }
 
 func (d Duration) MarshalJSON() ([]byte, error) {
-	return json.Marshal(d.Get().String())
+	return json.Marshal(d.least.String() + ".." + d.most.String())
 }
 
 func (d *Duration) UnmarshalJSON(b []byte) error {
@@ -20,10 +32,25 @@ func (d *Duration) UnmarshalJSON(b []byte) error {
 	if err := json.Unmarshal(b, &s); err != nil {
 		return err
 	}
-	d2, err := time.ParseDuration(s)
+	if !strings.Contains(s, "..") {
+		s = s + ".." + s
+	}
+	splits := strings.Split(s, "..")
+	if len(splits) != 2 {
+		return errors.New("unexpected ..")
+	}
+	least, err := time.ParseDuration(splits[0])
 	if err != nil {
 		return err
 	}
-	*d = Duration(d2)
+	most, err := time.ParseDuration(splits[1])
+	if err != nil {
+		return err
+	}
+	if least > most {
+		most, least = least, most
+	}
+	d.most = most
+	d.least = least
 	return nil
 }

config/duration_test.go

@@ -0,0 +1,105 @@
+package config
+
+import (
+	"encoding/json"
+	"testing"
+	"time"
+)
+
+func TestDurationMarshal(t *testing.T) {
+	cases := map[string]struct {
+		in     string
+		want   Duration
+		wantJS string
+	}{
+		"empty string": {
+			wantJS: `"0s..0s"`,
+		},
+		"random in": {
+			in:     "abc",
+			want:   Duration{},
+			wantJS: `"0s..0s"`,
+		},
+		"1 dur": {
+			in: "1m",
+			want: Duration{
+				least: time.Minute,
+				most:  time.Minute,
+			},
+			wantJS: `"1m0s..1m0s"`,
+		},
+		"descending": {
+			in: "2m..1m",
+			want: Duration{
+				least: time.Minute,
+				most:  2 * time.Minute,
+			},
+			wantJS: `"1m0s..2m0s"`,
+		},
+		"happy span": {
+			in: "1m..2m",
+			want: Duration{
+				least: time.Minute,
+				most:  2 * time.Minute,
+			},
+			wantJS: `"1m0s..2m0s"`,
+		},
+		"multi unit descending": {
+			in: "1h1m..2m3ms",
+			want: Duration{
+				least: 2*time.Minute + 3*time.Millisecond,
+				most:  time.Hour + time.Minute,
+			},
+			wantJS: `"2m0.003s..1h1m0s"`,
+		},
+	}
+
+	for name, d := range cases {
+		c := d
+		t.Run(name, func(t *testing.T) {
+			var got Duration
+			err := json.Unmarshal([]byte(`"`+c.in+`"`), &got)
+			if got != c.want {
+				t.Fatalf("err %v: want %+v, got %+v", err, c.want, got)
+			}
+			js, _ := json.Marshal(got)
+			if string(js) != c.wantJS {
+				t.Fatalf("want marshalled %s, got %s", c.wantJS, js)
+			}
+			var got2 Duration
+			json.Unmarshal(js, &got2)
+			if got != got2 {
+				t.Fatalf("want unmarshal-marshal-unmarshal %+v, got %+v", got, got2)
+			}
+		})
+	}
+}
+
+func TestDurationGet(t *testing.T) {
+	t.Run("same", func(t *testing.T) {
+		d := Duration{least: time.Second, most: time.Second}
+		for i := 0; i < 50; i++ {
+			if got := d.Get(); got != time.Second {
+				t.Error(got)
+			}
+		}
+	})
+
+	t.Run("1ms span", func(t *testing.T) {
+		d := Duration{least: time.Second, most: time.Second + time.Millisecond}
+		for i := 0; i < 50; i++ {
+			if got := d.Get(); got != time.Second {
+				t.Error(got)
+			}
+		}
+	})
+
+	t.Run("5s span", func(t *testing.T) {
+		d := Duration{least: time.Second, most: 6 * time.Second}
+		for i := 0; i < 50; i++ {
+			if got := d.Get(); got > time.Second*6 || got < time.Second {
+				t.Error(got)
+			}
+		}
+	})
+}

main.go

@@ -21,17 +21,16 @@ var stateFinder = regexp.MustCompile(`[A-Za-z]+`)
 func main() {
 	lock := &sync.Mutex{}
 	go func() {
-		c := time.NewTicker(time.Minute)
+		for {
-		for range c.C {
+			time.Sleep(config.Get().Interval.Email.Get())
-			if !config.Get().EmailerEnabled {
+			if config.Get().EmailerEnabled {
-				continue
-			}
 				lock.Lock()
 				if err := email(); err != nil {
 					log.Print(err)
 				}
 				lock.Unlock()
 			}
+		}
 	}()
 	if err := _main(); err != nil {
 		panic(err)
@@ -94,17 +93,32 @@ func parseOutStates(b []byte) []config.State {
 
 func _main() error {
 	for {
+		err := _mainOne()
+		if err != nil {
+			log.Println(err)
+		}
+		if config.Get().Once {
+			return err
+		}
+		if err != nil {
+			time.Sleep(config.Get().Interval.Error.Get())
+		} else {
+			time.Sleep(config.Get().Interval.OK.Get())
+		}
+	}
+	return nil
+}
+
+func _mainOne() error {
+	log.Println("config.refreshing...")
 	if err := config.Refresh(); err != nil {
 		return err
 	}
+	log.Println("once...")
 	if err := once(); err != nil {
 		return err
 	}
-		if config.Get().Once {
+	log.Println("/_mainOne")
-			break
-		}
-		time.Sleep(config.Get().Interval.Get())
-	}
 	return nil
 }
 
@@ -125,6 +139,7 @@ func once() error {
 		if err := sendJob(jobs[i]); err != nil {
 			return err
 		}
+		log.Println("sent job", jobs[i])
 		if err := config.Get().DB().Set(jobs[i].ID, []byte(`sent`)); err != nil {
 			return err
 		}

todo.yaml

@@ -3,8 +3,13 @@ todo:
   subtasks:
   - banlist criteria like vendors, brokers, metadata
 - quiet hours
-- setup pa on element
+- setup ma on element
+- accept states via element for one system
+- set up copy for caleb, broc
 done:
+- setup pa on element
+- configurable email interval
+- jitter on intervals, including dedicated err span
 - email doesnt get all matches
 - send jobs
 - read jobs