-
Notifications
You must be signed in to change notification settings - Fork 5
/
simplenode.go
115 lines (109 loc) · 3.27 KB
/
simplenode.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
// simplenode package will test with ipfs api
package simplenode
import (
"crypto/rand"
"sync"
"time"
"github.com/ConsenSys/ipfs-lookup-measurement/controller/pkg/server"
logging "github.com/ipfs/go-log"
)
var log = logging.Logger("controller")
// Experiment publish message from one node, and lookup from all other nodes
func Experiment(publish int, key []byte, nodesList []string) {
// Publish string from node[publish]
publisher := nodesList[publish]
// Generate random content, 512 bytes.
content := make([]byte, 512)
rand.Read(content)
// Request Publish
// First do a disconnection to avoid using bitswap
out, err := server.RequestDisconnect(publisher, key)
if err != nil {
log.Errorf("Error requesting disconnection to %v: %v", publisher, err.Error())
return
}
log.Infof("Response of disconnection from %v is: %v", publisher, out)
cid, err := server.RequestPublish(publisher, key, content)
if err != nil {
log.Errorf("Error in publishing content from %v: %v", publisher, err.Error())
return
}
log.Infof("Published content from %v with cid: %v", publisher, cid)
// Need to wait till publish is finished.
for i := 0; i < 60; i++ {
time.Sleep(5 * time.Second)
done, err := server.RequestCheck(publisher, key, cid)
if err != nil {
log.Errorf("Error in requesting a check to %v: %v", publisher, err.Error())
return
}
if done {
log.Infof("Publish from %v is done", publisher)
break
}
if i == 59 {
log.Errorf("Error in publishing from %v", publisher)
return
}
log.Infof("Publish from %v in progress...", publisher)
}
// Start lookup from every other node.
var wg sync.WaitGroup
for i, lookupNode := range nodesList {
if i == publish {
continue
}
wg.Add(1)
go func(wg *sync.WaitGroup, lookupNode string) {
defer wg.Done()
// First do a disconnection to avoid using bitswap
out, err := server.RequestDisconnect(lookupNode, key)
if err != nil {
log.Errorf("Error requesting disconnection to %v: %v", lookupNode, err.Error())
return
}
log.Infof("Response of disconnection from %v is: %v", lookupNode, out)
log.Infof("Start lookup %v from %v", cid, lookupNode)
err = server.RequestLookup(lookupNode, key, cid)
if err != nil {
log.Errorf("Error requesting lookup to %v: %v", lookupNode, err.Error())
return
}
// Need to wait till lookup is finished.
for i := 0; i < 30; i++ {
time.Sleep(5 * time.Second)
done, err := server.RequestCheck(lookupNode, key, cid)
if err != nil {
log.Errorf("Error in requesting a check to %v: %v", lookupNode, err.Error())
return
}
if done {
log.Infof("Lookup from %v is done", lookupNode)
break
}
if i == 29 {
log.Errorf("Error in lookup from %v", lookupNode)
return
}
log.Infof("Lookup from %v in progress...", lookupNode)
}
}(&wg, lookupNode)
}
// Wait till all lookup is finished.
wg.Wait()
// Clean
for _, node := range nodesList {
wg.Add(1)
go func(wg *sync.WaitGroup, node string) {
defer wg.Done()
out, err := server.RequestClean(node, key, cid)
if err != nil {
log.Errorf("Error in requesting clean of %v to %v: %v", cid, node, err.Error())
} else {
log.Infof("Response of clean of %v from %v is: %v", cid, node, out)
}
}(&wg, node)
}
wg.Wait()
log.Infof("clean is done")
}