10493180931

Committed 21 Aug 2024 03:50PM UTC coverage: 16.077% (-2.2%) from 18.241%

Build # 10493180931

Build Type

push

github

Committed by

web-flow

Commit Message

Support secure connections (#22)

Run Details

0 of 8 new or added lines in 1 file covered. (0.0%)

12 existing lines in 2 files now uncovered.

100 of 622 relevant lines covered (16.08%)

0.17 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

5.45

/handler/handler.go

package handler

import (
        "encoding/json"
        "fmt"
        "math"
        "net"
        "net/http"
        "net/url"
        "os"
        "path"
        "time"

        "github.com/m-lab/go/timex"
        "github.com/m-lab/ndt-server/metadata"
        "github.com/m-lab/packet-test/api"
        "github.com/m-lab/packet-test/static"
        log "github.com/sirupsen/logrus"
)

// Client handles requests for packet tests.
type Client struct {
        // DataDir is the directory where measurement results are saved.
        DataDir  string
        hostname string
}

// New returns a new instance of *Client.
func New(dataDir string, hostname string) *Client {
        return &Client{
                DataDir:  dataDir,
                hostname: hostname,
        }
}

// ProcessPacketLoop listens for a kickoff UDP packet and then runs a packet test.
func (c *Client) ProcessPacketLoop(conn net.PacketConn) {
        log.Info("Listening for UDP packets")

        buf := make([]byte, static.BufferBytes)
        for {
                n, addr, err := conn.ReadFrom(buf)
                if err != nil {
                        log.Errorf("Failed to read UDP packet: %v", err)
                        continue
                }

                msg := string(buf[:n])
                log.Infof("Received UDP packet addr: %s, n: %d, type: %s ", addr.String(), n, msg)

                switch msg {
                case "pair1":
                        err = c.sendPairs(conn, addr, static.PairGap)
                case "train1":
                        err = c.sendTrains(conn, addr)
                }

        }
}

// HandleResult receives the measurement results from the client and writes them out to
// `datadir`.
func (c *Client) HandleResult(rw http.ResponseWriter, req *http.Request) {
        measurements := make([]api.Measurement, 0)
        err := json.NewDecoder(req.Body).Decode(&measurements)
        if err != nil {
                log.Errorf("Failed to decide measurement result: %v", err)
                rw.WriteHeader(http.StatusBadRequest)
                return
        }

        result := api.Result{
                Server:         c.hostname,
                Client:         req.RemoteAddr,
                ClientMetadata: getClientMetadata(req.URL.Query()),
                Measurements:   measurements,
        }

        err = c.writeMeasurements(req.URL.Query().Get("datatype"), result)
        if err != nil {
                log.Errorf("Failed to write measurement out: %v", err)
                rw.WriteHeader(http.StatusServiceUnavailable)
                return
        }
        rw.WriteHeader(http.StatusOK)
}

func (c *Client) writeMeasurements(datatype string, data interface{}) error {
        t := time.Now().UTC()
        dir := path.Join(c.DataDir, datatype, t.Format(timex.YYYYMMDDWithSlash))
        err := os.MkdirAll(dir, 0755)
        if err != nil {
                return err
        }

        filename := path.Join(dir, datatype+"-"+t.Format("20060102T150405.000000000Z")+".json")
        file, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0644)
        if err != nil {
                return err
        }
        defer file.Close()

        jsonResult, err := json.Marshal(data)
        if err != nil {
                return nil
        }

        _, err = file.Write(jsonResult)
        return err
}

func sendPacket(conn net.PacketConn, addr net.Addr, pkt *api.Packet) error {
        pkt.Sent = time.Now().UTC().UnixMicro()

        m, err := json.Marshal(pkt)
        if err != nil {
                return err
        }

        _, err = conn.WriteTo(m, addr)
        if err != nil {
                return err
        }

        return nil
}

func receiveMeasurements(listener *net.TCPListener) ([]api.Measurement, error) {
        measurements := make([]api.Measurement, 0)

        conn, err := listener.Accept()
        if err != nil {
                return nil, err
        }
        defer conn.Close()

        buf := make([]byte, math.MaxUint16)
        n, err := conn.Read(buf)

        fmt.Println(string(buf[:n]))
        fmt.Println(n)
        fmt.Println(err)

        if err != nil {
                return nil, err
        }

        err = json.Unmarshal(buf[:n], &measurements)
        if err != nil {
                return nil, err
        }

        return measurements, nil
}

func getClientMetadata(values url.Values) []metadata.NameValue {
        md := make([]metadata.NameValue, 0)
        for name, values := range values {
                md = append(md, metadata.NameValue{
                        Name:  name,
                        Value: values[0],
                })
        }
        return md
}

