-
Notifications
You must be signed in to change notification settings - Fork 15
/
dialer.go
162 lines (146 loc) · 3.98 KB
/
dialer.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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
package measurex
//
// Dialer
//
// Wrappers for Dialer and Conn to store events into a WritableDB.
//
import (
"context"
"net"
"time"
"github.com/ooni/probe-engine/pkg/model"
"github.com/ooni/probe-engine/pkg/netxlite"
)
// Conn is a network connection.
type Conn = net.Conn
// WrapDialer creates a new dialer that writes events
// into the given WritableDB. The net.Conns created by
// a wrapped dialer also write into the WritableDB.
func (mx *Measurer) WrapDialer(db WritableDB, dialer model.Dialer) model.Dialer {
return WrapDialer(mx.Begin, db, dialer)
}
// WrapDialer wraps a dialer.
func WrapDialer(begin time.Time, db WritableDB, dialer model.Dialer) model.Dialer {
return &dialerDB{Dialer: dialer, db: db, begin: begin}
}
// NewDialerWithSystemResolver creates a
func (mx *Measurer) NewDialerWithSystemResolver(db WritableDB, logger model.Logger) model.Dialer {
r := mx.NewResolverSystem(db, logger)
return mx.WrapDialer(db, netxlite.NewDialerWithResolver(logger, r))
}
// NewDialerWithoutResolver is a convenience factory for creating
// a dialer that saves measurements into the DB and that is not attached
// to any resolver (hence only works when passed IP addresses).
func (mx *Measurer) NewDialerWithoutResolver(db WritableDB, logger model.Logger) model.Dialer {
return mx.WrapDialer(db, netxlite.NewDialerWithoutResolver(logger))
}
type dialerDB struct {
model.Dialer
begin time.Time
db WritableDB
}
// NetworkEvent contains a network event. This kind of events
// are generated by Dialer, QUICDialer, Conn, QUICConn.
type NetworkEvent struct {
RemoteAddr string
Failure *string
Count int
Operation string
Network string
Oddity Oddity
Finished float64
Started float64
}
func (d *dialerDB) DialContext(
ctx context.Context, network, address string) (Conn, error) {
started := time.Since(d.begin).Seconds()
conn, err := d.Dialer.DialContext(ctx, network, address)
finished := time.Since(d.begin).Seconds()
d.db.InsertIntoDial(&NetworkEvent{
Operation: "connect",
Network: network,
RemoteAddr: address,
Started: started,
Finished: finished,
Failure: NewFailure(err),
Oddity: d.computeOddity(err),
Count: 0,
})
if err != nil {
return nil, err
}
return &connDB{
Conn: conn,
begin: d.begin,
db: d.db,
network: network,
remoteAddr: address,
}, nil
}
func (c *dialerDB) computeOddity(err error) Oddity {
if err == nil {
return ""
}
switch err.Error() {
case netxlite.FailureGenericTimeoutError:
return OddityTCPConnectTimeout
case netxlite.FailureConnectionRefused:
return OddityTCPConnectRefused
case netxlite.FailureHostUnreachable:
return OddityTCPConnectHostUnreachable
default:
return OddityTCPConnectOher
}
}
type connDB struct {
net.Conn
begin time.Time
db WritableDB
network string
remoteAddr string
}
func (c *connDB) Read(b []byte) (int, error) {
started := time.Since(c.begin).Seconds()
count, err := c.Conn.Read(b)
finished := time.Since(c.begin).Seconds()
c.db.InsertIntoReadWrite(&NetworkEvent{
Operation: "read",
Network: c.network,
RemoteAddr: c.remoteAddr,
Started: started,
Finished: finished,
Failure: NewFailure(err),
Count: count,
})
return count, err
}
func (c *connDB) Write(b []byte) (int, error) {
started := time.Since(c.begin).Seconds()
count, err := c.Conn.Write(b)
finished := time.Since(c.begin).Seconds()
c.db.InsertIntoReadWrite(&NetworkEvent{
Operation: "write",
Network: c.network,
RemoteAddr: c.remoteAddr,
Started: started,
Finished: finished,
Failure: NewFailure(err),
Count: count,
})
return count, err
}
func (c *connDB) Close() error {
started := time.Since(c.begin).Seconds()
err := c.Conn.Close()
finished := time.Since(c.begin).Seconds()
c.db.InsertIntoClose(&NetworkEvent{
Operation: "close",
Network: c.network,
RemoteAddr: c.remoteAddr,
Started: started,
Finished: finished,
Failure: NewFailure(err),
Count: 0,
})
return err
}