new

Author: mininet

esspresso.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"os/exec"
 	"flag"
 	"fmt"
 	"io/ioutil"
@@ -11,13 +12,46 @@ import (
 	"github.com/google/gopacket/pcap"
 )
 
-// main
-func main() {
-	var err error
+type Metric struct {
+	Rate         int
+	CurrentValue int
+	PrevValue    int
+}
+
+func getHandleFunc(metric *int, metricDescription string) func(w http.ResponseWriter, r *http.Request){
+	return func(w http.ResponseWriter, r *http.Request) {
+		if _, err := w.Write([]byte(fmt.Sprintf("%d\n", *metric))); err != nil {
+			log.Fatal("Can't write ", metricDescription)
+		}
+	}
+}
 
-	requests := 0
-	responses := 0
+func createPacketSource(device string, filter string) (*gopacket.PacketSource, *pcap.Handle) {
+	var (
+		snapshotLen int32 = 1024
+		promiscuous bool = true
+		timeout time.Duration = 100 * time.Millisecond
+		err error
+		handler *pcap.Handle
+		packetSource *gopacket.PacketSource
+	)
+
+	handler, err = pcap.OpenLive(device, snapshotLen, promiscuous, timeout)
+	if err != nil {
+		log.Fatal(err)
+	}
 
+	if err := handler.SetBPFFilter(filter); err != nil {
+		log.Fatal(err)
+	}
+
+	packetSource = gopacket.NewPacketSource(handler, handler.LinkType())
+
+	return packetSource, handler
+}
+
+// main
+func main() {
 	// cmd line options
 	var (
 		device   = flag.String("device", "docker0", "device to sniff packets from")
@@ -34,72 +68,79 @@ func main() {
 		log.SetOutput(ioutil.Discard)
 	}
 
+	requests := &Metric{
+		Rate:         0,
+		CurrentValue: 0,
+		PrevValue:    0,
+	}
+
+	responses := &Metric{
+		Rate:         0,
+		CurrentValue: 0,
+		PrevValue:    0,
+	}
+
+	ticker := time.NewTicker(1 * time.Second)
 
+	//requests2 := 0
 	go func() {
-		http.HandleFunc("/requests", func(w http.ResponseWriter, r *http.Request) {
-			if _, err := w.Write([]byte(fmt.Sprintf("%d\n", requests))); err != nil {
-				log.Fatal("Can't write rate")
+		command := exec.Command("/bin/sleep", "100")
+		command.Start()
+		for {
+			std, err := command.Output()
+			time.Sleep(2 * time.Second)
+			if (err != nil) {
+				log.Fatal(err)
 			}
-		})
-		http.HandleFunc("/responses", func(w http.ResponseWriter, r *http.Request) {
-			if _, err := w.Write([]byte(fmt.Sprintf("%d\n", responses))); err != nil {
-				log.Fatal("Can't write rate")
-			}
-		})
-		log.Fatal(http.ListenAndServe(":6666", nil))
+			fmt.Println(std)
+			fmt.Println("foo")
+		}
+		//requests2 = os.Run("")
 	}()
 
-	requestFilter := fmt.Sprintf("src %s and dst %s and (tcp[0xd] & tcp-syn) != 0", *clientIP, *gorbIP)
-	responseFilter := fmt.Sprintf("dst %s and (((ip[2:2] - ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0)", *clientIP)
-
+	// requestFilter := fmt.Sprintf("src %s and dst %s and (tcp[0xd] & tcp-syn) != 0", *clientIP, *gorbIP)
+  requestFilter := fmt.Sprintf("tcp and dst %s and tcp[(tcp[0xc] >> 4) << 2 : 4] = 0x47455420", *gorbIP)
 	fmt.Printf("Request filter: %s\n", requestFilter)
-	fmt.Printf("Response filter: %s\n", responseFilter)
-
-	// Open device
-	var requestPacketSource *gopacket.PacketSource
-	var responsePacketSource *gopacket.PacketSource
 
-	var (
-		snapshotLen int32         = 1024
-		promiscuous bool          = true
-		timeout     time.Duration = 1 * time.Second
-		handle_res  *pcap.Handle
-		handle_req  *pcap.Handle
-	)
-
-	handle_req, err = pcap.OpenLive(*device, snapshotLen, promiscuous, timeout)
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer handle_req.Close()
+	requestPacketSource, requestHandler := createPacketSource(*device, requestFilter)
+	defer requestHandler.Close()
 
-	if err := handle_req.SetBPFFilter(requestFilter); err != nil {
-		log.Fatal(err)
-	}
+	responseFilter := fmt.Sprintf("dst %s and (((ip[2:2] - ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0)", *clientIP)
+	fmt.Printf("Response filter: %s\n", responseFilter)
 
-	requestPacketSource = gopacket.NewPacketSource(handle_req, handle_req.LinkType())
+	responsePacketSource, responseHandler := createPacketSource(*device, responseFilter)
+	defer responseHandler.Close()
 
-	handle_res, err = pcap.OpenLive(*device, snapshotLen, promiscuous, timeout)
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer handle_res.Close()
+	go func() {
+		http.HandleFunc("/request/count", getHandleFunc(&requests.CurrentValue, "request count"))
+		http.HandleFunc("/response/count", getHandleFunc(&responses.CurrentValue, "response count"))
+		http.HandleFunc("/request/rate", getHandleFunc(&requests.Rate, "request rate"))
+		http.HandleFunc("/response/rate", getHandleFunc(&responses.Rate, "response rate"))
 
-	if err := handle_res.SetBPFFilter(responseFilter); err != nil {
-		log.Fatal(err)
-	}
-	responsePacketSource = gopacket.NewPacketSource(handle_res, handle_res.LinkType())
+		log.Fatal(http.ListenAndServe(":6666", nil))
+	}()
 
 	for {
 		select {
+		case <-ticker.C:
+			go func() {
+					requests.Rate = requests.CurrentValue - requests.PrevValue
+					requests.PrevValue = requests.CurrentValue
+					responses.Rate = responses.CurrentValue - responses.PrevValue
+					responses.PrevValue = responses.CurrentValue
+		  }()
 		case request := <-requestPacketSource.Packets():
-			log.Print(request)
-			requests += 1
-			log.Print("Requests: ", requests)
+			go func() {
+				log.Print(request)
+				requests.CurrentValue += 1
+				log.Print("Requests: ", requests.CurrentValue)
+			}()
 		case response := <-responsePacketSource.Packets():
-			log.Print(response)
-			responses += 1
-			log.Print("Responses: ", responses)
+			go func() {
+				log.Print(response)
+				responses.CurrentValue += 1
+				log.Print("Responses: ", responses.CurrentValue)
+			}()
 		}
 	}
 }