├── tcpmeter.png
├── logger.go
├── README.md
├── LICENSE
├── main.go
├── server.go
├── client.go
├── index.html
└── admui.go


/tcpmeter.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/9nut/tcpmeter/HEAD/tcpmeter.png


--------------------------------------------------------------------------------
/logger.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"log"
 5 | )
 6 | 
 7 | // Continually log any stats, provide them on an output channel
 8 | // to downstream receivers (usually a CStatHandler)
 9 | func LogClient(si chan Stats, so chan Stats) {
10 | 	log.Println("LogClient started...")
11 | 	for {
12 | 		stats, ok := <-si
13 | 		if !ok {
14 | 			log.Fatal("receive failed")
15 | 		}
16 | 		if stats.Stat == "Running" {
17 | 			trace.Printf("|DATA|%s|%d|\n", stats.Type, stats.Rate)
18 | 		}
19 | 		select {
20 | 		case so <- stats:
21 | 		default:
22 | 		}
23 | 	}
24 | }
25 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | **tcpmeter** - a tool for measuring TCP upload and download speeds and RTT latency.
 2 | 
 3 | ### Build
 4 | 
 5 | ```shell
 6 | go build
 7 | ```
 8 | 
 9 | #### Run
10 | 
11 | * start the server on the remote machine:
12 | 
13 |   `tcpmeter -s -r $(hostname):8001`
14 | 
15 | * start the client on the local machine:
16 | 
17 |   `tcpmeter -c`
18 | 
19 |   then navigate to `http://localhost:8080` using an HTML5 browser to interact with the client.
20 | 
21 | ## Documentation
22 | 
23 |  `godoc`
24 | 
25 | ## License
26 |  MIT license (see LICENSE file).
27 | 
28 | ## Contact
29 |  `skip.tavakkolian@gmail.com`
30 | 	
31 | ## Screenshot
32 | ![alt text](https://github.com/9nut/tcpmeter/raw/master/tcpmeter.png "tcpmeter client web UI")
33 | 
34 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2012 Fariborz "Skip" Tavakkolian
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining
 4 | a copy of this software and associated documentation files (the
 5 | "Software"), to deal in the Software without restriction, including
 6 | without limitation the rights to use, copy, modify, merge, publish,
 7 | distribute, sublicense, and/or sell copies of the Software, and to
 8 | permit persons to whom the Software is furnished to do so, subject to
 9 | the following conditions:
10 | 
11 | The above copyright notice and this permission notice shall be
12 | included in all copies or substantial portions of the Software.
13 | 
14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
15 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
16 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
17 | IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
18 | CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
19 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
20 | SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | 


--------------------------------------------------------------------------------
/main.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"flag"
 5 | 	"log"
 6 | 	"os"
 7 | 	"runtime/pprof"
 8 | )
 9 | 
10 | var trace *log.Logger
11 | 
12 | func main() {
13 | 	var cf, sf bool
14 | 	var haddr, raddr string
15 | 	var fname, pname string
16 | 	cmdline := flag.NewFlagSet(os.Args[0], flag.ExitOnError)
17 | 	cmdline.Usage = func() {
18 | 		log.Printf("usage: %s (-c|-s) [-r [host:]port] [-h [host:]port] [-l logfile]\n", os.Args[0])
19 | 	}
20 | 	cmdline.BoolVar(&cf, "c", false, "client mode")
21 | 	cmdline.BoolVar(&sf, "s", false, "server mode")
22 | 	cmdline.StringVar(&raddr, "r", ":8001", "RPC address")
23 | 	cmdline.StringVar(&haddr, "h", ":8080", "Admin WebUI")
24 | 	cmdline.StringVar(&fname, "l", "/tmp/tcpmeter.log", "Log file name")
25 | 	cmdline.StringVar(&pname, "p", "", "CPU profile file")
26 | 
27 | 	cmdline.Parse(os.Args[1:])
28 | 
29 | 	if pname != "" {
30 | 		f, err := os.Create(pname)
31 | 		if err != nil {
32 | 			log.Fatal(err)
33 | 		}
34 | 		if err = pprof.StartCPUProfile(f); err != nil {
35 | 			log.Fatal(err)
36 | 		}
37 | 		defer pprof.StopCPUProfile()
38 | 	}
39 | 	if cf == sf {
40 | 		cmdline.Usage()
41 | 		log.Fatalln("either -s or -c must be specified")
42 | 	}
43 | 
44 | 	logfile, err := os.OpenFile(fname, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0660)
45 | 	if err != nil {
46 | 		log.Fatal("OpenFile failed", err)
47 | 	}
48 | 	defer logfile.Close()
49 | 	trace = log.New(logfile, "", log.LstdFlags)
50 | 	log.SetFlags(log.Flags() | log.Llongfile)
51 | 
52 | 	if cf {
53 | 		ClientMain(haddr)
54 | 	} else {
55 | 		TCPServer(raddr)
56 | 	}
57 | }
58 | 


