me/p2p-rendering-computation
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

added config module

Browse Source
This commit is contained in:
Akilan Selvacoumar
2021-04-11 01:25:21 +04:00
parent f6653de158
commit d2b050b14b
74 changed files with 0 additions and 10839 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
p2p/50.bin
View File

Binary file not shown.

13
p2p/README
View File

@@ -1,13 +0,0 @@
P2P module
===========
(Techniques to get over NAT)
- UPNP implementation
- DMZ to be used if UPNP does not work
- Port forwarding for future release
(Discovery of Nodes)
- Connect to reliable connection (that has some knowledge)
- Check if the connection is still open (If not instruct the server to remove from table)
- According speed tests
- Send list of servers connection open
- default 100 MB (to store tables of ip records)

10
p2p/ip_table.json
View File

@@ -1,10 +0,0 @@
{
"ip_address": [
{
"ipv4": "localhost",
"latency": 14981051,
"download": 8142.122540206258,
"upload": 3578.766512629995
}
]
}

79
p2p/iptable.go
View File

@@ -1,79 +0,0 @@
package p2p
import (
"encoding/json"
"fmt"
"io/ioutil"
"os"
"time"
)
// Get IP table Data
type IpAddresses struct {
IpAddress []IpAddress `json:"ip_address"`
}
type IpAddress struct {
Ipv4 string `json:"ipv4"`
Latency time.Duration `json:"latency"`
Download float64 `json:"download"`
Upload float64 `json:"upload"`
}
// Read data from Ip tables from json file
func ReadIpTable()(*IpAddresses ,error){
jsonFile, err := os.Open("/etc/p2p-rendering/ip_table.json")
// if we os.Open returns an error then handle it
if err != nil {
return nil,err
}
// defer the closing of our jsonFile so that we can parse it later on
defer jsonFile.Close()
// read our opened xmlFile as a byte array.
byteValue, _ := ioutil.ReadAll(jsonFile)
// we initialize our Users array
var ipAddresses IpAddresses
// we unmarshal our byteArray which contains our
// jsonFile's content into 'users' which we defined above
json.Unmarshal(byteValue, &ipAddresses)
return &ipAddresses, nil
}
// Write to IP table json file
func (i *IpAddresses) WriteIpTable() error {
file, err := json.MarshalIndent(i, "", " ")
if err != nil {
return err
}
err = ioutil.WriteFile("/etc/p2p-rendering/ip_table.json", file, 0644)
if err != nil {
return err
}
return nil
}
// Print Ip table data for Cli
func PrintIpTable() error {
table, err := ReadIpTable()
if err != nil {
return err
}
for i := 0; i < len(table.IpAddress); i++ {
fmt.Printf("----------------------\nIP Address: %s\nLatency: %s\nDownload: %f\nUplaod: %f\n-----------" +
"-----------\n",table.IpAddress[i].Ipv4,
table.IpAddress[i].Latency,table.IpAddress[i].Download,table.IpAddress[i].Upload)
}
return nil
}

22
p2p/iptable_test.go
View File

@@ -1,22 +0,0 @@
package p2p
import (
"testing"
)
func TestReadIpTable(t *testing.T) {
json, err := ReadIpTable()
if err != nil {
t.Fatal(err)
}
err = json.WriteIpTable()
if err != nil {
t.Fatal(err)
}
err = PrintIpTable()
if err != nil {
t.Fatal(err)
}
}

88
p2p/speedtest.go
View File

@@ -1,88 +0,0 @@
package p2p
// Runs a speed test and does updates IP tables accordingly
func (ip *IpAddresses)SpeedTest() error{
for i, _ := range ip.IpAddress {
// Ping Test
err := ip.IpAddress[i].PingTest()
if err != nil {
// Remove IP address of element not pingable
ip.IpAddress = append(ip.IpAddress[:i], ip.IpAddress[i+1:]...)
// Proceed to next element in the array
continue
}
//Upload Speed Test
err = ip.IpAddress[i].UploadSpeed()
if err != nil {
return err
}
err = ip.IpAddress[i].DownloadSpeed()
if err != nil {
return err
}
}
err := ip.WriteIpTable()
if err != nil {
return err
}
return nil
}
// Called when ip tables from client/server is also passed on
func (ip *IpAddresses)SpeedTestUpdatedIPTable() error{
targets, err := ReadIpTable()
if err != nil {
return err
}
// To ensure struct has no duplicates IP addresses
DoNotRead := targets
// Appends all IP addresses
for i, _ := range targets.IpAddress {
Exists := false
for k := range DoNotRead.IpAddress {
if DoNotRead.IpAddress[k].Ipv4 == targets.IpAddress[i].Ipv4 {
Exists = true
break
}
}
// If the struct exists then continues
if Exists {
continue
}
ip.IpAddress = append(ip.IpAddress, targets.IpAddress[i])
}
err = ip.SpeedTest()
if err != nil {
return err
}
return nil
}
// Runs speed test in iptables locally only
func LocalSpeedTestIpTable() error {
targets, err := ReadIpTable()
if err != nil {
return err
}
err = targets.SpeedTest()
if err != nil {
return err
}
return nil
}

