personal/q3k: door^Wship stuck
Change-Id: I189fc13971d46790634804c3fa1b54e2c4788273
diff --git a/personal/q3k/shipstuck/main.go b/personal/q3k/shipstuck/main.go
new file mode 100644
index 0000000..0224c3d
--- /dev/null
+++ b/personal/q3k/shipstuck/main.go
@@ -0,0 +1,191 @@
+package main
+
+import (
+ "context"
+ "encoding/json"
+ "flag"
+ "fmt"
+ "net/http"
+ "sync"
+ "time"
+
+ "code.hackerspace.pl/hscloud/go/mirko"
+ "github.com/golang/glog"
+ "github.com/grpc-ecosystem/grpc-gateway/runtime"
+
+ pb "code.hackerspace.pl/hscloud/personal/q3k/shipstuck/proto"
+)
+
+type vessel struct {
+ // No idea what these fields are, but they seem to be related to
+ // latitude/longitude. Use these to detect the stuckness of the ship.
+ GT int64 `json:"gt"`
+ DW int64 `json:"dw"`
+}
+
+// get retrieves the current status of the ship - returns true if stack, false
+// otherwise.
+func get(ctx context.Context) (bool, error) {
+ // Sorry vesselfinder, if you made it easy to set up an account I would
+ // gladly pay for the API instead of doing this. Limiting requests to once
+ // every 15 minutes though, that seems fair enough.
+ req, err := http.NewRequestWithContext(ctx, "GET", "https://www.vesselfinder.com/api/pub/click/353136000", nil)
+ if err != nil {
+ return false, fmt.Errorf("NewRequestWithContext: %w", err)
+ }
+ req.Header.Set("User-Agent", "Mozilla/5.0 (X11; Linux x86_64; rv:86.0) Gecko/20100101 Firefox/86.0")
+
+ res, err := http.DefaultClient.Do(req)
+ if err != nil {
+ return false, fmt.Errorf("Do: %w", err)
+ }
+
+ defer res.Body.Close()
+
+ v := &vessel{}
+ err = json.NewDecoder(res.Body).Decode(v)
+ if err != nil {
+ return false, fmt.Errorf("Decode: %w", err)
+ }
+
+ if v.GT == 219079 && v.DW == 199489 {
+ return true, nil
+ } else {
+ glog.Infof("Freed! %+v", v)
+ return false, nil
+ }
+}
+
+type shipState string
+
+const (
+ shipStateUnknown shipState = "UNKNOWN"
+ shipStateStuck shipState = "STUCK"
+ shipStateFreed shipState = "FREED"
+)
+
+type service struct {
+ lastStateMu sync.RWMutex
+ lastState shipState
+ lastStateTime time.Time
+}
+
+func (s *service) worker(ctx context.Context) {
+ update := func() {
+ state := shipStateUnknown
+ // shitty back off, good enough.
+ retries := 10
+ for {
+ stuck, err := get(ctx)
+ if err != nil {
+ glog.Warningf("get: %v", err)
+ if retries > 0 {
+ time.Sleep(60 * time.Second)
+ retries -= 1
+ } else {
+ glog.Errorf("giving up on get")
+ break
+ }
+ } else {
+ if stuck {
+ state = shipStateStuck
+ } else {
+ state = shipStateFreed
+ }
+ break
+ }
+ }
+
+ glog.Infof("New state: %v", state)
+ s.lastStateMu.Lock()
+ s.lastState = state
+ s.lastStateTime = time.Now()
+ s.lastStateMu.Unlock()
+ }
+
+ update()
+ ticker := time.NewTicker(15 * 60 * time.Second)
+ for {
+ select {
+ case <-ctx.Done():
+ return
+ case <-ticker.C:
+ update()
+ }
+ }
+}
+
+func timeMust(t time.Time, err error) time.Time {
+ if err != nil {
+ panic(err)
+ }
+ return t
+}
+
+var (
+ timeStuck = timeMust(time.Parse(
+ "At 15:04 Eastern European Time (MST) on 2 January 2006",
+ "At 07:40 Eastern European Time (UTC) on 23 March 2021",
+ ))
+)
+
+func (s *service) Status(ctx context.Context, req *pb.StatusRequest) (*pb.StatusResponse, error) {
+ s.lastStateMu.RLock()
+ state := s.lastState
+ lastChecked := s.lastStateTime
+ s.lastStateMu.RUnlock()
+
+ res := &pb.StatusResponse{
+ LastChecked: lastChecked.UnixNano(),
+ }
+ switch state {
+ case shipStateUnknown:
+ res.Current = pb.StatusResponse_STUCKNESS_UNKNOWN
+ case shipStateStuck:
+ res.Current = pb.StatusResponse_STUCKNESS_STUCK
+ res.Elapsed = time.Since(timeStuck).Nanoseconds()
+ case shipStateFreed:
+ res.Current = pb.StatusResponse_STUCKNESS_FREE
+ }
+
+ return res, nil
+}
+
+var (
+ flagPublicAddress string
+)
+
+func main() {
+ flag.StringVar(&flagPublicAddress, "public_address", "127.0.0.1:8080", "Public HTTP/JSON listen address")
+ flag.Parse()
+ m := mirko.New()
+ if err := m.Listen(); err != nil {
+ glog.Exitf("Listen(): %v", err)
+ }
+
+ s := &service{}
+ pb.RegisterShipStuckServer(m.GRPC(), s)
+
+ publicMux := runtime.NewServeMux()
+ publicSrv := http.Server{
+ Addr: flagPublicAddress,
+ Handler: publicMux,
+ }
+ go func() {
+ glog.Infof("REST listening on %s", flagPublicAddress)
+ if err := publicSrv.ListenAndServe(); err != nil {
+ glog.Exitf("public ListenAndServe: %v", err)
+ }
+ }()
+ if err := pb.RegisterShipStuckHandlerServer(m.Context(), publicMux, s); err != nil {
+ glog.Exitf("RegisterShipStuckHandlerSerever: %v", err)
+ }
+
+ go s.worker(m.Context())
+
+ if err := m.Serve(); err != nil {
+ glog.Exitf("Serve(): %v", err)
+ }
+
+ <-m.Done()
+}