--------------------------------------------------------------------------------
/server.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"errors"
  5 | 	"fmt"
  6 | 	"io"
  7 | 	"log"
  8 | 	"net"
  9 | 	"net/rpc"
 10 | 	"time"
 11 | )
 12 | 
 13 | var SrvAddr *net.TCPAddr
 14 | 
 15 | type NullFile struct{}
 16 | type ZeroFile struct{}
 17 | 
 18 | func (d *NullFile) Write(p []byte) (int, error) {
 19 | 	return len(p), nil
 20 | }
 21 | 
 22 | func (d *ZeroFile) Read(p []byte) (int, error) {
 23 | 	return len(p), nil
 24 | }
 25 | 
 26 | // TCPPerf is the receiver type for TCP Performance RPC methods
 27 | type TCPPerf struct {
 28 | 	LData   *net.TCPListener // payload data listener
 29 | 	DevNull *NullFile
 30 | 	DevZero *ZeroFile
 31 | }
 32 | 
 33 | // TCPStart method prepares the tcp link that will be used for tcp performance testing
 34 | func (p *TCPPerf) TCPStart(_ int, r *string) error {
 35 | 	log.Println("TCPStart called")
 36 | 	if p.LData != nil {
 37 | 		p.LData.Close()
 38 | 	}
 39 | 
 40 | 	var err error
 41 | 	p.DevNull = &NullFile{}
 42 | 	p.DevZero = &ZeroFile{}
 43 | 
 44 | 	addr := "" // use any available port for payload
 45 | 	if SrvAddr.IP != nil {
 46 | 		addr = SrvAddr.IP.String() + ":0"
 47 | 	} else {
 48 | 		addr = "localhost:0"
 49 | 	}
 50 | 
 51 | 	DAddr, err := net.ResolveTCPAddr("tcp", addr)
 52 | 	if err != nil {
 53 | 		log.Println("ResolveTCPAddr: ", err)
 54 | 		return err
 55 | 	}
 56 | 
 57 | 	p.LData, err = net.ListenTCP("tcp", DAddr)
 58 | 	if err != nil {
 59 | 		log.Println("ListenTCP: ", err)
 60 | 		return err
 61 | 	}
 62 | 
 63 | 	DAddr, ok := p.LData.Addr().(*net.TCPAddr)
 64 | 	if ok {
 65 | 		*r = fmt.Sprint(DAddr.Port)
 66 | 	}
 67 | 
 68 | 	log.Println("Payload port: ", *r)
 69 | 	return nil
 70 | }
 71 | 
 72 | // TCPStop method tears down the tcp link that was used for tcp performance testing
 73 | func (p *TCPPerf) TCPStop(_ int, r *bool) error {
 74 | 	*r = false
 75 | 	log.Println("TCPStop called")
 76 | 	p.LData.Close()
 77 | 	p.LData = nil
 78 | 	*r = true
 79 | 	return nil
 80 | }
 81 | 
 82 | // accept with deadline will do a timed accept of the payload tcp, returning a TCPConn
 83 | // when possible
 84 | func (p *TCPPerf) timedaccept() (conn *net.TCPConn, err error) {
 85 | 	log.Println("timedaccept called")
 86 | 	if p.LData == nil {
 87 | 		err = errors.New("No Payload TCP Listener")
 88 | 		log.Println(err)
 89 | 		return nil, err
 90 | 	}
 91 | 
 92 | 	stop := make(chan bool)
 93 | 	go func(stop chan bool) {
 94 | 		select {
 95 | 		case <-time.After(5 * time.Second):
 96 | 			log.Println("Timeout")
 97 | 			p.LData.Close()
 98 | 		case <-stop:
 99 | 		}
100 | 	}(stop)
101 | 	conn, err = p.LData.AcceptTCP()
102 | 	if err != nil {
103 | 		log.Println("AcceptTCP", err)
104 | 	}
105 | 	stop <- true // there will be a race
106 | 	return
107 | }
108 | 
109 | // TCPRcv method tries to receive the number of bytes given by the first parameter
110 | // on a TCP host/port specified in the TCPPerf reciever.  If successful, it will store
111 | // the number of bytes it actually received, at the location given by the second parameter.
112 | func (p *TCPPerf) TCPRcv(n uint64, r *uint64) error {
113 | 	*r = 0
114 | 	log.Println("TCPRcv called")
115 | 	conn, err := p.timedaccept()
116 | 	if err != nil {
117 | 		log.Println("timedaccept", err)
118 | 		return err
119 | 	}
120 | 	defer conn.Close()
121 | 
122 | 	ncpy, err := io.CopyN(p.DevNull, conn, int64(n))
123 | 	if err != nil {
124 | 		log.Println("CopyN error: ", err)
125 | 		return err
126 | 	}
127 | 	*r = uint64(ncpy)
128 | 	return nil
129 | }
130 | 
131 | // TCPSnd method tries to send the number of bytes given by the first parameter
132 | // on a TCP host/port specified in the TCPPerf reciever. It will store
133 | // the number of bytes it actually sent, at the location given by the second parameter.
134 | func (p *TCPPerf) TCPSnd(n uint64, r *uint64) error {
135 | 	*r = 0
136 | 	log.Println("TCPSnd called")
137 | 	conn, err := p.timedaccept()
138 | 	if err != nil {
139 | 		log.Println("timedaccept", err)
140 | 		return err
141 | 	}
142 | 	defer conn.Close()
143 | 
144 | 	ncpy, err := io.CopyN(conn, p.DevZero, int64(n))
145 | 	if err != nil {
146 | 		log.Println("CopyN error: ", err)
147 | 		return err
148 | 	}
149 | 	*r = uint64(ncpy)
150 | 	return nil
151 | }
152 | 
153 | // TCPCpy method listens on a TCP host/port specified in the TCPPerf receiver and
154 | // once established, it copies everything it recieves back to the sender.
155 | func (p *TCPPerf) TCPCpy(_ uint64, r *uint64) error {
156 | 	*r = 0
157 | 	log.Println("TCPCpy called")
158 | 	conn, err := p.timedaccept()
159 | 	if err != nil {
160 | 		log.Println("timedaccept", err)
161 | 		return err
162 | 	}
163 | 	defer conn.Close()
164 | 
165 | 	ncpy, err := io.Copy(conn, conn)
166 | 	if err != nil {
167 | 		log.Println("Copy error: ", err)
168 | 		return err
169 | 	}
170 | 	*r = uint64(ncpy)
171 | 	return nil
172 | }
173 | 
174 | // TCPServer listens and handles RPC calls from clients.
175 | func TCPServer(raddr string) {
176 | 	var err error
177 | 
178 | 	perf := new(TCPPerf)
179 | 	rpc.Register(perf)
180 | 
181 | 	SrvAddr, err = net.ResolveTCPAddr("tcp", raddr)
182 | 	if err != nil {
183 | 		log.Fatal(err)
184 | 	}
185 | 
186 | 	l, err := net.ListenTCP("tcp", SrvAddr)
187 | 	if err != nil {
188 | 		log.Fatal(err)
189 | 	}
190 | 	log.Println("Starting server")
191 | 	rpc.Accept(l)
192 | }
193 | 