21
p2p/speedtest/speedtest.go
View File

@@ -1,21 +0,0 @@
package main
import (
"fmt"
"github.com/showwin/speedtest-go/speedtest"
)
func main() {
user, _ := speedtest.FetchUserInfo()
serverList, _ := speedtest.FetchServerList(user)
targets, _ := serverList.FindServer([]int{})
for _, s := range targets {
s.PingTest()
s.DownloadTest(false)
s.UploadTest(false)
fmt.Printf("Latency: %s, Download: %f, Upload: %f\n", s.Latency, s.DLSpeed, s.ULSpeed)
}
}

16
p2p/speedtest_test.go
View File

@@ -1,16 +0,0 @@
package p2p
import (
"testing"
)
// To run this test ip_table.json must be populated
func TestServer_SpeedTest(t *testing.T) {
err := LocalSpeedTestIpTable()
if err != nil {
t.Fatal(err)
}
//HumaidTest("http://localhost:8088/50")
//HumaidTest("http://ipv4.download.thinkbroadband.com/50MB.zip")
}

281
p2p/testingMetrics.go
View File

@@ -1,281 +0,0 @@
package p2p
import (
"bytes"
"io"
"io/ioutil"
"log"
"mime/multipart"
"net/http"
"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 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
//}
// Download Speed
func (s *IpAddress)DownloadSpeed() error {
start := time.Now()
resp, err := client.Get("http://" + s.Ipv4 + ":8088/50")
if err != nil {
return err
}
defer resp.Body.Close()
ioutil.ReadAll(resp.Body)
t := time.Since(start)
//fmt.Println(s.Seconds())
// size * time (seconds)
s.Download = (50/t.Seconds())*8
return nil
}
func (s *IpAddress)UploadSpeed() error {
start := time.Now()
b, w := createMultipartFormData("file","/etc/p2p-rendering/50.bin")
req, err := http.NewRequest("GET", "http://" + s.Ipv4 + ":8088/upload", &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
//}
// PingTest executes test to measure latency
func (s *IpAddress) PingTest() error {
//pingURL := strings.Split(s.URL, "/upload")[0] + "/latency.txt"
pingURL := "http://" + s.Ipv4 + ":8088/server_info"
l := time.Duration(100000000000) // 10sec
for i := 0; i < 3; i++ {
sTime := time.Now()
resp, err := http.Get(pingURL)
fTime := time.Now()
if err != nil {
return err
}
if fTime.Sub(sTime) < l {
l = fTime.Sub(sTime)
}
resp.Body.Close()
}
s.Latency = time.Duration(int64(l.Nanoseconds() / 2))
return nil
}

76
p2p/upnp.go
View File

@@ -1,76 +0,0 @@
package p2p
import (
"fmt"
"gitlab.com/NebulousLabs/go-upnp"
)
// Port forwarding to the router
func ForwardPort(port int) error{
// connect to router
d, err := upnp.Discover()
if err != nil {
return err
}
// discover external IP
ip, err := d.ExternalIP()
if err != nil {
return err
}
fmt.Println("Your external IP is:", ip)
// forward a port
err = d.Forward(50498, "upnp test")
if err != nil {
return err
}
// record router's location
loc := d.Location()
// connect to router directly
d, err = upnp.Load(loc)
if err != nil {
return err
}
return nil
}
// unForwardPort from router
func UnForwardPort(port int) error{
// connect to router
d, err := upnp.Discover()
if err != nil {
return err
}
// discover external IP
ip, err := d.ExternalIP()
if err != nil {
return err
}
fmt.Println("Your external IP is:", ip)
// un-forward a port
err = d.Clear(50498)
if err != nil {
return err
}
// record router's location
loc := d.Location()
// connect to router directly
d, err = upnp.Load(loc)
if err != nil {
return err
}
return nil
}

21
p2p/upnp_test.go
View File

@@ -1,21 +0,0 @@
package p2p
import(
"testing"
)
func TestAddRemoveUpnp(t *testing.T){
// forwarding port 23241 via upnp
err := ForwardPort(23241)
if err != nil {
t.Errorf("Error returned: %q", err)
}
// unforwarding port 23241 via upnp
err = UnForwardPort(23241)
if err != nil {
t.Errorf("Error returned: %q", err)
}
}