forked from glycerine/grpc-demo
/
main.go
139 lines (108 loc) · 3.17 KB
/
main.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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
package main
import (
"encoding/binary"
"flag"
"fmt"
"log"
"os"
"runtime/pprof"
"time"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials/insecure"
"github.com/devops-filetransfer/filetransfer/client/config"
_grpc "github.com/devops-filetransfer/filetransfer/client/grpc"
"github.com/devops-filetransfer/filetransfer/client/print"
)
func SequentialPayload(n int64) []byte {
if n%8 != 0 {
panic(fmt.Sprintf("n == %v must be a multiple of 8; has remainder %v", n, n%8))
}
k := uint64(n / 8)
by := make([]byte, n)
j := uint64(0)
for i := uint64(0); i < k; i++ {
j = i * 8
binary.LittleEndian.PutUint64(by[j:j+8], j)
}
return by
}
const ProgramName = "client"
func main() {
myflags := flag.NewFlagSet(ProgramName, flag.ContinueOnError)
cfg := &config.ClientConfig{}
cfg.DefineFlags(myflags)
cfg.SkipEncryption = true
err := myflags.Parse(os.Args[1:])
if err != nil {
log.Fatalf("%s command line flag error: '%s'", ProgramName, err)
}
if cfg.CpuProfilePath != "" {
f, err := os.Create(cfg.CpuProfilePath)
if err != nil {
log.Fatal(err)
}
_ = pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
}
err = cfg.ValidateConfig()
if err != nil {
log.Fatalf("%s command line flag error: '%s'", ProgramName, err)
}
var opts []grpc.DialOption
if cfg.UseTLS {
cfg.SetupTLS(&opts)
} else if cfg.SkipEncryption {
// no encryption
opts = append(opts, grpc.WithTransportCredentials(insecure.NewCredentials()))
print.P("client configured to skip encryption.")
} else {
cfg.SetupSSH(&opts)
}
serverAddr := fmt.Sprintf("%v:%v", cfg.ServerHost, cfg.ServerPort)
conn, err := grpc.Dial(serverAddr, opts...)
if err != nil {
log.Fatalf("fail to dial: %v", err)
}
defer conn.Close()
// SendFile
c := _grpc.NewClient(conn)
myID := "test-client-0"
data := []byte("hello peer, it is nice to meet you!!")
err = c.RunSendFile("file1", data, 3, false, myID)
print.PanicOn(err)
data2 := []byte("second set of data should be kept separate!")
err = c.RunSendFile("file2", data2, 3, false, myID)
print.PanicOn(err)
//n := 1 << 29 // test with 512MB file. Works with up to 1MB or 2MB chunks.
n := cfg.PayloadSizeMegaBytes * 1 << 20
print.P("generating test data of size %v bytes", n)
data3 := SequentialPayload(int64(n))
//chunkSz := 1 << 22 // 4MB // GRPC will fail with EOF.
chunkSz := 1 << 20
c2done := make(chan struct{})
overlap := false
// overlap two sends to different paths
go func() {
if overlap {
time.Sleep(10 * time.Millisecond)
print.P("after 10msec of sleep, comencing bigfile3...")
c2 := _grpc.NewClient(conn)
t0 := time.Now()
err = c2.RunSendFile("bigfile3", data3, chunkSz, false, myID)
t1 := time.Now()
print.PanicOn(err)
mb := float64(len(data3)) / float64(1<<20)
elap := t1.Sub(t0)
print.P("c2: elap time to send %v MB was %v => %.03f MB/sec", mb, elap, mb/(float64(elap)/1e9))
}
close(c2done)
}()
t0 := time.Now()
err = c.RunSendFile("bigfile4", data3, chunkSz, false, myID)
t1 := time.Now()
print.PanicOn(err)
mb := float64(len(data3)) / float64(1<<20)
elap := t1.Sub(t0)
print.P("c: elap time to send %v MB was %v => %.03f MB/sec", mb, elap, mb/(float64(elap)/1e9))
<-c2done
}