--------------------------------------------------------------------------------
/client.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"log"
  6 | 	"net"
  7 | 	"net/rpc"
  8 | 	"time"
  9 | )
 10 | 
 11 | type TCPWorker interface {
 12 | 	GetName() string
 13 | 	Work(stop <-chan bool, stats chan<- uint64, nbytes uint64, addr string)
 14 | 	GetRPC() string
 15 | }
 16 | 
 17 | // Type TCPSender implements TCPWorker interface for Upload speed test
 18 | // It contains the name of the server side RPC function to call to initiate testing
 19 | type TCPSender string
 20 | 
 21 | func (s TCPSender) GetName() string {
 22 | 	return "UP"
 23 | }
 24 | 
 25 | func (s TCPSender) GetRPC() string {
 26 | 	return string(s)
 27 | }
 28 | 
 29 | // TCPSender Work method uploads nbyte bytes to tcp address addr; if it receives anything on
 30 | // the stop channel sch, it exits. it periodically reports the number of bytes it
 31 | // transfered since the last report on cch
 32 | func (s TCPSender) Work(sch <-chan bool, cch chan<- uint64, nbytes uint64, addr string) {
 33 | 	defer close(cch) // to signal the launcher we exited
 34 | 
 35 | 	pktsize := uint64(8 * 1024)
 36 | 	every := uint64(16 * pktsize)
 37 | 
 38 | 	buf := make([]byte, pktsize)
 39 | 
 40 | 	log.Println("About to dial ", addr)
 41 | 	conn, err := net.Dial("tcp", addr)
 42 | 	if err != nil {
 43 | 		log.Println(err)
 44 | 		return
 45 | 	}
 46 | 	defer conn.Close()
 47 | 	conn.SetWriteDeadline(time.Now().Add(5 * time.Second))
 48 | 	incr := pktsize
 49 | 	nw := 0
 50 | 
 51 | 	for n := uint64(0); n < nbytes; n += uint64(nw) {
 52 | 		if nbytes-n < pktsize {
 53 | 			incr = nbytes - n
 54 | 			buf = buf[:incr]
 55 | 		}
 56 | 		nw, err = conn.Write(buf)
 57 | 		if err != nil {
 58 | 			log.Println(err)
 59 | 			return
 60 | 		} else if nw != len(buf) {
 61 | 			log.Println("Short write")
 62 | 			return
 63 | 		} else {
 64 | 			conn.SetWriteDeadline(time.Now().Add(5 * time.Second))
 65 | 		}
 66 | 		select {
 67 | 		case <-sch:
 68 | 			return
 69 | 		default:
 70 | 			if (n+incr)%every == 0 {
 71 | 				cch <- every
 72 | 			}
 73 | 		}
 74 | 	}
 75 | 	cch <- incr
 76 | }
 77 | 
 78 | // Type TCPReceiver implements TCPWorker interface for Download speed test
 79 | // It contains the name of the server side RPC function to call to initiate testing
 80 | type TCPReceiver string
 81 | 
 82 | func (r TCPReceiver) GetName() string {
 83 | 	return "DOWN"
 84 | }
 85 | 
 86 | func (r TCPReceiver) GetRPC() string {
 87 | 	return string(r)
 88 | }
 89 | 
 90 | // TCPReceiver Work method downloads nbyte bytes from tcp address addr; if it receives
 91 | // anything on the stop channel sch, it exits. it periodically reports the number of bytes
 92 | // it received since the last report on cch
 93 | func (r TCPReceiver) Work(sch <-chan bool, cch chan<- uint64, nbytes uint64, addr string) {
 94 | 	defer close(cch) // to signal the launcher we exited
 95 | 
 96 | 	pktsize := uint64(8 * 1024)
 97 | 	every := uint64(16 * pktsize)
 98 | 
 99 | 	buf := make([]byte, pktsize)
100 | 
101 | 	log.Println("About to dial ", addr)
102 | 	conn, err := net.Dial("tcp", addr)
103 | 	if err != nil {
104 | 		log.Println(err)
105 | 		return
106 | 	}
107 | 	defer conn.Close()
108 | 	conn.SetReadDeadline(time.Now().Add(5 * time.Second))
109 | 	nw := 0
110 | 	chkpt := uint64(0)
111 | 
112 | L:
113 | 	for n := uint64(0); n < nbytes; n += uint64(nw) {
114 | 		nw, err = conn.Read(buf)
115 | 		if err != nil {
116 | 			log.Println(err)
117 | 			return
118 | 		} else {
119 | 			conn.SetReadDeadline(time.Now().Add(5 * time.Second))
120 | 		}
121 | 		chkpt += uint64(nw)
122 | 		select {
123 | 		case <-sch:
124 | 			break L
125 | 		default:
126 | 			if chkpt >= every {
127 | 				cch <- chkpt
128 | 				chkpt = 0
129 | 			}
130 | 		}
131 | 	}
132 | 	cch <- chkpt
133 | }
134 | 
135 | func Dispatch(ch chan<- Stats, cfg SrvConfig, worker TCPWorker) error {
136 | 	name := worker.GetName()
137 | 
138 | 	log.Println("Measuring ", name, " speed...")
139 | 	client, err := rpc.Dial("tcp", cfg.Host+":"+cfg.RPCPort)
140 | 	if err != nil {
141 | 		log.Println(err)
142 | 		return err
143 | 	}
144 | 	defer client.Close()
145 | 
146 | 	Done := make(chan bool)
147 | 	Res := make(chan uint64)
148 | 	samples := make([]BitRate, 1, 21)
149 | 	var (
150 | 		rep      bool
151 | 		addr     string
152 | 		tcnt     uint64
153 | 		lcnt     uint64
154 | 		srvtotal uint64
155 | 		br       BitRate
156 | 	)
157 | 
158 | 	err = client.Call("TCPPerf.TCPStart", 0, &addr)
159 | 	if err != nil {
160 | 		log.Println(err)
161 | 		return err
162 | 	}
163 | 
164 | 	log.Println("Payload address: ", addr)
165 | 
166 | 	rpcname := worker.GetRPC()
167 | 	log.Println("Calling ", rpcname, " ...")
168 | 	aRcv := client.Go(rpcname, cfg.Count, &srvtotal, nil)
169 | 
170 | 	go worker.Work(Done, Res, cfg.Count, cfg.Host+":"+addr)
171 | 
172 | 	log.Println("Entering wait loop")
173 | 	t0 := time.Now()
174 | 	t1 := t0
175 | 	bps := func(n uint64, t0, t1 time.Time) BitRate {
176 | 		// n*8 bits
177 | 		return BitRate(n * uint64(8e9) / uint64(t1.Sub(t0).Nanoseconds()))
178 | 	}
179 | 	avg := func(s []BitRate) BitRate {
180 | 		t := uint64(0)
181 | 		for _, x := range s {
182 | 			t += uint64(x)
183 | 		}
184 | 		return BitRate(t / uint64(len(s)))
185 | 	}
186 | 	addsamp := func() {
187 | 		tn := time.Now()
188 | 		xr := bps(lcnt, t1, tn)
189 | 		lcnt = uint64(0)
190 | 		t1 = tn
191 | 		samples = append(samples, xr)
192 | 		if len(samples) > 20 {
193 | 			samples = samples[len(samples)-20:]
194 | 		}
195 | 	}
196 | 	timer := time.Tick(500 * time.Millisecond)
197 | 
198 | L1:
199 | 	for {
200 | 		select {
201 | 		case <-timer:
202 | 			addsamp()
203 | 			br = avg(samples)
204 | 			// log.Println("Bitrate: ", br.Mbps(), " Mbps, samples:", len(samples))
205 | 			if tcnt >= cfg.Count {
206 | 				Done <- true
207 | 				break L1
208 | 			}
209 | 			select {
210 | 			case ch <- Stats{"Running", name, br}:
211 | 			default:
212 | 			}
213 | 		case count, ok := <-Res:
214 | 			if ok {
215 | 				tcnt += count
216 | 				lcnt += count
217 | 			} else {
218 | 				addsamp()
219 | 				br = avg(samples)
220 | 				// log.Println("Bitrate: ", br.Mbps(), " Mbps")
221 | 				break L1
222 | 			}
223 | 		}
224 | 	}
225 | 
226 | 	ch <- Stats{"Running", name, br}
227 | 
228 | 	<-aRcv.Done
229 | 	br = bps(tcnt, t0, time.Now())
230 | 	log.Println("My count: ", cfg.Count, " Server count: ", srvtotal, " Average: ", br.Mbps(), "Mbps")
231 | 
232 | 	err = client.Call("TCPPerf.TCPStop", 0, &rep)
233 | 	if err != nil {
234 | 		log.Println(err)
235 | 	}
236 | 	return err
237 | 
238 | }
239 | 
240 | // TCPClient initiates Upload, Download or RTT measurements, based on
241 | // the instructions sent to it over the Command chan and reports back
242 | // its results over Stats chan.
243 | func TCPClient(cch <-chan Command, sch chan<- Stats) {
244 | 	log.Println("TCPClient started")
245 | 
246 | 	ops := map[string]TCPWorker{
247 | 		"UP":   TCPSender("TCPPerf.TCPRcv"),
248 | 		"DOWN": TCPReceiver("TCPPerf.TCPSnd"),
249 | 	}
250 | 
251 | 	timer := time.Tick(1 * time.Second)
252 | L:
253 | 	for {
254 | 		select {
255 | 		case c, ok := (<-cch):
256 | 			if !ok {
257 | 				close(sch)
258 | 				break L
259 | 			}
260 | 			log.Println("Command: ", c.Name)
261 | 			worker, found := ops[c.Name]
262 | 			if found {
263 | 				err := Dispatch(sch, c.Cfg, worker)
264 | 				if err != nil {
265 | 					log.Println(err)
266 | 				}
267 | 			} else if c.Name != "STOP" {
268 | 				log.Println("Unsupported command:", c.Name)
269 | 				select {
270 | 				case sch <- Stats{Stat: "Error", Type: "Illegal command:" + c.Name}:
271 | 				default:
272 | 				}
273 | 			}
274 | 		case <-timer:
275 | 			select {
276 | 			case sch <- Stats{Stat: "Stopped"}:
277 | 			default:
278 | 			}
279 | 		}
280 | 	}
281 | }
282 | 
283 | func ClientMain(haddr string) {
284 | 	cch := make(chan Command)
285 | 	sch := make(chan Stats, 10)
286 | 	lch := make(chan Stats)
287 | 	go TCPClient(cch, sch)
288 | 	go LogClient(sch, lch)
289 | 	fmt.Printf("Open http://localhost%s in a browser\n", haddr)
290 | 	WebUI(haddr, cch, lch)
291 | }
292 | 


