feat: updates to peerfinder app

2022-11-20 10:28:50 -07:00
parent 5e31d27c54
commit bbb45c8854
12 changed files with 1029 additions and 134 deletions
--- a/app/peerfinder/layouts/form.tpl
+++ b/app/peerfinder/layouts/form.tpl
@@ -1,21 +0,0 @@
-<div class="form-group"><label class="col-sm-2 control-label" >Peer Name</label><div class='col-sm-10'><input class="form-control" type=text name=peer_name  value="{$o.peer_name|default:''|escape}"/></div></div>
-<div class="form-group"><label class="col-sm-2 control-label" >IRC Nick</label><div class='col-sm-10'><input class="form-control" type=text name=peer_nick  value="{$o.peer_nick|default:''|escape}"/></div></div>
-<div class="form-group"><label class="col-sm-2 control-label" >Note</label><div class='col-sm-10'><input class="form-control" type=text name=peer_note  value="{$o.peer_note|default:''|escape}"/></div></div>
-<div class="form-group"><label class="col-sm-2 control-label" >Country</label><div class='col-sm-2'><input class="form-control" type=text name=peer_country maxlength=3  value="{$o.peer_country|default:''|escape}"/></div></div>
-<div class="form-group"><label class="col-sm-2 control-label" >VPN Types</label><div class='col-sm-10'><select class="form-control" size=12  multiple name="peer_type[]">
-  <option {$types['openvpn']|default:''} value="openvpn">openvpn</option>
-  <option {$types['gre/ipsec']|default:''} value="gre/ipsec">gre/ipsec</option>
-  <option {$types['gre/plain']|default:''} value="gre/plain">gre/plain</option>
-  <option {$types['fastd']|default:''} value="fastd">fastd</option>
-  <option {$types['tinc']|default:''} value="tinc">tinc</option>
-  <option {$types['zerotier']|default:''} value="zerotier">zerotier</option>
-  <option {$types['wireguard']|default:''} value="wireguard">wireguard</option>
-  <option {$types['pptp']|default:''} value="pptp">pptp</option>
-  <option {$types['l2tp']|default:''} value="l2tp">l2tp</option>
-  <option {$types['other']|default:''} value="other">other</option>
-</select></div></div>
-<div class="form-group"><label class="col-sm-2 control-label" >Address Family</label><div class='col-sm-10'>
-  <label><input type="radio" name="peer_family"  value="1"   {$fam[0]|default:''} /> ipv4 </label>
-  <label><input type="radio" name="peer_family"  value="2"   {$fam[1]|default:''} /> ipv6 </label>
-  <label><input type="radio" name="peer_family"  value="3"   {$fam[2]|default:''} /> both </label>
-</div></div>
--- a/app/peerfinder/layouts/main.tpl
+++ b/app/peerfinder/layouts/main.tpl
@@ -18,9 +18,11 @@
        <nav>
          <ul class="nav nav-pills pull-right">
            <li role="presentation"><a href="/peers">Home</a></li>
-            <li role="presentation"><a href="/peers/status">Status</a></li>
+            <!--
+              <li role="presentation"><a href="/peers/status">Status</a></li>
+            -->
            <li role="presentation"><a href="//util.sour.is/peer">Sign up/Manage</a></li>
-            <li role="presentation"><a href="//git.dn42.us/dn42/pingfinder/src/master/clients">Scripts</a></li>
+            <li role="presentation"><a href="https://git.dn42.dev/dn42/pingfinder/src/branch/master/clients">Scripts</a></li>
          </ul>
        </nav>
        <h3 class="text-muted">DN42 PeerFinder</h3>
@@ -31,11 +33,6 @@
 	{{template "content" .}}
 </div>

-<div class=container>
-  <h2>JSON Output</h2>
-  <pre style="background:#222; color:#ddd; height: 20em; font-size: 65%">{$o|json_encode:128|escape}</pre>
-</div>
-
 </body>
 </html>
 {{end}}
--- a/app/peerfinder/pages/home.tpl
+++ b/app/peerfinder/pages/home.tpl
@@ -30,9 +30,9 @@
  <form class="form-inline" method="POST" action="/peers/req">
        <label>Ping IP Address [Check Hidden?]:</label>
        <div class="input-group input-group-sm">
-            <input class="form-control" type="text" name="req_ip" placeholder="{$rq->remote_ip}">
+            <input class="form-control" type="text" name="req_ip" placeholder="{{ .RemoteIP }}">
            <span class="input-group-addon">
-              <input type="checkbox" name="req_hidden" value=1 aria-label="Hidden?">
+              <input type="checkbox" name="req_hidden" disabled value=1 aria-label="Hidden?">
            </span>
        </div>
        <button class="btn btn-default" type="submit">Submit</button>
