Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
ce5d2a6dd0 | ||
|
|
a2e301c648 | ||
|
|
0425d5bf6a | ||
|
|
2fa576f3c0 | ||
|
|
fa29a4b4af | ||
|
|
d698aefbfc | ||
|
|
a3b6380296 | ||
|
|
469d456c8b | ||
|
|
daa369b86c | ||
|
|
c54f2959ad | ||
|
|
bd06553ce0 | ||
|
|
158fa9d8e5 | ||
|
|
8d71467802 | ||
|
|
8c5cbc738a | ||
|
|
01e3d1d81b | ||
|
|
39b0d2a0cb | ||
|
|
260b416cd7 | ||
|
|
ad5845b67f | ||
|
|
7fcd837277 | ||
|
|
5993b3e846 | ||
|
|
4e48b956d9 | ||
|
|
5b5d9d833a | ||
|
|
e16a4aa97a | ||
|
|
12fa345d10 | ||
|
|
d2ea7e046d | ||
|
|
1b50285609 | ||
|
|
658c910862 | ||
|
|
e1ab6a9035 | ||
|
|
8c8709e527 | ||
|
|
d1e004dedc | ||
|
|
4fc232be61 | ||
|
|
df2868fcdd | ||
|
|
b1aa52b3ed | ||
|
|
11c368531a | ||
|
|
608da90dc7 | ||
|
|
fbb6e58b4f | ||
|
|
1283ba4f61 | ||
|
|
87b61419f3 | ||
|
|
0b4f9dbcf9 | ||
|
|
9644ed3f29 | ||
|
|
1d52615452 | ||
|
|
327a6f6d61 | ||
|
|
05652c0a3c | ||
|
|
503546d2a9 | ||
|
|
3252a25e00 | ||
|
|
6847a3551d | ||
|
|
70bd0ade45 | ||
|
|
8405e0759a | ||
|
|
be3b0aa976 | ||
|
|
5ac8cc74d3 | ||
|
|
68e5ed575f | ||
|
|
f6966548eb | ||
|
|
fb3ed9c1a6 | ||
|
|
61fc5d56fb | ||
|
|
e96b68f0aa | ||
|
|
393fa3a333 | ||
|
|
9ce229ba3a | ||
|
|
8b432a4d3e | ||
|
|
560f38330e | ||
|
|
9243bc2b0a | ||
|
|
df5d6972e1 | ||
|
|
380cb9b0fc | ||
|
|
bd3b3791c6 | ||
|
|
7decce690a | ||
|
|
65ecac6f1a | ||
|
|
14a3898371 | ||
|
|
c012650476 | ||
|
|
789a6192f2 | ||
|
|
019a065d03 | ||
|
|
de1304d424 | ||
|
|
ef915ca58f | ||
|
|
5de090999c | ||
|
|
8ea5d999c2 | ||
|
|
671dddf761 | ||
|
|
f4a117a8fc | ||
|
|
0e655a2bbd | ||
|
|
a5739e8753 | ||
|
|
79f2324d2b | ||
|
|
c1a3ea925d | ||
|
|
062c7a6fdc | ||
|
|
6cc7f37dbb | ||
|
|
d2450aae1c | ||
|
|
76f9afb59c | ||
|
|
192fbe3a53 | ||
|
|
427b6d2902 | ||
|
|
2f5a3f4513 | ||
|
|
c984ec1e86 | ||
|
|
061d2b123f | ||
|
|
07780fa10c | ||
|
|
a6b7f0a9d4 | ||
|
|
5b72142aa3 | ||
|
|
476d2fee09 | ||
|
|
b95c559564 | ||
|
|
cfdba71f90 | ||
|
|
8ac90c693d | ||
|
|
74546578ac | ||
|
|
88c6c17767 | ||
|
|
f5223d754a | ||
|
|
278f7d8381 | ||
|
|
2dddc58754 | ||
|
|
d454e610f1 | ||
|
|
4d06069138 | ||
|
|
3f0a5d9e5d | ||
|
|
85bda72038 | ||
|
|
1c7df2958a | ||
|
|
302d412530 | ||
|
|
ca2e54c361 | ||
|
|
b9706e456a | ||
|
|
e1478eefd4 | ||
|
|
3a2452baf6 | ||
|
|
82c9a88aa2 | ||
|
|
7ef007bbf5 | ||
|
|
d32fc495c8 | ||
|
|
d3635eed77 | ||
|
|
a16b48d8f3 | ||
|
|
6ad9dac71a | ||
|
|
a921f77258 | ||
|
|
8253d17529 | ||
|
|
d3be3d8912 | ||
|
|
a6e0226189 | ||
|
|
f3dbebd467 | ||
|
|
b7b9322e33 | ||
|
|
5e4ab7f307 | ||
|
|
2b159b0c75 | ||
|
|
984ba8a377 | ||
|
|
01be916c37 | ||
|
|
0e54de63cc | ||
|
|
c0c5906d07 | ||
|
|
f6f4ee708a | ||
|
|
8f54f83285 | ||
|
|
e393b4aaa6 | ||
|
|
8822aa4ece | ||
|
|
3e83897752 | ||
|
|
1d7cdfae5d | ||
|
|
0e71b7c01d | ||
|
|
3c8bff70df | ||
|
|
6de0c06ada | ||
|
|
4ede0ac923 | ||
|
|
fa3f1b277f | ||
|
|
5ade5cca03 | ||
|
|
99a5b4aed3 | ||
|
|
07026bc7a9 | ||
|
|
0ed9694199 | ||
|
|
098be788ae | ||
|
|
c6609bd248 | ||
|
|
cadc3869b3 | ||
|
|
4669da6074 | ||
|
|
439c9143af | ||
|
|
b9340ada3e | ||
|
|
88e2761b18 | ||
|
|
02516361c7 | ||
|
|
31ca8f9dbf | ||
|
|
a657e25a81 | ||
|
|
e355e50c0d | ||
|
|
af8f590646 | ||
|
|
c3ecbc9d48 | ||
|
|
a09986baa2 | ||
|
|
e9ca0ffad1 | ||
|
|
aed6fd3fcc | ||
|
|
e77b2ae288 | ||
|
|
828e5ba0b8 | ||
|
|
0eee97b988 | ||
|
|
358342aa4f | ||
|
|
6b08f97910 | ||
|
|
045edcca2f | ||
|
|
b4050276a9 | ||
|
|
6639353568 | ||
|
|
928a693491 | ||
|
|
f08148cabb | ||
|
|
d1ca38e106 | ||
|
|
15bdf6cd2d | ||
|
|
4037c763c2 | ||
|
|
d4fb739981 | ||
|
|
4bd6de5995 | ||
|
|
61b0d0ba9e | ||
|
|
56bfe15eca | ||
|
|
c10d26cf02 | ||
|
|
695babf7ba | ||
|
|
ecf1887e5b | ||
|
|
c6e8f54fe7 | ||
|
|
a4062bd15c | ||
|
|
4d352d6eb1 | ||
|
|
737b0e0504 | ||
|
|
16e5032528 | ||
|
|
26bd1b5787 | ||
|
|
13f3ff15bd | ||
|
|
e88e67f02c | ||
|
|
9c7b27acf0 | ||
|
|
aad5b4dd7e | ||
|
|
c12a52d20e | ||
|
|
0c59de40e7 | ||
|
|
a897a7711c | ||
|
|
fb8167c6f1 | ||
|
|
0482d0716f | ||
|
|
f183cb491f | ||
|
|
80770cc96e | ||
|
|
21d061fa44 | ||
|
|
7d27df0907 | ||
|
|
768e2a31fa | ||
|
|
487392b99c | ||
|
|
50af75972a | ||
|
|
88518ba278 | ||
|
|
a83359da7d | ||
|
|
9c4b4ca35f | ||
|
|
2e31087818 | ||
|
|
11e520e212 | ||
|
|
3254870899 | ||
|
|
51210045f7 | ||
|
|
9e6ae4422e | ||
|
|
ce431dd73f | ||
|
|
934ec2467d | ||
|
|
ff4d0dae70 | ||
|
|
bac3d65ede | ||
|
|
ecb180c0c5 | ||
|
|
f01d91459b | ||
|
|
3e07f03c87 | ||
|
|
28e0b14220 | ||
|
|
f82ef55c67 | ||
|
|
53ba2f0aff | ||
|
|
45b36b378d | ||
|
|
41a5c6f523 | ||
|
|
4f1d87f893 | ||
|
|
66c92fe075 | ||
|
|
ebc5dcb4bb | ||
|
|
afff92c248 | ||
|
|
ead3518b4b | ||
|
|
c38dcb1d73 | ||
|
|
00fe47ba62 | ||
|
|
b7d49cdeb7 | ||
|
|
495a35a6a6 | ||
|
|
9f13d28508 | ||
|
|
de4cc0ad54 | ||
|
|
7f4c527fc5 | ||
|
|
8a305ee189 | ||
|
|
718e93bd23 | ||
|
|
254be128b0 | ||
|
|
2c49cd1e0a | ||
|
|
ec167554c5 | ||
|
|
f24f38be9c | ||
|
|
0f89f8562f | ||
|
|
8eb52538de | ||
|
|
90629bc6d3 | ||
|
|
c6fea4939e | ||
|
|
0597162189 | ||
|
|
74e7d383c9 | ||
|
|
051320e73c | ||
|
|
6e04ccf677 | ||
|
|
436dc01f52 | ||
|
|
a6bb02aca1 | ||
|
|
ec5008c702 | ||
|
|
3453972ac4 | ||
|
|
7c37cd98dd | ||
|
|
a1eb940c51 | ||
|
|
bd6359dcb1 | ||
|
|
cc75b084d8 | ||
|
|
bd9314939b | ||
|
|
2298927331 | ||
|
|
b3b93b28df | ||
|
|
d68c1a8187 | ||
|
|
06a525456d | ||
|
|
9d19676ef1 | ||
|
|
540b55a35c | ||
|
|
2f435cfcce | ||
|
|
18f678a3c8 | ||
|
|
cc06a2d8ab | ||
|
|
1dd2cdf7a9 | ||
|
|
5944f069b6 | ||
|
|
aade206f22 | ||
|
|
22c3582699 | ||
|
|
2948deb210 | ||
|
|
db9139a0cd | ||
|
|
bbcbb5f7b8 | ||
|
|
1a872f3895 | ||
|
|
095d7e54c3 | ||
|
|
b2a484d5f0 | ||
|
|
8472272afe | ||
|
|
648632d5ac | ||
|
|
ea3456756d | ||
|
|
0672a0858f | ||
|
|
a1381fe0cf | ||
|
|
3baf8058ed | ||
|
|
daf92d8e08 | ||
|
|
c91b2c2907 | ||
|
|
6e0aea233b | ||
|
|
abd138026b | ||
|
|
3b9847d5d9 | ||
|
|
c4ec25bb14 | ||
|
|
0109bf0ac7 | ||
|
|
4482d307bf | ||
|
|
5aa2a7a14c | ||
|
|
984cad5b58 | ||
|
|
de8c1d262f | ||
|
|
2d964bdc95 | ||
|
|
91044ac0fa | ||
|
|
98aeb674c4 | ||
|
|
ea11c5eedc | ||
|
|
c146ee142d | ||
|
|
88d115aab1 | ||
|
|
fce954192c | ||
|
|
aab86c38b7 | ||
|
|
adc038d8d1 | ||
|
|
cfa9b4f638 | ||
|
|
e6fd970920 | ||
|
|
ad0a5477f9 | ||
|
|
2b617633ae | ||
|
|
7776e48a62 | ||
|
|
6c0075ab82 | ||
|
|
48534b1e30 | ||
|
|
8b6c5bdae4 | ||
|
|
b8abb22833 | ||
|
|
ae0a4fef50 | ||
|
|
4dcec8265d | ||
|
|
8360024e06 | ||
|
|
7a7867ae16 | ||
|
|
43f8d073db | ||
|
|
2e4d56efd6 | ||
|
|
6bc199a8bc | ||
|
|
ad42f27e03 | ||
|
|
c75cadf007 | ||
|
|
b080224072 | ||
|
|
537868008f | ||
|
|
63a9f879fb | ||
|
|
1664fce9d1 | ||
|
|
c2cf825cdf | ||
|
|
38a79b7f59 | ||
|
|
010766fe9e | ||
|
|
c09dfe6b5a | ||
|
|
d177bb8a47 | ||
|
|
a26dd1b1d7 | ||
|
|
34de08d649 | ||
|
|
74d0b3b51e | ||
|
|
6b33f4215b | ||
|
|
cc43782d87 | ||
|
|
c2eb900dd3 | ||
|
|
915a72ad18 | ||
|
|
320a8ad15b | ||
|
|
cf08b8b1aa | ||
|
|
001322751f | ||
|
|
0b3dd35624 | ||
|
|
cdf3e4b98e | ||
|
|
0d10479e8a | ||
|
|
357d0e918a | ||
|
|
3123418022 | ||
|
|
dcc2d16408 | ||
|
|
e9081c6607 | ||
|
|
439e57ca56 | ||
|
|
18ddf50b4c | ||
|
|
6ebac90cb0 | ||
|
|
5e0231ec5e | ||
|
|
c25bfafcb2 | ||
|
|
6e4f025d9c | ||
|
|
07ea8a2613 | ||
|
|
f9a0ba82a0 | ||
|
|
4c0fe7b006 | ||
|
|
cddef7cae5 | ||
|
|
197f4165a3 | ||
|
|
4a2affabb5 | ||
|
|
211e527d3f | ||
|
|
09a6c2eda0 | ||
|
|
71ec252298 | ||
|
|
9f10b21c9c | ||
|
|
62d823850c | ||
|
|
c48eefa82d | ||
|
|
65eff683dd | ||
|
|
b1ec2b788a | ||
|
|
f42e275884 | ||
|
|
8ce6d3863e | ||
|
|
f11314ed3e | ||
|
|
e080f00354 | ||
|
|
b00f0aee65 | ||
|
|
7b6364696c | ||
|
|
5dfd104728 | ||
|
|
88cb07203a | ||
|
|
bc7539c4ad | ||
|
|
0474227d6e | ||
|
|
04bbb14f59 | ||
|
|
f9f6e8ed26 | ||
|
|
9c2e9bab14 | ||
|
|
4539bde5f5 | ||
|
|
44db686ef3 | ||
|
|
221ef4adca | ||
|
|
c1d4e34ed0 | ||
|
|
4903c2b23c | ||
|
|
cd9b7bfcda | ||
|
|
c8ca295cda | ||
|
|
4e09889cab | ||
|
|
a66543f98e | ||
|
|
0705319f25 | ||
|
|
b153e6a0d2 | ||
|
|
ef892fd4ed | ||
|
|
024eb46c7d | ||
|
|
ecdd7aa7ce | ||
|
|
b09b556796 | ||
|
|
2d6a916b2d | ||
|
|
011fb55e5f | ||
|
|
ac4e87418a | ||
|
|
42ff61f97c | ||
|
|
08059412b5 | ||
|
|
f9615c34dc | ||
|
|
703b8dfd11 | ||
|
|
b86e6412fa | ||
|
|
aa1c1cc9be | ||
|
|
4b5fb2785e | ||
|
|
4eaeb0f30c | ||
|
|
9c096526b8 | ||
|
|
eee77d49d1 | ||
|
|
d2d1d2b43a | ||
|
|
4874605add | ||
|
|
922f465ecb | ||
|
|
c80bf7e996 | ||
|
|
dd505a8e17 | ||
|
|
08e9db900a | ||
|
|
86bfc91ac9 | ||
|
|
2eeb754454 | ||
|
|
2a10182cf6 | ||
|
|
115162fbfd | ||
|
|
82adc85562 | ||
|
|
05a7024b88 | ||
|
|
62e8028591 | ||
|
|
2bc5fd30c0 | ||
|
|
35671135bd | ||
|
|
a57335738d | ||
|
|
459bb08828 | ||
|
|
3ad9d8e785 | ||
|
|
52552b59fb | ||
|
|
f8e2af32cd | ||
|
|
66cd178308 | ||
|
|
be2dfda78e | ||
|
|
0009b05635 | ||
|
|
f2e38ae6c5 | ||
|
|
b83f4a00ed | ||
|
|
e2c8dba981 | ||
|
|
6584df274e | ||
|
|
7c65b6e3bb | ||
|
|
268d355cae | ||
|
|
b84ef98de8 | ||
|
|
29674b7780 | ||
|
|
9cfc104fc7 | ||
|
|
824329d4c9 | ||
|
|
604309fb53 | ||
|
|
73f1a04d5f | ||
|
|
b76e2a87cf | ||
|
|
b6eec08247 | ||
|
|
03563e847e | ||
|
|
4c159a9af6 | ||
|
|
bc61838aaa | ||
|
|
8c9937b0be | ||
|
|
bdc9eae000 | ||
|
|
95cbc8940e | ||
|
|
f29716387f | ||
|
|
30b9d33276 | ||
|
|
532a6b69d9 | ||
|
|
f2ef5e880a | ||
|
|
dd74bb1774 | ||
|
|
adf56d316d | ||
|
|
cb9af20a2e | ||
|
|
cb01e3f87b | ||
|
|
590c1dde1d | ||
|
|
246f394731 | ||
|
|
f5d8fc5de2 | ||
|
|
7cdf273c88 | ||
|
|
7453c7a5dd | ||
|
|
71af1f3120 | ||
|
|
e65a08471f | ||
|
|
b96330d529 | ||
|
|
f17d50cc50 | ||
|
|
436f8ef7c8 | ||
|
|
65f435f042 | ||
|
|
561c8d012c | ||
|
|
bb4c0f5247 | ||
|
|
31a964ba9b | ||
|
|
b717399364 | ||
|
|
b79bb32782 | ||
|
|
6ff7419981 | ||
|
|
b228bbb9fb | ||
|
|
752baa4bd6 | ||
|
|
6cbde89eeb | ||
|
|
c5361801c9 | ||
|
|
3283bc89fc | ||
|
|
26519333c0 | ||
|
|
639cde0f67 | ||
|
|
6f65512471 | ||
|
|
d5b82cac45 | ||
|
|
f4ad97b0c9 | ||
|
|
d7a1bdd7a8 | ||
|
|
d9637ce620 | ||
|
|
644485d4ae | ||
|
|
b064bcce49 | ||
|
|
0f9d9c77a3 | ||
|
|
33c81add8d | ||
|
|
497a104db7 | ||
|
|
5dd8584fb6 | ||
|
|
4bd18737b7 | ||
|
|
ba8926a6ea | ||
|
|
09cd9e091a | ||
|
|
2d4d3577ba | ||
|
|
546f9592f9 | ||
|
|
06f3793f05 | ||
|
|
f396c60402 | ||
|
|
ad036499eb | ||
|
|
38c6eb28e8 | ||
|
|
11e2515f70 | ||
|
|
c79e036c08 | ||
|
|
7a19c2f147 | ||
|
|
4cee647e73 | ||
|
|
7ea3299dc6 | ||
|
|
5707581ba3 | ||
|
|
264d5e4828 | ||
|
|
9311294d9c | ||
|
|
2bfc86e7b2 | ||
|
|
36ee8bacb0 | ||
|
|
1bb1108b91 | ||
|
|
a77201bf77 | ||
|
|
a3d842bf4a | ||
|
|
43eb70193b | ||
|
|
a401d0d6ea | ||
|
|
6252871e93 | ||
|
|
6d1e33b558 | ||
|
|
ed3c50f43e | ||
|
|
9ac62e8005 | ||
|
|
034da376c4 | ||
|
|
10fbc75997 | ||
|
|
98d76e1099 | ||
|
|
f2a1b3829d | ||
|
|
e47c4a78f0 | ||
|
|
f9f6649f90 | ||
|
|
a5c9898884 | ||
|
|
839eb28310 | ||
|
|
e2ec2b436d | ||
|
|
07b79568dd | ||
|
|
1d3c80ab49 | ||
|
|
38013d2f41 | ||
|
|
65c48707f6 | ||
|
|
415e550f86 | ||
|
|
034d8933c0 | ||
|
|
cf24bb0e89 | ||
|
|
ae725e333a | ||
|
|
dde244160b | ||
|
|
fdd006022d | ||
|
|
1e01a31939 | ||
|
|
4117ef0c50 | ||
|
|
e3c19d6414 | ||
|
|
b1e6bc2929 | ||
|
|
feee4f0494 | ||
|
|
34ab86124b | ||
|
|
f37eb4b77d | ||
|
|
90795e5446 | ||
|
|
6bebce0b5a | ||
|
|
71da517e88 | ||
|
|
faa7bad8d8 | ||
|
|
710c13ced9 | ||
|
|
6bd8da905e | ||
|
|
839f534350 | ||
|
|
0a4b3a04ba | ||
|
|
78f2d82984 | ||
|
|
f8fa37c895 | ||
|
|
c2a869491f | ||
|
|
a750ef8033 | ||
|
|
30fef10afa | ||
|
|
2e9c1ee046 | ||
|
|
81c49e6005 | ||
|
|
11ccada740 | ||
|
|
b2c9802aa2 | ||
|
|
5fbceb0f78 | ||
|
|
3c6211f9f2 | ||
|
|
b9502ee1cd | ||
|
|
4f97b3ac85 | ||
|
|
e4828ad30a | ||
|
|
20dab1f8fe | ||
|
|
c0ece16881 | ||
|
|
95a4ca8e3e | ||
|
|
cab4e37ef8 | ||
|
|
0dff2e66c6 | ||
|
|
6680a8a054 | ||
|
|
482045aed8 | ||
|
|
610a90c727 | ||
|
|
31f736b37e | ||
|
|
d220379ad3 | ||
|
|
952e9de265 | ||
|
|
ef1b8d6237 | ||
|
|
2970df4505 | ||
|
|
87f793f0e0 | ||
|
|
1a590b3ffa | ||
|
|
e249a7ef0c | ||
|
|
83412e4514 | ||
|
|
1a59734cdb | ||
|
|
7f3dc6f202 | ||
|
|
efffbe6de1 | ||
|
|
a64435a9a5 | ||
|
|
c2fba38c46 | ||
|
|
d2ba647f68 | ||
|
|
a6aad6dc49 | ||
|
|
7455a699c4 | ||
|
|
0872623ca5 | ||
|
|
4d05775e11 | ||
|
|
d5bfc61a73 | ||
|
|
7ec17ab2ef | ||
|
|
03ac917567 | ||
|
|
5d598a1015 | ||
|
|
adafb79e34 | ||
|
|
bafa3f4f4e | ||
|
|
6570b0ba1a | ||
|
|
2a2b2da097 | ||
|
|
dd7271aaa2 | ||
|
|
133c16f989 | ||
|
|
e631fb0d69 | ||
|
|
432c1904da | ||
|
|
8a691814e2 | ||
|
|
553c8b734d | ||
|
|
3767a680e8 | ||
|
|
e27b320ede | ||
|
|
90afa7db93 | ||
|
|
efd4fc4704 | ||
|
|
d770532b08 | ||
|
|
31b303a419 | ||
|
|
9578798ec0 | ||
|
|
8061ea4079 | ||
|
|
a83b58cd27 | ||
|
|
8eeb6dd836 | ||
|
|
bd7e5d6921 | ||
|
|
7c1e80ca89 | ||
|
|
9aae1fa3c9 | ||
|
|
5bf440d558 | ||
|
|
d97c385b4e | ||
|
|
1d3ca061ad | ||
|
|
d50975a185 | ||
|
|
6261ce0865 | ||
|
|
b4682bbc8c | ||
|
|
d9a32e563c | ||
|
|
b0e98f99d0 | ||
|
|
6684ae8316 | ||
|
|
9b4a5d1cb4 | ||
|
|
9f79e5be54 | ||
|
|
aa44b66a31 | ||
|
|
3a367595d7 | ||
|
|
e5c256daa1 | ||
|
|
f12ec3b295 | ||
|
|
9f0399f27e | ||
|
|
cc72f7d3ee | ||
|
|
c098aefed9 | ||
|
|
6a103aef27 | ||
|
|
80df5a7906 | ||
|
|
28561237ab | ||
|
|
799160c5c2 | ||
|
|
29ebeeaff5 | ||
|
|
257d88f48e | ||
|
|
e468399616 | ||
|
|
b2b293a8ee | ||
|
|
2f885a7906 | ||
|
|
7985e43e68 | ||
|
|
f84b933d7c | ||
|
|
4672e9ec1f | ||
|
|
a5ddba03f7 | ||
|
|
9336cc4121 | ||
|
|
d2ad5ddb01 | ||
|
|
73df093e48 | ||
|
|
abea21245d | ||
|
|
0b4f1b5af0 | ||
|
|
9933a4a368 | ||
|
|
c3f2150b5b | ||
|
|
46566e2159 | ||
|
|
1d8d098450 | ||
|
|
1038cbd1a3 | ||
|
|
21a2cdd579 | ||
|
|
d9b9ce6bcd | ||
|
|
4fffa6fa43 | ||
|
|
c0cd9dffc2 | ||
|
|
f91d7bb7e4 | ||
|
|
3e6f31c8e2 | ||
|
|
19b53cdeb1 | ||
|
|
c6cc10169f | ||
|
|
987d89632d | ||
|
|
8804f88c93 | ||
|
|
3c654bc036 | ||
|
|
8ddbb3d8af | ||
|
|
422e9b58cd | ||
|
|
64a017c972 | ||
|
|
604f5c599a | ||
|
|
9aa4313d37 | ||
|
|
969dc4e527 | ||
|
|
bbd0b15792 | ||
|
|
99b7fbbc71 | ||
|
|
486eb740b5 | ||
|
|
c6a73b8a75 | ||
|
|
262f8915a8 | ||
|
|
b623e914c9 | ||
|
|
70bfcd033b | ||
|
|
1bec425510 | ||
|
|
c3e6669d18 | ||
|
|
d010000583 | ||
|
|
419f2ff71b | ||
|
|
4ebcd355f6 | ||
|
|
ec872d7b45 | ||
|
|
9801e00ba6 | ||
|
|
79452d3a9a | ||
|
|
0ee22af32d | ||
|
|
13f37edb64 | ||
|
|
75d9e95b15 | ||
|
|
d59594c6b0 | ||
|
|
4a6b72c649 | ||
|
|
20a8488a15 | ||
|
|
be8260ae79 | ||
|
|
9c31de9cb9 | ||
|
|
c1e8c9c537 | ||
|
|
24d1c73012 | ||
|
|
2816899543 | ||
|
|
394d2add68 | ||
|
|
159bad54b0 | ||
|
|
1cc7ca18ba | ||
|
|
4e22922256 | ||
|
|
8f01f6e85c | ||
|
|
27f477a075 | ||
|
|
82ac69be4e | ||
|
|
0f357cdf7c | ||
|
|
872d88acb6 | ||
|
|
f0f0e6f36d | ||
|
|
6ecdf69b88 | ||
|
|
58de14ff65 | ||
|
|
4d304146f3 | ||
|
|
e9520215a0 | ||
|
|
a2b192c472 | ||
|
|
52575915d0 | ||
|
|
0ecc0ee02e | ||
|
|
8101dea338 | ||
|
|
373f8a4463 | ||
|
|
8846274c42 | ||
|
|
c2356ebcde | ||
|
|
33812f7666 | ||
|
|
f58e3bf2a9 | ||
|
|
5473995305 | ||
|
|
1796582032 | ||
|
|
4214a09392 | ||
|
|
e833ab672d | ||
|
|
39e29fd40b | ||
|
|
ec0c5f0375 | ||
|
|
ac53d7d47b | ||
|
|
fdc7e15192 | ||
|
|
78ba69ef9f | ||
|
|
593e3d3593 | ||
|
|
716f50c4e4 | ||
|
|
2f94d727ea | ||
|
|
cb6176fd8a | ||
|
|
b93ce1cea5 | ||
|
|
3be28523c9 | ||
|
|
592335092c | ||
|
|
6c4e9fccd3 | ||
|
|
6903b8d458 | ||
|
|
274265f001 | ||
|
|
ceac3c3d83 | ||
|
|
5580b7a522 | ||
|
|
bda8cff7c1 | ||
|
|
31006002f3 | ||
|
|
b1cb0c298d | ||
|
|
d7835eabfb |
No files matched your search
+4
-8
@@ -25,6 +25,7 @@ _testmain.go
|
|||||||
*.prof
|
*.prof
|
||||||
profile.cov
|
profile.cov
|
||||||
coverage.html
|
coverage.html
|
||||||
|
.pkg
|
||||||
|
|
||||||
# Emacs backup files
|
# Emacs backup files
|
||||||
*~
|
*~
|
||||||
@@ -41,16 +42,12 @@ prog/sigproxy/sigproxy
|
|||||||
prog/weavewait/weavewait
|
prog/weavewait/weavewait
|
||||||
prog/weavewait/weavewait_noop
|
prog/weavewait/weavewait_noop
|
||||||
prog/weavewait/weavewait_nomcast
|
prog/weavewait/weavewait_nomcast
|
||||||
prog/netcheck/netcheck
|
prog/weaveutil/weaveutil
|
||||||
prog/docker_tls_args/docker_tls_args
|
|
||||||
prog/plugin/plugin
|
prog/plugin/plugin
|
||||||
testing/cover/cover
|
testing/cover/cover
|
||||||
testing/runner/runner
|
testing/runner/runner
|
||||||
releases
|
releases
|
||||||
.weaver.uptodate
|
.*.uptodate
|
||||||
.weavedns.uptodate
|
|
||||||
.weaveexec.uptodate
|
|
||||||
.dockerplugin.uptodate
|
|
||||||
weave.tar.gz
|
weave.tar.gz
|
||||||
prog/weaveexec/weave
|
prog/weaveexec/weave
|
||||||
prog/weaveexec/weavehosts
|
prog/weaveexec/weavehosts
|
||||||
@@ -59,8 +56,7 @@ prog/weaveexec/weavewait
|
|||||||
prog/weaveexec/weavewait_noop
|
prog/weaveexec/weavewait_noop
|
||||||
prog/weaveexec/weavewait_nomcast
|
prog/weaveexec/weavewait_nomcast
|
||||||
prog/weaveexec/sigproxy
|
prog/weaveexec/sigproxy
|
||||||
prog/weaveexec/netcheck
|
prog/weaveexec/weaveutil
|
||||||
prog/weaveexec/docker_tls_args
|
|
||||||
prog/weaveexec/docker*.tgz
|
prog/weaveexec/docker*.tgz
|
||||||
Vagrantfile.local
|
Vagrantfile.local
|
||||||
test/tls/tls
|
test/tls/tls
|
||||||
|
|||||||
+69
@@ -1,3 +1,72 @@
|
|||||||
[submodule "tools"]
|
[submodule "tools"]
|
||||||
path = tools
|
path = tools
|
||||||
url = https://github.com/weaveworks/build-tools
|
url = https://github.com/weaveworks/build-tools
|
||||||
|
[submodule "vendor/github.com/vishvananda/netlink"]
|
||||||
|
path = vendor/github.com/vishvananda/netlink
|
||||||
|
url = https://github.com/vishvananda/netlink.git
|
||||||
|
[submodule "vendor/github.com/davecheney/profile"]
|
||||||
|
path = vendor/github.com/davecheney/profile
|
||||||
|
url = https://github.com/davecheney/profile.git
|
||||||
|
[submodule "vendor/github.com/gorilla/mux"]
|
||||||
|
path = vendor/github.com/gorilla/mux
|
||||||
|
url = https://github.com/gorilla/mux.git
|
||||||
|
[submodule "vendor/github.com/gorilla/context"]
|
||||||
|
path = vendor/github.com/gorilla/context
|
||||||
|
url = https://github.com/gorilla/context.git
|
||||||
|
[submodule "vendor/github.com/google/gopacket"]
|
||||||
|
path = vendor/github.com/google/gopacket
|
||||||
|
url = https://github.com/google/gopacket.git
|
||||||
|
[submodule "vendor/github.com/weaveworks/go-odp"]
|
||||||
|
path = vendor/github.com/weaveworks/go-odp
|
||||||
|
url = https://github.com/weaveworks/go-odp.git
|
||||||
|
[submodule "vendor/github.com/opencontainers/runc"]
|
||||||
|
path = vendor/github.com/opencontainers/runc
|
||||||
|
url = https://github.com/opencontainers/runc.git
|
||||||
|
[submodule "vendor/github.com/fsouza/go-dockerclient"]
|
||||||
|
path = vendor/github.com/fsouza/go-dockerclient
|
||||||
|
url = https://github.com/fsouza/go-dockerclient.git
|
||||||
|
[submodule "vendor/github.com/docker/libnetwork"]
|
||||||
|
path = vendor/github.com/docker/libnetwork
|
||||||
|
url = https://github.com/docker/libnetwork.git
|
||||||
|
[submodule "vendor/github.com/docker/docker"]
|
||||||
|
path = vendor/github.com/docker/docker
|
||||||
|
url = https://github.com/docker/docker.git
|
||||||
|
[submodule "vendor/github.com/Sirupsen/logrus"]
|
||||||
|
path = vendor/github.com/Sirupsen/logrus
|
||||||
|
url = https://github.com/Sirupsen/logrus.git
|
||||||
|
[submodule "vendor/github.com/andybalholm/go-bit"]
|
||||||
|
path = vendor/github.com/andybalholm/go-bit
|
||||||
|
url = https://github.com/andybalholm/go-bit.git
|
||||||
|
[submodule "vendor/github.com/miekg/dns"]
|
||||||
|
path = vendor/github.com/miekg/dns
|
||||||
|
url = https://github.com/miekg/dns.git
|
||||||
|
[submodule "vendor/github.com/stretchr/testify"]
|
||||||
|
path = vendor/github.com/stretchr/testify
|
||||||
|
url = https://github.com/stretchr/testify.git
|
||||||
|
[submodule "vendor/golang.org/x/crypto"]
|
||||||
|
path = vendor/golang.org/x/crypto
|
||||||
|
url = https://github.com/golang/crypto.git
|
||||||
|
[submodule "vendor/github.com/docker/machine"]
|
||||||
|
path = vendor/github.com/docker/machine
|
||||||
|
url = https://github.com/docker/machine.git
|
||||||
|
[submodule "vendor/github.com/weaveworks/mesh"]
|
||||||
|
path = vendor/github.com/weaveworks/mesh
|
||||||
|
url = https://github.com/weaveworks/mesh
|
||||||
|
[submodule "vendor/github.com/vishvananda/netns"]
|
||||||
|
path = vendor/github.com/vishvananda/netns
|
||||||
|
url = https://github.com/vishvananda/netns.git
|
||||||
|
[submodule "vendor/github.com/boltdb/bolt"]
|
||||||
|
path = vendor/github.com/boltdb/bolt
|
||||||
|
url = https://github.com/boltdb/bolt
|
||||||
|
[submodule "vendor/github.com/weaveworks/go-checkpoint"]
|
||||||
|
path = vendor/github.com/weaveworks/go-checkpoint
|
||||||
|
url = https://github.com/weaveworks/go-checkpoint
|
||||||
|
[submodule "vendor/github.com/hashicorp/go-cleanhttp"]
|
||||||
|
path = vendor/github.com/hashicorp/go-cleanhttp
|
||||||
|
url = http://github.com/hashicorp/go-cleanhttp
|
||||||
|
[submodule "vendor/github.com/appc/cni"]
|
||||||
|
path = vendor/github.com/appc/cni
|
||||||
|
url = https://github.com/appc/cni
|
||||||
|
[submodule "vendor/github.com/coreos/go-iptables"]
|
||||||
|
path = vendor/github.com/coreos/go-iptables
|
||||||
|
url = https://github.com/coreos/go-iptables
|
||||||
-13
@@ -1,13 +0,0 @@
|
|||||||
language: python
|
|
||||||
sudo: false
|
|
||||||
|
|
||||||
env:
|
|
||||||
- PATH="${PATH}:${HOME}/gsutil"
|
|
||||||
|
|
||||||
install:
|
|
||||||
- pip install pyopenssl
|
|
||||||
- curl --silent --location https://storage.googleapis.com/pub/gsutil.tar.gz | tar xz -C $HOME
|
|
||||||
- bin/setup-ci-secrets $encrypted_5ba036e89377_key $encrypted_5ba036e89377_iv
|
|
||||||
|
|
||||||
script:
|
|
||||||
- 'test "${TRAVIS_PULL_REQUEST}" = "true" || site/build-and-publish.sh'
|
|
||||||
@@ -1,3 +1,52 @@
|
|||||||
|
## Release 1.5.1
|
||||||
|
|
||||||
|
Bug fixes and minor improvements
|
||||||
|
|
||||||
|
* Persisted data that was rendered invalid by changing peer name or
|
||||||
|
allocation range is detected and removed automatically, preventing
|
||||||
|
crashes and hangs #2246/#2209/#2249
|
||||||
|
* `weave rmpeer` persists the range takeover in case the peer on which
|
||||||
|
it was executed dies subsequently #2238
|
||||||
|
* Launching a container with an explicit `WEAVE_CIDR` in the
|
||||||
|
allocation range now waits instead of erroring if the allocator
|
||||||
|
hasn't finished initialising #2232/#2265
|
||||||
|
* Weave DNS now responds to AAAA queries with an empty answer section,
|
||||||
|
instead of NXDOMAIN which could be cached and block subsequent
|
||||||
|
resolution of A records #2244/#2252
|
||||||
|
* Many improvements to the documentation.
|
||||||
|
|
||||||
|
More details in the [change log](https://github.com/weaveworks/weave/issues?q=milestone%3A1.5.1).
|
||||||
|
|
||||||
|
## Release 1.5.0
|
||||||
|
|
||||||
|
## Highlights
|
||||||
|
|
||||||
|
- A new [Container Network Interface](https://github.com/appc/cni#cni---the-container-network-interface) plugin.
|
||||||
|
- This release is much more robust against unscheduled restarts,
|
||||||
|
because it persists key data to disk.
|
||||||
|
- New configuration options that are useful when you create or
|
||||||
|
auto-scale larger networks.
|
||||||
|
- Weave now periodically checks for updates (can be disabled)
|
||||||
|
|
||||||
|
Plus many bug fixes and minor enhancements. More details below and in
|
||||||
|
the [change log](https://github.com/weaveworks/weave/issues?q=milestone%3A1.5.0).
|
||||||
|
|
||||||
|
## Release 1.4.6
|
||||||
|
|
||||||
|
Fixes some issues encountered by our users.
|
||||||
|
|
||||||
|
* Restarting a peer could leave stale entries in WeaveDNS
|
||||||
|
#1867/#2023/#2081
|
||||||
|
* Weave proxy occasionally failing to attach any new containers
|
||||||
|
#2016/#2049
|
||||||
|
|
||||||
|
Other fixes:
|
||||||
|
|
||||||
|
* Resolved a crash when a restarting peer re-connected to a peer that
|
||||||
|
had not received the latest IPAM data #2083/#2092
|
||||||
|
* Make IP address space available immediately after a dead peer is
|
||||||
|
removed #2068
|
||||||
|
|
||||||
## Release 1.4.5
|
## Release 1.4.5
|
||||||
|
|
||||||
Higher performance for multicast and broadcast traffic when using
|
Higher performance for multicast and broadcast traffic when using
|
||||||
|
|||||||
@@ -176,7 +176,7 @@
|
|||||||
|
|
||||||
END OF TERMS AND CONDITIONS
|
END OF TERMS AND CONDITIONS
|
||||||
|
|
||||||
Copyright 2014-2015 Weaveworks Ltd.
|
Copyright 2014-2016 Weaveworks Ltd.
|
||||||
|
|
||||||
Licensed under the Apache License, Version 2.0 (the "License");
|
Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
you may not use this file except in compliance with the License.
|
you may not use this file except in compliance with the License.
|
||||||
|
|||||||
@@ -1,10 +1,14 @@
|
|||||||
PUBLISH=publish_weave publish_weaveexec publish_plugin
|
PUBLISH=publish_weave publish_weaveexec publish_plugin
|
||||||
|
|
||||||
.DEFAULT: all
|
.DEFAULT: all
|
||||||
.PHONY: all update tests lint publish $(PUBLISH) clean clean-bin prerequisites build travis run-smoketests
|
.PHONY: all exes testrunner update tests lint publish $(PUBLISH) clean clean-bin prerequisites build run-smoketests
|
||||||
|
|
||||||
# If you can use docker without being root, you can do "make SUDO="
|
# If you can use docker without being root, you can do "make SUDO="
|
||||||
SUDO=sudo
|
SUDO=sudo -E
|
||||||
|
BUILD_IN_CONTAINER=true
|
||||||
|
RM=--rm
|
||||||
|
RUN_FLAGS=-ti
|
||||||
|
COVERAGE=
|
||||||
|
|
||||||
DOCKERHUB_USER=weaveworks
|
DOCKERHUB_USER=weaveworks
|
||||||
WEAVE_VERSION=git-$(shell git rev-parse --short=12 HEAD)
|
WEAVE_VERSION=git-$(shell git rev-parse --short=12 HEAD)
|
||||||
@@ -15,25 +19,28 @@ SIGPROXY_EXE=prog/sigproxy/sigproxy
|
|||||||
WEAVEWAIT_EXE=prog/weavewait/weavewait
|
WEAVEWAIT_EXE=prog/weavewait/weavewait
|
||||||
WEAVEWAIT_NOOP_EXE=prog/weavewait/weavewait_noop
|
WEAVEWAIT_NOOP_EXE=prog/weavewait/weavewait_noop
|
||||||
WEAVEWAIT_NOMCAST_EXE=prog/weavewait/weavewait_nomcast
|
WEAVEWAIT_NOMCAST_EXE=prog/weavewait/weavewait_nomcast
|
||||||
NETCHECK_EXE=prog/netcheck/netcheck
|
WEAVEUTIL_EXE=prog/weaveutil/weaveutil
|
||||||
DOCKERTLSARGS_EXE=prog/docker_tls_args/docker_tls_args
|
PLUGIN_EXE=prog/plugin/plugin
|
||||||
DOCKERPLUGIN_EXE=prog/plugin/plugin
|
|
||||||
RUNNER_EXE=tools/runner/runner
|
RUNNER_EXE=tools/runner/runner
|
||||||
TEST_TLS_EXE=test/tls/tls
|
TEST_TLS_EXE=test/tls/tls
|
||||||
|
|
||||||
EXES=$(WEAVER_EXE) $(SIGPROXY_EXE) $(WEAVEPROXY_EXE) $(WEAVEWAIT_EXE) $(WEAVEWAIT_NOOP_EXE) $(WEAVEWAIT_NOMCAST_EXE) $(NETCHECK_EXE) $(DOCKERTLSARGS_EXE) $(DOCKERPLUGIN_EXE) $(TEST_TLS_EXE)
|
EXES=$(WEAVER_EXE) $(SIGPROXY_EXE) $(WEAVEPROXY_EXE) $(WEAVEWAIT_EXE) $(WEAVEWAIT_NOOP_EXE) $(WEAVEWAIT_NOMCAST_EXE) $(WEAVEUTIL_EXE) $(PLUGIN_EXE) $(TEST_TLS_EXE)
|
||||||
|
|
||||||
|
BUILD_UPTODATE=.build.uptodate
|
||||||
WEAVER_UPTODATE=.weaver.uptodate
|
WEAVER_UPTODATE=.weaver.uptodate
|
||||||
WEAVEEXEC_UPTODATE=.weaveexec.uptodate
|
WEAVEEXEC_UPTODATE=.weaveexec.uptodate
|
||||||
DOCKERPLUGIN_UPTODATE=.dockerplugin.uptodate
|
PLUGIN_UPTODATE=.plugin.uptodate
|
||||||
|
WEAVEDB_UPTODATE=.weavedb.uptodate
|
||||||
|
|
||||||
IMAGES_UPTODATE=$(WEAVER_UPTODATE) $(WEAVEEXEC_UPTODATE) $(DOCKERPLUGIN_UPTODATE)
|
IMAGES_UPTODATE=$(WEAVER_UPTODATE) $(WEAVEEXEC_UPTODATE) $(PLUGIN_UPTODATE) $(BUILD_UPTODATE) $(WEAVEDB_UPTODATE)
|
||||||
|
|
||||||
WEAVER_IMAGE=$(DOCKERHUB_USER)/weave
|
WEAVER_IMAGE=$(DOCKERHUB_USER)/weave
|
||||||
WEAVEEXEC_IMAGE=$(DOCKERHUB_USER)/weaveexec
|
WEAVEEXEC_IMAGE=$(DOCKERHUB_USER)/weaveexec
|
||||||
DOCKERPLUGIN_IMAGE=$(DOCKERHUB_USER)/plugin
|
PLUGIN_IMAGE=$(DOCKERHUB_USER)/plugin
|
||||||
|
BUILD_IMAGE=$(DOCKERHUB_USER)/weavebuild
|
||||||
|
WEAVEDB_IMAGE=$(DOCKERHUB_USER)/weavedb
|
||||||
|
|
||||||
IMAGES=$(WEAVER_IMAGE) $(WEAVEEXEC_IMAGE) $(DOCKERPLUGIN_IMAGE)
|
IMAGES=$(WEAVER_IMAGE) $(WEAVEEXEC_IMAGE) $(PLUGIN_IMAGE) $(WEAVEDB_IMAGE)
|
||||||
|
|
||||||
WEAVE_EXPORT=weave.tar.gz
|
WEAVE_EXPORT=weave.tar.gz
|
||||||
|
|
||||||
@@ -48,79 +55,102 @@ NETGO_CHECK=@strings $@ | grep cgo_stub\\\.go >/dev/null || { \
|
|||||||
echo " sudo go install -tags netgo std"; \
|
echo " sudo go install -tags netgo std"; \
|
||||||
false; \
|
false; \
|
||||||
}
|
}
|
||||||
BUILD_FLAGS=-ldflags "-extldflags \"-static\" -X main.version $(WEAVE_VERSION)" -tags netgo
|
BUILD_FLAGS=-i -ldflags "-extldflags \"-static\" -X main.version=$(WEAVE_VERSION)" -tags netgo
|
||||||
|
|
||||||
PACKAGE_BASE=$(shell go list -e ./)
|
PACKAGE_BASE=$(shell go list -e ./)
|
||||||
|
|
||||||
all: $(WEAVE_EXPORT) $(RUNNER_EXE) $(TEST_TLS_EXE)
|
all: $(WEAVE_EXPORT)
|
||||||
|
exes: $(EXES)
|
||||||
|
testrunner: $(RUNNER_EXE) $(TEST_TLS_EXE)
|
||||||
|
|
||||||
travis: $(EXES)
|
$(EXES): $(BUILD_UPTODATE)
|
||||||
|
$(WEAVER_EXE) $(WEAVEPROXY_EXE) $(WEAVEUTIL_EXE): common/*.go common/*/*.go net/*.go net/*/*.go
|
||||||
|
$(WEAVER_EXE): router/*.go ipam/*.go ipam/*/*.go db/*.go nameserver/*.go prog/weaver/*.go
|
||||||
|
$(WEAVEPROXY_EXE): proxy/*.go prog/weaveproxy/*.go
|
||||||
|
$(WEAVEUTIL_EXE): prog/weaveutil/*.go
|
||||||
|
$(SIGPROXY_EXE): prog/sigproxy/*.go
|
||||||
|
$(PLUGIN_EXE): prog/plugin/*.go plugin/*/*.go api/*.go common/*.go common/docker/*.go
|
||||||
|
$(TEST_TLS_EXE): test/tls/*.go
|
||||||
|
$(WEAVEWAIT_NOOP_EXE): prog/weavewait/*.go
|
||||||
|
$(WEAVEWAIT_EXE): prog/weavewait/*.go net/*.go
|
||||||
|
$(WEAVEWAIT_NOMCAST_EXE): prog/weavewait/*.go net/*.go
|
||||||
|
tests: $(BUILD_UPTODATE) tools/.git
|
||||||
|
lint: $(BUILD_UPTODATE) tools/.git
|
||||||
|
|
||||||
update:
|
ifeq ($(BUILD_IN_CONTAINER),true)
|
||||||
go get -u -f -v -tags netgo $(addprefix ./,$(dir $(EXES)))
|
|
||||||
|
|
||||||
$(WEAVER_EXE) $(WEAVEPROXY_EXE): common/*.go common/*/*.go net/*.go
|
$(EXES) tests lint:
|
||||||
|
git submodule update --init
|
||||||
|
@mkdir -p $(shell pwd)/.pkg
|
||||||
|
$(SUDO) docker run $(RM) $(RUN_FLAGS) \
|
||||||
|
-v $(shell pwd):/go/src/github.com/weaveworks/weave \
|
||||||
|
-v $(shell pwd)/.pkg:/go/pkg \
|
||||||
|
-e GOARCH -e GOOS -e CIRCLECI -e CIRCLE_BUILD_NUM -e CIRCLE_NODE_TOTAL -e CIRCLE_NODE_INDEX -e COVERDIR -e SLOW \
|
||||||
|
$(BUILD_IMAGE) COVERAGE=$(COVERAGE) WEAVE_VERSION=$(WEAVE_VERSION) $@
|
||||||
|
|
||||||
|
else
|
||||||
|
|
||||||
|
$(WEAVER_EXE) $(WEAVEPROXY_EXE) $(PLUGIN_EXE):
|
||||||
ifeq ($(COVERAGE),true)
|
ifeq ($(COVERAGE),true)
|
||||||
$(eval COVERAGE_MODULES := $(shell (go list ./$(@D); go list -f '{{join .Deps "\n"}}' ./$(@D) | grep "^$(PACKAGE_BASE)/") | paste -s -d,))
|
go build -v $(BUILD_FLAGS) -o $@ ./$(@D)
|
||||||
go get -t -tags netgo ./$(@D)
|
$(eval COVERAGE_MODULES := $(shell (go list ./$(@D); go list -f '{{join .Deps "\n"}}' ./$(@D) | grep "^$(PACKAGE_BASE)/") | grep -v "^$(PACKAGE_BASE)/vendor/" | paste -s -d,))
|
||||||
go test -c -o ./$@ $(BUILD_FLAGS) -v -covermode=atomic -coverpkg $(COVERAGE_MODULES) ./$(@D)/
|
go test -c -o ./$@ $(BUILD_FLAGS) -v -covermode=atomic -coverpkg $(COVERAGE_MODULES) ./$(@D)/
|
||||||
else
|
else
|
||||||
go get -tags netgo ./$(@D)
|
|
||||||
go build $(BUILD_FLAGS) -o $@ ./$(@D)
|
go build $(BUILD_FLAGS) -o $@ ./$(@D)
|
||||||
endif
|
endif
|
||||||
$(NETGO_CHECK)
|
$(NETGO_CHECK)
|
||||||
|
|
||||||
$(NETCHECK_EXE): common/*.go common/*/*.go net/*.go
|
$(WEAVEUTIL_EXE):
|
||||||
go get -tags netgo ./$(@D)
|
|
||||||
go build $(BUILD_FLAGS) -o $@ ./$(@D)
|
go build $(BUILD_FLAGS) -o $@ ./$(@D)
|
||||||
$(NETGO_CHECK)
|
$(NETGO_CHECK)
|
||||||
|
|
||||||
$(WEAVER_EXE): router/*.go mesh/*.go ipam/*.go ipam/*/*.go nameserver/*.go prog/weaver/*.go
|
$(WEAVEWAIT_EXE):
|
||||||
$(WEAVEPROXY_EXE): proxy/*.go prog/weaveproxy/main.go
|
|
||||||
$(NETCHECK_EXE): prog/netcheck/netcheck.go
|
|
||||||
|
|
||||||
# These next programs need separate rules as they fail the netgo check in
|
|
||||||
# the main build stanza due to not importing net package
|
|
||||||
$(SIGPROXY_EXE): prog/sigproxy/main.go
|
|
||||||
$(DOCKERTLSARGS_EXE): prog/docker_tls_args/*.go
|
|
||||||
$(DOCKERPLUGIN_EXE): prog/plugin/*.go plugin/net/*.go plugin/ipam/*.go plugin/skel/*.go api/*.go common/docker/*.go
|
|
||||||
$(TEST_TLS_EXE): test/tls/*.go
|
|
||||||
|
|
||||||
$(SIGPROXY_EXE) $(DOCKERTLSARGS_EXE) $(DOCKERPLUGIN_EXE) $(TEST_TLS_EXE):
|
|
||||||
go get -tags netgo ./$(@D)
|
|
||||||
go build $(BUILD_FLAGS) -o $@ ./$(@D)
|
|
||||||
|
|
||||||
$(WEAVEWAIT_EXE): prog/weavewait/*.go net/*.go
|
|
||||||
go get -tags netgo ./$(@D)
|
|
||||||
go build $(BUILD_FLAGS) -tags "netgo iface mcast" -o $@ ./$(@D)
|
go build $(BUILD_FLAGS) -tags "netgo iface mcast" -o $@ ./$(@D)
|
||||||
|
$(NETGO_CHECK)
|
||||||
|
|
||||||
$(WEAVEWAIT_NOMCAST_EXE): prog/weavewait/*.go net/*.go
|
$(WEAVEWAIT_NOMCAST_EXE):
|
||||||
go get -tags netgo ./$(@D)
|
|
||||||
go build $(BUILD_FLAGS) -tags "netgo iface" -o $@ ./$(@D)
|
go build $(BUILD_FLAGS) -tags "netgo iface" -o $@ ./$(@D)
|
||||||
|
$(NETGO_CHECK)
|
||||||
|
|
||||||
$(WEAVEWAIT_NOOP_EXE): prog/weavewait/*.go
|
# These programs need a separate rule as they fail the netgo check in
|
||||||
go get -tags netgo ./$(@D)
|
# the main build stanza due to not importing net package
|
||||||
|
$(SIGPROXY_EXE) $(TEST_TLS_EXE) $(WEAVEWAIT_NOOP_EXE):
|
||||||
go build $(BUILD_FLAGS) -o $@ ./$(@D)
|
go build $(BUILD_FLAGS) -o $@ ./$(@D)
|
||||||
|
|
||||||
|
tests:
|
||||||
|
./tools/test -no-go-get
|
||||||
|
|
||||||
|
lint:
|
||||||
|
./tools/lint -nocomment -notestpackage .
|
||||||
|
|
||||||
|
endif
|
||||||
|
|
||||||
|
$(BUILD_UPTODATE): build/*
|
||||||
|
$(SUDO) docker build -t $(BUILD_IMAGE) build/
|
||||||
|
touch $@
|
||||||
|
|
||||||
$(WEAVER_UPTODATE): prog/weaver/Dockerfile $(WEAVER_EXE)
|
$(WEAVER_UPTODATE): prog/weaver/Dockerfile $(WEAVER_EXE)
|
||||||
$(SUDO) DOCKER_HOST=$(DOCKER_HOST) docker build -t $(WEAVER_IMAGE) prog/weaver
|
$(SUDO) DOCKER_HOST=$(DOCKER_HOST) docker build -t $(WEAVER_IMAGE) prog/weaver
|
||||||
touch $@
|
touch $@
|
||||||
|
|
||||||
$(WEAVEEXEC_UPTODATE): prog/weaveexec/Dockerfile prog/weaveexec/symlink $(DOCKER_DISTRIB) weave $(SIGPROXY_EXE) $(WEAVEPROXY_EXE) $(WEAVEWAIT_EXE) $(WEAVEWAIT_NOOP_EXE) $(WEAVEWAIT_NOMCAST_EXE) $(NETCHECK_EXE) $(DOCKERTLSARGS_EXE)
|
$(WEAVEEXEC_UPTODATE): prog/weaveexec/Dockerfile prog/weaveexec/symlink $(DOCKER_DISTRIB) weave $(SIGPROXY_EXE) $(WEAVEPROXY_EXE) $(WEAVEWAIT_EXE) $(WEAVEWAIT_NOOP_EXE) $(WEAVEWAIT_NOMCAST_EXE) $(WEAVEUTIL_EXE)
|
||||||
cp weave prog/weaveexec/weave
|
cp weave prog/weaveexec/weave
|
||||||
cp $(SIGPROXY_EXE) prog/weaveexec/sigproxy
|
cp $(SIGPROXY_EXE) prog/weaveexec/sigproxy
|
||||||
cp $(WEAVEPROXY_EXE) prog/weaveexec/weaveproxy
|
cp $(WEAVEPROXY_EXE) prog/weaveexec/weaveproxy
|
||||||
cp $(WEAVEWAIT_EXE) prog/weaveexec/weavewait
|
cp $(WEAVEWAIT_EXE) prog/weaveexec/weavewait
|
||||||
cp $(WEAVEWAIT_NOOP_EXE) prog/weaveexec/weavewait_noop
|
cp $(WEAVEWAIT_NOOP_EXE) prog/weaveexec/weavewait_noop
|
||||||
cp $(WEAVEWAIT_NOMCAST_EXE) prog/weaveexec/weavewait_nomcast
|
cp $(WEAVEWAIT_NOMCAST_EXE) prog/weaveexec/weavewait_nomcast
|
||||||
cp $(NETCHECK_EXE) prog/weaveexec/netcheck
|
cp $(WEAVEUTIL_EXE) prog/weaveexec/weaveutil
|
||||||
cp $(DOCKERTLSARGS_EXE) prog/weaveexec/docker_tls_args
|
|
||||||
cp $(DOCKER_DISTRIB) prog/weaveexec/docker.tgz
|
cp $(DOCKER_DISTRIB) prog/weaveexec/docker.tgz
|
||||||
$(SUDO) DOCKER_HOST=$(DOCKER_HOST) docker build -t $(WEAVEEXEC_IMAGE) prog/weaveexec
|
$(SUDO) DOCKER_HOST=$(DOCKER_HOST) docker build -t $(WEAVEEXEC_IMAGE) prog/weaveexec
|
||||||
touch $@
|
touch $@
|
||||||
|
|
||||||
$(DOCKERPLUGIN_UPTODATE): prog/plugin/Dockerfile $(DOCKERPLUGIN_EXE) $(WEAVEEXEC_UPTODATE)
|
$(PLUGIN_UPTODATE): prog/plugin/Dockerfile $(PLUGIN_EXE) $(WEAVEEXEC_UPTODATE)
|
||||||
$(SUDO) docker build -t $(DOCKERPLUGIN_IMAGE) prog/plugin
|
$(SUDO) docker build -t $(PLUGIN_IMAGE) prog/plugin
|
||||||
|
touch $@
|
||||||
|
|
||||||
|
$(WEAVEDB_UPTODATE): prog/weavedb/Dockerfile
|
||||||
|
$(SUDO) docker build -t $(WEAVEDB_IMAGE) prog/weavedb
|
||||||
touch $@
|
touch $@
|
||||||
|
|
||||||
$(WEAVE_EXPORT): $(IMAGES_UPTODATE)
|
$(WEAVE_EXPORT): $(IMAGES_UPTODATE)
|
||||||
@@ -129,12 +159,6 @@ $(WEAVE_EXPORT): $(IMAGES_UPTODATE)
|
|||||||
$(DOCKER_DISTRIB):
|
$(DOCKER_DISTRIB):
|
||||||
curl -o $(DOCKER_DISTRIB) $(DOCKER_DISTRIB_URL)
|
curl -o $(DOCKER_DISTRIB) $(DOCKER_DISTRIB_URL)
|
||||||
|
|
||||||
tests: tools/.git
|
|
||||||
tools/test
|
|
||||||
|
|
||||||
lint: tools/.git
|
|
||||||
tools/lint -nocomment -notestpackage .
|
|
||||||
|
|
||||||
tools/.git:
|
tools/.git:
|
||||||
git submodule update --init
|
git submodule update --init
|
||||||
|
|
||||||
@@ -151,9 +175,8 @@ endif
|
|||||||
publish: $(PUBLISH)
|
publish: $(PUBLISH)
|
||||||
|
|
||||||
clean-bin:
|
clean-bin:
|
||||||
-$(SUDO) DOCKER_HOST=$(DOCKER_HOST) docker rmi $(IMAGES)
|
-$(SUDO) DOCKER_HOST=$(DOCKER_HOST) docker rmi $(IMAGES) $(BUILD_IMAGE)
|
||||||
go clean -r $(addprefix ./,$(dir $(EXES)))
|
rm -rf $(EXES) $(IMAGES_UPTODATE) $(WEAVE_EXPORT) .pkg
|
||||||
rm -f $(EXES) $(IMAGES_UPTODATE) $(WEAVE_EXPORT)
|
|
||||||
|
|
||||||
clean: clean-bin
|
clean: clean-bin
|
||||||
rm -rf test/tls/*.pem test/coverage.* test/coverage
|
rm -rf test/tls/*.pem test/coverage.* test/coverage
|
||||||
@@ -163,5 +186,5 @@ build:
|
|||||||
$(SUDO) go install -tags netgo std
|
$(SUDO) go install -tags netgo std
|
||||||
$(MAKE)
|
$(MAKE)
|
||||||
|
|
||||||
run-smoketests: all
|
run-smoketests: all testrunner
|
||||||
cd test && ./setup.sh && ./run_all.sh
|
cd test && ./setup.sh && ./run_all.sh
|
||||||
@@ -1,3 +1,3 @@
|
|||||||
Weave
|
Weave
|
||||||
Copyright 2014-2015 Weaveworks Ltd.
|
Copyright 2014-2016 Weaveworks Ltd.
|
||||||
This product includes software developed at Weaveworks Ltd.
|
This product includes software developed at Weaveworks Ltd.
|
||||||
@@ -1,174 +1,21 @@
|
|||||||
# Weave - weaving containers into applications
|
# Weave Net - Weaving Containers into Applications
|
||||||
|
|
||||||
[](https://travis-ci.org/weaveworks/weave) [](https://circleci.com/gh/weaveworks/weave) [](https://coveralls.io/r/weaveworks/weave)
|
[](https://travis-ci.org/weaveworks/weave) [](https://circleci.com/gh/weaveworks/weave) [](https://coveralls.io/r/weaveworks/weave)
|
||||||
|
|
||||||
# About Weaveworks
|
# About Weaveworks
|
||||||
|
|
||||||
[Weaveworks](http://weave.works) is the company that develops Weave -
|
[Weaveworks](https://www.weave.works) is the company that delivers the most productive way for developers to connect, observe and control
|
||||||
the most productive way for developers to connect, observe and control
|
Docker containers.
|
||||||
Docker containers. To learn about our products, including getting
|
|
||||||
started tutorials, visit our [website](http://weave.works) and
|
|
||||||
[documentation](http://docs.weave.works) or continue to read about
|
|
||||||
some of the more technical aspects of Weave in this readme.
|
|
||||||
|
|
||||||
# Weave
|
This repository contains [Weave Net](https://www.weave.works/products/weave-net/), the first product developed by Weaveworks, with nearly 5 million downloads to date, which enables users to get started with Docker clusters and portable apps in a fraction of the time compared with other solutions.
|
||||||
|
|
||||||
Weave creates a virtual network that connects Docker containers
|
Other products from Weaveworks include [Weave Scope](https://www.weave.works/products/weave-scope/), a powerful container monitoring tool that automatically maps Docker containers and their interactions, and [Weave Flux](https://www.weave.works/products/weave-flux/), a microservice router that automates the access of containers as services.
|
||||||
deployed across multiple hosts and enables their automatic discovery.
|
|
||||||
|
|
||||||

|
# Weave Net
|
||||||
|
|
||||||
Applications use the network just as if the containers were all
|
Weave Net creates a virtual network that connects Docker containers across multiple hosts and enables their automatic discovery. With Weave Net, portable microservices-based applications consisting of multiple containers can run anywhere: on one host, multiple hosts or even across cloud providers and data centers. Applications use the network just as if the containers were all plugged into the same network switch, without having to configure port mappings, ambassadors or links.
|
||||||
plugged into the same network switch, with no need to configure port
|
|
||||||
mappings, links, etc. Services provided by application containers on
|
|
||||||
the weave network can be made accessible to the outside world,
|
|
||||||
regardless of where those containers are running. Similarly, existing
|
|
||||||
internal systems can be exposed to application containers irrespective
|
|
||||||
of their location.
|
|
||||||
|
|
||||||

|
Services provided by application containers on the Weave network can be exposed to the outside world, regardless of where they are running. Similarly, existing internal systems can be opened to accept connections from application containers irrespective of their location.
|
||||||
|
|
||||||
Weave can traverse firewalls and operate in partially connected
|
* [Install Weave Net](https://www.weave.works/docs/net/latest/installing-weave/)
|
||||||
networks. Traffic can be encrypted, allowing hosts to be connected
|
* [Find out more about Weave Net](https://www.weave.works/products/weave-net/)
|
||||||
across an untrusted network.
|
|
||||||
|
|
||||||
With weave you can easily construct applications consisting of
|
|
||||||
multiple containers, running anywhere.
|
|
||||||
|
|
||||||
Weave works alongside Docker's existing (single host) networking
|
|
||||||
capabilities, so these can continue to be used by containers.
|
|
||||||
|
|
||||||
## Installation
|
|
||||||
|
|
||||||
Ensure you are running Linux (kernel 3.8 or later) and have Docker
|
|
||||||
(version 1.6.0 or later) installed. Then install weave with
|
|
||||||
|
|
||||||
sudo curl -L git.io/weave -o /usr/local/bin/weave
|
|
||||||
sudo chmod a+x /usr/local/bin/weave
|
|
||||||
|
|
||||||
For usage on OSX (with Docker Machine) you first need to make sure
|
|
||||||
that a VM is running and configured, as shown in [the Docker Machine
|
|
||||||
documentation](https://docs.docker.com/installation/mac/#from-your-shell).
|
|
||||||
Then you can launch weave directly from the OSX host.
|
|
||||||
|
|
||||||
CoreOS users see [here](https://github.com/fintanr/weave-gs/blob/master/coreos-simple/user-data) for an example of installing weave using cloud-config.
|
|
||||||
|
|
||||||
Amazon ECS users see
|
|
||||||
[here](https://github.com/weaveworks/guides/blob/master/aws-ecs/LATESTAMIs.md)
|
|
||||||
for the latest Weave AMIs and
|
|
||||||
[here](http://weave.works/guides/service-discovery-with-weave-aws-ecs.html) to get started with Weave on ECS.
|
|
||||||
|
|
||||||
Weave respects the environment variable `DOCKER_HOST`, so you can run
|
|
||||||
it locally to control a weave network on a remote host.
|
|
||||||
|
|
||||||
## Quick Start Screencast
|
|
||||||
|
|
||||||
<a href="https://youtu.be/kihQCCT1ykE" alt="Click to watch the screencast" target="_blank">
|
|
||||||
<img src="/docs/hello-screencast.png" />
|
|
||||||
</a>
|
|
||||||
|
|
||||||
## Example
|
|
||||||
|
|
||||||
Say you have docker running on two hosts, accessible to each other as
|
|
||||||
`$HOST1` and `$HOST2`, and want to deploy an application consisting of
|
|
||||||
two containers, one on each host.
|
|
||||||
|
|
||||||
On $HOST1 we run:
|
|
||||||
|
|
||||||
host1$ weave launch
|
|
||||||
host1$ eval $(weave env)
|
|
||||||
host1$ docker run --name a1 -ti ubuntu
|
|
||||||
|
|
||||||
> NB: If the first command results in an error like
|
|
||||||
> `http:///var/run/docker.sock/v1.19/containers/create: dial unix
|
|
||||||
> /var/run/docker.sock: permission denied. Are you trying to connect
|
|
||||||
> to a TLS-enabled daemon without TLS?` then you likely need to be
|
|
||||||
> 'root' in order to connect to the Docker daemon. If so, run the
|
|
||||||
> above and all subsequent commands in a *single* root shell (e.g. one
|
|
||||||
> created with `sudo -s`). Do *not* prefix individual commands with
|
|
||||||
> `sudo`, since some commands modify environment entries and hence
|
|
||||||
> they all need to be executed from the same shell.
|
|
||||||
|
|
||||||
The first line runs weave. The second line configures our environment
|
|
||||||
so that containers launched via the docker command line are
|
|
||||||
automatically attached to the weave network. Finally, we run our
|
|
||||||
application container.
|
|
||||||
|
|
||||||
That's it! If our application consists of more than one container on
|
|
||||||
this host we simply launch them with `docker run` as appropriate.
|
|
||||||
|
|
||||||
Next we repeat similar steps on `$HOST2`...
|
|
||||||
|
|
||||||
host2$ weave launch $HOST1
|
|
||||||
host2$ eval $(weave env)
|
|
||||||
host2$ docker run --name a2 -ti ubuntu
|
|
||||||
|
|
||||||
The only difference, apart from the name of the application container,
|
|
||||||
is that we tell our weave that it should peer with the weave on
|
|
||||||
`$HOST1` (specified as the IP address or hostname, and optional
|
|
||||||
`:port`, by which `$HOST2` can reach it). NB: if there is a firewall
|
|
||||||
between `$HOST1` and `$HOST2`, you must permit traffic to the weave
|
|
||||||
control port (TCP 6783) and data ports (UDP 6783/6784).
|
|
||||||
|
|
||||||
Note that we could instead have told the weave on `$HOST1` to connect to
|
|
||||||
`$HOST2`, or told both about each other. Order does not matter here;
|
|
||||||
weave automatically (re)connects to peers when they become
|
|
||||||
available. Also, we can tell weave to connect to multiple peers by
|
|
||||||
supplying multiple addresses, separated by spaces. And we can
|
|
||||||
[add peers dynamically](http://docs.weave.works/weave/latest_release/features.html#dynamic-topologies).
|
|
||||||
|
|
||||||
Weave must be started once per host. The relevant container images are
|
|
||||||
pulled down on demand, but if you wish you can preload them by running
|
|
||||||
`weave setup` - this is particularly useful for automated deployments,
|
|
||||||
and ensures that there are no delays during later operations.
|
|
||||||
|
|
||||||
Now that we've got everything set up, let's see whether our containers
|
|
||||||
can talk to each other...
|
|
||||||
|
|
||||||
In the container started on `$HOST1`...
|
|
||||||
|
|
||||||
root@a1:/# ping -c 1 -q a2
|
|
||||||
PING a2.weave.local (10.40.0.2) 56(84) bytes of data.
|
|
||||||
--- a2.weave.local ping statistics ---
|
|
||||||
1 packets transmitted, 1 received, 0% packet loss, time 0ms
|
|
||||||
rtt min/avg/max/mdev = 0.341/0.341/0.341/0.000 ms
|
|
||||||
|
|
||||||
Similarly, in the container started on `$HOST2`...
|
|
||||||
|
|
||||||
root@a2:/# ping -c 1 -q a1
|
|
||||||
PING a1.weave.local (10.32.0.2) 56(84) bytes of data.
|
|
||||||
--- a1.weave.local ping statistics ---
|
|
||||||
1 packets transmitted, 1 received, 0% packet loss, time 0ms
|
|
||||||
rtt min/avg/max/mdev = 0.366/0.366/0.366/0.000 ms
|
|
||||||
|
|
||||||
So there we have it, two containers on separate hosts happily talking
|
|
||||||
to each other.
|
|
||||||
|
|
||||||
## Find out more
|
|
||||||
|
|
||||||
* [Documentation homepage](http://docs.weave.works/weave/latest_release/)
|
|
||||||
* [Getting Started Guides](http://weave.works/guides/)
|
|
||||||
* [Features](http://docs.weave.works/weave/latest_release/features.html)
|
|
||||||
* [Troubleshooting](http://docs.weave.works/weave/latest_release/troubleshooting.html)
|
|
||||||
* [Building](http://docs.weave.works/weave/latest_release/building.html)
|
|
||||||
* [How it works](http://docs.weave.works/weave/latest_release/how-it-works.html)
|
|
||||||
|
|
||||||
## Contact Us
|
|
||||||
|
|
||||||
Found a bug, want to suggest a feature, or have a question? You can
|
|
||||||
[File an issue](https://github.com/weaveworks/weave/issues). And
|
|
||||||
there is a [Weave Users Google
|
|
||||||
Group](https://groups.google.com/a/weave.works/forum/#!forum/weave-users),
|
|
||||||
which you can post to by email at weave-users@weave.works. Or you can
|
|
||||||
contact Weaveworks directly at help@weave.works. When reporting a
|
|
||||||
bug, please include which version of weave you are running, as shown
|
|
||||||
by `weave version`.
|
|
||||||
|
|
||||||
Follow on Twitter:
|
|
||||||
[@weaveworks](https://twitter.com/weaveworks).
|
|
||||||
|
|
||||||
Read the Weave blog:
|
|
||||||
[Weaveblog](http://weaveblog.com/).
|
|
||||||
|
|
||||||
IRC:
|
|
||||||
[#weavenetwork](https://botbot.me/freenode/weavenetwork/)
|
|
||||||
Vendored
+2
-3
@@ -5,7 +5,7 @@ require './vagrant-common.rb'
|
|||||||
vm_ip = "172.16.0.3" # arbitrary private IP
|
vm_ip = "172.16.0.3" # arbitrary private IP
|
||||||
|
|
||||||
pkgs = %w(
|
pkgs = %w(
|
||||||
docker-engine
|
docker-engine=1.10.2-0~wily
|
||||||
aufs-tools
|
aufs-tools
|
||||||
build-essential
|
build-essential
|
||||||
ethtool
|
ethtool
|
||||||
@@ -18,8 +18,7 @@ pkgs = %w(
|
|||||||
|
|
||||||
Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
|
Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
|
||||||
|
|
||||||
config.vm.box = "ubuntu/ubuntu-15.04-amd64"
|
config.vm.box = "ubuntu/wily64"
|
||||||
config.vm.box_url = "https://cloud-images.ubuntu.com/vagrant/vivid/current/vivid-server-cloudimg-amd64-vagrant-disk1.box"
|
|
||||||
|
|
||||||
config.vm.network "private_network", ip: vm_ip
|
config.vm.network "private_network", ip: vm_ip
|
||||||
config.vm.provider :virtualbox do |vb|
|
config.vm.provider :virtualbox do |vb|
|
||||||
|
|||||||
@@ -5,6 +5,10 @@ import (
|
|||||||
"net/url"
|
"net/url"
|
||||||
)
|
)
|
||||||
|
|
||||||
|
func (client *Client) DNSDomain() (string, error) {
|
||||||
|
return client.httpVerb("GET", "/domain", nil)
|
||||||
|
}
|
||||||
|
|
||||||
func (client *Client) RegisterWithDNS(ID string, fqdn string, ip string) error {
|
func (client *Client) RegisterWithDNS(ID string, fqdn string, ip string) error {
|
||||||
data := url.Values{}
|
data := url.Values{}
|
||||||
data.Add("fqdn", fqdn)
|
data.Add("fqdn", fqdn)
|
||||||
|
|||||||
+17
-3
@@ -18,15 +18,29 @@ func (client *Client) AllocateIP(ID string) (*net.IPNet, error) {
|
|||||||
return client.ipamOp(ID, "POST")
|
return client.ipamOp(ID, "POST")
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func (client *Client) AllocateIPInSubnet(ID string, subnet *net.IPNet) (*net.IPNet, error) {
|
||||||
|
ip, err := client.httpVerb("POST", fmt.Sprintf("/ip/%s/%s", ID, subnet), nil)
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
return parseIP(ip)
|
||||||
|
}
|
||||||
|
|
||||||
// returns an IP for the ID given, or nil if one has not been
|
// returns an IP for the ID given, or nil if one has not been
|
||||||
// allocated
|
// allocated
|
||||||
func (client *Client) LookupIP(ID string) (*net.IPNet, error) {
|
func (client *Client) LookupIP(ID string) (*net.IPNet, error) {
|
||||||
return client.ipamOp(ID, "GET")
|
return client.ipamOp(ID, "GET")
|
||||||
}
|
}
|
||||||
|
|
||||||
// release an IP which is no longer needed
|
// Claim a specific IP on behalf of the ID
|
||||||
func (client *Client) ReleaseIP(ID string) error {
|
func (client *Client) ClaimIP(ID string, cidr *net.IPNet) error {
|
||||||
_, err := client.ipamOp(ID, "DELETE")
|
_, err := client.httpVerb("PUT", fmt.Sprintf("/ip/%s/%s", ID, cidr), nil)
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
// release all IPs owned by an ID
|
||||||
|
func (client *Client) ReleaseIPsFor(ID string) error {
|
||||||
|
_, err := client.httpVerb("DELETE", fmt.Sprintf("/ip/%s", ID), nil)
|
||||||
return err
|
return err
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
+42
-33
@@ -8,30 +8,21 @@ import (
|
|||||||
"net/http"
|
"net/http"
|
||||||
"net/url"
|
"net/url"
|
||||||
"strings"
|
"strings"
|
||||||
|
|
||||||
. "github.com/weaveworks/weave/common"
|
|
||||||
)
|
)
|
||||||
|
|
||||||
const (
|
const (
|
||||||
WeaveHttpPort = 6784
|
WeaveHTTPHost = "127.0.0.1"
|
||||||
|
WeaveHTTPPort = 6784
|
||||||
)
|
)
|
||||||
|
|
||||||
type Client struct {
|
type Client struct {
|
||||||
baseUrl string
|
baseURL string
|
||||||
resolve func() (string, error)
|
log Logger
|
||||||
}
|
}
|
||||||
|
|
||||||
func (client *Client) httpVerb(verb string, url string, values url.Values) (string, error) {
|
func (client *Client) httpVerb(verb string, url string, values url.Values) (string, error) {
|
||||||
baseUrl := client.baseUrl
|
url = client.baseURL + url
|
||||||
if client.resolve != nil {
|
client.log.Debugf("weave %s to %s with %v", verb, url, values)
|
||||||
addr, err := client.resolve()
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
baseUrl = fmt.Sprintf("http://%s:%d", addr, WeaveHttpPort)
|
|
||||||
}
|
|
||||||
url = baseUrl + url
|
|
||||||
Log.Debugf("weave %s to %s with %v", verb, url, values)
|
|
||||||
var body io.Reader
|
var body io.Reader
|
||||||
if values != nil {
|
if values != nil {
|
||||||
body = strings.NewReader(values.Encode())
|
body = strings.NewReader(values.Encode())
|
||||||
@@ -43,31 +34,49 @@ func (client *Client) httpVerb(verb string, url string, values url.Values) (stri
|
|||||||
if values != nil {
|
if values != nil {
|
||||||
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
|
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
|
||||||
}
|
}
|
||||||
if resp, err := http.DefaultClient.Do(req); err != nil {
|
resp, err := http.DefaultClient.Do(req)
|
||||||
|
if err != nil {
|
||||||
return "", err
|
return "", err
|
||||||
} else {
|
|
||||||
defer resp.Body.Close()
|
|
||||||
body, err := ioutil.ReadAll(resp.Body)
|
|
||||||
if err != nil {
|
|
||||||
return "", err
|
|
||||||
}
|
|
||||||
if resp.StatusCode == http.StatusOK || resp.StatusCode == http.StatusNoContent {
|
|
||||||
return string(body), nil
|
|
||||||
} else {
|
|
||||||
return "", errors.New(resp.Status + ": " + string(body))
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
defer resp.Body.Close()
|
||||||
|
rbody, err := ioutil.ReadAll(resp.Body)
|
||||||
|
if err != nil {
|
||||||
|
return "", err
|
||||||
|
}
|
||||||
|
if resp.StatusCode == http.StatusOK || resp.StatusCode == http.StatusNoContent {
|
||||||
|
return string(rbody), nil
|
||||||
|
}
|
||||||
|
return "", errors.New(resp.Status + ": " + string(rbody))
|
||||||
}
|
}
|
||||||
|
|
||||||
func NewClient(addr string) *Client {
|
func NewClient(addr string, log Logger) *Client {
|
||||||
return &Client{baseUrl: fmt.Sprintf("http://%s:%d", addr, WeaveHttpPort)}
|
host := WeaveHTTPHost
|
||||||
}
|
port := fmt.Sprintf("%d", WeaveHTTPPort)
|
||||||
|
switch parts := strings.Split(addr, ":"); len(parts) {
|
||||||
func NewClientWithResolver(resolver func() (string, error)) *Client {
|
case 0:
|
||||||
return &Client{resolve: resolver}
|
case 1:
|
||||||
|
if parts[0] != "" {
|
||||||
|
host = parts[0]
|
||||||
|
}
|
||||||
|
case 2:
|
||||||
|
if parts[0] != "" {
|
||||||
|
host = parts[0]
|
||||||
|
}
|
||||||
|
if parts[1] != "" {
|
||||||
|
port = parts[1]
|
||||||
|
}
|
||||||
|
default:
|
||||||
|
return &Client{baseURL: fmt.Sprintf("http://%s", addr), log: log}
|
||||||
|
}
|
||||||
|
return &Client{baseURL: fmt.Sprintf("http://%s:%s", host, port), log: log}
|
||||||
}
|
}
|
||||||
|
|
||||||
func (client *Client) Connect(remote string) error {
|
func (client *Client) Connect(remote string) error {
|
||||||
_, err := client.httpVerb("POST", "/connect", url.Values{"peer": {remote}})
|
_, err := client.httpVerb("POST", "/connect", url.Values{"peer": {remote}})
|
||||||
return err
|
return err
|
||||||
}
|
}
|
||||||
|
|
||||||
|
type Logger interface {
|
||||||
|
Infof(string, ...interface{})
|
||||||
|
Debugf(string, ...interface{})
|
||||||
|
}
|
||||||
+25
-14
@@ -14,7 +14,8 @@ set -e
|
|||||||
START=${FIRST_WEAVE:-1}
|
START=${FIRST_WEAVE:-1}
|
||||||
COUNT=${NUM_WEAVES:-28}
|
COUNT=${NUM_WEAVES:-28}
|
||||||
FINISH=$((START+COUNT-1))
|
FINISH=$((START+COUNT-1))
|
||||||
PORT=6783
|
|
||||||
|
SUBNET=192.168.7
|
||||||
|
|
||||||
weavedir=$(dirname $0)/..
|
weavedir=$(dirname $0)/..
|
||||||
|
|
||||||
@@ -26,32 +27,42 @@ random_mac() {
|
|||||||
od -txC -An -N6 /dev/urandom | ( read a b c d e f && printf "%02x:$b:$c:$d:$e:$f" $((0x$a & ~1 | 2)) )
|
od -txC -An -N6 /dev/urandom | ( read a b c d e f && printf "%02x:$b:$c:$d:$e:$f" $((0x$a & ~1 | 2)) )
|
||||||
}
|
}
|
||||||
|
|
||||||
|
weave() {
|
||||||
|
i=$1
|
||||||
|
shift
|
||||||
|
WEAVE_CONTAINER_NAME=weave$i WEAVE_HTTP_ADDR=$SUBNET.$i:6784 $weavedir/weave "$@"
|
||||||
|
}
|
||||||
|
|
||||||
case "$1" in
|
case "$1" in
|
||||||
launch)
|
launch)
|
||||||
shift 1
|
shift 1
|
||||||
echo $(date -R) launching
|
echo $(date -R) launching
|
||||||
|
ip link show multiweave >/dev/null 2>&1 || sudo ip link add name multiweave type bridge
|
||||||
for i in $(seq $START $FINISH); do
|
for i in $(seq $START $FINISH); do
|
||||||
WEAVE_CONTAINER_NAME=weave$i WEAVE_PORT=$((5000+i)) $weavedir/weave launch-router --iface '' --name $(random_mac) --nickname weave$i --port $PORT --no-dns "$@"
|
IP=$SUBNET.$i
|
||||||
|
sudo ip addr add $IP/24 dev multiweave
|
||||||
|
weave $i launch-router --datapath '' --iface '' --no-dns --host $IP \
|
||||||
|
--name $(random_mac) --nickname weave$i "$@"
|
||||||
done
|
done
|
||||||
if [ $START -ne 1 ] ; then
|
|
||||||
status=$(docker inspect --format='{{.State.Running}} {{.NetworkSettings.IPAddress}}' weave$((START-1)))
|
|
||||||
PREV="${status#true }"
|
|
||||||
fi
|
|
||||||
echo $(date -R) connecting
|
echo $(date -R) connecting
|
||||||
|
[ $START -gt 1 ] || START=2
|
||||||
for i in $(seq $START $FINISH); do
|
for i in $(seq $START $FINISH); do
|
||||||
if [ -n "$PREV" ] ; then
|
TO=$SUBNET.$((i-1))
|
||||||
echo connecting weave$i to $PREV
|
echo connecting weave$i to $TO
|
||||||
WEAVE_CONTAINER_NAME=weave$i $weavedir/weave connect $PREV
|
weave $i connect $TO
|
||||||
fi
|
|
||||||
status=$(docker inspect --format='{{.State.Running}} {{.NetworkSettings.IPAddress}}' weave$i)
|
|
||||||
PREV="${status#true }"
|
|
||||||
done
|
done
|
||||||
echo $(date -R) done
|
echo $(date -R) done
|
||||||
;;
|
;;
|
||||||
stop)
|
stop)
|
||||||
for i in $(seq $START $FINISH); do
|
for i in $(seq $FINISH -1 $START); do
|
||||||
|
IP=$SUBNET.$i
|
||||||
echo Stopping weave$i
|
echo Stopping weave$i
|
||||||
WEAVE_CONTAINER_NAME=weave$i $weavedir/weave stop-router
|
weave $i stop-router
|
||||||
|
sudo ip addr del $IP/24 dev multiweave || true
|
||||||
done
|
done
|
||||||
|
[ -z "$(ip -4 -o addr show multiweave)" ] && sudo ip link del multiweave
|
||||||
|
;;
|
||||||
|
*)
|
||||||
|
weave "$@"
|
||||||
;;
|
;;
|
||||||
esac
|
esac
|
||||||
Executable
+46
@@ -0,0 +1,46 @@
|
|||||||
|
#!/bin/bash
|
||||||
|
|
||||||
|
set -e
|
||||||
|
set -o pipefail
|
||||||
|
|
||||||
|
PRODUCT=net
|
||||||
|
|
||||||
|
fatal() {
|
||||||
|
echo "$@" >&2
|
||||||
|
exit 1
|
||||||
|
}
|
||||||
|
|
||||||
|
if [ ! -d .git ] ; then
|
||||||
|
fatal "Current directory is not a git clone"
|
||||||
|
fi
|
||||||
|
|
||||||
|
if ! BRANCH=$(git symbolic-ref --short HEAD) || [ -z "$BRANCH" ] ; then
|
||||||
|
fatal "Could not determine branch"
|
||||||
|
fi
|
||||||
|
|
||||||
|
case "$BRANCH" in
|
||||||
|
issues/*)
|
||||||
|
VERSION="${BRANCH#issues/}"
|
||||||
|
TAGS="$VERSION"
|
||||||
|
;;
|
||||||
|
*)
|
||||||
|
if echo "$BRANCH" | grep -qE '^[0-9]+\.[0-9]+' ; then
|
||||||
|
DESCRIBE=$(git describe --match 'v*')
|
||||||
|
if ! VERSION=$(echo "$DESCRIBE" | grep -oP '(?<=^v)[0-9]+\.[0-9]+\.[0-9]+') ; then
|
||||||
|
fatal "Could not infer latest $BRANCH version from $DESCRIBE"
|
||||||
|
fi
|
||||||
|
TAGS="$VERSION latest"
|
||||||
|
else
|
||||||
|
VERSION="$BRANCH"
|
||||||
|
TAGS="$VERSION"
|
||||||
|
fi
|
||||||
|
;;
|
||||||
|
esac
|
||||||
|
|
||||||
|
for TAG in $TAGS ; do
|
||||||
|
echo ">>> Publishing $PRODUCT $VERSION to $1/docs/$PRODUCT/$TAG"
|
||||||
|
wordepress \
|
||||||
|
--url "$1" --user "$2" --password "$3" \
|
||||||
|
--product "$PRODUCT" --version "$VERSION" --tag "$TAG" \
|
||||||
|
publish site
|
||||||
|
done
|
||||||
+6
-22
@@ -1,24 +1,8 @@
|
|||||||
FROM ubuntu
|
FROM golang:1.5.2
|
||||||
|
ENV GO15VENDOREXPERIMENT 1
|
||||||
RUN apt-get -y update && apt-get -y install --no-install-recommends ca-certificates apt-transport-https
|
RUN apt-get update && apt-get install -y libpcap-dev python-requests time file
|
||||||
RUN apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 36A1D7869245C8950F966E92D8576A8BA88D21E9
|
RUN go get github.com/golang/lint/golint github.com/fzipp/gocyclo github.com/client9/misspell/cmd/misspell
|
||||||
RUN echo deb https://get.docker.io/ubuntu docker main > /etc/apt/sources.list.d/docker.list
|
RUN go clean -i net && go install -tags netgo std
|
||||||
RUN apt-get -y update && apt-get -y install --no-install-recommends build-essential git lxc-docker-1.6.2 mercurial libpcap-dev curl make pkg-config gcc bison flex python-requests
|
RUN go install -race -tags netgo std
|
||||||
|
|
||||||
# When doing a build in a container, "apt-get update" happens twice,
|
|
||||||
# which can be a very significant overhead for incremental builds.
|
|
||||||
# And it's unnecessary, because if any of the prerequisites do change,
|
|
||||||
# the right thing to do is to rebuild the container image. Rather
|
|
||||||
# than suppressing the "apt-get update" commands explicitly, we clear
|
|
||||||
# out sources.list so that 'apt-get update' doesn't do anything.
|
|
||||||
RUN echo >/etc/apt/sources.list
|
|
||||||
|
|
||||||
ENV GO_VERSION 1.4.2
|
|
||||||
RUN curl -sSL https://golang.org/dl/go${GO_VERSION}.linux-amd64.tar.gz | tar -C /usr/local -xz
|
|
||||||
ENV PATH /usr/local/go/bin:$PATH
|
|
||||||
|
|
||||||
# So that sudo does not trample on PATH
|
|
||||||
RUN sed -ie '/secure_path/d' /etc/sudoers
|
|
||||||
|
|
||||||
COPY build.sh /
|
COPY build.sh /
|
||||||
ENTRYPOINT ["sh", "/build.sh"]
|
ENTRYPOINT ["sh", "/build.sh"]
|
||||||
+19
-36
@@ -1,45 +1,28 @@
|
|||||||
#!/bin/sh
|
#!/bin/sh
|
||||||
set -e
|
|
||||||
|
|
||||||
GOPATH=/home/go
|
set -eu
|
||||||
export GOPATH
|
|
||||||
|
|
||||||
WEAVE_SRC=$GOPATH/src/github.com/weaveworks/weave
|
WEAVE_SRC=$GOPATH/src/github.com/weaveworks/weave
|
||||||
|
|
||||||
if [ $# -eq 0 -o "$1" = "tests" ] ; then
|
if ! [ -e $WEAVE_SRC ] ; then
|
||||||
# No arguments. Expect that the weave repo will be bind-mounted
|
cat 2>&1 <<EOF
|
||||||
# into $GOPATH
|
Nothing at ${WEAVE_SRC}. Please bind-mount the weave repo with the
|
||||||
if ! [ -e $WEAVE_SRC ] ; then
|
|
||||||
cat 2>&1 <<EOF
|
|
||||||
No container arguments supplied, and nothing at ${WEAVE_SRC}. Please
|
|
||||||
either bind-mount the golang workspace containing weave with the
|
|
||||||
docker run -v option, e.g.:
|
docker run -v option, e.g.:
|
||||||
|
|
||||||
$ docker run -v <host gopath>:${GOPATH} \\
|
$ cd weave
|
||||||
-v /var/run/docker.sock:/var/run/docker.sock weaveworks/weave-build
|
$ docker run -v $(pwd):/go/src/github.com/weaveworks/weave \\
|
||||||
|
weaveworks/weave-build
|
||||||
Or supply git clone arguments to retrieve it, e.g.:
|
|
||||||
|
|
||||||
$ docker run -v /var/run/docker.sock:/var/run/docker.sock \\
|
|
||||||
weaveworks/weave-build https://github.com/weaveworks/weave.git
|
|
||||||
EOF
|
EOF
|
||||||
exit 1
|
|
||||||
fi
|
|
||||||
|
|
||||||
# If we run make directly, any files created on the bind mount
|
|
||||||
# will have awkward ownership. So we switch to a user with the
|
|
||||||
# same user and group IDs as source directory. We have to set a
|
|
||||||
# few things up so that sudo works without complaining later on.
|
|
||||||
uid=$(stat --format="%u" $WEAVE_SRC)
|
|
||||||
gid=$(stat --format="%g" $WEAVE_SRC)
|
|
||||||
echo "weave:x:$uid:$gid::$WEAVE_SRC:/bin/sh" >>/etc/passwd
|
|
||||||
echo "weave:*:::::::" >>/etc/shadow
|
|
||||||
echo "weave ALL=(ALL) NOPASSWD: ALL" >>/etc/sudoers
|
|
||||||
|
|
||||||
su weave -c "PATH=$PATH make -C $WEAVE_SRC build"
|
|
||||||
else
|
|
||||||
# There are arguments to pass to git-clone
|
|
||||||
mkdir -p ${WEAVE_SRC%/*}
|
|
||||||
git clone "$@" $WEAVE_SRC
|
|
||||||
make -C $WEAVE_SRC build
|
|
||||||
fi
|
fi
|
||||||
|
|
||||||
|
# If we run make directly, any files created on the bind mount
|
||||||
|
# will have awkward ownership. So we switch to a user with the
|
||||||
|
# same user and group IDs as source directory. We have to set a
|
||||||
|
# few things up so that sudo works without complaining later on.
|
||||||
|
uid=$(stat --format="%u" $WEAVE_SRC)
|
||||||
|
gid=$(stat --format="%g" $WEAVE_SRC)
|
||||||
|
echo "weave:x:$uid:$gid::$WEAVE_SRC:/bin/sh" >>/etc/passwd
|
||||||
|
echo "weave:*:::::::" >>/etc/shadow
|
||||||
|
echo "weave ALL=(ALL) NOPASSWD: ALL" >>/etc/sudoers
|
||||||
|
|
||||||
|
su weave -c "PATH=$PATH make -C $WEAVE_SRC BUILD_IN_CONTAINER=false $*"
|
||||||
+25
-20
@@ -12,62 +12,67 @@ machine:
|
|||||||
SRCDIR: /home/ubuntu/src/github.com/weaveworks/weave
|
SRCDIR: /home/ubuntu/src/github.com/weaveworks/weave
|
||||||
PATH: $PATH:$HOME/.local/bin:$HOME/google-cloud-sdk/bin/
|
PATH: $PATH:$HOME/.local/bin:$HOME/google-cloud-sdk/bin/
|
||||||
CLOUDSDK_CORE_DISABLE_PROMPTS: 1
|
CLOUDSDK_CORE_DISABLE_PROMPTS: 1
|
||||||
WEAVE_TEST: $HOME/docker/weave-test.tar
|
|
||||||
|
|
||||||
dependencies:
|
dependencies:
|
||||||
cache_directories:
|
cache_directories:
|
||||||
- "~/docker"
|
- "~/docker"
|
||||||
override:
|
|
||||||
- if [[ -e "$WEAVE_TEST" ]]; then
|
|
||||||
docker load -i $WEAVE_TEST;
|
|
||||||
else
|
|
||||||
docker build -t weaveworks/weave-build build;
|
|
||||||
docker build -t weaveworks/weave-test test/image;
|
|
||||||
mkdir -p $(dirname "$WEAVE_TEST");
|
|
||||||
docker save weaveworks/weave-test >$WEAVE_TEST;
|
|
||||||
fi
|
|
||||||
post:
|
post:
|
||||||
- sudo apt-get update && sudo apt-get install bc jq && pip install requests
|
- "sudo apt-get update && sudo apt-get install bc jq"
|
||||||
- curl https://sdk.cloud.google.com | bash
|
- curl https://sdk.cloud.google.com | bash
|
||||||
- bin/setup-circleci-secrets "$SECRET_PASSWORD"
|
- bin/setup-circleci-secrets "$SECRET_PASSWORD"
|
||||||
- mkdir -p $(dirname $SRCDIR) && cp -r $(pwd)/ $SRCDIR
|
- "mkdir -p $(dirname $SRCDIR) && cp -r $(pwd)/ $SRCDIR"
|
||||||
|
- "cd $SRCDIR; git submodule update --init"
|
||||||
- cd $SRCDIR/test; ./gce.sh make_template:
|
- cd $SRCDIR/test; ./gce.sh make_template:
|
||||||
parallel: false
|
parallel: false
|
||||||
|
- "cd $SRCDIR/build; ../tools/rebuild-image weaveworks/weavebuild . Dockerfile build.sh && touch $SRCDIR/.build.uptodate"
|
||||||
|
|
||||||
test:
|
test:
|
||||||
override:
|
override:
|
||||||
- cd $SRCDIR; make lint:
|
- cd $SRCDIR; make lint:
|
||||||
parallel: true
|
parallel: true
|
||||||
- docker run -v /home/ubuntu:/home/go -e COVERDIR=test/coverage -e SLOW=true -e CIRCLECI -e CIRCLE_BUILD_NUM -e CIRCLE_NODE_TOTAL -e CIRCLE_NODE_INDEX weaveworks/weave-test:
|
- cd $SRCDIR; COVERDIR=test/coverage make RM= tests:
|
||||||
parallel: true
|
parallel: true
|
||||||
- docker run -v /var/run/docker.sock:/run/docker.sock -v /home/ubuntu:/home/go -e COVERAGE=true weaveworks/weave-build:
|
- cd $SRCDIR; make COVERAGE=true RM= all:
|
||||||
|
parallel: true
|
||||||
|
- cd $SRCDIR; make testrunner:
|
||||||
parallel: true
|
parallel: true
|
||||||
- cd $SRCDIR/test; ./gce.sh setup && eval $(./gce.sh hosts) && ./setup.sh:
|
- cd $SRCDIR/test; ./gce.sh setup && eval $(./gce.sh hosts) && ./setup.sh:
|
||||||
parallel: true
|
parallel: true
|
||||||
- cd $SRCDIR/test; eval $(./gce.sh hosts); export COVERAGE=true; ./run_all.sh:
|
- cd $SRCDIR/test; eval $(./gce.sh hosts); export COVERAGE=true; ./run_all.sh:
|
||||||
parallel: true
|
parallel: true
|
||||||
timeout: 300
|
timeout: 300
|
||||||
- cd $SRCDIR; make clean-bin:
|
|
||||||
parallel: true
|
|
||||||
- docker run -v /var/run/docker.sock:/run/docker.sock -v /home/ubuntu:/home/go weaveworks/weave-build:
|
|
||||||
parallel: true
|
|
||||||
post:
|
post:
|
||||||
- cd $SRCDIR/test; ./gce.sh destroy:
|
- cd $SRCDIR/test; ./gce.sh destroy:
|
||||||
parallel: true
|
parallel: true
|
||||||
|
- test "$CIRCLE_NODE_INDEX" != "0" || (cd $SRCDIR/test; ./gen_coverage_reports.sh):
|
||||||
|
parallel: true
|
||||||
|
|
||||||
teardown:
|
teardown:
|
||||||
pre:
|
pre:
|
||||||
- test "$CIRCLE_NODE_INDEX" != "0" || (cd $SRCDIR/test; ./gen_coverage_reports.sh):
|
|
||||||
parallel: true
|
|
||||||
- test "$CIRCLE_NODE_INDEX" != "0" || (go get github.com/mattn/goveralls && goveralls -repotoken $COVERALLS_REPO_TOKEN -coverprofile=$SRCDIR/test/profile.cov -service=circleci || true):
|
- test "$CIRCLE_NODE_INDEX" != "0" || (go get github.com/mattn/goveralls && goveralls -repotoken $COVERALLS_REPO_TOKEN -coverprofile=$SRCDIR/test/profile.cov -service=circleci || true):
|
||||||
parallel: true
|
parallel: true
|
||||||
- test "$CIRCLE_NODE_INDEX" != "0" || (cd $SRCDIR/test; cp coverage.* $CIRCLE_ARTIFACTS):
|
- test "$CIRCLE_NODE_INDEX" != "0" || (cd $SRCDIR/test; cp coverage.* $CIRCLE_ARTIFACTS):
|
||||||
parallel: true
|
parallel: true
|
||||||
|
|
||||||
deployment:
|
deployment:
|
||||||
|
release:
|
||||||
|
branch: /[0-9]+\.[0-9]+/
|
||||||
|
owner: weaveworks
|
||||||
|
commands:
|
||||||
|
- go get github.com/weaveworks/wordepress && cd /home/ubuntu/src/github.com/weaveworks/wordepress && git checkout v1.0.0 && cd cmd/wordepress && go get
|
||||||
|
- cd $SRCDIR; bin/publish-site "$WP_LIVE_URL" "$WP_LIVE_USER" "$WP_LIVE_PASSWORD"
|
||||||
hub:
|
hub:
|
||||||
branch: master
|
branch: master
|
||||||
owner: weaveworks
|
owner: weaveworks
|
||||||
commands:
|
commands:
|
||||||
- docker login -e $DOCKER_EMAIL -u $DOCKER_USER -p $DOCKER_PASS
|
- docker login -e $DOCKER_EMAIL -u $DOCKER_USER -p $DOCKER_PASS
|
||||||
|
- cd $SRCDIR; make clean-bin
|
||||||
- cd $SRCDIR; make publish
|
- cd $SRCDIR; make publish
|
||||||
|
- go get github.com/weaveworks/wordepress && cd /home/ubuntu/src/github.com/weaveworks/wordepress && git checkout v1.0.0 && cd cmd/wordepress && go get
|
||||||
|
- cd $SRCDIR; bin/publish-site "$WP_DEV_URL" "$WP_DEV_USER" "$WP_DEV_PASSWORD"
|
||||||
|
issues:
|
||||||
|
branch: /.*/
|
||||||
|
owner: weaveworks
|
||||||
|
commands:
|
||||||
|
- go get github.com/weaveworks/wordepress && cd /home/ubuntu/src/github.com/weaveworks/wordepress && git checkout v1.0.0 && cd cmd/wordepress && go get
|
||||||
|
- cd $SRCDIR; bin/publish-site "$WP_DEV_URL" "$WP_DEV_USER" "$WP_DEV_PASSWORD"
|
||||||
@@ -0,0 +1,43 @@
|
|||||||
|
package common
|
||||||
|
|
||||||
|
import "fmt"
|
||||||
|
import "io"
|
||||||
|
import "os"
|
||||||
|
|
||||||
|
// Configure the ARP cache parameters for the given interface. This
|
||||||
|
// makes containers react more quickly to a change in the MAC address
|
||||||
|
// associated with an IP address.
|
||||||
|
func ConfigureARPCache(name string) error {
|
||||||
|
if err := sysctl(fmt.Sprintf("net/ipv4/neigh/%s/base_reachable_time", name), "5"); err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
if err := sysctl(fmt.Sprintf("net/ipv4/neigh/%s/delay_first_probe_time", name), "2"); err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
if err := sysctl(fmt.Sprintf("net/ipv4/neigh/%s/ucast_solicit", name), "1"); err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func sysctl(variable, value string) error {
|
||||||
|
f, err := os.OpenFile(fmt.Sprintf("/proc/sys/%s", variable), os.O_WRONLY, 0)
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
n, err := io.WriteString(f, value)
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
if n < len(value) {
|
||||||
|
return io.ErrShortWrite
|
||||||
|
}
|
||||||
|
|
||||||
|
err = f.Close()
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
return nil
|
||||||
|
}
|
||||||
+100
-21
@@ -4,22 +4,36 @@ import (
|
|||||||
"errors"
|
"errors"
|
||||||
"fmt"
|
"fmt"
|
||||||
"strings"
|
"strings"
|
||||||
|
"time"
|
||||||
|
|
||||||
docker "github.com/fsouza/go-dockerclient"
|
docker "github.com/fsouza/go-dockerclient"
|
||||||
|
|
||||||
. "github.com/weaveworks/weave/common"
|
"github.com/weaveworks/weave/common"
|
||||||
|
)
|
||||||
|
|
||||||
|
const (
|
||||||
|
InitialInterval = 1 * time.Second
|
||||||
|
MaxInterval = 20 * time.Second
|
||||||
)
|
)
|
||||||
|
|
||||||
// An observer for container events
|
// An observer for container events
|
||||||
type ContainerObserver interface {
|
type ContainerObserver interface {
|
||||||
ContainerStarted(ident string)
|
ContainerStarted(ident string)
|
||||||
ContainerDied(ident string)
|
ContainerDied(ident string)
|
||||||
|
ContainerDestroyed(ident string)
|
||||||
}
|
}
|
||||||
|
|
||||||
type Client struct {
|
type Client struct {
|
||||||
*docker.Client
|
*docker.Client
|
||||||
}
|
}
|
||||||
|
|
||||||
|
type syncPair struct {
|
||||||
|
stop chan struct{}
|
||||||
|
done chan struct{}
|
||||||
|
}
|
||||||
|
|
||||||
|
type pendingStarts map[string]*syncPair
|
||||||
|
|
||||||
// NewClient creates a new Docker client and checks we can talk to Docker
|
// NewClient creates a new Docker client and checks we can talk to Docker
|
||||||
func NewClient(apiPath string) (*Client, error) {
|
func NewClient(apiPath string) (*Client, error) {
|
||||||
if apiPath != "" && !strings.Contains(apiPath, "://") {
|
if apiPath != "" && !strings.Contains(apiPath, "://") {
|
||||||
@@ -63,36 +77,97 @@ func (c *Client) checkWorking() error {
|
|||||||
}
|
}
|
||||||
|
|
||||||
func (c *Client) Info() string {
|
func (c *Client) Info() string {
|
||||||
if env, err := c.Version(); err != nil {
|
env, err := c.Version()
|
||||||
|
if err != nil {
|
||||||
return fmt.Sprintf("Docker API error: %s", err)
|
return fmt.Sprintf("Docker API error: %s", err)
|
||||||
} else {
|
|
||||||
return fmt.Sprintf("Docker API on %s: %v", c.Endpoint(), env)
|
|
||||||
}
|
}
|
||||||
|
return fmt.Sprintf("Docker API on %s: %v", c.Endpoint(), env)
|
||||||
}
|
}
|
||||||
|
|
||||||
// AddObserver adds an observer for docker events
|
// AddObserver adds an observer for docker events
|
||||||
func (c *Client) AddObserver(ob ContainerObserver) error {
|
func (c *Client) AddObserver(ob ContainerObserver) error {
|
||||||
events := make(chan *docker.APIEvents)
|
|
||||||
if err := c.AddEventListener(events); err != nil {
|
|
||||||
Log.Errorf("[docker] Unable to add listener to Docker API: %s", err)
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
go func() {
|
go func() {
|
||||||
for event := range events {
|
pending := make(pendingStarts)
|
||||||
switch event.Status {
|
retryInterval := InitialInterval
|
||||||
case "start":
|
for {
|
||||||
id := event.ID
|
events := make(chan *docker.APIEvents)
|
||||||
ob.ContainerStarted(id)
|
if err := c.AddEventListener(events); err != nil {
|
||||||
case "die":
|
c.errorf("Unable to add listener to Docker API: %s - retrying in %ds", err, retryInterval/time.Second)
|
||||||
id := event.ID
|
} else {
|
||||||
ob.ContainerDied(id)
|
start := time.Now()
|
||||||
|
for event := range events {
|
||||||
|
switch event.Status {
|
||||||
|
case "start":
|
||||||
|
pending.finish(event.ID)
|
||||||
|
pending.start(event.ID, c, ob)
|
||||||
|
case "die":
|
||||||
|
pending.finish(event.ID)
|
||||||
|
ob.ContainerDied(event.ID)
|
||||||
|
case "destroy":
|
||||||
|
pending.finish(event.ID)
|
||||||
|
ob.ContainerDestroyed(event.ID)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if time.Since(start) > retryInterval {
|
||||||
|
retryInterval = InitialInterval
|
||||||
|
}
|
||||||
|
c.errorf("Event listener channel closed - retrying subscription in %ds", retryInterval/time.Second)
|
||||||
|
}
|
||||||
|
time.Sleep(retryInterval)
|
||||||
|
retryInterval = retryInterval * 3 / 2
|
||||||
|
if retryInterval > MaxInterval {
|
||||||
|
retryInterval = MaxInterval
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}()
|
}()
|
||||||
return nil
|
return nil
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Docker sends a 'start' event before it has attempted to start the
|
||||||
|
// container. Delay notifying the observer until the container has a
|
||||||
|
// pid, or we are told to stop when a 'die' event arrives.
|
||||||
|
//
|
||||||
|
// Note we always deliver the event, even if the container seems to
|
||||||
|
// have gone away.
|
||||||
|
func (pending pendingStarts) start(id string, c *Client, ob ContainerObserver) {
|
||||||
|
sync := syncPair{make(chan struct{}), make(chan struct{})}
|
||||||
|
pending[id] = &sync
|
||||||
|
go func() {
|
||||||
|
defer close(sync.done)
|
||||||
|
defer ob.ContainerStarted(id)
|
||||||
|
for {
|
||||||
|
if container, err := c.InspectContainer(id); err != nil || container.State.Pid != 0 {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
select {
|
||||||
|
case <-sync.stop:
|
||||||
|
return
|
||||||
|
case <-time.After(200 * time.Millisecond):
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}()
|
||||||
|
}
|
||||||
|
|
||||||
|
func (pending pendingStarts) finish(id string) {
|
||||||
|
if sync, found := pending[id]; found {
|
||||||
|
close(sync.stop)
|
||||||
|
<-sync.done
|
||||||
|
delete(pending, id)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (c *Client) AllContainerIDs() ([]string, error) {
|
||||||
|
all, err := c.ListContainers(docker.ListContainersOptions{All: true})
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
var ids []string
|
||||||
|
for _, c := range all {
|
||||||
|
ids = append(ids, c.ID)
|
||||||
|
}
|
||||||
|
return ids, nil
|
||||||
|
}
|
||||||
|
|
||||||
// IsContainerNotRunning returns true if we have checked with Docker that the ID is not running
|
// IsContainerNotRunning returns true if we have checked with Docker that the ID is not running
|
||||||
func (c *Client) IsContainerNotRunning(idStr string) bool {
|
func (c *Client) IsContainerNotRunning(idStr string) bool {
|
||||||
container, err := c.InspectContainer(idStr)
|
container, err := c.InspectContainer(idStr)
|
||||||
@@ -102,7 +177,7 @@ func (c *Client) IsContainerNotRunning(idStr string) bool {
|
|||||||
if _, notThere := err.(*docker.NoSuchContainer); notThere {
|
if _, notThere := err.(*docker.NoSuchContainer); notThere {
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
Log.Errorf("[docker] Could not check container status: %s", err)
|
c.errorf("Could not check container status: %s", err)
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -110,13 +185,11 @@ func (c *Client) IsContainerNotRunning(idStr string) bool {
|
|||||||
// if it is on the Docker bridge network then that address; if on the host network
|
// if it is on the Docker bridge network then that address; if on the host network
|
||||||
// then localhost
|
// then localhost
|
||||||
func (c *Client) GetContainerIP(nameOrID string) (string, error) {
|
func (c *Client) GetContainerIP(nameOrID string) (string, error) {
|
||||||
Log.Debugf("Getting IP for container %s", nameOrID)
|
|
||||||
info, err := c.InspectContainer(nameOrID)
|
info, err := c.InspectContainer(nameOrID)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return "", err
|
return "", err
|
||||||
}
|
}
|
||||||
if info.NetworkSettings.Networks != nil {
|
if info.NetworkSettings.Networks != nil {
|
||||||
Log.Debugln("Networks: ", info.NetworkSettings.Networks)
|
|
||||||
if bridgeNetwork, ok := info.NetworkSettings.Networks["bridge"]; ok {
|
if bridgeNetwork, ok := info.NetworkSettings.Networks["bridge"]; ok {
|
||||||
return bridgeNetwork.IPAddress, nil
|
return bridgeNetwork.IPAddress, nil
|
||||||
} else if _, ok := info.NetworkSettings.Networks["host"]; ok {
|
} else if _, ok := info.NetworkSettings.Networks["host"]; ok {
|
||||||
@@ -130,3 +203,9 @@ func (c *Client) GetContainerIP(nameOrID string) (string, error) {
|
|||||||
}
|
}
|
||||||
return info.NetworkSettings.IPAddress, nil
|
return info.NetworkSettings.IPAddress, nil
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// logging
|
||||||
|
|
||||||
|
func (c *Client) errorf(fmt string, args ...interface{}) {
|
||||||
|
common.Log.Errorf("[docker] "+fmt, args...)
|
||||||
|
}
|
||||||
@@ -3,6 +3,7 @@ package common
|
|||||||
import (
|
import (
|
||||||
"bytes"
|
"bytes"
|
||||||
"fmt"
|
"fmt"
|
||||||
|
"log"
|
||||||
"strings"
|
"strings"
|
||||||
|
|
||||||
"github.com/Sirupsen/logrus"
|
"github.com/Sirupsen/logrus"
|
||||||
@@ -64,3 +65,23 @@ func CheckWarn(e error) {
|
|||||||
Log.Warnln(e)
|
Log.Warnln(e)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Adaptor type to go from Logrus to something expecting a standard library log.Logger
|
||||||
|
type logLogger struct {
|
||||||
|
logger *logrus.Logger
|
||||||
|
}
|
||||||
|
|
||||||
|
// io.Writer interface
|
||||||
|
func (l logLogger) Write(p []byte) (n int, err error) {
|
||||||
|
ln := len(p)
|
||||||
|
// Strip a trailing newline, because logrus formatter adds one
|
||||||
|
if ln > 0 && p[ln-1] == '\n' {
|
||||||
|
p = p[:ln-1]
|
||||||
|
}
|
||||||
|
l.logger.Info(string(p))
|
||||||
|
return ln, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func LogLogger() *log.Logger {
|
||||||
|
return log.New(logLogger{Log}, "", 0)
|
||||||
|
}
|
||||||
+9
-16
@@ -10,49 +10,45 @@ import (
|
|||||||
|
|
||||||
// ODP admin functionality
|
// ODP admin functionality
|
||||||
|
|
||||||
func CreateDatapath(dpname string) (err error, supported bool) {
|
func CreateDatapath(dpname string) (supported bool, err error) {
|
||||||
dpif, err := odp.NewDpif()
|
dpif, err := odp.NewDpif()
|
||||||
if err != nil {
|
if err != nil {
|
||||||
if odp.IsKernelLacksODPError(err) {
|
if odp.IsKernelLacksODPError(err) {
|
||||||
return nil, false
|
return false, nil
|
||||||
}
|
}
|
||||||
|
return true, err
|
||||||
return err, true
|
|
||||||
}
|
}
|
||||||
|
|
||||||
defer dpif.Close()
|
defer dpif.Close()
|
||||||
|
|
||||||
dp, err := dpif.CreateDatapath(dpname)
|
dp, err := dpif.CreateDatapath(dpname)
|
||||||
if err != nil && !odp.IsDatapathNameAlreadyExistsError(err) {
|
if err != nil && !odp.IsDatapathNameAlreadyExistsError(err) {
|
||||||
return err, true
|
return true, err
|
||||||
}
|
}
|
||||||
|
|
||||||
// Pick an ephemeral port number to use in probing for vxlan
|
// Pick an ephemeral port number to use in probing for vxlan
|
||||||
// support.
|
// support.
|
||||||
udpconn, err := net.ListenUDP("udp4", nil)
|
udpconn, err := net.ListenUDP("udp4", nil)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return err, true
|
return true, err
|
||||||
}
|
}
|
||||||
|
defer udpconn.Close()
|
||||||
|
|
||||||
// we leave the UDP socket open, so creating a vxlan vport on
|
// we leave the UDP socket open, so creating a vxlan vport on
|
||||||
// the same port number should fail. But that's fine: It's
|
// the same port number should fail. But that's fine: It's
|
||||||
// still sufficient to probe for support.
|
// still sufficient to probe for support.
|
||||||
portno := uint16(udpconn.LocalAddr().(*net.UDPAddr).Port)
|
portno := uint16(udpconn.LocalAddr().(*net.UDPAddr).Port)
|
||||||
vpid, err := dp.CreateVport(odp.NewVxlanVportSpec(
|
vpid, err := dp.CreateVport(odp.NewVxlanVportSpec(fmt.Sprintf("vxlan-%d", portno), portno))
|
||||||
fmt.Sprintf("vxlan-%d", portno), portno))
|
|
||||||
if nlerr, ok := err.(odp.NetlinkError); ok {
|
if nlerr, ok := err.(odp.NetlinkError); ok {
|
||||||
if syscall.Errno(nlerr) == syscall.EAFNOSUPPORT {
|
if syscall.Errno(nlerr) == syscall.EAFNOSUPPORT {
|
||||||
dp.Delete()
|
dp.Delete()
|
||||||
return fmt.Errorf("kernel does not have Open vSwitch VXLAN support"), false
|
return false, fmt.Errorf("kernel does not have Open vSwitch VXLAN support")
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
if err == nil {
|
if err == nil {
|
||||||
dp.DeleteVport(vpid)
|
dp.DeleteVport(vpid)
|
||||||
}
|
}
|
||||||
|
|
||||||
udpconn.Close()
|
return true, nil
|
||||||
return nil, true
|
|
||||||
}
|
}
|
||||||
|
|
||||||
func DeleteDatapath(dpname string) error {
|
func DeleteDatapath(dpname string) error {
|
||||||
@@ -60,7 +56,6 @@ func DeleteDatapath(dpname string) error {
|
|||||||
if err != nil {
|
if err != nil {
|
||||||
return err
|
return err
|
||||||
}
|
}
|
||||||
|
|
||||||
defer dpif.Close()
|
defer dpif.Close()
|
||||||
|
|
||||||
dp, err := dpif.LookupDatapath(dpname)
|
dp, err := dpif.LookupDatapath(dpname)
|
||||||
@@ -68,7 +63,6 @@ func DeleteDatapath(dpname string) error {
|
|||||||
if odp.IsNoSuchDatapathError(err) {
|
if odp.IsNoSuchDatapathError(err) {
|
||||||
return nil
|
return nil
|
||||||
}
|
}
|
||||||
|
|
||||||
return err
|
return err
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -80,7 +74,6 @@ func AddDatapathInterface(dpname string, ifname string) error {
|
|||||||
if err != nil {
|
if err != nil {
|
||||||
return err
|
return err
|
||||||
}
|
}
|
||||||
|
|
||||||
defer dpif.Close()
|
defer dpif.Close()
|
||||||
|
|
||||||
dp, err := dpif.LookupDatapath(dpname)
|
dp, err := dpif.LookupDatapath(dpname)
|
||||||
|
|||||||
+136
@@ -1,6 +1,12 @@
|
|||||||
package common
|
package common
|
||||||
|
|
||||||
import (
|
import (
|
||||||
|
"fmt"
|
||||||
|
"github.com/vishvananda/netlink"
|
||||||
|
"github.com/vishvananda/netns"
|
||||||
|
"net"
|
||||||
|
"os"
|
||||||
|
"runtime"
|
||||||
"strings"
|
"strings"
|
||||||
)
|
)
|
||||||
|
|
||||||
@@ -18,3 +24,133 @@ func ErrorMessages(errors []error) string {
|
|||||||
}
|
}
|
||||||
return strings.Join(result, "\n")
|
return strings.Join(result, "\n")
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func WithNetNS(ns netns.NsHandle, work func() error) error {
|
||||||
|
runtime.LockOSThread()
|
||||||
|
defer runtime.UnlockOSThread()
|
||||||
|
|
||||||
|
oldNs, err := netns.Get()
|
||||||
|
if err == nil {
|
||||||
|
defer oldNs.Close()
|
||||||
|
|
||||||
|
err = netns.Set(ns)
|
||||||
|
if err == nil {
|
||||||
|
defer netns.Set(oldNs)
|
||||||
|
|
||||||
|
err = work()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
type NetDev struct {
|
||||||
|
Name string
|
||||||
|
MAC net.HardwareAddr
|
||||||
|
CIDRs []*net.IPNet
|
||||||
|
}
|
||||||
|
|
||||||
|
// Search the network namespace of a process for interfaces matching a predicate
|
||||||
|
func FindNetDevs(processID int, match func(link netlink.Link) bool) ([]NetDev, error) {
|
||||||
|
var netDevs []NetDev
|
||||||
|
|
||||||
|
ns, err := netns.GetFromPid(processID)
|
||||||
|
if err != nil {
|
||||||
|
if os.IsNotExist(err) {
|
||||||
|
return nil, nil
|
||||||
|
}
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
defer ns.Close()
|
||||||
|
|
||||||
|
err = WithNetNS(ns, func() error {
|
||||||
|
return forEachLink(func(link netlink.Link) error {
|
||||||
|
if match(link) {
|
||||||
|
netDev, err := linkToNetDev(link)
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
netDevs = append(netDevs, *netDev)
|
||||||
|
}
|
||||||
|
return nil
|
||||||
|
})
|
||||||
|
})
|
||||||
|
|
||||||
|
return netDevs, err
|
||||||
|
}
|
||||||
|
|
||||||
|
func forEachLink(f func(netlink.Link) error) error {
|
||||||
|
links, err := netlink.LinkList()
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
for _, link := range links {
|
||||||
|
if err := f(link); err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func linkToNetDev(link netlink.Link) (*NetDev, error) {
|
||||||
|
addrs, err := netlink.AddrList(link, netlink.FAMILY_V4)
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
|
||||||
|
netDev := &NetDev{Name: link.Attrs().Name, MAC: link.Attrs().HardwareAddr}
|
||||||
|
for _, addr := range addrs {
|
||||||
|
netDev.CIDRs = append(netDev.CIDRs, addr.IPNet)
|
||||||
|
}
|
||||||
|
return netDev, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// Lookup the weave interface of a container
|
||||||
|
func GetWeaveNetDevs(processID int) ([]NetDev, error) {
|
||||||
|
// Bail out if this container is running in the root namespace
|
||||||
|
nsToplevel, err := netns.GetFromPid(1)
|
||||||
|
if err != nil {
|
||||||
|
return nil, fmt.Errorf("unable to open root namespace: %s", err)
|
||||||
|
}
|
||||||
|
nsContainr, err := netns.GetFromPid(processID)
|
||||||
|
if err != nil {
|
||||||
|
return nil, fmt.Errorf("unable to open process %d namespace: %s", processID, err)
|
||||||
|
}
|
||||||
|
if nsToplevel.Equal(nsContainr) {
|
||||||
|
return nil, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
weaveBridge, err := netlink.LinkByName("weave")
|
||||||
|
if err != nil {
|
||||||
|
return nil, fmt.Errorf("Cannot find weave bridge: %s", err)
|
||||||
|
}
|
||||||
|
// Scan devices in root namespace to find those attached to weave bridge
|
||||||
|
indexes := make(map[int]struct{})
|
||||||
|
err = forEachLink(func(link netlink.Link) error {
|
||||||
|
if link.Attrs().MasterIndex == weaveBridge.Attrs().Index {
|
||||||
|
peerIndex := link.Attrs().ParentIndex
|
||||||
|
if peerIndex == 0 {
|
||||||
|
// perhaps running on an older kernel where ParentIndex doesn't work.
|
||||||
|
// as fall-back, assume the indexes are consecutive
|
||||||
|
peerIndex = link.Attrs().Index - 1
|
||||||
|
}
|
||||||
|
indexes[peerIndex] = struct{}{}
|
||||||
|
}
|
||||||
|
return nil
|
||||||
|
})
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
return FindNetDevs(processID, func(link netlink.Link) bool {
|
||||||
|
_, isveth := link.(*netlink.Veth)
|
||||||
|
_, found := indexes[link.Attrs().Index]
|
||||||
|
return isveth && found
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
// Get the weave bridge interface
|
||||||
|
func GetBridgeNetDev(bridgeName string) ([]NetDev, error) {
|
||||||
|
return FindNetDevs(1, func(link netlink.Link) bool {
|
||||||
|
return link.Attrs().Name == bridgeName
|
||||||
|
})
|
||||||
|
}
|
||||||
@@ -0,0 +1,84 @@
|
|||||||
|
package db
|
||||||
|
|
||||||
|
import (
|
||||||
|
"bytes"
|
||||||
|
"encoding/gob"
|
||||||
|
"fmt"
|
||||||
|
|
||||||
|
"github.com/boltdb/bolt"
|
||||||
|
)
|
||||||
|
|
||||||
|
type DB interface {
|
||||||
|
Load(string, interface{}) (bool, error)
|
||||||
|
Save(string, interface{}) error
|
||||||
|
}
|
||||||
|
|
||||||
|
type BoltDB struct {
|
||||||
|
db *bolt.DB
|
||||||
|
}
|
||||||
|
|
||||||
|
var (
|
||||||
|
versionIdent = []byte("version")
|
||||||
|
persistenceVersion = []byte{1, 0} // major.minor
|
||||||
|
topBucket = []byte("top")
|
||||||
|
)
|
||||||
|
|
||||||
|
func NewBoltDB(dbPathname string) (*BoltDB, error) {
|
||||||
|
db, err := bolt.Open(dbPathname, 0660, nil)
|
||||||
|
if err != nil {
|
||||||
|
return nil, fmt.Errorf("[boltDB] Unable to open %s: %s", dbPathname, err)
|
||||||
|
}
|
||||||
|
// check the persistence version
|
||||||
|
err = db.Update(func(tx *bolt.Tx) error {
|
||||||
|
if top := tx.Bucket(topBucket); top == nil {
|
||||||
|
top, err := tx.CreateBucket(topBucket)
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
if err := top.Put(versionIdent, persistenceVersion); err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
if checkVersion := top.Get(versionIdent); checkVersion != nil {
|
||||||
|
if checkVersion[0] != persistenceVersion[0] {
|
||||||
|
return fmt.Errorf("[boltDB] Cannot use persistence file %s - version %x", dbPathname, checkVersion)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return nil
|
||||||
|
})
|
||||||
|
return &BoltDB{db: db}, err
|
||||||
|
}
|
||||||
|
|
||||||
|
func (d *BoltDB) Load(ident string, data interface{}) (bool, error) {
|
||||||
|
found := true
|
||||||
|
err := d.db.View(func(tx *bolt.Tx) error {
|
||||||
|
b := tx.Bucket(topBucket)
|
||||||
|
v := b.Get([]byte(ident))
|
||||||
|
if v == nil {
|
||||||
|
found = false
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
reader := bytes.NewReader(v)
|
||||||
|
decoder := gob.NewDecoder(reader)
|
||||||
|
err := decoder.Decode(data)
|
||||||
|
return err
|
||||||
|
})
|
||||||
|
return found, err
|
||||||
|
}
|
||||||
|
|
||||||
|
func (d *BoltDB) Save(ident string, data interface{}) error {
|
||||||
|
return d.db.Update(func(tx *bolt.Tx) error {
|
||||||
|
b := tx.Bucket(topBucket)
|
||||||
|
buf := new(bytes.Buffer)
|
||||||
|
enc := gob.NewEncoder(buf)
|
||||||
|
if err := enc.Encode(data); err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
return b.Put([]byte(ident), buf.Bytes())
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
func (d *BoltDB) Close() error {
|
||||||
|
return d.db.Close()
|
||||||
|
}
|
||||||
+3
-3
@@ -24,7 +24,7 @@ The router relies on having access to the source and destination peer
|
|||||||
when deciding how to forward packets. When the Sleeve overlay is in
|
when deciding how to forward packets. When the Sleeve overlay is in
|
||||||
use this information is conveyed directly within the encapsulation by
|
use this information is conveyed directly within the encapsulation by
|
||||||
including the names of the peers in question, a solution not
|
including the names of the peers in question, a solution not
|
||||||
accomodated directly by the vxlan wire format. Fortunately vxlan does
|
accommodated directly by the vxlan wire format. Fortunately vxlan does
|
||||||
have a twenty four bit segment ID field in the header we can use to
|
have a twenty four bit segment ID field in the header we can use to
|
||||||
encode this data - the challenge is to identify peers uniquely with a
|
encode this data - the challenge is to identify peers uniquely with a
|
||||||
twelve bit identifier instead of the seventeen bytes used by Sleeve.
|
twelve bit identifier instead of the seventeen bytes used by Sleeve.
|
||||||
@@ -54,8 +54,8 @@ with low path MTUs.
|
|||||||
To avoid triggering this fallback in typical deployments, the datapath
|
To avoid triggering this fallback in typical deployments, the datapath
|
||||||
interface is statically configured with an MTU of 1410 bytes allowing
|
interface is statically configured with an MTU of 1410 bytes allowing
|
||||||
it to work with most underlay network provider MTUs, including GCE at
|
it to work with most underlay network provider MTUs, including GCE at
|
||||||
1460 bytes (the fifty byte difference accomodates the vxlan overhead).
|
1460 bytes (the fifty byte difference accommodates the vxlan overhead).
|
||||||
This value can be overriden by setting `WEAVE_MTU` at launch if
|
This value can be overridden by setting `WEAVE_MTU` at launch if
|
||||||
necessary.
|
necessary.
|
||||||
|
|
||||||
# Virtual Ports
|
# Virtual Ports
|
||||||
|
|||||||
@@ -210,11 +210,3 @@ reached the peer that does the `rmpeer`, then we get an inconsistent
|
|||||||
ring. We could make it safe, up to partitions, by inquiring of every
|
ring. We could make it safe, up to partitions, by inquiring of every
|
||||||
live peer what its view of the dead peer is, and making sure we use
|
live peer what its view of the dead peer is, and making sure we use
|
||||||
the latest info.)
|
the latest info.)
|
||||||
|
|
||||||
## Limitations
|
|
||||||
|
|
||||||
Nothing is persisted. If one peer restarts it should receive gossip
|
|
||||||
from other peers showing what it used to own, and in that case it can
|
|
||||||
recover quite well. If, however, there are no peers left alive, or
|
|
||||||
this peer cannot establish network communication with those that are,
|
|
||||||
then it cannot recover.
|
|
||||||
+13
-2
@@ -7,6 +7,7 @@
|
|||||||
github-release](https://help.github.com/articles/creating-an-access-token-for-command-line-use/);
|
github-release](https://help.github.com/articles/creating-an-access-token-for-command-line-use/);
|
||||||
set and export `$GITHUB_TOKEN` with this value
|
set and export `$GITHUB_TOKEN` with this value
|
||||||
* Update all dependencies with `make update`
|
* Update all dependencies with `make update`
|
||||||
|
* Ensure you are still on the right branch, since Go may switch to `master` as part of `make update`
|
||||||
|
|
||||||
## Release Types
|
## Release Types
|
||||||
|
|
||||||
@@ -63,9 +64,10 @@ This has the following effects:
|
|||||||
## Draft Phase
|
## Draft Phase
|
||||||
### Push Version Tag Upstream
|
### Push Version Tag Upstream
|
||||||
|
|
||||||
First you must push your version tag upstream, so that an associated
|
First you must push your branch and version tag upstream, so that an
|
||||||
GitHub release may be created:
|
associated GitHub release may be created:
|
||||||
|
|
||||||
|
git push git@github.com:weaveworks/weave
|
||||||
git push git@github.com:weaveworks/weave $TAG
|
git push git@github.com:weaveworks/weave $TAG
|
||||||
|
|
||||||
N.B. if you're testing the release process, push to your fork
|
N.B. if you're testing the release process, push to your fork
|
||||||
@@ -128,6 +130,15 @@ Finally, for **Mainline** releases only:
|
|||||||
|
|
||||||
* Images tagged `latest` are updated on DockerHub
|
* Images tagged `latest` are updated on DockerHub
|
||||||
|
|
||||||
|
### Finish up
|
||||||
|
|
||||||
|
* If not on master, merge branch into master and push to GitHub.
|
||||||
|
* Merge the branch you are on into `latest_release_doc_updates` and push to GitHub.
|
||||||
|
* Close the [milestone](https://github.com/weaveworks/weave/milestones) in GitHub and create the next milestone
|
||||||
|
* Update the `#weavenetwork` topic heading on freenode (requires 'chanops' permission)
|
||||||
|
* For a mainline release vX.Y.0, create a release branch X.Y from the
|
||||||
|
tag and push to GitHub - this will result in X.Y.0 site docs being
|
||||||
|
published to https://www.weave.works
|
||||||
|
|
||||||
## Troubleshooting
|
## Troubleshooting
|
||||||
|
|
||||||
|
|||||||
@@ -9,7 +9,7 @@ The model is that each host has a service that is notified of
|
|||||||
hostnames and weave addresses for containers on the host. Like IPAM,
|
hostnames and weave addresses for containers on the host. Like IPAM,
|
||||||
this service is embedded within the router. It binds to
|
this service is embedded within the router. It binds to
|
||||||
the host bridge to answer DNS queries from local containers; for
|
the host bridge to answer DNS queries from local containers; for
|
||||||
anything it can't answer, it uses the infomation in the host's
|
anything it can't answer, it uses the information in the host's
|
||||||
/etc/resolv.conf to query an 'fallback' server.
|
/etc/resolv.conf to query an 'fallback' server.
|
||||||
|
|
||||||
The service is comprised of a DNS server, which answers all DNS queries
|
The service is comprised of a DNS server, which answers all DNS queries
|
||||||
@@ -33,7 +33,7 @@ are re-broadcast around the cluster.
|
|||||||
The DNS server also listens to the Docker event stream, and removes
|
The DNS server also listens to the Docker event stream, and removes
|
||||||
entries for containers when they die. Entries removed in this way are
|
entries for containers when they die. Entries removed in this way are
|
||||||
tombstoned, and the tombstone lazily broadcast around the cluster.
|
tombstoned, and the tombstone lazily broadcast around the cluster.
|
||||||
After a short timeout the tombstones are independantly removed from
|
After a short timeout the tombstones are independently removed from
|
||||||
each host.
|
each host.
|
||||||
|
|
||||||
|
|
||||||
+13
-10
@@ -14,7 +14,8 @@ type allocateResult struct {
|
|||||||
type allocate struct {
|
type allocate struct {
|
||||||
resultChan chan<- allocateResult
|
resultChan chan<- allocateResult
|
||||||
ident string
|
ident string
|
||||||
r address.Range // Range we are trying to allocate within
|
r address.CIDR // Subnet we are trying to allocate within
|
||||||
|
isContainer bool
|
||||||
hasBeenCancelled func() bool
|
hasBeenCancelled func() bool
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -25,34 +26,36 @@ func (g *allocate) Try(alloc *Allocator) bool {
|
|||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
|
|
||||||
if addr, found := alloc.lookupOwned(g.ident, g.r); found {
|
if addrs := alloc.ownedInRange(g.ident, g.r.Range()); len(addrs) > 0 {
|
||||||
g.resultChan <- allocateResult{addr, nil}
|
// If we had heard that this container died, resurrect it
|
||||||
|
delete(alloc.dead, g.ident) // delete is no-op if key not in map
|
||||||
|
g.resultChan <- allocateResult{addrs[0].Addr, nil}
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
|
|
||||||
if !alloc.universe.Overlaps(g.r) {
|
if !alloc.universe.Overlaps(g.r.Range()) {
|
||||||
g.resultChan <- allocateResult{0, fmt.Errorf("range %s out of bounds: %s", g.r, alloc.universe)}
|
g.resultChan <- allocateResult{err: fmt.Errorf("range %s out of bounds: %s", g.r, alloc.universe)}
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
|
|
||||||
alloc.establishRing()
|
alloc.establishRing()
|
||||||
|
|
||||||
if ok, addr := alloc.space.Allocate(g.r); ok {
|
if ok, addr := alloc.space.Allocate(g.r.HostRange()); ok {
|
||||||
// If caller hasn't supplied a unique ID, file it under the IP address
|
// If caller hasn't supplied a unique ID, file it under the IP address
|
||||||
// which lets the caller then release the address using DELETE /ip/address
|
// which lets the caller then release the address using DELETE /ip/address
|
||||||
if g.ident == "_" {
|
if g.ident == "_" {
|
||||||
g.ident = addr.String()
|
g.ident = addr.String()
|
||||||
}
|
}
|
||||||
alloc.debugln("Allocated", addr, "for", g.ident, "in", g.r)
|
alloc.debugln("Allocated", addr, "for", g.ident, "in", g.r)
|
||||||
alloc.addOwned(g.ident, addr)
|
alloc.addOwned(g.ident, address.MakeCIDR(g.r, addr), g.isContainer)
|
||||||
g.resultChan <- allocateResult{addr, nil}
|
g.resultChan <- allocateResult{addr, nil}
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
|
|
||||||
// out of space
|
// out of space
|
||||||
donors := alloc.ring.ChoosePeersToAskForSpace(g.r.Start, g.r.End)
|
donors := alloc.ring.ChoosePeersToAskForSpace(g.r.Addr, g.r.Range().End)
|
||||||
for _, donor := range donors {
|
for _, donor := range donors {
|
||||||
if err := alloc.sendSpaceRequest(donor, g.r); err != nil {
|
if err := alloc.sendSpaceRequest(donor, g.r.Range()); err != nil {
|
||||||
alloc.debugln("Problem asking peer", donor, "for space:", err)
|
alloc.debugln("Problem asking peer", donor, "for space:", err)
|
||||||
} else {
|
} else {
|
||||||
alloc.debugln("Decided to ask peer", donor, "for space in range", g.r)
|
alloc.debugln("Decided to ask peer", donor, "for space in range", g.r)
|
||||||
@@ -64,7 +67,7 @@ func (g *allocate) Try(alloc *Allocator) bool {
|
|||||||
}
|
}
|
||||||
|
|
||||||
func (g *allocate) Cancel() {
|
func (g *allocate) Cancel() {
|
||||||
g.resultChan <- allocateResult{0, &errorCancelled{"Allocate", g.ident}}
|
g.resultChan <- allocateResult{err: &errorCancelled{"Allocate", g.ident}}
|
||||||
}
|
}
|
||||||
|
|
||||||
func (g *allocate) ForContainer(ident string) bool {
|
func (g *allocate) ForContainer(ident string) bool {
|
||||||
|
|||||||
+434
-156
@@ -7,11 +7,13 @@ import (
|
|||||||
"sort"
|
"sort"
|
||||||
"time"
|
"time"
|
||||||
|
|
||||||
|
"github.com/weaveworks/mesh"
|
||||||
|
|
||||||
"github.com/weaveworks/weave/common"
|
"github.com/weaveworks/weave/common"
|
||||||
|
"github.com/weaveworks/weave/db"
|
||||||
"github.com/weaveworks/weave/ipam/paxos"
|
"github.com/weaveworks/weave/ipam/paxos"
|
||||||
"github.com/weaveworks/weave/ipam/ring"
|
"github.com/weaveworks/weave/ipam/ring"
|
||||||
"github.com/weaveworks/weave/ipam/space"
|
"github.com/weaveworks/weave/ipam/space"
|
||||||
"github.com/weaveworks/weave/mesh"
|
|
||||||
"github.com/weaveworks/weave/net/address"
|
"github.com/weaveworks/weave/net/address"
|
||||||
)
|
)
|
||||||
|
|
||||||
@@ -21,8 +23,9 @@ const (
|
|||||||
msgRingUpdate
|
msgRingUpdate
|
||||||
msgSpaceRequestDenied
|
msgSpaceRequestDenied
|
||||||
|
|
||||||
paxosInterval = time.Second * 5
|
tickInterval = time.Second * 5
|
||||||
MinSubnetSize = 4 // first and last addresses are excluded, so 2 would be too small
|
MinSubnetSize = 4 // first and last addresses are excluded, so 2 would be too small
|
||||||
|
containerDiedTimeout = time.Second * 30
|
||||||
)
|
)
|
||||||
|
|
||||||
// operation represents something which Allocator wants to do, but
|
// operation represents something which Allocator wants to do, but
|
||||||
@@ -38,52 +41,107 @@ type operation interface {
|
|||||||
ForContainer(ident string) bool
|
ForContainer(ident string) bool
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// This type is persisted hence all fields exported
|
||||||
|
type ownedData struct {
|
||||||
|
IsContainer bool
|
||||||
|
Cidrs []address.CIDR
|
||||||
|
}
|
||||||
|
|
||||||
// Allocator brings together Ring and space.Set, and does the
|
// Allocator brings together Ring and space.Set, and does the
|
||||||
// necessary plumbing. Runs as a single-threaded Actor, so no locks
|
// necessary plumbing. Runs as a single-threaded Actor, so no locks
|
||||||
// are used around data structures.
|
// are used around data structures.
|
||||||
type Allocator struct {
|
type Allocator struct {
|
||||||
actionChan chan<- func()
|
actionChan chan<- func()
|
||||||
ourName mesh.PeerName
|
stopChan chan<- struct{}
|
||||||
universe address.Range // superset of all ranges
|
ourName mesh.PeerName
|
||||||
ring *ring.Ring // information on ranges owned by all peers
|
seed []mesh.PeerName // optional user supplied ring seed
|
||||||
space space.Space // more detail on ranges owned by us
|
universe address.Range // superset of all ranges
|
||||||
owned map[string][]address.Address // who owns what addresses, indexed by container-ID
|
ring *ring.Ring // information on ranges owned by all peers
|
||||||
nicknames map[mesh.PeerName]string // so we can map nicknames for rmpeer
|
space space.Space // more detail on ranges owned by us
|
||||||
pendingAllocates []operation // held until we get some free space
|
owned map[string]ownedData // who owns what addresses, indexed by container-ID
|
||||||
pendingClaims []operation // held until we know who owns the space
|
nicknames map[mesh.PeerName]string // so we can map nicknames for rmpeer
|
||||||
gossip mesh.Gossip // our link to the outside world for sending messages
|
pendingAllocates []operation // held until we get some free space
|
||||||
paxos *paxos.Node
|
pendingClaims []operation // held until we know who owns the space
|
||||||
paxosTicker *time.Ticker
|
pendingPrimes []operation // held while our ring is empty
|
||||||
shuttingDown bool // to avoid doing any requests while trying to shut down
|
dead map[string]time.Time // containers we heard were dead, and when
|
||||||
isKnownPeer func(mesh.PeerName) bool
|
db db.DB // persistence
|
||||||
now func() time.Time
|
gossip mesh.Gossip // our link to the outside world for sending messages
|
||||||
|
paxos paxos.Participant
|
||||||
|
awaitingConsensus bool
|
||||||
|
ticker *time.Ticker
|
||||||
|
shuttingDown bool // to avoid doing any requests while trying to shut down
|
||||||
|
isKnownPeer func(mesh.PeerName) bool
|
||||||
|
quorum func() uint
|
||||||
|
now func() time.Time
|
||||||
|
}
|
||||||
|
|
||||||
|
type Config struct {
|
||||||
|
OurName mesh.PeerName
|
||||||
|
OurUID mesh.PeerUID
|
||||||
|
OurNickname string
|
||||||
|
Seed []mesh.PeerName
|
||||||
|
Universe address.Range
|
||||||
|
IsObserver bool
|
||||||
|
Quorum func() uint
|
||||||
|
Db db.DB
|
||||||
|
IsKnownPeer func(name mesh.PeerName) bool
|
||||||
}
|
}
|
||||||
|
|
||||||
// NewAllocator creates and initialises a new Allocator
|
// NewAllocator creates and initialises a new Allocator
|
||||||
func NewAllocator(ourName mesh.PeerName, ourUID mesh.PeerUID, ourNickname string, universe address.Range, quorum uint, isKnownPeer func(name mesh.PeerName) bool) *Allocator {
|
func NewAllocator(config Config) *Allocator {
|
||||||
|
var participant paxos.Participant
|
||||||
|
if config.IsObserver {
|
||||||
|
participant = paxos.NewObserver()
|
||||||
|
} else {
|
||||||
|
participant = paxos.NewNode(config.OurName, config.OurUID, 0)
|
||||||
|
}
|
||||||
return &Allocator{
|
return &Allocator{
|
||||||
ourName: ourName,
|
ourName: config.OurName,
|
||||||
universe: universe,
|
seed: config.Seed,
|
||||||
ring: ring.New(universe.Start, universe.End, ourName),
|
universe: config.Universe,
|
||||||
owned: make(map[string][]address.Address),
|
ring: ring.New(config.Universe.Start, config.Universe.End, config.OurName),
|
||||||
paxos: paxos.NewNode(ourName, ourUID, quorum),
|
owned: make(map[string]ownedData),
|
||||||
nicknames: map[mesh.PeerName]string{ourName: ourNickname},
|
db: config.Db,
|
||||||
isKnownPeer: isKnownPeer,
|
paxos: participant,
|
||||||
|
nicknames: map[mesh.PeerName]string{config.OurName: config.OurNickname},
|
||||||
|
isKnownPeer: config.IsKnownPeer,
|
||||||
|
quorum: config.Quorum,
|
||||||
|
dead: make(map[string]time.Time),
|
||||||
now: time.Now,
|
now: time.Now,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// Start runs the allocator goroutine
|
// Start runs the allocator goroutine
|
||||||
func (alloc *Allocator) Start() {
|
func (alloc *Allocator) Start() {
|
||||||
|
loadedPersistedData := alloc.loadPersistedData()
|
||||||
|
switch {
|
||||||
|
case loadedPersistedData && len(alloc.seed) != 0:
|
||||||
|
alloc.infof("Found persisted IPAM data, ignoring supplied IPAM seed")
|
||||||
|
case loadedPersistedData:
|
||||||
|
alloc.infof("Initialising with persisted data")
|
||||||
|
case len(alloc.seed) != 0:
|
||||||
|
alloc.infof("Initialising with supplied IPAM seed")
|
||||||
|
alloc.createRing(alloc.seed)
|
||||||
|
case alloc.paxos.IsElector():
|
||||||
|
alloc.infof("Initialising via deferred consensus")
|
||||||
|
default:
|
||||||
|
alloc.infof("Initialising as observer - awaiting IPAM data from another peer")
|
||||||
|
}
|
||||||
actionChan := make(chan func(), mesh.ChannelSize)
|
actionChan := make(chan func(), mesh.ChannelSize)
|
||||||
|
stopChan := make(chan struct{})
|
||||||
alloc.actionChan = actionChan
|
alloc.actionChan = actionChan
|
||||||
go alloc.actorLoop(actionChan)
|
alloc.stopChan = stopChan
|
||||||
|
alloc.ticker = time.NewTicker(tickInterval)
|
||||||
|
go alloc.actorLoop(actionChan, stopChan)
|
||||||
}
|
}
|
||||||
|
|
||||||
// Stop makes the actor routine exit, for test purposes ONLY because any
|
// Stop makes the actor routine exit, for test purposes ONLY because any
|
||||||
// calls after this is processed will hang. Async.
|
// calls after this is processed will hang. Async.
|
||||||
func (alloc *Allocator) Stop() {
|
func (alloc *Allocator) Stop() {
|
||||||
alloc.actionChan <- nil
|
select {
|
||||||
|
case alloc.stopChan <- struct{}{}:
|
||||||
|
default:
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// Operation life cycle
|
// Operation life cycle
|
||||||
@@ -154,6 +212,8 @@ func (alloc *Allocator) tryOps(ops *[]operation) {
|
|||||||
|
|
||||||
// Try all pending operations
|
// Try all pending operations
|
||||||
func (alloc *Allocator) tryPendingOps() {
|
func (alloc *Allocator) tryPendingOps() {
|
||||||
|
// Unblock pending primes first
|
||||||
|
alloc.tryOps(&alloc.pendingPrimes)
|
||||||
// Process existing claims before servicing new allocations
|
// Process existing claims before servicing new allocations
|
||||||
alloc.tryOps(&alloc.pendingClaims)
|
alloc.tryOps(&alloc.pendingClaims)
|
||||||
alloc.tryOps(&alloc.pendingAllocates)
|
alloc.tryOps(&alloc.pendingAllocates)
|
||||||
@@ -162,7 +222,7 @@ func (alloc *Allocator) tryPendingOps() {
|
|||||||
func (alloc *Allocator) spaceRequestDenied(sender mesh.PeerName, r address.Range) {
|
func (alloc *Allocator) spaceRequestDenied(sender mesh.PeerName, r address.Range) {
|
||||||
for i := 0; i < len(alloc.pendingClaims); {
|
for i := 0; i < len(alloc.pendingClaims); {
|
||||||
claim := alloc.pendingClaims[i].(*claim)
|
claim := alloc.pendingClaims[i].(*claim)
|
||||||
if r.Contains(claim.addr) {
|
if r.Contains(claim.cidr.Addr) {
|
||||||
claim.deniedBy(alloc, sender)
|
claim.deniedBy(alloc, sender)
|
||||||
alloc.pendingClaims = append(alloc.pendingClaims[:i], alloc.pendingClaims[i+1:]...)
|
alloc.pendingClaims = append(alloc.pendingClaims[:i], alloc.pendingClaims[i+1:]...)
|
||||||
continue
|
continue
|
||||||
@@ -182,87 +242,135 @@ func (e *errorCancelled) Error() string {
|
|||||||
|
|
||||||
// Actor client API
|
// Actor client API
|
||||||
|
|
||||||
|
// Prime (Sync) - wait for consensus
|
||||||
|
func (alloc *Allocator) Prime() {
|
||||||
|
resultChan := make(chan struct{})
|
||||||
|
op := &prime{resultChan: resultChan}
|
||||||
|
alloc.doOperation(op, &alloc.pendingPrimes)
|
||||||
|
<-resultChan
|
||||||
|
}
|
||||||
|
|
||||||
// Allocate (Sync) - get new IP address for container with given name in range
|
// Allocate (Sync) - get new IP address for container with given name in range
|
||||||
// if there isn't any space in that range we block indefinitely
|
// if there isn't any space in that range we block indefinitely
|
||||||
func (alloc *Allocator) Allocate(ident string, r address.Range, hasBeenCancelled func() bool) (address.Address, error) {
|
func (alloc *Allocator) Allocate(ident string, r address.CIDR, isContainer bool, hasBeenCancelled func() bool) (address.Address, error) {
|
||||||
resultChan := make(chan allocateResult)
|
resultChan := make(chan allocateResult)
|
||||||
op := &allocate{resultChan: resultChan, ident: ident, r: r, hasBeenCancelled: hasBeenCancelled}
|
op := &allocate{
|
||||||
|
resultChan: resultChan,
|
||||||
|
ident: ident,
|
||||||
|
r: r,
|
||||||
|
isContainer: isContainer,
|
||||||
|
hasBeenCancelled: hasBeenCancelled,
|
||||||
|
}
|
||||||
alloc.doOperation(op, &alloc.pendingAllocates)
|
alloc.doOperation(op, &alloc.pendingAllocates)
|
||||||
result := <-resultChan
|
result := <-resultChan
|
||||||
return result.addr, result.err
|
return result.addr, result.err
|
||||||
}
|
}
|
||||||
|
|
||||||
// Lookup (Sync) - get existing IP address for container with given name in range
|
// Lookup (Sync) - get existing IP addresses for container with given name in range
|
||||||
func (alloc *Allocator) Lookup(ident string, r address.Range) (address.Address, error) {
|
func (alloc *Allocator) Lookup(ident string, r address.Range) ([]address.CIDR, error) {
|
||||||
resultChan := make(chan allocateResult)
|
resultChan := make(chan []address.CIDR)
|
||||||
alloc.actionChan <- func() {
|
alloc.actionChan <- func() {
|
||||||
if addr, found := alloc.lookupOwned(ident, r); found {
|
resultChan <- alloc.ownedInRange(ident, r)
|
||||||
resultChan <- allocateResult{addr: addr}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
resultChan <- allocateResult{err: fmt.Errorf("lookup: no address found for %s in range %s", ident, r)}
|
|
||||||
}
|
}
|
||||||
result := <-resultChan
|
return <-resultChan, nil
|
||||||
return result.addr, result.err
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// Claim an address that we think we should own (Sync)
|
// Claim an address that we think we should own (Sync)
|
||||||
func (alloc *Allocator) Claim(ident string, addr address.Address, noErrorOnUnknown bool) error {
|
func (alloc *Allocator) Claim(ident string, cidr address.CIDR, isContainer, noErrorOnUnknown bool, hasBeenCancelled func() bool) error {
|
||||||
resultChan := make(chan error)
|
resultChan := make(chan error)
|
||||||
op := &claim{resultChan: resultChan, ident: ident, addr: addr, noErrorOnUnknown: noErrorOnUnknown}
|
op := &claim{
|
||||||
|
resultChan: resultChan,
|
||||||
|
ident: ident,
|
||||||
|
cidr: cidr,
|
||||||
|
isContainer: isContainer,
|
||||||
|
noErrorOnUnknown: noErrorOnUnknown,
|
||||||
|
hasBeenCancelled: hasBeenCancelled,
|
||||||
|
}
|
||||||
alloc.doOperation(op, &alloc.pendingClaims)
|
alloc.doOperation(op, &alloc.pendingClaims)
|
||||||
return <-resultChan
|
return <-resultChan
|
||||||
}
|
}
|
||||||
|
|
||||||
// ContainerDied is provided to satisfy the updater interface; does a 'Delete' underneath. Sync.
|
// ContainerDied called from the updater interface. Async.
|
||||||
func (alloc *Allocator) ContainerDied(ident string) {
|
func (alloc *Allocator) ContainerDied(ident string) {
|
||||||
if err := alloc.Delete(ident); err == nil {
|
alloc.actionChan <- func() {
|
||||||
alloc.debugln("Container", ident, "died; released addresses")
|
if alloc.hasOwned(ident) {
|
||||||
|
alloc.debugln("Container", ident, "died; noting to remove later")
|
||||||
|
alloc.dead[ident] = alloc.now()
|
||||||
|
}
|
||||||
|
// Also remove any pending ops
|
||||||
|
alloc.cancelOpsFor(&alloc.pendingAllocates, ident)
|
||||||
|
alloc.cancelOpsFor(&alloc.pendingClaims, ident)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
func (alloc *Allocator) ContainerStarted(ident string) {}
|
// ContainerDestroyed called from the updater interface. Async.
|
||||||
|
func (alloc *Allocator) ContainerDestroyed(ident string) {
|
||||||
|
alloc.actionChan <- func() {
|
||||||
|
if alloc.hasOwned(ident) {
|
||||||
|
alloc.debugln("Container", ident, "destroyed; removing addresses")
|
||||||
|
alloc.delete(ident)
|
||||||
|
delete(alloc.dead, ident)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (alloc *Allocator) removeDeadContainers() {
|
||||||
|
cutoff := alloc.now().Add(-containerDiedTimeout)
|
||||||
|
for ident, timeOfDeath := range alloc.dead {
|
||||||
|
if timeOfDeath.Before(cutoff) {
|
||||||
|
if err := alloc.delete(ident); err == nil {
|
||||||
|
alloc.debugln("Removed addresses for container", ident)
|
||||||
|
}
|
||||||
|
delete(alloc.dead, ident)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (alloc *Allocator) ContainerStarted(ident string) {
|
||||||
|
alloc.actionChan <- func() {
|
||||||
|
delete(alloc.dead, ident) // delete is no-op if key not in map
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (alloc *Allocator) AllContainerIDs(ids []string) {
|
||||||
|
alloc.actionChan <- func() {
|
||||||
|
idmap := make(map[string]struct{}, len(ids))
|
||||||
|
for _, id := range ids {
|
||||||
|
idmap[id] = struct{}{}
|
||||||
|
}
|
||||||
|
alloc.syncOwned(idmap)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
// Delete (Sync) - release all IP addresses for container with given name
|
// Delete (Sync) - release all IP addresses for container with given name
|
||||||
func (alloc *Allocator) Delete(ident string) error {
|
func (alloc *Allocator) Delete(ident string) error {
|
||||||
errChan := make(chan error)
|
errChan := make(chan error)
|
||||||
alloc.actionChan <- func() {
|
alloc.actionChan <- func() {
|
||||||
addrs, found := alloc.owned[ident]
|
errChan <- alloc.delete(ident)
|
||||||
for _, addr := range addrs {
|
|
||||||
alloc.space.Free(addr)
|
|
||||||
}
|
|
||||||
delete(alloc.owned, ident)
|
|
||||||
|
|
||||||
// Also remove any pending ops
|
|
||||||
found = alloc.cancelOpsFor(&alloc.pendingAllocates, ident) || found
|
|
||||||
found = alloc.cancelOpsFor(&alloc.pendingClaims, ident) || found
|
|
||||||
|
|
||||||
if !found {
|
|
||||||
errChan <- fmt.Errorf("Delete: no addresses for %s", ident)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
errChan <- nil
|
|
||||||
}
|
}
|
||||||
return <-errChan
|
return <-errChan
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func (alloc *Allocator) delete(ident string) error {
|
||||||
|
cidrs := alloc.removeAllOwned(ident)
|
||||||
|
if len(cidrs) == 0 {
|
||||||
|
return fmt.Errorf("Delete: no addresses for %s", ident)
|
||||||
|
}
|
||||||
|
for _, cidr := range cidrs {
|
||||||
|
alloc.space.Free(cidr.Addr)
|
||||||
|
}
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
// Free (Sync) - release single IP address for container
|
// Free (Sync) - release single IP address for container
|
||||||
func (alloc *Allocator) Free(ident string, addrToFree address.Address) error {
|
func (alloc *Allocator) Free(ident string, addrToFree address.Address) error {
|
||||||
errChan := make(chan error)
|
errChan := make(chan error)
|
||||||
alloc.actionChan <- func() {
|
alloc.actionChan <- func() {
|
||||||
addrs := alloc.owned[ident]
|
if alloc.removeOwned(ident, addrToFree) {
|
||||||
for i, ownedAddr := range addrs {
|
alloc.debugln("Freed", addrToFree, "for", ident)
|
||||||
if ownedAddr == addrToFree {
|
alloc.space.Free(addrToFree)
|
||||||
alloc.debugln("Freed", addrToFree, "for", ident)
|
errChan <- nil
|
||||||
if len(addrs) == 1 {
|
return
|
||||||
delete(alloc.owned, ident)
|
|
||||||
} else {
|
|
||||||
alloc.owned[ident] = append(addrs[:i], addrs[i+1:]...)
|
|
||||||
}
|
|
||||||
alloc.space.Free(addrToFree)
|
|
||||||
errChan <- nil
|
|
||||||
return
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
errChan <- fmt.Errorf("Free: address %s not found for %s", addrToFree, ident)
|
errChan <- fmt.Errorf("Free: address %s not found for %s", addrToFree, ident)
|
||||||
@@ -293,7 +401,7 @@ func (alloc *Allocator) pickPeerForTransfer() mesh.PeerName {
|
|||||||
if heir := alloc.ring.PickPeerForTransfer(t); heir != mesh.UnknownPeerName {
|
if heir := alloc.ring.PickPeerForTransfer(t); heir != mesh.UnknownPeerName {
|
||||||
return heir
|
return heir
|
||||||
}
|
}
|
||||||
// finally, disappeared peers that that passively participated in IPAM
|
// finally, disappeared peers that passively participated in IPAM
|
||||||
return alloc.pickPeerFromNicknames(t)
|
return alloc.pickPeerFromNicknames(t)
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -305,8 +413,10 @@ func (alloc *Allocator) Shutdown() {
|
|||||||
alloc.shuttingDown = true
|
alloc.shuttingDown = true
|
||||||
alloc.cancelOps(&alloc.pendingClaims)
|
alloc.cancelOps(&alloc.pendingClaims)
|
||||||
alloc.cancelOps(&alloc.pendingAllocates)
|
alloc.cancelOps(&alloc.pendingAllocates)
|
||||||
|
alloc.cancelOps(&alloc.pendingPrimes)
|
||||||
if heir := alloc.pickPeerForTransfer(); heir != mesh.UnknownPeerName {
|
if heir := alloc.pickPeerForTransfer(); heir != mesh.UnknownPeerName {
|
||||||
alloc.ring.Transfer(alloc.ourName, heir)
|
alloc.ring.Transfer(alloc.ourName, heir)
|
||||||
|
alloc.persistRing()
|
||||||
alloc.space.Clear()
|
alloc.space.Clear()
|
||||||
alloc.gossip.GossipBroadcast(alloc.Gossip())
|
alloc.gossip.GossipBroadcast(alloc.Gossip())
|
||||||
time.Sleep(100 * time.Millisecond)
|
time.Sleep(100 * time.Millisecond)
|
||||||
@@ -316,26 +426,40 @@ func (alloc *Allocator) Shutdown() {
|
|||||||
<-doneChan
|
<-doneChan
|
||||||
}
|
}
|
||||||
|
|
||||||
// AdminTakeoverRanges (Sync) - take over the ranges owned by a given peer.
|
// AdminTakeoverRanges (Sync) - take over the ranges owned by a given
|
||||||
// Only done on adminstrator command.
|
// peer, and return how much space was transferred in the process.
|
||||||
func (alloc *Allocator) AdminTakeoverRanges(peerNameOrNickname string) error {
|
// Only done on administrator command.
|
||||||
resultChan := make(chan error)
|
func (alloc *Allocator) AdminTakeoverRanges(peerNameOrNickname string) address.Count {
|
||||||
|
resultChan := make(chan address.Count)
|
||||||
alloc.actionChan <- func() {
|
alloc.actionChan <- func() {
|
||||||
peername, err := alloc.lookupPeername(peerNameOrNickname)
|
peername, err := alloc.lookupPeername(peerNameOrNickname)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
resultChan <- fmt.Errorf("Cannot find peer '%s'", peerNameOrNickname)
|
alloc.warnf("attempt to take over range from unknown peer '%s'", peerNameOrNickname)
|
||||||
|
resultChan <- address.Count(0)
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
alloc.debugln("AdminTakeoverRanges:", peername)
|
alloc.debugln("AdminTakeoverRanges:", peername)
|
||||||
if peername == alloc.ourName {
|
if peername == alloc.ourName {
|
||||||
resultChan <- fmt.Errorf("Cannot take over ranges from yourself!")
|
alloc.warnf("attempt to take over range from ourself")
|
||||||
|
resultChan <- address.Count(0)
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
newRanges, err := alloc.ring.Transfer(peername, alloc.ourName)
|
newRanges := alloc.ring.Transfer(peername, alloc.ourName)
|
||||||
alloc.space.AddRanges(newRanges)
|
|
||||||
resultChan <- err
|
if len(newRanges) == 0 {
|
||||||
|
resultChan <- address.Count(0)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
before := alloc.space.NumFreeAddresses()
|
||||||
|
alloc.ringUpdated()
|
||||||
|
after := alloc.space.NumFreeAddresses()
|
||||||
|
|
||||||
|
alloc.gossip.GossipBroadcast(alloc.Gossip())
|
||||||
|
|
||||||
|
resultChan <- after - before
|
||||||
}
|
}
|
||||||
return <-resultChan
|
return <-resultChan
|
||||||
}
|
}
|
||||||
@@ -419,7 +543,7 @@ func (alloc *Allocator) OnGossipBroadcast(sender mesh.PeerName, msg []byte) (mes
|
|||||||
|
|
||||||
type gossipState struct {
|
type gossipState struct {
|
||||||
// We send a timstamp along with the information to be
|
// We send a timstamp along with the information to be
|
||||||
// gossipped in order to detect skewed clocks
|
// gossipped for backwards-compatibility (previously to detect skewed clocks)
|
||||||
Now int64
|
Now int64
|
||||||
Nicknames map[mesh.PeerName]string
|
Nicknames map[mesh.PeerName]string
|
||||||
|
|
||||||
@@ -434,6 +558,9 @@ func (alloc *Allocator) encode() []byte {
|
|||||||
}
|
}
|
||||||
|
|
||||||
// We're only interested in Paxos until we have a Ring.
|
// We're only interested in Paxos until we have a Ring.
|
||||||
|
// Non-electing participants (e.g. observers) return
|
||||||
|
// a nil gossip state in order to provoke a unicast ring
|
||||||
|
// update from electing peers who have reached consensus.
|
||||||
if alloc.ring.Empty() {
|
if alloc.ring.Empty() {
|
||||||
data.Paxos = alloc.paxos.GossipState()
|
data.Paxos = alloc.paxos.GossipState()
|
||||||
} else {
|
} else {
|
||||||
@@ -493,21 +620,22 @@ func (alloc *Allocator) SetInterfaces(gossip mesh.Gossip) {
|
|||||||
|
|
||||||
// ACTOR server
|
// ACTOR server
|
||||||
|
|
||||||
func (alloc *Allocator) actorLoop(actionChan <-chan func()) {
|
func (alloc *Allocator) actorLoop(actionChan <-chan func(), stopChan <-chan struct{}) {
|
||||||
|
defer alloc.ticker.Stop()
|
||||||
for {
|
for {
|
||||||
var tickChan <-chan time.Time
|
|
||||||
if alloc.paxosTicker != nil {
|
|
||||||
tickChan = alloc.paxosTicker.C
|
|
||||||
}
|
|
||||||
|
|
||||||
select {
|
select {
|
||||||
case action := <-actionChan:
|
case action := <-actionChan:
|
||||||
if action == nil {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
action()
|
action()
|
||||||
case <-tickChan:
|
case <-stopChan:
|
||||||
alloc.propose()
|
return
|
||||||
|
case <-alloc.ticker.C:
|
||||||
|
// Retry things in case messages got lost between here and recipients
|
||||||
|
if alloc.awaitingConsensus {
|
||||||
|
alloc.propose()
|
||||||
|
} else {
|
||||||
|
alloc.tryPendingOps()
|
||||||
|
}
|
||||||
|
alloc.removeDeadContainers()
|
||||||
}
|
}
|
||||||
|
|
||||||
alloc.assertInvariants()
|
alloc.assertInvariants()
|
||||||
@@ -519,39 +647,35 @@ func (alloc *Allocator) actorLoop(actionChan <-chan func()) {
|
|||||||
|
|
||||||
// Ensure we are making progress towards an established ring
|
// Ensure we are making progress towards an established ring
|
||||||
func (alloc *Allocator) establishRing() {
|
func (alloc *Allocator) establishRing() {
|
||||||
if !alloc.ring.Empty() || alloc.paxosTicker != nil {
|
if !alloc.ring.Empty() || alloc.awaitingConsensus {
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
|
alloc.awaitingConsensus = true
|
||||||
|
alloc.paxos.SetQuorum(alloc.quorum())
|
||||||
alloc.propose()
|
alloc.propose()
|
||||||
if ok, cons := alloc.paxos.Consensus(); ok {
|
if ok, cons := alloc.paxos.Consensus(); ok {
|
||||||
// If the quorum was 1, then proposing immediately
|
// If the quorum was 1, then proposing immediately
|
||||||
// leads to consensus
|
// leads to consensus
|
||||||
alloc.createRing(cons.Value)
|
alloc.createRing(cons.Value)
|
||||||
} else {
|
|
||||||
// re-try until we get consensus
|
|
||||||
alloc.paxosTicker = time.NewTicker(paxosInterval)
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
func (alloc *Allocator) createRing(peers []mesh.PeerName) {
|
func (alloc *Allocator) createRing(peers []mesh.PeerName) {
|
||||||
alloc.debugln("Paxos consensus:", peers)
|
alloc.debugln("Paxos consensus:", peers)
|
||||||
alloc.ring.ClaimForPeers(normalizeConsensus(peers))
|
alloc.ring.ClaimForPeers(normalizeConsensus(peers))
|
||||||
alloc.gossip.GossipBroadcast(alloc.Gossip())
|
|
||||||
alloc.ringUpdated()
|
alloc.ringUpdated()
|
||||||
|
alloc.gossip.GossipBroadcast(alloc.Gossip())
|
||||||
}
|
}
|
||||||
|
|
||||||
func (alloc *Allocator) ringUpdated() {
|
func (alloc *Allocator) ringUpdated() {
|
||||||
// When we have a ring, we don't need paxos any more
|
// When we have a ring, we don't need paxos any more
|
||||||
if alloc.paxos != nil {
|
if alloc.awaitingConsensus {
|
||||||
|
alloc.awaitingConsensus = false
|
||||||
alloc.paxos = nil
|
alloc.paxos = nil
|
||||||
|
|
||||||
if alloc.paxosTicker != nil {
|
|
||||||
alloc.paxosTicker.Stop()
|
|
||||||
alloc.paxosTicker = nil
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
alloc.persistRing()
|
||||||
alloc.space.UpdateRanges(alloc.ring.OwnedRanges())
|
alloc.space.UpdateRanges(alloc.ring.OwnedRanges())
|
||||||
alloc.tryPendingOps()
|
alloc.tryPendingOps()
|
||||||
}
|
}
|
||||||
@@ -626,21 +750,21 @@ func (alloc *Allocator) update(sender mesh.PeerName, msg []byte) error {
|
|||||||
return err
|
return err
|
||||||
}
|
}
|
||||||
|
|
||||||
deltat := time.Unix(data.Now, 0).Sub(alloc.now())
|
|
||||||
if deltat > time.Hour || -deltat > time.Hour {
|
|
||||||
return fmt.Errorf("clock skew of %v detected, ignoring update", deltat)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Merge nicknames
|
// Merge nicknames
|
||||||
for peer, nickname := range data.Nicknames {
|
for peer, nickname := range data.Nicknames {
|
||||||
alloc.nicknames[peer] = nickname
|
alloc.nicknames[peer] = nickname
|
||||||
}
|
}
|
||||||
|
|
||||||
// only one of Ring and Paxos should be present. And we
|
switch {
|
||||||
// shouldn't get updates for a empty Ring. But tolerate
|
// If someone sent us a ring, merge it into ours. Note this will move us
|
||||||
// them just in case.
|
// out of the awaiting-consensus state if we didn't have a ring already.
|
||||||
if data.Ring != nil {
|
case data.Ring != nil:
|
||||||
switch err = alloc.ring.Merge(*data.Ring); err {
|
switch err = alloc.ring.Merge(*data.Ring); err {
|
||||||
|
case nil:
|
||||||
|
if !alloc.ring.Empty() {
|
||||||
|
alloc.pruneNicknames()
|
||||||
|
alloc.ringUpdated()
|
||||||
|
}
|
||||||
case ring.ErrDifferentSeeds:
|
case ring.ErrDifferentSeeds:
|
||||||
return fmt.Errorf("IP allocation was seeded by different peers (received: %v, ours: %v)",
|
return fmt.Errorf("IP allocation was seeded by different peers (received: %v, ours: %v)",
|
||||||
alloc.annotatePeernames(data.Ring.Seeds), alloc.annotatePeernames(alloc.ring.Seeds))
|
alloc.annotatePeernames(data.Ring.Seeds), alloc.annotatePeernames(alloc.ring.Seeds))
|
||||||
@@ -648,31 +772,44 @@ func (alloc *Allocator) update(sender mesh.PeerName, msg []byte) error {
|
|||||||
return fmt.Errorf("Incompatible IP allocation ranges (received: %s, ours: %s)",
|
return fmt.Errorf("Incompatible IP allocation ranges (received: %s, ours: %s)",
|
||||||
data.Ring.Range().AsCIDRString(), alloc.ring.Range().AsCIDRString())
|
data.Ring.Range().AsCIDRString(), alloc.ring.Range().AsCIDRString())
|
||||||
default:
|
default:
|
||||||
if err == nil && !alloc.ring.Empty() {
|
|
||||||
alloc.pruneNicknames()
|
|
||||||
alloc.ringUpdated()
|
|
||||||
}
|
|
||||||
return err
|
return err
|
||||||
}
|
}
|
||||||
}
|
|
||||||
|
|
||||||
if data.Paxos != nil {
|
// If we reach this point we know the sender is either an elector
|
||||||
if alloc.ring.Empty() {
|
// broadcasting a paxos proposal to form a ring or a non-elector
|
||||||
if alloc.paxos.Update(data.Paxos) {
|
// broadcasting a ring request. If we have a ring already we can just send
|
||||||
if alloc.paxos.Think() {
|
// it back regardless.
|
||||||
// If something important changed, broadcast
|
case !alloc.ring.Empty():
|
||||||
alloc.gossip.GossipBroadcast(alloc.Gossip())
|
if sender != mesh.UnknownPeerName {
|
||||||
}
|
|
||||||
|
|
||||||
if ok, cons := alloc.paxos.Consensus(); ok {
|
|
||||||
alloc.createRing(cons.Value)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
} else if sender != mesh.UnknownPeerName {
|
|
||||||
// Sender is trying to initialize a ring, but we have one
|
|
||||||
// already - send it straight back
|
|
||||||
alloc.sendRingUpdate(sender)
|
alloc.sendRingUpdate(sender)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Otherwise, we need to react according to whether or not we received a
|
||||||
|
// paxos proposal.
|
||||||
|
case data.Paxos != nil:
|
||||||
|
// Process the proposal (this is a no-op if we're an observer)
|
||||||
|
if alloc.paxos.Update(data.Paxos) {
|
||||||
|
if alloc.paxos.Think() {
|
||||||
|
// If something important changed, broadcast
|
||||||
|
alloc.gossip.GossipBroadcast(alloc.Gossip())
|
||||||
|
}
|
||||||
|
|
||||||
|
if ok, cons := alloc.paxos.Consensus(); ok {
|
||||||
|
alloc.createRing(cons.Value)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// No paxos proposal present, so sender is a non-elector. We don't have a
|
||||||
|
// ring to send, so attempt to establish one on their behalf. NB we only do
|
||||||
|
// this:
|
||||||
|
//
|
||||||
|
// * On an explicit broadcast request triggered by a remote allocation attempt
|
||||||
|
// (if we did so on periodic gossip we would force consensus unnecessarily)
|
||||||
|
// * If we are an elector (to avoid a broadcast storm of ring request messages)
|
||||||
|
default:
|
||||||
|
if alloc.paxos.IsElector() && sender != mesh.UnknownPeerName {
|
||||||
|
alloc.establishRing()
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
return nil
|
return nil
|
||||||
@@ -680,7 +817,7 @@ func (alloc *Allocator) update(sender mesh.PeerName, msg []byte) error {
|
|||||||
|
|
||||||
func (alloc *Allocator) donateSpace(r address.Range, to mesh.PeerName) {
|
func (alloc *Allocator) donateSpace(r address.Range, to mesh.PeerName) {
|
||||||
// No matter what we do, we'll send a unicast gossip
|
// No matter what we do, we'll send a unicast gossip
|
||||||
// of our ring back to tha chap who asked for space.
|
// of our ring back to the chap who asked for space.
|
||||||
// This serves to both tell him of any space we might
|
// This serves to both tell him of any space we might
|
||||||
// have given him, or tell him where he might find some
|
// have given him, or tell him where he might find some
|
||||||
// more.
|
// more.
|
||||||
@@ -699,7 +836,7 @@ func (alloc *Allocator) donateSpace(r address.Range, to mesh.PeerName) {
|
|||||||
}
|
}
|
||||||
alloc.debugln("Giving range", chunk, "to", to)
|
alloc.debugln("Giving range", chunk, "to", to)
|
||||||
alloc.ring.GrantRangeToHost(chunk.Start, chunk.End, to)
|
alloc.ring.GrantRangeToHost(chunk.Start, chunk.End, to)
|
||||||
alloc.sendRingUpdate(to)
|
alloc.persistRing()
|
||||||
}
|
}
|
||||||
|
|
||||||
func (alloc *Allocator) assertInvariants() {
|
func (alloc *Allocator) assertInvariants() {
|
||||||
@@ -725,33 +862,144 @@ func (alloc *Allocator) reportFreeSpace() {
|
|||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
freespace := make(map[address.Address]address.Offset)
|
freespace := make(map[address.Address]address.Count)
|
||||||
for _, r := range ranges {
|
for _, r := range ranges {
|
||||||
freespace[r.Start] = alloc.space.NumFreeAddressesInRange(r)
|
freespace[r.Start] = alloc.space.NumFreeAddressesInRange(r)
|
||||||
}
|
}
|
||||||
alloc.ring.ReportFree(freespace)
|
alloc.ring.ReportFree(freespace)
|
||||||
}
|
}
|
||||||
|
|
||||||
// Owned addresses
|
// Persistent data
|
||||||
|
const (
|
||||||
|
ringIdent = "ring"
|
||||||
|
nameIdent = "peername"
|
||||||
|
ownedIdent = "ownedAddresses"
|
||||||
|
)
|
||||||
|
|
||||||
// NB: addr must not be owned by ident already
|
func (alloc *Allocator) persistRing() {
|
||||||
func (alloc *Allocator) addOwned(ident string, addr address.Address) {
|
// It would be better if these two Save operations happened in the same transaction
|
||||||
alloc.owned[ident] = append(alloc.owned[ident], addr)
|
if err := alloc.db.Save(nameIdent, alloc.ourName); err != nil {
|
||||||
|
alloc.fatalf("Error persisting ring data: %s", err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
if err := alloc.db.Save(ringIdent, alloc.ring); err != nil {
|
||||||
|
alloc.fatalf("Error persisting ring data: %s", err)
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
func (alloc *Allocator) lookupOwned(ident string, r address.Range) (address.Address, bool) {
|
// Returns true if persisted data is to be used, otherwise false
|
||||||
for _, addr := range alloc.owned[ident] {
|
func (alloc *Allocator) loadPersistedData() bool {
|
||||||
if r.Contains(addr) {
|
var checkPeerName mesh.PeerName
|
||||||
return addr, true
|
nameFound, err := alloc.db.Load(nameIdent, &checkPeerName)
|
||||||
|
if err != nil {
|
||||||
|
alloc.fatalf("Error loading persisted peer name: %s", err)
|
||||||
|
}
|
||||||
|
var persistedRing *ring.Ring
|
||||||
|
ringFound, err := alloc.db.Load(ringIdent, &persistedRing)
|
||||||
|
if err != nil {
|
||||||
|
alloc.fatalf("Error loading persisted IPAM data: %s", err)
|
||||||
|
}
|
||||||
|
var persistedOwned map[string]ownedData
|
||||||
|
ownedFound, err := alloc.db.Load(ownedIdent, &persistedOwned)
|
||||||
|
if err != nil {
|
||||||
|
alloc.fatalf("Error loading persisted address data: %s", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
overwritePersisted := func(fmt string, args ...interface{}) {
|
||||||
|
alloc.infof(fmt, args...)
|
||||||
|
alloc.persistRing()
|
||||||
|
alloc.persistOwned()
|
||||||
|
}
|
||||||
|
|
||||||
|
if !nameFound || !ringFound {
|
||||||
|
overwritePersisted("No valid persisted data")
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
if checkPeerName != alloc.ourName {
|
||||||
|
overwritePersisted("Deleting persisted data for peername %s", checkPeerName)
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
if persistedRing.Range() != alloc.universe {
|
||||||
|
overwritePersisted("Deleting persisted data for IPAM range %s; our range is %s", persistedRing.Range(), alloc.universe)
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
alloc.ring = persistedRing
|
||||||
|
alloc.space.UpdateRanges(alloc.ring.OwnedRanges())
|
||||||
|
|
||||||
|
if ownedFound {
|
||||||
|
alloc.owned = persistedOwned
|
||||||
|
for _, d := range alloc.owned {
|
||||||
|
for _, cidr := range d.Cidrs {
|
||||||
|
alloc.space.Claim(cidr.Addr)
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
return 0, false
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
|
func (alloc *Allocator) persistOwned() {
|
||||||
|
if err := alloc.db.Save(ownedIdent, alloc.owned); err != nil {
|
||||||
|
alloc.fatalf("Error persisting address data: %s", err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Owned addresses
|
||||||
|
|
||||||
|
func (alloc *Allocator) hasOwned(ident string) bool {
|
||||||
|
_, b := alloc.owned[ident]
|
||||||
|
return b
|
||||||
|
}
|
||||||
|
|
||||||
|
// NB: addr must not be owned by ident already
|
||||||
|
func (alloc *Allocator) addOwned(ident string, cidr address.CIDR, isContainer bool) {
|
||||||
|
d := alloc.owned[ident]
|
||||||
|
d.IsContainer = isContainer
|
||||||
|
d.Cidrs = append(d.Cidrs, cidr)
|
||||||
|
alloc.owned[ident] = d
|
||||||
|
alloc.persistOwned()
|
||||||
|
}
|
||||||
|
|
||||||
|
func (alloc *Allocator) removeAllOwned(ident string) []address.CIDR {
|
||||||
|
a := alloc.owned[ident]
|
||||||
|
delete(alloc.owned, ident)
|
||||||
|
alloc.persistOwned()
|
||||||
|
return a.Cidrs
|
||||||
|
}
|
||||||
|
|
||||||
|
func (alloc *Allocator) removeOwned(ident string, addrToFree address.Address) bool {
|
||||||
|
d := alloc.owned[ident]
|
||||||
|
for i, ownedCidr := range d.Cidrs {
|
||||||
|
if ownedCidr.Addr == addrToFree {
|
||||||
|
if len(d.Cidrs) == 1 {
|
||||||
|
delete(alloc.owned, ident)
|
||||||
|
} else {
|
||||||
|
d.Cidrs = append(d.Cidrs[:i], d.Cidrs[i+1:]...)
|
||||||
|
alloc.owned[ident] = d
|
||||||
|
}
|
||||||
|
alloc.persistOwned()
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
func (alloc *Allocator) ownedInRange(ident string, r address.Range) []address.CIDR {
|
||||||
|
var c []address.CIDR
|
||||||
|
for _, cidr := range alloc.owned[ident].Cidrs {
|
||||||
|
if r.Contains(cidr.Addr) {
|
||||||
|
c = append(c, cidr)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return c
|
||||||
}
|
}
|
||||||
|
|
||||||
func (alloc *Allocator) findOwner(addr address.Address) string {
|
func (alloc *Allocator) findOwner(addr address.Address) string {
|
||||||
for ident, addrs := range alloc.owned {
|
for ident, d := range alloc.owned {
|
||||||
for _, candidate := range addrs {
|
for _, candidate := range d.Cidrs {
|
||||||
if candidate == addr {
|
if candidate.Addr == addr {
|
||||||
return ident
|
return ident
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -759,14 +1007,44 @@ func (alloc *Allocator) findOwner(addr address.Address) string {
|
|||||||
return ""
|
return ""
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// For each ID in the 'owned' map, remove the entry if it isn't in the map
|
||||||
|
func (alloc *Allocator) syncOwned(ids map[string]struct{}) {
|
||||||
|
changed := false
|
||||||
|
for ident, d := range alloc.owned {
|
||||||
|
if !d.IsContainer {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if _, found := ids[ident]; !found {
|
||||||
|
for _, cidr := range d.Cidrs {
|
||||||
|
alloc.space.Free(cidr.Addr)
|
||||||
|
}
|
||||||
|
alloc.debugf("Deleting old entry %s: %v", ident, d.Cidrs)
|
||||||
|
delete(alloc.owned, ident)
|
||||||
|
changed = true
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if changed {
|
||||||
|
alloc.persistOwned()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
// Logging
|
// Logging
|
||||||
|
|
||||||
|
func (alloc *Allocator) fatalf(fmt string, args ...interface{}) {
|
||||||
|
alloc.logf(common.Log.Fatalf, fmt, args...)
|
||||||
|
}
|
||||||
|
func (alloc *Allocator) warnf(fmt string, args ...interface{}) {
|
||||||
|
alloc.logf(common.Log.Warnf, fmt, args...)
|
||||||
|
}
|
||||||
func (alloc *Allocator) infof(fmt string, args ...interface{}) {
|
func (alloc *Allocator) infof(fmt string, args ...interface{}) {
|
||||||
common.Log.Infof("[allocator %s] "+fmt, append([]interface{}{alloc.ourName}, args...)...)
|
alloc.logf(common.Log.Infof, fmt, args...)
|
||||||
|
}
|
||||||
|
func (alloc *Allocator) debugf(fmt string, args ...interface{}) {
|
||||||
|
alloc.logf(common.Log.Debugf, fmt, args...)
|
||||||
|
}
|
||||||
|
func (alloc *Allocator) logf(f func(string, ...interface{}), fmt string, args ...interface{}) {
|
||||||
|
f("[allocator %s] "+fmt, append([]interface{}{alloc.ourName}, args...)...)
|
||||||
}
|
}
|
||||||
func (alloc *Allocator) debugln(args ...interface{}) {
|
func (alloc *Allocator) debugln(args ...interface{}) {
|
||||||
common.Log.Debugln(append([]interface{}{fmt.Sprintf("[allocator %s]:", alloc.ourName)}, args...)...)
|
common.Log.Debugln(append([]interface{}{fmt.Sprintf("[allocator %s]:", alloc.ourName)}, args...)...)
|
||||||
}
|
}
|
||||||
func (alloc *Allocator) debugf(fmt string, args ...interface{}) {
|
|
||||||
common.Log.Debugf("[allocator %s] "+fmt, append([]interface{}{alloc.ourName}, args...)...)
|
|
||||||
}
|
|
||||||
+144
-89
@@ -22,6 +22,14 @@ const (
|
|||||||
|
|
||||||
func returnFalse() bool { return false }
|
func returnFalse() bool { return false }
|
||||||
|
|
||||||
|
func (alloc *Allocator) SimplyAllocate(ident string, cidr address.CIDR) (address.Address, error) {
|
||||||
|
return alloc.Allocate(ident, cidr, true, returnFalse)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (alloc *Allocator) SimplyClaim(ident string, cidr address.CIDR) error {
|
||||||
|
return alloc.Claim(ident, cidr, true, true, returnFalse)
|
||||||
|
}
|
||||||
|
|
||||||
func TestAllocFree(t *testing.T) {
|
func TestAllocFree(t *testing.T) {
|
||||||
const (
|
const (
|
||||||
container1 = "abcdef"
|
container1 = "abcdef"
|
||||||
@@ -37,40 +45,54 @@ func TestAllocFree(t *testing.T) {
|
|||||||
|
|
||||||
alloc, subnet := makeAllocatorWithMockGossip(t, "01:00:00:01:00:00", universe, 1)
|
alloc, subnet := makeAllocatorWithMockGossip(t, "01:00:00:01:00:00", universe, 1)
|
||||||
defer alloc.Stop()
|
defer alloc.Stop()
|
||||||
_, cidr1, _ := address.ParseCIDR(subnet1)
|
cidr1, _ := address.ParseCIDR(subnet1)
|
||||||
_, cidr2, _ := address.ParseCIDR(subnet2)
|
cidr2, _ := address.ParseCIDR(subnet2)
|
||||||
|
|
||||||
alloc.claimRingForTesting()
|
alloc.claimRingForTesting()
|
||||||
addr1, err := alloc.Allocate(container1, cidr1.HostRange(), returnFalse)
|
addr1, err := alloc.SimplyAllocate(container1, cidr1)
|
||||||
require.NoError(t, err)
|
require.NoError(t, err)
|
||||||
require.Equal(t, testAddr1, addr1.String(), "address")
|
require.Equal(t, testAddr1, addr1.String(), "address")
|
||||||
|
|
||||||
addr2, err := alloc.Allocate(container1, cidr2.HostRange(), returnFalse)
|
addr2, err := alloc.SimplyAllocate(container1, cidr2)
|
||||||
require.NoError(t, err)
|
require.NoError(t, err)
|
||||||
require.Equal(t, testAddr2, addr2.String(), "address")
|
require.Equal(t, testAddr2, addr2.String(), "address")
|
||||||
|
|
||||||
|
addrs, err := alloc.Lookup(container1, subnet.Range())
|
||||||
|
require.NoError(t, err)
|
||||||
|
require.Equal(t, []address.CIDR{address.MakeCIDR(cidr1, addr1), address.MakeCIDR(cidr2, addr2)}, addrs)
|
||||||
|
|
||||||
// Ask for another address for a different container and check it's different
|
// Ask for another address for a different container and check it's different
|
||||||
addr1b, _ := alloc.Allocate(container2, cidr1.HostRange(), returnFalse)
|
addr1b, _ := alloc.SimplyAllocate(container2, cidr1)
|
||||||
if addr1b.String() == testAddr1 {
|
if addr1b.String() == testAddr1 {
|
||||||
t.Fatalf("Expected different address but got %s", addr1b.String())
|
t.Fatalf("Expected different address but got %s", addr1b.String())
|
||||||
}
|
}
|
||||||
|
|
||||||
// Ask for the first container again and we should get the same addresses again
|
// Ask for the first container again and we should get the same addresses again
|
||||||
addr1a, _ := alloc.Allocate(container1, cidr1.HostRange(), returnFalse)
|
addr1a, _ := alloc.SimplyAllocate(container1, cidr1)
|
||||||
require.Equal(t, testAddr1, addr1a.String(), "address")
|
require.Equal(t, testAddr1, addr1a.String(), "address")
|
||||||
addr2a, _ := alloc.Allocate(container1, cidr2.HostRange(), returnFalse)
|
addr2a, _ := alloc.SimplyAllocate(container1, cidr2)
|
||||||
require.Equal(t, testAddr2, addr2a.String(), "address")
|
require.Equal(t, testAddr2, addr2a.String(), "address")
|
||||||
|
|
||||||
// Now delete the first container, and we should get its addresses back
|
// Now delete the first container, and we should get its addresses back
|
||||||
require.NoError(t, alloc.Delete(container1))
|
require.NoError(t, alloc.Delete(container1))
|
||||||
addr3, _ := alloc.Allocate(container3, cidr1.HostRange(), returnFalse)
|
addr3, _ := alloc.SimplyAllocate(container3, cidr1)
|
||||||
require.Equal(t, testAddr1, addr3.String(), "address")
|
require.Equal(t, testAddr1, addr3.String(), "address")
|
||||||
addr4, _ := alloc.Allocate(container3, cidr2.HostRange(), returnFalse)
|
addr4, _ := alloc.SimplyAllocate(container3, cidr2)
|
||||||
require.Equal(t, testAddr2, addr4.String(), "address")
|
require.Equal(t, testAddr2, addr4.String(), "address")
|
||||||
|
|
||||||
alloc.ContainerDied(container2)
|
alloc.ContainerDied(container2)
|
||||||
|
|
||||||
|
// Resurrect
|
||||||
|
addr1c, err := alloc.SimplyAllocate(container2, cidr1)
|
||||||
|
require.NoError(t, err)
|
||||||
|
require.Equal(t, addr1b, addr1c, "address")
|
||||||
|
|
||||||
alloc.ContainerDied(container3)
|
alloc.ContainerDied(container3)
|
||||||
require.Equal(t, address.Offset(spaceSize), alloc.NumFreeAddresses(subnet))
|
alloc.Encode() // sync up
|
||||||
|
// Move the clock forward and clear out the dead container
|
||||||
|
alloc.actionChan <- func() { alloc.now = func() time.Time { return time.Now().Add(containerDiedTimeout * 2) } }
|
||||||
|
alloc.actionChan <- func() { alloc.removeDeadContainers() }
|
||||||
|
require.Equal(t, address.Count(spaceSize+1), alloc.NumFreeAddresses(subnet.Range()))
|
||||||
}
|
}
|
||||||
|
|
||||||
func TestBootstrap(t *testing.T) {
|
func TestBootstrap(t *testing.T) {
|
||||||
@@ -95,7 +117,7 @@ func TestBootstrap(t *testing.T) {
|
|||||||
ExpectBroadcastMessage(alloc1, nil) // alloc1 will try to form consensus
|
ExpectBroadcastMessage(alloc1, nil) // alloc1 will try to form consensus
|
||||||
done := make(chan bool)
|
done := make(chan bool)
|
||||||
go func() {
|
go func() {
|
||||||
alloc1.Allocate("somecontainer", subnet, returnFalse)
|
alloc1.Allocate("somecontainer", subnet, true, returnFalse)
|
||||||
done <- true
|
done <- true
|
||||||
}()
|
}()
|
||||||
time.Sleep(100 * time.Millisecond)
|
time.Sleep(100 * time.Millisecond)
|
||||||
@@ -103,6 +125,7 @@ func TestBootstrap(t *testing.T) {
|
|||||||
|
|
||||||
CheckAllExpectedMessagesSent(alloc1, alloc2)
|
CheckAllExpectedMessagesSent(alloc1, alloc2)
|
||||||
|
|
||||||
|
// Check that tryPendingOps doesn't cause anything to happen here
|
||||||
alloc1.actionChan <- func() { alloc1.tryPendingOps() }
|
alloc1.actionChan <- func() { alloc1.tryPendingOps() }
|
||||||
AssertNothingSent(t, done)
|
AssertNothingSent(t, done)
|
||||||
|
|
||||||
@@ -115,14 +138,24 @@ func TestBootstrap(t *testing.T) {
|
|||||||
ExpectBroadcastMessage(alloc1, nil)
|
ExpectBroadcastMessage(alloc1, nil)
|
||||||
alloc1.OnGossipBroadcast(alloc2.ourName, alloc2.Encode())
|
alloc1.OnGossipBroadcast(alloc2.ourName, alloc2.Encode())
|
||||||
|
|
||||||
// both nodes will get consensus now so initialize the ring
|
CheckAllExpectedMessagesSent(alloc1, alloc2)
|
||||||
ExpectBroadcastMessage(alloc2, nil)
|
|
||||||
|
// at this point, both nodes have seen each other, but don't have a valid proposal
|
||||||
|
// so there is another exchange of messages
|
||||||
ExpectBroadcastMessage(alloc2, nil)
|
ExpectBroadcastMessage(alloc2, nil)
|
||||||
alloc2.OnGossipBroadcast(alloc1.ourName, alloc1.Encode())
|
alloc2.OnGossipBroadcast(alloc1.ourName, alloc1.Encode())
|
||||||
|
|
||||||
|
// we have consensus now so alloc1 will initialize the ring
|
||||||
|
ExpectBroadcastMessage(alloc1, nil)
|
||||||
|
alloc1.OnGossipBroadcast(alloc2.ourName, alloc2.Encode())
|
||||||
|
|
||||||
|
CheckAllExpectedMessagesSent(alloc1, alloc2)
|
||||||
|
|
||||||
|
// alloc2 receives the ring and does not reply
|
||||||
|
alloc2.OnGossipBroadcast(alloc1.ourName, alloc1.Encode())
|
||||||
|
|
||||||
CheckAllExpectedMessagesSent(alloc1, alloc2)
|
CheckAllExpectedMessagesSent(alloc1, alloc2)
|
||||||
|
|
||||||
alloc1.OnGossipBroadcast(alloc2.ourName, alloc2.Encode())
|
|
||||||
// now alloc1 should have space
|
// now alloc1 should have space
|
||||||
|
|
||||||
AssertSent(t, done)
|
AssertSent(t, done)
|
||||||
@@ -135,42 +168,42 @@ func TestAllocatorClaim(t *testing.T) {
|
|||||||
container1 = "abcdef"
|
container1 = "abcdef"
|
||||||
container3 = "b01df00d"
|
container3 = "b01df00d"
|
||||||
universe = "10.0.3.0/24"
|
universe = "10.0.3.0/24"
|
||||||
testAddr1 = "10.0.3.2"
|
testAddr1 = "10.0.3.2/24"
|
||||||
testAddr2 = "10.0.4.2"
|
testAddr2 = "10.0.4.2/24"
|
||||||
)
|
)
|
||||||
|
|
||||||
allocs, _, subnet := makeNetworkOfAllocators(2, universe)
|
allocs, router, subnet := makeNetworkOfAllocators(2, universe)
|
||||||
|
defer stopNetworkOfAllocators(allocs, router)
|
||||||
alloc := allocs[1]
|
alloc := allocs[1]
|
||||||
defer alloc.Stop()
|
addr1, _ := address.ParseCIDR(testAddr1)
|
||||||
addr1, _ := address.ParseIP(testAddr1)
|
|
||||||
|
|
||||||
// First claim should trigger "dunno, I'm going to wait"
|
// First claim should trigger "dunno, I'm going to wait"
|
||||||
err := alloc.Claim(container3, addr1, true)
|
err := alloc.SimplyClaim(container3, addr1)
|
||||||
require.NoError(t, err)
|
require.NoError(t, err)
|
||||||
|
|
||||||
// Do one allocate to ensure paxos is all done
|
alloc.Prime()
|
||||||
alloc.Allocate("unused", subnet, returnFalse)
|
|
||||||
// Do an allocate on the other peer, which we will try to claim later
|
// Do an allocate on the other peer, which we will try to claim later
|
||||||
addrx, err := allocs[0].Allocate(container1, subnet, returnFalse)
|
addrx, err := allocs[0].Allocate(container1, subnet, true, returnFalse)
|
||||||
|
router.Flush()
|
||||||
|
|
||||||
// Now try the claim again
|
// Now try the claim again
|
||||||
err = alloc.Claim(container3, addr1, true)
|
err = alloc.SimplyClaim(container3, addr1)
|
||||||
require.NoError(t, err)
|
require.NoError(t, err)
|
||||||
// Check we get this address back if we try an allocate
|
// Check we get this address back if we try an allocate
|
||||||
addr3, _ := alloc.Allocate(container3, subnet, returnFalse)
|
addr3, _ := alloc.SimplyAllocate(container3, subnet)
|
||||||
require.Equal(t, testAddr1, addr3.String(), "address")
|
require.Equal(t, testAddr1, address.MakeCIDR(subnet, addr3).String(), "address")
|
||||||
// one more claim should still work
|
// one more claim should still work
|
||||||
err = alloc.Claim(container3, addr1, true)
|
err = alloc.SimplyClaim(container3, addr1)
|
||||||
require.NoError(t, err)
|
require.NoError(t, err)
|
||||||
// claim for a different container should fail
|
// claim for a different container should fail
|
||||||
err = alloc.Claim(container1, addr1, true)
|
err = alloc.SimplyClaim(container1, addr1)
|
||||||
require.Error(t, err)
|
require.Error(t, err)
|
||||||
// claiming the address allocated on the other peer should fail
|
// claiming the address allocated on the other peer should fail
|
||||||
err = alloc.Claim(container1, addrx, true)
|
err = alloc.SimplyClaim(container1, address.MakeCIDR(subnet, addrx))
|
||||||
require.Error(t, err, "claiming address allocated on other peer should fail")
|
require.Error(t, err, "claiming address allocated on other peer should fail")
|
||||||
// Check an address outside of our universe
|
// Check an address outside of our universe
|
||||||
addr2, _ := address.ParseIP(testAddr2)
|
addr2, _ := address.ParseCIDR(testAddr2)
|
||||||
err = alloc.Claim(container1, addr2, true)
|
err = alloc.SimplyClaim(container1, addr2)
|
||||||
require.NoError(t, err)
|
require.NoError(t, err)
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -187,16 +220,13 @@ func (alloc *Allocator) pause() func() {
|
|||||||
}
|
}
|
||||||
|
|
||||||
func TestCancel(t *testing.T) {
|
func TestCancel(t *testing.T) {
|
||||||
const (
|
const cidr = "10.0.1.7/26"
|
||||||
CIDR = "10.0.1.7/26"
|
|
||||||
)
|
|
||||||
|
|
||||||
router := gossip.NewTestRouter(0.0)
|
router := gossip.NewTestRouter(0.0)
|
||||||
|
|
||||||
alloc1, subnet := makeAllocator("01:00:00:02:00:00", CIDR, 2)
|
alloc1, subnet := makeAllocator("01:00:00:02:00:00", cidr, 2)
|
||||||
alloc1.SetInterfaces(router.Connect(alloc1.ourName, alloc1))
|
alloc1.SetInterfaces(router.Connect(alloc1.ourName, alloc1))
|
||||||
|
|
||||||
alloc2, _ := makeAllocator("02:00:00:02:00:00", CIDR, 2)
|
alloc2, _ := makeAllocator("02:00:00:02:00:00", cidr, 2)
|
||||||
alloc2.SetInterfaces(router.Connect(alloc2.ourName, alloc2))
|
alloc2.SetInterfaces(router.Connect(alloc2.ourName, alloc2))
|
||||||
alloc1.claimRingForTesting(alloc1, alloc2)
|
alloc1.claimRingForTesting(alloc1, alloc2)
|
||||||
alloc2.claimRingForTesting(alloc1, alloc2)
|
alloc2.claimRingForTesting(alloc1, alloc2)
|
||||||
@@ -208,9 +238,9 @@ func TestCancel(t *testing.T) {
|
|||||||
alloc1.OnGossipBroadcast(alloc2.ourName, alloc2.Encode())
|
alloc1.OnGossipBroadcast(alloc2.ourName, alloc2.Encode())
|
||||||
|
|
||||||
// Get some IPs, so each allocator has some space
|
// Get some IPs, so each allocator has some space
|
||||||
res1, _ := alloc1.Allocate("foo", subnet, returnFalse)
|
res1, _ := alloc1.Allocate("foo", subnet, true, returnFalse)
|
||||||
common.Log.Debugf("res1 = %s", res1.String())
|
common.Log.Debugf("res1 = %s", res1.String())
|
||||||
res2, _ := alloc2.Allocate("bar", subnet, returnFalse)
|
res2, _ := alloc2.Allocate("bar", subnet, true, returnFalse)
|
||||||
common.Log.Debugf("res2 = %s", res2.String())
|
common.Log.Debugf("res2 = %s", res2.String())
|
||||||
if res1 == res2 {
|
if res1 == res2 {
|
||||||
require.FailNow(t, "Error: got same ips!")
|
require.FailNow(t, "Error: got same ips!")
|
||||||
@@ -221,13 +251,13 @@ func TestCancel(t *testing.T) {
|
|||||||
unpause := alloc2.pause()
|
unpause := alloc2.pause()
|
||||||
|
|
||||||
// Use up all the IPs that alloc1 owns, so the allocation after this will prompt a request to alloc2
|
// Use up all the IPs that alloc1 owns, so the allocation after this will prompt a request to alloc2
|
||||||
for i := 0; alloc1.NumFreeAddresses(subnet) > 0; i++ {
|
for i := 0; alloc1.NumFreeAddresses(subnet.HostRange()) > 0; i++ {
|
||||||
alloc1.Allocate(fmt.Sprintf("tmp%d", i), subnet, returnFalse)
|
alloc1.Allocate(fmt.Sprintf("tmp%d", i), subnet, true, returnFalse)
|
||||||
}
|
}
|
||||||
cancelChan := make(chan bool, 1)
|
cancelChan := make(chan bool, 1)
|
||||||
doneChan := make(chan bool)
|
doneChan := make(chan bool)
|
||||||
go func() {
|
go func() {
|
||||||
_, ok := alloc1.Allocate("baz", subnet,
|
_, ok := alloc1.Allocate("baz", subnet, true,
|
||||||
func() bool {
|
func() bool {
|
||||||
select {
|
select {
|
||||||
case <-cancelChan:
|
case <-cancelChan:
|
||||||
@@ -251,18 +281,18 @@ func TestCancel(t *testing.T) {
|
|||||||
|
|
||||||
func TestCancelOnDied(t *testing.T) {
|
func TestCancelOnDied(t *testing.T) {
|
||||||
const (
|
const (
|
||||||
CIDR = "10.0.1.7/26"
|
cidr = "10.0.1.7/26"
|
||||||
container1 = "abcdef"
|
container1 = "abcdef"
|
||||||
)
|
)
|
||||||
|
|
||||||
router := gossip.NewTestRouter(0.0)
|
router := gossip.NewTestRouter(0.0)
|
||||||
alloc1, subnet := makeAllocator("01:00:00:02:00:00", CIDR, 2)
|
alloc1, subnet := makeAllocator("01:00:00:02:00:00", cidr, 2)
|
||||||
alloc1.SetInterfaces(router.Connect(alloc1.ourName, alloc1))
|
alloc1.SetInterfaces(router.Connect(alloc1.ourName, alloc1))
|
||||||
alloc1.Start()
|
alloc1.Start()
|
||||||
|
|
||||||
doneChan := make(chan bool)
|
doneChan := make(chan bool)
|
||||||
f := func() {
|
f := func() {
|
||||||
_, ok := alloc1.Allocate(container1, subnet, returnFalse)
|
_, ok := alloc1.Allocate(container1, subnet, true, returnFalse)
|
||||||
doneChan <- ok == nil
|
doneChan <- ok == nil
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -293,62 +323,65 @@ func TestGossipShutdown(t *testing.T) {
|
|||||||
defer alloc.Stop()
|
defer alloc.Stop()
|
||||||
|
|
||||||
alloc.claimRingForTesting()
|
alloc.claimRingForTesting()
|
||||||
alloc.Allocate(container1, subnet, returnFalse)
|
alloc.SimplyAllocate(container1, subnet)
|
||||||
|
|
||||||
alloc.Shutdown()
|
alloc.Shutdown()
|
||||||
|
|
||||||
_, err := alloc.Allocate(container2, subnet, returnFalse) // trying to allocate after shutdown should fail
|
_, err := alloc.SimplyAllocate(container2, subnet) // trying to allocate after shutdown should fail
|
||||||
require.False(t, err == nil, "no address")
|
require.False(t, err == nil, "no address")
|
||||||
|
|
||||||
CheckAllExpectedMessagesSent(alloc)
|
CheckAllExpectedMessagesSent(alloc)
|
||||||
}
|
}
|
||||||
|
|
||||||
func TestTransfer(t *testing.T) {
|
func TestTransfer(t *testing.T) {
|
||||||
const (
|
const cidr = "10.0.1.7/22"
|
||||||
cidr = "10.0.1.7/22"
|
|
||||||
)
|
|
||||||
allocs, router, subnet := makeNetworkOfAllocators(3, cidr)
|
allocs, router, subnet := makeNetworkOfAllocators(3, cidr)
|
||||||
alloc1 := allocs[0]
|
defer stopNetworkOfAllocators(allocs, router)
|
||||||
alloc2 := allocs[1]
|
alloc0 := allocs[0]
|
||||||
alloc3 := allocs[2] // This will be 'master' and get the first range
|
alloc1 := allocs[1]
|
||||||
|
alloc2 := allocs[2]
|
||||||
|
|
||||||
_, err := alloc2.Allocate("foo", subnet, returnFalse)
|
_, err := alloc1.Allocate("foo", subnet, true, returnFalse)
|
||||||
require.True(t, err == nil, "Failed to get address")
|
require.True(t, err == nil, "Failed to get address")
|
||||||
|
|
||||||
_, err = alloc3.Allocate("bar", subnet, returnFalse)
|
_, err = alloc2.Allocate("bar", subnet, true, returnFalse)
|
||||||
require.True(t, err == nil, "Failed to get address")
|
require.True(t, err == nil, "Failed to get address")
|
||||||
|
|
||||||
|
// simulation of periodic gossip
|
||||||
alloc2.gossip.GossipBroadcast(alloc2.Gossip())
|
alloc2.gossip.GossipBroadcast(alloc2.Gossip())
|
||||||
router.Flush()
|
router.Flush()
|
||||||
alloc2.gossip.GossipBroadcast(alloc3.Gossip())
|
alloc1.gossip.GossipBroadcast(alloc1.Gossip())
|
||||||
router.Flush()
|
router.Flush()
|
||||||
|
|
||||||
|
free1 := alloc1.NumFreeAddresses(subnet.Range())
|
||||||
|
free2 := alloc2.NumFreeAddresses(subnet.Range())
|
||||||
|
|
||||||
|
router.RemovePeer(alloc1.ourName)
|
||||||
router.RemovePeer(alloc2.ourName)
|
router.RemovePeer(alloc2.ourName)
|
||||||
router.RemovePeer(alloc3.ourName)
|
|
||||||
alloc2.Stop()
|
|
||||||
alloc3.Stop()
|
|
||||||
router.Flush()
|
|
||||||
require.NoError(t, alloc1.AdminTakeoverRanges(alloc2.ourName.String()))
|
|
||||||
require.NoError(t, alloc1.AdminTakeoverRanges(alloc3.ourName.String()))
|
|
||||||
router.Flush()
|
|
||||||
|
|
||||||
require.Equal(t, address.Offset(1022), alloc1.NumFreeAddresses(subnet))
|
|
||||||
|
|
||||||
_, err = alloc1.Allocate("foo", subnet, returnFalse)
|
|
||||||
require.True(t, err == nil, "Failed to get address")
|
|
||||||
alloc1.Stop()
|
alloc1.Stop()
|
||||||
|
alloc2.Stop()
|
||||||
|
router.Flush()
|
||||||
|
|
||||||
|
require.Equal(t, free1+1, alloc0.AdminTakeoverRanges(alloc1.ourName.String()))
|
||||||
|
require.Equal(t, free2+1, alloc0.AdminTakeoverRanges(alloc2.ourName.String()))
|
||||||
|
router.Flush()
|
||||||
|
|
||||||
|
require.Equal(t, address.Count(1024), alloc0.NumFreeAddresses(subnet.Range()))
|
||||||
|
|
||||||
|
_, err = alloc0.Allocate("foo", subnet, true, returnFalse)
|
||||||
|
require.True(t, err == nil, "Failed to get address")
|
||||||
|
alloc0.Stop()
|
||||||
}
|
}
|
||||||
|
|
||||||
func TestFakeRouterSimple(t *testing.T) {
|
func TestFakeRouterSimple(t *testing.T) {
|
||||||
const (
|
const cidr = "10.0.1.7/22"
|
||||||
cidr = "10.0.1.7/22"
|
allocs, router, subnet := makeNetworkOfAllocators(2, cidr)
|
||||||
)
|
defer stopNetworkOfAllocators(allocs, router)
|
||||||
allocs, _, subnet := makeNetworkOfAllocators(2, cidr)
|
|
||||||
defer stopNetworkOfAllocators(allocs)
|
|
||||||
|
|
||||||
alloc1 := allocs[0]
|
alloc1 := allocs[0]
|
||||||
//alloc2 := allocs[1]
|
//alloc2 := allocs[1]
|
||||||
|
|
||||||
_, err := alloc1.Allocate("foo", subnet, returnFalse)
|
_, err := alloc1.Allocate("foo", subnet, true, returnFalse)
|
||||||
require.NoError(t, err, "Failed to get address")
|
require.NoError(t, err, "Failed to get address")
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -361,8 +394,8 @@ func TestAllocatorFuzz(t *testing.T) {
|
|||||||
concurrency = 5
|
concurrency = 5
|
||||||
cidr = "10.0.1.7/22"
|
cidr = "10.0.1.7/22"
|
||||||
)
|
)
|
||||||
allocs, _, subnet := makeNetworkOfAllocators(nodes, cidr)
|
allocs, router, subnet := makeNetworkOfAllocators(nodes, cidr)
|
||||||
defer stopNetworkOfAllocators(allocs)
|
defer stopNetworkOfAllocators(allocs, router)
|
||||||
|
|
||||||
// Test state
|
// Test state
|
||||||
// For each IP issued we store the allocator
|
// For each IP issued we store the allocator
|
||||||
@@ -429,7 +462,7 @@ func TestAllocatorFuzz(t *testing.T) {
|
|||||||
allocIndex := rand.Int31n(nodes)
|
allocIndex := rand.Int31n(nodes)
|
||||||
alloc := allocs[allocIndex]
|
alloc := allocs[allocIndex]
|
||||||
//common.Log.Infof("Allocate: asking allocator %d", allocIndex)
|
//common.Log.Infof("Allocate: asking allocator %d", allocIndex)
|
||||||
addr, err := alloc.Allocate(name, subnet, returnFalse)
|
addr, err := alloc.SimplyAllocate(name, subnet)
|
||||||
|
|
||||||
if err != nil {
|
if err != nil {
|
||||||
panic(fmt.Sprintf("Could not allocate addr"))
|
panic(fmt.Sprintf("Could not allocate addr"))
|
||||||
@@ -486,7 +519,7 @@ func TestAllocatorFuzz(t *testing.T) {
|
|||||||
|
|
||||||
//common.Log.Infof("Asking for %s (%s) on allocator %d again", res.name, addr, res.alloc)
|
//common.Log.Infof("Asking for %s (%s) on allocator %d again", res.name, addr, res.alloc)
|
||||||
|
|
||||||
newAddr, _ := alloc.Allocate(res.name, subnet, returnFalse)
|
newAddr, _ := alloc.SimplyAllocate(res.name, subnet)
|
||||||
oldAddr, _ := address.ParseIP(addr)
|
oldAddr, _ := address.ParseIP(addr)
|
||||||
if newAddr != oldAddr {
|
if newAddr != oldAddr {
|
||||||
panic(fmt.Sprintf("Got different address for repeat request for %s: %s != %s", res.name, newAddr, oldAddr))
|
panic(fmt.Sprintf("Got different address for repeat request for %s: %s != %s", res.name, newAddr, oldAddr))
|
||||||
@@ -506,8 +539,8 @@ func TestAllocatorFuzz(t *testing.T) {
|
|||||||
allocIndex := rand.Int31n(nodes)
|
allocIndex := rand.Int31n(nodes)
|
||||||
addressIndex := rand.Int31n(int32(subnet.Size()))
|
addressIndex := rand.Int31n(int32(subnet.Size()))
|
||||||
alloc := allocs[allocIndex]
|
alloc := allocs[allocIndex]
|
||||||
addr := address.Add(subnet.Start, address.Offset(addressIndex))
|
addr := address.Add(subnet.Addr, address.Offset(addressIndex))
|
||||||
err := alloc.Claim(name, addr, true)
|
err := alloc.SimplyClaim(name, address.MakeCIDR(subnet, addr))
|
||||||
if err == nil {
|
if err == nil {
|
||||||
noteAllocation(allocIndex, name, addr)
|
noteAllocation(allocIndex, name, addr)
|
||||||
}
|
}
|
||||||
@@ -563,14 +596,36 @@ func TestAllocatorFuzz(t *testing.T) {
|
|||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
func TestGossipSkew(t *testing.T) {
|
func TestSpaceRequest(t *testing.T) {
|
||||||
alloc1, _ := makeAllocatorWithMockGossip(t, "01:00:00:01:00:00", "10.0.1.0/22", 2)
|
const (
|
||||||
defer alloc1.Stop()
|
container1 = "cont-1"
|
||||||
alloc2, _ := makeAllocatorWithMockGossip(t, "02:00:00:02:00:00", "10.0.1.0/22", 2)
|
container2 = "cont-2"
|
||||||
alloc2.now = func() time.Time { return time.Now().Add(time.Hour * 2) }
|
universe = "10.32.0.0/12"
|
||||||
defer alloc2.Stop()
|
)
|
||||||
|
allocs, router, subnet := makeNetworkOfAllocators(1, universe)
|
||||||
|
defer stopNetworkOfAllocators(allocs, router)
|
||||||
|
alloc1 := allocs[0]
|
||||||
|
|
||||||
if _, err := alloc1.OnGossipBroadcast(alloc2.ourName, alloc2.Encode()); err == nil {
|
addr, err := alloc1.Allocate(container1, subnet, true, returnFalse)
|
||||||
t.Fail()
|
require.Nil(t, err, "")
|
||||||
}
|
// free it again so the donation splits the range neatly
|
||||||
|
err = alloc1.Free(container1, addr)
|
||||||
|
require.Nil(t, err, "")
|
||||||
|
require.Equal(t, cidrRanges(universe), alloc1.OwnedRanges(), "")
|
||||||
|
|
||||||
|
// Start a new peer
|
||||||
|
alloc2, _ := makeAllocator("02:00:00:02:00:00", universe, 2)
|
||||||
|
alloc2.SetInterfaces(router.Connect(alloc2.ourName, alloc2))
|
||||||
|
alloc2.Start()
|
||||||
|
defer alloc2.Stop()
|
||||||
|
alloc2.Allocate(container2, subnet, true, returnFalse)
|
||||||
|
|
||||||
|
// Test whether the universe has been split into two equal halves (GH #2009)
|
||||||
|
require.Equal(t, cidrRanges("10.32.0.0/13"), alloc1.OwnedRanges(), "")
|
||||||
|
require.Equal(t, cidrRanges("10.40.0.0/13"), alloc2.OwnedRanges(), "")
|
||||||
|
}
|
||||||
|
|
||||||
|
func cidrRanges(s string) []address.Range {
|
||||||
|
c, _ := address.ParseCIDR(s)
|
||||||
|
return []address.Range{c.Range()}
|
||||||
}
|
}
|
||||||
+35
-17
@@ -3,16 +3,19 @@ package ipam
|
|||||||
import (
|
import (
|
||||||
"fmt"
|
"fmt"
|
||||||
|
|
||||||
|
"github.com/weaveworks/mesh"
|
||||||
|
|
||||||
"github.com/weaveworks/weave/common"
|
"github.com/weaveworks/weave/common"
|
||||||
"github.com/weaveworks/weave/mesh"
|
|
||||||
"github.com/weaveworks/weave/net/address"
|
"github.com/weaveworks/weave/net/address"
|
||||||
)
|
)
|
||||||
|
|
||||||
type claim struct {
|
type claim struct {
|
||||||
resultChan chan<- error
|
resultChan chan<- error
|
||||||
ident string
|
ident string
|
||||||
addr address.Address
|
cidr address.CIDR
|
||||||
|
isContainer bool
|
||||||
noErrorOnUnknown bool
|
noErrorOnUnknown bool
|
||||||
|
hasBeenCancelled func() bool
|
||||||
}
|
}
|
||||||
|
|
||||||
// Send an error (or nil for success) back to caller listening on resultChan
|
// Send an error (or nil for success) back to caller listening on resultChan
|
||||||
@@ -31,33 +34,41 @@ func (c *claim) sendResult(result error) {
|
|||||||
|
|
||||||
// Try returns true for success (or failure), false if we need to try again later
|
// Try returns true for success (or failure), false if we need to try again later
|
||||||
func (c *claim) Try(alloc *Allocator) bool {
|
func (c *claim) Try(alloc *Allocator) bool {
|
||||||
if !alloc.ring.Contains(c.addr) {
|
if c.hasBeenCancelled() {
|
||||||
|
c.Cancel()
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
|
if !alloc.ring.Contains(c.cidr.Addr) {
|
||||||
// Address not within our universe; assume user knows what they are doing
|
// Address not within our universe; assume user knows what they are doing
|
||||||
alloc.infof("Ignored address %s claimed by %s - not in our universe", c.addr, c.ident)
|
alloc.infof("Address %s claimed by %s - not in our range", c.cidr, c.ident)
|
||||||
|
alloc.addOwned(c.ident, c.cidr, c.isContainer)
|
||||||
c.sendResult(nil)
|
c.sendResult(nil)
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
|
|
||||||
alloc.establishRing()
|
alloc.establishRing()
|
||||||
|
|
||||||
switch owner := alloc.ring.Owner(c.addr); owner {
|
// If we had heard that this container died, resurrect it
|
||||||
|
delete(alloc.dead, c.ident) // (delete is no-op if key not in map)
|
||||||
|
|
||||||
|
switch owner := alloc.ring.Owner(c.cidr.Addr); owner {
|
||||||
case alloc.ourName:
|
case alloc.ourName:
|
||||||
// success
|
// success
|
||||||
case mesh.UnknownPeerName:
|
case mesh.UnknownPeerName:
|
||||||
// If our ring doesn't know, it must be empty.
|
// If our ring doesn't know, it must be empty.
|
||||||
|
alloc.infof("Claim %s for %s: is in the range %s, but the allocator is not initialized yet; will try later.",
|
||||||
|
c.cidr, c.ident, alloc.universe.AsCIDRString())
|
||||||
if c.noErrorOnUnknown {
|
if c.noErrorOnUnknown {
|
||||||
alloc.infof("Claim %s for %s: address allocator still initializing; will try later.", c.addr, c.ident)
|
|
||||||
c.sendResult(nil)
|
c.sendResult(nil)
|
||||||
} else {
|
|
||||||
c.sendResult(fmt.Errorf("%s is in the range %s, but the allocator is not initialized yet", c.addr, alloc.universe.AsCIDRString()))
|
|
||||||
}
|
}
|
||||||
return false
|
return false
|
||||||
default:
|
default:
|
||||||
alloc.debugf("requesting address %s from other peer %s", c.addr, owner)
|
alloc.debugf("requesting address %s from other peer %s", c.cidr, owner)
|
||||||
err := alloc.sendSpaceRequest(owner, address.NewRange(c.addr, 1))
|
err := alloc.sendSpaceRequest(owner, address.NewRange(c.cidr.Addr, 1))
|
||||||
if err != nil { // can't speak to owner right now
|
if err != nil { // can't speak to owner right now
|
||||||
if c.noErrorOnUnknown {
|
if c.noErrorOnUnknown {
|
||||||
alloc.infof("Claim %s for %s: %s; will try later.", c.addr, c.ident, err)
|
alloc.infof("Claim %s for %s: %s; will try later.", c.cidr, c.ident, err)
|
||||||
c.sendResult(nil)
|
c.sendResult(nil)
|
||||||
} else { // just tell the user they can't do this.
|
} else { // just tell the user they can't do this.
|
||||||
c.deniedBy(alloc, owner)
|
c.deniedBy(alloc, owner)
|
||||||
@@ -66,22 +77,29 @@ func (c *claim) Try(alloc *Allocator) bool {
|
|||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
|
|
||||||
|
if c.ident == "_" { // Special "I don't have a unique ID" identifier
|
||||||
|
c.ident = c.cidr.Addr.String()
|
||||||
|
}
|
||||||
// We are the owner, check we haven't given it to another container
|
// We are the owner, check we haven't given it to another container
|
||||||
switch existingIdent := alloc.findOwner(c.addr); existingIdent {
|
switch existingIdent := alloc.findOwner(c.cidr.Addr); existingIdent {
|
||||||
case "":
|
case "":
|
||||||
if err := alloc.space.Claim(c.addr); err == nil {
|
if err := alloc.space.Claim(c.cidr.Addr); err == nil {
|
||||||
alloc.debugln("Claimed", c.addr, "for", c.ident)
|
alloc.debugln("Claimed", c.cidr, "for", c.ident)
|
||||||
alloc.addOwned(c.ident, c.addr)
|
alloc.addOwned(c.ident, c.cidr, c.isContainer)
|
||||||
c.sendResult(nil)
|
c.sendResult(nil)
|
||||||
} else {
|
} else {
|
||||||
c.sendResult(err)
|
c.sendResult(err)
|
||||||
}
|
}
|
||||||
case c.ident:
|
case c.ident:
|
||||||
// same identifier is claiming same address; that's OK
|
// same identifier is claiming same address; that's OK
|
||||||
|
alloc.debugln("Re-Claimed", c.cidr, "for", c.ident)
|
||||||
c.sendResult(nil)
|
c.sendResult(nil)
|
||||||
|
case c.cidr.Addr.String():
|
||||||
|
// Address already allocated via "_" name
|
||||||
|
c.sendResult(fmt.Errorf("address %s already in use", c.cidr))
|
||||||
default:
|
default:
|
||||||
// Addr already owned by container on this machine
|
// Addr already owned by container on this machine
|
||||||
c.sendResult(fmt.Errorf("address %s is already owned by %s", c.addr.String(), existingIdent))
|
c.sendResult(fmt.Errorf("address %s is already owned by %s", c.cidr.String(), existingIdent))
|
||||||
}
|
}
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
@@ -91,7 +109,7 @@ func (c *claim) deniedBy(alloc *Allocator, owner mesh.PeerName) {
|
|||||||
if found {
|
if found {
|
||||||
name = " (" + name + ")"
|
name = " (" + name + ")"
|
||||||
}
|
}
|
||||||
c.sendResult(fmt.Errorf("address %s is owned by other peer %s%s", c.addr.String(), owner, name))
|
c.sendResult(fmt.Errorf("address %s is owned by other peer %s%s", c.cidr.String(), owner, name))
|
||||||
}
|
}
|
||||||
|
|
||||||
func (c *claim) Cancel() {
|
func (c *claim) Cancel() {
|
||||||
|
|||||||
+67
-44
@@ -16,91 +16,118 @@ func badRequest(w http.ResponseWriter, err error) {
|
|||||||
common.Log.Warningln("[allocator]:", err.Error())
|
common.Log.Warningln("[allocator]:", err.Error())
|
||||||
}
|
}
|
||||||
|
|
||||||
func parseCIDR(w http.ResponseWriter, cidrStr string) (address.CIDR, bool) {
|
func parseCIDR(w http.ResponseWriter, cidrStr string, net bool) (address.CIDR, bool) {
|
||||||
subnetAddr, cidr, err := address.ParseCIDR(cidrStr)
|
cidr, err := address.ParseCIDR(cidrStr)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
badRequest(w, err)
|
badRequest(w, err)
|
||||||
return address.CIDR{}, false
|
return address.CIDR{}, false
|
||||||
}
|
}
|
||||||
if cidr.Start != subnetAddr {
|
if net && !cidr.IsSubnet() {
|
||||||
badRequest(w, fmt.Errorf("Invalid subnet %s - bits after network prefix are not all zero", cidrStr))
|
badRequest(w, fmt.Errorf("Invalid subnet %s - bits after network prefix are not all zero", cidrStr))
|
||||||
return address.CIDR{}, false
|
return address.CIDR{}, false
|
||||||
}
|
}
|
||||||
return cidr, true
|
return cidr, true
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func writeAddresses(w http.ResponseWriter, cidrs []address.CIDR) {
|
||||||
|
for i, cidr := range cidrs {
|
||||||
|
fmt.Fprint(w, cidr)
|
||||||
|
if i < len(cidrs)-1 {
|
||||||
|
w.Write([]byte{' '})
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func hasBeenCanceled(dockerCli *docker.Client, closedChan <-chan bool, ident string, checkAlive bool) func() bool {
|
||||||
|
return func() bool {
|
||||||
|
select {
|
||||||
|
case <-closedChan:
|
||||||
|
return true
|
||||||
|
default:
|
||||||
|
res := checkAlive && dockerCli != nil && dockerCli.IsContainerNotRunning(ident)
|
||||||
|
checkAlive = false // we check only once; if the container dies later we learn about that through events
|
||||||
|
return res
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func cancellationErr(w http.ResponseWriter, err error) bool {
|
||||||
|
if _, ok := err.(*errorCancelled); ok {
|
||||||
|
common.Log.Infoln("[allocator]:", err.Error())
|
||||||
|
fmt.Fprint(w, "cancelled")
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
func (alloc *Allocator) handleHTTPAllocate(dockerCli *docker.Client, w http.ResponseWriter, ident string, checkAlive bool, subnet address.CIDR) {
|
func (alloc *Allocator) handleHTTPAllocate(dockerCli *docker.Client, w http.ResponseWriter, ident string, checkAlive bool, subnet address.CIDR) {
|
||||||
closedChan := w.(http.CloseNotifier).CloseNotify()
|
addr, err := alloc.Allocate(ident, subnet, checkAlive,
|
||||||
addr, err := alloc.Allocate(ident, subnet.HostRange(),
|
hasBeenCanceled(dockerCli, w.(http.CloseNotifier).CloseNotify(), ident, checkAlive))
|
||||||
func() bool {
|
|
||||||
select {
|
|
||||||
case <-closedChan:
|
|
||||||
return true
|
|
||||||
default:
|
|
||||||
res := checkAlive && dockerCli != nil && dockerCli.IsContainerNotRunning(ident)
|
|
||||||
checkAlive = false // we check only once; if the container dies later we learn about that through events
|
|
||||||
return res
|
|
||||||
}
|
|
||||||
})
|
|
||||||
if err != nil {
|
if err != nil {
|
||||||
if _, ok := err.(*errorCancelled); ok { // cancellation is not really an error
|
if !cancellationErr(w, err) {
|
||||||
common.Log.Infoln("[allocator]:", err.Error())
|
badRequest(w, err)
|
||||||
fmt.Fprint(w, "cancelled")
|
|
||||||
return
|
|
||||||
}
|
}
|
||||||
badRequest(w, err)
|
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
fmt.Fprintf(w, "%s/%d", addr, subnet.PrefixLen)
|
fmt.Fprintf(w, "%s/%d", addr, subnet.PrefixLen)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func (alloc *Allocator) handleHTTPClaim(dockerCli *docker.Client, w http.ResponseWriter, ident string, cidr address.CIDR, checkAlive, noErrorOnUnknown bool) {
|
||||||
|
err := alloc.Claim(ident, cidr, checkAlive, noErrorOnUnknown,
|
||||||
|
hasBeenCanceled(dockerCli, w.(http.CloseNotifier).CloseNotify(), ident, checkAlive))
|
||||||
|
if err != nil {
|
||||||
|
if !cancellationErr(w, err) {
|
||||||
|
badRequest(w, fmt.Errorf("Unable to claim: %s", err))
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
w.WriteHeader(204)
|
||||||
|
}
|
||||||
|
|
||||||
// HandleHTTP wires up ipams HTTP endpoints to the provided mux.
|
// HandleHTTP wires up ipams HTTP endpoints to the provided mux.
|
||||||
func (alloc *Allocator) HandleHTTP(router *mux.Router, defaultSubnet address.CIDR, dockerCli *docker.Client) {
|
func (alloc *Allocator) HandleHTTP(router *mux.Router, defaultSubnet address.CIDR, dockerCli *docker.Client) {
|
||||||
router.Methods("GET").Path("/ipinfo/defaultsubnet").HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
router.Methods("GET").Path("/ipinfo/defaultsubnet").HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||||
fmt.Fprintf(w, "%s", defaultSubnet)
|
fmt.Fprintf(w, "%s", defaultSubnet)
|
||||||
})
|
})
|
||||||
|
|
||||||
router.Methods("PUT").Path("/ip/{id}/{ip}").HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
router.Methods("PUT").Path("/ip/{id}/{ip}/{prefixlen}").HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||||
vars := mux.Vars(r)
|
vars := mux.Vars(r)
|
||||||
ident := vars["id"]
|
if cidr, ok := parseCIDR(w, vars["ip"]+"/"+vars["prefixlen"], false); ok {
|
||||||
ipStr := vars["ip"]
|
ident := vars["id"]
|
||||||
noErrorOnUnknown := r.FormValue("noErrorOnUnknown") == "true"
|
checkAlive := r.FormValue("check-alive") == "true"
|
||||||
if ip, err := address.ParseIP(ipStr); err != nil {
|
noErrorOnUnknown := r.FormValue("noErrorOnUnknown") == "true"
|
||||||
badRequest(w, err)
|
alloc.handleHTTPClaim(dockerCli, w, ident, cidr, checkAlive, noErrorOnUnknown)
|
||||||
return
|
|
||||||
} else if err := alloc.Claim(ident, ip, noErrorOnUnknown); err != nil {
|
|
||||||
badRequest(w, fmt.Errorf("Unable to claim: %s", err))
|
|
||||||
return
|
|
||||||
}
|
}
|
||||||
|
})
|
||||||
|
|
||||||
w.WriteHeader(204)
|
router.Methods("GET").Path("/ring").HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||||
|
alloc.Prime()
|
||||||
})
|
})
|
||||||
|
|
||||||
router.Methods("GET").Path("/ip/{id}/{ip}/{prefixlen}").HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
router.Methods("GET").Path("/ip/{id}/{ip}/{prefixlen}").HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||||
vars := mux.Vars(r)
|
vars := mux.Vars(r)
|
||||||
if subnet, ok := parseCIDR(w, vars["ip"]+"/"+vars["prefixlen"]); ok {
|
if subnet, ok := parseCIDR(w, vars["ip"]+"/"+vars["prefixlen"], true); ok {
|
||||||
addr, err := alloc.Lookup(vars["id"], subnet.HostRange())
|
cidrs, err := alloc.Lookup(vars["id"], subnet.HostRange())
|
||||||
if err != nil {
|
if err != nil {
|
||||||
http.NotFound(w, r)
|
http.NotFound(w, r)
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
fmt.Fprintf(w, "%s/%d", addr, subnet.PrefixLen)
|
writeAddresses(w, cidrs)
|
||||||
}
|
}
|
||||||
})
|
})
|
||||||
|
|
||||||
router.Methods("GET").Path("/ip/{id}").HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
router.Methods("GET").Path("/ip/{id}").HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||||
addr, err := alloc.Lookup(mux.Vars(r)["id"], defaultSubnet.HostRange())
|
addrs, err := alloc.Lookup(mux.Vars(r)["id"], defaultSubnet.HostRange())
|
||||||
if err != nil {
|
if err != nil {
|
||||||
http.NotFound(w, r)
|
http.NotFound(w, r)
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
fmt.Fprintf(w, "%s/%d", addr, defaultSubnet.PrefixLen)
|
writeAddresses(w, addrs)
|
||||||
})
|
})
|
||||||
|
|
||||||
router.Methods("POST").Path("/ip/{id}/{ip}/{prefixlen}").HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
router.Methods("POST").Path("/ip/{id}/{ip}/{prefixlen}").HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||||
vars := mux.Vars(r)
|
vars := mux.Vars(r)
|
||||||
if subnet, ok := parseCIDR(w, vars["ip"]+"/"+vars["prefixlen"]); ok {
|
if subnet, ok := parseCIDR(w, vars["ip"]+"/"+vars["prefixlen"], true); ok {
|
||||||
alloc.handleHTTPAllocate(dockerCli, w, vars["id"], r.FormValue("check-alive") == "true", subnet)
|
alloc.handleHTTPAllocate(dockerCli, w, vars["id"], r.FormValue("check-alive") == "true", subnet)
|
||||||
}
|
}
|
||||||
})
|
})
|
||||||
@@ -142,11 +169,7 @@ func (alloc *Allocator) HandleHTTP(router *mux.Router, defaultSubnet address.CID
|
|||||||
|
|
||||||
router.Methods("DELETE").Path("/peer/{id}").HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
router.Methods("DELETE").Path("/peer/{id}").HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||||
ident := mux.Vars(r)["id"]
|
ident := mux.Vars(r)["id"]
|
||||||
if err := alloc.AdminTakeoverRanges(ident); err != nil {
|
transferred := alloc.AdminTakeoverRanges(ident)
|
||||||
badRequest(w, err)
|
fmt.Fprintf(w, "%d IPs taken over from %s\n", transferred, ident)
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
w.WriteHeader(204)
|
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
+13
-17
@@ -80,7 +80,7 @@ func TestHttp(t *testing.T) {
|
|||||||
)
|
)
|
||||||
|
|
||||||
alloc, _ := makeAllocatorWithMockGossip(t, "08:00:27:01:c3:9a", universe, 1)
|
alloc, _ := makeAllocatorWithMockGossip(t, "08:00:27:01:c3:9a", universe, 1)
|
||||||
_, cidr, _ := address.ParseCIDR(universe)
|
cidr, _ := address.ParseCIDR(universe)
|
||||||
port := listenHTTP(alloc, cidr)
|
port := listenHTTP(alloc, cidr)
|
||||||
alloc.claimRingForTesting()
|
alloc.claimRingForTesting()
|
||||||
|
|
||||||
@@ -122,7 +122,7 @@ func TestBadHttp(t *testing.T) {
|
|||||||
|
|
||||||
alloc, _ := makeAllocatorWithMockGossip(t, "08:00:27:01:c3:9a", testCIDR1, 1)
|
alloc, _ := makeAllocatorWithMockGossip(t, "08:00:27:01:c3:9a", testCIDR1, 1)
|
||||||
defer alloc.Stop()
|
defer alloc.Stop()
|
||||||
_, cidr, _ := address.ParseCIDR(testCIDR1)
|
cidr, _ := address.ParseCIDR(testCIDR1)
|
||||||
port := listenHTTP(alloc, cidr)
|
port := listenHTTP(alloc, cidr)
|
||||||
|
|
||||||
alloc.claimRingForTesting()
|
alloc.claimRingForTesting()
|
||||||
@@ -149,29 +149,25 @@ func TestHTTPCancel(t *testing.T) {
|
|||||||
testCIDR1 = "10.0.3.0/29"
|
testCIDR1 = "10.0.3.0/29"
|
||||||
)
|
)
|
||||||
|
|
||||||
alloc, _ := makeAllocatorWithMockGossip(t, "08:00:27:01:c3:9a", testCIDR1, 1)
|
// Say quorum=2, so the allocate won't go ahead
|
||||||
|
alloc, _ := makeAllocatorWithMockGossip(t, "08:00:27:01:c3:9a", testCIDR1, 2)
|
||||||
defer alloc.Stop()
|
defer alloc.Stop()
|
||||||
alloc.claimRingForTesting()
|
ExpectBroadcastMessage(alloc, nil) // trying to form consensus
|
||||||
_, cidr, _ := address.ParseCIDR(testCIDR1)
|
cidr, _ := address.ParseCIDR(testCIDR1)
|
||||||
port := listenHTTP(alloc, cidr)
|
port := listenHTTP(alloc, cidr)
|
||||||
|
|
||||||
// Stop the alloc so nothing actually works
|
|
||||||
unpause := alloc.pause()
|
|
||||||
|
|
||||||
// Ask the http server for a new address
|
// Ask the http server for a new address
|
||||||
done := make(chan *http.Response)
|
|
||||||
req, _ := http.NewRequest("POST", allocURL(port, testCIDR1, containerID), nil)
|
req, _ := http.NewRequest("POST", allocURL(port, testCIDR1, containerID), nil)
|
||||||
|
// On another goroutine, wait for a bit then cancel the request
|
||||||
go func() {
|
go func() {
|
||||||
res, _ := http.DefaultClient.Do(req)
|
time.Sleep(100 * time.Millisecond)
|
||||||
done <- res
|
common.Log.Debug("Cancelling allocate")
|
||||||
|
http.DefaultTransport.(*http.Transport).CancelRequest(req)
|
||||||
}()
|
}()
|
||||||
|
|
||||||
time.Sleep(100 * time.Millisecond)
|
res, _ := http.DefaultClient.Do(req)
|
||||||
fmt.Println("Cancelling allocate")
|
|
||||||
http.DefaultTransport.(*http.Transport).CancelRequest(req)
|
|
||||||
unpause()
|
|
||||||
res := <-done
|
|
||||||
if res != nil {
|
if res != nil {
|
||||||
require.FailNow(t, "Error: Allocate returned non-nil")
|
body, _ := ioutil.ReadAll(res.Body)
|
||||||
|
require.FailNow(t, "Error: Allocate returned non-nil", string(body))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -0,0 +1,44 @@
|
|||||||
|
package paxos
|
||||||
|
|
||||||
|
type Participant interface {
|
||||||
|
GossipState() GossipState
|
||||||
|
Update(from GossipState) bool
|
||||||
|
SetQuorum(uint)
|
||||||
|
Propose()
|
||||||
|
Think() bool
|
||||||
|
Consensus() (bool, AcceptedValue)
|
||||||
|
IsElector() bool
|
||||||
|
}
|
||||||
|
|
||||||
|
type Observer struct {
|
||||||
|
}
|
||||||
|
|
||||||
|
func NewObserver() Participant {
|
||||||
|
return &Observer{}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (observer *Observer) GossipState() GossipState {
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func (observer *Observer) Update(from GossipState) bool {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
func (observer *Observer) Propose() {
|
||||||
|
}
|
||||||
|
|
||||||
|
func (observer *Observer) SetQuorum(uint) {
|
||||||
|
}
|
||||||
|
|
||||||
|
func (observer *Observer) Think() bool {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
func (observer *Observer) Consensus() (bool, AcceptedValue) {
|
||||||
|
return false, AcceptedValue{}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (observer *Observer) IsElector() bool {
|
||||||
|
return false
|
||||||
|
}
|
||||||
+17
-5
@@ -1,7 +1,7 @@
|
|||||||
package paxos
|
package paxos
|
||||||
|
|
||||||
import (
|
import (
|
||||||
"github.com/weaveworks/weave/mesh"
|
"github.com/weaveworks/mesh"
|
||||||
)
|
)
|
||||||
|
|
||||||
// The node identifier. The use of the UID here is important: Paxos
|
// The node identifier. The use of the UID here is important: Paxos
|
||||||
@@ -80,6 +80,10 @@ func NewNode(name mesh.PeerName, uid mesh.PeerUID, quorum uint) *Node {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func (node *Node) SetQuorum(quorum uint) {
|
||||||
|
node.quorum = quorum
|
||||||
|
}
|
||||||
|
|
||||||
func (node *Node) GossipState() GossipState {
|
func (node *Node) GossipState() GossipState {
|
||||||
return node.knows
|
return node.knows
|
||||||
}
|
}
|
||||||
@@ -124,6 +128,9 @@ func max(a uint, b uint) uint {
|
|||||||
// simply a matter of gossipping a new proposal that supersedes all
|
// simply a matter of gossipping a new proposal that supersedes all
|
||||||
// others.
|
// others.
|
||||||
func (node *Node) Propose() {
|
func (node *Node) Propose() {
|
||||||
|
if node.quorum == 0 {
|
||||||
|
panic("Paxos node.Propose() called with no quorum set")
|
||||||
|
}
|
||||||
// Find the highest round number around
|
// Find the highest round number around
|
||||||
round := uint(0)
|
round := uint(0)
|
||||||
|
|
||||||
@@ -234,6 +241,9 @@ func (node *Node) pickValue() Value {
|
|||||||
|
|
||||||
// Has a consensus been reached, based on the known claims of other nodes?
|
// Has a consensus been reached, based on the known claims of other nodes?
|
||||||
func (node *Node) Consensus() (bool, AcceptedValue) {
|
func (node *Node) Consensus() (bool, AcceptedValue) {
|
||||||
|
if node.quorum == 0 {
|
||||||
|
return false, AcceptedValue{}
|
||||||
|
}
|
||||||
counts := map[ProposalID]uint{}
|
counts := map[ProposalID]uint{}
|
||||||
|
|
||||||
for _, claims := range node.knows {
|
for _, claims := range node.knows {
|
||||||
@@ -250,14 +260,16 @@ func (node *Node) Consensus() (bool, AcceptedValue) {
|
|||||||
return false, AcceptedValue{}
|
return false, AcceptedValue{}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func (node *Node) IsElector() bool {
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
type Status struct {
|
type Status struct {
|
||||||
|
Elector bool
|
||||||
KnownNodes int
|
KnownNodes int
|
||||||
Quorum uint
|
Quorum uint
|
||||||
}
|
}
|
||||||
|
|
||||||
func NewStatus(node *Node) *Status {
|
func NewStatus(node *Node) *Status {
|
||||||
if node == nil {
|
return &Status{true, len(node.knows), node.quorum}
|
||||||
return nil
|
|
||||||
}
|
|
||||||
return &Status{len(node.knows), node.quorum}
|
|
||||||
}
|
}
|
||||||
@@ -6,7 +6,7 @@ import (
|
|||||||
"testing"
|
"testing"
|
||||||
"time"
|
"time"
|
||||||
|
|
||||||
"github.com/weaveworks/weave/mesh"
|
"github.com/weaveworks/mesh"
|
||||||
)
|
)
|
||||||
|
|
||||||
type TestNode struct {
|
type TestNode struct {
|
||||||
@@ -300,14 +300,14 @@ func (m *Model) validate() {
|
|||||||
for i := range m.nodes {
|
for i := range m.nodes {
|
||||||
ok, val := m.nodes[i].Consensus()
|
ok, val := m.nodes[i].Consensus()
|
||||||
if !ok {
|
if !ok {
|
||||||
//m.dump()
|
m.dump()
|
||||||
m.t.Fatal("Node doesn't know about consensus")
|
m.t.Fatal("Node doesn't know about consensus")
|
||||||
}
|
}
|
||||||
|
|
||||||
firstConsensus := m.nodes[i].firstConsensus
|
firstConsensus := m.nodes[i].firstConsensus
|
||||||
if firstConsensus.Origin.valid() &&
|
if firstConsensus.Origin.valid() &&
|
||||||
firstConsensus.Origin != val.Origin {
|
firstConsensus.Origin != val.Origin {
|
||||||
//m.dump()
|
m.dump()
|
||||||
m.t.Fatal("Consensus mismatch")
|
m.t.Fatal("Consensus mismatch")
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -0,0 +1,24 @@
|
|||||||
|
package ipam
|
||||||
|
|
||||||
|
type prime struct {
|
||||||
|
resultChan chan<- struct{}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (c *prime) Try(alloc *Allocator) bool {
|
||||||
|
if !alloc.ring.Empty() {
|
||||||
|
close(c.resultChan)
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
|
alloc.establishRing()
|
||||||
|
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
func (c *prime) Cancel() {
|
||||||
|
close(c.resultChan)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (c *prime) ForContainer(ident string) bool {
|
||||||
|
return false
|
||||||
|
}
|
||||||
+3
-1
@@ -3,8 +3,9 @@ package ring
|
|||||||
import (
|
import (
|
||||||
"sort"
|
"sort"
|
||||||
|
|
||||||
|
"github.com/weaveworks/mesh"
|
||||||
|
|
||||||
"github.com/weaveworks/weave/common"
|
"github.com/weaveworks/weave/common"
|
||||||
"github.com/weaveworks/weave/mesh"
|
|
||||||
"github.com/weaveworks/weave/net/address"
|
"github.com/weaveworks/weave/net/address"
|
||||||
)
|
)
|
||||||
|
|
||||||
@@ -14,6 +15,7 @@ type entry struct {
|
|||||||
Peer mesh.PeerName // Who owns this range
|
Peer mesh.PeerName // Who owns this range
|
||||||
Version uint32 // Version of this range
|
Version uint32 // Version of this range
|
||||||
Free address.Offset // Number of free IPs in this range
|
Free address.Offset // Number of free IPs in this range
|
||||||
|
// Note: Free should perhaps be an address.Count, but we can't change the wire protocol
|
||||||
}
|
}
|
||||||
|
|
||||||
func (e *entry) Equal(e2 *entry) bool {
|
func (e *entry) Equal(e2 *entry) bool {
|
||||||
|
|||||||
+40
-41
@@ -12,8 +12,9 @@ import (
|
|||||||
"sort"
|
"sort"
|
||||||
"time"
|
"time"
|
||||||
|
|
||||||
|
"github.com/weaveworks/mesh"
|
||||||
|
|
||||||
"github.com/weaveworks/weave/common"
|
"github.com/weaveworks/weave/common"
|
||||||
"github.com/weaveworks/weave/mesh"
|
|
||||||
"github.com/weaveworks/weave/net/address"
|
"github.com/weaveworks/weave/net/address"
|
||||||
)
|
)
|
||||||
|
|
||||||
@@ -39,40 +40,51 @@ var (
|
|||||||
ErrTokenOutOfRange = errors.New("Token is out of range")
|
ErrTokenOutOfRange = errors.New("Token is out of range")
|
||||||
ErrDifferentSeeds = errors.New("Received ring was seeded differently from ours!")
|
ErrDifferentSeeds = errors.New("Received ring was seeded differently from ours!")
|
||||||
ErrDifferentRange = errors.New("Received range differs from ours!")
|
ErrDifferentRange = errors.New("Received range differs from ours!")
|
||||||
ErrNewerVersion = errors.New("Received new version for entry I own!")
|
|
||||||
ErrInvalidEntry = errors.New("Received invalid state update!")
|
|
||||||
ErrEntryInMyRange = errors.New("Received new entry in my range!")
|
|
||||||
ErrNotFound = errors.New("No entries for peer found")
|
ErrNotFound = errors.New("No entries for peer found")
|
||||||
)
|
)
|
||||||
|
|
||||||
|
func errInconsistentEntry(mine, theirs *entry) error {
|
||||||
|
return fmt.Errorf("Inconsistent entries for %s: owned by %s but incoming message says %s", mine.Token, mine.Peer, theirs.Peer)
|
||||||
|
}
|
||||||
|
func errEntryInMyRange(theirs *entry) error {
|
||||||
|
return fmt.Errorf("Peer %s says it owns the IP range from %s, which I think I own", theirs.Peer, theirs.Token)
|
||||||
|
}
|
||||||
|
func errNewerVersion(mine, theirs *entry) error {
|
||||||
|
return fmt.Errorf("Received update for IP range I own at %s v%d: incoming message says owner %s v%d", mine.Token, mine.Version, theirs.Peer, theirs.Version)
|
||||||
|
}
|
||||||
|
|
||||||
func (r *Ring) checkInvariants() error {
|
func (r *Ring) checkInvariants() error {
|
||||||
if !sort.IsSorted(r.Entries) {
|
return r.checkEntries(r.Entries)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (r *Ring) checkEntries(entries entries) error {
|
||||||
|
if !sort.IsSorted(entries) {
|
||||||
return ErrNotSorted
|
return ErrNotSorted
|
||||||
}
|
}
|
||||||
|
|
||||||
// Check no token appears twice
|
// Check no token appears twice
|
||||||
// We know it's sorted...
|
// We know it's sorted...
|
||||||
for i := 1; i < len(r.Entries); i++ {
|
for i := 1; i < len(entries); i++ {
|
||||||
if r.Entries[i-1].Token == r.Entries[i].Token {
|
if entries[i-1].Token == entries[i].Token {
|
||||||
return ErrTokenRepeated
|
return ErrTokenRepeated
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
if len(r.Entries) == 0 {
|
if len(entries) == 0 {
|
||||||
return nil
|
return nil
|
||||||
}
|
}
|
||||||
|
|
||||||
// Check tokens are in range
|
// Check tokens are in range
|
||||||
if r.Entries.entry(0).Token < r.Start {
|
if entries.entry(0).Token < r.Start {
|
||||||
return ErrTokenOutOfRange
|
return ErrTokenOutOfRange
|
||||||
}
|
}
|
||||||
if r.Entries.entry(-1).Token >= r.End {
|
if entries.entry(-1).Token >= r.End {
|
||||||
return ErrTokenOutOfRange
|
return ErrTokenOutOfRange
|
||||||
}
|
}
|
||||||
|
|
||||||
// Check all the freespaces are in range
|
// Check all the freespaces are in range
|
||||||
for i, entry := range r.Entries {
|
for i, entry := range entries {
|
||||||
next := r.Entries.entry(i + 1)
|
next := entries.entry(i + 1)
|
||||||
distance := r.distance(entry.Token, next.Token)
|
distance := r.distance(entry.Token, next.Token)
|
||||||
|
|
||||||
if entry.Free > distance {
|
if entry.Free > distance {
|
||||||
@@ -181,7 +193,6 @@ func (r *Ring) GrantRangeToHost(start, end address.Address, peer mesh.PeerName)
|
|||||||
// Merge the given ring into this ring and return any new ranges added
|
// Merge the given ring into this ring and return any new ranges added
|
||||||
func (r *Ring) Merge(gossip Ring) error {
|
func (r *Ring) Merge(gossip Ring) error {
|
||||||
r.assertInvariants()
|
r.assertInvariants()
|
||||||
defer r.assertInvariants()
|
|
||||||
defer r.updateExportedVariables()
|
defer r.updateExportedVariables()
|
||||||
|
|
||||||
// Don't panic when checking the gossiped in ring.
|
// Don't panic when checking the gossiped in ring.
|
||||||
@@ -223,7 +234,7 @@ func (r *Ring) Merge(gossip Ring) error {
|
|||||||
case mine.Token > theirs.Token:
|
case mine.Token > theirs.Token:
|
||||||
// insert, checking that a range owned by us hasn't been split
|
// insert, checking that a range owned by us hasn't been split
|
||||||
if previousOwner != nil && *previousOwner == r.Peer && theirs.Peer != r.Peer {
|
if previousOwner != nil && *previousOwner == r.Peer && theirs.Peer != r.Peer {
|
||||||
return ErrEntryInMyRange
|
return errEntryInMyRange(theirs)
|
||||||
}
|
}
|
||||||
addToResult(*theirs)
|
addToResult(*theirs)
|
||||||
previousOwner = nil
|
previousOwner = nil
|
||||||
@@ -233,14 +244,13 @@ func (r *Ring) Merge(gossip Ring) error {
|
|||||||
switch {
|
switch {
|
||||||
case mine.Version >= theirs.Version:
|
case mine.Version >= theirs.Version:
|
||||||
if mine.Version == theirs.Version && !mine.Equal(theirs) {
|
if mine.Version == theirs.Version && !mine.Equal(theirs) {
|
||||||
common.Log.Debugf("Error merging entries at %s - %v != %v", mine.Token, mine, theirs)
|
return errInconsistentEntry(mine, theirs)
|
||||||
return ErrInvalidEntry
|
|
||||||
}
|
}
|
||||||
addToResult(*mine)
|
addToResult(*mine)
|
||||||
previousOwner = &mine.Peer
|
previousOwner = &mine.Peer
|
||||||
case mine.Version < theirs.Version:
|
case mine.Version < theirs.Version:
|
||||||
if mine.Peer == r.Peer { // We shouldn't receive updates to our own tokens
|
if mine.Peer == r.Peer { // We shouldn't receive updates to our own tokens
|
||||||
return ErrNewerVersion
|
return errNewerVersion(mine, theirs)
|
||||||
}
|
}
|
||||||
addToResult(*theirs)
|
addToResult(*theirs)
|
||||||
previousOwner = nil
|
previousOwner = nil
|
||||||
@@ -261,12 +271,16 @@ func (r *Ring) Merge(gossip Ring) error {
|
|||||||
for ; j < len(gossip.Entries); j++ {
|
for ; j < len(gossip.Entries); j++ {
|
||||||
theirs = gossip.Entries[j]
|
theirs = gossip.Entries[j]
|
||||||
if previousOwner != nil && *previousOwner == r.Peer && theirs.Peer != r.Peer {
|
if previousOwner != nil && *previousOwner == r.Peer && theirs.Peer != r.Peer {
|
||||||
return ErrEntryInMyRange
|
return errEntryInMyRange(theirs)
|
||||||
}
|
}
|
||||||
addToResult(*theirs)
|
addToResult(*theirs)
|
||||||
previousOwner = nil
|
previousOwner = nil
|
||||||
}
|
}
|
||||||
|
|
||||||
|
if err := r.checkEntries(result); err != nil {
|
||||||
|
return fmt.Errorf("Merge of incoming data causes: %s", err)
|
||||||
|
}
|
||||||
|
|
||||||
if len(r.Seeds) == 0 {
|
if len(r.Seeds) == 0 {
|
||||||
r.Seeds = gossip.Seeds
|
r.Seeds = gossip.Seeds
|
||||||
}
|
}
|
||||||
@@ -355,12 +369,7 @@ func (r *Ring) ClaimForPeers(peers []mesh.PeerName) {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
if e, found := r.Entries.get(pos); found {
|
r.Entries.insert(entry{Token: pos, Peer: peer, Free: share})
|
||||||
e.update(peer, share)
|
|
||||||
} else {
|
|
||||||
r.Entries.insert(entry{Token: pos, Peer: peer, Free: share})
|
|
||||||
}
|
|
||||||
|
|
||||||
pos += address.Address(share)
|
pos += address.Address(share)
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -391,7 +400,7 @@ func (r *Ring) String() string {
|
|||||||
// ReportFree is used by the allocator to tell the ring how many free
|
// ReportFree is used by the allocator to tell the ring how many free
|
||||||
// ips are in a given range, so that ChoosePeersToAskForSpace can make
|
// ips are in a given range, so that ChoosePeersToAskForSpace can make
|
||||||
// more intelligent decisions.
|
// more intelligent decisions.
|
||||||
func (r *Ring) ReportFree(freespace map[address.Address]address.Offset) {
|
func (r *Ring) ReportFree(freespace map[address.Address]address.Count) {
|
||||||
r.assertInvariants()
|
r.assertInvariants()
|
||||||
defer r.assertInvariants()
|
defer r.assertInvariants()
|
||||||
defer r.updateExportedVariables()
|
defer r.updateExportedVariables()
|
||||||
@@ -421,13 +430,13 @@ func (r *Ring) ReportFree(freespace map[address.Address]address.Offset) {
|
|||||||
// Check we're not reporting more space than the range
|
// Check we're not reporting more space than the range
|
||||||
entry, next := entries.entry(i), entries.entry(i+1)
|
entry, next := entries.entry(i), entries.entry(i+1)
|
||||||
maxSize := r.distance(entry.Token, next.Token)
|
maxSize := r.distance(entry.Token, next.Token)
|
||||||
common.Assert(free <= maxSize)
|
common.Assert(free <= address.Count(maxSize))
|
||||||
|
|
||||||
if entries[i].Free == free {
|
if address.Count(entries[i].Free) == free {
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
entries[i].Free = free
|
entries[i].Free = address.Offset(free)
|
||||||
entries[i].Version++
|
entries[i].Version++
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -446,10 +455,7 @@ func (ws weightedPeers) Swap(i, j int) { ws[i], ws[j] = ws[j], ws[i] }
|
|||||||
// ChoosePeersToAskForSpace returns all peers we can ask for space in
|
// ChoosePeersToAskForSpace returns all peers we can ask for space in
|
||||||
// the range [start, end), in weighted-random order. Assumes start<end.
|
// the range [start, end), in weighted-random order. Assumes start<end.
|
||||||
func (r *Ring) ChoosePeersToAskForSpace(start, end address.Address) []mesh.PeerName {
|
func (r *Ring) ChoosePeersToAskForSpace(start, end address.Address) []mesh.PeerName {
|
||||||
var (
|
totalSpacePerPeer := make(map[mesh.PeerName]address.Offset)
|
||||||
sum address.Offset
|
|
||||||
totalSpacePerPeer = make(map[mesh.PeerName]address.Offset) // Compute total free space per peer
|
|
||||||
)
|
|
||||||
|
|
||||||
// iterate through tokens
|
// iterate through tokens
|
||||||
for i, entry := range r.Entries {
|
for i, entry := range r.Entries {
|
||||||
@@ -471,7 +477,6 @@ func (r *Ring) ChoosePeersToAskForSpace(start, end address.Address) []mesh.PeerN
|
|||||||
}
|
}
|
||||||
|
|
||||||
totalSpacePerPeer[entry.Peer] += entry.Free
|
totalSpacePerPeer[entry.Peer] += entry.Free
|
||||||
sum += entry.Free
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// Compute weighted random numbers, then sort.
|
// Compute weighted random numbers, then sort.
|
||||||
@@ -500,28 +505,22 @@ func (r *Ring) PickPeerForTransfer(isValid func(mesh.PeerName) bool) mesh.PeerNa
|
|||||||
|
|
||||||
// Transfer will mark all entries associated with 'from' peer as owned by 'to' peer
|
// Transfer will mark all entries associated with 'from' peer as owned by 'to' peer
|
||||||
// and return ranges indicating the new space we picked up
|
// and return ranges indicating the new space we picked up
|
||||||
func (r *Ring) Transfer(from, to mesh.PeerName) ([]address.Range, error) {
|
func (r *Ring) Transfer(from, to mesh.PeerName) []address.Range {
|
||||||
r.assertInvariants()
|
r.assertInvariants()
|
||||||
defer r.assertInvariants()
|
defer r.assertInvariants()
|
||||||
defer r.updateExportedVariables()
|
defer r.updateExportedVariables()
|
||||||
|
|
||||||
var newRanges []address.Range
|
var newRanges []address.Range
|
||||||
found := false
|
|
||||||
|
|
||||||
for i, entry := range r.Entries {
|
for i, entry := range r.Entries {
|
||||||
if entry.Peer == from {
|
if entry.Peer == from {
|
||||||
found = true
|
|
||||||
entry.Peer = to
|
entry.Peer = to
|
||||||
entry.Version++
|
entry.Version++
|
||||||
newRanges = append(newRanges, address.Range{Start: entry.Token, End: r.Entries.entry(i + 1).Token})
|
newRanges = append(newRanges, address.Range{Start: entry.Token, End: r.Entries.entry(i + 1).Token})
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
if !found {
|
return r.splitRangesOverZero(newRanges)
|
||||||
return nil, ErrNotFound
|
|
||||||
}
|
|
||||||
|
|
||||||
return r.splitRangesOverZero(newRanges), nil
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// Contains returns true if addr is in this ring
|
// Contains returns true if addr is in this ring
|
||||||
|
|||||||
+44
-14
@@ -8,8 +8,9 @@ import (
|
|||||||
"testing"
|
"testing"
|
||||||
|
|
||||||
"github.com/stretchr/testify/require"
|
"github.com/stretchr/testify/require"
|
||||||
|
"github.com/weaveworks/mesh"
|
||||||
|
|
||||||
"github.com/weaveworks/weave/common"
|
"github.com/weaveworks/weave/common"
|
||||||
"github.com/weaveworks/weave/mesh"
|
|
||||||
"github.com/weaveworks/weave/net/address"
|
"github.com/weaveworks/weave/net/address"
|
||||||
)
|
)
|
||||||
|
|
||||||
@@ -59,13 +60,19 @@ func TestInsert(t *testing.T) {
|
|||||||
|
|
||||||
ring.Entries.entry(0).Free = 0
|
ring.Entries.entry(0).Free = 0
|
||||||
ring.Entries.insert(entry{Token: dot245, Peer: peer1name})
|
ring.Entries.insert(entry{Token: dot245, Peer: peer1name})
|
||||||
ring2 := New(start, end, peer1name)
|
check := []RangeInfo{
|
||||||
ring2.Entries = []*entry{{Token: start, Peer: peer1name, Free: 0}, {Token: dot245, Peer: peer1name}}
|
{Peer: peer1name, Range: address.Range{Start: start, End: dot245}},
|
||||||
require.Equal(t, ring2, ring)
|
{Peer: peer1name, Range: address.Range{Start: dot245, End: end}},
|
||||||
|
}
|
||||||
|
require.Equal(t, check, ring.AllRangeInfo())
|
||||||
|
|
||||||
ring.Entries.insert(entry{Token: dot10, Peer: peer1name})
|
ring.Entries.insert(entry{Token: dot10, Peer: peer1name})
|
||||||
ring2.Entries = []*entry{{Token: start, Peer: peer1name, Free: 0}, {Token: dot10, Peer: peer1name}, {Token: dot245, Peer: peer1name}}
|
check2 := []RangeInfo{
|
||||||
require.Equal(t, ring2, ring)
|
{Peer: peer1name, Range: address.Range{Start: start, End: dot10}},
|
||||||
|
{Peer: peer1name, Range: address.Range{Start: dot10, End: dot245}},
|
||||||
|
{Peer: peer1name, Range: address.Range{Start: dot245, End: end}},
|
||||||
|
}
|
||||||
|
require.Equal(t, check2, ring.AllRangeInfo())
|
||||||
}
|
}
|
||||||
|
|
||||||
func TestBetween(t *testing.T) {
|
func TestBetween(t *testing.T) {
|
||||||
@@ -218,17 +225,18 @@ func TestMergeErrors(t *testing.T) {
|
|||||||
ring2 = New(start, end, peer2name)
|
ring2 = New(start, end, peer2name)
|
||||||
ring1.Entries = []*entry{{Token: start, Peer: peer1name}}
|
ring1.Entries = []*entry{{Token: start, Peer: peer1name}}
|
||||||
ring2.Entries = []*entry{{Token: start, Peer: peer1name, Version: 1}}
|
ring2.Entries = []*entry{{Token: start, Peer: peer1name, Version: 1}}
|
||||||
require.True(t, ring1.Merge(*ring2) == ErrNewerVersion, "Expected ErrNewerVersion")
|
fmt.Println(ring1.Merge(*ring2))
|
||||||
|
require.Error(t, ring1.Merge(*ring2), "Expected error")
|
||||||
|
|
||||||
// Cannot Merge two entries with same version but different hosts
|
// Cannot Merge two entries with same version but different hosts
|
||||||
ring1.Entries = []*entry{{Token: start, Peer: peer1name}}
|
ring1.Entries = []*entry{{Token: start, Peer: peer1name}}
|
||||||
ring2.Entries = []*entry{{Token: start, Peer: peer2name}}
|
ring2.Entries = []*entry{{Token: start, Peer: peer2name}}
|
||||||
require.True(t, ring1.Merge(*ring2) == ErrInvalidEntry, "Expected ErrInvalidEntry")
|
require.Error(t, ring1.Merge(*ring2), "Expected error")
|
||||||
|
|
||||||
// Cannot Merge an entry into a range I own
|
// Cannot Merge an entry into a range I own
|
||||||
ring1.Entries = []*entry{{Token: start, Peer: peer1name}}
|
ring1.Entries = []*entry{{Token: start, Peer: peer1name}}
|
||||||
ring2.Entries = []*entry{{Token: middle, Peer: peer2name}}
|
ring2.Entries = []*entry{{Token: middle, Peer: peer2name}}
|
||||||
require.True(t, ring1.Merge(*ring2) == ErrEntryInMyRange, "Expected ErrEntryInMyRange")
|
require.Error(t, ring1.Merge(*ring2), "Expected error")
|
||||||
}
|
}
|
||||||
|
|
||||||
func TestMergeMore(t *testing.T) {
|
func TestMergeMore(t *testing.T) {
|
||||||
@@ -366,7 +374,7 @@ func TestFindFree(t *testing.T) {
|
|||||||
assertPeersWithSpace(t, ring1, start, end, 0)
|
assertPeersWithSpace(t, ring1, start, end, 0)
|
||||||
|
|
||||||
// We shouldn't return outselves
|
// We shouldn't return outselves
|
||||||
ring1.ReportFree(map[address.Address]address.Offset{start: 10})
|
ring1.ReportFree(map[address.Address]address.Count{start: 10})
|
||||||
assertPeersWithSpace(t, ring1, start, end, 0)
|
assertPeersWithSpace(t, ring1, start, end, 0)
|
||||||
|
|
||||||
ring1.Entries = []*entry{{Token: start, Peer: peer1name, Free: 1},
|
ring1.Entries = []*entry{{Token: start, Peer: peer1name, Free: 1},
|
||||||
@@ -401,7 +409,7 @@ func TestReportFree(t *testing.T) {
|
|||||||
ring1.GrantRangeToHost(middle, end, peer2name)
|
ring1.GrantRangeToHost(middle, end, peer2name)
|
||||||
require.NoError(t, ring2.Merge(*ring1))
|
require.NoError(t, ring2.Merge(*ring1))
|
||||||
|
|
||||||
freespace := make(map[address.Address]address.Offset)
|
freespace := make(map[address.Address]address.Count)
|
||||||
for _, r := range ring2.OwnedRanges() {
|
for _, r := range ring2.OwnedRanges() {
|
||||||
freespace[r.Start] = 0
|
freespace[r.Start] = 0
|
||||||
}
|
}
|
||||||
@@ -505,6 +513,29 @@ func TestOwner(t *testing.T) {
|
|||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func makePeerName(i int) mesh.PeerName {
|
||||||
|
if i >= 10000 {
|
||||||
|
panic("makePeerName: invalid value")
|
||||||
|
}
|
||||||
|
peer, _ := mesh.PeerNameFromString(fmt.Sprintf("%02d:%02d:00:00:00:ff", i/100, i%100))
|
||||||
|
return peer
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestClaimForPeers(t *testing.T) {
|
||||||
|
const numPeers = 12
|
||||||
|
// Different end to usual so we get a number of addresses that a)
|
||||||
|
// is smaller than the max number of peers, and b) is divisible by
|
||||||
|
// some number of peers. This maximises coverage of edge cases.
|
||||||
|
end := dot10
|
||||||
|
peers := make([]mesh.PeerName, numPeers)
|
||||||
|
// Test for a range of peer counts
|
||||||
|
for i := 0; i < numPeers; i++ {
|
||||||
|
peers[i] = makePeerName(i)
|
||||||
|
ring := New(start, end, peers[0])
|
||||||
|
ring.ClaimForPeers(peers[:i+1])
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
type addressSlice []address.Address
|
type addressSlice []address.Address
|
||||||
|
|
||||||
func (s addressSlice) Len() int { return len(s) }
|
func (s addressSlice) Len() int { return len(s) }
|
||||||
@@ -519,8 +550,7 @@ func TestFuzzRing(t *testing.T) {
|
|||||||
|
|
||||||
peers := make([]mesh.PeerName, numPeers)
|
peers := make([]mesh.PeerName, numPeers)
|
||||||
for i := 0; i < numPeers; i++ {
|
for i := 0; i < numPeers; i++ {
|
||||||
peer, _ := mesh.PeerNameFromString(fmt.Sprintf("%02d:00:00:00:02:00", i))
|
peers[i] = makePeerName(i)
|
||||||
peers[i] = peer
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// Make a valid, random ring
|
// Make a valid, random ring
|
||||||
@@ -607,7 +637,7 @@ func TestFuzzRingHard(t *testing.T) {
|
|||||||
)
|
)
|
||||||
|
|
||||||
addPeer := func() {
|
addPeer := func() {
|
||||||
peer, _ := mesh.PeerNameFromString(fmt.Sprintf("%02d:%02d:00:00:00:00", nextPeerID/10, nextPeerID%10))
|
peer := makePeerName(nextPeerID)
|
||||||
common.Log.Debugf("%s: Adding peer", peer)
|
common.Log.Debugf("%s: Adding peer", peer)
|
||||||
nextPeerID++
|
nextPeerID++
|
||||||
peers = append(peers, peer)
|
peers = append(peers, peer)
|
||||||
|
|||||||
+13
-5
@@ -31,8 +31,8 @@ func (s *Space) Add(start address.Address, size address.Offset) {
|
|||||||
|
|
||||||
// Clear removes all spaces from this space set. Used during node shutdown.
|
// Clear removes all spaces from this space set. Used during node shutdown.
|
||||||
func (s *Space) Clear() {
|
func (s *Space) Clear() {
|
||||||
s.free = s.free[:0]
|
|
||||||
s.ours = s.ours[:0]
|
s.ours = s.ours[:0]
|
||||||
|
s.free = s.free[:0]
|
||||||
}
|
}
|
||||||
|
|
||||||
// Walk down the free list calling f() on the in-range portions, until
|
// Walk down the free list calling f() on the in-range portions, until
|
||||||
@@ -88,8 +88,16 @@ func (s *Space) Claim(addr address.Address) error {
|
|||||||
return nil
|
return nil
|
||||||
}
|
}
|
||||||
|
|
||||||
func (s *Space) NumFreeAddressesInRange(r address.Range) address.Offset {
|
func (s *Space) NumFreeAddresses() address.Count {
|
||||||
res := address.Offset(0)
|
res := address.Count(0)
|
||||||
|
for i := 0; i < len(s.free); i += 2 {
|
||||||
|
res += address.Length(s.free[i+1], s.free[i])
|
||||||
|
}
|
||||||
|
return res
|
||||||
|
}
|
||||||
|
|
||||||
|
func (s *Space) NumFreeAddressesInRange(r address.Range) address.Count {
|
||||||
|
res := address.Count(0)
|
||||||
s.walkFree(r, func(chunk address.Range) bool {
|
s.walkFree(r, func(chunk address.Range) bool {
|
||||||
res += chunk.Size()
|
res += chunk.Size()
|
||||||
return false
|
return false
|
||||||
@@ -111,7 +119,7 @@ func (s *Space) Free(addr address.Address) error {
|
|||||||
}
|
}
|
||||||
|
|
||||||
func (s *Space) biggestFreeRange(r address.Range) (biggest address.Range) {
|
func (s *Space) biggestFreeRange(r address.Range) (biggest address.Range) {
|
||||||
biggestSize := address.Offset(0)
|
biggestSize := address.Count(0)
|
||||||
s.walkFree(r, func(chunk address.Range) bool {
|
s.walkFree(r, func(chunk address.Range) bool {
|
||||||
if size := chunk.Size(); size >= biggestSize {
|
if size := chunk.Size(); size >= biggestSize {
|
||||||
biggest = chunk
|
biggest = chunk
|
||||||
@@ -131,7 +139,7 @@ func (s *Space) Donate(r address.Range) (address.Range, bool) {
|
|||||||
|
|
||||||
// Donate half of that biggest free range. Note size/2 rounds down, so
|
// Donate half of that biggest free range. Note size/2 rounds down, so
|
||||||
// the resulting donation size rounds up, and in particular can't be empty.
|
// the resulting donation size rounds up, and in particular can't be empty.
|
||||||
biggest.Start = address.Add(biggest.Start, biggest.Size()/2)
|
biggest.Start = address.Add(biggest.Start, address.Offset(biggest.Size()/2))
|
||||||
|
|
||||||
s.ours = subtract(s.ours, biggest.Start, biggest.End)
|
s.ours = subtract(s.ours, biggest.Start, biggest.End)
|
||||||
s.free = subtract(s.free, biggest.Start, biggest.End)
|
s.free = subtract(s.free, biggest.Start, biggest.End)
|
||||||
|
|||||||
+20
-30
@@ -19,16 +19,6 @@ func ip(s string) address.Address {
|
|||||||
return addr
|
return addr
|
||||||
}
|
}
|
||||||
|
|
||||||
// Helper function to avoid 'NumFreeAddressesInRange(start, end)'
|
|
||||||
// dozens of times in tests
|
|
||||||
func (s *Space) NumFreeAddresses() address.Offset {
|
|
||||||
res := address.Offset(0)
|
|
||||||
for i := 0; i < len(s.free); i += 2 {
|
|
||||||
res += address.Subtract(s.free[i+1], s.free[i])
|
|
||||||
}
|
|
||||||
return res
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestLowlevel(t *testing.T) {
|
func TestLowlevel(t *testing.T) {
|
||||||
a := []address.Address{}
|
a := []address.Address{}
|
||||||
a = add(a, 100, 200)
|
a = add(a, 100, 200)
|
||||||
@@ -61,19 +51,19 @@ func TestLowlevel(t *testing.T) {
|
|||||||
require.Equal(t, []address.Address{}, a)
|
require.Equal(t, []address.Address{}, a)
|
||||||
|
|
||||||
s := New()
|
s := New()
|
||||||
require.Equal(t, address.Offset(0), s.NumFreeAddresses())
|
require.Equal(t, address.Count(0), s.NumFreeAddresses())
|
||||||
ok, got := s.Allocate(address.NewRange(0, 1000))
|
ok, got := s.Allocate(address.NewRange(0, 1000))
|
||||||
require.False(t, ok, "allocate in empty space should fail")
|
require.False(t, ok, "allocate in empty space should fail")
|
||||||
|
|
||||||
s.Add(100, 100)
|
s.Add(100, 100)
|
||||||
require.Equal(t, address.Offset(100), s.NumFreeAddresses())
|
require.Equal(t, address.Count(100), s.NumFreeAddresses())
|
||||||
ok, got = s.Allocate(address.NewRange(0, 1000))
|
ok, got = s.Allocate(address.NewRange(0, 1000))
|
||||||
require.True(t, ok && got == 100, "allocate")
|
require.True(t, ok && got == 100, "allocate")
|
||||||
require.Equal(t, address.Offset(99), s.NumFreeAddresses())
|
require.Equal(t, address.Count(99), s.NumFreeAddresses())
|
||||||
require.NoError(t, s.Claim(150))
|
require.NoError(t, s.Claim(150))
|
||||||
require.Equal(t, address.Offset(98), s.NumFreeAddresses())
|
require.Equal(t, address.Count(98), s.NumFreeAddresses())
|
||||||
require.NoError(t, s.Free(100))
|
require.NoError(t, s.Free(100))
|
||||||
require.Equal(t, address.Offset(99), s.NumFreeAddresses())
|
require.Equal(t, address.Count(99), s.NumFreeAddresses())
|
||||||
wt.AssertErrorInterface(t, (*error)(nil), s.Free(0), "free not allocated")
|
wt.AssertErrorInterface(t, (*error)(nil), s.Free(0), "free not allocated")
|
||||||
wt.AssertErrorInterface(t, (*error)(nil), s.Free(100), "double free")
|
wt.AssertErrorInterface(t, (*error)(nil), s.Free(100), "double free")
|
||||||
|
|
||||||
@@ -107,19 +97,19 @@ func TestSpaceAllocate(t *testing.T) {
|
|||||||
)
|
)
|
||||||
|
|
||||||
space1 := makeSpace(start, size)
|
space1 := makeSpace(start, size)
|
||||||
require.Equal(t, address.Offset(20), space1.NumFreeAddresses())
|
require.Equal(t, address.Count(20), space1.NumFreeAddresses())
|
||||||
space1.assertInvariants()
|
space1.assertInvariants()
|
||||||
|
|
||||||
_, addr1 := space1.Allocate(address.NewRange(start, size))
|
_, addr1 := space1.Allocate(address.NewRange(start, size))
|
||||||
require.Equal(t, testAddr1, addr1.String(), "address")
|
require.Equal(t, testAddr1, addr1.String(), "address")
|
||||||
require.Equal(t, address.Offset(19), space1.NumFreeAddresses())
|
require.Equal(t, address.Count(19), space1.NumFreeAddresses())
|
||||||
space1.assertInvariants()
|
space1.assertInvariants()
|
||||||
|
|
||||||
_, addr2 := space1.Allocate(address.NewRange(start, size))
|
_, addr2 := space1.Allocate(address.NewRange(start, size))
|
||||||
require.False(t, addr2.String() == testAddr1, "address")
|
require.False(t, addr2.String() == testAddr1, "address")
|
||||||
require.Equal(t, address.Offset(18), space1.NumFreeAddresses())
|
require.Equal(t, address.Count(18), space1.NumFreeAddresses())
|
||||||
require.Equal(t, address.Offset(13), space1.NumFreeAddressesInRange(address.Range{Start: ip(testAddr1), End: ip(testAddrx)}))
|
require.Equal(t, address.Count(13), space1.NumFreeAddressesInRange(address.Range{Start: ip(testAddr1), End: ip(testAddrx)}))
|
||||||
require.Equal(t, address.Offset(18), space1.NumFreeAddressesInRange(address.Range{Start: ip(testAddr1), End: ip(testAddry)}))
|
require.Equal(t, address.Count(18), space1.NumFreeAddressesInRange(address.Range{Start: ip(testAddr1), End: ip(testAddry)}))
|
||||||
space1.assertInvariants()
|
space1.assertInvariants()
|
||||||
|
|
||||||
space1.Free(addr2)
|
space1.Free(addr2)
|
||||||
@@ -155,7 +145,7 @@ func TestSpaceFree(t *testing.T) {
|
|||||||
// Check we are full
|
// Check we are full
|
||||||
ok, _ := space.Allocate(entireRange)
|
ok, _ := space.Allocate(entireRange)
|
||||||
require.True(t, !ok, "Should have failed to get address")
|
require.True(t, !ok, "Should have failed to get address")
|
||||||
r, ok = space.Donate(entireRange)
|
r, _ = space.Donate(entireRange)
|
||||||
require.True(t, r.Size() == 0, "Wrong space")
|
require.True(t, r.Size() == 0, "Wrong space")
|
||||||
|
|
||||||
// Free in the middle
|
// Free in the middle
|
||||||
@@ -172,7 +162,7 @@ func TestSpaceFree(t *testing.T) {
|
|||||||
require.NoError(t, space.Free(ip("10.0.3.22")))
|
require.NoError(t, space.Free(ip("10.0.3.22")))
|
||||||
require.NoError(t, space.Free(ip("10.0.3.21")))
|
require.NoError(t, space.Free(ip("10.0.3.21")))
|
||||||
|
|
||||||
require.Equal(t, address.Offset(4), space.NumFreeAddresses())
|
require.Equal(t, address.Count(4), space.NumFreeAddresses())
|
||||||
|
|
||||||
// Now get the biggest free space; should be 3.21
|
// Now get the biggest free space; should be 3.21
|
||||||
r = space.biggestFreeRange(entireRange)
|
r = space.biggestFreeRange(entireRange)
|
||||||
@@ -183,7 +173,7 @@ func TestSpaceFree(t *testing.T) {
|
|||||||
require.NoError(t, space.Free(ip("10.0.3.11")))
|
require.NoError(t, space.Free(ip("10.0.3.11")))
|
||||||
require.NoError(t, space.Free(ip("10.0.3.10")))
|
require.NoError(t, space.Free(ip("10.0.3.10")))
|
||||||
|
|
||||||
require.Equal(t, address.Offset(7), space.NumFreeAddresses())
|
require.Equal(t, address.Count(7), space.NumFreeAddresses())
|
||||||
|
|
||||||
// Now get the biggest free space; should be 3.21
|
// Now get the biggest free space; should be 3.21
|
||||||
r = space.biggestFreeRange(entireRange)
|
r = space.biggestFreeRange(entireRange)
|
||||||
@@ -210,8 +200,8 @@ func TestDonateSimple(t *testing.T) {
|
|||||||
numGivenUp := r.Size()
|
numGivenUp := r.Size()
|
||||||
require.True(t, ok, "Donate result")
|
require.True(t, ok, "Donate result")
|
||||||
require.Equal(t, "10.0.1.24", r.Start.String(), "Invalid start")
|
require.Equal(t, "10.0.1.24", r.Start.String(), "Invalid start")
|
||||||
require.Equal(t, address.Offset(size/2), numGivenUp)
|
require.Equal(t, address.Count(size/2), numGivenUp)
|
||||||
require.Equal(t, address.Offset(size/2), ps1.NumFreeAddresses())
|
require.Equal(t, address.Count(size/2), ps1.NumFreeAddresses())
|
||||||
|
|
||||||
// Now check we can give the rest up.
|
// Now check we can give the rest up.
|
||||||
count := 0 // count to avoid infinite loop
|
count := 0 // count to avoid infinite loop
|
||||||
@@ -222,8 +212,8 @@ func TestDonateSimple(t *testing.T) {
|
|||||||
}
|
}
|
||||||
numGivenUp += r.Size()
|
numGivenUp += r.Size()
|
||||||
}
|
}
|
||||||
require.Equal(t, address.Offset(0), ps1.NumFreeAddresses())
|
require.Equal(t, address.Count(0), ps1.NumFreeAddresses())
|
||||||
require.Equal(t, address.Offset(size), numGivenUp)
|
require.Equal(t, address.Count(size), numGivenUp)
|
||||||
}
|
}
|
||||||
|
|
||||||
func TestDonateHard(t *testing.T) {
|
func TestDonateHard(t *testing.T) {
|
||||||
@@ -240,7 +230,7 @@ func TestDonateHard(t *testing.T) {
|
|||||||
require.True(t, ok, "Failed to get IP!")
|
require.True(t, ok, "Failed to get IP!")
|
||||||
}
|
}
|
||||||
|
|
||||||
require.Equal(t, address.Offset(0), spaceset.NumFreeAddresses())
|
require.Equal(t, address.Count(0), spaceset.NumFreeAddresses())
|
||||||
|
|
||||||
// Now free all but the last address
|
// Now free all but the last address
|
||||||
// this will force us to split the free list
|
// this will force us to split the free list
|
||||||
@@ -252,8 +242,8 @@ func TestDonateHard(t *testing.T) {
|
|||||||
newRange, ok := spaceset.Donate(address.NewRange(start, size))
|
newRange, ok := spaceset.Donate(address.NewRange(start, size))
|
||||||
require.True(t, ok, "GiveUpSpace result")
|
require.True(t, ok, "GiveUpSpace result")
|
||||||
require.Equal(t, ip("10.0.1.23"), newRange.Start)
|
require.Equal(t, ip("10.0.1.23"), newRange.Start)
|
||||||
require.Equal(t, address.Offset(24), newRange.Size())
|
require.Equal(t, address.Count(24), newRange.Size())
|
||||||
require.Equal(t, address.Offset(23), spaceset.NumFreeAddresses())
|
require.Equal(t, address.Count(23), spaceset.NumFreeAddresses())
|
||||||
|
|
||||||
//Space set should now have 2 spaces
|
//Space set should now have 2 spaces
|
||||||
expected := New()
|
expected := New()
|
||||||
|
|||||||
+11
-5
@@ -26,8 +26,8 @@ type EntryStatus struct {
|
|||||||
}
|
}
|
||||||
|
|
||||||
type ClaimStatus struct {
|
type ClaimStatus struct {
|
||||||
Ident string
|
Ident string
|
||||||
Address address.Address
|
CIDR address.CIDR
|
||||||
}
|
}
|
||||||
|
|
||||||
func NewStatus(allocator *Allocator, defaultSubnet address.CIDR) *Status {
|
func NewStatus(allocator *Allocator, defaultSubnet address.CIDR) *Status {
|
||||||
@@ -36,8 +36,14 @@ func NewStatus(allocator *Allocator, defaultSubnet address.CIDR) *Status {
|
|||||||
}
|
}
|
||||||
|
|
||||||
var paxosStatus *paxos.Status
|
var paxosStatus *paxos.Status
|
||||||
if allocator.paxosTicker != nil {
|
if allocator.awaitingConsensus && allocator.paxos != nil {
|
||||||
paxosStatus = paxos.NewStatus(allocator.paxos)
|
if allocator.paxos.IsElector() {
|
||||||
|
if node, ok := allocator.paxos.(*paxos.Node); ok {
|
||||||
|
paxosStatus = paxos.NewStatus(node)
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
paxosStatus = &paxos.Status{Elector: false}
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
resultChan := make(chan *Status)
|
resultChan := make(chan *Status)
|
||||||
@@ -80,7 +86,7 @@ func newClaimStatusSlice(allocator *Allocator) []ClaimStatus {
|
|||||||
var slice []ClaimStatus
|
var slice []ClaimStatus
|
||||||
for _, op := range allocator.pendingClaims {
|
for _, op := range allocator.pendingClaims {
|
||||||
claim := op.(*claim)
|
claim := op.(*claim)
|
||||||
slice = append(slice, ClaimStatus{claim.ident, claim.addr})
|
slice = append(slice, ClaimStatus{claim.ident, claim.cidr})
|
||||||
}
|
}
|
||||||
return slice
|
return slice
|
||||||
}
|
}
|
||||||
|
|||||||
+37
-15
@@ -7,8 +7,9 @@ import (
|
|||||||
"testing"
|
"testing"
|
||||||
"time"
|
"time"
|
||||||
|
|
||||||
|
"github.com/weaveworks/mesh"
|
||||||
|
|
||||||
"github.com/stretchr/testify/require"
|
"github.com/stretchr/testify/require"
|
||||||
"github.com/weaveworks/weave/mesh"
|
|
||||||
"github.com/weaveworks/weave/net/address"
|
"github.com/weaveworks/weave/net/address"
|
||||||
"github.com/weaveworks/weave/testing/gossip"
|
"github.com/weaveworks/weave/testing/gossip"
|
||||||
)
|
)
|
||||||
@@ -48,7 +49,7 @@ func (m *mockGossipComms) String() string {
|
|||||||
// that the contents of messages are never re-ordered. Which, for instance,
|
// that the contents of messages are never re-ordered. Which, for instance,
|
||||||
// requires they are not based off iterating through a map.
|
// requires they are not based off iterating through a map.
|
||||||
|
|
||||||
func (m *mockGossipComms) GossipBroadcast(update mesh.GossipData) error {
|
func (m *mockGossipComms) GossipBroadcast(update mesh.GossipData) {
|
||||||
m.Lock()
|
m.Lock()
|
||||||
defer m.Unlock()
|
defer m.Unlock()
|
||||||
buf := []byte{}
|
buf := []byte{}
|
||||||
@@ -62,7 +63,6 @@ func (m *mockGossipComms) GossipBroadcast(update mesh.GossipData) error {
|
|||||||
// Swallow this message
|
// Swallow this message
|
||||||
m.messages = m.messages[1:]
|
m.messages = m.messages[1:]
|
||||||
}
|
}
|
||||||
return nil
|
|
||||||
}
|
}
|
||||||
|
|
||||||
func equalByteBuffer(a, b []byte) bool {
|
func equalByteBuffer(a, b []byte) bool {
|
||||||
@@ -123,24 +123,35 @@ func CheckAllExpectedMessagesSent(allocs ...*Allocator) {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
func makeAllocator(name string, cidrStr string, quorum uint) (*Allocator, address.Range) {
|
type mockDB struct{}
|
||||||
|
|
||||||
|
func (d *mockDB) Load(_ string, _ interface{}) (bool, error) { return false, nil }
|
||||||
|
func (d *mockDB) Save(_ string, _ interface{}) error { return nil }
|
||||||
|
|
||||||
|
func makeAllocator(name string, cidrStr string, quorum uint) (*Allocator, address.CIDR) {
|
||||||
peername, err := mesh.PeerNameFromString(name)
|
peername, err := mesh.PeerNameFromString(name)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
panic(err)
|
panic(err)
|
||||||
}
|
}
|
||||||
|
|
||||||
_, cidr, err := address.ParseCIDR(cidrStr)
|
cidr, err := address.ParseCIDR(cidrStr)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
panic(err)
|
panic(err)
|
||||||
}
|
}
|
||||||
|
|
||||||
alloc := NewAllocator(peername, mesh.PeerUID(rand.Int63()),
|
return NewAllocator(Config{
|
||||||
"nick-"+name, cidr.Range(), quorum, func(mesh.PeerName) bool { return true })
|
OurName: peername,
|
||||||
|
OurUID: mesh.PeerUID(rand.Int63()),
|
||||||
return alloc, cidr.HostRange()
|
OurNickname: "nick-" + name,
|
||||||
|
Universe: cidr.Range(),
|
||||||
|
IsObserver: quorum == 0,
|
||||||
|
Quorum: func() uint { return quorum },
|
||||||
|
Db: new(mockDB),
|
||||||
|
IsKnownPeer: func(mesh.PeerName) bool { return true },
|
||||||
|
}), cidr
|
||||||
}
|
}
|
||||||
|
|
||||||
func makeAllocatorWithMockGossip(t *testing.T, name string, universeCIDR string, quorum uint) (*Allocator, address.Range) {
|
func makeAllocatorWithMockGossip(t *testing.T, name string, universeCIDR string, quorum uint) (*Allocator, address.CIDR) {
|
||||||
alloc, subnet := makeAllocator(name, universeCIDR, quorum)
|
alloc, subnet := makeAllocator(name, universeCIDR, quorum)
|
||||||
gossip := &mockGossipComms{T: t, name: name}
|
gossip := &mockGossipComms{T: t, name: name}
|
||||||
alloc.SetInterfaces(gossip)
|
alloc.SetInterfaces(gossip)
|
||||||
@@ -157,14 +168,22 @@ func (alloc *Allocator) claimRingForTesting(allocs ...*Allocator) {
|
|||||||
alloc.space.AddRanges(alloc.ring.OwnedRanges())
|
alloc.space.AddRanges(alloc.ring.OwnedRanges())
|
||||||
}
|
}
|
||||||
|
|
||||||
func (alloc *Allocator) NumFreeAddresses(r address.Range) address.Offset {
|
func (alloc *Allocator) NumFreeAddresses(r address.Range) address.Count {
|
||||||
resultChan := make(chan address.Offset)
|
resultChan := make(chan address.Count)
|
||||||
alloc.actionChan <- func() {
|
alloc.actionChan <- func() {
|
||||||
resultChan <- alloc.space.NumFreeAddressesInRange(r)
|
resultChan <- alloc.space.NumFreeAddressesInRange(r)
|
||||||
}
|
}
|
||||||
return <-resultChan
|
return <-resultChan
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func (alloc *Allocator) OwnedRanges() (result []address.Range) {
|
||||||
|
resultChan := make(chan []address.Range)
|
||||||
|
alloc.actionChan <- func() {
|
||||||
|
resultChan <- alloc.ring.OwnedRanges()
|
||||||
|
}
|
||||||
|
return <-resultChan
|
||||||
|
}
|
||||||
|
|
||||||
// Check whether or not something was sent on a channel
|
// Check whether or not something was sent on a channel
|
||||||
func AssertSent(t *testing.T, ch <-chan bool) {
|
func AssertSent(t *testing.T, ch <-chan bool) {
|
||||||
timeout := time.After(10 * time.Second)
|
timeout := time.After(10 * time.Second)
|
||||||
@@ -194,10 +213,10 @@ func AssertNothingSentErr(t *testing.T, ch <-chan error) {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
func makeNetworkOfAllocators(size int, cidr string) ([]*Allocator, *gossip.TestRouter, address.Range) {
|
func makeNetworkOfAllocators(size int, cidr string) ([]*Allocator, *gossip.TestRouter, address.CIDR) {
|
||||||
gossipRouter := gossip.NewTestRouter(0.0)
|
gossipRouter := gossip.NewTestRouter(0.0)
|
||||||
allocs := make([]*Allocator, size)
|
allocs := make([]*Allocator, size)
|
||||||
var subnet address.Range
|
var subnet address.CIDR
|
||||||
|
|
||||||
for i := 0; i < size; i++ {
|
for i := 0; i < size; i++ {
|
||||||
var alloc *Allocator
|
var alloc *Allocator
|
||||||
@@ -213,7 +232,10 @@ func makeNetworkOfAllocators(size int, cidr string) ([]*Allocator, *gossip.TestR
|
|||||||
return allocs, gossipRouter, subnet
|
return allocs, gossipRouter, subnet
|
||||||
}
|
}
|
||||||
|
|
||||||
func stopNetworkOfAllocators(allocs []*Allocator) {
|
func stopNetworkOfAllocators(allocs []*Allocator, gossipRouter *gossip.TestRouter) {
|
||||||
|
// NB: We must stop the router first since ipam gossip makes
|
||||||
|
// synchronous calls into the allocator.
|
||||||
|
gossipRouter.Stop()
|
||||||
for _, alloc := range allocs {
|
for _, alloc := range allocs {
|
||||||
alloc.Stop()
|
alloc.Stop()
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -1,460 +0,0 @@
|
|||||||
package mesh
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"net"
|
|
||||||
"strconv"
|
|
||||||
"sync"
|
|
||||||
"time"
|
|
||||||
)
|
|
||||||
|
|
||||||
type Connection interface {
|
|
||||||
Local() *Peer
|
|
||||||
Remote() *Peer
|
|
||||||
RemoteTCPAddr() string
|
|
||||||
Outbound() bool
|
|
||||||
Established() bool
|
|
||||||
BreakTie(Connection) ConnectionTieBreak
|
|
||||||
Shutdown(error)
|
|
||||||
Log(args ...interface{})
|
|
||||||
}
|
|
||||||
|
|
||||||
type ConnectionTieBreak int
|
|
||||||
|
|
||||||
const (
|
|
||||||
TieBreakWon ConnectionTieBreak = iota
|
|
||||||
TieBreakLost
|
|
||||||
TieBreakTied
|
|
||||||
)
|
|
||||||
|
|
||||||
var ErrConnectToSelf = fmt.Errorf("Cannot connect to ourself")
|
|
||||||
|
|
||||||
type RemoteConnection struct {
|
|
||||||
local *Peer
|
|
||||||
remote *Peer
|
|
||||||
remoteTCPAddr string
|
|
||||||
outbound bool
|
|
||||||
established bool
|
|
||||||
}
|
|
||||||
|
|
||||||
type LocalConnection struct {
|
|
||||||
sync.RWMutex
|
|
||||||
RemoteConnection
|
|
||||||
TCPConn *net.TCPConn
|
|
||||||
TrustRemote bool // is remote on a trusted subnet?
|
|
||||||
TrustedByRemote bool // does remote trust us?
|
|
||||||
version byte
|
|
||||||
tcpSender TCPSender
|
|
||||||
SessionKey *[32]byte
|
|
||||||
heartbeatTCP *time.Ticker
|
|
||||||
Router *Router
|
|
||||||
uid uint64
|
|
||||||
actionChan chan<- ConnectionAction
|
|
||||||
errorChan chan<- error
|
|
||||||
finished <-chan struct{} // closed to signal that actorLoop has finished
|
|
||||||
OverlayConn OverlayConnection
|
|
||||||
}
|
|
||||||
|
|
||||||
type ConnectionAction func() error
|
|
||||||
|
|
||||||
func NewRemoteConnection(from, to *Peer, tcpAddr string, outbound bool, established bool) *RemoteConnection {
|
|
||||||
return &RemoteConnection{
|
|
||||||
local: from,
|
|
||||||
remote: to,
|
|
||||||
remoteTCPAddr: tcpAddr,
|
|
||||||
outbound: outbound,
|
|
||||||
established: established,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (conn *RemoteConnection) Local() *Peer { return conn.local }
|
|
||||||
func (conn *RemoteConnection) Remote() *Peer { return conn.remote }
|
|
||||||
func (conn *RemoteConnection) RemoteTCPAddr() string { return conn.remoteTCPAddr }
|
|
||||||
func (conn *RemoteConnection) Outbound() bool { return conn.outbound }
|
|
||||||
func (conn *RemoteConnection) Established() bool { return conn.established }
|
|
||||||
func (conn *RemoteConnection) BreakTie(Connection) ConnectionTieBreak { return TieBreakTied }
|
|
||||||
func (conn *RemoteConnection) Shutdown(error) {}
|
|
||||||
|
|
||||||
func (conn *RemoteConnection) Log(args ...interface{}) {
|
|
||||||
log.Println(append(append([]interface{}{}, fmt.Sprintf("->[%s|%s]:", conn.remoteTCPAddr, conn.remote)), args...)...)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (conn *RemoteConnection) ErrorLog(args ...interface{}) {
|
|
||||||
log.Errorln(append(append([]interface{}{}, fmt.Sprintf("->[%s|%s]:", conn.remoteTCPAddr, conn.remote)), args...)...)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Does not return anything. If the connection is successful, it will
|
|
||||||
// end up in the local peer's connections map.
|
|
||||||
func StartLocalConnection(connRemote *RemoteConnection, tcpConn *net.TCPConn, router *Router, acceptNewPeer bool) {
|
|
||||||
if connRemote.local != router.Ourself.Peer {
|
|
||||||
log.Fatal("Attempt to create local connection from a peer which is not ourself")
|
|
||||||
}
|
|
||||||
actionChan := make(chan ConnectionAction, ChannelSize)
|
|
||||||
errorChan := make(chan error, 1)
|
|
||||||
finished := make(chan struct{})
|
|
||||||
conn := &LocalConnection{
|
|
||||||
RemoteConnection: *connRemote, // NB, we're taking a copy of connRemote here.
|
|
||||||
Router: router,
|
|
||||||
TCPConn: tcpConn,
|
|
||||||
TrustRemote: router.Trusts(connRemote),
|
|
||||||
uid: randUint64(),
|
|
||||||
actionChan: actionChan,
|
|
||||||
errorChan: errorChan,
|
|
||||||
finished: finished}
|
|
||||||
go conn.run(actionChan, errorChan, finished, acceptNewPeer)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (conn *LocalConnection) BreakTie(dupConn Connection) ConnectionTieBreak {
|
|
||||||
dupConnLocal := dupConn.(*LocalConnection)
|
|
||||||
// conn.uid is used as the tie breaker here, in the knowledge that
|
|
||||||
// both sides will make the same decision.
|
|
||||||
if conn.uid < dupConnLocal.uid {
|
|
||||||
return TieBreakWon
|
|
||||||
} else if dupConnLocal.uid < conn.uid {
|
|
||||||
return TieBreakLost
|
|
||||||
} else {
|
|
||||||
return TieBreakTied
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (conn *LocalConnection) Established() bool {
|
|
||||||
return conn.established
|
|
||||||
}
|
|
||||||
|
|
||||||
func (conn *LocalConnection) SendProtocolMsg(m ProtocolMsg) {
|
|
||||||
if err := conn.sendProtocolMsg(m); err != nil {
|
|
||||||
conn.Shutdown(err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// ACTOR methods
|
|
||||||
|
|
||||||
// NB: The conn.* fields are only written by the connection actor
|
|
||||||
// process, which is the caller of the ConnectionAction funs. Hence we
|
|
||||||
// do not need locks for reading, and only need write locks for fields
|
|
||||||
// read by other processes.
|
|
||||||
|
|
||||||
// Non-blocking.
|
|
||||||
func (conn *LocalConnection) Shutdown(err error) {
|
|
||||||
// err should always be a real error, even if only io.EOF
|
|
||||||
if err == nil {
|
|
||||||
panic("nil error")
|
|
||||||
}
|
|
||||||
|
|
||||||
select {
|
|
||||||
case conn.errorChan <- err:
|
|
||||||
default:
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Send an actor request to the actorLoop, but don't block if
|
|
||||||
// actorLoop has exited - see http://blog.golang.org/pipelines for
|
|
||||||
// pattern
|
|
||||||
func (conn *LocalConnection) sendAction(action ConnectionAction) {
|
|
||||||
select {
|
|
||||||
case conn.actionChan <- action:
|
|
||||||
case <-conn.finished:
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// ACTOR server
|
|
||||||
|
|
||||||
func (conn *LocalConnection) run(actionChan <-chan ConnectionAction, errorChan <-chan error, finished chan<- struct{}, acceptNewPeer bool) {
|
|
||||||
var err error // important to use this var and not create another one with 'err :='
|
|
||||||
defer func() { conn.shutdown(err) }()
|
|
||||||
defer close(finished)
|
|
||||||
|
|
||||||
conn.TCPConn.SetLinger(0)
|
|
||||||
intro, err := ProtocolIntroParams{
|
|
||||||
MinVersion: conn.Router.ProtocolMinVersion,
|
|
||||||
MaxVersion: ProtocolMaxVersion,
|
|
||||||
Features: conn.makeFeatures(),
|
|
||||||
Conn: conn.TCPConn,
|
|
||||||
Password: conn.Router.Password,
|
|
||||||
Outbound: conn.outbound,
|
|
||||||
}.DoIntro()
|
|
||||||
if err != nil {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
conn.SessionKey = intro.SessionKey
|
|
||||||
conn.tcpSender = intro.Sender
|
|
||||||
conn.version = intro.Version
|
|
||||||
|
|
||||||
remote, err := conn.parseFeatures(intro.Features)
|
|
||||||
if err != nil {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
if err = conn.registerRemote(remote, acceptNewPeer); err != nil {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
conn.Log("connection ready; using protocol version", conn.version)
|
|
||||||
|
|
||||||
// only use negotiated session key for untrusted connections
|
|
||||||
var sessionKey *[32]byte
|
|
||||||
if conn.Untrusted() {
|
|
||||||
sessionKey = conn.SessionKey
|
|
||||||
}
|
|
||||||
|
|
||||||
params := OverlayConnectionParams{
|
|
||||||
RemotePeer: conn.remote,
|
|
||||||
LocalAddr: conn.TCPConn.LocalAddr().(*net.TCPAddr),
|
|
||||||
RemoteAddr: conn.TCPConn.RemoteAddr().(*net.TCPAddr),
|
|
||||||
Outbound: conn.outbound,
|
|
||||||
ConnUID: conn.uid,
|
|
||||||
SessionKey: sessionKey,
|
|
||||||
SendControlMessage: conn.sendOverlayControlMessage,
|
|
||||||
Features: intro.Features,
|
|
||||||
}
|
|
||||||
if conn.OverlayConn, err = conn.Router.Overlay.PrepareConnection(params); err != nil {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// As soon as we do AddConnection, the new connection becomes
|
|
||||||
// visible to the packet routing logic. So AddConnection must
|
|
||||||
// come after PrepareConnection
|
|
||||||
if err = conn.Router.Ourself.AddConnection(conn); err != nil {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
conn.Router.ConnectionMaker.ConnectionCreated(conn)
|
|
||||||
|
|
||||||
// OverlayConnection confirmation comes after AddConnection,
|
|
||||||
// because only after that completes do we know the connection is
|
|
||||||
// valid: in particular that it is not a duplicate connection to
|
|
||||||
// the same peer. Overlay communication on a duplicate connection
|
|
||||||
// can cause problems such as tripping up overlay crypto at the
|
|
||||||
// other end due to data being decoded by the other connection. It
|
|
||||||
// is also generally wasteful to engage in any interaction with
|
|
||||||
// the remote on a connection that turns out to be invalid.
|
|
||||||
conn.OverlayConn.Confirm()
|
|
||||||
|
|
||||||
// receiveTCP must follow also AddConnection. In the absence
|
|
||||||
// of any indirect connectivity to the remote peer, the first
|
|
||||||
// we hear about it (and any peers reachable from it) is
|
|
||||||
// through topology gossip it sends us on the connection. We
|
|
||||||
// must ensure that the connection has been added to Ourself
|
|
||||||
// prior to processing any such gossip, otherwise we risk
|
|
||||||
// immediately gc'ing part of that newly received portion of
|
|
||||||
// the topology (though not the remote peer itself, since that
|
|
||||||
// will have a positive ref count), leaving behind dangling
|
|
||||||
// references to peers. Hence we must invoke AddConnection,
|
|
||||||
// which is *synchronous*, first.
|
|
||||||
conn.heartbeatTCP = time.NewTicker(TCPHeartbeat)
|
|
||||||
go conn.receiveTCP(intro.Receiver)
|
|
||||||
|
|
||||||
// AddConnection must precede actorLoop. More precisely, it
|
|
||||||
// must precede shutdown, since that invokes DeleteConnection
|
|
||||||
// and is invoked on termination of this entire
|
|
||||||
// function. Essentially this boils down to a prohibition on
|
|
||||||
// running AddConnection in a separate goroutine, at least not
|
|
||||||
// without some synchronisation. Which in turn requires the
|
|
||||||
// launching of the receiveTCP goroutine to precede actorLoop.
|
|
||||||
err = conn.actorLoop(actionChan, errorChan)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (conn *LocalConnection) makeFeatures() map[string]string {
|
|
||||||
features := map[string]string{
|
|
||||||
"PeerNameFlavour": PeerNameFlavour,
|
|
||||||
"Name": conn.local.Name.String(),
|
|
||||||
"NickName": conn.local.NickName,
|
|
||||||
"ShortID": fmt.Sprint(conn.local.ShortID),
|
|
||||||
"UID": fmt.Sprint(conn.local.UID),
|
|
||||||
"ConnID": fmt.Sprint(conn.uid),
|
|
||||||
"Trusted": fmt.Sprint(conn.TrustRemote),
|
|
||||||
}
|
|
||||||
conn.Router.Overlay.AddFeaturesTo(features)
|
|
||||||
return features
|
|
||||||
}
|
|
||||||
|
|
||||||
type features map[string]string
|
|
||||||
|
|
||||||
func (features features) MustHave(keys []string) error {
|
|
||||||
for _, key := range keys {
|
|
||||||
if _, ok := features[key]; !ok {
|
|
||||||
return fmt.Errorf("Field %s is missing", key)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (features features) Get(key string) string {
|
|
||||||
return features[key]
|
|
||||||
}
|
|
||||||
|
|
||||||
func (conn *LocalConnection) parseFeatures(features features) (*Peer, error) {
|
|
||||||
if err := features.MustHave([]string{"PeerNameFlavour", "Name", "NickName", "UID", "ConnID"}); err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
|
|
||||||
remotePeerNameFlavour := features.Get("PeerNameFlavour")
|
|
||||||
if remotePeerNameFlavour != PeerNameFlavour {
|
|
||||||
return nil, fmt.Errorf("Peer name flavour mismatch (ours: '%s', theirs: '%s')", PeerNameFlavour, remotePeerNameFlavour)
|
|
||||||
}
|
|
||||||
|
|
||||||
name, err := PeerNameFromString(features.Get("Name"))
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
|
|
||||||
nickName := features.Get("NickName")
|
|
||||||
|
|
||||||
var shortID uint64
|
|
||||||
var hasShortID bool
|
|
||||||
if shortIDStr, present := features["ShortID"]; present {
|
|
||||||
hasShortID = true
|
|
||||||
shortID, err = strconv.ParseUint(shortIDStr, 10, PeerShortIDBits)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
var trusted bool
|
|
||||||
if trustedStr, present := features["Trusted"]; present {
|
|
||||||
trusted, err = strconv.ParseBool(trustedStr)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
conn.TrustedByRemote = trusted
|
|
||||||
|
|
||||||
uid, err := ParsePeerUID(features.Get("UID"))
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
|
|
||||||
remoteConnID, err := strconv.ParseUint(features.Get("ConnID"), 10, 64)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
|
|
||||||
conn.uid ^= remoteConnID
|
|
||||||
peer := NewPeer(name, nickName, uid, 0, PeerShortID(shortID))
|
|
||||||
peer.HasShortID = hasShortID
|
|
||||||
return peer, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (conn *LocalConnection) registerRemote(remote *Peer, acceptNewPeer bool) error {
|
|
||||||
if acceptNewPeer {
|
|
||||||
conn.remote = conn.Router.Peers.FetchWithDefault(remote)
|
|
||||||
} else {
|
|
||||||
conn.remote = conn.Router.Peers.FetchAndAddRef(remote.Name)
|
|
||||||
if conn.remote == nil {
|
|
||||||
return fmt.Errorf("Found unknown remote name: %s at %s", remote.Name, conn.remoteTCPAddr)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if conn.remote == conn.local {
|
|
||||||
return ErrConnectToSelf
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (conn *LocalConnection) actorLoop(actionChan <-chan ConnectionAction, errorChan <-chan error) (err error) {
|
|
||||||
fwdErrorChan := conn.OverlayConn.ErrorChannel()
|
|
||||||
fwdEstablishedChan := conn.OverlayConn.EstablishedChannel()
|
|
||||||
|
|
||||||
for err == nil {
|
|
||||||
select {
|
|
||||||
case action := <-actionChan:
|
|
||||||
err = action()
|
|
||||||
|
|
||||||
case err = <-errorChan:
|
|
||||||
|
|
||||||
case <-conn.heartbeatTCP.C:
|
|
||||||
err = conn.sendSimpleProtocolMsg(ProtocolHeartbeat)
|
|
||||||
|
|
||||||
case <-fwdEstablishedChan:
|
|
||||||
conn.established = true
|
|
||||||
fwdEstablishedChan = nil
|
|
||||||
conn.Router.Ourself.ConnectionEstablished(conn)
|
|
||||||
|
|
||||||
case err = <-fwdErrorChan:
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func (conn *LocalConnection) shutdown(err error) {
|
|
||||||
if conn.remote == nil {
|
|
||||||
log.Errorf("->[%s] connection shutting down due to error during handshake: %v", conn.remoteTCPAddr, err)
|
|
||||||
} else {
|
|
||||||
conn.ErrorLog("connection shutting down due to error:", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
if conn.TCPConn != nil {
|
|
||||||
checkWarn(conn.TCPConn.Close())
|
|
||||||
}
|
|
||||||
|
|
||||||
if conn.remote != nil {
|
|
||||||
conn.Router.Peers.Dereference(conn.remote)
|
|
||||||
conn.Router.Ourself.DeleteConnection(conn)
|
|
||||||
}
|
|
||||||
|
|
||||||
if conn.heartbeatTCP != nil {
|
|
||||||
conn.heartbeatTCP.Stop()
|
|
||||||
}
|
|
||||||
|
|
||||||
if conn.OverlayConn != nil {
|
|
||||||
conn.OverlayConn.Stop()
|
|
||||||
}
|
|
||||||
|
|
||||||
conn.Router.ConnectionMaker.ConnectionTerminated(conn, err)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (conn *LocalConnection) sendOverlayControlMessage(tag byte, msg []byte) error {
|
|
||||||
return conn.sendProtocolMsg(ProtocolMsg{ProtocolTag(tag), msg})
|
|
||||||
}
|
|
||||||
|
|
||||||
// Helpers
|
|
||||||
|
|
||||||
func (conn *LocalConnection) sendSimpleProtocolMsg(tag ProtocolTag) error {
|
|
||||||
return conn.sendProtocolMsg(ProtocolMsg{tag: tag})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (conn *LocalConnection) sendProtocolMsg(m ProtocolMsg) error {
|
|
||||||
return conn.tcpSender.Send(append([]byte{byte(m.tag)}, m.msg...))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (conn *LocalConnection) receiveTCP(receiver TCPReceiver) {
|
|
||||||
var err error
|
|
||||||
for {
|
|
||||||
conn.extendReadDeadline()
|
|
||||||
|
|
||||||
var msg []byte
|
|
||||||
if msg, err = receiver.Receive(); err != nil {
|
|
||||||
break
|
|
||||||
}
|
|
||||||
if len(msg) < 1 {
|
|
||||||
conn.Log("ignoring blank msg")
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
if err = conn.handleProtocolMsg(ProtocolTag(msg[0]), msg[1:]); err != nil {
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
conn.Shutdown(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (conn *LocalConnection) handleProtocolMsg(tag ProtocolTag, payload []byte) error {
|
|
||||||
switch tag {
|
|
||||||
case ProtocolHeartbeat:
|
|
||||||
case ProtocolReserved1, ProtocolReserved2, ProtocolReserved3, ProtocolOverlayControlMsg:
|
|
||||||
conn.OverlayConn.ControlMessage(byte(tag), payload)
|
|
||||||
case ProtocolGossipUnicast, ProtocolGossipBroadcast, ProtocolGossip:
|
|
||||||
return conn.Router.handleGossip(tag, payload)
|
|
||||||
default:
|
|
||||||
conn.Log("ignoring unknown protocol tag:", tag)
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (conn *LocalConnection) extendReadDeadline() {
|
|
||||||
conn.TCPConn.SetReadDeadline(time.Now().Add(TCPHeartbeat * 2))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (conn *LocalConnection) Untrusted() bool {
|
|
||||||
return !conn.TrustRemote || !conn.TrustedByRemote
|
|
||||||
}
|
|
||||||
@@ -1,317 +0,0 @@
|
|||||||
package mesh
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"math/rand"
|
|
||||||
"net"
|
|
||||||
"time"
|
|
||||||
)
|
|
||||||
|
|
||||||
const (
|
|
||||||
InitialInterval = 2 * time.Second
|
|
||||||
MaxInterval = 6 * time.Minute
|
|
||||||
ResetAfter = 1 * time.Minute
|
|
||||||
)
|
|
||||||
|
|
||||||
type peerAddrs map[string]*net.TCPAddr
|
|
||||||
|
|
||||||
type ConnectionMaker struct {
|
|
||||||
ourself *LocalPeer
|
|
||||||
peers *Peers
|
|
||||||
port int
|
|
||||||
discovery bool
|
|
||||||
targets map[string]*Target
|
|
||||||
connections map[Connection]struct{}
|
|
||||||
directPeers peerAddrs
|
|
||||||
actionChan chan<- ConnectionMakerAction
|
|
||||||
}
|
|
||||||
|
|
||||||
type TargetState int
|
|
||||||
|
|
||||||
const (
|
|
||||||
TargetWaiting TargetState = iota // we are waiting to connect there
|
|
||||||
TargetAttempting // we are attempting to connect there
|
|
||||||
TargetConnected // we are connected to there
|
|
||||||
)
|
|
||||||
|
|
||||||
// Information about an address where we may find a peer
|
|
||||||
type Target struct {
|
|
||||||
state TargetState
|
|
||||||
lastError error // reason for disconnection last time
|
|
||||||
tryAfter time.Time // next time to try this address
|
|
||||||
tryInterval time.Duration // retry delay on next failure
|
|
||||||
}
|
|
||||||
|
|
||||||
type ConnectionMakerAction func() bool
|
|
||||||
|
|
||||||
func NewConnectionMaker(ourself *LocalPeer, peers *Peers, port int, discovery bool) *ConnectionMaker {
|
|
||||||
actionChan := make(chan ConnectionMakerAction, ChannelSize)
|
|
||||||
cm := &ConnectionMaker{
|
|
||||||
ourself: ourself,
|
|
||||||
peers: peers,
|
|
||||||
port: port,
|
|
||||||
discovery: discovery,
|
|
||||||
directPeers: peerAddrs{},
|
|
||||||
targets: make(map[string]*Target),
|
|
||||||
connections: make(map[Connection]struct{}),
|
|
||||||
actionChan: actionChan}
|
|
||||||
go cm.queryLoop(actionChan)
|
|
||||||
return cm
|
|
||||||
}
|
|
||||||
|
|
||||||
func (cm *ConnectionMaker) InitiateConnections(peers []string, replace bool) []error {
|
|
||||||
errors := []error{}
|
|
||||||
addrs := peerAddrs{}
|
|
||||||
for _, peer := range peers {
|
|
||||||
host, port, err := net.SplitHostPort(peer)
|
|
||||||
if err != nil {
|
|
||||||
host = peer
|
|
||||||
port = "0" // we use that as an indication that "no port was supplied"
|
|
||||||
}
|
|
||||||
if addr, err := net.ResolveTCPAddr("tcp4", fmt.Sprintf("%s:%s", host, port)); err != nil {
|
|
||||||
errors = append(errors, err)
|
|
||||||
} else {
|
|
||||||
addrs[peer] = addr
|
|
||||||
}
|
|
||||||
}
|
|
||||||
cm.actionChan <- func() bool {
|
|
||||||
if replace {
|
|
||||||
cm.directPeers = peerAddrs{}
|
|
||||||
}
|
|
||||||
for peer, addr := range addrs {
|
|
||||||
cm.directPeers[peer] = addr
|
|
||||||
// curtail any existing reconnect interval
|
|
||||||
if target, found := cm.targets[cm.completeAddr(*addr)]; found {
|
|
||||||
target.nextTryNow()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
return errors
|
|
||||||
}
|
|
||||||
|
|
||||||
func (cm *ConnectionMaker) ForgetConnections(peers []string) {
|
|
||||||
cm.actionChan <- func() bool {
|
|
||||||
for _, peer := range peers {
|
|
||||||
delete(cm.directPeers, peer)
|
|
||||||
}
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (cm *ConnectionMaker) ConnectionAborted(address string, err error) {
|
|
||||||
cm.actionChan <- func() bool {
|
|
||||||
target := cm.targets[address]
|
|
||||||
target.state = TargetWaiting
|
|
||||||
target.lastError = err
|
|
||||||
target.nextTryLater()
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (cm *ConnectionMaker) ConnectionCreated(conn Connection) {
|
|
||||||
cm.actionChan <- func() bool {
|
|
||||||
cm.connections[conn] = void
|
|
||||||
if conn.Outbound() {
|
|
||||||
target := cm.targets[conn.RemoteTCPAddr()]
|
|
||||||
target.state = TargetConnected
|
|
||||||
}
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (cm *ConnectionMaker) ConnectionTerminated(conn Connection, err error) {
|
|
||||||
cm.actionChan <- func() bool {
|
|
||||||
delete(cm.connections, conn)
|
|
||||||
if conn.Outbound() {
|
|
||||||
target := cm.targets[conn.RemoteTCPAddr()]
|
|
||||||
target.state = TargetWaiting
|
|
||||||
target.lastError = err
|
|
||||||
switch {
|
|
||||||
case err == ErrConnectToSelf:
|
|
||||||
target.nextTryNever()
|
|
||||||
case time.Now().After(target.tryAfter.Add(ResetAfter)):
|
|
||||||
target.nextTryNow()
|
|
||||||
default:
|
|
||||||
target.nextTryLater()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (cm *ConnectionMaker) Refresh() {
|
|
||||||
cm.actionChan <- func() bool { return true }
|
|
||||||
}
|
|
||||||
|
|
||||||
func (cm *ConnectionMaker) queryLoop(actionChan <-chan ConnectionMakerAction) {
|
|
||||||
timer := time.NewTimer(MaxDuration)
|
|
||||||
run := func() { timer.Reset(cm.checkStateAndAttemptConnections()) }
|
|
||||||
for {
|
|
||||||
select {
|
|
||||||
case action := <-actionChan:
|
|
||||||
if action() {
|
|
||||||
run()
|
|
||||||
}
|
|
||||||
case <-timer.C:
|
|
||||||
run()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (cm *ConnectionMaker) completeAddr(addr net.TCPAddr) string {
|
|
||||||
if addr.Port == 0 {
|
|
||||||
addr.Port = cm.port
|
|
||||||
}
|
|
||||||
return addr.String()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (cm *ConnectionMaker) checkStateAndAttemptConnections() time.Duration {
|
|
||||||
var (
|
|
||||||
validTarget = make(map[string]struct{})
|
|
||||||
directTarget = make(map[string]struct{})
|
|
||||||
)
|
|
||||||
ourConnectedPeers, ourConnectedTargets, ourInboundIPs := cm.ourConnections()
|
|
||||||
|
|
||||||
addTarget := func(address string) {
|
|
||||||
if _, connected := ourConnectedTargets[address]; connected {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
validTarget[address] = void
|
|
||||||
if _, found := cm.targets[address]; found {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
target := &Target{state: TargetWaiting}
|
|
||||||
target.nextTryNow()
|
|
||||||
cm.targets[address] = target
|
|
||||||
}
|
|
||||||
|
|
||||||
// Add direct targets that are not connected
|
|
||||||
for _, addr := range cm.directPeers {
|
|
||||||
attempt := true
|
|
||||||
if addr.Port == 0 {
|
|
||||||
// If a peer was specified w/o a port, then we do not
|
|
||||||
// attempt to connect to it if we have any inbound
|
|
||||||
// connections from that IP.
|
|
||||||
if _, connected := ourInboundIPs[addr.IP.String()]; connected {
|
|
||||||
attempt = false
|
|
||||||
}
|
|
||||||
}
|
|
||||||
address := cm.completeAddr(*addr)
|
|
||||||
directTarget[address] = void
|
|
||||||
if attempt {
|
|
||||||
addTarget(address)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Add targets for peers that someone else is connected to, but we
|
|
||||||
// aren't
|
|
||||||
if cm.discovery {
|
|
||||||
cm.addPeerTargets(ourConnectedPeers, addTarget)
|
|
||||||
}
|
|
||||||
|
|
||||||
return cm.connectToTargets(validTarget, directTarget)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (cm *ConnectionMaker) ourConnections() (PeerNameSet, map[string]struct{}, map[string]struct{}) {
|
|
||||||
var (
|
|
||||||
ourConnectedPeers = make(PeerNameSet)
|
|
||||||
ourConnectedTargets = make(map[string]struct{})
|
|
||||||
ourInboundIPs = make(map[string]struct{})
|
|
||||||
)
|
|
||||||
for conn := range cm.connections {
|
|
||||||
address := conn.RemoteTCPAddr()
|
|
||||||
ourConnectedPeers[conn.Remote().Name] = void
|
|
||||||
ourConnectedTargets[address] = void
|
|
||||||
if conn.Outbound() {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
if ip, _, err := net.SplitHostPort(address); err == nil { // should always succeed
|
|
||||||
ourInboundIPs[ip] = void
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return ourConnectedPeers, ourConnectedTargets, ourInboundIPs
|
|
||||||
}
|
|
||||||
|
|
||||||
func (cm *ConnectionMaker) addPeerTargets(ourConnectedPeers PeerNameSet, addTarget func(string)) {
|
|
||||||
cm.peers.ForEach(func(peer *Peer) {
|
|
||||||
if peer == cm.ourself.Peer {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
// Modifying peer.connections requires a write lock on Peers,
|
|
||||||
// and since we are holding a read lock (due to the ForEach),
|
|
||||||
// access without locking the peer is safe.
|
|
||||||
for otherPeer, conn := range peer.connections {
|
|
||||||
if otherPeer == cm.ourself.Name {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
if _, connected := ourConnectedPeers[otherPeer]; connected {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
address := conn.RemoteTCPAddr()
|
|
||||||
if conn.Outbound() {
|
|
||||||
addTarget(address)
|
|
||||||
} else if ip, _, err := net.SplitHostPort(address); err == nil {
|
|
||||||
// There is no point connecting to the (likely
|
|
||||||
// ephemeral) remote port of an inbound connection
|
|
||||||
// that some peer has. Let's try to connect on the
|
|
||||||
// weave port instead.
|
|
||||||
addTarget(fmt.Sprintf("%s:%d", ip, cm.port))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (cm *ConnectionMaker) connectToTargets(validTarget map[string]struct{}, directTarget map[string]struct{}) time.Duration {
|
|
||||||
now := time.Now() // make sure we catch items just added
|
|
||||||
after := MaxDuration
|
|
||||||
for address, target := range cm.targets {
|
|
||||||
if target.state != TargetWaiting {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
if _, valid := validTarget[address]; !valid {
|
|
||||||
delete(cm.targets, address)
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
if target.tryAfter.IsZero() {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
switch duration := target.tryAfter.Sub(now); {
|
|
||||||
case duration <= 0:
|
|
||||||
target.state = TargetAttempting
|
|
||||||
_, isCmdLineTarget := directTarget[address]
|
|
||||||
go cm.attemptConnection(address, isCmdLineTarget)
|
|
||||||
case duration < after:
|
|
||||||
after = duration
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return after
|
|
||||||
}
|
|
||||||
|
|
||||||
func (cm *ConnectionMaker) attemptConnection(address string, acceptNewPeer bool) {
|
|
||||||
log.Printf("->[%s] attempting connection", address)
|
|
||||||
if err := cm.ourself.CreateConnection(address, acceptNewPeer); err != nil {
|
|
||||||
log.Errorf("->[%s] error during connection attempt: %v", address, err)
|
|
||||||
cm.ConnectionAborted(address, err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (t *Target) nextTryNever() {
|
|
||||||
t.tryAfter = time.Time{}
|
|
||||||
t.tryInterval = MaxInterval
|
|
||||||
}
|
|
||||||
|
|
||||||
func (t *Target) nextTryNow() {
|
|
||||||
t.tryAfter = time.Now()
|
|
||||||
t.tryInterval = InitialInterval
|
|
||||||
}
|
|
||||||
|
|
||||||
// The delay at the nth retry is a random value in the range
|
|
||||||
// [i-i/2,i+i/2], where i = InitialInterval * 1.5^(n-1).
|
|
||||||
func (t *Target) nextTryLater() {
|
|
||||||
t.tryAfter = time.Now().Add(t.tryInterval/2 + time.Duration(rand.Int63n(int64(t.tryInterval))))
|
|
||||||
t.tryInterval = t.tryInterval * 3 / 2
|
|
||||||
if t.tryInterval > MaxInterval {
|
|
||||||
t.tryInterval = MaxInterval
|
|
||||||
}
|
|
||||||
}
|
|
||||||
-170
@@ -1,170 +0,0 @@
|
|||||||
package mesh
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
)
|
|
||||||
|
|
||||||
type GossipData interface {
|
|
||||||
Encode() [][]byte
|
|
||||||
Merge(GossipData) GossipData
|
|
||||||
}
|
|
||||||
|
|
||||||
type Gossip interface {
|
|
||||||
// specific message from one peer to another
|
|
||||||
// intermediate peers relay it using unicast topology.
|
|
||||||
GossipUnicast(dstPeerName PeerName, msg []byte) error
|
|
||||||
// send gossip to every peer, relayed using broadcast topology.
|
|
||||||
GossipBroadcast(update GossipData) error
|
|
||||||
}
|
|
||||||
|
|
||||||
type Gossiper interface {
|
|
||||||
OnGossipUnicast(sender PeerName, msg []byte) error
|
|
||||||
// merge received data into state and return a representation of
|
|
||||||
// the received data, for further propagation
|
|
||||||
OnGossipBroadcast(sender PeerName, update []byte) (GossipData, error)
|
|
||||||
// return state of everything we know; gets called periodically
|
|
||||||
Gossip() GossipData
|
|
||||||
// merge received data into state and return "everything new I've
|
|
||||||
// just learnt", or nil if nothing in the received data was new
|
|
||||||
OnGossip(update []byte) (GossipData, error)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Accumulates GossipData that needs to be sent to one destination,
|
|
||||||
// and sends it when possible.
|
|
||||||
type GossipSender struct {
|
|
||||||
send func(GossipData)
|
|
||||||
cell chan GossipData
|
|
||||||
// for testing
|
|
||||||
sent bool
|
|
||||||
flushch chan chan bool
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewGossipSender(send func(GossipData)) *GossipSender {
|
|
||||||
cell := make(chan GossipData, 1)
|
|
||||||
flushch := make(chan chan bool)
|
|
||||||
sender := &GossipSender{
|
|
||||||
send: send,
|
|
||||||
cell: cell,
|
|
||||||
flushch: flushch,
|
|
||||||
}
|
|
||||||
go sender.run()
|
|
||||||
return sender
|
|
||||||
}
|
|
||||||
|
|
||||||
func (sender *GossipSender) run() {
|
|
||||||
for {
|
|
||||||
select {
|
|
||||||
case pending := <-sender.cell:
|
|
||||||
if pending == nil { // receive zero value when chan is closed
|
|
||||||
return
|
|
||||||
}
|
|
||||||
sender.send(pending)
|
|
||||||
sender.sent = true
|
|
||||||
case ch := <-sender.flushch:
|
|
||||||
// send anything pending, then reply back whether we sent
|
|
||||||
// anything since previous flush
|
|
||||||
select {
|
|
||||||
case pending := <-sender.cell:
|
|
||||||
sender.send(pending)
|
|
||||||
sender.sent = true
|
|
||||||
default:
|
|
||||||
}
|
|
||||||
ch <- sender.sent
|
|
||||||
sender.sent = false
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (sender *GossipSender) Send(data GossipData) {
|
|
||||||
// NB: this must not be invoked concurrently
|
|
||||||
select {
|
|
||||||
case pending := <-sender.cell:
|
|
||||||
sender.cell <- pending.Merge(data)
|
|
||||||
default:
|
|
||||||
sender.cell <- data
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (sender *GossipSender) Stop() {
|
|
||||||
close(sender.cell)
|
|
||||||
}
|
|
||||||
|
|
||||||
type GossipChannels map[string]*GossipChannel
|
|
||||||
|
|
||||||
func (router *Router) NewGossip(channelName string, g Gossiper) Gossip {
|
|
||||||
channel := NewGossipChannel(channelName, router.Ourself, router.Routes, g)
|
|
||||||
router.gossipLock.Lock()
|
|
||||||
defer router.gossipLock.Unlock()
|
|
||||||
if _, found := router.gossipChannels[channelName]; found {
|
|
||||||
checkFatal(fmt.Errorf("[gossip] duplicate channel %s", channelName))
|
|
||||||
}
|
|
||||||
router.gossipChannels[channelName] = channel
|
|
||||||
return channel
|
|
||||||
}
|
|
||||||
|
|
||||||
func (router *Router) gossipChannel(channelName string) *GossipChannel {
|
|
||||||
router.gossipLock.RLock()
|
|
||||||
channel, found := router.gossipChannels[channelName]
|
|
||||||
router.gossipLock.RUnlock()
|
|
||||||
if found {
|
|
||||||
return channel
|
|
||||||
}
|
|
||||||
router.gossipLock.Lock()
|
|
||||||
defer router.gossipLock.Unlock()
|
|
||||||
if channel, found = router.gossipChannels[channelName]; found {
|
|
||||||
return channel
|
|
||||||
}
|
|
||||||
channel = NewGossipChannel(channelName, router.Ourself, router.Routes, &surrogateGossiper)
|
|
||||||
channel.log("created surrogate channel")
|
|
||||||
router.gossipChannels[channelName] = channel
|
|
||||||
return channel
|
|
||||||
}
|
|
||||||
|
|
||||||
func (router *Router) gossipChannelSet() map[*GossipChannel]struct{} {
|
|
||||||
channels := make(map[*GossipChannel]struct{})
|
|
||||||
router.gossipLock.RLock()
|
|
||||||
defer router.gossipLock.RUnlock()
|
|
||||||
for _, channel := range router.gossipChannels {
|
|
||||||
channels[channel] = void
|
|
||||||
}
|
|
||||||
return channels
|
|
||||||
}
|
|
||||||
|
|
||||||
func (router *Router) SendAllGossip() {
|
|
||||||
for channel := range router.gossipChannelSet() {
|
|
||||||
if gossip := channel.gossiper.Gossip(); gossip != nil {
|
|
||||||
channel.Send(router.Ourself.Name, gossip)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (router *Router) SendAllGossipDown(conn Connection) {
|
|
||||||
for channel := range router.gossipChannelSet() {
|
|
||||||
if gossip := channel.gossiper.Gossip(); gossip != nil {
|
|
||||||
channel.SendDown(conn, gossip)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// for testing
|
|
||||||
|
|
||||||
func (router *Router) sendPendingGossip() bool {
|
|
||||||
sentSomething := false
|
|
||||||
for channel := range router.gossipChannelSet() {
|
|
||||||
channel.Lock()
|
|
||||||
for _, sender := range channel.senders {
|
|
||||||
sentSomething = sender.flush() || sentSomething
|
|
||||||
}
|
|
||||||
for _, sender := range channel.broadcasters {
|
|
||||||
sentSomething = sender.flush() || sentSomething
|
|
||||||
}
|
|
||||||
channel.Unlock()
|
|
||||||
}
|
|
||||||
return sentSomething
|
|
||||||
}
|
|
||||||
|
|
||||||
func (sender *GossipSender) flush() bool {
|
|
||||||
ch := make(chan bool)
|
|
||||||
sender.flushch <- ch
|
|
||||||
return <-ch
|
|
||||||
}
|
|
||||||
@@ -1,244 +0,0 @@
|
|||||||
package mesh
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"encoding/gob"
|
|
||||||
"fmt"
|
|
||||||
"sync"
|
|
||||||
)
|
|
||||||
|
|
||||||
type GossipChannel struct {
|
|
||||||
sync.Mutex
|
|
||||||
name string
|
|
||||||
ourself *LocalPeer
|
|
||||||
routes *Routes
|
|
||||||
gossiper Gossiper
|
|
||||||
senders connectionSenders
|
|
||||||
broadcasters peerSenders
|
|
||||||
}
|
|
||||||
|
|
||||||
type connectionSenders map[Connection]*GossipSender
|
|
||||||
type peerSenders map[PeerName]*GossipSender
|
|
||||||
|
|
||||||
func NewGossipChannel(channelName string, ourself *LocalPeer, routes *Routes, g Gossiper) *GossipChannel {
|
|
||||||
return &GossipChannel{
|
|
||||||
name: channelName,
|
|
||||||
ourself: ourself,
|
|
||||||
routes: routes,
|
|
||||||
gossiper: g,
|
|
||||||
senders: make(connectionSenders),
|
|
||||||
broadcasters: make(peerSenders)}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (router *Router) handleGossip(tag ProtocolTag, payload []byte) error {
|
|
||||||
decoder := gob.NewDecoder(bytes.NewReader(payload))
|
|
||||||
var channelName string
|
|
||||||
if err := decoder.Decode(&channelName); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
channel := router.gossipChannel(channelName)
|
|
||||||
var srcName PeerName
|
|
||||||
if err := decoder.Decode(&srcName); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
switch tag {
|
|
||||||
case ProtocolGossipUnicast:
|
|
||||||
return channel.deliverUnicast(srcName, payload, decoder)
|
|
||||||
case ProtocolGossipBroadcast:
|
|
||||||
return channel.deliverBroadcast(srcName, payload, decoder)
|
|
||||||
case ProtocolGossip:
|
|
||||||
return channel.deliver(srcName, payload, decoder)
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *GossipChannel) deliverUnicast(srcName PeerName, origPayload []byte, dec *gob.Decoder) error {
|
|
||||||
var destName PeerName
|
|
||||||
if err := dec.Decode(&destName); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if c.ourself.Name != destName {
|
|
||||||
if err := c.relayUnicast(destName, origPayload); err != nil {
|
|
||||||
// just log errors from relayUnicast; a problem between us and destination
|
|
||||||
// is not enough reason to break the connection from the source
|
|
||||||
c.log(err)
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
var payload []byte
|
|
||||||
if err := dec.Decode(&payload); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
return c.gossiper.OnGossipUnicast(srcName, payload)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *GossipChannel) deliverBroadcast(srcName PeerName, _ []byte, dec *gob.Decoder) error {
|
|
||||||
var payload []byte
|
|
||||||
if err := dec.Decode(&payload); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
data, err := c.gossiper.OnGossipBroadcast(srcName, payload)
|
|
||||||
if err != nil || data == nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
return c.relayBroadcast(srcName, data)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *GossipChannel) deliver(srcName PeerName, _ []byte, dec *gob.Decoder) error {
|
|
||||||
var payload []byte
|
|
||||||
if err := dec.Decode(&payload); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
if data, err := c.gossiper.OnGossip(payload); err != nil {
|
|
||||||
return err
|
|
||||||
} else if data != nil {
|
|
||||||
c.Send(srcName, data)
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *GossipChannel) GossipUnicast(dstPeerName PeerName, msg []byte) error {
|
|
||||||
return c.relayUnicast(dstPeerName, GobEncode(c.name, c.ourself.Name, dstPeerName, msg))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *GossipChannel) GossipBroadcast(update GossipData) error {
|
|
||||||
return c.relayBroadcast(c.ourself.Name, update)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *GossipChannel) relayUnicast(dstPeerName PeerName, buf []byte) (err error) {
|
|
||||||
if relayPeerName, found := c.routes.UnicastAll(dstPeerName); !found {
|
|
||||||
err = fmt.Errorf("unknown relay destination: %s", dstPeerName)
|
|
||||||
} else if conn, found := c.ourself.ConnectionTo(relayPeerName); !found {
|
|
||||||
err = fmt.Errorf("unable to find connection to relay peer %s", relayPeerName)
|
|
||||||
} else {
|
|
||||||
conn.(ProtocolSender).SendProtocolMsg(ProtocolMsg{ProtocolGossipUnicast, buf})
|
|
||||||
}
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *GossipChannel) relayBroadcast(srcName PeerName, update GossipData) error {
|
|
||||||
names := c.routes.PeerNames() // do this outside the lock so they don't nest
|
|
||||||
c.Lock()
|
|
||||||
defer c.Unlock()
|
|
||||||
// GC - randomly (courtesy of go's map iterator) pick some
|
|
||||||
// existing broadcasters and stop&remove them if their source peer
|
|
||||||
// is unknown. We stop as soon as we encounter a valid entry; the
|
|
||||||
// idea being that when there is little or no garbage then this
|
|
||||||
// executes close to O(1)[1], whereas when there is lots of
|
|
||||||
// garbage we remove it quickly.
|
|
||||||
//
|
|
||||||
// [1] TODO Unfortunately, due to the desire to avoid nested
|
|
||||||
// locks, instead of simply invoking Peers.Fetch(name) below, we
|
|
||||||
// have that Peers.Names() invocation above. That is O(n_peers) at
|
|
||||||
// best.
|
|
||||||
for name, broadcaster := range c.broadcasters {
|
|
||||||
if _, found := names[name]; !found {
|
|
||||||
delete(c.broadcasters, name)
|
|
||||||
broadcaster.Stop()
|
|
||||||
} else {
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
broadcaster, found := c.broadcasters[srcName]
|
|
||||||
if !found {
|
|
||||||
broadcaster = NewGossipSender(func(pending GossipData) { c.sendBroadcast(srcName, pending) })
|
|
||||||
c.broadcasters[srcName] = broadcaster
|
|
||||||
}
|
|
||||||
broadcaster.Send(update)
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *GossipChannel) sendBroadcast(srcName PeerName, update GossipData) {
|
|
||||||
c.routes.EnsureRecalculated()
|
|
||||||
nextHops := c.routes.BroadcastAll(srcName)
|
|
||||||
if len(nextHops) == 0 {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
connections := c.ourself.ConnectionsTo(nextHops)
|
|
||||||
for _, msg := range update.Encode() {
|
|
||||||
protocolMsg := ProtocolMsg{ProtocolGossipBroadcast, GobEncode(c.name, srcName, msg)}
|
|
||||||
// FIXME a single blocked connection can stall us
|
|
||||||
for _, conn := range connections {
|
|
||||||
conn.(ProtocolSender).SendProtocolMsg(protocolMsg)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *GossipChannel) Send(srcName PeerName, data GossipData) {
|
|
||||||
c.routes.EnsureRecalculated()
|
|
||||||
destinations := c.routes.RandomNeighbours(srcName)
|
|
||||||
if len(destinations) == 0 {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
c.sendDown(c.ourself.ConnectionsTo(destinations), data)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *GossipChannel) SendDown(conn Connection, data GossipData) {
|
|
||||||
c.sendDown([]Connection{conn}, data)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *GossipChannel) sendDown(selectedConnections []Connection, data GossipData) {
|
|
||||||
if len(selectedConnections) == 0 {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
connections := c.ourself.Connections()
|
|
||||||
c.Lock()
|
|
||||||
defer c.Unlock()
|
|
||||||
// GC - randomly (courtesy of go's map iterator) pick some
|
|
||||||
// existing senders and stop&remove them if the associated
|
|
||||||
// connection is no longer active. We stop as soon as we
|
|
||||||
// encounter a valid entry; the idea being that when there is
|
|
||||||
// little or no garbage then this executes close to O(1)[1],
|
|
||||||
// whereas when there is lots of garbage we remove it quickly.
|
|
||||||
//
|
|
||||||
// [1] TODO Unfortunately, due to the desire to avoid nested
|
|
||||||
// locks, instead of simply invoking LocalPeer.ConnectionTo(name),
|
|
||||||
// we operate on LocalPeer.Connections(). That is
|
|
||||||
// O(n_our_connections) at best.
|
|
||||||
for conn, sender := range c.senders {
|
|
||||||
if _, found := connections[conn]; !found {
|
|
||||||
delete(c.senders, conn)
|
|
||||||
sender.Stop()
|
|
||||||
} else {
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
// start senders, if necessary, and send.
|
|
||||||
for _, conn := range selectedConnections {
|
|
||||||
sender, found := c.senders[conn]
|
|
||||||
if !found {
|
|
||||||
sender = c.makeSender(conn)
|
|
||||||
c.senders[conn] = sender
|
|
||||||
}
|
|
||||||
sender.Send(data)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// We have seen a couple of failures which suggest a >128GB slice was encountered.
|
|
||||||
// 100MB should be enough for anyone.
|
|
||||||
const maxFeasibleMessageLen = 100 * 1024 * 1024
|
|
||||||
|
|
||||||
func (c *GossipChannel) makeSender(conn Connection) *GossipSender {
|
|
||||||
return NewGossipSender(func(pending GossipData) {
|
|
||||||
for _, msg := range pending.Encode() {
|
|
||||||
if len(msg) > maxFeasibleMessageLen {
|
|
||||||
panic(fmt.Sprintf("Gossip message too large: len=%d bytes; on channel '%s' from %+v", len(msg), c.name, pending))
|
|
||||||
}
|
|
||||||
protocolMsg := ProtocolMsg{ProtocolGossip, GobEncode(c.name, c.ourself.Name, msg)}
|
|
||||||
conn.(ProtocolSender).SendProtocolMsg(protocolMsg)
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (c *GossipChannel) log(args ...interface{}) {
|
|
||||||
log.Println(append(append([]interface{}{}, "[gossip "+c.name+"]:"), args...)...)
|
|
||||||
}
|
|
||||||
|
|
||||||
func GobEncode(items ...interface{}) []byte {
|
|
||||||
buf := new(bytes.Buffer)
|
|
||||||
enc := gob.NewEncoder(buf)
|
|
||||||
for _, i := range items {
|
|
||||||
checkFatal(enc.Encode(i))
|
|
||||||
}
|
|
||||||
return buf.Bytes()
|
|
||||||
}
|
|
||||||
@@ -1,230 +0,0 @@
|
|||||||
package mesh
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"sync"
|
|
||||||
"testing"
|
|
||||||
|
|
||||||
"github.com/stretchr/testify/require"
|
|
||||||
)
|
|
||||||
|
|
||||||
// TODO test gossip unicast; atm we only test topology gossip and
|
|
||||||
// surrogates, neither of which employ unicast.
|
|
||||||
|
|
||||||
type mockGossipConnection struct {
|
|
||||||
RemoteConnection
|
|
||||||
dest *Router
|
|
||||||
start chan struct{}
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewTestRouter(name string) *Router {
|
|
||||||
peerName, _ := PeerNameFromString(name)
|
|
||||||
router := NewRouter(Config{}, peerName, "nick", nil)
|
|
||||||
router.Start()
|
|
||||||
return router
|
|
||||||
}
|
|
||||||
|
|
||||||
func (conn *mockGossipConnection) SendProtocolMsg(protocolMsg ProtocolMsg) {
|
|
||||||
<-conn.start
|
|
||||||
if err := conn.dest.handleGossip(protocolMsg.tag, protocolMsg.msg); err != nil {
|
|
||||||
panic(err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (conn *mockGossipConnection) Start() {
|
|
||||||
close(conn.start)
|
|
||||||
}
|
|
||||||
|
|
||||||
func sendPendingGossip(routers ...*Router) {
|
|
||||||
// Loop until all routers report they didn't send anything
|
|
||||||
for sentSomething := true; sentSomething; {
|
|
||||||
sentSomething = false
|
|
||||||
for _, router := range routers {
|
|
||||||
sentSomething = router.sendPendingGossip() || sentSomething
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func AddTestGossipConnection(r1, r2 *Router) {
|
|
||||||
c1 := r1.NewTestGossipConnection(r2)
|
|
||||||
c2 := r2.NewTestGossipConnection(r1)
|
|
||||||
c1.Start()
|
|
||||||
c2.Start()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (router *Router) NewTestGossipConnection(r *Router) *mockGossipConnection {
|
|
||||||
to := r.Ourself.Peer
|
|
||||||
toPeer := NewPeer(to.Name, to.NickName, to.UID, 0, to.ShortID)
|
|
||||||
toPeer = router.Peers.FetchWithDefault(toPeer) // Has side-effect of incrementing refcount
|
|
||||||
|
|
||||||
conn := &mockGossipConnection{
|
|
||||||
RemoteConnection{router.Ourself.Peer, toPeer, "", false, true}, r, make(chan struct{})}
|
|
||||||
router.Ourself.handleAddConnection(conn)
|
|
||||||
router.Ourself.handleConnectionEstablished(conn)
|
|
||||||
return conn
|
|
||||||
}
|
|
||||||
|
|
||||||
func (router *Router) DeleteTestGossipConnection(r *Router) {
|
|
||||||
toName := r.Ourself.Peer.Name
|
|
||||||
conn, _ := router.Ourself.ConnectionTo(toName)
|
|
||||||
router.Peers.Dereference(conn.Remote())
|
|
||||||
router.Ourself.handleDeleteConnection(conn)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Create a Peer representing the receiver router, with connections to
|
|
||||||
// the routers supplied as arguments, carrying across all UID and
|
|
||||||
// version information.
|
|
||||||
func (router *Router) tp(routers ...*Router) *Peer {
|
|
||||||
peer := NewPeerFrom(router.Ourself.Peer)
|
|
||||||
connections := make(map[PeerName]Connection)
|
|
||||||
for _, r := range routers {
|
|
||||||
p := NewPeerFrom(r.Ourself.Peer)
|
|
||||||
connections[r.Ourself.Peer.Name] = newMockConnection(peer, p)
|
|
||||||
}
|
|
||||||
peer.Version = router.Ourself.Peer.Version
|
|
||||||
peer.connections = connections
|
|
||||||
return peer
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check that the topology of router matches the peers and all of their connections
|
|
||||||
func checkTopology(t *testing.T, router *Router, wantedPeers ...*Peer) {
|
|
||||||
router.Peers.RLock()
|
|
||||||
checkTopologyPeers(t, true, router.Peers.allPeers(), wantedPeers...)
|
|
||||||
router.Peers.RUnlock()
|
|
||||||
}
|
|
||||||
|
|
||||||
func flushAndCheckTopology(t *testing.T, routers []*Router, wantedPeers ...*Peer) {
|
|
||||||
sendPendingGossip(routers...)
|
|
||||||
for _, r := range routers {
|
|
||||||
checkTopology(t, r, wantedPeers...)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestGossipTopology(t *testing.T) {
|
|
||||||
// Create some peers that will talk to each other
|
|
||||||
r1 := NewTestRouter("01:00:00:01:00:00")
|
|
||||||
r2 := NewTestRouter("02:00:00:02:00:00")
|
|
||||||
r3 := NewTestRouter("03:00:00:03:00:00")
|
|
||||||
routers := []*Router{r1, r2, r3}
|
|
||||||
// Check state when they have no connections
|
|
||||||
checkTopology(t, r1, r1.tp())
|
|
||||||
checkTopology(t, r2, r2.tp())
|
|
||||||
|
|
||||||
// Now try adding some connections
|
|
||||||
AddTestGossipConnection(r1, r2)
|
|
||||||
sendPendingGossip(r1, r2)
|
|
||||||
checkTopology(t, r1, r1.tp(r2), r2.tp(r1))
|
|
||||||
checkTopology(t, r2, r1.tp(r2), r2.tp(r1))
|
|
||||||
|
|
||||||
AddTestGossipConnection(r2, r3)
|
|
||||||
flushAndCheckTopology(t, routers, r1.tp(r2), r2.tp(r1, r3), r3.tp(r2))
|
|
||||||
|
|
||||||
AddTestGossipConnection(r3, r1)
|
|
||||||
flushAndCheckTopology(t, routers, r1.tp(r2, r3), r2.tp(r1, r3), r3.tp(r1, r2))
|
|
||||||
|
|
||||||
// Drop the connection from 2 to 3
|
|
||||||
r2.DeleteTestGossipConnection(r3)
|
|
||||||
flushAndCheckTopology(t, routers, r1.tp(r2, r3), r2.tp(r1), r3.tp(r1, r2))
|
|
||||||
|
|
||||||
// Drop the connection from 1 to 3
|
|
||||||
r1.DeleteTestGossipConnection(r3)
|
|
||||||
sendPendingGossip(r1, r2, r3)
|
|
||||||
checkTopology(t, r1, r1.tp(r2), r2.tp(r1))
|
|
||||||
checkTopology(t, r2, r1.tp(r2), r2.tp(r1))
|
|
||||||
// r3 still thinks r1 has a connection to it
|
|
||||||
checkTopology(t, r3, r1.tp(r2, r3), r2.tp(r1), r3.tp(r1, r2))
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestGossipSurrogate(t *testing.T) {
|
|
||||||
// create the topology r1 <-> r2 <-> r3
|
|
||||||
r1 := NewTestRouter("01:00:00:01:00:00")
|
|
||||||
r2 := NewTestRouter("02:00:00:02:00:00")
|
|
||||||
r3 := NewTestRouter("03:00:00:03:00:00")
|
|
||||||
routers := []*Router{r1, r2, r3}
|
|
||||||
AddTestGossipConnection(r1, r2)
|
|
||||||
AddTestGossipConnection(r3, r2)
|
|
||||||
flushAndCheckTopology(t, routers, r1.tp(r2), r2.tp(r1, r3), r3.tp(r2))
|
|
||||||
|
|
||||||
// create a gossiper at either end, but not the middle
|
|
||||||
g1 := newTestGossiper()
|
|
||||||
g3 := newTestGossiper()
|
|
||||||
s1 := r1.NewGossip("Test", g1)
|
|
||||||
s3 := r3.NewGossip("Test", g3)
|
|
||||||
|
|
||||||
// broadcast a message from each end, check it reaches the other
|
|
||||||
broadcast(s1, 1)
|
|
||||||
broadcast(s3, 2)
|
|
||||||
sendPendingGossip(r1, r2, r3)
|
|
||||||
g1.checkHas(t, 2)
|
|
||||||
g3.checkHas(t, 1)
|
|
||||||
|
|
||||||
// check that each end gets their message back through periodic
|
|
||||||
// gossip
|
|
||||||
r1.SendAllGossip()
|
|
||||||
r3.SendAllGossip()
|
|
||||||
sendPendingGossip(r1, r2, r3)
|
|
||||||
g1.checkHas(t, 1, 2)
|
|
||||||
g3.checkHas(t, 1, 2)
|
|
||||||
}
|
|
||||||
|
|
||||||
type testGossiper struct {
|
|
||||||
sync.RWMutex
|
|
||||||
state map[byte]struct{}
|
|
||||||
}
|
|
||||||
|
|
||||||
func newTestGossiper() *testGossiper {
|
|
||||||
return &testGossiper{state: make(map[byte]struct{})}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (g *testGossiper) OnGossipUnicast(sender PeerName, msg []byte) error {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (g *testGossiper) OnGossipBroadcast(_ PeerName, update []byte) (GossipData, error) {
|
|
||||||
g.Lock()
|
|
||||||
defer g.Unlock()
|
|
||||||
for _, v := range update {
|
|
||||||
g.state[v] = void
|
|
||||||
}
|
|
||||||
return NewSurrogateGossipData(update), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (g *testGossiper) Gossip() GossipData {
|
|
||||||
g.RLock()
|
|
||||||
defer g.RUnlock()
|
|
||||||
state := make([]byte, len(g.state))
|
|
||||||
for v := range g.state {
|
|
||||||
state = append(state, v)
|
|
||||||
}
|
|
||||||
return NewSurrogateGossipData(state)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (g *testGossiper) OnGossip(update []byte) (GossipData, error) {
|
|
||||||
g.Lock()
|
|
||||||
defer g.Unlock()
|
|
||||||
var delta []byte
|
|
||||||
for _, v := range update {
|
|
||||||
if _, found := g.state[v]; !found {
|
|
||||||
delta = append(delta, v)
|
|
||||||
g.state[v] = void
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if len(delta) == 0 {
|
|
||||||
return nil, nil
|
|
||||||
}
|
|
||||||
return NewSurrogateGossipData(delta), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (g *testGossiper) checkHas(t *testing.T, vs ...byte) {
|
|
||||||
g.RLock()
|
|
||||||
defer g.RUnlock()
|
|
||||||
for _, v := range vs {
|
|
||||||
if _, found := g.state[v]; !found {
|
|
||||||
require.FailNow(t, fmt.Sprintf("%d is missing", v))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func broadcast(s Gossip, v byte) {
|
|
||||||
s.GossipBroadcast(NewSurrogateGossipData([]byte{v}))
|
|
||||||
}
|
|
||||||
@@ -1,261 +0,0 @@
|
|||||||
package mesh
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"net"
|
|
||||||
"sync"
|
|
||||||
"time"
|
|
||||||
)
|
|
||||||
|
|
||||||
type LocalPeer struct {
|
|
||||||
sync.RWMutex
|
|
||||||
*Peer
|
|
||||||
router *Router
|
|
||||||
actionChan chan<- LocalPeerAction
|
|
||||||
}
|
|
||||||
|
|
||||||
type LocalPeerAction func()
|
|
||||||
|
|
||||||
func NewLocalPeer(name PeerName, nickName string, router *Router) *LocalPeer {
|
|
||||||
actionChan := make(chan LocalPeerAction, ChannelSize)
|
|
||||||
peer := &LocalPeer{
|
|
||||||
Peer: NewPeer(name, nickName, randomPeerUID(), 0, randomPeerShortID()),
|
|
||||||
router: router,
|
|
||||||
actionChan: actionChan,
|
|
||||||
}
|
|
||||||
go peer.actorLoop(actionChan)
|
|
||||||
return peer
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peer *LocalPeer) Connections() ConnectionSet {
|
|
||||||
connections := make(ConnectionSet)
|
|
||||||
peer.RLock()
|
|
||||||
defer peer.RUnlock()
|
|
||||||
for _, conn := range peer.connections {
|
|
||||||
connections[conn] = void
|
|
||||||
}
|
|
||||||
return connections
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peer *LocalPeer) ConnectionTo(name PeerName) (Connection, bool) {
|
|
||||||
peer.RLock()
|
|
||||||
defer peer.RUnlock()
|
|
||||||
conn, found := peer.connections[name]
|
|
||||||
return conn, found // yes, you really can't inline that. FFS.
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peer *LocalPeer) ConnectionsTo(names []PeerName) []Connection {
|
|
||||||
conns := make([]Connection, 0, len(names))
|
|
||||||
peer.RLock()
|
|
||||||
defer peer.RUnlock()
|
|
||||||
for _, name := range names {
|
|
||||||
conn, found := peer.connections[name]
|
|
||||||
// Again, !found could just be due to a race.
|
|
||||||
if found {
|
|
||||||
conns = append(conns, conn)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return conns
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peer *LocalPeer) CreateConnection(peerAddr string, acceptNewPeer bool) error {
|
|
||||||
if err := peer.checkConnectionLimit(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
tcpAddr, err := net.ResolveTCPAddr("tcp4", peerAddr)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
tcpConn, err := net.DialTCP("tcp4", nil, tcpAddr)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
connRemote := NewRemoteConnection(peer.Peer, nil, tcpConn.RemoteAddr().String(), true, false)
|
|
||||||
StartLocalConnection(connRemote, tcpConn, peer.router, acceptNewPeer)
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// ACTOR client API
|
|
||||||
|
|
||||||
// Sync.
|
|
||||||
func (peer *LocalPeer) AddConnection(conn *LocalConnection) error {
|
|
||||||
resultChan := make(chan error)
|
|
||||||
peer.actionChan <- func() {
|
|
||||||
resultChan <- peer.handleAddConnection(conn)
|
|
||||||
}
|
|
||||||
return <-resultChan
|
|
||||||
}
|
|
||||||
|
|
||||||
// Async.
|
|
||||||
func (peer *LocalPeer) ConnectionEstablished(conn *LocalConnection) {
|
|
||||||
peer.actionChan <- func() {
|
|
||||||
peer.handleConnectionEstablished(conn)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Sync.
|
|
||||||
func (peer *LocalPeer) DeleteConnection(conn *LocalConnection) {
|
|
||||||
resultChan := make(chan interface{})
|
|
||||||
peer.actionChan <- func() {
|
|
||||||
peer.handleDeleteConnection(conn)
|
|
||||||
resultChan <- nil
|
|
||||||
}
|
|
||||||
<-resultChan
|
|
||||||
}
|
|
||||||
|
|
||||||
// ACTOR server
|
|
||||||
|
|
||||||
func (peer *LocalPeer) actorLoop(actionChan <-chan LocalPeerAction) {
|
|
||||||
gossipTimer := time.Tick(GossipInterval)
|
|
||||||
for {
|
|
||||||
select {
|
|
||||||
case action := <-actionChan:
|
|
||||||
action()
|
|
||||||
case <-gossipTimer:
|
|
||||||
peer.router.SendAllGossip()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peer *LocalPeer) handleAddConnection(conn Connection) error {
|
|
||||||
if peer.Peer != conn.Local() {
|
|
||||||
log.Fatal("Attempt made to add connection to peer where peer is not the source of connection")
|
|
||||||
}
|
|
||||||
if conn.Remote() == nil {
|
|
||||||
log.Fatal("Attempt made to add connection to peer with unknown remote peer")
|
|
||||||
}
|
|
||||||
toName := conn.Remote().Name
|
|
||||||
dupErr := fmt.Errorf("Multiple connections to %s added to %s", conn.Remote(), peer.String())
|
|
||||||
// deliberately non symmetrical
|
|
||||||
if dupConn, found := peer.connections[toName]; found {
|
|
||||||
if dupConn == conn {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
switch conn.BreakTie(dupConn) {
|
|
||||||
case TieBreakWon:
|
|
||||||
dupConn.Shutdown(dupErr)
|
|
||||||
peer.handleDeleteConnection(dupConn)
|
|
||||||
case TieBreakLost:
|
|
||||||
return dupErr
|
|
||||||
case TieBreakTied:
|
|
||||||
// oh good grief. Sod it, just kill both of them.
|
|
||||||
dupConn.Shutdown(dupErr)
|
|
||||||
peer.handleDeleteConnection(dupConn)
|
|
||||||
return dupErr
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if err := peer.checkConnectionLimit(); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
_, isConnectedPeer := peer.router.Routes.Unicast(toName)
|
|
||||||
peer.addConnection(conn)
|
|
||||||
if isConnectedPeer {
|
|
||||||
conn.Log("connection added")
|
|
||||||
} else {
|
|
||||||
conn.Log("connection added (new peer)")
|
|
||||||
peer.router.SendAllGossipDown(conn)
|
|
||||||
}
|
|
||||||
|
|
||||||
peer.router.Routes.Recalculate()
|
|
||||||
peer.broadcastPeerUpdate(conn.Remote())
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peer *LocalPeer) handleConnectionEstablished(conn Connection) {
|
|
||||||
if peer.Peer != conn.Local() {
|
|
||||||
log.Fatal("Peer informed of active connection where peer is not the source of connection")
|
|
||||||
}
|
|
||||||
if dupConn, found := peer.connections[conn.Remote().Name]; !found || conn != dupConn {
|
|
||||||
conn.Shutdown(fmt.Errorf("Cannot set unknown connection active"))
|
|
||||||
return
|
|
||||||
}
|
|
||||||
peer.connectionEstablished(conn)
|
|
||||||
conn.Log("connection fully established")
|
|
||||||
|
|
||||||
peer.router.Routes.Recalculate()
|
|
||||||
peer.broadcastPeerUpdate()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peer *LocalPeer) handleDeleteConnection(conn Connection) {
|
|
||||||
if peer.Peer != conn.Local() {
|
|
||||||
log.Fatal("Attempt made to delete connection from peer where peer is not the source of connection")
|
|
||||||
}
|
|
||||||
if conn.Remote() == nil {
|
|
||||||
log.Fatal("Attempt made to delete connection to peer with unknown remote peer")
|
|
||||||
}
|
|
||||||
toName := conn.Remote().Name
|
|
||||||
if connFound, found := peer.connections[toName]; !found || connFound != conn {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
peer.deleteConnection(conn)
|
|
||||||
conn.Log("connection deleted")
|
|
||||||
// Must do garbage collection first to ensure we don't send out an
|
|
||||||
// update with unreachable peers (can cause looping)
|
|
||||||
peer.router.Peers.GarbageCollect()
|
|
||||||
peer.router.Routes.Recalculate()
|
|
||||||
peer.broadcastPeerUpdate()
|
|
||||||
}
|
|
||||||
|
|
||||||
// helpers
|
|
||||||
|
|
||||||
func (peer *LocalPeer) broadcastPeerUpdate(peers ...*Peer) {
|
|
||||||
// Some tests run without a router. This should be fixed so
|
|
||||||
// that the relevant part of Router can be easily run in the
|
|
||||||
// context of a test, but that will involve significant
|
|
||||||
// reworking of tests.
|
|
||||||
if peer.router != nil {
|
|
||||||
peer.router.BroadcastTopologyUpdate(append(peers, peer.Peer))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peer *LocalPeer) checkConnectionLimit() error {
|
|
||||||
limit := peer.router.ConnLimit
|
|
||||||
if 0 != limit && peer.connectionCount() >= limit {
|
|
||||||
return fmt.Errorf("Connection limit reached (%v)", limit)
|
|
||||||
}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peer *LocalPeer) addConnection(conn Connection) {
|
|
||||||
peer.Lock()
|
|
||||||
defer peer.Unlock()
|
|
||||||
peer.connections[conn.Remote().Name] = conn
|
|
||||||
peer.Version++
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peer *LocalPeer) deleteConnection(conn Connection) {
|
|
||||||
peer.Lock()
|
|
||||||
defer peer.Unlock()
|
|
||||||
delete(peer.connections, conn.Remote().Name)
|
|
||||||
peer.Version++
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peer *LocalPeer) connectionEstablished(conn Connection) {
|
|
||||||
peer.Lock()
|
|
||||||
defer peer.Unlock()
|
|
||||||
peer.Version++
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peer *LocalPeer) connectionCount() int {
|
|
||||||
peer.RLock()
|
|
||||||
defer peer.RUnlock()
|
|
||||||
return len(peer.connections)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peer *LocalPeer) setShortID(shortID PeerShortID) {
|
|
||||||
peer.Lock()
|
|
||||||
defer peer.Unlock()
|
|
||||||
peer.ShortID = shortID
|
|
||||||
peer.Version++
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peer *LocalPeer) setVersionBeyond(version uint64) bool {
|
|
||||||
peer.Lock()
|
|
||||||
defer peer.Unlock()
|
|
||||||
if version >= peer.Version {
|
|
||||||
peer.Version = version + 1
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
@@ -1,115 +0,0 @@
|
|||||||
// No mocks are tested by this file.
|
|
||||||
//
|
|
||||||
// It supplies some mock implementations to other unit tests, and is
|
|
||||||
// named "...test.go" so it is only compiled under `go test`.
|
|
||||||
|
|
||||||
package mesh
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"testing"
|
|
||||||
|
|
||||||
"github.com/stretchr/testify/require"
|
|
||||||
)
|
|
||||||
|
|
||||||
// Add to peers a connection from peers.ourself to p
|
|
||||||
func (peers *Peers) AddTestConnection(p *Peer) {
|
|
||||||
summary := p.PeerSummary
|
|
||||||
summary.Version = 0
|
|
||||||
toPeer := NewPeerFromSummary(summary)
|
|
||||||
toPeer = peers.FetchWithDefault(toPeer) // Has side-effect of incrementing refcount
|
|
||||||
conn := newMockConnection(peers.ourself.Peer, toPeer)
|
|
||||||
peers.ourself.addConnection(conn)
|
|
||||||
peers.ourself.connectionEstablished(conn)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Add to peers a connection from p1 to p2
|
|
||||||
func (peers *Peers) AddTestRemoteConnection(p1, p2 *Peer) {
|
|
||||||
fromPeer := NewPeerFrom(p1)
|
|
||||||
fromPeer = peers.FetchWithDefault(fromPeer)
|
|
||||||
toPeer := NewPeerFrom(p2)
|
|
||||||
toPeer = peers.FetchWithDefault(toPeer)
|
|
||||||
peers.ourself.addConnection(&RemoteConnection{fromPeer, toPeer, "", false, false})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peers *Peers) DeleteTestConnection(p *Peer) {
|
|
||||||
toName := p.Name
|
|
||||||
toPeer := peers.Fetch(toName)
|
|
||||||
peers.Dereference(toPeer)
|
|
||||||
conn, _ := peers.ourself.ConnectionTo(toName)
|
|
||||||
peers.ourself.deleteConnection(conn)
|
|
||||||
}
|
|
||||||
|
|
||||||
// mockConnection used in testing is very similar to a
|
|
||||||
// RemoteConnection, without the RemoteTCPAddr(). We are making it a
|
|
||||||
// separate type in order to distinguish what is created by the test
|
|
||||||
// from what is created by the real code.
|
|
||||||
func newMockConnection(from, to *Peer) Connection {
|
|
||||||
type mockConnection struct{ RemoteConnection }
|
|
||||||
return &mockConnection{RemoteConnection{from, to, "", false, false}}
|
|
||||||
}
|
|
||||||
|
|
||||||
func checkEqualConns(t *testing.T, ourName PeerName, got, wanted map[PeerName]Connection) {
|
|
||||||
checkConns := make(PeerNameSet)
|
|
||||||
for _, conn := range wanted {
|
|
||||||
checkConns[conn.Remote().Name] = void
|
|
||||||
}
|
|
||||||
for _, conn := range got {
|
|
||||||
remoteName := conn.Remote().Name
|
|
||||||
if _, found := checkConns[remoteName]; found {
|
|
||||||
delete(checkConns, remoteName)
|
|
||||||
} else {
|
|
||||||
require.FailNow(t, fmt.Sprintf("Unexpected connection from %s to %s", ourName, remoteName))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if len(checkConns) > 0 {
|
|
||||||
require.FailNow(t, fmt.Sprintf("Expected connections not found: from %s to %v", ourName, checkConns))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Get all the peers from a Peers in a slice
|
|
||||||
func (peers *Peers) allPeers() []*Peer {
|
|
||||||
var res []*Peer
|
|
||||||
for _, peer := range peers.byName {
|
|
||||||
res = append(res, peer)
|
|
||||||
}
|
|
||||||
return res
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peers *Peers) allPeersExcept(excludeName PeerName) []*Peer {
|
|
||||||
res := peers.allPeers()
|
|
||||||
for i, peer := range res {
|
|
||||||
if peer.Name == excludeName {
|
|
||||||
return append(res[:i], res[i+1:]...)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return res
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check that the peers slice matches the wanted peers
|
|
||||||
func checkPeerArray(t *testing.T, peers []*Peer, wantedPeers ...*Peer) {
|
|
||||||
checkTopologyPeers(t, false, peers, wantedPeers...)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check that the peers slice matches the wanted peers and optionally
|
|
||||||
// all of their connections
|
|
||||||
func checkTopologyPeers(t *testing.T, checkConns bool, peers []*Peer, wantedPeers ...*Peer) {
|
|
||||||
check := make(map[PeerName]*Peer)
|
|
||||||
for _, peer := range wantedPeers {
|
|
||||||
check[peer.Name] = peer
|
|
||||||
}
|
|
||||||
for _, peer := range peers {
|
|
||||||
name := peer.Name
|
|
||||||
if wantedPeer, found := check[name]; found {
|
|
||||||
if checkConns {
|
|
||||||
checkEqualConns(t, name, peer.connections, wantedPeer.connections)
|
|
||||||
}
|
|
||||||
delete(check, name)
|
|
||||||
} else {
|
|
||||||
require.FailNow(t, fmt.Sprintf("Unexpected peer: %s", name))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if len(check) > 0 {
|
|
||||||
require.FailNow(t, fmt.Sprintf("Expected peers not found: %v", check))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
-116
@@ -1,116 +0,0 @@
|
|||||||
package mesh
|
|
||||||
|
|
||||||
import (
|
|
||||||
"net"
|
|
||||||
)
|
|
||||||
|
|
||||||
type Overlay interface {
|
|
||||||
// Enhance a features map with overlay-related features
|
|
||||||
AddFeaturesTo(map[string]string)
|
|
||||||
|
|
||||||
// Prepare on overlay connection. The connection should remain
|
|
||||||
// passive until it has been Confirm()ed.
|
|
||||||
PrepareConnection(OverlayConnectionParams) (OverlayConnection, error)
|
|
||||||
|
|
||||||
// Obtain diagnostic information specific to the overlay
|
|
||||||
Diagnostics() interface{}
|
|
||||||
}
|
|
||||||
|
|
||||||
type OverlayConnectionParams struct {
|
|
||||||
RemotePeer *Peer
|
|
||||||
|
|
||||||
// The local address of the corresponding TCP connection. Used to
|
|
||||||
// derive the local IP address for sending. May differ for
|
|
||||||
// different overlay connections.
|
|
||||||
LocalAddr *net.TCPAddr
|
|
||||||
|
|
||||||
// The remote address of the corresponding TCP connection. Used to
|
|
||||||
// determine the address to send to, but only if the TCP
|
|
||||||
// connection is outbound. Otherwise the Overlay needs to discover
|
|
||||||
// it (e.g. from incoming datagrams).
|
|
||||||
RemoteAddr *net.TCPAddr
|
|
||||||
|
|
||||||
// Is the corresponding TCP connection outbound?
|
|
||||||
Outbound bool
|
|
||||||
|
|
||||||
// Unique identifier for this connection
|
|
||||||
ConnUID uint64
|
|
||||||
|
|
||||||
// Session key, if connection is encrypted; nil otherwise.
|
|
||||||
//
|
|
||||||
// NB: overlay connections must take care not to use nonces which
|
|
||||||
// may collide with those of the main connection. These nonces are
|
|
||||||
// 192 bits, with the top most bit unspecified, the next bit set
|
|
||||||
// to 1, followed by 126 zero bits, and a message sequence number
|
|
||||||
// in the lowest 64 bits.
|
|
||||||
SessionKey *[32]byte
|
|
||||||
|
|
||||||
// Function to send a control message to the counterpart
|
|
||||||
// overlay connection.
|
|
||||||
SendControlMessage func(tag byte, msg []byte) error
|
|
||||||
|
|
||||||
// Features passed at connection initiation
|
|
||||||
Features map[string]string
|
|
||||||
}
|
|
||||||
|
|
||||||
// All of the machinery to manage overlay connectivity to a particular
|
|
||||||
// peer
|
|
||||||
type OverlayConnection interface {
|
|
||||||
// Confirm that the connection is really wanted, and so the
|
|
||||||
// Overlay should begin heartbeats etc. to verify the operation of
|
|
||||||
// the overlay connection.
|
|
||||||
Confirm()
|
|
||||||
|
|
||||||
// A channel indicating that the overlay connection is
|
|
||||||
// established, i.e. its operation has been confirmed.
|
|
||||||
EstablishedChannel() <-chan struct{}
|
|
||||||
|
|
||||||
// A channel indicating an error from the overlay connection. The
|
|
||||||
// overlay connection is not expected to be operational after the
|
|
||||||
// first error, so the channel only needs to buffer a single
|
|
||||||
// error.
|
|
||||||
ErrorChannel() <-chan error
|
|
||||||
|
|
||||||
Stop()
|
|
||||||
|
|
||||||
// Handle a message from the peer. 'tag' exists for
|
|
||||||
// compatibility, and should always be
|
|
||||||
// ProtocolOverlayControlMessage for non-sleeve overlays.
|
|
||||||
ControlMessage(tag byte, msg []byte)
|
|
||||||
|
|
||||||
// User facing overlay name
|
|
||||||
DisplayName() string
|
|
||||||
}
|
|
||||||
|
|
||||||
type NullOverlay struct{}
|
|
||||||
|
|
||||||
func (NullOverlay) AddFeaturesTo(map[string]string) {
|
|
||||||
}
|
|
||||||
|
|
||||||
func (NullOverlay) PrepareConnection(OverlayConnectionParams) (OverlayConnection, error) {
|
|
||||||
return NullOverlay{}, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (NullOverlay) Diagnostics() interface{} {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
func (NullOverlay) Confirm() {
|
|
||||||
}
|
|
||||||
|
|
||||||
func (NullOverlay) EstablishedChannel() <-chan struct{} {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (NullOverlay) ErrorChannel() <-chan error {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (NullOverlay) Stop() {
|
|
||||||
}
|
|
||||||
|
|
||||||
func (NullOverlay) ControlMessage(byte, []byte) {
|
|
||||||
}
|
|
||||||
|
|
||||||
func (NullOverlay) DisplayName() string {
|
|
||||||
return "null"
|
|
||||||
}
|
|
||||||
-182
@@ -1,182 +0,0 @@
|
|||||||
package mesh
|
|
||||||
|
|
||||||
import (
|
|
||||||
"crypto/rand"
|
|
||||||
"encoding/binary"
|
|
||||||
"fmt"
|
|
||||||
"sort"
|
|
||||||
"strconv"
|
|
||||||
)
|
|
||||||
|
|
||||||
func randBytes(n int) []byte {
|
|
||||||
buf := make([]byte, n)
|
|
||||||
_, err := rand.Read(buf)
|
|
||||||
checkFatal(err)
|
|
||||||
return buf
|
|
||||||
}
|
|
||||||
|
|
||||||
func randUint64() (r uint64) {
|
|
||||||
return binary.LittleEndian.Uint64(randBytes(8))
|
|
||||||
}
|
|
||||||
|
|
||||||
func randUint16() (r uint16) {
|
|
||||||
return binary.LittleEndian.Uint16(randBytes(2))
|
|
||||||
}
|
|
||||||
|
|
||||||
type PeerUID uint64
|
|
||||||
|
|
||||||
func randomPeerUID() PeerUID {
|
|
||||||
for {
|
|
||||||
uid := randUint64()
|
|
||||||
if uid != 0 { // uid 0 is reserved for peer placeholder
|
|
||||||
return PeerUID(uid)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func ParsePeerUID(s string) (PeerUID, error) {
|
|
||||||
uid, err := strconv.ParseUint(s, 10, 64)
|
|
||||||
return PeerUID(uid), err
|
|
||||||
}
|
|
||||||
|
|
||||||
// Short IDs exist for the sake of fast datapath. They are 12 bits,
|
|
||||||
// randomly assigned, but we detect and recover from collisions. This
|
|
||||||
// does limit us to 4096 peers, but that should be sufficient for a
|
|
||||||
// while.
|
|
||||||
type PeerShortID uint16
|
|
||||||
|
|
||||||
const PeerShortIDBits = 12
|
|
||||||
|
|
||||||
func randomPeerShortID() PeerShortID {
|
|
||||||
return PeerShortID(randUint16() & (1<<PeerShortIDBits - 1))
|
|
||||||
}
|
|
||||||
|
|
||||||
type PeerSummary struct {
|
|
||||||
NameByte []byte
|
|
||||||
NickName string
|
|
||||||
UID PeerUID
|
|
||||||
Version uint64
|
|
||||||
ShortID PeerShortID
|
|
||||||
HasShortID bool
|
|
||||||
}
|
|
||||||
|
|
||||||
type Peer struct {
|
|
||||||
Name PeerName
|
|
||||||
PeerSummary
|
|
||||||
localRefCount uint64 // maintained by Peers
|
|
||||||
connections map[PeerName]Connection
|
|
||||||
}
|
|
||||||
|
|
||||||
type ListOfPeers []*Peer
|
|
||||||
|
|
||||||
func (lop ListOfPeers) Len() int {
|
|
||||||
return len(lop)
|
|
||||||
}
|
|
||||||
func (lop ListOfPeers) Swap(i, j int) {
|
|
||||||
lop[i], lop[j] = lop[j], lop[i]
|
|
||||||
}
|
|
||||||
func (lop ListOfPeers) Less(i, j int) bool {
|
|
||||||
return lop[i].Name < lop[j].Name
|
|
||||||
}
|
|
||||||
|
|
||||||
type ConnectionSet map[Connection]struct{}
|
|
||||||
|
|
||||||
func NewPeerFromSummary(summary PeerSummary) *Peer {
|
|
||||||
return &Peer{
|
|
||||||
Name: PeerNameFromBin(summary.NameByte),
|
|
||||||
PeerSummary: summary,
|
|
||||||
connections: make(map[PeerName]Connection),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewPeer(name PeerName, nickName string, uid PeerUID, version uint64, shortID PeerShortID) *Peer {
|
|
||||||
return NewPeerFromSummary(PeerSummary{
|
|
||||||
NameByte: name.Bin(),
|
|
||||||
NickName: nickName,
|
|
||||||
UID: uid,
|
|
||||||
Version: version,
|
|
||||||
ShortID: shortID,
|
|
||||||
HasShortID: true,
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewPeerPlaceholder(name PeerName) *Peer {
|
|
||||||
return NewPeerFromSummary(PeerSummary{NameByte: name.Bin()})
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewPeerFrom(peer *Peer) *Peer {
|
|
||||||
return NewPeerFromSummary(peer.PeerSummary)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peer *Peer) String() string {
|
|
||||||
return fmt.Sprint(peer.Name, "(", peer.NickName, ")")
|
|
||||||
}
|
|
||||||
|
|
||||||
// Calculate the routing table from this peer to all peers reachable
|
|
||||||
// from it, returning a "next hop" map of PeerNameX -> PeerNameY,
|
|
||||||
// which says "in order to send a message to X, the peer should send
|
|
||||||
// the message to its neighbour Y".
|
|
||||||
//
|
|
||||||
// Because currently we do not have weightings on the connections
|
|
||||||
// between peers, there is no need to use a minimum spanning tree
|
|
||||||
// algorithm. Instead we employ the simpler and cheaper breadth-first
|
|
||||||
// widening. The computation is deterministic, which ensures that when
|
|
||||||
// it is performed on the same data by different peers, they get the
|
|
||||||
// same result. This is important since otherwise we risk message loss
|
|
||||||
// or routing cycles.
|
|
||||||
//
|
|
||||||
// When the 'establishedAndSymmetric' flag is set, only connections
|
|
||||||
// that are marked as 'established' and are symmetric (i.e. where both
|
|
||||||
// sides indicate they have a connection to the other) are considered.
|
|
||||||
//
|
|
||||||
// When a non-nil stopAt peer is supplied, the widening stops when it
|
|
||||||
// reaches that peer. The boolean return indicates whether that has
|
|
||||||
// happened.
|
|
||||||
//
|
|
||||||
// NB: This function should generally be invoked while holding a read
|
|
||||||
// lock on Peers and LocalPeer.
|
|
||||||
func (peer *Peer) Routes(stopAt *Peer, establishedAndSymmetric bool) (bool, map[PeerName]PeerName) {
|
|
||||||
routes := make(unicastRoutes)
|
|
||||||
routes[peer.Name] = UnknownPeerName
|
|
||||||
nextWorklist := []*Peer{peer}
|
|
||||||
for len(nextWorklist) > 0 {
|
|
||||||
worklist := nextWorklist
|
|
||||||
sort.Sort(ListOfPeers(worklist))
|
|
||||||
nextWorklist = []*Peer{}
|
|
||||||
for _, curPeer := range worklist {
|
|
||||||
if curPeer == stopAt {
|
|
||||||
return true, routes
|
|
||||||
}
|
|
||||||
curPeer.ForEachConnectedPeer(establishedAndSymmetric, routes,
|
|
||||||
func(remotePeer *Peer) {
|
|
||||||
nextWorklist = append(nextWorklist, remotePeer)
|
|
||||||
remoteName := remotePeer.Name
|
|
||||||
// We now know how to get to remoteName: the same
|
|
||||||
// way we get to curPeer. Except, if curPeer is
|
|
||||||
// the starting peer in which case we know we can
|
|
||||||
// reach remoteName directly.
|
|
||||||
if curPeer == peer {
|
|
||||||
routes[remoteName] = remoteName
|
|
||||||
} else {
|
|
||||||
routes[remoteName] = routes[curPeer.Name]
|
|
||||||
}
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return false, routes
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peer *Peer) ForEachConnectedPeer(establishedAndSymmetric bool, exclude map[PeerName]PeerName, f func(*Peer)) {
|
|
||||||
for remoteName, conn := range peer.connections {
|
|
||||||
if establishedAndSymmetric && !conn.Established() {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
if _, found := exclude[remoteName]; found {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
remotePeer := conn.Remote()
|
|
||||||
if remoteConn, found := remotePeer.connections[peer.Name]; !establishedAndSymmetric || (found && remoteConn.Established()) {
|
|
||||||
f(remotePeer)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,46 +0,0 @@
|
|||||||
// +build peer_name_hash
|
|
||||||
|
|
||||||
// Let peer names be sha256 hashes...of anything (as long as it's
|
|
||||||
// unique).
|
|
||||||
|
|
||||||
package mesh
|
|
||||||
|
|
||||||
import (
|
|
||||||
"crypto/sha256"
|
|
||||||
"encoding/hex"
|
|
||||||
)
|
|
||||||
|
|
||||||
type PeerName string
|
|
||||||
|
|
||||||
const (
|
|
||||||
PeerNameFlavour = "hash"
|
|
||||||
NameSize = sha256.Size >> 1
|
|
||||||
UnknownPeerName = PeerName("")
|
|
||||||
)
|
|
||||||
|
|
||||||
func PeerNameFromUserInput(userInput string) (PeerName, error) {
|
|
||||||
// fixed-length identity
|
|
||||||
nameByteAry := sha256.Sum256([]byte(userInput))
|
|
||||||
return PeerNameFromBin(nameByteAry[:NameSize]), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func PeerNameFromString(nameStr string) (PeerName, error) {
|
|
||||||
if _, err := hex.DecodeString(nameStr); err != nil {
|
|
||||||
return UnknownPeerName, err
|
|
||||||
}
|
|
||||||
return PeerName(nameStr), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func PeerNameFromBin(nameByte []byte) PeerName {
|
|
||||||
return PeerName(hex.EncodeToString(nameByte))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (name PeerName) Bin() []byte {
|
|
||||||
res, err := hex.DecodeString(string(name))
|
|
||||||
checkFatal(err)
|
|
||||||
return res
|
|
||||||
}
|
|
||||||
|
|
||||||
func (name PeerName) String() string {
|
|
||||||
return string(name)
|
|
||||||
}
|
|
||||||
@@ -1,75 +0,0 @@
|
|||||||
// The !peer_name_alternative effectively makes this the default,
|
|
||||||
// i.e. to choose an alternative, run "go build -tags
|
|
||||||
// 'peer_name_alternative peer_name_hash'"
|
|
||||||
|
|
||||||
// +build peer_name_mac !peer_name_alternative
|
|
||||||
|
|
||||||
// Let peer names be MACs...
|
|
||||||
//
|
|
||||||
// MACs need to be unique across our network, or bad things will
|
|
||||||
// happen anyway. So they make pretty good candidates for peer
|
|
||||||
// names. And doing so is pretty efficient both computationally and
|
|
||||||
// network overhead wise.
|
|
||||||
//
|
|
||||||
// Note that we do not mandate *what* MAC should be used as the peer
|
|
||||||
// name. In particular it doesn't actually have to be the MAC of, say,
|
|
||||||
// the network interface the peer is sniffing on.
|
|
||||||
|
|
||||||
package mesh
|
|
||||||
|
|
||||||
import (
|
|
||||||
"net"
|
|
||||||
)
|
|
||||||
|
|
||||||
// PeerName is used as a map key. Since net.HardwareAddr isn't
|
|
||||||
// suitable for that - it's a slice, and slices can't be map keys - we
|
|
||||||
// convert that to/from uint64.
|
|
||||||
type PeerName uint64
|
|
||||||
|
|
||||||
const (
|
|
||||||
PeerNameFlavour = "mac"
|
|
||||||
NameSize = 6
|
|
||||||
UnknownPeerName = PeerName(0)
|
|
||||||
)
|
|
||||||
|
|
||||||
func PeerNameFromUserInput(userInput string) (PeerName, error) {
|
|
||||||
res, err := PeerNameFromString(userInput)
|
|
||||||
return res, err
|
|
||||||
}
|
|
||||||
|
|
||||||
func PeerNameFromString(nameStr string) (PeerName, error) {
|
|
||||||
mac, err := net.ParseMAC(nameStr)
|
|
||||||
if err != nil {
|
|
||||||
return UnknownPeerName, err
|
|
||||||
}
|
|
||||||
return PeerName(macint(mac)), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func PeerNameFromBin(nameByte []byte) PeerName {
|
|
||||||
return PeerName(macint(net.HardwareAddr(nameByte)))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (name PeerName) Bin() []byte {
|
|
||||||
return intmac(uint64(name))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (name PeerName) String() string {
|
|
||||||
return intmac(uint64(name)).String()
|
|
||||||
}
|
|
||||||
|
|
||||||
func macint(mac net.HardwareAddr) (r uint64) {
|
|
||||||
for _, b := range mac {
|
|
||||||
r <<= 8
|
|
||||||
r |= uint64(b)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func intmac(key uint64) (r net.HardwareAddr) {
|
|
||||||
r = make([]byte, 6)
|
|
||||||
for i := 5; i >= 0; i-- {
|
|
||||||
r[i] = byte(key)
|
|
||||||
key >>= 8
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
-530
@@ -1,530 +0,0 @@
|
|||||||
package mesh
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"encoding/gob"
|
|
||||||
"io"
|
|
||||||
"math/rand"
|
|
||||||
"sync"
|
|
||||||
)
|
|
||||||
|
|
||||||
var void = struct{}{}
|
|
||||||
|
|
||||||
type Peers struct {
|
|
||||||
sync.RWMutex
|
|
||||||
ourself *LocalPeer
|
|
||||||
byName map[PeerName]*Peer
|
|
||||||
byShortID map[PeerShortID]ShortIDPeers
|
|
||||||
onGC []func(*Peer)
|
|
||||||
|
|
||||||
// Called when the mapping from short ids to peers changes
|
|
||||||
onInvalidateShortIDs []func()
|
|
||||||
}
|
|
||||||
|
|
||||||
type ShortIDPeers struct {
|
|
||||||
// If we know about a single peer with the short id, this is
|
|
||||||
// that peer. If there is a collision, this is the peer with
|
|
||||||
// the lowest Name.
|
|
||||||
peer *Peer
|
|
||||||
|
|
||||||
// In case of a collision, this holds the other peers.
|
|
||||||
others []*Peer
|
|
||||||
}
|
|
||||||
|
|
||||||
type PeerNameSet map[PeerName]struct{}
|
|
||||||
|
|
||||||
type ConnectionSummary struct {
|
|
||||||
NameByte []byte
|
|
||||||
RemoteTCPAddr string
|
|
||||||
Outbound bool
|
|
||||||
Established bool
|
|
||||||
}
|
|
||||||
|
|
||||||
// Pending notifications due to changes to Peers that need to be sent
|
|
||||||
// out once the Peers is unlocked.
|
|
||||||
type PeersPendingNotifications struct {
|
|
||||||
// Peers that have been GCed
|
|
||||||
removed []*Peer
|
|
||||||
|
|
||||||
// The mapping from shorts ids to peers changed
|
|
||||||
invalidateShortIDs bool
|
|
||||||
|
|
||||||
// The local short ID needs reassigning due to a collision
|
|
||||||
reassignLocalShortID bool
|
|
||||||
|
|
||||||
// The local peer was modified
|
|
||||||
localPeerModified bool
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewPeers(ourself *LocalPeer) *Peers {
|
|
||||||
peers := &Peers{
|
|
||||||
ourself: ourself,
|
|
||||||
byName: make(map[PeerName]*Peer),
|
|
||||||
byShortID: make(map[PeerShortID]ShortIDPeers),
|
|
||||||
}
|
|
||||||
peers.FetchWithDefault(ourself.Peer)
|
|
||||||
return peers
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peers *Peers) OnGC(callback func(*Peer)) {
|
|
||||||
peers.Lock()
|
|
||||||
defer peers.Unlock()
|
|
||||||
|
|
||||||
// Although the array underlying peers.onGC might be accessed
|
|
||||||
// without holding the lock in unlockAndNotify, we don't
|
|
||||||
// support removing callbacks, so a simple append here is
|
|
||||||
// safe.
|
|
||||||
peers.onGC = append(peers.onGC, callback)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peers *Peers) OnInvalidateShortIDs(callback func()) {
|
|
||||||
peers.Lock()
|
|
||||||
defer peers.Unlock()
|
|
||||||
|
|
||||||
// Safe, as in OnGC
|
|
||||||
peers.onInvalidateShortIDs = append(peers.onInvalidateShortIDs, callback)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peers *Peers) unlockAndNotify(pending *PeersPendingNotifications) {
|
|
||||||
broadcastLocalPeer := (pending.reassignLocalShortID && peers.reassignLocalShortID(pending)) ||
|
|
||||||
pending.localPeerModified
|
|
||||||
onGC := peers.onGC
|
|
||||||
onInvalidateShortIDs := peers.onInvalidateShortIDs
|
|
||||||
peers.Unlock()
|
|
||||||
|
|
||||||
if pending.removed != nil {
|
|
||||||
for _, callback := range onGC {
|
|
||||||
for _, peer := range pending.removed {
|
|
||||||
callback(peer)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if pending.invalidateShortIDs {
|
|
||||||
for _, callback := range onInvalidateShortIDs {
|
|
||||||
callback()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if broadcastLocalPeer {
|
|
||||||
peers.ourself.broadcastPeerUpdate()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peers *Peers) addByShortID(peer *Peer, pending *PeersPendingNotifications) {
|
|
||||||
if !peer.HasShortID {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
entry, ok := peers.byShortID[peer.ShortID]
|
|
||||||
if !ok {
|
|
||||||
entry = ShortIDPeers{peer: peer}
|
|
||||||
} else if entry.peer == nil {
|
|
||||||
// This short ID is free, but was used in the past.
|
|
||||||
// Because we are reusing it, it's an invalidation
|
|
||||||
// event.
|
|
||||||
entry.peer = peer
|
|
||||||
pending.invalidateShortIDs = true
|
|
||||||
} else if peer.Name < entry.peer.Name {
|
|
||||||
// Short ID collision, this peer becomes the principal
|
|
||||||
// peer for the short ID, bumping the previous one
|
|
||||||
// into others.
|
|
||||||
|
|
||||||
if entry.peer == peers.ourself.Peer {
|
|
||||||
// The bumped peer is peers.ourself, so we
|
|
||||||
// need to look for a new short id
|
|
||||||
pending.reassignLocalShortID = true
|
|
||||||
}
|
|
||||||
|
|
||||||
entry.others = append(entry.others, entry.peer)
|
|
||||||
entry.peer = peer
|
|
||||||
pending.invalidateShortIDs = true
|
|
||||||
} else {
|
|
||||||
// Short ID collision, this peer is secondary
|
|
||||||
entry.others = append(entry.others, peer)
|
|
||||||
}
|
|
||||||
|
|
||||||
peers.byShortID[peer.ShortID] = entry
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peers *Peers) deleteByShortID(peer *Peer, pending *PeersPendingNotifications) {
|
|
||||||
if !peer.HasShortID {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
entry := peers.byShortID[peer.ShortID]
|
|
||||||
var otherIndex int
|
|
||||||
|
|
||||||
if peer != entry.peer {
|
|
||||||
// peer is secondary, find its index in others
|
|
||||||
otherIndex = -1
|
|
||||||
|
|
||||||
for i, other := range entry.others {
|
|
||||||
if peer == other {
|
|
||||||
otherIndex = i
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if otherIndex < 0 {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
} else if len(entry.others) != 0 {
|
|
||||||
// need to find the peer with the lowest name to
|
|
||||||
// become the new principal one
|
|
||||||
otherIndex = 0
|
|
||||||
minName := entry.others[0].Name
|
|
||||||
|
|
||||||
for i := 1; i < len(entry.others); i++ {
|
|
||||||
otherName := entry.others[i].Name
|
|
||||||
if otherName < minName {
|
|
||||||
minName = otherName
|
|
||||||
otherIndex = i
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
entry.peer = entry.others[otherIndex]
|
|
||||||
pending.invalidateShortIDs = true
|
|
||||||
} else {
|
|
||||||
// This is the last peer with the short id. We clear
|
|
||||||
// the entry, don't delete it, in order to detect when
|
|
||||||
// it gets re-used.
|
|
||||||
peers.byShortID[peer.ShortID] = ShortIDPeers{}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
entry.others[otherIndex] = entry.others[len(entry.others)-1]
|
|
||||||
entry.others = entry.others[:len(entry.others)-1]
|
|
||||||
peers.byShortID[peer.ShortID] = entry
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peers *Peers) reassignLocalShortID(pending *PeersPendingNotifications) bool {
|
|
||||||
newShortID, ok := peers.chooseShortID()
|
|
||||||
if ok {
|
|
||||||
peers.setLocalShortID(newShortID, pending)
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
// Otherwise we'll try again later on in garbageColleect
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peers *Peers) setLocalShortID(newShortID PeerShortID, pending *PeersPendingNotifications) {
|
|
||||||
peers.deleteByShortID(peers.ourself.Peer, pending)
|
|
||||||
peers.ourself.setShortID(newShortID)
|
|
||||||
peers.addByShortID(peers.ourself.Peer, pending)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Choose an available short id at random
|
|
||||||
func (peers *Peers) chooseShortID() (PeerShortID, bool) {
|
|
||||||
rng := rand.New(rand.NewSource(int64(randUint64())))
|
|
||||||
|
|
||||||
// First, just try picking some short ids at random, and
|
|
||||||
// seeing if they are available:
|
|
||||||
for i := 0; i < 10; i++ {
|
|
||||||
shortID := PeerShortID(rng.Intn(1 << PeerShortIDBits))
|
|
||||||
if peers.byShortID[shortID].peer == nil {
|
|
||||||
return shortID, true
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Looks like most short ids are used. So count the number of
|
|
||||||
// unused ones, and pick one at random.
|
|
||||||
available := int(1 << PeerShortIDBits)
|
|
||||||
for _, entry := range peers.byShortID {
|
|
||||||
if entry.peer != nil {
|
|
||||||
available--
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if available == 0 {
|
|
||||||
// All short ids are used.
|
|
||||||
return 0, false
|
|
||||||
}
|
|
||||||
|
|
||||||
n := rng.Intn(available)
|
|
||||||
var i PeerShortID
|
|
||||||
for {
|
|
||||||
if peers.byShortID[i].peer == nil {
|
|
||||||
if n == 0 {
|
|
||||||
return PeerShortID(i), true
|
|
||||||
}
|
|
||||||
|
|
||||||
n--
|
|
||||||
}
|
|
||||||
|
|
||||||
i++
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peers *Peers) FetchWithDefault(peer *Peer) *Peer {
|
|
||||||
peers.Lock()
|
|
||||||
var pending PeersPendingNotifications
|
|
||||||
defer peers.unlockAndNotify(&pending)
|
|
||||||
|
|
||||||
if existingPeer, found := peers.byName[peer.Name]; found {
|
|
||||||
existingPeer.localRefCount++
|
|
||||||
return existingPeer
|
|
||||||
}
|
|
||||||
|
|
||||||
peers.byName[peer.Name] = peer
|
|
||||||
peers.addByShortID(peer, &pending)
|
|
||||||
peer.localRefCount++
|
|
||||||
return peer
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peers *Peers) Fetch(name PeerName) *Peer {
|
|
||||||
peers.RLock()
|
|
||||||
defer peers.RUnlock()
|
|
||||||
return peers.byName[name]
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peers *Peers) FetchAndAddRef(name PeerName) *Peer {
|
|
||||||
peers.Lock()
|
|
||||||
defer peers.Unlock()
|
|
||||||
peer := peers.byName[name]
|
|
||||||
if peer != nil {
|
|
||||||
peer.localRefCount++
|
|
||||||
}
|
|
||||||
return peer
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peers *Peers) FetchByShortID(shortID PeerShortID) *Peer {
|
|
||||||
peers.RLock()
|
|
||||||
defer peers.RUnlock()
|
|
||||||
return peers.byShortID[shortID].peer
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peers *Peers) Dereference(peer *Peer) {
|
|
||||||
peers.Lock()
|
|
||||||
defer peers.Unlock()
|
|
||||||
peer.localRefCount--
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peers *Peers) ForEach(fun func(*Peer)) {
|
|
||||||
peers.RLock()
|
|
||||||
defer peers.RUnlock()
|
|
||||||
for _, peer := range peers.byName {
|
|
||||||
fun(peer)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Merge an incoming update with our own topology.
|
|
||||||
//
|
|
||||||
// We add peers hitherto unknown to us, and update peers for which the
|
|
||||||
// update contains a more recent version than known to us. The return
|
|
||||||
// value is a) a representation of the received update, and b) an
|
|
||||||
// "improved" update containing just these new/updated elements.
|
|
||||||
func (peers *Peers) ApplyUpdate(update []byte) (PeerNameSet, PeerNameSet, error) {
|
|
||||||
peers.Lock()
|
|
||||||
var pending PeersPendingNotifications
|
|
||||||
defer peers.unlockAndNotify(&pending)
|
|
||||||
|
|
||||||
newPeers, decodedUpdate, decodedConns, err := peers.decodeUpdate(update)
|
|
||||||
if err != nil {
|
|
||||||
return nil, nil, err
|
|
||||||
}
|
|
||||||
|
|
||||||
// Add new peers
|
|
||||||
for name, newPeer := range newPeers {
|
|
||||||
peers.byName[name] = newPeer
|
|
||||||
peers.addByShortID(newPeer, &pending)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Now apply the updates
|
|
||||||
newUpdate := peers.applyUpdate(decodedUpdate, decodedConns, &pending)
|
|
||||||
peers.garbageCollect(&pending)
|
|
||||||
for _, peerRemoved := range pending.removed {
|
|
||||||
delete(newUpdate, peerRemoved.Name)
|
|
||||||
}
|
|
||||||
|
|
||||||
updateNames := make(PeerNameSet)
|
|
||||||
for _, peer := range decodedUpdate {
|
|
||||||
updateNames[peer.Name] = void
|
|
||||||
}
|
|
||||||
|
|
||||||
return updateNames, newUpdate, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peers *Peers) Names() PeerNameSet {
|
|
||||||
peers.RLock()
|
|
||||||
defer peers.RUnlock()
|
|
||||||
|
|
||||||
names := make(PeerNameSet)
|
|
||||||
for name := range peers.byName {
|
|
||||||
names[name] = void
|
|
||||||
}
|
|
||||||
return names
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peers *Peers) EncodePeers(names PeerNameSet) []byte {
|
|
||||||
buf := new(bytes.Buffer)
|
|
||||||
enc := gob.NewEncoder(buf)
|
|
||||||
peers.RLock()
|
|
||||||
defer peers.RUnlock()
|
|
||||||
for name := range names {
|
|
||||||
if peer, found := peers.byName[name]; found {
|
|
||||||
if peer == peers.ourself.Peer {
|
|
||||||
peers.ourself.Encode(enc)
|
|
||||||
} else {
|
|
||||||
peer.Encode(enc)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return buf.Bytes()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peers *Peers) GarbageCollect() {
|
|
||||||
peers.Lock()
|
|
||||||
var pending PeersPendingNotifications
|
|
||||||
defer peers.unlockAndNotify(&pending)
|
|
||||||
|
|
||||||
peers.garbageCollect(&pending)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peers *Peers) garbageCollect(pending *PeersPendingNotifications) {
|
|
||||||
peers.ourself.RLock()
|
|
||||||
_, reached := peers.ourself.Routes(nil, false)
|
|
||||||
peers.ourself.RUnlock()
|
|
||||||
|
|
||||||
for name, peer := range peers.byName {
|
|
||||||
if _, found := reached[peer.Name]; !found && peer.localRefCount == 0 {
|
|
||||||
delete(peers.byName, name)
|
|
||||||
peers.deleteByShortID(peer, pending)
|
|
||||||
pending.removed = append(pending.removed, peer)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if peers.byShortID[peers.ourself.ShortID].peer != peers.ourself.Peer {
|
|
||||||
// The local peer doesn't own its short id. Garbage
|
|
||||||
// collection might have freed some up, so try to
|
|
||||||
// reassign.
|
|
||||||
pending.reassignLocalShortID = true
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peers *Peers) decodeUpdate(update []byte) (newPeers map[PeerName]*Peer, decodedUpdate []*Peer, decodedConns [][]ConnectionSummary, err error) {
|
|
||||||
newPeers = make(map[PeerName]*Peer)
|
|
||||||
decodedUpdate = []*Peer{}
|
|
||||||
decodedConns = [][]ConnectionSummary{}
|
|
||||||
|
|
||||||
decoder := gob.NewDecoder(bytes.NewReader(update))
|
|
||||||
|
|
||||||
for {
|
|
||||||
peerSummary, connSummaries, decErr := decodePeer(decoder)
|
|
||||||
if decErr == io.EOF {
|
|
||||||
break
|
|
||||||
} else if decErr != nil {
|
|
||||||
err = decErr
|
|
||||||
return
|
|
||||||
}
|
|
||||||
newPeer := NewPeerFromSummary(peerSummary)
|
|
||||||
decodedUpdate = append(decodedUpdate, newPeer)
|
|
||||||
decodedConns = append(decodedConns, connSummaries)
|
|
||||||
if _, found := peers.byName[newPeer.Name]; !found {
|
|
||||||
newPeers[newPeer.Name] = newPeer
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, connSummaries := range decodedConns {
|
|
||||||
for _, connSummary := range connSummaries {
|
|
||||||
remoteName := PeerNameFromBin(connSummary.NameByte)
|
|
||||||
if _, found := newPeers[remoteName]; found {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
if _, found := peers.byName[remoteName]; found {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
// Update refers to a peer which we have no knowledge of.
|
|
||||||
newPeers[remoteName] = NewPeerPlaceholder(remoteName)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peers *Peers) applyUpdate(decodedUpdate []*Peer, decodedConns [][]ConnectionSummary, pending *PeersPendingNotifications) PeerNameSet {
|
|
||||||
newUpdate := make(PeerNameSet)
|
|
||||||
for idx, newPeer := range decodedUpdate {
|
|
||||||
connSummaries := decodedConns[idx]
|
|
||||||
name := newPeer.Name
|
|
||||||
// guaranteed to find peer in the peers.byName
|
|
||||||
switch peer := peers.byName[name]; peer {
|
|
||||||
case peers.ourself.Peer:
|
|
||||||
if newPeer.UID != peer.UID {
|
|
||||||
// The update contains information about an old
|
|
||||||
// incarnation of ourselves. We increase our version
|
|
||||||
// number beyond that which we received, so our
|
|
||||||
// information supersedes the old one when it is
|
|
||||||
// received by other peers.
|
|
||||||
pending.localPeerModified = peers.ourself.setVersionBeyond(newPeer.Version)
|
|
||||||
}
|
|
||||||
case newPeer:
|
|
||||||
peer.connections = makeConnsMap(peer, connSummaries, peers.byName)
|
|
||||||
newUpdate[name] = void
|
|
||||||
default: // existing peer
|
|
||||||
if newPeer.Version < peer.Version ||
|
|
||||||
(newPeer.Version == peer.Version &&
|
|
||||||
(newPeer.UID < peer.UID ||
|
|
||||||
(newPeer.UID == peer.UID &&
|
|
||||||
(!newPeer.HasShortID || peer.HasShortID)))) {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
peer.Version = newPeer.Version
|
|
||||||
peer.UID = newPeer.UID
|
|
||||||
peer.NickName = newPeer.NickName
|
|
||||||
peer.connections = makeConnsMap(peer, connSummaries, peers.byName)
|
|
||||||
|
|
||||||
if newPeer.ShortID != peer.ShortID || newPeer.HasShortID != peer.HasShortID {
|
|
||||||
peers.deleteByShortID(peer, pending)
|
|
||||||
peer.ShortID = newPeer.ShortID
|
|
||||||
peer.HasShortID = newPeer.HasShortID
|
|
||||||
peers.addByShortID(peer, pending)
|
|
||||||
}
|
|
||||||
newUpdate[name] = void
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return newUpdate
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peer *Peer) Encode(enc *gob.Encoder) {
|
|
||||||
checkFatal(enc.Encode(peer.PeerSummary))
|
|
||||||
|
|
||||||
connSummaries := []ConnectionSummary{}
|
|
||||||
for _, conn := range peer.connections {
|
|
||||||
connSummaries = append(connSummaries, ConnectionSummary{
|
|
||||||
conn.Remote().NameByte,
|
|
||||||
conn.RemoteTCPAddr(),
|
|
||||||
conn.Outbound(),
|
|
||||||
conn.Established(),
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
checkFatal(enc.Encode(connSummaries))
|
|
||||||
}
|
|
||||||
|
|
||||||
func (peer *LocalPeer) Encode(enc *gob.Encoder) {
|
|
||||||
peer.RLock()
|
|
||||||
defer peer.RUnlock()
|
|
||||||
peer.Peer.Encode(enc)
|
|
||||||
}
|
|
||||||
|
|
||||||
func decodePeer(dec *gob.Decoder) (peerSummary PeerSummary, connSummaries []ConnectionSummary, err error) {
|
|
||||||
if err = dec.Decode(&peerSummary); err != nil {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
if err = dec.Decode(&connSummaries); err != nil {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func makeConnsMap(peer *Peer, connSummaries []ConnectionSummary, byName map[PeerName]*Peer) map[PeerName]Connection {
|
|
||||||
conns := make(map[PeerName]Connection)
|
|
||||||
for _, connSummary := range connSummaries {
|
|
||||||
name := PeerNameFromBin(connSummary.NameByte)
|
|
||||||
remotePeer := byName[name]
|
|
||||||
conn := NewRemoteConnection(peer, remotePeer, connSummary.RemoteTCPAddr, connSummary.Outbound, connSummary.Established)
|
|
||||||
conns[name] = conn
|
|
||||||
}
|
|
||||||
return conns
|
|
||||||
}
|
|
||||||
@@ -1,376 +0,0 @@
|
|||||||
package mesh
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"math/rand"
|
|
||||||
"testing"
|
|
||||||
"time"
|
|
||||||
|
|
||||||
"github.com/stretchr/testify/require"
|
|
||||||
)
|
|
||||||
|
|
||||||
// TODO we should also test:
|
|
||||||
//
|
|
||||||
// - applying an incremental update, including the case where that
|
|
||||||
// leads to an UnknownPeerError
|
|
||||||
//
|
|
||||||
// - the "improved update" calculation
|
|
||||||
//
|
|
||||||
// - non-gc of peers that are only referenced locally
|
|
||||||
|
|
||||||
func newNode(name PeerName) (*Peer, *Peers) {
|
|
||||||
peer := NewLocalPeer(name, "", nil)
|
|
||||||
peers := NewPeers(peer)
|
|
||||||
return peer.Peer, peers
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check that ApplyUpdate copies the whole topology from peers
|
|
||||||
func checkApplyUpdate(t *testing.T, peers *Peers) {
|
|
||||||
dummyName, _ := PeerNameFromString("99:00:00:01:00:00")
|
|
||||||
// We need a new node outside of the network, with a connection
|
|
||||||
// into it.
|
|
||||||
_, testBedPeers := newNode(dummyName)
|
|
||||||
testBedPeers.AddTestConnection(peers.ourself.Peer)
|
|
||||||
testBedPeers.ApplyUpdate(peers.EncodePeers(peers.Names()))
|
|
||||||
|
|
||||||
checkTopologyPeers(t, true, testBedPeers.allPeersExcept(dummyName), peers.allPeers()...)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestPeersEncoding(t *testing.T) {
|
|
||||||
const numNodes = 20
|
|
||||||
const numIters = 1000
|
|
||||||
var peer [numNodes]*Peer
|
|
||||||
var ps [numNodes]*Peers
|
|
||||||
for i := 0; i < numNodes; i++ {
|
|
||||||
name, _ := PeerNameFromString(fmt.Sprintf("%02d:00:00:01:00:00", i))
|
|
||||||
peer[i], ps[i] = newNode(name)
|
|
||||||
}
|
|
||||||
|
|
||||||
var conns []struct{ from, to int }
|
|
||||||
for i := 0; i < numIters; i++ {
|
|
||||||
oper := rand.Intn(2)
|
|
||||||
switch oper {
|
|
||||||
case 0:
|
|
||||||
from, to := rand.Intn(numNodes), rand.Intn(numNodes)
|
|
||||||
if from != to {
|
|
||||||
if _, found := peer[from].connections[peer[to].Name]; !found {
|
|
||||||
ps[from].AddTestConnection(peer[to])
|
|
||||||
conns = append(conns, struct{ from, to int }{from, to})
|
|
||||||
checkApplyUpdate(t, ps[from])
|
|
||||||
}
|
|
||||||
}
|
|
||||||
case 1:
|
|
||||||
if len(conns) > 0 {
|
|
||||||
n := rand.Intn(len(conns))
|
|
||||||
c := conns[n]
|
|
||||||
ps[c.from].DeleteTestConnection(peer[c.to])
|
|
||||||
ps[c.from].GarbageCollect()
|
|
||||||
checkApplyUpdate(t, ps[c.from])
|
|
||||||
conns = append(conns[:n], conns[n+1:]...)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func garbageCollect(peers *Peers) []*Peer {
|
|
||||||
var removed []*Peer
|
|
||||||
peers.OnGC(func(peer *Peer) { removed = append(removed, peer) })
|
|
||||||
peers.GarbageCollect()
|
|
||||||
return removed
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestPeersGarbageCollection(t *testing.T) {
|
|
||||||
const (
|
|
||||||
peer1NameString = "01:00:00:01:00:00"
|
|
||||||
peer2NameString = "02:00:00:02:00:00"
|
|
||||||
peer3NameString = "03:00:00:03:00:00"
|
|
||||||
)
|
|
||||||
var (
|
|
||||||
peer1Name, _ = PeerNameFromString(peer1NameString)
|
|
||||||
peer2Name, _ = PeerNameFromString(peer2NameString)
|
|
||||||
peer3Name, _ = PeerNameFromString(peer3NameString)
|
|
||||||
)
|
|
||||||
|
|
||||||
// Create some peers with some connections to each other
|
|
||||||
p1, ps1 := newNode(peer1Name)
|
|
||||||
p2, ps2 := newNode(peer2Name)
|
|
||||||
p3, ps3 := newNode(peer3Name)
|
|
||||||
ps1.AddTestConnection(p2)
|
|
||||||
ps2.AddTestRemoteConnection(p1, p2)
|
|
||||||
ps2.AddTestConnection(p1)
|
|
||||||
ps2.AddTestConnection(p3)
|
|
||||||
ps3.AddTestConnection(p1)
|
|
||||||
ps1.AddTestConnection(p3)
|
|
||||||
ps2.AddTestRemoteConnection(p1, p3)
|
|
||||||
ps2.AddTestRemoteConnection(p3, p1)
|
|
||||||
|
|
||||||
// Every peer is referenced, so nothing should be dropped
|
|
||||||
require.Empty(t, garbageCollect(ps1), "peers removed")
|
|
||||||
require.Empty(t, garbageCollect(ps2), "peers removed")
|
|
||||||
require.Empty(t, garbageCollect(ps3), "peers removed")
|
|
||||||
|
|
||||||
// Drop the connection from 2 to 3, and 3 isn't garbage-collected
|
|
||||||
// because 1 has a connection to 3
|
|
||||||
ps2.DeleteTestConnection(p3)
|
|
||||||
require.Empty(t, garbageCollect(ps2), "peers removed")
|
|
||||||
|
|
||||||
// Drop the connection from 1 to 3, and 3 will get removed by
|
|
||||||
// garbage-collection
|
|
||||||
ps1.DeleteTestConnection(p3)
|
|
||||||
checkPeerArray(t, garbageCollect(ps1), p3)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestShortIDCollisions(t *testing.T) {
|
|
||||||
rng := rand.New(rand.NewSource(time.Now().UnixNano()))
|
|
||||||
_, peers := newNode(PeerName(1 << PeerShortIDBits))
|
|
||||||
|
|
||||||
// Make enough peers that short id collisions are
|
|
||||||
// overwhelmingly likely
|
|
||||||
ps := make([]*Peer, 1<<PeerShortIDBits)
|
|
||||||
for i := 0; i < 1<<PeerShortIDBits; i++ {
|
|
||||||
ps[i] = NewPeer(PeerName(i), "", PeerUID(i), 0,
|
|
||||||
PeerShortID(rng.Intn(1<<PeerShortIDBits)))
|
|
||||||
}
|
|
||||||
|
|
||||||
shuffle := func() {
|
|
||||||
for i := range ps {
|
|
||||||
j := rng.Intn(i + 1)
|
|
||||||
ps[i], ps[j] = ps[j], ps[i]
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Fill peers
|
|
||||||
shuffle()
|
|
||||||
var pending PeersPendingNotifications
|
|
||||||
for _, p := range ps {
|
|
||||||
peers.addByShortID(p, &pending)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check invariants
|
|
||||||
counts := make([]int, 1<<PeerShortIDBits)
|
|
||||||
saw := func(p *Peer) {
|
|
||||||
if p != peers.ourself.Peer {
|
|
||||||
counts[p.UID]++
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
for shortID, entry := range peers.byShortID {
|
|
||||||
if entry.peer == nil {
|
|
||||||
// no principal peer for this short id, so
|
|
||||||
// others must be empty
|
|
||||||
require.Empty(t, entry.others)
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
|
|
||||||
require.Equal(t, shortID, entry.peer.ShortID)
|
|
||||||
saw(entry.peer)
|
|
||||||
|
|
||||||
for _, p := range entry.others {
|
|
||||||
saw(p)
|
|
||||||
require.Equal(t, shortID, p.ShortID)
|
|
||||||
|
|
||||||
// the principal peer should have the lowest name
|
|
||||||
require.True(t, p.Name > entry.peer.Name)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check that every peer was seen
|
|
||||||
for _, n := range counts {
|
|
||||||
require.Equal(t, 1, n)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Delete all the peers
|
|
||||||
shuffle()
|
|
||||||
for _, p := range ps {
|
|
||||||
peers.deleteByShortID(p, &pending)
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, entry := range peers.byShortID {
|
|
||||||
if entry.peer != peers.ourself.Peer {
|
|
||||||
require.Nil(t, entry.peer)
|
|
||||||
}
|
|
||||||
|
|
||||||
require.Empty(t, entry.others)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Test the easy case of short id reassignment, when few short ids are taken
|
|
||||||
func TestShortIDReassignmentEasy(t *testing.T) {
|
|
||||||
rng := rand.New(rand.NewSource(time.Now().UnixNano()))
|
|
||||||
_, peers := newNode(PeerName(0))
|
|
||||||
|
|
||||||
for i := 1; i <= 10; i++ {
|
|
||||||
peers.FetchWithDefault(NewPeer(PeerName(i), "", PeerUID(i), 0,
|
|
||||||
PeerShortID(rng.Intn(1<<PeerShortIDBits))))
|
|
||||||
}
|
|
||||||
|
|
||||||
checkShortIDReassignment(t, peers)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Test the hard case of short id reassignment, when most short ids are taken
|
|
||||||
func TestShortIDReassignmentHard(t *testing.T) {
|
|
||||||
rng := rand.New(rand.NewSource(time.Now().UnixNano()))
|
|
||||||
_, peers := newNode(PeerName(1 << PeerShortIDBits))
|
|
||||||
|
|
||||||
// Take all short ids
|
|
||||||
ps := make([]*Peer, 1<<PeerShortIDBits)
|
|
||||||
var pending PeersPendingNotifications
|
|
||||||
for i := 0; i < 1<<PeerShortIDBits; i++ {
|
|
||||||
ps[i] = NewPeer(PeerName(i), "", PeerUID(i), 0,
|
|
||||||
PeerShortID(i))
|
|
||||||
peers.addByShortID(ps[i], &pending)
|
|
||||||
}
|
|
||||||
|
|
||||||
// As all short ids are taken, an attempted reassigment won't
|
|
||||||
// do anything
|
|
||||||
oldShortID := peers.ourself.ShortID
|
|
||||||
require.False(t, peers.reassignLocalShortID(&pending))
|
|
||||||
require.Equal(t, oldShortID, peers.ourself.ShortID)
|
|
||||||
|
|
||||||
// Free up a few ids
|
|
||||||
for i := 0; i < 10; i++ {
|
|
||||||
x := rng.Intn(len(ps))
|
|
||||||
if ps[x] != nil {
|
|
||||||
peers.deleteByShortID(ps[x], &pending)
|
|
||||||
ps[x] = nil
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
checkShortIDReassignment(t, peers)
|
|
||||||
}
|
|
||||||
|
|
||||||
func checkShortIDReassignment(t *testing.T, peers *Peers) {
|
|
||||||
oldShortID := peers.ourself.ShortID
|
|
||||||
peers.reassignLocalShortID(&PeersPendingNotifications{})
|
|
||||||
require.NotEqual(t, oldShortID, peers.ourself.ShortID)
|
|
||||||
require.Equal(t, peers.ourself.Peer, peers.byShortID[peers.ourself.ShortID].peer)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestShortIDInvalidation(t *testing.T) {
|
|
||||||
_, peers := newNode(PeerName(1 << PeerShortIDBits))
|
|
||||||
|
|
||||||
// need to use a short id that is not the local peer's
|
|
||||||
shortID := peers.ourself.ShortID + 1
|
|
||||||
|
|
||||||
var pending PeersPendingNotifications
|
|
||||||
|
|
||||||
requireInvalidateShortIDs := func(expect bool) {
|
|
||||||
require.Equal(t, expect, pending.invalidateShortIDs)
|
|
||||||
pending.invalidateShortIDs = false
|
|
||||||
}
|
|
||||||
|
|
||||||
// The use of a fresh short id does not cause invalidation
|
|
||||||
a := NewPeer(PeerName(1), "", PeerUID(1), 0, shortID)
|
|
||||||
peers.addByShortID(a, &pending)
|
|
||||||
requireInvalidateShortIDs(false)
|
|
||||||
|
|
||||||
// An addition which does not change the mapping
|
|
||||||
b := NewPeer(PeerName(2), "", PeerUID(2), 0, shortID)
|
|
||||||
peers.addByShortID(b, &pending)
|
|
||||||
requireInvalidateShortIDs(false)
|
|
||||||
|
|
||||||
// An addition which does change the mapping
|
|
||||||
c := NewPeer(PeerName(0), "", PeerUID(0), 0, shortID)
|
|
||||||
peers.addByShortID(c, &pending)
|
|
||||||
requireInvalidateShortIDs(true)
|
|
||||||
|
|
||||||
// A deletion which does not change the mapping
|
|
||||||
peers.deleteByShortID(b, &pending)
|
|
||||||
requireInvalidateShortIDs(false)
|
|
||||||
|
|
||||||
// A deletion which does change the mapping
|
|
||||||
peers.deleteByShortID(c, &pending)
|
|
||||||
requireInvalidateShortIDs(true)
|
|
||||||
|
|
||||||
// Deleting the last peer with a short id does not cause invalidation
|
|
||||||
peers.deleteByShortID(a, &pending)
|
|
||||||
requireInvalidateShortIDs(false)
|
|
||||||
|
|
||||||
// .. but subsequent reuse of that short id does cause invalidation
|
|
||||||
peers.addByShortID(a, &pending)
|
|
||||||
requireInvalidateShortIDs(true)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestShortIDPropagation(t *testing.T) {
|
|
||||||
_, peers1 := newNode(PeerName(1))
|
|
||||||
_, peers2 := newNode(PeerName(2))
|
|
||||||
|
|
||||||
peers1.AddTestConnection(peers2.ourself.Peer)
|
|
||||||
peers1.ApplyUpdate(peers2.EncodePeers(peers2.Names()))
|
|
||||||
peers12 := peers1.Fetch(PeerName(2))
|
|
||||||
old := peers12.PeerSummary
|
|
||||||
|
|
||||||
require.True(t,
|
|
||||||
peers2.reassignLocalShortID(&PeersPendingNotifications{}))
|
|
||||||
peers1.ApplyUpdate(peers2.EncodePeers(peers2.Names()))
|
|
||||||
require.NotEqual(t, old.Version, peers12.Version)
|
|
||||||
require.NotEqual(t, old.ShortID, peers12.ShortID)
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestShortIDCollision(t *testing.T) {
|
|
||||||
// Create 3 peers
|
|
||||||
_, peers1 := newNode(PeerName(1))
|
|
||||||
_, peers2 := newNode(PeerName(2))
|
|
||||||
_, peers3 := newNode(PeerName(3))
|
|
||||||
|
|
||||||
var pending PeersPendingNotifications
|
|
||||||
peers1.setLocalShortID(1, &pending)
|
|
||||||
peers2.setLocalShortID(2, &pending)
|
|
||||||
peers3.setLocalShortID(3, &pending)
|
|
||||||
|
|
||||||
peers2.AddTestConnection(peers1.ourself.Peer)
|
|
||||||
peers3.AddTestConnection(peers2.ourself.Peer)
|
|
||||||
|
|
||||||
// Propogate from 1 to 2 to 3
|
|
||||||
peers2.ApplyUpdate(peers1.EncodePeers(peers1.Names()))
|
|
||||||
peers3.ApplyUpdate(peers2.EncodePeers(peers2.Names()))
|
|
||||||
|
|
||||||
// Force the short id of peer 1 to collide with peer 2. Peer
|
|
||||||
// 1 has the lowest name, so it gets to keep the short id
|
|
||||||
peers1.setLocalShortID(2, &pending)
|
|
||||||
|
|
||||||
oldShortID := peers2.ourself.ShortID
|
|
||||||
_, updated, _ := peers2.ApplyUpdate(peers1.EncodePeers(peers1.Names()))
|
|
||||||
|
|
||||||
// peer 2 should have noticed the collision and resolved it
|
|
||||||
require.NotEqual(t, oldShortID, peers2.ourself.ShortID)
|
|
||||||
|
|
||||||
// The Peers do not have a Router, so broadcastPeerUpdate does
|
|
||||||
// nothing in the context of this test. So we fake what it
|
|
||||||
// would do.
|
|
||||||
updated[PeerName(2)] = void
|
|
||||||
|
|
||||||
// the update from peer 2 should include its short id change
|
|
||||||
peers3.ApplyUpdate(peers2.EncodePeers(updated))
|
|
||||||
require.Equal(t, peers2.ourself.ShortID,
|
|
||||||
peers3.Fetch(PeerName(2)).ShortID)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Test the case where all short ids are taken, but then some peers go
|
|
||||||
// away, so the local peer reassigns
|
|
||||||
func TestDeferredShortIDReassignment(t *testing.T) {
|
|
||||||
rng := rand.New(rand.NewSource(time.Now().UnixNano()))
|
|
||||||
_, us := newNode(PeerName(1 << PeerShortIDBits))
|
|
||||||
|
|
||||||
// Connect us to other peers occupying all short ids
|
|
||||||
others := make([]*Peers, 1<<PeerShortIDBits)
|
|
||||||
var pending PeersPendingNotifications
|
|
||||||
for i := range others {
|
|
||||||
_, others[i] = newNode(PeerName(i))
|
|
||||||
others[i].setLocalShortID(PeerShortID(i), &pending)
|
|
||||||
us.AddTestConnection(others[i].ourself.Peer)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check that, as expected, the local peer does not own its
|
|
||||||
// short id
|
|
||||||
require.NotEqual(t, us.ourself.Peer,
|
|
||||||
us.byShortID[us.ourself.ShortID].peer)
|
|
||||||
|
|
||||||
// Disconnect one peer, and we should now be able to claim its
|
|
||||||
// short id
|
|
||||||
other := others[rng.Intn(1<<PeerShortIDBits)]
|
|
||||||
us.DeleteTestConnection(other.ourself.Peer)
|
|
||||||
us.GarbageCollect()
|
|
||||||
|
|
||||||
require.Equal(t, us.ourself.Peer, us.byShortID[us.ourself.ShortID].peer)
|
|
||||||
}
|
|
||||||
@@ -1,348 +0,0 @@
|
|||||||
package mesh
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"encoding/gob"
|
|
||||||
"encoding/hex"
|
|
||||||
"fmt"
|
|
||||||
"io"
|
|
||||||
"time"
|
|
||||||
)
|
|
||||||
|
|
||||||
const (
|
|
||||||
Protocol = "weave"
|
|
||||||
ProtocolMinVersion = 1
|
|
||||||
ProtocolMaxVersion = 2
|
|
||||||
)
|
|
||||||
|
|
||||||
var (
|
|
||||||
ProtocolBytes = []byte(Protocol)
|
|
||||||
|
|
||||||
HeaderTimeout = 10 * time.Second
|
|
||||||
|
|
||||||
ProtocolV1Features = []string{
|
|
||||||
"ConnID",
|
|
||||||
"Name",
|
|
||||||
"NickName",
|
|
||||||
"PeerNameFlavour",
|
|
||||||
"UID",
|
|
||||||
}
|
|
||||||
|
|
||||||
ErrExpectedCrypto = fmt.Errorf("Password specified, but peer requested an unencrypted connection")
|
|
||||||
ErrExpectedNoCrypto = fmt.Errorf("No password specificed, but peer requested an encrypted connection")
|
|
||||||
)
|
|
||||||
|
|
||||||
// We don't need the full net.TCPConn to do the protocol intro. This
|
|
||||||
// interface contains just the parts we do need, to support testing
|
|
||||||
type ProtocolIntroConn interface {
|
|
||||||
// io.Reader
|
|
||||||
Read(b []byte) (n int, err error)
|
|
||||||
|
|
||||||
// io.Writer
|
|
||||||
Write(b []byte) (n int, err error)
|
|
||||||
|
|
||||||
// net.Conn's deadline methods
|
|
||||||
SetDeadline(t time.Time) error
|
|
||||||
SetReadDeadline(t time.Time) error
|
|
||||||
SetWriteDeadline(t time.Time) error
|
|
||||||
}
|
|
||||||
|
|
||||||
type ProtocolIntroParams struct {
|
|
||||||
MinVersion byte
|
|
||||||
MaxVersion byte
|
|
||||||
Features map[string]string
|
|
||||||
Conn ProtocolIntroConn
|
|
||||||
Password []byte
|
|
||||||
Outbound bool
|
|
||||||
}
|
|
||||||
|
|
||||||
type ProtocolIntroResults struct {
|
|
||||||
Features map[string]string
|
|
||||||
Receiver TCPReceiver
|
|
||||||
Sender TCPSender
|
|
||||||
SessionKey *[32]byte
|
|
||||||
Version byte
|
|
||||||
}
|
|
||||||
|
|
||||||
func (params ProtocolIntroParams) DoIntro() (res ProtocolIntroResults, err error) {
|
|
||||||
if err = params.Conn.SetDeadline(time.Now().Add(HeaderTimeout)); err != nil {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
if res.Version, err = params.exchangeProtocolHeader(); err != nil {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
var pubKey, privKey *[32]byte
|
|
||||||
if params.Password != nil {
|
|
||||||
if pubKey, privKey, err = GenerateKeyPair(); err != nil {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
if err = params.Conn.SetWriteDeadline(time.Time{}); err != nil {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
if err = params.Conn.SetReadDeadline(time.Now().Add(TCPHeartbeat * 2)); err != nil {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
switch res.Version {
|
|
||||||
case 1:
|
|
||||||
err = res.doIntroV1(params, pubKey, privKey)
|
|
||||||
case 2:
|
|
||||||
err = res.doIntroV2(params, pubKey, privKey)
|
|
||||||
default:
|
|
||||||
panic("unhandled protocol version")
|
|
||||||
}
|
|
||||||
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func (params ProtocolIntroParams) exchangeProtocolHeader() (byte, error) {
|
|
||||||
// Write in a separate goroutine to avoid the possibility of
|
|
||||||
// deadlock. The result channel is of size 1 so that the
|
|
||||||
// goroutine does not linger even if we encounter an error on
|
|
||||||
// the read side.
|
|
||||||
sendHeader := append(ProtocolBytes, params.MinVersion, params.MaxVersion)
|
|
||||||
writeDone := make(chan error, 1)
|
|
||||||
go func() {
|
|
||||||
_, err := params.Conn.Write(sendHeader)
|
|
||||||
writeDone <- err
|
|
||||||
}()
|
|
||||||
|
|
||||||
header := make([]byte, len(ProtocolBytes)+2)
|
|
||||||
if n, err := io.ReadFull(params.Conn, header); err != nil && n == 0 {
|
|
||||||
return 0, fmt.Errorf("failed to receive remote protocol header: %s", err)
|
|
||||||
} else if err != nil {
|
|
||||||
return 0, fmt.Errorf("received incomplete remote protocol header (%d octets instead of %d): %v; error: %s",
|
|
||||||
n, len(header), header[:n], err)
|
|
||||||
}
|
|
||||||
|
|
||||||
if !bytes.Equal(ProtocolBytes, header[:len(ProtocolBytes)]) {
|
|
||||||
return 0, fmt.Errorf("remote protocol header not recognised: %v", header[:len(ProtocolBytes)])
|
|
||||||
}
|
|
||||||
|
|
||||||
theirMinVersion := header[len(ProtocolBytes)]
|
|
||||||
minVersion := theirMinVersion
|
|
||||||
if params.MinVersion > minVersion {
|
|
||||||
minVersion = params.MinVersion
|
|
||||||
}
|
|
||||||
|
|
||||||
theirMaxVersion := header[len(ProtocolBytes)+1]
|
|
||||||
maxVersion := theirMaxVersion
|
|
||||||
if maxVersion > params.MaxVersion {
|
|
||||||
maxVersion = params.MaxVersion
|
|
||||||
}
|
|
||||||
|
|
||||||
if minVersion > maxVersion {
|
|
||||||
return 0, fmt.Errorf("remote version range [%d,%d] is incompatible with ours [%d,%d]",
|
|
||||||
theirMinVersion, theirMaxVersion,
|
|
||||||
params.MinVersion, params.MaxVersion)
|
|
||||||
}
|
|
||||||
|
|
||||||
if err := <-writeDone; err != nil {
|
|
||||||
return 0, err
|
|
||||||
}
|
|
||||||
|
|
||||||
return maxVersion, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// The V1 procotol consists of the protocol identification/version
|
|
||||||
// header, followed by a stream of gobified values. The first value
|
|
||||||
// is the encoded features map (never encrypted). The subsequent
|
|
||||||
// values are the messages on the connection (encrypted for an
|
|
||||||
// encrypted connection). For an encrypted connection, the public key
|
|
||||||
// is passed in the "PublicKey" feature as a string of hex digits.
|
|
||||||
func (res *ProtocolIntroResults) doIntroV1(params ProtocolIntroParams, pubKey, privKey *[32]byte) error {
|
|
||||||
features := filterV1Features(params.Features)
|
|
||||||
if pubKey != nil {
|
|
||||||
features["PublicKey"] = hex.EncodeToString(pubKey[:])
|
|
||||||
}
|
|
||||||
|
|
||||||
enc := gob.NewEncoder(params.Conn)
|
|
||||||
dec := gob.NewDecoder(params.Conn)
|
|
||||||
|
|
||||||
// Encode in a separate goroutine to avoid the possibility of
|
|
||||||
// deadlock. The result channel is of size 1 so that the
|
|
||||||
// goroutine does not linger even if we encounter an error on
|
|
||||||
// the read side.
|
|
||||||
encodeDone := make(chan error, 1)
|
|
||||||
go func() {
|
|
||||||
encodeDone <- enc.Encode(features)
|
|
||||||
}()
|
|
||||||
|
|
||||||
if err := dec.Decode(&res.Features); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
if err := <-encodeDone; err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
res.Sender = NewGobTCPSender(enc)
|
|
||||||
res.Receiver = NewGobTCPReceiver(dec)
|
|
||||||
|
|
||||||
if pubKey == nil {
|
|
||||||
if _, present := res.Features["PublicKey"]; present {
|
|
||||||
return ErrExpectedNoCrypto
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
remotePubKeyStr, ok := res.Features["PublicKey"]
|
|
||||||
if !ok {
|
|
||||||
return ErrExpectedCrypto
|
|
||||||
}
|
|
||||||
|
|
||||||
remotePubKey, err := hex.DecodeString(remotePubKeyStr)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
res.setupCrypto(params, remotePubKey, privKey)
|
|
||||||
}
|
|
||||||
|
|
||||||
res.Features = filterV1Features(res.Features)
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// In the V1 protocol, the intro fields are sent unencrypted. So we
|
|
||||||
// restrict them to an established subset of fields that are assumed
|
|
||||||
// to be safe.
|
|
||||||
func filterV1Features(intro map[string]string) map[string]string {
|
|
||||||
safe := make(map[string]string)
|
|
||||||
for _, k := range ProtocolV1Features {
|
|
||||||
if val, ok := intro[k]; ok {
|
|
||||||
safe[k] = val
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return safe
|
|
||||||
}
|
|
||||||
|
|
||||||
// The V2 procotol consists of the protocol identification/version
|
|
||||||
// header, followed by:
|
|
||||||
//
|
|
||||||
// - A single "encryption flag" byte: 0 for no encryption, 1 for
|
|
||||||
// encryption.
|
|
||||||
//
|
|
||||||
// - When the connection is encrypted, 32 bytes follow containing the
|
|
||||||
// public key.
|
|
||||||
//
|
|
||||||
// - Then a stream of length-prefixed messages, which are encrypted
|
|
||||||
// for an encrypted connection.
|
|
||||||
//
|
|
||||||
// The first message contains the encoded features map (so in contrast
|
|
||||||
// to V1, it will be encrypted on an encrypted connection).
|
|
||||||
func (res *ProtocolIntroResults) doIntroV2(params ProtocolIntroParams, pubKey, privKey *[32]byte) error {
|
|
||||||
// Public key exchange
|
|
||||||
var wbuf []byte
|
|
||||||
if pubKey == nil {
|
|
||||||
wbuf = []byte{0}
|
|
||||||
} else {
|
|
||||||
wbuf = make([]byte, 1+len(*pubKey))
|
|
||||||
wbuf[0] = 1
|
|
||||||
copy(wbuf[1:], (*pubKey)[:])
|
|
||||||
}
|
|
||||||
|
|
||||||
// Write in a separate goroutine to avoid the possibility of
|
|
||||||
// deadlock. The result channel is of size 1 so that the
|
|
||||||
// goroutine does not linger even if we encounter an error on
|
|
||||||
// the read side.
|
|
||||||
writeDone := make(chan error, 1)
|
|
||||||
go func() {
|
|
||||||
_, err := params.Conn.Write(wbuf)
|
|
||||||
writeDone <- err
|
|
||||||
}()
|
|
||||||
|
|
||||||
rbuf := make([]byte, 1)
|
|
||||||
if _, err := io.ReadFull(params.Conn, rbuf); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
switch rbuf[0] {
|
|
||||||
case 0:
|
|
||||||
if pubKey != nil {
|
|
||||||
return ErrExpectedCrypto
|
|
||||||
}
|
|
||||||
|
|
||||||
res.Sender = NewLengthPrefixTCPSender(params.Conn)
|
|
||||||
res.Receiver = NewLengthPrefixTCPReceiver(params.Conn)
|
|
||||||
|
|
||||||
case 1:
|
|
||||||
if pubKey == nil {
|
|
||||||
return ErrExpectedNoCrypto
|
|
||||||
}
|
|
||||||
|
|
||||||
rbuf = make([]byte, len(pubKey))
|
|
||||||
if _, err := io.ReadFull(params.Conn, rbuf); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
res.Sender = NewLengthPrefixTCPSender(params.Conn)
|
|
||||||
res.Receiver = NewLengthPrefixTCPReceiver(params.Conn)
|
|
||||||
res.setupCrypto(params, rbuf, privKey)
|
|
||||||
|
|
||||||
default:
|
|
||||||
return fmt.Errorf("Bad encryption flag %d", rbuf[0])
|
|
||||||
}
|
|
||||||
|
|
||||||
if err := <-writeDone; err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
// Features exchange
|
|
||||||
go func() {
|
|
||||||
buf := new(bytes.Buffer)
|
|
||||||
if err := gob.NewEncoder(buf).Encode(¶ms.Features); err != nil {
|
|
||||||
writeDone <- err
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
writeDone <- res.Sender.Send(buf.Bytes())
|
|
||||||
}()
|
|
||||||
|
|
||||||
rbuf, err := res.Receiver.Receive()
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
if err := gob.NewDecoder(bytes.NewReader(rbuf)).Decode(&res.Features); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
if err := <-writeDone; err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (res *ProtocolIntroResults) setupCrypto(params ProtocolIntroParams, remotePubKey []byte, privKey *[32]byte) {
|
|
||||||
var remotePubKeyArr [32]byte
|
|
||||||
copy(remotePubKeyArr[:], remotePubKey)
|
|
||||||
res.SessionKey = FormSessionKey(&remotePubKeyArr, privKey, params.Password)
|
|
||||||
res.Sender = NewEncryptedTCPSender(res.Sender, res.SessionKey, params.Outbound)
|
|
||||||
res.Receiver = NewEncryptedTCPReceiver(res.Receiver, res.SessionKey, params.Outbound)
|
|
||||||
}
|
|
||||||
|
|
||||||
type ProtocolTag byte
|
|
||||||
|
|
||||||
const (
|
|
||||||
ProtocolHeartbeat = iota
|
|
||||||
ProtocolReserved1 // legacy overlay control messages
|
|
||||||
ProtocolReserved2 //
|
|
||||||
ProtocolReserved3 //
|
|
||||||
ProtocolGossip
|
|
||||||
ProtocolGossipUnicast
|
|
||||||
ProtocolGossipBroadcast
|
|
||||||
ProtocolOverlayControlMsg
|
|
||||||
)
|
|
||||||
|
|
||||||
type ProtocolMsg struct {
|
|
||||||
tag ProtocolTag
|
|
||||||
msg []byte
|
|
||||||
}
|
|
||||||
|
|
||||||
type ProtocolSender interface {
|
|
||||||
SendProtocolMsg(m ProtocolMsg)
|
|
||||||
}
|
|
||||||
@@ -1,180 +0,0 @@
|
|||||||
package mesh
|
|
||||||
|
|
||||||
import (
|
|
||||||
"crypto/rand"
|
|
||||||
"crypto/sha256"
|
|
||||||
"encoding/binary"
|
|
||||||
"encoding/gob"
|
|
||||||
"fmt"
|
|
||||||
"io"
|
|
||||||
"sync"
|
|
||||||
|
|
||||||
"golang.org/x/crypto/nacl/box"
|
|
||||||
"golang.org/x/crypto/nacl/secretbox"
|
|
||||||
)
|
|
||||||
|
|
||||||
const MaxTCPMsgSize = 10 * 1024 * 1024
|
|
||||||
|
|
||||||
func GenerateKeyPair() (publicKey, privateKey *[32]byte, err error) {
|
|
||||||
return box.GenerateKey(rand.Reader)
|
|
||||||
}
|
|
||||||
|
|
||||||
func FormSessionKey(remotePublicKey, localPrivateKey *[32]byte, secretKey []byte) *[32]byte {
|
|
||||||
var sharedKey [32]byte
|
|
||||||
box.Precompute(&sharedKey, remotePublicKey, localPrivateKey)
|
|
||||||
sharedKeySlice := sharedKey[:]
|
|
||||||
sharedKeySlice = append(sharedKeySlice, secretKey...)
|
|
||||||
sessionKey := sha256.Sum256(sharedKeySlice)
|
|
||||||
return &sessionKey
|
|
||||||
}
|
|
||||||
|
|
||||||
// TCP Senders/Receivers
|
|
||||||
|
|
||||||
// The lowest 64 bits of the nonce contain the message sequence
|
|
||||||
// number. The top most bit indicates the connection polarity at the
|
|
||||||
// sender - '1' for outbound; the next indicates protocol type - '1'
|
|
||||||
// for TCP. The remaining 126 bits are zero. The polarity is needed so
|
|
||||||
// that the two ends of a connection do not use the same nonces; the
|
|
||||||
// protocol type so that the TCP connection nonces are distinct from
|
|
||||||
// nonces used by overlay connections, if they share the session key.
|
|
||||||
// This is a requirement of the NaCl Security Model; see
|
|
||||||
// http://nacl.cr.yp.to/box.html.
|
|
||||||
type TCPCryptoState struct {
|
|
||||||
sessionKey *[32]byte
|
|
||||||
nonce [24]byte
|
|
||||||
seqNo uint64
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewTCPCryptoState(sessionKey *[32]byte, outbound bool) *TCPCryptoState {
|
|
||||||
s := &TCPCryptoState{sessionKey: sessionKey}
|
|
||||||
if outbound {
|
|
||||||
s.nonce[0] |= (1 << 7)
|
|
||||||
}
|
|
||||||
s.nonce[0] |= (1 << 6)
|
|
||||||
return s
|
|
||||||
}
|
|
||||||
|
|
||||||
func (s *TCPCryptoState) advance() {
|
|
||||||
s.seqNo++
|
|
||||||
binary.BigEndian.PutUint64(s.nonce[16:24], s.seqNo)
|
|
||||||
}
|
|
||||||
|
|
||||||
type TCPSender interface {
|
|
||||||
Send([]byte) error
|
|
||||||
}
|
|
||||||
|
|
||||||
type GobTCPSender struct {
|
|
||||||
encoder *gob.Encoder
|
|
||||||
}
|
|
||||||
|
|
||||||
type LengthPrefixTCPSender struct {
|
|
||||||
writer io.Writer
|
|
||||||
}
|
|
||||||
|
|
||||||
type EncryptedTCPSender struct {
|
|
||||||
sync.RWMutex
|
|
||||||
sender TCPSender
|
|
||||||
state *TCPCryptoState
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewGobTCPSender(encoder *gob.Encoder) *GobTCPSender {
|
|
||||||
return &GobTCPSender{encoder: encoder}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (sender *GobTCPSender) Send(msg []byte) error {
|
|
||||||
return sender.encoder.Encode(msg)
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewLengthPrefixTCPSender(writer io.Writer) *LengthPrefixTCPSender {
|
|
||||||
return &LengthPrefixTCPSender{writer: writer}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (sender *LengthPrefixTCPSender) Send(msg []byte) error {
|
|
||||||
l := len(msg)
|
|
||||||
if l > MaxTCPMsgSize {
|
|
||||||
return fmt.Errorf("outgoing message exceeds maximum size: %d > %d", l, MaxTCPMsgSize)
|
|
||||||
}
|
|
||||||
// We copy the message so we can send it in a single Write
|
|
||||||
// operation, thus making this thread-safe without locking.
|
|
||||||
prefixedMsg := make([]byte, 4+l)
|
|
||||||
binary.BigEndian.PutUint32(prefixedMsg, uint32(l))
|
|
||||||
copy(prefixedMsg[4:], msg)
|
|
||||||
_, err := sender.writer.Write(prefixedMsg)
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewEncryptedTCPSender(sender TCPSender, sessionKey *[32]byte, outbound bool) *EncryptedTCPSender {
|
|
||||||
return &EncryptedTCPSender{sender: sender, state: NewTCPCryptoState(sessionKey, outbound)}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (sender *EncryptedTCPSender) Send(msg []byte) error {
|
|
||||||
sender.Lock()
|
|
||||||
defer sender.Unlock()
|
|
||||||
encodedMsg := secretbox.Seal(nil, msg, &sender.state.nonce, sender.state.sessionKey)
|
|
||||||
sender.state.advance()
|
|
||||||
return sender.sender.Send(encodedMsg)
|
|
||||||
}
|
|
||||||
|
|
||||||
type TCPReceiver interface {
|
|
||||||
Receive() ([]byte, error)
|
|
||||||
}
|
|
||||||
|
|
||||||
type GobTCPReceiver struct {
|
|
||||||
decoder *gob.Decoder
|
|
||||||
}
|
|
||||||
|
|
||||||
type LengthPrefixTCPReceiver struct {
|
|
||||||
reader io.Reader
|
|
||||||
}
|
|
||||||
|
|
||||||
type EncryptedTCPReceiver struct {
|
|
||||||
receiver TCPReceiver
|
|
||||||
state *TCPCryptoState
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewGobTCPReceiver(decoder *gob.Decoder) *GobTCPReceiver {
|
|
||||||
return &GobTCPReceiver{decoder: decoder}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (receiver *GobTCPReceiver) Receive() ([]byte, error) {
|
|
||||||
var msg []byte
|
|
||||||
err := receiver.decoder.Decode(&msg)
|
|
||||||
return msg, err
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewLengthPrefixTCPReceiver(reader io.Reader) *LengthPrefixTCPReceiver {
|
|
||||||
return &LengthPrefixTCPReceiver{reader: reader}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (receiver *LengthPrefixTCPReceiver) Receive() ([]byte, error) {
|
|
||||||
lenPrefix := make([]byte, 4)
|
|
||||||
if _, err := io.ReadFull(receiver.reader, lenPrefix); err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
l := binary.BigEndian.Uint32(lenPrefix)
|
|
||||||
if l > MaxTCPMsgSize {
|
|
||||||
return nil, fmt.Errorf("incoming message exceeds maximum size: %d > %d", l, MaxTCPMsgSize)
|
|
||||||
}
|
|
||||||
msg := make([]byte, l)
|
|
||||||
_, err := io.ReadFull(receiver.reader, msg)
|
|
||||||
return msg, err
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewEncryptedTCPReceiver(receiver TCPReceiver, sessionKey *[32]byte, outbound bool) *EncryptedTCPReceiver {
|
|
||||||
return &EncryptedTCPReceiver{receiver: receiver, state: NewTCPCryptoState(sessionKey, !outbound)}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (receiver *EncryptedTCPReceiver) Receive() ([]byte, error) {
|
|
||||||
msg, err := receiver.receiver.Receive()
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
|
|
||||||
decodedMsg, success := secretbox.Open(nil, msg, &receiver.state.nonce, receiver.state.sessionKey)
|
|
||||||
if !success {
|
|
||||||
return nil, fmt.Errorf("Unable to decrypt TCP msg")
|
|
||||||
}
|
|
||||||
|
|
||||||
receiver.state.advance()
|
|
||||||
return decodedMsg, nil
|
|
||||||
}
|
|
||||||
@@ -1,96 +0,0 @@
|
|||||||
package mesh
|
|
||||||
|
|
||||||
import (
|
|
||||||
"io"
|
|
||||||
"testing"
|
|
||||||
"time"
|
|
||||||
|
|
||||||
"github.com/stretchr/testify/require"
|
|
||||||
)
|
|
||||||
|
|
||||||
type testConn struct {
|
|
||||||
io.Writer
|
|
||||||
io.Reader
|
|
||||||
}
|
|
||||||
|
|
||||||
func (testConn) SetDeadline(t time.Time) error {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (testConn) SetReadDeadline(t time.Time) error {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (testConn) SetWriteDeadline(t time.Time) error {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func connPair() (ProtocolIntroConn, ProtocolIntroConn) {
|
|
||||||
a := testConn{}
|
|
||||||
b := testConn{}
|
|
||||||
a.Reader, b.Writer = io.Pipe()
|
|
||||||
b.Reader, a.Writer = io.Pipe()
|
|
||||||
return &a, &b
|
|
||||||
}
|
|
||||||
|
|
||||||
func doIntro(t *testing.T, params ProtocolIntroParams) <-chan ProtocolIntroResults {
|
|
||||||
ch := make(chan ProtocolIntroResults, 1)
|
|
||||||
go func() {
|
|
||||||
res, err := params.DoIntro()
|
|
||||||
require.Nil(t, err)
|
|
||||||
ch <- res
|
|
||||||
}()
|
|
||||||
return ch
|
|
||||||
}
|
|
||||||
|
|
||||||
func doProtocolIntro(t *testing.T, aver, bver byte, password []byte) byte {
|
|
||||||
aconn, bconn := connPair()
|
|
||||||
aresch := doIntro(t, ProtocolIntroParams{
|
|
||||||
MinVersion: ProtocolMinVersion,
|
|
||||||
MaxVersion: aver,
|
|
||||||
Features: map[string]string{"Name": "A"},
|
|
||||||
Conn: aconn,
|
|
||||||
Outbound: true,
|
|
||||||
Password: password,
|
|
||||||
})
|
|
||||||
bresch := doIntro(t, ProtocolIntroParams{
|
|
||||||
MinVersion: ProtocolMinVersion,
|
|
||||||
MaxVersion: bver,
|
|
||||||
Features: map[string]string{"Name": "B"},
|
|
||||||
Conn: bconn,
|
|
||||||
Outbound: false,
|
|
||||||
Password: password,
|
|
||||||
})
|
|
||||||
ares := <-aresch
|
|
||||||
bres := <-bresch
|
|
||||||
|
|
||||||
// Check that features were conveyed
|
|
||||||
require.Equal(t, "B", ares.Features["Name"])
|
|
||||||
require.Equal(t, "A", bres.Features["Name"])
|
|
||||||
|
|
||||||
// Check that Senders and Receivers work
|
|
||||||
go func() {
|
|
||||||
require.Nil(t, ares.Sender.Send([]byte("Hello from A")))
|
|
||||||
require.Nil(t, bres.Sender.Send([]byte("Hello from B")))
|
|
||||||
}()
|
|
||||||
|
|
||||||
data, err := bres.Receiver.Receive()
|
|
||||||
require.Nil(t, err)
|
|
||||||
require.Equal(t, "Hello from A", string(data))
|
|
||||||
|
|
||||||
data, err = ares.Receiver.Receive()
|
|
||||||
require.Nil(t, err)
|
|
||||||
require.Equal(t, "Hello from B", string(data))
|
|
||||||
|
|
||||||
require.Equal(t, ares.Version, bres.Version)
|
|
||||||
return ares.Version
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestProtocolIntro(t *testing.T) {
|
|
||||||
require.Equal(t, 2, int(doProtocolIntro(t, 2, 2, nil)))
|
|
||||||
require.Equal(t, 2, int(doProtocolIntro(t, 2, 2, []byte("sekr1t"))))
|
|
||||||
require.Equal(t, 1, int(doProtocolIntro(t, 1, 2, nil)))
|
|
||||||
require.Equal(t, 1, int(doProtocolIntro(t, 1, 2, []byte("pa55"))))
|
|
||||||
require.Equal(t, 1, int(doProtocolIntro(t, 2, 1, nil)))
|
|
||||||
require.Equal(t, 1, int(doProtocolIntro(t, 2, 1, []byte("w0rd"))))
|
|
||||||
}
|
|
||||||
-198
@@ -1,198 +0,0 @@
|
|||||||
package mesh
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"math"
|
|
||||||
"net"
|
|
||||||
"sync"
|
|
||||||
"time"
|
|
||||||
|
|
||||||
"github.com/weaveworks/weave/common"
|
|
||||||
)
|
|
||||||
|
|
||||||
const (
|
|
||||||
Port = 6783
|
|
||||||
ChannelSize = 16
|
|
||||||
TCPHeartbeat = 30 * time.Second
|
|
||||||
GossipInterval = 30 * time.Second
|
|
||||||
MaxDuration = time.Duration(math.MaxInt64)
|
|
||||||
|
|
||||||
acceptMaxTokens = 100 // [1]
|
|
||||||
acceptTokenDelay = 100 * time.Millisecond // [2]
|
|
||||||
)
|
|
||||||
|
|
||||||
// [1] capacity of token bucket for rate limiting accepts
|
|
||||||
|
|
||||||
// [2] control rate at which new tokens are added to the bucket
|
|
||||||
|
|
||||||
var (
|
|
||||||
log = common.Log
|
|
||||||
checkFatal = common.CheckFatal
|
|
||||||
checkWarn = common.CheckWarn
|
|
||||||
)
|
|
||||||
|
|
||||||
type Config struct {
|
|
||||||
Port int
|
|
||||||
ProtocolMinVersion byte
|
|
||||||
Password []byte
|
|
||||||
ConnLimit int
|
|
||||||
PeerDiscovery bool
|
|
||||||
TrustedSubnets []*net.IPNet
|
|
||||||
}
|
|
||||||
|
|
||||||
type Router struct {
|
|
||||||
Config
|
|
||||||
Overlay Overlay
|
|
||||||
Ourself *LocalPeer
|
|
||||||
Peers *Peers
|
|
||||||
Routes *Routes
|
|
||||||
ConnectionMaker *ConnectionMaker
|
|
||||||
gossipLock sync.RWMutex
|
|
||||||
gossipChannels GossipChannels
|
|
||||||
TopologyGossip Gossip
|
|
||||||
acceptLimiter *TokenBucket
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewRouter(config Config, name PeerName, nickName string, overlay Overlay) *Router {
|
|
||||||
router := &Router{Config: config, gossipChannels: make(GossipChannels)}
|
|
||||||
|
|
||||||
if overlay == nil {
|
|
||||||
overlay = NullOverlay{}
|
|
||||||
}
|
|
||||||
|
|
||||||
router.Overlay = overlay
|
|
||||||
router.Ourself = NewLocalPeer(name, nickName, router)
|
|
||||||
router.Peers = NewPeers(router.Ourself)
|
|
||||||
router.Peers.OnGC(func(peer *Peer) {
|
|
||||||
log.Println("Removed unreachable peer", peer)
|
|
||||||
})
|
|
||||||
router.Routes = NewRoutes(router.Ourself, router.Peers)
|
|
||||||
router.ConnectionMaker = NewConnectionMaker(router.Ourself, router.Peers, router.Port, router.PeerDiscovery)
|
|
||||||
router.TopologyGossip = router.NewGossip("topology", router)
|
|
||||||
router.acceptLimiter = NewTokenBucket(acceptMaxTokens, acceptTokenDelay)
|
|
||||||
|
|
||||||
return router
|
|
||||||
}
|
|
||||||
|
|
||||||
// Start listening for TCP connections. This is separate from
|
|
||||||
// NewRouter so that gossipers can register before we start forming
|
|
||||||
// connections.
|
|
||||||
func (router *Router) Start() {
|
|
||||||
router.listenTCP(router.Port)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (router *Router) Stop() error {
|
|
||||||
// TODO: perform graceful shutdown...
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (router *Router) UsingPassword() bool {
|
|
||||||
return router.Password != nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (router *Router) listenTCP(localPort int) {
|
|
||||||
localAddr, err := net.ResolveTCPAddr("tcp4", fmt.Sprint(":", localPort))
|
|
||||||
checkFatal(err)
|
|
||||||
ln, err := net.ListenTCP("tcp4", localAddr)
|
|
||||||
checkFatal(err)
|
|
||||||
go func() {
|
|
||||||
defer ln.Close()
|
|
||||||
for {
|
|
||||||
tcpConn, err := ln.AcceptTCP()
|
|
||||||
if err != nil {
|
|
||||||
log.Errorln(err)
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
router.acceptTCP(tcpConn)
|
|
||||||
router.acceptLimiter.Wait()
|
|
||||||
}
|
|
||||||
}()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (router *Router) acceptTCP(tcpConn *net.TCPConn) {
|
|
||||||
remoteAddrStr := tcpConn.RemoteAddr().String()
|
|
||||||
log.Printf("->[%s] connection accepted", remoteAddrStr)
|
|
||||||
connRemote := NewRemoteConnection(router.Ourself.Peer, nil, remoteAddrStr, false, false)
|
|
||||||
StartLocalConnection(connRemote, tcpConn, router, true)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Gossiper methods - the Router is the topology Gossiper
|
|
||||||
|
|
||||||
type TopologyGossipData struct {
|
|
||||||
peers *Peers
|
|
||||||
update PeerNameSet
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *TopologyGossipData) Merge(other GossipData) GossipData {
|
|
||||||
names := make(PeerNameSet)
|
|
||||||
for name := range d.update {
|
|
||||||
names[name] = void
|
|
||||||
}
|
|
||||||
for name := range other.(*TopologyGossipData).update {
|
|
||||||
names[name] = void
|
|
||||||
}
|
|
||||||
return &TopologyGossipData{peers: d.peers, update: names}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *TopologyGossipData) Encode() [][]byte {
|
|
||||||
return [][]byte{d.peers.EncodePeers(d.update)}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (router *Router) BroadcastTopologyUpdate(update []*Peer) {
|
|
||||||
names := make(PeerNameSet)
|
|
||||||
for _, p := range update {
|
|
||||||
names[p.Name] = void
|
|
||||||
}
|
|
||||||
router.TopologyGossip.GossipBroadcast(
|
|
||||||
&TopologyGossipData{peers: router.Peers, update: names})
|
|
||||||
}
|
|
||||||
|
|
||||||
func (router *Router) OnGossipUnicast(sender PeerName, msg []byte) error {
|
|
||||||
return fmt.Errorf("unexpected topology gossip unicast: %v", msg)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (router *Router) OnGossipBroadcast(_ PeerName, update []byte) (GossipData, error) {
|
|
||||||
origUpdate, _, err := router.applyTopologyUpdate(update)
|
|
||||||
if err != nil || len(origUpdate) == 0 {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
return &TopologyGossipData{peers: router.Peers, update: origUpdate}, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (router *Router) Gossip() GossipData {
|
|
||||||
return &TopologyGossipData{peers: router.Peers, update: router.Peers.Names()}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (router *Router) OnGossip(update []byte) (GossipData, error) {
|
|
||||||
_, newUpdate, err := router.applyTopologyUpdate(update)
|
|
||||||
if err != nil || len(newUpdate) == 0 {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
return &TopologyGossipData{peers: router.Peers, update: newUpdate}, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (router *Router) applyTopologyUpdate(update []byte) (PeerNameSet, PeerNameSet, error) {
|
|
||||||
origUpdate, newUpdate, err := router.Peers.ApplyUpdate(update)
|
|
||||||
if err != nil {
|
|
||||||
return nil, nil, err
|
|
||||||
}
|
|
||||||
if len(newUpdate) > 0 {
|
|
||||||
router.ConnectionMaker.Refresh()
|
|
||||||
router.Routes.Recalculate()
|
|
||||||
}
|
|
||||||
return origUpdate, newUpdate, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (router *Router) Trusts(remote *RemoteConnection) bool {
|
|
||||||
if tcpAddr, err := net.ResolveTCPAddr("tcp4", remote.remoteTCPAddr); err == nil {
|
|
||||||
for _, trustedSubnet := range router.TrustedSubnets {
|
|
||||||
if trustedSubnet.Contains(tcpAddr.IP) {
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
// Should not happen as remoteTCPAddr was obtained from TCPConn
|
|
||||||
log.Errorf("Unable to parse remote TCP addr: %s", err)
|
|
||||||
}
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
-276
@@ -1,276 +0,0 @@
|
|||||||
package mesh
|
|
||||||
|
|
||||||
import (
|
|
||||||
"math"
|
|
||||||
"sync"
|
|
||||||
)
|
|
||||||
|
|
||||||
type unicastRoutes map[PeerName]PeerName
|
|
||||||
type broadcastRoutes map[PeerName][]PeerName
|
|
||||||
|
|
||||||
type Routes struct {
|
|
||||||
sync.RWMutex
|
|
||||||
ourself *LocalPeer
|
|
||||||
peers *Peers
|
|
||||||
onChange []func()
|
|
||||||
unicast unicastRoutes
|
|
||||||
unicastAll unicastRoutes // [1]
|
|
||||||
broadcast broadcastRoutes
|
|
||||||
broadcastAll broadcastRoutes // [1]
|
|
||||||
recalculate chan<- *struct{}
|
|
||||||
wait chan<- chan struct{}
|
|
||||||
// [1] based on *all* connections, not just established &
|
|
||||||
// symmetric ones
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewRoutes(ourself *LocalPeer, peers *Peers) *Routes {
|
|
||||||
recalculate := make(chan *struct{}, 1)
|
|
||||||
wait := make(chan chan struct{})
|
|
||||||
routes := &Routes{
|
|
||||||
ourself: ourself,
|
|
||||||
peers: peers,
|
|
||||||
unicast: make(unicastRoutes),
|
|
||||||
unicastAll: make(unicastRoutes),
|
|
||||||
broadcast: make(broadcastRoutes),
|
|
||||||
broadcastAll: make(broadcastRoutes),
|
|
||||||
recalculate: recalculate,
|
|
||||||
wait: wait}
|
|
||||||
routes.unicast[ourself.Name] = UnknownPeerName
|
|
||||||
routes.unicastAll[ourself.Name] = UnknownPeerName
|
|
||||||
routes.broadcast[ourself.Name] = []PeerName{}
|
|
||||||
routes.broadcastAll[ourself.Name] = []PeerName{}
|
|
||||||
go routes.run(recalculate, wait)
|
|
||||||
return routes
|
|
||||||
}
|
|
||||||
|
|
||||||
func (routes *Routes) OnChange(callback func()) {
|
|
||||||
routes.Lock()
|
|
||||||
defer routes.Unlock()
|
|
||||||
routes.onChange = append(routes.onChange, callback)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (routes *Routes) PeerNames() PeerNameSet {
|
|
||||||
return routes.peers.Names()
|
|
||||||
}
|
|
||||||
|
|
||||||
func (routes *Routes) Unicast(name PeerName) (PeerName, bool) {
|
|
||||||
routes.RLock()
|
|
||||||
defer routes.RUnlock()
|
|
||||||
hop, found := routes.unicast[name]
|
|
||||||
return hop, found
|
|
||||||
}
|
|
||||||
|
|
||||||
func (routes *Routes) UnicastAll(name PeerName) (PeerName, bool) {
|
|
||||||
routes.RLock()
|
|
||||||
defer routes.RUnlock()
|
|
||||||
hop, found := routes.unicastAll[name]
|
|
||||||
return hop, found
|
|
||||||
}
|
|
||||||
|
|
||||||
func (routes *Routes) Broadcast(name PeerName) []PeerName {
|
|
||||||
routes.RLock()
|
|
||||||
defer routes.RUnlock()
|
|
||||||
return routes.broadcast[name]
|
|
||||||
}
|
|
||||||
|
|
||||||
func (routes *Routes) BroadcastAll(name PeerName) []PeerName {
|
|
||||||
routes.RLock()
|
|
||||||
defer routes.RUnlock()
|
|
||||||
return routes.broadcastAll[name]
|
|
||||||
}
|
|
||||||
|
|
||||||
// Choose min(log2(n_peers), n_neighbouring_peers) neighbours, with a
|
|
||||||
// random distribution that is topology-sensitive, favouring
|
|
||||||
// neighbours at the end of "bottleneck links". We determine the
|
|
||||||
// latter based on the unicast routing table. If a neighbour appears
|
|
||||||
// as the value more frequently than others - meaning that we reach a
|
|
||||||
// higher proportion of peers via that neighbour than other neighbours
|
|
||||||
// - then it is chosen with a higher probability.
|
|
||||||
//
|
|
||||||
// Note that we choose log2(n_peers) *neighbours*, not
|
|
||||||
// peers. Consequently, on sparsely connected peers this function
|
|
||||||
// returns a higher proportion of neighbours than elsewhere. In
|
|
||||||
// extremis, on peers with fewer than log2(n_peers) neighbours, all
|
|
||||||
// neighbours are returned.
|
|
||||||
func (routes *Routes) RandomNeighbours(except PeerName) []PeerName {
|
|
||||||
destinations := make(PeerNameSet)
|
|
||||||
routes.RLock()
|
|
||||||
defer routes.RUnlock()
|
|
||||||
count := int(math.Log2(float64(len(routes.unicastAll))))
|
|
||||||
// depends on go's random map iteration
|
|
||||||
for _, dst := range routes.unicastAll {
|
|
||||||
if dst != UnknownPeerName && dst != except {
|
|
||||||
destinations[dst] = void
|
|
||||||
if len(destinations) >= count {
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
res := make([]PeerName, 0, len(destinations))
|
|
||||||
for dst := range destinations {
|
|
||||||
res = append(res, dst)
|
|
||||||
}
|
|
||||||
return res
|
|
||||||
}
|
|
||||||
|
|
||||||
// Request recalculation of the routing table. This is async but can
|
|
||||||
// effectively be made synchronous with a subsequent call to
|
|
||||||
// EnsureRecalculated.
|
|
||||||
func (routes *Routes) Recalculate() {
|
|
||||||
// The use of a 1-capacity channel in combination with the
|
|
||||||
// non-blocking send is an optimisation that results in multiple
|
|
||||||
// requests being coalesced.
|
|
||||||
select {
|
|
||||||
case routes.recalculate <- nil:
|
|
||||||
default:
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Wait for any preceding Recalculate requests to be processed.
|
|
||||||
func (routes *Routes) EnsureRecalculated() {
|
|
||||||
done := make(chan struct{})
|
|
||||||
routes.wait <- done
|
|
||||||
<-done
|
|
||||||
}
|
|
||||||
|
|
||||||
func (routes *Routes) run(recalculate <-chan *struct{}, wait <-chan chan struct{}) {
|
|
||||||
for {
|
|
||||||
select {
|
|
||||||
case <-recalculate:
|
|
||||||
routes.calculate()
|
|
||||||
case done := <-wait:
|
|
||||||
select {
|
|
||||||
case <-recalculate:
|
|
||||||
routes.calculate()
|
|
||||||
default:
|
|
||||||
}
|
|
||||||
close(done)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (routes *Routes) calculate() {
|
|
||||||
routes.peers.RLock()
|
|
||||||
routes.ourself.RLock()
|
|
||||||
var (
|
|
||||||
oldUnicast = routes.unicast
|
|
||||||
oldBroadcast = routes.broadcast
|
|
||||||
unicast = routes.calculateUnicast(true)
|
|
||||||
unicastAll = routes.calculateUnicast(false)
|
|
||||||
broadcast = routes.calculateBroadcast(true)
|
|
||||||
broadcastAll = routes.calculateBroadcast(false)
|
|
||||||
)
|
|
||||||
routes.ourself.RUnlock()
|
|
||||||
routes.peers.RUnlock()
|
|
||||||
|
|
||||||
routes.Lock()
|
|
||||||
routes.unicast = unicast
|
|
||||||
routes.unicastAll = unicastAll
|
|
||||||
routes.broadcast = broadcast
|
|
||||||
routes.broadcastAll = broadcastAll
|
|
||||||
onChange := routes.onChange
|
|
||||||
routes.Unlock()
|
|
||||||
|
|
||||||
if !unicast.equals(oldUnicast) || !broadcast.equals(oldBroadcast) {
|
|
||||||
for _, callback := range onChange {
|
|
||||||
callback()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Calculate all the routes for the question: if *we* want to send a
|
|
||||||
// packet to Peer X, what is the next hop?
|
|
||||||
//
|
|
||||||
// When we sniff a packet, we determine the destination peer
|
|
||||||
// ourself. Consequently, we can relay the packet via any
|
|
||||||
// arbitrary peers - the intermediate peers do not have to have
|
|
||||||
// any knowledge of the MAC address at all. Thus there's no need
|
|
||||||
// to exchange knowledge of MAC addresses, nor any constraints on
|
|
||||||
// the routes that we construct.
|
|
||||||
func (routes *Routes) calculateUnicast(establishedAndSymmetric bool) unicastRoutes {
|
|
||||||
_, unicast := routes.ourself.Routes(nil, establishedAndSymmetric)
|
|
||||||
return unicast
|
|
||||||
}
|
|
||||||
|
|
||||||
// Calculate all the routes for the question: if we receive a
|
|
||||||
// broadcast originally from Peer X, which peers should we pass the
|
|
||||||
// frames on to?
|
|
||||||
//
|
|
||||||
// When the topology is stable, and thus all peers perform route
|
|
||||||
// calculations based on the same data, the algorithm ensures that
|
|
||||||
// broadcasts reach every peer exactly once.
|
|
||||||
//
|
|
||||||
// This is largely due to properties of the Peer.Routes algorithm. In
|
|
||||||
// particular:
|
|
||||||
//
|
|
||||||
// ForAll X,Y,Z in Peers.
|
|
||||||
// X.Routes(Y) <= X.Routes(Z) \/
|
|
||||||
// X.Routes(Z) <= X.Routes(Y)
|
|
||||||
// ForAll X,Y,Z in Peers.
|
|
||||||
// Y =/= Z /\ X.Routes(Y) <= X.Routes(Z) =>
|
|
||||||
// X.Routes(Y) u [P | Y.HasSymmetricConnectionTo(P)] <= X.Routes(Z)
|
|
||||||
// where <= is the subset relationship on keys of the returned map.
|
|
||||||
func (routes *Routes) calculateBroadcast(establishedAndSymmetric bool) broadcastRoutes {
|
|
||||||
broadcast := make(broadcastRoutes)
|
|
||||||
for _, peer := range routes.peers.byName {
|
|
||||||
hops := []PeerName{}
|
|
||||||
if found, reached := peer.Routes(routes.ourself.Peer, establishedAndSymmetric); found {
|
|
||||||
routes.ourself.ForEachConnectedPeer(establishedAndSymmetric, reached,
|
|
||||||
func(remotePeer *Peer) { hops = append(hops, remotePeer.Name) })
|
|
||||||
}
|
|
||||||
broadcast[peer.Name] = hops
|
|
||||||
}
|
|
||||||
return broadcast
|
|
||||||
}
|
|
||||||
|
|
||||||
func (a unicastRoutes) equals(b unicastRoutes) bool {
|
|
||||||
for key, aval := range a {
|
|
||||||
if bval, ok := b[key]; !ok || bval != aval {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
for key := range b {
|
|
||||||
if _, ok := a[key]; !ok {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
|
|
||||||
func (a broadcastRoutes) equals(b broadcastRoutes) bool {
|
|
||||||
set := make(map[PeerName]struct{})
|
|
||||||
|
|
||||||
for key, aval := range a {
|
|
||||||
bval, ok := b[key]
|
|
||||||
if !ok {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, peer := range aval {
|
|
||||||
set[peer] = struct{}{}
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, peer := range bval {
|
|
||||||
if _, ok := set[peer]; !ok {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
delete(set, peer)
|
|
||||||
}
|
|
||||||
|
|
||||||
if len(set) != 0 {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
for key := range b {
|
|
||||||
if _, ok := a[key]; !ok {
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return true
|
|
||||||
}
|
|
||||||
-211
@@ -1,211 +0,0 @@
|
|||||||
package mesh
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"net"
|
|
||||||
)
|
|
||||||
|
|
||||||
type Status struct {
|
|
||||||
Protocol string
|
|
||||||
ProtocolMinVersion int
|
|
||||||
ProtocolMaxVersion int
|
|
||||||
Encryption bool
|
|
||||||
PeerDiscovery bool
|
|
||||||
Name string
|
|
||||||
NickName string
|
|
||||||
Port int
|
|
||||||
Peers []PeerStatus
|
|
||||||
UnicastRoutes []UnicastRouteStatus
|
|
||||||
BroadcastRoutes []BroadcastRouteStatus
|
|
||||||
Connections []LocalConnectionStatus
|
|
||||||
Targets []string
|
|
||||||
OverlayDiagnostics interface{}
|
|
||||||
TrustedSubnets []string
|
|
||||||
}
|
|
||||||
|
|
||||||
type PeerStatus struct {
|
|
||||||
Name string
|
|
||||||
NickName string
|
|
||||||
UID PeerUID
|
|
||||||
ShortID PeerShortID
|
|
||||||
Version uint64
|
|
||||||
Connections []ConnectionStatus
|
|
||||||
}
|
|
||||||
|
|
||||||
type ConnectionStatus struct {
|
|
||||||
Name string
|
|
||||||
NickName string
|
|
||||||
Address string
|
|
||||||
Outbound bool
|
|
||||||
Established bool
|
|
||||||
}
|
|
||||||
|
|
||||||
type UnicastRouteStatus struct {
|
|
||||||
Dest, Via string
|
|
||||||
}
|
|
||||||
|
|
||||||
type BroadcastRouteStatus struct {
|
|
||||||
Source string
|
|
||||||
Via []string
|
|
||||||
}
|
|
||||||
|
|
||||||
type LocalConnectionStatus struct {
|
|
||||||
Address string
|
|
||||||
Outbound bool
|
|
||||||
State string
|
|
||||||
Info string
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewStatus(router *Router) *Status {
|
|
||||||
return &Status{
|
|
||||||
Protocol,
|
|
||||||
ProtocolMinVersion,
|
|
||||||
ProtocolMaxVersion,
|
|
||||||
router.UsingPassword(),
|
|
||||||
router.PeerDiscovery,
|
|
||||||
router.Ourself.Name.String(),
|
|
||||||
router.Ourself.NickName,
|
|
||||||
router.Port,
|
|
||||||
NewPeerStatusSlice(router.Peers),
|
|
||||||
NewUnicastRouteStatusSlice(router.Routes),
|
|
||||||
NewBroadcastRouteStatusSlice(router.Routes),
|
|
||||||
NewLocalConnectionStatusSlice(router.ConnectionMaker),
|
|
||||||
NewTargetSlice(router.ConnectionMaker),
|
|
||||||
router.Overlay.Diagnostics(),
|
|
||||||
NewTrustedSubnetsSlice(router.TrustedSubnets)}
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewPeerStatusSlice(peers *Peers) []PeerStatus {
|
|
||||||
var slice []PeerStatus
|
|
||||||
|
|
||||||
peers.ForEach(func(peer *Peer) {
|
|
||||||
var connections []ConnectionStatus
|
|
||||||
if peer == peers.ourself.Peer {
|
|
||||||
for conn := range peers.ourself.Connections() {
|
|
||||||
connections = append(connections, newConnectionStatus(conn))
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
// Modifying peer.connections requires a write lock on
|
|
||||||
// Peers, and since we are holding a read lock (due to the
|
|
||||||
// ForEach), access without locking the peer is safe.
|
|
||||||
for _, conn := range peer.connections {
|
|
||||||
connections = append(connections, newConnectionStatus(conn))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
slice = append(slice, PeerStatus{
|
|
||||||
peer.Name.String(),
|
|
||||||
peer.NickName,
|
|
||||||
peer.UID,
|
|
||||||
peer.ShortID,
|
|
||||||
peer.Version,
|
|
||||||
connections})
|
|
||||||
})
|
|
||||||
|
|
||||||
return slice
|
|
||||||
}
|
|
||||||
|
|
||||||
func newConnectionStatus(c Connection) ConnectionStatus {
|
|
||||||
return ConnectionStatus{
|
|
||||||
c.Remote().Name.String(),
|
|
||||||
c.Remote().NickName,
|
|
||||||
c.RemoteTCPAddr(),
|
|
||||||
c.Outbound(),
|
|
||||||
c.Established()}
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewUnicastRouteStatusSlice(routes *Routes) []UnicastRouteStatus {
|
|
||||||
routes.RLock()
|
|
||||||
defer routes.RUnlock()
|
|
||||||
|
|
||||||
var slice []UnicastRouteStatus
|
|
||||||
for dest, via := range routes.unicast {
|
|
||||||
slice = append(slice, UnicastRouteStatus{dest.String(), via.String()})
|
|
||||||
}
|
|
||||||
return slice
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewBroadcastRouteStatusSlice(routes *Routes) []BroadcastRouteStatus {
|
|
||||||
routes.RLock()
|
|
||||||
defer routes.RUnlock()
|
|
||||||
|
|
||||||
var slice []BroadcastRouteStatus
|
|
||||||
for source, via := range routes.broadcast {
|
|
||||||
var hops []string
|
|
||||||
for _, hop := range via {
|
|
||||||
hops = append(hops, hop.String())
|
|
||||||
}
|
|
||||||
slice = append(slice, BroadcastRouteStatus{source.String(), hops})
|
|
||||||
}
|
|
||||||
return slice
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewLocalConnectionStatusSlice(cm *ConnectionMaker) []LocalConnectionStatus {
|
|
||||||
resultChan := make(chan []LocalConnectionStatus, 0)
|
|
||||||
cm.actionChan <- func() bool {
|
|
||||||
var slice []LocalConnectionStatus
|
|
||||||
for conn := range cm.connections {
|
|
||||||
state := "pending"
|
|
||||||
if conn.Established() {
|
|
||||||
state = "established"
|
|
||||||
}
|
|
||||||
lc, _ := conn.(*LocalConnection)
|
|
||||||
info := fmt.Sprintf("%-6v %v", lc.OverlayConn.DisplayName(), conn.Remote())
|
|
||||||
if lc.Router.UsingPassword() {
|
|
||||||
if lc.Untrusted() {
|
|
||||||
info = fmt.Sprintf("%-11v %v", "encrypted", info)
|
|
||||||
} else {
|
|
||||||
info = fmt.Sprintf("%-11v %v", "unencrypted", info)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
slice = append(slice, LocalConnectionStatus{conn.RemoteTCPAddr(), conn.Outbound(), state, info})
|
|
||||||
}
|
|
||||||
for address, target := range cm.targets {
|
|
||||||
add := func(state, info string) {
|
|
||||||
slice = append(slice, LocalConnectionStatus{address, true, state, info})
|
|
||||||
}
|
|
||||||
switch target.state {
|
|
||||||
case TargetWaiting:
|
|
||||||
until := "never"
|
|
||||||
if !target.tryAfter.IsZero() {
|
|
||||||
until = target.tryAfter.String()
|
|
||||||
}
|
|
||||||
if target.lastError == nil { // shouldn't happen
|
|
||||||
add("waiting", "until: "+until)
|
|
||||||
} else {
|
|
||||||
add("failed", target.lastError.Error()+", retry: "+until)
|
|
||||||
}
|
|
||||||
case TargetAttempting:
|
|
||||||
if target.lastError == nil {
|
|
||||||
add("connecting", "")
|
|
||||||
} else {
|
|
||||||
add("retrying", target.lastError.Error())
|
|
||||||
}
|
|
||||||
case TargetConnected:
|
|
||||||
}
|
|
||||||
}
|
|
||||||
resultChan <- slice
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
return <-resultChan
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewTargetSlice(cm *ConnectionMaker) []string {
|
|
||||||
resultChan := make(chan []string, 0)
|
|
||||||
cm.actionChan <- func() bool {
|
|
||||||
var slice []string
|
|
||||||
for peer := range cm.directPeers {
|
|
||||||
slice = append(slice, peer)
|
|
||||||
}
|
|
||||||
resultChan <- slice
|
|
||||||
return false
|
|
||||||
}
|
|
||||||
return <-resultChan
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewTrustedSubnetsSlice(trustedSubnets []*net.IPNet) []string {
|
|
||||||
trustedSubnetStrs := []string{}
|
|
||||||
for _, trustedSubnet := range trustedSubnets {
|
|
||||||
trustedSubnetStrs = append(trustedSubnetStrs, trustedSubnet.String())
|
|
||||||
}
|
|
||||||
return trustedSubnetStrs
|
|
||||||
}
|
|
||||||
@@ -1,45 +0,0 @@
|
|||||||
package mesh
|
|
||||||
|
|
||||||
type SurrogateGossipData struct {
|
|
||||||
messages [][]byte
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewSurrogateGossipData(msg []byte) *SurrogateGossipData {
|
|
||||||
return &SurrogateGossipData{messages: [][]byte{msg}}
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *SurrogateGossipData) Encode() [][]byte {
|
|
||||||
return d.messages
|
|
||||||
}
|
|
||||||
|
|
||||||
func (d *SurrogateGossipData) Merge(other GossipData) GossipData {
|
|
||||||
o := other.(*SurrogateGossipData)
|
|
||||||
messages := make([][]byte, 0, len(d.messages)+len(o.messages))
|
|
||||||
messages = append(messages, d.messages...)
|
|
||||||
messages = append(messages, o.messages...)
|
|
||||||
return &SurrogateGossipData{messages: messages}
|
|
||||||
}
|
|
||||||
|
|
||||||
// SurrogateGossiper ignores unicasts and relays broadcasts and gossips.
|
|
||||||
|
|
||||||
type SurrogateGossiper struct{}
|
|
||||||
|
|
||||||
func (*SurrogateGossiper) OnGossipUnicast(sender PeerName, msg []byte) error {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (*SurrogateGossiper) OnGossipBroadcast(_ PeerName, update []byte) (GossipData, error) {
|
|
||||||
return NewSurrogateGossipData(update), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (*SurrogateGossiper) Gossip() GossipData {
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (*SurrogateGossiper) OnGossip(update []byte) (GossipData, error) {
|
|
||||||
return NewSurrogateGossipData(update), nil
|
|
||||||
}
|
|
||||||
|
|
||||||
var (
|
|
||||||
surrogateGossiper SurrogateGossiper
|
|
||||||
)
|
|
||||||
@@ -1,42 +0,0 @@
|
|||||||
package mesh
|
|
||||||
|
|
||||||
import (
|
|
||||||
"time"
|
|
||||||
)
|
|
||||||
|
|
||||||
type TokenBucket struct {
|
|
||||||
capacity int64 // Maximum capacity of bucket
|
|
||||||
tokenInterval time.Duration // Token replenishment rate
|
|
||||||
refillDuration time.Duration // Time to refill from empty
|
|
||||||
earliestUnspentToken time.Time
|
|
||||||
}
|
|
||||||
|
|
||||||
func NewTokenBucket(capacity int64, tokenInterval time.Duration) *TokenBucket {
|
|
||||||
tb := TokenBucket{
|
|
||||||
capacity: capacity,
|
|
||||||
tokenInterval: tokenInterval,
|
|
||||||
refillDuration: tokenInterval * time.Duration(capacity)}
|
|
||||||
|
|
||||||
tb.earliestUnspentToken = tb.capacityToken()
|
|
||||||
|
|
||||||
return &tb
|
|
||||||
}
|
|
||||||
|
|
||||||
func (tb *TokenBucket) Wait() {
|
|
||||||
// If earliest unspent token is in the future, sleep until then
|
|
||||||
time.Sleep(tb.earliestUnspentToken.Sub(time.Now()))
|
|
||||||
|
|
||||||
// Alternatively, enforce bucket capacity if necessary
|
|
||||||
capacityToken := tb.capacityToken()
|
|
||||||
if tb.earliestUnspentToken.Before(capacityToken) {
|
|
||||||
tb.earliestUnspentToken = capacityToken
|
|
||||||
}
|
|
||||||
|
|
||||||
// 'Remove' a token from the bucket
|
|
||||||
tb.earliestUnspentToken = tb.earliestUnspentToken.Add(tb.tokenInterval)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Determine the historic token timestamp representing a full bucket
|
|
||||||
func (tb *TokenBucket) capacityToken() time.Time {
|
|
||||||
return time.Now().Add(-tb.refillDuration).Truncate(tb.tokenInterval)
|
|
||||||
}
|
|
||||||
+8
-2
@@ -134,7 +134,7 @@ func (d *DNSServer) createMux(client *dns.Client, defaultMaxResponseSize int) *d
|
|||||||
|
|
||||||
func (h *handler) handleLocal(w dns.ResponseWriter, req *dns.Msg) {
|
func (h *handler) handleLocal(w dns.ResponseWriter, req *dns.Msg) {
|
||||||
h.ns.debugf("local request: %+v", *req)
|
h.ns.debugf("local request: %+v", *req)
|
||||||
if len(req.Question) != 1 || req.Question[0].Qtype != dns.TypeA {
|
if len(req.Question) != 1 {
|
||||||
h.nameError(w, req)
|
h.nameError(w, req)
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
@@ -149,6 +149,12 @@ func (h *handler) handleLocal(w dns.ResponseWriter, req *dns.Msg) {
|
|||||||
h.nameError(w, req)
|
h.nameError(w, req)
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
// Per RFC4074, if we have an A but another type was requested,
|
||||||
|
// return 'no error' with empty answer section
|
||||||
|
if req.Question[0].Qtype != dns.TypeA {
|
||||||
|
h.respond(w, h.makeResponse(req, nil))
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
header := dns.RR_Header{
|
header := dns.RR_Header{
|
||||||
Name: req.Question[0].Name,
|
Name: req.Question[0].Name,
|
||||||
@@ -204,7 +210,7 @@ func (h *handler) handleRecursive(w dns.ResponseWriter, req *dns.Msg) {
|
|||||||
h.ns.debugf("recursive request: %+v", *req)
|
h.ns.debugf("recursive request: %+v", *req)
|
||||||
|
|
||||||
// Resolve unqualified names locally
|
// Resolve unqualified names locally
|
||||||
if len(req.Question) == 1 && req.Question[0].Qtype == dns.TypeA {
|
if len(req.Question) == 1 {
|
||||||
hostname := dns.Fqdn(req.Question[0].Name)
|
hostname := dns.Fqdn(req.Question[0].Name)
|
||||||
if strings.Count(hostname, ".") == 1 {
|
if strings.Count(hostname, ".") == 1 {
|
||||||
h.handleLocal(w, req)
|
h.handleLocal(w, req)
|
||||||
|
|||||||
@@ -11,7 +11,7 @@ import (
|
|||||||
"github.com/miekg/dns"
|
"github.com/miekg/dns"
|
||||||
"github.com/stretchr/testify/require"
|
"github.com/stretchr/testify/require"
|
||||||
|
|
||||||
"github.com/weaveworks/weave/mesh"
|
"github.com/weaveworks/mesh"
|
||||||
"github.com/weaveworks/weave/net/address"
|
"github.com/weaveworks/weave/net/address"
|
||||||
)
|
)
|
||||||
|
|
||||||
|
|||||||
+26
-4
@@ -8,7 +8,8 @@ import (
|
|||||||
"strings"
|
"strings"
|
||||||
"time"
|
"time"
|
||||||
|
|
||||||
"github.com/weaveworks/weave/mesh"
|
"github.com/weaveworks/mesh"
|
||||||
|
|
||||||
"github.com/weaveworks/weave/net/address"
|
"github.com/weaveworks/weave/net/address"
|
||||||
)
|
)
|
||||||
|
|
||||||
@@ -93,6 +94,9 @@ func (e1 *Entry) merge(e2 *Entry) bool {
|
|||||||
e1.Version = e2.Version
|
e1.Version = e2.Version
|
||||||
e1.Tombstone = e2.Tombstone
|
e1.Tombstone = e2.Tombstone
|
||||||
return true
|
return true
|
||||||
|
} else if e2.Version == e1.Version && e2.Tombstone > e1.Tombstone {
|
||||||
|
e1.Tombstone = e2.Tombstone
|
||||||
|
return true
|
||||||
}
|
}
|
||||||
return false
|
return false
|
||||||
}
|
}
|
||||||
@@ -105,6 +109,15 @@ func (e1 *Entry) addLowercase() {
|
|||||||
e1.lHostname = strings.ToLower(e1.Hostname)
|
e1.lHostname = strings.ToLower(e1.Hostname)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func (e1 *Entry) tombstone() bool {
|
||||||
|
if e1.Tombstone > 0 {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
e1.Tombstone = now()
|
||||||
|
e1.Version++
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
func check(es SortableEntries) error {
|
func check(es SortableEntries) error {
|
||||||
if !sort.IsSorted(es) {
|
if !sort.IsSorted(es) {
|
||||||
return fmt.Errorf("Not sorted!")
|
return fmt.Errorf("Not sorted!")
|
||||||
@@ -181,9 +194,7 @@ func (es *Entries) tombstone(ourname mesh.PeerName, f func(*Entry) bool) Entries
|
|||||||
|
|
||||||
tombstoned := Entries{}
|
tombstoned := Entries{}
|
||||||
for i, e := range *es {
|
for i, e := range *es {
|
||||||
if f(&e) && e.Origin == ourname {
|
if f(&e) && e.Origin == ourname && e.tombstone() {
|
||||||
e.Version++
|
|
||||||
e.Tombstone = now()
|
|
||||||
(*es)[i] = e
|
(*es)[i] = e
|
||||||
tombstoned = append(tombstoned, e)
|
tombstoned = append(tombstoned, e)
|
||||||
}
|
}
|
||||||
@@ -191,6 +202,7 @@ func (es *Entries) tombstone(ourname mesh.PeerName, f func(*Entry) bool) Entries
|
|||||||
return tombstoned
|
return tombstoned
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// note f() may only modify entries such that they remain in order defined by less()
|
||||||
func (es *Entries) filter(f func(*Entry) bool) {
|
func (es *Entries) filter(f func(*Entry) bool) {
|
||||||
defer es.checkAndPanic().checkAndPanic()
|
defer es.checkAndPanic().checkAndPanic()
|
||||||
|
|
||||||
@@ -205,6 +217,16 @@ func (es *Entries) filter(f func(*Entry) bool) {
|
|||||||
*es = (*es)[:i]
|
*es = (*es)[:i]
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func (es Entries) findEqual(e *Entry) (*Entry, bool) {
|
||||||
|
i := sort.Search(len(es), func(i int) bool {
|
||||||
|
return !es[i].insensitiveLess(e)
|
||||||
|
})
|
||||||
|
if i < len(es) && es[i].equal(*e) {
|
||||||
|
return &es[i], true
|
||||||
|
}
|
||||||
|
return nil, false
|
||||||
|
}
|
||||||
|
|
||||||
func (es Entries) lookup(hostname string) Entries {
|
func (es Entries) lookup(hostname string) Entries {
|
||||||
es.checkAndPanic()
|
es.checkAndPanic()
|
||||||
|
|
||||||
|
|||||||
@@ -4,8 +4,8 @@ import (
|
|||||||
"testing"
|
"testing"
|
||||||
|
|
||||||
"github.com/stretchr/testify/require"
|
"github.com/stretchr/testify/require"
|
||||||
|
"github.com/weaveworks/mesh"
|
||||||
|
|
||||||
"github.com/weaveworks/weave/mesh"
|
|
||||||
"github.com/weaveworks/weave/net/address"
|
"github.com/weaveworks/weave/net/address"
|
||||||
)
|
)
|
||||||
|
|
||||||
@@ -86,6 +86,21 @@ func TestTombstone(t *testing.T) {
|
|||||||
Entry{Hostname: "B", Version: 1, Tombstone: 1234},
|
Entry{Hostname: "B", Version: 1, Tombstone: 1234},
|
||||||
})
|
})
|
||||||
require.Equal(t, expected, es)
|
require.Equal(t, expected, es)
|
||||||
|
|
||||||
|
// Now try a merge including two entries which differ only in tombstone
|
||||||
|
e2 := make(Entries, len(es))
|
||||||
|
copy(e2, es)
|
||||||
|
e2[1].Tombstone = 5555
|
||||||
|
|
||||||
|
diff := es.merge(e2)
|
||||||
|
|
||||||
|
expected2 := l(Entries{
|
||||||
|
Entry{Hostname: "A"},
|
||||||
|
Entry{Hostname: "B", Version: 1, Tombstone: 5555},
|
||||||
|
})
|
||||||
|
require.Equal(t, expected2, es)
|
||||||
|
expectedDiff := l(Entries{Entry{Hostname: "B", Version: 1, Tombstone: 5555}})
|
||||||
|
require.Equal(t, expectedDiff, diff)
|
||||||
}
|
}
|
||||||
|
|
||||||
func TestDelete(t *testing.T) {
|
func TestDelete(t *testing.T) {
|
||||||
|
|||||||
+3
-11
@@ -40,16 +40,11 @@ func (n *Nameserver) HandleHTTP(router *mux.Router, dockerCli *docker.Client) {
|
|||||||
return
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
if err := n.AddEntry(hostname, container, n.ourName, ip); err != nil {
|
n.AddEntry(hostname, container, n.ourName, ip)
|
||||||
n.badRequest(w, fmt.Errorf("Unable to add entry: %v", err))
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
if r.FormValue("check-alive") == "true" && dockerCli != nil && dockerCli.IsContainerNotRunning(container) {
|
if r.FormValue("check-alive") == "true" && dockerCli != nil && dockerCli.IsContainerNotRunning(container) {
|
||||||
n.infof("container '%s' is not running: removing", container)
|
n.infof("container '%s' is not running: removing", container)
|
||||||
if err := n.Delete(hostname, container, ipStr, ip); err != nil {
|
n.Delete(hostname, container, ipStr, ip)
|
||||||
n.infof("failed to remove: %v", err)
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
w.WriteHeader(204)
|
w.WriteHeader(204)
|
||||||
@@ -79,10 +74,7 @@ func (n *Nameserver) HandleHTTP(router *mux.Router, dockerCli *docker.Client) {
|
|||||||
ipStr = "*"
|
ipStr = "*"
|
||||||
}
|
}
|
||||||
|
|
||||||
if err := n.Delete(hostname, container, ipStr, ip); err != nil {
|
n.Delete(hostname, container, ipStr, ip)
|
||||||
n.badRequest(w, fmt.Errorf("Unable to delete entries: %v", err))
|
|
||||||
return
|
|
||||||
}
|
|
||||||
w.WriteHeader(204)
|
w.WriteHeader(204)
|
||||||
}
|
}
|
||||||
router.Methods("DELETE").Path("/name/{container}/{ip}").HandlerFunc(deleteHandler)
|
router.Methods("DELETE").Path("/name/{container}/{ip}").HandlerFunc(deleteHandler)
|
||||||
|
|||||||
+52
-19
@@ -6,9 +6,9 @@ import (
|
|||||||
"time"
|
"time"
|
||||||
|
|
||||||
"github.com/miekg/dns"
|
"github.com/miekg/dns"
|
||||||
|
"github.com/weaveworks/mesh"
|
||||||
|
|
||||||
. "github.com/weaveworks/weave/common"
|
"github.com/weaveworks/weave/common"
|
||||||
"github.com/weaveworks/weave/mesh"
|
|
||||||
"github.com/weaveworks/weave/net/address"
|
"github.com/weaveworks/weave/net/address"
|
||||||
)
|
)
|
||||||
|
|
||||||
@@ -73,22 +73,22 @@ func (n *Nameserver) Stop() {
|
|||||||
n.quit <- struct{}{}
|
n.quit <- struct{}{}
|
||||||
}
|
}
|
||||||
|
|
||||||
func (n *Nameserver) broadcastEntries(es ...Entry) error {
|
func (n *Nameserver) broadcastEntries(es ...Entry) {
|
||||||
if n.gossip == nil || len(es) == 0 {
|
if n.gossip == nil || len(es) == 0 {
|
||||||
return nil
|
return
|
||||||
}
|
}
|
||||||
return n.gossip.GossipBroadcast(&GossipData{
|
n.gossip.GossipBroadcast(&GossipData{
|
||||||
Entries: Entries(es),
|
Entries: Entries(es),
|
||||||
Timestamp: now(),
|
Timestamp: now(),
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
func (n *Nameserver) AddEntry(hostname, containerid string, origin mesh.PeerName, addr address.Address) error {
|
func (n *Nameserver) AddEntry(hostname, containerid string, origin mesh.PeerName, addr address.Address) {
|
||||||
n.Lock()
|
n.Lock()
|
||||||
n.infof("adding entry for %s: %s -> %s", containerid, hostname, addr.String())
|
n.infof("adding entry for %s: %s -> %s", containerid, hostname, addr.String())
|
||||||
entry := n.entries.add(hostname, containerid, origin, addr)
|
entry := n.entries.add(hostname, containerid, origin, addr)
|
||||||
n.Unlock()
|
n.Unlock()
|
||||||
return n.broadcastEntries(entry)
|
n.broadcastEntries(entry)
|
||||||
}
|
}
|
||||||
|
|
||||||
func (n *Nameserver) Lookup(hostname string) []address.Address {
|
func (n *Nameserver) Lookup(hostname string) []address.Address {
|
||||||
@@ -121,7 +121,8 @@ func (n *Nameserver) ReverseLookup(ip address.Address) (string, error) {
|
|||||||
return match.Hostname, nil
|
return match.Hostname, nil
|
||||||
}
|
}
|
||||||
|
|
||||||
func (n *Nameserver) ContainerStarted(ident string) {}
|
func (n *Nameserver) ContainerStarted(ident string) {}
|
||||||
|
func (n *Nameserver) ContainerDestroyed(ident string) {}
|
||||||
|
|
||||||
func (n *Nameserver) ContainerDied(ident string) {
|
func (n *Nameserver) ContainerDied(ident string) {
|
||||||
n.Lock()
|
n.Lock()
|
||||||
@@ -133,9 +134,7 @@ func (n *Nameserver) ContainerDied(ident string) {
|
|||||||
return false
|
return false
|
||||||
})
|
})
|
||||||
n.Unlock()
|
n.Unlock()
|
||||||
if err := n.broadcastEntries(entries...); err != nil {
|
n.broadcastEntries(entries...)
|
||||||
n.errorf("failed to broadcast container %s death: %v", ident, err)
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
func (n *Nameserver) PeerGone(peer mesh.PeerName) {
|
func (n *Nameserver) PeerGone(peer mesh.PeerName) {
|
||||||
@@ -147,7 +146,7 @@ func (n *Nameserver) PeerGone(peer mesh.PeerName) {
|
|||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
func (n *Nameserver) Delete(hostname, containerid, ipStr string, ip address.Address) error {
|
func (n *Nameserver) Delete(hostname, containerid, ipStr string, ip address.Address) {
|
||||||
n.Lock()
|
n.Lock()
|
||||||
n.infof("tombstoning hostname=%s, container=%s, ip=%s", hostname, containerid, ipStr)
|
n.infof("tombstoning hostname=%s, container=%s, ip=%s", hostname, containerid, ipStr)
|
||||||
entries := n.entries.tombstone(n.ourName, func(e *Entry) bool {
|
entries := n.entries.tombstone(n.ourName, func(e *Entry) bool {
|
||||||
@@ -167,7 +166,7 @@ func (n *Nameserver) Delete(hostname, containerid, ipStr string, ip address.Addr
|
|||||||
return true
|
return true
|
||||||
})
|
})
|
||||||
n.Unlock()
|
n.Unlock()
|
||||||
return n.broadcastEntries(entries...)
|
n.broadcastEntries(entries...)
|
||||||
}
|
}
|
||||||
|
|
||||||
func (n *Nameserver) deleteTombstones() {
|
func (n *Nameserver) deleteTombstones() {
|
||||||
@@ -203,14 +202,43 @@ func (n *Nameserver) receiveGossip(msg []byte) (mesh.GossipData, mesh.GossipData
|
|||||||
return nil, nil, fmt.Errorf("clock skew of %d detected", delta)
|
return nil, nil, fmt.Errorf("clock skew of %d detected", delta)
|
||||||
}
|
}
|
||||||
|
|
||||||
n.Lock()
|
// Filter to remove entries from unknown peers, done before we take
|
||||||
defer n.Unlock()
|
// the nameserver lock, so we don't have to worry what isKnownPeer locks.
|
||||||
|
|
||||||
gossip.Entries.filter(func(e *Entry) bool {
|
gossip.Entries.filter(func(e *Entry) bool {
|
||||||
return n.isKnownPeer(e.Origin)
|
return n.isKnownPeer(e.Origin)
|
||||||
})
|
})
|
||||||
|
|
||||||
|
var overriddenEntries []Entry
|
||||||
|
n.Lock()
|
||||||
|
|
||||||
|
// Check entries claiming to originate from us against our current data
|
||||||
|
gossip.Entries.filter(func(e *Entry) bool {
|
||||||
|
if e.Origin == n.ourName {
|
||||||
|
if ourEntry, ok := n.entries.findEqual(e); ok {
|
||||||
|
if ourEntry.Version < e.Version ||
|
||||||
|
(ourEntry.Version == e.Version && ourEntry.Tombstone != e.Tombstone) {
|
||||||
|
// Take our version of the data, but make the version higher than the incoming
|
||||||
|
nextVersion := e.Version + 1
|
||||||
|
*e = *ourEntry
|
||||||
|
e.Version = nextVersion
|
||||||
|
overriddenEntries = append(overriddenEntries, *e)
|
||||||
|
}
|
||||||
|
} else { // We have no entry matching the one that came in with us as Origin
|
||||||
|
if e.tombstone() {
|
||||||
|
overriddenEntries = append(overriddenEntries, *e)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return true
|
||||||
|
})
|
||||||
|
|
||||||
newEntries := n.entries.merge(gossip.Entries)
|
newEntries := n.entries.merge(gossip.Entries)
|
||||||
|
n.Unlock() // unlock before attempting to broadcast
|
||||||
|
|
||||||
|
// Note that all overriddenEntries have been merged into our entries, either
|
||||||
|
// because we forced the version higher or because they were missing before.
|
||||||
|
n.broadcastEntries(overriddenEntries...)
|
||||||
|
|
||||||
if len(newEntries) > 0 {
|
if len(newEntries) > 0 {
|
||||||
return &GossipData{Entries: newEntries, Timestamp: now()}, &gossip, nil
|
return &GossipData{Entries: newEntries, Timestamp: now()}, &gossip, nil
|
||||||
}
|
}
|
||||||
@@ -231,12 +259,17 @@ func (n *Nameserver) OnGossipBroadcast(_ mesh.PeerName, msg []byte) (mesh.Gossip
|
|||||||
return entries, err
|
return entries, err
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Logging
|
||||||
|
|
||||||
func (n *Nameserver) infof(fmt string, args ...interface{}) {
|
func (n *Nameserver) infof(fmt string, args ...interface{}) {
|
||||||
Log.Infof("[nameserver %s] "+fmt, append([]interface{}{n.ourName}, args...)...)
|
n.logf(common.Log.Infof, fmt, args...)
|
||||||
}
|
}
|
||||||
func (n *Nameserver) debugf(fmt string, args ...interface{}) {
|
func (n *Nameserver) debugf(fmt string, args ...interface{}) {
|
||||||
Log.Debugf("[nameserver %s] "+fmt, append([]interface{}{n.ourName}, args...)...)
|
n.logf(common.Log.Debugf, fmt, args...)
|
||||||
}
|
}
|
||||||
func (n *Nameserver) errorf(fmt string, args ...interface{}) {
|
func (n *Nameserver) errorf(fmt string, args ...interface{}) {
|
||||||
Log.Errorf("[nameserver %s] "+fmt, append([]interface{}{n.ourName}, args...)...)
|
n.logf(common.Log.Errorf, fmt, args...)
|
||||||
|
}
|
||||||
|
func (n *Nameserver) logf(f func(string, ...interface{}), fmt string, args ...interface{}) {
|
||||||
|
f("[nameserver %s] "+fmt, append([]interface{}{n.ourName}, args...)...)
|
||||||
}
|
}
|
||||||
@@ -10,8 +10,8 @@ import (
|
|||||||
"time"
|
"time"
|
||||||
|
|
||||||
"github.com/stretchr/testify/require"
|
"github.com/stretchr/testify/require"
|
||||||
|
"github.com/weaveworks/mesh"
|
||||||
|
|
||||||
"github.com/weaveworks/weave/mesh"
|
|
||||||
"github.com/weaveworks/weave/net/address"
|
"github.com/weaveworks/weave/net/address"
|
||||||
"github.com/weaveworks/weave/testing/gossip"
|
"github.com/weaveworks/weave/testing/gossip"
|
||||||
)
|
)
|
||||||
@@ -117,7 +117,7 @@ func TestNameservers(t *testing.T) {
|
|||||||
mapping := mapping{hostname, []pair{{nameserver.ourName, addr}}}
|
mapping := mapping{hostname, []pair{{nameserver.ourName, addr}}}
|
||||||
mappings = append(mappings, mapping)
|
mappings = append(mappings, mapping)
|
||||||
|
|
||||||
require.Nil(t, nameserver.AddEntry(hostname, "", nameserver.ourName, addr))
|
nameserver.AddEntry(hostname, "", nameserver.ourName, addr)
|
||||||
check(nameserver, mapping)
|
check(nameserver, mapping)
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -132,7 +132,7 @@ func TestNameservers(t *testing.T) {
|
|||||||
mapping.addrs = append(mapping.addrs, pair{nameserver.ourName, addr})
|
mapping.addrs = append(mapping.addrs, pair{nameserver.ourName, addr})
|
||||||
mappings[i] = mapping
|
mappings[i] = mapping
|
||||||
|
|
||||||
require.Nil(t, nameserver.AddEntry(mapping.hostname, "", nameserver.ourName, addr))
|
nameserver.AddEntry(mapping.hostname, "", nameserver.ourName, addr)
|
||||||
check(nameserver, mapping)
|
check(nameserver, mapping)
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -157,7 +157,7 @@ func TestNameservers(t *testing.T) {
|
|||||||
mappings[i] = mapping
|
mappings[i] = mapping
|
||||||
nameserver := nameserversByName[pair.origin]
|
nameserver := nameserversByName[pair.origin]
|
||||||
|
|
||||||
require.Nil(t, nameserver.Delete(mapping.hostname, "*", pair.addr.String(), pair.addr))
|
nameserver.Delete(mapping.hostname, "*", pair.addr.String(), pair.addr)
|
||||||
check(nameserver, mapping)
|
check(nameserver, mapping)
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -223,15 +223,13 @@ func TestContainerAndPeerDeath(t *testing.T) {
|
|||||||
require.Nil(t, err)
|
require.Nil(t, err)
|
||||||
nameserver := makeNameserver(peername)
|
nameserver := makeNameserver(peername)
|
||||||
|
|
||||||
err = nameserver.AddEntry("hostname", "containerid", peername, address.Address(0))
|
nameserver.AddEntry("hostname", "containerid", peername, address.Address(0))
|
||||||
require.Nil(t, err)
|
|
||||||
require.Equal(t, []address.Address{0}, nameserver.Lookup("hostname"))
|
require.Equal(t, []address.Address{0}, nameserver.Lookup("hostname"))
|
||||||
|
|
||||||
nameserver.ContainerDied("containerid")
|
nameserver.ContainerDied("containerid")
|
||||||
require.Equal(t, []address.Address{}, nameserver.Lookup("hostname"))
|
require.Equal(t, []address.Address{}, nameserver.Lookup("hostname"))
|
||||||
|
|
||||||
err = nameserver.AddEntry("hostname", "containerid", peername, address.Address(0))
|
nameserver.AddEntry("hostname", "containerid", peername, address.Address(0))
|
||||||
require.Nil(t, err)
|
|
||||||
require.Equal(t, []address.Address{0}, nameserver.Lookup("hostname"))
|
require.Equal(t, []address.Address{0}, nameserver.Lookup("hostname"))
|
||||||
|
|
||||||
nameserver.PeerGone(peername)
|
nameserver.PeerGone(peername)
|
||||||
@@ -247,15 +245,13 @@ func TestTombstoneDeletion(t *testing.T) {
|
|||||||
require.Nil(t, err)
|
require.Nil(t, err)
|
||||||
nameserver := makeNameserver(peername)
|
nameserver := makeNameserver(peername)
|
||||||
|
|
||||||
err = nameserver.AddEntry("hostname", "containerid", peername, address.Address(0))
|
nameserver.AddEntry("hostname", "containerid", peername, address.Address(0))
|
||||||
require.Nil(t, err)
|
|
||||||
require.Equal(t, []address.Address{0}, nameserver.Lookup("hostname"))
|
require.Equal(t, []address.Address{0}, nameserver.Lookup("hostname"))
|
||||||
|
|
||||||
nameserver.deleteTombstones()
|
nameserver.deleteTombstones()
|
||||||
require.Equal(t, []address.Address{0}, nameserver.Lookup("hostname"))
|
require.Equal(t, []address.Address{0}, nameserver.Lookup("hostname"))
|
||||||
|
|
||||||
err = nameserver.Delete("hostname", "containerid", "", address.Address(0))
|
nameserver.Delete("hostname", "containerid", "", address.Address(0))
|
||||||
require.Nil(t, err)
|
|
||||||
require.Equal(t, []address.Address{}, nameserver.Lookup("hostname"))
|
require.Equal(t, []address.Address{}, nameserver.Lookup("hostname"))
|
||||||
require.Equal(t, l(Entries{Entry{
|
require.Equal(t, l(Entries{Entry{
|
||||||
ContainerID: "containerid",
|
ContainerID: "containerid",
|
||||||
|
|||||||
+25
-10
@@ -10,6 +10,7 @@ import (
|
|||||||
// Using 32-bit integer to represent IPv4 address
|
// Using 32-bit integer to represent IPv4 address
|
||||||
type Address uint32
|
type Address uint32
|
||||||
type Offset uint32
|
type Offset uint32
|
||||||
|
type Count uint32
|
||||||
|
|
||||||
type Range struct {
|
type Range struct {
|
||||||
Start, End Address // [Start, End); Start <= End
|
Start, End Address // [Start, End); Start <= End
|
||||||
@@ -18,7 +19,7 @@ type Range struct {
|
|||||||
func NewRange(start Address, size Offset) Range {
|
func NewRange(start Address, size Offset) Range {
|
||||||
return Range{Start: start, End: Add(start, size)}
|
return Range{Start: start, End: Add(start, size)}
|
||||||
}
|
}
|
||||||
func (r Range) Size() Offset { return Subtract(r.End, r.Start) }
|
func (r Range) Size() Count { return Length(r.End, r.Start) }
|
||||||
func (r Range) String() string { return fmt.Sprintf("%s-%s", r.Start, r.End-1) }
|
func (r Range) String() string { return fmt.Sprintf("%s-%s", r.Start, r.End-1) }
|
||||||
func (r Range) Overlaps(or Range) bool { return !(r.Start >= or.End || r.End <= or.Start) }
|
func (r Range) Overlaps(or Range) bool { return !(r.Start >= or.End || r.End <= or.Start) }
|
||||||
func (r Range) Contains(addr Address) bool { return addr >= r.Start && addr < r.End }
|
func (r Range) Contains(addr Address) bool { return addr >= r.Start && addr < r.End }
|
||||||
@@ -31,11 +32,15 @@ func (r Range) AsCIDRString() string {
|
|||||||
}
|
}
|
||||||
prefixLen--
|
prefixLen--
|
||||||
}
|
}
|
||||||
return CIDR{Start: r.Start, PrefixLen: prefixLen}.String()
|
return CIDR{Addr: r.Start, PrefixLen: prefixLen}.String()
|
||||||
|
}
|
||||||
|
|
||||||
|
func MakeCIDR(subnet CIDR, addr Address) CIDR {
|
||||||
|
return CIDR{Addr: addr, PrefixLen: subnet.PrefixLen}
|
||||||
}
|
}
|
||||||
|
|
||||||
type CIDR struct {
|
type CIDR struct {
|
||||||
Start Address
|
Addr Address
|
||||||
PrefixLen int
|
PrefixLen int
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -46,29 +51,34 @@ func ParseIP(s string) (Address, error) {
|
|||||||
return 0, &net.ParseError{Type: "IP Address", Text: s}
|
return 0, &net.ParseError{Type: "IP Address", Text: s}
|
||||||
}
|
}
|
||||||
|
|
||||||
func ParseCIDR(s string) (Address, CIDR, error) {
|
func ParseCIDR(s string) (CIDR, error) {
|
||||||
if ip, ipnet, err := net.ParseCIDR(s); err != nil {
|
if ip, ipnet, err := net.ParseCIDR(s); err != nil {
|
||||||
return 0, CIDR{}, err
|
return CIDR{}, err
|
||||||
} else if ipnet.IP.To4() == nil {
|
} else if ipnet.IP.To4() == nil {
|
||||||
return 0, CIDR{}, &net.ParseError{Type: "Non-IPv4 address not supported", Text: s}
|
return CIDR{}, &net.ParseError{Type: "Non-IPv4 address not supported", Text: s}
|
||||||
} else {
|
} else {
|
||||||
prefixLen, _ := ipnet.Mask.Size()
|
prefixLen, _ := ipnet.Mask.Size()
|
||||||
return FromIP4(ip), CIDR{Start: FromIP4(ipnet.IP), PrefixLen: prefixLen}, nil
|
return CIDR{Addr: FromIP4(ip), PrefixLen: prefixLen}, nil
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func (cidr CIDR) IsSubnet() bool {
|
||||||
|
mask := cidr.Size() - 1
|
||||||
|
return Offset(cidr.Addr)&mask == 0
|
||||||
|
}
|
||||||
|
|
||||||
func (cidr CIDR) Size() Offset { return 1 << uint(32-cidr.PrefixLen) }
|
func (cidr CIDR) Size() Offset { return 1 << uint(32-cidr.PrefixLen) }
|
||||||
|
|
||||||
func (cidr CIDR) Range() Range {
|
func (cidr CIDR) Range() Range {
|
||||||
return NewRange(cidr.Start, cidr.Size())
|
return NewRange(cidr.Addr, cidr.Size())
|
||||||
}
|
}
|
||||||
func (cidr CIDR) HostRange() Range {
|
func (cidr CIDR) HostRange() Range {
|
||||||
// Respect RFC1122 exclusions of first and last addresses
|
// Respect RFC1122 exclusions of first and last addresses
|
||||||
return NewRange(cidr.Start+1, cidr.Size()-2)
|
return NewRange(cidr.Addr+1, cidr.Size()-2)
|
||||||
}
|
}
|
||||||
|
|
||||||
func (cidr CIDR) String() string {
|
func (cidr CIDR) String() string {
|
||||||
return fmt.Sprintf("%s/%d", cidr.Start.String(), cidr.PrefixLen)
|
return fmt.Sprintf("%s/%d", cidr.Addr.String(), cidr.PrefixLen)
|
||||||
}
|
}
|
||||||
|
|
||||||
// FromIP4 converts an ipv4 address to our integer address type
|
// FromIP4 converts an ipv4 address to our integer address type
|
||||||
@@ -107,6 +117,11 @@ func Subtract(a, b Address) Offset {
|
|||||||
return Offset(a - b)
|
return Offset(a - b)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func Length(a, b Address) Count {
|
||||||
|
common.Assert(a >= b)
|
||||||
|
return Count(a - b)
|
||||||
|
}
|
||||||
|
|
||||||
func Min(a, b Offset) Offset {
|
func Min(a, b Offset) Offset {
|
||||||
if a > b {
|
if a > b {
|
||||||
return b
|
return b
|
||||||
|
|||||||
@@ -19,9 +19,10 @@ func EnsureInterface(ifaceName string) (*net.Interface, error) {
|
|||||||
|
|
||||||
func ensureInterface(ifaceName string) (*net.Interface, error) {
|
func ensureInterface(ifaceName string) (*net.Interface, error) {
|
||||||
ch := make(chan netlink.LinkUpdate)
|
ch := make(chan netlink.LinkUpdate)
|
||||||
done := make(chan struct{})
|
// NB: We do not supply (and eventually close) a 'done' channel
|
||||||
defer close(done)
|
// here since that can cause incorrect file descriptor
|
||||||
if err := netlink.LinkSubscribe(ch, done); err != nil {
|
// re-usage. See https://github.com/weaveworks/weave/issues/2120
|
||||||
|
if err := netlink.LinkSubscribe(ch, nil); err != nil {
|
||||||
return nil, err
|
return nil, err
|
||||||
}
|
}
|
||||||
// check for currently-existing interface after subscribing, to avoid race
|
// check for currently-existing interface after subscribing, to avoid race
|
||||||
@@ -46,9 +47,7 @@ func EnsureInterfaceAndMcastRoute(ifaceName string) (*net.Interface, error) {
|
|||||||
return nil, err
|
return nil, err
|
||||||
}
|
}
|
||||||
ch := make(chan netlink.RouteUpdate)
|
ch := make(chan netlink.RouteUpdate)
|
||||||
done := make(chan struct{})
|
if err := netlink.RouteSubscribe(ch, nil); err != nil {
|
||||||
defer close(done)
|
|
||||||
if err := netlink.RouteSubscribe(ch, done); err != nil {
|
|
||||||
return nil, err
|
return nil, err
|
||||||
}
|
}
|
||||||
dest := net.IPv4(224, 0, 0, 0)
|
dest := net.IPv4(224, 0, 0, 0)
|
||||||
|
|||||||
@@ -0,0 +1,18 @@
|
|||||||
|
package net
|
||||||
|
|
||||||
|
import (
|
||||||
|
"fmt"
|
||||||
|
"net"
|
||||||
|
"os"
|
||||||
|
)
|
||||||
|
|
||||||
|
func ListenUnixSocket(pathname string) (net.Listener, error) {
|
||||||
|
if err := os.Remove(pathname); err != nil && !os.IsNotExist(err) {
|
||||||
|
return nil, fmt.Errorf("Error removing existing unix socket: %s", err)
|
||||||
|
}
|
||||||
|
listener, err := net.Listen("unix", pathname)
|
||||||
|
if err != nil {
|
||||||
|
return nil, fmt.Errorf("ListenUnixSocket failed: %s", err)
|
||||||
|
}
|
||||||
|
return listener, nil
|
||||||
|
}
|
||||||
+10
-5
@@ -1,9 +1,14 @@
|
|||||||
# Weave network driver extension for Docker
|
# Weave network driver extension for Docker and Kubernetes
|
||||||
|
|
||||||
A [plugin](http://docs.docker.com/engine/extend/plugin_api/) to
|
This directory implements both a
|
||||||
integrate [weave Net](http://weave.works/net/) with Docker.
|
[Docker plugin](http://docs.docker.com/engine/extend/plugin_api/) to
|
||||||
|
integrate [Weave Net](http://weave.works/net/) with Docker, and a
|
||||||
|
[Container Network Interface (CNI) plugin](https://github.com/appc/cni#cni---the-container-network-interface),
|
||||||
|
to integrate Weave Net with [Kubernetes](http://kubernetes.io/).
|
||||||
|
|
||||||
The plugin runs automatically when you `weave launch`, provided your
|
The Docker plugin runs automatically when you `weave launch`, provided your
|
||||||
Docker daemon is version 1.9 or newer.
|
Docker daemon is version 1.9 or newer.
|
||||||
|
|
||||||
More detail [here](http://docs.weave.works/weave/latest_release/plugin.html).
|
More detail on the Docker plugin [here](https://www.weave.works/docs/net/latest/plugin/).
|
||||||
|
|
||||||
|
More detail on the CNI plugin [here](https://www.weave.works/docs/net/latest/cni-plugin/).
|
||||||
@@ -0,0 +1,80 @@
|
|||||||
|
package ipamplugin
|
||||||
|
|
||||||
|
import (
|
||||||
|
"encoding/json"
|
||||||
|
"fmt"
|
||||||
|
"net"
|
||||||
|
|
||||||
|
"github.com/appc/cni/pkg/skel"
|
||||||
|
"github.com/appc/cni/pkg/types"
|
||||||
|
)
|
||||||
|
|
||||||
|
func (i *Ipam) CmdAdd(args *skel.CmdArgs) error {
|
||||||
|
result, err := i.Allocate(args)
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
return result.Print()
|
||||||
|
}
|
||||||
|
|
||||||
|
func (i *Ipam) Allocate(args *skel.CmdArgs) (*types.Result, error) {
|
||||||
|
// extract the things we care about
|
||||||
|
conf, err := loadIPAMConf(args.StdinData)
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
if conf == nil {
|
||||||
|
conf = &ipamConf{}
|
||||||
|
}
|
||||||
|
containerID := args.ContainerID
|
||||||
|
if containerID == "" {
|
||||||
|
return nil, fmt.Errorf("Weave CNI Allocate: blank container name")
|
||||||
|
}
|
||||||
|
var ipnet *net.IPNet
|
||||||
|
|
||||||
|
if conf.Subnet == "" {
|
||||||
|
ipnet, err = i.weave.AllocateIP(containerID)
|
||||||
|
} else {
|
||||||
|
var subnet *net.IPNet
|
||||||
|
subnet, err = types.ParseCIDR(conf.Subnet)
|
||||||
|
if err != nil {
|
||||||
|
return nil, fmt.Errorf("subnet given in config, but not parseable: %s", err)
|
||||||
|
}
|
||||||
|
ipnet, err = i.weave.AllocateIPInSubnet(containerID, subnet)
|
||||||
|
}
|
||||||
|
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
result := &types.Result{
|
||||||
|
IP4: &types.IPConfig{
|
||||||
|
IP: *ipnet,
|
||||||
|
Gateway: conf.Gateway,
|
||||||
|
Routes: conf.Routes,
|
||||||
|
},
|
||||||
|
}
|
||||||
|
return result, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func (i *Ipam) CmdDel(args *skel.CmdArgs) error {
|
||||||
|
return i.Release(args)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (i *Ipam) Release(args *skel.CmdArgs) error {
|
||||||
|
return i.weave.ReleaseIPsFor(args.ContainerID)
|
||||||
|
}
|
||||||
|
|
||||||
|
type ipamConf struct {
|
||||||
|
Subnet string `json:"subnet,omitempty"`
|
||||||
|
Gateway net.IP `json:"gateway,omitempty"`
|
||||||
|
Routes []types.Route `json:"routes"`
|
||||||
|
}
|
||||||
|
|
||||||
|
type netConf struct {
|
||||||
|
IPAM *ipamConf `json:"ipam"`
|
||||||
|
}
|
||||||
|
|
||||||
|
func loadIPAMConf(stdinData []byte) (*ipamConf, error) {
|
||||||
|
var conf netConf
|
||||||
|
return conf.IPAM, json.Unmarshal(stdinData, &conf)
|
||||||
|
}
|
||||||
+82
-43
@@ -3,78 +3,117 @@ package ipamplugin
|
|||||||
import (
|
import (
|
||||||
"fmt"
|
"fmt"
|
||||||
"net"
|
"net"
|
||||||
|
"strings"
|
||||||
|
|
||||||
"github.com/docker/libnetwork/discoverapi"
|
"github.com/docker/libnetwork/discoverapi"
|
||||||
"github.com/docker/libnetwork/ipamapi"
|
|
||||||
"github.com/docker/libnetwork/netlabel"
|
"github.com/docker/libnetwork/netlabel"
|
||||||
godocker "github.com/fsouza/go-dockerclient"
|
|
||||||
"github.com/weaveworks/weave/api"
|
"github.com/weaveworks/weave/api"
|
||||||
. "github.com/weaveworks/weave/common"
|
"github.com/weaveworks/weave/common"
|
||||||
"github.com/weaveworks/weave/common/docker"
|
|
||||||
)
|
)
|
||||||
|
|
||||||
const (
|
type Ipam struct {
|
||||||
WeaveContainer = "weave"
|
weave *api.Client
|
||||||
)
|
|
||||||
|
|
||||||
type ipam struct {
|
|
||||||
client *docker.Client
|
|
||||||
weave *api.Client
|
|
||||||
}
|
}
|
||||||
|
|
||||||
func NewIpam(client *docker.Client, version string) (ipamapi.Ipam, error) {
|
func NewIpam(weave *api.Client) *Ipam {
|
||||||
resolver := func() (string, error) {
|
return &Ipam{weave: weave}
|
||||||
addr, err := client.GetContainerIP(WeaveContainer)
|
|
||||||
if _, ok := err.(*godocker.NoSuchContainer); ok {
|
|
||||||
return "", fmt.Errorf("%s container is not present. Have you launched it?", WeaveContainer)
|
|
||||||
}
|
|
||||||
return addr, err
|
|
||||||
}
|
|
||||||
return &ipam{client: client, weave: api.NewClientWithResolver(resolver)}, nil
|
|
||||||
}
|
}
|
||||||
|
|
||||||
func (i *ipam) GetDefaultAddressSpaces() (string, string, error) {
|
func (i *Ipam) GetDefaultAddressSpaces() (string, string, error) {
|
||||||
Log.Debugln("GetDefaultAddressSpaces")
|
i.logReq("GetDefaultAddressSpaces")
|
||||||
return "weavelocal", "weaveglobal", nil
|
return "weavelocal", "weaveglobal", nil
|
||||||
}
|
}
|
||||||
|
|
||||||
func (i *ipam) RequestPool(addressSpace, pool, subPool string, options map[string]string, v6 bool) (string, *net.IPNet, map[string]string, error) {
|
func (i *Ipam) RequestPool(addressSpace, pool, subPool string, options map[string]string, v6 bool) (poolname string, subnet *net.IPNet, data map[string]string, err error) {
|
||||||
Log.Debugln("RequestPool", addressSpace, pool, subPool, options)
|
i.logReq("RequestPool", addressSpace, pool, subPool, options)
|
||||||
cidr, err := i.weave.DefaultSubnet()
|
defer func() { i.logRes("RequestPool", err, poolname, subnet, data) }()
|
||||||
Log.Debugln("RequestPool returning ", cidr, err)
|
if pool == "" {
|
||||||
if err != nil {
|
subnet, err = i.weave.DefaultSubnet()
|
||||||
return "", nil, nil, err
|
} else {
|
||||||
|
_, subnet, err = net.ParseCIDR(pool)
|
||||||
}
|
}
|
||||||
|
if err != nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
iprange := subnet
|
||||||
|
if subPool != "" {
|
||||||
|
if _, iprange, err = net.ParseCIDR(subPool); err != nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// Cunningly-constructed pool "name" which gives us what we need later
|
||||||
|
poolname = strings.Join([]string{"weave", subnet.String(), iprange.String()}, "-")
|
||||||
// Pass back a fake "gateway address"; we don't actually use it,
|
// Pass back a fake "gateway address"; we don't actually use it,
|
||||||
// so just give the network address.
|
// so just give the network address.
|
||||||
data := map[string]string{netlabel.Gateway: cidr.String()}
|
data = map[string]string{netlabel.Gateway: subnet.String()}
|
||||||
return "weavepool", cidr, data, err
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
func (i *ipam) ReleasePool(poolID string) error {
|
func (i *Ipam) ReleasePool(poolID string) error {
|
||||||
Log.Debugln("ReleasePool", poolID)
|
i.logReq("ReleasePool", poolID)
|
||||||
return nil
|
return nil
|
||||||
}
|
}
|
||||||
|
|
||||||
func (i *ipam) RequestAddress(poolID string, address net.IP, options map[string]string) (*net.IPNet, map[string]string, error) {
|
func (i *Ipam) RequestAddress(poolID string, address net.IP, options map[string]string) (ip *net.IPNet, _ map[string]string, err error) {
|
||||||
Log.Debugln("RequestAddress", poolID, address, options)
|
i.logReq("RequestAddress", poolID, address, options)
|
||||||
// Pass magic string to weave IPAM, which then stores the address under its own string
|
defer func() { i.logRes("RequestAddress", err, ip) }()
|
||||||
ip, err := i.weave.AllocateIP("_")
|
// If we pass magic string "_" to weave IPAM it stores the address under its own string
|
||||||
Log.Debugln("allocateIP returned", ip, err)
|
if poolID == "weavepool" { // old-style
|
||||||
return ip, nil, err
|
ip, err = i.weave.AllocateIP("_")
|
||||||
|
return
|
||||||
|
}
|
||||||
|
parts := strings.Split(poolID, "-")
|
||||||
|
if len(parts) != 3 || parts[0] != "weave" {
|
||||||
|
err = fmt.Errorf("Unrecognized pool ID: %s", poolID)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
var subnet, iprange *net.IPNet
|
||||||
|
if _, subnet, err = net.ParseCIDR(parts[1]); err != nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
if address != nil { // try to claim specific address requested
|
||||||
|
ip = &net.IPNet{IP: address, Mask: subnet.Mask}
|
||||||
|
if err = i.weave.ClaimIP("_", ip); err != nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
if _, iprange, err = net.ParseCIDR(parts[2]); err != nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
// We are lying slightly to IPAM here: the range is not a subnet
|
||||||
|
if ip, err = i.weave.AllocateIPInSubnet("_", iprange); err != nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
ip.Mask = subnet.Mask // fix up the subnet we lied about
|
||||||
|
}
|
||||||
|
return
|
||||||
}
|
}
|
||||||
|
|
||||||
func (i *ipam) ReleaseAddress(poolID string, address net.IP) error {
|
func (i *Ipam) ReleaseAddress(poolID string, address net.IP) error {
|
||||||
Log.Debugln("ReleaseAddress", poolID, address)
|
i.logReq("ReleaseAddress", poolID, address)
|
||||||
return i.weave.ReleaseIP(address.String())
|
return i.weave.ReleaseIPsFor(address.String())
|
||||||
}
|
}
|
||||||
|
|
||||||
// Functions required by ipamapi "contract" but not actually used.
|
// Functions required by ipamapi "contract" but not actually used.
|
||||||
|
|
||||||
func (i *ipam) DiscoverNew(discoverapi.DiscoveryType, interface{}) error {
|
func (i *Ipam) DiscoverNew(discoverapi.DiscoveryType, interface{}) error {
|
||||||
return nil
|
return nil
|
||||||
}
|
}
|
||||||
|
|
||||||
func (i *ipam) DiscoverDelete(discoverapi.DiscoveryType, interface{}) error {
|
func (i *Ipam) DiscoverDelete(discoverapi.DiscoveryType, interface{}) error {
|
||||||
return nil
|
return nil
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// logging
|
||||||
|
|
||||||
|
func (i *Ipam) logReq(fun string, args ...interface{}) {
|
||||||
|
common.Log.Infoln(append([]interface{}{fmt.Sprintf("[ipam] %s", fun)}, args...)...)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (i *Ipam) logRes(fun string, err error, args ...interface{}) {
|
||||||
|
if err == nil {
|
||||||
|
common.Log.Debugln(append([]interface{}{fmt.Sprintf("[ipam] %s result", fun)}, args...)...)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
common.Log.Errorf("[ipam] %s: %s", fun, err)
|
||||||
|
}
|
||||||
@@ -0,0 +1,240 @@
|
|||||||
|
package plugin
|
||||||
|
|
||||||
|
import (
|
||||||
|
"crypto/rand"
|
||||||
|
"encoding/json"
|
||||||
|
"fmt"
|
||||||
|
"net"
|
||||||
|
"os"
|
||||||
|
|
||||||
|
"github.com/appc/cni/pkg/ipam"
|
||||||
|
"github.com/appc/cni/pkg/skel"
|
||||||
|
"github.com/appc/cni/pkg/types"
|
||||||
|
"github.com/vishvananda/netlink"
|
||||||
|
"github.com/vishvananda/netns"
|
||||||
|
weaveapi "github.com/weaveworks/weave/api"
|
||||||
|
"github.com/weaveworks/weave/common"
|
||||||
|
ipamplugin "github.com/weaveworks/weave/plugin/ipam"
|
||||||
|
)
|
||||||
|
|
||||||
|
var (
|
||||||
|
zeroNetwork = net.IPNet{IP: net.IPv4zero, Mask: net.IPv4Mask(0, 0, 0, 0)}
|
||||||
|
mask32 = net.IPv4Mask(0xff, 0xff, 0xff, 0xff)
|
||||||
|
)
|
||||||
|
|
||||||
|
type CNIPlugin struct {
|
||||||
|
weave *weaveapi.Client
|
||||||
|
}
|
||||||
|
|
||||||
|
func NewCNIPlugin(weave *weaveapi.Client) *CNIPlugin {
|
||||||
|
return &CNIPlugin{weave: weave}
|
||||||
|
}
|
||||||
|
|
||||||
|
func loadNetConf(bytes []byte) (*NetConf, error) {
|
||||||
|
n := &NetConf{
|
||||||
|
BrName: "weave",
|
||||||
|
}
|
||||||
|
if err := json.Unmarshal(bytes, n); err != nil {
|
||||||
|
return nil, fmt.Errorf("failed to load netconf: %v", err)
|
||||||
|
}
|
||||||
|
return n, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func (c *CNIPlugin) CmdAdd(args *skel.CmdArgs) error {
|
||||||
|
conf, err := loadNetConf(args.StdinData)
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
if conf.IsGW {
|
||||||
|
return fmt.Errorf("Gateway functionality not supported")
|
||||||
|
}
|
||||||
|
if conf.IPMasq {
|
||||||
|
return fmt.Errorf("IP Masquerading functionality not supported")
|
||||||
|
}
|
||||||
|
|
||||||
|
ns, err := netns.GetFromPath(args.Netns)
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
defer ns.Close()
|
||||||
|
|
||||||
|
id := args.ContainerID
|
||||||
|
if len(id) < 5 {
|
||||||
|
data := make([]byte, 5)
|
||||||
|
_, err := rand.Reader.Read(data)
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
id = fmt.Sprintf("%x", data)
|
||||||
|
}
|
||||||
|
|
||||||
|
local, err := createAndAttach(id, conf.BrName, conf.MTU)
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
cleanup := func(err error) error {
|
||||||
|
netlink.LinkDel(local)
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
guest, err := netlink.LinkByName(local.PeerName)
|
||||||
|
if err != nil {
|
||||||
|
return cleanup(err)
|
||||||
|
}
|
||||||
|
if err = netlink.LinkSetNsFd(guest, int(ns)); err != nil {
|
||||||
|
return cleanup(fmt.Errorf("failed to move veth to container netns: %s", err))
|
||||||
|
}
|
||||||
|
|
||||||
|
if err := netlink.LinkSetUp(local); err != nil {
|
||||||
|
return cleanup(fmt.Errorf("unable to bring veth up: %s", err))
|
||||||
|
}
|
||||||
|
|
||||||
|
var result *types.Result
|
||||||
|
// Default IPAM is Weave's own
|
||||||
|
if conf.IPAM.Type == "" {
|
||||||
|
result, err = ipamplugin.NewIpam(c.weave).Allocate(args)
|
||||||
|
} else {
|
||||||
|
result, err = ipam.ExecAdd(conf.IPAM.Type, args.StdinData)
|
||||||
|
}
|
||||||
|
if err != nil {
|
||||||
|
return cleanup(fmt.Errorf("unable to allocate IP address: %s", err))
|
||||||
|
}
|
||||||
|
if result.IP4 == nil {
|
||||||
|
return cleanup(fmt.Errorf("IPAM plugin failed to allocate IP address"))
|
||||||
|
}
|
||||||
|
|
||||||
|
// If config says nothing about routes or gateway, default one will be via the bridge
|
||||||
|
if result.IP4.Routes == nil && result.IP4.Gateway == nil {
|
||||||
|
bridgeIP, err := findBridgeIP(conf.BrName, result.IP4.IP)
|
||||||
|
if err != nil {
|
||||||
|
return cleanup(err)
|
||||||
|
}
|
||||||
|
result.IP4.Gateway = bridgeIP
|
||||||
|
}
|
||||||
|
|
||||||
|
err = common.WithNetNS(ns, func() error {
|
||||||
|
return setupGuestIP4(local.PeerName, args.IfName, result.IP4.IP, result.IP4.Gateway, result.IP4.Routes)
|
||||||
|
})
|
||||||
|
if err != nil {
|
||||||
|
return cleanup(fmt.Errorf("error setting up interface: %s", err))
|
||||||
|
}
|
||||||
|
|
||||||
|
result.DNS = conf.DNS
|
||||||
|
return result.Print()
|
||||||
|
}
|
||||||
|
|
||||||
|
func setupGuestIP4(origName, name string, ipnet net.IPNet, gw net.IP, routes []types.Route) error {
|
||||||
|
guest, err := netlink.LinkByName(origName)
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
if err = netlink.LinkSetName(guest, name); err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
if err = netlink.LinkSetUp(guest); err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
if err = common.ConfigureARPCache(name); err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
if routes == nil { // If config says nothing about routes, add a default one
|
||||||
|
if !ipnet.Contains(gw) {
|
||||||
|
// The bridge IP is not on the same subnet; add a specific route to it
|
||||||
|
gw32 := &net.IPNet{IP: gw, Mask: mask32}
|
||||||
|
if err = addRoute(guest, netlink.SCOPE_LINK, gw32, nil); err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
}
|
||||||
|
routes = []types.Route{{Dst: zeroNetwork}}
|
||||||
|
}
|
||||||
|
if err = netlink.AddrAdd(guest, &netlink.Addr{IPNet: &ipnet}); err != nil {
|
||||||
|
return fmt.Errorf("failed to add IP address to %q: %v", name, err)
|
||||||
|
}
|
||||||
|
for _, r := range routes {
|
||||||
|
if r.GW != nil {
|
||||||
|
err = addRoute(guest, netlink.SCOPE_UNIVERSE, &r.Dst, r.GW)
|
||||||
|
} else {
|
||||||
|
err = addRoute(guest, netlink.SCOPE_UNIVERSE, &r.Dst, gw)
|
||||||
|
}
|
||||||
|
if err != nil {
|
||||||
|
return fmt.Errorf("failed to add route '%v via %v dev %v': %v", r.Dst, gw, name, err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func addRoute(link netlink.Link, scope netlink.Scope, dst *net.IPNet, gw net.IP) error {
|
||||||
|
err := netlink.RouteAdd(&netlink.Route{
|
||||||
|
LinkIndex: link.Attrs().Index,
|
||||||
|
Scope: scope,
|
||||||
|
Dst: dst,
|
||||||
|
Gw: gw,
|
||||||
|
})
|
||||||
|
if os.IsExist(err) { // squash duplicate route errors
|
||||||
|
err = nil
|
||||||
|
}
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
func findBridgeIP(bridgeName string, subnet net.IPNet) (net.IP, error) {
|
||||||
|
netdevs, err := common.GetBridgeNetDev(bridgeName)
|
||||||
|
if err != nil {
|
||||||
|
return nil, fmt.Errorf("Failed to get netdev for %q bridge: %s", bridgeName, err)
|
||||||
|
}
|
||||||
|
if len(netdevs) == 0 {
|
||||||
|
return nil, fmt.Errorf("Could not find %q bridge", bridgeName)
|
||||||
|
}
|
||||||
|
if len(netdevs[0].CIDRs) == 0 {
|
||||||
|
return nil, fmt.Errorf("Bridge %q has no IP addresses", bridgeName)
|
||||||
|
}
|
||||||
|
for _, cidr := range netdevs[0].CIDRs {
|
||||||
|
if subnet.Contains(cidr.IP) {
|
||||||
|
return cidr.IP, nil
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// None in the required subnet; just return the first one
|
||||||
|
return netdevs[0].CIDRs[0].IP, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func (c *CNIPlugin) CmdDel(args *skel.CmdArgs) error {
|
||||||
|
conf, err := loadNetConf(args.StdinData)
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
ns, err := netns.GetFromPath(args.Netns)
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
defer ns.Close()
|
||||||
|
err = common.WithNetNS(ns, func() error {
|
||||||
|
link, err := netlink.LinkByName(args.IfName)
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
return netlink.LinkDel(link)
|
||||||
|
})
|
||||||
|
if err != nil {
|
||||||
|
return fmt.Errorf("error removing interface: %s", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Default IPAM is Weave's own
|
||||||
|
if conf.IPAM.Type == "" {
|
||||||
|
err = ipamplugin.NewIpam(c.weave).Release(args)
|
||||||
|
} else {
|
||||||
|
err = ipam.ExecDel(conf.IPAM.Type, args.StdinData)
|
||||||
|
}
|
||||||
|
if err != nil {
|
||||||
|
return fmt.Errorf("unable to release IP address: %s", err)
|
||||||
|
}
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
type NetConf struct {
|
||||||
|
types.NetConf
|
||||||
|
BrName string `json:"bridge"`
|
||||||
|
IsGW bool `json:"isGateway"`
|
||||||
|
IPMasq bool `json:"ipMasq"`
|
||||||
|
MTU int `json:"mtu"`
|
||||||
|
}
|
||||||
+92
-72
@@ -7,90 +7,78 @@ import (
|
|||||||
"github.com/docker/libnetwork/drivers/remote/api"
|
"github.com/docker/libnetwork/drivers/remote/api"
|
||||||
"github.com/docker/libnetwork/types"
|
"github.com/docker/libnetwork/types"
|
||||||
|
|
||||||
. "github.com/weaveworks/weave/common"
|
"github.com/vishvananda/netlink"
|
||||||
|
weaveapi "github.com/weaveworks/weave/api"
|
||||||
|
"github.com/weaveworks/weave/common"
|
||||||
"github.com/weaveworks/weave/common/docker"
|
"github.com/weaveworks/weave/common/docker"
|
||||||
"github.com/weaveworks/weave/common/odp"
|
"github.com/weaveworks/weave/common/odp"
|
||||||
"github.com/weaveworks/weave/plugin/skel"
|
"github.com/weaveworks/weave/plugin/skel"
|
||||||
|
|
||||||
"github.com/vishvananda/netlink"
|
|
||||||
)
|
)
|
||||||
|
|
||||||
const (
|
const (
|
||||||
WeaveContainer = "weave"
|
WeaveBridge = "weave"
|
||||||
WeaveBridge = "weave"
|
|
||||||
)
|
)
|
||||||
|
|
||||||
type driver struct {
|
type driver struct {
|
||||||
version string
|
|
||||||
nameserver string
|
|
||||||
scope string
|
scope string
|
||||||
noMulticastRoute bool
|
noMulticastRoute bool
|
||||||
sync.RWMutex
|
sync.RWMutex
|
||||||
endpoints map[string]struct{}
|
endpoints map[string]struct{}
|
||||||
}
|
}
|
||||||
|
|
||||||
func New(client *docker.Client, version string, nameserver string, scope string, noMulticastRoute bool) (skel.Driver, error) {
|
func New(client *docker.Client, weave *weaveapi.Client, scope string, noMulticastRoute bool) (skel.Driver, error) {
|
||||||
driver := &driver{
|
driver := &driver{
|
||||||
nameserver: nameserver,
|
|
||||||
noMulticastRoute: noMulticastRoute,
|
noMulticastRoute: noMulticastRoute,
|
||||||
version: version,
|
|
||||||
scope: scope,
|
scope: scope,
|
||||||
endpoints: make(map[string]struct{}),
|
endpoints: make(map[string]struct{}),
|
||||||
}
|
}
|
||||||
|
|
||||||
_, err := NewWatcher(client, driver)
|
_, err := NewWatcher(client, weave, driver)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return nil, err
|
return nil, err
|
||||||
}
|
}
|
||||||
return driver, nil
|
return driver, nil
|
||||||
}
|
}
|
||||||
|
|
||||||
func errorf(format string, a ...interface{}) error {
|
|
||||||
Log.Errorf(format, a...)
|
|
||||||
return fmt.Errorf(format, a...)
|
|
||||||
}
|
|
||||||
|
|
||||||
// === protocol handlers
|
// === protocol handlers
|
||||||
|
|
||||||
func (driver *driver) GetCapabilities() (*api.GetCapabilityResponse, error) {
|
func (driver *driver) GetCapabilities() (*api.GetCapabilityResponse, error) {
|
||||||
|
driver.logReq("GetCapabilities", nil, "")
|
||||||
var caps = &api.GetCapabilityResponse{
|
var caps = &api.GetCapabilityResponse{
|
||||||
Scope: driver.scope,
|
Scope: driver.scope,
|
||||||
}
|
}
|
||||||
Log.Debugf("Get capabilities: responded with %+v", caps)
|
driver.logRes("GetCapabilities", caps)
|
||||||
return caps, nil
|
return caps, nil
|
||||||
}
|
}
|
||||||
|
|
||||||
func (driver *driver) CreateNetwork(create *api.CreateNetworkRequest) error {
|
func (driver *driver) CreateNetwork(create *api.CreateNetworkRequest) error {
|
||||||
Log.Debugf("Create network request %+v", create)
|
driver.logReq("CreateNetwork", create, create.NetworkID)
|
||||||
Log.Infof("Create network %s", create.NetworkID)
|
|
||||||
return nil
|
return nil
|
||||||
}
|
}
|
||||||
|
|
||||||
func (driver *driver) DeleteNetwork(delete *api.DeleteNetworkRequest) error {
|
func (driver *driver) DeleteNetwork(delete *api.DeleteNetworkRequest) error {
|
||||||
Log.Debugf("Delete network request: %+v", delete)
|
driver.logReq("DeleteNetwork", delete, delete.NetworkID)
|
||||||
Log.Infof("Destroy network %s", delete.NetworkID)
|
|
||||||
return nil
|
return nil
|
||||||
}
|
}
|
||||||
|
|
||||||
func (driver *driver) CreateEndpoint(create *api.CreateEndpointRequest) (*api.CreateEndpointResponse, error) {
|
func (driver *driver) CreateEndpoint(create *api.CreateEndpointRequest) (*api.CreateEndpointResponse, error) {
|
||||||
Log.Debugf("Create endpoint request %+v", create)
|
driver.logReq("CreateEndpoint", create, create.EndpointID)
|
||||||
endID := create.EndpointID
|
endID := create.EndpointID
|
||||||
|
|
||||||
if create.Interface == nil {
|
if create.Interface == nil {
|
||||||
return nil, fmt.Errorf("Not supported: creating an interface from within CreateEndpoint")
|
return nil, driver.error("CreateEndpoint", "Not supported: creating an interface from within CreateEndpoint")
|
||||||
}
|
}
|
||||||
driver.Lock()
|
driver.Lock()
|
||||||
driver.endpoints[endID] = struct{}{}
|
driver.endpoints[endID] = struct{}{}
|
||||||
driver.Unlock()
|
driver.Unlock()
|
||||||
resp := &api.CreateEndpointResponse{}
|
resp := &api.CreateEndpointResponse{}
|
||||||
|
|
||||||
Log.Infof("Create endpoint %s %+v", endID, resp)
|
driver.logRes("CreateEndpoint", resp)
|
||||||
return resp, nil
|
return resp, nil
|
||||||
}
|
}
|
||||||
|
|
||||||
func (driver *driver) DeleteEndpoint(deleteReq *api.DeleteEndpointRequest) error {
|
func (driver *driver) DeleteEndpoint(deleteReq *api.DeleteEndpointRequest) error {
|
||||||
Log.Debugf("Delete endpoint request: %+v", deleteReq)
|
driver.logReq("DeleteEndpoint", deleteReq, deleteReq.EndpointID)
|
||||||
Log.Infof("Delete endpoint %s", deleteReq.EndpointID)
|
|
||||||
driver.Lock()
|
driver.Lock()
|
||||||
delete(driver.endpoints, deleteReq.EndpointID)
|
delete(driver.endpoints, deleteReq.EndpointID)
|
||||||
driver.Unlock()
|
driver.Unlock()
|
||||||
@@ -105,47 +93,20 @@ func (driver *driver) HasEndpoint(endpointID string) bool {
|
|||||||
}
|
}
|
||||||
|
|
||||||
func (driver *driver) EndpointInfo(req *api.EndpointInfoRequest) (*api.EndpointInfoResponse, error) {
|
func (driver *driver) EndpointInfo(req *api.EndpointInfoRequest) (*api.EndpointInfoResponse, error) {
|
||||||
Log.Debugf("Endpoint info request: %+v", req)
|
driver.logReq("EndpointInfo", req, req.EndpointID)
|
||||||
Log.Infof("Endpoint info %s", req.EndpointID)
|
|
||||||
return &api.EndpointInfoResponse{Value: map[string]interface{}{}}, nil
|
return &api.EndpointInfoResponse{Value: map[string]interface{}{}}, nil
|
||||||
}
|
}
|
||||||
|
|
||||||
func (driver *driver) JoinEndpoint(j *api.JoinRequest) (*api.JoinResponse, error) {
|
func (driver *driver) JoinEndpoint(j *api.JoinRequest) (*api.JoinResponse, error) {
|
||||||
endID := j.EndpointID
|
driver.logReq("JoinEndpoint", j, fmt.Sprintf("%s:%s to %s", j.NetworkID, j.EndpointID, j.SandboxKey))
|
||||||
|
|
||||||
maybeBridge, err := netlink.LinkByName(WeaveBridge)
|
local, err := createAndAttach(j.EndpointID, WeaveBridge, 0)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return nil, errorf(`bridge "%s" not present; did you launch weave?`, WeaveBridge)
|
return nil, driver.error("JoinEndpoint", "%s", err)
|
||||||
}
|
}
|
||||||
|
|
||||||
// create and attach local name to the bridge
|
|
||||||
local := vethPair(endID[:5])
|
|
||||||
local.Attrs().MTU = maybeBridge.Attrs().MTU
|
|
||||||
if err := netlink.LinkAdd(local); err != nil {
|
|
||||||
return nil, errorf("could not create veth pair: %s", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
switch maybeBridge.(type) {
|
|
||||||
case *netlink.Bridge:
|
|
||||||
if err := netlink.LinkSetMasterByIndex(local, maybeBridge.Attrs().Index); err != nil {
|
|
||||||
return nil, errorf(`unable to set master: %s`, err)
|
|
||||||
}
|
|
||||||
case *netlink.GenericLink:
|
|
||||||
if maybeBridge.Type() != "openvswitch" {
|
|
||||||
Log.Errorf("device %s is %+v", WeaveBridge, maybeBridge)
|
|
||||||
return nil, errorf(`device "%s" is of type "%s"`, WeaveBridge, maybeBridge.Type())
|
|
||||||
}
|
|
||||||
odp.AddDatapathInterface(WeaveBridge, local.Name)
|
|
||||||
case *netlink.Device:
|
|
||||||
Log.Warnf("kernel does not report what kind of device %s is, just %+v", WeaveBridge, maybeBridge)
|
|
||||||
// Assume it's our openvswitch device, and the kernel has not been updated to report the kind.
|
|
||||||
odp.AddDatapathInterface(WeaveBridge, local.Name)
|
|
||||||
default:
|
|
||||||
Log.Errorf("device %s is %+v", WeaveBridge, maybeBridge)
|
|
||||||
return nil, errorf(`device "%s" not a bridge`, WeaveBridge)
|
|
||||||
}
|
|
||||||
if err := netlink.LinkSetUp(local); err != nil {
|
if err := netlink.LinkSetUp(local); err != nil {
|
||||||
return nil, errorf(`unable to bring veth up: %s`, err)
|
return nil, driver.error("JoinEndpoint", "unable to bring up veth %s-%s: %s", local.Name, local.PeerName, err)
|
||||||
}
|
}
|
||||||
|
|
||||||
ifname := &api.InterfaceName{
|
ifname := &api.InterfaceName{
|
||||||
@@ -156,14 +117,6 @@ func (driver *driver) JoinEndpoint(j *api.JoinRequest) (*api.JoinResponse, error
|
|||||||
response := &api.JoinResponse{
|
response := &api.JoinResponse{
|
||||||
InterfaceName: ifname,
|
InterfaceName: ifname,
|
||||||
}
|
}
|
||||||
if driver.nameserver != "" {
|
|
||||||
routeToDNS := api.StaticRoute{
|
|
||||||
Destination: driver.nameserver + "/32",
|
|
||||||
RouteType: types.CONNECTED,
|
|
||||||
NextHop: "",
|
|
||||||
}
|
|
||||||
response.StaticRoutes = []api.StaticRoute{routeToDNS}
|
|
||||||
}
|
|
||||||
if !driver.noMulticastRoute {
|
if !driver.noMulticastRoute {
|
||||||
multicastRoute := api.StaticRoute{
|
multicastRoute := api.StaticRoute{
|
||||||
Destination: "224.0.0.0/4",
|
Destination: "224.0.0.0/4",
|
||||||
@@ -171,28 +124,67 @@ func (driver *driver) JoinEndpoint(j *api.JoinRequest) (*api.JoinResponse, error
|
|||||||
}
|
}
|
||||||
response.StaticRoutes = append(response.StaticRoutes, multicastRoute)
|
response.StaticRoutes = append(response.StaticRoutes, multicastRoute)
|
||||||
}
|
}
|
||||||
Log.Infof("Join endpoint %s:%s to %s", j.NetworkID, j.EndpointID, j.SandboxKey)
|
driver.logRes("JoinEndpoint", response)
|
||||||
return response, nil
|
return response, nil
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// create and attach local name to the Weave bridge
|
||||||
|
func createAndAttach(id, bridgeName string, mtu int) (*netlink.Veth, error) {
|
||||||
|
maybeBridge, err := netlink.LinkByName(bridgeName)
|
||||||
|
if err != nil {
|
||||||
|
return nil, fmt.Errorf(`bridge "%s" not present; did you launch weave?`, bridgeName)
|
||||||
|
}
|
||||||
|
|
||||||
|
local := vethPair(id[:5])
|
||||||
|
if mtu == 0 {
|
||||||
|
local.Attrs().MTU = maybeBridge.Attrs().MTU
|
||||||
|
} else {
|
||||||
|
local.Attrs().MTU = mtu
|
||||||
|
}
|
||||||
|
if err := netlink.LinkAdd(local); err != nil {
|
||||||
|
return nil, fmt.Errorf(`could not create veth pair %s-%s: %s`, local.Name, local.PeerName, err)
|
||||||
|
}
|
||||||
|
|
||||||
|
switch maybeBridge.(type) {
|
||||||
|
case *netlink.Bridge:
|
||||||
|
if err := netlink.LinkSetMasterByIndex(local, maybeBridge.Attrs().Index); err != nil {
|
||||||
|
return nil, fmt.Errorf(`unable to set master of %s: %s`, local.Name, err)
|
||||||
|
}
|
||||||
|
case *netlink.GenericLink:
|
||||||
|
if maybeBridge.Type() != "openvswitch" {
|
||||||
|
return nil, fmt.Errorf(`device "%s" is of type "%s"`, bridgeName, maybeBridge.Type())
|
||||||
|
}
|
||||||
|
if err := odp.AddDatapathInterface(bridgeName, local.Name); err != nil {
|
||||||
|
return nil, fmt.Errorf(`failed to attach %s to device "%s": %s`, local.Name, bridgeName, err)
|
||||||
|
}
|
||||||
|
case *netlink.Device:
|
||||||
|
// Assume it's our openvswitch device, and the kernel has not been updated to report the kind.
|
||||||
|
if err := odp.AddDatapathInterface(bridgeName, local.Name); err != nil {
|
||||||
|
return nil, fmt.Errorf(`failed to attach %s to device "%s": %s`, local.Name, bridgeName, err)
|
||||||
|
}
|
||||||
|
default:
|
||||||
|
return nil, fmt.Errorf(`device "%s" is not a bridge`, bridgeName)
|
||||||
|
}
|
||||||
|
return local, nil
|
||||||
|
}
|
||||||
|
|
||||||
func (driver *driver) LeaveEndpoint(leave *api.LeaveRequest) error {
|
func (driver *driver) LeaveEndpoint(leave *api.LeaveRequest) error {
|
||||||
Log.Debugf("Leave request: %+v", leave)
|
driver.logReq("LeaveEndpoint", leave, fmt.Sprintf("%s:%s", leave.NetworkID, leave.EndpointID))
|
||||||
|
|
||||||
local := vethPair(leave.EndpointID[:5])
|
local := vethPair(leave.EndpointID[:5])
|
||||||
if err := netlink.LinkDel(local); err != nil {
|
if err := netlink.LinkDel(local); err != nil {
|
||||||
Log.Warningf("unable to delete veth on leave: %s", err)
|
driver.warn("LeaveEndpoint", "unable to delete veth: %s", err)
|
||||||
}
|
}
|
||||||
Log.Infof("Leave %s:%s", leave.NetworkID, leave.EndpointID)
|
|
||||||
return nil
|
return nil
|
||||||
}
|
}
|
||||||
|
|
||||||
func (driver *driver) DiscoverNew(disco *api.DiscoveryNotification) error {
|
func (driver *driver) DiscoverNew(disco *api.DiscoveryNotification) error {
|
||||||
Log.Debugf("Dicovery new notification: %+v", disco)
|
driver.logReq("DiscoverNew", disco, "")
|
||||||
return nil
|
return nil
|
||||||
}
|
}
|
||||||
|
|
||||||
func (driver *driver) DiscoverDelete(disco *api.DiscoveryNotification) error {
|
func (driver *driver) DiscoverDelete(disco *api.DiscoveryNotification) error {
|
||||||
Log.Debugf("Dicovery delete notification: %+v", disco)
|
driver.logReq("DiscoverDelete", disco, "")
|
||||||
return nil
|
return nil
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -204,3 +196,31 @@ func vethPair(suffix string) *netlink.Veth {
|
|||||||
PeerName: "vethwg" + suffix,
|
PeerName: "vethwg" + suffix,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// logging
|
||||||
|
|
||||||
|
func (driver *driver) logReq(fun string, req interface{}, short string) {
|
||||||
|
driver.log(common.Log.Debugf, " %+v", fun, req)
|
||||||
|
common.Log.Infof("[net] %s %s", fun, short)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (driver *driver) logRes(fun string, res interface{}) {
|
||||||
|
driver.log(common.Log.Debugf, " %+v", fun, res)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (driver *driver) warn(fun string, format string, a ...interface{}) {
|
||||||
|
driver.log(common.Log.Warnf, ": "+format, fun, a...)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (driver *driver) debug(fun string, format string, a ...interface{}) {
|
||||||
|
driver.log(common.Log.Debugf, ": "+format, fun, a...)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (driver *driver) error(fun string, format string, a ...interface{}) error {
|
||||||
|
driver.log(common.Log.Errorf, ": "+format, fun, a...)
|
||||||
|
return fmt.Errorf(format, a...)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (driver *driver) log(f func(string, ...interface{}), format string, fun string, a ...interface{}) {
|
||||||
|
f("[net] %s"+format, append([]interface{}{fun}, a...)...)
|
||||||
|
}
|
||||||
+8
-14
@@ -4,7 +4,6 @@ import (
|
|||||||
"fmt"
|
"fmt"
|
||||||
|
|
||||||
weaveapi "github.com/weaveworks/weave/api"
|
weaveapi "github.com/weaveworks/weave/api"
|
||||||
. "github.com/weaveworks/weave/common"
|
|
||||||
"github.com/weaveworks/weave/common/docker"
|
"github.com/weaveworks/weave/common/docker"
|
||||||
)
|
)
|
||||||
|
|
||||||
@@ -21,23 +20,16 @@ type watcher struct {
|
|||||||
type Watcher interface {
|
type Watcher interface {
|
||||||
}
|
}
|
||||||
|
|
||||||
func NewWatcher(client *docker.Client, driver *driver) (Watcher, error) {
|
func NewWatcher(client *docker.Client, weave *weaveapi.Client, driver *driver) (Watcher, error) {
|
||||||
resolver := func() (string, error) { return client.GetContainerIP(WeaveContainer) }
|
w := &watcher{client: client, weave: weave, driver: driver}
|
||||||
w := &watcher{client: client, driver: driver,
|
return w, client.AddObserver(w)
|
||||||
weave: weaveapi.NewClientWithResolver(resolver)}
|
|
||||||
err := client.AddObserver(w)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
|
|
||||||
return w, nil
|
|
||||||
}
|
}
|
||||||
|
|
||||||
func (w *watcher) ContainerStarted(id string) {
|
func (w *watcher) ContainerStarted(id string) {
|
||||||
Log.Debugf("Container started %s", id)
|
w.driver.debug("ContainerStarted", "%s", id)
|
||||||
info, err := w.client.InspectContainer(id)
|
info, err := w.client.InspectContainer(id)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
Log.Warningf("error inspecting container: %s", err)
|
w.driver.warn("ContainerStarted", "error inspecting container %s: %s", id, err)
|
||||||
return
|
return
|
||||||
}
|
}
|
||||||
// check that it's on our network, via the endpointID
|
// check that it's on our network, via the endpointID
|
||||||
@@ -45,7 +37,7 @@ func (w *watcher) ContainerStarted(id string) {
|
|||||||
if w.driver.HasEndpoint(net.EndpointID) {
|
if w.driver.HasEndpoint(net.EndpointID) {
|
||||||
fqdn := fmt.Sprintf("%s.%s", info.Config.Hostname, info.Config.Domainname)
|
fqdn := fmt.Sprintf("%s.%s", info.Config.Hostname, info.Config.Domainname)
|
||||||
if err := w.weave.RegisterWithDNS(id, fqdn, net.IPAddress); err != nil {
|
if err := w.weave.RegisterWithDNS(id, fqdn, net.IPAddress); err != nil {
|
||||||
Log.Warningf("unable to register with weaveDNS: %s", err)
|
w.driver.warn("ContainerStarted", "unable to register %s with weaveDNS: %s", id, err)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -55,3 +47,5 @@ func (w *watcher) ContainerDied(id string) {
|
|||||||
// don't need to do this as WeaveDNS removes names on container died anyway
|
// don't need to do this as WeaveDNS removes names on container died anyway
|
||||||
// (note by the time we get this event we can't see the EndpointID)
|
// (note by the time we get this event we can't see the EndpointID)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func (w *watcher) ContainerDestroyed(id string) {}
|
||||||
@@ -1,54 +0,0 @@
|
|||||||
/* netcheck: check whether a given network or address overlaps with any existing routes */
|
|
||||||
package main
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"net"
|
|
||||||
"os"
|
|
||||||
|
|
||||||
"github.com/docker/docker/pkg/mflag"
|
|
||||||
weavenet "github.com/weaveworks/weave/net"
|
|
||||||
)
|
|
||||||
|
|
||||||
func fatal(err error) {
|
|
||||||
fmt.Fprintln(os.Stderr, err)
|
|
||||||
os.Exit(1)
|
|
||||||
}
|
|
||||||
|
|
||||||
type stringList map[string]struct{}
|
|
||||||
|
|
||||||
func (ss *stringList) Set(value string) error {
|
|
||||||
(*ss)[value] = struct{}{}
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
func (ss *stringList) String() string {
|
|
||||||
return fmt.Sprintf("%v", *ss)
|
|
||||||
}
|
|
||||||
|
|
||||||
func main() {
|
|
||||||
ignoreIfaceNames := make(stringList)
|
|
||||||
|
|
||||||
mflag.Var(&ignoreIfaceNames, []string{"-ignore-iface"}, "name of interface to ignore)")
|
|
||||||
mflag.Parse()
|
|
||||||
|
|
||||||
if len(mflag.Args()) < 1 {
|
|
||||||
fmt.Fprintln(os.Stderr, "usage: netcheck [--ignore-iface <iface-name>] network-cidr")
|
|
||||||
os.Exit(1)
|
|
||||||
}
|
|
||||||
|
|
||||||
cidrStr := mflag.Args()[0]
|
|
||||||
addr, ipnet, err := net.ParseCIDR(cidrStr)
|
|
||||||
if err != nil {
|
|
||||||
fatal(err)
|
|
||||||
}
|
|
||||||
if ipnet.IP.Equal(addr) {
|
|
||||||
err = weavenet.CheckNetworkFree(ipnet, ignoreIfaceNames)
|
|
||||||
} else {
|
|
||||||
err = weavenet.CheckAddressOverlap(addr, ignoreIfaceNames)
|
|
||||||
}
|
|
||||||
if err != nil {
|
|
||||||
fatal(err)
|
|
||||||
}
|
|
||||||
os.Exit(0)
|
|
||||||
}
|
|
||||||
+43
-59
@@ -4,15 +4,18 @@ import (
|
|||||||
"flag"
|
"flag"
|
||||||
"fmt"
|
"fmt"
|
||||||
"net"
|
"net"
|
||||||
|
"net/http"
|
||||||
"os"
|
"os"
|
||||||
"os/signal"
|
"os/signal"
|
||||||
"strings"
|
"strings"
|
||||||
"syscall"
|
"syscall"
|
||||||
|
|
||||||
|
cni "github.com/appc/cni/pkg/skel"
|
||||||
"github.com/docker/libnetwork/ipamapi"
|
"github.com/docker/libnetwork/ipamapi"
|
||||||
go_docker "github.com/fsouza/go-dockerclient"
|
weaveapi "github.com/weaveworks/weave/api"
|
||||||
. "github.com/weaveworks/weave/common"
|
"github.com/weaveworks/weave/common"
|
||||||
"github.com/weaveworks/weave/common/docker"
|
"github.com/weaveworks/weave/common/docker"
|
||||||
|
weavenet "github.com/weaveworks/weave/net"
|
||||||
ipamplugin "github.com/weaveworks/weave/plugin/ipam"
|
ipamplugin "github.com/weaveworks/weave/plugin/ipam"
|
||||||
netplugin "github.com/weaveworks/weave/plugin/net"
|
netplugin "github.com/weaveworks/weave/plugin/net"
|
||||||
"github.com/weaveworks/weave/plugin/skel"
|
"github.com/weaveworks/weave/plugin/skel"
|
||||||
@@ -20,26 +23,26 @@ import (
|
|||||||
|
|
||||||
var version = "(unreleased version)"
|
var version = "(unreleased version)"
|
||||||
|
|
||||||
|
var Log = common.Log
|
||||||
|
|
||||||
func main() {
|
func main() {
|
||||||
var (
|
var (
|
||||||
justVersion bool
|
justVersion bool
|
||||||
|
cniNet bool
|
||||||
|
cniIpam bool
|
||||||
address string
|
address string
|
||||||
nameserver string
|
|
||||||
meshAddress string
|
meshAddress string
|
||||||
logLevel string
|
logLevel string
|
||||||
meshNetworkName string
|
|
||||||
noMulticastRoute bool
|
noMulticastRoute bool
|
||||||
removeNetwork bool
|
|
||||||
)
|
)
|
||||||
|
|
||||||
flag.BoolVar(&justVersion, "version", false, "print version and exit")
|
flag.BoolVar(&justVersion, "version", false, "print version and exit")
|
||||||
|
flag.BoolVar(&cniNet, "cni-net", false, "act as a CNI network plugin")
|
||||||
|
flag.BoolVar(&cniIpam, "cni-ipam", false, "act as a CNI IPAM plugin")
|
||||||
flag.StringVar(&logLevel, "log-level", "info", "logging level (debug, info, warning, error)")
|
flag.StringVar(&logLevel, "log-level", "info", "logging level (debug, info, warning, error)")
|
||||||
flag.StringVar(&address, "socket", "/run/docker/plugins/weave.sock", "socket on which to listen")
|
flag.StringVar(&address, "socket", "/run/docker/plugins/weave.sock", "socket on which to listen")
|
||||||
flag.StringVar(&nameserver, "nameserver", "", "nameserver to provide to containers")
|
|
||||||
flag.StringVar(&meshAddress, "meshsocket", "/run/docker/plugins/weavemesh.sock", "socket on which to listen in mesh mode")
|
flag.StringVar(&meshAddress, "meshsocket", "/run/docker/plugins/weavemesh.sock", "socket on which to listen in mesh mode")
|
||||||
flag.StringVar(&meshNetworkName, "mesh-network-name", "weave", "network name to create in mesh mode")
|
|
||||||
flag.BoolVar(&noMulticastRoute, "no-multicast-route", false, "do not add a multicast route to network endpoints")
|
flag.BoolVar(&noMulticastRoute, "no-multicast-route", false, "do not add a multicast route to network endpoints")
|
||||||
flag.BoolVar(&removeNetwork, "remove-network", false, "remove mesh network and exit")
|
|
||||||
|
|
||||||
flag.Parse()
|
flag.Parse()
|
||||||
|
|
||||||
@@ -48,7 +51,20 @@ func main() {
|
|||||||
os.Exit(0)
|
os.Exit(0)
|
||||||
}
|
}
|
||||||
|
|
||||||
SetLogLevel(logLevel)
|
common.SetLogLevel(logLevel)
|
||||||
|
|
||||||
|
weave := weaveapi.NewClient(os.Getenv("WEAVE_HTTP_ADDR"), Log)
|
||||||
|
|
||||||
|
switch {
|
||||||
|
case cniIpam || strings.HasSuffix(os.Args[0], "weave-ipam"):
|
||||||
|
i := ipamplugin.NewIpam(weave)
|
||||||
|
cni.PluginMain(i.CmdAdd, i.CmdDel)
|
||||||
|
os.Exit(0)
|
||||||
|
case cniNet || strings.HasSuffix(os.Args[0], "weave-net"):
|
||||||
|
n := netplugin.NewCNIPlugin(weave)
|
||||||
|
cni.PluginMain(n.CmdAdd, n.CmdDel)
|
||||||
|
os.Exit(0)
|
||||||
|
}
|
||||||
|
|
||||||
// API 1.21 is the first version that supports docker network commands
|
// API 1.21 is the first version that supports docker network commands
|
||||||
dockerClient, err := docker.NewVersionedClientFromEnv("1.21")
|
dockerClient, err := docker.NewVersionedClientFromEnv("1.21")
|
||||||
@@ -56,29 +72,19 @@ func main() {
|
|||||||
Log.Fatalf("unable to connect to docker: %s", err)
|
Log.Fatalf("unable to connect to docker: %s", err)
|
||||||
}
|
}
|
||||||
|
|
||||||
if removeNetwork {
|
|
||||||
if _, err = dockerClient.Client.NetworkInfo(meshNetworkName); err == nil {
|
|
||||||
err = dockerClient.Client.RemoveNetwork(meshNetworkName)
|
|
||||||
if err != nil {
|
|
||||||
Log.Fatalf("unable to remove network: %s", err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
os.Exit(0)
|
|
||||||
}
|
|
||||||
|
|
||||||
Log.Println("Weave plugin", version, "Command line options:", os.Args[1:])
|
Log.Println("Weave plugin", version, "Command line options:", os.Args[1:])
|
||||||
Log.Info(dockerClient.Info())
|
Log.Info(dockerClient.Info())
|
||||||
|
|
||||||
err = run(dockerClient, address, meshAddress, meshNetworkName, nameserver, noMulticastRoute)
|
err = run(dockerClient, weave, address, meshAddress, noMulticastRoute)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
Log.Fatal(err)
|
Log.Fatal(err)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
func run(dockerClient *docker.Client, address, meshAddress, meshNetworkName, nameserver string, noMulticastRoute bool) error {
|
func run(dockerClient *docker.Client, weave *weaveapi.Client, address, meshAddress string, noMulticastRoute bool) error {
|
||||||
endChan := make(chan error, 1)
|
endChan := make(chan error, 1)
|
||||||
if address != "" {
|
if address != "" {
|
||||||
globalListener, err := listenAndServe(dockerClient, address, nameserver, noMulticastRoute, endChan, "global", false)
|
globalListener, err := listenAndServe(dockerClient, weave, address, noMulticastRoute, endChan, "global", false)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return err
|
return err
|
||||||
}
|
}
|
||||||
@@ -86,7 +92,7 @@ func run(dockerClient *docker.Client, address, meshAddress, meshNetworkName, nam
|
|||||||
defer globalListener.Close()
|
defer globalListener.Close()
|
||||||
}
|
}
|
||||||
if meshAddress != "" {
|
if meshAddress != "" {
|
||||||
meshListener, err := listenAndServe(dockerClient, meshAddress, nameserver, noMulticastRoute, endChan, "local", true)
|
meshListener, err := listenAndServe(dockerClient, weave, meshAddress, noMulticastRoute, endChan, "local", true)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return err
|
return err
|
||||||
}
|
}
|
||||||
@@ -94,12 +100,11 @@ func run(dockerClient *docker.Client, address, meshAddress, meshNetworkName, nam
|
|||||||
defer meshListener.Close()
|
defer meshListener.Close()
|
||||||
}
|
}
|
||||||
|
|
||||||
if meshNetworkName != "" {
|
statusListener, err := weavenet.ListenUnixSocket("/home/weave/status.sock")
|
||||||
if err := createNetwork(dockerClient, meshNetworkName, meshAddress); err != nil {
|
if err != nil {
|
||||||
return err
|
return err
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
go serveStatus(statusListener)
|
||||||
sigChan := make(chan os.Signal, 1)
|
sigChan := make(chan os.Signal, 1)
|
||||||
signal.Notify(sigChan, os.Interrupt, os.Kill, syscall.SIGTERM)
|
signal.Notify(sigChan, os.Interrupt, os.Kill, syscall.SIGTERM)
|
||||||
|
|
||||||
@@ -112,26 +117,18 @@ func run(dockerClient *docker.Client, address, meshAddress, meshNetworkName, nam
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
func listenAndServe(dockerClient *docker.Client, address, nameserver string, noMulticastRoute bool, endChan chan<- error, scope string, withIpam bool) (net.Listener, error) {
|
func listenAndServe(dockerClient *docker.Client, weave *weaveapi.Client, address string, noMulticastRoute bool, endChan chan<- error, scope string, withIpam bool) (net.Listener, error) {
|
||||||
d, err := netplugin.New(dockerClient, version, nameserver, scope, noMulticastRoute)
|
d, err := netplugin.New(dockerClient, weave, scope, noMulticastRoute)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return nil, err
|
return nil, err
|
||||||
}
|
}
|
||||||
|
|
||||||
var i ipamapi.Ipam
|
var i ipamapi.Ipam
|
||||||
if withIpam {
|
if withIpam {
|
||||||
if i, err = ipamplugin.NewIpam(dockerClient, version); err != nil {
|
i = ipamplugin.NewIpam(weave)
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
var listener net.Listener
|
listener, err := weavenet.ListenUnixSocket(address)
|
||||||
|
|
||||||
// remove sockets from last invocation
|
|
||||||
if err := os.Remove(address); err != nil && !os.IsNotExist(err) {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
listener, err = net.Listen("unix", address)
|
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return nil, err
|
return nil, err
|
||||||
}
|
}
|
||||||
@@ -144,24 +141,11 @@ func listenAndServe(dockerClient *docker.Client, address, nameserver string, noM
|
|||||||
return listener, nil
|
return listener, nil
|
||||||
}
|
}
|
||||||
|
|
||||||
func createNetwork(dockerClient *docker.Client, networkName, address string) error {
|
func serveStatus(listener net.Listener) {
|
||||||
if _, err := dockerClient.Client.NetworkInfo(networkName); err == nil {
|
server := &http.Server{Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||||
Log.Printf("Docker network '%s' already exists", networkName)
|
fmt.Fprintln(w, "ok")
|
||||||
} else if _, ok := err.(*go_docker.NoSuchNetwork); ok {
|
})}
|
||||||
driverName := strings.TrimSuffix(address, ".sock")
|
if err := server.Serve(listener); err != nil {
|
||||||
if i := strings.LastIndex(driverName, "/"); i >= 0 {
|
Log.Fatalf("ListenAndServeStatus failed: %s", err)
|
||||||
driverName = driverName[i+1:]
|
|
||||||
}
|
|
||||||
options := go_docker.CreateNetworkOptions{
|
|
||||||
Name: networkName,
|
|
||||||
CheckDuplicate: true,
|
|
||||||
Driver: driverName,
|
|
||||||
IPAM: go_docker.IPAMOptions{Driver: driverName},
|
|
||||||
}
|
|
||||||
_, err := dockerClient.Client.CreateNetwork(options)
|
|
||||||
if err != nil {
|
|
||||||
return fmt.Errorf("Error creating network: %s", err)
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
return nil
|
|
||||||
}
|
}
|
||||||
@@ -0,0 +1,12 @@
|
|||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"testing"
|
||||||
|
|
||||||
|
weavetest "github.com/weaveworks/weave/testing"
|
||||||
|
)
|
||||||
|
|
||||||
|
func TestMain(t *testing.T) {
|
||||||
|
weavetest.TrimTestArgs()
|
||||||
|
main()
|
||||||
|
}
|
||||||
@@ -0,0 +1,6 @@
|
|||||||
|
# This is a nearly-empty image that we use to create a data-only container for persistence
|
||||||
|
FROM scratch
|
||||||
|
MAINTAINER Weaveworks Inc <help@weave.works>
|
||||||
|
ENTRYPOINT ["data-only"]
|
||||||
|
# Work round Docker refusing to save an empty image
|
||||||
|
COPY Dockerfile /
|
||||||
@@ -17,7 +17,7 @@ RUN apk add --update \
|
|||||||
&& rm -rf /var/cache/apk/*
|
&& rm -rf /var/cache/apk/*
|
||||||
|
|
||||||
ADD ./weave ./sigproxy ./weaveproxy ./symlink /home/weave/
|
ADD ./weave ./sigproxy ./weaveproxy ./symlink /home/weave/
|
||||||
ADD ./netcheck ./docker_tls_args /usr/bin/
|
ADD ./weaveutil /usr/bin/
|
||||||
ADD ./weavewait /w/w
|
ADD ./weavewait /w/w
|
||||||
ADD ./weavewait_noop /w-noop/w
|
ADD ./weavewait_noop /w-noop/w
|
||||||
ADD ./weavewait_nomcast /w-nomcast/w
|
ADD ./weavewait_nomcast /w-nomcast/w
|
||||||
|
|||||||
+18
-16
@@ -6,21 +6,27 @@ import (
|
|||||||
"strings"
|
"strings"
|
||||||
|
|
||||||
"github.com/docker/docker/pkg/mflag"
|
"github.com/docker/docker/pkg/mflag"
|
||||||
. "github.com/weaveworks/weave/common"
|
"github.com/weaveworks/weave/common"
|
||||||
"github.com/weaveworks/weave/common/mflagext"
|
"github.com/weaveworks/weave/common/mflagext"
|
||||||
"github.com/weaveworks/weave/proxy"
|
"github.com/weaveworks/weave/proxy"
|
||||||
)
|
)
|
||||||
|
|
||||||
var (
|
var version = "(unreleased version)"
|
||||||
version = "(unreleased version)"
|
|
||||||
defaultDockerHost = "unix:///var/run/docker.sock"
|
var Log = common.Log
|
||||||
)
|
|
||||||
|
func getenv(key, defaultVal string) string {
|
||||||
|
if v := os.Getenv(key); v != "" {
|
||||||
|
return v
|
||||||
|
}
|
||||||
|
return defaultVal
|
||||||
|
}
|
||||||
|
|
||||||
func main() {
|
func main() {
|
||||||
var (
|
var (
|
||||||
justVersion bool
|
justVersion bool
|
||||||
logLevel = "info"
|
logLevel = "info"
|
||||||
c = proxy.Config{Image: "weaveworks/weaveexec"}
|
c proxy.Config
|
||||||
withDNS bool
|
withDNS bool
|
||||||
)
|
)
|
||||||
|
|
||||||
@@ -50,11 +56,7 @@ func main() {
|
|||||||
os.Exit(0)
|
os.Exit(0)
|
||||||
}
|
}
|
||||||
|
|
||||||
SetLogLevel(logLevel)
|
common.SetLogLevel(logLevel)
|
||||||
|
|
||||||
if image := os.Getenv("EXEC_IMAGE"); image != "" {
|
|
||||||
c.Image = image
|
|
||||||
}
|
|
||||||
|
|
||||||
Log.Infoln("weave proxy", version)
|
Log.Infoln("weave proxy", version)
|
||||||
Log.Infoln("Command line arguments:", strings.Join(os.Args[1:], " "))
|
Log.Infoln("Command line arguments:", strings.Join(os.Args[1:], " "))
|
||||||
@@ -63,19 +65,19 @@ func main() {
|
|||||||
Log.Warning("--with-dns option has been removed; DNS is on by default")
|
Log.Warning("--with-dns option has been removed; DNS is on by default")
|
||||||
}
|
}
|
||||||
|
|
||||||
c.DockerHost = defaultDockerHost
|
c.Image = getenv("EXEC_IMAGE", "weaveworks/weaveexec")
|
||||||
if dockerHost := os.Getenv("DOCKER_HOST"); dockerHost != "" {
|
c.DockerBridge = getenv("DOCKER_BRIDGE", "docker0")
|
||||||
c.DockerHost = dockerHost
|
c.DockerHost = getenv("DOCKER_HOST", "unix:///var/run/docker.sock")
|
||||||
}
|
|
||||||
|
|
||||||
p, err := proxy.NewProxy(c)
|
p, err := proxy.NewProxy(c)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
Log.Fatalf("Could not start proxy: %s", err)
|
Log.Fatalf("Could not start proxy: %s", err)
|
||||||
}
|
}
|
||||||
|
defer p.Stop()
|
||||||
|
|
||||||
listeners := p.Listen()
|
listeners := p.Listen()
|
||||||
p.AttachExistingContainers()
|
p.AttachExistingContainers()
|
||||||
go p.Serve(listeners)
|
go p.Serve(listeners)
|
||||||
go p.ListenAndServeStatus("/home/weave/status.sock")
|
go p.ListenAndServeStatus("/home/weave/status.sock")
|
||||||
SignalHandlerLoop()
|
common.SignalHandlerLoop()
|
||||||
}
|
}
|
||||||
@@ -3,4 +3,6 @@ MAINTAINER Weaveworks Inc <help@weave.works>
|
|||||||
LABEL works.weave.role=system
|
LABEL works.weave.role=system
|
||||||
WORKDIR /home/weave
|
WORKDIR /home/weave
|
||||||
ADD ./weaver /home/weave/
|
ADD ./weaver /home/weave/
|
||||||
|
ADD weavedata.db /weavedb/
|
||||||
|
COPY ca-certificates.crt /etc/ssl/certs/
|
||||||
ENTRYPOINT ["/home/weave/weaver"]
|
ENTRYPOINT ["/home/weave/weaver"]
|
||||||
File diff suppressed because it is too large.
Load diff
+47
-8
@@ -7,11 +7,13 @@ import (
|
|||||||
"net/http"
|
"net/http"
|
||||||
"strings"
|
"strings"
|
||||||
"text/template"
|
"text/template"
|
||||||
|
"time"
|
||||||
|
|
||||||
"github.com/gorilla/mux"
|
"github.com/gorilla/mux"
|
||||||
. "github.com/weaveworks/weave/common"
|
"github.com/weaveworks/mesh"
|
||||||
|
|
||||||
|
"github.com/weaveworks/go-checkpoint"
|
||||||
"github.com/weaveworks/weave/ipam"
|
"github.com/weaveworks/weave/ipam"
|
||||||
"github.com/weaveworks/weave/mesh"
|
|
||||||
"github.com/weaveworks/weave/nameserver"
|
"github.com/weaveworks/weave/nameserver"
|
||||||
"github.com/weaveworks/weave/net/address"
|
"github.com/weaveworks/weave/net/address"
|
||||||
weave "github.com/weaveworks/weave/router"
|
weave "github.com/weaveworks/weave/router"
|
||||||
@@ -138,7 +140,7 @@ func defTemplate(name string, text string) *template.Template {
|
|||||||
}
|
}
|
||||||
|
|
||||||
var statusTemplate = defTemplate("status", `\
|
var statusTemplate = defTemplate("status", `\
|
||||||
Version: {{.Version}}
|
Version: {{.Version}} ({{.VersionCheck}})
|
||||||
|
|
||||||
Service: router
|
Service: router
|
||||||
Protocol: {{.Router.Protocol}} \
|
Protocol: {{.Router.Protocol}} \
|
||||||
@@ -166,7 +168,11 @@ var statusTemplate = defTemplate("status", `\
|
|||||||
Status: ready
|
Status: ready
|
||||||
{{end}}\
|
{{end}}\
|
||||||
{{else if .IPAM.Paxos}}\
|
{{else if .IPAM.Paxos}}\
|
||||||
|
{{if .IPAM.Paxos.Elector}}\
|
||||||
Status: awaiting consensus (quorum: {{.IPAM.Paxos.Quorum}}, known: {{.IPAM.Paxos.KnownNodes}})
|
Status: awaiting consensus (quorum: {{.IPAM.Paxos.Quorum}}, known: {{.IPAM.Paxos.KnownNodes}})
|
||||||
|
{{else}}\
|
||||||
|
Status: priming
|
||||||
|
{{end}}\
|
||||||
{{else}}\
|
{{else}}\
|
||||||
Status: idle
|
Status: idle
|
||||||
{{end}}\
|
{{end}}\
|
||||||
@@ -217,17 +223,51 @@ var dnsEntriesTemplate = defTemplate("dnsEntries", `\
|
|||||||
|
|
||||||
var ipamTemplate = defTemplate("ipamTemplate", `{{printIPAMRanges .Router .IPAM}}`)
|
var ipamTemplate = defTemplate("ipamTemplate", `{{printIPAMRanges .Router .IPAM}}`)
|
||||||
|
|
||||||
|
type VersionCheck struct {
|
||||||
|
Enabled bool
|
||||||
|
NewVersion string
|
||||||
|
NextCheckAt time.Time
|
||||||
|
}
|
||||||
|
|
||||||
|
func versionCheck() *VersionCheck {
|
||||||
|
v := &VersionCheck{}
|
||||||
|
if checkpoint.IsCheckDisabled() {
|
||||||
|
return v
|
||||||
|
}
|
||||||
|
|
||||||
|
v.Enabled = true
|
||||||
|
v.NewVersion = newVersion.Load().(string)
|
||||||
|
v.NextCheckAt = checker.NextCheckAt()
|
||||||
|
|
||||||
|
return v
|
||||||
|
}
|
||||||
|
|
||||||
|
func (v *VersionCheck) String() string {
|
||||||
|
switch {
|
||||||
|
case !v.Enabled:
|
||||||
|
return "version check update disabled"
|
||||||
|
case v.NewVersion != "":
|
||||||
|
return fmt.Sprintf("version %s available - please upgrade!",
|
||||||
|
v.NewVersion)
|
||||||
|
default:
|
||||||
|
return fmt.Sprintf("up to date; next check at %s",
|
||||||
|
v.NextCheckAt.Format("2006/01/02 15:04:05"))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
type WeaveStatus struct {
|
type WeaveStatus struct {
|
||||||
Version string
|
Version string
|
||||||
Router *weave.NetworkRouterStatus `json:"Router,omitempty"`
|
VersionCheck *VersionCheck `json:"VersionCheck,omitempty"`
|
||||||
IPAM *ipam.Status `json:"IPAM,omitempty"`
|
Router *weave.NetworkRouterStatus `json:"Router,omitempty"`
|
||||||
DNS *nameserver.Status `json:"DNS,omitempty"`
|
IPAM *ipam.Status `json:"IPAM,omitempty"`
|
||||||
|
DNS *nameserver.Status `json:"DNS,omitempty"`
|
||||||
}
|
}
|
||||||
|
|
||||||
func HandleHTTP(muxRouter *mux.Router, version string, router *weave.NetworkRouter, allocator *ipam.Allocator, defaultSubnet address.CIDR, ns *nameserver.Nameserver, dnsserver *nameserver.DNSServer) {
|
func HandleHTTP(muxRouter *mux.Router, version string, router *weave.NetworkRouter, allocator *ipam.Allocator, defaultSubnet address.CIDR, ns *nameserver.Nameserver, dnsserver *nameserver.DNSServer) {
|
||||||
status := func() WeaveStatus {
|
status := func() WeaveStatus {
|
||||||
return WeaveStatus{
|
return WeaveStatus{
|
||||||
version,
|
version,
|
||||||
|
versionCheck(),
|
||||||
weave.NewNetworkRouterStatus(router),
|
weave.NewNetworkRouterStatus(router),
|
||||||
ipam.NewStatus(allocator, defaultSubnet),
|
ipam.NewStatus(allocator, defaultSubnet),
|
||||||
nameserver.NewStatus(ns, dnsserver)}
|
nameserver.NewStatus(ns, dnsserver)}
|
||||||
@@ -279,5 +319,4 @@ func HandleHTTP(muxRouter *mux.Router, version string, router *weave.NetworkRout
|
|||||||
defHandler("/status/peers", peersTemplate)
|
defHandler("/status/peers", peersTemplate)
|
||||||
defHandler("/status/dns", dnsEntriesTemplate)
|
defHandler("/status/dns", dnsEntriesTemplate)
|
||||||
defHandler("/status/ipam", ipamTemplate)
|
defHandler("/status/ipam", ipamTemplate)
|
||||||
|
|
||||||
}
|
}
|
||||||
+306
-189
@@ -7,18 +7,21 @@ import (
|
|||||||
_ "net/http/pprof"
|
_ "net/http/pprof"
|
||||||
"os"
|
"os"
|
||||||
"runtime"
|
"runtime"
|
||||||
|
"strconv"
|
||||||
"strings"
|
"strings"
|
||||||
|
"sync/atomic"
|
||||||
"time"
|
"time"
|
||||||
|
|
||||||
"github.com/davecheney/profile"
|
"github.com/davecheney/profile"
|
||||||
"github.com/docker/docker/pkg/mflag"
|
"github.com/docker/docker/pkg/mflag"
|
||||||
"github.com/gorilla/mux"
|
"github.com/gorilla/mux"
|
||||||
|
"github.com/weaveworks/mesh"
|
||||||
|
|
||||||
. "github.com/weaveworks/weave/common"
|
"github.com/weaveworks/go-checkpoint"
|
||||||
|
"github.com/weaveworks/weave/common"
|
||||||
"github.com/weaveworks/weave/common/docker"
|
"github.com/weaveworks/weave/common/docker"
|
||||||
"github.com/weaveworks/weave/common/odp"
|
"github.com/weaveworks/weave/db"
|
||||||
"github.com/weaveworks/weave/ipam"
|
"github.com/weaveworks/weave/ipam"
|
||||||
"github.com/weaveworks/weave/mesh"
|
|
||||||
"github.com/weaveworks/weave/nameserver"
|
"github.com/weaveworks/weave/nameserver"
|
||||||
weavenet "github.com/weaveworks/weave/net"
|
weavenet "github.com/weaveworks/weave/net"
|
||||||
"github.com/weaveworks/weave/net/address"
|
"github.com/weaveworks/weave/net/address"
|
||||||
@@ -26,6 +29,113 @@ import (
|
|||||||
)
|
)
|
||||||
|
|
||||||
var version = "(unreleased version)"
|
var version = "(unreleased version)"
|
||||||
|
var checker *checkpoint.Checker
|
||||||
|
var newVersion atomic.Value
|
||||||
|
|
||||||
|
var Log = common.Log
|
||||||
|
|
||||||
|
type ipamConfig struct {
|
||||||
|
IPRangeCIDR string
|
||||||
|
IPSubnetCIDR string
|
||||||
|
PeerCount int
|
||||||
|
Mode string
|
||||||
|
Observer bool
|
||||||
|
SeedPeerNames []mesh.PeerName
|
||||||
|
}
|
||||||
|
|
||||||
|
type dnsConfig struct {
|
||||||
|
Domain string
|
||||||
|
ListenAddress string
|
||||||
|
TTL int
|
||||||
|
ClientTimeout time.Duration
|
||||||
|
EffectiveListenAddress string
|
||||||
|
}
|
||||||
|
|
||||||
|
const (
|
||||||
|
updateCheckPeriod = 6 * time.Hour
|
||||||
|
)
|
||||||
|
|
||||||
|
func checkForUpdates() {
|
||||||
|
newVersion.Store("")
|
||||||
|
|
||||||
|
handleResponse := func(r *checkpoint.CheckResponse, err error) {
|
||||||
|
if err != nil {
|
||||||
|
Log.Printf("Error checking version: %v", err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
if r.Outdated {
|
||||||
|
newVersion.Store(r.CurrentVersion)
|
||||||
|
Log.Printf("Weave version %s is available; please update at %s",
|
||||||
|
r.CurrentVersion, r.CurrentDownloadURL)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Start background version checking
|
||||||
|
params := checkpoint.CheckParams{
|
||||||
|
Product: "weave-net",
|
||||||
|
Version: version,
|
||||||
|
SignatureFile: "",
|
||||||
|
}
|
||||||
|
checker = checkpoint.CheckInterval(¶ms, updateCheckPeriod, handleResponse)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (c *ipamConfig) Enabled() bool {
|
||||||
|
var (
|
||||||
|
hasPeerCount = c.PeerCount > 0
|
||||||
|
hasMode = len(c.Mode) > 0
|
||||||
|
hasRange = c.IPRangeCIDR != ""
|
||||||
|
hasSubnet = c.IPSubnetCIDR != ""
|
||||||
|
)
|
||||||
|
switch {
|
||||||
|
case !(hasPeerCount || hasMode || hasRange || hasSubnet):
|
||||||
|
return false
|
||||||
|
case !hasRange && hasSubnet:
|
||||||
|
Log.Fatal("--ipalloc-default-subnet specified without --ipalloc-range.")
|
||||||
|
case !hasRange:
|
||||||
|
Log.Fatal("--ipalloc-init or --init-peer-count specified without --ipalloc-range.")
|
||||||
|
case hasMode && hasPeerCount:
|
||||||
|
Log.Fatal("At most one of --ipalloc-init or --init-peer-count may be specified.")
|
||||||
|
}
|
||||||
|
if hasMode {
|
||||||
|
if err := c.parseMode(); err != nil {
|
||||||
|
Log.Fatalf("Unable to parse --ipalloc-init: %s", err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
|
func (c *ipamConfig) parseMode() error {
|
||||||
|
modeAndParam := strings.SplitN(c.Mode, "=", 2)
|
||||||
|
|
||||||
|
switch modeAndParam[0] {
|
||||||
|
case "consensus":
|
||||||
|
if len(modeAndParam) == 2 {
|
||||||
|
peerCount, err := strconv.Atoi(modeAndParam[1])
|
||||||
|
if err != nil {
|
||||||
|
return fmt.Errorf("bad consensus parameter: %s", err)
|
||||||
|
}
|
||||||
|
c.PeerCount = peerCount
|
||||||
|
}
|
||||||
|
case "seed":
|
||||||
|
if len(modeAndParam) != 2 {
|
||||||
|
return fmt.Errorf("seed mode requires peer name list")
|
||||||
|
}
|
||||||
|
seedPeerNames, err := parsePeerNames(modeAndParam[1])
|
||||||
|
if err != nil {
|
||||||
|
return fmt.Errorf("bad seed parameter: %s", err)
|
||||||
|
}
|
||||||
|
c.SeedPeerNames = seedPeerNames
|
||||||
|
case "observer":
|
||||||
|
if len(modeAndParam) != 1 {
|
||||||
|
return fmt.Errorf("observer mode takes no parameter")
|
||||||
|
}
|
||||||
|
c.Observer = true
|
||||||
|
default:
|
||||||
|
return fmt.Errorf("unknown mode: %s", modeAndParam[0])
|
||||||
|
}
|
||||||
|
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
func main() {
|
func main() {
|
||||||
procs := runtime.NumCPU()
|
procs := runtime.NumCPU()
|
||||||
@@ -37,39 +147,28 @@ func main() {
|
|||||||
runtime.GOMAXPROCS(procs)
|
runtime.GOMAXPROCS(procs)
|
||||||
|
|
||||||
var (
|
var (
|
||||||
// flags that cause immediate exit
|
justVersion bool
|
||||||
justVersion bool
|
config mesh.Config
|
||||||
createDatapath bool
|
networkConfig weave.NetworkConfig
|
||||||
deleteDatapath bool
|
protocolMinVersion int
|
||||||
addDatapathInterface string
|
ifaceName string
|
||||||
|
routerName string
|
||||||
config mesh.Config
|
nickName string
|
||||||
networkConfig weave.NetworkConfig
|
password string
|
||||||
protocolMinVersion int
|
pktdebug bool
|
||||||
ifaceName string
|
logLevel string
|
||||||
routerName string
|
prof string
|
||||||
nickName string
|
bufSzMB int
|
||||||
password string
|
noDiscovery bool
|
||||||
pktdebug bool
|
httpAddr string
|
||||||
logLevel string
|
ipamConfig ipamConfig
|
||||||
prof string
|
dockerAPI string
|
||||||
bufSzMB int
|
peers []string
|
||||||
noDiscovery bool
|
noDNS bool
|
||||||
httpAddr string
|
dnsConfig dnsConfig
|
||||||
iprangeCIDR string
|
datapathName string
|
||||||
ipsubnetCIDR string
|
trustedSubnetStr string
|
||||||
peerCount int
|
dbPrefix string
|
||||||
dockerAPI string
|
|
||||||
peers []string
|
|
||||||
noDNS bool
|
|
||||||
dnsDomain string
|
|
||||||
dnsListenAddress string
|
|
||||||
dnsTTL int
|
|
||||||
dnsClientTimeout time.Duration
|
|
||||||
dnsEffectiveListenAddress string
|
|
||||||
iface *net.Interface
|
|
||||||
datapathName string
|
|
||||||
trustedSubnetStr string
|
|
||||||
|
|
||||||
defaultDockerHost = "unix:///var/run/docker.sock"
|
defaultDockerHost = "unix:///var/run/docker.sock"
|
||||||
)
|
)
|
||||||
@@ -79,10 +178,7 @@ func main() {
|
|||||||
}
|
}
|
||||||
|
|
||||||
mflag.BoolVar(&justVersion, []string{"#version", "-version"}, false, "print version and exit")
|
mflag.BoolVar(&justVersion, []string{"#version", "-version"}, false, "print version and exit")
|
||||||
mflag.BoolVar(&createDatapath, []string{"-create-datapath"}, false, "create ODP datapath and exit")
|
mflag.StringVar(&config.Host, []string{"-host"}, "", "router host")
|
||||||
mflag.BoolVar(&deleteDatapath, []string{"-delete-datapath"}, false, "delete ODP datapath and exit")
|
|
||||||
mflag.StringVar(&addDatapathInterface, []string{"-add-datapath-iface"}, "", "add a network interface to the ODP datapath and exit")
|
|
||||||
|
|
||||||
mflag.IntVar(&config.Port, []string{"#port", "-port"}, mesh.Port, "router port")
|
mflag.IntVar(&config.Port, []string{"#port", "-port"}, mesh.Port, "router port")
|
||||||
mflag.IntVar(&protocolMinVersion, []string{"-min-protocol-version"}, mesh.ProtocolMinVersion, "minimum weave protocol version")
|
mflag.IntVar(&protocolMinVersion, []string{"-min-protocol-version"}, mesh.ProtocolMinVersion, "minimum weave protocol version")
|
||||||
mflag.StringVar(&ifaceName, []string{"#iface", "-iface"}, "", "name of interface to capture/inject from (disabled if blank)")
|
mflag.StringVar(&ifaceName, []string{"#iface", "-iface"}, "", "name of interface to capture/inject from (disabled if blank)")
|
||||||
@@ -96,19 +192,20 @@ func main() {
|
|||||||
mflag.BoolVar(&noDiscovery, []string{"#nodiscovery", "#-nodiscovery", "-no-discovery"}, false, "disable peer discovery")
|
mflag.BoolVar(&noDiscovery, []string{"#nodiscovery", "#-nodiscovery", "-no-discovery"}, false, "disable peer discovery")
|
||||||
mflag.IntVar(&bufSzMB, []string{"#bufsz", "-bufsz"}, 8, "capture buffer size in MB")
|
mflag.IntVar(&bufSzMB, []string{"#bufsz", "-bufsz"}, 8, "capture buffer size in MB")
|
||||||
mflag.StringVar(&httpAddr, []string{"#httpaddr", "#-httpaddr", "-http-addr"}, "", "address to bind HTTP interface to (disabled if blank, absolute path indicates unix domain socket)")
|
mflag.StringVar(&httpAddr, []string{"#httpaddr", "#-httpaddr", "-http-addr"}, "", "address to bind HTTP interface to (disabled if blank, absolute path indicates unix domain socket)")
|
||||||
mflag.StringVar(&iprangeCIDR, []string{"#iprange", "#-iprange", "-ipalloc-range"}, "", "IP address range reserved for automatic allocation, in CIDR notation")
|
mflag.StringVar(&ipamConfig.Mode, []string{"-ipalloc-init"}, "", "allocator initialisation strategy (consensus, seed or observer)")
|
||||||
mflag.StringVar(&ipsubnetCIDR, []string{"#ipsubnet", "#-ipsubnet", "-ipalloc-default-subnet"}, "", "subnet to allocate within by default, in CIDR notation")
|
mflag.StringVar(&ipamConfig.IPRangeCIDR, []string{"#iprange", "#-iprange", "-ipalloc-range"}, "", "IP address range reserved for automatic allocation, in CIDR notation")
|
||||||
mflag.IntVar(&peerCount, []string{"#initpeercount", "#-initpeercount", "-init-peer-count"}, 0, "number of peers in network (for IP address allocation)")
|
mflag.StringVar(&ipamConfig.IPSubnetCIDR, []string{"#ipsubnet", "#-ipsubnet", "-ipalloc-default-subnet"}, "", "subnet to allocate within by default, in CIDR notation")
|
||||||
|
mflag.IntVar(&ipamConfig.PeerCount, []string{"#initpeercount", "#-initpeercount", "-init-peer-count"}, 0, "number of peers in network (for IP address allocation)")
|
||||||
mflag.StringVar(&dockerAPI, []string{"#api", "#-api", "-docker-api"}, defaultDockerHost, "Docker API endpoint")
|
mflag.StringVar(&dockerAPI, []string{"#api", "#-api", "-docker-api"}, defaultDockerHost, "Docker API endpoint")
|
||||||
mflag.BoolVar(&noDNS, []string{"-no-dns"}, false, "disable DNS server")
|
mflag.BoolVar(&noDNS, []string{"-no-dns"}, false, "disable DNS server")
|
||||||
mflag.StringVar(&dnsDomain, []string{"-dns-domain"}, nameserver.DefaultDomain, "local domain to server requests for")
|
mflag.StringVar(&dnsConfig.Domain, []string{"-dns-domain"}, nameserver.DefaultDomain, "local domain to server requests for")
|
||||||
mflag.StringVar(&dnsListenAddress, []string{"-dns-listen-address"}, nameserver.DefaultListenAddress, "address to listen on for DNS requests")
|
mflag.StringVar(&dnsConfig.ListenAddress, []string{"-dns-listen-address"}, nameserver.DefaultListenAddress, "address to listen on for DNS requests")
|
||||||
mflag.IntVar(&dnsTTL, []string{"-dns-ttl"}, nameserver.DefaultTTL, "TTL for DNS request from our domain")
|
mflag.IntVar(&dnsConfig.TTL, []string{"-dns-ttl"}, nameserver.DefaultTTL, "TTL for DNS request from our domain")
|
||||||
mflag.DurationVar(&dnsClientTimeout, []string{"-dns-fallback-timeout"}, nameserver.DefaultClientTimeout, "timeout for fallback DNS requests")
|
mflag.DurationVar(&dnsConfig.ClientTimeout, []string{"-dns-fallback-timeout"}, nameserver.DefaultClientTimeout, "timeout for fallback DNS requests")
|
||||||
mflag.StringVar(&dnsEffectiveListenAddress, []string{"-dns-effective-listen-address"}, "", "address DNS will actually be listening, after Docker port mapping")
|
mflag.StringVar(&dnsConfig.EffectiveListenAddress, []string{"-dns-effective-listen-address"}, "", "address DNS will actually be listening, after Docker port mapping")
|
||||||
mflag.StringVar(&datapathName, []string{"-datapath"}, "", "ODP datapath name")
|
mflag.StringVar(&datapathName, []string{"-datapath"}, "", "ODP datapath name")
|
||||||
|
mflag.StringVar(&trustedSubnetStr, []string{"-trusted-subnets"}, "", "comma-separated list of trusted subnets in CIDR notation")
|
||||||
mflag.StringVar(&trustedSubnetStr, []string{"-trusted-subnets"}, "", "Command separated list of trusted subnets in CIDR notation")
|
mflag.StringVar(&dbPrefix, []string{"-db-prefix"}, "/weavedb/weave", "pathname/prefix of filename to store data")
|
||||||
|
|
||||||
// crude way of detecting that we probably have been started in a
|
// crude way of detecting that we probably have been started in a
|
||||||
// container, with `weave launch` --> suppress misleading paths in
|
// container, with `weave launch` --> suppress misleading paths in
|
||||||
@@ -122,111 +219,16 @@ func main() {
|
|||||||
|
|
||||||
peers = mflag.Args()
|
peers = mflag.Args()
|
||||||
|
|
||||||
SetLogLevel(logLevel)
|
common.SetLogLevel(logLevel)
|
||||||
|
|
||||||
switch {
|
if justVersion {
|
||||||
case justVersion:
|
|
||||||
fmt.Printf("weave router %s\n", version)
|
fmt.Printf("weave router %s\n", version)
|
||||||
os.Exit(0)
|
os.Exit(0)
|
||||||
|
|
||||||
case createDatapath:
|
|
||||||
err, odp_supported := odp.CreateDatapath(datapathName)
|
|
||||||
if !odp_supported {
|
|
||||||
if err != nil {
|
|
||||||
Log.Error(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// When the kernel lacks ODP support, exit
|
|
||||||
// with a special status to distinguish it for
|
|
||||||
// the weave script.
|
|
||||||
os.Exit(17)
|
|
||||||
}
|
|
||||||
|
|
||||||
checkFatal(err)
|
|
||||||
os.Exit(0)
|
|
||||||
|
|
||||||
case deleteDatapath:
|
|
||||||
checkFatal(odp.DeleteDatapath(datapathName))
|
|
||||||
os.Exit(0)
|
|
||||||
|
|
||||||
case addDatapathInterface != "":
|
|
||||||
checkFatal(odp.AddDatapathInterface(datapathName, addDatapathInterface))
|
|
||||||
os.Exit(0)
|
|
||||||
}
|
}
|
||||||
|
|
||||||
Log.Println("Command line options:", options())
|
Log.Println("Command line options:", options())
|
||||||
Log.Println("Command line peers:", peers)
|
|
||||||
|
|
||||||
if protocolMinVersion < mesh.ProtocolMinVersion || protocolMinVersion > mesh.ProtocolMaxVersion {
|
checkForUpdates()
|
||||||
Log.Fatalf("--min-protocol-version must be in range [%d,%d]", mesh.ProtocolMinVersion, mesh.ProtocolMaxVersion)
|
|
||||||
}
|
|
||||||
config.ProtocolMinVersion = byte(protocolMinVersion)
|
|
||||||
|
|
||||||
var fastDPOverlay weave.NetworkOverlay
|
|
||||||
if datapathName != "" {
|
|
||||||
// A datapath name implies that "Bridge" and "Overlay"
|
|
||||||
// packet handling use fast datapath, although other
|
|
||||||
// options can override that below. Even if both
|
|
||||||
// things are overridden, we might need bridging on
|
|
||||||
// the datapath.
|
|
||||||
fastdp, err := weave.NewFastDatapath(weave.FastDatapathConfig{
|
|
||||||
DatapathName: datapathName,
|
|
||||||
Port: config.Port,
|
|
||||||
})
|
|
||||||
|
|
||||||
checkFatal(err)
|
|
||||||
networkConfig.Bridge = fastdp.Bridge()
|
|
||||||
fastDPOverlay = fastdp.Overlay()
|
|
||||||
}
|
|
||||||
|
|
||||||
if ifaceName != "" {
|
|
||||||
// -iface can coexist with -datapath, because
|
|
||||||
// pcap-based packet capture is a bit more efficient
|
|
||||||
// than capture via ODP misses, even when using an
|
|
||||||
// ODP-based bridge. So when using weave encyption,
|
|
||||||
// it's preferable to use -iface.
|
|
||||||
var err error
|
|
||||||
iface, err = weavenet.EnsureInterface(ifaceName)
|
|
||||||
checkFatal(err)
|
|
||||||
|
|
||||||
// bufsz flag is in MB
|
|
||||||
networkConfig.Bridge, err = weave.NewPcap(iface, bufSzMB*1024*1024)
|
|
||||||
checkFatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
if password == "" {
|
|
||||||
password = os.Getenv("WEAVE_PASSWORD")
|
|
||||||
}
|
|
||||||
|
|
||||||
if password == "" {
|
|
||||||
Log.Println("Communication between peers is unencrypted.")
|
|
||||||
} else {
|
|
||||||
config.Password = []byte(password)
|
|
||||||
Log.Println("Communication between peers via untrusted networks is encrypted.")
|
|
||||||
}
|
|
||||||
|
|
||||||
overlays := weave.NewOverlaySwitch()
|
|
||||||
if fastDPOverlay != nil {
|
|
||||||
overlays.Add("fastdp", fastDPOverlay)
|
|
||||||
}
|
|
||||||
sleeve := weave.NewSleeveOverlay(config.Port)
|
|
||||||
overlays.Add("sleeve", sleeve)
|
|
||||||
overlays.SetCompatOverlay(sleeve)
|
|
||||||
|
|
||||||
if routerName == "" {
|
|
||||||
if iface == nil {
|
|
||||||
Log.Fatal("Either an interface must be specified with --iface or a name with -name")
|
|
||||||
}
|
|
||||||
routerName = iface.HardwareAddr.String()
|
|
||||||
}
|
|
||||||
|
|
||||||
name, err := mesh.PeerNameFromUserInput(routerName)
|
|
||||||
checkFatal(err)
|
|
||||||
|
|
||||||
if nickName == "" {
|
|
||||||
nickName, err = os.Hostname()
|
|
||||||
checkFatal(err)
|
|
||||||
}
|
|
||||||
|
|
||||||
if prof != "" {
|
if prof != "" {
|
||||||
p := *profile.CPUProfile
|
p := *profile.CPUProfile
|
||||||
@@ -235,7 +237,10 @@ func main() {
|
|||||||
defer profile.Start(&p).Stop()
|
defer profile.Start(&p).Stop()
|
||||||
}
|
}
|
||||||
|
|
||||||
config.PeerDiscovery = !noDiscovery
|
if protocolMinVersion < mesh.ProtocolMinVersion || protocolMinVersion > mesh.ProtocolMaxVersion {
|
||||||
|
Log.Fatalf("--min-protocol-version must be in range [%d,%d]", mesh.ProtocolMinVersion, mesh.ProtocolMaxVersion)
|
||||||
|
}
|
||||||
|
config.ProtocolMinVersion = byte(protocolMinVersion)
|
||||||
|
|
||||||
if pktdebug {
|
if pktdebug {
|
||||||
networkConfig.PacketLogging = packetLogging{}
|
networkConfig.PacketLogging = packetLogging{}
|
||||||
@@ -243,13 +248,32 @@ func main() {
|
|||||||
networkConfig.PacketLogging = nopPacketLogging{}
|
networkConfig.PacketLogging = nopPacketLogging{}
|
||||||
}
|
}
|
||||||
|
|
||||||
if config.TrustedSubnets, err = parseTrustedSubnets(trustedSubnetStr); err != nil {
|
overlay, bridge := createOverlay(datapathName, ifaceName, config.Host, config.Port, bufSzMB)
|
||||||
Log.Fatal("Unable to parse trusted subnets: ", err)
|
networkConfig.Bridge = bridge
|
||||||
|
|
||||||
|
name := peerName(routerName, bridge.Interface())
|
||||||
|
|
||||||
|
if nickName == "" {
|
||||||
|
var err error
|
||||||
|
nickName, err = os.Hostname()
|
||||||
|
checkFatal(err)
|
||||||
}
|
}
|
||||||
|
|
||||||
router := weave.NewNetworkRouter(config, networkConfig, name, nickName, overlays)
|
config.Password = determinePassword(password)
|
||||||
|
config.TrustedSubnets = parseTrustedSubnets(trustedSubnetStr)
|
||||||
|
config.PeerDiscovery = !noDiscovery
|
||||||
|
|
||||||
|
db, err := db.NewBoltDB(dbPrefix + "data.db")
|
||||||
|
checkFatal(err)
|
||||||
|
defer db.Close()
|
||||||
|
|
||||||
|
router := weave.NewNetworkRouter(config, networkConfig, name, nickName, overlay, db)
|
||||||
Log.Println("Our name is", router.Ourself)
|
Log.Println("Our name is", router.Ourself)
|
||||||
|
|
||||||
|
if peers, err = router.InitialPeers(peers); err != nil {
|
||||||
|
Log.Fatal("Unable to get initial peer set: ", err)
|
||||||
|
}
|
||||||
|
|
||||||
var dockerCli *docker.Client
|
var dockerCli *docker.Client
|
||||||
if dockerAPI != "" {
|
if dockerAPI != "" {
|
||||||
dc, err := docker.NewClient(dockerAPI)
|
dc, err := docker.NewClient(dockerAPI)
|
||||||
@@ -262,7 +286,7 @@ func main() {
|
|||||||
}
|
}
|
||||||
observeContainers := func(o docker.ContainerObserver) {
|
observeContainers := func(o docker.ContainerObserver) {
|
||||||
if dockerCli != nil {
|
if dockerCli != nil {
|
||||||
if err = dockerCli.AddObserver(o); err != nil {
|
if err := dockerCli.AddObserver(o); err != nil {
|
||||||
Log.Fatal("Unable to start watcher", err)
|
Log.Fatal("Unable to start watcher", err)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -270,13 +294,17 @@ func main() {
|
|||||||
isKnownPeer := func(name mesh.PeerName) bool {
|
isKnownPeer := func(name mesh.PeerName) bool {
|
||||||
return router.Peers.Fetch(name) != nil
|
return router.Peers.Fetch(name) != nil
|
||||||
}
|
}
|
||||||
var allocator *ipam.Allocator
|
|
||||||
var defaultSubnet address.CIDR
|
var (
|
||||||
if iprangeCIDR != "" {
|
allocator *ipam.Allocator
|
||||||
allocator, defaultSubnet = createAllocator(router.Router, iprangeCIDR, ipsubnetCIDR, determineQuorum(peerCount, peers), isKnownPeer)
|
defaultSubnet address.CIDR
|
||||||
|
)
|
||||||
|
if ipamConfig.Enabled() {
|
||||||
|
allocator, defaultSubnet = createAllocator(router, ipamConfig, db, isKnownPeer)
|
||||||
observeContainers(allocator)
|
observeContainers(allocator)
|
||||||
} else if peerCount > 0 {
|
ids, err := dockerCli.AllContainerIDs()
|
||||||
Log.Fatal("--init-peer-count flag specified without --ipalloc-range")
|
checkFatal(err)
|
||||||
|
allocator.AllContainerIDs(ids)
|
||||||
}
|
}
|
||||||
|
|
||||||
var (
|
var (
|
||||||
@@ -284,29 +312,17 @@ func main() {
|
|||||||
dnsserver *nameserver.DNSServer
|
dnsserver *nameserver.DNSServer
|
||||||
)
|
)
|
||||||
if !noDNS {
|
if !noDNS {
|
||||||
ns = nameserver.New(router.Ourself.Peer.Name, dnsDomain, isKnownPeer)
|
ns, dnsserver = createDNSServer(dnsConfig, router.Router, isKnownPeer)
|
||||||
router.Peers.OnGC(func(peer *mesh.Peer) { ns.PeerGone(peer.Name) })
|
|
||||||
ns.SetGossip(router.NewGossip("nameserver", ns))
|
|
||||||
observeContainers(ns)
|
observeContainers(ns)
|
||||||
ns.Start()
|
ns.Start()
|
||||||
defer ns.Stop()
|
defer ns.Stop()
|
||||||
dnsserver, err = nameserver.NewDNSServer(ns, dnsDomain, dnsListenAddress,
|
|
||||||
dnsEffectiveListenAddress, uint32(dnsTTL), dnsClientTimeout)
|
|
||||||
if err != nil {
|
|
||||||
Log.Fatal("Unable to start dns server: ", err)
|
|
||||||
}
|
|
||||||
listenAddr := dnsListenAddress
|
|
||||||
if dnsEffectiveListenAddress != "" {
|
|
||||||
listenAddr = dnsEffectiveListenAddress
|
|
||||||
}
|
|
||||||
Log.Println("Listening for DNS queries on", listenAddr)
|
|
||||||
dnsserver.ActivateAndServe()
|
dnsserver.ActivateAndServe()
|
||||||
defer dnsserver.Stop()
|
defer dnsserver.Stop()
|
||||||
}
|
}
|
||||||
|
|
||||||
router.Start()
|
router.Start()
|
||||||
if errors := router.ConnectionMaker.InitiateConnections(peers, false); len(errors) > 0 {
|
if errors := router.InitiateConnections(peers, false); len(errors) > 0 {
|
||||||
Log.Fatal(ErrorMessages(errors))
|
Log.Fatal(common.ErrorMessages(errors))
|
||||||
}
|
}
|
||||||
|
|
||||||
// The weave script always waits for a status call to succeed,
|
// The weave script always waits for a status call to succeed,
|
||||||
@@ -327,7 +343,7 @@ func main() {
|
|||||||
go listenAndServeHTTP(httpAddr, muxRouter)
|
go listenAndServeHTTP(httpAddr, muxRouter)
|
||||||
}
|
}
|
||||||
|
|
||||||
SignalHandlerLoop(router)
|
common.SignalHandlerLoop(router)
|
||||||
}
|
}
|
||||||
|
|
||||||
func options() map[string]string {
|
func options() map[string]string {
|
||||||
@@ -370,26 +386,69 @@ func (nopPacketLogging) LogPacket(string, weave.PacketKey) {
|
|||||||
func (nopPacketLogging) LogForwardPacket(string, weave.ForwardPacketKey) {
|
func (nopPacketLogging) LogForwardPacket(string, weave.ForwardPacketKey) {
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func createOverlay(datapathName string, ifaceName string, host string, port int, bufSzMB int) (weave.NetworkOverlay, weave.Bridge) {
|
||||||
|
overlay := weave.NewOverlaySwitch()
|
||||||
|
var bridge weave.Bridge
|
||||||
|
switch {
|
||||||
|
case datapathName != "" && ifaceName != "":
|
||||||
|
Log.Fatal("At most one of --datapath and --iface must be specified.")
|
||||||
|
case datapathName != "":
|
||||||
|
iface, err := weavenet.EnsureInterface(datapathName)
|
||||||
|
checkFatal(err)
|
||||||
|
fastdp, err := weave.NewFastDatapath(iface, port)
|
||||||
|
checkFatal(err)
|
||||||
|
bridge = fastdp.Bridge()
|
||||||
|
overlay.Add("fastdp", fastdp.Overlay())
|
||||||
|
case ifaceName != "":
|
||||||
|
iface, err := weavenet.EnsureInterface(ifaceName)
|
||||||
|
checkFatal(err)
|
||||||
|
bridge, err = weave.NewPcap(iface, bufSzMB*1024*1024) // bufsz flag is in MB
|
||||||
|
checkFatal(err)
|
||||||
|
default:
|
||||||
|
bridge = weave.NullBridge{}
|
||||||
|
}
|
||||||
|
sleeve := weave.NewSleeveOverlay(host, port)
|
||||||
|
overlay.Add("sleeve", sleeve)
|
||||||
|
overlay.SetCompatOverlay(sleeve)
|
||||||
|
return overlay, bridge
|
||||||
|
}
|
||||||
|
|
||||||
func parseAndCheckCIDR(cidrStr string) address.CIDR {
|
func parseAndCheckCIDR(cidrStr string) address.CIDR {
|
||||||
_, cidr, err := address.ParseCIDR(cidrStr)
|
cidr, err := address.ParseCIDR(cidrStr)
|
||||||
checkFatal(err)
|
checkFatal(err)
|
||||||
|
|
||||||
|
if !cidr.IsSubnet() {
|
||||||
|
Log.Fatalf("Invalid allocation range %s - bits after network prefix are not all zero", cidrStr)
|
||||||
|
}
|
||||||
if cidr.Size() < ipam.MinSubnetSize {
|
if cidr.Size() < ipam.MinSubnetSize {
|
||||||
Log.Fatalf("Allocation range smaller than minimum size %d: %s", ipam.MinSubnetSize, cidrStr)
|
Log.Fatalf("Allocation range smaller than minimum size %d: %s", ipam.MinSubnetSize, cidrStr)
|
||||||
}
|
}
|
||||||
return cidr
|
return cidr
|
||||||
}
|
}
|
||||||
|
|
||||||
func createAllocator(router *mesh.Router, ipRangeStr string, defaultSubnetStr string, quorum uint, isKnownPeer func(mesh.PeerName) bool) (*ipam.Allocator, address.CIDR) {
|
func createAllocator(router *weave.NetworkRouter, config ipamConfig, db db.DB, isKnownPeer func(mesh.PeerName) bool) (*ipam.Allocator, address.CIDR) {
|
||||||
ipRange := parseAndCheckCIDR(ipRangeStr)
|
ipRange := parseAndCheckCIDR(config.IPRangeCIDR)
|
||||||
defaultSubnet := ipRange
|
defaultSubnet := ipRange
|
||||||
if defaultSubnetStr != "" {
|
if config.IPSubnetCIDR != "" {
|
||||||
defaultSubnet = parseAndCheckCIDR(defaultSubnetStr)
|
defaultSubnet = parseAndCheckCIDR(config.IPSubnetCIDR)
|
||||||
if !ipRange.Range().Overlaps(defaultSubnet.Range()) {
|
if !ipRange.Range().Overlaps(defaultSubnet.Range()) {
|
||||||
Log.Fatalf("IP address allocation default subnet %s does not overlap with allocation range %s", defaultSubnet, ipRange)
|
Log.Fatalf("IP address allocation default subnet %s does not overlap with allocation range %s", defaultSubnet, ipRange)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
allocator := ipam.NewAllocator(router.Ourself.Peer.Name, router.Ourself.Peer.UID, router.Ourself.Peer.NickName, ipRange.Range(), quorum, isKnownPeer)
|
|
||||||
|
c := ipam.Config{
|
||||||
|
OurName: router.Ourself.Peer.Name,
|
||||||
|
OurUID: router.Ourself.Peer.UID,
|
||||||
|
OurNickname: router.Ourself.Peer.NickName,
|
||||||
|
Seed: config.SeedPeerNames,
|
||||||
|
Universe: ipRange.Range(),
|
||||||
|
IsObserver: config.Observer,
|
||||||
|
Quorum: func() uint { return determineQuorum(config.PeerCount, router) },
|
||||||
|
Db: db,
|
||||||
|
IsKnownPeer: isKnownPeer,
|
||||||
|
}
|
||||||
|
|
||||||
|
allocator := ipam.NewAllocator(c)
|
||||||
|
|
||||||
allocator.SetInterfaces(router.NewGossip("IPallocation", allocator))
|
allocator.SetInterfaces(router.NewGossip("IPallocation", allocator))
|
||||||
allocator.Start()
|
allocator.Start()
|
||||||
@@ -397,13 +456,31 @@ func createAllocator(router *mesh.Router, ipRangeStr string, defaultSubnetStr st
|
|||||||
return allocator, defaultSubnet
|
return allocator, defaultSubnet
|
||||||
}
|
}
|
||||||
|
|
||||||
// Pick a quorum size heuristically based on the number of peer
|
func createDNSServer(config dnsConfig, router *mesh.Router, isKnownPeer func(mesh.PeerName) bool) (*nameserver.Nameserver, *nameserver.DNSServer) {
|
||||||
// addresses passed.
|
ns := nameserver.New(router.Ourself.Peer.Name, config.Domain, isKnownPeer)
|
||||||
func determineQuorum(initPeerCountFlag int, peers []string) uint {
|
router.Peers.OnGC(func(peer *mesh.Peer) { ns.PeerGone(peer.Name) })
|
||||||
|
ns.SetGossip(router.NewGossip("nameserver", ns))
|
||||||
|
dnsserver, err := nameserver.NewDNSServer(ns, config.Domain, config.ListenAddress,
|
||||||
|
config.EffectiveListenAddress, uint32(config.TTL), config.ClientTimeout)
|
||||||
|
if err != nil {
|
||||||
|
Log.Fatal("Unable to start dns server: ", err)
|
||||||
|
}
|
||||||
|
listenAddr := config.ListenAddress
|
||||||
|
if config.EffectiveListenAddress != "" {
|
||||||
|
listenAddr = config.EffectiveListenAddress
|
||||||
|
}
|
||||||
|
Log.Println("Listening for DNS queries on", listenAddr)
|
||||||
|
return ns, dnsserver
|
||||||
|
}
|
||||||
|
|
||||||
|
// Pick a quorum size based on the number of peer addresses.
|
||||||
|
func determineQuorum(initPeerCountFlag int, router *weave.NetworkRouter) uint {
|
||||||
if initPeerCountFlag > 0 {
|
if initPeerCountFlag > 0 {
|
||||||
return uint(initPeerCountFlag/2 + 1)
|
return uint(initPeerCountFlag/2 + 1)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
peers := router.ConnectionMaker.Targets(true)
|
||||||
|
|
||||||
// Guess a suitable quorum size based on the list of peer
|
// Guess a suitable quorum size based on the list of peer
|
||||||
// addresses. The peer list might or might not contain an
|
// addresses. The peer list might or might not contain an
|
||||||
// address for this peer, so the conservative assumption is
|
// address for this peer, so the conservative assumption is
|
||||||
@@ -417,22 +494,62 @@ func determineQuorum(initPeerCountFlag int, peers []string) uint {
|
|||||||
return quorum
|
return quorum
|
||||||
}
|
}
|
||||||
|
|
||||||
func parseTrustedSubnets(trustedSubnetStr string) ([]*net.IPNet, error) {
|
func determinePassword(password string) []byte {
|
||||||
trustedSubnets := []*net.IPNet{}
|
if password == "" {
|
||||||
|
password = os.Getenv("WEAVE_PASSWORD")
|
||||||
|
}
|
||||||
|
if password == "" {
|
||||||
|
Log.Println("Communication between peers is unencrypted.")
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
Log.Println("Communication between peers via untrusted networks is encrypted.")
|
||||||
|
return []byte(password)
|
||||||
|
}
|
||||||
|
|
||||||
|
func peerName(routerName string, iface *net.Interface) mesh.PeerName {
|
||||||
|
if routerName == "" {
|
||||||
|
if iface == nil {
|
||||||
|
Log.Fatal("Either an interface must be specified with --datapath or --iface, or a name with --name")
|
||||||
|
}
|
||||||
|
routerName = iface.HardwareAddr.String()
|
||||||
|
}
|
||||||
|
name, err := mesh.PeerNameFromUserInput(routerName)
|
||||||
|
checkFatal(err)
|
||||||
|
return name
|
||||||
|
}
|
||||||
|
|
||||||
|
func parseTrustedSubnets(trustedSubnetStr string) []*net.IPNet {
|
||||||
|
trustedSubnets := []*net.IPNet{}
|
||||||
if trustedSubnetStr == "" {
|
if trustedSubnetStr == "" {
|
||||||
return trustedSubnets, nil
|
return trustedSubnets
|
||||||
}
|
}
|
||||||
|
|
||||||
for _, subnetStr := range strings.Split(trustedSubnetStr, ",") {
|
for _, subnetStr := range strings.Split(trustedSubnetStr, ",") {
|
||||||
_, subnet, err := net.ParseCIDR(subnetStr)
|
_, subnet, err := net.ParseCIDR(subnetStr)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return nil, err
|
Log.Fatal("Unable to parse trusted subnets: ", err)
|
||||||
}
|
}
|
||||||
trustedSubnets = append(trustedSubnets, subnet)
|
trustedSubnets = append(trustedSubnets, subnet)
|
||||||
}
|
}
|
||||||
|
|
||||||
return trustedSubnets, nil
|
return trustedSubnets
|
||||||
|
}
|
||||||
|
|
||||||
|
func parsePeerNames(s string) ([]mesh.PeerName, error) {
|
||||||
|
peerNames := []mesh.PeerName{}
|
||||||
|
if s == "" {
|
||||||
|
return peerNames, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
for _, peerNameStr := range strings.Split(s, ",") {
|
||||||
|
peerName, err := mesh.PeerNameFromUserInput(peerNameStr)
|
||||||
|
if err != nil {
|
||||||
|
return nil, fmt.Errorf("error parsing peer names: %s", err)
|
||||||
|
}
|
||||||
|
peerNames = append(peerNames, peerName)
|
||||||
|
}
|
||||||
|
|
||||||
|
return peerNames, nil
|
||||||
}
|
}
|
||||||
|
|
||||||
func listenAndServeHTTP(httpAddr string, muxRouter *mux.Router) {
|
func listenAndServeHTTP(httpAddr string, muxRouter *mux.Router) {
|
||||||
|
|||||||
Whitespace-only changes.
@@ -0,0 +1,57 @@
|
|||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"fmt"
|
||||||
|
"github.com/fsouza/go-dockerclient"
|
||||||
|
"github.com/weaveworks/weave/common"
|
||||||
|
)
|
||||||
|
|
||||||
|
func containerAddrs(args []string) error {
|
||||||
|
if len(args) < 1 {
|
||||||
|
cmdUsage("container-addrs", "<bridgeName> [containerID ...]")
|
||||||
|
}
|
||||||
|
bridgeName := args[0]
|
||||||
|
|
||||||
|
c, err := docker.NewVersionedClientFromEnv("1.18")
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
for _, containerID := range args[1:] {
|
||||||
|
netDevs, err := getNetDevs(bridgeName, c, containerID)
|
||||||
|
if err != nil {
|
||||||
|
if _, ok := err.(*docker.NoSuchContainer); ok {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
for _, netDev := range netDevs {
|
||||||
|
fmt.Printf("%12s %s %s", containerID, netDev.Name, netDev.MAC.String())
|
||||||
|
for _, cidr := range netDev.CIDRs {
|
||||||
|
prefixLength, _ := cidr.Mask.Size()
|
||||||
|
fmt.Printf(" %v/%v", cidr.IP, prefixLength)
|
||||||
|
}
|
||||||
|
fmt.Println()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func getNetDevs(bridgeName string, c *docker.Client, containerID string) ([]common.NetDev, error) {
|
||||||
|
if containerID == "weave:expose" {
|
||||||
|
return common.GetBridgeNetDev(bridgeName)
|
||||||
|
}
|
||||||
|
|
||||||
|
container, err := c.InspectContainer(containerID)
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
|
||||||
|
if container.State.Pid == 0 {
|
||||||
|
return nil, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
return common.GetWeaveNetDevs(container.State.Pid)
|
||||||
|
}
|
||||||
@@ -0,0 +1,39 @@
|
|||||||
|
// various fastdp operations
|
||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"fmt"
|
||||||
|
"os"
|
||||||
|
|
||||||
|
"github.com/weaveworks/weave/common/odp"
|
||||||
|
)
|
||||||
|
|
||||||
|
func createDatapath(args []string) error {
|
||||||
|
if len(args) != 1 {
|
||||||
|
cmdUsage("create-datapath", "<datapath>")
|
||||||
|
}
|
||||||
|
odpSupported, err := odp.CreateDatapath(args[0])
|
||||||
|
if !odpSupported {
|
||||||
|
if err != nil {
|
||||||
|
fmt.Fprintln(os.Stderr, err)
|
||||||
|
}
|
||||||
|
// When the kernel lacks ODP support, exit with a special
|
||||||
|
// status to distinguish it for the weave script.
|
||||||
|
os.Exit(17)
|
||||||
|
}
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
func deleteDatapath(args []string) error {
|
||||||
|
if len(args) != 1 {
|
||||||
|
cmdUsage("delete-datapath", "<datapath>")
|
||||||
|
}
|
||||||
|
return odp.DeleteDatapath(args[0])
|
||||||
|
}
|
||||||
|
|
||||||
|
func addDatapathInterface(args []string) error {
|
||||||
|
if len(args) != 2 {
|
||||||
|
cmdUsage("add-datapath-interface", "<datapath> <interface>")
|
||||||
|
}
|
||||||
|
return odp.AddDatapathInterface(args[0], args[1])
|
||||||
|
}
|
||||||
@@ -1,26 +1,24 @@
|
|||||||
// docker_tls_args: find the docker daemon's tls args
|
// docker_tls_args: find the docker daemon's tls args
|
||||||
// This reimplements pgrep, because pgrep will only look in /proc, but not in
|
|
||||||
// $PROCFS.
|
|
||||||
package main
|
package main
|
||||||
|
|
||||||
import (
|
import (
|
||||||
"bytes"
|
"bytes"
|
||||||
"fmt"
|
"fmt"
|
||||||
"io/ioutil"
|
"io/ioutil"
|
||||||
"os"
|
|
||||||
"path/filepath"
|
"path/filepath"
|
||||||
"strconv"
|
"strconv"
|
||||||
"strings"
|
"strings"
|
||||||
)
|
)
|
||||||
|
|
||||||
func main() {
|
func dockerTLSArgs(args []string) error {
|
||||||
procRoot := os.Getenv("PROCFS")
|
if len(args) > 0 {
|
||||||
if procRoot == "" {
|
cmdUsage("docker-tls-args", "")
|
||||||
procRoot = "/proc"
|
|
||||||
}
|
}
|
||||||
|
procRoot := "/proc"
|
||||||
dirEntries, err := ioutil.ReadDir(procRoot)
|
dirEntries, err := ioutil.ReadDir(procRoot)
|
||||||
checkErr(err)
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
for _, dirEntry := range dirEntries {
|
for _, dirEntry := range dirEntries {
|
||||||
dirName := dirEntry.Name()
|
dirName := dirEntry.Name()
|
||||||
@@ -63,15 +61,8 @@ func main() {
|
|||||||
}
|
}
|
||||||
|
|
||||||
fmt.Println(strings.Join(tlsArgs, " "))
|
fmt.Println(strings.Join(tlsArgs, " "))
|
||||||
os.Exit(0)
|
return nil
|
||||||
}
|
}
|
||||||
|
|
||||||
os.Exit(1)
|
return fmt.Errorf("cannot locate running docker daemon")
|
||||||
}
|
|
||||||
|
|
||||||
func checkErr(err error) {
|
|
||||||
if err != nil {
|
|
||||||
fmt.Fprintln(os.Stderr, err)
|
|
||||||
os.Exit(1)
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
@@ -0,0 +1,62 @@
|
|||||||
|
/* weaveutil: collection of operations required by weave script */
|
||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"fmt"
|
||||||
|
"os"
|
||||||
|
)
|
||||||
|
|
||||||
|
var commands map[string]func([]string) error
|
||||||
|
|
||||||
|
func init() {
|
||||||
|
commands = map[string]func([]string) error{
|
||||||
|
"help": help,
|
||||||
|
"netcheck": netcheck,
|
||||||
|
"docker-tls-args": dockerTLSArgs,
|
||||||
|
"create-datapath": createDatapath,
|
||||||
|
"delete-datapath": deleteDatapath,
|
||||||
|
"add-datapath-interface": addDatapathInterface,
|
||||||
|
"create-plugin-network": createPluginNetwork,
|
||||||
|
"remove-plugin-network": removePluginNetwork,
|
||||||
|
"container-addrs": containerAddrs,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func main() {
|
||||||
|
if len(os.Args) < 2 {
|
||||||
|
usage()
|
||||||
|
os.Exit(1)
|
||||||
|
}
|
||||||
|
cmd, found := commands[os.Args[1]]
|
||||||
|
if !found {
|
||||||
|
usage()
|
||||||
|
os.Exit(1)
|
||||||
|
}
|
||||||
|
if err := cmd(os.Args[2:]); err != nil {
|
||||||
|
fmt.Fprintln(os.Stderr, err)
|
||||||
|
os.Exit(1)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func help(args []string) error {
|
||||||
|
if len(args) > 0 {
|
||||||
|
cmdUsage("help", "")
|
||||||
|
}
|
||||||
|
usage()
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func usage() {
|
||||||
|
fmt.Fprintln(os.Stderr, "usage: weaveutil <command> <arg>...")
|
||||||
|
fmt.Fprintln(os.Stderr)
|
||||||
|
fmt.Fprintln(os.Stderr, "where <command> is one of:")
|
||||||
|
fmt.Fprintln(os.Stderr)
|
||||||
|
for cmd := range commands {
|
||||||
|
fmt.Fprintln(os.Stderr, cmd)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func cmdUsage(cmd string, usage string) {
|
||||||
|
fmt.Fprintf(os.Stderr, "usage: weaveutil %s %s\n", cmd, usage)
|
||||||
|
os.Exit(1)
|
||||||
|
}
|
||||||
@@ -0,0 +1,28 @@
|
|||||||
|
/* netcheck: check whether a given network or address overlaps with any existing routes */
|
||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"net"
|
||||||
|
|
||||||
|
weavenet "github.com/weaveworks/weave/net"
|
||||||
|
)
|
||||||
|
|
||||||
|
func netcheck(args []string) error {
|
||||||
|
if len(args) < 1 {
|
||||||
|
cmdUsage("netcheck", "<cidr> [<interface-to-ignore> ...]")
|
||||||
|
}
|
||||||
|
addr, ipnet, err := net.ParseCIDR(args[0])
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
ignoreIfaceNames := make(map[string]struct{})
|
||||||
|
for _, ifName := range args[1:] {
|
||||||
|
ignoreIfaceNames[ifName] = struct{}{}
|
||||||
|
}
|
||||||
|
if ipnet.IP.Equal(addr) {
|
||||||
|
err = weavenet.CheckNetworkFree(ipnet, ignoreIfaceNames)
|
||||||
|
} else {
|
||||||
|
err = weavenet.CheckAddressOverlap(addr, ignoreIfaceNames)
|
||||||
|
}
|
||||||
|
return err
|
||||||
|
}
|
||||||
@@ -0,0 +1,67 @@
|
|||||||
|
/* various weave docker network plugin operations */
|
||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"fmt"
|
||||||
|
|
||||||
|
"github.com/fsouza/go-dockerclient"
|
||||||
|
)
|
||||||
|
|
||||||
|
func createPluginNetwork(args []string) error {
|
||||||
|
if len(args) != 2 {
|
||||||
|
cmdUsage("create-plugin-network", "<network-name> <driver-name>")
|
||||||
|
}
|
||||||
|
networkName := args[0]
|
||||||
|
driverName := args[1]
|
||||||
|
d, err := newDockerClient()
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
_, err = d.CreateNetwork(
|
||||||
|
docker.CreateNetworkOptions{
|
||||||
|
Name: networkName,
|
||||||
|
CheckDuplicate: true,
|
||||||
|
Driver: driverName,
|
||||||
|
IPAM: docker.IPAMOptions{Driver: driverName},
|
||||||
|
})
|
||||||
|
if err != docker.ErrNetworkAlreadyExists && err != nil {
|
||||||
|
// Despite appearances to the contrary, CreateNetwork does
|
||||||
|
// sometimes(always?) *not* return ErrNetworkAlreadyExists
|
||||||
|
// when the network already exists. Hence we need to check for
|
||||||
|
// this explicitly.
|
||||||
|
if _, err2 := d.NetworkInfo(networkName); err2 != nil {
|
||||||
|
return fmt.Errorf("unable to create network: %s", err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func removePluginNetwork(args []string) error {
|
||||||
|
if len(args) != 1 {
|
||||||
|
cmdUsage("remove-plugin-network", "<network-name>")
|
||||||
|
}
|
||||||
|
networkName := args[0]
|
||||||
|
d, err := newDockerClient()
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
err = d.RemoveNetwork(networkName)
|
||||||
|
if _, ok := err.(*docker.NoSuchNetwork); !ok && err != nil {
|
||||||
|
return fmt.Errorf("unable to remove network: %s", err)
|
||||||
|
}
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func newDockerClient() (*docker.Client, error) {
|
||||||
|
// API 1.21 is the first version that supports docker network
|
||||||
|
// commands
|
||||||
|
c, err := docker.NewVersionedClientFromEnv("1.21")
|
||||||
|
if err != nil {
|
||||||
|
return nil, fmt.Errorf("unable to connect to docker: %s", err)
|
||||||
|
}
|
||||||
|
_, err = c.Version()
|
||||||
|
if err != nil {
|
||||||
|
return nil, fmt.Errorf("unable to connect to docker: %s", err)
|
||||||
|
}
|
||||||
|
return c, nil
|
||||||
|
}
|
||||||
+7
-35
@@ -3,10 +3,8 @@ package proxy
|
|||||||
import (
|
import (
|
||||||
"bytes"
|
"bytes"
|
||||||
"encoding/json"
|
"encoding/json"
|
||||||
"errors"
|
|
||||||
"fmt"
|
"fmt"
|
||||||
"io/ioutil"
|
"io/ioutil"
|
||||||
"net"
|
|
||||||
"net/http"
|
"net/http"
|
||||||
"os"
|
"os"
|
||||||
"os/exec"
|
"os/exec"
|
||||||
@@ -14,7 +12,7 @@ import (
|
|||||||
"strings"
|
"strings"
|
||||||
|
|
||||||
"github.com/fsouza/go-dockerclient"
|
"github.com/fsouza/go-dockerclient"
|
||||||
. "github.com/weaveworks/weave/common"
|
"github.com/weaveworks/weave/common"
|
||||||
)
|
)
|
||||||
|
|
||||||
var (
|
var (
|
||||||
@@ -22,6 +20,8 @@ var (
|
|||||||
weaveWaitEntrypoint = []string{"/w/w"}
|
weaveWaitEntrypoint = []string{"/w/w"}
|
||||||
weaveEntrypoint = "/home/weave/weaver"
|
weaveEntrypoint = "/home/weave/weaver"
|
||||||
weaveContainerName = "/weave"
|
weaveContainerName = "/weave"
|
||||||
|
|
||||||
|
Log = common.Log
|
||||||
)
|
)
|
||||||
|
|
||||||
func callWeave(args ...string) ([]byte, []byte, error) {
|
func callWeave(args ...string) ([]byte, []byte, error) {
|
||||||
@@ -29,7 +29,6 @@ func callWeave(args ...string) ([]byte, []byte, error) {
|
|||||||
cmd := exec.Command("./weave", args...)
|
cmd := exec.Command("./weave", args...)
|
||||||
cmd.Env = []string{
|
cmd.Env = []string{
|
||||||
"PATH=/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
|
"PATH=/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
|
||||||
"PROCFS=/hostproc",
|
|
||||||
}
|
}
|
||||||
|
|
||||||
propagateEnv := func(key string) {
|
propagateEnv := func(key string) {
|
||||||
@@ -38,16 +37,18 @@ func callWeave(args ...string) ([]byte, []byte, error) {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
propagateEnv("DOCKER_BRIDGE")
|
|
||||||
propagateEnv("DOCKER_HOST")
|
propagateEnv("DOCKER_HOST")
|
||||||
|
|
||||||
// Propogage WEAVE_DEBUG, to make debugging easier.
|
// Propagate WEAVE_DEBUG, to make debugging easier.
|
||||||
propagateEnv("WEAVE_DEBUG")
|
propagateEnv("WEAVE_DEBUG")
|
||||||
|
|
||||||
// This prevents the code coverage contortions in our
|
// This prevents the code coverage contortions in our
|
||||||
// integration test suite breaking things.
|
// integration test suite breaking things.
|
||||||
propagateEnv("COVERAGE")
|
propagateEnv("COVERAGE")
|
||||||
|
|
||||||
|
// In case the router control endpoint address is non-standard.
|
||||||
|
propagateEnv("WEAVE_HTTP_ADDR")
|
||||||
|
|
||||||
Log.Debug("Calling weave args: ", args, "env: ", cmd.Env)
|
Log.Debug("Calling weave args: ", args, "env: ", cmd.Env)
|
||||||
var stdout, stderr bytes.Buffer
|
var stdout, stderr bytes.Buffer
|
||||||
cmd.Stdout = &stdout
|
cmd.Stdout = &stdout
|
||||||
@@ -128,35 +129,6 @@ func inspectContainerInPath(client *docker.Client, path string) (*docker.Contain
|
|||||||
return container, err
|
return container, err
|
||||||
}
|
}
|
||||||
|
|
||||||
func weaveContainerIPs(containerID string) (mac string, ips []net.IP, nets []*net.IPNet, err error) {
|
|
||||||
stdout, stderr, err := callWeave("ps", containerID)
|
|
||||||
if err != nil || len(stderr) > 0 {
|
|
||||||
err = errors.New(string(stderr))
|
|
||||||
return
|
|
||||||
}
|
|
||||||
if len(stdout) <= 0 {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
fields := strings.Fields(string(stdout))
|
|
||||||
if len(fields) < 2 {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
mac = fields[1]
|
|
||||||
|
|
||||||
var ip net.IP
|
|
||||||
var ipnet *net.IPNet
|
|
||||||
for _, cidr := range fields[2:] {
|
|
||||||
ip, ipnet, err = net.ParseCIDR(cidr)
|
|
||||||
if err != nil {
|
|
||||||
return
|
|
||||||
}
|
|
||||||
ips = append(ips, ip)
|
|
||||||
nets = append(nets, ipnet)
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
func addVolume(hostConfig jsonObject, source, target, mode string) error {
|
func addVolume(hostConfig jsonObject, source, target, mode string) error {
|
||||||
configBinds, err := hostConfig.StringArray("Binds")
|
configBinds, err := hostConfig.StringArray("Binds")
|
||||||
if err != nil {
|
if err != nil {
|
||||||
|
|||||||
@@ -6,7 +6,6 @@ import (
|
|||||||
"strings"
|
"strings"
|
||||||
|
|
||||||
"github.com/fsouza/go-dockerclient"
|
"github.com/fsouza/go-dockerclient"
|
||||||
. "github.com/weaveworks/weave/common"
|
|
||||||
)
|
)
|
||||||
|
|
||||||
const MaxDockerHostname = 64
|
const MaxDockerHostname = 64
|
||||||
|
|||||||
Loaded 100 of 251 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user