--------------------------------------------------------------------------------
/index.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html>
  3 |   <head>
  4 |     <script type='text/javascript' src='https://www.google.com/jsapi'></script>
  5 |     <script src="http://yui.yahooapis.com/3.8.0/build/yui/yui-min.js"></script>
  6 |     <script type='text/javascript'>
  7 |       google.load('visualization', '1', {packages:['corechart', 'gauge']});
  8 | 	</script>
  9 | 	<script type='text/javascript'>
 10 |     YUI().use("node", "io", "io-form", "event", "dump", "json-parse", "button", function(Y) {
 11 |         var that = this;
 12 |         var running = false;
 13 |         var gauge_options = {
 14 |             width: 200, height: 200,
 15 |             redFrom: 0, redTo: 10,
 16 |             yellowFrom: 10, yellowTo: 50,
 17 |             greenFrom: 50, greenTo: 100,
 18 |             minorTicks: 6,
 19 |         };
 20 |         var chart_options = {
 21 |             width: 600, height: 200,
 22 |             title : 'Megabits / Second',
 23 |             animation : { duration : 500 },
 24 |         };
 25 | 
 26 |         var upgauge = new google.visualization.Gauge(Y.one('#upgauge').getDOMNode());
 27 |         var dngauge = new google.visualization.Gauge(Y.one('#dngauge').getDOMNode());
 28 |         var upchart = new google.visualization.LineChart(Y.one('#upchart').getDOMNode());
 29 |         var dnchart = new google.visualization.LineChart(Y.one('#dnchart').getDOMNode());
 30 |         var dtable = new google.visualization.DataTable();
 31 |         var lUp = 0, lDown = 0;
 32 |         dtable.addColumn('timeofday', 'Time');
 33 |         dtable.addColumn('number', 'Bitrate');
 34 |         upchart.draw(dtable, chart_options);
 35 |         dnchart.draw(dtable, chart_options);
 36 |         upgauge.draw(google.visualization.arrayToDataTable([['Label', 'Value'], ['Upload', 0]]), gauge_options);
 37 |         dngauge.draw(google.visualization.arrayToDataTable([['Label', 'Value'], ['Download', 0]]), gauge_options);
 38 | 
 39 |         var onSuccess = function (id, o, args) {
 40 |             dtable = new google.visualization.DataTable();
 41 |             dtable.addColumn('timeofday', 'Time');
 42 |             dtable.addColumn('number', 'Bitrate');
 43 |             Y.one('#status_div').setHTML("<i>Starting...</i>");
 44 |             Y.all('#tstreqform input').setAttribute('disabled', 'disabled');
 45 |             Y.later(250, that, updateVisuals, false);  // give it time so that GET "/stats" doesn't fail right away
 46 |         };
 47 |         var onFailure = function (id, o, args) {
 48 |             Y.one('#start').removeAttribute('disabled');
 49 |             Y.all('#tstreqform input').removeAttribute('disabled');
 50 |             running = false;
 51 |             Y.one('#params_div').setStyle('opacity', '');
 52 |         }
 53 | 
 54 |         var enableForm = function () {
 55 |             Y.one('#start').removeAttribute('disabled');
 56 |             Y.all('#tstreqform input').removeAttribute('disabled');
 57 |             running = false;
 58 |             Y.one('#params_div').setStyle('opacity', '');
 59 |         };
 60 |         Y.one('#start').on('click', function(e) {
 61 |             if (running) return;
 62 |             Y.one('#start').setAttribute('disabled', 'disabled');
 63 |             running = true;
 64 |             Y.one('#params_div').setStyle('opacity', '0.4');
 65 |             e.halt(true);
 66 |             var cfg = {
 67 |                 method : "POST",
 68 |                 form : { id : Y.one('#tstreqform'), useDisabled : false },
 69 |                 on : { success : onSuccess , failure : onFailure },
 70 |                 context : Y,
 71 |                 arguments : { success : '/cmd' },
 72 |             };
 73 |             Y.io("/cmd", cfg);
 74 |         });
 75 | 
 76 |         enableForm();
 77 |         /*
 78 |         Y.one('#stop').on('click', function(e) {
 79 |             var cfg = { method : "POST", data : "tstt=STOP" }
 80 |             Y.io("/cmd", cfg);
 81 |         });
 82 |         */
 83 | 
 84 |         var updateVisuals = function () {
 85 |             Y.io("/stats", {
 86 |                 on : {
 87 |                     success : function (tx, r) {
 88 |                         var pr;
 89 |                         try {
 90 |                             pr = Y.JSON.parse(r.responseText);
 91 |                         } catch (e) {
 92 |                             alert("JSON Parse failed: ", r.responseText);
 93 |                             Y.one('#status_div').setHTML("<i>Error: "+e+"</i>");
 94 |                             enableForm();
 95 |                             return;
 96 |                         }
 97 |                         var msg = pr.Stat + " " + ((pr.Type=="UP")?"Upload":((pr.Type=="DOWN")?"Download":''));
 98 |                         Y.one('#status_div').setHTML("<i>"+msg+"</i>");
 99 |                         if (pr.Stat != "Running") {
100 |                             enableForm();
101 |                             return;
102 |                         }
103 |                         var foo = new Date();
104 |                         var xtm = [foo.getHours(), foo.getMinutes(), foo.getSeconds(), foo.getMilliseconds()];
105 |                         dtable.addRows([[xtm, pr.Rate]]);
106 |                         if (pr.Type == "UP") {
107 |                             upchart.draw(dtable, chart_options);
108 |                             lUp = pr.Rate;
109 |                             var dt = google.visualization.arrayToDataTable([
110 |                                 ['Label', 'Value'],
111 |                                 ['Upload', lUp ]
112 |                                 ]);
113 |                             upgauge.draw(dt, gauge_options);
114 |                         } else {
115 |                             dnchart.draw(dtable, chart_options);
116 |                             lDown = pr.Rate;
117 |                             var dt = google.visualization.arrayToDataTable([
118 |                                 ['Label', 'Value'],
119 |                                 ['Download', lDown ]
120 |                                 ]);
121 |                             dngauge.draw(dt, gauge_options);
122 |                         }
123 |                         Y.later(500, that, updateVisuals, false);
124 |                     },
125 |                     failure : function (tx, r) {
126 |                         alert("No data");
127 |                         enableForm();
128 |                     },
129 |                 },
130 |             });
131 |         };
132 |     });
133 |     </script>
134 | 	<link rel="stylesheet" type="text/css" href="http://yui.yahooapis.com/3.8.0/build/cssfonts/cssfonts-min.css">
135 |     <link rel="stylesheet" type="text/css" href="http://yui.yahooapis.com/3.8.0/build/cssgrids/grids-min.css">
136 |   </head>
137 |   <body>
138 |    <div> <!-- class="yui3-cssfonts"> -->
139 |     <h1>tcpmeter - TCP Speedometer</h1>
140 |     <div class="yui3-skin-sam">
141 |       <div class="yui3-g">
142 |         <div id="params_div" class="yui3-u-1-4">
143 |           <form id="tstreqform" method="post" action="/cmd">
144 | 			<fieldset>
145 | 			  <legend>Server Information</legend>
146 |               <p>
147 |               <label>Host:<input type=text name=raddr required></label><br />
148 |               <label>RPC:<input type=number name=rport default="8001" placeholder="8001" required></label>
149 |               </p>
150 | 			</fieldset>
151 |             <p>
152 |             <fieldset>
153 |               <legend>Packet Type</legend>
154 |               <p>
155 |               <input type=radio name=pktt value="udp" disabled="disabled">UDP</input>
156 |               <input type=radio name=pktt value="tcp" checked="checked">TCP</input>
157 |               </p>
158 |             </fieldset>
159 |             </p>
160 |             <p>
161 |             <fieldset>
162 |               <legend>Type of Measurement</legend>
163 |               <p>
164 |               <input type=radio name=tstt value="UP" checked="checked">Upload</input>
165 |               <input type=radio name=tstt value="DOWN">Download</input>
166 |               <input type=radio name=tstt value="RTT">Round Trip</input><br />
167 |               <input type=checkbox name=txcont checked="">Continuous</input>
168 |               </p>
169 |             </fieldset>
170 |             </p>
171 |             <p>
172 |             <fieldset>
173 |               <legend>Size of Dataset</legend>
174 |               <p>
175 |               <label>Amount of data:<input type=number name=txsize></label><br />
176 |               <input type=radio name=txmult value="KB">KB</input>
177 |               <input type=radio name=txmult value="MB" checked="checked">MB</input>
178 |               <input type=radio name=txmult value="GB">GB</input>
179 |               </p>
180 |             </fieldset>
181 |             </p>
182 |           </form>
183 |           <p>
184 |           <input id="start" type="button" value="Start" />
185 |           <!-- <input id="stop" type="button" value="Abort" /> -->
186 |           </p>
187 |         </div>
188 | 		<div class="yui3-u-3-4">
189 |             <div class="yui3-g">
190 |                 <div class="yui3-u-1-4" id='upgauge'></div>
191 |                 <div class="yui3-u-3-4" id='upchart'></div>
192 |             </div>
193 |             <div class="yui3-g">
194 |                 <div class="yui3-u-1-4" id='dngauge'></div>
195 |                 <div class="yui3-u-3-4" id='dnchart'></div>
196 |             </div>
197 |             <div id='status_div' style="text-align:center"><p><i>Stopped</i></p></div>
198 | 		</div>
199 |       </div>
200 |     </div>
201 |    </div>
202 |   </body>
203 | </html>
204 | 