@@ -40,4 +40,21 @@

  <p>If you mark your measurement as hidden, it will not be displayed on the
  page below.  Note that the IP addresses of the target will be shown alongside the result.</p>
+
+
+  <div class=row>
+  <h2>Results</h2>
+  {{ with $args := . }}
+  {{range $req := .Requests}}
+      <div class="panel panel-primary">
+          <div class="panel-heading">
+            <a href="/peers/req/{{ $req.RequestID }}">{{ $req.RequestIP }} on {{ $req.Created }}</a> 
+            <div style='float:right'><a href="/peers/req/{{ $req.RequestID }}" class='btn btn-success'>{{ countResponses $req }} / {{ $args.CountPeers }} </a></div>
+          </div>
+          <div class="panel-body"><b>Request ID:</b> {{ $req.RequestID }}</div>
+      </div>
+  {{end}}
+  {{end}}
+  </div>
+
 {{end}}
--- a/app/peerfinder/pages/req.tpl
+++ b/app/peerfinder/pages/req.tpl
@@ -0,0 +1,52 @@
+{{template "main" .}}
+
+{{define "meta"}}
+  <meta http-equiv="refresh" content="30">
+{{end}}
+
+
+{{define "content"}}
+  {{range .Requests}}
+    <h2>Results to {{.RequestIP}}</h2>
+
+    {{with (orderByPeer .)}}
+      {{range .}}  
+        <div class="panel panel-primary" id="peer-{{.Nick}}">
+          <div class="panel-heading">
+            <b> {{.Country}} :: {{.Name}} :: {{.Nick}} </b>
+            <div style='float:right'>
+              <a class='btn btn-success' href="#peer-{{.Nick}}">{{printf "%0.3f ms" .Latency}}</a>
+            </div>
+          </div>
+          <div class="panel-body">
+            <b>Note:</b> {{.Note}}<br/>
+            <b>VPN Types:</b> {{range .VPNTypes}} {{.}} {{end}}<br/>
+            <b>IRC:</b> {{.Nick}}
+            <h4>Other Results</h4>
+
+            <table class="table table-striped">
+              <thead>
+                <tr>
+                  <th>Peer Name</th>
+                  <th>Country</th>
+                  <th>Latency</th>
+                  <th>Jitter</th>
+                </tr>
+              </thead>
+              <tbody>
+                {{range .Results}}
+                  <tr>
+                    <th>{{.Name}}</th>
+                    <td>{{.Country}}</td>
+                    <td>{{printf "%0.3f ms" .Latency}}</td>
+                    <td>{{ if eq .Jitter 0.0 }}&mdash;{{ else }}{{ printf "%0.3f ms" .Jitter }}{{ end }}</td>
+                  </tr>
+                {{end}}
+              </tbody>
+            </table>
+          </div>
+        </div>
+      {{end}}
+    {{end}}
+  {{end}}
+{{end}}
--- a/app/peerfinder/peer.go
+++ b/app/peerfinder/peer.go
@@ -4,43 +4,149 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"net"
 	"net/netip"
 	"strconv"
+	"strings"
 	"time"

+	"github.com/tj/go-semver"
+
+	"github.com/oklog/ulid/v2"
 	"github.com/sour-is/ev/pkg/es/event"
 )