1	package handler
2
3	import (
4	"encoding/json"
5	"fmt"
6	"math"
7	"net"
8	"net/http"
9	"net/url"
10	"os"
11	"path"
12	"time"
13
14	"github.com/m-lab/go/timex"
15	"github.com/m-lab/ndt-server/metadata"
16	"github.com/m-lab/packet-test/api"
17	"github.com/m-lab/packet-test/static"
18	log "github.com/sirupsen/logrus"
19	)
20
21	// Client handles requests for packet tests.
22	type Client struct {
23	// DataDir is the directory where measurement results are saved.
24	DataDir string
25	hostname string
26	}
27
28	// New returns a new instance of *Client.
29	func New(dataDir string, hostname string) *Client {	1✔
30	return &Client{	1✔
31	DataDir: dataDir,	1✔
32	hostname: hostname,	1✔
33	}	1✔
34	}	1✔
35
36	// ProcessPacketLoop listens for a kickoff UDP packet and then runs a packet test.
37	func (c *Client) ProcessPacketLoop(conn net.PacketConn) {	×
38	log.Info("Listening for UDP packets")	×
39		×
40	buf := make([]byte, static.BufferBytes)	×
41	for {	×
42	n, addr, err := conn.ReadFrom(buf)	×
43	if err != nil {	×
44	log.Errorf("Failed to read UDP packet: %v", err)	×
45	continue	×
46	}
47
48	msg := string(buf[:n])	×
49	log.Infof("Received UDP packet addr: %s, n: %d, type: %s ", addr.String(), n, msg)	×
50		×
51	switch msg {	×
52	case "pair1":	×
53	err = c.sendPairs(conn, addr, static.PairGap)	×
54	case "train1":	×
55	err = c.sendTrains(conn, addr)	×
56	}
57
58	}
59	}
60
61	// HandleResult receives the measurement results from the client and writes them out to
62	// `datadir`.
63	func (c Client) HandleResult(rw http.ResponseWriter, req http.Request) {	×
64	measurements := make([]api.Measurement, 0)	×
65	err := json.NewDecoder(req.Body).Decode(&measurements)	×
66	if err != nil {	×
67	log.Errorf("Failed to decide measurement result: %v", err)	×
68	rw.WriteHeader(http.StatusBadRequest)	×
69	return	×
70	}	×
71
72	result := api.Result{	×
73	Server: c.hostname,	×
74	Client: req.RemoteAddr,	×
75	ClientMetadata: getClientMetadata(req.URL.Query()),	×
76	Measurements: measurements,	×
77	}	×
78		×
79	err = c.writeMeasurements(req.URL.Query().Get("datatype"), result)	×
80	if err != nil {	×
81	log.Errorf("Failed to write measurement out: %v", err)	×
82	rw.WriteHeader(http.StatusServiceUnavailable)	×
83	return	×
84	}	×
85	rw.WriteHeader(http.StatusOK)	×
86	}
87
UNCOV 88	func (c *Client) writeMeasurements(datatype string, data interface{}) error {	×
UNCOV 89	t := time.Now().UTC()	×
UNCOV 90	dir := path.Join(c.DataDir, datatype, t.Format(timex.YYYYMMDDWithSlash))	×
UNCOV 91	err := os.MkdirAll(dir, 0755)	×
UNCOV 92	if err != nil {	×
93	return err	×
94	}	×
95
96	filename := path.Join(dir, datatype+"-"+t.Format("20060102T150405.000000000Z")+".json")	×
97	file, err := os.OpenFile(filename, os.O_WRONLY\|os.O_CREATE\|os.O_EXCL, 0644)	×
98	if err != nil {	×
99	return err	×
100	}	×
101	defer file.Close()	×
102		×
103	jsonResult, err := json.Marshal(data)	×
104	if err != nil {	×
105	return nil	×
106	}	×
107
108	_, err = file.Write(jsonResult)	×
109	return err	×
110	}
111
112	func sendPacket(conn net.PacketConn, addr net.Addr, pkt *api.Packet) error {	×
113	pkt.Sent = time.Now().UTC().UnixMicro()	×
114		×
115	m, err := json.Marshal(pkt)	×
116	if err != nil {	×
117	return err	×
118	}	×
119
120	_, err = conn.WriteTo(m, addr)	×
121	if err != nil {	×
122	return err	×
123	}	×
124
125	return nil	×
126	}
127
128	func receiveMeasurements(listener *net.TCPListener) ([]api.Measurement, error) {	×
129	measurements := make([]api.Measurement, 0)	×
130		×
131	conn, err := listener.Accept()	×
132	if err != nil {	×
133	return nil, err	×
134	}	×
135	defer conn.Close()	×
136		×
137	buf := make([]byte, math.MaxUint16)	×
138	n, err := conn.Read(buf)	×
139		×
140	fmt.Println(string(buf[:n]))	×
141	fmt.Println(n)	×
142	fmt.Println(err)	×
143		×
144	if err != nil {	×
145	return nil, err	×
146	}	×
147
148	err = json.Unmarshal(buf[:n], &measurements)	×
149	if err != nil {	×
150	return nil, err	×
151	}	×
152
153	return measurements, nil	×
154	}
155
156	func getClientMetadata(values url.Values) []metadata.NameValue {	×
157	md := make([]metadata.NameValue, 0)	×
158	for name, values := range values {	×
159	md = append(md, metadata.NameValue{	×
160	Name: name,	×
161	Value: values[0],	×
162	})	×
163	}	×
164	return md	×
165	}

m-lab / packet-test / 10493180931

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous