diff --git a/p2p/50.bin b/p2p/50.bin new file mode 100644 index 0000000..151a7c2 Binary files /dev/null and b/p2p/50.bin differ diff --git a/p2p/speedtest.go b/p2p/speedtest.go index cc839d9..3868c71 100644 --- a/p2p/speedtest.go +++ b/p2p/speedtest.go @@ -2,26 +2,8 @@ package p2p import ( "fmt" - "time" ) -type Server struct { - URL string `xml:"url,attr"` - Lat string `xml:"lat,attr"` - Lon string `xml:"lon,attr"` - Name string `xml:"name,attr"` - Country string `xml:"country,attr"` - Sponsor string `xml:"sponsor,attr"` - ID string `xml:"id,attr"` - URL2 string `xml:"url2,attr"` - Host string `xml:"host,attr"` - Distance float64 - Latency time.Duration - DLSpeed float64 - ULSpeed float64 -} - - func SpeedTest() error{ targets, err := ReadIpTable() @@ -29,11 +11,9 @@ func SpeedTest() error{ if err != nil { return err } - //serverList, _ := speedtest.FetchServerList(user) - //targets, _ := serverList.FindServer([]int{}) for _, s := range targets.IpAddress { - //fmt.Print(strings.Split(i., "/upload")[0] + "/latency.txt") + // Ping Test err = s.PingTest() if err != nil { @@ -41,7 +21,7 @@ func SpeedTest() error{ } //Upload Speed Test - err = s.UploadTest(false) + err = s.UploadSpeed() if err != nil { return err } @@ -53,7 +33,7 @@ func SpeedTest() error{ //s.DownloadTest(false) //s.UploadTest(false) - fmt.Println(s.Download) + fmt.Println(s.Upload) //fmt.Printf("Latency: %s, Download: %f, Upload: %f\n", s.Latency, s.DLSpeed, s.ULSpeed) } diff --git a/p2p/testingMetrics.go b/p2p/testingMetrics.go index 66ceaac..acab19e 100644 --- a/p2p/testingMetrics.go +++ b/p2p/testingMetrics.go @@ -1,84 +1,85 @@ package p2p import ( - "golang.org/x/sync/errgroup" + "bytes" + "io" "io/ioutil" + "log" + "mime/multipart" "net/http" - "net/url" - "strconv" - "strings" + "os" "time" ) -var dlSizes = [...]int{350, 500, 750, 1000, 1500, 2000, 2500, 3000, 3500, 4000} -var ulSizes = [...]int{100, 300, 500, 800, 1000, 1500, 2500, 3000, 3500, 4000} //kB +//var dlSizes = [...]int{350, 500, 750, 1000, 1500, 2000, 2500, 3000, 3500, 4000} +//var ulSizes = [...]int{100, 300, 500, 800, 1000, 1500, 2500, 3000, 3500, 4000} //kB var client = http.Client{} // DownloadTest executes the test to measure download speed -func (s *IpAddress) DownloadTest(savingMode bool) error { - dlURL := "http://" + s.Ipv4 + ":8088/server_info" - eg := errgroup.Group{} - - // Warming up - sTime := time.Now() - for i := 0; i < 2; i++ { - eg.Go(func() error { - return dlWarmUp("http://" + s.Ipv4 + ":8088/server_info") - }) - } - if err := eg.Wait(); err != nil { - return err - } - fTime := time.Now() - // 1.125MB for each request (750 * 750 * 2) - wuSpeed := 1.125 * 8 * 2 / fTime.Sub(sTime.Add(s.Latency)).Seconds() - - // Decide workload by warm up speed - workload := 0 - weight := 0 - skip := false - if savingMode { - workload = 6 - weight = 3 - } else if 10.0 < wuSpeed { - workload = 16 - weight = 4 - } else if 4.0 < wuSpeed { - workload = 8 - weight = 4 - } else if 2.5 < wuSpeed { - workload = 4 - weight = 4 - } else { - skip = true - } - - // Main speedtest - dlSpeed := wuSpeed - if skip == false { - sTime = time.Now() - for i := 0; i < workload; i++ { - eg.Go(func() error { - return downloadRequest(dlURL, weight) - }) - } - if err := eg.Wait(); err != nil { - return err - } - fTime = time.Now() - - reqMB := dlSizes[weight] * dlSizes[weight] * 2 / 1000 / 1000 - dlSpeed = float64(reqMB) * 8 * float64(workload) / fTime.Sub(sTime).Seconds() - } - - s.Download = dlSpeed - return nil -} +//func (s *IpAddress) DownloadTest(savingMode bool) error { +// dlURL := "http://" + s.Ipv4 + ":8088/server_info" +// eg := errgroup.Group{} +// +// // Warming up +// sTime := time.Now() +// for i := 0; i < 2; i++ { +// eg.Go(func() error { +// return dlWarmUp("http://" + s.Ipv4 + ":8088/server_info") +// }) +// } +// if err := eg.Wait(); err != nil { +// return err +// } +// fTime := time.Now() +// // 1.125MB for each request (750 * 750 * 2) +// wuSpeed := 1.125 * 8 * 2 / fTime.Sub(sTime.Add(s.Latency)).Seconds() +// +// // Decide workload by warm up speed +// workload := 0 +// weight := 0 +// skip := false +// if savingMode { +// workload = 6 +// weight = 3 +// } else if 10.0 < wuSpeed { +// workload = 16 +// weight = 4 +// } else if 4.0 < wuSpeed { +// workload = 8 +// weight = 4 +// } else if 2.5 < wuSpeed { +// workload = 4 +// weight = 4 +// } else { +// skip = true +// } +// +// // Main speedtest +// dlSpeed := wuSpeed +// if skip == false { +// sTime = time.Now() +// for i := 0; i < workload; i++ { +// eg.Go(func() error { +// return downloadRequest(dlURL, weight) +// }) +// } +// if err := eg.Wait(); err != nil { +// return err +// } +// fTime = time.Now() +// +// reqMB := dlSizes[weight] * dlSizes[weight] * 2 / 1000 / 1000 +// dlSpeed = float64(reqMB) * 8 * float64(workload) / fTime.Sub(sTime).Seconds() +// } +// +// s.Download = dlSpeed +// return nil +//} // Download Speed func (s *IpAddress)DownloadSpeed() error { start := time.Now() - resp, err := client.Get("http://" + s.Ipv4 + ":8080/50") + resp, err := client.Get("http://" + s.Ipv4 + ":8088/50") if err != nil { return err } @@ -91,123 +92,170 @@ func (s *IpAddress)DownloadSpeed() error { return nil } +func (s *IpAddress)UploadSpeed() error { + start := time.Now() + b, w := createMultipartFormData("file","50.bin") + + req, err := http.NewRequest("GET", "http://" + s.Ipv4 + ":8088/", &b) + if err != nil { + return err + } + // Don't forget to set the content type, this will contain the boundary. + req.Header.Set("Content-Type", w.FormDataContentType()) + defer req.Body.Close() + ioutil.ReadAll(req.Body) + + t := time.Since(start) + //fmt.Println(s.Seconds()) + // size * time (seconds) + s.Upload = (50/t.Seconds())*8 + return nil +} + +//Upload helper function for uploading +//(https://stackoverflow.com/questions/20205796/post-data-using-the-content-type-multipart-form-data +func createMultipartFormData(fieldName, fileName string) (bytes.Buffer, *multipart.Writer) { + var b bytes.Buffer + var err error + w := multipart.NewWriter(&b) + var fw io.Writer + file := mustOpen(fileName) + if fw, err = w.CreateFormFile(fieldName, file.Name()); err != nil { + log.Fatalf("Error creating writer: %v", err) + } + if _, err = io.Copy(fw, file); err != nil { + log.Fatalf("Error with io.Copy: %v", err) + //t.Errorf("Error with io.Copy: %v", err) + } + w.Close() + return b, w +} + +func mustOpen(f string) *os.File { + r, err := os.Open(f) + if err != nil { + log.Fatalf("Error with mustOpen: %v",err) + } + return r +} + // UploadTest executes the test to measure upload speed -func (s *IpAddress) UploadTest(savingMode bool) error { - // Warm up - sTime := time.Now() - eg := errgroup.Group{} - for i := 0; i < 2; i++ { - eg.Go(func() error { - return ulWarmUp("http://" + s.Ipv4 + ":8088/server_info") - }) - } - if err := eg.Wait(); err != nil { - return err - } - fTime := time.Since(sTime) - // 1.0 MB for each request - wuSpeed := 1.0 * 8 * 2 / (fTime.Seconds() + s.Latency.Seconds()) - - // Decide workload by warm up speed - workload := 0 - weight := 0 - skip := false - if savingMode { - workload = 1 - weight = 7 - } else if 10.0 < wuSpeed { - workload = 16 - weight = 9 - } else if 4.0 < wuSpeed { - workload = 8 - weight = 9 - } else if 2.5 < wuSpeed { - workload = 4 - weight = 5 - } else { - skip = true - } - - // Main speedtest - ulSpeed := wuSpeed - if skip == false { - sTime = time.Now() - for i := 0; i < workload; i++ { - eg.Go(func() error { - return uploadRequest("http://"+s.Ipv4+":8088/server_info") - }) - } - if err := eg.Wait(); err != nil { - return err - } - fTime := time.Since(sTime) - - reqMB := float64(ulSizes[weight]) / 1000 - ulSpeed = reqMB * 8 * float64(workload) / fTime.Seconds() - } - - s.Upload = ulSpeed - - return nil -} - -func dlWarmUp(dlURL string) error { - size := dlSizes[2] - xdlURL := dlURL + "/random" + strconv.Itoa(size) + "x" + strconv.Itoa(size) + ".jpg" - - resp, err := client.Get(xdlURL) - if err != nil { - return err - } - defer resp.Body.Close() - ioutil.ReadAll(resp.Body) - - return nil -} - -func ulWarmUp(ulURL string) error { - size := ulSizes[4] - v := url.Values{} - v.Add("content", strings.Repeat("0123456789", size*100-51)) - - resp, err := client.PostForm(ulURL, v) - if err != nil { - return err - } - defer resp.Body.Close() - ioutil.ReadAll(resp.Body) - - return nil -} - -func downloadRequest(dlURL string, w int) error { - size := dlSizes[w] - xdlURL := dlURL + "/random" + strconv.Itoa(size) + "x" + strconv.Itoa(size) + ".jpg" - - resp, err := client.Get(xdlURL) - if err != nil { - return err - } - defer resp.Body.Close() - ioutil.ReadAll(resp.Body) - - return nil -} - -func uploadRequest(ulURL string) error { - size := ulSizes[9] - v := url.Values{} - v.Add("content", strings.Repeat("0123456789", size*100-51)) - - resp, err := client.PostForm(ulURL, v) - if err != nil { - return err - } - defer resp.Body.Close() - ioutil.ReadAll(resp.Body) - - return nil -} +//func (s *IpAddress) UploadTest(savingMode bool) error { +// // Warm up +// sTime := time.Now() +// eg := errgroup.Group{} +// for i := 0; i < 2; i++ { +// eg.Go(func() error { +// return ulWarmUp("http://" + s.Ipv4 + ":8088/server_info") +// }) +// } +// if err := eg.Wait(); err != nil { +// return err +// } +// fTime := time.Since(sTime) +// // 1.0 MB for each request +// wuSpeed := 1.0 * 8 * 2 / (fTime.Seconds() + s.Latency.Seconds()) +// +// // Decide workload by warm up speed +// workload := 0 +// weight := 0 +// skip := false +// if savingMode { +// workload = 1 +// weight = 7 +// } else if 10.0 < wuSpeed { +// workload = 16 +// weight = 9 +// } else if 4.0 < wuSpeed { +// workload = 8 +// weight = 9 +// } else if 2.5 < wuSpeed { +// workload = 4 +// weight = 5 +// } else { +// skip = true +// } +// +// // Main speedtest +// ulSpeed := wuSpeed +// if skip == false { +// sTime = time.Now() +// for i := 0; i < workload; i++ { +// eg.Go(func() error { +// return uploadRequest("http://"+s.Ipv4+":8088/server_info") +// }) +// } +// if err := eg.Wait(); err != nil { +// return err +// } +// fTime := time.Since(sTime) +// +// reqMB := float64(ulSizes[weight]) / 1000 +// ulSpeed = reqMB * 8 * float64(workload) / fTime.Seconds() +// } +// +// s.Upload = ulSpeed +// +// return nil +//} +// +//func dlWarmUp(dlURL string) error { +// size := dlSizes[2] +// xdlURL := dlURL + "/random" + strconv.Itoa(size) + "x" + strconv.Itoa(size) + ".jpg" +// +// resp, err := client.Get(xdlURL) +// if err != nil { +// return err +// } +// defer resp.Body.Close() +// ioutil.ReadAll(resp.Body) +// +// return nil +//} +// +//func ulWarmUp(ulURL string) error { +// size := ulSizes[4] +// v := url.Values{} +// v.Add("content", strings.Repeat("0123456789", size*100-51)) +// +// resp, err := client.PostForm(ulURL, v) +// if err != nil { +// return err +// } +// defer resp.Body.Close() +// ioutil.ReadAll(resp.Body) +// +// return nil +//} +// +//func downloadRequest(dlURL string, w int) error { +// size := dlSizes[w] +// xdlURL := dlURL + "/random" + strconv.Itoa(size) + "x" + strconv.Itoa(size) + ".jpg" +// +// resp, err := client.Get(xdlURL) +// if err != nil { +// return err +// } +// defer resp.Body.Close() +// ioutil.ReadAll(resp.Body) +// +// return nil +//} +// +//func uploadRequest(ulURL string) error { +// size := ulSizes[9] +// v := url.Values{} +// v.Add("content", strings.Repeat("0123456789", size*100-51)) +// +// resp, err := client.PostForm(ulURL, v) +// if err != nil { +// return err +// } +// defer resp.Body.Close() +// ioutil.ReadAll(resp.Body) +// +// return nil +//} // PingTest executes test to measure latency func (s *IpAddress) PingTest() error { diff --git a/server/server.go b/server/server.go index 149d2fc..2382181 100644 --- a/server/server.go +++ b/server/server.go @@ -3,7 +3,6 @@ package server import ( "fmt" "github.com/gin-gonic/gin" - "log" "net/http" //"fmt" ) @@ -24,7 +23,6 @@ func Server() { // Route build to do a speed test r.GET("/upload", func(c *gin.Context) { file, _ := c.FormFile("file") - log.Println(file.Filename) // Upload the file to specific dst. // c.SaveUploadedFile(file, dst)