From a311623bb9ac4984a0c60d17e7289970491c9a79 Mon Sep 17 00:00:00 2001 From: David Wragg Date: Tue, 19 May 2015 11:00:57 +0100 Subject: [PATCH 01/82] Eliminate the Start method on LocalConnection --- router/connection.go | 21 +++++++++------------ router/local_peer.go | 3 +-- router/router.go | 3 +-- 3 files changed, 11 insertions(+), 16 deletions(-) diff --git a/router/connection.go b/router/connection.go index adf9e04c..3d15c269 100644 --- a/router/connection.go +++ b/router/connection.go @@ -98,26 +98,23 @@ func (conn *RemoteConnection) String() string { return fmt.Sprint("Connection ", from, "->", to) } -func NewLocalConnection(connRemote *RemoteConnection, tcpConn *net.TCPConn, udpAddr *net.UDPAddr, router *Router) *LocalConnection { +// 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, udpAddr *net.UDPAddr, router *Router, acceptNewPeer bool) { if connRemote.local != router.Ourself.Peer { log.Fatal("Attempt to create local connection from a peer which is not ourself") } // NB, we're taking a copy of connRemote here. - return &LocalConnection{ + actionChan := make(chan ConnectionAction, ChannelSize) + finished := make(chan struct{}) + conn := &LocalConnection{ RemoteConnection: *connRemote, Router: router, TCPConn: tcpConn, remoteUDPAddr: udpAddr, - effectivePMTU: DefaultPMTU} -} - -// Async. Does not return anything. If the connection is successful, -// it will end up in the local peer's connections map. -func (conn *LocalConnection) Start(acceptNewPeer bool) { - actionChan := make(chan ConnectionAction, ChannelSize) - conn.actionChan = actionChan - finished := make(chan struct{}) - conn.finished = finished + effectivePMTU: DefaultPMTU, + actionChan: actionChan, + finished: finished} go conn.run(actionChan, finished, acceptNewPeer) } diff --git a/router/local_peer.go b/router/local_peer.go index 09498629..0a15076d 100644 --- a/router/local_peer.go +++ b/router/local_peer.go @@ -132,8 +132,7 @@ func (peer *LocalPeer) CreateConnection(peerAddr string, acceptNewPeer bool) err return err } connRemote := NewRemoteConnection(peer.Peer, nil, tcpConn.RemoteAddr().String(), true, false) - connLocal := NewLocalConnection(connRemote, tcpConn, udpAddr, peer.router) - connLocal.Start(acceptNewPeer) + StartLocalConnection(connRemote, tcpConn, udpAddr, peer.router, acceptNewPeer) return nil } diff --git a/router/router.go b/router/router.go index ab671a0d..520ca080 100644 --- a/router/router.go +++ b/router/router.go @@ -224,8 +224,7 @@ func (router *Router) acceptTCP(tcpConn *net.TCPConn) { remoteAddrStr := tcpConn.RemoteAddr().String() log.Printf("->[%s] connection accepted\n", remoteAddrStr) connRemote := NewRemoteConnection(router.Ourself.Peer, nil, remoteAddrStr, false, false) - connLocal := NewLocalConnection(connRemote, tcpConn, nil, router) - connLocal.Start(true) + StartLocalConnection(connRemote, tcpConn, nil, router, true) } func (router *Router) listenUDP(localPort int, po PacketSink) *net.UDPConn { From d6bceb139ee12eaaa1f5bf00e65c0128227939d8 Mon Sep 17 00:00:00 2001 From: David Wragg Date: Tue, 19 May 2015 11:12:41 +0100 Subject: [PATCH 02/82] Eliminate MacCache Start method --- router/mac_cache.go | 6 ++---- router/router.go | 1 - 2 files changed, 2 insertions(+), 5 deletions(-) diff --git a/router/mac_cache.go b/router/mac_cache.go index d251d194..5eb03f41 100644 --- a/router/mac_cache.go +++ b/router/mac_cache.go @@ -22,14 +22,12 @@ type MacCache struct { } func NewMacCache(maxAge time.Duration, onExpiry func(net.HardwareAddr, *Peer)) *MacCache { - return &MacCache{ + cache := &MacCache{ table: make(map[uint64]*MacCacheEntry), maxAge: maxAge, onExpiry: onExpiry} -} - -func (cache *MacCache) Start() { cache.setExpiryTimer() + return cache } func (cache *MacCache) Enter(mac net.HardwareAddr, peer *Peer) bool { diff --git a/router/router.go b/router/router.go index 520ca080..b5f40071 100644 --- a/router/router.go +++ b/router/router.go @@ -96,7 +96,6 @@ func (router *Router) Start() { checkFatal(err) } router.Ourself.Start() - router.Macs.Start() router.Routes.Start() router.ConnectionMaker.Start() router.UDPListener = router.listenUDP(router.Port, po) From 72039bbe5a308a5dd6a93ed3950fb1b1186fb645 Mon Sep 17 00:00:00 2001 From: David Wragg Date: Tue, 19 May 2015 11:14:45 +0100 Subject: [PATCH 03/82] Eliminate the LocalPeer Start method --- router/local_peer.go | 11 ++++++----- router/router.go | 1 - 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/router/local_peer.go b/router/local_peer.go index 0a15076d..b9ea939b 100644 --- a/router/local_peer.go +++ b/router/local_peer.go @@ -18,13 +18,14 @@ type LocalPeer struct { type LocalPeerAction func() func NewLocalPeer(name PeerName, nickName string, router *Router) *LocalPeer { - return &LocalPeer{Peer: NewPeer(name, nickName, 0, 0), router: router} -} - -func (peer *LocalPeer) Start() { actionChan := make(chan LocalPeerAction, ChannelSize) - peer.actionChan = actionChan + peer := &LocalPeer{ + Peer: NewPeer(name, nickName, 0, 0), + router: router, + actionChan: actionChan, + } go peer.actorLoop(actionChan) + return peer } func (peer *LocalPeer) Forward(dstPeer *Peer, df bool, frame []byte, dec *EthernetDecoder) error { diff --git a/router/router.go b/router/router.go index b5f40071..c3cc1464 100644 --- a/router/router.go +++ b/router/router.go @@ -95,7 +95,6 @@ func (router *Router) Start() { po, err = NewPcapO(router.Iface.Name) checkFatal(err) } - router.Ourself.Start() router.Routes.Start() router.ConnectionMaker.Start() router.UDPListener = router.listenUDP(router.Port, po) From ae1805de76e8bc76de986955897d5ad1f82c5061 Mon Sep 17 00:00:00 2001 From: Matthias Radestock Date: Tue, 23 Jun 2015 19:33:01 +0100 Subject: [PATCH 04/82] separate the image build and export phases That way the export can be just a single tar, which is more convenient. And without introducing unnecessary image builds. --- .gitignore | 5 +++-- Makefile | 31 ++++++++++++++++++------------- site/building.md | 11 ++++------- test/setup.sh | 2 -- 4 files changed, 25 insertions(+), 24 deletions(-) diff --git a/.gitignore b/.gitignore index 6c9406eb..609b440f 100644 --- a/.gitignore +++ b/.gitignore @@ -39,9 +39,10 @@ prog/netcheck/netcheck tools/bin tools/build releases +.weaver.uptodate +.weavedns.uptodate +.weaveexec.uptodate weave.tar -weavedns.tar -weaveexec.tar prog/weaveexec/weave prog/weaveexec/weaveproxy prog/weaveexec/weavewait diff --git a/Makefile b/Makefile index bfd649ee..5031dede 100644 --- a/Makefile +++ b/Makefile @@ -18,23 +18,25 @@ NETCHECK_EXE=prog/netcheck/netcheck EXES=$(WEAVER_EXE) $(WEAVEDNS_EXE) $(SIGPROXY_EXE) $(WEAVEPROXY_EXE) $(WEAVEWAIT_EXE) $(NETCHECK_EXE) +WEAVER_UPTODATE=.weaver.uptodate +WEAVEDNS_UPTODATE=.weavedns.uptodate +WEAVEEXEC_UPTODATE=.weaveexec.uptodate + +IMAGES_UPTODATE=$(WEAVER_UPTODATE) $(WEAVEDNS_UPTODATE) $(WEAVEEXEC_UPTODATE) + WEAVER_IMAGE=$(DOCKERHUB_USER)/weave WEAVEDNS_IMAGE=$(DOCKERHUB_USER)/weavedns WEAVEEXEC_IMAGE=$(DOCKERHUB_USER)/weaveexec IMAGES=$(WEAVER_IMAGE) $(WEAVEDNS_IMAGE) $(WEAVEEXEC_IMAGE) -WEAVER_EXPORT=weave.tar -WEAVEDNS_EXPORT=weavedns.tar -WEAVEEXEC_EXPORT=weaveexec.tar - -EXPORTS=$(WEAVER_EXPORT) $(WEAVEDNS_EXPORT) $(WEAVEEXEC_EXPORT) +WEAVE_EXPORT=weave.tar WEAVEEXEC_DOCKER_VERSION=1.3.1 DOCKER_DISTRIB=prog/weaveexec/docker-$(WEAVEEXEC_DOCKER_VERSION).tgz DOCKER_DISTRIB_URL=https://get.docker.com/builds/Linux/x86_64/docker-$(WEAVEEXEC_DOCKER_VERSION).tgz -all: $(EXPORTS) +all: $(WEAVE_EXPORT) travis: $(EXES) @@ -66,15 +68,15 @@ $(SIGPROXY_EXE): prog/sigproxy/main.go $(WEAVEWAIT_EXE): prog/weavewait/main.go go build -o $@ ./$(@D) -$(WEAVER_EXPORT): prog/weaver/Dockerfile $(WEAVER_EXE) +$(WEAVER_UPTODATE): prog/weaver/Dockerfile $(WEAVER_EXE) $(SUDO) docker build -t $(WEAVER_IMAGE) prog/weaver - $(SUDO) docker save $(WEAVER_IMAGE):latest > $@ + touch $@ -$(WEAVEDNS_EXPORT): prog/weavedns/Dockerfile $(WEAVEDNS_EXE) +$(WEAVEDNS_UPTODATE): prog/weavedns/Dockerfile $(WEAVEDNS_EXE) $(SUDO) docker build -t $(WEAVEDNS_IMAGE) prog/weavedns - $(SUDO) docker save $(WEAVEDNS_IMAGE):latest > $@ + touch $@ -$(WEAVEEXEC_EXPORT): prog/weaveexec/Dockerfile $(DOCKER_DISTRIB) weave $(SIGPROXY_EXE) $(WEAVEPROXY_EXE) $(WEAVEWAIT_EXE) $(NETCHECK_EXE) +$(WEAVEEXEC_UPTODATE): prog/weaveexec/Dockerfile $(DOCKER_DISTRIB) weave $(SIGPROXY_EXE) $(WEAVEPROXY_EXE) $(WEAVEWAIT_EXE) $(NETCHECK_EXE) cp weave prog/weaveexec/weave cp $(SIGPROXY_EXE) prog/weaveexec/sigproxy cp $(WEAVEPROXY_EXE) prog/weaveexec/weaveproxy @@ -82,7 +84,10 @@ $(WEAVEEXEC_EXPORT): prog/weaveexec/Dockerfile $(DOCKER_DISTRIB) weave $(SIGPROX cp $(NETCHECK_EXE) prog/weaveexec/netcheck cp $(DOCKER_DISTRIB) prog/weaveexec/docker.tgz $(SUDO) docker build -t $(WEAVEEXEC_IMAGE) prog/weaveexec - $(SUDO) docker save $(WEAVEEXEC_IMAGE):latest > $@ + touch $@ + +$(WEAVE_EXPORT): $(IMAGES_UPTODATE) + $(SUDO) docker save $(addsuffix :latest,$(IMAGES)) > $@ $(DOCKER_DISTRIB): curl -o $(DOCKER_DISTRIB) $(DOCKER_DISTRIB_URL) @@ -112,7 +117,7 @@ publish: $(PUBLISH) clean: -$(SUDO) docker rmi $(IMAGES) - rm -f $(EXES) $(EXPORTS) + rm -f $(EXES) $(IMAGES_UPTODATE) $(WEAVE_EXPORT) rm -f test/tls/*.pem build: diff --git a/site/building.md b/site/building.md index 04b998ab..4b91d59f 100644 --- a/site/building.md +++ b/site/building.md @@ -57,8 +57,7 @@ $ make This will build the weave components and package them into three Docker images (`weaveworks/weave`, `weaveworks/weavedns`, and -`weaveworks/weaveexec`). These are then exported (as `weave.tar`, -`weavedns.tar` and `weaveexec.tar`). +`weaveworks/weaveexec`). These are then exported as `weave.tar`. ## Building in a Docker container @@ -171,15 +170,13 @@ you can do so with $ vagrant ssh -c 'make -C src/github.com/weaveworks/weave' ``` -you should then find container snapshot tarballs in the top-level -directory. You can use these snapshots with `docker load` against a -different host, e.g. +you should then find a `weave.tar` container snapshot tarball in the +top-level directory. You can use that snapshot with `docker load` +against a different host, e.g. ```bash $ export DOCKER_HOST=tcp:// $ docker load < weave.tar -$ docker load < weavedns.tar -$ docker load < weaveexec.tar ``` You can provide extra Vagrant configuration by putting a file diff --git a/test/setup.sh b/test/setup.sh index d2b49f01..7235b4a4 100755 --- a/test/setup.sh +++ b/test/setup.sh @@ -10,8 +10,6 @@ echo "Copying weave images, scripts, and certificates to hosts, and" echo " prefetch test images" for HOST in $HOSTS; do docker_on $HOST load -i ../weave.tar - docker_on $HOST load -i ../weavedns.tar - docker_on $HOST load -i ../weaveexec.tar run_on $HOST mkdir -p bin cat ../bin/docker-ns | run_on $HOST sh -c "cat > $DOCKER_NS" cat ../weave | run_on $HOST sh -c "cat > ./weave" From bdda9d03ae05ba52c03a5e8713d3d85b97ed0dca Mon Sep 17 00:00:00 2001 From: Matthias Radestock Date: Wed, 24 Jun 2015 02:59:24 +0100 Subject: [PATCH 05/82] bump docker version in weave-build docker image to 1.3.1, the same version we use everywhere else, e.g. in weavexec. --- build/Dockerfile | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/build/Dockerfile b/build/Dockerfile index 562673c8..23861bdf 100644 --- a/build/Dockerfile +++ b/build/Dockerfile @@ -1,6 +1,9 @@ FROM ubuntu -RUN apt-get -y update && apt-get -y install --no-install-recommends build-essential git ca-certificates docker.io mercurial libpcap-dev curl make pkg-config gcc bison flex +RUN apt-get -y update && apt-get -y install --no-install-recommends ca-certificates apt-transport-https +RUN apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 36A1D7869245C8950F966E92D8576A8BA88D21E9 +RUN echo deb https://get.docker.io/ubuntu docker main > /etc/apt/sources.list.d/docker.list +RUN apt-get -y update && apt-get -y install --no-install-recommends build-essential git lxc-docker-1.3.1 mercurial libpcap-dev curl make pkg-config gcc bison flex # When doing a build in a container, "apt-get update" happens twice, # which can be a very significant overhead for incremental builds. From e3574f243f2e5331e93266debf9c8ddfee32c858 Mon Sep 17 00:00:00 2001 From: Fintan Ryan Date: Wed, 24 Jun 2015 10:35:12 +0100 Subject: [PATCH 06/82] Remove Link to Dockercon from README --- README.md | 2 -- 1 file changed, 2 deletions(-) diff --git a/README.md b/README.md index 37392793..792c298f 100644 --- a/README.md +++ b/README.md @@ -4,8 +4,6 @@ # About Weaveworks -[Come meet Weaveworks at Dockercon](http://weave.works/dockercon) - [Weaveworks](http://weave.works) is the company that develops Weave - the most productive way for developers to connect, observe and control Docker containers. To learn about our products, including getting started tutorials, visit our [website](http://weave.works), read about the [1.0 release of Weave](http://blog.weave.works/2015/06/18/weave-1-0-is-out-and-it-is-good/), visit our [documentation](http://docs.weave.works) or continue to read about some of the more technical aspects of Weave in this readme. # Weave From 4b11874390f20ab1bb8d5d6797463992738ce080 Mon Sep 17 00:00:00 2001 From: Matthias Radestock Date: Tue, 23 Jun 2015 17:12:51 +0100 Subject: [PATCH 07/82] sleep for 0.1s instead of 1s in the wait_for_status loop This reduces `weave launch|launch-dns` execution time. Closes #992. --- weave | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/weave b/weave index 9c6533d2..7b58efb1 100755 --- a/weave +++ b/weave @@ -183,6 +183,21 @@ command_exists() { command -v $1 >/dev/null 2>&1 } +fractional_sleep() { + case $1 in + *.*) + if [ -z "$NO_FRACTIONAL_SLEEP" ] ; then + sleep $1 >/dev/null 2>&1 && return 0 + NO_FRACTIONAL_SLEEP=1 + fi + sleep $((${1%.*} + 1)) + ;; + *) + sleep $1 + ;; + esac +} + run_iptables() { # -w is recent addition to iptables if [ -z "$CHECKED_IPTABLES_W" ] ; then @@ -585,7 +600,7 @@ wait_for_status() { echo "$err_msg" >&2 return 1 fi - sleep 1 + fractional_sleep 0.1 done } From 409961fff3188ddecae9c948f29218e5f88812ca Mon Sep 17 00:00:00 2001 From: Adam Harrison Date: Wed, 24 Jun 2015 10:56:34 +0100 Subject: [PATCH 08/82] Rename launch to launch-router --- weave | 36 ++++++++++++++++++------------------ 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/weave b/weave index 9c6533d2..ad52497b 100755 --- a/weave +++ b/weave @@ -26,22 +26,22 @@ CIDR_REGEXP="$IP_REGEXP/[0-9]{1,2}" usage() { echo "Usage:" echo "weave setup" - echo "weave launch [-password ] [-nickname ] [-nodiscovery]" - echo " [-iprange [-ipsubnet ]] ..." - echo "weave launch-dns []" - echo "weave launch-proxy [-H ] [--with-dns | --without-dns]" - echo " [--no-default-ipam]" - echo "weave connect [--replace] [ ...]" - echo "weave forget ..." - echo "weave run [--with-dns | --without-dns] [ ...] ..." - echo "weave start [ ...] " - echo "weave attach [ ...] " - echo "weave detach [ ...] " - echo "weave dns-add [ ...] [-h ]" - echo "weave dns-remove [ ...] [-h ]" - echo "weave expose [ ...] [-h ]" - echo "weave hide [ ...]" - echo "weave ps [ ...]" + echo "weave launch-router [-password ] [-nickname ] [-nodiscovery]" + echo " [-iprange [-ipsubnet ]] ..." + echo "weave launch-dns []" + echo "weave launch-proxy [-H ] [--with-dns | --without-dns]" + echo " [--no-default-ipam]" + echo "weave connect [--replace] [ ...]" + echo "weave forget ..." + echo "weave run [--with-dns | --without-dns] [ ...] ..." + echo "weave start [ ...] " + echo "weave attach [ ...] " + echo "weave detach [ ...] " + echo "weave dns-add [ ...] [-h ]" + echo "weave dns-remove [ ...] [-h ]" + echo "weave expose [ ...] [-h ]" + echo "weave hide [ ...]" + echo "weave ps [ ...]" echo "weave status" echo "weave proxy-env" echo "weave proxy-config" @@ -50,7 +50,7 @@ usage() { echo "weave stop-dns" echo "weave stop-proxy" echo "weave reset" - echo "weave rmpeer " + echo "weave rmpeer " echo echo "where = [:]" echo " = /" @@ -977,7 +977,7 @@ case "$COMMAND" in create-bridge) create_bridge --without-ethtool ;; - launch) + launch-router) check_not_running $CONTAINER_NAME $BASE_IMAGE create_bridge # We set the router name to the bridge mac since that is From 8250e056189d33e4723c21974bab4a5e8deb8a13 Mon Sep 17 00:00:00 2001 From: David Kaltschmidt Date: Wed, 24 Jun 2015 14:37:41 +0200 Subject: [PATCH 09/82] include stylesheet in repo, update footer need because website's custom.css is fingerprinted --- site/_includes/footer.html | 27 +- site/_includes/header-navbaronly.html | 14 +- site/_layouts/default.html | 6 +- site/assets/custom.css | 5880 +++++++++++++++++++++++++ 4 files changed, 5910 insertions(+), 17 deletions(-) create mode 100644 site/assets/custom.css diff --git a/site/_includes/footer.html b/site/_includes/footer.html index e569c16e..1d114958 100644 --- a/site/_includes/footer.html +++ b/site/_includes/footer.html @@ -2,38 +2,49 @@
-
+
Company
About Weave
- + Meet the Team
Blog
-
+ Learn More
+
+
Community
Partners
Code
-
+
Documentation
Docs
Getting Started Guides
Help and Support
Blog
-
+
Get in Touch
- help@weave.works
+ Twitter
Github
Slideshare
Linkedin
GooglePlus
+
-
+


-
+

© Weaveworks 2014 ‐ 2015

diff --git a/site/_includes/header-navbaronly.html b/site/_includes/header-navbaronly.html index 393938ba..fc5a9ce7 100644 --- a/site/_includes/header-navbaronly.html +++ b/site/_includes/header-navbaronly.html @@ -1,9 +1,10 @@ -
- +
diff --git a/site/_layouts/default.html b/site/_layouts/default.html index 81c13686..cafadc71 100644 --- a/site/_layouts/default.html +++ b/site/_layouts/default.html @@ -19,7 +19,7 @@ - + @@ -33,8 +33,8 @@
{% include header-navbaronly.html %} -
-
+
+
{{ content }}
diff --git a/site/assets/custom.css b/site/assets/custom.css new file mode 100644 index 00000000..34a32cdd --- /dev/null +++ b/site/assets/custom.css @@ -0,0 +1,5880 @@ +@import url(http://fonts.googleapis.com/css?family=Raleway:400,300,600); +/*! normalize.css v3.0.2 | MIT License | git.io/normalize */ +html { + font-family: sans-serif; + -ms-text-size-adjust: 100%; + -webkit-text-size-adjust: 100%; +} +body { + margin: 0; +} +article, +aside, +details, +figcaption, +figure, +footer, +header, +hgroup, +main, +menu, +nav, +section, +summary { + display: block; +} +audio, +canvas, +progress, +video { + display: inline-block; + vertical-align: baseline; +} +audio:not([controls]) { + display: none; + height: 0; +} +[hidden], +template { + display: none; +} +a { + background-color: transparent; +} +a:active, +a:hover { + outline: 0; +} +abbr[title] { + border-bottom: 1px dotted; +} +b, +strong { + font-weight: bold; +} +dfn { + font-style: italic; +} +h1 { + font-size: 2em; + margin: 0.67em 0; +} +mark { + background: #ff0; + color: #000; +} +small { + font-size: 80%; +} +sub, +sup { + font-size: 75%; + line-height: 0; + position: relative; + vertical-align: baseline; +} +sup { + top: -0.5em; +} +sub { + bottom: -0.25em; +} +img { + border: 0; +} +svg:not(:root) { + overflow: hidden; +} +figure { + margin: 1em 40px; +} +hr { + -moz-box-sizing: content-box; + box-sizing: content-box; + height: 0; +} +pre { + overflow: auto; +} +code, +kbd, +pre, +samp { + font-family: monospace, monospace; + font-size: 1em; +} +button, +input, +optgroup, +select, +textarea { + color: inherit; + font: inherit; + margin: 0; +} +button { + overflow: visible; +} +button, +select { + text-transform: none; +} +button, +html input[type="button"], +input[type="reset"], +input[type="submit"] { + -webkit-appearance: button; + cursor: pointer; +} +button[disabled], +html input[disabled] { + cursor: default; +} +button::-moz-focus-inner, +input::-moz-focus-inner { + border: 0; + padding: 0; +} +input { + line-height: normal; +} +input[type="checkbox"], +input[type="radio"] { + box-sizing: border-box; + padding: 0; +} +input[type="number"]::-webkit-inner-spin-button, +input[type="number"]::-webkit-outer-spin-button { + height: auto; +} +input[type="search"] { + -webkit-appearance: textfield; + -moz-box-sizing: content-box; + -webkit-box-sizing: content-box; + box-sizing: content-box; +} +input[type="search"]::-webkit-search-cancel-button, +input[type="search"]::-webkit-search-decoration { + -webkit-appearance: none; +} +fieldset { + border: 1px solid #c0c0c0; + margin: 0 2px; + padding: 0.35em 0.625em 0.75em; +} +legend { + border: 0; + padding: 0; +} +textarea { + overflow: auto; +} +optgroup { + font-weight: bold; +} +table { + border-collapse: collapse; + border-spacing: 0; +} +td, +th { + padding: 0; +} +/*! Source: https://github.com/h5bp/html5-boilerplate/blob/master/src/css/main.css */ +@media print { + *, + *:before, + *:after { + background: transparent !important; + color: #000 !important; + box-shadow: none !important; + text-shadow: none !important; + } + a, + a:visited { + text-decoration: underline; + } + a[href]:after { + content: " (" attr(href) ")"; + } + abbr[title]:after { + content: " (" attr(title) ")"; + } + a[href^="#"]:after, + a[href^="javascript:"]:after { + content: ""; + } + pre, + blockquote { + border: 1px solid #999; + page-break-inside: avoid; + } + thead { + display: table-header-group; + } + tr, + img { + page-break-inside: avoid; + } + img { + max-width: 100% !important; + } + p, + h2, + h3 { + orphans: 3; + widows: 3; + } + h2, + h3 { + page-break-after: avoid; + } + select { + background: #fff !important; + } + .navbar { + display: none; + } + .btn > .caret, + .dropup > .btn > .caret { + border-top-color: #000 !important; + } + .label { + border: 1px solid #000; + } + .table { + border-collapse: collapse !important; + } + .table td, + .table th { + background-color: #fff !important; + } + .table-bordered th, + .table-bordered td { + border: 1px solid #ddd !important; + } +} +@font-face { + font-family: 'Glyphicons Halflings'; + src: url('../fonts/glyphicons-halflings-regular.eot'); + src: url('../fonts/glyphicons-halflings-regular.eot?#iefix') format('embedded-opentype'), url('../fonts/glyphicons-halflings-regular.woff2') format('woff2'), url('../fonts/glyphicons-halflings-regular.woff') format('woff'), url('../fonts/glyphicons-halflings-regular.ttf') format('truetype'), url('../fonts/glyphicons-halflings-regular.svg#glyphicons_halflingsregular') format('svg'); +} +.glyphicon { + position: relative; + top: 1px; + display: inline-block; + font-family: 'Glyphicons Halflings'; + font-style: normal; + font-weight: normal; + line-height: 1; + -webkit-font-smoothing: antialiased; + -moz-osx-font-smoothing: grayscale; +} +.glyphicon-asterisk:before { + content: "\2a"; +} +.glyphicon-plus:before { + content: "\2b"; +} +.glyphicon-euro:before, +.glyphicon-eur:before { + content: "\20ac"; +} +.glyphicon-minus:before { + content: "\2212"; +} +.glyphicon-cloud:before { + content: "\2601"; +} +.glyphicon-envelope:before { + content: "\2709"; +} +.glyphicon-pencil:before { + content: "\270f"; +} +.glyphicon-glass:before { + content: "\e001"; +} +.glyphicon-music:before { + content: "\e002"; +} +.glyphicon-search:before { + content: "\e003"; +} +.glyphicon-heart:before { + content: "\e005"; +} +.glyphicon-star:before { + content: "\e006"; +} +.glyphicon-star-empty:before { + content: "\e007"; +} +.glyphicon-user:before { + content: "\e008"; +} +.glyphicon-film:before { + content: "\e009"; +} +.glyphicon-th-large:before { + content: "\e010"; +} +.glyphicon-th:before { + content: "\e011"; +} +.glyphicon-th-list:before { + content: "\e012"; +} +.glyphicon-ok:before { + content: "\e013"; +} +.glyphicon-remove:before { + content: "\e014"; +} +.glyphicon-zoom-in:before { + content: "\e015"; +} +.glyphicon-zoom-out:before { + content: "\e016"; +} +.glyphicon-off:before { + content: "\e017"; +} +.glyphicon-signal:before { + content: "\e018"; +} +.glyphicon-cog:before { + content: "\e019"; +} +.glyphicon-trash:before { + content: "\e020"; +} +.glyphicon-home:before { + content: "\e021"; +} +.glyphicon-file:before { + content: "\e022"; +} +.glyphicon-time:before { + content: "\e023"; +} +.glyphicon-road:before { + content: "\e024"; +} +.glyphicon-download-alt:before { + content: "\e025"; +} +.glyphicon-download:before { + content: "\e026"; +} +.glyphicon-upload:before { + content: "\e027"; +} +.glyphicon-inbox:before { + content: "\e028"; +} +.glyphicon-play-circle:before { + content: "\e029"; +} +.glyphicon-repeat:before { + content: "\e030"; +} +.glyphicon-refresh:before { + content: "\e031"; +} +.glyphicon-list-alt:before { + content: "\e032"; +} +.glyphicon-lock:before { + content: "\e033"; +} +.glyphicon-flag:before { + content: "\e034"; +} +.glyphicon-headphones:before { + content: "\e035"; +} +.glyphicon-volume-off:before { + content: "\e036"; +} +.glyphicon-volume-down:before { + content: "\e037"; +} +.glyphicon-volume-up:before { + content: "\e038"; +} +.glyphicon-qrcode:before { + content: "\e039"; +} +.glyphicon-barcode:before { + content: "\e040"; +} +.glyphicon-tag:before { + content: "\e041"; +} +.glyphicon-tags:before { + content: "\e042"; +} +.glyphicon-book:before { + content: "\e043"; +} +.glyphicon-bookmark:before { + content: "\e044"; +} +.glyphicon-print:before { + content: "\e045"; +} +.glyphicon-camera:before { + content: "\e046"; +} +.glyphicon-font:before { + content: "\e047"; +} +.glyphicon-bold:before { + content: "\e048"; +} +.glyphicon-italic:before { + content: "\e049"; +} +.glyphicon-text-height:before { + content: "\e050"; +} +.glyphicon-text-width:before { + content: "\e051"; +} +.glyphicon-align-left:before { + content: "\e052"; +} +.glyphicon-align-center:before { + content: "\e053"; +} +.glyphicon-align-right:before { + content: "\e054"; +} +.glyphicon-align-justify:before { + content: "\e055"; +} +.glyphicon-list:before { + content: "\e056"; +} +.glyphicon-indent-left:before { + content: "\e057"; +} +.glyphicon-indent-right:before { + content: "\e058"; +} +.glyphicon-facetime-video:before { + content: "\e059"; +} +.glyphicon-picture:before { + content: "\e060"; +} +.glyphicon-map-marker:before { + content: "\e062"; +} +.glyphicon-adjust:before { + content: "\e063"; +} +.glyphicon-tint:before { + content: "\e064"; +} +.glyphicon-edit:before { + content: "\e065"; +} +.glyphicon-share:before { + content: "\e066"; +} +.glyphicon-check:before { + content: "\e067"; +} +.glyphicon-move:before { + content: "\e068"; +} +.glyphicon-step-backward:before { + content: "\e069"; +} +.glyphicon-fast-backward:before { + content: "\e070"; +} +.glyphicon-backward:before { + content: "\e071"; +} +.glyphicon-play:before { + content: "\e072"; +} +.glyphicon-pause:before { + content: "\e073"; +} +.glyphicon-stop:before { + content: "\e074"; +} +.glyphicon-forward:before { + content: "\e075"; +} +.glyphicon-fast-forward:before { + content: "\e076"; +} +.glyphicon-step-forward:before { + content: "\e077"; +} +.glyphicon-eject:before { + content: "\e078"; +} +.glyphicon-chevron-left:before { + content: "\e079"; +} +.glyphicon-chevron-right:before { + content: "\e080"; +} +.glyphicon-plus-sign:before { + content: "\e081"; +} +.glyphicon-minus-sign:before { + content: "\e082"; +} +.glyphicon-remove-sign:before { + content: "\e083"; +} +.glyphicon-ok-sign:before { + content: "\e084"; +} +.glyphicon-question-sign:before { + content: "\e085"; +} +.glyphicon-info-sign:before { + content: "\e086"; +} +.glyphicon-screenshot:before { + content: "\e087"; +} +.glyphicon-remove-circle:before { + content: "\e088"; +} +.glyphicon-ok-circle:before { + content: "\e089"; +} +.glyphicon-ban-circle:before { + content: "\e090"; +} +.glyphicon-arrow-left:before { + content: "\e091"; +} +.glyphicon-arrow-right:before { + content: "\e092"; +} +.glyphicon-arrow-up:before { + content: "\e093"; +} +.glyphicon-arrow-down:before { + content: "\e094"; +} +.glyphicon-share-alt:before { + content: "\e095"; +} +.glyphicon-resize-full:before { + content: "\e096"; +} +.glyphicon-resize-small:before { + content: "\e097"; +} +.glyphicon-exclamation-sign:before { + content: "\e101"; +} +.glyphicon-gift:before { + content: "\e102"; +} +.glyphicon-leaf:before { + content: "\e103"; +} +.glyphicon-fire:before { + content: "\e104"; +} +.glyphicon-eye-open:before { + content: "\e105"; +} +.glyphicon-eye-close:before { + content: "\e106"; +} +.glyphicon-warning-sign:before { + content: "\e107"; +} +.glyphicon-plane:before { + content: "\e108"; +} +.glyphicon-calendar:before { + content: "\e109"; +} +.glyphicon-random:before { + content: "\e110"; +} +.glyphicon-comment:before { + content: "\e111"; +} +.glyphicon-magnet:before { + content: "\e112"; +} +.glyphicon-chevron-up:before { + content: "\e113"; +} +.glyphicon-chevron-down:before { + content: "\e114"; +} +.glyphicon-retweet:before { + content: "\e115"; +} +.glyphicon-shopping-cart:before { + content: "\e116"; +} +.glyphicon-folder-close:before { + content: "\e117"; +} +.glyphicon-folder-open:before { + content: "\e118"; +} +.glyphicon-resize-vertical:before { + content: "\e119"; +} +.glyphicon-resize-horizontal:before { + content: "\e120"; +} +.glyphicon-hdd:before { + content: "\e121"; +} +.glyphicon-bullhorn:before { + content: "\e122"; +} +.glyphicon-bell:before { + content: "\e123"; +} +.glyphicon-certificate:before { + content: "\e124"; +} +.glyphicon-thumbs-up:before { + content: "\e125"; +} +.glyphicon-thumbs-down:before { + content: "\e126"; +} +.glyphicon-hand-right:before { + content: "\e127"; +} +.glyphicon-hand-left:before { + content: "\e128"; +} +.glyphicon-hand-up:before { + content: "\e129"; +} +.glyphicon-hand-down:before { + content: "\e130"; +} +.glyphicon-circle-arrow-right:before { + content: "\e131"; +} +.glyphicon-circle-arrow-left:before { + content: "\e132"; +} +.glyphicon-circle-arrow-up:before { + content: "\e133"; +} +.glyphicon-circle-arrow-down:before { + content: "\e134"; +} +.glyphicon-globe:before { + content: "\e135"; +} +.glyphicon-wrench:before { + content: "\e136"; +} +.glyphicon-tasks:before { + content: "\e137"; +} +.glyphicon-filter:before { + content: "\e138"; +} +.glyphicon-briefcase:before { + content: "\e139"; +} +.glyphicon-fullscreen:before { + content: "\e140"; +} +.glyphicon-dashboard:before { + content: "\e141"; +} +.glyphicon-paperclip:before { + content: "\e142"; +} +.glyphicon-heart-empty:before { + content: "\e143"; +} +.glyphicon-link:before { + content: "\e144"; +} +.glyphicon-phone:before { + content: "\e145"; +} +.glyphicon-pushpin:before { + content: "\e146"; +} +.glyphicon-usd:before { + content: "\e148"; +} +.glyphicon-gbp:before { + content: "\e149"; +} +.glyphicon-sort:before { + content: "\e150"; +} +.glyphicon-sort-by-alphabet:before { + content: "\e151"; +} +.glyphicon-sort-by-alphabet-alt:before { + content: "\e152"; +} +.glyphicon-sort-by-order:before { + content: "\e153"; +} +.glyphicon-sort-by-order-alt:before { + content: "\e154"; +} +.glyphicon-sort-by-attributes:before { + content: "\e155"; +} +.glyphicon-sort-by-attributes-alt:before { + content: "\e156"; +} +.glyphicon-unchecked:before { + content: "\e157"; +} +.glyphicon-expand:before { + content: "\e158"; +} +.glyphicon-collapse-down:before { + content: "\e159"; +} +.glyphicon-collapse-up:before { + content: "\e160"; +} +.glyphicon-log-in:before { + content: "\e161"; +} +.glyphicon-flash:before { + content: "\e162"; +} +.glyphicon-log-out:before { + content: "\e163"; +} +.glyphicon-new-window:before { + content: "\e164"; +} +.glyphicon-record:before { + content: "\e165"; +} +.glyphicon-save:before { + content: "\e166"; +} +.glyphicon-open:before { + content: "\e167"; +} +.glyphicon-saved:before { + content: "\e168"; +} +.glyphicon-import:before { + content: "\e169"; +} +.glyphicon-export:before { + content: "\e170"; +} +.glyphicon-send:before { + content: "\e171"; +} +.glyphicon-floppy-disk:before { + content: "\e172"; +} +.glyphicon-floppy-saved:before { + content: "\e173"; +} +.glyphicon-floppy-remove:before { + content: "\e174"; +} +.glyphicon-floppy-save:before { + content: "\e175"; +} +.glyphicon-floppy-open:before { + content: "\e176"; +} +.glyphicon-credit-card:before { + content: "\e177"; +} +.glyphicon-transfer:before { + content: "\e178"; +} +.glyphicon-cutlery:before { + content: "\e179"; +} +.glyphicon-header:before { + content: "\e180"; +} +.glyphicon-compressed:before { + content: "\e181"; +} +.glyphicon-earphone:before { + content: "\e182"; +} +.glyphicon-phone-alt:before { + content: "\e183"; +} +.glyphicon-tower:before { + content: "\e184"; +} +.glyphicon-stats:before { + content: "\e185"; +} +.glyphicon-sd-video:before { + content: "\e186"; +} +.glyphicon-hd-video:before { + content: "\e187"; +} +.glyphicon-subtitles:before { + content: "\e188"; +} +.glyphicon-sound-stereo:before { + content: "\e189"; +} +.glyphicon-sound-dolby:before { + content: "\e190"; +} +.glyphicon-sound-5-1:before { + content: "\e191"; +} +.glyphicon-sound-6-1:before { + content: "\e192"; +} +.glyphicon-sound-7-1:before { + content: "\e193"; +} +.glyphicon-copyright-mark:before { + content: "\e194"; +} +.glyphicon-registration-mark:before { + content: "\e195"; +} +.glyphicon-cloud-download:before { + content: "\e197"; +} +.glyphicon-cloud-upload:before { + content: "\e198"; +} +.glyphicon-tree-conifer:before { + content: "\e199"; +} +.glyphicon-tree-deciduous:before { + content: "\e200"; +} +.glyphicon-cd:before { + content: "\e201"; +} +.glyphicon-save-file:before { + content: "\e202"; +} +.glyphicon-open-file:before { + content: "\e203"; +} +.glyphicon-level-up:before { + content: "\e204"; +} +.glyphicon-copy:before { + content: "\e205"; +} +.glyphicon-paste:before { + content: "\e206"; +} +.glyphicon-alert:before { + content: "\e209"; +} +.glyphicon-equalizer:before { + content: "\e210"; +} +.glyphicon-king:before { + content: "\e211"; +} +.glyphicon-queen:before { + content: "\e212"; +} +.glyphicon-pawn:before { + content: "\e213"; +} +.glyphicon-bishop:before { + content: "\e214"; +} +.glyphicon-knight:before { + content: "\e215"; +} +.glyphicon-baby-formula:before { + content: "\e216"; +} +.glyphicon-tent:before { + content: "\26fa"; +} +.glyphicon-blackboard:before { + content: "\e218"; +} +.glyphicon-bed:before { + content: "\e219"; +} +.glyphicon-apple:before { + content: "\f8ff"; +} +.glyphicon-erase:before { + content: "\e221"; +} +.glyphicon-hourglass:before { + content: "\231b"; +} +.glyphicon-lamp:before { + content: "\e223"; +} +.glyphicon-duplicate:before { + content: "\e224"; +} +.glyphicon-piggy-bank:before { + content: "\e225"; +} +.glyphicon-scissors:before { + content: "\e226"; +} +.glyphicon-bitcoin:before { + content: "\e227"; +} +.glyphicon-btc:before { + content: "\e227"; +} +.glyphicon-xbt:before { + content: "\e227"; +} +.glyphicon-yen:before { + content: "\00a5"; +} +.glyphicon-jpy:before { + content: "\00a5"; +} +.glyphicon-ruble:before { + content: "\20bd"; +} +.glyphicon-rub:before { + content: "\20bd"; +} +.glyphicon-scale:before { + content: "\e230"; +} +.glyphicon-ice-lolly:before { + content: "\e231"; +} +.glyphicon-ice-lolly-tasted:before { + content: "\e232"; +} +.glyphicon-education:before { + content: "\e233"; +} +.glyphicon-option-horizontal:before { + content: "\e234"; +} +.glyphicon-option-vertical:before { + content: "\e235"; +} +.glyphicon-menu-hamburger:before { + content: "\e236"; +} +.glyphicon-modal-window:before { + content: "\e237"; +} +.glyphicon-oil:before { + content: "\e238"; +} +.glyphicon-grain:before { + content: "\e239"; +} +.glyphicon-sunglasses:before { + content: "\e240"; +} +.glyphicon-text-size:before { + content: "\e241"; +} +.glyphicon-text-color:before { + content: "\e242"; +} +.glyphicon-text-background:before { + content: "\e243"; +} +.glyphicon-object-align-top:before { + content: "\e244"; +} +.glyphicon-object-align-bottom:before { + content: "\e245"; +} +.glyphicon-object-align-horizontal:before { + content: "\e246"; +} +.glyphicon-object-align-left:before { + content: "\e247"; +} +.glyphicon-object-align-vertical:before { + content: "\e248"; +} +.glyphicon-object-align-right:before { + content: "\e249"; +} +.glyphicon-triangle-right:before { + content: "\e250"; +} +.glyphicon-triangle-left:before { + content: "\e251"; +} +.glyphicon-triangle-bottom:before { + content: "\e252"; +} +.glyphicon-triangle-top:before { + content: "\e253"; +} +.glyphicon-console:before { + content: "\e254"; +} +.glyphicon-superscript:before { + content: "\e255"; +} +.glyphicon-subscript:before { + content: "\e256"; +} +.glyphicon-menu-left:before { + content: "\e257"; +} +.glyphicon-menu-right:before { + content: "\e258"; +} +.glyphicon-menu-down:before { + content: "\e259"; +} +.glyphicon-menu-up:before { + content: "\e260"; +} +* { + -webkit-box-sizing: border-box; + -moz-box-sizing: border-box; + box-sizing: border-box; +} +*:before, +*:after { + -webkit-box-sizing: border-box; + -moz-box-sizing: border-box; + box-sizing: border-box; +} +html { + font-size: 10px; + -webkit-tap-highlight-color: rgba(0, 0, 0, 0); +} +body { + font-family: Raleway, "Helvetica Neue", Helvetica, Arial, sans-serif; + font-size: 11pt; + line-height: 1.6; + color: #81817f; + background-color: #ffffff; +} +input, +button, +select, +textarea { + font-family: inherit; + font-size: inherit; + line-height: inherit; +} +a { + color: #7f90b4; + text-decoration: none; +} +a:hover, +a:focus { + color: #afbad0; + text-decoration: underline; +} +a:focus { + outline: thin dotted; + outline: 5px auto -webkit-focus-ring-color; + outline-offset: -2px; +} +figure { + margin: 0; +} +img { + vertical-align: middle; +} +.img-responsive { + display: block; + max-width: 100%; + height: auto; +} +.img-rounded { + border-radius: 6px; +} +.img-thumbnail { + padding: 4px; + line-height: 1.6; + background-color: #ffffff; + border: 1px solid #dddddd; + border-radius: 4px; + -webkit-transition: all 0.2s ease-in-out; + -moz-transition: all 0.2s ease-in-out; + -ms-transition: all 0.2s ease-in-out; + -o-transition: all 0.2s ease-in-out; + transition: all 0.2s ease-in-out; + display: inline-block; + max-width: 100%; + height: auto; +} +.img-circle { + border-radius: 50%; +} +hr { + margin-top: 17pt; + margin-bottom: 17pt; + border: 0; + border-top: 1px solid #ffffff; +} +.sr-only { + position: absolute; + width: 1px; + height: 1px; + margin: -1px; + padding: 0; + overflow: hidden; + clip: rect(0, 0, 0, 0); + border: 0; +} +.sr-only-focusable:active, +.sr-only-focusable:focus { + position: static; + width: auto; + height: auto; + margin: 0; + overflow: visible; + clip: auto; +} +[role="button"] { + cursor: pointer; +} +h1, +h2, +h3, +h4, +h5, +h6, +.h1, +.h2, +.h3, +.h4, +.h5, +.h6 { + font-family: Raleway, sans-serif; + font-weight: 300; + line-height: 1.1; + color: inherit; +} +h1 small, +h2 small, +h3 small, +h4 small, +h5 small, +h6 small, +.h1 small, +.h2 small, +.h3 small, +.h4 small, +.h5 small, +.h6 small, +h1 .small, +h2 .small, +h3 .small, +h4 .small, +h5 .small, +h6 .small, +.h1 .small, +.h2 .small, +.h3 .small, +.h4 .small, +.h5 .small, +.h6 .small { + font-weight: normal; + line-height: 1; + color: #cdcdcc; +} +h1, +.h1, +h2, +.h2, +h3, +.h3 { + margin-top: 17pt; + margin-bottom: 8.5pt; +} +h1 small, +.h1 small, +h2 small, +.h2 small, +h3 small, +.h3 small, +h1 .small, +.h1 .small, +h2 .small, +.h2 .small, +h3 .small, +.h3 .small { + font-size: 65%; +} +h4, +.h4, +h5, +.h5, +h6, +.h6 { + margin-top: 8.5pt; + margin-bottom: 8.5pt; +} +h4 small, +.h4 small, +h5 small, +.h5 small, +h6 small, +.h6 small, +h4 .small, +.h4 .small, +h5 .small, +.h5 .small, +h6 .small, +.h6 .small { + font-size: 75%; +} +h1, +.h1 { + font-size: 28pt; +} +h2, +.h2 { + font-size: 23pt; +} +h3, +.h3 { + font-size: 19pt; +} +h4, +.h4 { + font-size: 14pt; +} +h5, +.h5 { + font-size: 11pt; +} +h6, +.h6 { + font-size: 10pt; +} +p { + margin: 0 0 8.5pt; +} +.lead { + margin-bottom: 17pt; + font-size: 12pt; + font-weight: 300; + line-height: 1.4; +} +@media (min-width: 768px) { + .lead { + font-size: 16.5pt; + } +} +small, +.small { + font-size: 90%; +} +mark, +.mark { + background-color: #fcf8e3; + padding: .2em; +} +.text-left { + text-align: left; +} +.text-right { + text-align: right; +} +.text-center { + text-align: center; +} +.text-justify { + text-align: justify; +} +.text-nowrap { + white-space: nowrap; +} +.text-lowercase { + text-transform: lowercase; +} +.text-uppercase { + text-transform: uppercase; +} +.text-capitalize { + text-transform: capitalize; +} +.text-muted { + color: #cdcdcc; +} +.text-primary { + color: #e53200; +} +a.text-primary:hover { + color: #b22700; +} +.text-success { + color: #3c763d; +} +a.text-success:hover { + color: #2b542c; +} +.text-info { + color: #31708f; +} +a.text-info:hover { + color: #245269; +} +.text-warning { + color: #8a6d3b; +} +a.text-warning:hover { + color: #66512c; +} +.text-danger { + color: #a94442; +} +a.text-danger:hover { + color: #843534; +} +.bg-primary { + color: #fff; + background-color: #e53200; +} +a.bg-primary:hover { + background-color: #b22700; +} +.bg-success { + background-color: #dff0d8; +} +a.bg-success:hover { + background-color: #c1e2b3; +} +.bg-info { + background-color: #d9edf7; +} +a.bg-info:hover { + background-color: #afd9ee; +} +.bg-warning { + background-color: #fcf8e3; +} +a.bg-warning:hover { + background-color: #f7ecb5; +} +.bg-danger { + background-color: #f2dede; +} +a.bg-danger:hover { + background-color: #e4b9b9; +} +.page-header { + padding-bottom: 7.5pt; + margin: 34pt 0 17pt; + border-bottom: 1px solid #ffffff; +} +ul, +ol { + margin-top: 0; + margin-bottom: 8.5pt; +} +ul ul, +ol ul, +ul ol, +ol ol { + margin-bottom: 0; +} +.list-unstyled { + padding-left: 0; + list-style: none; +} +.list-inline { + padding-left: 0; + list-style: none; + margin-left: -5px; +} +.list-inline > li { + display: inline-block; + padding-left: 5px; + padding-right: 5px; +} +dl { + margin-top: 0; + margin-bottom: 17pt; +} +dt, +dd { + line-height: 1.6; +} +dt { + font-weight: bold; +} +dd { + margin-left: 0; +} +@media (min-width: 768px) { + .dl-horizontal dt { + float: left; + width: 160px; + clear: left; + text-align: right; + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; + } + .dl-horizontal dd { + margin-left: 180px; + } +} +abbr[title], +abbr[data-original-title] { + cursor: help; + border-bottom: 1px dotted #cdcdcc; +} +.initialism { + font-size: 90%; + text-transform: uppercase; +} +blockquote { + padding: 8.5pt 17pt; + margin: 0 0 17pt; + font-size: 13.75pt; + border-left: 5px solid #ffffff; +} +blockquote p:last-child, +blockquote ul:last-child, +blockquote ol:last-child { + margin-bottom: 0; +} +blockquote footer, +blockquote small, +blockquote .small { + display: block; + font-size: 80%; + line-height: 1.6; + color: #cdcdcc; +} +blockquote footer:before, +blockquote small:before, +blockquote .small:before { + content: '\2014 \00A0'; +} +.blockquote-reverse, +blockquote.pull-right { + padding-right: 15px; + padding-left: 0; + border-right: 5px solid #ffffff; + border-left: 0; + text-align: right; +} +.blockquote-reverse footer:before, +blockquote.pull-right footer:before, +.blockquote-reverse small:before, +blockquote.pull-right small:before, +.blockquote-reverse .small:before, +blockquote.pull-right .small:before { + content: ''; +} +.blockquote-reverse footer:after, +blockquote.pull-right footer:after, +.blockquote-reverse small:after, +blockquote.pull-right small:after, +.blockquote-reverse .small:after, +blockquote.pull-right .small:after { + content: '\00A0 \2014'; +} +address { + margin-bottom: 17pt; + font-style: normal; + line-height: 1.6; +} +code, +kbd, +pre, +samp { + font-family: Menlo, Monaco, Consolas, "Courier New", monospace; +} +code { + padding: 2px 4px; + font-size: 90%; + color: #c7254e; + background-color: #f9f2f4; + border-radius: 4px; +} +kbd { + padding: 2px 4px; + font-size: 90%; + color: #ffffff; + background-color: #333333; + border-radius: 3px; + box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.25); +} +kbd kbd { + padding: 0; + font-size: 100%; + font-weight: bold; + box-shadow: none; +} +pre { + display: block; + padding: 8pt; + margin: 0 0 8.5pt; + font-size: 10pt; + line-height: 1.6; + word-break: break-all; + word-wrap: break-word; + color: #81817f; + background-color: #f5f5f5; + border: 1px solid #cccccc; + border-radius: 4px; +} +pre code { + padding: 0; + font-size: inherit; + color: inherit; + white-space: pre-wrap; + background-color: transparent; + border-radius: 0; +} +.pre-scrollable { + max-height: 340px; + overflow-y: scroll; +} +.container { + margin-right: auto; + margin-left: auto; + padding-left: 15px; + padding-right: 15px; +} +@media (min-width: 768px) { + .container { + width: 750px; + } +} +@media (min-width: 992px) { + .container { + width: 970px; + } +} +@media (min-width: 1200px) { + .container { + width: 1170px; + } +} +.container-fluid { + margin-right: auto; + margin-left: auto; + padding-left: 15px; + padding-right: 15px; +} +.row { + margin-left: -15px; + margin-right: -15px; +} +.col-xs-1, .col-sm-1, .col-md-1, .col-lg-1, .col-xs-2, .col-sm-2, .col-md-2, .col-lg-2, .col-xs-3, .col-sm-3, .col-md-3, .col-lg-3, .col-xs-4, .col-sm-4, .col-md-4, .col-lg-4, .col-xs-5, .col-sm-5, .col-md-5, .col-lg-5, .col-xs-6, .col-sm-6, .col-md-6, .col-lg-6, .col-xs-7, .col-sm-7, .col-md-7, .col-lg-7, .col-xs-8, .col-sm-8, .col-md-8, .col-lg-8, .col-xs-9, .col-sm-9, .col-md-9, .col-lg-9, .col-xs-10, .col-sm-10, .col-md-10, .col-lg-10, .col-xs-11, .col-sm-11, .col-md-11, .col-lg-11, .col-xs-12, .col-sm-12, .col-md-12, .col-lg-12 { + position: relative; + min-height: 1px; + padding-left: 15px; + padding-right: 15px; +} +.col-xs-1, .col-xs-2, .col-xs-3, .col-xs-4, .col-xs-5, .col-xs-6, .col-xs-7, .col-xs-8, .col-xs-9, .col-xs-10, .col-xs-11, .col-xs-12 { + float: left; +} +.col-xs-12 { + width: 100%; +} +.col-xs-11 { + width: 91.66666667%; +} +.col-xs-10 { + width: 83.33333333%; +} +.col-xs-9 { + width: 75%; +} +.col-xs-8 { + width: 66.66666667%; +} +.col-xs-7 { + width: 58.33333333%; +} +.col-xs-6 { + width: 50%; +} +.col-xs-5 { + width: 41.66666667%; +} +.col-xs-4 { + width: 33.33333333%; +} +.col-xs-3 { + width: 25%; +} +.col-xs-2 { + width: 16.66666667%; +} +.col-xs-1 { + width: 8.33333333%; +} +.col-xs-pull-12 { + right: 100%; +} +.col-xs-pull-11 { + right: 91.66666667%; +} +.col-xs-pull-10 { + right: 83.33333333%; +} +.col-xs-pull-9 { + right: 75%; +} +.col-xs-pull-8 { + right: 66.66666667%; +} +.col-xs-pull-7 { + right: 58.33333333%; +} +.col-xs-pull-6 { + right: 50%; +} +.col-xs-pull-5 { + right: 41.66666667%; +} +.col-xs-pull-4 { + right: 33.33333333%; +} +.col-xs-pull-3 { + right: 25%; +} +.col-xs-pull-2 { + right: 16.66666667%; +} +.col-xs-pull-1 { + right: 8.33333333%; +} +.col-xs-pull-0 { + right: auto; +} +.col-xs-push-12 { + left: 100%; +} +.col-xs-push-11 { + left: 91.66666667%; +} +.col-xs-push-10 { + left: 83.33333333%; +} +.col-xs-push-9 { + left: 75%; +} +.col-xs-push-8 { + left: 66.66666667%; +} +.col-xs-push-7 { + left: 58.33333333%; +} +.col-xs-push-6 { + left: 50%; +} +.col-xs-push-5 { + left: 41.66666667%; +} +.col-xs-push-4 { + left: 33.33333333%; +} +.col-xs-push-3 { + left: 25%; +} +.col-xs-push-2 { + left: 16.66666667%; +} +.col-xs-push-1 { + left: 8.33333333%; +} +.col-xs-push-0 { + left: auto; +} +.col-xs-offset-12 { + margin-left: 100%; +} +.col-xs-offset-11 { + margin-left: 91.66666667%; +} +.col-xs-offset-10 { + margin-left: 83.33333333%; +} +.col-xs-offset-9 { + margin-left: 75%; +} +.col-xs-offset-8 { + margin-left: 66.66666667%; +} +.col-xs-offset-7 { + margin-left: 58.33333333%; +} +.col-xs-offset-6 { + margin-left: 50%; +} +.col-xs-offset-5 { + margin-left: 41.66666667%; +} +.col-xs-offset-4 { + margin-left: 33.33333333%; +} +.col-xs-offset-3 { + margin-left: 25%; +} +.col-xs-offset-2 { + margin-left: 16.66666667%; +} +.col-xs-offset-1 { + margin-left: 8.33333333%; +} +.col-xs-offset-0 { + margin-left: 0%; +} +@media (min-width: 768px) { + .col-sm-1, .col-sm-2, .col-sm-3, .col-sm-4, .col-sm-5, .col-sm-6, .col-sm-7, .col-sm-8, .col-sm-9, .col-sm-10, .col-sm-11, .col-sm-12 { + float: left; + } + .col-sm-12 { + width: 100%; + } + .col-sm-11 { + width: 91.66666667%; + } + .col-sm-10 { + width: 83.33333333%; + } + .col-sm-9 { + width: 75%; + } + .col-sm-8 { + width: 66.66666667%; + } + .col-sm-7 { + width: 58.33333333%; + } + .col-sm-6 { + width: 50%; + } + .col-sm-5 { + width: 41.66666667%; + } + .col-sm-4 { + width: 33.33333333%; + } + .col-sm-3 { + width: 25%; + } + .col-sm-2 { + width: 16.66666667%; + } + .col-sm-1 { + width: 8.33333333%; + } + .col-sm-pull-12 { + right: 100%; + } + .col-sm-pull-11 { + right: 91.66666667%; + } + .col-sm-pull-10 { + right: 83.33333333%; + } + .col-sm-pull-9 { + right: 75%; + } + .col-sm-pull-8 { + right: 66.66666667%; + } + .col-sm-pull-7 { + right: 58.33333333%; + } + .col-sm-pull-6 { + right: 50%; + } + .col-sm-pull-5 { + right: 41.66666667%; + } + .col-sm-pull-4 { + right: 33.33333333%; + } + .col-sm-pull-3 { + right: 25%; + } + .col-sm-pull-2 { + right: 16.66666667%; + } + .col-sm-pull-1 { + right: 8.33333333%; + } + .col-sm-pull-0 { + right: auto; + } + .col-sm-push-12 { + left: 100%; + } + .col-sm-push-11 { + left: 91.66666667%; + } + .col-sm-push-10 { + left: 83.33333333%; + } + .col-sm-push-9 { + left: 75%; + } + .col-sm-push-8 { + left: 66.66666667%; + } + .col-sm-push-7 { + left: 58.33333333%; + } + .col-sm-push-6 { + left: 50%; + } + .col-sm-push-5 { + left: 41.66666667%; + } + .col-sm-push-4 { + left: 33.33333333%; + } + .col-sm-push-3 { + left: 25%; + } + .col-sm-push-2 { + left: 16.66666667%; + } + .col-sm-push-1 { + left: 8.33333333%; + } + .col-sm-push-0 { + left: auto; + } + .col-sm-offset-12 { + margin-left: 100%; + } + .col-sm-offset-11 { + margin-left: 91.66666667%; + } + .col-sm-offset-10 { + margin-left: 83.33333333%; + } + .col-sm-offset-9 { + margin-left: 75%; + } + .col-sm-offset-8 { + margin-left: 66.66666667%; + } + .col-sm-offset-7 { + margin-left: 58.33333333%; + } + .col-sm-offset-6 { + margin-left: 50%; + } + .col-sm-offset-5 { + margin-left: 41.66666667%; + } + .col-sm-offset-4 { + margin-left: 33.33333333%; + } + .col-sm-offset-3 { + margin-left: 25%; + } + .col-sm-offset-2 { + margin-left: 16.66666667%; + } + .col-sm-offset-1 { + margin-left: 8.33333333%; + } + .col-sm-offset-0 { + margin-left: 0%; + } +} +@media (min-width: 992px) { + .col-md-1, .col-md-2, .col-md-3, .col-md-4, .col-md-5, .col-md-6, .col-md-7, .col-md-8, .col-md-9, .col-md-10, .col-md-11, .col-md-12 { + float: left; + } + .col-md-12 { + width: 100%; + } + .col-md-11 { + width: 91.66666667%; + } + .col-md-10 { + width: 83.33333333%; + } + .col-md-9 { + width: 75%; + } + .col-md-8 { + width: 66.66666667%; + } + .col-md-7 { + width: 58.33333333%; + } + .col-md-6 { + width: 50%; + } + .col-md-5 { + width: 41.66666667%; + } + .col-md-4 { + width: 33.33333333%; + } + .col-md-3 { + width: 25%; + } + .col-md-2 { + width: 16.66666667%; + } + .col-md-1 { + width: 8.33333333%; + } + .col-md-pull-12 { + right: 100%; + } + .col-md-pull-11 { + right: 91.66666667%; + } + .col-md-pull-10 { + right: 83.33333333%; + } + .col-md-pull-9 { + right: 75%; + } + .col-md-pull-8 { + right: 66.66666667%; + } + .col-md-pull-7 { + right: 58.33333333%; + } + .col-md-pull-6 { + right: 50%; + } + .col-md-pull-5 { + right: 41.66666667%; + } + .col-md-pull-4 { + right: 33.33333333%; + } + .col-md-pull-3 { + right: 25%; + } + .col-md-pull-2 { + right: 16.66666667%; + } + .col-md-pull-1 { + right: 8.33333333%; + } + .col-md-pull-0 { + right: auto; + } + .col-md-push-12 { + left: 100%; + } + .col-md-push-11 { + left: 91.66666667%; + } + .col-md-push-10 { + left: 83.33333333%; + } + .col-md-push-9 { + left: 75%; + } + .col-md-push-8 { + left: 66.66666667%; + } + .col-md-push-7 { + left: 58.33333333%; + } + .col-md-push-6 { + left: 50%; + } + .col-md-push-5 { + left: 41.66666667%; + } + .col-md-push-4 { + left: 33.33333333%; + } + .col-md-push-3 { + left: 25%; + } + .col-md-push-2 { + left: 16.66666667%; + } + .col-md-push-1 { + left: 8.33333333%; + } + .col-md-push-0 { + left: auto; + } + .col-md-offset-12 { + margin-left: 100%; + } + .col-md-offset-11 { + margin-left: 91.66666667%; + } + .col-md-offset-10 { + margin-left: 83.33333333%; + } + .col-md-offset-9 { + margin-left: 75%; + } + .col-md-offset-8 { + margin-left: 66.66666667%; + } + .col-md-offset-7 { + margin-left: 58.33333333%; + } + .col-md-offset-6 { + margin-left: 50%; + } + .col-md-offset-5 { + margin-left: 41.66666667%; + } + .col-md-offset-4 { + margin-left: 33.33333333%; + } + .col-md-offset-3 { + margin-left: 25%; + } + .col-md-offset-2 { + margin-left: 16.66666667%; + } + .col-md-offset-1 { + margin-left: 8.33333333%; + } + .col-md-offset-0 { + margin-left: 0%; + } +} +@media (min-width: 1200px) { + .col-lg-1, .col-lg-2, .col-lg-3, .col-lg-4, .col-lg-5, .col-lg-6, .col-lg-7, .col-lg-8, .col-lg-9, .col-lg-10, .col-lg-11, .col-lg-12 { + float: left; + } + .col-lg-12 { + width: 100%; + } + .col-lg-11 { + width: 91.66666667%; + } + .col-lg-10 { + width: 83.33333333%; + } + .col-lg-9 { + width: 75%; + } + .col-lg-8 { + width: 66.66666667%; + } + .col-lg-7 { + width: 58.33333333%; + } + .col-lg-6 { + width: 50%; + } + .col-lg-5 { + width: 41.66666667%; + } + .col-lg-4 { + width: 33.33333333%; + } + .col-lg-3 { + width: 25%; + } + .col-lg-2 { + width: 16.66666667%; + } + .col-lg-1 { + width: 8.33333333%; + } + .col-lg-pull-12 { + right: 100%; + } + .col-lg-pull-11 { + right: 91.66666667%; + } + .col-lg-pull-10 { + right: 83.33333333%; + } + .col-lg-pull-9 { + right: 75%; + } + .col-lg-pull-8 { + right: 66.66666667%; + } + .col-lg-pull-7 { + right: 58.33333333%; + } + .col-lg-pull-6 { + right: 50%; + } + .col-lg-pull-5 { + right: 41.66666667%; + } + .col-lg-pull-4 { + right: 33.33333333%; + } + .col-lg-pull-3 { + right: 25%; + } + .col-lg-pull-2 { + right: 16.66666667%; + } + .col-lg-pull-1 { + right: 8.33333333%; + } + .col-lg-pull-0 { + right: auto; + } + .col-lg-push-12 { + left: 100%; + } + .col-lg-push-11 { + left: 91.66666667%; + } + .col-lg-push-10 { + left: 83.33333333%; + } + .col-lg-push-9 { + left: 75%; + } + .col-lg-push-8 { + left: 66.66666667%; + } + .col-lg-push-7 { + left: 58.33333333%; + } + .col-lg-push-6 { + left: 50%; + } + .col-lg-push-5 { + left: 41.66666667%; + } + .col-lg-push-4 { + left: 33.33333333%; + } + .col-lg-push-3 { + left: 25%; + } + .col-lg-push-2 { + left: 16.66666667%; + } + .col-lg-push-1 { + left: 8.33333333%; + } + .col-lg-push-0 { + left: auto; + } + .col-lg-offset-12 { + margin-left: 100%; + } + .col-lg-offset-11 { + margin-left: 91.66666667%; + } + .col-lg-offset-10 { + margin-left: 83.33333333%; + } + .col-lg-offset-9 { + margin-left: 75%; + } + .col-lg-offset-8 { + margin-left: 66.66666667%; + } + .col-lg-offset-7 { + margin-left: 58.33333333%; + } + .col-lg-offset-6 { + margin-left: 50%; + } + .col-lg-offset-5 { + margin-left: 41.66666667%; + } + .col-lg-offset-4 { + margin-left: 33.33333333%; + } + .col-lg-offset-3 { + margin-left: 25%; + } + .col-lg-offset-2 { + margin-left: 16.66666667%; + } + .col-lg-offset-1 { + margin-left: 8.33333333%; + } + .col-lg-offset-0 { + margin-left: 0%; + } +} +fieldset { + padding: 0; + margin: 0; + border: 0; + min-width: 0; +} +legend { + display: block; + width: 100%; + padding: 0; + margin-bottom: 17pt; + font-size: 16.5pt; + line-height: inherit; + color: #81817f; + border: 0; + border-bottom: 1px solid #e5e5e5; +} +label { + display: inline-block; + max-width: 100%; + margin-bottom: 5px; + font-weight: bold; +} +input[type="search"] { + -webkit-box-sizing: border-box; + -moz-box-sizing: border-box; + box-sizing: border-box; +} +input[type="radio"], +input[type="checkbox"] { + margin: 4px 0 0; + margin-top: 1px \9; + line-height: normal; +} +input[type="file"] { + display: block; +} +input[type="range"] { + display: block; + width: 100%; +} +select[multiple], +select[size] { + height: auto; +} +input[type="file"]:focus, +input[type="radio"]:focus, +input[type="checkbox"]:focus { + outline: thin dotted; + outline: 5px auto -webkit-focus-ring-color; + outline-offset: -2px; +} +output { + display: block; + padding-top: 7px; + font-size: 11pt; + line-height: 1.6; + color: #ffffff; +} +.form-control { + display: block; + width: 100%; + height: 28pt; + padding: 6px 12px; + font-size: 11pt; + line-height: 1.6; + color: #ffffff; + background-color: #ffffff; + background-image: none; + border: 1px solid #cccccc; + border-radius: 4px; + -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075); + box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075); + -webkit-transition: border-color ease-in-out .15s, box-shadow ease-in-out .15s; + -moz-transition: border-color ease-in-out .15s, box-shadow ease-in-out .15s; + -ms-transition: border-color ease-in-out .15s, box-shadow ease-in-out .15s; + -o-transition: border-color ease-in-out .15s, box-shadow ease-in-out .15s; + transition: border-color ease-in-out .15s, box-shadow ease-in-out .15s; +} +.form-control:focus { + border-color: #66afe9; + outline: 0; + -webkit-box-shadow: inset 0 1px 1px rgba(0,0,0,.075), 0 0 8px rgba(102, 175, 233, 0.6); + box-shadow: inset 0 1px 1px rgba(0,0,0,.075), 0 0 8px rgba(102, 175, 233, 0.6); +} +.form-control::-moz-placeholder { + color: #999999; + opacity: 1; +} +.form-control:-ms-input-placeholder { + color: #999999; +} +.form-control::-webkit-input-placeholder { + color: #999999; +} +.form-control[disabled], +.form-control[readonly], +fieldset[disabled] .form-control { + background-color: #ffffff; + opacity: 1; +} +.form-control[disabled], +fieldset[disabled] .form-control { + cursor: not-allowed; +} +textarea.form-control { + height: auto; +} +input[type="search"] { + -webkit-appearance: none; +} +@media screen and (-webkit-min-device-pixel-ratio: 0) { + input[type="date"], + input[type="time"], + input[type="datetime-local"], + input[type="month"] { + line-height: 28pt; + } + input[type="date"].input-sm, + input[type="time"].input-sm, + input[type="datetime-local"].input-sm, + input[type="month"].input-sm, + .input-group-sm input[type="date"], + .input-group-sm input[type="time"], + .input-group-sm input[type="datetime-local"], + .input-group-sm input[type="month"] { + line-height: 24.5pt; + } + input[type="date"].input-lg, + input[type="time"].input-lg, + input[type="datetime-local"].input-lg, + input[type="month"].input-lg, + .input-group-lg input[type="date"], + .input-group-lg input[type="time"], + .input-group-lg input[type="datetime-local"], + .input-group-lg input[type="month"] { + line-height: 36pt; + } +} +.form-group { + margin-bottom: 15px; +} +.radio, +.checkbox { + position: relative; + display: block; + margin-top: 10px; + margin-bottom: 10px; +} +.radio label, +.checkbox label { + min-height: 17pt; + padding-left: 20px; + margin-bottom: 0; + font-weight: normal; + cursor: pointer; +} +.radio input[type="radio"], +.radio-inline input[type="radio"], +.checkbox input[type="checkbox"], +.checkbox-inline input[type="checkbox"] { + position: absolute; + margin-left: -20px; + margin-top: 4px \9; +} +.radio + .radio, +.checkbox + .checkbox { + margin-top: -5px; +} +.radio-inline, +.checkbox-inline { + position: relative; + display: inline-block; + padding-left: 20px; + margin-bottom: 0; + vertical-align: middle; + font-weight: normal; + cursor: pointer; +} +.radio-inline + .radio-inline, +.checkbox-inline + .checkbox-inline { + margin-top: 0; + margin-left: 10px; +} +input[type="radio"][disabled], +input[type="checkbox"][disabled], +input[type="radio"].disabled, +input[type="checkbox"].disabled, +fieldset[disabled] input[type="radio"], +fieldset[disabled] input[type="checkbox"] { + cursor: not-allowed; +} +.radio-inline.disabled, +.checkbox-inline.disabled, +fieldset[disabled] .radio-inline, +fieldset[disabled] .checkbox-inline { + cursor: not-allowed; +} +.radio.disabled label, +.checkbox.disabled label, +fieldset[disabled] .radio label, +fieldset[disabled] .checkbox label { + cursor: not-allowed; +} +.form-control-static { + padding-top: 7px; + padding-bottom: 7px; + margin-bottom: 0; + min-height: 28pt; +} +.form-control-static.input-lg, +.form-control-static.input-sm { + padding-left: 0; + padding-right: 0; +} +.input-sm { + height: 24.5pt; + padding: 5px 10px; + font-size: 10pt; + line-height: 1.5; + border-radius: 3px; +} +select.input-sm { + height: 24.5pt; + line-height: 24.5pt; +} +textarea.input-sm, +select[multiple].input-sm { + height: auto; +} +.form-group-sm .form-control { + height: 24.5pt; + padding: 5px 10px; + font-size: 10pt; + line-height: 1.5; + border-radius: 3px; +} +select.form-group-sm .form-control { + height: 24.5pt; + line-height: 24.5pt; +} +textarea.form-group-sm .form-control, +select[multiple].form-group-sm .form-control { + height: auto; +} +.form-group-sm .form-control-static { + height: 24.5pt; + padding: 5px 10px; + font-size: 10pt; + line-height: 1.5; + min-height: 27pt; +} +.input-lg { + height: 36pt; + padding: 10px 16px; + font-size: 14pt; + line-height: 1.3333333; + border-radius: 6px; +} +select.input-lg { + height: 36pt; + line-height: 36pt; +} +textarea.input-lg, +select[multiple].input-lg { + height: auto; +} +.form-group-lg .form-control { + height: 36pt; + padding: 10px 16px; + font-size: 14pt; + line-height: 1.3333333; + border-radius: 6px; +} +select.form-group-lg .form-control { + height: 36pt; + line-height: 36pt; +} +textarea.form-group-lg .form-control, +select[multiple].form-group-lg .form-control { + height: auto; +} +.form-group-lg .form-control-static { + height: 36pt; + padding: 10px 16px; + font-size: 14pt; + line-height: 1.3333333; + min-height: 31pt; +} +.has-feedback { + position: relative; +} +.has-feedback .form-control { + padding-right: 35pt; +} +.form-control-feedback { + position: absolute; + top: 0; + right: 0; + z-index: 2; + display: block; + width: 28pt; + height: 28pt; + line-height: 28pt; + text-align: center; + pointer-events: none; +} +.input-lg + .form-control-feedback { + width: 36pt; + height: 36pt; + line-height: 36pt; +} +.input-sm + .form-control-feedback { + width: 24.5pt; + height: 24.5pt; + line-height: 24.5pt; +} +.has-success .help-block, +.has-success .control-label, +.has-success .radio, +.has-success .checkbox, +.has-success .radio-inline, +.has-success .checkbox-inline, +.has-success.radio label, +.has-success.checkbox label, +.has-success.radio-inline label, +.has-success.checkbox-inline label { + color: #3c763d; +} +.has-success .form-control { + border-color: #3c763d; + -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075); + box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075); +} +.has-success .form-control:focus { + border-color: #2b542c; + -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #67b168; + box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #67b168; +} +.has-success .input-group-addon { + color: #3c763d; + border-color: #3c763d; + background-color: #dff0d8; +} +.has-success .form-control-feedback { + color: #3c763d; +} +.has-warning .help-block, +.has-warning .control-label, +.has-warning .radio, +.has-warning .checkbox, +.has-warning .radio-inline, +.has-warning .checkbox-inline, +.has-warning.radio label, +.has-warning.checkbox label, +.has-warning.radio-inline label, +.has-warning.checkbox-inline label { + color: #8a6d3b; +} +.has-warning .form-control { + border-color: #8a6d3b; + -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075); + box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075); +} +.has-warning .form-control:focus { + border-color: #66512c; + -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #c0a16b; + box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #c0a16b; +} +.has-warning .input-group-addon { + color: #8a6d3b; + border-color: #8a6d3b; + background-color: #fcf8e3; +} +.has-warning .form-control-feedback { + color: #8a6d3b; +} +.has-error .help-block, +.has-error .control-label, +.has-error .radio, +.has-error .checkbox, +.has-error .radio-inline, +.has-error .checkbox-inline, +.has-error.radio label, +.has-error.checkbox label, +.has-error.radio-inline label, +.has-error.checkbox-inline label { + color: #a94442; +} +.has-error .form-control { + border-color: #a94442; + -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075); + box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075); +} +.has-error .form-control:focus { + border-color: #843534; + -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #ce8483; + box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075), 0 0 6px #ce8483; +} +.has-error .input-group-addon { + color: #a94442; + border-color: #a94442; + background-color: #f2dede; +} +.has-error .form-control-feedback { + color: #a94442; +} +.has-feedback label ~ .form-control-feedback { + top: 22pt; +} +.has-feedback label.sr-only ~ .form-control-feedback { + top: 0; +} +.help-block { + display: block; + margin-top: 5px; + margin-bottom: 10px; + color: #c0c0bf; +} +@media (min-width: 768px) { + .form-inline .form-group { + display: inline-block; + margin-bottom: 0; + vertical-align: middle; + } + .form-inline .form-control { + display: inline-block; + width: auto; + vertical-align: middle; + } + .form-inline .form-control-static { + display: inline-block; + } + .form-inline .input-group { + display: inline-table; + vertical-align: middle; + } + .form-inline .input-group .input-group-addon, + .form-inline .input-group .input-group-btn, + .form-inline .input-group .form-control { + width: auto; + } + .form-inline .input-group > .form-control { + width: 100%; + } + .form-inline .control-label { + margin-bottom: 0; + vertical-align: middle; + } + .form-inline .radio, + .form-inline .checkbox { + display: inline-block; + margin-top: 0; + margin-bottom: 0; + vertical-align: middle; + } + .form-inline .radio label, + .form-inline .checkbox label { + padding-left: 0; + } + .form-inline .radio input[type="radio"], + .form-inline .checkbox input[type="checkbox"] { + position: relative; + margin-left: 0; + } + .form-inline .has-feedback .form-control-feedback { + top: 0; + } +} +.form-horizontal .radio, +.form-horizontal .checkbox, +.form-horizontal .radio-inline, +.form-horizontal .checkbox-inline { + margin-top: 0; + margin-bottom: 0; + padding-top: 7px; +} +.form-horizontal .radio, +.form-horizontal .checkbox { + min-height: 22.25pt; +} +.form-horizontal .form-group { + margin-left: -15px; + margin-right: -15px; +} +@media (min-width: 768px) { + .form-horizontal .control-label { + text-align: right; + margin-bottom: 0; + padding-top: 7px; + } +} +.form-horizontal .has-feedback .form-control-feedback { + right: 15px; +} +@media (min-width: 768px) { + .form-horizontal .form-group-lg .control-label { + padding-top: 14.333333px; + } +} +@media (min-width: 768px) { + .form-horizontal .form-group-sm .control-label { + padding-top: 6px; + } +} +.btn { + display: inline-block; + margin-bottom: 0; + font-weight: normal; + text-align: center; + vertical-align: middle; + touch-action: manipulation; + cursor: pointer; + background-image: none; + border: 1px solid transparent; + white-space: nowrap; + padding: 6px 12px; + font-size: 11pt; + line-height: 1.6; + border-radius: 4px; + -webkit-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; +} +.btn:focus, +.btn:active:focus, +.btn.active:focus, +.btn.focus, +.btn:active.focus, +.btn.active.focus { + outline: thin dotted; + outline: 5px auto -webkit-focus-ring-color; + outline-offset: -2px; +} +.btn:hover, +.btn:focus, +.btn.focus { + color: #333333; + text-decoration: none; +} +.btn:active, +.btn.active { + outline: 0; + background-image: none; + -webkit-box-shadow: inset 0 3px 5px rgba(0, 0, 0, 0.125); + box-shadow: inset 0 3px 5px rgba(0, 0, 0, 0.125); +} +.btn.disabled, +.btn[disabled], +fieldset[disabled] .btn { + cursor: not-allowed; + pointer-events: none; + opacity: 0.65; + filter: alpha(opacity=65); + -webkit-box-shadow: none; + box-shadow: none; +} +.btn-default { + color: #333333; + background-color: #ffffff; + border-color: #cccccc; +} +.btn-default:hover, +.btn-default:focus, +.btn-default.focus, +.btn-default:active, +.btn-default.active, +.open > .dropdown-toggle.btn-default { + color: #333333; + background-color: #e6e6e6; + border-color: #adadad; +} +.btn-default:active, +.btn-default.active, +.open > .dropdown-toggle.btn-default { + background-image: none; +} +.btn-default.disabled, +.btn-default[disabled], +fieldset[disabled] .btn-default, +.btn-default.disabled:hover, +.btn-default[disabled]:hover, +fieldset[disabled] .btn-default:hover, +.btn-default.disabled:focus, +.btn-default[disabled]:focus, +fieldset[disabled] .btn-default:focus, +.btn-default.disabled.focus, +.btn-default[disabled].focus, +fieldset[disabled] .btn-default.focus, +.btn-default.disabled:active, +.btn-default[disabled]:active, +fieldset[disabled] .btn-default:active, +.btn-default.disabled.active, +.btn-default[disabled].active, +fieldset[disabled] .btn-default.active { + background-color: #ffffff; + border-color: #cccccc; +} +.btn-default .badge { + color: #ffffff; + background-color: #333333; +} +.btn-primary { + color: #ffffff; + background-color: #e53200; + border-color: #cc2c00; +} +.btn-primary:hover, +.btn-primary:focus, +.btn-primary.focus, +.btn-primary:active, +.btn-primary.active, +.open > .dropdown-toggle.btn-primary { + color: #ffffff; + background-color: #b22700; + border-color: #8e1f00; +} +.btn-primary:active, +.btn-primary.active, +.open > .dropdown-toggle.btn-primary { + background-image: none; +} +.btn-primary.disabled, +.btn-primary[disabled], +fieldset[disabled] .btn-primary, +.btn-primary.disabled:hover, +.btn-primary[disabled]:hover, +fieldset[disabled] .btn-primary:hover, +.btn-primary.disabled:focus, +.btn-primary[disabled]:focus, +fieldset[disabled] .btn-primary:focus, +.btn-primary.disabled.focus, +.btn-primary[disabled].focus, +fieldset[disabled] .btn-primary.focus, +.btn-primary.disabled:active, +.btn-primary[disabled]:active, +fieldset[disabled] .btn-primary:active, +.btn-primary.disabled.active, +.btn-primary[disabled].active, +fieldset[disabled] .btn-primary.active { + background-color: #e53200; + border-color: #cc2c00; +} +.btn-primary .badge { + color: #e53200; + background-color: #ffffff; +} +.btn-success { + color: #ffffff; + background-color: #5cb85c; + border-color: #4cae4c; +} +.btn-success:hover, +.btn-success:focus, +.btn-success.focus, +.btn-success:active, +.btn-success.active, +.open > .dropdown-toggle.btn-success { + color: #ffffff; + background-color: #449d44; + border-color: #398439; +} +.btn-success:active, +.btn-success.active, +.open > .dropdown-toggle.btn-success { + background-image: none; +} +.btn-success.disabled, +.btn-success[disabled], +fieldset[disabled] .btn-success, +.btn-success.disabled:hover, +.btn-success[disabled]:hover, +fieldset[disabled] .btn-success:hover, +.btn-success.disabled:focus, +.btn-success[disabled]:focus, +fieldset[disabled] .btn-success:focus, +.btn-success.disabled.focus, +.btn-success[disabled].focus, +fieldset[disabled] .btn-success.focus, +.btn-success.disabled:active, +.btn-success[disabled]:active, +fieldset[disabled] .btn-success:active, +.btn-success.disabled.active, +.btn-success[disabled].active, +fieldset[disabled] .btn-success.active { + background-color: #5cb85c; + border-color: #4cae4c; +} +.btn-success .badge { + color: #5cb85c; + background-color: #ffffff; +} +.btn-info { + color: #ffffff; + background-color: #5bc0de; + border-color: #46b8da; +} +.btn-info:hover, +.btn-info:focus, +.btn-info.focus, +.btn-info:active, +.btn-info.active, +.open > .dropdown-toggle.btn-info { + color: #ffffff; + background-color: #31b0d5; + border-color: #269abc; +} +.btn-info:active, +.btn-info.active, +.open > .dropdown-toggle.btn-info { + background-image: none; +} +.btn-info.disabled, +.btn-info[disabled], +fieldset[disabled] .btn-info, +.btn-info.disabled:hover, +.btn-info[disabled]:hover, +fieldset[disabled] .btn-info:hover, +.btn-info.disabled:focus, +.btn-info[disabled]:focus, +fieldset[disabled] .btn-info:focus, +.btn-info.disabled.focus, +.btn-info[disabled].focus, +fieldset[disabled] .btn-info.focus, +.btn-info.disabled:active, +.btn-info[disabled]:active, +fieldset[disabled] .btn-info:active, +.btn-info.disabled.active, +.btn-info[disabled].active, +fieldset[disabled] .btn-info.active { + background-color: #5bc0de; + border-color: #46b8da; +} +.btn-info .badge { + color: #5bc0de; + background-color: #ffffff; +} +.btn-warning { + color: #ffffff; + background-color: #f0ad4e; + border-color: #eea236; +} +.btn-warning:hover, +.btn-warning:focus, +.btn-warning.focus, +.btn-warning:active, +.btn-warning.active, +.open > .dropdown-toggle.btn-warning { + color: #ffffff; + background-color: #ec971f; + border-color: #d58512; +} +.btn-warning:active, +.btn-warning.active, +.open > .dropdown-toggle.btn-warning { + background-image: none; +} +.btn-warning.disabled, +.btn-warning[disabled], +fieldset[disabled] .btn-warning, +.btn-warning.disabled:hover, +.btn-warning[disabled]:hover, +fieldset[disabled] .btn-warning:hover, +.btn-warning.disabled:focus, +.btn-warning[disabled]:focus, +fieldset[disabled] .btn-warning:focus, +.btn-warning.disabled.focus, +.btn-warning[disabled].focus, +fieldset[disabled] .btn-warning.focus, +.btn-warning.disabled:active, +.btn-warning[disabled]:active, +fieldset[disabled] .btn-warning:active, +.btn-warning.disabled.active, +.btn-warning[disabled].active, +fieldset[disabled] .btn-warning.active { + background-color: #f0ad4e; + border-color: #eea236; +} +.btn-warning .badge { + color: #f0ad4e; + background-color: #ffffff; +} +.btn-danger { + color: #ffffff; + background-color: #d9534f; + border-color: #d43f3a; +} +.btn-danger:hover, +.btn-danger:focus, +.btn-danger.focus, +.btn-danger:active, +.btn-danger.active, +.open > .dropdown-toggle.btn-danger { + color: #ffffff; + background-color: #c9302c; + border-color: #ac2925; +} +.btn-danger:active, +.btn-danger.active, +.open > .dropdown-toggle.btn-danger { + background-image: none; +} +.btn-danger.disabled, +.btn-danger[disabled], +fieldset[disabled] .btn-danger, +.btn-danger.disabled:hover, +.btn-danger[disabled]:hover, +fieldset[disabled] .btn-danger:hover, +.btn-danger.disabled:focus, +.btn-danger[disabled]:focus, +fieldset[disabled] .btn-danger:focus, +.btn-danger.disabled.focus, +.btn-danger[disabled].focus, +fieldset[disabled] .btn-danger.focus, +.btn-danger.disabled:active, +.btn-danger[disabled]:active, +fieldset[disabled] .btn-danger:active, +.btn-danger.disabled.active, +.btn-danger[disabled].active, +fieldset[disabled] .btn-danger.active { + background-color: #d9534f; + border-color: #d43f3a; +} +.btn-danger .badge { + color: #d9534f; + background-color: #ffffff; +} +.btn-link { + color: #7f90b4; + font-weight: normal; + border-radius: 0; +} +.btn-link, +.btn-link:active, +.btn-link.active, +.btn-link[disabled], +fieldset[disabled] .btn-link { + background-color: transparent; + -webkit-box-shadow: none; + box-shadow: none; +} +.btn-link, +.btn-link:hover, +.btn-link:focus, +.btn-link:active { + border-color: transparent; +} +.btn-link:hover, +.btn-link:focus { + color: #afbad0; + text-decoration: underline; + background-color: transparent; +} +.btn-link[disabled]:hover, +fieldset[disabled] .btn-link:hover, +.btn-link[disabled]:focus, +fieldset[disabled] .btn-link:focus { + color: #cdcdcc; + text-decoration: none; +} +.btn-lg { + padding: 10px 16px; + font-size: 14pt; + line-height: 1.3333333; + border-radius: 6px; +} +.btn-sm { + padding: 5px 10px; + font-size: 10pt; + line-height: 1.5; + border-radius: 3px; +} +.btn-xs { + padding: 1px 5px; + font-size: 10pt; + line-height: 1.5; + border-radius: 3px; +} +.btn-block { + display: block; + width: 100%; +} +.btn-block + .btn-block { + margin-top: 5px; +} +input[type="submit"].btn-block, +input[type="reset"].btn-block, +input[type="button"].btn-block { + width: 100%; +} +.nav { + margin-bottom: 0; + padding-left: 0; + list-style: none; +} +.nav > li { + position: relative; + display: block; +} +.nav > li > a { + position: relative; + display: block; + padding: 10px 15px; +} +.nav > li > a:hover, +.nav > li > a:focus { + text-decoration: none; + background-color: transparent; +} +.nav > li.disabled > a { + color: #cdcdcc; +} +.nav > li.disabled > a:hover, +.nav > li.disabled > a:focus { + color: #cdcdcc; + text-decoration: none; + background-color: transparent; + cursor: not-allowed; +} +.nav .open > a, +.nav .open > a:hover, +.nav .open > a:focus { + background-color: transparent; + border-color: #7f90b4; +} +.nav .nav-divider { + height: 1px; + margin: 7.5pt 0; + overflow: hidden; + background-color: #e5e5e5; +} +.nav > li > a > img { + max-width: none; +} +.nav-tabs { + border-bottom: 1px solid #dddddd; +} +.nav-tabs > li { + float: left; + margin-bottom: -1px; +} +.nav-tabs > li > a { + margin-right: 2px; + line-height: 1.6; + border: 1px solid transparent; + border-radius: 4px 4px 0 0; +} +.nav-tabs > li > a:hover { + border-color: #ffffff #ffffff #dddddd; +} +.nav-tabs > li.active > a, +.nav-tabs > li.active > a:hover, +.nav-tabs > li.active > a:focus { + color: #ffffff; + background-color: #ffffff; + border: 1px solid #dddddd; + border-bottom-color: transparent; + cursor: default; +} +.nav-tabs.nav-justified { + width: 100%; + border-bottom: 0; +} +.nav-tabs.nav-justified > li { + float: none; +} +.nav-tabs.nav-justified > li > a { + text-align: center; + margin-bottom: 5px; +} +.nav-tabs.nav-justified > .dropdown .dropdown-menu { + top: auto; + left: auto; +} +@media (min-width: 768px) { + .nav-tabs.nav-justified > li { + display: table-cell; + width: 1%; + } + .nav-tabs.nav-justified > li > a { + margin-bottom: 0; + } +} +.nav-tabs.nav-justified > li > a { + margin-right: 0; + border-radius: 4px; +} +.nav-tabs.nav-justified > .active > a, +.nav-tabs.nav-justified > .active > a:hover, +.nav-tabs.nav-justified > .active > a:focus { + border: 1px solid #dddddd; +} +@media (min-width: 768px) { + .nav-tabs.nav-justified > li > a { + border-bottom: 1px solid #dddddd; + border-radius: 4px 4px 0 0; + } + .nav-tabs.nav-justified > .active > a, + .nav-tabs.nav-justified > .active > a:hover, + .nav-tabs.nav-justified > .active > a:focus { + border-bottom-color: #ffffff; + } +} +.nav-pills > li { + float: left; +} +.nav-pills > li > a { + border-radius: 4px; +} +.nav-pills > li + li { + margin-left: 2px; +} +.nav-pills > li.active > a, +.nav-pills > li.active > a:hover, +.nav-pills > li.active > a:focus { + color: #ffffff; + background-color: #e53200; +} +.nav-stacked > li { + float: none; +} +.nav-stacked > li + li { + margin-top: 2px; + margin-left: 0; +} +.nav-justified { + width: 100%; +} +.nav-justified > li { + float: none; +} +.nav-justified > li > a { + text-align: center; + margin-bottom: 5px; +} +.nav-justified > .dropdown .dropdown-menu { + top: auto; + left: auto; +} +@media (min-width: 768px) { + .nav-justified > li { + display: table-cell; + width: 1%; + } + .nav-justified > li > a { + margin-bottom: 0; + } +} +.nav-tabs-justified { + border-bottom: 0; +} +.nav-tabs-justified > li > a { + margin-right: 0; + border-radius: 4px; +} +.nav-tabs-justified > .active > a, +.nav-tabs-justified > .active > a:hover, +.nav-tabs-justified > .active > a:focus { + border: 1px solid #dddddd; +} +@media (min-width: 768px) { + .nav-tabs-justified > li > a { + border-bottom: 1px solid #dddddd; + border-radius: 4px 4px 0 0; + } + .nav-tabs-justified > .active > a, + .nav-tabs-justified > .active > a:hover, + .nav-tabs-justified > .active > a:focus { + border-bottom-color: #ffffff; + } +} +.tab-content > .tab-pane { + display: none; +} +.tab-content > .active { + display: block; +} +.nav-tabs .dropdown-menu { + margin-top: -1px; + border-top-right-radius: 0; + border-top-left-radius: 0; +} +.navbar { + position: relative; + min-height: 100px; + margin-bottom: 17pt; + border: 1px solid transparent; +} +@media (min-width: 768px) { + .navbar { + border-radius: 4px; + } +} +@media (min-width: 768px) { + .navbar-header { + float: left; + } +} +.navbar-collapse { + overflow-x: visible; + padding-right: 15px; + padding-left: 15px; + border-top: 1px solid transparent; + box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.1); + -webkit-overflow-scrolling: touch; +} +.navbar-collapse.in { + overflow-y: auto; +} +@media (min-width: 768px) { + .navbar-collapse { + width: auto; + border-top: 0; + box-shadow: none; + } + .navbar-collapse.collapse { + display: block !important; + height: auto !important; + padding-bottom: 0; + overflow: visible !important; + } + .navbar-collapse.in { + overflow-y: visible; + } + .navbar-fixed-top .navbar-collapse, + .navbar-static-top .navbar-collapse, + .navbar-fixed-bottom .navbar-collapse { + padding-left: 0; + padding-right: 0; + } +} +.navbar-fixed-top .navbar-collapse, +.navbar-fixed-bottom .navbar-collapse { + max-height: 340px; +} +@media (max-device-width: 480px) and (orientation: landscape) { + .navbar-fixed-top .navbar-collapse, + .navbar-fixed-bottom .navbar-collapse { + max-height: 200px; + } +} +.container > .navbar-header, +.container-fluid > .navbar-header, +.container > .navbar-collapse, +.container-fluid > .navbar-collapse { + margin-right: -15px; + margin-left: -15px; +} +@media (min-width: 768px) { + .container > .navbar-header, + .container-fluid > .navbar-header, + .container > .navbar-collapse, + .container-fluid > .navbar-collapse { + margin-right: 0; + margin-left: 0; + } +} +.navbar-static-top { + z-index: 1000; + border-width: 0 0 1px; +} +@media (min-width: 768px) { + .navbar-static-top { + border-radius: 0; + } +} +.navbar-fixed-top, +.navbar-fixed-bottom { + position: fixed; + right: 0; + left: 0; + z-index: 1030; +} +@media (min-width: 768px) { + .navbar-fixed-top, + .navbar-fixed-bottom { + border-radius: 0; + } +} +.navbar-fixed-top { + top: 0; + border-width: 0 0 1px; +} +.navbar-fixed-bottom { + bottom: 0; + margin-bottom: 0; + border-width: 1px 0 0; +} +.navbar-brand { + float: left; + padding: 38.66666667px 15px; + font-size: 14pt; + line-height: 17pt; + height: 100px; +} +.navbar-brand:hover, +.navbar-brand:focus { + text-decoration: none; +} +.navbar-brand > img { + display: block; +} +@media (min-width: 768px) { + .navbar > .container .navbar-brand, + .navbar > .container-fluid .navbar-brand { + margin-left: -15px; + } +} +.navbar-toggle { + position: relative; + float: right; + margin-right: 15px; + padding: 9px 10px; + margin-top: 33px; + margin-bottom: 33px; + background-color: transparent; + background-image: none; + border: 1px solid transparent; + border-radius: 4px; +} +.navbar-toggle:focus { + outline: 0; +} +.navbar-toggle .icon-bar { + display: block; + width: 22px; + height: 2px; + border-radius: 1px; +} +.navbar-toggle .icon-bar + .icon-bar { + margin-top: 4px; +} +@media (min-width: 768px) { + .navbar-toggle { + display: none; + } +} +.navbar-nav { + margin: 19.33333333px -15px; +} +.navbar-nav > li > a { + padding-top: 10px; + padding-bottom: 10px; + line-height: 17pt; +} +@media (max-width: 767px) { + .navbar-nav .open .dropdown-menu { + position: static; + float: none; + width: auto; + margin-top: 0; + background-color: transparent; + border: 0; + box-shadow: none; + } + .navbar-nav .open .dropdown-menu > li > a, + .navbar-nav .open .dropdown-menu .dropdown-header { + padding: 5px 15px 5px 25px; + } + .navbar-nav .open .dropdown-menu > li > a { + line-height: 17pt; + } + .navbar-nav .open .dropdown-menu > li > a:hover, + .navbar-nav .open .dropdown-menu > li > a:focus { + background-image: none; + } +} +@media (min-width: 768px) { + .navbar-nav { + float: left; + margin: 0; + } + .navbar-nav > li { + float: left; + } + .navbar-nav > li > a { + padding-top: 38.66666667px; + padding-bottom: 38.66666667px; + } +} +.navbar-form { + margin-left: -15px; + margin-right: -15px; + padding: 10px 15px; + border-top: 1px solid transparent; + border-bottom: 1px solid transparent; + -webkit-box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.1), 0 1px 0 rgba(255, 255, 255, 0.1); + box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.1), 0 1px 0 rgba(255, 255, 255, 0.1); + margin-top: 31.33333333px; + margin-bottom: 31.33333333px; +} +@media (min-width: 768px) { + .navbar-form .form-group { + display: inline-block; + margin-bottom: 0; + vertical-align: middle; + } + .navbar-form .form-control { + display: inline-block; + width: auto; + vertical-align: middle; + } + .navbar-form .form-control-static { + display: inline-block; + } + .navbar-form .input-group { + display: inline-table; + vertical-align: middle; + } + .navbar-form .input-group .input-group-addon, + .navbar-form .input-group .input-group-btn, + .navbar-form .input-group .form-control { + width: auto; + } + .navbar-form .input-group > .form-control { + width: 100%; + } + .navbar-form .control-label { + margin-bottom: 0; + vertical-align: middle; + } + .navbar-form .radio, + .navbar-form .checkbox { + display: inline-block; + margin-top: 0; + margin-bottom: 0; + vertical-align: middle; + } + .navbar-form .radio label, + .navbar-form .checkbox label { + padding-left: 0; + } + .navbar-form .radio input[type="radio"], + .navbar-form .checkbox input[type="checkbox"] { + position: relative; + margin-left: 0; + } + .navbar-form .has-feedback .form-control-feedback { + top: 0; + } +} +@media (max-width: 767px) { + .navbar-form .form-group { + margin-bottom: 5px; + } + .navbar-form .form-group:last-child { + margin-bottom: 0; + } +} +@media (min-width: 768px) { + .navbar-form { + width: auto; + border: 0; + margin-left: 0; + margin-right: 0; + padding-top: 0; + padding-bottom: 0; + -webkit-box-shadow: none; + box-shadow: none; + } +} +.navbar-nav > li > .dropdown-menu { + margin-top: 0; + border-top-right-radius: 0; + border-top-left-radius: 0; +} +.navbar-fixed-bottom .navbar-nav > li > .dropdown-menu { + margin-bottom: 0; + border-top-right-radius: 4px; + border-top-left-radius: 4px; + border-bottom-right-radius: 0; + border-bottom-left-radius: 0; +} +.navbar-btn { + margin-top: 31.33333333px; + margin-bottom: 31.33333333px; +} +.navbar-btn.btn-sm { + margin-top: 33.66666667px; + margin-bottom: 33.66666667px; +} +.navbar-btn.btn-xs { + margin-top: 39px; + margin-bottom: 39px; +} +.navbar-text { + margin-top: 38.66666667px; + margin-bottom: 38.66666667px; +} +@media (min-width: 768px) { + .navbar-text { + float: left; + margin-left: 15px; + margin-right: 15px; + } +} +@media (min-width: 768px) { + .navbar-left { + float: left !important; + } + .navbar-right { + float: right !important; + margin-right: -15px; + } + .navbar-right ~ .navbar-right { + margin-right: 0; + } +} +.navbar-default { + background-color: #f8f8f8; + border-color: #e7e7e7; +} +.navbar-default .navbar-brand { + color: #f8f8f8; +} +.navbar-default .navbar-brand:hover, +.navbar-default .navbar-brand:focus { + color: #dfdfdf; + background-color: transparent; +} +.navbar-default .navbar-text { + color: #777777; +} +.navbar-default .navbar-nav > li > a { + color: #f8f8f8; +} +.navbar-default .navbar-nav > li > a:hover, +.navbar-default .navbar-nav > li > a:focus { + color: #333333; + background-color: transparent; +} +.navbar-default .navbar-nav > .active > a, +.navbar-default .navbar-nav > .active > a:hover, +.navbar-default .navbar-nav > .active > a:focus { + color: #555555; + background-color: #e7e7e7; +} +.navbar-default .navbar-nav > .disabled > a, +.navbar-default .navbar-nav > .disabled > a:hover, +.navbar-default .navbar-nav > .disabled > a:focus { + color: #cccccc; + background-color: transparent; +} +.navbar-default .navbar-toggle { + border-color: #dddddd; +} +.navbar-default .navbar-toggle:hover, +.navbar-default .navbar-toggle:focus { + background-color: #dddddd; +} +.navbar-default .navbar-toggle .icon-bar { + background-color: #888888; +} +.navbar-default .navbar-collapse, +.navbar-default .navbar-form { + border-color: #e7e7e7; +} +.navbar-default .navbar-nav > .open > a, +.navbar-default .navbar-nav > .open > a:hover, +.navbar-default .navbar-nav > .open > a:focus { + background-color: #e7e7e7; + color: #555555; +} +@media (max-width: 767px) { + .navbar-default .navbar-nav .open .dropdown-menu > li > a { + color: #f8f8f8; + } + .navbar-default .navbar-nav .open .dropdown-menu > li > a:hover, + .navbar-default .navbar-nav .open .dropdown-menu > li > a:focus { + color: #333333; + background-color: transparent; + } + .navbar-default .navbar-nav .open .dropdown-menu > .active > a, + .navbar-default .navbar-nav .open .dropdown-menu > .active > a:hover, + .navbar-default .navbar-nav .open .dropdown-menu > .active > a:focus { + color: #555555; + background-color: #e7e7e7; + } + .navbar-default .navbar-nav .open .dropdown-menu > .disabled > a, + .navbar-default .navbar-nav .open .dropdown-menu > .disabled > a:hover, + .navbar-default .navbar-nav .open .dropdown-menu > .disabled > a:focus { + color: #cccccc; + background-color: transparent; + } +} +.navbar-default .navbar-link { + color: #f8f8f8; +} +.navbar-default .navbar-link:hover { + color: #333333; +} +.navbar-default .btn-link { + color: #f8f8f8; +} +.navbar-default .btn-link:hover, +.navbar-default .btn-link:focus { + color: #333333; +} +.navbar-default .btn-link[disabled]:hover, +fieldset[disabled] .navbar-default .btn-link:hover, +.navbar-default .btn-link[disabled]:focus, +fieldset[disabled] .navbar-default .btn-link:focus { + color: #cccccc; +} +.navbar-inverse { + background-color: transparent; + border-color: rgba(0, 0, 0, 0); +} +.navbar-inverse .navbar-brand { + color: #ffffff; +} +.navbar-inverse .navbar-brand:hover, +.navbar-inverse .navbar-brand:focus { + color: #ffffff; + background-color: transparent; +} +.navbar-inverse .navbar-text { + color: #f3f3f2; +} +.navbar-inverse .navbar-nav > li > a { + color: #ffffff; +} +.navbar-inverse .navbar-nav > li > a:hover, +.navbar-inverse .navbar-nav > li > a:focus { + color: #ffffff; + background-color: transparent; +} +.navbar-inverse .navbar-nav > .active > a, +.navbar-inverse .navbar-nav > .active > a:hover, +.navbar-inverse .navbar-nav > .active > a:focus { + color: #ffffff; + background-color: rgba(0, 0, 0, 0); +} +.navbar-inverse .navbar-nav > .disabled > a, +.navbar-inverse .navbar-nav > .disabled > a:hover, +.navbar-inverse .navbar-nav > .disabled > a:focus { + color: #444444; + background-color: transparent; +} +.navbar-inverse .navbar-toggle { + border-color: #333333; +} +.navbar-inverse .navbar-toggle:hover, +.navbar-inverse .navbar-toggle:focus { + background-color: #333333; +} +.navbar-inverse .navbar-toggle .icon-bar { + background-color: #ffffff; +} +.navbar-inverse .navbar-collapse, +.navbar-inverse .navbar-form { + border-color: rgba(0, 0, 0, 0); +} +.navbar-inverse .navbar-nav > .open > a, +.navbar-inverse .navbar-nav > .open > a:hover, +.navbar-inverse .navbar-nav > .open > a:focus { + background-color: rgba(0, 0, 0, 0); + color: #ffffff; +} +@media (max-width: 767px) { + .navbar-inverse .navbar-nav .open .dropdown-menu > .dropdown-header { + border-color: rgba(0, 0, 0, 0); + } + .navbar-inverse .navbar-nav .open .dropdown-menu .divider { + background-color: rgba(0, 0, 0, 0); + } + .navbar-inverse .navbar-nav .open .dropdown-menu > li > a { + color: #ffffff; + } + .navbar-inverse .navbar-nav .open .dropdown-menu > li > a:hover, + .navbar-inverse .navbar-nav .open .dropdown-menu > li > a:focus { + color: #ffffff; + background-color: transparent; + } + .navbar-inverse .navbar-nav .open .dropdown-menu > .active > a, + .navbar-inverse .navbar-nav .open .dropdown-menu > .active > a:hover, + .navbar-inverse .navbar-nav .open .dropdown-menu > .active > a:focus { + color: #ffffff; + background-color: rgba(0, 0, 0, 0); + } + .navbar-inverse .navbar-nav .open .dropdown-menu > .disabled > a, + .navbar-inverse .navbar-nav .open .dropdown-menu > .disabled > a:hover, + .navbar-inverse .navbar-nav .open .dropdown-menu > .disabled > a:focus { + color: #444444; + background-color: transparent; + } +} +.navbar-inverse .navbar-link { + color: #ffffff; +} +.navbar-inverse .navbar-link:hover { + color: #ffffff; +} +.navbar-inverse .btn-link { + color: #ffffff; +} +.navbar-inverse .btn-link:hover, +.navbar-inverse .btn-link:focus { + color: #ffffff; +} +.navbar-inverse .btn-link[disabled]:hover, +fieldset[disabled] .navbar-inverse .btn-link:hover, +.navbar-inverse .btn-link[disabled]:focus, +fieldset[disabled] .navbar-inverse .btn-link:focus { + color: #444444; +} +.alert { + padding: 15px; + margin-bottom: 17pt; + border: 1px solid transparent; + border-radius: 4px; +} +.alert h4 { + margin-top: 0; + color: inherit; +} +.alert .alert-link { + font-weight: bold; +} +.alert > p, +.alert > ul { + margin-bottom: 0; +} +.alert > p + p { + margin-top: 5px; +} +.alert-dismissable, +.alert-dismissible { + padding-right: 35px; +} +.alert-dismissable .close, +.alert-dismissible .close { + position: relative; + top: -2px; + right: -21px; + color: inherit; +} +.alert-success { + background-color: #dff0d8; + border-color: #d6e9c6; + color: #3c763d; +} +.alert-success hr { + border-top-color: #c9e2b3; +} +.alert-success .alert-link { + color: #2b542c; +} +.alert-info { + background-color: #d9edf7; + border-color: #bce8f1; + color: #31708f; +} +.alert-info hr { + border-top-color: #a6e1ec; +} +.alert-info .alert-link { + color: #245269; +} +.alert-warning { + background-color: #fcf8e3; + border-color: #faebcc; + color: #8a6d3b; +} +.alert-warning hr { + border-top-color: #f7e1b5; +} +.alert-warning .alert-link { + color: #66512c; +} +.alert-danger { + background-color: #f2dede; + border-color: #ebccd1; + color: #a94442; +} +.alert-danger hr { + border-top-color: #e4b9c0; +} +.alert-danger .alert-link { + color: #843534; +} +.embed-responsive { + position: relative; + display: block; + height: 0; + padding: 0; + overflow: hidden; +} +.embed-responsive .embed-responsive-item, +.embed-responsive iframe, +.embed-responsive embed, +.embed-responsive object, +.embed-responsive video { + position: absolute; + top: 0; + left: 0; + bottom: 0; + height: 100%; + width: 100%; + border: 0; +} +.embed-responsive-16by9 { + padding-bottom: 56.25%; +} +.embed-responsive-4by3 { + padding-bottom: 75%; +} +.well { + min-height: 20px; + padding: 19px; + margin-bottom: 20px; + background-color: #f5f5f5; + border: 1px solid #e3e3e3; + border-radius: 4px; + -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.05); + box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.05); +} +.well blockquote { + border-color: #ddd; + border-color: rgba(0, 0, 0, 0.15); +} +.well-lg { + padding: 24px; + border-radius: 6px; +} +.well-sm { + padding: 9px; + border-radius: 3px; +} +.clearfix:before, +.clearfix:after, +.dl-horizontal dd:before, +.dl-horizontal dd:after, +.container:before, +.container:after, +.container-fluid:before, +.container-fluid:after, +.row:before, +.row:after, +.form-horizontal .form-group:before, +.form-horizontal .form-group:after, +.nav:before, +.nav:after, +.navbar:before, +.navbar:after, +.navbar-header:before, +.navbar-header:after, +.navbar-collapse:before, +.navbar-collapse:after { + content: " "; + display: table; +} +.clearfix:after, +.dl-horizontal dd:after, +.container:after, +.container-fluid:after, +.row:after, +.form-horizontal .form-group:after, +.nav:after, +.navbar:after, +.navbar-header:after, +.navbar-collapse:after { + clear: both; +} +.center-block { + display: block; + margin-left: auto; + margin-right: auto; +} +.pull-right { + float: right !important; +} +.pull-left { + float: left !important; +} +.hide { + display: none !important; +} +.show { + display: block !important; +} +.invisible { + visibility: hidden; +} +.text-hide { + font: 0/0 a; + color: transparent; + text-shadow: none; + background-color: transparent; + border: 0; +} +.hidden { + display: none !important; +} +.affix { + position: fixed; +} +@-ms-viewport { + width: device-width; +} +.visible-xs, +.visible-sm, +.visible-md, +.visible-lg { + display: none !important; +} +.visible-xs-block, +.visible-xs-inline, +.visible-xs-inline-block, +.visible-sm-block, +.visible-sm-inline, +.visible-sm-inline-block, +.visible-md-block, +.visible-md-inline, +.visible-md-inline-block, +.visible-lg-block, +.visible-lg-inline, +.visible-lg-inline-block { + display: none !important; +} +@media (max-width: 767px) { + .visible-xs { + display: block !important; + } + table.visible-xs { + display: table; + } + tr.visible-xs { + display: table-row !important; + } + th.visible-xs, + td.visible-xs { + display: table-cell !important; + } +} +@media (max-width: 767px) { + .visible-xs-block { + display: block !important; + } +} +@media (max-width: 767px) { + .visible-xs-inline { + display: inline !important; + } +} +@media (max-width: 767px) { + .visible-xs-inline-block { + display: inline-block !important; + } +} +@media (min-width: 768px) and (max-width: 991px) { + .visible-sm { + display: block !important; + } + table.visible-sm { + display: table; + } + tr.visible-sm { + display: table-row !important; + } + th.visible-sm, + td.visible-sm { + display: table-cell !important; + } +} +@media (min-width: 768px) and (max-width: 991px) { + .visible-sm-block { + display: block !important; + } +} +@media (min-width: 768px) and (max-width: 991px) { + .visible-sm-inline { + display: inline !important; + } +} +@media (min-width: 768px) and (max-width: 991px) { + .visible-sm-inline-block { + display: inline-block !important; + } +} +@media (min-width: 992px) and (max-width: 1199px) { + .visible-md { + display: block !important; + } + table.visible-md { + display: table; + } + tr.visible-md { + display: table-row !important; + } + th.visible-md, + td.visible-md { + display: table-cell !important; + } +} +@media (min-width: 992px) and (max-width: 1199px) { + .visible-md-block { + display: block !important; + } +} +@media (min-width: 992px) and (max-width: 1199px) { + .visible-md-inline { + display: inline !important; + } +} +@media (min-width: 992px) and (max-width: 1199px) { + .visible-md-inline-block { + display: inline-block !important; + } +} +@media (min-width: 1200px) { + .visible-lg { + display: block !important; + } + table.visible-lg { + display: table; + } + tr.visible-lg { + display: table-row !important; + } + th.visible-lg, + td.visible-lg { + display: table-cell !important; + } +} +@media (min-width: 1200px) { + .visible-lg-block { + display: block !important; + } +} +@media (min-width: 1200px) { + .visible-lg-inline { + display: inline !important; + } +} +@media (min-width: 1200px) { + .visible-lg-inline-block { + display: inline-block !important; + } +} +@media (max-width: 767px) { + .hidden-xs { + display: none !important; + } +} +@media (min-width: 768px) and (max-width: 991px) { + .hidden-sm { + display: none !important; + } +} +@media (min-width: 992px) and (max-width: 1199px) { + .hidden-md { + display: none !important; + } +} +@media (min-width: 1200px) { + .hidden-lg { + display: none !important; + } +} +.visible-print { + display: none !important; +} +@media print { + .visible-print { + display: block !important; + } + table.visible-print { + display: table; + } + tr.visible-print { + display: table-row !important; + } + th.visible-print, + td.visible-print { + display: table-cell !important; + } +} +.visible-print-block { + display: none !important; +} +@media print { + .visible-print-block { + display: block !important; + } +} +.visible-print-inline { + display: none !important; +} +@media print { + .visible-print-inline { + display: inline !important; + } +} +.visible-print-inline-block { + display: none !important; +} +@media print { + .visible-print-inline-block { + display: inline-block !important; + } +} +@media print { + .hidden-print { + display: none !important; + } +} +pre { + color: #8f9ebd; + background-color: #1c2331; + border-color: #262f41; +} +g { + -webkit-transition: opacity 0.15s ease-out; + -moz-transition: opacity 0.15s ease-out; + -ms-transition: opacity 0.15s ease-out; + -o-transition: opacity 0.15s ease-out; + transition: opacity 0.15s ease-out; + opacity: 1.0; +} +g.faded { + opacity: 0; + pointer-events: none; +} +.graph-divider { + width: 100%; + height: 5px; + background-color: #cdcdcc; +} +/* ========================================================================== + Wrap Sections + ========================================================================== */ +.scope { + margin-bottom: 180px; +} +@media (max-width: 991px) { + .scope { + margin-bottom: 0; + } +} +.scope h1 { + color: white; + font-size: 96px; + text-shadow: 0 1px 3px rgba(0, 0, 0, 0.25); + margin-bottom: 0; +} +.scope h3 { + color: white; + font-size: 30px; + margin-top: 0; + text-shadow: 0 1px 3px rgba(0, 0, 0, 0.25); +} +.scope h5 { + font-weight: 700; + color: white; + text-align: left; + text-shadow: 0 1px 3px rgba(0, 0, 0, 0.25); +} +.scope p { + text-align: left; + color: #ffffff; +} +/* intro Wrap */ +#intro { + padding-top: 2em; + border-top: #bdc3c7 solid 5px; + padding-bottom: 2em; +} +#featureswrap { + color: white; + display: block; + padding-top: 2em; +} +#featureswrap h1, +#featureswrap h3, +#featureswrap h4, +#featureswrap h5 { + color: white; +} +#featureswrap .row { + margin: 4em 0; +} +/* Showcase Wrap */ +#showcasewrap { + display: block; + background: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAQAAAAECAYAAACp8Z5+AAAAKklEQVQIW2OU98z7zwAF//8zPGeECYA5jAySYAEYB6SQUc4j7xlIBqYNAIfdED63kdz3AAAAAElFTkSuQmCC) repeat; +} +#showcasewrap .carousel-indicators { + bottom: -50px; +} +#showcasewrap .carousel-inner { + box-shadow: 0 3px 10px rgba(0, 0, 0, 0.5); +} +#showcasewrap h1 { + color: white; + padding: 1em 0; +} +#footerwrap { + background-color: #13131d; + color: white; + padding-top: 40px; + padding-bottom: 60px; + text-align: left; +} +#footerwrap .btn { + font-weight: bold; + font-size: 125%; +} +#footerwrap h3 { + font-size: 28px; + color: white; +} +#footerwrap p { + color: white; + font-size: 90%; +} +/* Copyright Wrap */ +#c { + background: #222222; + padding-top: 15px; +} +#c p { + color: #ffffff; +} +/* Topology */ +#graph { + position: relative; +} +.bottom { + margin-top: 700px; +} +#graph svg { + height: 1050px; + position: absolute; + top: -260px; + left: 0; + z-index: 100; +} +text { + font: 10px sans-serif; + pointer-events: none; + fill: #81817f; + text-shadow: 0 1px 2px rgba(0, 0, 0, 0.2); +} +path.thin-link { + fill: none; + stroke: #81817f; + stroke-width: 1px; + stroke-opacity: 0.2; + pointer-events: none; +} +path.shadow-link { + fill: none; + stroke: #6f83aa; + stroke-width: 9px; + stroke-opacity: 0; + pointer-events: none; +} +g.active path.shadow-link, +g.highlight path.thin-link { + stroke-opacity: 0.8; +} +g.active path.thin-link, +g.connected path.thin-link { + stroke: #425271; + stroke-opacity: 0.8; +} +g.host circle.host-shadow { + fill: #f3f3f2; + stroke: white; + stroke-width: 4px; + fill-opacity: 0.8; +} +g.host circle.host { + fill: #81817f; +} +g.host text.hostname { + fill: #9a9a98; + font-size: 16px; +} +g.host.active circle.host { + fill: #425271; +} +g.host.active circle.host-shadow { + fill: #bfc8d9; +} +g.host#host-theinternet text { + fill: #9a9a98; + font-size: 16px; +} +g.host#host-theinternet .internet-symbol { + fill: #81817f; +} +g.host#host-theinternet.active text.internet-symbol, +g.host#host-theinternet.connected text.internet-symbol { + fill: #425271; +} +/* + * Social Buttons for Bootstrap + * + * Copyright 2013-2015 Panayiotis Lipiridis + * Licensed under the MIT License + * + * https://github.com/lipis/bootstrap-social + */ +.btn-social { + position: relative; + padding-left: 35pt; + text-align: left; + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; +} +.btn-social > :first-child { + position: absolute; + left: 0; + top: 0; + bottom: 0; + width: 26pt; + line-height: 28pt; + font-size: 1.6em; + text-align: center; + border-right: 1px solid rgba(0, 0, 0, 0.2); +} +.btn-social.btn-lg { + padding-left: 49pt; +} +.btn-social.btn-lg > :first-child { + line-height: 37pt; + width: 37pt; + font-size: 1.8em; +} +.btn-social.btn-sm { + padding-left: 30pt; +} +.btn-social.btn-sm > :first-child { + line-height: 22.5pt; + width: 22.5pt; + font-size: 1.4em; +} +.btn-social.btn-xs { + padding-left: 24.25pt; +} +.btn-social.btn-xs > :first-child { + line-height: 16.75pt; + width: 16.75pt; + font-size: 1.2em; +} +.btn-social-icon { + position: relative; + padding-left: 35pt; + text-align: left; + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; + height: 28pt; + width: 28pt; + padding: 0; +} +.btn-social-icon > :first-child { + position: absolute; + left: 0; + top: 0; + bottom: 0; + width: 26pt; + line-height: 28pt; + font-size: 1.6em; + text-align: center; + border-right: 1px solid rgba(0, 0, 0, 0.2); +} +.btn-social-icon.btn-lg { + padding-left: 49pt; +} +.btn-social-icon.btn-lg > :first-child { + line-height: 37pt; + width: 37pt; + font-size: 1.8em; +} +.btn-social-icon.btn-sm { + padding-left: 30pt; +} +.btn-social-icon.btn-sm > :first-child { + line-height: 22.5pt; + width: 22.5pt; + font-size: 1.4em; +} +.btn-social-icon.btn-xs { + padding-left: 24.25pt; +} +.btn-social-icon.btn-xs > :first-child { + line-height: 16.75pt; + width: 16.75pt; + font-size: 1.2em; +} +.btn-social-icon > :first-child { + border: none; + text-align: center; + width: 100%!important; +} +.btn-social-icon.btn-lg { + height: 37pt; + width: 37pt; + padding-left: 0; + padding-right: 0; +} +.btn-social-icon.btn-sm { + height: 24.5pt; + width: 24.5pt; + padding-left: 0; + padding-right: 0; +} +.btn-social-icon.btn-xs { + height: 18.75pt; + width: 18.75pt; + padding-left: 0; + padding-right: 0; +} +.btn-adn { + color: #ffffff; + background-color: #d87a68; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-adn:hover, +.btn-adn:focus, +.btn-adn.focus, +.btn-adn:active, +.btn-adn.active, +.open > .dropdown-toggle.btn-adn { + color: #ffffff; + background-color: #ce563f; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-adn:active, +.btn-adn.active, +.open > .dropdown-toggle.btn-adn { + background-image: none; +} +.btn-adn.disabled, +.btn-adn[disabled], +fieldset[disabled] .btn-adn, +.btn-adn.disabled:hover, +.btn-adn[disabled]:hover, +fieldset[disabled] .btn-adn:hover, +.btn-adn.disabled:focus, +.btn-adn[disabled]:focus, +fieldset[disabled] .btn-adn:focus, +.btn-adn.disabled.focus, +.btn-adn[disabled].focus, +fieldset[disabled] .btn-adn.focus, +.btn-adn.disabled:active, +.btn-adn[disabled]:active, +fieldset[disabled] .btn-adn:active, +.btn-adn.disabled.active, +.btn-adn[disabled].active, +fieldset[disabled] .btn-adn.active { + background-color: #d87a68; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-adn .badge { + color: #d87a68; + background-color: #ffffff; +} +.btn-bitbucket { + color: #ffffff; + background-color: #205081; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-bitbucket:hover, +.btn-bitbucket:focus, +.btn-bitbucket.focus, +.btn-bitbucket:active, +.btn-bitbucket.active, +.open > .dropdown-toggle.btn-bitbucket { + color: #ffffff; + background-color: #163758; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-bitbucket:active, +.btn-bitbucket.active, +.open > .dropdown-toggle.btn-bitbucket { + background-image: none; +} +.btn-bitbucket.disabled, +.btn-bitbucket[disabled], +fieldset[disabled] .btn-bitbucket, +.btn-bitbucket.disabled:hover, +.btn-bitbucket[disabled]:hover, +fieldset[disabled] .btn-bitbucket:hover, +.btn-bitbucket.disabled:focus, +.btn-bitbucket[disabled]:focus, +fieldset[disabled] .btn-bitbucket:focus, +.btn-bitbucket.disabled.focus, +.btn-bitbucket[disabled].focus, +fieldset[disabled] .btn-bitbucket.focus, +.btn-bitbucket.disabled:active, +.btn-bitbucket[disabled]:active, +fieldset[disabled] .btn-bitbucket:active, +.btn-bitbucket.disabled.active, +.btn-bitbucket[disabled].active, +fieldset[disabled] .btn-bitbucket.active { + background-color: #205081; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-bitbucket .badge { + color: #205081; + background-color: #ffffff; +} +.btn-dropbox { + color: #ffffff; + background-color: #1087dd; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-dropbox:hover, +.btn-dropbox:focus, +.btn-dropbox.focus, +.btn-dropbox:active, +.btn-dropbox.active, +.open > .dropdown-toggle.btn-dropbox { + color: #ffffff; + background-color: #0d6aad; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-dropbox:active, +.btn-dropbox.active, +.open > .dropdown-toggle.btn-dropbox { + background-image: none; +} +.btn-dropbox.disabled, +.btn-dropbox[disabled], +fieldset[disabled] .btn-dropbox, +.btn-dropbox.disabled:hover, +.btn-dropbox[disabled]:hover, +fieldset[disabled] .btn-dropbox:hover, +.btn-dropbox.disabled:focus, +.btn-dropbox[disabled]:focus, +fieldset[disabled] .btn-dropbox:focus, +.btn-dropbox.disabled.focus, +.btn-dropbox[disabled].focus, +fieldset[disabled] .btn-dropbox.focus, +.btn-dropbox.disabled:active, +.btn-dropbox[disabled]:active, +fieldset[disabled] .btn-dropbox:active, +.btn-dropbox.disabled.active, +.btn-dropbox[disabled].active, +fieldset[disabled] .btn-dropbox.active { + background-color: #1087dd; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-dropbox .badge { + color: #1087dd; + background-color: #ffffff; +} +.btn-facebook { + color: #ffffff; + background-color: #3b5998; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-facebook:hover, +.btn-facebook:focus, +.btn-facebook.focus, +.btn-facebook:active, +.btn-facebook.active, +.open > .dropdown-toggle.btn-facebook { + color: #ffffff; + background-color: #2d4373; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-facebook:active, +.btn-facebook.active, +.open > .dropdown-toggle.btn-facebook { + background-image: none; +} +.btn-facebook.disabled, +.btn-facebook[disabled], +fieldset[disabled] .btn-facebook, +.btn-facebook.disabled:hover, +.btn-facebook[disabled]:hover, +fieldset[disabled] .btn-facebook:hover, +.btn-facebook.disabled:focus, +.btn-facebook[disabled]:focus, +fieldset[disabled] .btn-facebook:focus, +.btn-facebook.disabled.focus, +.btn-facebook[disabled].focus, +fieldset[disabled] .btn-facebook.focus, +.btn-facebook.disabled:active, +.btn-facebook[disabled]:active, +fieldset[disabled] .btn-facebook:active, +.btn-facebook.disabled.active, +.btn-facebook[disabled].active, +fieldset[disabled] .btn-facebook.active { + background-color: #3b5998; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-facebook .badge { + color: #3b5998; + background-color: #ffffff; +} +.btn-flickr { + color: #ffffff; + background-color: #ff0084; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-flickr:hover, +.btn-flickr:focus, +.btn-flickr.focus, +.btn-flickr:active, +.btn-flickr.active, +.open > .dropdown-toggle.btn-flickr { + color: #ffffff; + background-color: #cc006a; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-flickr:active, +.btn-flickr.active, +.open > .dropdown-toggle.btn-flickr { + background-image: none; +} +.btn-flickr.disabled, +.btn-flickr[disabled], +fieldset[disabled] .btn-flickr, +.btn-flickr.disabled:hover, +.btn-flickr[disabled]:hover, +fieldset[disabled] .btn-flickr:hover, +.btn-flickr.disabled:focus, +.btn-flickr[disabled]:focus, +fieldset[disabled] .btn-flickr:focus, +.btn-flickr.disabled.focus, +.btn-flickr[disabled].focus, +fieldset[disabled] .btn-flickr.focus, +.btn-flickr.disabled:active, +.btn-flickr[disabled]:active, +fieldset[disabled] .btn-flickr:active, +.btn-flickr.disabled.active, +.btn-flickr[disabled].active, +fieldset[disabled] .btn-flickr.active { + background-color: #ff0084; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-flickr .badge { + color: #ff0084; + background-color: #ffffff; +} +.btn-foursquare { + color: #ffffff; + background-color: #f94877; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-foursquare:hover, +.btn-foursquare:focus, +.btn-foursquare.focus, +.btn-foursquare:active, +.btn-foursquare.active, +.open > .dropdown-toggle.btn-foursquare { + color: #ffffff; + background-color: #f71752; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-foursquare:active, +.btn-foursquare.active, +.open > .dropdown-toggle.btn-foursquare { + background-image: none; +} +.btn-foursquare.disabled, +.btn-foursquare[disabled], +fieldset[disabled] .btn-foursquare, +.btn-foursquare.disabled:hover, +.btn-foursquare[disabled]:hover, +fieldset[disabled] .btn-foursquare:hover, +.btn-foursquare.disabled:focus, +.btn-foursquare[disabled]:focus, +fieldset[disabled] .btn-foursquare:focus, +.btn-foursquare.disabled.focus, +.btn-foursquare[disabled].focus, +fieldset[disabled] .btn-foursquare.focus, +.btn-foursquare.disabled:active, +.btn-foursquare[disabled]:active, +fieldset[disabled] .btn-foursquare:active, +.btn-foursquare.disabled.active, +.btn-foursquare[disabled].active, +fieldset[disabled] .btn-foursquare.active { + background-color: #f94877; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-foursquare .badge { + color: #f94877; + background-color: #ffffff; +} +.btn-github { + color: #ffffff; + background-color: #444444; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-github:hover, +.btn-github:focus, +.btn-github.focus, +.btn-github:active, +.btn-github.active, +.open > .dropdown-toggle.btn-github { + color: #ffffff; + background-color: #2b2b2b; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-github:active, +.btn-github.active, +.open > .dropdown-toggle.btn-github { + background-image: none; +} +.btn-github.disabled, +.btn-github[disabled], +fieldset[disabled] .btn-github, +.btn-github.disabled:hover, +.btn-github[disabled]:hover, +fieldset[disabled] .btn-github:hover, +.btn-github.disabled:focus, +.btn-github[disabled]:focus, +fieldset[disabled] .btn-github:focus, +.btn-github.disabled.focus, +.btn-github[disabled].focus, +fieldset[disabled] .btn-github.focus, +.btn-github.disabled:active, +.btn-github[disabled]:active, +fieldset[disabled] .btn-github:active, +.btn-github.disabled.active, +.btn-github[disabled].active, +fieldset[disabled] .btn-github.active { + background-color: #444444; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-github .badge { + color: #444444; + background-color: #ffffff; +} +.btn-google { + color: #ffffff; + background-color: #dd4b39; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-google:hover, +.btn-google:focus, +.btn-google.focus, +.btn-google:active, +.btn-google.active, +.open > .dropdown-toggle.btn-google { + color: #ffffff; + background-color: #c23321; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-google:active, +.btn-google.active, +.open > .dropdown-toggle.btn-google { + background-image: none; +} +.btn-google.disabled, +.btn-google[disabled], +fieldset[disabled] .btn-google, +.btn-google.disabled:hover, +.btn-google[disabled]:hover, +fieldset[disabled] .btn-google:hover, +.btn-google.disabled:focus, +.btn-google[disabled]:focus, +fieldset[disabled] .btn-google:focus, +.btn-google.disabled.focus, +.btn-google[disabled].focus, +fieldset[disabled] .btn-google.focus, +.btn-google.disabled:active, +.btn-google[disabled]:active, +fieldset[disabled] .btn-google:active, +.btn-google.disabled.active, +.btn-google[disabled].active, +fieldset[disabled] .btn-google.active { + background-color: #dd4b39; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-google .badge { + color: #dd4b39; + background-color: #ffffff; +} +.btn-instagram { + color: #ffffff; + background-color: #3f729b; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-instagram:hover, +.btn-instagram:focus, +.btn-instagram.focus, +.btn-instagram:active, +.btn-instagram.active, +.open > .dropdown-toggle.btn-instagram { + color: #ffffff; + background-color: #305777; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-instagram:active, +.btn-instagram.active, +.open > .dropdown-toggle.btn-instagram { + background-image: none; +} +.btn-instagram.disabled, +.btn-instagram[disabled], +fieldset[disabled] .btn-instagram, +.btn-instagram.disabled:hover, +.btn-instagram[disabled]:hover, +fieldset[disabled] .btn-instagram:hover, +.btn-instagram.disabled:focus, +.btn-instagram[disabled]:focus, +fieldset[disabled] .btn-instagram:focus, +.btn-instagram.disabled.focus, +.btn-instagram[disabled].focus, +fieldset[disabled] .btn-instagram.focus, +.btn-instagram.disabled:active, +.btn-instagram[disabled]:active, +fieldset[disabled] .btn-instagram:active, +.btn-instagram.disabled.active, +.btn-instagram[disabled].active, +fieldset[disabled] .btn-instagram.active { + background-color: #3f729b; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-instagram .badge { + color: #3f729b; + background-color: #ffffff; +} +.btn-linkedin { + color: #ffffff; + background-color: #007bb6; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-linkedin:hover, +.btn-linkedin:focus, +.btn-linkedin.focus, +.btn-linkedin:active, +.btn-linkedin.active, +.open > .dropdown-toggle.btn-linkedin { + color: #ffffff; + background-color: #005983; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-linkedin:active, +.btn-linkedin.active, +.open > .dropdown-toggle.btn-linkedin { + background-image: none; +} +.btn-linkedin.disabled, +.btn-linkedin[disabled], +fieldset[disabled] .btn-linkedin, +.btn-linkedin.disabled:hover, +.btn-linkedin[disabled]:hover, +fieldset[disabled] .btn-linkedin:hover, +.btn-linkedin.disabled:focus, +.btn-linkedin[disabled]:focus, +fieldset[disabled] .btn-linkedin:focus, +.btn-linkedin.disabled.focus, +.btn-linkedin[disabled].focus, +fieldset[disabled] .btn-linkedin.focus, +.btn-linkedin.disabled:active, +.btn-linkedin[disabled]:active, +fieldset[disabled] .btn-linkedin:active, +.btn-linkedin.disabled.active, +.btn-linkedin[disabled].active, +fieldset[disabled] .btn-linkedin.active { + background-color: #007bb6; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-linkedin .badge { + color: #007bb6; + background-color: #ffffff; +} +.btn-microsoft { + color: #ffffff; + background-color: #2672ec; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-microsoft:hover, +.btn-microsoft:focus, +.btn-microsoft.focus, +.btn-microsoft:active, +.btn-microsoft.active, +.open > .dropdown-toggle.btn-microsoft { + color: #ffffff; + background-color: #125acd; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-microsoft:active, +.btn-microsoft.active, +.open > .dropdown-toggle.btn-microsoft { + background-image: none; +} +.btn-microsoft.disabled, +.btn-microsoft[disabled], +fieldset[disabled] .btn-microsoft, +.btn-microsoft.disabled:hover, +.btn-microsoft[disabled]:hover, +fieldset[disabled] .btn-microsoft:hover, +.btn-microsoft.disabled:focus, +.btn-microsoft[disabled]:focus, +fieldset[disabled] .btn-microsoft:focus, +.btn-microsoft.disabled.focus, +.btn-microsoft[disabled].focus, +fieldset[disabled] .btn-microsoft.focus, +.btn-microsoft.disabled:active, +.btn-microsoft[disabled]:active, +fieldset[disabled] .btn-microsoft:active, +.btn-microsoft.disabled.active, +.btn-microsoft[disabled].active, +fieldset[disabled] .btn-microsoft.active { + background-color: #2672ec; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-microsoft .badge { + color: #2672ec; + background-color: #ffffff; +} +.btn-openid { + color: #ffffff; + background-color: #f7931e; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-openid:hover, +.btn-openid:focus, +.btn-openid.focus, +.btn-openid:active, +.btn-openid.active, +.open > .dropdown-toggle.btn-openid { + color: #ffffff; + background-color: #da7908; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-openid:active, +.btn-openid.active, +.open > .dropdown-toggle.btn-openid { + background-image: none; +} +.btn-openid.disabled, +.btn-openid[disabled], +fieldset[disabled] .btn-openid, +.btn-openid.disabled:hover, +.btn-openid[disabled]:hover, +fieldset[disabled] .btn-openid:hover, +.btn-openid.disabled:focus, +.btn-openid[disabled]:focus, +fieldset[disabled] .btn-openid:focus, +.btn-openid.disabled.focus, +.btn-openid[disabled].focus, +fieldset[disabled] .btn-openid.focus, +.btn-openid.disabled:active, +.btn-openid[disabled]:active, +fieldset[disabled] .btn-openid:active, +.btn-openid.disabled.active, +.btn-openid[disabled].active, +fieldset[disabled] .btn-openid.active { + background-color: #f7931e; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-openid .badge { + color: #f7931e; + background-color: #ffffff; +} +.btn-pinterest { + color: #ffffff; + background-color: #cb2027; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-pinterest:hover, +.btn-pinterest:focus, +.btn-pinterest.focus, +.btn-pinterest:active, +.btn-pinterest.active, +.open > .dropdown-toggle.btn-pinterest { + color: #ffffff; + background-color: #9f191f; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-pinterest:active, +.btn-pinterest.active, +.open > .dropdown-toggle.btn-pinterest { + background-image: none; +} +.btn-pinterest.disabled, +.btn-pinterest[disabled], +fieldset[disabled] .btn-pinterest, +.btn-pinterest.disabled:hover, +.btn-pinterest[disabled]:hover, +fieldset[disabled] .btn-pinterest:hover, +.btn-pinterest.disabled:focus, +.btn-pinterest[disabled]:focus, +fieldset[disabled] .btn-pinterest:focus, +.btn-pinterest.disabled.focus, +.btn-pinterest[disabled].focus, +fieldset[disabled] .btn-pinterest.focus, +.btn-pinterest.disabled:active, +.btn-pinterest[disabled]:active, +fieldset[disabled] .btn-pinterest:active, +.btn-pinterest.disabled.active, +.btn-pinterest[disabled].active, +fieldset[disabled] .btn-pinterest.active { + background-color: #cb2027; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-pinterest .badge { + color: #cb2027; + background-color: #ffffff; +} +.btn-reddit { + color: #000000; + background-color: #eff7ff; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-reddit:hover, +.btn-reddit:focus, +.btn-reddit.focus, +.btn-reddit:active, +.btn-reddit.active, +.open > .dropdown-toggle.btn-reddit { + color: #000000; + background-color: #bcddff; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-reddit:active, +.btn-reddit.active, +.open > .dropdown-toggle.btn-reddit { + background-image: none; +} +.btn-reddit.disabled, +.btn-reddit[disabled], +fieldset[disabled] .btn-reddit, +.btn-reddit.disabled:hover, +.btn-reddit[disabled]:hover, +fieldset[disabled] .btn-reddit:hover, +.btn-reddit.disabled:focus, +.btn-reddit[disabled]:focus, +fieldset[disabled] .btn-reddit:focus, +.btn-reddit.disabled.focus, +.btn-reddit[disabled].focus, +fieldset[disabled] .btn-reddit.focus, +.btn-reddit.disabled:active, +.btn-reddit[disabled]:active, +fieldset[disabled] .btn-reddit:active, +.btn-reddit.disabled.active, +.btn-reddit[disabled].active, +fieldset[disabled] .btn-reddit.active { + background-color: #eff7ff; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-reddit .badge { + color: #eff7ff; + background-color: #000000; +} +.btn-soundcloud { + color: #ffffff; + background-color: #ff5500; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-soundcloud:hover, +.btn-soundcloud:focus, +.btn-soundcloud.focus, +.btn-soundcloud:active, +.btn-soundcloud.active, +.open > .dropdown-toggle.btn-soundcloud { + color: #ffffff; + background-color: #cc4400; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-soundcloud:active, +.btn-soundcloud.active, +.open > .dropdown-toggle.btn-soundcloud { + background-image: none; +} +.btn-soundcloud.disabled, +.btn-soundcloud[disabled], +fieldset[disabled] .btn-soundcloud, +.btn-soundcloud.disabled:hover, +.btn-soundcloud[disabled]:hover, +fieldset[disabled] .btn-soundcloud:hover, +.btn-soundcloud.disabled:focus, +.btn-soundcloud[disabled]:focus, +fieldset[disabled] .btn-soundcloud:focus, +.btn-soundcloud.disabled.focus, +.btn-soundcloud[disabled].focus, +fieldset[disabled] .btn-soundcloud.focus, +.btn-soundcloud.disabled:active, +.btn-soundcloud[disabled]:active, +fieldset[disabled] .btn-soundcloud:active, +.btn-soundcloud.disabled.active, +.btn-soundcloud[disabled].active, +fieldset[disabled] .btn-soundcloud.active { + background-color: #ff5500; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-soundcloud .badge { + color: #ff5500; + background-color: #ffffff; +} +.btn-tumblr { + color: #ffffff; + background-color: #2c4762; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-tumblr:hover, +.btn-tumblr:focus, +.btn-tumblr.focus, +.btn-tumblr:active, +.btn-tumblr.active, +.open > .dropdown-toggle.btn-tumblr { + color: #ffffff; + background-color: #1c2d3f; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-tumblr:active, +.btn-tumblr.active, +.open > .dropdown-toggle.btn-tumblr { + background-image: none; +} +.btn-tumblr.disabled, +.btn-tumblr[disabled], +fieldset[disabled] .btn-tumblr, +.btn-tumblr.disabled:hover, +.btn-tumblr[disabled]:hover, +fieldset[disabled] .btn-tumblr:hover, +.btn-tumblr.disabled:focus, +.btn-tumblr[disabled]:focus, +fieldset[disabled] .btn-tumblr:focus, +.btn-tumblr.disabled.focus, +.btn-tumblr[disabled].focus, +fieldset[disabled] .btn-tumblr.focus, +.btn-tumblr.disabled:active, +.btn-tumblr[disabled]:active, +fieldset[disabled] .btn-tumblr:active, +.btn-tumblr.disabled.active, +.btn-tumblr[disabled].active, +fieldset[disabled] .btn-tumblr.active { + background-color: #2c4762; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-tumblr .badge { + color: #2c4762; + background-color: #ffffff; +} +.btn-twitter { + color: #ffffff; + background-color: #55acee; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-twitter:hover, +.btn-twitter:focus, +.btn-twitter.focus, +.btn-twitter:active, +.btn-twitter.active, +.open > .dropdown-toggle.btn-twitter { + color: #ffffff; + background-color: #2795e9; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-twitter:active, +.btn-twitter.active, +.open > .dropdown-toggle.btn-twitter { + background-image: none; +} +.btn-twitter.disabled, +.btn-twitter[disabled], +fieldset[disabled] .btn-twitter, +.btn-twitter.disabled:hover, +.btn-twitter[disabled]:hover, +fieldset[disabled] .btn-twitter:hover, +.btn-twitter.disabled:focus, +.btn-twitter[disabled]:focus, +fieldset[disabled] .btn-twitter:focus, +.btn-twitter.disabled.focus, +.btn-twitter[disabled].focus, +fieldset[disabled] .btn-twitter.focus, +.btn-twitter.disabled:active, +.btn-twitter[disabled]:active, +fieldset[disabled] .btn-twitter:active, +.btn-twitter.disabled.active, +.btn-twitter[disabled].active, +fieldset[disabled] .btn-twitter.active { + background-color: #55acee; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-twitter .badge { + color: #55acee; + background-color: #ffffff; +} +.btn-vimeo { + color: #ffffff; + background-color: #1ab7ea; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-vimeo:hover, +.btn-vimeo:focus, +.btn-vimeo.focus, +.btn-vimeo:active, +.btn-vimeo.active, +.open > .dropdown-toggle.btn-vimeo { + color: #ffffff; + background-color: #1295bf; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-vimeo:active, +.btn-vimeo.active, +.open > .dropdown-toggle.btn-vimeo { + background-image: none; +} +.btn-vimeo.disabled, +.btn-vimeo[disabled], +fieldset[disabled] .btn-vimeo, +.btn-vimeo.disabled:hover, +.btn-vimeo[disabled]:hover, +fieldset[disabled] .btn-vimeo:hover, +.btn-vimeo.disabled:focus, +.btn-vimeo[disabled]:focus, +fieldset[disabled] .btn-vimeo:focus, +.btn-vimeo.disabled.focus, +.btn-vimeo[disabled].focus, +fieldset[disabled] .btn-vimeo.focus, +.btn-vimeo.disabled:active, +.btn-vimeo[disabled]:active, +fieldset[disabled] .btn-vimeo:active, +.btn-vimeo.disabled.active, +.btn-vimeo[disabled].active, +fieldset[disabled] .btn-vimeo.active { + background-color: #1ab7ea; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-vimeo .badge { + color: #1ab7ea; + background-color: #ffffff; +} +.btn-vk { + color: #ffffff; + background-color: #587ea3; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-vk:hover, +.btn-vk:focus, +.btn-vk.focus, +.btn-vk:active, +.btn-vk.active, +.open > .dropdown-toggle.btn-vk { + color: #ffffff; + background-color: #466482; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-vk:active, +.btn-vk.active, +.open > .dropdown-toggle.btn-vk { + background-image: none; +} +.btn-vk.disabled, +.btn-vk[disabled], +fieldset[disabled] .btn-vk, +.btn-vk.disabled:hover, +.btn-vk[disabled]:hover, +fieldset[disabled] .btn-vk:hover, +.btn-vk.disabled:focus, +.btn-vk[disabled]:focus, +fieldset[disabled] .btn-vk:focus, +.btn-vk.disabled.focus, +.btn-vk[disabled].focus, +fieldset[disabled] .btn-vk.focus, +.btn-vk.disabled:active, +.btn-vk[disabled]:active, +fieldset[disabled] .btn-vk:active, +.btn-vk.disabled.active, +.btn-vk[disabled].active, +fieldset[disabled] .btn-vk.active { + background-color: #587ea3; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-vk .badge { + color: #587ea3; + background-color: #ffffff; +} +.btn-yahoo { + color: #ffffff; + background-color: #720e9e; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-yahoo:hover, +.btn-yahoo:focus, +.btn-yahoo.focus, +.btn-yahoo:active, +.btn-yahoo.active, +.open > .dropdown-toggle.btn-yahoo { + color: #ffffff; + background-color: #500a6f; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-yahoo:active, +.btn-yahoo.active, +.open > .dropdown-toggle.btn-yahoo { + background-image: none; +} +.btn-yahoo.disabled, +.btn-yahoo[disabled], +fieldset[disabled] .btn-yahoo, +.btn-yahoo.disabled:hover, +.btn-yahoo[disabled]:hover, +fieldset[disabled] .btn-yahoo:hover, +.btn-yahoo.disabled:focus, +.btn-yahoo[disabled]:focus, +fieldset[disabled] .btn-yahoo:focus, +.btn-yahoo.disabled.focus, +.btn-yahoo[disabled].focus, +fieldset[disabled] .btn-yahoo.focus, +.btn-yahoo.disabled:active, +.btn-yahoo[disabled]:active, +fieldset[disabled] .btn-yahoo:active, +.btn-yahoo.disabled.active, +.btn-yahoo[disabled].active, +fieldset[disabled] .btn-yahoo.active { + background-color: #720e9e; + border-color: rgba(0, 0, 0, 0.2); +} +.btn-yahoo .badge { + color: #720e9e; + background-color: #ffffff; +} +html { + height: 100%; +} +body { + display: flex; + -webkit-box-orient: vertical; + -webkit-box-direction: normal; + flex-direction: column; + height: 100%; +} +/* Links */ +a { + word-wrap: break-word; + -webkit-transition: opacity 0.15s ease-out; + -moz-transition: opacity 0.15s ease-out; + -ms-transition: opacity 0.15s ease-out; + -o-transition: opacity 0.15s ease-out; + transition: opacity 0.15s ease-out; + -webkit-transition: color 0.1s ease-in; + -moz-transition: color 0.1s ease-in; + -ms-transition: color 0.1s ease-in; + -o-transition: color 0.1s ease-in; + transition: color 0.1s ease-in; + -webkit-transition: background 0.1s ease-in; + -moz-transition: background 0.1s ease-in; + -ms-transition: background 0.1s ease-in; + -o-transition: background 0.1s ease-in; + transition: background 0.1s ease-in; +} +h1, +h2, +h3, +h4, +h5 { + margin: 1em 0 0.5em; +} +h1 { + font-size: 300%; +} +p { + margin: 1em 0; +} +pre { + padding: 30px; +} +.navbar { + padding-top: 15px; +} +.navbar li a { + text-transform: uppercase; + padding: 4px; + margin: 8px; +} +.navbar li a.nav-link { + color: #e6e6e6; +} +.navbar li a.nav-link:hover { + color: white; +} +.navbar .navbar-brand { + padding-top: 26px; + padding-bottom: 0px; +} +@media (max-width: 991px) { + .navbar .navbar-brand { + width: 100%; + text-align: center; + } + .navbar .navbar-brand img { + display: inline-block; + } +} +.navbar .nav-wrapper { + margin-top: 30px; +} +@media (max-width: 991px) { + .navbar { + margin-bottom: 0; + } + .navbar .nav-wrapper { + margin-top: 0; + text-align: center; + } +} +.navbar .navbar-try { + text-transform: uppercase; + margin-left: 30px; + float: left; + margin-top: 4px; + margin-right: 0; +} +.navbar .navbar-nav { + margin: 0 15px; +} +@media (max-width: 991px) { + .navbar .navbar-nav { + display: inline-block; + } + .navbar .navbar-nav li { + float: left; + } +} +.centered { + text-align: center; +} +.content { + flex: 1 0 auto; + -webkit-box-flex: 1; + width: 100%; + background: linear-gradient(30deg, #eeeeee 0%, #f2f2f2 100%); +} +.content.hero { + background: linear-gradient(30deg, #28283c 33%, #3c3c5a 100%); + color: white; +} +.content.hero .section-header { + margin-top: 45px; +} +.content.hero .section-header h1 { + font-size: 500%; + margin: 0 0 60px; +} +@media (max-width: 991px) { + .content.hero .section-header h1 { + font-size: 300%; + margin-bottom: 20px; + } +} +.content .navbaronly { + background: linear-gradient(30deg, #363651 0%, #3c3c5a 100%); + color: white; + padding-bottom: 5px; +} +.content .markdown-page { + padding: 30px 0; +} +.content .page { + padding: 30px 0 60px; +} +.content::after { + content: '\00a0'; + /*   */ + display: block; + margin-top: var(--space); + height: 0px; + visibility: hidden; +} +.section { + padding: 90px 0; +} +.section-header { + padding-top: 0; +} +.btn-md { + transition: all .3s ease; + border-radius: 8px; + border: 2px solid white; + color: white; + padding: 8px 15px; + line-height: 1; +} +.btn-lg { + transition: all .3s ease; + padding: 15px 30px; + border-radius: 45px; + border: 2px solid white; + color: white; + background-color: transparent; +} +.btn-lg:hover { + background-color: #cc2c00; + border-color: white; + color: white; +} +.btn-learn { + background-color: #0093b3; +} +.btn-learn:hover { + background-color: #cc2c00; + border-color: white; + color: white; +} +.btn-lgplugins { + transition: all .3s ease; + padding: 15px 30px; + border-radius: 45px; + border: 2px solid #e53200; + color: #32324b; + background-color: transparent; +} +.btn-lgplugins:hover { + background-color: #cc2c00; + border-color: transparent; +} +.slogan { + padding: 45px 75px; + font-size: 120%; + color: #f3f3f2; +} +@media (max-width: 991px) { + .slogan { + padding: 30px 15px; + } +} +.quote-wrapper { + margin-top: 0px; +} +.quote { + padding: 15px; + font-size: 120%; + color: #f3f3f2; +} +.quote:before { + content: ',,'; + font-family: Helvetica, Arial; + position: relative; + letter-spacing: -20px; + top: -30px; + left: 10px; + font-size: 200px; + opacity: 0.2; + line-height: 0; + -webkit-transform: scale(-1, 1); +} +.quote .author { + font-style: italic; + font-size: 90%; + margin-top: 0.5em; +} +.banner { + margin-top: -10px; +} +.banner a { + text-decoration: none; +} +.banner .alert { + -webkit-transition: background-color 0.15s ease-out; + -moz-transition: background-color 0.15s ease-out; + -ms-transition: background-color 0.15s ease-out; + -o-transition: background-color 0.15s ease-out; + transition: background-color 0.15s ease-out; + padding-top: 20px; + padding-bottom: 10px; + margin-bottom: 0; + background-color: #515179; + color: white; + border-color: white; +} +.banner .alert:hover { + background-color: #5b5b88; +} +.banner .alert img { + position: relative; + top: -1px; +} +.learn-and-guides-hint { + margin-top: 1em; +} +.hero-features { + background: linear-gradient(30deg, #eeeeee 0%, #f2f2f2 100%); + color: #81817f; + padding: 30px 0; +} +.hero-features .scope-details { + margin-top: 1em; + box-shadow: 0 6px 10px rgba(0, 0, 0, 0.23); +} +.section.features { + padding: 75px 0 90px; +} +.section.features h3 { + margin-bottom: 0; +} +@media (max-width: 991px) { + .section.features h3 { + margin-top: 60px; + } +} +.section.features .features-image { + margin: 15px; +} +.section.features .features-slogan { + font-size: 120%; + margin-bottom: 45px; +} +@media (max-width: 991px) { + .section.features .features-slogan { + margin-bottom: 15px; + } +} +.section.features .features-product-caption { + margin-top: -30px; + padding: 0 30px; +} +.section.features-footer { + padding: 60px 0; + background: linear-gradient(30deg, #eeeeee 0%, #f2f2f2 100%); + color: #81817f; +} +.section.features-footer .btn { + margin-top: 60px; + color: #00d2ff; + border-color: #00d2ff; +} +.section.features-footer .btn:hover { + color: white; + border-color: white; +} +.section.features-footer .features-footer-teaser { + font-size: 150%; +} +.section.features-footer .features-footer-button-wrapper { + text-align: center; +} +.section.features-footer .features-footer-button-caption { + padding: 15px 5px 0 15px; +} +.section.features-footer ul { + margin-top: 30px; + margin-bottom: 30px; +} +.section.features-footer li { + margin-bottom: 0.5rem; +} +.section-tour { + background-color: #00a8cc; + color: white; + padding: 90px 0 105px; +} +.section-tour li { + font-size: 120%; + line-height: 2.0; +} +.section-tour .btn-lg { + margin-top: 90px; +} +.section-integration { + padding-top: 60px; + background-color: white; + color: #81817f; +} +.section-integration .row a { + opacity: 0.75; + height: 100px; + display: inline-block; + margin: 15px 0; +} +.section-integration .row a:hover { + opacity: 1; +} +.section-integration .row img { + max-width: 180px; + max-height: 100px; +} +.section-news { + color: white; + background-color: #32324b; +} +.section-news img { + margin-bottom: 30px; +} +.section-news h3 { + margin-top: 45px; +} +.section-news li { + font-size: 110%; + margin-top: 15px; +} +.section.pluginsnews { + color: #32324b; + background-color: white; + border-top: 2px solid #00d2ff; + padding: 25px 0 25px; +} +.section.pluginsnews h3 { + margin-top: 45px; +} +.section.pluginsnews .container { + margin-top: 10px; +} +.section.pluginsnews li { + font-size: 110%; + margin-top: 15px; +} +.page-learn-index h4 { + margin-top: 2em; +} +.page-learn-index-products h4, +.page-learn-index-products .features-image { + text-align: center; +} +.page-learn-index-products .features-image { + overflow: hidden; +} +.section-learn-more { + background: linear-gradient(30deg, #c8c8c8 0%, #e5e5e5 100%); + color: #747472; +} +.section-learn-more h1 { + margin-top: 30px; +} +@media (max-width: 991px) { + .section-learn-more li { + text-align: left; + } + .section-learn-more div { + text-align: center; + } +} +.section-learn-more-button-wrapper { + margin: 15px 0; + text-align: center; +} +.section-learn-more-wrapper:last-child { + margin-top: 45px; +} +.section.footer { + background-color: #13131d; + color: white; + padding: 60px 0; + flex: none; + -webkit-box-flex: 0; +} +@media (max-width: 991px) { + .section.footer { + padding-left: 15px; + } + .section.footer .row > div { + margin-bottom: 0.5em; + } +} +.section.footer .copyright { + color: #556991; +} From 00744fb9b496c1aa17fe50dde2df54f601c1af03 Mon Sep 17 00:00:00 2001 From: David Kaltschmidt Date: Wed, 24 Jun 2015 17:54:50 +0200 Subject: [PATCH 10/82] use relative paths for stylesheet in docs --- site/_layouts/default.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/site/_layouts/default.html b/site/_layouts/default.html index cafadc71..8d655afa 100644 --- a/site/_layouts/default.html +++ b/site/_layouts/default.html @@ -19,7 +19,7 @@ - + From 94a8338be58f67c94773a6627481e21958a398a7 Mon Sep 17 00:00:00 2001 From: Matthias Radestock Date: Wed, 24 Jun 2015 17:02:35 +0100 Subject: [PATCH 11/82] fix typo in comment --- weave | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/weave b/weave index 7b58efb1..f3317164 100755 --- a/weave +++ b/weave @@ -238,7 +238,7 @@ configure_arp_cache() { } # Send out an unsolicated ARP response to update ARP cache entries -# accross the weave network. We do this in addition to +# across the weave network. We do this in addition to # configure_arp_cache because a) with those ARP cache settings it # still takes a few seconds to correct a stale ARP mapping, and b) # there is a kernel bug that means that the base_reachable_time From 8f5d1eec113fac29f62028700cf1d1c1ac77e535 Mon Sep 17 00:00:00 2001 From: David Wragg Date: Tue, 19 May 2015 11:24:40 +0100 Subject: [PATCH 12/82] Eliminate the Routes Start method --- router/gossip_test.go | 9 ++------- router/router.go | 1 - router/routes.go | 15 ++++++--------- 3 files changed, 8 insertions(+), 17 deletions(-) diff --git a/router/gossip_test.go b/router/gossip_test.go index c1ace338..c6936a09 100644 --- a/router/gossip_test.go +++ b/router/gossip_test.go @@ -18,15 +18,10 @@ type mockChannelConnection struct { dest *Router } -// Construct a "passive" Router, i.e. without any goroutines, except -// for Routes and GossipSenders. func NewTestRouter(name string) *Router { peerName, _ := PeerNameFromString(name) - router := NewRouter(Config{}, peerName, "") - // need to create a dummy channel otherwise tests hang on nil - // channels when the Router invoked ConnectionMaker.Refresh - router.ConnectionMaker.actionChan = make(chan ConnectionMakerAction, ChannelSize) - router.Routes.Start() + router := NewRouter(Config{}, peerName, "nick") + router.Start() return router } diff --git a/router/router.go b/router/router.go index c3cc1464..3877f13f 100644 --- a/router/router.go +++ b/router/router.go @@ -95,7 +95,6 @@ func (router *Router) Start() { po, err = NewPcapO(router.Iface.Name) checkFatal(err) } - router.Routes.Start() router.ConnectionMaker.Start() router.UDPListener = router.listenUDP(router.Port, po) router.listenTCP(router.Port) diff --git a/router/routes.go b/router/routes.go index f244f28f..1f73833d 100644 --- a/router/routes.go +++ b/router/routes.go @@ -22,26 +22,23 @@ type Routes struct { } 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(map[PeerName]PeerName), unicastAll: make(map[PeerName]PeerName), broadcast: make(map[PeerName][]PeerName), - broadcastAll: make(map[PeerName][]PeerName)} + broadcastAll: make(map[PeerName][]PeerName), + recalculate: recalculate, + wait: wait} routes.unicast[ourself.Name] = UnknownPeerName routes.unicastAll[ourself.Name] = UnknownPeerName routes.broadcast[ourself.Name] = []PeerName{} routes.broadcastAll[ourself.Name] = []PeerName{} - return routes -} - -func (routes *Routes) Start() { - recalculate := make(chan *struct{}, 1) - wait := make(chan chan struct{}) - routes.recalculate = recalculate - routes.wait = wait go routes.run(recalculate, wait) + return routes } func (routes *Routes) PeerNames() PeerNameSet { From f444ae9224b10cc13c23e55db2ad5f8c0def6df0 Mon Sep 17 00:00:00 2001 From: David Wragg Date: Tue, 19 May 2015 12:12:46 +0100 Subject: [PATCH 13/82] Eliminate ConnectionMaker Start method --- router/connection_maker.go | 12 +++++------- router/router.go | 1 - 2 files changed, 5 insertions(+), 8 deletions(-) diff --git a/router/connection_maker.go b/router/connection_maker.go index 57a93a06..2e36b69f 100644 --- a/router/connection_maker.go +++ b/router/connection_maker.go @@ -37,19 +37,17 @@ type Target struct { type ConnectionMakerAction func() bool func NewConnectionMaker(ourself *LocalPeer, peers *Peers, port int, discovery bool) *ConnectionMaker { - return &ConnectionMaker{ + actionChan := make(chan ConnectionMakerAction, ChannelSize) + cm := &ConnectionMaker{ ourself: ourself, peers: peers, port: port, discovery: discovery, directPeers: peerAddrs{}, - targets: make(map[string]*Target)} -} - -func (cm *ConnectionMaker) Start() { - actionChan := make(chan ConnectionMakerAction, ChannelSize) - cm.actionChan = actionChan + targets: make(map[string]*Target), + actionChan: actionChan} go cm.queryLoop(actionChan) + return cm } func (cm *ConnectionMaker) InitiateConnections(peers []string, replace bool) []error { diff --git a/router/router.go b/router/router.go index 3877f13f..fbedfcc6 100644 --- a/router/router.go +++ b/router/router.go @@ -95,7 +95,6 @@ func (router *Router) Start() { po, err = NewPcapO(router.Iface.Name) checkFatal(err) } - router.ConnectionMaker.Start() router.UDPListener = router.listenUDP(router.Port, po) router.listenTCP(router.Port) if pio != nil { From 5e6b107d018edd5350afb0605fb536287be63726 Mon Sep 17 00:00:00 2001 From: David Wragg Date: Tue, 19 May 2015 12:18:07 +0100 Subject: [PATCH 14/82] Eliminate the GossipSender Start method --- router/gossip.go | 14 ++++++++------ router/gossip_channel.go | 2 -- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/router/gossip.go b/router/gossip.go index f66ea9d0..a3af241b 100644 --- a/router/gossip.go +++ b/router/gossip.go @@ -40,13 +40,15 @@ type GossipSender struct { } func NewGossipSender(send func(GossipData)) *GossipSender { - return &GossipSender{send: send} -} - -func (sender *GossipSender) Start() { - sender.cell = make(chan GossipData, 1) - sender.flushch = make(chan chan bool) + 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() { diff --git a/router/gossip_channel.go b/router/gossip_channel.go index da7dc0ec..8dc1f510 100644 --- a/router/gossip_channel.go +++ b/router/gossip_channel.go @@ -147,7 +147,6 @@ func (c *GossipChannel) sendDown(conn Connection, data GossipData) { } }) c.senders[conn] = sender - sender.Start() } sender.Send(data) } @@ -198,7 +197,6 @@ func (c *GossipChannel) relayBroadcast(srcName PeerName, update GossipData) erro if !found { broadcaster = NewGossipSender(func(pending GossipData) { c.sendBroadcast(srcName, pending) }) c.broadcasters[srcName] = broadcaster - broadcaster.Start() } broadcaster.Send(update) return nil From 576dd69b0bda171e278f6286479b97b67db5815c Mon Sep 17 00:00:00 2001 From: David Wragg Date: Wed, 24 Jun 2015 17:37:02 +0100 Subject: [PATCH 15/82] Add a comment to Router's Start method --- router/router.go | 3 +++ 1 file changed, 3 insertions(+) diff --git a/router/router.go b/router/router.go index fbedfcc6..9f9e626f 100644 --- a/router/router.go +++ b/router/router.go @@ -84,6 +84,9 @@ func NewRouter(config Config, name PeerName, nickName string) *Router { return router } +// Start listening for TCP connections, locally captured packets, and +// packets forwarded over UDP. This is separate from NewRouter so +// that gossipers can register before we start forming connections. func (router *Router) Start() { // we need two pcap handles since they aren't thread-safe var pio PacketSourceSink From 7387caa2eb187dd51944c3ab92d995429f8c07d2 Mon Sep 17 00:00:00 2001 From: David Wragg Date: Wed, 24 Jun 2015 17:36:18 +0100 Subject: [PATCH 16/82] Eliminate forwarder Start methods --- router/forwarder.go | 38 +++++++++++++++----------------------- 1 file changed, 15 insertions(+), 23 deletions(-) diff --git a/router/forwarder.go b/router/forwarder.go index 802369bd..3c9ba0ed 100644 --- a/router/forwarder.go +++ b/router/forwarder.go @@ -40,16 +40,12 @@ func (conn *LocalConnection) ensureForwarders() error { forwarder := NewForwarder(conn, encryptor, udpSender, DefaultPMTU) forwarderDF := NewForwarderDF(conn, encryptorDF, udpSenderDF, DefaultPMTU) - effectivePMTU := forwarderDF.unverifiedPMTU - forwarder.Start() - forwarderDF.Start() // Various fields in the conn struct are read by other processes, // so we have to use locks. conn.Lock() conn.forwarder = forwarder conn.forwarderDF = forwarderDF - conn.effectivePMTU = effectivePMTU conn.Unlock() return nil @@ -195,20 +191,18 @@ type Forwarder struct { } func NewForwarder(conn *LocalConnection, enc Encryptor, udpSender UDPSender, pmtu int) *Forwarder { - return &Forwarder{ + ch := make(chan *ForwardedFrame, ChannelSize) + finished := make(chan struct{}) + fwd := &Forwarder{ conn: conn, + ch: ch, + finished: finished, enc: enc, udpSender: udpSender, maxPayload: pmtu - UDPOverhead, processSendError: func(err error) error { return err }} -} - -func (fwd *Forwarder) Start() { - ch := make(chan *ForwardedFrame, ChannelSize) - fwd.ch = ch - finished := make(chan struct{}) - fwd.finished = finished go fwd.run(ch, finished) + return fwd } func (fwd *Forwarder) Shutdown() { @@ -310,25 +304,23 @@ type ForwarderDF struct { } func NewForwarderDF(conn *LocalConnection, enc Encryptor, udpSender UDPSender, pmtu int) *ForwarderDF { + ch := make(chan *ForwardedFrame, ChannelSize) + finished := make(chan struct{}) + verifyPMTU := make(chan int, ChannelSize) fwd := &ForwarderDF{ Forwarder: Forwarder{ conn: conn, + ch: ch, + finished: finished, enc: enc, udpSender: udpSender, - maxPayload: pmtu - UDPOverhead}} + maxPayload: pmtu - UDPOverhead}, + verifyPMTU: verifyPMTU} fwd.Forwarder.processSendError = fwd.processSendError fwd.unverifiedPMTU = pmtu - fwd.effectiveOverhead() - return fwd -} - -func (fwd *ForwarderDF) Start() { - ch := make(chan *ForwardedFrame, ChannelSize) - fwd.ch = ch - finished := make(chan struct{}) - fwd.finished = finished - verifyPMTU := make(chan int, ChannelSize) - fwd.verifyPMTU = verifyPMTU + conn.setEffectivePMTU(fwd.unverifiedPMTU) go fwd.run(ch, finished, verifyPMTU) + return fwd } func (fwd *ForwarderDF) PMTUVerified(pmtu int) { From 7780ac10782786f7ee3b89fa899c5731f0113373 Mon Sep 17 00:00:00 2001 From: Tom Wilkie Date: Wed, 24 Jun 2015 17:02:12 +0000 Subject: [PATCH 17/82] Fix gce.sh destory timeouts. --- test/gce.sh | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/test/gce.sh b/test/gce.sh index be914546..3f54a366 100755 --- a/test/gce.sh +++ b/test/gce.sh @@ -36,11 +36,17 @@ function destroy { names="$(vm_names)" for i in {0..10}; do # gcloud instances delete can sometimes hang. - timeout 60s /bin/bash -c "gcloud compute instances delete --zone $ZONE -q $names || true" - # 124 means it timed out - if [ $? -ne 124 ]; then - return - fi + case $(set +e; timeout 60s /bin/bash -c "gcloud compute instances delete --zone $ZONE -q $names >/dev/null 2>&1 || true"; echo $?) in + 0) + return 0 + ;; + 124) + # 124 means it timed out + break + ;; + *) + return 1 + esac done } From 657bbbffbc1be6d109e6d61aebcd464a0054b2c0 Mon Sep 17 00:00:00 2001 From: Matthias Radestock Date: Wed, 24 Jun 2015 18:17:15 +0100 Subject: [PATCH 18/82] tiny refactor: raise abstraction level --- proxy/create_container_interceptor.go | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/proxy/create_container_interceptor.go b/proxy/create_container_interceptor.go index db9433ef..69f5815b 100644 --- a/proxy/create_container_interceptor.go +++ b/proxy/create_container_interceptor.go @@ -56,7 +56,7 @@ func (i *createContainerInterceptor) InterceptRequest(r *http.Request) error { if err := i.setWeaveWaitEntrypoint(container.Config); err != nil { return err } - if err := i.setWeaveDNS(&container, r); err != nil { + if err := i.setWeaveDNS(&container, r.URL.Query().Get("name")); err != nil { return err } } @@ -96,7 +96,7 @@ func (i *createContainerInterceptor) setWeaveWaitEntrypoint(container *docker.Co return nil } -func (i *createContainerInterceptor) setWeaveDNS(container *createContainerRequestBody, r *http.Request) error { +func (i *createContainerInterceptor) setWeaveDNS(container *createContainerRequestBody, name string) error { if i.proxy.WithoutDNS { return nil } @@ -108,7 +108,6 @@ func (i *createContainerInterceptor) setWeaveDNS(container *createContainerReque container.HostConfig.DNS = append(container.HostConfig.DNS, i.proxy.dockerBridgeIP) - name := r.URL.Query().Get("name") if container.Hostname == "" && name != "" { container.Hostname = name // Strip trailing period because it's unusual to see it used on the end of a host name From 9f784b3c316d557e45345044a96ec5443d7941c4 Mon Sep 17 00:00:00 2001 From: Bryan Boreham Date: Thu, 25 Jun 2015 12:22:53 +0100 Subject: [PATCH 19/82] Report errors in unicasting gossip --- ipam/allocator.go | 4 ++-- router/gossip_channel.go | 17 ++++++++++++----- 2 files changed, 14 insertions(+), 7 deletions(-) diff --git a/ipam/allocator.go b/ipam/allocator.go index 8b609b96..98f36f3d 100644 --- a/ipam/allocator.go +++ b/ipam/allocator.go @@ -575,14 +575,14 @@ func (alloc *Allocator) propose() { alloc.gossip.GossipBroadcast(alloc.Gossip()) } -func (alloc *Allocator) sendSpaceRequest(dest router.PeerName, r address.Range) { +func (alloc *Allocator) sendSpaceRequest(dest router.PeerName, r address.Range) error { buf := new(bytes.Buffer) enc := gob.NewEncoder(buf) if err := enc.Encode(r); err != nil { panic(err) } msg := router.Concat([]byte{msgSpaceRequest}, buf.Bytes()) - alloc.gossip.GossipUnicast(dest, msg) + return alloc.gossip.GossipUnicast(dest, msg) } func (alloc *Allocator) sendRingUpdate(dest router.PeerName) { diff --git a/router/gossip_channel.go b/router/gossip_channel.go index da7dc0ec..bbc177db 100644 --- a/router/gossip_channel.go +++ b/router/gossip_channel.go @@ -3,6 +3,7 @@ package router import ( "bytes" "encoding/gob" + "fmt" "log" "sync" ) @@ -58,7 +59,10 @@ func (c *GossipChannel) deliverUnicast(srcName PeerName, origPayload []byte, dec return err } if c.ourself.Name != destName { - return c.relayUnicast(destName, origPayload) + c.relayUnicast(destName, origPayload) + // ignore errors in passing on data; a problem between us and destination + // is not enough reason to break the connection from the source + return nil } var payload []byte if err := dec.Decode(&payload); err != nil { @@ -160,15 +164,18 @@ func (c *GossipChannel) GossipBroadcast(update GossipData) error { return c.relayBroadcast(c.ourself.Name, update) } -func (c *GossipChannel) relayUnicast(dstPeerName PeerName, buf []byte) error { +func (c *GossipChannel) relayUnicast(dstPeerName PeerName, buf []byte) (err error) { if relayPeerName, found := c.routes.UnicastAll(dstPeerName); !found { - c.log("unknown relay destination:", dstPeerName) + err = fmt.Errorf("unknown relay destination: %s", dstPeerName) } else if conn, found := c.ourself.ConnectionTo(relayPeerName); !found { - c.log("unable to find connection to relay peer", relayPeerName) + err = fmt.Errorf("unable to find connection to relay peer %s", relayPeerName) } else { conn.(ProtocolSender).SendProtocolMsg(ProtocolMsg{ProtocolGossipUnicast, buf}) } - return nil + if err != nil { + c.log(err) + } + return err } func (c *GossipChannel) relayBroadcast(srcName PeerName, update GossipData) error { From fcd79a78afe268ccf95c4c387e0edc6eda4dc5f3 Mon Sep 17 00:00:00 2001 From: Adam Harrison Date: Wed, 24 Jun 2015 13:56:53 +0100 Subject: [PATCH 20/82] Implement new weave launch behaviour --- weave | 216 ++++++++++++++++++++++++++++++++-------------------------- 1 file changed, 121 insertions(+), 95 deletions(-) diff --git a/weave b/weave index ad52497b..d4fede60 100755 --- a/weave +++ b/weave @@ -26,6 +26,8 @@ CIDR_REGEXP="$IP_REGEXP/[0-9]{1,2}" usage() { echo "Usage:" echo "weave setup" + echo "weave launch [-password ] [-nickname ] [-nodiscovery]" + echo " [-iprange [-ipsubnet ]] ..." echo "weave launch-router [-password ] [-nickname ] [-nodiscovery]" echo " [-iprange [-ipsubnet ]] ..." echo "weave launch-dns []" @@ -918,6 +920,114 @@ proxy_addr() { return 1 } +###################################################################### +# launch helpers +###################################################################### + +launch_router() { + create_bridge + # We set the router name to the bridge mac since that is + # stable across re-creations of the containers. + # + # TODO use the mac of one of the physical host interfaces + # (eth0, wlan0, etc) so the name becomes stable across host + # restarts. + PEERNAME=$(cat /sys/class/net/$BRIDGE/address) + # backward compatibility... + if is_cidr "$1" ; then + echo "WARNING: $1 parameter ignored; 'weave launch' no longer takes a CIDR as the first parameter" >&2 + shift 1 + fi + CONTAINER_PORT=$PORT + ARGS="" + IPRANGE= + IPRANGE_SPECIFIED= + while [ $# -gt 0 ] ; do + case "$1" in + -password) + [ $# -gt 1 ] || usage + WEAVE_PASSWORD="$2" + export WEAVE_PASSWORD + shift 2 + ;; + -port) + [ $# -gt 1 ] || usage + CONTAINER_PORT="$2" + shift 2 + ;; + -iprange) + [ $# -gt 1 ] || usage + IPRANGE="$2" + IPRANGE_SPECIFIED=1 + shift 2 + ;; + *) + ARGS="$ARGS '$(echo "$1" | sed "s|'|'\"'\"'|g")'" + shift + ;; + esac + done + eval "set -- $ARGS" + if [ -z "$IPRANGE_SPECIFIED" ] ; then + IPRANGE="10.128.0.0/10" + if command_exists netcheck && ! netcheck $IPRANGE ; then + echo "Default -iprange $IPRANGE overlaps with existing route." >&2 + echo "Please pick another range and set it on all hosts." >&2 + exit 1 + fi + fi + # Set WEAVE_DOCKER_ARGS in the environment in order to supply + # additional parameters, such as resource limits, to docker + # when launching the weave container. + CONTAINER=$(docker run --privileged -d --name=$CONTAINER_NAME \ + -p $PORT:$CONTAINER_PORT/tcp -p $PORT:$CONTAINER_PORT/udp \ + -v /var/run/docker.sock:/var/run/docker.sock \ + -e WEAVE_PASSWORD \ + -e WEAVE_CIDR=none \ + $WEAVE_DOCKER_ARGS $IMAGE -iface $CONTAINER_IFNAME -port $CONTAINER_PORT -name "$PEERNAME" -nickname "$(hostname)" -iprange "$IPRANGE" "$@") + with_container_netns_or_die $CONTAINER launch + wait_for_status $CONTAINER_NAME $HTTP_PORT + if [ -n "$IPRANGE" ] ; then + # Tell the newly-started weave IP allocator about existing weave IPs + with_container_addresses ipam_claim weave:expose $(docker ps -q --no-trunc) + fi +} + +launch_dns() { + collect_cidr_args "$@" + [ $CIDR_ARG_COUNT -lt 2 ] || usage + shift $CIDR_ARG_COUNT + create_bridge + docker_bridge_ip + # Set WEAVEDNS_DOCKER_ARGS in the environment in order to supply + # additional parameters, such as resource limits, to docker + # when launching the weave container. + DNS_CONTAINER=$(docker run --privileged -d --name=$DNS_CONTAINER_NAME \ + -p $DOCKER_BRIDGE_IP:53:53/udp \ + -e WEAVE_CIDR=none \ + -v /var/run/docker.sock:/var/run/docker.sock \ + $WEAVEDNS_DOCKER_ARGS $DNS_IMAGE -iface $CONTAINER_IFNAME -httpiface "$DNS_HTTP_IFNAME" "$@") + ipam_cidrs_or_die $DNS_CONTAINER $CIDR_ARGS + with_container_netns_or_die $DNS_CONTAINER attach $ALL_CIDRS + populate_dns +} + +launch_proxy() { + # Set WEAVEPROXY_DOCKER_ARGS in the environment in order to supply + # additional parameters, such as resource limits, to docker + # when launching the weaveproxy container. + proxy_args "$@" + PROXY_CONTAINER=$(docker run --privileged -d --name=$PROXY_CONTAINER_NAME --net=host \ + $PROXY_VOLUMES \ + -v /var/run/docker.sock:/var/run/docker.sock \ + -v /proc:/hostproc \ + -e PROCFS=/hostproc \ + -e WEAVE_CIDR=none \ + --entrypoint=/home/weave/weaveproxy \ + $WEAVEPROXY_DOCKER_ARGS $EXEC_IMAGE $PROXY_ARGS) + wait_for_log $PROXY_CONTAINER_NAME "proxy listening" +} + ########################################################################################## [ $(id -u) = 0 ] || { @@ -977,111 +1087,27 @@ case "$COMMAND" in create-bridge) create_bridge --without-ethtool ;; + launch) + check_not_running $CONTAINER_NAME $BASE_IMAGE + check_not_running $DNS_CONTAINER_NAME $BASE_DNS_IMAGE + check_not_running $PROXY_CONTAINER_NAME $EXEC_IMAGE + launch_router "$@" + launch_dns + launch_proxy + ;; launch-router) check_not_running $CONTAINER_NAME $BASE_IMAGE - create_bridge - # We set the router name to the bridge mac since that is - # stable across re-creations of the containers. - # - # TODO use the mac of one of the physical host interfaces - # (eth0, wlan0, etc) so the name becomes stable across host - # restarts. - PEERNAME=$(cat /sys/class/net/$BRIDGE/address) - # backward compatibility... - if is_cidr "$1" ; then - echo "WARNING: $1 parameter ignored; 'weave launch' no longer takes a CIDR as the first parameter" >&2 - shift 1 - fi - CONTAINER_PORT=$PORT - ARGS="" - IPRANGE= - IPRANGE_SPECIFIED= - while [ $# -gt 0 ] ; do - case "$1" in - -password) - [ $# -gt 1 ] || usage - WEAVE_PASSWORD="$2" - export WEAVE_PASSWORD - shift 2 - ;; - -port) - [ $# -gt 1 ] || usage - CONTAINER_PORT="$2" - shift 2 - ;; - -iprange) - [ $# -gt 1 ] || usage - IPRANGE="$2" - IPRANGE_SPECIFIED=1 - shift 2 - ;; - *) - ARGS="$ARGS '$(echo "$1" | sed "s|'|'\"'\"'|g")'" - shift - ;; - esac - done - eval "set -- $ARGS" - if [ -z "$IPRANGE_SPECIFIED" ] ; then - IPRANGE="10.128.0.0/10" - if command_exists netcheck && ! netcheck $IPRANGE ; then - echo "Default -iprange $IPRANGE overlaps with existing route." >&2 - echo "Please pick another range and set it on all hosts." >&2 - exit 1 - fi - fi - # Set WEAVE_DOCKER_ARGS in the environment in order to supply - # additional parameters, such as resource limits, to docker - # when launching the weave container. - CONTAINER=$(docker run --privileged -d --name=$CONTAINER_NAME \ - -p $PORT:$CONTAINER_PORT/tcp -p $PORT:$CONTAINER_PORT/udp \ - -v /var/run/docker.sock:/var/run/docker.sock \ - -e WEAVE_PASSWORD \ - -e WEAVE_CIDR=none \ - $WEAVE_DOCKER_ARGS $IMAGE -iface $CONTAINER_IFNAME -port $CONTAINER_PORT -name "$PEERNAME" -nickname "$(hostname)" -iprange "$IPRANGE" "$@") - with_container_netns_or_die $CONTAINER launch - wait_for_status $CONTAINER_NAME $HTTP_PORT - if [ -n "$IPRANGE" ] ; then - # Tell the newly-started weave IP allocator about existing weave IPs - with_container_addresses ipam_claim weave:expose $(docker ps -q --no-trunc) - fi + launch_router "$@" echo $CONTAINER ;; launch-dns) - collect_cidr_args "$@" - [ $CIDR_ARG_COUNT -lt 2 ] || usage - shift $CIDR_ARG_COUNT check_not_running $DNS_CONTAINER_NAME $BASE_DNS_IMAGE - create_bridge - docker_bridge_ip - # Set WEAVEDNS_DOCKER_ARGS in the environment in order to supply - # additional parameters, such as resource limits, to docker - # when launching the weave container. - DNS_CONTAINER=$(docker run --privileged -d --name=$DNS_CONTAINER_NAME \ - -p $DOCKER_BRIDGE_IP:53:53/udp \ - -e WEAVE_CIDR=none \ - -v /var/run/docker.sock:/var/run/docker.sock \ - $WEAVEDNS_DOCKER_ARGS $DNS_IMAGE -iface $CONTAINER_IFNAME -httpiface "$DNS_HTTP_IFNAME" "$@") - ipam_cidrs_or_die $DNS_CONTAINER $CIDR_ARGS - with_container_netns_or_die $DNS_CONTAINER attach $ALL_CIDRS - populate_dns + launch_dns "$@" echo $DNS_CONTAINER ;; launch-proxy) check_not_running $PROXY_CONTAINER_NAME $EXEC_IMAGE - # Set WEAVEPROXY_DOCKER_ARGS in the environment in order to supply - # additional parameters, such as resource limits, to docker - # when launching the weaveproxy container. - proxy_args "$@" - PROXY_CONTAINER=$(docker run --privileged -d --name=$PROXY_CONTAINER_NAME --net=host \ - $PROXY_VOLUMES \ - -v /var/run/docker.sock:/var/run/docker.sock \ - -v /proc:/hostproc \ - -e PROCFS=/hostproc \ - -e WEAVE_CIDR=none \ - --entrypoint=/home/weave/weaveproxy \ - $WEAVEPROXY_DOCKER_ARGS $EXEC_IMAGE $PROXY_ARGS) - wait_for_log $PROXY_CONTAINER_NAME "proxy listening" + launch_proxy "$@" echo $PROXY_CONTAINER ;; proxy-env) From 0d5aad3e902b168241cbbe4fc9cd1a909e108f13 Mon Sep 17 00:00:00 2001 From: Adam Harrison Date: Wed, 24 Jun 2015 14:30:23 +0100 Subject: [PATCH 21/82] Rename stop to stop-router --- weave | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/weave b/weave index d4fede60..cc41a069 100755 --- a/weave +++ b/weave @@ -48,7 +48,7 @@ usage() { echo "weave proxy-env" echo "weave proxy-config" echo "weave version" - echo "weave stop" + echo "weave stop-router" echo "weave stop-dns" echo "weave stop-proxy" echo "weave reset" @@ -1285,7 +1285,7 @@ case "$COMMAND" in done show_addrs $ALL_CIDRS ;; - stop) + stop-router) [ $# -eq 0 ] || usage stop $CONTAINER_NAME "Weave" conntrack -D -p udp --dport $PORT >/dev/null 2>&1 || true From 08f3d5b8e8c8c0a23f9d877afdb1441011885a62 Mon Sep 17 00:00:00 2001 From: Adam Harrison Date: Wed, 24 Jun 2015 14:37:10 +0100 Subject: [PATCH 22/82] Implement new weave stop behaviour --- weave | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/weave b/weave index cc41a069..40e9b991 100755 --- a/weave +++ b/weave @@ -48,6 +48,7 @@ usage() { echo "weave proxy-env" echo "weave proxy-config" echo "weave version" + echo "weave stop" echo "weave stop-router" echo "weave stop-dns" echo "weave stop-proxy" @@ -1285,6 +1286,13 @@ case "$COMMAND" in done show_addrs $ALL_CIDRS ;; + stop) + [ $# -eq 0 ] || usage + stop $PROXY_CONTAINER_NAME "Proxy" + stop $DNS_CONTAINER_NAME "WeaveDNS" + stop $CONTAINER_NAME "Weave" + conntrack -D -p udp --dport $PORT >/dev/null 2>&1 || true + ;; stop-router) [ $# -eq 0 ] || usage stop $CONTAINER_NAME "Weave" From af9668f130f6b115a2d7b9a38c1384a90c19cdf8 Mon Sep 17 00:00:00 2001 From: Bryan Boreham Date: Thu, 25 Jun 2015 12:47:38 +0100 Subject: [PATCH 23/82] Keep trying peers to ask for space until we find one that doesn't error --- ipam/allocate.go | 7 +++++-- ipam/ring/ring.go | 31 +++++++++++++++---------------- ipam/ring/ring_test.go | 37 ++++++++++++++++++++----------------- 3 files changed, 40 insertions(+), 35 deletions(-) diff --git a/ipam/allocate.go b/ipam/allocate.go index 130380e9..c1dcda66 100644 --- a/ipam/allocate.go +++ b/ipam/allocate.go @@ -42,9 +42,12 @@ func (g *allocate) Try(alloc *Allocator) bool { } // out of space - if donor, err := alloc.ring.ChoosePeerToAskForSpace(g.r.Start, g.r.End); err == nil { + donors := alloc.ring.ChoosePeersToAskForSpace(g.r.Start, g.r.End) + for _, donor := range donors { alloc.debugln("Decided to ask peer", donor, "for space in range", g.r) - alloc.sendSpaceRequest(donor, g.r) + if err := alloc.sendSpaceRequest(donor, g.r); err == nil { + break + } } return false diff --git a/ipam/ring/ring.go b/ipam/ring/ring.go index fcdb362e..4908e571 100644 --- a/ipam/ring/ring.go +++ b/ipam/ring/ring.go @@ -392,9 +392,9 @@ func (r *Ring) ReportFree(freespace map[address.Address]address.Offset) { } } -// ChoosePeerToAskForSpace chooses a weighted-random peer to ask -// for space in the range [start, end). Assumes start 0 { + // Pick random peer, weighted by total free space + rn := rand.Int63n(int64(sum)) // note using 64-bit because rand.Intn uses signed int + for peername, space := range totalSpacePerPeer { + rn -= int64(space) + if rn < 0 { + result = append(result, peername) + sum -= space + delete(totalSpacePerPeer, peername) + break + } } } - - panic("Should never reach this point") + return } func (r *Ring) PickPeerForTransfer() router.PeerName { diff --git a/ipam/ring/ring_test.go b/ipam/ring/ring_test.go index ce63a38e..7c23ccdd 100644 --- a/ipam/ring/ring_test.go +++ b/ipam/ring/ring_test.go @@ -345,39 +345,42 @@ func TestGossip(t *testing.T) { func TestFindFree(t *testing.T) { ring1 := New(start, end, peer1name) - _, err := ring1.ChoosePeerToAskForSpace(start, end) - wt.AssertTrue(t, err == ErrNoFreeSpace, "Expected ErrNoFreeSpace") + peers := ring1.ChoosePeersToAskForSpace(start, end) + wt.AssertTrue(t, len(peers) == 0, "Expected no peers") ring1.Entries = []*entry{{Token: start, Peer: peer1name}} - _, err = ring1.ChoosePeerToAskForSpace(start, end) - wt.AssertTrue(t, err == ErrNoFreeSpace, "Expected ErrNoFreeSpace") + peers = ring1.ChoosePeersToAskForSpace(start, end) + wt.AssertTrue(t, len(peers) == 0, "Expected no peers") // We shouldn't return outselves ring1.ReportFree(map[address.Address]address.Offset{start: 10}) - _, err = ring1.ChoosePeerToAskForSpace(start, end) - wt.AssertTrue(t, err == ErrNoFreeSpace, "Expected ErrNoFreeSpace") + peers = ring1.ChoosePeersToAskForSpace(start, end) + wt.AssertTrue(t, len(peers) == 0, "Expected no peers") ring1.Entries = []*entry{{Token: start, Peer: peer1name, Free: 1}, {Token: middle, Peer: peer1name, Free: 1}} - _, err = ring1.ChoosePeerToAskForSpace(start, end) - wt.AssertTrue(t, err == ErrNoFreeSpace, "Expected ErrNoFreeSpace") + peers = ring1.ChoosePeersToAskForSpace(start, end) + wt.AssertTrue(t, len(peers) == 0, "Expected no peers") ring1.assertInvariants() // We should return others ring1.Entries = []*entry{{Token: start, Peer: peer2name, Free: 1}} - peer, err := ring1.ChoosePeerToAskForSpace(start, end) - wt.AssertSuccess(t, err) - wt.AssertEquals(t, peer, peer2name) + peers = ring1.ChoosePeersToAskForSpace(start, end) + wt.AssertTrue(t, len(peers) == 1, "Expected one peer") + wt.AssertEquals(t, peers[0], peer2name) ring1.Entries = []*entry{{Token: start, Peer: peer2name, Free: 1}, {Token: middle, Peer: peer3name, Free: 1}} - peer, err = ring1.ChoosePeerToAskForSpace(start, middle) - wt.AssertSuccess(t, err) - wt.AssertEquals(t, peer, peer2name) + peers = ring1.ChoosePeersToAskForSpace(start, middle) + wt.AssertTrue(t, len(peers) == 1, "Expected one peer") + wt.AssertEquals(t, peers[0], peer2name) - peer, err = ring1.ChoosePeerToAskForSpace(middle, end) - wt.AssertSuccess(t, err) - wt.AssertEquals(t, peer, peer3name) + peers = ring1.ChoosePeersToAskForSpace(middle, end) + wt.AssertTrue(t, len(peers) == 1, "Expected one peer") + wt.AssertEquals(t, peers[0], peer3name) + + peers = ring1.ChoosePeersToAskForSpace(start, end) + wt.AssertTrue(t, len(peers) == 2, "Expected two peers") ring1.assertInvariants() } From c58cc449c07941f6f38b49730e246c4822102902 Mon Sep 17 00:00:00 2001 From: Bryan Boreham Date: Thu, 25 Jun 2015 13:19:49 +0100 Subject: [PATCH 24/82] More complex ChoosePeersToAskForSpace, with better complexity --- ipam/ring/ring.go | 41 +++++++++++++++++++++++++---------------- 1 file changed, 25 insertions(+), 16 deletions(-) diff --git a/ipam/ring/ring.go b/ipam/ring/ring.go index 4908e571..c411b163 100644 --- a/ipam/ring/ring.go +++ b/ipam/ring/ring.go @@ -395,10 +395,7 @@ func (r *Ring) ReportFree(freespace map[address.Address]address.Offset) { // ChoosePeerToAskForSpace returns all peers we can ask for space in // the range [start, end), in weighted-random order. Assumes start 0 { - // Pick random peer, weighted by total free space - rn := rand.Int63n(int64(sum)) // note using 64-bit because rand.Intn uses signed int - for peername, space := range totalSpacePerPeer { - rn -= int64(space) - if rn < 0 { - result = append(result, peername) - sum -= space - delete(totalSpacePerPeer, peername) - break - } + // Compute cumulative distribution of spaces + type spaceCDF struct { + sum address.Offset + peername router.PeerName + } + var cdf []spaceCDF + var sum address.Offset + for peername, space := range totalSpacePerPeer { + sum += space + cdf = append(cdf, spaceCDF{sum: sum, peername: peername}) + } + + for len(cdf) > 0 { + // Pick a number up to remaining free space + // (note using 64-bit because rand.Intn is signed int) + rn := rand.Int63n(int64(cdf[len(cdf)-1].sum)) + // Find where this number lands in the CDF, and take that peer + i := sort.Search(len(cdf), func(j int) bool { return int64(cdf[j].sum) > rn }) + result = append(result, cdf[i].peername) + // Remove this entry from the CDF and adjust all following sums + space := totalSpacePerPeer[cdf[i].peername] + for j := i; j < len(cdf); j++ { + cdf[j].sum -= space } + cdf = append(cdf[:i], cdf[i+1:]...) } return } From b472da18f04b65470e7197521e5c5bbd68918f50 Mon Sep 17 00:00:00 2001 From: Bryan Boreham Date: Thu, 25 Jun 2015 14:04:37 +0100 Subject: [PATCH 25/82] Improve logging of unicast gossip errors --- ipam/allocate.go | 6 ++++-- router/gossip_channel.go | 11 +++++------ 2 files changed, 9 insertions(+), 8 deletions(-) diff --git a/ipam/allocate.go b/ipam/allocate.go index c1dcda66..f2da3c74 100644 --- a/ipam/allocate.go +++ b/ipam/allocate.go @@ -44,8 +44,10 @@ func (g *allocate) Try(alloc *Allocator) bool { // out of space donors := alloc.ring.ChoosePeersToAskForSpace(g.r.Start, g.r.End) for _, donor := range donors { - alloc.debugln("Decided to ask peer", donor, "for space in range", g.r) - if err := alloc.sendSpaceRequest(donor, g.r); err == nil { + if err := alloc.sendSpaceRequest(donor, g.r); err != nil { + alloc.debugln("Problem asking peer", donor, "for space:", err) + } else { + alloc.debugln("Decided to ask peer", donor, "for space in range", g.r) break } } diff --git a/router/gossip_channel.go b/router/gossip_channel.go index bbc177db..39de093a 100644 --- a/router/gossip_channel.go +++ b/router/gossip_channel.go @@ -59,9 +59,11 @@ func (c *GossipChannel) deliverUnicast(srcName PeerName, origPayload []byte, dec return err } if c.ourself.Name != destName { - c.relayUnicast(destName, origPayload) - // ignore errors in passing on data; a problem between us and destination - // is not enough reason to break the connection from the source + 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 @@ -172,9 +174,6 @@ func (c *GossipChannel) relayUnicast(dstPeerName PeerName, buf []byte) (err erro } else { conn.(ProtocolSender).SendProtocolMsg(ProtocolMsg{ProtocolGossipUnicast, buf}) } - if err != nil { - c.log(err) - } return err } From a9e3320e7cfda5be74ccb96ff1ab2601f98a96c2 Mon Sep 17 00:00:00 2001 From: Adam Harrison Date: Thu, 25 Jun 2015 14:32:08 +0100 Subject: [PATCH 26/82] Update documentation --- site/features.md | 2 -- site/proxy.md | 17 +++++++++++++---- site/weavedns.md | 24 +++++++++++++++++++----- 3 files changed, 32 insertions(+), 11 deletions(-) diff --git a/site/features.md b/site/features.md index af72ffdc..8692affe 100644 --- a/site/features.md +++ b/site/features.md @@ -141,10 +141,8 @@ Let's begin by configuring weave's allocator to manage multiple subnets: host1$ weave launch -iprange 10.2.0.0/16 -ipsubnet 10.2.1.0/24 - host1$ weave launch-dns && weave launch-proxy host1$ eval $(weave proxy-env) host2$ weave launch -iprange 10.2.0.0/16 -ipsubnet 10.2.1.0/24 $HOST1 - host2$ weave launch-dns && weave launch-proxy host2$ eval $(weave proxy-env) This delegates the entire 10.2.0.0/16 subnet to weave, and instructs diff --git a/site/proxy.md b/site/proxy.md index 04861579..0514e30b 100644 --- a/site/proxy.md +++ b/site/proxy.md @@ -23,11 +23,18 @@ instead of `weave run`. ## Setup The proxy sits between the Docker client (command line or API) and the -Docker daemon, intercepting the communication between the two. +Docker daemon, intercepting the communication between the two. You can +start it simultaneously with the router and weaveDNS via `launch`: -To start the proxy, run + host1$ weave launch - host1$ weave launch-proxy +or independently via `launch-proxy`: + + host1$ weave launch-router && weave launch-dns && weave launch-proxy + +The first form is more convenient, however you can only pass proxy +related configuration arguments to `launch-proxy` so if you need to +modify the default behaviour you will have to use the latter. By default, the proxy listens on port 12375, on all network interfaces. This can be adjusted with the `-H` argument, e.g. @@ -49,10 +56,12 @@ Alternatively, the proxy host can be set on a per-command basis with host1$ docker $(weave proxy-config) ps -The proxy can be stopped with +The proxy can be stopped independently with host1$ weave stop-proxy +or in conjunction with the router and weaveDNS via `stop`. + If you set your `DOCKER_HOST` to point at the proxy, remember to revert to the original setting. diff --git a/site/weavedns.md b/site/weavedns.md index 0720ab77..c97d80d5 100644 --- a/site/weavedns.md +++ b/site/weavedns.md @@ -28,13 +28,23 @@ hosts. WeaveDNS is deployed as a set of containers that communicate with each other over the weave network. One such container needs to be started -on every weave host, by invoking the weave script command -`launch-dns`: +on every weave host, either simultaneously with the router and proxy +via `launch`: ```bash -host1$ weave launch && weave launch-dns && weave launch-proxy +host1$ weave launch host1$ eval $(weave proxy-env) ``` +or independently via `launch-dns`: + +```bash +host1$ weave launch-router && weave launch-dns && weave launch-proxy +host1$ eval $(weave proxy-env) +``` + +The first form is more convenient, however you can only pass weaveDNS +related configuration arguments to `launch-dns` so if you need to +modify the default behaviour you will have to use the latter. Application containers will use weaveDNS automatically if it is running at the point when they are started. They will use it for name @@ -67,7 +77,11 @@ however specify an address in CIDR format manually. In this case you are responsible for ensuring that the IP addresses specified are uniquely allocated and not in use by any other container. -Finally, WeaveDNS containers can be stopped with `stop-dns`. +Finally, weaveDNS can be stopped independently with + + host1$ weave stop-dns + +or in conjunction with the router and proxy via `stop`. ## How it works @@ -112,7 +126,7 @@ Returning to our earlier example, let us start an additional `pingme` container, this time on the 2nd host, and then run some ping tests... ```bash -host2$ weave launch && weave launch-dns && weave launch-proxy +host2$ weave launch host2$ eval $(weave proxy-env) host2$ docker run -dti --name=pingme ubuntu From c76f640e2e67d9dfeb345269dc0671eaf0ec31f4 Mon Sep 17 00:00:00 2001 From: Bryan Boreham Date: Thu, 25 Jun 2015 14:48:17 +0100 Subject: [PATCH 27/82] Simpler implementation of weighted-random order --- ipam/ring/ring.go | 50 +++++++++++++++++++++++------------------------ 1 file changed, 25 insertions(+), 25 deletions(-) diff --git a/ipam/ring/ring.go b/ipam/ring/ring.go index c411b163..da65014b 100644 --- a/ipam/ring/ring.go +++ b/ipam/ring/ring.go @@ -392,10 +392,23 @@ func (r *Ring) ReportFree(freespace map[address.Address]address.Offset) { } } -// ChoosePeerToAskForSpace returns all peers we can ask for space in +type weightedPeer struct { + weight float64 + peername router.PeerName +} +type weightedPeers []weightedPeer + +func (ws weightedPeers) Len() int { return len(ws) } +func (ws weightedPeers) Less(i, j int) bool { return ws[i].weight < ws[j].weight } +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 // the range [start, end), in weighted-random order. Assumes start 0 { - // Pick a number up to remaining free space - // (note using 64-bit because rand.Intn is signed int) - rn := rand.Int63n(int64(cdf[len(cdf)-1].sum)) - // Find where this number lands in the CDF, and take that peer - i := sort.Search(len(cdf), func(j int) bool { return int64(cdf[j].sum) > rn }) - result = append(result, cdf[i].peername) - // Remove this entry from the CDF and adjust all following sums - space := totalSpacePerPeer[cdf[i].peername] - for j := i; j < len(cdf); j++ { - cdf[j].sum -= space - } - cdf = append(cdf[:i], cdf[i+1:]...) + sort.Sort(ws) + // Reverse order (bigger weights come last after sort) and copy to result + for i := range ws { + result = append(result, ws[len(ws)-i-1].peername) } return } From 8a4b0d536eb92c2bbcc06eaa18299aabe362255f Mon Sep 17 00:00:00 2001 From: Bryan Boreham Date: Thu, 25 Jun 2015 15:30:49 +0100 Subject: [PATCH 28/82] Updated after review feedback --- ipam/ring/ring.go | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/ipam/ring/ring.go b/ipam/ring/ring.go index da65014b..127175e8 100644 --- a/ipam/ring/ring.go +++ b/ipam/ring/ring.go @@ -398,13 +398,14 @@ type weightedPeer struct { } type weightedPeers []weightedPeer +// Note Less is using > so that bigger weights sort earlier +func (ws weightedPeers) Less(i, j int) bool { return ws[i].weight > ws[j].weight } func (ws weightedPeers) Len() int { return len(ws) } -func (ws weightedPeers) Less(i, j int) bool { return ws[i].weight < ws[j].weight } 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 // the range [start, end), in weighted-random order. Assumes start Date: Thu, 25 Jun 2015 16:42:53 +0100 Subject: [PATCH 29/82] Extend 'go get' to tests The `-t` flag asks Go to fetch anything required for tests, which is more necessary now we have added testify. --- Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Makefile b/Makefile index 5031dede..91cdbeb1 100644 --- a/Makefile +++ b/Makefile @@ -44,7 +44,7 @@ update: $(EXES) go get -u -f -v -tags -netgo $(addprefix ./,$(dir $(EXES))) $(WEAVER_EXE) $(WEAVEDNS_EXE) $(WEAVEPROXY_EXE) $(NETCHECK_EXE): common/*.go common/*/*.go net/*.go - go get -tags netgo ./$(@D) + go get -t -tags netgo ./$(@D) go build -ldflags "-extldflags \"-static\" -X main.version $(WEAVE_VERSION)" -tags netgo -o $@ ./$(@D) @strings $@ | grep cgo_stub\\\.go >/dev/null || { \ rm $@; \ From 4162dcafd352c7ffa98ec9b7ea56ed627cfd8122 Mon Sep 17 00:00:00 2001 From: David Wragg Date: Mon, 25 May 2015 20:17:28 +0100 Subject: [PATCH 30/82] Make the full EthernetDecoder available to LogFrame So that LogFrame can include information about the decoded frame beyond the ethernet layer. --- prog/weaver/main.go | 8 ++++---- router/ethernet_decoder.go | 30 +++++++++++++++--------------- router/forwarder.go | 4 ++-- router/local_peer.go | 2 +- router/router.go | 26 +++++++++++++------------- 5 files changed, 35 insertions(+), 35 deletions(-) diff --git a/prog/weaver/main.go b/prog/weaver/main.go index d0ac8596..91985ced 100644 --- a/prog/weaver/main.go +++ b/prog/weaver/main.go @@ -192,14 +192,14 @@ func options() map[string]string { func logFrameFunc(debug bool) weave.LogFrameFunc { if !debug { - return func(prefix string, frame []byte, eth *layers.Ethernet) {} + return func(prefix string, frame []byte, dec *weave.EthernetDecoder) {} } - return func(prefix string, frame []byte, eth *layers.Ethernet) { + return func(prefix string, frame []byte, dec *weave.EthernetDecoder) { h := fmt.Sprintf("%x", sha256.Sum256(frame)) - if eth == nil { + if dec == nil { log.Println(prefix, len(frame), "bytes (", h, ")") } else { - log.Println(prefix, len(frame), "bytes (", h, "):", eth.SrcMAC, "->", eth.DstMAC) + log.Println(prefix, len(frame), "bytes (", h, "):", dec.Eth.SrcMAC, "->", dec.Eth.DstMAC) } } } diff --git a/router/ethernet_decoder.go b/router/ethernet_decoder.go index 297a2011..0080cc82 100644 --- a/router/ethernet_decoder.go +++ b/router/ethernet_decoder.go @@ -10,15 +10,15 @@ import ( ) type EthernetDecoder struct { - eth layers.Ethernet - ip layers.IPv4 + Eth layers.Ethernet + IP layers.IPv4 decoded []gopacket.LayerType parser *gopacket.DecodingLayerParser } func NewEthernetDecoder() *EthernetDecoder { dec := &EthernetDecoder{} - dec.parser = gopacket.NewDecodingLayerParser(layers.LayerTypeEthernet, &dec.eth, &dec.ip) + dec.parser = gopacket.NewDecodingLayerParser(layers.LayerTypeEthernet, &dec.Eth, &dec.IP) return dec } @@ -31,23 +31,23 @@ func (dec *EthernetDecoder) sendICMPFragNeeded(mtu int, sendFrame func([]byte) e opts := gopacket.SerializeOptions{ FixLengths: true, ComputeChecksums: true} - ipHeaderSize := int(dec.ip.IHL) * 4 // IHL is the number of 32-byte words in the header - payload := gopacket.Payload(dec.ip.BaseLayer.Contents[:ipHeaderSize+8]) + ipHeaderSize := int(dec.IP.IHL) * 4 // IHL is the number of 32-byte words in the header + payload := gopacket.Payload(dec.IP.BaseLayer.Contents[:ipHeaderSize+8]) err := gopacket.SerializeLayers(buf, opts, &layers.Ethernet{ - SrcMAC: dec.eth.DstMAC, - DstMAC: dec.eth.SrcMAC, - EthernetType: dec.eth.EthernetType}, + SrcMAC: dec.Eth.DstMAC, + DstMAC: dec.Eth.SrcMAC, + EthernetType: dec.Eth.EthernetType}, &layers.IPv4{ Version: 4, - TOS: dec.ip.TOS, + TOS: dec.IP.TOS, Id: 0, Flags: 0, FragOffset: 0, TTL: 64, Protocol: layers.IPProtocolICMPv4, - DstIP: dec.ip.SrcIP, - SrcIP: dec.ip.DstIP}, + DstIP: dec.IP.SrcIP, + SrcIP: dec.IP.DstIP}, &layers.ICMPv4{ TypeCode: 0x304, Id: 0, @@ -57,7 +57,7 @@ func (dec *EthernetDecoder) sendICMPFragNeeded(mtu int, sendFrame func([]byte) e return err } - log.Printf("Sending ICMP 3,4 (%v -> %v): PMTU= %v\n", dec.ip.DstIP, dec.ip.SrcIP, mtu) + log.Printf("Sending ICMP 3,4 (%v -> %v): PMTU= %v\n", dec.IP.DstIP, dec.IP.SrcIP, mtu) return sendFrame(buf.Bytes()) } @@ -68,10 +68,10 @@ var ( ) func (dec *EthernetDecoder) DropFrame() bool { - return bytes.Equal(stpMACPrefix, dec.eth.DstMAC[:len(stpMACPrefix)]) + return bytes.Equal(stpMACPrefix, dec.Eth.DstMAC[:len(stpMACPrefix)]) } func (dec *EthernetDecoder) IsSpecial() bool { - return dec.eth.Length == 0 && dec.eth.EthernetType == layers.EthernetTypeLLC && - bytes.Equal(zeroMAC, dec.eth.SrcMAC) && bytes.Equal(zeroMAC, dec.eth.DstMAC) + return dec.Eth.Length == 0 && dec.Eth.EthernetType == layers.EthernetTypeLLC && + bytes.Equal(zeroMAC, dec.Eth.SrcMAC) && bytes.Equal(zeroMAC, dec.Eth.DstMAC) } diff --git a/router/forwarder.go b/router/forwarder.go index 3c9ba0ed..da727034 100644 --- a/router/forwarder.go +++ b/router/forwarder.go @@ -105,11 +105,11 @@ func (conn *LocalConnection) Forward(df bool, frame *ForwardedFrame, dec *Ethern forwarderDF.Forward(frame) return nil } - conn.Router.LogFrame("Fragmenting", frame.frame, &dec.eth) + conn.Router.LogFrame("Fragmenting", frame.frame, dec) // We can't trust the stack to fragment, we have IP, and we // have a frame that's too big for the MTU, so we have to // fragment it ourself. - return fragment(dec.eth, dec.ip, effectivePMTU, frame, func(segFrame *ForwardedFrame) { + return fragment(dec.Eth, dec.IP, effectivePMTU, frame, func(segFrame *ForwardedFrame) { forwarderDF.Forward(segFrame) }) } diff --git a/router/local_peer.go b/router/local_peer.go index b9ea939b..3be1e7b5 100644 --- a/router/local_peer.go +++ b/router/local_peer.go @@ -70,7 +70,7 @@ func (peer *LocalPeer) RelayBroadcast(srcPeer *Peer, df bool, frame []byte, dec dec) if err != nil { if ftbe, ok := err.(FrameTooBigError); ok { - log.Printf("dropping too big DF broadcast frame (%v -> %v): PMTU= %v\n", dec.ip.DstIP, dec.ip.SrcIP, ftbe.EPMTU) + log.Printf("dropping too big DF broadcast frame (%v -> %v): PMTU= %v\n", dec.IP.DstIP, dec.IP.SrcIP, ftbe.EPMTU) } else { log.Println(err) } diff --git a/router/router.go b/router/router.go index 9f9e626f..8873729c 100644 --- a/router/router.go +++ b/router/router.go @@ -27,7 +27,7 @@ const ( // against brute-force attacks on the password when encryption is in // use. It is also a basic DoS defence. -type LogFrameFunc func(string, []byte, *layers.Ethernet) +type LogFrameFunc func(string, []byte, *EthernetDecoder) type Config struct { Port int @@ -151,7 +151,7 @@ func (router *Router) handleCapturedPacket(frameData []byte, dec *EthernetDecode if decodedLen == 0 { return } - srcMac := dec.eth.SrcMAC + srcMac := dec.Eth.SrcMAC srcPeer, found := router.Macs.Lookup(srcMac) // We need to filter out frames we injected ourselves. For such // frames, the srcMAC will have been recorded as associated with a @@ -165,16 +165,16 @@ func (router *Router) handleCapturedPacket(frameData []byte, dec *EthernetDecode if dec.DropFrame() { return } - dstMac := dec.eth.DstMAC + dstMac := dec.Eth.DstMAC dstPeer, found := router.Macs.Lookup(dstMac) if found && dstPeer == router.Ourself.Peer { return } - df := decodedLen == 2 && (dec.ip.Flags&layers.IPv4DontFragment != 0) + df := decodedLen == 2 && (dec.IP.Flags&layers.IPv4DontFragment != 0) if df { - router.LogFrame("Forwarding DF", frameData, &dec.eth) + router.LogFrame("Forwarding DF", frameData, dec) } else { - router.LogFrame("Forwarding", frameData, &dec.eth) + router.LogFrame("Forwarding", frameData, dec) } // at this point we are handing over the frame to forwarders, so // we need to make a copy of it in order to prevent the next @@ -316,14 +316,14 @@ func (router *Router) handleUDPPacketFunc(relayConn *LocalConnection, dec *Ether return } - df := decodedLen == 2 && (dec.ip.Flags&layers.IPv4DontFragment != 0) + df := decodedLen == 2 && (dec.IP.Flags&layers.IPv4DontFragment != 0) if dstPeer != router.Ourself.Peer { // it's not for us, we're just relaying it if df { - router.LogFrame("Relaying DF", frame, &dec.eth) + router.LogFrame("Relaying DF", frame, dec) } else { - router.LogFrame("Relaying", frame, &dec.eth) + router.LogFrame("Relaying", frame, dec) } err := router.Ourself.Relay(srcPeer, dstPeer, df, frame, dec) @@ -337,20 +337,20 @@ func (router *Router) handleUDPPacketFunc(relayConn *LocalConnection, dec *Ether return } - srcMac := dec.eth.SrcMAC - dstMac := dec.eth.DstMAC + srcMac := dec.Eth.SrcMAC + dstMac := dec.Eth.DstMAC if router.Macs.Enter(srcMac, srcPeer) { log.Println("Discovered remote MAC", srcMac, "at", srcPeer) } if po != nil { - router.LogFrame("Injecting", frame, &dec.eth) + router.LogFrame("Injecting", frame, dec) checkWarn(po.WritePacket(frame)) } dstPeer, found = router.Macs.Lookup(dstMac) if !found || dstPeer != router.Ourself.Peer { - router.LogFrame("Relaying broadcast", frame, &dec.eth) + router.LogFrame("Relaying broadcast", frame, dec) router.Ourself.RelayBroadcast(srcPeer, df, frame, dec) } } From 569090217397a82c5b7bd00c8edfc570f4403a3e Mon Sep 17 00:00:00 2001 From: David Wragg Date: Wed, 17 Jun 2015 16:25:16 +0100 Subject: [PATCH 31/82] Move DF indication into LogFrame --- prog/weaver/main.go | 15 ++++++++++----- router/ethernet_decoder.go | 4 ++++ router/router.go | 19 +++++-------------- 3 files changed, 19 insertions(+), 19 deletions(-) diff --git a/prog/weaver/main.go b/prog/weaver/main.go index 91985ced..7b98dbb6 100644 --- a/prog/weaver/main.go +++ b/prog/weaver/main.go @@ -11,7 +11,6 @@ import ( "runtime" "strings" - "code.google.com/p/gopacket/layers" "github.com/davecheney/profile" "github.com/gorilla/mux" . "github.com/weaveworks/weave/common" @@ -196,11 +195,17 @@ func logFrameFunc(debug bool) weave.LogFrameFunc { } return func(prefix string, frame []byte, dec *weave.EthernetDecoder) { h := fmt.Sprintf("%x", sha256.Sum256(frame)) - if dec == nil { - log.Println(prefix, len(frame), "bytes (", h, ")") - } else { - log.Println(prefix, len(frame), "bytes (", h, "):", dec.Eth.SrcMAC, "->", dec.Eth.DstMAC) + parts := []interface{}{prefix, len(frame), "bytes (", h, ")"} + + if dec != nil { + parts = append(parts, dec.Eth.SrcMAC, "->", dec.Eth.DstMAC) + + if dec.DF() { + parts = append(parts, "(DF)") + } } + + log.Println(parts...) } } diff --git a/router/ethernet_decoder.go b/router/ethernet_decoder.go index 0080cc82..036840c8 100644 --- a/router/ethernet_decoder.go +++ b/router/ethernet_decoder.go @@ -75,3 +75,7 @@ func (dec *EthernetDecoder) IsSpecial() bool { return dec.Eth.Length == 0 && dec.Eth.EthernetType == layers.EthernetTypeLLC && bytes.Equal(zeroMAC, dec.Eth.SrcMAC) && bytes.Equal(zeroMAC, dec.Eth.DstMAC) } + +func (dec *EthernetDecoder) DF() bool { + return len(dec.decoded) == 2 && (dec.IP.Flags&layers.IPv4DontFragment != 0) +} diff --git a/router/router.go b/router/router.go index 8873729c..67d7b239 100644 --- a/router/router.go +++ b/router/router.go @@ -11,7 +11,6 @@ import ( "syscall" "time" - "code.google.com/p/gopacket/layers" . "github.com/weaveworks/weave/common" ) @@ -170,12 +169,9 @@ func (router *Router) handleCapturedPacket(frameData []byte, dec *EthernetDecode if found && dstPeer == router.Ourself.Peer { return } - df := decodedLen == 2 && (dec.IP.Flags&layers.IPv4DontFragment != 0) - if df { - router.LogFrame("Forwarding DF", frameData, dec) - } else { - router.LogFrame("Forwarding", frameData, dec) - } + df := dec.DF() + router.LogFrame("Forwarding", frameData, dec) + // at this point we are handing over the frame to forwarders, so // we need to make a copy of it in order to prevent the next // capture from overwriting the data @@ -316,16 +312,11 @@ func (router *Router) handleUDPPacketFunc(relayConn *LocalConnection, dec *Ether return } - df := decodedLen == 2 && (dec.IP.Flags&layers.IPv4DontFragment != 0) + df := dec.DF() if dstPeer != router.Ourself.Peer { // it's not for us, we're just relaying it - if df { - router.LogFrame("Relaying DF", frame, dec) - } else { - router.LogFrame("Relaying", frame, dec) - } - + router.LogFrame("Relaying", frame, dec) err := router.Ourself.Relay(srcPeer, dstPeer, df, frame, dec) if ftbe, ok := err.(FrameTooBigError); ok { err = dec.sendICMPFragNeeded(ftbe.EPMTU, func(icmpFrame []byte) error { From 64ac7745fec17dafe1c75a38f2999d43bba0e76e Mon Sep 17 00:00:00 2001 From: David Wragg Date: Mon, 25 May 2015 21:38:55 +0100 Subject: [PATCH 32/82] Don't inspect the DF flag earlier than we need to --- router/forwarder.go | 5 +++++ router/local_peer.go | 16 ++++++++-------- router/router.go | 13 +++++-------- 3 files changed, 18 insertions(+), 16 deletions(-) diff --git a/router/forwarder.go b/router/forwarder.go index da727034..cab1c0ff 100644 --- a/router/forwarder.go +++ b/router/forwarder.go @@ -77,6 +77,11 @@ func (conn *LocalConnection) Forward(df bool, frame *ForwardedFrame, dec *Ethern conn.Log("Cannot forward frame yet - awaiting contact") return nil } + + if dec != nil { + df = dec.DF() + } + // We could use non-blocking channel sends here, i.e. drop frames // on the floor when the forwarder is busy. This would allow our // caller - the capturing loop in the router - to read frames more diff --git a/router/local_peer.go b/router/local_peer.go index 3be1e7b5..930fbf1b 100644 --- a/router/local_peer.go +++ b/router/local_peer.go @@ -28,15 +28,15 @@ func NewLocalPeer(name PeerName, nickName string, router *Router) *LocalPeer { return peer } -func (peer *LocalPeer) Forward(dstPeer *Peer, df bool, frame []byte, dec *EthernetDecoder) error { - return peer.Relay(peer.Peer, dstPeer, df, frame, dec) +func (peer *LocalPeer) Forward(dstPeer *Peer, frame []byte, dec *EthernetDecoder) error { + return peer.Relay(peer.Peer, dstPeer, frame, dec) } -func (peer *LocalPeer) Broadcast(df bool, frame []byte, dec *EthernetDecoder) { - peer.RelayBroadcast(peer.Peer, df, frame, dec) +func (peer *LocalPeer) Broadcast(frame []byte, dec *EthernetDecoder) { + peer.RelayBroadcast(peer.Peer, frame, dec) } -func (peer *LocalPeer) Relay(srcPeer, dstPeer *Peer, df bool, frame []byte, dec *EthernetDecoder) error { +func (peer *LocalPeer) Relay(srcPeer, dstPeer *Peer, frame []byte, dec *EthernetDecoder) error { relayPeerName, found := peer.router.Routes.Unicast(dstPeer.Name) if !found { // Not necessarily an error as there could be a race with the @@ -50,20 +50,20 @@ func (peer *LocalPeer) Relay(srcPeer, dstPeer *Peer, df bool, frame []byte, dec log.Println("Unable to find connection to relay peer", relayPeerName) return nil } - return conn.(*LocalConnection).Forward(df, &ForwardedFrame{ + return conn.(*LocalConnection).Forward(false, &ForwardedFrame{ srcPeer: srcPeer, dstPeer: dstPeer, frame: frame}, dec) } -func (peer *LocalPeer) RelayBroadcast(srcPeer *Peer, df bool, frame []byte, dec *EthernetDecoder) { +func (peer *LocalPeer) RelayBroadcast(srcPeer *Peer, frame []byte, dec *EthernetDecoder) { nextHops := peer.router.Routes.Broadcast(srcPeer.Name) if len(nextHops) == 0 { return } for _, conn := range peer.ConnectionsTo(nextHops) { - err := conn.(*LocalConnection).Forward(df, &ForwardedFrame{ + err := conn.(*LocalConnection).Forward(false, &ForwardedFrame{ srcPeer: srcPeer, dstPeer: conn.Remote(), frame: frame}, diff --git a/router/router.go b/router/router.go index 67d7b239..a85d1fb1 100644 --- a/router/router.go +++ b/router/router.go @@ -169,7 +169,6 @@ func (router *Router) handleCapturedPacket(frameData []byte, dec *EthernetDecode if found && dstPeer == router.Ourself.Peer { return } - df := dec.DF() router.LogFrame("Forwarding", frameData, dec) // at this point we are handing over the frame to forwarders, so @@ -182,11 +181,11 @@ func (router *Router) handleCapturedPacket(frameData []byte, dec *EthernetDecode // If we don't know which peer corresponds to the dest MAC, // broadcast it. if !found { - router.Ourself.Broadcast(df, frameCopy, dec) + router.Ourself.Broadcast(frameCopy, dec) return } - err := router.Ourself.Forward(dstPeer, df, frameCopy, dec) + err := router.Ourself.Forward(dstPeer, frameCopy, dec) if ftbe, ok := err.(FrameTooBigError); ok { err = dec.sendICMPFragNeeded(ftbe.EPMTU, po.WritePacket) } @@ -312,15 +311,13 @@ func (router *Router) handleUDPPacketFunc(relayConn *LocalConnection, dec *Ether return } - df := dec.DF() - if dstPeer != router.Ourself.Peer { // it's not for us, we're just relaying it router.LogFrame("Relaying", frame, dec) - err := router.Ourself.Relay(srcPeer, dstPeer, df, frame, dec) + err := router.Ourself.Relay(srcPeer, dstPeer, frame, dec) if ftbe, ok := err.(FrameTooBigError); ok { err = dec.sendICMPFragNeeded(ftbe.EPMTU, func(icmpFrame []byte) error { - return router.Ourself.Forward(srcPeer, false, icmpFrame, nil) + return router.Ourself.Forward(srcPeer, icmpFrame, nil) }) } @@ -342,7 +339,7 @@ func (router *Router) handleUDPPacketFunc(relayConn *LocalConnection, dec *Ether dstPeer, found = router.Macs.Lookup(dstMac) if !found || dstPeer != router.Ourself.Peer { router.LogFrame("Relaying broadcast", frame, dec) - router.Ourself.RelayBroadcast(srcPeer, df, frame, dec) + router.Ourself.RelayBroadcast(srcPeer, frame, dec) } } } From 82da45a6380ce70f7f8301e4fae78eb4b77b9f0d Mon Sep 17 00:00:00 2001 From: Matthias Radestock Date: Thu, 25 Jun 2015 19:31:38 +0100 Subject: [PATCH 33/82] `go get` test dependencies The previous 'fix' wasn't working since it `go get -t`'ed the dirs where our executables live. Which don't contain any tests. --- Makefile | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Makefile b/Makefile index 91cdbeb1..0e4efa86 100644 --- a/Makefile +++ b/Makefile @@ -44,7 +44,7 @@ update: $(EXES) go get -u -f -v -tags -netgo $(addprefix ./,$(dir $(EXES))) $(WEAVER_EXE) $(WEAVEDNS_EXE) $(WEAVEPROXY_EXE) $(NETCHECK_EXE): common/*.go common/*/*.go net/*.go - go get -t -tags netgo ./$(@D) + go get -tags netgo ./$(@D) go build -ldflags "-extldflags \"-static\" -X main.version $(WEAVE_VERSION)" -tags netgo -o $@ ./$(@D) @strings $@ | grep cgo_stub\\\.go >/dev/null || { \ rm $@; \ @@ -96,6 +96,7 @@ tests: echo "mode: count" > profile.cov fail=0 ; \ for dir in $$(find . -type f -name '*_test.go' | xargs -n1 dirname | sort -u); do \ + go get -t -tags netgo $$dir ; \ output=$$(mktemp cover.XXXXXXXXXX) ; \ if ! go test -cpu 4 -tags netgo -covermode=count -coverprofile=$$output $$dir ; then \ fail=1 ; \ From 635a3e5b2670cad382765d4ec9927f3f5c27a2b4 Mon Sep 17 00:00:00 2001 From: Matthias Radestock Date: Thu, 25 Jun 2015 19:51:39 +0100 Subject: [PATCH 34/82] cosmetic: remove attempt at pretty shell fragment there is just no way to format this so it looks good everywhere, due to different tab widths. --- Makefile | 25 +++++++++++++------------ 1 file changed, 13 insertions(+), 12 deletions(-) diff --git a/Makefile b/Makefile index 0e4efa86..f69d0969 100644 --- a/Makefile +++ b/Makefile @@ -94,18 +94,19 @@ $(DOCKER_DISTRIB): tests: echo "mode: count" > profile.cov - fail=0 ; \ - for dir in $$(find . -type f -name '*_test.go' | xargs -n1 dirname | sort -u); do \ - go get -t -tags netgo $$dir ; \ - output=$$(mktemp cover.XXXXXXXXXX) ; \ - if ! go test -cpu 4 -tags netgo -covermode=count -coverprofile=$$output $$dir ; then \ - fail=1 ; \ - fi ; \ - if [ -f $$output ]; then \ - tail -n +2 <$$output >>profile.cov; \ - rm $$output; \ - fi \ - done ; \ + fail=0 ; \ + for dir in $$(find . -type f -name '*_test.go' | xargs -n1 dirname | sort -u); do \ + go get -t -tags netgo $$dir ; \ + output=$$(mktemp cover.XXXXXXXXXX) ; \ + if ! go test -cpu 4 -tags netgo \ + -covermode=count -coverprofile=$$output $$dir ; then \ + fail=1 ; \ + fi ; \ + if [ -f $$output ]; then \ + tail -n +2 <$$output >>profile.cov; \ + rm $$output; \ + fi \ + done ; \ exit $$fail go tool cover -html=profile.cov -o=coverage.html From 39a6d1c87e2dbb08953b02271c6ed8e721c6330f Mon Sep 17 00:00:00 2001 From: Matthias Radestock Date: Thu, 25 Jun 2015 20:13:03 +0100 Subject: [PATCH 35/82] refactor: simplify a test --- ipam/ring/ring_test.go | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/ipam/ring/ring_test.go b/ipam/ring/ring_test.go index ee3f15f8..71a228d4 100644 --- a/ipam/ring/ring_test.go +++ b/ipam/ring/ring_test.go @@ -351,45 +351,45 @@ func TestGossip(t *testing.T) { assertRing(ring2, []*entry{{Token: start, Peer: peer1name, Free: 255}}) } +func assertPeersWithSpace(t *testing.T, ring *Ring, start, end address.Address, expected int) []router.PeerName { + peers := ring.ChoosePeersToAskForSpace(start, end) + require.Equal(t, expected, len(peers)) + return peers +} + func TestFindFree(t *testing.T) { ring1 := New(start, end, peer1name) - peers := ring1.ChoosePeersToAskForSpace(start, end) - require.Equal(t, 0, len(peers), "Expected no peers") + assertPeersWithSpace(t, ring1, start, end, 0) ring1.Entries = []*entry{{Token: start, Peer: peer1name}} - peers = ring1.ChoosePeersToAskForSpace(start, end) - require.Equal(t, 0, len(peers), "Expected no peers") + assertPeersWithSpace(t, ring1, start, end, 0) // We shouldn't return outselves ring1.ReportFree(map[address.Address]address.Offset{start: 10}) - peers = ring1.ChoosePeersToAskForSpace(start, end) - require.Equal(t, 0, len(peers), "Expected no peers") + assertPeersWithSpace(t, ring1, start, end, 0) ring1.Entries = []*entry{{Token: start, Peer: peer1name, Free: 1}, {Token: middle, Peer: peer1name, Free: 1}} - peers = ring1.ChoosePeersToAskForSpace(start, end) - require.Equal(t, 0, len(peers), "Expected no peers") + assertPeersWithSpace(t, ring1, start, end, 0) ring1.assertInvariants() // We should return others + var peers []router.PeerName + ring1.Entries = []*entry{{Token: start, Peer: peer2name, Free: 1}} - peers = ring1.ChoosePeersToAskForSpace(start, end) - require.Equal(t, 1, len(peers), "Expected one peer") + peers = assertPeersWithSpace(t, ring1, start, end, 1) require.Equal(t, peer2name, peers[0]) ring1.Entries = []*entry{{Token: start, Peer: peer2name, Free: 1}, {Token: middle, Peer: peer3name, Free: 1}} - peers = ring1.ChoosePeersToAskForSpace(start, middle) - require.Equal(t, 1, len(peers), "Expected one peer") + peers = assertPeersWithSpace(t, ring1, start, middle, 1) require.Equal(t, peer2name, peers[0]) - peers = ring1.ChoosePeersToAskForSpace(middle, end) - require.Equal(t, 1, len(peers), "Expected one peer") + peers = assertPeersWithSpace(t, ring1, middle, end, 1) require.Equal(t, peer3name, peers[0]) - peers = ring1.ChoosePeersToAskForSpace(start, end) - require.Equal(t, 2, len(peers), "Expected two peer") + assertPeersWithSpace(t, ring1, start, end, 2) ring1.assertInvariants() } From d4c1766532eef12252e1a308fad90c5331aa5d16 Mon Sep 17 00:00:00 2001 From: Adam Harrison Date: Wed, 24 Jun 2015 16:33:46 +0100 Subject: [PATCH 36/82] Fix smoke tests --- test/150_connect_forget_test.sh | 8 ++++---- test/210_dns_multicast_test.sh | 4 ++-- test/280_with_or_without_dns_test.sh | 2 +- test/500_weave_multi_cidr_test.sh | 2 +- test/620_proxy_entrypoint_command_test.sh | 2 +- test/650_proxy_env_test.sh | 2 +- test/660_proxy_ipam_test.sh | 4 ++-- test/670_proxy_tls_test.sh | 2 +- 8 files changed, 13 insertions(+), 13 deletions(-) diff --git a/test/150_connect_forget_test.sh b/test/150_connect_forget_test.sh index a1ac7df9..8f8da392 100755 --- a/test/150_connect_forget_test.sh +++ b/test/150_connect_forget_test.sh @@ -15,8 +15,8 @@ assert_peers() { start_suite "Connecting and forgetting routers after launch" -weave_on $HOST1 launch -weave_on $HOST2 launch +weave_on $HOST1 launch-router +weave_on $HOST2 launch-router start_container $HOST1 $C1/24 --name=c1 start_container $HOST2 $C2/24 --name=c2 @@ -33,8 +33,8 @@ assert_raises "exec_on $HOST1 c1 $PING $C2" # Forget everyone and disonnect assert_raises "weave_on $HOST2 forget $HOST1 $HOST2" -assert_raises "weave_on $HOST1 stop" -assert_raises "weave_on $HOST1 launch" +assert_raises "weave_on $HOST1 stop-router" +assert_raises "weave_on $HOST1 launch-router" assert_peers $HOST2 "" assert_raises "exec_on $HOST1 c1 sh -c '! $PING $C2'" diff --git a/test/210_dns_multicast_test.sh b/test/210_dns_multicast_test.sh index dbb559bc..fb47f334 100755 --- a/test/210_dns_multicast_test.sh +++ b/test/210_dns_multicast_test.sh @@ -29,8 +29,8 @@ check() { start_suite "Resolve names across hosts (with and without IPAM), and repopulate on restart" -weave_on $HOST1 launch -iprange $UNIVERSE -weave_on $HOST2 launch -iprange $UNIVERSE $HOST1 +weave_on $HOST1 launch-router -iprange $UNIVERSE +weave_on $HOST2 launch-router -iprange $UNIVERSE $HOST1 start_container $HOST2 $C2/24 --name=c2 -h $NAME2 start_container_with_dns $HOST1 $C1/24 --name=c1 diff --git a/test/280_with_or_without_dns_test.sh b/test/280_with_or_without_dns_test.sh index f537b7dd..2a58be95 100755 --- a/test/280_with_or_without_dns_test.sh +++ b/test/280_with_or_without_dns_test.sh @@ -20,7 +20,7 @@ assert_resolution() { start_suite "With or without DNS test" -weave_on $HOST1 launch +weave_on $HOST1 launch-router DNS_IP=$(weave_on $HOST1 docker-bridge-ip) diff --git a/test/500_weave_multi_cidr_test.sh b/test/500_weave_multi_cidr_test.sh index 0bbf6e5d..884d7c74 100755 --- a/test/500_weave_multi_cidr_test.sh +++ b/test/500_weave_multi_cidr_test.sh @@ -73,7 +73,7 @@ start_suite "Weave run/start/attach/detach/expose/hide with multiple cidr argume # specific address, i.e. we are assuming that IPAM always returns the # lowest available address in the subnet -weave_on $HOST1 launch -debug -iprange 10.2.3.0/24 +weave_on $HOST1 launch-router -debug -iprange 10.2.3.0/24 launch_dns_on $HOST1 10.254.254.254/24 # Run container with three cidrs diff --git a/test/620_proxy_entrypoint_command_test.sh b/test/620_proxy_entrypoint_command_test.sh index f2b5f959..20316d32 100755 --- a/test/620_proxy_entrypoint_command_test.sh +++ b/test/620_proxy_entrypoint_command_test.sh @@ -26,7 +26,7 @@ run_container "grep ^1$ /sys/class/net/ethwe/carrier" build_image false '["/bin/false"]' '' run_container "--entrypoint='grep' false ^1$ /sys/class/net/ethwe/carrier" -weave_on $HOST1 launch -iprange 10.2.2.0/24 +weave_on $HOST1 launch-router -iprange 10.2.2.0/24 docker_on $HOST1 kill weaveproxy weave_on $HOST1 launch-proxy diff --git a/test/650_proxy_env_test.sh b/test/650_proxy_env_test.sh index beb8a558..97e33084 100755 --- a/test/650_proxy_env_test.sh +++ b/test/650_proxy_env_test.sh @@ -13,6 +13,6 @@ assert_raises "docker $(weave_on $HOST1 proxy-config) $CMD" # Check we can use the weave script through the proxy assert_raises "eval '$(weave_on $HOST1 proxy-env)' ; $WEAVE version" assert_raises "eval '$(weave_on $HOST1 proxy-env)' ; $WEAVE ps" -assert_raises "eval '$(weave_on $HOST1 proxy-env)' ; $WEAVE launch" +assert_raises "eval '$(weave_on $HOST1 proxy-env)' ; $WEAVE launch-router" end_suite diff --git a/test/660_proxy_ipam_test.sh b/test/660_proxy_ipam_test.sh index 11137995..f0635f83 100755 --- a/test/660_proxy_ipam_test.sh +++ b/test/660_proxy_ipam_test.sh @@ -17,8 +17,8 @@ assert_no_ethwe() { start_suite "Ping proxied containers over cross-host weave network (with IPAM)" -weave_on $HOST1 launch -iprange $UNIVERSE -weave_on $HOST2 launch -iprange $UNIVERSE $HOST1 +weave_on $HOST1 launch-router -iprange $UNIVERSE +weave_on $HOST2 launch-router -iprange $UNIVERSE $HOST1 weave_on $HOST1 launch-proxy weave_on $HOST2 launch-proxy --no-default-ipam diff --git a/test/670_proxy_tls_test.sh b/test/670_proxy_tls_test.sh index 1d284133..69cff352 100755 --- a/test/670_proxy_tls_test.sh +++ b/test/670_proxy_tls_test.sh @@ -6,7 +6,7 @@ start_suite "Boot the proxy with TLS-enabled Docker support" PWD=$($SSH $HOST1 pwd) -weave_on $HOST1 launch +weave_on $HOST1 launch-router weave_on $HOST1 launch-proxy \ --tlsverify \ --tlscacert $PWD/tls/ca.pem \ From 039a2030db09d288c6a96dfa66d6b786c8e615bb Mon Sep 17 00:00:00 2001 From: Matthias Radestock Date: Fri, 26 Jun 2015 04:15:05 +0100 Subject: [PATCH 37/82] refactor: make DF flag passing logic more obvious ...and provide a better abstraction for sending special frames. --- router/connection.go | 31 +++++++++---------------------- router/forwarder.go | 26 +++++++++++++++++--------- router/local_peer.go | 4 ++-- 3 files changed, 28 insertions(+), 33 deletions(-) diff --git a/router/connection.go b/router/connection.go index 3d15c269..eebbce1b 100644 --- a/router/connection.go +++ b/router/connection.go @@ -50,7 +50,7 @@ type LocalConnection struct { SessionKey *[32]byte heartbeatTCP *time.Ticker heartbeatTimeout *time.Timer - heartbeatFrame *ForwardedFrame + heartbeatFrame []byte heartbeat *time.Ticker fragTest *time.Ticker forwarder *Forwarder @@ -156,8 +156,7 @@ func (conn *LocalConnection) setEffectivePMTU(pmtu int) { } // Called by the connection's actor process, and by the connection's -// TCP received process. StackFrag is read in conn.Forward (called by -// router udp listener and sniffer processes) +// TCP receiver process. StackFrag is read in conn.forward func (conn *LocalConnection) setStackFrag(frag bool) { conn.Lock() defer conn.Unlock() @@ -251,15 +250,11 @@ func (conn *LocalConnection) SetEstablished() { } // Send a large frame down the DF channel in order to prompt // PMTU discovery to start. - conn.Forward(true, &ForwardedFrame{ - srcPeer: conn.local, - dstPeer: conn.remote, - frame: PMTUDiscovery}, - nil) + conn.Send(true, PMTUDiscovery) conn.heartbeat = time.NewTicker(SlowHeartbeat) conn.fragTest = time.NewTicker(FragTestInterval) // avoid initial waits for timers to fire - conn.Forward(true, conn.heartbeatFrame, nil) + conn.Send(true, conn.heartbeatFrame) conn.performFragTest() return nil }) @@ -355,12 +350,8 @@ func (conn *LocalConnection) run(actionChan <-chan ConnectionAction, finished ch func (conn *LocalConnection) initHeartbeats() error { conn.heartbeatTCP = time.NewTicker(TCPHeartbeat) conn.heartbeatTimeout = time.NewTimer(HeartbeatTimeout) - heartbeatFrameBytes := make([]byte, EthernetOverhead+8) - binary.BigEndian.PutUint64(heartbeatFrameBytes[EthernetOverhead:], conn.uid) - conn.heartbeatFrame = &ForwardedFrame{ - srcPeer: conn.local, - dstPeer: conn.remote, - frame: heartbeatFrameBytes} + conn.heartbeatFrame = make([]byte, EthernetOverhead+8) + binary.BigEndian.PutUint64(conn.heartbeatFrame[EthernetOverhead:], conn.uid) if conn.remoteUDPAddr == nil { return nil } @@ -377,7 +368,7 @@ func (conn *LocalConnection) actorLoop(actionChan <-chan ConnectionAction) (err case <-conn.heartbeatTimeout.C: err = fmt.Errorf("timed out waiting for UDP heartbeat") case <-tickerChan(conn.heartbeat): - conn.Forward(true, conn.heartbeatFrame, nil) + conn.Send(true, conn.heartbeatFrame) case <-tickerChan(conn.fragTest): conn.performFragTest() } @@ -485,18 +476,14 @@ func (conn *LocalConnection) sendFastHeartbeats() error { err := conn.ensureForwarders() if err == nil { conn.heartbeat = time.NewTicker(FastHeartbeat) - conn.Forward(true, conn.heartbeatFrame, nil) // avoid initial wait + conn.Send(true, conn.heartbeatFrame) // avoid initial wait } return err } func (conn *LocalConnection) performFragTest() { conn.setStackFrag(false) - conn.Forward(false, &ForwardedFrame{ - srcPeer: conn.local, - dstPeer: conn.remote, - frame: FragTest}, - nil) + conn.Send(false, FragTest) } func tickerChan(ticker *time.Ticker) <-chan time.Time { diff --git a/router/forwarder.go b/router/forwarder.go index cab1c0ff..9143c030 100644 --- a/router/forwarder.go +++ b/router/forwarder.go @@ -59,11 +59,23 @@ func (conn *LocalConnection) stopForwarders() { conn.forwarderDF.Shutdown() } -// Called from peer.Relay[Broadcast] which is itself invoked from -// router (both UDP listener process and sniffer process). Also called -// from connection's heartbeat process, and from the connection's TCP -// receiver process. -func (conn *LocalConnection) Forward(df bool, frame *ForwardedFrame, dec *EthernetDecoder) error { +// Called from connection's actor process, and from the connection's +// TCP receiver process. +func (conn *LocalConnection) Send(df bool, frameBytes []byte) error { + frame := &ForwardedFrame{ + srcPeer: conn.local, + dstPeer: conn.remote, + frame: frameBytes} + return conn.forward(frame, nil, df) +} + +// Called from LocalPeer.Relay[Broadcast] which is itself invoked from +// router (both UDP listener process and sniffer process). +func (conn *LocalConnection) Forward(frame *ForwardedFrame, dec *EthernetDecoder) error { + return conn.forward(frame, dec, dec != nil && dec.DF()) +} + +func (conn *LocalConnection) forward(frame *ForwardedFrame, dec *EthernetDecoder, df bool) error { conn.RLock() var ( forwarder = conn.forwarder @@ -78,10 +90,6 @@ func (conn *LocalConnection) Forward(df bool, frame *ForwardedFrame, dec *Ethern return nil } - if dec != nil { - df = dec.DF() - } - // We could use non-blocking channel sends here, i.e. drop frames // on the floor when the forwarder is busy. This would allow our // caller - the capturing loop in the router - to read frames more diff --git a/router/local_peer.go b/router/local_peer.go index 930fbf1b..3463e6ba 100644 --- a/router/local_peer.go +++ b/router/local_peer.go @@ -50,7 +50,7 @@ func (peer *LocalPeer) Relay(srcPeer, dstPeer *Peer, frame []byte, dec *Ethernet log.Println("Unable to find connection to relay peer", relayPeerName) return nil } - return conn.(*LocalConnection).Forward(false, &ForwardedFrame{ + return conn.(*LocalConnection).Forward(&ForwardedFrame{ srcPeer: srcPeer, dstPeer: dstPeer, frame: frame}, @@ -63,7 +63,7 @@ func (peer *LocalPeer) RelayBroadcast(srcPeer *Peer, frame []byte, dec *Ethernet return } for _, conn := range peer.ConnectionsTo(nextHops) { - err := conn.(*LocalConnection).Forward(false, &ForwardedFrame{ + err := conn.(*LocalConnection).Forward(&ForwardedFrame{ srcPeer: srcPeer, dstPeer: conn.Remote(), frame: frame}, From 6488b0d11cd131d5c0f2ce0bc892d425024451d8 Mon Sep 17 00:00:00 2001 From: Bryan Boreham Date: Thu, 25 Jun 2015 16:45:18 +0100 Subject: [PATCH 38/82] More idiomatic exitChan --- ipam/testutils_test.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ipam/testutils_test.go b/ipam/testutils_test.go index 6768a121..2ffac518 100644 --- a/ipam/testutils_test.go +++ b/ipam/testutils_test.go @@ -205,7 +205,7 @@ type gossipMessage struct { sender *router.PeerName buf []byte // for unicast data router.GossipData // for broadcast - exitChan chan bool + exitChan chan struct{} } type TestGossipRouter struct { @@ -225,7 +225,7 @@ func (grouter *TestGossipRouter) GossipBroadcast(update router.GossipData) error func (grouter *TestGossipRouter) removePeer(peer router.PeerName) { gossipChan := grouter.gossipChans[peer] - resultChan := make(chan bool) + resultChan := make(chan struct{}) gossipChan <- gossipMessage{exitChan: resultChan} <-resultChan delete(grouter.gossipChans, peer) @@ -245,7 +245,7 @@ func (grouter *TestGossipRouter) connect(sender router.PeerName, gossiper router select { case message := <-gossipChan: if message.exitChan != nil { - message.exitChan <- true + close(message.exitChan) return } From 959e5f0082b42d9919df40f80c1c6fa89d6499b2 Mon Sep 17 00:00:00 2001 From: Bryan Boreham Date: Thu, 25 Jun 2015 17:04:07 +0100 Subject: [PATCH 39/82] Use different object types for mock gossip messages --- ipam/allocator_test.go | 2 +- ipam/testutils_test.go | 38 ++++++++++++++++++++------------------ 2 files changed, 21 insertions(+), 19 deletions(-) diff --git a/ipam/allocator_test.go b/ipam/allocator_test.go index d32e9174..2aaece78 100644 --- a/ipam/allocator_test.go +++ b/ipam/allocator_test.go @@ -168,7 +168,7 @@ func TestCancel(t *testing.T) { CIDR = "10.0.1.7/26" ) - router := TestGossipRouter{make(map[router.PeerName]chan gossipMessage), 0.0} + router := TestGossipRouter{make(map[router.PeerName]chan interface{}), 0.0} alloc1, subnet := makeAllocator("01:00:00:02:00:00", CIDR, 2) alloc1.SetInterfaces(router.connect(alloc1.ourName, alloc1)) diff --git a/ipam/testutils_test.go b/ipam/testutils_test.go index 2ffac518..fb2af1fd 100644 --- a/ipam/testutils_test.go +++ b/ipam/testutils_test.go @@ -200,23 +200,26 @@ func AssertNothingSentErr(t *testing.T, ch <-chan error) { } // Router to convey gossip from one gossiper to another, for testing -type gossipMessage struct { - isUnicast bool - sender *router.PeerName - buf []byte // for unicast - data router.GossipData // for broadcast - exitChan chan struct{} +type unicastMessage struct { + sender *router.PeerName + buf []byte +} +type broadcastMessage struct { + data router.GossipData +} +type exitMessage struct { + exitChan chan struct{} } type TestGossipRouter struct { - gossipChans map[router.PeerName]chan gossipMessage + gossipChans map[router.PeerName]chan interface{} loss float32 // 0.0 means no loss } func (grouter *TestGossipRouter) GossipBroadcast(update router.GossipData) error { for _, gossipChan := range grouter.gossipChans { select { - case gossipChan <- gossipMessage{data: update}: + case gossipChan <- broadcastMessage{data: update}: default: // drop the message if we cannot send it } } @@ -226,7 +229,7 @@ func (grouter *TestGossipRouter) GossipBroadcast(update router.GossipData) error func (grouter *TestGossipRouter) removePeer(peer router.PeerName) { gossipChan := grouter.gossipChans[peer] resultChan := make(chan struct{}) - gossipChan <- gossipMessage{exitChan: resultChan} + gossipChan <- exitMessage{exitChan: resultChan} <-resultChan delete(grouter.gossipChans, peer) } @@ -237,27 +240,26 @@ type TestGossipRouterClient struct { } func (grouter *TestGossipRouter) connect(sender router.PeerName, gossiper router.Gossiper) router.Gossip { - gossipChan := make(chan gossipMessage, 100) + gossipChan := make(chan interface{}, 100) go func() { gossipTimer := time.Tick(10 * time.Second) for { select { - case message := <-gossipChan: - if message.exitChan != nil { + case gossip := <-gossipChan: + if message, isExit := gossip.(exitMessage); isExit { close(message.exitChan) return } - if rand.Float32() > (1.0 - grouter.loss) { continue } - - if message.isUnicast { + switch message := gossip.(type) { + case unicastMessage: if err := gossiper.OnGossipUnicast(*message.sender, message.buf); err != nil { panic(fmt.Sprintf("Error doing gossip unicast to %s: %s", sender, err)) } - } else { + case broadcastMessage: for _, msg := range message.data.Encode() { if _, err := gossiper.OnGossipBroadcast(msg); err != nil { panic(fmt.Sprintf("Error doing gossip broadcast to %s: %s", sender, err)) @@ -276,7 +278,7 @@ func (grouter *TestGossipRouter) connect(sender router.PeerName, gossiper router func (client TestGossipRouterClient) GossipUnicast(dstPeerName router.PeerName, buf []byte) error { select { - case client.router.gossipChans[dstPeerName] <- gossipMessage{isUnicast: true, sender: &client.sender, buf: buf}: + case client.router.gossipChans[dstPeerName] <- unicastMessage{sender: &client.sender, buf: buf}: default: // drop the message if we cannot send it common.Error.Printf("Dropping message") } @@ -289,7 +291,7 @@ func (client TestGossipRouterClient) GossipBroadcast(update router.GossipData) e func makeNetworkOfAllocators(size int, cidr string) ([]*Allocator, TestGossipRouter, address.Range) { - gossipRouter := TestGossipRouter{make(map[router.PeerName]chan gossipMessage), 0.0} + gossipRouter := TestGossipRouter{make(map[router.PeerName]chan interface{}), 0.0} allocs := make([]*Allocator, size) var subnet address.Range From c659e3448ad551996ff2a235a43f20efea3a2da4 Mon Sep 17 00:00:00 2001 From: Bryan Boreham Date: Thu, 25 Jun 2015 17:38:02 +0100 Subject: [PATCH 40/82] Add a flush() function to the mock gossip router, and call it where required --- ipam/allocator_test.go | 4 ++++ ipam/testutils_test.go | 16 +++++++++++++++- 2 files changed, 19 insertions(+), 1 deletion(-) diff --git a/ipam/allocator_test.go b/ipam/allocator_test.go index 2aaece78..6cc9aae5 100644 --- a/ipam/allocator_test.go +++ b/ipam/allocator_test.go @@ -256,13 +256,17 @@ func TestTransfer(t *testing.T) { wt.AssertTrue(t, err == nil, "Failed to get address") router.GossipBroadcast(alloc2.Gossip()) + router.flush() router.GossipBroadcast(alloc3.Gossip()) + router.flush() router.removePeer(alloc2.ourName) router.removePeer(alloc3.ourName) alloc2.Stop() alloc3.Stop() + router.flush() wt.AssertSuccess(t, alloc1.AdminTakeoverRanges(alloc2.ourName.String())) wt.AssertSuccess(t, alloc1.AdminTakeoverRanges(alloc3.ourName.String())) + router.flush() wt.AssertEquals(t, alloc1.NumFreeAddresses(subnet), address.Offset(1022)) diff --git a/ipam/testutils_test.go b/ipam/testutils_test.go index fb2af1fd..8448c2a2 100644 --- a/ipam/testutils_test.go +++ b/ipam/testutils_test.go @@ -210,6 +210,9 @@ type broadcastMessage struct { type exitMessage struct { exitChan chan struct{} } +type flushMessage struct { + flushChan chan struct{} +} type TestGossipRouter struct { gossipChans map[router.PeerName]chan interface{} @@ -226,6 +229,14 @@ func (grouter *TestGossipRouter) GossipBroadcast(update router.GossipData) error return nil } +func (grouter *TestGossipRouter) flush() { + for _, gossipChan := range grouter.gossipChans { + flushChan := make(chan struct{}) + gossipChan <- flushMessage{flushChan: flushChan} + <-flushChan + } +} + func (grouter *TestGossipRouter) removePeer(peer router.PeerName) { gossipChan := grouter.gossipChans[peer] resultChan := make(chan struct{}) @@ -251,6 +262,9 @@ func (grouter *TestGossipRouter) connect(sender router.PeerName, gossiper router close(message.exitChan) return } + if message, isFlush := gossip.(flushMessage); isFlush { + close(message.flushChan) + } if rand.Float32() > (1.0 - grouter.loss) { continue } @@ -305,7 +319,7 @@ func makeNetworkOfAllocators(size int, cidr string) ([]*Allocator, TestGossipRou } gossipRouter.GossipBroadcast(allocs[size-1].Gossip()) - time.Sleep(1000 * time.Millisecond) + gossipRouter.flush() return allocs, gossipRouter, subnet } From 6725c8355f886e65518e0ef9c2073e05b6bb7ce0 Mon Sep 17 00:00:00 2001 From: Bryan Boreham Date: Thu, 25 Jun 2015 17:41:18 +0100 Subject: [PATCH 41/82] Check the result of Allocate in TestFakeRouterSimple() --- ipam/allocator_test.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ipam/allocator_test.go b/ipam/allocator_test.go index 6cc9aae5..33bed602 100644 --- a/ipam/allocator_test.go +++ b/ipam/allocator_test.go @@ -286,7 +286,8 @@ func TestFakeRouterSimple(t *testing.T) { alloc1 := allocs[0] //alloc2 := allocs[1] - alloc1.Allocate("foo", subnet, nil) + _, err := alloc1.Allocate("foo", subnet, nil) + wt.AssertTrue(t, err == nil, "Failed to get address") } func TestAllocatorFuzz(t *testing.T) { From c84c5dbcdfa4841b7b78519241fa721eb4cdfc89 Mon Sep 17 00:00:00 2001 From: Bryan Boreham Date: Thu, 25 Jun 2015 18:13:43 +0100 Subject: [PATCH 42/82] Make TestGossipRouter goroutine easier to follow --- ipam/testutils_test.go | 64 +++++++++++++++++++++++------------------- 1 file changed, 35 insertions(+), 29 deletions(-) diff --git a/ipam/testutils_test.go b/ipam/testutils_test.go index 8448c2a2..73334e2d 100644 --- a/ipam/testutils_test.go +++ b/ipam/testutils_test.go @@ -201,7 +201,7 @@ func AssertNothingSentErr(t *testing.T, ch <-chan error) { // Router to convey gossip from one gossiper to another, for testing type unicastMessage struct { - sender *router.PeerName + sender router.PeerName buf []byte } type broadcastMessage struct { @@ -250,41 +250,47 @@ type TestGossipRouterClient struct { sender router.PeerName } -func (grouter *TestGossipRouter) connect(sender router.PeerName, gossiper router.Gossiper) router.Gossip { - gossipChan := make(chan interface{}, 100) +func (grouter *TestGossipRouter) run(gossiper router.Gossiper, gossipChan chan interface{}) { + gossipTimer := time.Tick(10 * time.Second) + for { + select { + case gossip := <-gossipChan: + switch message := gossip.(type) { + case exitMessage: + close(message.exitChan) + return - go func() { - gossipTimer := time.Tick(10 * time.Second) - for { - select { - case gossip := <-gossipChan: - if message, isExit := gossip.(exitMessage); isExit { - close(message.exitChan) - return - } - if message, isFlush := gossip.(flushMessage); isFlush { - close(message.flushChan) - } + case flushMessage: + close(message.flushChan) + + case unicastMessage: if rand.Float32() > (1.0 - grouter.loss) { continue } - switch message := gossip.(type) { - case unicastMessage: - if err := gossiper.OnGossipUnicast(*message.sender, message.buf); err != nil { - panic(fmt.Sprintf("Error doing gossip unicast to %s: %s", sender, err)) - } - case broadcastMessage: - for _, msg := range message.data.Encode() { - if _, err := gossiper.OnGossipBroadcast(msg); err != nil { - panic(fmt.Sprintf("Error doing gossip broadcast to %s: %s", sender, err)) - } + if err := gossiper.OnGossipUnicast(message.sender, message.buf); err != nil { + panic(fmt.Sprintf("Error doing gossip unicast to %s: %s", message.sender, err)) + } + + case broadcastMessage: + if rand.Float32() > (1.0 - grouter.loss) { + continue + } + for _, msg := range message.data.Encode() { + if _, err := gossiper.OnGossipBroadcast(msg); err != nil { + panic(fmt.Sprintf("Error doing gossip broadcast: %s", err)) } } - case <-gossipTimer: - grouter.GossipBroadcast(gossiper.Gossip()) } + case <-gossipTimer: + grouter.GossipBroadcast(gossiper.Gossip()) } - }() + } +} + +func (grouter *TestGossipRouter) connect(sender router.PeerName, gossiper router.Gossiper) router.Gossip { + gossipChan := make(chan interface{}, 100) + + go grouter.run(gossiper, gossipChan) grouter.gossipChans[sender] = gossipChan return TestGossipRouterClient{grouter, sender} @@ -292,7 +298,7 @@ func (grouter *TestGossipRouter) connect(sender router.PeerName, gossiper router func (client TestGossipRouterClient) GossipUnicast(dstPeerName router.PeerName, buf []byte) error { select { - case client.router.gossipChans[dstPeerName] <- unicastMessage{sender: &client.sender, buf: buf}: + case client.router.gossipChans[dstPeerName] <- unicastMessage{sender: client.sender, buf: buf}: default: // drop the message if we cannot send it common.Error.Printf("Dropping message") } From c4565f6ed3ae435596d274933a936720d7d4f302 Mon Sep 17 00:00:00 2001 From: Tom Wilkie Date: Fri, 26 Jun 2015 11:43:26 +0000 Subject: [PATCH 43/82] Make proxy listen on /var/run/weave.sock --- prog/weaveproxy/main.go | 22 ++------- proxy/proxy.go | 103 ++++++++++++++++++++++++++++++++++++---- site/proxy.md | 9 ++-- weave | 10 ++-- 4 files changed, 106 insertions(+), 38 deletions(-) diff --git a/prog/weaveproxy/main.go b/prog/weaveproxy/main.go index 76466794..e1d87a7a 100644 --- a/prog/weaveproxy/main.go +++ b/prog/weaveproxy/main.go @@ -11,21 +11,21 @@ import ( ) var ( - version = "(unreleased version)" - defaultListenAddr = "tcp://0.0.0.0:12375" + version = "(unreleased version)" + defaultListenAddrs = []string{"tcp://0.0.0.0:12375", "unix:///var/run/weave.sock"} ) func main() { var ( debug bool justVersion bool - c = proxy.Config{ListenAddr: defaultListenAddr} + c = proxy.Config{ListenAddrs: defaultListenAddrs} ) c.Version = version getopt.BoolVarLong(&debug, "debug", 'd', "log debugging information") getopt.BoolVarLong(&justVersion, "version", 0, "print version and exit") - getopt.StringVar(&c.ListenAddr, 'H', fmt.Sprintf("address on which to listen (default %s)", defaultListenAddr)) + getopt.ListVar(&c.ListenAddrs, 'H', fmt.Sprintf("address on which to listen (default %s)", defaultListenAddrs)) getopt.BoolVarLong(&c.NoDefaultIPAM, "no-default-ipam", 0, "do not automatically allocate addresses for containers without a WEAVE_CIDR") getopt.StringVarLong(&c.TLSConfig.CACert, "tlscacert", 0, "Trust certs signed only by this CA") getopt.StringVarLong(&c.TLSConfig.Cert, "tlscert", 0, "Path to TLS certificate file") @@ -52,22 +52,10 @@ func main() { Info.Println("weave proxy", version) Info.Println("Command line arguments:", strings.Join(os.Args[1:], " ")) - protoAddrParts := strings.SplitN(c.ListenAddr, "://", 2) - if len(protoAddrParts) == 2 { - if protoAddrParts[0] != "tcp" { - Error.Fatalf("Invalid protocol format: %q", protoAddrParts[0]) - } - c.ListenAddr = protoAddrParts[1] - } else { - c.ListenAddr = protoAddrParts[0] - } - p, err := proxy.NewProxy(c) if err != nil { Error.Fatalf("Could not start proxy: %s", err) } - if err := p.ListenAndServe(); err != nil { - Error.Fatalf("Could not listen on %s: %s", p.ListenAddr, err) - } + p.ListenAndServe() } diff --git a/proxy/proxy.go b/proxy/proxy.go index 7191a4a4..a2a756ed 100644 --- a/proxy/proxy.go +++ b/proxy/proxy.go @@ -2,10 +2,13 @@ package proxy import ( "crypto/tls" + "fmt" "net" "net/http" + "os" "regexp" "strings" + "syscall" "github.com/fsouza/go-dockerclient" . "github.com/weaveworks/weave/common" @@ -15,6 +18,8 @@ const ( defaultCaFile = "ca.pem" defaultKeyFile = "key.pem" defaultCertFile = "cert.pem" + dockerSock = "/var/run/docker.sock" + dockerSockUnix = "unix://" + dockerSock ) var ( @@ -24,7 +29,7 @@ var ( ) type Config struct { - ListenAddr string + ListenAddrs []string NoDefaultIPAM bool TLSConfig TLSConfig Version string @@ -45,7 +50,7 @@ func NewProxy(c Config) (*Proxy, error) { Error.Fatalf("Could not configure tls for proxy: %s", err) } - client, err := docker.NewClient("unix:///var/run/docker.sock") + client, err := docker.NewClient(dockerSockUnix) if err != nil { return nil, err } @@ -63,7 +68,7 @@ func NewProxy(c Config) (*Proxy, error) { } func (proxy *Proxy) Dial() (net.Conn, error) { - return net.Dial("unix", "/var/run/docker.sock") + return net.Dial("unix", dockerSock) } func (proxy *Proxy) ServeHTTP(w http.ResponseWriter, r *http.Request) { @@ -83,19 +88,97 @@ func (proxy *Proxy) ServeHTTP(w http.ResponseWriter, r *http.Request) { proxy.Intercept(i, w, r) } -func (proxy *Proxy) ListenAndServe() error { - listener, err := net.Listen("tcp", proxy.ListenAddr) +func (proxy *Proxy) ListenAndServe() { + listeners := []net.Listener{} + addrs := []string{} + for _, addr := range proxy.ListenAddrs { + listener, normalisedAddr, err := proxy.listen(addr) + if err != nil { + Error.Fatalf("Cannot listen on %s: %s", addr, err) + } + listeners = append(listeners, listener) + addrs = append(addrs, normalisedAddr) + } + + for _, addr := range addrs { + Info.Println("proxy listening on", addr) + } + + errs := make(chan error) + for _, listener := range listeners { + go func(listener net.Listener) { + errs <- (&http.Server{Handler: proxy}).Serve(listener) + }(listener) + } + for range listeners { + err := <-errs + if err != nil { + Error.Fatalf("Serve failed: %s", err) + } + } +} + +func copyOwnerAndPermissions(from, to string) error { + stat, err := os.Stat(from) if err != nil { return err } - - if proxy.TLSConfig.enabled() { - listener = tls.NewListener(listener, proxy.TLSConfig.Config) + if err = os.Chmod(to, stat.Mode()); err != nil { + return err } - Info.Println("proxy listening on", proxy.ListenAddr) + moreStat, ok := stat.Sys().(*syscall.Stat_t) + if !ok { + return nil + } - return (&http.Server{Handler: proxy}).Serve(listener) + if err = os.Chown(to, int(moreStat.Uid), int(moreStat.Gid)); err != nil { + return err + } + + return nil +} + +func (proxy *Proxy) listen(protoAndAddr string) (net.Listener, string, error) { + var ( + listener net.Listener + err error + proto, addr string + ) + + if protoAddrParts := strings.SplitN(protoAndAddr, "://", 2); len(protoAddrParts) == 2 { + proto, addr = protoAddrParts[0], protoAddrParts[1] + } else if strings.HasPrefix(protoAndAddr, "/") { + proto, addr = "unix", protoAndAddr + } else { + proto, addr = "tcp", protoAndAddr + } + + switch proto { + case "tcp": + listener, err = net.Listen(proto, addr) + if err != nil { + return nil, "", err + } + if proxy.TLSConfig.enabled() { + listener = tls.NewListener(listener, proxy.TLSConfig.Config) + } + + case "unix": + os.Remove(addr) // remove socket from last invocation + listener, err = net.Listen(proto, addr) + if err != nil { + return nil, "", err + } + if err = copyOwnerAndPermissions(dockerSock, addr); err != nil { + return nil, "", err + } + + default: + Error.Fatalf("Invalid protocol format: %q", proto) + } + + return listener, fmt.Sprintf("%s://%s", proto, addr), nil } func (proxy *Proxy) weaveCIDRsFromConfig(config *docker.Config) ([]string, bool) { diff --git a/site/proxy.md b/site/proxy.md index 0514e30b..3ec5ed76 100644 --- a/site/proxy.md +++ b/site/proxy.md @@ -36,13 +36,14 @@ The first form is more convenient, however you can only pass proxy related configuration arguments to `launch-proxy` so if you need to modify the default behaviour you will have to use the latter. -By default, the proxy listens on port 12375, on all network -interfaces. This can be adjusted with the `-H` argument, e.g. +By default, the proxy listens on /var/run/weave.sock and port 12375, on +all network interfaces. This can be adjusted with the `-H` argument, e.g. host1$ weave launch-proxy -H tcp://127.0.0.1:9999 -If you are working with a remote docker daemon, then any firewalls -inbetween need to be configured to permit access to the proxy port. +Multiple -H arguments can be specified. If you are working with a remote +docker daemon, then any firewalls inbetween need to be configured to permit +access to the proxy port. All docker commands can be run via the proxy, so it is safe to adjust your `DOCKER_HOST` to point at the proxy. Weave provides a convenient diff --git a/weave b/weave index 88609fcc..4326d360 100755 --- a/weave +++ b/weave @@ -58,7 +58,7 @@ usage() { echo "where = [:]" echo " = /" echo " = [ip:] | net: | net:default" - echo " = [tcp://][]:" + echo " = [tcp://][]: | [unix://]/path/to/socket" echo " = or weave internal peer ID" exit 1 } @@ -925,11 +925,7 @@ proxy_args() { proxy_addr() { if addr=$(docker logs $PROXY_CONTAINER_NAME 2>/dev/null | head -n3 | grep -oE "proxy listening on .*"); then - addr=${addr##* } - host=${addr%:*} - [ "$host" = "0.0.0.0" ] && host=$PROXY_HOST - port=${addr#*:} - echo "${1}tcp://${host:-$PROXY_HOST}:${port:-$PROXY_PORT}" + echo "${1}${addr##* }" | sed "s/0.0.0.0/$PROXY_HOST/g" return 0 fi echo "$PROXY_CONTAINER_NAME container is not present. Have you launched it?" >&2 @@ -1035,7 +1031,7 @@ launch_proxy() { proxy_args "$@" PROXY_CONTAINER=$(docker run --privileged -d --name=$PROXY_CONTAINER_NAME --net=host \ $PROXY_VOLUMES \ - -v /var/run/docker.sock:/var/run/docker.sock \ + -v /var/run:/var/run \ -v /proc:/hostproc \ -e PROCFS=/hostproc \ -e WEAVE_CIDR=none \ From 565454d3cb2b48dc5732193509da213419372e4a Mon Sep 17 00:00:00 2001 From: Bryan Boreham Date: Fri, 26 Jun 2015 17:22:35 +0100 Subject: [PATCH 44/82] fixed Logf format specifier --- nameserver/cache_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nameserver/cache_test.go b/nameserver/cache_test.go index 8f230368..8b467488 100644 --- a/nameserver/cache_test.go +++ b/nameserver/cache_test.go @@ -213,7 +213,7 @@ func TestCacheEntries(t *testing.T) { require.True(t, err == errNoLocalReplies, "Get() error with CacheNoLocalReplies") clk.Add(time.Duration(DefaultLocalTTL/2) * time.Second) - t.Logf("Checking that we get an expired response after %f seconds", DefaultLocalTTL) + t.Logf("Checking that we get an expired response after %d seconds", DefaultLocalTTL) clk.Add(time.Second * time.Duration(DefaultLocalTTL+1)) t.Logf("Checking that we get an expired response after %d seconds", DefaultLocalTTL) resp, err = l.Get(questionMsg3, minUDPSize) From 51ecf05091126d9e59575cf685a41b28a8556482 Mon Sep 17 00:00:00 2001 From: Matthias Radestock Date: Sat, 27 Jun 2015 09:35:14 +0100 Subject: [PATCH 45/82] cosmetic: fix typo in comment --- test/150_connect_forget_test.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/150_connect_forget_test.sh b/test/150_connect_forget_test.sh index 8f8da392..984e70e7 100755 --- a/test/150_connect_forget_test.sh +++ b/test/150_connect_forget_test.sh @@ -31,7 +31,7 @@ assert_raises "weave_on $HOST2 connect --replace $HOST1 $HOST2" assert_peers $HOST2 "$HOST1\n$HOST2" assert_raises "exec_on $HOST1 c1 $PING $C2" -# Forget everyone and disonnect +# Forget everyone and disconnect assert_raises "weave_on $HOST2 forget $HOST1 $HOST2" assert_raises "weave_on $HOST1 stop-router" assert_raises "weave_on $HOST1 launch-router" From 1ef3bd3a8b5b47b42f7e2efc9b7233ed81af317d Mon Sep 17 00:00:00 2001 From: Paul Bellamy Date: Wed, 24 Jun 2015 12:23:12 +0100 Subject: [PATCH 46/82] add docker version and weave version to test sanity checks --- test/sanity_check.sh | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/test/sanity_check.sh b/test/sanity_check.sh index a003f570..1ec566bc 100755 --- a/test/sanity_check.sh +++ b/test/sanity_check.sh @@ -9,5 +9,22 @@ run_on $HOST2 $PING $HOST1 run_on $HOST1 $PING $HOST2 whitely echo Check we can reach docker +echo +echo Host Version Info: $HOST1 +echo ===================================== +echo "# docker version" +docker_on $HOST1 version +echo "# docker info" docker_on $HOST1 info +echo "# weave version" +weave_on $HOST1 version + +echo +echo Host Version Info: $HOST2 +echo ===================================== +echo "# docker version" +docker_on $HOST2 version +echo "# docker info" docker_on $HOST2 info +echo "# weave version" +weave_on $HOST2 version From 26cb65c357e0f856f277f37452293fedef681ca8 Mon Sep 17 00:00:00 2001 From: Paul Bellamy Date: Mon, 22 Jun 2015 18:02:09 +0100 Subject: [PATCH 47/82] making test helpers more robust so scope can use them --- test/140_weave_local_test.sh | 8 ++++---- test/config.sh | 24 ++++++++++++++++++++---- test/gce.sh | 2 +- test/run_all.sh | 13 +++++++------ test/setup.sh | 7 ++++--- 5 files changed, 36 insertions(+), 18 deletions(-) diff --git a/test/140_weave_local_test.sh b/test/140_weave_local_test.sh index fce13db2..f3d00d6d 100755 --- a/test/140_weave_local_test.sh +++ b/test/140_weave_local_test.sh @@ -4,15 +4,15 @@ start_suite "Run weave with --local" -run_on $HOST1 sudo ./weave --local reset +run_on $HOST1 sudo weave --local reset -run_on $HOST1 sudo ./weave --local launch -iprange 10.2.5.0/24 +run_on $HOST1 sudo weave --local launch -iprange 10.2.5.0/24 assert_raises "docker_on $HOST1 ps | grep weave" -run_on $HOST1 sudo ./weave --local run 10.2.6.5/24 -ti --name=c1 $SMALL_IMAGE /bin/sh +run_on $HOST1 sudo weave --local run 10.2.6.5/24 -ti --name=c1 $SMALL_IMAGE /bin/sh assert_raises "exec_on $HOST1 c1 $CHECK_ETHWE_UP" -run_on $HOST1 sudo ./weave --local run -ti --name=c2 $SMALL_IMAGE /bin/sh +run_on $HOST1 sudo weave --local run -ti --name=c2 $SMALL_IMAGE /bin/sh assert_raises "exec_on $HOST1 c2 $CHECK_ETHWE_UP" end_suite diff --git a/test/config.sh b/test/config.sh index cd5d32e3..10aa9d01 100644 --- a/test/config.sh +++ b/test/config.sh @@ -2,6 +2,8 @@ set -e +DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" + # Protect against being sourced multiple times to prevent # overwriting assert.sh global state if ! [ -z "$SOURCED_CONFIG_SH" ]; then @@ -25,9 +27,11 @@ fi HOST1=$(echo $HOSTS | cut -f 1 -d ' ') HOST2=$(echo $HOSTS | cut -f 2 -d ' ') -. ./assert.sh +. "$DIR/assert.sh" -SSH=${SSH:-ssh -l vagrant -i ./insecure_private_key -o UserKnownHostsFile=./.ssh_known_hosts -o CheckHostIP=no -o StrictHostKeyChecking=no} + +SSH_DIR=${SSH_DIR:-$DIR} +SSH=${SSH:-ssh -l vagrant -i "$SSH_DIR/insecure_private_key" -o "UserKnownHostsFile=$SSH_DIR/.ssh_known_hosts" -o CheckHostIP=no -o StrictHostKeyChecking=no} SMALL_IMAGE="gliderlabs/alpine" DNS_IMAGE="aanand/docker-dnsutils" @@ -41,6 +45,18 @@ DOCKER_PORT=2375 WEAVEDNS_ARGS="--no-cache" [ -n "$DEBUG" ] && WEAVEDNS_ARGS="$WEAVEDNS_ARGS --debug" + +upload_executable() { + host=$1 + file=$2 + prefix=${3:-/usr/local/bin/} + suffix=$(basename "$file") + target="$prefix$suffix" + [ -z "$DEBUG" ] || greyly echo "Uploading to $host: $file -> $target" >&2 + <"$file" remote $host $SSH $host sh -c "cat | sudo tee $target >/dev/null" + run_on $host "sudo chmod a+x $target" +} + remote() { rem=$1 shift 1 @@ -182,5 +198,5 @@ end_suite() { whitely assert_end } -WEAVE=../weave -DOCKER_NS=./bin/docker-ns +WEAVE=$DIR/../weave +DOCKER_NS=$DIR/../bin/docker-ns diff --git a/test/gce.sh b/test/gce.sh index 3f54a366..02738928 100755 --- a/test/gce.sh +++ b/test/gce.sh @@ -9,7 +9,7 @@ set -ex KEY_FILE=/tmp/gce_private_key.json SSH_KEY_FILE=$HOME/.ssh/gce_ssh_key -PROJECT=positive-cocoa-90213 +PROJECT=${PROJECT:-positive-cocoa-90213} IMAGE=ubuntu-14-04 TEMPLATE_NAME="test-template-2" ZONE=us-central1-a diff --git a/test/run_all.sh b/test/run_all.sh index b0dddbd4..4afd13d5 100755 --- a/test/run_all.sh +++ b/test/run_all.sh @@ -1,9 +1,10 @@ #!/bin/bash -. ./config.sh +DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +. "$DIR/config.sh" whitely echo Sanity checks -if ! bash ./sanity_check.sh; then +if ! bash "$DIR/sanity_check.sh"; then whitely echo ...failed exit 1 fi @@ -27,8 +28,8 @@ trap check_test_status EXIT TESTS="${@:-*_test.sh}" # If running on circle, use the scheduler to work out what tests to run -if [ -n "$CIRCLECI" ]; then - TESTS=$(echo $TESTS | ./sched sched $CIRCLE_BUILD_NUM $CIRCLE_NODE_TOTAL $CIRCLE_NODE_INDEX) +if [ -n "$CIRCLECI" -a -z "$NO_SCHEDULER" ]; then + TESTS=$(echo $TESTS | "$DIR/sched" sched $CIRCLE_BUILD_NUM $CIRCLE_NODE_TOTAL $CIRCLE_NODE_INDEX) fi echo Running $TESTS @@ -39,7 +40,7 @@ for t in $TESTS; do . $t # Report test runtime when running on circle, to help scheduler - if [ -n "$CIRCLECI" ]; then - ./sched time $t $(bc -l <<< "$tests_time/1000000000") + if [ -n "$CIRCLECI" -a -z "$NO_SCHEDULER" ]; then + "$DIR/sched" time $t $(bc -l <<< "$tests_time/1000000000") fi done diff --git a/test/setup.sh b/test/setup.sh index 7235b4a4..e5e9edad 100755 --- a/test/setup.sh +++ b/test/setup.sh @@ -2,6 +2,8 @@ set -e +cd "$(dirname "${BASH_SOURCE[0]}")" + . ./config.sh (cd ./tls && go get ./... && go run generate_certs.go $HOSTS) @@ -11,9 +13,8 @@ echo " prefetch test images" for HOST in $HOSTS; do docker_on $HOST load -i ../weave.tar run_on $HOST mkdir -p bin - cat ../bin/docker-ns | run_on $HOST sh -c "cat > $DOCKER_NS" - cat ../weave | run_on $HOST sh -c "cat > ./weave" - run_on $HOST chmod a+x $DOCKER_NS ./weave + upload_executable $HOST ../bin/docker-ns + upload_executable $HOST ../weave rsync -az -e "$SSH" ./tls/ $HOST:~/tls for IMG in $TEST_IMAGES ; do docker_on $HOST inspect --format=" " $IMG >/dev/null 2>&1 || docker_on $HOST pull $IMG From 322247844968f53871fbfe9e383d6eba136d4850 Mon Sep 17 00:00:00 2001 From: David Wragg Date: Tue, 16 Jun 2015 15:58:39 +0100 Subject: [PATCH 48/82] Remove the LogFrame when fragmenting Subsequent commits make this LogFrame call a little tricky to retain, and it's not clear that it is really needed. --- router/forwarder.go | 1 - 1 file changed, 1 deletion(-) diff --git a/router/forwarder.go b/router/forwarder.go index 9143c030..80367e9b 100644 --- a/router/forwarder.go +++ b/router/forwarder.go @@ -118,7 +118,6 @@ func (conn *LocalConnection) forward(frame *ForwardedFrame, dec *EthernetDecoder forwarderDF.Forward(frame) return nil } - conn.Router.LogFrame("Fragmenting", frame.frame, dec) // We can't trust the stack to fragment, we have IP, and we // have a frame that's too big for the MTU, so we have to // fragment it ourself. From d6fedc1e6e33bf06861481bfebae7c1e9bc43325 Mon Sep 17 00:00:00 2001 From: David Wragg Date: Tue, 23 Jun 2015 14:49:52 +0100 Subject: [PATCH 49/82] Remove error return value from DecodeLayers It is never checked, so add a comment explaining why. --- router/ethernet_decoder.go | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/router/ethernet_decoder.go b/router/ethernet_decoder.go index 036840c8..fc96a14b 100644 --- a/router/ethernet_decoder.go +++ b/router/ethernet_decoder.go @@ -22,8 +22,12 @@ func NewEthernetDecoder() *EthernetDecoder { return dec } -func (dec *EthernetDecoder) DecodeLayers(data []byte) error { - return dec.parser.DecodeLayers(data, &dec.decoded) +func (dec *EthernetDecoder) DecodeLayers(data []byte) { + // We intentionally discard the error return here, because it + // is normal for gopacket to return an error saying that it + // cannot decode a layer beyond the ones we specified when + // setting up the parser. + dec.parser.DecodeLayers(data, &dec.decoded) } func (dec *EthernetDecoder) sendICMPFragNeeded(mtu int, sendFrame func([]byte) error) error { From ab943d938a64ac7525c53dfdaef50d1df5a3a699 Mon Sep 17 00:00:00 2001 From: Matthias Radestock Date: Mon, 29 Jun 2015 12:38:21 +0100 Subject: [PATCH 50/82] refactor: don't return encoder from handshake() We did this for symmetry/completeness, but the encoder is actually "consumed" by handshake() in the creation of the tcp senders, hence it is in fact dangerous to return it. --- router/connection.go | 2 +- router/handshake.go | 26 +++++++++++++------------- 2 files changed, 14 insertions(+), 14 deletions(-) diff --git a/router/connection.go b/router/connection.go index eebbce1b..fc10055b 100644 --- a/router/connection.go +++ b/router/connection.go @@ -279,7 +279,7 @@ func (conn *LocalConnection) run(actionChan <-chan ConnectionAction, finished ch conn.TCPConn.SetLinger(0) - _, dec, err := conn.handshake(acceptNewPeer) + dec, err := conn.handshake(acceptNewPeer) if err != nil { return } diff --git a/router/handshake.go b/router/handshake.go index 25a93690..d90423e7 100644 --- a/router/handshake.go +++ b/router/handshake.go @@ -45,7 +45,7 @@ func (fv *FieldValidator) Err() error { return fv.err } -func (conn *LocalConnection) handshake(acceptNewPeer bool) (*gob.Encoder, *gob.Decoder, error) { +func (conn *LocalConnection) handshake(acceptNewPeer bool) (*gob.Decoder, error) { // We do not need to worry about locking in here as at this point // the connection is not reachable by any go-routine other than // ourself. Only when we add this connection to the conn.local @@ -54,7 +54,7 @@ func (conn *LocalConnection) handshake(acceptNewPeer bool) (*gob.Encoder, *gob.D conn.TCPConn.SetDeadline(time.Now().Add(HeaderTimeout)) version, err := exchangeProtocolHeader(conn.TCPConn, conn.TCPConn) if err != nil { - return nil, nil, err + return nil, err } conn.version = version conn.TCPConn.SetDeadline(time.Time{}) @@ -66,7 +66,7 @@ func (conn *LocalConnection) handshake(acceptNewPeer bool) (*gob.Encoder, *gob.D dec := gob.NewDecoder(conn.TCPConn) fv, private, err := conn.exchangeHandshake(localConnID, usingPassword, enc, dec) if err != nil { - return nil, nil, err + return nil, err } nameStr, _ := fv.Value("Name") @@ -74,39 +74,39 @@ func (conn *LocalConnection) handshake(acceptNewPeer bool) (*gob.Encoder, *gob.D uidStr, _ := fv.Value("UID") remoteConnIDStr, _ := fv.Value("ConnID") if err := fv.Err(); err != nil { - return nil, nil, err + return nil, err } name, err := PeerNameFromString(nameStr) if err != nil { - return nil, nil, err + return nil, err } if !acceptNewPeer { if _, found := conn.Router.Peers.Fetch(name); !found { - return nil, nil, fmt.Errorf("Found unknown remote name: %s at %s", name, conn.remoteTCPAddr) + return nil, fmt.Errorf("Found unknown remote name: %s at %s", name, conn.remoteTCPAddr) } } if existingConn, found := conn.Router.Ourself.ConnectionTo(name); found && existingConn.Established() { - return nil, nil, fmt.Errorf("Already have connection to %s at %s", existingConn.Remote(), existingConn.RemoteTCPAddr()) + return nil, fmt.Errorf("Already have connection to %s at %s", existingConn.Remote(), existingConn.RemoteTCPAddr()) } uid, err := ParsePeerUID(uidStr) if err != nil { - return nil, nil, err + return nil, err } remoteConnID, err := strconv.ParseUint(remoteConnIDStr, 10, 64) if err != nil { - return nil, nil, err + return nil, err } conn.uid = localConnID ^ remoteConnID remotePublicStr, rpErr := fv.Value("PublicKey") if usingPassword { if rpErr != nil { - return nil, nil, rpErr + return nil, rpErr } remotePublicSlice, rpErr := hex.DecodeString(remotePublicStr) if rpErr != nil { - return nil, nil, rpErr + return nil, rpErr } remotePublic := [32]byte{} for idx, elem := range remotePublicSlice { @@ -117,13 +117,13 @@ func (conn *LocalConnection) handshake(acceptNewPeer bool) (*gob.Encoder, *gob.D conn.Decryptor = NewNaClDecryptor(conn.SessionKey, conn.outbound) } else { if rpErr == nil { - return nil, nil, fmt.Errorf("Remote network is encrypted. Password required.") + return nil, fmt.Errorf("Remote network is encrypted. Password required.") } conn.tcpSender = NewSimpleTCPSender(enc) conn.Decryptor = NewNonDecryptor() } - return enc, dec, conn.setRemote(NewPeer(name, nickNameStr, uid, 0)) + return dec, conn.setRemote(NewPeer(name, nickNameStr, uid, 0)) } func (conn *LocalConnection) exchangeHandshake(localConnID uint64, usingPassword bool, enc *gob.Encoder, dec *gob.Decoder) (*FieldValidator, *[32]byte, error) { From 9127eb8acf0f6e49bdfa7589accd0a48536ea2b6 Mon Sep 17 00:00:00 2001 From: Matthias Radestock Date: Mon, 29 Jun 2015 16:56:57 +0100 Subject: [PATCH 51/82] cosmetic: make `weave run` usage fit in 80 columns --- weave | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/weave b/weave index 4326d360..12ac2755 100755 --- a/weave +++ b/weave @@ -35,7 +35,8 @@ usage() { echo " [--no-default-ipam]" echo "weave connect [--replace] [ ...]" echo "weave forget ..." - echo "weave run [--with-dns | --without-dns] [ ...] ..." + echo "weave run [--with-dns | --without-dns] [ ...]" + echo " ..." echo "weave start [ ...] " echo "weave attach [ ...] " echo "weave detach [ ...] " From 864461918fca13e37565fc7e48c41142a717b8d6 Mon Sep 17 00:00:00 2001 From: Michael Bridgen Date: Mon, 29 Jun 2015 15:41:29 +0100 Subject: [PATCH 52/82] Add -initpeercount to usage --- weave | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/weave b/weave index 4326d360..5e6f6f00 100755 --- a/weave +++ b/weave @@ -27,9 +27,11 @@ usage() { echo "Usage:" echo "weave setup" echo "weave launch [-password ] [-nickname ] [-nodiscovery]" - echo " [-iprange [-ipsubnet ]] ..." + echo " [-iprange [-ipsubnet ]]" + echo " [-initpeercount ] ..." echo "weave launch-router [-password ] [-nickname ] [-nodiscovery]" - echo " [-iprange [-ipsubnet ]] ..." + echo " [-iprange [-ipsubnet ]]" + echo " [-initpeercount ] ..." echo "weave launch-dns []" echo "weave launch-proxy [-H ] [--with-dns | --without-dns]" echo " [--no-default-ipam]" From c0b2fe3e3bd44e31c19c05abb8432b527f9c5ee0 Mon Sep 17 00:00:00 2001 From: Michael Bridgen Date: Mon, 29 Jun 2015 19:19:44 +0100 Subject: [PATCH 53/82] Remove references to 'IPAM' in docs and UI The option `--no-default-ipam` is replaced with `--no-default-ipalloc`; the former will still work (in a 'last one wins' way), but its usage message says it's deprecated. --- prog/weaveproxy/main.go | 3 ++- site/proxy.md | 10 +++++----- site/weavedns.md | 8 ++++---- test/600_proxy_docker_py_test.sh | 2 +- test/660_proxy_ipam_test.sh | 2 +- weave | 2 +- 6 files changed, 14 insertions(+), 13 deletions(-) diff --git a/prog/weaveproxy/main.go b/prog/weaveproxy/main.go index e1d87a7a..df1a732f 100644 --- a/prog/weaveproxy/main.go +++ b/prog/weaveproxy/main.go @@ -26,7 +26,8 @@ func main() { getopt.BoolVarLong(&debug, "debug", 'd', "log debugging information") getopt.BoolVarLong(&justVersion, "version", 0, "print version and exit") getopt.ListVar(&c.ListenAddrs, 'H', fmt.Sprintf("address on which to listen (default %s)", defaultListenAddrs)) - getopt.BoolVarLong(&c.NoDefaultIPAM, "no-default-ipam", 0, "do not automatically allocate addresses for containers without a WEAVE_CIDR") + getopt.BoolVarLong(&c.NoDefaultIPAM, "no-default-ipalloc", 0, "do not automatically allocate addresses for containers without a WEAVE_CIDR") + getopt.BoolVarLong(&c.NoDefaultIPAM, "no-default-ipam", 0, "do not automatically allocate addresses for containers without a WEAVE_CIDR (deprecated; please use --no-default-ipalloc") getopt.StringVarLong(&c.TLSConfig.CACert, "tlscacert", 0, "Trust certs signed only by this CA") getopt.StringVarLong(&c.TLSConfig.Cert, "tlscert", 0, "Path to TLS certificate file") getopt.BoolVarLong(&c.TLSConfig.Enabled, "tls", 0, "Use TLS; implied by --tlsverify") diff --git a/site/proxy.md b/site/proxy.md index 3ec5ed76..611a5643 100644 --- a/site/proxy.md +++ b/site/proxy.md @@ -110,10 +110,10 @@ To start a container without connecting it to the weave network, pass host1$ docker run -ti -e WEAVE_CIDR=none ubuntu -If you do not want IPAM to be used by default, the proxy needs to be -passed the `--no-default-ipam` flag, e.g. +If you do not want an IP to be assigned by default, the proxy needs to +be passed the `--no-default-ipalloc` flag, e.g., - host1$ docker launch-proxy --no-default-ipam + host1$ docker launch-proxy --no-default-ipalloc In this configuration, containers with no `WEAVE_CIDR` environment variable will not be connected to the weave network. Containers @@ -121,7 +121,7 @@ started with a `WEAVE_CIDR` environment variable are handled as before. To automatically assign an address in this mode, we start the container with a blank `WEAVE_CIDR`, e.g. - host1$ docker run -ti -e WEAVE_CIDR= ubuntu + host1$ docker run -ti -e WEAVE_CIDR="" ubuntu ## Automatic discovery @@ -186,7 +186,7 @@ containers on the weave network with `weave run`: The arguments after `run` are passed through to `docker run` so you can freely specify whichever docker options are appropriate. Once the container is started, `weave run` attaches it to the weave network, in -this example with an address allocated by IPAM. If you wish you can +this example with an automatically allocated IP. If you wish you can specify addresses manually instead: $ weave run 10.2.1.1/24 -ti ubuntu diff --git a/site/weavedns.md b/site/weavedns.md index c97d80d5..304364dd 100644 --- a/site/weavedns.md +++ b/site/weavedns.md @@ -72,10 +72,10 @@ detection of the weaveDNS container. Each weaveDNS container started with `launch-dns` needs its own unique IP address in a subnet that is common to all weaveDNS containers. In the example above we did not specify such an address, so one was -allocated automatically by IPAM from the default subnet; you can -however specify an address in CIDR format manually. In this case you -are responsible for ensuring that the IP addresses specified are -uniquely allocated and not in use by any other container. +allocated automatically from the default subnet; you can however +specify an address in CIDR format manually. In this case you are +responsible for ensuring that the IP addresses specified are uniquely +allocated and not in use by any other container. Finally, weaveDNS can be stopped independently with diff --git a/test/600_proxy_docker_py_test.sh b/test/600_proxy_docker_py_test.sh index 84d27608..f016572f 100755 --- a/test/600_proxy_docker_py_test.sh +++ b/test/600_proxy_docker_py_test.sh @@ -6,7 +6,7 @@ start_suite "Run docker-py test suite against the proxy" docker_on $HOST1 pull joffrey/docker-py >/dev/null -weave_on $HOST1 launch-proxy --no-default-ipam +weave_on $HOST1 launch-proxy --no-default-ipalloc if docker_on $HOST1 run \ -e NOT_ON_HOST=true \ diff --git a/test/660_proxy_ipam_test.sh b/test/660_proxy_ipam_test.sh index f0635f83..72a4ceed 100755 --- a/test/660_proxy_ipam_test.sh +++ b/test/660_proxy_ipam_test.sh @@ -20,7 +20,7 @@ start_suite "Ping proxied containers over cross-host weave network (with IPAM)" weave_on $HOST1 launch-router -iprange $UNIVERSE weave_on $HOST2 launch-router -iprange $UNIVERSE $HOST1 weave_on $HOST1 launch-proxy -weave_on $HOST2 launch-proxy --no-default-ipam +weave_on $HOST2 launch-proxy --no-default-ipalloc start $HOST1 --name=auto start $HOST1 --name=none -e WEAVE_CIDR=none diff --git a/weave b/weave index 4326d360..a9effdd7 100755 --- a/weave +++ b/weave @@ -32,7 +32,7 @@ usage() { echo " [-iprange [-ipsubnet ]] ..." echo "weave launch-dns []" echo "weave launch-proxy [-H ] [--with-dns | --without-dns]" - echo " [--no-default-ipam]" + echo " [--no-default-ipalloc]" echo "weave connect [--replace] [ ...]" echo "weave forget ..." echo "weave run [--with-dns | --without-dns] [ ...] ..." From 312122e1beac19f754eebb295e4880bf5ef2c837 Mon Sep 17 00:00:00 2001 From: Matthias Radestock Date: Wed, 1 Jul 2015 10:30:12 +0100 Subject: [PATCH 54/82] fix typo --- nameserver/addrs.go | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/nameserver/addrs.go b/nameserver/addrs.go index bb4ac27c..fb3deb66 100644 --- a/nameserver/addrs.go +++ b/nameserver/addrs.go @@ -7,9 +7,11 @@ import ( ) // A zone record -// Note: we will try to keep all the zone records information is concentrated here. Maybe not all queries will -// use things like priorities or weights, but we do not want to create a hierarchy for dealing with all -// possible queries... +// +// Note: all the zone records information is concentrated here. Maybe +// not all queries will use things like priorities or weights, but we +// do not want to create a hierarchy for dealing with all possible +// queries... type ZoneRecord interface { Name() string // The name for this IP IP() net.IP // The IP (v4) address From 6403e7a11cfd10a6fb141477e15cd35eaca2dffc Mon Sep 17 00:00:00 2001 From: Bryan Boreham Date: Wed, 1 Jul 2015 11:13:40 +0100 Subject: [PATCH 55/82] Add missing rule to rebuild netcheck when its source changes --- Makefile | 1 + 1 file changed, 1 insertion(+) diff --git a/Makefile b/Makefile index f69d0969..8559d21b 100644 --- a/Makefile +++ b/Makefile @@ -58,6 +58,7 @@ $(WEAVER_EXE) $(WEAVEDNS_EXE) $(WEAVEPROXY_EXE) $(NETCHECK_EXE): common/*.go com $(WEAVER_EXE): router/*.go ipam/*.go ipam/*/*.go prog/weaver/main.go $(WEAVEDNS_EXE): nameserver/*.go prog/weavedns/main.go $(WEAVEPROXY_EXE): proxy/*.go prog/weaveproxy/main.go +$(NETCHECK_EXE): prog/netcheck/netcheck.go # Sigproxy and weavewait need separate rules as they fail the netgo check in # the main build stanza due to not importing net package From 5b9d35000274c014217c431fbf5d61351187d0e8 Mon Sep 17 00:00:00 2001 From: Adam Harrison Date: Tue, 30 Jun 2015 14:43:37 +0100 Subject: [PATCH 56/82] Draw attention to --hostname precedence --- site/weavedns.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/site/weavedns.md b/site/weavedns.md index 0720ab77..48d57255 100644 --- a/site/weavedns.md +++ b/site/weavedns.md @@ -49,10 +49,10 @@ root@ubuntu:/# ping pingme ... ``` -If both hostname and container name are specified at the same time the -hostname takes precedence; in this circumstance if the hostname is not -in the weaveDNS domain the container will not be registered, but will -still use weaveDNS for resolution. +> **Please note** if both hostname and container name are specified at +> the same time the hostname takes precedence; in this circumstance if +> the hostname is not in the weaveDNS domain the container will *not* be +> registered, but will still use weaveDNS for resolution. It is also possible to force or forbid an application container's use of weaveDNS with the `--with-dns` and `--without-dns` options to From f05225da22b78c4c2980b59b17f0cb783df3f300 Mon Sep 17 00:00:00 2001 From: Bryan Boreham Date: Wed, 1 Jul 2015 11:14:37 +0100 Subject: [PATCH 57/82] Check specific addresses differently to networks For a network, as used by IPAM, we care if *any* address in the range could possibly conflict with an existing address routed by the host. When given a single address, we only care if *that specific address* conflicts with an existing route. --- net/route.go | 17 ++++++++++++++++- prog/netcheck/netcheck.go | 13 +++++++++---- 2 files changed, 25 insertions(+), 5 deletions(-) diff --git a/net/route.go b/net/route.go index 0d8a1bab..5673117f 100644 --- a/net/route.go +++ b/net/route.go @@ -16,7 +16,7 @@ func CheckNetworkFree(subnet *net.IPNet) error { } for _, route := range routes { if route.Dst != nil && overlaps(route.Dst, subnet) { - return fmt.Errorf("network %s would overlap with route %s", subnet, route.Dst) + return fmt.Errorf("Network %s would overlap with existing route %s", subnet, route.Dst) } } return nil @@ -26,3 +26,18 @@ func CheckNetworkFree(subnet *net.IPNet) error { func overlaps(n1, n2 *net.IPNet) bool { return n1.Contains(n2.IP) || n2.Contains(n1.IP) } + +// For a specific address, we only care if it is actually *inside* an +// existing route, because weave-local traffic never hits IP routing. +func CheckAddressOverlap(addr net.IP) error { + routes, err := netlink.RouteList(nil, netlink.FAMILY_V4) + if err != nil { + return err + } + for _, route := range routes { + if route.Dst != nil && route.Dst.Contains(addr) { + return fmt.Errorf("Address %s would overlap with existing route %s", addr, route.Dst) + } + } + return nil +} diff --git a/prog/netcheck/netcheck.go b/prog/netcheck/netcheck.go index 383f5d9b..85f6003b 100644 --- a/prog/netcheck/netcheck.go +++ b/prog/netcheck/netcheck.go @@ -1,4 +1,4 @@ -/* netcheck: check whether a given network overlaps with any existing routes */ +/* netcheck: check whether a given network or address overlaps with any existing routes */ package main import ( @@ -19,12 +19,17 @@ func main() { os.Exit(0) } - ipRangeStr := os.Args[1] - _, ipnet, err := net.ParseCIDR(ipRangeStr) + cidrStr := os.Args[1] + addr, ipnet, err := net.ParseCIDR(cidrStr) if err != nil { fatal(err) } - if err := weavenet.CheckNetworkFree(ipnet); err != nil { + if ipnet.IP.Equal(addr) { + err = weavenet.CheckNetworkFree(ipnet) + } else { + err = weavenet.CheckAddressOverlap(addr) + } + if err != nil { fatal(err) } os.Exit(0) From c9a20ae10c34c3e63edbf333c12d08fa4ea4b99d Mon Sep 17 00:00:00 2001 From: Bryan Boreham Date: Wed, 1 Jul 2015 11:15:31 +0100 Subject: [PATCH 58/82] Warn user if they are trying to use a specific address that clashes with an existing route --- weave | 2 ++ 1 file changed, 2 insertions(+) diff --git a/weave b/weave index 39edfa75..f250ae44 100755 --- a/weave +++ b/weave @@ -858,6 +858,8 @@ ipam_cidrs() { IPAM_CIDRS="$IPAM_CIDRS $CIDR" ALL_CIDRS="$ALL_CIDRS $CIDR" else + # This is a plain IP address; warn if it clashes but carry on + command_exists netcheck && netcheck $1 || true ALL_CIDRS="$ALL_CIDRS $1" fi shift 1 From 91099694c9308ed5a1319587f5f1d9ab27ecf972 Mon Sep 17 00:00:00 2001 From: Bryan Boreham Date: Wed, 1 Jul 2015 11:21:16 +0100 Subject: [PATCH 59/82] Send error message to stderr --- prog/netcheck/netcheck.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/prog/netcheck/netcheck.go b/prog/netcheck/netcheck.go index 85f6003b..96a26ed4 100644 --- a/prog/netcheck/netcheck.go +++ b/prog/netcheck/netcheck.go @@ -10,7 +10,7 @@ import ( ) func fatal(err error) { - fmt.Println(err) + fmt.Fprintln(os.Stderr, err) os.Exit(1) } From c786e7eb5a3a5b07c6a177578e345fd46b22bc54 Mon Sep 17 00:00:00 2001 From: Bryan Boreham Date: Fri, 26 Jun 2015 17:19:07 +0100 Subject: [PATCH 60/82] Switch from basic logger to logrus --- common/logging.go | 68 ++++++++++++++++++++++++++++++++++++---------- nameserver/http.go | 2 +- 2 files changed, 55 insertions(+), 15 deletions(-) diff --git a/common/logging.go b/common/logging.go index 8def1602..11af82f5 100644 --- a/common/logging.go +++ b/common/logging.go @@ -1,24 +1,44 @@ package common import ( + "bytes" + "fmt" "io" "io/ioutil" - "log" "os" + "strings" + + "github.com/Sirupsen/logrus" ) -const ( - standardLogFlags = log.Ldate | log.Ltime | log.Lmicroseconds -) +type textFormatter struct { +} -// Largely taken from -// http://www.goinggo.net/2013/11/using-log-package-in-go.html +// Based off logrus.TextFormatter, which behaves completely +// differently when you don't want colored output +func (f *textFormatter) Format(entry *logrus.Entry) ([]byte, error) { + b := &bytes.Buffer{} + + levelText := strings.ToUpper(entry.Level.String())[0:4] + timeStamp := entry.Time.Format("2006/01/02 15:04:05.000000") + fmt.Fprintf(b, "%s: %s %-44s ", levelText, timeStamp, entry.Message) + for k, v := range entry.Data { + fmt.Fprintf(b, " %s=%v", k, v) + } + + b.WriteByte('\n') + return b.Bytes(), nil +} var ( - Debug *log.Logger - Info *log.Logger - Warning *log.Logger - Error *log.Logger + standardTextFormatter = &textFormatter{} +) + +var ( + Debug *logrus.Logger + Info *logrus.Logger + Warning *logrus.Logger + Error *logrus.Logger debugF bool ) @@ -27,10 +47,30 @@ func InitLogging(debugHandle io.Writer, warningHandle io.Writer, errorHandle io.Writer) { - Debug = log.New(debugHandle, "DEBUG: ", standardLogFlags) - Info = log.New(infoHandle, "INFO: ", standardLogFlags) - Warning = log.New(warningHandle, "WARNING: ", standardLogFlags) - Error = log.New(errorHandle, "ERROR: ", standardLogFlags) + Debug = &logrus.Logger{ + Out: debugHandle, + Formatter: standardTextFormatter, + Hooks: make(logrus.LevelHooks), + Level: logrus.DebugLevel, + } + Info = &logrus.Logger{ + Out: infoHandle, + Formatter: standardTextFormatter, + Hooks: make(logrus.LevelHooks), + Level: logrus.InfoLevel, + } + Warning = &logrus.Logger{ + Out: warningHandle, + Formatter: standardTextFormatter, + Hooks: make(logrus.LevelHooks), + Level: logrus.WarnLevel, + } + Error = &logrus.Logger{ + Out: errorHandle, + Formatter: standardTextFormatter, + Hooks: make(logrus.LevelHooks), + Level: logrus.ErrorLevel, + } } func InitDefaultLogging(debug bool) { diff --git a/nameserver/http.go b/nameserver/http.go index 20753a98..c98276d6 100644 --- a/nameserver/http.go +++ b/nameserver/http.go @@ -2,10 +2,10 @@ package nameserver import ( "fmt" - "log" "net" "net/http" + log "github.com/Sirupsen/logrus" "github.com/gorilla/mux" "github.com/miekg/dns" . "github.com/weaveworks/weave/common" From d82578d8953f4aaf839b8e7468c0aa5ab99027bb Mon Sep 17 00:00:00 2001 From: Bryan Boreham Date: Fri, 26 Jun 2015 18:15:49 +0100 Subject: [PATCH 61/82] Replace logging calls with new style --- common/docker/client.go | 6 ++-- common/errors.go | 4 +-- common/logging.go | 27 +++-------------- common/sched_queue.go | 6 ++-- ipam/allocator.go | 6 ++-- ipam/allocator_test.go | 4 +-- ipam/http.go | 2 +- ipam/http_test.go | 4 +-- ipam/ring/ring.go | 2 +- ipam/ring/ring_test.go | 10 +++---- ipam/testutils_test.go | 2 +- nameserver/cache.go | 12 ++++---- nameserver/http.go | 13 ++++---- nameserver/mdns_lookup.go | 4 +-- nameserver/mdns_server.go | 12 ++++---- nameserver/mdns_server_test.go | 12 ++++---- nameserver/mdns_test.go | 18 +++++------ nameserver/mocks_test.go | 26 ++++++++-------- nameserver/server.go | 28 ++++++++--------- nameserver/server_cache_test.go | 44 +++++++++++++-------------- nameserver/zone.go | 12 ++++---- nameserver/zone_lookup.go | 36 +++++++++++----------- nameserver/zone_lookup_test.go | 42 +++++++++++++------------- prog/weavedns/main.go | 28 ++++++++--------- prog/weaveproxy/main.go | 4 +-- prog/weaver/main.go | 45 +++++++++++++--------------- proxy/common.go | 6 ++-- proxy/proxy.go | 8 ++--- proxy/proxy_intercept.go | 22 +++++++------- proxy/start_container_interceptor.go | 4 +-- 30 files changed, 212 insertions(+), 237 deletions(-) diff --git a/common/docker/client.go b/common/docker/client.go index bb96cf29..e5526a6e 100644 --- a/common/docker/client.go +++ b/common/docker/client.go @@ -44,7 +44,7 @@ func NewClient(apiPath string) (*Client, error) { func (c *Client) AddObserver(ob ContainerObserver) error { events := make(chan *docker.APIEvents) if err := c.AddEventListener(events); err != nil { - Error.Printf("[docker] Unable to add listener to Docker API: %s", err) + Log.Errorf("[docker] Unable to add listener to Docker API: %s", err) return err } @@ -63,7 +63,7 @@ func (c *Client) AddObserver(ob ContainerObserver) error { // IsContainerNotRunning returns true if we have checked with Docker that the ID is not running func (c *Client) IsContainerNotRunning(idStr string) bool { if !IsContainerID(idStr) { - Debug.Printf("[docker] '%s' does not seem to be a container id", idStr) + Log.Debugf("[docker] '%s' does not seem to be a container id", idStr) return false } @@ -75,6 +75,6 @@ func (c *Client) IsContainerNotRunning(idStr string) bool { if _, notThere := err.(*docker.NoSuchContainer); notThere { return true } - Error.Printf("[docker] Could not check container status: %s", err) + Log.Errorf("[docker] Could not check container status: %s", err) return false } diff --git a/common/errors.go b/common/errors.go index a0a9cc96..ea6fed41 100644 --- a/common/errors.go +++ b/common/errors.go @@ -2,13 +2,13 @@ package common func CheckFatal(e error) { if e != nil { - Error.Fatal(e) + Log.Fatal(e) } } func CheckWarn(e error) { if e != nil { - Warning.Println(e) + Log.Warningln(e) } } diff --git a/common/logging.go b/common/logging.go index 11af82f5..cd3deaa5 100644 --- a/common/logging.go +++ b/common/logging.go @@ -35,11 +35,9 @@ var ( ) var ( - Debug *logrus.Logger - Info *logrus.Logger - Warning *logrus.Logger - Error *logrus.Logger - debugF bool + Log *logrus.Logger + Info *logrus.Logger + debugF bool ) func InitLogging(debugHandle io.Writer, @@ -47,30 +45,13 @@ func InitLogging(debugHandle io.Writer, warningHandle io.Writer, errorHandle io.Writer) { - Debug = &logrus.Logger{ - Out: debugHandle, - Formatter: standardTextFormatter, - Hooks: make(logrus.LevelHooks), - Level: logrus.DebugLevel, - } Info = &logrus.Logger{ Out: infoHandle, Formatter: standardTextFormatter, Hooks: make(logrus.LevelHooks), Level: logrus.InfoLevel, } - Warning = &logrus.Logger{ - Out: warningHandle, - Formatter: standardTextFormatter, - Hooks: make(logrus.LevelHooks), - Level: logrus.WarnLevel, - } - Error = &logrus.Logger{ - Out: errorHandle, - Formatter: standardTextFormatter, - Hooks: make(logrus.LevelHooks), - Level: logrus.ErrorLevel, - } + Log = Info } func InitDefaultLogging(debug bool) { diff --git a/common/sched_queue.go b/common/sched_queue.go index 26e7bd49..cbfc9eb3 100644 --- a/common/sched_queue.go +++ b/common/sched_queue.go @@ -76,7 +76,7 @@ func NewSchedQueue(clock clock.Clock) *SchedQueue { // Start starts the scheduled queue func (cq *SchedQueue) Start() { go func() { - defer func() { Debug.Printf("[sched-q] Quitting (%d calls pending)", len(cq.callablesH)) }() + defer func() { Log.Debugf("[sched-q] Quitting (%d calls pending)", len(cq.callablesH)) }() var now time.Time timer := cq.clock.Timer(time.Duration(math.MaxInt64)) @@ -116,14 +116,14 @@ func (cq *SchedQueue) Start() { // Stop stops the scheduled queue func (cq *SchedQueue) Stop() { - Debug.Printf("[sched-q] Stopping...") + Log.Debugf("[sched-q] Stopping...") cq.closeChan <- true } // Add schedules a call. // The callable should not modify the scheduled queue in any way. func (cq *SchedQueue) Add(c callable, t time.Time) { - Debug.Printf("[sched-q] Adding call at %s", t) + Log.Debugf("[sched-q] Adding call at %s", t) ce := schedCall{c: c, t: t} cq.schedChan <- &ce } diff --git a/ipam/allocator.go b/ipam/allocator.go index 98f36f3d..a63ecb5b 100644 --- a/ipam/allocator.go +++ b/ipam/allocator.go @@ -718,11 +718,11 @@ func (alloc *Allocator) findOwner(addr address.Address) string { // Logging func (alloc *Allocator) infof(fmt string, args ...interface{}) { - common.Info.Printf("[allocator %s] "+fmt, append([]interface{}{alloc.ourName}, args...)...) + common.Log.Infof("[allocator %s] "+fmt, append([]interface{}{alloc.ourName}, args...)...) } func (alloc *Allocator) debugln(args ...interface{}) { - common.Debug.Println(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.Debug.Printf("[allocator %s] "+fmt, append([]interface{}{alloc.ourName}, args...)...) + common.Log.Debugf("[allocator %s] "+fmt, append([]interface{}{alloc.ourName}, args...)...) } diff --git a/ipam/allocator_test.go b/ipam/allocator_test.go index b0843f9a..2176f643 100644 --- a/ipam/allocator_test.go +++ b/ipam/allocator_test.go @@ -186,9 +186,9 @@ func TestCancel(t *testing.T) { // Get some IPs, so each allocator has some space res1, _ := alloc1.Allocate("foo", subnet, nil) - common.Debug.Printf("res1 = %s", res1.String()) + common.Log.Debugf("res1 = %s", res1.String()) res2, _ := alloc2.Allocate("bar", subnet, nil) - common.Debug.Printf("res2 = %s", res2.String()) + common.Log.Debugf("res2 = %s", res2.String()) if res1 == res2 { require.FailNow(t, "Error: got same ips!") } diff --git a/ipam/http.go b/ipam/http.go index 8164d8c8..4218744c 100644 --- a/ipam/http.go +++ b/ipam/http.go @@ -13,7 +13,7 @@ import ( func badRequest(w http.ResponseWriter, err error) { http.Error(w, err.Error(), http.StatusBadRequest) - common.Warning.Println("[allocator]:", err.Error()) + common.Log.Warningln("[allocator]:", err.Error()) } // HandleHTTP wires up ipams HTTP endpoints to the provided mux. diff --git a/ipam/http_test.go b/ipam/http_test.go index 63c4dbab..f00ea0b2 100644 --- a/ipam/http_test.go +++ b/ipam/http_test.go @@ -48,13 +48,13 @@ func listenHTTP(alloc *Allocator, subnet address.CIDR) int { httpListener, err := net.Listen("tcp", ":0") if err != nil { - common.Error.Fatal("Unable to create http listener: ", err) + common.Log.Fatal("Unable to create http listener: ", err) } go func() { srv := &http.Server{Handler: router} if err := srv.Serve(httpListener); err != nil { - common.Error.Fatal("Unable to serve http: ", err) + common.Log.Fatal("Unable to serve http: ", err) } }() return httpListener.Addr().(*net.TCPAddr).Port diff --git a/ipam/ring/ring.go b/ipam/ring/ring.go index 127175e8..7a178b05 100644 --- a/ipam/ring/ring.go +++ b/ipam/ring/ring.go @@ -217,7 +217,7 @@ func (r *Ring) Merge(gossip Ring) error { switch { case mine.Version >= theirs.Version: if mine.Version == theirs.Version && !mine.Equal(theirs) { - common.Debug.Printf("Error merging entries at %s - %v != %v\n", mine.Token, mine, theirs) + common.Log.Debugf("Error merging entries at %s - %v != %v\n", mine.Token, mine, theirs) return ErrInvalidEntry } addToResult(*mine) diff --git a/ipam/ring/ring_test.go b/ipam/ring/ring_test.go index 71a228d4..852f060e 100644 --- a/ipam/ring/ring_test.go +++ b/ipam/ring/ring_test.go @@ -608,7 +608,7 @@ func TestFuzzRingHard(t *testing.T) { addPeer := func() { peer, _ := router.PeerNameFromString(fmt.Sprintf("%02d:%02d:00:00:00:00", nextPeerID/10, nextPeerID%10)) - common.Debug.Printf("%s: Adding peer", peer) + common.Log.Debugf("%s: Adding peer", peer) nextPeerID++ peers = append(peers, peer) rings = append(rings, New(start, end, peer)) @@ -658,7 +658,7 @@ func TestFuzzRingHard(t *testing.T) { require.NoError(t, otherRing.Merge(*ring)) } - common.Debug.Printf("%s: transferring from peer %s", otherPeername, peername) + common.Log.Debugf("%s: transferring from peer %s", otherPeername, peername) otherRing.Transfer(peername, peername) // And now tell everyone about the transfer - rmpeer is @@ -687,12 +687,12 @@ func TestFuzzRingHard(t *testing.T) { size := address.Subtract(rangeToSplit.End, rangeToSplit.Start) ipInRange := address.Add(rangeToSplit.Start, address.Offset(rand.Intn(int(size)))) _, peerToGiveTo, _ := randomPeer(-1) - common.Debug.Printf("%s: Granting [%v, %v) to %s", ring.Peer, ipInRange, rangeToSplit.End, peerToGiveTo) + common.Log.Debugf("%s: Granting [%v, %v) to %s", ring.Peer, ipInRange, rangeToSplit.End, peerToGiveTo) ring.GrantRangeToHost(ipInRange, rangeToSplit.End, peerToGiveTo) // Now 'gossip' this to a random host (note, note could be same host as above) otherIndex, _, otherRing := randomPeer(-1) - common.Debug.Printf("%s: 'Gossiping' to %s", ring.Peer, otherRing.Peer) + common.Log.Debugf("%s: 'Gossiping' to %s", ring.Peer, otherRing.Peer) require.NoError(t, otherRing.Merge(*ring)) theRanges[indexWithRanges] = ring.OwnedRanges() @@ -711,7 +711,7 @@ func TestFuzzRingHard(t *testing.T) { } ring1 := ringsWithEntries[rand.Intn(len(ringsWithEntries))] ring2index, _, ring2 := randomPeer(-1) - common.Debug.Printf("%s: 'Gossiping' to %s", ring1.Peer, ring2.Peer) + common.Log.Debugf("%s: 'Gossiping' to %s", ring1.Peer, ring2.Peer) require.NoError(t, ring2.Merge(*ring1)) theRanges[ring2index] = ring2.OwnedRanges() } diff --git a/ipam/testutils_test.go b/ipam/testutils_test.go index 9356e58c..cab3daea 100644 --- a/ipam/testutils_test.go +++ b/ipam/testutils_test.go @@ -295,7 +295,7 @@ func (client TestGossipRouterClient) GossipUnicast(dstPeerName router.PeerName, select { case client.router.gossipChans[dstPeerName] <- unicastMessage{sender: client.sender, buf: buf}: default: // drop the message if we cannot send it - common.Error.Printf("Dropping message") + common.Log.Errorf("Dropping message") } return nil } diff --git a/nameserver/cache.go b/nameserver/cache.go index 4af548c8..fd0be604 100644 --- a/nameserver/cache.go +++ b/nameserver/cache.go @@ -86,7 +86,7 @@ func (e *cacheEntry) getReply(request *dns.Msg, maxLen int, now time.Time) (*dns } if e.ReplyLen >= maxLen { - Debug.Printf("[cache msgid %d] returning truncated reponse: %d > %d", request.MsgHdr.Id, e.ReplyLen, maxLen) + Log.Debugf("[cache msgid %d] returning truncated reponse: %d > %d", request.MsgHdr.Id, e.ReplyLen, maxLen) return makeTruncatedReply(request), nil } @@ -122,7 +122,7 @@ func (e *cacheEntry) setReply(reply *dns.Msg, ttl int, flags uint8, now time.Tim var prevValidUntil time.Time if e.Status == stResolved { if reply != nil { - Debug.Printf("[cache msgid %d] replacing response in cache", reply.MsgHdr.Id) + Log.Debugf("[cache msgid %d] replacing response in cache", reply.MsgHdr.Id) } prevValidUntil = e.validUntil } @@ -147,7 +147,7 @@ func (e *cacheEntry) setReply(reply *dns.Msg, ttl int, flags uint8, now time.Tim } e.validUntil = now.Add(time.Second * time.Duration(minTTL)) } else { - Warning.Printf("[cache] no valid TTL could be calculated") + Log.Warningf("[cache] no valid TTL could be calculated") } e.Status = stResolved @@ -323,7 +323,7 @@ func (c *Cache) Get(request *dns.Msg, maxLen int) (reply *dns.Msg, err error) { if ent, found := c.entries[key]; found { reply, err = ent.getReply(request, maxLen, now) if ent.hasExpired(now) { - Debug.Printf("[cache msgid %d] expired: removing", request.MsgHdr.Id) + Log.Debugf("[cache msgid %d] expired: removing", request.MsgHdr.Id) if ent.index > 0 { heap.Remove(&c.entriesH, ent.index) } @@ -332,7 +332,7 @@ func (c *Cache) Get(request *dns.Msg, maxLen int) (reply *dns.Msg, err error) { } } else { // we are the first asking for this name: create an entry with no reply... the caller must wait - Debug.Printf("[cache msgid %d] addind in pending state", request.MsgHdr.Id) + Log.Debugf("[cache msgid %d] addind in pending state", request.MsgHdr.Id) c.entries[key] = newCacheEntry(&question, now) } return @@ -345,7 +345,7 @@ func (c *Cache) Remove(question *dns.Question) { key := cacheKey(*question) if entry, found := c.entries[key]; found { - Debug.Printf("[cache] removing %s-response for '%s'", dns.TypeToString[question.Qtype], question.Name) + Log.Debugf("[cache] removing %s-response for '%s'", dns.TypeToString[question.Qtype], question.Name) if entry.index > 0 { heap.Remove(&c.entriesH, entry.index) } diff --git a/nameserver/http.go b/nameserver/http.go index c98276d6..3de340bc 100644 --- a/nameserver/http.go +++ b/nameserver/http.go @@ -5,17 +5,16 @@ import ( "net" "net/http" - log "github.com/Sirupsen/logrus" "github.com/gorilla/mux" "github.com/miekg/dns" . "github.com/weaveworks/weave/common" "github.com/weaveworks/weave/common/docker" ) -func httpErrorAndLog(level *log.Logger, w http.ResponseWriter, msg string, +func httpErrorAndLog(w http.ResponseWriter, msg string, status int, logmsg string, logargs ...interface{}) { http.Error(w, msg, status) - level.Printf("[http] "+logmsg, logargs...) + Log.Warningf("[http] "+logmsg, logargs...) } func extractFQDN(r *http.Request) (string, string) { @@ -41,7 +40,7 @@ func ServeHTTP(listener net.Listener, version string, server *DNSServer, dockerC muxRouter.Methods("PUT").Path("/name/{id:.+}/{ip:.+}").HandlerFunc(func(w http.ResponseWriter, r *http.Request) { reqError := func(msg string, logmsg string, logargs ...interface{}) { - httpErrorAndLog(Warning, w, msg, http.StatusBadRequest, logmsg, logargs...) + httpErrorAndLog(w, msg, http.StatusBadRequest, logmsg, logargs...) } vars := mux.Vars(r) @@ -69,7 +68,7 @@ func ServeHTTP(listener net.Listener, version string, server *DNSServer, dockerC if err := server.Zone.AddRecord(idStr, name, ip); err != nil { if _, ok := err.(DuplicateError); !ok { httpErrorAndLog( - Error, w, "Internal error", http.StatusInternalServerError, + w, "Internal error", http.StatusInternalServerError, "Unexpected error from DB: %s", err) return } // oh, I already know this. whatever. @@ -89,7 +88,7 @@ func ServeHTTP(listener net.Listener, version string, server *DNSServer, dockerC ip := net.ParseIP(ipStr) if ip == nil { httpErrorAndLog( - Warning, w, "Invalid IP in request", http.StatusBadRequest, + w, "Invalid IP in request", http.StatusBadRequest, "Invalid IP in request: %s", ipStr) return } @@ -120,6 +119,6 @@ func ServeHTTP(listener net.Listener, version string, server *DNSServer, dockerC http.Handle("/", muxRouter) if err := http.Serve(listener, nil); err != nil { - Error.Fatal("[http] Unable to serve http: ", err) + Log.Fatal("[http] Unable to serve http: ", err) } } diff --git a/nameserver/mdns_lookup.go b/nameserver/mdns_lookup.go index 05619367..db051bb4 100644 --- a/nameserver/mdns_lookup.go +++ b/nameserver/mdns_lookup.go @@ -12,10 +12,10 @@ func mdnsLookup(client *MDNSClient, name string, qtype uint16, insistent bool) ( for resp := range channel { if err := resp.err; err != nil { - Debug.Printf("[mdns] Error for query type %s name %s: %s", dns.TypeToString[qtype], name, err) + Log.Debugf("[mdns] Error for query type %s name %s: %s", dns.TypeToString[qtype], name, err) return nil, err } - Debug.Printf("[mdns] Got response name for %s-query about name '%s': name '%s', addr '%s'", + Log.Debugf("[mdns] Got response name for %s-query about name '%s': name '%s', addr '%s'", dns.TypeToString[qtype], name, resp.name, resp.addr) if !insistent { diff --git a/nameserver/mdns_server.go b/nameserver/mdns_server.go index 4a013a4f..df51f6f8 100644 --- a/nameserver/mdns_server.go +++ b/nameserver/mdns_server.go @@ -113,7 +113,7 @@ func (s *MDNSServer) makeHandler(qtype uint16, lookup LookupFunc) dns.HandlerFun // answer. remoteAddr := rw.RemoteAddr() if s.addrIsLocal(remoteAddr) && !s.allowLocal { - Debug.Printf("[mdns] srv: mDNS query from local host ('%s'): ignored", remoteAddr) + Log.Debugf("[mdns] srv: mDNS query from local host ('%s'): ignored", remoteAddr) return } @@ -121,16 +121,16 @@ func (s *MDNSServer) makeHandler(qtype uint16, lookup LookupFunc) dns.HandlerFun if len(r.Answer) == 0 && len(r.Question) > 0 { q := &r.Question[0] if q.Qtype == qtype { - Debug.Printf("[mdns msgid %d] srv: trying to answer to mDNS query '%s'", r.MsgHdr.Id, q.Name) + Log.Debugf("[mdns msgid %d] srv: trying to answer to mDNS query '%s'", r.MsgHdr.Id, q.Name) if m := lookup(s.zone, r, q); m != nil { - Debug.Printf("[mdns msgid %d] srv: found local answer to mDNS query '%s'", r.MsgHdr.Id, q.Name) + Log.Debugf("[mdns msgid %d] srv: found local answer to mDNS query '%s'", r.MsgHdr.Id, q.Name) if err := s.sendResponse(m); err != nil { - Warning.Printf("[mdns msgid %d] srv: error writing mDNS response to %v", r.MsgHdr.Id, s.sendconn) + Log.Warningf("[mdns msgid %d] srv: error writing mDNS response to %v", r.MsgHdr.Id, s.sendconn) } else { - Debug.Printf("[mdns msgid %d] srv: response sent: %d answers", r.MsgHdr.Id, len(m.Answer)) + Log.Debugf("[mdns msgid %d] srv: response sent: %d answers", r.MsgHdr.Id, len(m.Answer)) } } else { - Debug.Printf("[mdns msgid %d] srv: no local answer for answering mDNS query '%s'", + Log.Debugf("[mdns msgid %d] srv: no local answer for answering mDNS query '%s'", r.MsgHdr.Id, q.Name) } } diff --git a/nameserver/mdns_server_test.go b/nameserver/mdns_server_test.go index ecfd2681..7f94e5de 100644 --- a/nameserver/mdns_server_test.go +++ b/nameserver/mdns_server_test.go @@ -59,11 +59,11 @@ func TestServerSimpleQuery(t *testing.T) { require.NoError(t, err) conn, err := net.ListenUDP("udp4", &net.UDPAddr{IP: net.IPv4zero, Port: 0}) require.NoError(t, err) - Debug.Printf("Sending UDP packet to %s", ipv4Addr) + Log.Debugf("Sending UDP packet to %s", ipv4Addr) _, err = conn.WriteTo(buf, ipv4Addr) require.NoError(t, err) - Debug.Printf("Waiting for response") + Log.Debugf("Waiting for response") for { select { case x := <-recvChan: @@ -80,7 +80,7 @@ func TestServerSimpleQuery(t *testing.T) { return } case <-time.After(100 * time.Millisecond): - Debug.Printf("Timeout while waiting for response") + Log.Debugf("Timeout while waiting for response") return } } @@ -96,7 +96,7 @@ func TestServerSimpleQuery(t *testing.T) { time.Sleep(100 * time.Millisecond) // Allow for server to get going - Debug.Printf("Checking that we get 2 IPs fo name '%s' [A]", testRecord1.Name()) + Log.Debugf("Checking that we get 2 IPs fo name '%s' [A]", testRecord1.Name()) sendQuery(testRecord1.Name(), dns.TypeA) if receivedCount != 2 { t.Fatalf("Unexpected result count %d for %s", receivedCount, testRecord1.Name()) @@ -108,13 +108,13 @@ func TestServerSimpleQuery(t *testing.T) { t.Fatalf("Unexpected result %s for %s", receivedAddrs, testRecord1.Name()) } - Debug.Printf("Checking that 'testfail.weave.' [A] gets no answers") + Log.Debugf("Checking that 'testfail.weave.' [A] gets no answers") sendQuery("testfail.weave.", dns.TypeA) if receivedCount != 0 { t.Fatalf("Unexpected result count %d for testfail.weave", receivedCount) } - Debug.Printf("Checking that '%s' [PTR] gets one name", testInAddr1) + Log.Debugf("Checking that '%s' [PTR] gets one name", testInAddr1) sendQuery(testInAddr1, dns.TypePTR) if receivedCount != 1 { t.Fatalf("Expected an answer to %s, got %d answers", testInAddr1, receivedCount) diff --git a/nameserver/mdns_test.go b/nameserver/mdns_test.go index 4cdae430..867eedec 100644 --- a/nameserver/mdns_test.go +++ b/nameserver/mdns_test.go @@ -37,7 +37,7 @@ func TestClientServerSimpleQuery(t *testing.T) { receivedAddr = nil receivedName = "" receivedCount = 0 - Debug.Printf("Sending query...") + Log.Debugf("Sending query...") switch querytype { case dns.TypeA: r, err := mdnsCli.LookupName(name) @@ -60,7 +60,7 @@ func TestClientServerSimpleQuery(t *testing.T) { time.Sleep(100 * time.Millisecond) // Allow for server to get going - Debug.Printf("Query: %s dns.TypeA", testRecord1.Name()) + Log.Debugf("Query: %s dns.TypeA", testRecord1.Name()) sendQuery(testRecord1.Name(), dns.TypeA) if receivedCount != 1 { t.Fatalf("Unexpected result count %d for %s", receivedCount, testRecord1.Name()) @@ -69,13 +69,13 @@ func TestClientServerSimpleQuery(t *testing.T) { t.Fatalf("Unexpected result %s for %s", receivedAddr, testRecord1.Name()) } - Debug.Printf("Query: testfail.weave. dns.TypeA") + Log.Debugf("Query: testfail.weave. dns.TypeA") sendQuery("testfail.weave.", dns.TypeA) if receivedCount != 0 { t.Fatalf("Unexpected result count %d for testfail.weave", receivedCount) } - Debug.Printf("Query: %s dns.TypePTR", testInAddr1) + Log.Debugf("Query: %s dns.TypePTR", testInAddr1) sendQuery(testInAddr1, dns.TypePTR) if receivedCount != 1 { t.Fatalf("Expected an answer to %s, got %d answers", testInAddr1, receivedCount) @@ -127,7 +127,7 @@ func TestClientServerInsistentQuery(t *testing.T) { receivedAddrs = nil receivedNames = nil receivedCount = 0 - Debug.Printf("Sending query...") + Log.Debugf("Sending query...") switch querytype { case dns.TypeA: receivedAddrs, err = mdnsCli.InsistentLookupName(name) @@ -144,25 +144,25 @@ func TestClientServerInsistentQuery(t *testing.T) { time.Sleep(100 * time.Millisecond) // Allow for server to get going - Debug.Printf("Query: %s dns.TypeA", testRecord1.Name()) + Log.Debugf("Query: %s dns.TypeA", testRecord1.Name()) sendQuery(testRecord1.Name(), dns.TypeA) if receivedCount != 2 { t.Fatalf("Unexpected result count %d for %s", receivedCount, testRecord1.Name()) } - Debug.Printf("Query: testfail.weave. dns.TypeA") + Log.Debugf("Query: testfail.weave. dns.TypeA") sendQuery("testfail.weave.", dns.TypeA) if receivedCount != 0 { t.Fatalf("Unexpected result count %d for testfail.weave", receivedCount) } - Debug.Printf("Query: %s dns.TypePTR", testInAddr1) + Log.Debugf("Query: %s dns.TypePTR", testInAddr1) sendQuery(testInAddr1, dns.TypePTR) if receivedCount != 1 { t.Fatalf("Expected an answer to %s, got %d answers", testInAddr1, receivedCount) } - Debug.Printf("Query: %s dns.TypePTR", testInAddr2) + Log.Debugf("Query: %s dns.TypePTR", testInAddr2) sendQuery(testInAddr2, dns.TypePTR) if receivedCount != 1 { t.Fatalf("Expected an answer to %s, got %d answers", testInAddr2, receivedCount) diff --git a/nameserver/mocks_test.go b/nameserver/mocks_test.go index 397dbc02..58bb5e04 100644 --- a/nameserver/mocks_test.go +++ b/nameserver/mocks_test.go @@ -19,7 +19,7 @@ const ( ) // Warn about some methods that some day should be implemented... -func notImplWarn() { Warning.Printf("Mocked method. Not implemented.") } +func notImplWarn() { Log.Warningf("Mocked method. Not implemented.") } // A mocked Zone that always returns the same records // * it does not send/receive any mDNS query @@ -38,7 +38,7 @@ func newMockedZoneWithRecords(zr []ZoneRecord) *mockedZoneWithRecords { } func (mz *mockedZoneWithRecords) Domain() string { return DefaultLocalDomain } func (mz *mockedZoneWithRecords) LookupName(name string) ([]ZoneRecord, error) { - Debug.Printf("[mocked zone]: LookupName: returning records %s", mz.records) + Log.Debugf("[mocked zone]: LookupName: returning records %s", mz.records) mz.Lock() defer mz.Unlock() @@ -53,7 +53,7 @@ func (mz *mockedZoneWithRecords) LookupName(name string) ([]ZoneRecord, error) { } func (mz *mockedZoneWithRecords) LookupInaddr(inaddr string) ([]ZoneRecord, error) { - Debug.Printf("[mocked zone]: LookupInaddr: returning records %s", mz.records) + Log.Debugf("[mocked zone]: LookupInaddr: returning records %s", mz.records) mz.Lock() defer mz.Unlock() @@ -243,17 +243,17 @@ func newZoneDbsWithMockedMDns(num int, config ZoneConfig) zoneDbsWithMockedMDns for i := 0; i < num; i++ { res[i] = new(zbmEntry) - Debug.Printf("[test] Creating mocked mDNS server #%d", i) + Log.Debugf("[test] Creating mocked mDNS server #%d", i) res[i].Server = newMockedMDNSServer(nil) - Debug.Printf("[test] Creating mocked mDNS client #%d", i) + Log.Debugf("[test] Creating mocked mDNS client #%d", i) res[i].Client = newMockedMDNSClient([]*mockedMDNSServer{}) cfg := config cfg.MDNSClient = res[i].Client cfg.MDNSServer = res[i].Server - Debug.Printf("[test] Creating ZoneDb #%d", i) + Log.Debugf("[test] Creating ZoneDb #%d", i) res[i].Zone, _ = NewZoneDb(cfg) // link the mDNS server to its zone @@ -270,7 +270,7 @@ func newZoneDbsWithMockedMDns(num int, config ZoneConfig) zoneDbsWithMockedMDns // this is not what we currently do, but can be convenient in some cases // for finding some bugs... if i != j { - Debug.Printf("[test] Linking mocked mDNS client #%d to server #%d", i, j) + Log.Debugf("[test] Linking mocked mDNS client #%d to server #%d", i, j) res[i].Client.AddServer(res[j].Server) } } @@ -389,7 +389,7 @@ func (mf *mockedFallback) Stop() error { // Run a UDP fallback server func runLocalUDPServer(laddr string, handler dns.HandlerFunc) (*dns.Server, string, error) { - Debug.Printf("[mocked fallback] Starting fallback UDP server at %s", laddr) + Log.Debugf("[mocked fallback] Starting fallback UDP server at %s", laddr) pc, err := net.ListenPacket("udp", laddr) if err != nil { return nil, "", err @@ -401,13 +401,13 @@ func runLocalUDPServer(laddr string, handler dns.HandlerFunc) (*dns.Server, stri pc.Close() }() - Debug.Printf("[mocked fallback] Fallback UDP server listening at %s", pc.LocalAddr()) + Log.Debugf("[mocked fallback] Fallback UDP server listening at %s", pc.LocalAddr()) return server, pc.LocalAddr().String(), nil } // Run a TCP fallback server func runLocalTCPServer(laddr string, handler dns.HandlerFunc) (*dns.Server, string, error) { - Debug.Printf("[mocked fallback] Starting fallback TCP server at %s", laddr) + Log.Debugf("[mocked fallback] Starting fallback TCP server at %s", laddr) laddrTCP, err := net.ResolveTCPAddr("tcp", laddr) if err != nil { return nil, "", err @@ -424,7 +424,7 @@ func runLocalTCPServer(laddr string, handler dns.HandlerFunc) (*dns.Server, stri l.Close() }() - Debug.Printf("[mocked fallback] Fallback TCP server listening at %s", l.Addr().String()) + Log.Debugf("[mocked fallback] Fallback TCP server listening at %s", l.Addr().String()) return server, l.Addr().String(), nil } @@ -442,9 +442,9 @@ func newMockedClock() *mockedClock { // be waiting in channels. So your code should not depend on the channels // for creating new timers. Otherwise, time travelling will not be reliable... func (clk *mockedClock) Forward(secs int) { - Debug.Printf(">>>>>>> Moving clock forward %d seconds - Time traveling >>>>>>>", secs) + Log.Debugf(">>>>>>> Moving clock forward %d seconds - Time traveling >>>>>>>", secs) clk.Add(time.Duration(secs) * time.Second) - Debug.Printf("<<<<<<< Time travel finished! We are at %s <<<<<<<", clk.Now()) + Log.Debugf("<<<<<<< Time travel finished! We are at %s <<<<<<<", clk.Now()) } ////////////////////////////////////////////////////////////////// diff --git a/nameserver/server.go b/nameserver/server.go index a7b84bc7..a8955138 100644 --- a/nameserver/server.go +++ b/nameserver/server.go @@ -74,7 +74,7 @@ func (proto dnsProtocol) String() string { // get a new dns.Client for a protocol func (proto dnsProtocol) GetNewClient(bufsize int, timeout time.Duration) *dns.Client { - Debug.Printf("[dns] Creating %s DNS client with %s timeout", proto, timeout) + Log.Debugf("[dns] Creating %s DNS client with %s timeout", proto, timeout) switch proto { case protTCP: return &dns.Client{Net: "tcp", ReadTimeout: timeout} @@ -228,7 +228,7 @@ func (s *DNSServer) ActivateAndServe() { Info.Printf("[dns] Listening for DNS on %s (UDP)", s.ListenAddr) err := s.udpSrv.ActivateAndServe() CheckFatal(err) - Debug.Printf("[dns] DNS UDP server exiting...") + Log.Debugf("[dns] DNS UDP server exiting...") }() go func() { @@ -237,7 +237,7 @@ func (s *DNSServer) ActivateAndServe() { Info.Printf("[dns] Listening for DNS on %s (TCP)", s.ListenAddr) err := s.tcpSrv.ActivateAndServe() CheckFatal(err) - Debug.Printf("[dns] DNS TCP server exiting...") + Log.Debugf("[dns] DNS TCP server exiting...") }() // Waiting for all goroutines to finish (otherwise they die as main routine dies) @@ -305,7 +305,7 @@ func (s *DNSServer) localHandler(proto dnsProtocol, kind string, qtype uint16, return func(w dns.ResponseWriter, r *dns.Msg) { q := r.Question[0] - Debug.Printf("[dns msgid %d] %s: %+v", r.MsgHdr.Id, kind, q) + Log.Debugf("[dns msgid %d] %s: %+v", r.MsgHdr.Id, kind, q) maxLen := getMaxReplyLen(r, proto) // cache a response if the cache is enabled, and observe the name/IP @@ -324,17 +324,17 @@ func (s *DNSServer) localHandler(proto dnsProtocol, kind string, qtype uint16, reply, err := s.cache.Get(r, maxLen) if err != nil { if err == errNoLocalReplies { - Debug.Printf("[dns msgid %d] Cached no-local-replies", r.MsgHdr.Id) + Log.Debugf("[dns msgid %d] Cached no-local-replies", r.MsgHdr.Id) fallback(w, r) } else { - Debug.Printf("[dns msgid %d] Error from cache: %s", r.MsgHdr.Id, err) + Log.Debugf("[dns msgid %d] Error from cache: %s", r.MsgHdr.Id, err) w.WriteMsg(makeDNSFailResponse(r)) } return } if reply != nil { reply.Answer = pruneAnswers(shuffleAnswers(reply.Answer), s.maxAnswers) - Debug.Printf("[dns msgid %d] Returning reply from cache: %s/%d answers", + Log.Debugf("[dns msgid %d] Returning reply from cache: %s/%d answers", r.MsgHdr.Id, dns.RcodeToString[reply.MsgHdr.Rcode], len(reply.Answer)) w.WriteMsg(reply) return @@ -343,7 +343,7 @@ func (s *DNSServer) localHandler(proto dnsProtocol, kind string, qtype uint16, // catch unsupported queries if q.Qtype != qtype { - Debug.Printf("[dns msgid %d] Unsupported query type %s", r.MsgHdr.Id, dns.TypeToString[q.Qtype]) + Log.Debugf("[dns msgid %d] Unsupported query type %s", r.MsgHdr.Id, dns.TypeToString[q.Qtype]) m := makeDNSFailResponse(r) maybeCache(m, s.negLocalTTL, 0) w.WriteMsg(m) @@ -360,7 +360,7 @@ func (s *DNSServer) localHandler(proto dnsProtocol, kind string, qtype uint16, m.Authoritative = true maybeCache(m, nullTTL, 0) m.Answer = pruneAnswers(shuffleAnswers(m.Answer), s.maxAnswers) - Debug.Printf("[dns msgid %d] Sending response: %s/%d answers [code:%s]", + Log.Debugf("[dns msgid %d] Sending response: %s/%d answers [code:%s]", m.MsgHdr.Id, dns.TypeToString[q.Qtype], len(m.Answer), dns.RcodeToString[m.Rcode]) w.WriteMsg(m) } @@ -380,25 +380,25 @@ func (s *DNSServer) notUsHandler(proto dnsProtocol) dns.HandlerFunc { rcopy := r rcopy.SetEdns0(uint16(maxLen), false) - Debug.Printf("[dns msgid %d] Fallback query: %+v [%s, max:%d bytes]", rcopy.MsgHdr.Id, q, proto, maxLen) + Log.Debugf("[dns msgid %d] Fallback query: %+v [%s, max:%d bytes]", rcopy.MsgHdr.Id, q, proto, maxLen) for _, server := range s.Upstream.Servers { reply, _, err := dnsClient.Exchange(rcopy, fmt.Sprintf("%s:%s", server, s.Upstream.Port)) if err != nil { - Debug.Printf("[dns msgid %d] Network error trying %s (%s)", + Log.Debugf("[dns msgid %d] Network error trying %s (%s)", r.MsgHdr.Id, server, err) continue } if reply != nil && reply.Rcode != dns.RcodeSuccess { - Debug.Printf("[dns msgid %d] Failure reported by %s for query %s", + Log.Debugf("[dns msgid %d] Failure reported by %s for query %s", r.MsgHdr.Id, server, q.Name) continue } - Debug.Printf("[dns msgid %d] Given answer by %s for query %s", + Log.Debugf("[dns msgid %d] Given answer by %s for query %s", r.MsgHdr.Id, server, q.Name) w.WriteMsg(reply) return } - Warning.Printf("[dns msgid %d] Failed lookup for external name %s", r.MsgHdr.Id, q.Name) + Log.Warningf("[dns msgid %d] Failed lookup for external name %s", r.MsgHdr.Id, q.Name) w.WriteMsg(makeDNSFailResponse(r)) } } diff --git a/nameserver/server_cache_test.go b/nameserver/server_cache_test.go index 31200d72..8b0d8651 100644 --- a/nameserver/server_cache_test.go +++ b/nameserver/server_cache_test.go @@ -24,11 +24,11 @@ func TestServerDbCacheInvalidation(t *testing.T) { clk := newMockedClock() - Debug.Printf("Creating mocked mDNS client and server") + Log.Debugf("Creating mocked mDNS client and server") mdnsServer1 := newMockedMDNSServerWithRecord(Record{testName1, net.ParseIP("10.2.2.9"), 0, 0, 0}) mdnsCli1 := newMockedMDNSClient([]*mockedMDNSServer{mdnsServer1}) - Debug.Printf("Creating zone database with the mocked mDNS client and server") + Log.Debugf("Creating zone database with the mocked mDNS client and server") zoneConfig := ZoneConfig{ MDNSServer: mdnsServer1, MDNSClient: mdnsCli1, @@ -40,7 +40,7 @@ func TestServerDbCacheInvalidation(t *testing.T) { require.NoError(t, err) defer zone.Stop() - Debug.Printf("Creating a cache") + Log.Debugf("Creating a cache") cache, err := NewCache(1024, clk) require.NoError(t, err) @@ -59,7 +59,7 @@ func TestServerDbCacheInvalidation(t *testing.T) { fallback.Start() defer fallback.Stop() - Debug.Printf("Creating a real DNS server with a mocked cache") + Log.Debugf("Creating a real DNS server with a mocked cache") srv, err := NewDNSServer(DNSServerConfig{ Zone: zone, Cache: cache, @@ -79,7 +79,7 @@ func TestServerDbCacheInvalidation(t *testing.T) { require.NoError(t, err) require.NotEqual(t, 0, testPort, "invalid listen port") - Debug.Printf("Adding two IPs to %s", testName1) + Log.Debugf("Adding two IPs to %s", testName1) zone.AddRecord(containerID, testName1, net.ParseIP("10.2.2.1")) zone.AddRecord(containerID, testName1, net.ParseIP("10.2.2.2")) q, _ := assertExchange(t, testName1, dns.TypeA, testPort, 2, 2, 0) @@ -93,7 +93,7 @@ func TestServerDbCacheInvalidation(t *testing.T) { // we should have an entry in the cache for this query // if we add another IP, that cache entry should be removed - Debug.Printf("Adding a new IP to %s: the cache entry should be removed", testName1) + Log.Debugf("Adding a new IP to %s: the cache entry should be removed", testName1) zone.AddRecord(containerID, testName1, net.ParseIP("10.2.2.3")) assertNotInCache(t, cache, q, fmt.Sprintf("after adding a new IP for %s", testName1)) @@ -101,10 +101,10 @@ func TestServerDbCacheInvalidation(t *testing.T) { // first.weave.local = 10.2.2.1 10.2.2.2 10.2.2.3 // second.weave.local = 10.9.9.1 - Debug.Printf("Querying again (so a cache entry will be created)") + Log.Debugf("Querying again (so a cache entry will be created)") q, _ = assertExchange(t, testName1, dns.TypeA, testPort, 3, 4, 0) assertInCache(t, cache, q, "after asking about the name") - Debug.Printf("... and removing one of the IP addresses") + Log.Debugf("... and removing one of the IP addresses") zone.DeleteRecords(containerID, "", net.ParseIP("10.2.2.2")) assertNotInCache(t, cache, q, "after deleting IP for 10.2.2.2") @@ -113,7 +113,7 @@ func TestServerDbCacheInvalidation(t *testing.T) { // second.weave.local = 10.9.9.1 // generate cache responses - Debug.Printf("Querying for a raddr") + Log.Debugf("Querying for a raddr") qname, _ := assertExchange(t, testName1, dns.TypeA, testPort, 2, 2, 0) qptr, _ := assertExchange(t, "1.2.2.10.in-addr.arpa.", dns.TypePTR, testPort, 1, 1, 0) qotherName, _ := assertExchange(t, testName2, dns.TypeA, testPort, 1, 1, 0) @@ -126,7 +126,7 @@ func TestServerDbCacheInvalidation(t *testing.T) { assertNotLocalInCache(t, cache, qwrongName, "after asking for a wrong name") // now we will check if a removal affects all the responses - Debug.Printf("... and removing an IP should invalidate both the cached responses for name and raddr") + Log.Debugf("... and removing an IP should invalidate both the cached responses for name and raddr") zone.DeleteRecords(containerID, "", net.ParseIP("10.2.2.1")) assertNotInCache(t, cache, qptr, "after deleting record") assertNotInCache(t, cache, qname, "after deleting record") @@ -137,7 +137,7 @@ func TestServerDbCacheInvalidation(t *testing.T) { // second.weave.local = 10.9.9.1 // generate cache responses - Debug.Printf("Querying for a raddr") + Log.Debugf("Querying for a raddr") qptr, _ = assertExchange(t, "3.2.2.10.in-addr.arpa.", dns.TypePTR, testPort, 1, 1, 0) qname, _ = assertExchange(t, testName1, dns.TypeA, testPort, 1, 1, 0) qotherName, _ = assertExchange(t, testName2, dns.TypeA, testPort, 1, 1, 0) @@ -148,7 +148,7 @@ func TestServerDbCacheInvalidation(t *testing.T) { assertInCache(t, cache, qotherPtr, "after asking for second address") // let's repeat this, but adding an IP - Debug.Printf("... and adding a new IP should invalidate both the cached responses for the name") + Log.Debugf("... and adding a new IP should invalidate both the cached responses for the name") zone.AddRecord(containerID, testName1, net.ParseIP("10.2.2.7")) assertNotInCache(t, cache, qname, "after adding a new IP") assertInCache(t, cache, qotherName, "after adding a new IP") @@ -182,7 +182,7 @@ func TestServerCacheExpiration(t *testing.T) { clk := newMockedClock() - Debug.Printf("Creating 2 zone databases") + Log.Debugf("Creating 2 zone databases") zoneConfig := ZoneConfig{ RefreshInterval: 0, // no name updates Clock: clk, @@ -191,11 +191,11 @@ func TestServerCacheExpiration(t *testing.T) { dbs.Start() defer dbs.Stop() - Debug.Printf("Creating a cache") + Log.Debugf("Creating a cache") cache, err := NewCache(1024, clk) require.NoError(t, err) - Debug.Printf("Creating a real DNS server for the first zone database and with the cache") + Log.Debugf("Creating a real DNS server for the first zone database and with the cache") srv, err := NewDNSServer(DNSServerConfig{ Zone: dbs[0].Zone, Cache: cache, @@ -225,7 +225,7 @@ func TestServerCacheExpiration(t *testing.T) { assertNotInCache(t, cache, qName1, fmt.Sprintf("after asking for %s", testName1)) // We add the IP in the second peer right after - Debug.Printf("Adding an IPs to %s in database #2", testName1) + Log.Debugf("Adding an IPs to %s in database #2", testName1) dbs[1].Zone.AddRecord(containerID, testName1, net.ParseIP("10.2.2.1")) t.Logf("Zone database #2:\n%s", dbs[1].Zone) @@ -241,7 +241,7 @@ func TestServerCacheExpiration(t *testing.T) { assertNotInCache(t, cache, qName1, fmt.Sprintf("after asking for %s", testName1)) // We delete the IP in the second peer right after - Debug.Printf("Removing the IPs from %s in database #2", testName1) + Log.Debugf("Removing the IPs from %s in database #2", testName1) dbs[1].Zone.DeleteRecords(containerID, "", net.ParseIP("10.2.2.1")) // Check that we return to the initial state: a neg-local entry in the cache @@ -269,7 +269,7 @@ func TestServerCacheRefresh(t *testing.T) { Info.Println("TestServerCacheRefresh starting") clk := newMockedClock() - Debug.Printf("Creating 2 zone databases") + Log.Debugf("Creating 2 zone databases") zoneConfig := ZoneConfig{ RefreshInterval: refreshInterval, Clock: clk, @@ -278,11 +278,11 @@ func TestServerCacheRefresh(t *testing.T) { dbs.Start() defer dbs.Stop() - Debug.Printf("Creating a cache") + Log.Debugf("Creating a cache") cache, err := NewCache(1024, clk) require.NoError(t, err) - Debug.Printf("Creating a real DNS server for the first zone database and with the cache") + Log.Debugf("Creating a real DNS server for the first zone database and with the cache") srv, err := NewDNSServer(DNSServerConfig{ Zone: dbs[0].Zone, Cache: cache, @@ -301,7 +301,7 @@ func TestServerCacheRefresh(t *testing.T) { require.NoError(t, err) require.NotEqual(t, 0, testPort, "listen port") - Debug.Printf("Adding an IPs to %s", testName1) + Log.Debugf("Adding an IPs to %s", testName1) dbs[1].Zone.AddRecord(containerID, testName1, net.ParseIP("10.2.2.1")) dbs.Flush() // ensure the immediate refresh is done @@ -317,7 +317,7 @@ func TestServerCacheRefresh(t *testing.T) { clk.Forward(refreshInterval / 2) dbs.Flush() - Debug.Printf("Adding an IP to %s and to %s", testName1, testName2) + Log.Debugf("Adding an IP to %s and to %s", testName1, testName2) dbs[1].Zone.AddRecord(containerID, testName1, net.ParseIP("10.2.2.2")) dbs[1].Zone.AddRecord(containerID, testName2, net.ParseIP("10.9.9.2")) diff --git a/nameserver/zone.go b/nameserver/zone.go index fc75e612..98fc76a0 100644 --- a/nameserver/zone.go +++ b/nameserver/zone.go @@ -111,7 +111,7 @@ func (re *recordEntry) addIPObserver(zro ZoneRecordObserver) { func (re *recordEntry) notifyIPObservers() { numObservers := len(re.observers) if numObservers > 0 { - Debug.Printf("[zonedb] Notifying %d observers of '%s'", numObservers, re.ip) + Log.Debugf("[zonedb] Notifying %d observers of '%s'", numObservers, re.ip) for _, observer := range re.observers { observer() } @@ -257,7 +257,7 @@ func (n *name) addNameObserver(observer ZoneRecordObserver) { func (n *name) notifyNameObservers() { numObservers := len(n.observers) if numObservers > 0 { - Debug.Printf("[zonedb] Notifying %d observers of '%s'", numObservers, n.name) + Log.Debugf("[zonedb] Notifying %d observers of '%s'", numObservers, n.name) for _, observer := range n.observers { observer() } @@ -373,7 +373,7 @@ func (ns *nameSet) getNameLastAccess(n string) time.Time { // The access time is saved only for locally-introduced records (otherwise it could // be lost when names are irrelevant...) func (ns *nameSet) touchName(name string, now time.Time) { - Debug.Printf("[zonedb] Touching name %s", name) + Log.Debugf("[zonedb] Touching name %s", name) n := ns.getName(name, false) if n != nil { n.lastAccessTime = now @@ -527,11 +527,11 @@ func (zone *ZoneDb) Start() (err error) { // Perform a graceful shutdown of the zone database func (zone *ZoneDb) Stop() error { if zone.refreshInterval > 0 { - Debug.Printf("[zonedb] Closing background updaters...") + Log.Debugf("[zonedb] Closing background updaters...") zone.refreshScheds.Stop() } - Debug.Printf("[zonedb] Exiting mDNS client and server...") + Log.Debugf("[zonedb] Exiting mDNS client and server...") zone.mdnsCli.Stop() zone.mdnsSrv.Stop() return nil @@ -555,7 +555,7 @@ func (zone *ZoneDb) Status() string { func (zone *ZoneDb) AddRecord(ident string, name string, ip net.IP) (err error) { zone.mx.Lock() defer zone.mx.Unlock() - Debug.Printf("[zonedb] Adding record: '%s'/'%s'[%s]", ident, name, ip) + Log.Debugf("[zonedb] Adding record: '%s'/'%s'[%s]", ident, name, ip) record := Record{dns.Fqdn(name), ip, 0, 0, 0} _, err = zone.getNameSet(ident).addIPToName(record, zone.clock.Now()) return diff --git a/nameserver/zone_lookup.go b/nameserver/zone_lookup.go index 5c5aacd6..6e515b62 100644 --- a/nameserver/zone_lookup.go +++ b/nameserver/zone_lookup.go @@ -63,7 +63,7 @@ func (zone *ZoneDb) LookupName(name string) (res []ZoneRecord, err error) { // note: LookupName() is usually called from the mDNS server, so we do not touch the name name = dns.Fqdn(name) - Debug.Printf("[zonedb] Looking for name '%s' in local database", name) + Log.Debugf("[zonedb] Looking for name '%s' in local database", name) return zone.lookup(name, func(ns *nameSet) []*recordEntry { return ns.getEntriesForName(name) }) } @@ -78,23 +78,23 @@ func (zone *ZoneDb) LookupInaddr(inaddr string) (res []ZoneRecord, err error) { if err != nil { return nil, newParseError("lookup address", inaddr) } - Debug.Printf("[zonedb] Looking for address in local database: '%s' (%s)", revIPv4, inaddr) + Log.Debugf("[zonedb] Looking for address in local database: '%s' (%s)", revIPv4, inaddr) return zone.lookup(inaddr, func(ns *nameSet) []*recordEntry { return ns.getEntriesForIP(revIPv4) }) } // Perform a domain lookup with mDNS func (zone *ZoneDb) domainLookup(target string, lfun ZoneLookupFunc) (res []ZoneRecord, err error) { // no local results have been obtained in the local database: try with a mDNS query - Debug.Printf("[zonedb] '%s' not in local database... trying with mDNS", target) + Log.Debugf("[zonedb] '%s' not in local database... trying with mDNS", target) lanswers, err := lfun(target) if err != nil { - Debug.Printf("[zonedb] mDNS lookup error for '%s': %s", target, err) + Log.Debugf("[zonedb] mDNS lookup error for '%s': %s", target, err) return nil, err } // if the request has been successful, save the IP in the local database and return the corresponding ZoneRecord // (we do not get the remote ident in the mDNS reply, so we save it in a "remote" ident) - Debug.Printf("[zonedb] adding '%s' (obtained with mDNS) to '%s'", lanswers, target) + Log.Debugf("[zonedb] adding '%s' (obtained with mDNS) to '%s'", lanswers, target) res = make([]ZoneRecord, len(lanswers)) zone.mx.Lock() now := zone.clock.Now() @@ -104,7 +104,7 @@ func (zone *ZoneDb) domainLookup(target string, lfun ZoneLookupFunc) (res []Zone r, err := remoteIdent.addIPToName(answer, now) if err != nil { zone.mx.Unlock() - Warning.Printf("[zonedb] '%s' insertion for %s failed: %s", answer, target, err) + Log.Warningf("[zonedb] '%s' insertion for %s failed: %s", answer, target, err) return nil, err } uniq.add(r) @@ -118,7 +118,7 @@ func (zone *ZoneDb) domainLookup(target string, lfun ZoneLookupFunc) (res []Zone // The name can be resolved locally with the local database or with some other resolution method (eg, a mDNS query) func (zone *ZoneDb) DomainLookupName(name string) (res []ZoneRecord, err error) { name = dns.Fqdn(name) - Debug.Printf("[zonedb] Looking for name '%s' in local(&remote) database", name) + Log.Debugf("[zonedb] Looking for name '%s' in local(&remote) database", name) zone.mx.Lock() now := zone.clock.Now() @@ -128,7 +128,7 @@ func (zone *ZoneDb) DomainLookupName(name string) (res []ZoneRecord, err error) // filter the entries with expired TTL // locally introduced entries are never expired: they always have TTL=0 if ze.hasExpired(now) { - Debug.Printf("[zonedb] '%s': expired entry '%s' ignored: removing", name, ze) + Log.Debugf("[zonedb] '%s': expired entry '%s' ignored: removing", name, ze) nameset.deleteNameIP(name, net.IP{}) } else { uniq.add(ze) @@ -141,7 +141,7 @@ func (zone *ZoneDb) DomainLookupName(name string) (res []ZoneRecord, err error) zone.mx.Unlock() if len(uniq) > 0 { - Debug.Printf("[zonedb] '%s' resolved in local database", name) + Log.Debugf("[zonedb] '%s' resolved in local database", name) res = uniq.toSlice() } else { res, err = zone.domainLookup(name, zone.mdnsCli.LookupName) @@ -163,7 +163,7 @@ func (zone *ZoneDb) DomainLookupInaddr(inaddr string) (res []ZoneRecord, err err return nil, newParseError("lookup address", inaddr) } - Debug.Printf("[zonedb] Looking for address in local(&remote) database: '%s' (%s)", revIPv4, inaddr) + Log.Debugf("[zonedb] Looking for address in local(&remote) database: '%s' (%s)", revIPv4, inaddr) zone.mx.Lock() now := zone.clock.Now() @@ -173,7 +173,7 @@ func (zone *ZoneDb) DomainLookupInaddr(inaddr string) (res []ZoneRecord, err err // filter the entries with expired TTL // locally introduced entries are never expired: they always have TTL=0 if ze.hasExpired(now) { - Debug.Printf("[zonedb] '%s': expired entry '%s' ignored: removing", revIPv4, ze) + Log.Debugf("[zonedb] '%s': expired entry '%s' ignored: removing", revIPv4, ze) nameset.deleteNameIP("", revIPv4.toNetIP()) } else { uniq.add(ze) @@ -186,7 +186,7 @@ func (zone *ZoneDb) DomainLookupInaddr(inaddr string) (res []ZoneRecord, err err zone.mx.Unlock() if len(uniq) > 0 { - Debug.Printf("[zonedb] '%s' resolved in local database", inaddr) + Log.Debugf("[zonedb] '%s' resolved in local database", inaddr) res = uniq.toSlice() } else { res, err = zone.domainLookup(inaddr, zone.mdnsCli.LookupInaddr) @@ -243,7 +243,7 @@ func (zone *ZoneDb) startUpdatingName(name string) { n.lastRefreshTime = now zone.mx.Unlock() - Debug.Printf("[zonedb] Creating new immediate refresh request for '%s'", name) + Log.Debugf("[zonedb] Creating new immediate refresh request for '%s'", name) zone.refreshScheds.Add(func() time.Time { return zone.updater(name) }, now) } else { zone.mx.Unlock() @@ -261,7 +261,7 @@ func (zone *ZoneDb) updater(name string) (nextTime time.Time) { // if nobody has asked for this name for long time, just forget about it... if !zone.IsNameRelevant(name) || zone.IsNameExpired(name) { - Debug.Printf("[zonedb] '%s' seem to be irrelevant now: removing any remote information", name) + Log.Debugf("[zonedb] '%s' seem to be irrelevant now: removing any remote information", name) deleteRemoteInfo() return } @@ -269,7 +269,7 @@ func (zone *ZoneDb) updater(name string) (nextTime time.Time) { // perform the refresh for this name fullName := dns.Fqdn(name) startTime := zone.clock.Now() - Debug.Printf("[zonedb] Refreshing name '%s' with mDNS...", fullName) + Log.Debugf("[zonedb] Refreshing name '%s' with mDNS...", fullName) res, _ := zone.mdnsCli.InsistentLookupName(fullName) if res != nil && len(res) > 0 { numIps := len(res) @@ -277,14 +277,14 @@ func (zone *ZoneDb) updater(name string) (nextTime time.Time) { now := zone.clock.Now() added, removed := zone.getNameSet(defaultRemoteIdent).getName(name, true).updateIPs(res, now) zone.mx.Unlock() - Debug.Printf("[zonedb] Obtained %d IPs for name '%s' with mDNS: %d added, %d removed", + Log.Debugf("[zonedb] Obtained %d IPs for name '%s' with mDNS: %d added, %d removed", numIps, name, added, removed) // once the name has been updated, we re-schedule the update nextTime = startTime.Add(zone.refreshInterval) - Debug.Printf("[zonedb] Rescheduling update for '%s' in %s", name, nextTime.Sub(zone.clock.Now())) + Log.Debugf("[zonedb] Rescheduling update for '%s' in %s", name, nextTime.Sub(zone.clock.Now())) } else { - Debug.Printf("[zonedb] nobody knows about '%s'... removing", name) + Log.Debugf("[zonedb] nobody knows about '%s'... removing", name) deleteRemoteInfo() } return diff --git a/nameserver/zone_lookup_test.go b/nameserver/zone_lookup_test.go index 8a7d22fd..eb48488e 100644 --- a/nameserver/zone_lookup_test.go +++ b/nameserver/zone_lookup_test.go @@ -40,77 +40,77 @@ func TestZoneRefresh(t *testing.T) { time.Sleep(100 * time.Millisecond) // allow for server to get going - Debug.Printf("Adding '%s' to Db #1", name) + Log.Debugf("Adding '%s' to Db #1", name) dbs[0].Zone.AddRecord("someident", name, net.ParseIP(addr1)) - Debug.Printf("Checking that the name %s is relevant (as it has been locally inserted) and not remote", name) + Log.Debugf("Checking that the name %s is relevant (as it has been locally inserted) and not remote", name) require.True(t, dbs[0].Zone.IsNameRelevant(name), "name relevant") require.True(t, dbs[0].Zone.HasNameLocalInfo(name), "local name info") require.False(t, dbs[0].Zone.HasNameRemoteInfo(name), "remote name info") - Debug.Printf("Asking for '%s' to Db #1: should get 1 IP from the local database...", name) + Log.Debugf("Asking for '%s' to Db #1: should get 1 IP from the local database...", name) res, err := dbs[0].Zone.DomainLookupName(name) require.NoError(t, err) - Debug.Printf("Got: %s", res) + Log.Debugf("Got: %s", res) t.Logf("Db #1 after the lookup:\n%s", dbs[0].Zone) require.Equal(t, 1, len(res), "lookup result") clk.Forward(refreshInterval / 2) dbs.Flush() - Debug.Printf("A couple of seconds later, we should still have one IP for that name") + Log.Debugf("A couple of seconds later, we should still have one IP for that name") res, err = dbs[0].Zone.DomainLookupName(name) require.NoError(t, err) require.Equal(t, 1, len(res), "lookup result") - Debug.Printf("And then we add 2 IPs for that name at ZoneDb 2") + Log.Debugf("And then we add 2 IPs for that name at ZoneDb 2") clk.Forward(1) dbs.Flush() - Debug.Printf("Adding 2 IPs to '%s' in Db #2", name) + Log.Debugf("Adding 2 IPs to '%s' in Db #2", name) dbs[1].Zone.AddRecord("someident", name, net.ParseIP(addr2)) dbs[1].Zone.AddRecord("someident", name, net.ParseIP(addr3)) - Debug.Printf("Perform a lookup, to ensure the name will be updated in the background...") + Log.Debugf("Perform a lookup, to ensure the name will be updated in the background...") dbs[0].Zone.DomainLookupName(name) - Debug.Printf("Wait for a while, until a refresh is performed...") + Log.Debugf("Wait for a while, until a refresh is performed...") clk.Forward(refreshInterval + 1) dbs.Flush() - Debug.Printf("A refresh should have been scheduled now: we should have 3 IPs:") - Debug.Printf("the first (local) IP and the others obtained from zone2 with a mDNS query") - Debug.Printf("Asking for '%s' again... we should have 3 IPs now", name) + Log.Debugf("A refresh should have been scheduled now: we should have 3 IPs:") + Log.Debugf("the first (local) IP and the others obtained from zone2 with a mDNS query") + Log.Debugf("Asking for '%s' again... we should have 3 IPs now", name) res, err = dbs[0].Zone.DomainLookupName(name) - Debug.Printf("Got: %s", res) + Log.Debugf("Got: %s", res) t.Logf("Db #1 after the second lookup:\n%s", dbs[0].Zone) require.Equal(t, 3, len(res), "lookup result length") - Debug.Printf("We will not ask for `name` for a while, so it will become irrelevant and will be removed...") + Log.Debugf("We will not ask for `name` for a while, so it will become irrelevant and will be removed...") clk.Forward(refreshInterval + relevantTime + 1) dbs.Flush() // the name should be irrelevant now, and all remote info should have been // removed from the zone database - Debug.Printf("Name '%s' should not be in the remote database in ZoneDb 1", name) + Log.Debugf("Name '%s' should not be in the remote database in ZoneDb 1", name) require.False(t, dbs[0].Zone.IsNameRelevant(name), "name still relevant after some inactivity time") require.True(t, dbs[0].Zone.HasNameLocalInfo(name), "local name info") require.False(t, dbs[0].Zone.HasNameRemoteInfo(name), "remote name info") - Debug.Printf("There is no remote info about this name at zone 1: a new IP appears remotely meanwhile...") + Log.Debugf("There is no remote info about this name at zone 1: a new IP appears remotely meanwhile...") clk.Forward(1) dbs.Flush() - Debug.Printf("Adding '%s' to Db #2", name) + Log.Debugf("Adding '%s' to Db #2", name) dbs[1].Zone.AddRecord("someident", name, net.ParseIP(addr4)) - Debug.Printf("When we ask about this name again, we get 4 IPs (1 local, 3 remote)") - Debug.Printf("Asking for '%s' again... the first lookup will return only the local results", name) + Log.Debugf("When we ask about this name again, we get 4 IPs (1 local, 3 remote)") + Log.Debugf("Asking for '%s' again... the first lookup will return only the local results", name) res, err = dbs[0].Zone.DomainLookupName(name) require.Equal(t, 1, len(res), "lookup result length") - Debug.Printf("... but a second lookup should return all the results in the network") + Log.Debugf("... but a second lookup should return all the results in the network") clk.Forward(refreshInterval + 1) dbs.Flush() res, err = dbs[0].Zone.DomainLookupName(name) - Debug.Printf("Got: %s", res) + Log.Debugf("Got: %s", res) require.Equal(t, 4, len(res), "lookup result length") } diff --git a/prog/weavedns/main.go b/prog/weavedns/main.go index 21193da6..dea87bc0 100644 --- a/prog/weavedns/main.go +++ b/prog/weavedns/main.go @@ -79,7 +79,7 @@ func main() { Info.Println("[main] Waiting for mDNS interface", ifaceName, "to come up") iface, err = weavenet.EnsureInterface(ifaceName, wait) if err != nil { - Error.Fatal(err) + Log.Fatal(err) } else { Info.Println("[main] Interface", ifaceName, "is up") } @@ -92,22 +92,22 @@ func main() { Info.Println("[main] Waiting for HTTP interface", httpIfaceName, "to come up") httpIface, err := weavenet.EnsureInterface(httpIfaceName, wait) if err != nil { - Error.Fatal(err) + Log.Fatal(err) } Info.Println("[main] Interface", httpIfaceName, "is up") addrs, err := httpIface.Addrs() if err != nil { - Error.Fatal(err) + Log.Fatal(err) } if len(addrs) == 0 { - Error.Fatal("[main] No addresses on HTTP interface") + Log.Fatal("[main] No addresses on HTTP interface") } ip, _, err := net.ParseCIDR(addrs[0].String()) if err != nil { - Error.Fatal(err) + Log.Fatal(err) } httpIP = ip.String() @@ -124,22 +124,22 @@ func main() { } zone, err := weavedns.NewZoneDb(zoneConfig) if err != nil { - Error.Fatal("[main] Unable to initialize the Zone database", err) + Log.Fatal("[main] Unable to initialize the Zone database", err) } if err := zone.Start(); err != nil { - Error.Fatal("[main] Unable to start the Zone database", err) + Log.Fatal("[main] Unable to start the Zone database", err) } defer zone.Stop() dockerCli, err = docker.NewClient(apiPath) if err != nil { - Error.Fatal("[main] Unable to start docker client: ", err) + Log.Fatal("[main] Unable to start docker client: ", err) } if watch { err := dockerCli.AddObserver(zone) if err != nil { - Error.Fatal("[main] Unable to start watcher", err) + Log.Fatal("[main] Unable to start watcher", err) } } @@ -158,20 +158,20 @@ func main() { if len(fallback) > 0 { fallbackHost, fallbackPort, err := net.SplitHostPort(fallback) if err != nil { - Error.Fatal("[main] Could not parse fallback host and port", err) + Log.Fatal("[main] Could not parse fallback host and port", err) } srvConfig.UpstreamCfg = &dns.ClientConfig{Servers: []string{fallbackHost}, Port: fallbackPort} - Debug.Printf("[main] DNS fallback at %s:%s", fallbackHost, fallbackPort) + Log.Debugf("[main] DNS fallback at %s:%s", fallbackHost, fallbackPort) } srv, err := weavedns.NewDNSServer(srvConfig) if err != nil { - Error.Fatal("[main] Failed to initialize the WeaveDNS server", err) + Log.Fatal("[main] Failed to initialize the WeaveDNS server", err) } httpListener, err := net.Listen("tcp", httpAddr) if err != nil { - Error.Fatal("[main] Unable to create http listener: ", err) + Log.Fatal("[main] Unable to create http listener: ", err) } Info.Println("[main] HTTP API listening on", httpAddr) @@ -180,7 +180,7 @@ func main() { err = srv.Start() if err != nil { - Error.Fatal("[main] Failed to start the WeaveDNS server: ", err) + Log.Fatal("[main] Failed to start the WeaveDNS server: ", err) } srv.ActivateAndServe() } diff --git a/prog/weaveproxy/main.go b/prog/weaveproxy/main.go index df1a732f..6eecfa21 100644 --- a/prog/weaveproxy/main.go +++ b/prog/weaveproxy/main.go @@ -43,7 +43,7 @@ func main() { } if c.WithDNS && c.WithoutDNS { - Error.Fatalf("Cannot use both '--with-dns' and '--without-dns' flags") + Log.Fatalf("Cannot use both '--with-dns' and '--without-dns' flags") } if debug { @@ -55,7 +55,7 @@ func main() { p, err := proxy.NewProxy(c) if err != nil { - Error.Fatalf("Could not start proxy: %s", err) + Log.Fatalf("Could not start proxy: %s", err) } p.ListenAndServe() diff --git a/prog/weaver/main.go b/prog/weaver/main.go index 7b98dbb6..297444f3 100644 --- a/prog/weaver/main.go +++ b/prog/weaver/main.go @@ -4,7 +4,6 @@ import ( "crypto/sha256" "flag" "fmt" - "log" "net" "net/http" "os" @@ -24,10 +23,6 @@ import ( var version = "(unreleased version)" func main() { - - log.SetPrefix(weave.Protocol + " ") - log.SetFlags(log.Ldate | log.Ltime | log.Lmicroseconds) - procs := runtime.NumCPU() // packet sniffing can block an OS thread, so we need one thread // for that plus at least one more. @@ -84,33 +79,33 @@ func main() { os.Exit(0) } - log.Println("Command line options:", options()) - log.Println("Command line peers:", peers) + Log.Println("Command line options:", options()) + Log.Println("Command line peers:", peers) var err error if ifaceName != "" { config.Iface, err = weavenet.EnsureInterface(ifaceName, wait) if err != nil { - log.Fatal(err) + Log.Fatal(err) } } if routerName == "" { if config.Iface == nil { - log.Fatal("Either an interface must be specified with -iface or a name with -name") + Log.Fatal("Either an interface must be specified with -iface or a name with -name") } routerName = config.Iface.HardwareAddr.String() } name, err := weave.PeerNameFromUserInput(routerName) if err != nil { - log.Fatal(err) + Log.Fatal(err) } if nickName == "" { nickName, err = os.Hostname() if err != nil { - log.Fatal(err) + Log.Fatal(err) } } @@ -118,10 +113,10 @@ func main() { password = os.Getenv("WEAVE_PASSWORD") } if password == "" { - log.Println("Communication between peers is unencrypted.") + Log.Println("Communication between peers is unencrypted.") } else { config.Password = []byte(password) - log.Println("Communication between peers is encrypted.") + Log.Println("Communication between peers is encrypted.") } if prof != "" { @@ -136,7 +131,7 @@ func main() { config.PeerDiscovery = !noDiscovery router := weave.NewRouter(config, name, nickName) - log.Println("Our name is", router.Ourself) + Log.Println("Our name is", router.Ourself) var allocator *ipam.Allocator var defaultSubnet address.CIDR @@ -145,18 +140,18 @@ func main() { allocator, defaultSubnet = createAllocator(router, iprangeCIDR, ipsubnetCIDR, determineQuorum(peerCount, peers)) dockerCli, err = docker.NewClient(apiPath) if err != nil { - Error.Fatal("Unable to start docker client: ", err) + Log.Fatal("Unable to start docker client: ", err) } if err = dockerCli.AddObserver(allocator); err != nil { - Error.Fatal("Unable to start watcher", err) + Log.Fatal("Unable to start watcher", err) } } else if peerCount > 0 { - log.Fatal("-initpeercount flag specified without -iprange") + Log.Fatal("-initpeercount flag specified without -iprange") } router.Start() if errors := router.ConnectionMaker.InitiateConnections(peers, false); len(errors) > 0 { - log.Fatal(errorMessages(errors)) + Log.Fatal(errorMessages(errors)) } // The weave script always waits for a status call to succeed, @@ -205,17 +200,17 @@ func logFrameFunc(debug bool) weave.LogFrameFunc { } } - log.Println(parts...) + Log.Println(parts...) } } func parseAndCheckCIDR(cidrStr string) address.CIDR { _, cidr, err := address.ParseCIDR(cidrStr) if err != nil { - log.Fatal(err) + Log.Fatal(err) } 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 } @@ -226,7 +221,7 @@ func createAllocator(router *weave.Router, ipRangeStr string, defaultSubnetStr s if defaultSubnetStr != "" { defaultSubnet = parseAndCheckCIDR(defaultSubnetStr) if !ipRange.Range().Overlaps(defaultSubnet.Range()) { - log.Fatalf("Default subnet %s out of bounds: %s", defaultSubnet, ipRange) + Log.Fatalf("Default subnet %s out of bounds: %s", defaultSubnet, ipRange) } } allocator := ipam.NewAllocator(router.Ourself.Peer.Name, router.Ourself.Peer.UID, router.Ourself.Peer.NickName, ipRange.Range(), quorum) @@ -253,7 +248,7 @@ func determineQuorum(initPeerCountFlag int, peers []string) uint { // specify it explicitly if that becomes a problem. clusterSize := uint(len(peers) + 1) quorum := clusterSize/2 + 1 - log.Println("Assuming quorum size of", quorum) + Log.Println("Assuming quorum size of", quorum) return quorum } @@ -303,11 +298,11 @@ func handleHTTP(router *weave.Router, httpAddr string, allocator *ipam.Allocator } l, err := net.Listen(protocol, httpAddr) if err != nil { - log.Fatal("Unable to create http listener socket: ", err) + Log.Fatal("Unable to create http listener socket: ", err) } err = http.Serve(l, nil) if err != nil { - log.Fatal("Unable to create http server", err) + Log.Fatal("Unable to create http server", err) } } diff --git a/proxy/common.go b/proxy/common.go index 45ed79d8..7231226c 100644 --- a/proxy/common.go +++ b/proxy/common.go @@ -20,7 +20,7 @@ var ( func callWeave(args ...string) ([]byte, error) { args = append([]string{"--local"}, args...) - Debug.Print("Calling weave", args) + Log.Debug("Calling weave", args) cmd := exec.Command("./weave", args...) cmd.Env = []string{"PROCFS=/hostproc", "PATH=/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"} out, err := cmd.CombinedOutput() @@ -41,14 +41,14 @@ func inspectContainerInPath(client *docker.Client, path string) (*docker.Contain subs := containerIDRegexp.FindStringSubmatch(path) if subs == nil { err := fmt.Errorf("No container id found in request with path %s", path) - Warning.Println(err) + Log.Warningln(err) return nil, err } containerID := subs[2] container, err := client.InspectContainer(containerID) if err != nil { - Warning.Printf("Error inspecting container %s: %v", containerID, err) + Log.Warningf("Error inspecting container %s: %v", containerID, err) } return container, err } diff --git a/proxy/proxy.go b/proxy/proxy.go index a2a756ed..07be6faf 100644 --- a/proxy/proxy.go +++ b/proxy/proxy.go @@ -47,7 +47,7 @@ func NewProxy(c Config) (*Proxy, error) { p := &Proxy{Config: c} if err := p.TLSConfig.loadCerts(); err != nil { - Error.Fatalf("Could not configure tls for proxy: %s", err) + Log.Fatalf("Could not configure tls for proxy: %s", err) } client, err := docker.NewClient(dockerSockUnix) @@ -94,7 +94,7 @@ func (proxy *Proxy) ListenAndServe() { for _, addr := range proxy.ListenAddrs { listener, normalisedAddr, err := proxy.listen(addr) if err != nil { - Error.Fatalf("Cannot listen on %s: %s", addr, err) + Log.Fatalf("Cannot listen on %s: %s", addr, err) } listeners = append(listeners, listener) addrs = append(addrs, normalisedAddr) @@ -113,7 +113,7 @@ func (proxy *Proxy) ListenAndServe() { for range listeners { err := <-errs if err != nil { - Error.Fatalf("Serve failed: %s", err) + Log.Fatalf("Serve failed: %s", err) } } } @@ -175,7 +175,7 @@ func (proxy *Proxy) listen(protoAndAddr string) (net.Listener, string, error) { } default: - Error.Fatalf("Invalid protocol format: %q", proto) + Log.Fatalf("Invalid protocol format: %q", proto) } return listener, fmt.Sprintf("%s://%s", proto, addr), nil diff --git a/proxy/proxy_intercept.go b/proxy/proxy_intercept.go index d936bd16..1b6ca46c 100644 --- a/proxy/proxy_intercept.go +++ b/proxy/proxy_intercept.go @@ -23,7 +23,7 @@ func (proxy *Proxy) Intercept(i interceptor, w http.ResponseWriter, r *http.Requ http.Error(w, err.Error(), http.StatusNotFound) default: http.Error(w, err.Error(), http.StatusInternalServerError) - Warning.Print("Error intercepting request: ", err) + Log.Warning("Error intercepting request: ", err) } return } @@ -31,7 +31,7 @@ func (proxy *Proxy) Intercept(i interceptor, w http.ResponseWriter, r *http.Requ conn, err := proxy.Dial() if err != nil { http.Error(w, "Could not connect to target", http.StatusInternalServerError) - Warning.Print(err) + Log.Warning(err) return } client := httputil.NewClientConn(conn, nil) @@ -40,13 +40,13 @@ func (proxy *Proxy) Intercept(i interceptor, w http.ResponseWriter, r *http.Requ resp, err := client.Do(r) if err != nil && err != httputil.ErrPersistEOF { http.Error(w, fmt.Sprintf("Could not make request to target: %v", err), http.StatusInternalServerError) - Warning.Print("Error forwarding request: ", err) + Log.Warning("Error forwarding request: ", err) return } err = i.InterceptResponse(resp) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) - Warning.Print("Error intercepting response: ", err) + Log.Warning("Error intercepting response: ", err) return } @@ -56,7 +56,7 @@ func (proxy *Proxy) Intercept(i interceptor, w http.ResponseWriter, r *http.Requ hdr.Add(k, v) } } - Debug.Printf("Response from target: %s %v", resp.Status, w.Header()) + Log.Debugf("Response from target: %s %v", resp.Status, w.Header()) if resp.Header.Get("Content-Type") == "application/vnd.docker.raw-stream" { doRawStream(w, resp, client) @@ -65,7 +65,7 @@ func (proxy *Proxy) Intercept(i interceptor, w http.ResponseWriter, r *http.Requ } else { w.WriteHeader(resp.StatusCode) if _, err := io.Copy(w, resp.Body); err != nil { - Warning.Print(err) + Log.Warning(err) } } } @@ -80,17 +80,17 @@ func doRawStream(w http.ResponseWriter, resp *http.Response, client *httputil.Cl defer up.Close() if _, err := down.Write([]byte("HTTP/1.1 200 OK\n")); err != nil { - Warning.Print(err) + Log.Warning(err) return } if err := resp.Header.Write(down); err != nil { - Warning.Print(err) + Log.Warning(err) return } if _, err := down.Write([]byte("\n")); err != nil { - Warning.Print(err) + Log.Warning(err) return } @@ -105,13 +105,13 @@ func doRawStream(w http.ResponseWriter, resp *http.Response, client *httputil.Cl func copyStream(dst io.Writer, src io.Reader, done chan struct{}) { defer close(done) if _, err := io.Copy(dst, src); err != nil { - Warning.Print(err) + Log.Warning(err) } if c, ok := dst.(interface { CloseWrite() error }); ok { if err := c.CloseWrite(); err != nil { - Warning.Printf("Error closing connection: %s", err) + Log.Warningf("Error closing connection: %s", err) } } } diff --git a/proxy/start_container_interceptor.go b/proxy/start_container_interceptor.go index 4d54680d..4d092512 100644 --- a/proxy/start_container_interceptor.go +++ b/proxy/start_container_interceptor.go @@ -23,7 +23,7 @@ func (i *startContainerInterceptor) InterceptResponse(r *http.Response) error { cidrs, ok := i.proxy.weaveCIDRsFromConfig(container.Config) if !ok { - Debug.Print("No Weave CIDR, ignoring") + Log.Debug("No Weave CIDR, ignoring") return nil } Info.Printf("Attaching container %s with WEAVE_CIDR \"%s\" to weave network", container.ID, strings.Join(cidrs, " ")) @@ -31,7 +31,7 @@ func (i *startContainerInterceptor) InterceptResponse(r *http.Response) error { args = append(args, cidrs...) args = append(args, "--or-die", container.ID) if output, err := callWeave(args...); err != nil { - Warning.Printf("Attaching container %s to weave network failed: %s", container.ID, string(output)) + Log.Warningf("Attaching container %s to weave network failed: %s", container.ID, string(output)) return errors.New(string(output)) } From 67a6961b4bda497be33b969e9da3ad704cb9b624 Mon Sep 17 00:00:00 2001 From: Bryan Boreham Date: Mon, 29 Jun 2015 13:34:29 +0100 Subject: [PATCH 62/82] Adjust logrus feature of padding all lines less than 44 chars with spaces at the end --- common/logging.go | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/common/logging.go b/common/logging.go index cd3deaa5..9c971d09 100644 --- a/common/logging.go +++ b/common/logging.go @@ -21,9 +21,14 @@ func (f *textFormatter) Format(entry *logrus.Entry) ([]byte, error) { levelText := strings.ToUpper(entry.Level.String())[0:4] timeStamp := entry.Time.Format("2006/01/02 15:04:05.000000") - fmt.Fprintf(b, "%s: %s %-44s ", levelText, timeStamp, entry.Message) - for k, v := range entry.Data { - fmt.Fprintf(b, " %s=%v", k, v) + if len(entry.Data) > 0 { + fmt.Fprintf(b, "%s: %s %-44s ", levelText, timeStamp, entry.Message) + for k, v := range entry.Data { + fmt.Fprintf(b, " %s=%v", k, v) + } + } else { + // No padding when there's no fields + fmt.Fprintf(b, "%s: %s %s", levelText, timeStamp, entry.Message) } b.WriteByte('\n') From 7276fc1d4b4264268b87138862d57423cf0ccaba Mon Sep 17 00:00:00 2001 From: Bryan Boreham Date: Mon, 29 Jun 2015 14:22:20 +0100 Subject: [PATCH 63/82] Wire up selection of logging levels to match old behaviour - note that all output is now going to stderr. --- common/init.go | 7 +------ common/logging.go | 38 +++++++++++++++----------------------- 2 files changed, 16 insertions(+), 29 deletions(-) diff --git a/common/init.go b/common/init.go index 0e1968f7..297a339e 100644 --- a/common/init.go +++ b/common/init.go @@ -1,10 +1,5 @@ package common -import ( - "io/ioutil" - "os" -) - func init() { - InitLogging(ioutil.Discard, os.Stdout, os.Stdout, os.Stderr) + InitDefaultLogging(false) } diff --git a/common/logging.go b/common/logging.go index 9c971d09..daf144e0 100644 --- a/common/logging.go +++ b/common/logging.go @@ -3,8 +3,6 @@ package common import ( "bytes" "fmt" - "io" - "io/ioutil" "os" "strings" @@ -40,33 +38,27 @@ var ( ) var ( - Log *logrus.Logger - Info *logrus.Logger - debugF bool + Log *logrus.Logger + Info *logrus.Logger ) -func InitLogging(debugHandle io.Writer, - infoHandle io.Writer, - warningHandle io.Writer, - errorHandle io.Writer) { - - Info = &logrus.Logger{ - Out: infoHandle, - Formatter: standardTextFormatter, - Hooks: make(logrus.LevelHooks), - Level: logrus.InfoLevel, +func InitLogging(level logrus.Level) { + if Info == nil { + Info = &logrus.Logger{ + Out: os.Stderr, + Formatter: standardTextFormatter, + Hooks: make(logrus.LevelHooks), + Level: level, + } + Log = Info } - Log = Info + Info.Level = level } func InitDefaultLogging(debug bool) { - if debug == debugF { - return - } - debugF = debug - debugOut := ioutil.Discard + level := logrus.InfoLevel if debug { - debugOut = os.Stderr + level = logrus.DebugLevel } - InitLogging(debugOut, os.Stdout, os.Stdout, os.Stderr) + InitLogging(level) } From 13c0b62f96a6b59c586b762bd0959d65379417c0 Mon Sep 17 00:00:00 2001 From: Bryan Boreham Date: Mon, 29 Jun 2015 15:03:52 +0100 Subject: [PATCH 64/82] When looking at proxy logs, use both stderr and stdout --- weave | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/weave b/weave index 39edfa75..7d4c9f58 100755 --- a/weave +++ b/weave @@ -614,7 +614,7 @@ wait_for_status() { wait_for_log() { fifo=/tmp/tmpfifo.$$ mkfifo $fifo || exit 1 - docker logs -f $1 2>/dev/null >$fifo & + docker logs -f $1 >$fifo 2>&1 & res=0 grep -q "$2" $fifo || res=1 kill $! 2>/dev/null || true @@ -927,7 +927,7 @@ proxy_args() { } proxy_addr() { - if addr=$(docker logs $PROXY_CONTAINER_NAME 2>/dev/null | head -n3 | grep -oE "proxy listening on .*"); then + if addr=$(docker logs $PROXY_CONTAINER_NAME 2>&1 | head -n3 | grep -oE "proxy listening on .*"); then echo "${1}${addr##* }" | sed "s/0.0.0.0/$PROXY_HOST/g" return 0 fi From 013380c7e7ecee1c5f93afa59edf28986fe7afe4 Mon Sep 17 00:00:00 2001 From: Bryan Boreham Date: Mon, 29 Jun 2015 15:36:08 +0100 Subject: [PATCH 65/82] Update router code to use common logger --- router/connection.go | 17 +++++++++++------ router/connection_maker.go | 7 ++++--- router/ethernet_decoder.go | 4 ++-- router/forwarder.go | 2 +- router/gossip_channel.go | 5 +++-- router/local_peer.go | 21 +++++++++++---------- router/router.go | 23 +++++++++++------------ router/udp_sender.go | 4 ++-- router/utils.go | 7 ++++--- 9 files changed, 49 insertions(+), 41 deletions(-) diff --git a/router/connection.go b/router/connection.go index fc10055b..03c69a94 100644 --- a/router/connection.go +++ b/router/connection.go @@ -4,10 +4,11 @@ import ( "encoding/binary" "encoding/gob" "fmt" - "log" "net" "sync" "time" + + . "github.com/weaveworks/weave/common" ) type Connection interface { @@ -83,7 +84,11 @@ func (conn *RemoteConnection) BreakTie(Connection) ConnectionTieBreak { return T 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...)...) + 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...)...) } func (conn *RemoteConnection) String() string { @@ -102,7 +107,7 @@ func (conn *RemoteConnection) String() string { // end up in the local peer's connections map. func StartLocalConnection(connRemote *RemoteConnection, tcpConn *net.TCPConn, udpAddr *net.UDPAddr, router *Router, acceptNewPeer bool) { if connRemote.local != router.Ourself.Peer { - log.Fatal("Attempt to create local connection from a peer which is not ourself") + Log.Fatal("Attempt to create local connection from a peer which is not ourself") } // NB, we're taking a copy of connRemote here. actionChan := make(chan ConnectionAction, ChannelSize) @@ -227,7 +232,7 @@ func (conn *LocalConnection) ReceivedHeartbeat(remoteUDPAddr *net.UDPAddr, connU if oldRemoteUDPAddr == nil { return conn.sendFastHeartbeats() } else if oldRemoteUDPAddr.String() != remoteUDPAddr.String() { - log.Println("Peer", conn.remote, "moved from", old, "to", remoteUDPAddr) + Log.Println("Peer", conn.remote, "moved from", old, "to", remoteUDPAddr) } return nil }) @@ -378,9 +383,9 @@ func (conn *LocalConnection) actorLoop(actionChan <-chan ConnectionAction) (err func (conn *LocalConnection) shutdown(err error) { if conn.remote == nil { - log.Printf("->[%s] connection shutting down due to error during handshake: %v\n", conn.remoteTCPAddr, err) + Log.Errorf("->[%s] connection shutting down due to error during handshake: %v\n", conn.remoteTCPAddr, err) } else { - conn.Log("connection shutting down due to error:", err) + conn.ErrorLog("connection shutting down due to error:", err) } if conn.TCPConn != nil { diff --git a/router/connection_maker.go b/router/connection_maker.go index 2e36b69f..acb1102d 100644 --- a/router/connection_maker.go +++ b/router/connection_maker.go @@ -3,10 +3,11 @@ package router import ( "bytes" "fmt" - "log" "math/rand" "net" "time" + + . "github.com/weaveworks/weave/common" ) const ( @@ -298,9 +299,9 @@ func (cm *ConnectionMaker) connectToTargets(validTarget map[string]struct{}, dir } func (cm *ConnectionMaker) attemptConnection(address string, acceptNewPeer bool) { - log.Printf("->[%s] attempting connection\n", address) + Log.Printf("->[%s] attempting connection\n", address) if err := cm.ourself.CreateConnection(address, acceptNewPeer); err != nil { - log.Printf("->[%s] error during connection attempt: %v\n", address, err) + Log.Errorf("->[%s] error during connection attempt: %v\n", address, err) cm.ConnectionTerminated(address, err) } } diff --git a/router/ethernet_decoder.go b/router/ethernet_decoder.go index fc96a14b..d989d48a 100644 --- a/router/ethernet_decoder.go +++ b/router/ethernet_decoder.go @@ -2,11 +2,11 @@ package router import ( "bytes" - "log" "net" "code.google.com/p/gopacket" "code.google.com/p/gopacket/layers" + . "github.com/weaveworks/weave/common" ) type EthernetDecoder struct { @@ -61,7 +61,7 @@ func (dec *EthernetDecoder) sendICMPFragNeeded(mtu int, sendFrame func([]byte) e return err } - log.Printf("Sending ICMP 3,4 (%v -> %v): PMTU= %v\n", dec.IP.DstIP, dec.IP.SrcIP, mtu) + Log.Printf("Sending ICMP 3,4 (%v -> %v): PMTU= %v\n", dec.IP.DstIP, dec.IP.SrcIP, mtu) return sendFrame(buf.Bytes()) } diff --git a/router/forwarder.go b/router/forwarder.go index 80367e9b..0d9798d0 100644 --- a/router/forwarder.go +++ b/router/forwarder.go @@ -281,7 +281,7 @@ func (fwd *Forwarder) accumulateAndSendFrames(ch <-chan *ForwardedFrame, frame * } func (fwd *Forwarder) logDrop(frame *ForwardedFrame) { - fwd.conn.Log("Dropping too big frame during forwarding: frame len:", len(frame.frame), "; effective PMTU:", fwd.maxPayload+UDPOverhead-fwd.effectiveOverhead()) + fwd.conn.ErrorLog("Dropping too big frame during forwarding: frame len:", len(frame.frame), "; effective PMTU:", fwd.maxPayload+UDPOverhead-fwd.effectiveOverhead()) } func (fwd *Forwarder) appendFrame(frame *ForwardedFrame) bool { diff --git a/router/gossip_channel.go b/router/gossip_channel.go index aea6d25d..795573f8 100644 --- a/router/gossip_channel.go +++ b/router/gossip_channel.go @@ -4,8 +4,9 @@ import ( "bytes" "encoding/gob" "fmt" - "log" "sync" + + . "github.com/weaveworks/weave/common" ) type GossipChannel struct { @@ -225,5 +226,5 @@ func (c *GossipChannel) sendBroadcast(srcName PeerName, update GossipData) { } func (c *GossipChannel) log(args ...interface{}) { - log.Println(append(append([]interface{}{}, "[gossip "+c.name+"]:"), args...)...) + Log.Println(append(append([]interface{}{}, "[gossip "+c.name+"]:"), args...)...) } diff --git a/router/local_peer.go b/router/local_peer.go index 3463e6ba..395a7a2c 100644 --- a/router/local_peer.go +++ b/router/local_peer.go @@ -2,10 +2,11 @@ package router import ( "fmt" - "log" "net" "sync" "time" + + . "github.com/weaveworks/weave/common" ) type LocalPeer struct { @@ -41,13 +42,13 @@ func (peer *LocalPeer) Relay(srcPeer, dstPeer *Peer, frame []byte, dec *Ethernet if !found { // Not necessarily an error as there could be a race with the // dst disappearing whilst the frame is in flight - log.Println("Received packet for unknown destination:", dstPeer) + Log.Println("Received packet for unknown destination:", dstPeer) return nil } conn, found := peer.ConnectionTo(relayPeerName) if !found { // Again, could just be a race, not necessarily an error - log.Println("Unable to find connection to relay peer", relayPeerName) + Log.Println("Unable to find connection to relay peer", relayPeerName) return nil } return conn.(*LocalConnection).Forward(&ForwardedFrame{ @@ -70,9 +71,9 @@ func (peer *LocalPeer) RelayBroadcast(srcPeer *Peer, frame []byte, dec *Ethernet dec) if err != nil { if ftbe, ok := err.(FrameTooBigError); ok { - log.Printf("dropping too big DF broadcast frame (%v -> %v): PMTU= %v\n", dec.IP.DstIP, dec.IP.SrcIP, ftbe.EPMTU) + Log.Warnf("dropping too big DF broadcast frame (%v -> %v): PMTU= %v\n", dec.IP.DstIP, dec.IP.SrcIP, ftbe.EPMTU) } else { - log.Println(err) + Log.Errorln(err) } } } @@ -181,10 +182,10 @@ func (peer *LocalPeer) actorLoop(actionChan <-chan LocalPeerAction) { 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") + 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") + 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()) @@ -223,7 +224,7 @@ func (peer *LocalPeer) handleAddConnection(conn Connection) error { 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") + 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")) @@ -236,10 +237,10 @@ func (peer *LocalPeer) handleConnectionEstablished(conn Connection) { 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") + 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") + 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 { diff --git a/router/router.go b/router/router.go index a85d1fb1..00f53588 100644 --- a/router/router.go +++ b/router/router.go @@ -5,7 +5,6 @@ import ( "encoding/binary" "fmt" "io" - "log" "net" "sync" "syscall" @@ -67,11 +66,11 @@ type PacketSourceSink interface { func NewRouter(config Config, name PeerName, nickName string) *Router { router := &Router{Config: config, gossipChannels: make(GossipChannels)} onMacExpiry := func(mac net.HardwareAddr, peer *Peer) { - log.Println("Expired MAC", mac, "at", peer) + Log.Println("Expired MAC", mac, "at", peer) } onPeerGC := func(peer *Peer) { router.Macs.Delete(peer) - log.Println("Removed unreachable peer", peer) + Log.Println("Removed unreachable peer", peer) } router.Ourself = NewLocalPeer(name, nickName, router) router.Macs = NewMacCache(macMaxAge, onMacExpiry) @@ -127,12 +126,12 @@ func (router *Router) Status() string { } func (router *Router) sniff(pio PacketSourceSink) { - log.Println("Sniffing traffic on", router.Iface) + Log.Println("Sniffing traffic on", router.Iface) dec := NewEthernetDecoder() mac := router.Iface.HardwareAddr if router.Macs.Enter(mac, router.Ourself.Peer) { - log.Println("Discovered our MAC", mac) + Log.Println("Discovered our MAC", mac) } go func() { for { @@ -159,7 +158,7 @@ func (router *Router) handleCapturedPacket(frameData []byte, dec *EthernetDecode return } if router.Macs.Enter(srcMac, router.Ourself.Peer) { - log.Println("Discovered local MAC", srcMac) + Log.Println("Discovered local MAC", srcMac) } if dec.DropFrame() { return @@ -202,7 +201,7 @@ func (router *Router) listenTCP(localPort int) { for { tcpConn, err := ln.AcceptTCP() if err != nil { - log.Println(err) + Log.Errorln(err) continue } router.acceptTCP(tcpConn) @@ -216,7 +215,7 @@ func (router *Router) acceptTCP(tcpConn *net.TCPConn) { // on router.Port and we wait for them to send us something on UDP to // start. remoteAddrStr := tcpConn.RemoteAddr().String() - log.Printf("->[%s] connection accepted\n", remoteAddrStr) + Log.Printf("->[%s] connection accepted\n", remoteAddrStr) connRemote := NewRemoteConnection(router.Ourself.Peer, nil, remoteAddrStr, false, false) StartLocalConnection(connRemote, tcpConn, nil, router, true) } @@ -246,10 +245,10 @@ func (router *Router) udpReader(conn *net.UDPConn, po PacketSink) { if err == io.EOF { return } else if err != nil { - log.Println("ignoring UDP read error", err) + Log.Warnln("ignoring UDP read error", err) continue } else if n < NameSize { - log.Println("ignoring too short UDP packet from", sender) + Log.Warnln("ignoring too short UDP packet from", sender) continue } name := PeerNameFromBin(buf[:NameSize]) @@ -329,7 +328,7 @@ func (router *Router) handleUDPPacketFunc(relayConn *LocalConnection, dec *Ether dstMac := dec.Eth.DstMAC if router.Macs.Enter(srcMac, srcPeer) { - log.Println("Discovered remote MAC", srcMac, "at", srcPeer) + Log.Println("Discovered remote MAC", srcMac, "at", srcPeer) } if po != nil { router.LogFrame("Injecting", frame, dec) @@ -415,7 +414,7 @@ func (router *Router) applyTopologyUpdate(update []byte) (PeerNameSet, PeerNameS // itself included in the update, and we didn't know about // already. We ignore this; eventually we should receive an // update containing a complete topology. - log.Println("Topology gossip:", err) + Log.Println("Topology gossip:", err) return nil, nil, nil } if err != nil { diff --git a/router/udp_sender.go b/router/udp_sender.go index 4c264762..2159898f 100644 --- a/router/udp_sender.go +++ b/router/udp_sender.go @@ -1,12 +1,12 @@ package router import ( - "log" "net" "syscall" "code.google.com/p/gopacket" "code.google.com/p/gopacket/layers" + . "github.com/weaveworks/weave/common" ) type UDPSender interface { @@ -87,7 +87,7 @@ func (sender *RawUDPSender) Send(msg []byte) error { } defer f.Close() fd := int(f.Fd()) - log.Println("EMSGSIZE on send, expecting PMTU update (IP packet was", + Log.Println("EMSGSIZE on send, expecting PMTU update (IP packet was", len(packet), "bytes, payload was", len(msg), "bytes)") pmtu, err := syscall.GetsockoptInt(fd, syscall.IPPROTO_IP, syscall.IP_MTU) if err != nil { diff --git a/router/utils.go b/router/utils.go index a57d9e8b..8b56e810 100644 --- a/router/utils.go +++ b/router/utils.go @@ -5,21 +5,22 @@ import ( "crypto/rand" "encoding/gob" "fmt" - "log" "net" + + . "github.com/weaveworks/weave/common" ) var void = struct{}{} func checkFatal(e error) { if e != nil { - log.Fatal(e) + Log.Fatal(e) } } func checkWarn(e error) { if e != nil { - log.Println(e) + Log.Warnln(e) } } From a938608cc87474452bd05f8ae545edc027ceeb4e Mon Sep 17 00:00:00 2001 From: Bryan Boreham Date: Tue, 30 Jun 2015 15:09:06 +0100 Subject: [PATCH 66/82] Call weave reset before deleting containers, to improve clean-down --- test/config.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/config.sh b/test/config.sh index 3c3c0db4..9ca96777 100644 --- a/test/config.sh +++ b/test/config.sh @@ -170,8 +170,8 @@ assert_dns_ptr_record() { start_suite() { for host in $HOST1 $HOST2; do [ -z "$DEBUG" ] || echo "Cleaning up on $host: removing all containers and resetting weave" - rm_containers $host $(docker_on $host ps -aq 2>/dev/null) weave_on $host reset 2>/dev/null + rm_containers $host $(docker_on $host ps -aq 2>/dev/null) done whitely echo "$@" } From a5ddb63fca284b77d5bbf7fea0db1d83f72cf8b2 Mon Sep 17 00:00:00 2001 From: Bryan Boreham Date: Wed, 1 Jul 2015 14:01:45 +0100 Subject: [PATCH 67/82] Remove Info.Print in favour of Log.Info --- common/docker/client.go | 2 +- common/logging.go | 10 ++++------ common/sched_queue_test.go | 6 +++--- common/signals.go | 6 +++--- ipam/allocator_test.go | 8 ++++---- ipam/http.go | 4 ++-- nameserver/addrs_test.go | 2 +- nameserver/cache_test.go | 6 +++--- nameserver/dns_test.go | 2 +- nameserver/http.go | 12 ++++++------ nameserver/mdns_server_test.go | 2 +- nameserver/server.go | 17 +++++++++-------- nameserver/server_cache_test.go | 6 +++--- nameserver/server_test.go | 4 ++-- nameserver/zone.go | 6 +++--- nameserver/zone_lookup_test.go | 2 +- prog/weavedns/main.go | 12 ++++++------ prog/weaveproxy/main.go | 4 ++-- proxy/create_container_interceptor.go | 2 +- proxy/create_exec_interceptor.go | 2 +- proxy/proxy.go | 4 ++-- proxy/start_container_interceptor.go | 2 +- 22 files changed, 60 insertions(+), 61 deletions(-) diff --git a/common/docker/client.go b/common/docker/client.go index e5526a6e..71cdf316 100644 --- a/common/docker/client.go +++ b/common/docker/client.go @@ -36,7 +36,7 @@ func NewClient(apiPath string) (*Client, error) { if err != nil { return nil, err } - Info.Printf("[docker] Using Docker API on %s: %v", apiPath, env) + Log.Infof("[docker] Using Docker API on %s: %v", apiPath, env) return client, nil } diff --git a/common/logging.go b/common/logging.go index daf144e0..e2ef9d1a 100644 --- a/common/logging.go +++ b/common/logging.go @@ -38,21 +38,19 @@ var ( ) var ( - Log *logrus.Logger - Info *logrus.Logger + Log *logrus.Logger ) func InitLogging(level logrus.Level) { - if Info == nil { - Info = &logrus.Logger{ + if Log == nil { + Log = &logrus.Logger{ Out: os.Stderr, Formatter: standardTextFormatter, Hooks: make(logrus.LevelHooks), Level: level, } - Log = Info } - Info.Level = level + Log.Level = level } func InitDefaultLogging(debug bool) { diff --git a/common/sched_queue_test.go b/common/sched_queue_test.go index 54a89430..5c733355 100644 --- a/common/sched_queue_test.go +++ b/common/sched_queue_test.go @@ -11,7 +11,7 @@ import ( // Ensure we can add new calls while forwarding the clock func TestSchedCallsBasic(t *testing.T) { InitDefaultLogging(testing.Verbose()) - Info.Println("TestSchedCallsBasic starting") + Log.Infoln("TestSchedCallsBasic starting") const testSecs = 1000 clk := clock.NewMock() @@ -37,7 +37,7 @@ func TestSchedCallsBasic(t *testing.T) { // Ensure we can create a 100 seconds gap in the middle of the time travel func TestSchedCallsGap(t *testing.T) { InitDefaultLogging(testing.Verbose()) - Info.Println("TestSchedCallsGap starting") + Log.Infoln("TestSchedCallsGap starting") const testSecs = 1000 clk := clock.NewMock() @@ -65,7 +65,7 @@ func TestSchedCallsGap(t *testing.T) { func TestSchedCallsStop(t *testing.T) { InitDefaultLogging(testing.Verbose()) - Info.Println("TestSchedCallsStop starting") + Log.Infoln("TestSchedCallsStop starting") const testSecs = 1000 clk := clock.NewMock() diff --git a/common/signals.go b/common/signals.go index f92f3f60..e750a8ea 100644 --- a/common/signals.go +++ b/common/signals.go @@ -20,17 +20,17 @@ func SignalHandlerLoop(ss ...SignalReceiver) { for { switch <-sigs { case syscall.SIGINT: - Info.Printf("=== received SIGINT ===\n*** exiting\n") + Log.Infof("=== received SIGINT ===\n*** exiting\n") for _, subsystem := range ss { subsystem.Stop() } return case syscall.SIGQUIT: stacklen := runtime.Stack(buf, true) - Info.Printf("=== received SIGQUIT ===\n*** goroutine dump...\n%s\n*** end\n", buf[:stacklen]) + Log.Infof("=== received SIGQUIT ===\n*** goroutine dump...\n%s\n*** end\n", buf[:stacklen]) case syscall.SIGUSR1: for _, subsystem := range ss { - Info.Printf("=== received SIGUSR1 ===\n*** status...\n%s\n*** end\n", subsystem.Status()) + Log.Infof("=== received SIGUSR1 ===\n*** status...\n%s\n*** end\n", subsystem.Status()) } } } diff --git a/ipam/allocator_test.go b/ipam/allocator_test.go index 2176f643..fcd3027a 100644 --- a/ipam/allocator_test.go +++ b/ipam/allocator_test.go @@ -343,14 +343,14 @@ func TestAllocatorFuzz(t *testing.T) { allocIndex := rand.Int31n(nodes) alloc := allocs[allocIndex] - //common.Info.Printf("Allocate: asking allocator %d", allocIndex) + //common.Log.Infof("Allocate: asking allocator %d", allocIndex) addr, err := alloc.Allocate(name, subnet, nil) if err != nil { panic(fmt.Sprintf("Could not allocate addr")) } - //common.Info.Printf("Allocate: got address %s for name %s", addr, name) + //common.Log.Infof("Allocate: got address %s for name %s", addr, name) addrStr := addr.String() stateLock.Lock() @@ -387,7 +387,7 @@ func TestAllocatorFuzz(t *testing.T) { stateLock.Unlock() alloc := allocs[res.alloc] - //common.Info.Printf("Freeing %s (%s) on allocator %d", res.name, addr, res.alloc) + //common.Log.Infof("Freeing %s (%s) on allocator %d", res.name, addr, res.alloc) oldAddr, err := address.ParseIP(addr) if err != nil { @@ -412,7 +412,7 @@ func TestAllocatorFuzz(t *testing.T) { stateLock.Unlock() alloc := allocs[res.alloc] - //common.Info.Printf("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, nil) oldAddr, _ := address.ParseIP(addr) diff --git a/ipam/http.go b/ipam/http.go index 4218744c..0b665385 100644 --- a/ipam/http.go +++ b/ipam/http.go @@ -79,7 +79,7 @@ func (alloc *Allocator) HandleHTTP(router *mux.Router, defaultSubnet address.CID return } if dockerCli != nil && dockerCli.IsContainerNotRunning(ident) { - common.Info.Printf("[allocator] '%s' is not running: freeing %s", ident, addr) + common.Log.Infof("[allocator] '%s' is not running: freeing %s", ident, addr) alloc.Free(ident, addr) return } @@ -96,7 +96,7 @@ func (alloc *Allocator) HandleHTTP(router *mux.Router, defaultSubnet address.CID return } if dockerCli != nil && dockerCli.IsContainerNotRunning(ident) { - common.Info.Printf("[allocator] '%s' is not running: freeing %s", ident, newAddr) + common.Log.Infof("[allocator] '%s' is not running: freeing %s", ident, newAddr) alloc.Free(ident, newAddr) return } diff --git a/nameserver/addrs_test.go b/nameserver/addrs_test.go index 81392cdc..2118832b 100644 --- a/nameserver/addrs_test.go +++ b/nameserver/addrs_test.go @@ -10,7 +10,7 @@ import ( func TestAddrs(t *testing.T) { InitDefaultLogging(testing.Verbose()) - Info.Println("TestAddrs starting") + Log.Infoln("TestAddrs starting") ip, err := addrToIPv4("10.13.12.11") require.NoError(t, err) diff --git a/nameserver/cache_test.go b/nameserver/cache_test.go index 8b467488..f3a14cb0 100644 --- a/nameserver/cache_test.go +++ b/nameserver/cache_test.go @@ -15,7 +15,7 @@ import ( // Check that the cache keeps its intended capacity constant func TestCacheLength(t *testing.T) { InitDefaultLogging(testing.Verbose()) - Info.Println("TestCacheLength starting") + Log.Infoln("TestCacheLength starting") const cacheLen = 128 @@ -56,9 +56,9 @@ func TestCacheLength(t *testing.T) { // Check that the cache entries are ok func TestCacheEntries(t *testing.T) { InitDefaultLogging(testing.Verbose()) - Info.Println("TestCacheEntries starting") + Log.Infoln("TestCacheEntries starting") - Info.Println("Checking cache consistency") + Log.Infoln("Checking cache consistency") const cacheLen = 128 clk := clock.NewMock() diff --git a/nameserver/dns_test.go b/nameserver/dns_test.go index 3c46da41..1ec25147 100644 --- a/nameserver/dns_test.go +++ b/nameserver/dns_test.go @@ -12,7 +12,7 @@ import ( // Check that we can prune an answer func TestPrune(t *testing.T) { InitDefaultLogging(testing.Verbose()) - Info.Println("TestPrune starting") + Log.Infoln("TestPrune starting") questionMsg := new(dns.Msg) questionMsg.SetQuestion("name", dns.TypeA) diff --git a/nameserver/http.go b/nameserver/http.go index 3de340bc..42dd3231 100644 --- a/nameserver/http.go +++ b/nameserver/http.go @@ -61,10 +61,10 @@ func ServeHTTP(listener net.Listener, version string, server *DNSServer, dockerC domain := server.Zone.Domain() if !dns.IsSubDomain(domain, name) { - Info.Printf("[http] Ignoring name %s, not in %s", name, domain) + Log.Infof("[http] Ignoring name %s, not in %s", name, domain) return } - Info.Printf("[http] Adding %s -> %s", name, ipStr) + Log.Infof("[http] Adding %s -> %s", name, ipStr) if err := server.Zone.AddRecord(idStr, name, ip); err != nil { if _, ok := err.(DuplicateError); !ok { httpErrorAndLog( @@ -75,7 +75,7 @@ func ServeHTTP(listener net.Listener, version string, server *DNSServer, dockerC } if dockerCli != nil && dockerCli.IsContainerNotRunning(idStr) { - Info.Printf("[http] '%s' is not running: removing", idStr) + Log.Infof("[http] '%s' is not running: removing", idStr) server.Zone.DeleteRecords(idStr, name, ip) } }) @@ -95,7 +95,7 @@ func ServeHTTP(listener net.Listener, version string, server *DNSServer, dockerC fqdnStr, fqdn := extractFQDN(r) - Info.Printf("[http] Deleting ID %s, IP %s, FQDN %s", idStr, ipStr, fqdnStr) + Log.Infof("[http] Deleting ID %s, IP %s, FQDN %s", idStr, ipStr, fqdnStr) server.Zone.DeleteRecords(idStr, fqdn, ip) }) @@ -105,14 +105,14 @@ func ServeHTTP(listener net.Listener, version string, server *DNSServer, dockerC fqdnStr, fqdn := extractFQDN(r) - Info.Printf("[http] Deleting ID %s, IP *, FQDN %s", idStr, fqdnStr) + Log.Infof("[http] Deleting ID %s, IP *, FQDN %s", idStr, fqdnStr) server.Zone.DeleteRecords(idStr, fqdn, net.IP{}) }) muxRouter.Methods("DELETE").Path("/name").HandlerFunc(func(w http.ResponseWriter, r *http.Request) { fqdnStr, fqdn := extractFQDN(r) - Info.Printf("[http] Deleting ID *, IP *, FQDN %s", fqdnStr) + Log.Infof("[http] Deleting ID *, IP *, FQDN %s", fqdnStr) server.Zone.DeleteRecords("", fqdn, net.IP{}) }) diff --git a/nameserver/mdns_server_test.go b/nameserver/mdns_server_test.go index 7f94e5de..3fe89fe0 100644 --- a/nameserver/mdns_server_test.go +++ b/nameserver/mdns_server_test.go @@ -18,7 +18,7 @@ func TestServerSimpleQuery(t *testing.T) { ) InitDefaultLogging(testing.Verbose()) - Info.Println("TestServerSimpleQuery starting") + Log.Infoln("TestServerSimpleQuery starting") mzone := newMockedZoneWithRecords([]ZoneRecord{testRecord1, testRecord2}) mdnsServer, err := NewMDNSServer(mzone, true, DefaultLocalTTL) diff --git a/nameserver/server.go b/nameserver/server.go index a8955138..6f36aaf4 100644 --- a/nameserver/server.go +++ b/nameserver/server.go @@ -188,11 +188,11 @@ func NewDNSServer(config DNSServerConfig) (s *DNSServer, err error) { // Start the DNS server func (s *DNSServer) Start() error { - Info.Printf("[dns] Upstream server(s): %+v", s.Upstream) + Log.Infof("[dns] Upstream server(s): %+v", s.Upstream) if s.cacheDisabled { - Info.Printf("[dns] Cache: disabled") + Log.Infof("[dns] Cache: disabled") } else { - Info.Printf("[dns] Cache: %d entries", s.cache.Capacity()) + Log.Infof("[dns] Cache: %d entries", s.cache.Capacity()) } pc, err := net.ListenPacket("udp", s.ListenAddr) @@ -225,7 +225,7 @@ func (s *DNSServer) ActivateAndServe() { go func() { defer s.listenersWg.Done() - Info.Printf("[dns] Listening for DNS on %s (UDP)", s.ListenAddr) + Log.Infof("[dns] Listening for DNS on %s (UDP)", s.ListenAddr) err := s.udpSrv.ActivateAndServe() CheckFatal(err) Log.Debugf("[dns] DNS UDP server exiting...") @@ -234,7 +234,7 @@ func (s *DNSServer) ActivateAndServe() { go func() { defer s.listenersWg.Done() - Info.Printf("[dns] Listening for DNS on %s (TCP)", s.ListenAddr) + Log.Infof("[dns] Listening for DNS on %s (TCP)", s.ListenAddr) err := s.tcpSrv.ActivateAndServe() CheckFatal(err) Log.Debugf("[dns] DNS TCP server exiting...") @@ -243,7 +243,7 @@ func (s *DNSServer) ActivateAndServe() { // Waiting for all goroutines to finish (otherwise they die as main routine dies) s.listenersWg.Wait() - Info.Printf("[dns] Server exiting...") + Log.Infof("[dns] Server exiting...") } // Return status string @@ -284,7 +284,7 @@ func (s *DNSServer) createMux(proto dnsProtocol) *dns.ServeMux { } notUsHandler := s.notUsHandler(proto) notUsFallback := func(w dns.ResponseWriter, r *dns.Msg) { - Info.Printf("[dns msgid %d] -> sending to fallback server", r.MsgHdr.Id) + Log.Infof("[dns msgid %d] -> sending to fallback server", r.MsgHdr.Id) notUsHandler(w, r) } @@ -351,8 +351,9 @@ func (s *DNSServer) localHandler(proto dnsProtocol, kind string, qtype uint16, } if answers, err := lookup(q.Name); err != nil { - Info.Printf("[dns msgid %d] No results for type %s query for '%s' [caching no-local]", + Log.Infof("[dns msgid %d] No results for type %s query for '%s' [caching no-local]", r.MsgHdr.Id, dns.TypeToString[q.Qtype], q.Name) + maybeCache(nil, s.negLocalTTL, CacheNoLocalReplies) fallback(w, r) } else { diff --git a/nameserver/server_cache_test.go b/nameserver/server_cache_test.go index 8b0d8651..35f3dc82 100644 --- a/nameserver/server_cache_test.go +++ b/nameserver/server_cache_test.go @@ -20,7 +20,7 @@ func TestServerDbCacheInvalidation(t *testing.T) { ) InitDefaultLogging(testing.Verbose()) - Info.Println("TestServerDbCacheInvalidation starting") + Log.Infoln("TestServerDbCacheInvalidation starting") clk := newMockedClock() @@ -178,7 +178,7 @@ func TestServerCacheExpiration(t *testing.T) { ) InitDefaultLogging(testing.Verbose()) - Info.Println("TestServerCacheExpiration starting") + Log.Infoln("TestServerCacheExpiration starting") clk := newMockedClock() @@ -266,7 +266,7 @@ func TestServerCacheRefresh(t *testing.T) { ) InitDefaultLogging(testing.Verbose()) - Info.Println("TestServerCacheRefresh starting") + Log.Infoln("TestServerCacheRefresh starting") clk := newMockedClock() Log.Debugf("Creating 2 zone databases") diff --git a/nameserver/server_test.go b/nameserver/server_test.go index ce1d4a4c..ab19362b 100644 --- a/nameserver/server_test.go +++ b/nameserver/server_test.go @@ -41,7 +41,7 @@ func TestUDPDNSServer(t *testing.T) { testCIDR1 := testAddr1 + "/24" InitDefaultLogging(testing.Verbose()) - Info.Println("TestUDPDNSServer starting") + Log.Infoln("TestUDPDNSServer starting") zone, err := NewZoneDb(ZoneConfig{}) require.NoError(t, err) @@ -138,7 +138,7 @@ func TestTCPDNSServer(t *testing.T) { ) InitDefaultLogging(testing.Verbose()) - Info.Println("TestTCPDNSServer starting") + Log.Infoln("TestTCPDNSServer starting") zone, err := NewZoneDb(ZoneConfig{}) require.NoError(t, err) diff --git a/nameserver/zone.go b/nameserver/zone.go index 98fc76a0..e6598932 100644 --- a/nameserver/zone.go +++ b/nameserver/zone.go @@ -506,9 +506,9 @@ func NewZoneDb(config ZoneConfig) (zone *ZoneDb, err error) { // Start the zone database func (zone *ZoneDb) Start() (err error) { if zone.iface != nil { - Info.Printf("[zonedb] Using mDNS on %+v", zone.iface) + Log.Infof("[zonedb] Using mDNS on %+v", zone.iface) } else { - Info.Printf("[zonedb] Using mDNS on all interfaces") + Log.Infof("[zonedb] Using mDNS on all interfaces") } if err = zone.mdnsCli.Start(zone.iface); err != nil { @@ -638,7 +638,7 @@ func (zone *ZoneDb) String() string { // Notify that a container has died func (zone *ZoneDb) ContainerDied(ident string) error { - Info.Printf("[zonedb] Container %s down. Removing records", ident) + Log.Infof("[zonedb] Container %s down. Removing records", ident) zone.DeleteRecords(ident, "", net.IP{}) return nil } diff --git a/nameserver/zone_lookup_test.go b/nameserver/zone_lookup_test.go index eb48488e..5f86f34c 100644 --- a/nameserver/zone_lookup_test.go +++ b/nameserver/zone_lookup_test.go @@ -24,7 +24,7 @@ func TestZoneRefresh(t *testing.T) { ) InitDefaultLogging(testing.Verbose()) - Info.Println("TestZoneRefresh starting") + Log.Infoln("TestZoneRefresh starting") clk := newMockedClock() diff --git a/prog/weavedns/main.go b/prog/weavedns/main.go index dea87bc0..36763bc8 100644 --- a/prog/weavedns/main.go +++ b/prog/weavedns/main.go @@ -71,17 +71,17 @@ func main() { } InitDefaultLogging(debug) - Info.Printf("[main] WeaveDNS version %s\n", version) // first thing in log: the version + Log.Infof("[main] WeaveDNS version %s\n", version) // first thing in log: the version var iface *net.Interface if ifaceName != "" { var err error - Info.Println("[main] Waiting for mDNS interface", ifaceName, "to come up") + Log.Infoln("[main] Waiting for mDNS interface", ifaceName, "to come up") iface, err = weavenet.EnsureInterface(ifaceName, wait) if err != nil { Log.Fatal(err) } else { - Info.Println("[main] Interface", ifaceName, "is up") + Log.Infoln("[main] Interface", ifaceName, "is up") } } @@ -89,12 +89,12 @@ func main() { if httpIfaceName == "" { httpIP = "0.0.0.0" } else { - Info.Println("[main] Waiting for HTTP interface", httpIfaceName, "to come up") + Log.Infoln("[main] Waiting for HTTP interface", httpIfaceName, "to come up") httpIface, err := weavenet.EnsureInterface(httpIfaceName, wait) if err != nil { Log.Fatal(err) } - Info.Println("[main] Interface", httpIfaceName, "is up") + Log.Infoln("[main] Interface", httpIfaceName, "is up") addrs, err := httpIface.Addrs() if err != nil { @@ -173,7 +173,7 @@ func main() { if err != nil { Log.Fatal("[main] Unable to create http listener: ", err) } - Info.Println("[main] HTTP API listening on", httpAddr) + Log.Infoln("[main] HTTP API listening on", httpAddr) go SignalHandlerLoop(srv) go weavedns.ServeHTTP(httpListener, version, srv, dockerCli) diff --git a/prog/weaveproxy/main.go b/prog/weaveproxy/main.go index 6eecfa21..d4fdfcd8 100644 --- a/prog/weaveproxy/main.go +++ b/prog/weaveproxy/main.go @@ -50,8 +50,8 @@ func main() { InitDefaultLogging(true) } - Info.Println("weave proxy", version) - Info.Println("Command line arguments:", strings.Join(os.Args[1:], " ")) + Log.Infoln("weave proxy", version) + Log.Infoln("Command line arguments:", strings.Join(os.Args[1:], " ")) p, err := proxy.NewProxy(c) if err != nil { diff --git a/proxy/create_container_interceptor.go b/proxy/create_container_interceptor.go index 69f5815b..66f9f1f5 100644 --- a/proxy/create_container_interceptor.go +++ b/proxy/create_container_interceptor.go @@ -45,7 +45,7 @@ func (i *createContainerInterceptor) InterceptRequest(r *http.Request) error { } if cidrs, ok := i.proxy.weaveCIDRsFromConfig(container.Config); ok { - Info.Printf("Creating container with WEAVE_CIDR \"%s\"", strings.Join(cidrs, " ")) + Log.Infof("Creating container with WEAVE_CIDR \"%s\"", strings.Join(cidrs, " ")) if container.HostConfig == nil { container.HostConfig = &docker.HostConfig{} } diff --git a/proxy/create_exec_interceptor.go b/proxy/create_exec_interceptor.go index 72e62730..5414346e 100644 --- a/proxy/create_exec_interceptor.go +++ b/proxy/create_exec_interceptor.go @@ -30,7 +30,7 @@ func (i *createExecInterceptor) InterceptRequest(r *http.Request) error { } if cidrs, ok := i.proxy.weaveCIDRsFromConfig(container.Config); ok { - Info.Printf("Exec in container %s with WEAVE_CIDR \"%s\"", container.ID, strings.Join(cidrs, " ")) + Log.Infof("Exec in container %s with WEAVE_CIDR \"%s\"", container.ID, strings.Join(cidrs, " ")) cmd := append(weaveWaitEntrypoint, "-s") options.Cmd = append(cmd, options.Cmd...) } diff --git a/proxy/proxy.go b/proxy/proxy.go index 07be6faf..0812ab4b 100644 --- a/proxy/proxy.go +++ b/proxy/proxy.go @@ -72,7 +72,7 @@ func (proxy *Proxy) Dial() (net.Conn, error) { } func (proxy *Proxy) ServeHTTP(w http.ResponseWriter, r *http.Request) { - Info.Printf("%s %s", r.Method, r.URL) + Log.Infof("%s %s", r.Method, r.URL) path := r.URL.Path var i interceptor switch { @@ -101,7 +101,7 @@ func (proxy *Proxy) ListenAndServe() { } for _, addr := range addrs { - Info.Println("proxy listening on", addr) + Log.Infoln("proxy listening on", addr) } errs := make(chan error) diff --git a/proxy/start_container_interceptor.go b/proxy/start_container_interceptor.go index 4d092512..b7da0505 100644 --- a/proxy/start_container_interceptor.go +++ b/proxy/start_container_interceptor.go @@ -26,7 +26,7 @@ func (i *startContainerInterceptor) InterceptResponse(r *http.Response) error { Log.Debug("No Weave CIDR, ignoring") return nil } - Info.Printf("Attaching container %s with WEAVE_CIDR \"%s\" to weave network", container.ID, strings.Join(cidrs, " ")) + Log.Infof("Attaching container %s with WEAVE_CIDR \"%s\" to weave network", container.ID, strings.Join(cidrs, " ")) args := []string{"attach"} args = append(args, cidrs...) args = append(args, "--or-die", container.ID) From 84238a0262de201b82ae3bb8a0b269eef786d36c Mon Sep 17 00:00:00 2001 From: Bryan Boreham Date: Wed, 1 Jul 2015 14:58:42 +0100 Subject: [PATCH 68/82] Amend error message to reflect usage situation --- net/route.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/net/route.go b/net/route.go index 5673117f..80df987a 100644 --- a/net/route.go +++ b/net/route.go @@ -16,7 +16,7 @@ func CheckNetworkFree(subnet *net.IPNet) error { } for _, route := range routes { if route.Dst != nil && overlaps(route.Dst, subnet) { - return fmt.Errorf("Network %s would overlap with existing route %s", subnet, route.Dst) + return fmt.Errorf("Network %s overlaps with existing route %s", subnet, route.Dst) } } return nil @@ -36,7 +36,7 @@ func CheckAddressOverlap(addr net.IP) error { } for _, route := range routes { if route.Dst != nil && route.Dst.Contains(addr) { - return fmt.Errorf("Address %s would overlap with existing route %s", addr, route.Dst) + return fmt.Errorf("Address %s overlaps with existing route %s", addr, route.Dst) } } return nil From 3bd5ae56f01de45be6bf84bfea2fe7720675bcaa Mon Sep 17 00:00:00 2001 From: Matthias Radestock Date: Thu, 2 Jul 2015 11:46:48 +0100 Subject: [PATCH 69/82] fix `make update` Trying to build the thing for which we want to fetch the dependencies is rather silly. --- Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Makefile b/Makefile index bfd649ee..8973e892 100644 --- a/Makefile +++ b/Makefile @@ -38,7 +38,7 @@ all: $(EXPORTS) travis: $(EXES) -update: $(EXES) +update: go get -u -f -v -tags -netgo $(addprefix ./,$(dir $(EXES))) $(WEAVER_EXE) $(WEAVEDNS_EXE) $(WEAVEPROXY_EXE) $(NETCHECK_EXE): common/*.go common/*/*.go net/*.go From 18a4c14670d734708417ad927926483cc0a3f14a Mon Sep 17 00:00:00 2001 From: Matthias Radestock Date: Thu, 2 Jul 2015 11:51:22 +0100 Subject: [PATCH 70/82] clarify network/address route overlap error/warning message Closes #1034. --- net/route.go | 4 ++-- weave | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/net/route.go b/net/route.go index 80df987a..6d1722ad 100644 --- a/net/route.go +++ b/net/route.go @@ -16,7 +16,7 @@ func CheckNetworkFree(subnet *net.IPNet) error { } for _, route := range routes { if route.Dst != nil && overlaps(route.Dst, subnet) { - return fmt.Errorf("Network %s overlaps with existing route %s", subnet, route.Dst) + return fmt.Errorf("Network %s overlaps with existing route %s on host.", subnet, route.Dst) } } return nil @@ -36,7 +36,7 @@ func CheckAddressOverlap(addr net.IP) error { } for _, route := range routes { if route.Dst != nil && route.Dst.Contains(addr) { - return fmt.Errorf("Address %s overlaps with existing route %s", addr, route.Dst) + return fmt.Errorf("Address %s overlaps with existing route %s on host.", addr, route.Dst) } } return nil diff --git a/weave b/weave index 5bc53f69..54b8fc50 100755 --- a/weave +++ b/weave @@ -988,7 +988,7 @@ launch_router() { if [ -z "$IPRANGE_SPECIFIED" ] ; then IPRANGE="10.128.0.0/10" if command_exists netcheck && ! netcheck $IPRANGE ; then - echo "Default -iprange $IPRANGE overlaps with existing route." >&2 + echo "Default -iprange $IPRANGE overlaps with existing route on host." >&2 echo "Please pick another range and set it on all hosts." >&2 exit 1 fi From f6ffd604dd74da72c0184e86a7d52085b426440c Mon Sep 17 00:00:00 2001 From: Alvaro Saurin Date: Thu, 2 Jul 2015 13:23:32 +0200 Subject: [PATCH 71/82] Removed all the imports from "code.google.com" --- prog/weaveproxy/main.go | 2 +- router/crypto.go | 6 +++--- router/ethernet_decoder.go | 4 ++-- router/forwarder.go | 4 ++-- router/pcap.go | 2 +- router/udp_sender.go | 4 ++-- 6 files changed, 11 insertions(+), 11 deletions(-) diff --git a/prog/weaveproxy/main.go b/prog/weaveproxy/main.go index d4fdfcd8..150b4788 100644 --- a/prog/weaveproxy/main.go +++ b/prog/weaveproxy/main.go @@ -5,7 +5,7 @@ import ( "os" "strings" - "code.google.com/p/getopt" + "github.com/pborman/getopt" . "github.com/weaveworks/weave/common" "github.com/weaveworks/weave/proxy" ) diff --git a/router/crypto.go b/router/crypto.go index 291603d1..b66d2b73 100644 --- a/router/crypto.go +++ b/router/crypto.go @@ -8,9 +8,9 @@ import ( "fmt" "sync" - "code.google.com/p/go-bit/bit" - "code.google.com/p/go.crypto/nacl/box" - "code.google.com/p/go.crypto/nacl/secretbox" + "github.com/andybalholm/go-bit" + "golang.org/x/crypto/nacl/box" + "golang.org/x/crypto/nacl/secretbox" ) func GenerateKeyPair() (publicKey, privateKey *[32]byte, err error) { diff --git a/router/ethernet_decoder.go b/router/ethernet_decoder.go index d989d48a..0404f182 100644 --- a/router/ethernet_decoder.go +++ b/router/ethernet_decoder.go @@ -4,8 +4,8 @@ import ( "bytes" "net" - "code.google.com/p/gopacket" - "code.google.com/p/gopacket/layers" + "github.com/google/gopacket" + "github.com/google/gopacket/layers" . "github.com/weaveworks/weave/common" ) diff --git a/router/forwarder.go b/router/forwarder.go index 0d9798d0..a61eb782 100644 --- a/router/forwarder.go +++ b/router/forwarder.go @@ -4,8 +4,8 @@ import ( "syscall" "time" - "code.google.com/p/gopacket" - "code.google.com/p/gopacket/layers" + "github.com/google/gopacket" + "github.com/google/gopacket/layers" ) type ForwardedFrame struct { diff --git a/router/pcap.go b/router/pcap.go index 07d8b1d9..36962f20 100644 --- a/router/pcap.go +++ b/router/pcap.go @@ -3,7 +3,7 @@ package router import ( "fmt" - "code.google.com/p/gopacket/pcap" + "github.com/google/gopacket/pcap" ) type PcapIO struct { diff --git a/router/udp_sender.go b/router/udp_sender.go index 2159898f..bbc89e14 100644 --- a/router/udp_sender.go +++ b/router/udp_sender.go @@ -4,8 +4,8 @@ import ( "net" "syscall" - "code.google.com/p/gopacket" - "code.google.com/p/gopacket/layers" + "github.com/google/gopacket" + "github.com/google/gopacket/layers" . "github.com/weaveworks/weave/common" ) From 3914c4c018afa48168804209abc5ec08285d1987 Mon Sep 17 00:00:00 2001 From: Adam Harrison Date: Fri, 26 Jun 2015 16:40:10 +0100 Subject: [PATCH 72/82] Enforce maximum length on proxy hostname derivation --- proxy/create_container_interceptor.go | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/proxy/create_container_interceptor.go b/proxy/create_container_interceptor.go index db9433ef..b7d8d0c2 100644 --- a/proxy/create_container_interceptor.go +++ b/proxy/create_container_interceptor.go @@ -13,6 +13,8 @@ import ( "github.com/weaveworks/weave/nameserver" ) +const MaxDockerHostname = 64 + type createContainerInterceptor struct{ proxy *Proxy } type createContainerRequestBody struct { @@ -110,9 +112,14 @@ func (i *createContainerInterceptor) setWeaveDNS(container *createContainerReque name := r.URL.Query().Get("name") if container.Hostname == "" && name != "" { - container.Hostname = name // Strip trailing period because it's unusual to see it used on the end of a host name - container.Domainname = strings.TrimSuffix(dnsDomain, ".") + trimmedDNSDomain := strings.TrimSuffix(dnsDomain, ".") + if len(name)+1+len(trimmedDNSDomain) > MaxDockerHostname { + Warning.Printf("Container name [%s] too long to be used as hostname", name) + } else { + container.Hostname = name + container.Domainname = trimmedDNSDomain + } } if len(container.HostConfig.DNSSearch) == 0 { From d1a887857d04cf095dfea3c4ca301544d334c122 Mon Sep 17 00:00:00 2001 From: Adam Harrison Date: Fri, 26 Jun 2015 17:44:37 +0100 Subject: [PATCH 73/82] Enforce maximum length on weave run hostname derivation --- weave | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/weave b/weave index b36721b0..9574975d 100755 --- a/weave +++ b/weave @@ -693,8 +693,13 @@ dns_args() { DNS_ARGS="--dns $DOCKER_BRIDGE_IP" if [ -n "$NAME_ARG" -a -z "$HOSTNAME_SPECIFIED" ] ; then DOMAIN=$(dns_domain) - DNS_ARGS="$DNS_ARGS --hostname=$NAME_ARG.${DOMAIN%.}" - HOSTNAME_SPECIFIED=1 + HOSTNAME="$NAME_ARG.${DOMAIN%.}" + if [ ${#HOSTNAME} -gt 64 ] ; then + echo "Container name too long to be used as hostname" >&2 + else + DNS_ARGS="$DNS_ARGS --hostname=$HOSTNAME" + HOSTNAME_SPECIFIED=1 + fi fi if [ -z "$DNS_SEARCH_SPECIFIED" ] ; then if [ -z "$HOSTNAME_SPECIFIED" ] ; then From d427c99161174b59fc9d14c2c0e3b43cf15c4cb7 Mon Sep 17 00:00:00 2001 From: Adam Harrison Date: Wed, 1 Jul 2015 14:35:39 +0100 Subject: [PATCH 74/82] Add smoke test --- test/270_use_name_as_hostname_test.sh | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/test/270_use_name_as_hostname_test.sh b/test/270_use_name_as_hostname_test.sh index ccb0ff86..9d59bbe9 100755 --- a/test/270_use_name_as_hostname_test.sh +++ b/test/270_use_name_as_hostname_test.sh @@ -33,4 +33,8 @@ assert_expected_fqdn "$HOSTNAME" -h $HOSTNAME --name=$NAME assert_expected_fqdn "$HOSTNAME" --hostname=$HOSTNAME --name=$NAME assert_expected_fqdn "$HOSTNAME" --hostname $HOSTNAME --name=$NAME +# Ensure we can launch a container with a name that is too long for hostname derivation +SIXTY_FIVE_CHARS=01234567890123456789012345678901234567890123456789012345678901234 +assert_raises "start_container $HOST1 --name=$SIXTY_FIVE_CHARS" + end_suite From 5b79e274e8e0cf36614c62d915644b567a744ba6 Mon Sep 17 00:00:00 2001 From: Paul Bellamy Date: Thu, 2 Jul 2015 17:04:21 +0100 Subject: [PATCH 75/82] fixup logging changes, so it compiles --- proxy/create_container_interceptor.go | 6 +++--- router/local_peer.go | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/proxy/create_container_interceptor.go b/proxy/create_container_interceptor.go index 14b4e411..e566aacc 100644 --- a/proxy/create_container_interceptor.go +++ b/proxy/create_container_interceptor.go @@ -9,7 +9,7 @@ import ( "strings" "github.com/fsouza/go-dockerclient" - . "github.com/weaveworks/weave/common" + "github.com/weaveworks/weave/common" "github.com/weaveworks/weave/nameserver" ) @@ -47,7 +47,7 @@ func (i *createContainerInterceptor) InterceptRequest(r *http.Request) error { } if cidrs, ok := i.proxy.weaveCIDRsFromConfig(container.Config); ok { - Log.Infof("Creating container with WEAVE_CIDR \"%s\"", strings.Join(cidrs, " ")) + common.Log.Infof("Creating container with WEAVE_CIDR \"%s\"", strings.Join(cidrs, " ")) if container.HostConfig == nil { container.HostConfig = &docker.HostConfig{} } @@ -114,7 +114,7 @@ func (i *createContainerInterceptor) setWeaveDNS(container *createContainerReque // Strip trailing period because it's unusual to see it used on the end of a host name trimmedDNSDomain := strings.TrimSuffix(dnsDomain, ".") if len(name)+1+len(trimmedDNSDomain) > MaxDockerHostname { - Warning.Printf("Container name [%s] too long to be used as hostname", name) + common.Log.Warningf("Container name [%s] too long to be used as hostname", name) } else { container.Hostname = name container.Domainname = trimmedDNSDomain diff --git a/router/local_peer.go b/router/local_peer.go index 395a7a2c..3c9ac880 100644 --- a/router/local_peer.go +++ b/router/local_peer.go @@ -71,7 +71,7 @@ func (peer *LocalPeer) RelayBroadcast(srcPeer *Peer, frame []byte, dec *Ethernet dec) if err != nil { if ftbe, ok := err.(FrameTooBigError); ok { - Log.Warnf("dropping too big DF broadcast frame (%v -> %v): PMTU= %v\n", dec.IP.DstIP, dec.IP.SrcIP, ftbe.EPMTU) + Log.Warningf("dropping too big DF broadcast frame (%v -> %v): PMTU= %v\n", dec.IP.DstIP, dec.IP.SrcIP, ftbe.EPMTU) } else { Log.Errorln(err) } From 07ee2df8228083724105a5ba4626cc8fd6fe01e4 Mon Sep 17 00:00:00 2001 From: Matthias Radestock Date: Thu, 2 Jul 2015 21:07:51 +0100 Subject: [PATCH 76/82] cosmetic(ish): use dotted import. like everywhere else --- proxy/create_container_interceptor.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/proxy/create_container_interceptor.go b/proxy/create_container_interceptor.go index e566aacc..723a3d0b 100644 --- a/proxy/create_container_interceptor.go +++ b/proxy/create_container_interceptor.go @@ -9,7 +9,7 @@ import ( "strings" "github.com/fsouza/go-dockerclient" - "github.com/weaveworks/weave/common" + . "github.com/weaveworks/weave/common" "github.com/weaveworks/weave/nameserver" ) @@ -47,7 +47,7 @@ func (i *createContainerInterceptor) InterceptRequest(r *http.Request) error { } if cidrs, ok := i.proxy.weaveCIDRsFromConfig(container.Config); ok { - common.Log.Infof("Creating container with WEAVE_CIDR \"%s\"", strings.Join(cidrs, " ")) + Log.Infof("Creating container with WEAVE_CIDR \"%s\"", strings.Join(cidrs, " ")) if container.HostConfig == nil { container.HostConfig = &docker.HostConfig{} } @@ -114,7 +114,7 @@ func (i *createContainerInterceptor) setWeaveDNS(container *createContainerReque // Strip trailing period because it's unusual to see it used on the end of a host name trimmedDNSDomain := strings.TrimSuffix(dnsDomain, ".") if len(name)+1+len(trimmedDNSDomain) > MaxDockerHostname { - common.Log.Warningf("Container name [%s] too long to be used as hostname", name) + Log.Warningf("Container name [%s] too long to be used as hostname", name) } else { container.Hostname = name container.Domainname = trimmedDNSDomain From 7d5dcfafc92d4b4afde3d148cc5c3f3b00b47b99 Mon Sep 17 00:00:00 2001 From: Matthias Radestock Date: Fri, 3 Jul 2015 03:33:23 +0100 Subject: [PATCH 77/82] introduce 'Proxy' as 'Docker API Proxy' in order to reduce potential confusion about its role. Closes #1019. --- README.md | 18 +++++++++--------- site/features.md | 6 ++++-- site/how-it-works.md | 5 +++-- site/proxy.md | 6 +++--- site/troubleshooting.md | 2 +- 5 files changed, 20 insertions(+), 17 deletions(-) diff --git a/README.md b/README.md index 4757e97f..2eb8f808 100644 --- a/README.md +++ b/README.md @@ -56,10 +56,10 @@ First start weave on $HOST1: host1$ weave launch && weave launch-dns && weave launch-proxy -this runs the weave router, DNS and proxy, each in their own -container. Next we configure our `DOCKER_HOST` environment variable to -point to the proxy, so that containers launched via the docker command -line are automatically attached to the weave network: +this runs the weave router, DNS and Docker API proxy, each in their +own container. Next we configure our `DOCKER_HOST` environment +variable to point to the proxy, so that containers launched via the +docker command line are automatically attached to the weave network: host1$ eval $(weave proxy-env) @@ -92,11 +92,11 @@ 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). -The router, DNS and proxy need to 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. +The router, DNS and Docker API proxy need to 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... diff --git a/site/features.md b/site/features.md index 848bce29..e25d63e1 100644 --- a/site/features.md +++ b/site/features.md @@ -57,8 +57,10 @@ our data centre. ### Seamless Docker integration -Weave includes a [proxy](proxy.html) so that containers launched via -the Docker [command-line interface](https://docs.docker.com/reference/commandline/cli/) or +Weave includes a [Docker API proxy](proxy.html) so that containers +launched via the Docker +[command-line interface](https://docs.docker.com/reference/commandline/cli/) +or [remote API](https://docs.docker.com/reference/api/docker_remote_api/) are attached to the weave network before they begin execution. diff --git a/site/how-it-works.md b/site/how-it-works.md index 815fb60f..4e570c7c 100644 --- a/site/how-it-works.md +++ b/site/how-it-works.md @@ -29,8 +29,9 @@ encrypted, which carry encapsulated network packets. These Weave creates a network bridge on the host. Each container is connected to that bridge via a veth pair, the container side of which -is given the IP address & netmask supplied by the proxy. Also -connected to the bridge is the weave router container. +is given an IP address & netmask supplied either by the user or +Weave's IP address allocator. Also connected to the bridge is the +weave router container. A weave router captures Ethernet packets from its bridge-connected interface in promiscuous mode, using 'pcap'. This typically excludes diff --git a/site/proxy.md b/site/proxy.md index 4271c369..e42fcdd3 100644 --- a/site/proxy.md +++ b/site/proxy.md @@ -3,10 +3,10 @@ title: Weave Proxy layout: default --- -# Weave Proxy +# Weave Docker API Proxy -The proxy automatically attaches containers to the weave network when -they are started using the ordinary Docker +The Docker API proxy automatically attaches containers to the weave +network when they are started using the ordinary Docker [command-line interface](https://docs.docker.com/reference/commandline/cli/) or [remote API](https://docs.docker.com/reference/api/docker_remote_api/), diff --git a/site/troubleshooting.md b/site/troubleshooting.md index f988da07..8c05a828 100644 --- a/site/troubleshooting.md +++ b/site/troubleshooting.md @@ -142,7 +142,7 @@ is waiting for a while before connecting again. There may also be further sections for the [IP address allocator](ipam.html#troubleshooting), [weaveDNS](weavedns.html#troubleshooting), and -[proxy](proxy.html#troubleshooting). +[Weave Docker API Proxy](proxy.html#troubleshooting). ### List attached containers From 8b35f5e8feb33c66cdc9d3dbcd88c81636151d73 Mon Sep 17 00:00:00 2001 From: Matthias Radestock Date: Fri, 3 Jul 2015 10:03:07 +0100 Subject: [PATCH 78/82] fix typo in comment --- ipam/ring/ring.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ipam/ring/ring.go b/ipam/ring/ring.go index 127175e8..ac964b8d 100644 --- a/ipam/ring/ring.go +++ b/ipam/ring/ring.go @@ -348,9 +348,9 @@ func (r *Ring) String() string { return buffer.String() } -// ReportFree is used by the allocator to tell the ring -// how many free ips are in a given range, so that ChoosePeerToAskForSpace -// can make more intelligent decisions. +// ReportFree is used by the allocator to tell the ring how many free +// ips are in a given range, so that ChoosePeersToAskForSpace can make +// more intelligent decisions. func (r *Ring) ReportFree(freespace map[address.Address]address.Offset) { r.assertInvariants() defer r.assertInvariants() From 65cd2b0e04a7a7ff2724913411eec920ee8f6f7d Mon Sep 17 00:00:00 2001 From: Matthias Radestock Date: Fri, 3 Jul 2015 10:58:22 +0100 Subject: [PATCH 79/82] missed one --- site/proxy.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/site/proxy.md b/site/proxy.md index e42fcdd3..e01633ad 100644 --- a/site/proxy.md +++ b/site/proxy.md @@ -1,5 +1,5 @@ --- -title: Weave Proxy +title: Weave Docker API Proxy layout: default --- From 9009e0eb7fc2d7aa147b97048419ec86920b6369 Mon Sep 17 00:00:00 2001 From: Matthias Radestock Date: Fri, 3 Jul 2015 11:45:05 +0100 Subject: [PATCH 80/82] one more s/proxy/Weave Docker API proxy --- site/weavedns.md | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/site/weavedns.md b/site/weavedns.md index 48d57255..424fe8d4 100644 --- a/site/weavedns.md +++ b/site/weavedns.md @@ -73,9 +73,10 @@ Finally, WeaveDNS containers can be stopped with `stop-dns`. The weaveDNS container running on every host acts as the nameserver for containers on that host. It learns about hostnames for local -containers from the proxy and from the `weave run` command. If a -hostname is in the `.weave.local` domain then weaveDNS records the -association of that name with the container's weave IP address(es). +containers from the Weave Docker API proxy and from the `weave run` +command. If a hostname is in the `.weave.local` domain then weaveDNS +records the association of that name with the container's weave IP +address(es). When weaveDNS is queried for a name in the `.weave.local` domain, it first checks its own records. If the name is not found there, it asks From 3ea1448c5250df7b83a2da08ade07d00581d2d6f Mon Sep 17 00:00:00 2001 From: Matthias Radestock Date: Fri, 3 Jul 2015 11:49:20 +0100 Subject: [PATCH 81/82] cosmetic --- README.md | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 186431cf..1d7b7253 100644 --- a/README.md +++ b/README.md @@ -4,7 +4,14 @@ # About Weaveworks -[Weaveworks](http://weave.works) is the company that develops Weave - the most productive way for developers to connect, observe and control Docker containers. To learn about our products, including getting started tutorials, visit our [website](http://weave.works), read about the [1.0 release of Weave](http://blog.weave.works/2015/06/18/weave-1-0-is-out-and-it-is-good/), visit our [documentation](http://docs.weave.works) or continue to read about some of the more technical aspects of Weave in this readme. +[Weaveworks](http://weave.works) is the company that develops Weave - +the most productive way for developers to connect, observe and control +Docker containers. To learn about our products, including getting +started tutorials, visit our [website](http://weave.works), read about +the +[1.0 release of Weave](http://blog.weave.works/2015/06/18/weave-1-0-is-out-and-it-is-good/), +visit our [documentation](http://docs.weave.works) or continue to read +about some of the more technical aspects of Weave in this readme. # Weave From b81fce32f6b4b095b8452703103ecda430065e94 Mon Sep 17 00:00:00 2001 From: Matthias Radestock Date: Fri, 3 Jul 2015 11:51:12 +0100 Subject: [PATCH 82/82] one more s/proxy/Weave Docker API proxy --- site/weavedns.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/site/weavedns.md b/site/weavedns.md index 61cc8b82..2efee67e 100644 --- a/site/weavedns.md +++ b/site/weavedns.md @@ -28,8 +28,8 @@ hosts. WeaveDNS is deployed as a set of containers that communicate with each other over the weave network. One such container needs to be started -on every weave host, either simultaneously with the router and proxy -via `launch`: +on every weave host, either simultaneously with the Weave router and +Weave Docker API proxy via `launch`: ```bash host1$ weave launch