--------------------------------------------------------------------------------
/admui.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"encoding/json"
  5 | 	"fmt"
  6 | 	"log"
  7 | 	"io"
  8 | 	"net/http"
  9 | )
 10 | 
 11 | // SrvConfig defines the far-end server, and its command and payload ports
 12 | type SrvConfig struct {
 13 | 	Host    string
 14 | 	RPCPort string
 15 | 	Count   uint64
 16 | 	Repeat  bool
 17 | }
 18 | 
 19 | // Command controls the type of function that TCPClient should perform
 20 | type Command struct {
 21 | 	Name string
 22 | 	Cfg  SrvConfig
 23 | }
 24 | 
 25 | type BitRate uint64
 26 | 
 27 | // Returns bitrate in Mega-bits per second
 28 | func (b BitRate) Mbps() float32 {
 29 | 	return float32(b) / float32(1000000)
 30 | }
 31 | 
 32 | // Returns bitrate in Mega-bytes per second
 33 | func (b BitRate) MBps() float32 {
 34 | 	return float32(b) / float32(8*1000000)
 35 | }
 36 | 
 37 | // Returns bitrate in Kilo-bits per second
 38 | func (b BitRate) Kbps() float32 {
 39 | 	return float32(b) / float32(1000)
 40 | }
 41 | 
 42 | // Returns bitrate in Kilo-bytes per second
 43 | func (b BitRate) KBps() float32 {
 44 | 	return float32(b) / float32(8*1000)
 45 | }
 46 | 
 47 | func (b BitRate) String() string {
 48 | 	return fmt.Sprintf("%d", b)
 49 | }
 50 | 
 51 | // Stats is type of measurement that TCPClient reports on its stats channel.
 52 | type Stats struct {
 53 | 	Stat string
 54 | 	Type string
 55 | 	Rate BitRate
 56 | }
 57 | 
 58 | type JSONStats struct {
 59 | 	Stat string
 60 | 	Type string
 61 | 	Rate float32
 62 | }
 63 | 
 64 | // CCmdHandler is the receiver type for handling TCPClient control request
 65 | type CCmdHandler struct {
 66 | 	CmdCh chan Command
 67 | }
 68 | 
 69 | // CStatHandler is the reciever type for handling TCPClient stats requests
 70 | type CStatHandler struct {
 71 | 	StatCh chan Stats
 72 | }
 73 | 
 74 | // This handler parses the form from the user and initiates a TCPClient
 75 | // measurement.
 76 | func (c *CCmdHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 77 | 	var (
 78 | 		raddr  string
 79 | 		rport  int
 80 | 		pktt   string
 81 | 		tstt   string
 82 | 		txsize int
 83 | 		txmult string
 84 | 		txcont string
 85 | 	)
 86 | 	params := map[string]interface{}{
 87 | 		"raddr":  &raddr,
 88 | 		"rport":  &rport,
 89 | 		"pktt":   &pktt,
 90 | 		"tstt":   &tstt,
 91 | 		"txsize": &txsize,
 92 | 		"txmult": &txmult,
 93 | 		"txcont": &txcont,
 94 | 	}
 95 | 	Mult := map[string]uint64{
 96 | 		"KB": 1024,
 97 | 		"MB": 1024 * 1024,
 98 | 		"GB": 1024 * 1024 * 1024,
 99 | 	}
100 | 
101 | 	getformparams(r, params)
102 | 	trace.Printf("|CMD|%s|%s|\n", tstt, raddr)
103 | 	log.Println("CMD: ", raddr, rport, pktt, tstt, txsize, txmult, txcont != "")
104 | 
105 | 	cmd := Command{
106 | 		Name: tstt,
107 | 		Cfg: SrvConfig{
108 | 			Host:    raddr,
109 | 			RPCPort: fmt.Sprint(rport),
110 | 			Count:   uint64(txsize) * Mult[txmult],
111 | 			Repeat:  txcont != "",
112 | 		},
113 | 	}
114 | 	c.CmdCh <- cmd
115 | 	w.Header().Set("Content-Type", "text/html")
116 | 	w.Write([]byte(""))
117 | }
118 | 
119 | // parse and store form parameters in the map that's passed in
120 | func getformparams(r *http.Request, params map[string]interface{}) {
121 | 	for i, x := range params {
122 | 		if v := r.FormValue(i); v != "" {
123 | 			fmt.Sscan(v, x)
124 | 		}
125 | 	}
126 | }
127 | 
128 | // This handler deals with GET requests for TCPClient measurement results.
129 | // It returns the measurements since last snapshot in json format.
130 | func (s *CStatHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
131 | 	var jst JSONStats
132 | 	w.Header().Set("Content-Type", "text/plain")
133 | 	st, ok := <-s.StatCh
134 | 	if !ok {
135 | 		jst = JSONStats{Stat: "Error"}
136 | 	} else {
137 | 		jst = JSONStats{st.Stat, st.Type, st.Rate.Mbps()}
138 | 	}
139 | 	je := json.NewEncoder(w)
140 | 	je.Encode(jst)
141 | }
142 | 
143 | // WebUI is an http server that provides an html UI to the user, annoucing itself at address
144 | // that is passed in. It handles requests for starting and stopping of the load testing
145 | // client and reporting of data.
146 | func WebUI(addr string, cch chan Command, sch chan Stats) {
147 | 	cl := &CCmdHandler{cch}
148 | 	st := &CStatHandler{sch}
149 | 	http.Handle("/cmd", cl)
150 | 	http.Handle("/stats", st)
151 | 	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
152 | 		w.Header().Set("Content-Type", "text/html; charset=utf-8")
153 | 		io.WriteString(w, htmlfile)
154 | 
155 | 	})
156 | 	err := http.ListenAndServe(addr, nil)
157 | 	if err != nil {
158 | 		log.Fatal("ListenAndServe: " + err.Error())
159 | 	}
160 | }
161 | 
162 | // unfortunately there isn't an easy way to include
163 | // a file; so make the changes to index.html and then
164 | // replace the contents of the htmlfile const with it.
165 | const htmlfile = `
166 | <!DOCTYPE html>
167 | <html>
168 |   <head>
169 |     <script type='text/javascript' src='https://www.google.com/jsapi'></script>
170 |     <script src="http://yui.yahooapis.com/3.8.0/build/yui/yui-min.js"></script>
171 |     <script type='text/javascript'>
172 |       google.load('visualization', '1', {packages:['corechart', 'gauge']});
173 | 	</script>
174 | 	<script type='text/javascript'>
175 |     YUI().use("node", "io", "io-form", "event", "dump", "json-parse", "button", function(Y) {
176 |         var that = this;
177 |         var running = false;
178 |         var gauge_options = {
179 |             width: 200, height: 200,
180 |             redFrom: 0, redTo: 10,
181 |             yellowFrom: 10, yellowTo: 50,
182 |             greenFrom: 50, greenTo: 100,
183 |             minorTicks: 6,
184 |         };
185 |         var chart_options = {
186 |             width: 600, height: 200,
187 |             title : 'Megabits / Second',
188 |             animation : { duration : 500 },
189 |         };
190 | 
191 |         var upgauge = new google.visualization.Gauge(Y.one('#upgauge').getDOMNode());
192 |         var dngauge = new google.visualization.Gauge(Y.one('#dngauge').getDOMNode());
193 |         var upchart = new google.visualization.LineChart(Y.one('#upchart').getDOMNode());
194 |         var dnchart = new google.visualization.LineChart(Y.one('#dnchart').getDOMNode());
195 |         var dtable = new google.visualization.DataTable();
196 |         var lUp = 0, lDown = 0;
197 |         dtable.addColumn('timeofday', 'Time');
198 |         dtable.addColumn('number', 'Bitrate');
199 |         upchart.draw(dtable, chart_options);
200 |         dnchart.draw(dtable, chart_options);
201 |         upgauge.draw(google.visualization.arrayToDataTable([['Label', 'Value'], ['Upload', 0]]), gauge_options);
202 |         dngauge.draw(google.visualization.arrayToDataTable([['Label', 'Value'], ['Download', 0]]), gauge_options);
203 | 
204 |         var onSuccess = function (id, o, args) {
205 |             dtable = new google.visualization.DataTable();
206 |             dtable.addColumn('timeofday', 'Time');
207 |             dtable.addColumn('number', 'Bitrate');
208 |             Y.one('#status_div').setHTML("<i>Starting...</i>");
209 |             Y.all('#tstreqform input').setAttribute('disabled', 'disabled');
210 |             Y.later(250, that, updateVisuals, false);  // give it time so that GET "/stats" doesn't fail right away
211 |         };
212 |         var onFailure = function (id, o, args) {
213 |             Y.one('#start').removeAttribute('disabled');
214 |             Y.all('#tstreqform input').removeAttribute('disabled');
215 |             running = false;
216 |             Y.one('#params_div').setStyle('opacity', '');
217 |         }
218 | 
219 |         var enableForm = function () {
220 |             Y.one('#start').removeAttribute('disabled');
221 |             Y.all('#tstreqform input').removeAttribute('disabled');
222 |             running = false;
223 |             Y.one('#params_div').setStyle('opacity', '');
224 |         };
225 |         Y.one('#start').on('click', function(e) {
226 |             if (running) return;
227 |             Y.one('#start').setAttribute('disabled', 'disabled');
228 |             running = true;
229 |             Y.one('#params_div').setStyle('opacity', '0.4');
230 |             e.halt(true);
231 |             var cfg = {
232 |                 method : "POST",
233 |                 form : { id : Y.one('#tstreqform'), useDisabled : false },
234 |                 on : { success : onSuccess , failure : onFailure },
235 |                 context : Y,
236 |                 arguments : { success : '/cmd' },
237 |             };
238 |             Y.io("/cmd", cfg);
239 |         });
240 | 
241 |         enableForm();
242 |         /*
243 |         Y.one('#stop').on('click', function(e) {
244 |             var cfg = { method : "POST", data : "tstt=STOP" }
245 |             Y.io("/cmd", cfg);
246 |         });
247 |         */
248 | 
249 |         var updateVisuals = function () {
250 |             Y.io("/stats", {
251 |                 on : {
252 |                     success : function (tx, r) {
253 |                         var pr;
254 |                         try {
255 |                             pr = Y.JSON.parse(r.responseText);
256 |                         } catch (e) {
257 |                             alert("JSON Parse failed: ", r.responseText);
258 |                             Y.one('#status_div').setHTML("<i>Error: "+e+"</i>");
259 |                             enableForm();
260 |                             return;
261 |                         }
262 |                         var msg = pr.Stat + " " + ((pr.Type=="UP")?"Upload":((pr.Type=="DOWN")?"Download":''));
263 |                         Y.one('#status_div').setHTML("<i>"+msg+"</i>");
264 |                         if (pr.Stat != "Running") {
265 |                             enableForm();
266 |                             return;
267 |                         }
268 |                         var foo = new Date();
269 |                         var xtm = [foo.getHours(), foo.getMinutes(), foo.getSeconds(), foo.getMilliseconds()];
270 |                         dtable.addRows([[xtm, pr.Rate]]);
271 |                         if (pr.Type == "UP") {
272 |                             upchart.draw(dtable, chart_options);
273 |                             lUp = pr.Rate;
274 |                             var dt = google.visualization.arrayToDataTable([
275 |                                 ['Label', 'Value'],
276 |                                 ['Upload', lUp ]
277 |                                 ]);
278 |                             upgauge.draw(dt, gauge_options);
279 |                         } else {
280 |                             dnchart.draw(dtable, chart_options);
281 |                             lDown = pr.Rate;
282 |                             var dt = google.visualization.arrayToDataTable([
283 |                                 ['Label', 'Value'],
284 |                                 ['Download', lDown ]
285 |                                 ]);
286 |                             dngauge.draw(dt, gauge_options);
287 |                         }
288 |                         Y.later(500, that, updateVisuals, false);
289 |                     },
290 |                     failure : function (tx, r) {
291 |                         alert("No data");
292 |                         enableForm();
293 |                     },
294 |                 },
295 |             });
296 |         };
297 |     });
298 |     </script>
299 | 	<link rel="stylesheet" type="text/css" href="http://yui.yahooapis.com/3.8.0/build/cssfonts/cssfonts-min.css">
300 |     <link rel="stylesheet" type="text/css" href="http://yui.yahooapis.com/3.8.0/build/cssgrids/grids-min.css">
301 |   </head>
302 |   <body>
303 |    <div> <!-- class="yui3-cssfonts"> -->
304 |     <h1>tcpmeter - TCP Speedometer</h1>
305 |     <div class="yui3-skin-sam">
306 |       <div class="yui3-g">
307 |         <div id="params_div" class="yui3-u-1-4">
308 |           <form id="tstreqform" method="post" action="/cmd">
309 | 			<fieldset>
310 | 			  <legend>Server Information</legend>
311 |               <p>
312 |               <label>Host:<input type=text name=raddr required></label><br />
313 |               <label>RPC:<input type=number name=rport default="8001" placeholder="8001" required></label>
314 |               </p>
315 | 			</fieldset>
316 |             <p>
317 |             <fieldset>
318 |               <legend>Packet Type</legend>
319 |               <p>
320 |               <input type=radio name=pktt value="udp" disabled="disabled">UDP</input>
321 |               <input type=radio name=pktt value="tcp" checked="checked">TCP</input>
322 |               </p>
323 |             </fieldset>
324 |             </p>
325 |             <p>
326 |             <fieldset>
327 |               <legend>Type of Measurement</legend>
328 |               <p>
329 |               <input type=radio name=tstt value="UP" checked="checked">Upload</input>
330 |               <input type=radio name=tstt value="DOWN">Download</input>
331 |               <input type=radio name=tstt value="RTT">Round Trip</input><br />
332 |               <input type=checkbox name=txcont checked="">Continuous</input>
333 |               </p>
334 |             </fieldset>
335 |             </p>
336 |             <p>
337 |             <fieldset>
338 |               <legend>Size of Dataset</legend>
339 |               <p>
340 |               <label>Amount of data:<input type=number name=txsize></label><br />
341 |               <input type=radio name=txmult value="KB">KB</input>
342 |               <input type=radio name=txmult value="MB" checked="checked">MB</input>
343 |               <input type=radio name=txmult value="GB">GB</input>
344 |               </p>
345 |             </fieldset>
346 |             </p>
347 |           </form>
348 |           <p>
349 |           <input id="start" type="button" value="Start" />
350 |           <!-- <input id="stop" type="button" value="Abort" /> -->
351 |           </p>
352 |         </div>
353 | 		<div class="yui3-u-3-4">
354 |             <div class="yui3-g">
355 |                 <div class="yui3-u-1-4" id='upgauge'></div>
356 |                 <div class="yui3-u-3-4" id='upchart'></div>
357 |             </div>
358 |             <div class="yui3-g">
359 |                 <div class="yui3-u-1-4" id='dngauge'></div>
360 |                 <div class="yui3-u-3-4" id='dnchart'></div>
361 |             </div>
362 |             <div id='status_div' style="text-align:center"><p><i>Stopped</i></p></div>
363 | 		</div>
364 |       </div>
365 |     </div>
366 |    </div>
367 |   </body>
368 | </html>`
369 | 


--------------------------------------------------------------------------------