-type Request struct{
+type Request struct {
 	event.AggregateRoot

-	RequestIP string `json:"req_ip"`
-	Hidden    bool   `json:"hide,omitempty"`
+	RequestID string    `json:"req_id"`
+	RequestIP string    `json:"req_ip"`
+	Hidden    bool      `json:"hide,omitempty"`
+	Created   time.Time `json:"req_created"`

 	Responses []Response `json:"responses"`
 }

 var _ event.Aggregate = (*Request)(nil)
+
 func (a *Request) ApplyEvent(lis ...event.Event) {
 	for _, e := range lis {
-		switch e:=e.(type) {
+		switch e := e.(type) {
 		case *RequestSubmitted:
+			a.RequestID = e.eventMeta.EventID.String()
 			a.RequestIP = e.RequestIP
 			a.Hidden = e.Hidden
+			a.Created = ulid.Time(e.EventMeta().EventID.Time())
 		case *ResultSubmitted:
-				a.Responses = append(a.Responses, Response{
-					PeerID: e.PeerID,
-					PeerVersion: e.PeerVersion,
-					Latency: e.Latency,
-				})
+			a.Responses = append(a.Responses, Response{
+				PeerID:        e.PeerID,
+				ScriptVersion: e.PeerVersion,
+				Latency:       e.Latency,
+				Jitter:        e.Jitter,
+				MinRTT:        e.MinRTT,
+				MaxRTT:        e.MaxRTT,
+				Sent:          e.Sent,
+				Received:      e.Received,
+				Unreachable:   e.Unreachable,
+				Created:       ulid.Time(e.EventMeta().EventID.Time()),
+			})
 		}
 	}
 }

+type Time time.Time
+
+func (t *Time) UnmarshalJSON(b []byte) error {
+	time, err := time.Parse(`"2006-01-02 15:04:05"`, string(b))
+	*t = Time(time)
+	return err
+}
+func (t *Time) MarshalJSON() ([]byte, error) {
+	if t == nil {
+		return nil, nil
+	}
+	i := *t
+	return time.Time(i).MarshalJSON()
+}
+
+type ipFamily string
+
+const (
+	ipFamilyV4   ipFamily = "IPv4"
+	ipFamilyV6   ipFamily = "IPv6"
+	ipFamilyBoth ipFamily = "both"
+	ipFamilyNone ipFamily = "none"
+)
+
+func (t *ipFamily) UnmarshalJSON(b []byte) error {
+	i, err := strconv.Atoi(strings.Trim(string(b), `"`))
+	switch i {
+	case 1:
+		*t = ipFamilyV4
+	case 2:
+		*t = ipFamilyV6
+	case 3:
+		*t = ipFamilyBoth
+	default:
+		*t = ipFamilyNone
+	}
+	return err
+}
+
+type peerType []string
+
+func (t *peerType) UnmarshalJSON(b []byte) error {
+	*t = strings.Split(strings.Trim(string(b), `"`), ",")
+	return nil
+}
+
+type Peer struct {
+	ID      string   `json:"peer_id,omitempty"`
+	Owner   string   `json:"peer_owner"`
+	Nick    string   `json:"peer_nick"`
+	Name    string   `json:"peer_name"`
+	Country string   `json:"peer_country"`
+	Note    string   `json:"peer_note"`
+	Family  ipFamily `json:"peer_family"`
+	Type    peerType `json:"peer_type"`
+	Created Time     `json:"peer_created"`
+}
+
+func (p *Peer) CanSupport(ip string) bool {
+	addr := net.ParseIP(ip)
+	if addr == nil {
+		return false
+	}
+	if !addr.IsGlobalUnicast() {
+		return false
+	}
+
+	switch p.Family {
+	case ipFamilyV4:
+		return addr.To4() != nil
+	case ipFamilyV6:
+		return addr.To16() != nil
+	case ipFamilyNone:
+		return false
+	}
+
+	return true
+}
+
 type Response struct {
-	PeerID      string  `json:"peer_id"`
-	PeerVersion string  `json:"peer_version"`
-	Latency     float64 `json:"latency,omitempty"`
+	Peer          *Peer  `json:"peer"`
+	PeerID        string `json:"-"`
+	ScriptVersion string `json:"peer_scriptver"`
+
+	Latency     float64 `json:"res_latency"`
+	Jitter      float64 `json:"res_jitter,omitempty"`
+	MaxRTT      float64 `json:"res_maxrtt,omitempty"`
+	MinRTT      float64 `json:"res_minrtt,omitempty"`
+	Sent        int     `json:"res_sent,omitempty"`
+	Received    int     `json:"res_recv,omitempty"`
+	Unreachable bool    `json:"unreachable,omitempty"`
+
+	Created time.Time `json:"res_created"`
 }

 type RequestSubmitted struct {
@@ -131,6 +237,12 @@ type ResultSubmitted struct {
 	PeerID      string  `json:"peer_id"`
 	PeerVersion string  `json:"peer_version"`
 	Latency     float64 `json:"latency,omitempty"`
+	Jitter      float64 `json:"jitter,omitempty"`
+	MaxRTT      float64 `json:"maxrtt,omitempty"`
+	MinRTT      float64 `json:"minrtt,omitempty"`
+	Sent        int     `json:"res_sent,omitempty"`
+	Received    int     `json:"res_recv,omitempty"`
+	Unreachable bool    `json:"unreachable,omitempty"`
 }

 func (r *ResultSubmitted) Created() time.Time {
@@ -185,10 +297,17 @@ func (a *Info) MarshalEnviron() ([]byte, error) {

 	return b.Bytes(), nil
 }
-func (a *Info) OnCreate() error {
+func (a *Info) OnUpsert() error {
 	if a.StreamVersion() == 0 {
 		event.Raise(a, &VersionChanged{ScriptVersion: initVersion})
 	}
+	current, _ := semver.Parse(initVersion)
+	previous, _ := semver.Parse(a.ScriptVersion)
+
+	if current.Compare(previous) > 0 {
+		event.Raise(a, &VersionChanged{ScriptVersion: initVersion})
+	}
+
 	return nil
 }

--- a/app/peerfinder/service.go
+++ b/app/peerfinder/service.go
@@ -4,33 +4,41 @@ import (
 	"context"
 	"embed"
 	"encoding/json"
+	"errors"
+	"fmt"
 	"html/template"
 	"io"
 	"io/fs"
 	"log"
 	"net"
 	"net/http"
+	"sort"
 	"strconv"
 	"strings"
+	"time"

+	"github.com/oklog/ulid"
 	contentnegotiation "gitlab.com/jamietanna/content-negotiation-go"
 	"go.opentelemetry.io/otel/attribute"

-	"github.com/oklog/ulid"
 	"github.com/sour-is/ev/internal/lg"
 	"github.com/sour-is/ev/pkg/es"
 	"github.com/sour-is/ev/pkg/es/event"
 	"github.com/sour-is/ev/pkg/locker"
+	"github.com/sour-is/ev/pkg/math"
+	"github.com/sour-is/ev/pkg/set"
 )

 const (
-	aggInfo        = "pf-info"
-	queueRequests  = "pf-requests"
-	queueResponses = "pf-request-"
-	queuePeers     = "pf-peer-"
-	initVersion    = "1.1.0"
+	aggInfo       = "pf-info"
+	queueRequests = "pf-requests"
+	queueResults  = "pf-results"
+	initVersion   = "1.2.1"
 )

+func aggRequest(id string) string { return "pf-request-" + id }
+func aggPeer(id string) string    { return "pf-peer-" + id }
+
 var (
 	//go:embed pages/* layouts/* assets/*
 	files     embed.FS
@@ -38,33 +46,33 @@ var (
 )

 type service struct {
-	es *es.EventStore
+	es        *es.EventStore
+	statusURL string

-	State locker.Locked[state]
+	state *locker.Locked[state]
 }

 type state struct {
-	Version  string
-	Requests []Request
+	peers map[string]*Peer
 }

-func New(ctx context.Context, es *es.EventStore) (*service, error) {
+func New(ctx context.Context, es *es.EventStore, statusURL string) (*service, error) {
 	ctx, span := lg.Span(ctx)
 	defer span.End()

+	loadTemplates()
+
 	if err := event.Register(ctx, &RequestSubmitted{}, &ResultSubmitted{}, &VersionChanged{}); err != nil {
 		span.RecordError(err)
 		return nil, err
 	}

-	svc := &service{es: es}
+	svc := &service{es: es, statusURL: statusURL, state: locker.New(&state{peers: make(map[string]*Peer)})}

 	return svc, nil
 }
 func (s *service) RegisterHTTP(mux *http.ServeMux) {
-	loadTemplates()
-	a, err := fs.Sub(files, "assets")
-	log.Println(err)
+	a, _ := fs.Sub(files, "assets")
 	assets := http.StripPrefix("/peers/assets/", http.FileServer(http.FS(a)))

 	mux.Handle("/peers/assets/", lg.Htrace(assets, "peer-assets"))
@@ -73,7 +81,7 @@ func (s *service) RegisterHTTP(mux *http.ServeMux) {
 func (s *service) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()

-	_, span := lg.Span(ctx)
+	ctx, span := lg.Span(ctx)
 	defer span.End()

 	r = r.WithContext(ctx)
@@ -86,12 +94,20 @@ func (s *service) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 			return

 		case strings.HasPrefix(r.URL.Path, "/peers/req/"):
-			s.getResults(w, r, strings.TrimPrefix(r.URL.Path, "/peers/req/"))
+			s.getResultsForRequest(w, r, strings.TrimPrefix(r.URL.Path, "/peers/req/"))
 			return

+		case strings.HasPrefix(r.URL.Path, "/peers/status"):
+			s.state.Modify(r.Context(), func(ctx context.Context, state *state) error {
+				for id, p := range state.peers {
+					fmt.Fprintln(w, "PEER: ", id, p.Owner, p.Name)
+				}
+
+				return nil
+			})
+
 		default:
-			t := templates["home.tpl"]
-			t.Execute(w, nil)
+			s.getResults(w, r)
 			return
 		}
 	case http.MethodPost:
@@ -122,8 +138,23 @@ func (s *service) getPending(w http.ResponseWriter, r *http.Request, uuid string
 		attribute.String("uuid", uuid),
 	)

-	info, err := es.Upsert(ctx, s.es, "pf-info", func(ctx context.Context, agg *Info) error {
-		return agg.OnCreate() // initialize if not exists
+	var peer *Peer
+	err := s.state.Modify(ctx, func(ctx context.Context, state *state) error {
+		var ok bool
+		if peer, ok = state.peers[uuid]; !ok {
+			return fmt.Errorf("peer not found: %s", uuid)
+		}
+
+		return nil
+	})
+	if err != nil {
+		span.RecordError(err)
+		w.WriteHeader(http.StatusNotFound)
+		return
+	}
+
+	info, err := es.Upsert(ctx, s.es, aggInfo, func(ctx context.Context, agg *Info) error {
+		return agg.OnUpsert() // initialize if not exists
 	})
 	if err != nil {
 		span.RecordError(err)
@@ -138,14 +169,16 @@ func (s *service) getPending(w http.ResponseWriter, r *http.Request, uuid string
 		return
 	}

-	responses, err := s.es.Read(ctx, queuePeers+uuid, -1, -30)
+	responses, err := s.es.Read(ctx, aggPeer(uuid), -1, -30)
 	if err != nil {
 		span.RecordError(err)
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}

-	req := filter(requests, responses)
+	span.AddEvent(fmt.Sprintf("req = %d, res = %d", len(requests), len(responses)))
+
+	req := filter(peer, requests, responses)

 	negotiator := contentnegotiation.NewNegotiator("application/json", "text/environment", "text/plain", "text/html")
 	negotiated, _, err := negotiator.Negotiate(r.Header.Get("Accept"))
@@ -183,7 +216,41 @@ func (s *service) getPending(w http.ResponseWriter, r *http.Request, uuid string
 	}
 	span.RecordError(err)
 }
-func (s *service) getResults(w http.ResponseWriter, r *http.Request, uuid string) {
+func (s *service) getResults(w http.ResponseWriter, r *http.Request) {
+	ctx, span := lg.Span(r.Context())
+	defer span.End()
+
+	events, err := s.es.Read(ctx, queueRequests, -1, -30)
+	if err != nil {
+		span.RecordError(err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	requests := make([]*Request, len(events))
+	for i, req := range events {
+		if req, ok := req.(*RequestSubmitted); ok {
+			requests[i], err = s.loadResult(ctx, req.RequestID())
+			if err != nil {
+				span.RecordError(err)
+				w.WriteHeader(http.StatusInternalServerError)
+				return
+			}
+		}
+	}
+
+	args := requestArgs(r)
+	args.Requests = requests
+
+	s.state.Modify(ctx, func(ctx context.Context, state *state) error {
+		args.CountPeers = len(state.peers)
+		return nil
+	})
+
+	t := templates["home.tpl"]
+	t.Execute(w, args)
+}
+func (s *service) getResultsForRequest(w http.ResponseWriter, r *http.Request, uuid string) {
 	ctx, span := lg.Span(r.Context())
 	defer span.End()

@@ -191,23 +258,33 @@ func (s *service) getResults(w http.ResponseWriter, r *http.Request, uuid string
 		attribute.String("uuid", uuid),
 	)

-	responses, err := s.es.Read(ctx, queueResponses+uuid, -1, es.AllEvents)
+	request, err := s.loadResult(ctx, uuid)
 	if err != nil {
 		w.WriteHeader(http.StatusInternalServerError)
 		return
 	}

 	negotiator := contentnegotiation.NewNegotiator("application/json", "text/environment", "text/csv", "text/plain", "text/html")
-	negotiated, _, err := negotiator.Negotiate("application/json")
+	negotiated, _, err := negotiator.Negotiate(r.Header.Get("Accept"))
 	if err != nil {
 		w.WriteHeader(http.StatusNotAcceptable)
 		return
 	}
+	span.AddEvent(negotiated.String())
 	switch negotiated.String() {
 	// case "text/environment":
 	// 	encodeTo(w, responses.MarshalBinary)
 	case "application/json":
-		json.NewEncoder(w).Encode(responses)
+		json.NewEncoder(w).Encode(request)
+		return
+	default:
+		args := requestArgs(r)
+		args.Requests = append(args.Requests, request)
+		span.AddEvent(fmt.Sprint(args))
+		err := renderTo(w, "req.tpl", args)
+		span.RecordError(err)
+
+		return
 	}
 }
 func (s *service) postRequest(w http.ResponseWriter, r *http.Request) {
@@ -219,7 +296,14 @@ func (s *service) postRequest(w http.ResponseWriter, r *http.Request) {
 		return
 	}

-	ip := net.ParseIP(r.Form.Get("req_ip"))
+	args := requestArgs(r)
+	requestIP := args.RemoteIP
+
+	if ip := r.Form.Get("req_ip"); ip != "" {
+		requestIP = ip
+	}
+
+	ip := net.ParseIP(requestIP)
 	if ip == nil {
 		w.WriteHeader(http.StatusBadRequest)
 		return
@@ -236,6 +320,8 @@ func (s *service) postRequest(w http.ResponseWriter, r *http.Request) {
 	)

 	s.es.Append(ctx, queueRequests, event.NewEvents(req))
+
+	http.Redirect(w, r, "/peers/req/"+req.RequestID(), http.StatusSeeOther)
 }
 func (s *service) postResult(w http.ResponseWriter, r *http.Request, id string) {
 	ctx, span := lg.Span(r.Context())
@@ -255,10 +341,26 @@ func (s *service) postResult(w http.ResponseWriter, r *http.Request, id string)
 		return
 	}

+	peerID := r.Form.Get("peer_id")
+	err := s.state.Modify(ctx, func(ctx context.Context, state *state) error {
+		var ok bool
+		if _, ok = state.peers[peerID]; !ok {
+			// fmt.Printf("peer not found: %s\n", peerID)
+			return fmt.Errorf("peer not found: %s", peerID)
+		}
+
+		return nil
+	})
+	if err != nil {
+		span.RecordError(err)
+		w.WriteHeader(http.StatusNotFound)
+		return
+	}
+
+	var unreach bool
 	latency, err := strconv.ParseFloat(r.Form.Get("res_latency"), 64)
 	if err != nil {
-		w.WriteHeader(http.StatusUnprocessableEntity)
-		return
+		unreach = true
 	}

 	req := &ResultSubmitted{
@@ -266,13 +368,35 @@ func (s *service) postResult(w http.ResponseWriter, r *http.Request, id string)
 		PeerID:      r.Form.Get("peer_id"),
 		PeerVersion: r.Form.Get("peer_version"),
 		Latency:     latency,
+		Unreachable: unreach,
+	}
+
+	if jitter, err := strconv.ParseFloat(r.Form.Get("res_jitter"), 64); err == nil {
+		req.Jitter = jitter
+	} else {
+		span.RecordError(err)
+	}
+	if minrtt, err := strconv.ParseFloat(r.Form.Get("res_minrtt"), 64); err == nil {
+		req.MinRTT = minrtt
+	} else {
+		span.RecordError(err)
+	}
+	if maxrtt, err := strconv.ParseFloat(r.Form.Get("res_maxrtt"), 64); err == nil {
+		req.MaxRTT = maxrtt
+	} else {
+		span.RecordError(err)
 	}

 	span.SetAttributes(
 		attribute.Stringer("result", req),
 	)

-	idx, err := s.es.LastIndex(ctx, queueResponses+id)
+	s.state.Modify(ctx, func(ctx context.Context, state *state) error {
+
+		return nil
+	})
+
+	idx, err := s.es.LastIndex(ctx, aggRequest(id))
 	if err != nil {
 		w.WriteHeader(http.StatusInternalServerError)
 		return
@@ -282,16 +406,219 @@ func (s *service) postResult(w http.ResponseWriter, r *http.Request, id string)
 		return
 	}

-	s.es.Append(ctx, queueRequests, event.NewEvents(req))
+	s.es.Append(ctx, queueResults, event.NewEvents(req))
+}
+func (s *service) RefreshJob(ctx context.Context, _ time.Time) error {
+	ctx, span := lg.Span(ctx)
+	defer span.End()
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, s.statusURL, nil)
+	span.RecordError(err)
+	if err != nil {
+		return err
+	}
+	req.Header.Set("Accept", "application/json")
+
+	res, err := http.DefaultClient.Do(req)
+	span.RecordError(err)
+	if err != nil {
+		return err
+	}
+
+	defer res.Body.Close()
+	var peers []*Peer
+	err = json.NewDecoder(res.Body).Decode(&peers)
+	span.RecordError(err)
+	if err != nil {
+		return err
+	}
+
+	span.AddEvent(fmt.Sprintf("processed %d peers", len(peers)))
+
+	err = s.state.Modify(ctx, func(ctx context.Context, t *state) error {
+		for _, peer := range peers {
+			t.peers[peer.ID] = peer
+		}
+
+		return nil
+	})
+	span.RecordError(err)
+	return err
+}
+func (s *service) CleanJob(ctx context.Context, now time.Time) error {
+	ctx, span := lg.Span(ctx)
+	defer span.End()
+
+	fmt.Println("clear peerfinder requests")
+	span.AddEvent("clear peerfinder requests")
+
+	endRequestID, err := s.cleanRequests(ctx, now)
+	if err != nil {
+		return err
+	}
+	if err = s.cleanResults(ctx, endRequestID); err != nil {
+		return err
+	}
+
+	return s.cleanPeerJobs(ctx)
+}
+func (s *service) cleanPeerJobs(ctx context.Context) error {
+	ctx, span := lg.Span(ctx)
+	defer span.End()
+
+	peers := set.New[string]()
+	err := s.state.Modify(ctx, func(ctx context.Context, state *state) error {
+		for id := range state.peers {
+			peers.Add(id)
+		}
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+
+	// trunctate all the peer streams to last 30
+	for streamID := range peers {
+		streamID = aggPeer(streamID)
+		first, err := s.es.FirstIndex(ctx, streamID)
+		if err != nil {
+			return err
+		}
+		last, err := s.es.LastIndex(ctx, streamID)
+		if err != nil {
+			return err
+		}
+		newFirst := math.Max(math.Max(int64(last-30), int64(first)), 1)
+		if last == 0 || newFirst == int64(first) {
+			// fmt.Println("SKIP", streamID, first, newFirst, last)
+			span.AddEvent(fmt.Sprint("SKIP", streamID, first, newFirst, last))
+			continue
+		}
+		// fmt.Println("TRUNC", streamID, first, newFirst, last)
+		span.AddEvent(fmt.Sprint("TRUNC", streamID, first, newFirst, last))
+		err = s.es.Truncate(ctx, streamID, int64(newFirst))
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+func (s *service) cleanRequests(ctx context.Context, now time.Time) (string, error) {
+	ctx, span := lg.Span(ctx)
+	defer span.End()
+
+	var streamIDs []string
+	var endPosition uint64
+	var endRequestID string
+
+	last, err := s.es.LastIndex(ctx, queueRequests)
+	if err != nil {
+		return "", err
+	}
+
+end:
+	for {
+		events, err := s.es.Read(ctx, queueRequests, int64(endPosition), 1000) // read 1000 from the top each loop.
+		if err != nil && !errors.Is(err, es.ErrNotFound) {
+			span.RecordError(err)
+			return "", err
+		}
+
+		if len(events) == 0 {
+			break
+		}
+
+		endPosition = events.Last().EventMeta().ActualPosition
+		for _, event := range events {
+			switch e := event.(type) {
+			case *RequestSubmitted:
+				if e.eventMeta.ActualPosition < last-30 || e.Created().Before(now.Add(-24*time.Hour)) {
+					streamIDs = append(streamIDs, aggRequest(e.RequestID()))
+				} else {
+					endRequestID = e.RequestID()
+					endPosition = e.eventMeta.ActualPosition
+					break end
+				}
+			}
+		}
+	}
+
+	// truncate all reqs to found end position
+	// fmt.Println("TRUNC", queueRequests, int64(endPosition), last)
+	span.AddEvent(fmt.Sprint("TRUNC", queueRequests, int64(endPosition), last))
+	err = s.es.Truncate(ctx, queueRequests, int64(endPosition))
+	if err != nil {
+		return "", err
+	}
+
+	// truncate all the request streams
+	for _, streamID := range streamIDs {
+		last, err := s.es.LastIndex(ctx, streamID)
+		if err != nil {
+			return "", err
+		}
+		fmt.Println("TRUNC", streamID, last)
+		span.AddEvent(fmt.Sprint("TRUNC", streamID, last))
+		err = s.es.Truncate(ctx, streamID, int64(last))
+		if err != nil {
+			return "", err
+		}
+	}
+
+	return endRequestID, nil
+}
+func (s *service) cleanResults(ctx context.Context, endRequestID string) error {
+	ctx, span := lg.Span(ctx)
+	defer span.End()
+
+	var endPosition uint64
+
+	done := false
+	for !done {
+		events, err := s.es.Read(ctx, queueResults, int64(endPosition), 1000) // read 30 from the top each loop.
+		if err != nil {
+			return err
+		}
+
+		if len(events) == 0 {
+			done = true
+			continue
+		}
+
+		endPosition = events.Last().EventMeta().ActualPosition
+
+		for _, event := range events {
+			switch e := event.(type) {
+			case *ResultSubmitted:
+				if e.RequestID == endRequestID {
+					done = true
+					endPosition = e.eventMeta.ActualPosition
+				}
+			}
+		}
+	}
+	// truncate all reqs to found end position
+	// fmt.Println("TRUNC", queueResults, int64(endPosition), last)
+	span.AddEvent(fmt.Sprint("TRUNC", queueResults, int64(endPosition)))
+	err := s.es.Truncate(ctx, queueResults, int64(endPosition))
+	if err != nil {
+		return err
+	}
+	return nil
 }

-func filter(requests, responses event.Events) *RequestSubmitted {
+func filter(peer *Peer, requests, responses event.Events) *RequestSubmitted {
 	have := make(map[string]struct{}, len(responses))
 	for _, res := range toList[ResultSubmitted](responses...) {
 		have[res.RequestID] = struct{}{}
 	}
 	for _, req := range reverse(toList[RequestSubmitted](requests...)...) {
 		if _, ok := have[req.RequestID()]; !ok {
+			if !peer.CanSupport(req.RequestIP) {
+				continue
+			}
+
 			return req
 		}
 	}
@@ -345,12 +672,14 @@ func loadTemplates() error {
 		if tmpl.IsDir() {
 			continue
 		}
-		log.Println(tmpl.Name())
-		pt, err := template.ParseFS(files, "pages/"+tmpl.Name(), "layouts/*.tpl")
+		pt := template.New(tmpl.Name())
+		pt.Funcs(funcMap)
+		pt, err = pt.ParseFS(files, "pages/"+tmpl.Name(), "layouts/*.tpl")
 		if err != nil {
+			log.Println(err)
+
 			return err
 		}
-
 		templates[tmpl.Name()] = pt
 	}
 	return nil
@@ -364,17 +693,144 @@ func Projector(e event.Event) []event.Event {
 	switch e := e.(type) {
 	case *RequestSubmitted:
 		e1 := event.NewPtr(streamID, streamPos)
-		event.SetStreamID(queueResponses+e.RequestID(), e1)
+		event.SetStreamID(aggRequest(e.RequestID()), e1)

 		return []event.Event{e1}
 	case *ResultSubmitted:
 		e1 := event.NewPtr(streamID, streamPos)
-		event.SetStreamID(queueResponses+e.RequestID, e1)
+		event.SetStreamID(aggRequest(e.RequestID), e1)

 		e2 := event.NewPtr(streamID, streamPos)
-		event.SetStreamID(queuePeers+e.PeerID, e2)
+		event.SetStreamID(aggPeer(e.PeerID), e2)

 		return []event.Event{e1, e2}
 	}
 	return nil
 }
+
+type Args struct {
+	RemoteIP   string
+	Requests   []*Request
+	CountPeers int
+}
+
+func requestArgs(r *http.Request) Args {
+	remoteIP, _, _ := strings.Cut(r.RemoteAddr, ":")
+	if s := r.Header.Get("X-Forwarded-For"); s != "" {
+		remoteIP = s
+	}
+	return Args{
+		RemoteIP: remoteIP,
+	}
+}
+
+func renderTo(w io.Writer, name string, args any) (err error) {
+	defer func() {
+		if p := recover(); p != nil {
+			err = fmt.Errorf("panic: %s", p)
+		}
+		if err != nil {
+			fmt.Fprint(w, err)
+		}
+	}()
+
+	t, ok := templates[name]
+	if !ok || t == nil {
+		return fmt.Errorf("missing template")
+	}
+	return t.Execute(w, args)
+}
+
+type ListResponse []Response
+
+func (lis ListResponse) Len() int {
+	return len(lis)
+}
+func (lis ListResponse) Less(i, j int) bool {
+	return lis[i].Latency < lis[j].Latency
+}
+func (lis ListResponse) Swap(i, j int) {
+	lis[i], lis[j] = lis[j], lis[i]
+}
+
+func fnOrderByPeer(rq *Request) any {
+	type peerResult struct {
+		Name    string
+		Country string
+		Latency float64
+		Jitter  float64
+	}
+	type peer struct {
+		Name     string
+		Note     string
+		Nick     string
+		Country  string
+		Latency  float64
+		Jitter   float64
+		VPNTypes []string
+
+		Results []peerResult
+	}
+
+	peers := make(map[string]peer)
+	sort.Sort(ListResponse(rq.Responses))
+	for _, rs := range rq.Responses {
+		p, ok := peers[rs.Peer.Owner]
+
+		if !ok {
+			p.Country = rs.Peer.Country
+			p.Name = rs.Peer.Name
+			p.Nick = rs.Peer.Nick
+			p.Note = rs.Peer.Note
+			p.Latency = rs.Latency
+			p.Jitter = rs.Jitter
+			p.VPNTypes = rs.Peer.Type
+		}
+
+		p.Results = append(p.Results, peerResult{
+			Name:    rs.Peer.Name,
+			Country: rs.Peer.Country,
+			Latency: rs.Latency,
+			Jitter:  rs.Jitter,
+		})
+
+		peers[rs.Peer.Owner] = p
+	}
+
+	return peers
+}
+func fnCountResponses(rq *Request) int {
+	count := 0
+	for _, res := range rq.Responses {
+		if !res.Unreachable {
+			count++
+		}
+	}
+	return count
+}
+
+var funcMap = map[string]any{
+	"orderByPeer":    fnOrderByPeer,
+	"countResponses": fnCountResponses,
+}
+
+func (s *service) loadResult(ctx context.Context, uuid string) (*Request, error) {
+	request := &Request{}
+	request.SetStreamID(aggRequest(uuid))
+	err := s.es.Load(ctx, request)
+	if err != nil {
+		return nil, err
+	}
+
+	return request, s.state.Modify(ctx, func(ctx context.Context, t *state) error {
+		for i := range request.Responses {
+			res := &request.Responses[i]
+			if peer, ok := t.peers[res.PeerID]; ok {
+				res.Peer = peer
+				res.Peer.ID = ""
+			}
+		}
+
+		return nil
+	})
+}