git.giacomolli.uk - onehouse/blob - driver/alamo/gateway.go

   1 package alamo
   2
   3 import (
   4         "context"
   5         "fmt"
   6         "time"
   7 )
   8
   9 const (
  10         gatewayRequestInterval = 6 * time.Second
  11         gatewayExchangeTimeout = 5 * time.Second
  12 )
  13
  14 type gateway struct {
  15         client    Client
  16         nextStart time.Time
  17 }
  18
  19 func (g *gateway) status(ctx context.Context) ([]State, error) {
  20         err := g.wait(ctx)
  21         if err != nil {
  22                 return nil, fmt.Errorf("wait for status slot: %w", err)
  23         }
  24
  25         ctx, cancel := context.WithTimeout(ctx, gatewayExchangeTimeout)
  26         defer cancel()
  27
  28         states, err := g.client.Status(ctx)
  29         if err != nil {
  30                 return nil, fmt.Errorf("read gateway status: %w", err)
  31         }
  32
  33         return states, nil
  34 }
  35
  36 func (g *gateway) wait(ctx context.Context) error {
  37         err := ctx.Err()
  38         if err != nil {
  39                 return err
  40         }
  41
  42         delay := time.Until(g.nextStart)
  43         if delay > 0 {
  44                 timer := time.NewTimer(delay)
  45                 defer timer.Stop()
  46
  47                 select {
  48                 case <-ctx.Done():
  49                         return ctx.Err()
  50                 case <-timer.C:
  51                 }
  52         }
  53
  54         err = ctx.Err()
  55         if err != nil {
  56                 return err
  57         }
  58
  59         deadline, exists := ctx.Deadline()
  60         if exists && !time.Now().Before(deadline) {
  61                 return context.DeadlineExceeded
  62         }
  63
  64         g.nextStart = time.Now().Add(gatewayRequestInterval)
  65
  66         return nil
  67 }
  68
  69 func (g *gateway) action(ctx context.Context, mac string, action Action) (State, error) {
  70         err := g.wait(ctx)
  71         if err != nil {
  72                 return State{}, fmt.Errorf("wait for action slot: %w", err)
  73         }
  74
  75         ctx, cancel := context.WithTimeout(ctx, gatewayExchangeTimeout)
  76         defer cancel()
  77
  78         state, err := g.client.Action(ctx, mac, action)
  79         if err != nil {
  80                 return State{}, fmt.Errorf("exchange gateway action: %w", err)
  81         }
  82
  83         return state, nil
  84 }