gui: Fix scopes in notification directive (fixes #4941) (#4948)

The directive lives in its own isolated scope (where we put the visible() function). The stuff transcluded into the notification directive lives in the root scope and doesn't have access to the directive scope. Hence we cannot call dismiss() from inside the directive.

Similarly, config does not exist by itself in the directive scope, we need $parent to access the root scope.

Reference: https://docs.angularjs.org/guide/directive#isolating-the-scope-of-a-directive

How this worked before is a mystery. My guess is Angular bug with directive scope that was fixed in 1.3. One possibility is that transclude plus scope: true (which doesn't make sense as that is supposed to be an object) resulted in the root scope being used in the directive itself. This would then "work" as long as there is only one notification, as visible() and dismiss() would then be registered on the root scope, thus accessible from within the notification but also overridden by any notification rendered.

.gitattributes

@@ -2,8 +2,7 @@
 *   text=auto
 
 # Except the dependencies, which we leave alone
-Godeps/**   -text=auto
+vendor/**   -text=auto
 
 # Diffs on these files are meaningless
-gui.files.go    -diff
 *.svg           -diff

.github/CODEOWNERS

@@ -0,0 +1,2 @@
+/AUTHORS    @calmh
+/*.md       @calmh

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,34 @@
+### DO NOT REPORT SECURITY ISSUES IN THIS ISSUE TRACKER
+
+Instead, contact security@syncthing.net directly - see
+https://syncthing.net/security.html for more information.
+
+### DO NOT POST SUPPORT REQUESTS OR GENERAL QUESTIONS IN THIS ISSUE TRACKER
+
+Please use the forum at https://forum.syncthing.net/ where a large number of
+helpful people hang out. This issue tracker is for reporting bugs or feature
+requests directly to the developers. Worst case you might get a short
+"that's a bug, please report it on GitHub" response on the forum, in which
+case we thank you for your patience and following our advice. :)
+
+### Please do post actual bug reports and feature requests.
+
+If your issue is a bug report, replace this boilerplate with a description
+of the problem, being sure to include at least:
+
+ - what happened,
+ - what you expected to happen instead, and
+ - any steps to reproduce the problem.
+
+Also fill out the version information below and add log output or
+screenshots as appropriate.
+
+If your issue is a feature request, simply replace this template text in
+its entirety.
+
+### Version Information
+
+Syncthing Version: v0.x.y
+OS Version: Windows 7 / Ubuntu 14.04 / ...
+Browser Version: (if applicable, for GUI issues)
+

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,32 @@
+### Purpose
+
+Describe the purpose of this change. If there is an existing issue that is
+resolved by this pull request, ensure that the commit subject is on the form
+`Some short description (fixes #1234)` where 1234 is the issue number.
+
+### Testing
+
+Describe what testing has been done, and how the reviewer can test the change
+if new tests are not included.
+
+### Screenshots
+
+If this is a GUI change, include screenshots of the change. If not, please
+feel free to just delete this section.
+
+### Documentation
+
+If this is a user visible change (including API and protocol changes), add a link here
+to the corresponding pull request on https://github.com/syncthing/docs or describe
+the documentation changes necessary.
+
+### Authorship
+
+Every author of a code contribution (Go, Javascript, HTML, CSS etc, with the
+possible exception of minor typo corrections and similar) is recorded in the
+AUTHORS and NICKS files and the in-GUI credits. If this is your first
+contribution, a maintainer will add you properly before accepting the
+contribution. You need not do so yourself or worry about the fact that the
+"authors" automated test fails. However, if your name (such as you want it
+presented in the credits) is not visible on your Github profile or in your
+commit messages, please assist by providing it here.

.gitignore

@@ -1,16 +1,19 @@
-./syncthing
+/syncthing
+/stdiscosrv
 syncthing.exe
+stdiscosrv.exe
 *.tar.gz
 *.zip
 *.asc
+*.deb
 .jshintrc
 coverage.out
 files/pidx
 bin
 perfstats*.csv
 coverage.xml
-!gui/scripts/syncthing
-syncthing.md5
-syncthing.exe.md5
+syncthing.sig
 RELEASE
 deb
+lib/auto/gui.files.go
+snapcraft.yaml

.mailmap

@@ -1 +0,0 @@
-NICKS

AUTHORS

@@ -1,67 +1,134 @@
 # This is the official list of Syncthing authors for copyright purposes.
+# The format is:
+#
+#    Name Name Name (nickname) <email1@example.com> <email2@example.com>
+#
+# After changing this list, run "go run script/authors.go" to sort and update
+# the GUI HTML.
+#
 
-Aaron Bieber <qbit@deftly.net>
-Adam Piggott	<aD@simplypeachy.co.uk> <simplypeachy@users.noreply.github.com>
-Alexander Graf <register-github@alex-graf.de>
-Andrew Dunham <andrew@du.nham.ca>
-Antony Male <antony.male@gmail.com>
-Arthur Axel fREW Schmidt <frew@afoolishmanifesto.com> <frioux@gmail.com>
-Audrius Butkevicius <audrius.butkevicius@gmail.com>
-Bart De Vries <devriesb@gmail.com>
-Ben Curthoys <ben@bencurthoys.com>
-Ben Schulz <ueomkail@gmail.com> <uok@users.noreply.github.com>
-Ben Sidhom <bsidhom@gmail.com>
-Brandon Philips <brandon@ifup.org>
-Brendan Long <self@brendanlong.com>
-Brian R. Becker <brbecker@gmail.com>
-Caleb Callaway <enlightened.despot@gmail.com>
-Carsten Hagemann <moter8@gmail.com>
-Cathryne Linenweaver <cathryne.linenweaver@gmail.com> <Cathryne@users.noreply.github.com>
-Chris Howie <me@chrishowie.com>
-Chris Joel <chris@scriptolo.gy>
-Colin Kennedy <moshen.colin@gmail.com>
-Daniel Bergmann <dan.arne.bergmann@gmail.com> <brgmnn@users.noreply.github.com>
-Daniel Martí <mvdan@mvdan.cc>
-Denis A. <denisva@gmail.com>
-Dennis Wilson <dw@risu.io>
-Dominik Heidler <dominik@heidler.eu>
-Elias Jarlebring <jarlebring@gmail.com>
-Emil Hessman <emil@hessman.se>
-Erik Meitner <e.meitner@willystreet.coop>
-Federico Castagnini <federico.castagnini@gmail.com>
-Felix Ableitner <me@nutomic.com>
-Felix Unterpaintner <bigbear2nd@gmail.com>
-Francois-Xavier Gsell <fxgsell@gmail.com>
-Frank Isemann <frank@isemann.name>
-Gilli Sigurdsson <gilli@vx.is>
-Jacek Szafarkiewicz <szafar@linux.pl>
-Jakob Borg <jakob@nym.se>
-James Patterson <jamespatterson@operamail.com> <jpjp@users.noreply.github.com>
-Jaroslav Malec <dzardacz@gmail.com>
-Jens Diemer <github.com@jensdiemer.de> <git@jensdiemer.de>
-Jochen Voss <voss@seehuhn.de>
-Johan Vromans <jvromans@squirrel.nl>
-Karol Różycki <rozycki.karol@gmail.com>
-Ken'ichi Kamada <kamada@nanohz.org>
-Lode Hoste <zillode@zillode.be>
-Lord Landon Agahnim <lordlandon@gmail.com>
-Marc Laporte <marc@marclaporte.com> <marc@laporte.name>
-Marc Pujol <kilburn@la3.org>
-Marcin Dziadus <dziadus.marcin@gmail.com>
-Matt Burke <mburke@amplify.com>
-Michael Jephcote <rewt0r@gmx.com> <Rewt0r@users.noreply.github.com>
-Michael Tilli <pyfisch@gmail.com>
-Pascal Jungblut <github@pascalj.com> <mail@pascal-jungblut.com>
-Peter Hoeg <peter@speartail.com>
-Philippe Schommers <philippe@schommers.be>
-Phill Luby <phill.luby@newredo.com>
-Piotr Bejda <piotrb10@gmail.com>
-Ryan Sullivan <kayoticsully@gmail.com>
-Sergey Mishin <ralder@yandex.ru>
-Stefan Tatschner <stefan@sevenbyte.org> <rumpelsepp@sevenbyte.org>
-Tim Abell <tim@timwise.co.uk>
-Tobias Nygren <tnn@nygren.pp.se>
-Tomas Cerveny <kozec@kozec.com>
-Tully Robinson <tully@tojr.org>
-Veeti Paananen <veeti.paananen@rojekti.fi>
-Vil Brekin <vilbrekin@gmail.com>
+Aaron Bieber (qbit) <qbit@deftly.net>
+Adam Piggott (ProactiveServices) <aD@simplypeachy.co.uk> <simplypeachy@users.noreply.github.com> <ProactiveServices@users.noreply.github.com>
+Adel Qalieh (adelq) <aqalieh95@gmail.com> <adelq@users.noreply.github.com>
+Alessandro G. (alessandro.g89) <alessandro.g89@gmail.com>
+Alexander Graf (alex2108) <register-github@alex-graf.de>
+Alexandre Viau (aviau) <alexandre@alexandreviau.net> <aviau@debian.org>
+Anderson Mesquita (andersonvom) <andersonvom@gmail.com>
+Andrew Dunham (andrew-d) <andrew@du.nham.ca>
+Andrey D (scienmind) <scintertech@cryptolab.net>
+Antoine Lamielle (0x010C) <antoine.lamielle@0x010c.fr> <gh@0x010c.fr>
+Antony Male (canton7) <antony.male@gmail.com>
+Arthur Axel fREW Schmidt (frioux) <frew@afoolishmanifesto.com> <frioux@gmail.com>
+Audrius Butkevicius (AudriusButkevicius) <audrius.butkevicius@gmail.com>
+Bart De Vries (mogwa1) <devriesb@gmail.com>
+Ben Curthoys (bencurthoys) <ben@bencurthoys.com>
+Ben Schulz (uok) <ueomkail@gmail.com> <uok@users.noreply.github.com>
+Ben Shepherd (benshep) <bjashepherd@gmail.com>
+Ben Sidhom (bsidhom) <bsidhom@gmail.com>
+Benny Ng (tpng) <benny.tpng@gmail.com>
+Brandon Philips (philips) <brandon@ifup.org>
+Brendan Long (brendanlong) <self@brendanlong.com>
+Brian R. Becker (brbecker) <brbecker@gmail.com>
+Caleb Callaway (cqcallaw) <enlightened.despot@gmail.com>
+Carsten Hagemann (Moter8) <moter8@gmail.com>
+Cathryne Linenweaver (Cathryne) <cathryne.linenweaver@gmail.com> <Cathryne@users.noreply.github.com>
+Cedric Staniewski (xduugu) <cedric@gmx.ca>
+Chris Howie (cdhowie) <me@chrishowie.com>
+Chris Joel (cdata) <chris@scriptolo.gy>
+Colin Kennedy (moshen) <moshen.colin@gmail.com>
+Daniel Bergmann (brgmnn) <dan.arne.bergmann@gmail.com> <brgmnn@users.noreply.github.com>
+Daniel Harte (norgeous) <daniel@harte.me> <daniel@danielharte.co.uk> <norgeous@users.noreply.github.com>
+Daniel Martí (mvdan) <mvdan@mvdan.cc>
+Darshil Chanpura (dtchanpura) <dtchanpura@gmail.com> <dcprime314@gmail.com>
+David Rimmer (dinosore) <dinosore@dbrsoftware.co.uk>
+Denis A. (dva) <denisva@gmail.com>
+Dennis Wilson (snnd) <dw@risu.io>
+Dmitry Saveliev (dsaveliev) <d.e.saveliev@gmail.com>
+Dominik Heidler (asdil12) <dominik@heidler.eu>
+Elias Jarlebring (jarlebring) <jarlebring@gmail.com>
+Emil Hessman (ceh) <emil@hessman.se>
+Erik Meitner (WSGCSysadmin) <e.meitner@willystreet.coop>
+Federico Castagnini (facastagnini) <federico.castagnini@gmail.com>
+Felix Ableitner (Nutomic) <me@nutomic.com>
+Felix Unterpaintner (bigbear2nd) <bigbear2nd@gmail.com>
+Francois-Xavier Gsell (zukoo) <fxgsell@gmail.com>
+Frank Isemann (fti7) <frank@isemann.name>
+Gilli Sigurdsson (gillisig) <gilli@vx.is>
+Graham Miln (grahammiln) <graham.miln@dssw.co.uk> <graham.miln@miln.eu>
+Harrison Jones (harrisonhjones) <harrisonhjones@users.noreply.github.com>
+Heiko Zuerker (Smiley73) <heiko@zuerker.org>
+Jaakko Hannikainen (jgke) <jgke@jgke.fi>
+Jacek Szafarkiewicz (hadogenes) <szafar@linux.pl>
+Jake Peterson (acogdev) <jake@acogdev.com>
+Jakob Borg (calmh) <jakob@nym.se> <jakob@kastelo.net>
+James Patterson (jpjp) <jamespatterson@operamail.com> <jpjp@users.noreply.github.com>
+Jaroslav Malec (dzarda) <dzardacz@gmail.com>
+Jaya Chithra (jayachithra) <s.k.jayachithra@gmail.com>
+Jens Diemer (jedie) <github.com@jensdiemer.de> <git@jensdiemer.de>
+Jochen Voss (seehuhn) <voss@seehuhn.de>
+Johan Vromans (sciurius) <jvromans@squirrel.nl>
+John Rinehart (fuzzybear3965) <johnrichardrinehart@gmail.com>
+Jose Manuel Delicado (jmdaweb) <jmdaweb@hotmail.com> <jmdaweb@users.noreply.github.com>
+Karol Różycki (krozycki) <rozycki.karol@gmail.com>
+Kelong Cong (kc1212) <kc04bc@gmx.com> <kc1212@users.noreply.github.com>
+Ken'ichi Kamada (kamadak) <kamada@nanohz.org>
+Kevin Allen (ironmig) <kma1660@gmail.com>
+Kevin White, Jr. (kwhite17) <kevinwhite1710@gmail.com>
+Kurt Fitzner (Kudalufi) <kurt@va1der.ca> <kurt.fitzner@gmail.com>
+Lars K.W. Gohlke (lkwg82) <lkwg82@gmx.de>
+Laurent Etiemble (letiemble) <laurent.etiemble@gmail.com> <laurent.etiemble@monobjc.net>
+Leo Arias (elopio) <yo@elopio.net>
+Liu Siyuan (liusy182) <liusy182@gmail.com> <liusy182@hotmail.com>
+Lode Hoste (Zillode) <zillode@zillode.be>
+Lord Landon Agahnim (LordLandon) <lordlandon@gmail.com>
+Majed Abdulaziz (majedev) <majed.alhajry@gmail.com>
+Marc Laporte (marclaporte) <marc@marclaporte.com> <marc@laporte.name>
+Marc Pujol (kilburn) <kilburn@la3.org>
+Marcin Dziadus (marcindziadus) <dziadus.marcin@gmail.com>
+Mark Pulford (mpx) <mark@kyne.com.au>
+Mateusz Naściszewski (mateon1) <matin1111@wp.pl>
+Matt Burke (burkemw3) <mburke@amplify.com> <burkemw3@gmail.com>
+Max Schulze (kralo) <max.schulze@online.de> <kralo@users.noreply.github.com>
+Michael Jephcote (Rewt0r) <rewt0r@gmx.com> <Rewt0r@users.noreply.github.com>
+Michael Ploujnikov (plouj) <ploujj@gmail.com>
+Michael Tilli (pyfisch) <pyfisch@gmail.com>
+Nate Morrison (nrm21) <natemorrison@gmail.com>
+Nicholas Rishel (PrototypeNM1) <rishel.nick@gmail.com> <PrototypeNM1@users.noreply.github.com>
+Niels Peter Roest (Niller303) <nielsproest@hotmail.com> <seje.niels@hotmail.com>
+Nils Jakobi (thunderstorm99) <jakobi.nils@gmail.com>
+Pascal Jungblut (pascalj) <github@pascalj.com> <mail@pascal-jungblut.com>
+Pawel Palenica (qepasa) <pawelpalenica11@gmail.com>
+Peter Hoeg (peterhoeg) <peter@speartail.com>
+Peter Marquardt (wwwutz) <wwwutz@gmail.com> <wwwutz@googlemail.com>
+Philippe Schommers (filoozoom) <philippe@schommers.be>
+Phill Luby (pluby) <phill.luby@newredo.com>
+Piotr Bejda (piobpl) <piotrb10@gmail.com>
+Pramodh KP (pramodhkp) <pramodh.p@directi.com> <1507241+pramodhkp@users.noreply.github.com>
+Robert Carosi (nov1n) <robert@carosi.nl>
+Roman Zaynetdinov (zaynetro) <romanznet@gmail.com>
+Ross Smith II (rasa) <ross@smithii.com>
+Ryan Sullivan (KayoticSully) <kayoticsully@gmail.com>
+Sacheendra Talluri (sacheendra) <sacheendra.t@gmail.com>
+Scott Klupfel (kluppy) <kluppy@going2blue.com>
+Sergey Mishin (ralder) <ralder@yandex.ru>
+Simon Frei (imsodin) <freisim93@gmail.com>
+Stefan Kuntz (Stefan-Code) <stefan.github@gmail.com> <Stefan.github@gmail.com>
+Stefan Tatschner (rumpelsepp) <stefan@sevenbyte.org> <rumpelsepp@sevenbyte.org>
+Suhas Gundimeda (snugghash) <suhas.gundimeda@gmail.com> <snugghash@gmail.com>
+Taylor Khan (nelsonkhan) <nelsonkhan@gmail.com>
+Tim Abell (timabell) <tim@timwise.co.uk>
+Tim Howes (timhowes) <timhowes@berkeley.edu>
+Tobias Nygren (tnn2) <tnn@nygren.pp.se>
+Tobias Tom (tobiastom) <t.tom@succont.de>
+Tomas Cerveny (kozec) <kozec@kozec.com>
+Tully Robinson (tojrobinson) <tully@tojr.org>
+Tyler Brazier (tylerbrazier) <tyler@tylerbrazier.com>
+Unrud (Unrud) <unrud@openaliasbox.org> <Unrud@users.noreply.github.com>
+Veeti Paananen (veeti) <veeti.paananen@rojekti.fi>
+Victor Buinsky (buinsky) <vix_booja@tut.by>
+Vil Brekin (Vilbrekin) <vilbrekin@gmail.com>
+William A. Kennington III (wkennington) <william@wkennington.com>
+Wulf Weich (wweich) <wweich@users.noreply.github.com> <wweich@gmx.de> <wulf@weich-kr.de>
+Xavier O. (damajor) <damajor@gmail.com>
+xjtdy888 (xjtdy888) <xjtdy888@163.com>
+Yannic A. (eipiminus1) <eipiminusone+github@gmail.com> <eipiminus1@users.noreply.github.com>

CONTRIBUTING.md

@@ -33,20 +33,31 @@ latest info on Transifex.
 
 Every contribution is welcome. If you want to contribute but are unsure
 where to start, any open issues are fair game! See the [Contribution
-Guidelines](http://docs.syncthing.net/dev/contributing.html) for the full
+Guidelines](https://docs.syncthing.net/dev/contributing.html) for the full
 story on committing code.
 
 ## Contributing Documentation
 
-Updates to the [documentation site](http://docs.syncthing.net/) can be
+Updates to the [documentation site](https://docs.syncthing.net/) can be
 made as pull requests on the [documentation
 repository](https://github.com/syncthing/docs).
 
 ## Licensing
 
-All contributions are made under the same MPLv2 license as the rest of
-the project, except documentation, user interface text and translation
-strings which are licensed under the Creative Commons Attribution 4.0
-International License. You retain the copyright to code you have
-written.
+All contributions are made available under the same license as the already
+existing material being contributed to. For most of the project and unless
+otherwise stated this means MPLv2, but there are exceptions:
+
+- Certain commands (under cmd/...) may have a separate license, indicated by
+  the presence of a LICENSE file in the corresponding directory.
+
+- The documentation (man/...) is licensed under the Creative Commons
+  Attribution 4.0 International License.
+
+- Projects under vendor/... are copyright by and licensed from their
+  respective original authors. Contributions should be made to the original
+  project, not here.
+
+Regardless of the license in effect, you retain the copyright to your
+contribution.
 

Dockerfile

@@ -0,0 +1,32 @@
+FROM golang:1.10 AS builder
+
+WORKDIR /go/src/github.com/syncthing/syncthing
+COPY . .
+
+ENV CGO_ENABLED=0
+ENV BUILD_HOST=syncthing.net
+ENV BUILD_USER=docker
+RUN rm -f syncthing && go run build.go build syncthing
+
+FROM alpine
+
+EXPOSE 8384 22000 21027/udp
+
+VOLUME ["/var/syncthing"]
+
+RUN apk add --no-cache ca-certificates
+
+COPY --from=builder /go/src/github.com/syncthing/syncthing/syncthing /bin/syncthing
+
+RUN echo 'syncthing:x:1000:1000::/var/syncthing:/sbin/nologin' >> /etc/passwd \
+    && echo 'syncthing:!::0:::::' >> /etc/shadow \
+    && chown syncthing /var/syncthing
+
+USER syncthing
+ENV STNOUPGRADE=1
+
+HEALTHCHECK --interval=1m --timeout=10s \
+  CMD nc -z localhost 8384 || exit 1
+
+ENTRYPOINT ["/bin/syncthing", "-home", "/var/syncthing/config", "-gui-address", "0.0.0.0:8384"]
+

GOALS.md

@@ -0,0 +1,83 @@
+# The Syncthing Goals
+
+Syncthing is a **continuous file synchronization program**. It synchronizes
+files between two or more computers. We strive to fulfill the goals below.
+The goals are listed in order of importance, the most important one being
+the first.
+
+> "Syncing files" here is precise. It means we specifically exclude things
+> that are not files - calendar items, instant messages, and so on. If those
+> are in fact stored as files on disk, they can of course be synced as
+> files.
+
+Syncthing should be:
+
+### 1. Safe From Data Loss
+
+Protecting the user's data is paramount. We take every reasonable precaution
+to avoid corrupting the user's files.
+
+> This is the overriding goal, without which synchronizing files becomes
+> pointless. This means that we do not make unsafe trade offs for the sake
+> of performance or, in some cases, even usability.
+
+### 2. Secure Against Attackers
+
+Again, protecting the user's data is paramount. Regardless of our other
+goals we must never allow the user's data to be susceptible to eavesdropping
+or modification by unauthorized parties.
+
+> This should be understood in context. It is not necessarily reasonable to
+> expect Syncthing to be resistant against well equipped state level
+> attackers. We will however do our best. Note also that this is different
+> from anonymity which is not, currently, a goal.
+
+### 3. Easy to Use
+
+Syncthing should be approachable, understandable and inclusive.
+
+> Complex concepts and maths form the base of Syncthing's functionality.
+> This should nonetheless be abstracted or hidden to a degree where
+> Syncthing is usable by the general public.
+
+### 4. Automatic
+
+User interaction should be required only when absolutely necessary.
+
+> Specifically this means that changes to files are picked up without
+> prompting, conflicts are resolved without prompting and connections are
+> maintained without prompting. We only prompt the user when it is required
+> to fulfill one of the (overriding) Secure, Safe or Easy goals.
+
+### 5. Universally Available
+
+Syncthing should run on every common computer. We are mindful that the
+latest technology is not always available to any given individual.
+
+> Computers include desktops, laptops, servers, virtual machines, small
+> general purpose computers such as Raspberry Pis and, *where possible*,
+> tablets and phones. NAS appliances, toasters, cars, firearms, thermostats
+> and so on may include computing capabitilies but it is not our goal for
+> Syncthing to run smoothly on these devices.
+
+### 6. For Individuals
+
+Syncthing is primarily about empowering the individual user with safe,
+secure and easy to use file synchronization.
+
+> We acknowledge that it's also useful in an enterprise setting and include
+> functionality to support that. If this is in conflict with the
+> requirements of the individual, those will however take priority.
+
+### 7. Everything Else
+
+There are many things we care about that don't make it on to the list. It is
+fine to optimize for these values as well, as long as they are not in
+conflict with the stated goals above.
+
+> For example, performance is a thing we care about. We just don't care more
+> about it than safety, security, etc. Maintainability of the code base and
+> providing entertainment value for the maintainers are also things that
+> matter. It is understood that there are aspects of Syncthing that are
+> suboptimal or even in opposition with the goals above. However, we
+> continuously strive to align Syncthing more and more with these goals.

Godeps/Godeps.json

@@ -1,90 +0,0 @@
-{
-	"ImportPath": "github.com/syncthing/syncthing",
-	"GoVersion": "go1.5",
-	"Packages": [
-		"./cmd/..."
-	],
-	"Deps": [
-		{
-			"ImportPath": "github.com/bkaradzic/go-lz4",
-			"Rev": "d47913b1412890a261b9fefae99d72d2bf5aebd8"
-		},
-		{
-			"ImportPath": "github.com/calmh/du",
-			"Rev": "3c0690cca16228b97741327b1b6781397afbdb24"
-		},
-		{
-			"ImportPath": "github.com/calmh/logger",
-			"Rev": "c96f6a1a8c7b6bf2f4860c667867d90174799eb2"
-		},
-		{
-			"ImportPath": "github.com/calmh/luhn",
-			"Rev": "0c8388ff95fa92d4094011e5a04fc99dea3d1632"
-		},
-		{
-			"ImportPath": "github.com/calmh/xdr",
-			"Rev": "5f7208e86762911861c94f1849eddbfc0a60cbf0"
-		},
-		{
-			"ImportPath": "github.com/golang/snappy",
-			"Rev": "723cc1e459b8eea2dea4583200fd60757d40097a"
-		},
-		{
-			"ImportPath": "github.com/juju/ratelimit",
-			"Rev": "772f5c38e468398c4511514f4f6aa9a4185bc0a0"
-		},
-		{
-			"ImportPath": "github.com/kardianos/osext",
-			"Rev": "6e7f843663477789fac7c02def0d0909e969b4e5"
-		},
-		{
-			"ImportPath": "github.com/syncthing/protocol",
-			"Rev": "388a29bbe21d8772ee4c29f4520aa8040309607d"
-		},
-		{
-			"ImportPath": "github.com/syndtr/goleveldb/leveldb",
-			"Rev": "b743d92d3215f11c9b5ce8830fafe1f16786adf4"
-		},
-		{
-			"ImportPath": "github.com/thejerf/suture",
-			"Comment": "v1.0.1",
-			"Rev": "99c1f2d613756768fc4299acd9dc621e11ed3fd7"
-		},
-		{
-			"ImportPath": "github.com/vitrun/qart/coding",
-			"Rev": "ccb109cf25f0cd24474da73b9fee4e7a3e8a8ce0"
-		},
-		{
-			"ImportPath": "github.com/vitrun/qart/gf256",
-			"Rev": "ccb109cf25f0cd24474da73b9fee4e7a3e8a8ce0"
-		},
-		{
-			"ImportPath": "github.com/vitrun/qart/qr",
-			"Rev": "ccb109cf25f0cd24474da73b9fee4e7a3e8a8ce0"
-		},
-		{
-			"ImportPath": "golang.org/x/crypto/bcrypt",
-			"Rev": "c16968172724c0b5e8bdc6ad33f5a79443a44cd7"
-		},
-		{
-			"ImportPath": "golang.org/x/crypto/blowfish",
-			"Rev": "c16968172724c0b5e8bdc6ad33f5a79443a44cd7"
-		},
-		{
-			"ImportPath": "golang.org/x/net/internal/iana",
-			"Rev": "66f0418ca41253f8d1a024eb9754e9441a8e79b9"
-		},
-		{
-			"ImportPath": "golang.org/x/net/ipv6",
-			"Rev": "66f0418ca41253f8d1a024eb9754e9441a8e79b9"
-		},
-		{
-			"ImportPath": "golang.org/x/text/transform",
-			"Rev": "723492b65e225eafcba054e76ba18bb9c5ac1ea2"
-		},
-		{
-			"ImportPath": "golang.org/x/text/unicode/norm",
-			"Rev": "723492b65e225eafcba054e76ba18bb9c5ac1ea2"
-		}
-	]
-}

Godeps/Readme

@@ -1,5 +0,0 @@
-This directory tree is generated automatically by godep.
-
-Please do not edit.
-
-See https://github.com/tools/godep for more information.

Godeps/_workspace/.gitignore

@@ -1,2 +0,0 @@
-/pkg
-/bin

Godeps/_workspace/src/github.com/bkaradzic/go-lz4/.gitignore

@@ -1 +0,0 @@
-/lz4-example/lz4-example

Godeps/_workspace/src/github.com/bkaradzic/go-lz4/.travis.yml

@@ -1,8 +0,0 @@
-language: go
-
-go:
-  - 1.1
-  - 1.2
-  - 1.3
-  - 1.4
-  - tip

Godeps/_workspace/src/github.com/bkaradzic/go-lz4/README.md

@@ -1,71 +0,0 @@
-go-lz4
-======
-
-go-lz4 is port of LZ4 lossless compression algorithm to Go. The original C code
-is located at:
-
-https://github.com/Cyan4973/lz4
-
-Status
-------
-[![Build Status](https://secure.travis-ci.org/bkaradzic/go-lz4.png)](http://travis-ci.org/bkaradzic/go-lz4)  
-[![GoDoc](https://godoc.org/github.com/bkaradzic/go-lz4?status.png)](https://godoc.org/github.com/bkaradzic/go-lz4)
-
-Usage
------
-
-    go get github.com/bkaradzic/go-lz4
-
-    import "github.com/bkaradzic/go-lz4"
-
-The package name is `lz4`
-
-Notes
------
-
-* go-lz4 saves a uint32 with the original uncompressed length at the beginning
-  of the encoded buffer.  They may get in the way of interoperability with
-  other implementations.
-
-Contributors
-------------
-
-Damian Gryski ([@dgryski](https://github.com/dgryski))  
-Dustin Sallings ([@dustin](https://github.com/dustin))
-
-Contact
--------
-
-[@bkaradzic](https://twitter.com/bkaradzic)  
-http://www.stuckingeometry.com
-
-Project page  
-https://github.com/bkaradzic/go-lz4
-
-License
--------
-
-Copyright 2011-2012 Branimir Karadzic. All rights reserved.  
-Copyright 2013 Damian Gryski. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-   1. Redistributions of source code must retain the above copyright notice, this
-      list of conditions and the following disclaimer.
-
-   2. Redistributions in binary form must reproduce the above copyright notice,
-      this list of conditions and the following disclaimer in the documentation
-      and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY COPYRIGHT HOLDER ``AS IS'' AND ANY EXPRESS OR
-IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
-SHALL COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
-OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
-THE POSSIBILITY OF SUCH DAMAGE.
-

Godeps/_workspace/src/github.com/bkaradzic/go-lz4/lz4_test.go

@@ -1,63 +0,0 @@
-package lz4
-
-import (
-	"bytes"
-	"io/ioutil"
-	"testing"
-)
-
-var testfile, _ = ioutil.ReadFile("testdata/pg1661.txt")
-
-func roundtrip(t *testing.T, input []byte) {
-
-	dst, err := Encode(nil, input)
-	if err != nil {
-		t.Errorf("got error during compression: %s", err)
-	}
-
-	output, err := Decode(nil, dst)
-
-	if err != nil {
-		t.Errorf("got error during decompress: %s", err)
-	}
-
-	if !bytes.Equal(output, input) {
-		t.Errorf("roundtrip failed")
-	}
-}
-
-func TestEmpty(t *testing.T) {
-	roundtrip(t, nil)
-}
-
-func TestLengths(t *testing.T) {
-
-	for i := 0; i < 1024; i++ {
-		roundtrip(t, testfile[:i])
-	}
-
-	for i := 1024; i < 4096; i += 23 {
-		roundtrip(t, testfile[:i])
-	}
-}
-
-func TestWords(t *testing.T) {
-	roundtrip(t, testfile)
-}
-
-func BenchmarkLZ4Encode(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		Encode(nil, testfile)
-	}
-}
-
-func BenchmarkLZ4Decode(b *testing.B) {
-
-	var compressed, _ = Encode(nil, testfile)
-
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		Decode(nil, compressed)
-	}
-}

Godeps/_workspace/src/github.com/calmh/du/README.md

@@ -1,14 +0,0 @@
-du
-==
-
-Get total and available disk space on a given volume.
-
-Documentation
--------------
-
-http://godoc.org/github.com/calmh/du
-
-License
--------
-
-Public Domain

Godeps/_workspace/src/github.com/calmh/du/diskusage_windows.go

@@ -1,27 +0,0 @@
-package du
-
-import (
-	"syscall"
-	"unsafe"
-)
-
-// Get returns the Usage of a given path, or an error if usage data is
-// unavailable.
-func Get(path string) (Usage, error) {
-	h := syscall.MustLoadDLL("kernel32.dll")
-	c := h.MustFindProc("GetDiskFreeSpaceExW")
-
-	var u Usage
-
-	ret, _, err := c.Call(
-		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(path))),
-		uintptr(unsafe.Pointer(&u.FreeBytes)),
-		uintptr(unsafe.Pointer(&u.TotalBytes)),
-		uintptr(unsafe.Pointer(&u.AvailBytes)))
-
-	if ret == 0 {
-		return u, err
-	}
-
-	return u, nil
-}

Godeps/_workspace/src/github.com/calmh/logger/README.md

@@ -1,15 +0,0 @@
-logger
-======
-
-A small wrapper around `log` to provide log levels.
-
-Documentation
--------------
-
-http://godoc.org/github.com/calmh/logger
-
-License
--------
-
-MIT
-

Godeps/_workspace/src/github.com/calmh/logger/logger.go

@@ -1,187 +0,0 @@
-// Copyright (C) 2014 Jakob Borg. All rights reserved. Use of this source code
-// is governed by an MIT-style license that can be found in the LICENSE file.
-
-// Package logger implements a standardized logger with callback functionality
-package logger
-
-import (
-	"fmt"
-	"io/ioutil"
-	"log"
-	"os"
-	"strings"
-	"sync"
-)
-
-type LogLevel int
-
-const (
-	LevelDebug LogLevel = iota
-	LevelVerbose
-	LevelInfo
-	LevelOK
-	LevelWarn
-	LevelFatal
-	NumLevels
-)
-
-// A MessageHandler is called with the log level and message text.
-type MessageHandler func(l LogLevel, msg string)
-
-type Logger struct {
-	logger   *log.Logger
-	handlers [NumLevels][]MessageHandler
-	mut      sync.Mutex
-}
-
-// The default logger logs to standard output with a time prefix.
-var DefaultLogger = New()
-
-func New() *Logger {
-	if os.Getenv("LOGGER_DISCARD") != "" {
-		// Hack to completely disable logging, for example when running benchmarks.
-		return &Logger{
-			logger: log.New(ioutil.Discard, "", 0),
-		}
-	}
-
-	return &Logger{
-		logger: log.New(os.Stdout, "", log.Ltime),
-	}
-}
-
-// AddHandler registers a new MessageHandler to receive messages with the
-// specified log level or above.
-func (l *Logger) AddHandler(level LogLevel, h MessageHandler) {
-	l.mut.Lock()
-	defer l.mut.Unlock()
-	l.handlers[level] = append(l.handlers[level], h)
-}
-
-// See log.SetFlags
-func (l *Logger) SetFlags(flag int) {
-	l.logger.SetFlags(flag)
-}
-
-// See log.SetPrefix
-func (l *Logger) SetPrefix(prefix string) {
-	l.logger.SetPrefix(prefix)
-}
-
-func (l *Logger) callHandlers(level LogLevel, s string) {
-	for _, h := range l.handlers[level] {
-		h(level, strings.TrimSpace(s))
-	}
-}
-
-// Debugln logs a line with a DEBUG prefix.
-func (l *Logger) Debugln(vals ...interface{}) {
-	l.mut.Lock()
-	defer l.mut.Unlock()
-	s := fmt.Sprintln(vals...)
-	l.logger.Output(2, "DEBUG: "+s)
-	l.callHandlers(LevelDebug, s)
-}
-
-// Debugf logs a formatted line with a DEBUG prefix.
-func (l *Logger) Debugf(format string, vals ...interface{}) {
-	l.mut.Lock()
-	defer l.mut.Unlock()
-	s := fmt.Sprintf(format, vals...)
-	l.logger.Output(2, "DEBUG: "+s)
-	l.callHandlers(LevelDebug, s)
-}
-
-// Infoln logs a line with a VERBOSE prefix.
-func (l *Logger) Verboseln(vals ...interface{}) {
-	l.mut.Lock()
-	defer l.mut.Unlock()
-	s := fmt.Sprintln(vals...)
-	l.logger.Output(2, "VERBOSE: "+s)
-	l.callHandlers(LevelVerbose, s)
-}
-
-// Infof logs a formatted line with a VERBOSE prefix.
-func (l *Logger) Verbosef(format string, vals ...interface{}) {
-	l.mut.Lock()
-	defer l.mut.Unlock()
-	s := fmt.Sprintf(format, vals...)
-	l.logger.Output(2, "VERBOSE: "+s)
-	l.callHandlers(LevelVerbose, s)
-}
-
-// Infoln logs a line with an INFO prefix.
-func (l *Logger) Infoln(vals ...interface{}) {
-	l.mut.Lock()
-	defer l.mut.Unlock()
-	s := fmt.Sprintln(vals...)
-	l.logger.Output(2, "INFO: "+s)
-	l.callHandlers(LevelInfo, s)
-}
-
-// Infof logs a formatted line with an INFO prefix.
-func (l *Logger) Infof(format string, vals ...interface{}) {
-	l.mut.Lock()
-	defer l.mut.Unlock()
-	s := fmt.Sprintf(format, vals...)
-	l.logger.Output(2, "INFO: "+s)
-	l.callHandlers(LevelInfo, s)
-}
-
-// Okln logs a line with an OK prefix.
-func (l *Logger) Okln(vals ...interface{}) {
-	l.mut.Lock()
-	defer l.mut.Unlock()
-	s := fmt.Sprintln(vals...)
-	l.logger.Output(2, "OK: "+s)
-	l.callHandlers(LevelOK, s)
-}
-
-// Okf logs a formatted line with an OK prefix.
-func (l *Logger) Okf(format string, vals ...interface{}) {
-	l.mut.Lock()
-	defer l.mut.Unlock()
-	s := fmt.Sprintf(format, vals...)
-	l.logger.Output(2, "OK: "+s)
-	l.callHandlers(LevelOK, s)
-}
-
-// Warnln logs a formatted line with a WARNING prefix.
-func (l *Logger) Warnln(vals ...interface{}) {
-	l.mut.Lock()
-	defer l.mut.Unlock()
-	s := fmt.Sprintln(vals...)
-	l.logger.Output(2, "WARNING: "+s)
-	l.callHandlers(LevelWarn, s)
-}
-
-// Warnf logs a formatted line with a WARNING prefix.
-func (l *Logger) Warnf(format string, vals ...interface{}) {
-	l.mut.Lock()
-	defer l.mut.Unlock()
-	s := fmt.Sprintf(format, vals...)
-	l.logger.Output(2, "WARNING: "+s)
-	l.callHandlers(LevelWarn, s)
-}
-
-// Fatalln logs a line with a FATAL prefix and exits the process with exit
-// code 1.
-func (l *Logger) Fatalln(vals ...interface{}) {
-	l.mut.Lock()
-	defer l.mut.Unlock()
-	s := fmt.Sprintln(vals...)
-	l.logger.Output(2, "FATAL: "+s)
-	l.callHandlers(LevelFatal, s)
-	os.Exit(1)
-}
-
-// Fatalf logs a formatted line with a FATAL prefix and exits the process with
-// exit code 1.
-func (l *Logger) Fatalf(format string, vals ...interface{}) {
-	l.mut.Lock()
-	defer l.mut.Unlock()
-	s := fmt.Sprintf(format, vals...)
-	l.logger.Output(2, "FATAL: "+s)
-	l.callHandlers(LevelFatal, s)
-	os.Exit(1)
-}

Godeps/_workspace/src/github.com/calmh/logger/logger_test.go

@@ -1,58 +0,0 @@
-// Copyright (C) 2014 Jakob Borg. All rights reserved. Use of this source code
-// is governed by an MIT-style license that can be found in the LICENSE file.
-
-package logger
-
-import (
-	"strings"
-	"testing"
-)
-
-func TestAPI(t *testing.T) {
-	l := New()
-	l.SetFlags(0)
-	l.SetPrefix("testing")
-
-	debug := 0
-	l.AddHandler(LevelDebug, checkFunc(t, LevelDebug, "test 0", &debug))
-	info := 0
-	l.AddHandler(LevelInfo, checkFunc(t, LevelInfo, "test 1", &info))
-	warn := 0
-	l.AddHandler(LevelWarn, checkFunc(t, LevelWarn, "test 2", &warn))
-	ok := 0
-	l.AddHandler(LevelOK, checkFunc(t, LevelOK, "test 3", &ok))
-
-	l.Debugf("test %d", 0)
-	l.Debugln("test", 0)
-	l.Infof("test %d", 1)
-	l.Infoln("test", 1)
-	l.Warnf("test %d", 2)
-	l.Warnln("test", 2)
-	l.Okf("test %d", 3)
-	l.Okln("test", 3)
-
-	if debug != 2 {
-		t.Errorf("Debug handler called %d != 2 times", debug)
-	}
-	if info != 2 {
-		t.Errorf("Info handler called %d != 2 times", info)
-	}
-	if warn != 2 {
-		t.Errorf("Warn handler called %d != 2 times", warn)
-	}
-	if ok != 2 {
-		t.Errorf("Ok handler called %d != 2 times", ok)
-	}
-}
-
-func checkFunc(t *testing.T, expectl LogLevel, expectmsg string, counter *int) func(LogLevel, string) {
-	return func(l LogLevel, msg string) {
-		*counter++
-		if l != expectl {
-			t.Errorf("Incorrect message level %d != %d", l, expectl)
-		}
-		if !strings.HasSuffix(msg, expectmsg) {
-			t.Errorf("%q does not end with %q", msg, expectmsg)
-		}
-	}
-}

Godeps/_workspace/src/github.com/calmh/luhn/LICENSE

@@ -1,19 +0,0 @@
-Copyright (C) 2014 Jakob Borg
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-
-- The above copyright notice and this permission notice shall be included in
-  all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

Godeps/_workspace/src/github.com/calmh/luhn/luhn.go

@@ -1,70 +0,0 @@
-// Copyright (C) 2014 Jakob Borg
-
-// Package luhn generates and validates Luhn mod N check digits.
-package luhn
-
-import (
-	"fmt"
-	"strings"
-)
-
-// An alphabet is a string of N characters, representing the digits of a given
-// base N.
-type Alphabet string
-
-var (
-	Base32 Alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"
-)
-
-// Generate returns a check digit for the string s, which should be composed
-// of characters from the Alphabet a.
-func (a Alphabet) Generate(s string) (rune, error) {
-	if err := a.check(); err != nil {
-		return 0, err
-	}
-
-	factor := 1
-	sum := 0
-	n := len(a)
-
-	for i := range s {
-		codepoint := strings.IndexByte(string(a), s[i])
-		if codepoint == -1 {
-			return 0, fmt.Errorf("Digit %q not valid in alphabet %q", s[i], a)
-		}
-		addend := factor * codepoint
-		if factor == 2 {
-			factor = 1
-		} else {
-			factor = 2
-		}
-		addend = (addend / n) + (addend % n)
-		sum += addend
-	}
-	remainder := sum % n
-	checkCodepoint := (n - remainder) % n
-	return rune(a[checkCodepoint]), nil
-}
-
-// Validate returns true if the last character of the string s is correct, for
-// a string s composed of characters in the alphabet a.
-func (a Alphabet) Validate(s string) bool {
-	t := s[:len(s)-1]
-	c, err := a.Generate(t)
-	if err != nil {
-		return false
-	}
-	return rune(s[len(s)-1]) == c
-}
-
-// check returns an error if the given alphabet does not consist of unique characters
-func (a Alphabet) check() error {
-	cm := make(map[byte]bool, len(a))
-	for i := range a {
-		if cm[a[i]] {
-			return fmt.Errorf("Digit %q non-unique in alphabet %q", a[i], a)
-		}
-		cm[a[i]] = true
-	}
-	return nil
-}

Godeps/_workspace/src/github.com/calmh/luhn/luhn_test.go

@@ -1,59 +0,0 @@
-// Copyright (C) 2014 Jakob Borg
-
-package luhn_test
-
-import (
-	"testing"
-
-	"github.com/calmh/luhn"
-)
-
-func TestGenerate(t *testing.T) {
-	// Base 6 Luhn
-	a := luhn.Alphabet("abcdef")
-	c, err := a.Generate("abcdef")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if c != 'e' {
-		t.Errorf("Incorrect check digit %c != e", c)
-	}
-
-	// Base 10 Luhn
-	a = luhn.Alphabet("0123456789")
-	c, err = a.Generate("7992739871")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if c != '3' {
-		t.Errorf("Incorrect check digit %c != 3", c)
-	}
-}
-
-func TestInvalidString(t *testing.T) {
-	a := luhn.Alphabet("ABC")
-	_, err := a.Generate("7992739871")
-	t.Log(err)
-	if err == nil {
-		t.Error("Unexpected nil error")
-	}
-}
-
-func TestBadAlphabet(t *testing.T) {
-	a := luhn.Alphabet("01234566789")
-	_, err := a.Generate("7992739871")
-	t.Log(err)
-	if err == nil {
-		t.Error("Unexpected nil error")
-	}
-}
-
-func TestValidate(t *testing.T) {
-	a := luhn.Alphabet("abcdef")
-	if !a.Validate("abcdefe") {
-		t.Errorf("Incorrect validation response for abcdefe")
-	}
-	if a.Validate("abcdefd") {
-		t.Errorf("Incorrect validation response for abcdefd")
-	}
-}

Godeps/_workspace/src/github.com/calmh/xdr/.gitignore

@@ -1 +0,0 @@
-coverage.out

Godeps/_workspace/src/github.com/calmh/xdr/.travis.yml

@@ -1,19 +0,0 @@
-language: go
-go:
-- tip
-
-install:
-- export PATH=$PATH:$HOME/gopath/bin
-- go get code.google.com/p/go.tools/cmd/cover
-- go get github.com/mattn/goveralls
-
-script:
-- ./generate.sh
-- go test -coverprofile=coverage.out
-
-after_success:
-- goveralls -coverprofile=coverage.out -service=travis-ci -package=calmh/xdr -repotoken="$COVERALLS_TOKEN"
-
-env:
-  global:
-    secure: SmgnrGfp2zLrA44ChRMpjPeujubt9veZ8Fx/OseMWECmacyV5N/TuDhzIbwo6QwV4xB0sBacoPzvxQbJRVjNKsPiSu72UbcQmQ7flN4Tf7nW09tSh1iW8NgrpBCq/3UYLoBu2iPBEBKm93IK0aGNAKs6oEkB0fU27iTVBwiTXOY=

Godeps/_workspace/src/github.com/calmh/xdr/README.md

@@ -1,12 +0,0 @@
-xdr
-===
-
-[![Build Status](https://img.shields.io/travis/calmh/xdr.svg?style=flat)](https://travis-ci.org/calmh/xdr)
-[![Coverage Status](https://img.shields.io/coveralls/calmh/xdr.svg?style=flat)](https://coveralls.io/r/calmh/xdr?branch=master)
-[![API Documentation](http://img.shields.io/badge/api-Godoc-blue.svg?style=flat)](http://godoc.org/github.com/calmh/xdr)
-[![MIT License](http://img.shields.io/badge/license-MIT-blue.svg?style=flat)](http://opensource.org/licenses/MIT)
-
-This is an XDR encoding/decoding library. It uses code generation and
-not reflection. It supports the IPDR bastardized XDR format when built
-with `-tags ipdr`.
-

Godeps/_workspace/src/github.com/calmh/xdr/bench_test.go

@@ -1,117 +0,0 @@
-// Copyright (C) 2014 Jakob Borg. All rights reserved. Use of this source code
-// is governed by an MIT-style license that can be found in the LICENSE file.
-
-package xdr_test
-
-import (
-	"io"
-	"io/ioutil"
-	"testing"
-
-	"github.com/calmh/xdr"
-)
-
-type XDRBenchStruct struct {
-	I1  uint64
-	I2  uint32
-	I3  uint16
-	I4  uint8
-	Bs0 []byte // max:128
-	Bs1 []byte
-	S0  string // max:128
-	S1  string
-}
-
-var res []byte // no to be optimized away
-var s = XDRBenchStruct{
-	I1:  42,
-	I2:  43,
-	I3:  44,
-	I4:  45,
-	Bs0: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18},
-	Bs1: []byte{11, 12, 13, 14, 15, 16, 17, 18, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
-	S0:  "Hello World! String one.",
-	S1:  "Hello World! String two.",
-}
-var e []byte
-
-func init() {
-	e, _ = s.MarshalXDR()
-}
-
-func BenchmarkThisMarshal(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		res, _ = s.MarshalXDR()
-	}
-}
-
-func BenchmarkThisUnmarshal(b *testing.B) {
-	var t XDRBenchStruct
-	for i := 0; i < b.N; i++ {
-		err := t.UnmarshalXDR(e)
-		if err != nil {
-			b.Fatal(err)
-		}
-	}
-}
-
-func BenchmarkThisEncode(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		_, err := s.EncodeXDR(ioutil.Discard)
-		if err != nil {
-			b.Fatal(err)
-		}
-	}
-}
-
-func BenchmarkThisEncoder(b *testing.B) {
-	w := xdr.NewWriter(ioutil.Discard)
-	for i := 0; i < b.N; i++ {
-		_, err := s.EncodeXDRInto(w)
-		if err != nil {
-			b.Fatal(err)
-		}
-	}
-}
-
-type repeatReader struct {
-	data []byte
-}
-
-func (r *repeatReader) Read(bs []byte) (n int, err error) {
-	if len(bs) > len(r.data) {
-		err = io.EOF
-	}
-	n = copy(bs, r.data)
-	r.data = r.data[n:]
-	return n, err
-}
-
-func (r *repeatReader) Reset(bs []byte) {
-	r.data = bs
-}
-
-func BenchmarkThisDecode(b *testing.B) {
-	rr := &repeatReader{e}
-	var t XDRBenchStruct
-	for i := 0; i < b.N; i++ {
-		err := t.DecodeXDR(rr)
-		if err != nil {
-			b.Fatal(err)
-		}
-		rr.Reset(e)
-	}
-}
-
-func BenchmarkThisDecoder(b *testing.B) {
-	rr := &repeatReader{e}
-	r := xdr.NewReader(rr)
-	var t XDRBenchStruct
-	for i := 0; i < b.N; i++ {
-		err := t.DecodeXDRFrom(r)
-		if err != nil {
-			b.Fatal(err)
-		}
-		rr.Reset(e)
-	}
-}

Godeps/_workspace/src/github.com/calmh/xdr/bench_xdr_test.go

@@ -1,201 +0,0 @@
-// ************************************************************
-// This file is automatically generated by genxdr. Do not edit.
-// ************************************************************
-
-package xdr_test
-
-import (
-	"bytes"
-	"io"
-
-	"github.com/calmh/xdr"
-)
-
-/*
-
-XDRBenchStruct Structure:
-
- 0                   1                   2                   3
- 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                                                               |
-+                         I1 (64 bits)                          +
-|                                                               |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                              I2                               |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|            0x0000             |              I3               |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-/                                                               /
-\                        uint8 Structure                        \
-/                                                               /
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                         Length of Bs0                         |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-/                                                               /
-\                     Bs0 (variable length)                     \
-/                                                               /
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                         Length of Bs1                         |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-/                                                               /
-\                     Bs1 (variable length)                     \
-/                                                               /
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                         Length of S0                          |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-/                                                               /
-\                     S0 (variable length)                      \
-/                                                               /
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                         Length of S1                          |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-/                                                               /
-\                     S1 (variable length)                      \
-/                                                               /
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-
-
-struct XDRBenchStruct {
-	unsigned hyper I1;
-	unsigned int I2;
-	unsigned int I3;
-	uint8 I4;
-	opaque Bs0<128>;
-	opaque Bs1<>;
-	string S0<128>;
-	string S1<>;
-}
-
-*/
-
-func (o XDRBenchStruct) EncodeXDR(w io.Writer) (int, error) {
-	var xw = xdr.NewWriter(w)
-	return o.EncodeXDRInto(xw)
-}
-
-func (o XDRBenchStruct) MarshalXDR() ([]byte, error) {
-	return o.AppendXDR(make([]byte, 0, 128))
-}
-
-func (o XDRBenchStruct) MustMarshalXDR() []byte {
-	bs, err := o.MarshalXDR()
-	if err != nil {
-		panic(err)
-	}
-	return bs
-}
-
-func (o XDRBenchStruct) AppendXDR(bs []byte) ([]byte, error) {
-	var aw = xdr.AppendWriter(bs)
-	var xw = xdr.NewWriter(&aw)
-	_, err := o.EncodeXDRInto(xw)
-	return []byte(aw), err
-}
-
-func (o XDRBenchStruct) EncodeXDRInto(xw *xdr.Writer) (int, error) {
-	xw.WriteUint64(o.I1)
-	xw.WriteUint32(o.I2)
-	xw.WriteUint16(o.I3)
-	xw.WriteUint8(o.I4)
-	if l := len(o.Bs0); l > 128 {
-		return xw.Tot(), xdr.ElementSizeExceeded("Bs0", l, 128)
-	}
-	xw.WriteBytes(o.Bs0)
-	xw.WriteBytes(o.Bs1)
-	if l := len(o.S0); l > 128 {
-		return xw.Tot(), xdr.ElementSizeExceeded("S0", l, 128)
-	}
-	xw.WriteString(o.S0)
-	xw.WriteString(o.S1)
-	return xw.Tot(), xw.Error()
-}
-
-func (o *XDRBenchStruct) DecodeXDR(r io.Reader) error {
-	xr := xdr.NewReader(r)
-	return o.DecodeXDRFrom(xr)
-}
-
-func (o *XDRBenchStruct) UnmarshalXDR(bs []byte) error {
-	var br = bytes.NewReader(bs)
-	var xr = xdr.NewReader(br)
-	return o.DecodeXDRFrom(xr)
-}
-
-func (o *XDRBenchStruct) DecodeXDRFrom(xr *xdr.Reader) error {
-	o.I1 = xr.ReadUint64()
-	o.I2 = xr.ReadUint32()
-	o.I3 = xr.ReadUint16()
-	o.I4 = xr.ReadUint8()
-	o.Bs0 = xr.ReadBytesMax(128)
-	o.Bs1 = xr.ReadBytes()
-	o.S0 = xr.ReadStringMax(128)
-	o.S1 = xr.ReadString()
-	return xr.Error()
-}
-
-/*
-
-repeatReader Structure:
-
- 0                   1                   2                   3
- 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                        Length of data                         |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-/                                                               /
-\                    data (variable length)                     \
-/                                                               /
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-
-
-struct repeatReader {
-	opaque data<>;
-}
-
-*/
-
-func (o repeatReader) EncodeXDR(w io.Writer) (int, error) {
-	var xw = xdr.NewWriter(w)
-	return o.EncodeXDRInto(xw)
-}
-
-func (o repeatReader) MarshalXDR() ([]byte, error) {
-	return o.AppendXDR(make([]byte, 0, 128))
-}
-
-func (o repeatReader) MustMarshalXDR() []byte {
-	bs, err := o.MarshalXDR()
-	if err != nil {
-		panic(err)
-	}
-	return bs
-}
-
-func (o repeatReader) AppendXDR(bs []byte) ([]byte, error) {
-	var aw = xdr.AppendWriter(bs)
-	var xw = xdr.NewWriter(&aw)
-	_, err := o.EncodeXDRInto(xw)
-	return []byte(aw), err
-}
-
-func (o repeatReader) EncodeXDRInto(xw *xdr.Writer) (int, error) {
-	xw.WriteBytes(o.data)
-	return xw.Tot(), xw.Error()
-}
-
-func (o *repeatReader) DecodeXDR(r io.Reader) error {
-	xr := xdr.NewReader(r)
-	return o.DecodeXDRFrom(xr)
-}
-
-func (o *repeatReader) UnmarshalXDR(bs []byte) error {
-	var br = bytes.NewReader(bs)
-	var xr = xdr.NewReader(br)
-	return o.DecodeXDRFrom(xr)
-}
-
-func (o *repeatReader) DecodeXDRFrom(xr *xdr.Reader) error {
-	o.data = xr.ReadBytes()
-	return xr.Error()
-}

Godeps/_workspace/src/github.com/calmh/xdr/cmd/genxdr/main.go

@@ -1,467 +0,0 @@
-// Copyright (C) 2014 Jakob Borg. All rights reserved. Use of this source code
-// is governed by an MIT-style license that can be found in the LICENSE file.
-
-package main
-
-import (
-	"bytes"
-	"flag"
-	"fmt"
-	"go/ast"
-	"go/format"
-	"go/parser"
-	"go/token"
-	"io"
-	"log"
-	"os"
-	"regexp"
-	"strconv"
-	"strings"
-	"text/template"
-)
-
-type fieldInfo struct {
-	Name      string
-	IsBasic   bool   // handled by one the native Read/WriteUint64 etc functions
-	IsSlice   bool   // field is a slice of FieldType
-	FieldType string // original type of field, i.e. "int"
-	Encoder   string // the encoder name, i.e. "Uint64" for Read/WriteUint64
-	Convert   string // what to convert to when encoding, i.e. "uint64"
-	Max       int    // max size for slices and strings
-}
-
-type structInfo struct {
-	Name   string
-	Fields []fieldInfo
-}
-
-var headerTpl = template.Must(template.New("header").Parse(`// ************************************************************
-// This file is automatically generated by genxdr. Do not edit.
-// ************************************************************
-
-package {{.Package}}
-
-import (
-	"bytes"
-	"io"
-
-	"github.com/calmh/xdr"
-)
-`))
-
-var encodeTpl = template.Must(template.New("encoder").Parse(`
-func (o {{.TypeName}}) EncodeXDR(w io.Writer) (int, error) {
-	var xw = xdr.NewWriter(w)
-	return o.EncodeXDRInto(xw)
-}//+n
-
-func (o {{.TypeName}}) MarshalXDR() ([]byte, error) {
-	return o.AppendXDR(make([]byte, 0, 128))
-}//+n
-
-func (o {{.TypeName}}) MustMarshalXDR() []byte {
-	bs, err := o.MarshalXDR()
-	if err != nil {
-		panic(err)
-	}
-	return bs
-}//+n
-
-func (o {{.TypeName}}) AppendXDR(bs []byte) ([]byte, error) {
-	var aw = xdr.AppendWriter(bs)
-	var xw = xdr.NewWriter(&aw)
-	_, err := o.EncodeXDRInto(xw)
-	return []byte(aw), err
-}//+n
-
-func (o {{.TypeName}}) EncodeXDRInto(xw *xdr.Writer) (int, error) {
-	{{range $fieldInfo := .Fields}}
-		{{if not $fieldInfo.IsSlice}}
-			{{if ne $fieldInfo.Convert ""}}
-				xw.Write{{$fieldInfo.Encoder}}({{$fieldInfo.Convert}}(o.{{$fieldInfo.Name}}))
-			{{else if $fieldInfo.IsBasic}}
-				{{if ge $fieldInfo.Max 1}}
-					if l := len(o.{{$fieldInfo.Name}}); l > {{$fieldInfo.Max}} {
-						return xw.Tot(), xdr.ElementSizeExceeded("{{$fieldInfo.Name}}", l, {{$fieldInfo.Max}})
-					}
-				{{end}}
-				xw.Write{{$fieldInfo.Encoder}}(o.{{$fieldInfo.Name}})
-			{{else}}
-				_, err := o.{{$fieldInfo.Name}}.EncodeXDRInto(xw)
-				if err != nil {
-					return xw.Tot(), err
-				}
-			{{end}}
-		{{else}}
-			{{if ge $fieldInfo.Max 1}}
-				if l := len(o.{{$fieldInfo.Name}}); l > {{$fieldInfo.Max}} {
-					return xw.Tot(), xdr.ElementSizeExceeded("{{$fieldInfo.Name}}", l, {{$fieldInfo.Max}})
-				}
-			{{end}}
-			xw.WriteUint32(uint32(len(o.{{$fieldInfo.Name}})))
-			for i := range o.{{$fieldInfo.Name}} {
-			{{if ne $fieldInfo.Convert ""}}
-				xw.Write{{$fieldInfo.Encoder}}({{$fieldInfo.Convert}}(o.{{$fieldInfo.Name}}[i]))
-			{{else if $fieldInfo.IsBasic}}
-				xw.Write{{$fieldInfo.Encoder}}(o.{{$fieldInfo.Name}}[i])
-			{{else}}
-				_, err := o.{{$fieldInfo.Name}}[i].EncodeXDRInto(xw)
-				if err != nil {
-					return xw.Tot(), err
-				}
-			{{end}}
-			}
-		{{end}}
-	{{end}}
-	return xw.Tot(), xw.Error()
-}//+n
-
-func (o *{{.TypeName}}) DecodeXDR(r io.Reader) error {
-	xr := xdr.NewReader(r)
-	return o.DecodeXDRFrom(xr)
-}//+n
-
-func (o *{{.TypeName}}) UnmarshalXDR(bs []byte) error {
-	var br = bytes.NewReader(bs)
-	var xr = xdr.NewReader(br)
-	return o.DecodeXDRFrom(xr)
-}//+n
-
-func (o *{{.TypeName}}) DecodeXDRFrom(xr *xdr.Reader) error {
-	{{range $fieldInfo := .Fields}}
-		{{if not $fieldInfo.IsSlice}}
-			{{if ne $fieldInfo.Convert ""}}
-				o.{{$fieldInfo.Name}} = {{$fieldInfo.FieldType}}(xr.Read{{$fieldInfo.Encoder}}())
-			{{else if $fieldInfo.IsBasic}}
-				{{if ge $fieldInfo.Max 1}}
-					o.{{$fieldInfo.Name}} = xr.Read{{$fieldInfo.Encoder}}Max({{$fieldInfo.Max}})
-				{{else}}
-					o.{{$fieldInfo.Name}} = xr.Read{{$fieldInfo.Encoder}}()
-				{{end}}
-			{{else}}
-				(&o.{{$fieldInfo.Name}}).DecodeXDRFrom(xr)
-			{{end}}
-		{{else}}
-			_{{$fieldInfo.Name}}Size := int(xr.ReadUint32())
-			if _{{$fieldInfo.Name}}Size < 0 {
-				return xdr.ElementSizeExceeded("{{$fieldInfo.Name}}", _{{$fieldInfo.Name}}Size, {{$fieldInfo.Max}})
-			}
-			{{if ge $fieldInfo.Max 1}}
-				if _{{$fieldInfo.Name}}Size > {{$fieldInfo.Max}} {
-					return xdr.ElementSizeExceeded("{{$fieldInfo.Name}}", _{{$fieldInfo.Name}}Size, {{$fieldInfo.Max}})
-				}
-			{{end}}
-			o.{{$fieldInfo.Name}} = make([]{{$fieldInfo.FieldType}}, _{{$fieldInfo.Name}}Size)
-			for i := range o.{{$fieldInfo.Name}} {
-				{{if ne $fieldInfo.Convert ""}}
-					o.{{$fieldInfo.Name}}[i] = {{$fieldInfo.FieldType}}(xr.Read{{$fieldInfo.Encoder}}())
-				{{else if $fieldInfo.IsBasic}}
-					o.{{$fieldInfo.Name}}[i] = xr.Read{{$fieldInfo.Encoder}}()
-				{{else}}
-					(&o.{{$fieldInfo.Name}}[i]).DecodeXDRFrom(xr)
-				{{end}}
-			}
-		{{end}}
-	{{end}}
-	return xr.Error()
-}`))
-
-var maxRe = regexp.MustCompile(`\Wmax:(\d+)`)
-
-type typeSet struct {
-	Type    string
-	Encoder string
-}
-
-var xdrEncoders = map[string]typeSet{
-	"int8":   typeSet{"uint8", "Uint8"},
-	"uint8":  typeSet{"", "Uint8"},
-	"int16":  typeSet{"uint16", "Uint16"},
-	"uint16": typeSet{"", "Uint16"},
-	"int32":  typeSet{"uint32", "Uint32"},
-	"uint32": typeSet{"", "Uint32"},
-	"int64":  typeSet{"uint64", "Uint64"},
-	"uint64": typeSet{"", "Uint64"},
-	"int":    typeSet{"uint64", "Uint64"},
-	"string": typeSet{"", "String"},
-	"[]byte": typeSet{"", "Bytes"},
-	"bool":   typeSet{"", "Bool"},
-}
-
-func handleStruct(t *ast.StructType) []fieldInfo {
-	var fs []fieldInfo
-
-	for _, sf := range t.Fields.List {
-		if len(sf.Names) == 0 {
-			// We don't handle anonymous fields
-			continue
-		}
-
-		fn := sf.Names[0].Name
-		var max = 0
-		if sf.Comment != nil {
-			c := sf.Comment.List[0].Text
-			if m := maxRe.FindStringSubmatch(c); m != nil {
-				max, _ = strconv.Atoi(m[1])
-			}
-			if strings.Contains(c, "noencode") {
-				continue
-			}
-		}
-
-		var f fieldInfo
-		switch ft := sf.Type.(type) {
-		case *ast.Ident:
-			tn := ft.Name
-			if enc, ok := xdrEncoders[tn]; ok {
-				f = fieldInfo{
-					Name:      fn,
-					IsBasic:   true,
-					FieldType: tn,
-					Encoder:   enc.Encoder,
-					Convert:   enc.Type,
-					Max:       max,
-				}
-			} else {
-				f = fieldInfo{
-					Name:      fn,
-					IsBasic:   false,
-					FieldType: tn,
-					Max:       max,
-				}
-			}
-
-		case *ast.ArrayType:
-			if ft.Len != nil {
-				// We don't handle arrays
-				continue
-			}
-
-			tn := ft.Elt.(*ast.Ident).Name
-			if enc, ok := xdrEncoders["[]"+tn]; ok {
-				f = fieldInfo{
-					Name:      fn,
-					IsBasic:   true,
-					FieldType: tn,
-					Encoder:   enc.Encoder,
-					Convert:   enc.Type,
-					Max:       max,
-				}
-			} else if enc, ok := xdrEncoders[tn]; ok {
-				f = fieldInfo{
-					Name:      fn,
-					IsBasic:   true,
-					IsSlice:   true,
-					FieldType: tn,
-					Encoder:   enc.Encoder,
-					Convert:   enc.Type,
-					Max:       max,
-				}
-			} else {
-				f = fieldInfo{
-					Name:      fn,
-					IsSlice:   true,
-					FieldType: tn,
-					Max:       max,
-				}
-			}
-
-		case *ast.SelectorExpr:
-			f = fieldInfo{
-				Name:      fn,
-				FieldType: ft.Sel.Name,
-				Max:       max,
-			}
-		}
-
-		fs = append(fs, f)
-	}
-
-	return fs
-}
-
-func generateCode(output io.Writer, s structInfo) {
-	name := s.Name
-	fs := s.Fields
-
-	var buf bytes.Buffer
-	err := encodeTpl.Execute(&buf, map[string]interface{}{"TypeName": name, "Fields": fs})
-	if err != nil {
-		panic(err)
-	}
-
-	bs := regexp.MustCompile(`(\s*\n)+`).ReplaceAll(buf.Bytes(), []byte("\n"))
-	bs = bytes.Replace(bs, []byte("//+n"), []byte("\n"), -1)
-
-	bs, err = format.Source(bs)
-	if err != nil {
-		panic(err)
-	}
-	fmt.Fprintln(output, string(bs))
-}
-
-func uncamelize(s string) string {
-	return regexp.MustCompile("[a-z][A-Z]").ReplaceAllStringFunc(s, func(camel string) string {
-		return camel[:1] + " " + camel[1:]
-	})
-}
-
-func generateDiagram(output io.Writer, s structInfo) {
-	sn := s.Name
-	fs := s.Fields
-
-	fmt.Fprintln(output, sn+" Structure:")
-	fmt.Fprintln(output)
-	fmt.Fprintln(output, " 0                   1                   2                   3")
-	fmt.Fprintln(output, " 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1")
-	line := "+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+"
-	fmt.Fprintln(output, line)
-
-	for _, f := range fs {
-		tn := f.FieldType
-		name := uncamelize(f.Name)
-
-		if f.IsSlice {
-			fmt.Fprintf(output, "| %s |\n", center("Number of "+name, 61))
-			fmt.Fprintln(output, line)
-		}
-		switch tn {
-		case "bool":
-			fmt.Fprintf(output, "| %s |V|\n", center(name+" (V=0 or 1)", 59))
-			fmt.Fprintln(output, line)
-		case "int16", "uint16":
-			fmt.Fprintf(output, "| %s | %s |\n", center("0x0000", 29), center(name, 29))
-			fmt.Fprintln(output, line)
-		case "int32", "uint32":
-			fmt.Fprintf(output, "| %s |\n", center(name, 61))
-			fmt.Fprintln(output, line)
-		case "int64", "uint64":
-			fmt.Fprintf(output, "| %-61s |\n", "")
-			fmt.Fprintf(output, "+ %s +\n", center(name+" (64 bits)", 61))
-			fmt.Fprintf(output, "| %-61s |\n", "")
-			fmt.Fprintln(output, line)
-		case "string", "byte": // XXX We assume slice of byte!
-			fmt.Fprintf(output, "| %s |\n", center("Length of "+name, 61))
-			fmt.Fprintln(output, line)
-			fmt.Fprintf(output, "/ %61s /\n", "")
-			fmt.Fprintf(output, "\\ %s \\\n", center(name+" (variable length)", 61))
-			fmt.Fprintf(output, "/ %61s /\n", "")
-			fmt.Fprintln(output, line)
-		default:
-			if f.IsSlice {
-				tn = "Zero or more " + tn + " Structures"
-				fmt.Fprintf(output, "/ %s /\n", center("", 61))
-				fmt.Fprintf(output, "\\ %s \\\n", center(tn, 61))
-				fmt.Fprintf(output, "/ %s /\n", center("", 61))
-			} else {
-				tn = tn + " Structure"
-				fmt.Fprintf(output, "/ %s /\n", center("", 61))
-				fmt.Fprintf(output, "\\ %s \\\n", center(tn, 61))
-				fmt.Fprintf(output, "/ %s /\n", center("", 61))
-			}
-			fmt.Fprintln(output, line)
-		}
-	}
-	fmt.Fprintln(output)
-	fmt.Fprintln(output)
-}
-
-func generateXdr(output io.Writer, s structInfo) {
-	sn := s.Name
-	fs := s.Fields
-
-	fmt.Fprintf(output, "struct %s {\n", sn)
-
-	for _, f := range fs {
-		tn := f.FieldType
-		fn := f.Name
-		suf := ""
-		l := ""
-		if f.Max > 0 {
-			l = strconv.Itoa(f.Max)
-		}
-		if f.IsSlice {
-			suf = "<" + l + ">"
-		}
-
-		switch tn {
-		case "int16", "int32":
-			fmt.Fprintf(output, "\tint %s%s;\n", fn, suf)
-		case "uint16", "uint32":
-			fmt.Fprintf(output, "\tunsigned int %s%s;\n", fn, suf)
-		case "int64":
-			fmt.Fprintf(output, "\thyper %s%s;\n", fn, suf)
-		case "uint64":
-			fmt.Fprintf(output, "\tunsigned hyper %s%s;\n", fn, suf)
-		case "string":
-			fmt.Fprintf(output, "\tstring %s<%s>;\n", fn, l)
-		case "byte":
-			fmt.Fprintf(output, "\topaque %s<%s>;\n", fn, l)
-		default:
-			fmt.Fprintf(output, "\t%s %s%s;\n", tn, fn, suf)
-		}
-	}
-	fmt.Fprintln(output, "}")
-	fmt.Fprintln(output)
-}
-
-func center(s string, w int) string {
-	w -= len(s)
-	l := w / 2
-	r := l
-	if l+r < w {
-		r++
-	}
-	return strings.Repeat(" ", l) + s + strings.Repeat(" ", r)
-}
-
-func inspector(structs *[]structInfo) func(ast.Node) bool {
-	return func(n ast.Node) bool {
-		switch n := n.(type) {
-		case *ast.TypeSpec:
-			switch t := n.Type.(type) {
-			case *ast.StructType:
-				name := n.Name.Name
-				fs := handleStruct(t)
-				*structs = append(*structs, structInfo{name, fs})
-			}
-			return false
-		default:
-			return true
-		}
-	}
-}
-
-func main() {
-	outputFile := flag.String("o", "", "Output file, blank for stdout")
-	flag.Parse()
-	fname := flag.Arg(0)
-
-	fset := token.NewFileSet()
-	f, err := parser.ParseFile(fset, fname, nil, parser.ParseComments)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	var structs []structInfo
-	i := inspector(&structs)
-	ast.Inspect(f, i)
-
-	var output io.Writer = os.Stdout
-	if *outputFile != "" {
-		fd, err := os.Create(*outputFile)
-		if err != nil {
-			log.Fatal(err)
-		}
-		output = fd
-	}
-
-	headerTpl.Execute(output, map[string]string{"Package": f.Name.Name})
-	for _, s := range structs {
-		fmt.Fprintf(output, "\n/*\n\n")
-		generateDiagram(output, s)
-		generateXdr(output, s)
-		fmt.Fprintf(output, "*/\n")
-		generateCode(output, s)
-	}
-}

Godeps/_workspace/src/github.com/calmh/xdr/debug.go

@@ -1,16 +0,0 @@
-// Copyright (C) 2014 Jakob Borg. All rights reserved. Use of this source code
-// is governed by an MIT-style license that can be found in the LICENSE file.
-
-package xdr
-
-import (
-	"log"
-	"os"
-)
-
-var (
-	debug = len(os.Getenv("XDRTRACE")) > 0
-	dl    = log.New(os.Stdout, "xdr: ", log.Lshortfile|log.Ltime|log.Lmicroseconds)
-)
-
-const maxDebugBytes = 32

Godeps/_workspace/src/github.com/calmh/xdr/doc.go

@@ -1,5 +0,0 @@
-// Copyright (C) 2014 Jakob Borg. All rights reserved. Use of this source code
-// is governed by an MIT-style license that can be found in the LICENSE file.
-
-// Package xdr implements an XDR (RFC 4506) encoder/decoder.
-package xdr

Godeps/_workspace/src/github.com/calmh/xdr/encdec_test.go

@@ -1,79 +0,0 @@
-// Copyright (C) 2014 Jakob Borg. All rights reserved. Use of this source code
-// is governed by an MIT-style license that can be found in the LICENSE file.
-
-package xdr_test
-
-import (
-	"bytes"
-	"math/rand"
-	"reflect"
-	"testing"
-	"testing/quick"
-
-	"github.com/calmh/xdr"
-)
-
-// Contains all supported types
-type TestStruct struct {
-	I    int
-	I8   int8
-	UI8  uint8
-	I16  int16
-	UI16 uint16
-	I32  int32
-	UI32 uint32
-	I64  int64
-	UI64 uint64
-	BS   []byte // max:1024
-	S    string // max:1024
-	C    Opaque
-	SS   []string // max:1024
-}
-
-type Opaque [32]byte
-
-func (u *Opaque) EncodeXDRInto(w *xdr.Writer) (int, error) {
-	return w.WriteRaw(u[:])
-}
-
-func (u *Opaque) DecodeXDRFrom(r *xdr.Reader) (int, error) {
-	return r.ReadRaw(u[:])
-}
-
-func (Opaque) Generate(rand *rand.Rand, size int) reflect.Value {
-	var u Opaque
-	for i := range u[:] {
-		u[i] = byte(rand.Int())
-	}
-	return reflect.ValueOf(u)
-}
-
-func TestEncDec(t *testing.T) {
-	fn := func(t0 TestStruct) bool {
-		bs, err := t0.MarshalXDR()
-		if err != nil {
-			t.Fatal(err)
-		}
-		var t1 TestStruct
-		err = t1.UnmarshalXDR(bs)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		// Not comparing with DeepEqual since we'll unmarshal nil slices as empty
-		if t0.I != t1.I ||
-			t0.I16 != t1.I16 || t0.UI16 != t1.UI16 ||
-			t0.I32 != t1.I32 || t0.UI32 != t1.UI32 ||
-			t0.I64 != t1.I64 || t0.UI64 != t1.UI64 ||
-			bytes.Compare(t0.BS, t1.BS) != 0 ||
-			t0.S != t1.S || t0.C != t1.C {
-			t.Logf("%#v", t0)
-			t.Logf("%#v", t1)
-			return false
-		}
-		return true
-	}
-	if err := quick.Check(fn, nil); err != nil {
-		t.Error(err)
-	}
-}

Godeps/_workspace/src/github.com/calmh/xdr/encdec_xdr_test.go

@@ -1,185 +0,0 @@
-// ************************************************************
-// This file is automatically generated by genxdr. Do not edit.
-// ************************************************************
-
-package xdr_test
-
-import (
-	"bytes"
-	"io"
-
-	"github.com/calmh/xdr"
-)
-
-/*
-
-TestStruct Structure:
-
- 0                   1                   2                   3
- 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-/                                                               /
-\                         int Structure                         \
-/                                                               /
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-/                                                               /
-\                        int8 Structure                         \
-/                                                               /
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-/                                                               /
-\                        uint8 Structure                        \
-/                                                               /
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|            0x0000             |              I16              |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|            0x0000             |             UI16              |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                              I32                              |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                             UI32                              |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                                                               |
-+                         I64 (64 bits)                         +
-|                                                               |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                                                               |
-+                        UI64 (64 bits)                         +
-|                                                               |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                         Length of BS                          |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-/                                                               /
-\                     BS (variable length)                      \
-/                                                               /
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                          Length of S                          |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-/                                                               /
-\                      S (variable length)                      \
-/                                                               /
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-/                                                               /
-\                       Opaque Structure                        \
-/                                                               /
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                         Number of SS                          |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-|                         Length of SS                          |
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-/                                                               /
-\                     SS (variable length)                      \
-/                                                               /
-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-
-
-struct TestStruct {
-	int I;
-	int8 I8;
-	uint8 UI8;
-	int I16;
-	unsigned int UI16;
-	int I32;
-	unsigned int UI32;
-	hyper I64;
-	unsigned hyper UI64;
-	opaque BS<1024>;
-	string S<1024>;
-	Opaque C;
-	string SS<1024>;
-}
-
-*/
-
-func (o TestStruct) EncodeXDR(w io.Writer) (int, error) {
-	var xw = xdr.NewWriter(w)
-	return o.EncodeXDRInto(xw)
-}
-
-func (o TestStruct) MarshalXDR() ([]byte, error) {
-	return o.AppendXDR(make([]byte, 0, 128))
-}
-
-func (o TestStruct) MustMarshalXDR() []byte {
-	bs, err := o.MarshalXDR()
-	if err != nil {
-		panic(err)
-	}
-	return bs
-}
-
-func (o TestStruct) AppendXDR(bs []byte) ([]byte, error) {
-	var aw = xdr.AppendWriter(bs)
-	var xw = xdr.NewWriter(&aw)
-	_, err := o.EncodeXDRInto(xw)
-	return []byte(aw), err
-}
-
-func (o TestStruct) EncodeXDRInto(xw *xdr.Writer) (int, error) {
-	xw.WriteUint64(uint64(o.I))
-	xw.WriteUint8(uint8(o.I8))
-	xw.WriteUint8(o.UI8)
-	xw.WriteUint16(uint16(o.I16))
-	xw.WriteUint16(o.UI16)
-	xw.WriteUint32(uint32(o.I32))
-	xw.WriteUint32(o.UI32)
-	xw.WriteUint64(uint64(o.I64))
-	xw.WriteUint64(o.UI64)
-	if l := len(o.BS); l > 1024 {
-		return xw.Tot(), xdr.ElementSizeExceeded("BS", l, 1024)
-	}
-	xw.WriteBytes(o.BS)
-	if l := len(o.S); l > 1024 {
-		return xw.Tot(), xdr.ElementSizeExceeded("S", l, 1024)
-	}
-	xw.WriteString(o.S)
-	_, err := o.C.EncodeXDRInto(xw)
-	if err != nil {
-		return xw.Tot(), err
-	}
-	if l := len(o.SS); l > 1024 {
-		return xw.Tot(), xdr.ElementSizeExceeded("SS", l, 1024)
-	}
-	xw.WriteUint32(uint32(len(o.SS)))
-	for i := range o.SS {
-		xw.WriteString(o.SS[i])
-	}
-	return xw.Tot(), xw.Error()
-}
-
-func (o *TestStruct) DecodeXDR(r io.Reader) error {
-	xr := xdr.NewReader(r)
-	return o.DecodeXDRFrom(xr)
-}
-
-func (o *TestStruct) UnmarshalXDR(bs []byte) error {
-	var br = bytes.NewReader(bs)
-	var xr = xdr.NewReader(br)
-	return o.DecodeXDRFrom(xr)
-}
-
-func (o *TestStruct) DecodeXDRFrom(xr *xdr.Reader) error {
-	o.I = int(xr.ReadUint64())
-	o.I8 = int8(xr.ReadUint8())
-	o.UI8 = xr.ReadUint8()
-	o.I16 = int16(xr.ReadUint16())
-	o.UI16 = xr.ReadUint16()
-	o.I32 = int32(xr.ReadUint32())
-	o.UI32 = xr.ReadUint32()
-	o.I64 = int64(xr.ReadUint64())
-	o.UI64 = xr.ReadUint64()
-	o.BS = xr.ReadBytesMax(1024)
-	o.S = xr.ReadStringMax(1024)
-	(&o.C).DecodeXDRFrom(xr)
-	_SSSize := int(xr.ReadUint32())
-	if _SSSize < 0 {
-		return xdr.ElementSizeExceeded("SS", _SSSize, 1024)
-	}
-	if _SSSize > 1024 {
-		return xdr.ElementSizeExceeded("SS", _SSSize, 1024)
-	}
-	o.SS = make([]string, _SSSize)
-	for i := range o.SS {
-		o.SS[i] = xr.ReadString()
-	}
-	return xr.Error()
-}

Godeps/_workspace/src/github.com/calmh/xdr/generate.sh

@@ -1,4 +0,0 @@
-#!/bin/sh
-
-go run cmd/genxdr/main.go -- bench_test.go > bench_xdr_test.go
-go run cmd/genxdr/main.go -- encdec_test.go > encdec_xdr_test.go

Godeps/_workspace/src/github.com/calmh/xdr/pad_ipdr.go

@@ -1,10 +0,0 @@
-// Copyright (C) 2014 Jakob Borg. All rights reserved. Use of this source code
-// is governed by an MIT-style license that can be found in the LICENSE file.
-
-// +build ipdr
-
-package xdr
-
-func pad(l int) int {
-	return 0
-}

Godeps/_workspace/src/github.com/calmh/xdr/pad_xdr.go

@@ -1,14 +0,0 @@
-// Copyright (C) 2014 Jakob Borg. All rights reserved. Use of this source code
-// is governed by an MIT-style license that can be found in the LICENSE file.
-
-// +build !ipdr
-
-package xdr
-
-func pad(l int) int {
-	d := l % 4
-	if d == 0 {
-		return 0
-	}
-	return 4 - d
-}

Godeps/_workspace/src/github.com/calmh/xdr/reader.go

@@ -1,171 +0,0 @@
-// Copyright (C) 2014 Jakob Borg and Contributors (see the CONTRIBUTORS file).
-// All rights reserved. Use of this source code is governed by an MIT-style
-// license that can be found in the LICENSE file.
-
-package xdr
-
-import (
-	"fmt"
-	"io"
-	"reflect"
-	"unsafe"
-)
-
-type Reader struct {
-	r   io.Reader
-	err error
-	b   [8]byte
-}
-
-func NewReader(r io.Reader) *Reader {
-	return &Reader{
-		r: r,
-	}
-}
-
-func (r *Reader) ReadRaw(bs []byte) (int, error) {
-	if r.err != nil {
-		return 0, r.err
-	}
-
-	var n int
-	n, r.err = io.ReadFull(r.r, bs)
-	return n, r.err
-}
-
-func (r *Reader) ReadString() string {
-	return r.ReadStringMax(0)
-}
-
-func (r *Reader) ReadStringMax(max int) string {
-	buf := r.ReadBytesMaxInto(max, nil)
-	bh := (*reflect.SliceHeader)(unsafe.Pointer(&buf))
-	sh := reflect.StringHeader{
-		Data: bh.Data,
-		Len:  bh.Len,
-	}
-	return *((*string)(unsafe.Pointer(&sh)))
-}
-
-func (r *Reader) ReadBytes() []byte {
-	return r.ReadBytesInto(nil)
-}
-
-func (r *Reader) ReadBytesMax(max int) []byte {
-	return r.ReadBytesMaxInto(max, nil)
-}
-
-func (r *Reader) ReadBytesInto(dst []byte) []byte {
-	return r.ReadBytesMaxInto(0, dst)
-}
-
-func (r *Reader) ReadBytesMaxInto(max int, dst []byte) []byte {
-	if r.err != nil {
-		return nil
-	}
-
-	l := int(r.ReadUint32())
-	if r.err != nil {
-		return nil
-	}
-	if l < 0 || max > 0 && l > max {
-		// l may be negative on 32 bit builds
-		r.err = ElementSizeExceeded("bytes field", l, max)
-		return nil
-	}
-
-	if fullLen := l + pad(l); fullLen > len(dst) {
-		dst = make([]byte, fullLen)
-	} else {
-		dst = dst[:fullLen]
-	}
-
-	var n int
-	n, r.err = io.ReadFull(r.r, dst)
-	if r.err != nil {
-		if debug {
-			dl.Printf("rd bytes (%d): %v", len(dst), r.err)
-		}
-		return nil
-	}
-
-	if debug {
-		if n > maxDebugBytes {
-			dl.Printf("rd bytes (%d): %x...", len(dst), dst[:maxDebugBytes])
-		} else {
-			dl.Printf("rd bytes (%d): %x", len(dst), dst)
-		}
-	}
-	return dst[:l]
-}
-
-func (r *Reader) ReadBool() bool {
-	return r.ReadUint8() != 0
-}
-
-func (r *Reader) ReadUint32() uint32 {
-	if r.err != nil {
-		return 0
-	}
-
-	_, r.err = io.ReadFull(r.r, r.b[:4])
-	if r.err != nil {
-		if debug {
-			dl.Printf("rd uint32: %v", r.err)
-		}
-		return 0
-	}
-
-	v := uint32(r.b[3]) | uint32(r.b[2])<<8 | uint32(r.b[1])<<16 | uint32(r.b[0])<<24
-
-	if debug {
-		dl.Printf("rd uint32=%d (0x%08x)", v, v)
-	}
-	return v
-}
-
-func (r *Reader) ReadUint64() uint64 {
-	if r.err != nil {
-		return 0
-	}
-
-	_, r.err = io.ReadFull(r.r, r.b[:8])
-	if r.err != nil {
-		if debug {
-			dl.Printf("rd uint64: %v", r.err)
-		}
-		return 0
-	}
-
-	v := uint64(r.b[7]) | uint64(r.b[6])<<8 | uint64(r.b[5])<<16 | uint64(r.b[4])<<24 |
-		uint64(r.b[3])<<32 | uint64(r.b[2])<<40 | uint64(r.b[1])<<48 | uint64(r.b[0])<<56
-
-	if debug {
-		dl.Printf("rd uint64=%d (0x%016x)", v, v)
-	}
-	return v
-}
-
-type XDRError struct {
-	op  string
-	err error
-}
-
-func (e XDRError) Error() string {
-	return "xdr " + e.op + ": " + e.err.Error()
-}
-
-func (e XDRError) IsEOF() bool {
-	return e.err == io.EOF
-}
-
-func (r *Reader) Error() error {
-	if r.err == nil {
-		return nil
-	}
-	return XDRError{"read", r.err}
-}
-
-func ElementSizeExceeded(field string, size, limit int) error {
-	return fmt.Errorf("%s exceeds size limit; %d > %d", field, size, limit)
-}

Godeps/_workspace/src/github.com/calmh/xdr/reader_ipdr.go

@@ -1,49 +0,0 @@
-// Copyright (C) 2014 Jakob Borg and Contributors (see the CONTRIBUTORS file).
-// All rights reserved. Use of this source code is governed by an MIT-style
-// license that can be found in the LICENSE file.
-
-// +build ipdr
-
-package xdr
-
-import "io"
-
-func (r *Reader) ReadUint8() uint8 {
-	if r.err != nil {
-		return 0
-	}
-
-	_, r.err = io.ReadFull(r.r, r.b[:1])
-	if r.err != nil {
-		if debug {
-			dl.Printf("rd uint8: %v", r.err)
-		}
-		return 0
-	}
-
-	if debug {
-		dl.Printf("rd uint8=%d (0x%02x)", r.b[0], r.b[0])
-	}
-	return r.b[0]
-}
-
-func (r *Reader) ReadUint16() uint16 {
-	if r.err != nil {
-		return 0
-	}
-
-	_, r.err = io.ReadFull(r.r, r.b[:2])
-	if r.err != nil {
-		if debug {
-			dl.Printf("rd uint16: %v", r.err)
-		}
-		return 0
-	}
-
-	v := uint16(r.b[1]) | uint16(r.b[0])<<8
-
-	if debug {
-		dl.Printf("rd uint16=%d (0x%04x)", v, v)
-	}
-	return v
-}

Godeps/_workspace/src/github.com/calmh/xdr/reader_xdr.go

@@ -1,15 +0,0 @@
-// Copyright (C) 2014 Jakob Borg and Contributors (see the CONTRIBUTORS file).
-// All rights reserved. Use of this source code is governed by an MIT-style
-// license that can be found in the LICENSE file.
-
-// +build !ipdr
-
-package xdr
-
-func (r *Reader) ReadUint8() uint8 {
-	return uint8(r.ReadUint32())
-}
-
-func (r *Reader) ReadUint16() uint16 {
-	return uint16(r.ReadUint32())
-}

Godeps/_workspace/src/github.com/calmh/xdr/refl_test.go

@@ -1,44 +0,0 @@
-// Copyright (C) 2014 Jakob Borg. All rights reserved. Use of this source code
-// is governed by an MIT-style license that can be found in the LICENSE file.
-
-// +build refl
-
-package xdr_test
-
-import (
-	"bytes"
-	"testing"
-
-	refl "github.com/davecgh/go-xdr/xdr"
-)
-
-func TestCompareMarshals(t *testing.T) {
-	e0 := s.MarshalXDR()
-	e1, err := refl.Marshal(s)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if bytes.Compare(e0, e1) != 0 {
-		t.Fatalf("Encoding mismatch;\n\t%x (this)\n\t%x (refl)", e0, e1)
-	}
-}
-
-func BenchmarkReflMarshal(b *testing.B) {
-	var err error
-	for i := 0; i < b.N; i++ {
-		res, err = refl.Marshal(s)
-		if err != nil {
-			b.Fatal(err)
-		}
-	}
-}
-
-func BenchmarkReflUnmarshal(b *testing.B) {
-	var t XDRBenchStruct
-	for i := 0; i < b.N; i++ {
-		_, err := refl.Unmarshal(e, &t)
-		if err != nil {
-			b.Fatal(err)
-		}
-	}
-}

Godeps/_workspace/src/github.com/calmh/xdr/writer.go

@@ -1,146 +0,0 @@
-// Copyright (C) 2014 Jakob Borg. All rights reserved. Use of this source code
-// is governed by an MIT-style license that can be found in the LICENSE file.
-
-package xdr
-
-import (
-	"io"
-	"reflect"
-	"unsafe"
-)
-
-var padBytes = []byte{0, 0, 0}
-
-type Writer struct {
-	w   io.Writer
-	tot int
-	err error
-	b   [8]byte
-}
-
-type AppendWriter []byte
-
-func (w *AppendWriter) Write(bs []byte) (int, error) {
-	*w = append(*w, bs...)
-	return len(bs), nil
-}
-
-func NewWriter(w io.Writer) *Writer {
-	return &Writer{
-		w: w,
-	}
-}
-
-func (w *Writer) WriteRaw(bs []byte) (int, error) {
-	if w.err != nil {
-		return 0, w.err
-	}
-
-	var n int
-	n, w.err = w.w.Write(bs)
-	return n, w.err
-}
-
-func (w *Writer) WriteString(s string) (int, error) {
-	sh := *((*reflect.StringHeader)(unsafe.Pointer(&s)))
-	bh := reflect.SliceHeader{
-		Data: sh.Data,
-		Len:  sh.Len,
-		Cap:  sh.Len,
-	}
-	return w.WriteBytes(*(*[]byte)(unsafe.Pointer(&bh)))
-}
-
-func (w *Writer) WriteBytes(bs []byte) (int, error) {
-	if w.err != nil {
-		return 0, w.err
-	}
-
-	w.WriteUint32(uint32(len(bs)))
-	if w.err != nil {
-		return 0, w.err
-	}
-
-	if debug {
-		if len(bs) > maxDebugBytes {
-			dl.Printf("wr bytes (%d): %x...", len(bs), bs[:maxDebugBytes])
-		} else {
-			dl.Printf("wr bytes (%d): %x", len(bs), bs)
-		}
-	}
-
-	var l, n int
-	n, w.err = w.w.Write(bs)
-	l += n
-
-	if p := pad(len(bs)); w.err == nil && p > 0 {
-		n, w.err = w.w.Write(padBytes[:p])
-		l += n
-	}
-
-	w.tot += l
-	return l, w.err
-}
-
-func (w *Writer) WriteBool(v bool) (int, error) {
-	if v {
-		return w.WriteUint8(1)
-	} else {
-		return w.WriteUint8(0)
-	}
-}
-
-func (w *Writer) WriteUint32(v uint32) (int, error) {
-	if w.err != nil {
-		return 0, w.err
-	}
-
-	if debug {
-		dl.Printf("wr uint32=%d", v)
-	}
-
-	w.b[0] = byte(v >> 24)
-	w.b[1] = byte(v >> 16)
-	w.b[2] = byte(v >> 8)
-	w.b[3] = byte(v)
-
-	var l int
-	l, w.err = w.w.Write(w.b[:4])
-	w.tot += l
-	return l, w.err
-}
-
-func (w *Writer) WriteUint64(v uint64) (int, error) {
-	if w.err != nil {
-		return 0, w.err
-	}
-
-	if debug {
-		dl.Printf("wr uint64=%d", v)
-	}
-
-	w.b[0] = byte(v >> 56)
-	w.b[1] = byte(v >> 48)
-	w.b[2] = byte(v >> 40)
-	w.b[3] = byte(v >> 32)
-	w.b[4] = byte(v >> 24)
-	w.b[5] = byte(v >> 16)
-	w.b[6] = byte(v >> 8)
-	w.b[7] = byte(v)
-
-	var l int
-	l, w.err = w.w.Write(w.b[:8])
-	w.tot += l
-	return l, w.err
-}
-
-func (w *Writer) Tot() int {
-	return w.tot
-}
-
-func (w *Writer) Error() error {
-	if w.err == nil {
-		return nil
-	}
-	return XDRError{"write", w.err}
-}

Godeps/_workspace/src/github.com/calmh/xdr/writer_ipdr.go

@@ -1,41 +0,0 @@
-// Copyright (C) 2014 Jakob Borg. All rights reserved. Use of this source code
-// is governed by an MIT-style license that can be found in the LICENSE file.
-
-// +build ipdr
-
-package xdr
-
-func (w *Writer) WriteUint8(v uint8) (int, error) {
-	if w.err != nil {
-		return 0, w.err
-	}
-
-	if debug {
-		dl.Printf("wr uint8=%d", v)
-	}
-
-	w.b[0] = byte(v)
-
-	var l int
-	l, w.err = w.w.Write(w.b[:1])
-	w.tot += l
-	return l, w.err
-}
-
-func (w *Writer) WriteUint16(v uint16) (int, error) {
-	if w.err != nil {
-		return 0, w.err
-	}
-
-	if debug {
-		dl.Printf("wr uint8=%d", v)
-	}
-
-	w.b[0] = byte(v >> 8)
-	w.b[1] = byte(v)
-
-	var l int
-	l, w.err = w.w.Write(w.b[:2])
-	w.tot += l
-	return l, w.err
-}

Godeps/_workspace/src/github.com/calmh/xdr/writer_xdr.go

@@ -1,14 +0,0 @@
-// Copyright (C) 2014 Jakob Borg. All rights reserved. Use of this source code
-// is governed by an MIT-style license that can be found in the LICENSE file.
-
-// +build !ipdr
-
-package xdr
-
-func (w *Writer) WriteUint8(v uint8) (int, error) {
-	return w.WriteUint32(uint32(v))
-}
-
-func (w *Writer) WriteUint16(v uint16) (int, error) {
-	return w.WriteUint32(uint32(v))
-}

Godeps/_workspace/src/github.com/calmh/xdr/xdr_test.go

@@ -1,93 +0,0 @@
-// Copyright (C) 2014 Jakob Borg. All rights reserved. Use of this source code
-// is governed by an MIT-style license that can be found in the LICENSE file.
-
-package xdr
-
-import (
-	"bytes"
-	"strings"
-	"testing"
-	"testing/quick"
-)
-
-func TestBytesNil(t *testing.T) {
-	fn := func(bs []byte) bool {
-		var b = new(bytes.Buffer)
-		var w = NewWriter(b)
-		var r = NewReader(b)
-		w.WriteBytes(bs)
-		w.WriteBytes(bs)
-		r.ReadBytes()
-		res := r.ReadBytes()
-		return bytes.Compare(bs, res) == 0
-	}
-	if err := quick.Check(fn, nil); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestBytesGiven(t *testing.T) {
-	fn := func(bs []byte) bool {
-		var b = new(bytes.Buffer)
-		var w = NewWriter(b)
-		var r = NewReader(b)
-		w.WriteBytes(bs)
-		w.WriteBytes(bs)
-		res := make([]byte, 12)
-		res = r.ReadBytesInto(res)
-		res = r.ReadBytesInto(res)
-		return bytes.Compare(bs, res) == 0
-	}
-	if err := quick.Check(fn, nil); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestReadBytesMaxInto(t *testing.T) {
-	var max = 64
-	for tot := 32; tot < 128; tot++ {
-		for diff := -32; diff <= 32; diff++ {
-			var b = new(bytes.Buffer)
-			var r = NewReader(b)
-			var w = NewWriter(b)
-
-			var toWrite = make([]byte, tot)
-			w.WriteBytes(toWrite)
-
-			var buf = make([]byte, tot+diff)
-			var bs = r.ReadBytesMaxInto(max, buf)
-
-			if tot <= max {
-				if read := len(bs); read != tot {
-					t.Errorf("Incorrect read bytes, wrote=%d, buf=%d, max=%d, read=%d", tot, tot+diff, max, read)
-				}
-			} else if !strings.Contains(r.err.Error(), "exceeds size") {
-				t.Errorf("Unexpected non-ErrElementSizeExceeded error for wrote=%d, max=%d: %v", tot, max, r.err)
-			}
-		}
-	}
-}
-
-func TestReadStringMax(t *testing.T) {
-	for tot := 42; tot < 72; tot++ {
-		for max := 0; max < 128; max++ {
-			var b = new(bytes.Buffer)
-			var r = NewReader(b)
-			var w = NewWriter(b)
-
-			var toWrite = make([]byte, tot)
-			w.WriteBytes(toWrite)
-
-			var str = r.ReadStringMax(max)
-			var read = len(str)
-
-			if max == 0 || tot <= max {
-				if read != tot {
-					t.Errorf("Incorrect read bytes, wrote=%d, max=%d, read=%d", tot, max, read)
-				}
-			} else if !strings.Contains(r.err.Error(), "exceeds size") {
-				t.Errorf("Unexpected non-ErrElementSizeExceeded error for wrote=%d, max=%d, read=%d: %v", tot, max, read, r.err)
-			}
-		}
-	}
-}

Godeps/_workspace/src/github.com/golang/snappy/AUTHORS

@@ -1,14 +0,0 @@
-# This is the official list of Snappy-Go authors for copyright purposes.
-# This file is distinct from the CONTRIBUTORS files.
-# See the latter for an explanation.
-
-# Names should be added to this file as
-#	Name or Organization <email address>
-# The email address is not required for organizations.
-
-# Please keep the list sorted.
-
-Damian Gryski <dgryski@gmail.com>
-Google Inc.
-Jan Mercl <0xjnml@gmail.com>
-Sebastien Binet <seb.binet@gmail.com>

Godeps/_workspace/src/github.com/golang/snappy/CONTRIBUTORS

@@ -1,36 +0,0 @@
-# This is the official list of people who can contribute
-# (and typically have contributed) code to the Snappy-Go repository.
-# The AUTHORS file lists the copyright holders; this file
-# lists people.  For example, Google employees are listed here
-# but not in AUTHORS, because Google holds the copyright.
-#
-# The submission process automatically checks to make sure
-# that people submitting code are listed in this file (by email address).
-#
-# Names should be added to this file only after verifying that
-# the individual or the individual's organization has agreed to
-# the appropriate Contributor License Agreement, found here:
-#
-#     http://code.google.com/legal/individual-cla-v1.0.html
-#     http://code.google.com/legal/corporate-cla-v1.0.html
-#
-# The agreement for individuals can be filled out on the web.
-#
-# When adding J Random Contributor's name to this file,
-# either J's name or J's organization's name should be
-# added to the AUTHORS file, depending on whether the
-# individual or corporate CLA was used.
-
-# Names should be added to this file like so:
-#     Name <email address>
-
-# Please keep the list sorted.
-
-Damian Gryski <dgryski@gmail.com>
-Jan Mercl <0xjnml@gmail.com>
-Kai Backman <kaib@golang.org>
-Marc-Antoine Ruel <maruel@chromium.org>
-Nigel Tao <nigeltao@golang.org>
-Rob Pike <r@golang.org>
-Russ Cox <rsc@golang.org>
-Sebastien Binet <seb.binet@gmail.com>

Godeps/_workspace/src/github.com/golang/snappy/README

@@ -1,7 +0,0 @@
-The Snappy compression format in the Go programming language.
-
-To download and install from source:
-$ go get github.com/golang/snappy
-
-Unless otherwise noted, the Snappy-Go source files are distributed
-under the BSD-style license found in the LICENSE file.

Godeps/_workspace/src/github.com/golang/snappy/decode.go

@@ -1,294 +0,0 @@
-// Copyright 2011 The Snappy-Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package snappy
-
-import (
-	"encoding/binary"
-	"errors"
-	"io"
-)
-
-var (
-	// ErrCorrupt reports that the input is invalid.
-	ErrCorrupt = errors.New("snappy: corrupt input")
-	// ErrTooLarge reports that the uncompressed length is too large.
-	ErrTooLarge = errors.New("snappy: decoded block is too large")
-	// ErrUnsupported reports that the input isn't supported.
-	ErrUnsupported = errors.New("snappy: unsupported input")
-)
-
-// DecodedLen returns the length of the decoded block.
-func DecodedLen(src []byte) (int, error) {
-	v, _, err := decodedLen(src)
-	return v, err
-}
-
-// decodedLen returns the length of the decoded block and the number of bytes
-// that the length header occupied.
-func decodedLen(src []byte) (blockLen, headerLen int, err error) {
-	v, n := binary.Uvarint(src)
-	if n <= 0 || v > 0xffffffff {
-		return 0, 0, ErrCorrupt
-	}
-
-	const wordSize = 32 << (^uint(0) >> 32 & 1)
-	if wordSize == 32 && v > 0x7fffffff {
-		return 0, 0, ErrTooLarge
-	}
-	return int(v), n, nil
-}
-
-// Decode returns the decoded form of src. The returned slice may be a sub-
-// slice of dst if dst was large enough to hold the entire decoded block.
-// Otherwise, a newly allocated slice will be returned.
-// It is valid to pass a nil dst.
-func Decode(dst, src []byte) ([]byte, error) {
-	dLen, s, err := decodedLen(src)
-	if err != nil {
-		return nil, err
-	}
-	if len(dst) < dLen {
-		dst = make([]byte, dLen)
-	}
-
-	var d, offset, length int
-	for s < len(src) {
-		switch src[s] & 0x03 {
-		case tagLiteral:
-			x := uint(src[s] >> 2)
-			switch {
-			case x < 60:
-				s++
-			case x == 60:
-				s += 2
-				if s > len(src) {
-					return nil, ErrCorrupt
-				}
-				x = uint(src[s-1])
-			case x == 61:
-				s += 3
-				if s > len(src) {
-					return nil, ErrCorrupt
-				}
-				x = uint(src[s-2]) | uint(src[s-1])<<8
-			case x == 62:
-				s += 4
-				if s > len(src) {
-					return nil, ErrCorrupt
-				}
-				x = uint(src[s-3]) | uint(src[s-2])<<8 | uint(src[s-1])<<16
-			case x == 63:
-				s += 5
-				if s > len(src) {
-					return nil, ErrCorrupt
-				}
-				x = uint(src[s-4]) | uint(src[s-3])<<8 | uint(src[s-2])<<16 | uint(src[s-1])<<24
-			}
-			length = int(x + 1)
-			if length <= 0 {
-				return nil, errors.New("snappy: unsupported literal length")
-			}
-			if length > len(dst)-d || length > len(src)-s {
-				return nil, ErrCorrupt
-			}
-			copy(dst[d:], src[s:s+length])
-			d += length
-			s += length
-			continue
-
-		case tagCopy1:
-			s += 2
-			if s > len(src) {
-				return nil, ErrCorrupt
-			}
-			length = 4 + int(src[s-2])>>2&0x7
-			offset = int(src[s-2])&0xe0<<3 | int(src[s-1])
-
-		case tagCopy2:
-			s += 3
-			if s > len(src) {
-				return nil, ErrCorrupt
-			}
-			length = 1 + int(src[s-3])>>2
-			offset = int(src[s-2]) | int(src[s-1])<<8
-
-		case tagCopy4:
-			return nil, errors.New("snappy: unsupported COPY_4 tag")
-		}
-
-		end := d + length
-		if offset > d || end > len(dst) {
-			return nil, ErrCorrupt
-		}
-		for ; d < end; d++ {
-			dst[d] = dst[d-offset]
-		}
-	}
-	if d != dLen {
-		return nil, ErrCorrupt
-	}
-	return dst[:d], nil
-}
-
-// NewReader returns a new Reader that decompresses from r, using the framing
-// format described at
-// https://github.com/google/snappy/blob/master/framing_format.txt
-func NewReader(r io.Reader) *Reader {
-	return &Reader{
-		r:       r,
-		decoded: make([]byte, maxUncompressedChunkLen),
-		buf:     make([]byte, MaxEncodedLen(maxUncompressedChunkLen)+checksumSize),
-	}
-}
-
-// Reader is an io.Reader than can read Snappy-compressed bytes.
-type Reader struct {
-	r       io.Reader
-	err     error
-	decoded []byte
-	buf     []byte
-	// decoded[i:j] contains decoded bytes that have not yet been passed on.
-	i, j       int
-	readHeader bool
-}
-
-// Reset discards any buffered data, resets all state, and switches the Snappy
-// reader to read from r. This permits reusing a Reader rather than allocating
-// a new one.
-func (r *Reader) Reset(reader io.Reader) {
-	r.r = reader
-	r.err = nil
-	r.i = 0
-	r.j = 0
-	r.readHeader = false
-}
-
-func (r *Reader) readFull(p []byte) (ok bool) {
-	if _, r.err = io.ReadFull(r.r, p); r.err != nil {
-		if r.err == io.ErrUnexpectedEOF {
-			r.err = ErrCorrupt
-		}
-		return false
-	}
-	return true
-}
-
-// Read satisfies the io.Reader interface.
-func (r *Reader) Read(p []byte) (int, error) {
-	if r.err != nil {
-		return 0, r.err
-	}
-	for {
-		if r.i < r.j {
-			n := copy(p, r.decoded[r.i:r.j])
-			r.i += n
-			return n, nil
-		}
-		if !r.readFull(r.buf[:4]) {
-			return 0, r.err
-		}
-		chunkType := r.buf[0]
-		if !r.readHeader {
-			if chunkType != chunkTypeStreamIdentifier {
-				r.err = ErrCorrupt
-				return 0, r.err
-			}
-			r.readHeader = true
-		}
-		chunkLen := int(r.buf[1]) | int(r.buf[2])<<8 | int(r.buf[3])<<16
-		if chunkLen > len(r.buf) {
-			r.err = ErrUnsupported
-			return 0, r.err
-		}
-
-		// The chunk types are specified at
-		// https://github.com/google/snappy/blob/master/framing_format.txt
-		switch chunkType {
-		case chunkTypeCompressedData:
-			// Section 4.2. Compressed data (chunk type 0x00).
-			if chunkLen < checksumSize {
-				r.err = ErrCorrupt
-				return 0, r.err
-			}
-			buf := r.buf[:chunkLen]
-			if !r.readFull(buf) {
-				return 0, r.err
-			}
-			checksum := uint32(buf[0]) | uint32(buf[1])<<8 | uint32(buf[2])<<16 | uint32(buf[3])<<24
-			buf = buf[checksumSize:]
-
-			n, err := DecodedLen(buf)
-			if err != nil {
-				r.err = err
-				return 0, r.err
-			}
-			if n > len(r.decoded) {
-				r.err = ErrCorrupt
-				return 0, r.err
-			}
-			if _, err := Decode(r.decoded, buf); err != nil {
-				r.err = err
-				return 0, r.err
-			}
-			if crc(r.decoded[:n]) != checksum {
-				r.err = ErrCorrupt
-				return 0, r.err
-			}
-			r.i, r.j = 0, n
-			continue
-
-		case chunkTypeUncompressedData:
-			// Section 4.3. Uncompressed data (chunk type 0x01).
-			if chunkLen < checksumSize {
-				r.err = ErrCorrupt
-				return 0, r.err
-			}
-			buf := r.buf[:checksumSize]
-			if !r.readFull(buf) {
-				return 0, r.err
-			}
-			checksum := uint32(buf[0]) | uint32(buf[1])<<8 | uint32(buf[2])<<16 | uint32(buf[3])<<24
-			// Read directly into r.decoded instead of via r.buf.
-			n := chunkLen - checksumSize
-			if !r.readFull(r.decoded[:n]) {
-				return 0, r.err
-			}
-			if crc(r.decoded[:n]) != checksum {
-				r.err = ErrCorrupt
-				return 0, r.err
-			}
-			r.i, r.j = 0, n
-			continue
-
-		case chunkTypeStreamIdentifier:
-			// Section 4.1. Stream identifier (chunk type 0xff).
-			if chunkLen != len(magicBody) {
-				r.err = ErrCorrupt
-				return 0, r.err
-			}
-			if !r.readFull(r.buf[:len(magicBody)]) {
-				return 0, r.err
-			}
-			for i := 0; i < len(magicBody); i++ {
-				if r.buf[i] != magicBody[i] {
-					r.err = ErrCorrupt
-					return 0, r.err
-				}
-			}
-			continue
-		}
-
-		if chunkType <= 0x7f {
-			// Section 4.5. Reserved unskippable chunks (chunk types 0x02-0x7f).
-			r.err = ErrUnsupported
-			return 0, r.err
-		}
-		// Section 4.4 Padding (chunk type 0xfe).
-		// Section 4.6. Reserved skippable chunks (chunk types 0x80-0xfd).
-		if !r.readFull(r.buf[:chunkLen]) {
-			return 0, r.err
-		}
-	}
-}

Godeps/_workspace/src/github.com/golang/snappy/encode.go

@@ -1,254 +0,0 @@
-// Copyright 2011 The Snappy-Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package snappy
-
-import (
-	"encoding/binary"
-	"io"
-)
-
-// We limit how far copy back-references can go, the same as the C++ code.
-const maxOffset = 1 << 15
-
-// emitLiteral writes a literal chunk and returns the number of bytes written.
-func emitLiteral(dst, lit []byte) int {
-	i, n := 0, uint(len(lit)-1)
-	switch {
-	case n < 60:
-		dst[0] = uint8(n)<<2 | tagLiteral
-		i = 1
-	case n < 1<<8:
-		dst[0] = 60<<2 | tagLiteral
-		dst[1] = uint8(n)
-		i = 2
-	case n < 1<<16:
-		dst[0] = 61<<2 | tagLiteral
-		dst[1] = uint8(n)
-		dst[2] = uint8(n >> 8)
-		i = 3
-	case n < 1<<24:
-		dst[0] = 62<<2 | tagLiteral
-		dst[1] = uint8(n)
-		dst[2] = uint8(n >> 8)
-		dst[3] = uint8(n >> 16)
-		i = 4
-	case int64(n) < 1<<32:
-		dst[0] = 63<<2 | tagLiteral
-		dst[1] = uint8(n)
-		dst[2] = uint8(n >> 8)
-		dst[3] = uint8(n >> 16)
-		dst[4] = uint8(n >> 24)
-		i = 5
-	default:
-		panic("snappy: source buffer is too long")
-	}
-	if copy(dst[i:], lit) != len(lit) {
-		panic("snappy: destination buffer is too short")
-	}
-	return i + len(lit)
-}
-
-// emitCopy writes a copy chunk and returns the number of bytes written.
-func emitCopy(dst []byte, offset, length int) int {
-	i := 0
-	for length > 0 {
-		x := length - 4
-		if 0 <= x && x < 1<<3 && offset < 1<<11 {
-			dst[i+0] = uint8(offset>>8)&0x07<<5 | uint8(x)<<2 | tagCopy1
-			dst[i+1] = uint8(offset)
-			i += 2
-			break
-		}
-
-		x = length
-		if x > 1<<6 {
-			x = 1 << 6
-		}
-		dst[i+0] = uint8(x-1)<<2 | tagCopy2
-		dst[i+1] = uint8(offset)
-		dst[i+2] = uint8(offset >> 8)
-		i += 3
-		length -= x
-	}
-	return i
-}
-
-// Encode returns the encoded form of src. The returned slice may be a sub-
-// slice of dst if dst was large enough to hold the entire encoded block.
-// Otherwise, a newly allocated slice will be returned.
-// It is valid to pass a nil dst.
-func Encode(dst, src []byte) []byte {
-	if n := MaxEncodedLen(len(src)); len(dst) < n {
-		dst = make([]byte, n)
-	}
-
-	// The block starts with the varint-encoded length of the decompressed bytes.
-	d := binary.PutUvarint(dst, uint64(len(src)))
-
-	// Return early if src is short.
-	if len(src) <= 4 {
-		if len(src) != 0 {
-			d += emitLiteral(dst[d:], src)
-		}
-		return dst[:d]
-	}
-
-	// Initialize the hash table. Its size ranges from 1<<8 to 1<<14 inclusive.
-	const maxTableSize = 1 << 14
-	shift, tableSize := uint(32-8), 1<<8
-	for tableSize < maxTableSize && tableSize < len(src) {
-		shift--
-		tableSize *= 2
-	}
-	var table [maxTableSize]int
-
-	// Iterate over the source bytes.
-	var (
-		s   int // The iterator position.
-		t   int // The last position with the same hash as s.
-		lit int // The start position of any pending literal bytes.
-	)
-	for s+3 < len(src) {
-		// Update the hash table.
-		b0, b1, b2, b3 := src[s], src[s+1], src[s+2], src[s+3]
-		h := uint32(b0) | uint32(b1)<<8 | uint32(b2)<<16 | uint32(b3)<<24
-		p := &table[(h*0x1e35a7bd)>>shift]
-		// We need to to store values in [-1, inf) in table. To save
-		// some initialization time, (re)use the table's zero value
-		// and shift the values against this zero: add 1 on writes,
-		// subtract 1 on reads.
-		t, *p = *p-1, s+1
-		// If t is invalid or src[s:s+4] differs from src[t:t+4], accumulate a literal byte.
-		if t < 0 || s-t >= maxOffset || b0 != src[t] || b1 != src[t+1] || b2 != src[t+2] || b3 != src[t+3] {
-			s++
-			continue
-		}
-		// Otherwise, we have a match. First, emit any pending literal bytes.
-		if lit != s {
-			d += emitLiteral(dst[d:], src[lit:s])
-		}
-		// Extend the match to be as long as possible.
-		s0 := s
-		s, t = s+4, t+4
-		for s < len(src) && src[s] == src[t] {
-			s++
-			t++
-		}
-		// Emit the copied bytes.
-		d += emitCopy(dst[d:], s-t, s-s0)
-		lit = s
-	}
-
-	// Emit any final pending literal bytes and return.
-	if lit != len(src) {
-		d += emitLiteral(dst[d:], src[lit:])
-	}
-	return dst[:d]
-}
-
-// MaxEncodedLen returns the maximum length of a snappy block, given its
-// uncompressed length.
-func MaxEncodedLen(srcLen int) int {
-	// Compressed data can be defined as:
-	//    compressed := item* literal*
-	//    item       := literal* copy
-	//
-	// The trailing literal sequence has a space blowup of at most 62/60
-	// since a literal of length 60 needs one tag byte + one extra byte
-	// for length information.
-	//
-	// Item blowup is trickier to measure. Suppose the "copy" op copies
-	// 4 bytes of data. Because of a special check in the encoding code,
-	// we produce a 4-byte copy only if the offset is < 65536. Therefore
-	// the copy op takes 3 bytes to encode, and this type of item leads
-	// to at most the 62/60 blowup for representing literals.
-	//
-	// Suppose the "copy" op copies 5 bytes of data. If the offset is big
-	// enough, it will take 5 bytes to encode the copy op. Therefore the
-	// worst case here is a one-byte literal followed by a five-byte copy.
-	// That is, 6 bytes of input turn into 7 bytes of "compressed" data.
-	//
-	// This last factor dominates the blowup, so the final estimate is:
-	return 32 + srcLen + srcLen/6
-}
-
-// NewWriter returns a new Writer that compresses to w, using the framing
-// format described at
-// https://github.com/google/snappy/blob/master/framing_format.txt
-func NewWriter(w io.Writer) *Writer {
-	return &Writer{
-		w:   w,
-		enc: make([]byte, MaxEncodedLen(maxUncompressedChunkLen)),
-	}
-}
-
-// Writer is an io.Writer than can write Snappy-compressed bytes.
-type Writer struct {
-	w           io.Writer
-	err         error
-	enc         []byte
-	buf         [checksumSize + chunkHeaderSize]byte
-	wroteHeader bool
-}
-
-// Reset discards the writer's state and switches the Snappy writer to write to
-// w. This permits reusing a Writer rather than allocating a new one.
-func (w *Writer) Reset(writer io.Writer) {
-	w.w = writer
-	w.err = nil
-	w.wroteHeader = false
-}
-
-// Write satisfies the io.Writer interface.
-func (w *Writer) Write(p []byte) (n int, errRet error) {
-	if w.err != nil {
-		return 0, w.err
-	}
-	if !w.wroteHeader {
-		copy(w.enc, magicChunk)
-		if _, err := w.w.Write(w.enc[:len(magicChunk)]); err != nil {
-			w.err = err
-			return n, err
-		}
-		w.wroteHeader = true
-	}
-	for len(p) > 0 {
-		var uncompressed []byte
-		if len(p) > maxUncompressedChunkLen {
-			uncompressed, p = p[:maxUncompressedChunkLen], p[maxUncompressedChunkLen:]
-		} else {
-			uncompressed, p = p, nil
-		}
-		checksum := crc(uncompressed)
-
-		// Compress the buffer, discarding the result if the improvement
-		// isn't at least 12.5%.
-		chunkType := uint8(chunkTypeCompressedData)
-		chunkBody := Encode(w.enc, uncompressed)
-		if len(chunkBody) >= len(uncompressed)-len(uncompressed)/8 {
-			chunkType, chunkBody = chunkTypeUncompressedData, uncompressed
-		}
-
-		chunkLen := 4 + len(chunkBody)
-		w.buf[0] = chunkType
-		w.buf[1] = uint8(chunkLen >> 0)
-		w.buf[2] = uint8(chunkLen >> 8)
-		w.buf[3] = uint8(chunkLen >> 16)
-		w.buf[4] = uint8(checksum >> 0)
-		w.buf[5] = uint8(checksum >> 8)
-		w.buf[6] = uint8(checksum >> 16)
-		w.buf[7] = uint8(checksum >> 24)
-		if _, err := w.w.Write(w.buf[:]); err != nil {
-			w.err = err
-			return n, err
-		}
-		if _, err := w.w.Write(chunkBody); err != nil {
-			w.err = err
-			return n, err
-		}
-		n += len(uncompressed)
-	}
-	return n, nil
-}

Godeps/_workspace/src/github.com/golang/snappy/snappy.go

@@ -1,68 +0,0 @@
-// Copyright 2011 The Snappy-Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package snappy implements the snappy block-based compression format.
-// It aims for very high speeds and reasonable compression.
-//
-// The C++ snappy implementation is at https://github.com/google/snappy
-package snappy
-
-import (
-	"hash/crc32"
-)
-
-/*
-Each encoded block begins with the varint-encoded length of the decoded data,
-followed by a sequence of chunks. Chunks begin and end on byte boundaries. The
-first byte of each chunk is broken into its 2 least and 6 most significant bits
-called l and m: l ranges in [0, 4) and m ranges in [0, 64). l is the chunk tag.
-Zero means a literal tag. All other values mean a copy tag.
-
-For literal tags:
-  - If m < 60, the next 1 + m bytes are literal bytes.
-  - Otherwise, let n be the little-endian unsigned integer denoted by the next
-    m - 59 bytes. The next 1 + n bytes after that are literal bytes.
-
-For copy tags, length bytes are copied from offset bytes ago, in the style of
-Lempel-Ziv compression algorithms. In particular:
-  - For l == 1, the offset ranges in [0, 1<<11) and the length in [4, 12).
-    The length is 4 + the low 3 bits of m. The high 3 bits of m form bits 8-10
-    of the offset. The next byte is bits 0-7 of the offset.
-  - For l == 2, the offset ranges in [0, 1<<16) and the length in [1, 65).
-    The length is 1 + m. The offset is the little-endian unsigned integer
-    denoted by the next 2 bytes.
-  - For l == 3, this tag is a legacy format that is no longer supported.
-*/
-const (
-	tagLiteral = 0x00
-	tagCopy1   = 0x01
-	tagCopy2   = 0x02
-	tagCopy4   = 0x03
-)
-
-const (
-	checksumSize    = 4
-	chunkHeaderSize = 4
-	magicChunk      = "\xff\x06\x00\x00" + magicBody
-	magicBody       = "sNaPpY"
-	// https://github.com/google/snappy/blob/master/framing_format.txt says
-	// that "the uncompressed data in a chunk must be no longer than 65536 bytes".
-	maxUncompressedChunkLen = 65536
-)
-
-const (
-	chunkTypeCompressedData   = 0x00
-	chunkTypeUncompressedData = 0x01
-	chunkTypePadding          = 0xfe
-	chunkTypeStreamIdentifier = 0xff
-)
-
-var crcTable = crc32.MakeTable(crc32.Castagnoli)
-
-// crc implements the checksum specified in section 3 of
-// https://github.com/google/snappy/blob/master/framing_format.txt
-func crc(b []byte) uint32 {
-	c := crc32.Update(0, crcTable, b)
-	return uint32(c>>15|c<<17) + 0xa282ead8
-}

Godeps/_workspace/src/github.com/golang/snappy/snappy_test.go

@@ -1,377 +0,0 @@
-// Copyright 2011 The Snappy-Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package snappy
-
-import (
-	"bytes"
-	"flag"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"math/rand"
-	"net/http"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-var (
-	download = flag.Bool("download", false, "If true, download any missing files before running benchmarks")
-	testdata = flag.String("testdata", "testdata", "Directory containing the test data")
-)
-
-func roundtrip(b, ebuf, dbuf []byte) error {
-	d, err := Decode(dbuf, Encode(ebuf, b))
-	if err != nil {
-		return fmt.Errorf("decoding error: %v", err)
-	}
-	if !bytes.Equal(b, d) {
-		return fmt.Errorf("roundtrip mismatch:\n\twant %v\n\tgot  %v", b, d)
-	}
-	return nil
-}
-
-func TestEmpty(t *testing.T) {
-	if err := roundtrip(nil, nil, nil); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestSmallCopy(t *testing.T) {
-	for _, ebuf := range [][]byte{nil, make([]byte, 20), make([]byte, 64)} {
-		for _, dbuf := range [][]byte{nil, make([]byte, 20), make([]byte, 64)} {
-			for i := 0; i < 32; i++ {
-				s := "aaaa" + strings.Repeat("b", i) + "aaaabbbb"
-				if err := roundtrip([]byte(s), ebuf, dbuf); err != nil {
-					t.Errorf("len(ebuf)=%d, len(dbuf)=%d, i=%d: %v", len(ebuf), len(dbuf), i, err)
-				}
-			}
-		}
-	}
-}
-
-func TestSmallRand(t *testing.T) {
-	rng := rand.New(rand.NewSource(27354294))
-	for n := 1; n < 20000; n += 23 {
-		b := make([]byte, n)
-		for i := range b {
-			b[i] = uint8(rng.Uint32())
-		}
-		if err := roundtrip(b, nil, nil); err != nil {
-			t.Fatal(err)
-		}
-	}
-}
-
-func TestSmallRegular(t *testing.T) {
-	for n := 1; n < 20000; n += 23 {
-		b := make([]byte, n)
-		for i := range b {
-			b[i] = uint8(i%10 + 'a')
-		}
-		if err := roundtrip(b, nil, nil); err != nil {
-			t.Fatal(err)
-		}
-	}
-}
-
-func TestInvalidVarint(t *testing.T) {
-	data := []byte("\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00")
-	if _, err := DecodedLen(data); err != ErrCorrupt {
-		t.Errorf("DecodedLen: got %v, want ErrCorrupt", err)
-	}
-	if _, err := Decode(nil, data); err != ErrCorrupt {
-		t.Errorf("Decode: got %v, want ErrCorrupt", err)
-	}
-
-	// The encoded varint overflows 32 bits
-	data = []byte("\xff\xff\xff\xff\xff\x00")
-
-	if _, err := DecodedLen(data); err != ErrCorrupt {
-		t.Errorf("DecodedLen: got %v, want ErrCorrupt", err)
-	}
-	if _, err := Decode(nil, data); err != ErrCorrupt {
-		t.Errorf("Decode: got %v, want ErrCorrupt", err)
-	}
-}
-
-func cmp(a, b []byte) error {
-	if len(a) != len(b) {
-		return fmt.Errorf("got %d bytes, want %d", len(a), len(b))
-	}
-	for i := range a {
-		if a[i] != b[i] {
-			return fmt.Errorf("byte #%d: got 0x%02x, want 0x%02x", i, a[i], b[i])
-		}
-	}
-	return nil
-}
-
-func TestFramingFormat(t *testing.T) {
-	// src is comprised of alternating 1e5-sized sequences of random
-	// (incompressible) bytes and repeated (compressible) bytes. 1e5 was chosen
-	// because it is larger than maxUncompressedChunkLen (64k).
-	src := make([]byte, 1e6)
-	rng := rand.New(rand.NewSource(1))
-	for i := 0; i < 10; i++ {
-		if i%2 == 0 {
-			for j := 0; j < 1e5; j++ {
-				src[1e5*i+j] = uint8(rng.Intn(256))
-			}
-		} else {
-			for j := 0; j < 1e5; j++ {
-				src[1e5*i+j] = uint8(i)
-			}
-		}
-	}
-
-	buf := new(bytes.Buffer)
-	if _, err := NewWriter(buf).Write(src); err != nil {
-		t.Fatalf("Write: encoding: %v", err)
-	}
-	dst, err := ioutil.ReadAll(NewReader(buf))
-	if err != nil {
-		t.Fatalf("ReadAll: decoding: %v", err)
-	}
-	if err := cmp(dst, src); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestReaderReset(t *testing.T) {
-	gold := bytes.Repeat([]byte("All that is gold does not glitter,\n"), 10000)
-	buf := new(bytes.Buffer)
-	if _, err := NewWriter(buf).Write(gold); err != nil {
-		t.Fatalf("Write: %v", err)
-	}
-	encoded, invalid, partial := buf.String(), "invalid", "partial"
-	r := NewReader(nil)
-	for i, s := range []string{encoded, invalid, partial, encoded, partial, invalid, encoded, encoded} {
-		if s == partial {
-			r.Reset(strings.NewReader(encoded))
-			if _, err := r.Read(make([]byte, 101)); err != nil {
-				t.Errorf("#%d: %v", i, err)
-				continue
-			}
-			continue
-		}
-		r.Reset(strings.NewReader(s))
-		got, err := ioutil.ReadAll(r)
-		switch s {
-		case encoded:
-			if err != nil {
-				t.Errorf("#%d: %v", i, err)
-				continue
-			}
-			if err := cmp(got, gold); err != nil {
-				t.Errorf("#%d: %v", i, err)
-				continue
-			}
-		case invalid:
-			if err == nil {
-				t.Errorf("#%d: got nil error, want non-nil", i)
-				continue
-			}
-		}
-	}
-}
-
-func TestWriterReset(t *testing.T) {
-	gold := bytes.Repeat([]byte("Not all those who wander are lost;\n"), 10000)
-	var gots, wants [][]byte
-	const n = 20
-	w, failed := NewWriter(nil), false
-	for i := 0; i <= n; i++ {
-		buf := new(bytes.Buffer)
-		w.Reset(buf)
-		want := gold[:len(gold)*i/n]
-		if _, err := w.Write(want); err != nil {
-			t.Errorf("#%d: Write: %v", i, err)
-			failed = true
-			continue
-		}
-		got, err := ioutil.ReadAll(NewReader(buf))
-		if err != nil {
-			t.Errorf("#%d: ReadAll: %v", i, err)
-			failed = true
-			continue
-		}
-		gots = append(gots, got)
-		wants = append(wants, want)
-	}
-	if failed {
-		return
-	}
-	for i := range gots {
-		if err := cmp(gots[i], wants[i]); err != nil {
-			t.Errorf("#%d: %v", i, err)
-		}
-	}
-}
-
-func benchDecode(b *testing.B, src []byte) {
-	encoded := Encode(nil, src)
-	// Bandwidth is in amount of uncompressed data.
-	b.SetBytes(int64(len(src)))
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		Decode(src, encoded)
-	}
-}
-
-func benchEncode(b *testing.B, src []byte) {
-	// Bandwidth is in amount of uncompressed data.
-	b.SetBytes(int64(len(src)))
-	dst := make([]byte, MaxEncodedLen(len(src)))
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		Encode(dst, src)
-	}
-}
-
-func readFile(b testing.TB, filename string) []byte {
-	src, err := ioutil.ReadFile(filename)
-	if err != nil {
-		b.Skipf("skipping benchmark: %v", err)
-	}
-	if len(src) == 0 {
-		b.Fatalf("%s has zero length", filename)
-	}
-	return src
-}
-
-// expand returns a slice of length n containing repeated copies of src.
-func expand(src []byte, n int) []byte {
-	dst := make([]byte, n)
-	for x := dst; len(x) > 0; {
-		i := copy(x, src)
-		x = x[i:]
-	}
-	return dst
-}
-
-func benchWords(b *testing.B, n int, decode bool) {
-	// Note: the file is OS-language dependent so the resulting values are not
-	// directly comparable for non-US-English OS installations.
-	data := expand(readFile(b, "/usr/share/dict/words"), n)
-	if decode {
-		benchDecode(b, data)
-	} else {
-		benchEncode(b, data)
-	}
-}
-
-func BenchmarkWordsDecode1e3(b *testing.B) { benchWords(b, 1e3, true) }
-func BenchmarkWordsDecode1e4(b *testing.B) { benchWords(b, 1e4, true) }
-func BenchmarkWordsDecode1e5(b *testing.B) { benchWords(b, 1e5, true) }
-func BenchmarkWordsDecode1e6(b *testing.B) { benchWords(b, 1e6, true) }
-func BenchmarkWordsEncode1e3(b *testing.B) { benchWords(b, 1e3, false) }
-func BenchmarkWordsEncode1e4(b *testing.B) { benchWords(b, 1e4, false) }
-func BenchmarkWordsEncode1e5(b *testing.B) { benchWords(b, 1e5, false) }
-func BenchmarkWordsEncode1e6(b *testing.B) { benchWords(b, 1e6, false) }
-
-// testFiles' values are copied directly from
-// https://raw.githubusercontent.com/google/snappy/master/snappy_unittest.cc
-// The label field is unused in snappy-go.
-var testFiles = []struct {
-	label    string
-	filename string
-}{
-	{"html", "html"},
-	{"urls", "urls.10K"},
-	{"jpg", "fireworks.jpeg"},
-	{"jpg_200", "fireworks.jpeg"},
-	{"pdf", "paper-100k.pdf"},
-	{"html4", "html_x_4"},
-	{"txt1", "alice29.txt"},
-	{"txt2", "asyoulik.txt"},
-	{"txt3", "lcet10.txt"},
-	{"txt4", "plrabn12.txt"},
-	{"pb", "geo.protodata"},
-	{"gaviota", "kppkn.gtb"},
-}
-
-// The test data files are present at this canonical URL.
-const baseURL = "https://raw.githubusercontent.com/google/snappy/master/testdata/"
-
-func downloadTestdata(b *testing.B, basename string) (errRet error) {
-	filename := filepath.Join(*testdata, basename)
-	if stat, err := os.Stat(filename); err == nil && stat.Size() != 0 {
-		return nil
-	}
-
-	if !*download {
-		b.Skipf("test data not found; skipping benchmark without the -download flag")
-	}
-	// Download the official snappy C++ implementation reference test data
-	// files for benchmarking.
-	if err := os.Mkdir(*testdata, 0777); err != nil && !os.IsExist(err) {
-		return fmt.Errorf("failed to create testdata: %s", err)
-	}
-
-	f, err := os.Create(filename)
-	if err != nil {
-		return fmt.Errorf("failed to create %s: %s", filename, err)
-	}
-	defer f.Close()
-	defer func() {
-		if errRet != nil {
-			os.Remove(filename)
-		}
-	}()
-	url := baseURL + basename
-	resp, err := http.Get(url)
-	if err != nil {
-		return fmt.Errorf("failed to download %s: %s", url, err)
-	}
-	defer resp.Body.Close()
-	if s := resp.StatusCode; s != http.StatusOK {
-		return fmt.Errorf("downloading %s: HTTP status code %d (%s)", url, s, http.StatusText(s))
-	}
-	_, err = io.Copy(f, resp.Body)
-	if err != nil {
-		return fmt.Errorf("failed to download %s to %s: %s", url, filename, err)
-	}
-	return nil
-}
-
-func benchFile(b *testing.B, n int, decode bool) {
-	if err := downloadTestdata(b, testFiles[n].filename); err != nil {
-		b.Fatalf("failed to download testdata: %s", err)
-	}
-	data := readFile(b, filepath.Join(*testdata, testFiles[n].filename))
-	if decode {
-		benchDecode(b, data)
-	} else {
-		benchEncode(b, data)
-	}
-}
-
-// Naming convention is kept similar to what snappy's C++ implementation uses.
-func Benchmark_UFlat0(b *testing.B)  { benchFile(b, 0, true) }
-func Benchmark_UFlat1(b *testing.B)  { benchFile(b, 1, true) }
-func Benchmark_UFlat2(b *testing.B)  { benchFile(b, 2, true) }
-func Benchmark_UFlat3(b *testing.B)  { benchFile(b, 3, true) }
-func Benchmark_UFlat4(b *testing.B)  { benchFile(b, 4, true) }
-func Benchmark_UFlat5(b *testing.B)  { benchFile(b, 5, true) }
-func Benchmark_UFlat6(b *testing.B)  { benchFile(b, 6, true) }
-func Benchmark_UFlat7(b *testing.B)  { benchFile(b, 7, true) }
-func Benchmark_UFlat8(b *testing.B)  { benchFile(b, 8, true) }
-func Benchmark_UFlat9(b *testing.B)  { benchFile(b, 9, true) }
-func Benchmark_UFlat10(b *testing.B) { benchFile(b, 10, true) }
-func Benchmark_UFlat11(b *testing.B) { benchFile(b, 11, true) }
-func Benchmark_ZFlat0(b *testing.B)  { benchFile(b, 0, false) }
-func Benchmark_ZFlat1(b *testing.B)  { benchFile(b, 1, false) }
-func Benchmark_ZFlat2(b *testing.B)  { benchFile(b, 2, false) }
-func Benchmark_ZFlat3(b *testing.B)  { benchFile(b, 3, false) }
-func Benchmark_ZFlat4(b *testing.B)  { benchFile(b, 4, false) }
-func Benchmark_ZFlat5(b *testing.B)  { benchFile(b, 5, false) }
-func Benchmark_ZFlat6(b *testing.B)  { benchFile(b, 6, false) }
-func Benchmark_ZFlat7(b *testing.B)  { benchFile(b, 7, false) }
-func Benchmark_ZFlat8(b *testing.B)  { benchFile(b, 8, false) }
-func Benchmark_ZFlat9(b *testing.B)  { benchFile(b, 9, false) }
-func Benchmark_ZFlat10(b *testing.B) { benchFile(b, 10, false) }
-func Benchmark_ZFlat11(b *testing.B) { benchFile(b, 11, false) }

Godeps/_workspace/src/github.com/juju/ratelimit/LICENSE

@@ -1,191 +0,0 @@
-All files in this repository are licensed as follows. If you contribute
-to this repository, it is assumed that you license your contribution
-under the same license unless you state otherwise.
-
-All files Copyright (C) 2015 Canonical Ltd. unless otherwise specified in the file.
-
-This software is licensed under the LGPLv3, included below.
-
-As a special exception to the GNU Lesser General Public License version 3
-("LGPL3"), the copyright holders of this Library give you permission to
-convey to a third party a Combined Work that links statically or dynamically
-to this Library without providing any Minimal Corresponding Source or
-Minimal Application Code as set out in 4d or providing the installation
-information set out in section 4e, provided that you comply with the other
-provisions of LGPL3 and provided that you meet, for the Application the
-terms and conditions of the license(s) which apply to the Application.
-
-Except as stated in this special exception, the provisions of LGPL3 will
-continue to comply in full to this Library. If you modify this Library, you
-may apply this exception to your version of this Library, but you are not
-obliged to do so. If you do not wish to do so, delete this exception
-statement from your version. This exception does not (and cannot) modify any
-license terms which apply to the Application, with which you must still
-comply.
-
-
-                   GNU LESSER GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-
-  This version of the GNU Lesser General Public License incorporates
-the terms and conditions of version 3 of the GNU General Public
-License, supplemented by the additional permissions listed below.
-
-  0. Additional Definitions.
-
-  As used herein, "this License" refers to version 3 of the GNU Lesser
-General Public License, and the "GNU GPL" refers to version 3 of the GNU
-General Public License.
-
-  "The Library" refers to a covered work governed by this License,
-other than an Application or a Combined Work as defined below.
-
-  An "Application" is any work that makes use of an interface provided
-by the Library, but which is not otherwise based on the Library.
-Defining a subclass of a class defined by the Library is deemed a mode
-of using an interface provided by the Library.
-
-  A "Combined Work" is a work produced by combining or linking an
-Application with the Library.  The particular version of the Library
-with which the Combined Work was made is also called the "Linked
-Version".
-
-  The "Minimal Corresponding Source" for a Combined Work means the
-Corresponding Source for the Combined Work, excluding any source code
-for portions of the Combined Work that, considered in isolation, are
-based on the Application, and not on the Linked Version.
-
-  The "Corresponding Application Code" for a Combined Work means the
-object code and/or source code for the Application, including any data
-and utility programs needed for reproducing the Combined Work from the
-Application, but excluding the System Libraries of the Combined Work.
-
-  1. Exception to Section 3 of the GNU GPL.
-
-  You may convey a covered work under sections 3 and 4 of this License
-without being bound by section 3 of the GNU GPL.
-
-  2. Conveying Modified Versions.
-
-  If you modify a copy of the Library, and, in your modifications, a
-facility refers to a function or data to be supplied by an Application
-that uses the facility (other than as an argument passed when the
-facility is invoked), then you may convey a copy of the modified
-version:
-
-   a) under this License, provided that you make a good faith effort to
-   ensure that, in the event an Application does not supply the
-   function or data, the facility still operates, and performs
-   whatever part of its purpose remains meaningful, or
-
-   b) under the GNU GPL, with none of the additional permissions of
-   this License applicable to that copy.
-
-  3. Object Code Incorporating Material from Library Header Files.
-
-  The object code form of an Application may incorporate material from
-a header file that is part of the Library.  You may convey such object
-code under terms of your choice, provided that, if the incorporated
-material is not limited to numerical parameters, data structure
-layouts and accessors, or small macros, inline functions and templates
-(ten or fewer lines in length), you do both of the following:
-
-   a) Give prominent notice with each copy of the object code that the
-   Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the object code with a copy of the GNU GPL and this license
-   document.
-
-  4. Combined Works.
-
-  You may convey a Combined Work under terms of your choice that,
-taken together, effectively do not restrict modification of the
-portions of the Library contained in the Combined Work and reverse
-engineering for debugging such modifications, if you also do each of
-the following:
-
-   a) Give prominent notice with each copy of the Combined Work that
-   the Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the Combined Work with a copy of the GNU GPL and this license
-   document.
-
-   c) For a Combined Work that displays copyright notices during
-   execution, include the copyright notice for the Library among
-   these notices, as well as a reference directing the user to the
-   copies of the GNU GPL and this license document.
-
-   d) Do one of the following:
-
-       0) Convey the Minimal Corresponding Source under the terms of this
-       License, and the Corresponding Application Code in a form
-       suitable for, and under terms that permit, the user to
-       recombine or relink the Application with a modified version of
-       the Linked Version to produce a modified Combined Work, in the
-       manner specified by section 6 of the GNU GPL for conveying
-       Corresponding Source.
-
-       1) Use a suitable shared library mechanism for linking with the
-       Library.  A suitable mechanism is one that (a) uses at run time
-       a copy of the Library already present on the user's computer
-       system, and (b) will operate properly with a modified version
-       of the Library that is interface-compatible with the Linked
-       Version.
-
-   e) Provide Installation Information, but only if you would otherwise
-   be required to provide such information under section 6 of the
-   GNU GPL, and only to the extent that such information is
-   necessary to install and execute a modified version of the
-   Combined Work produced by recombining or relinking the
-   Application with a modified version of the Linked Version. (If
-   you use option 4d0, the Installation Information must accompany
-   the Minimal Corresponding Source and Corresponding Application
-   Code. If you use option 4d1, you must provide the Installation
-   Information in the manner specified by section 6 of the GNU GPL
-   for conveying Corresponding Source.)
-
-  5. Combined Libraries.
-
-  You may place library facilities that are a work based on the
-Library side by side in a single library together with other library
-facilities that are not Applications and are not covered by this
-License, and convey such a combined library under terms of your
-choice, if you do both of the following:
-
-   a) Accompany the combined library with a copy of the same work based
-   on the Library, uncombined with any other library facilities,
-   conveyed under the terms of this License.
-
-   b) Give prominent notice with the combined library that part of it
-   is a work based on the Library, and explaining where to find the
-   accompanying uncombined form of the same work.
-
-  6. Revised Versions of the GNU Lesser General Public License.
-
-  The Free Software Foundation may publish revised and/or new versions
-of the GNU Lesser General Public License from time to time. Such new
-versions will be similar in spirit to the present version, but may
-differ in detail to address new problems or concerns.
-
-  Each version is given a distinguishing version number. If the
-Library as you received it specifies that a certain numbered version
-of the GNU Lesser General Public License "or any later version"
-applies to it, you have the option of following the terms and
-conditions either of that published version or of any later version
-published by the Free Software Foundation. If the Library as you
-received it does not specify a version number of the GNU Lesser
-General Public License, you may choose any version of the GNU Lesser
-General Public License ever published by the Free Software Foundation.
-
-  If the Library as you received it specifies that a proxy can decide
-whether future versions of the GNU Lesser General Public License shall
-apply, that proxy's public statement of acceptance of any version is
-permanent authorization for you to choose that version for the
-Library.

Godeps/_workspace/src/github.com/juju/ratelimit/README.md

@@ -1,117 +0,0 @@
-# ratelimit
---
-    import "github.com/juju/ratelimit"
-
-The ratelimit package provides an efficient token bucket implementation. See
-http://en.wikipedia.org/wiki/Token_bucket.
-
-## Usage
-
-#### func  Reader
-
-```go
-func Reader(r io.Reader, bucket *Bucket) io.Reader
-```
-Reader returns a reader that is rate limited by the given token bucket. Each
-token in the bucket represents one byte.
-
-#### func  Writer
-
-```go
-func Writer(w io.Writer, bucket *Bucket) io.Writer
-```
-Writer returns a writer that is rate limited by the given token bucket. Each
-token in the bucket represents one byte.
-
-#### type Bucket
-
-```go
-type Bucket struct {
-}
-```
-
-Bucket represents a token bucket that fills at a predetermined rate. Methods on
-Bucket may be called concurrently.
-
-#### func  NewBucket
-
-```go
-func NewBucket(fillInterval time.Duration, capacity int64) *Bucket
-```
-NewBucket returns a new token bucket that fills at the rate of one token every
-fillInterval, up to the given maximum capacity. Both arguments must be positive.
-The bucket is initially full.
-
-#### func  NewBucketWithQuantum
-
-```go
-func NewBucketWithQuantum(fillInterval time.Duration, capacity, quantum int64) *Bucket
-```
-NewBucketWithQuantum is similar to NewBucket, but allows the specification of
-the quantum size - quantum tokens are added every fillInterval.
-
-#### func  NewBucketWithRate
-
-```go
-func NewBucketWithRate(rate float64, capacity int64) *Bucket
-```
-NewBucketWithRate returns a token bucket that fills the bucket at the rate of
-rate tokens per second up to the given maximum capacity. Because of limited
-clock resolution, at high rates, the actual rate may be up to 1% different from
-the specified rate.
-
-#### func (*Bucket) Rate
-
-```go
-func (tb *Bucket) Rate() float64
-```
-Rate returns the fill rate of the bucket, in tokens per second.
-
-#### func (*Bucket) Take
-
-```go
-func (tb *Bucket) Take(count int64) time.Duration
-```
-Take takes count tokens from the bucket without blocking. It returns the time
-that the caller should wait until the tokens are actually available.
-
-Note that if the request is irrevocable - there is no way to return tokens to
-the bucket once this method commits us to taking them.
-
-#### func (*Bucket) TakeAvailable
-
-```go
-func (tb *Bucket) TakeAvailable(count int64) int64
-```
-TakeAvailable takes up to count immediately available tokens from the bucket. It
-returns the number of tokens removed, or zero if there are no available tokens.
-It does not block.
-
-#### func (*Bucket) TakeMaxDuration
-
-```go
-func (tb *Bucket) TakeMaxDuration(count int64, maxWait time.Duration) (time.Duration, bool)
-```
-TakeMaxDuration is like Take, except that it will only take tokens from the
-bucket if the wait time for the tokens is no greater than maxWait.
-
-If it would take longer than maxWait for the tokens to become available, it does
-nothing and reports false, otherwise it returns the time that the caller should
-wait until the tokens are actually available, and reports true.
-
-#### func (*Bucket) Wait
-
-```go
-func (tb *Bucket) Wait(count int64)
-```
-Wait takes count tokens from the bucket, waiting until they are available.
-
-#### func (*Bucket) WaitMaxDuration
-
-```go
-func (tb *Bucket) WaitMaxDuration(count int64, maxWait time.Duration) bool
-```
-WaitMaxDuration is like Wait except that it will only take tokens from the
-bucket if it needs to wait for no greater than maxWait. It reports whether any
-tokens have been removed from the bucket If no tokens have been removed, it
-returns immediately.

Godeps/_workspace/src/github.com/juju/ratelimit/ratelimit.go

@@ -1,221 +0,0 @@
-// Copyright 2014 Canonical Ltd.
-// Licensed under the LGPLv3 with static-linking exception.
-// See LICENCE file for details.
-
-// The ratelimit package provides an efficient token bucket implementation
-// that can be used to limit the rate of arbitrary things.
-// See http://en.wikipedia.org/wiki/Token_bucket.
-package ratelimit
-
-import (
-	"strconv"
-	"sync"
-	"time"
-	"math"
-)
-
-// Bucket represents a token bucket that fills at a predetermined rate.
-// Methods on Bucket may be called concurrently.
-type Bucket struct {
-	startTime    time.Time
-	capacity     int64
-	quantum      int64
-	fillInterval time.Duration
-
-	// The mutex guards the fields following it.
-	mu sync.Mutex
-
-	// avail holds the number of available tokens
-	// in the bucket, as of availTick ticks from startTime.
-	// It will be negative when there are consumers
-	// waiting for tokens.
-	avail     int64
-	availTick int64
-}
-
-// NewBucket returns a new token bucket that fills at the
-// rate of one token every fillInterval, up to the given
-// maximum capacity. Both arguments must be
-// positive. The bucket is initially full.
-func NewBucket(fillInterval time.Duration, capacity int64) *Bucket {
-	return NewBucketWithQuantum(fillInterval, capacity, 1)
-}
-
-// rateMargin specifes the allowed variance of actual
-// rate from specified rate. 1% seems reasonable.
-const rateMargin = 0.01
-
-// NewBucketWithRate returns a token bucket that fills the bucket
-// at the rate of rate tokens per second up to the given
-// maximum capacity. Because of limited clock resolution,
-// at high rates, the actual rate may be up to 1% different from the
-// specified rate.
-func NewBucketWithRate(rate float64, capacity int64) *Bucket {
-	for quantum := int64(1); quantum < 1<<50; quantum = nextQuantum(quantum) {
-		fillInterval := time.Duration(1e9 * float64(quantum) / rate)
-		if fillInterval <= 0 {
-			continue
-		}
-		tb := NewBucketWithQuantum(fillInterval, capacity, quantum)
-		if diff := math.Abs(tb.Rate() - rate); diff/rate <= rateMargin {
-			return tb
-		}
-	}
-	panic("cannot find suitable quantum for " + strconv.FormatFloat(rate, 'g', -1, 64))
-}
-
-// nextQuantum returns the next quantum to try after q.
-// We grow the quantum exponentially, but slowly, so we
-// get a good fit in the lower numbers.
-func nextQuantum(q int64) int64 {
-	q1 := q * 11 / 10
-	if q1 == q {
-		q1++
-	}
-	return q1
-}
-
-// NewBucketWithQuantum is similar to NewBucket, but allows
-// the specification of the quantum size - quantum tokens
-// are added every fillInterval.
-func NewBucketWithQuantum(fillInterval time.Duration, capacity, quantum int64) *Bucket {
-	if fillInterval <= 0 {
-		panic("token bucket fill interval is not > 0")
-	}
-	if capacity <= 0 {
-		panic("token bucket capacity is not > 0")
-	}
-	if quantum <= 0 {
-		panic("token bucket quantum is not > 0")
-	}
-	return &Bucket{
-		startTime:    time.Now(),
-		capacity:     capacity,
-		quantum:      quantum,
-		avail:        capacity,
-		fillInterval: fillInterval,
-	}
-}
-
-// Wait takes count tokens from the bucket, waiting until they are
-// available.
-func (tb *Bucket) Wait(count int64) {
-	if d := tb.Take(count); d > 0 {
-		time.Sleep(d)
-	}
-}
-
-// WaitMaxDuration is like Wait except that it will
-// only take tokens from the bucket if it needs to wait
-// for no greater than maxWait. It reports whether
-// any tokens have been removed from the bucket
-// If no tokens have been removed, it returns immediately.
-func (tb *Bucket) WaitMaxDuration(count int64, maxWait time.Duration) bool {
-	d, ok := tb.TakeMaxDuration(count, maxWait)
-	if d > 0 {
-		time.Sleep(d)
-	}
-	return ok
-}
-
-const infinityDuration time.Duration = 0x7fffffffffffffff
-
-// Take takes count tokens from the bucket without blocking. It returns
-// the time that the caller should wait until the tokens are actually
-// available.
-//
-// Note that if the request is irrevocable - there is no way to return
-// tokens to the bucket once this method commits us to taking them.
-func (tb *Bucket) Take(count int64) time.Duration {
-	d, _ := tb.take(time.Now(), count, infinityDuration)
-	return d
-}
-
-// TakeMaxDuration is like Take, except that
-// it will only take tokens from the bucket if the wait
-// time for the tokens is no greater than maxWait.
-//
-// If it would take longer than maxWait for the tokens
-// to become available, it does nothing and reports false,
-// otherwise it returns the time that the caller should
-// wait until the tokens are actually available, and reports
-// true.
-func (tb *Bucket) TakeMaxDuration(count int64, maxWait time.Duration) (time.Duration, bool) {
-	return tb.take(time.Now(), count, maxWait)
-}
-
-// TakeAvailable takes up to count immediately available tokens from the
-// bucket. It returns the number of tokens removed, or zero if there are
-// no available tokens. It does not block.
-func (tb *Bucket) TakeAvailable(count int64) int64 {
-	return tb.takeAvailable(time.Now(), count)
-}
-
-// takeAvailable is the internal version of TakeAvailable - it takes the
-// current time as an argument to enable easy testing.
-func (tb *Bucket) takeAvailable(now time.Time, count int64) int64 {
-	if count <= 0 {
-		return 0
-	}
-	tb.mu.Lock()
-	defer tb.mu.Unlock()
-
-	tb.adjust(now)
-	if tb.avail <= 0 {
-		return 0
-	}
-	if count > tb.avail {
-		count = tb.avail
-	}
-	tb.avail -= count
-	return count
-}
-
-// Rate returns the fill rate of the bucket, in tokens per second.
-func (tb *Bucket) Rate() float64 {
-	return 1e9 * float64(tb.quantum) / float64(tb.fillInterval)
-}
-
-// take is the internal version of Take - it takes the current time as
-// an argument to enable easy testing.
-func (tb *Bucket) take(now time.Time, count int64, maxWait time.Duration) (time.Duration, bool) {
-	if count <= 0 {
-		return 0, true
-	}
-	tb.mu.Lock()
-	defer tb.mu.Unlock()
-
-	currentTick := tb.adjust(now)
-	avail := tb.avail - count
-	if avail >= 0 {
-		tb.avail = avail
-		return 0, true
-	}
-	// Round up the missing tokens to the nearest multiple
-	// of quantum - the tokens won't be available until
-	// that tick.
-	endTick := currentTick + (-avail+tb.quantum-1)/tb.quantum
-	endTime := tb.startTime.Add(time.Duration(endTick) * tb.fillInterval)
-	waitTime := endTime.Sub(now)
-	if waitTime > maxWait {
-		return 0, false
-	}
-	tb.avail = avail
-	return waitTime, true
-}
-
-// adjust adjusts the current bucket capacity based on the current time.
-// It returns the current tick.
-func (tb *Bucket) adjust(now time.Time) (currentTick int64) {
-	currentTick = int64(now.Sub(tb.startTime) / tb.fillInterval)
-
-	if tb.avail >= tb.capacity {
-		return
-	}
-	tb.avail += (currentTick - tb.availTick) * tb.quantum
-	if tb.avail > tb.capacity {
-		tb.avail = tb.capacity
-	}
-	tb.availTick = currentTick
-	return
-}

Godeps/_workspace/src/github.com/juju/ratelimit/ratelimit_test.go

@@ -1,328 +0,0 @@
-// Copyright 2014 Canonical Ltd.
-// Licensed under the LGPLv3 with static-linking exception.
-// See LICENCE file for details.
-
-package ratelimit
-
-import (
-	gc "launchpad.net/gocheck"
-
-	"testing"
-	"time"
-)
-
-func TestPackage(t *testing.T) {
-	gc.TestingT(t)
-}
-
-type rateLimitSuite struct{}
-
-var _ = gc.Suite(rateLimitSuite{})
-
-type takeReq struct {
-	time       time.Duration
-	count      int64
-	expectWait time.Duration
-}
-
-var takeTests = []struct {
-	about        string
-	fillInterval time.Duration
-	capacity     int64
-	reqs         []takeReq
-}{{
-	about:        "serial requests",
-	fillInterval: 250 * time.Millisecond,
-	capacity:     10,
-	reqs: []takeReq{{
-		time:       0,
-		count:      0,
-		expectWait: 0,
-	}, {
-		time:       0,
-		count:      10,
-		expectWait: 0,
-	}, {
-		time:       0,
-		count:      1,
-		expectWait: 250 * time.Millisecond,
-	}, {
-		time:       250 * time.Millisecond,
-		count:      1,
-		expectWait: 250 * time.Millisecond,
-	}},
-}, {
-	about:        "concurrent requests",
-	fillInterval: 250 * time.Millisecond,
-	capacity:     10,
-	reqs: []takeReq{{
-		time:       0,
-		count:      10,
-		expectWait: 0,
-	}, {
-		time:       0,
-		count:      2,
-		expectWait: 500 * time.Millisecond,
-	}, {
-		time:       0,
-		count:      2,
-		expectWait: 1000 * time.Millisecond,
-	}, {
-		time:       0,
-		count:      1,
-		expectWait: 1250 * time.Millisecond,
-	}},
-}, {
-	about:        "more than capacity",
-	fillInterval: 1 * time.Millisecond,
-	capacity:     10,
-	reqs: []takeReq{{
-		time:       0,
-		count:      10,
-		expectWait: 0,
-	}, {
-		time:       20 * time.Millisecond,
-		count:      15,
-		expectWait: 5 * time.Millisecond,
-	}},
-}, {
-	about:        "sub-quantum time",
-	fillInterval: 10 * time.Millisecond,
-	capacity:     10,
-	reqs: []takeReq{{
-		time:       0,
-		count:      10,
-		expectWait: 0,
-	}, {
-		time:       7 * time.Millisecond,
-		count:      1,
-		expectWait: 3 * time.Millisecond,
-	}, {
-		time:       8 * time.Millisecond,
-		count:      1,
-		expectWait: 12 * time.Millisecond,
-	}},
-}, {
-	about:        "within capacity",
-	fillInterval: 10 * time.Millisecond,
-	capacity:     5,
-	reqs: []takeReq{{
-		time:       0,
-		count:      5,
-		expectWait: 0,
-	}, {
-		time:       60 * time.Millisecond,
-		count:      5,
-		expectWait: 0,
-	}, {
-		time:       60 * time.Millisecond,
-		count:      1,
-		expectWait: 10 * time.Millisecond,
-	}, {
-		time:       80 * time.Millisecond,
-		count:      2,
-		expectWait: 10 * time.Millisecond,
-	}},
-}}
-
-func (rateLimitSuite) TestTake(c *gc.C) {
-	for i, test := range takeTests {
-		tb := NewBucket(test.fillInterval, test.capacity)
-		for j, req := range test.reqs {
-			d, ok := tb.take(tb.startTime.Add(req.time), req.count, infinityDuration)
-			c.Assert(ok, gc.Equals, true)
-			if d != req.expectWait {
-				c.Fatalf("test %d.%d, %s, got %v want %v", i, j, test.about, d, req.expectWait)
-			}
-		}
-	}
-}
-
-func (rateLimitSuite) TestTakeMaxDuration(c *gc.C) {
-	for i, test := range takeTests {
-		tb := NewBucket(test.fillInterval, test.capacity)
-		for j, req := range test.reqs {
-			if req.expectWait > 0 {
-				d, ok := tb.take(tb.startTime.Add(req.time), req.count, req.expectWait-1)
-				c.Assert(ok, gc.Equals, false)
-				c.Assert(d, gc.Equals, time.Duration(0))
-			}
-			d, ok := tb.take(tb.startTime.Add(req.time), req.count, req.expectWait)
-			c.Assert(ok, gc.Equals, true)
-			if d != req.expectWait {
-				c.Fatalf("test %d.%d, %s, got %v want %v", i, j, test.about, d, req.expectWait)
-			}
-		}
-	}
-}
-
-type takeAvailableReq struct {
-	time   time.Duration
-	count  int64
-	expect int64
-}
-
-var takeAvailableTests = []struct {
-	about        string
-	fillInterval time.Duration
-	capacity     int64
-	reqs         []takeAvailableReq
-}{{
-	about:        "serial requests",
-	fillInterval: 250 * time.Millisecond,
-	capacity:     10,
-	reqs: []takeAvailableReq{{
-		time:   0,
-		count:  0,
-		expect: 0,
-	}, {
-		time:   0,
-		count:  10,
-		expect: 10,
-	}, {
-		time:   0,
-		count:  1,
-		expect: 0,
-	}, {
-		time:   250 * time.Millisecond,
-		count:  1,
-		expect: 1,
-	}},
-}, {
-	about:        "concurrent requests",
-	fillInterval: 250 * time.Millisecond,
-	capacity:     10,
-	reqs: []takeAvailableReq{{
-		time:   0,
-		count:  5,
-		expect: 5,
-	}, {
-		time:   0,
-		count:  2,
-		expect: 2,
-	}, {
-		time:   0,
-		count:  5,
-		expect: 3,
-	}, {
-		time:   0,
-		count:  1,
-		expect: 0,
-	}},
-}, {
-	about:        "more than capacity",
-	fillInterval: 1 * time.Millisecond,
-	capacity:     10,
-	reqs: []takeAvailableReq{{
-		time:   0,
-		count:  10,
-		expect: 10,
-	}, {
-		time:   20 * time.Millisecond,
-		count:  15,
-		expect: 10,
-	}},
-}, {
-	about:        "within capacity",
-	fillInterval: 10 * time.Millisecond,
-	capacity:     5,
-	reqs: []takeAvailableReq{{
-		time:   0,
-		count:  5,
-		expect: 5,
-	}, {
-		time:   60 * time.Millisecond,
-		count:  5,
-		expect: 5,
-	}, {
-		time:   70 * time.Millisecond,
-		count:  1,
-		expect: 1,
-	}},
-}}
-
-func (rateLimitSuite) TestTakeAvailable(c *gc.C) {
-	for i, test := range takeAvailableTests {
-		tb := NewBucket(test.fillInterval, test.capacity)
-		for j, req := range test.reqs {
-			d := tb.takeAvailable(tb.startTime.Add(req.time), req.count)
-			if d != req.expect {
-				c.Fatalf("test %d.%d, %s, got %v want %v", i, j, test.about, d, req.expect)
-			}
-		}
-	}
-}
-
-func (rateLimitSuite) TestPanics(c *gc.C) {
-	c.Assert(func() { NewBucket(0, 1) }, gc.PanicMatches, "token bucket fill interval is not > 0")
-	c.Assert(func() { NewBucket(-2, 1) }, gc.PanicMatches, "token bucket fill interval is not > 0")
-	c.Assert(func() { NewBucket(1, 0) }, gc.PanicMatches, "token bucket capacity is not > 0")
-	c.Assert(func() { NewBucket(1, -2) }, gc.PanicMatches, "token bucket capacity is not > 0")
-}
-
-func isCloseTo(x, y, tolerance float64) bool {
-	return abs(x-y)/y < tolerance
-}
-
-func (rateLimitSuite) TestRate(c *gc.C) {
-	tb := NewBucket(1, 1)
-	if !isCloseTo(tb.Rate(), 1e9, 0.00001) {
-		c.Fatalf("got %v want 1e9", tb.Rate())
-	}
-	tb = NewBucket(2*time.Second, 1)
-	if !isCloseTo(tb.Rate(), 0.5, 0.00001) {
-		c.Fatalf("got %v want 0.5", tb.Rate())
-	}
-	tb = NewBucketWithQuantum(100*time.Millisecond, 1, 5)
-	if !isCloseTo(tb.Rate(), 50, 0.00001) {
-		c.Fatalf("got %v want 50", tb.Rate())
-	}
-}
-
-func checkRate(c *gc.C, rate float64) {
-	tb := NewBucketWithRate(rate, 1<<62)
-	if !isCloseTo(tb.Rate(), rate, rateMargin) {
-		c.Fatalf("got %g want %v", tb.Rate(), rate)
-	}
-	d, ok := tb.take(tb.startTime, 1<<62, infinityDuration)
-	c.Assert(ok, gc.Equals, true)
-	c.Assert(d, gc.Equals, time.Duration(0))
-
-	// Check that the actual rate is as expected by
-	// asking for a not-quite multiple of the bucket's
-	// quantum and checking that the wait time
-	// correct.
-	d, ok = tb.take(tb.startTime, tb.quantum*2-tb.quantum/2, infinityDuration)
-	c.Assert(ok, gc.Equals, true)
-	expectTime := 1e9 * float64(tb.quantum) * 2 / rate
-	if !isCloseTo(float64(d), expectTime, rateMargin) {
-		c.Fatalf("rate %g: got %g want %v", rate, float64(d), expectTime)
-	}
-}
-
-func (rateLimitSuite) TestNewWithRate(c *gc.C) {
-	for rate := float64(1); rate < 1e6; rate += 7 {
-		checkRate(c, rate)
-	}
-	for _, rate := range []float64{
-		1024 * 1024 * 1024,
-		1e-5,
-		0.9e-5,
-		0.5,
-		0.9,
-		0.9e8,
-		3e12,
-		4e18,
-	} {
-		checkRate(c, rate)
-		checkRate(c, rate/3)
-		checkRate(c, rate*1.3)
-	}
-}
-
-func BenchmarkWait(b *testing.B) {
-	tb := NewBucket(1, 16*1024)
-	for i := b.N - 1; i >= 0; i-- {
-		tb.Wait(1)
-	}
-}

Godeps/_workspace/src/github.com/juju/ratelimit/reader.go

@@ -1,51 +0,0 @@
-// Copyright 2014 Canonical Ltd.
-// Licensed under the LGPLv3 with static-linking exception.
-// See LICENCE file for details.
-
-package ratelimit
-
-import "io"
-
-type reader struct {
-	r      io.Reader
-	bucket *Bucket
-}
-
-// Reader returns a reader that is rate limited by
-// the given token bucket. Each token in the bucket
-// represents one byte.
-func Reader(r io.Reader, bucket *Bucket) io.Reader {
-	return &reader{
-		r:      r,
-		bucket: bucket,
-	}
-}
-
-func (r *reader) Read(buf []byte) (int, error) {
-	n, err := r.r.Read(buf)
-	if n <= 0 {
-		return n, err
-	}
-	r.bucket.Wait(int64(n))
-	return n, err
-}
-
-type writer struct {
-	w      io.Writer
-	bucket *Bucket
-}
-
-// Writer returns a reader that is rate limited by
-// the given token bucket. Each token in the bucket
-// represents one byte.
-func Writer(w io.Writer, bucket *Bucket) io.Writer {
-	return &writer{
-		w:      w,
-		bucket: bucket,
-	}
-}
-
-func (w *writer) Write(buf []byte) (int, error) {
-	w.bucket.Wait(int64(len(buf)))
-	return w.w.Write(buf)
-}

Godeps/_workspace/src/github.com/kardianos/osext/README.md

@@ -1,16 +0,0 @@
-### Extensions to the "os" package.
-
-## Find the current Executable and ExecutableFolder.
-
-There is sometimes utility in finding the current executable file
-that is running. This can be used for upgrading the current executable
-or finding resources located relative to the executable file. Both
-working directory and the os.Args[0] value are arbitrary and cannot
-be relied on; os.Args[0] can be "faked".
-
-Multi-platform and supports:
- * Linux
- * OS X
- * Windows
- * Plan 9
- * BSDs.

Godeps/_workspace/src/github.com/kardianos/osext/osext_sysctl.go

@@ -1,79 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build darwin freebsd
-
-package osext
-
-import (
-	"os"
-	"path/filepath"
-	"runtime"
-	"syscall"
-	"unsafe"
-)
-
-var initCwd, initCwdErr = os.Getwd()
-
-func executable() (string, error) {
-	var mib [4]int32
-	switch runtime.GOOS {
-	case "freebsd":
-		mib = [4]int32{1 /* CTL_KERN */, 14 /* KERN_PROC */, 12 /* KERN_PROC_PATHNAME */, -1}
-	case "darwin":
-		mib = [4]int32{1 /* CTL_KERN */, 38 /* KERN_PROCARGS */, int32(os.Getpid()), -1}
-	}
-
-	n := uintptr(0)
-	// Get length.
-	_, _, errNum := syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), 4, 0, uintptr(unsafe.Pointer(&n)), 0, 0)
-	if errNum != 0 {
-		return "", errNum
-	}
-	if n == 0 { // This shouldn't happen.
-		return "", nil
-	}
-	buf := make([]byte, n)
-	_, _, errNum = syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), 4, uintptr(unsafe.Pointer(&buf[0])), uintptr(unsafe.Pointer(&n)), 0, 0)
-	if errNum != 0 {
-		return "", errNum
-	}
-	if n == 0 { // This shouldn't happen.
-		return "", nil
-	}
-	for i, v := range buf {
-		if v == 0 {
-			buf = buf[:i]
-			break
-		}
-	}
-	var err error
-	execPath := string(buf)
-	// execPath will not be empty due to above checks.
-	// Try to get the absolute path if the execPath is not rooted.
-	if execPath[0] != '/' {
-		execPath, err = getAbs(execPath)
-		if err != nil {
-			return execPath, err
-		}
-	}
-	// For darwin KERN_PROCARGS may return the path to a symlink rather than the
-	// actual executable.
-	if runtime.GOOS == "darwin" {
-		if execPath, err = filepath.EvalSymlinks(execPath); err != nil {
-			return execPath, err
-		}
-	}
-	return execPath, nil
-}
-
-func getAbs(execPath string) (string, error) {
-	if initCwdErr != nil {
-		return execPath, initCwdErr
-	}
-	// The execPath may begin with a "../" or a "./" so clean it first.
-	// Join the two paths, trailing and starting slashes undetermined, so use
-	// the generic Join function.
-	return filepath.Join(initCwd, filepath.Clean(execPath)), nil
-}

Godeps/_workspace/src/github.com/kardianos/osext/osext_test.go

@@ -1,203 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build darwin linux freebsd netbsd windows
-
-package osext
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"runtime"
-	"testing"
-)
-
-const (
-	executableEnvVar = "OSTEST_OUTPUT_EXECUTABLE"
-
-	executableEnvValueMatch  = "match"
-	executableEnvValueDelete = "delete"
-)
-
-func TestPrintExecutable(t *testing.T) {
-	ef, err := Executable()
-	if err != nil {
-		t.Fatalf("Executable failed: %v", err)
-	}
-	t.Log("Executable:", ef)
-}
-func TestPrintExecutableFolder(t *testing.T) {
-	ef, err := ExecutableFolder()
-	if err != nil {
-		t.Fatalf("ExecutableFolder failed: %v", err)
-	}
-	t.Log("Executable Folder:", ef)
-}
-func TestExecutableFolder(t *testing.T) {
-	ef, err := ExecutableFolder()
-	if err != nil {
-		t.Fatalf("ExecutableFolder failed: %v", err)
-	}
-	if ef[len(ef)-1] == filepath.Separator {
-		t.Fatal("ExecutableFolder ends with a trailing slash.")
-	}
-}
-func TestExecutableMatch(t *testing.T) {
-	ep, err := Executable()
-	if err != nil {
-		t.Fatalf("Executable failed: %v", err)
-	}
-
-	// fullpath to be of the form "dir/prog".
-	dir := filepath.Dir(filepath.Dir(ep))
-	fullpath, err := filepath.Rel(dir, ep)
-	if err != nil {
-		t.Fatalf("filepath.Rel: %v", err)
-	}
-	// Make child start with a relative program path.
-	// Alter argv[0] for child to verify getting real path without argv[0].
-	cmd := &exec.Cmd{
-		Dir:  dir,
-		Path: fullpath,
-		Env:  []string{fmt.Sprintf("%s=%s", executableEnvVar, executableEnvValueMatch)},
-	}
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		t.Fatalf("exec(self) failed: %v", err)
-	}
-	outs := string(out)
-	if !filepath.IsAbs(outs) {
-		t.Fatalf("Child returned %q, want an absolute path", out)
-	}
-	if !sameFile(outs, ep) {
-		t.Fatalf("Child returned %q, not the same file as %q", out, ep)
-	}
-}
-
-func TestExecutableDelete(t *testing.T) {
-	if runtime.GOOS != "linux" {
-		t.Skip()
-	}
-	fpath, err := Executable()
-	if err != nil {
-		t.Fatalf("Executable failed: %v", err)
-	}
-
-	r, w := io.Pipe()
-	stderrBuff := &bytes.Buffer{}
-	stdoutBuff := &bytes.Buffer{}
-	cmd := &exec.Cmd{
-		Path:   fpath,
-		Env:    []string{fmt.Sprintf("%s=%s", executableEnvVar, executableEnvValueDelete)},
-		Stdin:  r,
-		Stderr: stderrBuff,
-		Stdout: stdoutBuff,
-	}
-	err = cmd.Start()
-	if err != nil {
-		t.Fatalf("exec(self) start failed: %v", err)
-	}
-
-	tempPath := fpath + "_copy"
-	_ = os.Remove(tempPath)
-
-	err = copyFile(tempPath, fpath)
-	if err != nil {
-		t.Fatalf("copy file failed: %v", err)
-	}
-	err = os.Remove(fpath)
-	if err != nil {
-		t.Fatalf("remove running test file failed: %v", err)
-	}
-	err = os.Rename(tempPath, fpath)
-	if err != nil {
-		t.Fatalf("rename copy to previous name failed: %v", err)
-	}
-
-	w.Write([]byte{0})
-	w.Close()
-
-	err = cmd.Wait()
-	if err != nil {
-		t.Fatalf("exec wait failed: %v", err)
-	}
-
-	childPath := stderrBuff.String()
-	if !filepath.IsAbs(childPath) {
-		t.Fatalf("Child returned %q, want an absolute path", childPath)
-	}
-	if !sameFile(childPath, fpath) {
-		t.Fatalf("Child returned %q, not the same file as %q", childPath, fpath)
-	}
-}
-
-func sameFile(fn1, fn2 string) bool {
-	fi1, err := os.Stat(fn1)
-	if err != nil {
-		return false
-	}
-	fi2, err := os.Stat(fn2)
-	if err != nil {
-		return false
-	}
-	return os.SameFile(fi1, fi2)
-}
-func copyFile(dest, src string) error {
-	df, err := os.Create(dest)
-	if err != nil {
-		return err
-	}
-	defer df.Close()
-
-	sf, err := os.Open(src)
-	if err != nil {
-		return err
-	}
-	defer sf.Close()
-
-	_, err = io.Copy(df, sf)
-	return err
-}
-
-func TestMain(m *testing.M) {
-	env := os.Getenv(executableEnvVar)
-	switch env {
-	case "":
-		os.Exit(m.Run())
-	case executableEnvValueMatch:
-		// First chdir to another path.
-		dir := "/"
-		if runtime.GOOS == "windows" {
-			dir = filepath.VolumeName(".")
-		}
-		os.Chdir(dir)
-		if ep, err := Executable(); err != nil {
-			fmt.Fprint(os.Stderr, "ERROR: ", err)
-		} else {
-			fmt.Fprint(os.Stderr, ep)
-		}
-	case executableEnvValueDelete:
-		bb := make([]byte, 1)
-		var err error
-		n, err := os.Stdin.Read(bb)
-		if err != nil {
-			fmt.Fprint(os.Stderr, "ERROR: ", err)
-			os.Exit(2)
-		}
-		if n != 1 {
-			fmt.Fprint(os.Stderr, "ERROR: n != 1, n == ", n)
-			os.Exit(2)
-		}
-		if ep, err := Executable(); err != nil {
-			fmt.Fprint(os.Stderr, "ERROR: ", err)
-		} else {
-			fmt.Fprint(os.Stderr, ep)
-		}
-	}
-	os.Exit(0)
-}

Godeps/_workspace/src/github.com/syncthing/protocol/AUTHORS

@@ -1,4 +0,0 @@
-# This is the official list of Protocol Authors for copyright purposes.
-
-Audrius Butkevicius <audrius.butkevicius@gmail.com>
-Jakob Borg <jakob@nym.se>

Godeps/_workspace/src/github.com/syncthing/protocol/CONTRIBUTING.md

@@ -1,76 +0,0 @@
-## Reporting Bugs
-
-Please file bugs in the [Github Issue
-Tracker](https://github.com/syncthing/protocol/issues).
-
-## Contributing Code
-
-Every contribution is welcome. Following the points below will make this
-a smoother process.
-
-Individuals making significant and valuable contributions are given
-commit-access to the project. If you make a significant contribution and
-are not considered for commit-access, please contact any of the
-Syncthing core team members.
-
-All nontrivial contributions should go through the pull request
-mechanism for internal review. Determining what is "nontrivial" is left
-at the discretion of the contributor.
-
-### Authorship
-
-All code authors are listed in the AUTHORS file. Commits must be made
-with the same name and email as listed in the AUTHORS file. To
-accomplish this, ensure that your git configuration is set correctly
-prior to making your first commit;
-
-    $ git config --global user.name "Jane Doe"
-    $ git config --global user.email janedoe@example.com
-
-You must be reachable on the given email address. If you do not wish to
-use your real name for whatever reason, using a nickname or pseudonym is
-perfectly acceptable.
-
-## Coding Style
-
-- Follow the conventions laid out in [Effective Go](https://golang.org/doc/effective_go.html)
-  as much as makes sense.
-
-- All text files use Unix line endings.
-
-- Each commit should be `go fmt` clean.
-
-- The commit message subject should be a single short sentence
-  describing the change, starting with a capital letter.
-
-- Commits that resolve an existing issue must include the issue number
-  as `(fixes #123)` at the end of the commit message subject.
-
-- Imports are grouped per `goimports` standard; that is, standard
-  library first, then third party libraries after a blank line.
-
-- A contribution solving a single issue or introducing a single new
-  feature should probably be a single commit based on the current
-  `master` branch. You may be asked to "rebase" or "squash" your pull
-  request to make sure this is the case, especially if there have been
-  amendments during review.
-
-## Licensing
-
-All contributions are made under the same MIT license as the rest of the
-project, except documentation, user interface text and translation
-strings which are licensed under the Creative Commons Attribution 4.0
-International License. You retain the copyright to code you have
-written.
-
-When accepting your first contribution, the maintainer of the project
-will ensure that you are added to the AUTHORS file. You are welcome to
-add yourself as a separate commit in your first pull request.
-
-## Tests
-
-Yes please!
-
-## License
-
-MIT

Godeps/_workspace/src/github.com/syncthing/protocol/README.md

@@ -1,13 +0,0 @@
-The BEPv1 Protocol
-==================
-
-[![Latest Build](http://img.shields.io/jenkins/s/http/build.syncthing.net/protocol.svg?style=flat-square)](http://build.syncthing.net/job/protocol/lastBuild/)
-[![API Documentation](http://img.shields.io/badge/api-Godoc-blue.svg?style=flat-square)](http://godoc.org/github.com/syncthing/protocol)
-[![MIT License](http://img.shields.io/badge/license-MIT-blue.svg?style=flat-square)](http://opensource.org/licenses/MIT)
-
-This is the protocol implementation used by Syncthing.
-
-License
-=======
-
-MIT

Godeps/_workspace/src/github.com/syncthing/protocol/common_test.go

@@ -1,81 +0,0 @@
-// Copyright (C) 2014 The Protocol Authors.
-
-package protocol
-
-import (
-	"io"
-	"time"
-)
-
-type TestModel struct {
-	data     []byte
-	folder   string
-	name     string
-	offset   int64
-	size     int
-	hash     []byte
-	flags    uint32
-	options  []Option
-	closedCh chan bool
-}
-
-func newTestModel() *TestModel {
-	return &TestModel{
-		closedCh: make(chan bool),
-	}
-}
-
-func (t *TestModel) Index(deviceID DeviceID, folder string, files []FileInfo, flags uint32, options []Option) {
-}
-
-func (t *TestModel) IndexUpdate(deviceID DeviceID, folder string, files []FileInfo, flags uint32, options []Option) {
-}
-
-func (t *TestModel) Request(deviceID DeviceID, folder, name string, offset int64, hash []byte, flags uint32, options []Option, buf []byte) error {
-	t.folder = folder
-	t.name = name
-	t.offset = offset
-	t.size = len(buf)
-	t.hash = hash
-	t.flags = flags
-	t.options = options
-	copy(buf, t.data)
-	return nil
-}
-
-func (t *TestModel) Close(deviceID DeviceID, err error) {
-	close(t.closedCh)
-}
-
-func (t *TestModel) ClusterConfig(deviceID DeviceID, config ClusterConfigMessage) {
-}
-
-func (t *TestModel) isClosed() bool {
-	select {
-	case <-t.closedCh:
-		return true
-	case <-time.After(1 * time.Second):
-		return false // Timeout
-	}
-}
-
-type ErrPipe struct {
-	io.PipeWriter
-	written int
-	max     int
-	err     error
-	closed  bool
-}
-
-func (e *ErrPipe) Write(data []byte) (int, error) {
-	if e.closed {
-		return 0, e.err
-	}
-	if e.written+len(data) > e.max {
-		n, _ := e.PipeWriter.Write(data[:e.max-e.written])
-		e.PipeWriter.CloseWithError(e.err)
-		e.closed = true
-		return n, e.err
-	}
-	return e.PipeWriter.Write(data)
-}

Godeps/_workspace/src/github.com/syncthing/protocol/compression.go

@@ -1,53 +0,0 @@
-// Copyright (C) 2015 The Protocol Authors.
-
-package protocol
-
-import "fmt"
-
-type Compression int
-
-const (
-	CompressMetadata Compression = iota // zero value is the default, default should be "metadata"
-	CompressNever
-	CompressAlways
-
-	compressionThreshold = 128 // don't bother compressing messages smaller than this many bytes
-)
-
-var compressionMarshal = map[Compression]string{
-	CompressNever:    "never",
-	CompressMetadata: "metadata",
-	CompressAlways:   "always",
-}
-
-var compressionUnmarshal = map[string]Compression{
-	// Legacy
-	"false": CompressNever,
-	"true":  CompressMetadata,
-
-	// Current
-	"never":    CompressNever,
-	"metadata": CompressMetadata,
-	"always":   CompressAlways,
-}
-
-func (c Compression) String() string {
-	s, ok := compressionMarshal[c]
-	if !ok {
-		return fmt.Sprintf("unknown:%d", c)
-	}
-	return s
-}
-
-func (c Compression) GoString() string {
-	return fmt.Sprintf("%q", c.String())
-}
-
-func (c Compression) MarshalText() ([]byte, error) {
-	return []byte(compressionMarshal[c]), nil
-}
-
-func (c *Compression) UnmarshalText(bs []byte) error {
-	*c = compressionUnmarshal[string(bs)]
-	return nil
-}

Godeps/_workspace/src/github.com/syncthing/protocol/conflict_test.go

@@ -1,23 +0,0 @@
-// Copyright (C) 2015 The Protocol Authors.
-
-package protocol
-
-import "testing"
-
-func TestWinsConflict(t *testing.T) {
-	testcases := [][2]FileInfo{
-		// The first should always win over the second
-		{{Modified: 42}, {Modified: 41}},
-		{{Modified: 41}, {Modified: 42, Flags: FlagDeleted}},
-		{{Modified: 41, Version: Vector{{42, 2}, {43, 1}}}, {Modified: 41, Version: Vector{{42, 1}, {43, 2}}}},
-	}
-
-	for _, tc := range testcases {
-		if !tc[0].WinsConflict(tc[1]) {
-			t.Errorf("%v should win over %v", tc[0], tc[1])
-		}
-		if tc[1].WinsConflict(tc[0]) {
-			t.Errorf("%v should not win over %v", tc[1], tc[0])
-		}
-	}
-}

Godeps/_workspace/src/github.com/syncthing/protocol/debug.go

@@ -1,15 +0,0 @@
-// Copyright (C) 2014 The Protocol Authors.
-
-package protocol
-
-import (
-	"os"
-	"strings"
-
-	"github.com/calmh/logger"
-)
-
-var (
-	debug = strings.Contains(os.Getenv("STTRACE"), "protocol") || os.Getenv("STTRACE") == "all"
-	l     = logger.DefaultLogger
-)

Godeps/_workspace/src/github.com/syncthing/protocol/deviceid.go

@@ -1,163 +0,0 @@
-// Copyright (C) 2014 The Protocol Authors.
-
-package protocol
-
-import (
-	"bytes"
-	"crypto/sha256"
-	"encoding/base32"
-	"encoding/binary"
-	"errors"
-	"fmt"
-	"regexp"
-	"strings"
-
-	"github.com/calmh/luhn"
-)
-
-type DeviceID [32]byte
-
-var LocalDeviceID = DeviceID{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}
-
-// NewDeviceID generates a new device ID from the raw bytes of a certificate
-func NewDeviceID(rawCert []byte) DeviceID {
-	var n DeviceID
-	hf := sha256.New()
-	hf.Write(rawCert)
-	hf.Sum(n[:0])
-	return n
-}
-
-func DeviceIDFromString(s string) (DeviceID, error) {
-	var n DeviceID
-	err := n.UnmarshalText([]byte(s))
-	return n, err
-}
-
-func DeviceIDFromBytes(bs []byte) DeviceID {
-	var n DeviceID
-	if len(bs) != len(n) {
-		panic("incorrect length of byte slice representing device ID")
-	}
-	copy(n[:], bs)
-	return n
-}
-
-// String returns the canonical string representation of the device ID
-func (n DeviceID) String() string {
-	id := base32.StdEncoding.EncodeToString(n[:])
-	id = strings.Trim(id, "=")
-	id, err := luhnify(id)
-	if err != nil {
-		// Should never happen
-		panic(err)
-	}
-	id = chunkify(id)
-	return id
-}
-
-func (n DeviceID) GoString() string {
-	return n.String()
-}
-
-func (n DeviceID) Compare(other DeviceID) int {
-	return bytes.Compare(n[:], other[:])
-}
-
-func (n DeviceID) Equals(other DeviceID) bool {
-	return bytes.Compare(n[:], other[:]) == 0
-}
-
-// Short returns an integer representing bits 0-63 of the device ID.
-func (n DeviceID) Short() uint64 {
-	return binary.BigEndian.Uint64(n[:])
-}
-
-func (n *DeviceID) MarshalText() ([]byte, error) {
-	return []byte(n.String()), nil
-}
-
-func (n *DeviceID) UnmarshalText(bs []byte) error {
-	id := string(bs)
-	id = strings.Trim(id, "=")
-	id = strings.ToUpper(id)
-	id = untypeoify(id)
-	id = unchunkify(id)
-
-	var err error
-	switch len(id) {
-	case 56:
-		// New style, with check digits
-		id, err = unluhnify(id)
-		if err != nil {
-			return err
-		}
-		fallthrough
-	case 52:
-		// Old style, no check digits
-		dec, err := base32.StdEncoding.DecodeString(id + "====")
-		if err != nil {
-			return err
-		}
-		copy(n[:], dec)
-		return nil
-	default:
-		return errors.New("device ID invalid: incorrect length")
-	}
-}
-
-func luhnify(s string) (string, error) {
-	if len(s) != 52 {
-		panic("unsupported string length")
-	}
-
-	res := make([]string, 0, 4)
-	for i := 0; i < 4; i++ {
-		p := s[i*13 : (i+1)*13]
-		l, err := luhn.Base32.Generate(p)
-		if err != nil {
-			return "", err
-		}
-		res = append(res, fmt.Sprintf("%s%c", p, l))
-	}
-	return res[0] + res[1] + res[2] + res[3], nil
-}
-
-func unluhnify(s string) (string, error) {
-	if len(s) != 56 {
-		return "", fmt.Errorf("unsupported string length %d", len(s))
-	}
-
-	res := make([]string, 0, 4)
-	for i := 0; i < 4; i++ {
-		p := s[i*14 : (i+1)*14-1]
-		l, err := luhn.Base32.Generate(p)
-		if err != nil {
-			return "", err
-		}
-		if g := fmt.Sprintf("%s%c", p, l); g != s[i*14:(i+1)*14] {
-			return "", errors.New("check digit incorrect")
-		}
-		res = append(res, p)
-	}
-	return res[0] + res[1] + res[2] + res[3], nil
-}
-
-func chunkify(s string) string {
-	s = regexp.MustCompile("(.{7})").ReplaceAllString(s, "$1-")
-	s = strings.Trim(s, "-")
-	return s
-}
-
-func unchunkify(s string) string {
-	s = strings.Replace(s, "-", "", -1)
-	s = strings.Replace(s, " ", "", -1)
-	return s
-}
-
-func untypeoify(s string) string {
-	s = strings.Replace(s, "0", "O", -1)
-	s = strings.Replace(s, "1", "I", -1)
-	s = strings.Replace(s, "8", "B", -1)
-	return s
-}

Godeps/_workspace/src/github.com/syncthing/protocol/deviceid_test.go

@@ -1,76 +0,0 @@
-// Copyright (C) 2014 The Protocol Authors.
-
-package protocol
-
-import "testing"
-
-var formatted = "P56IOI7-MZJNU2Y-IQGDREY-DM2MGTI-MGL3BXN-PQ6W5BM-TBBZ4TJ-XZWICQ2"
-var formatCases = []string{
-	"P56IOI-7MZJNU-2IQGDR-EYDM2M-GTMGL3-BXNPQ6-W5BTBB-Z4TJXZ-WICQ",
-	"P56IOI-7MZJNU2Y-IQGDR-EYDM2M-GTI-MGL3-BXNPQ6-W5BM-TBB-Z4TJXZ-WICQ2",
-	"P56IOI7 MZJNU2I QGDREYD M2MGTMGL 3BXNPQ6W 5BTB BZ4T JXZWICQ",
-	"P56IOI7 MZJNU2Y IQGDREY DM2MGTI MGL3BXN PQ6W5BM TBBZ4TJ XZWICQ2",
-	"P56IOI7MZJNU2IQGDREYDM2MGTMGL3BXNPQ6W5BTBBZ4TJXZWICQ",
-	"p56ioi7mzjnu2iqgdreydm2mgtmgl3bxnpq6w5btbbz4tjxzwicq",
-	"P56IOI7MZJNU2YIQGDREYDM2MGTIMGL3BXNPQ6W5BMTBBZ4TJXZWICQ2",
-	"P561017MZJNU2YIQGDREYDM2MGTIMGL3BXNPQ6W5BMT88Z4TJXZWICQ2",
-	"p56ioi7mzjnu2yiqgdreydm2mgtimgl3bxnpq6w5bmtbbz4tjxzwicq2",
-	"p561017mzjnu2yiqgdreydm2mgtimgl3bxnpq6w5bmt88z4tjxzwicq2",
-}
-
-func TestFormatDeviceID(t *testing.T) {
-	for i, tc := range formatCases {
-		var id DeviceID
-		err := id.UnmarshalText([]byte(tc))
-		if err != nil {
-			t.Errorf("#%d UnmarshalText(%q); %v", i, tc, err)
-		} else if f := id.String(); f != formatted {
-			t.Errorf("#%d FormatDeviceID(%q)\n\t%q !=\n\t%q", i, tc, f, formatted)
-		}
-	}
-}
-
-var validateCases = []struct {
-	s  string
-	ok bool
-}{
-	{"", false},
-	{"P56IOI7-MZJNU2Y-IQGDREY-DM2MGTI-MGL3BXN-PQ6W5BM-TBBZ4TJ-XZWICQ2", true},
-	{"P56IOI7-MZJNU2-IQGDREY-DM2MGT-MGL3BXN-PQ6W5B-TBBZ4TJ-XZWICQ", true},
-	{"P56IOI7 MZJNU2I QGDREYD M2MGTMGL 3BXNPQ6W 5BTB BZ4T JXZWICQ", true},
-	{"P56IOI7MZJNU2IQGDREYDM2MGTMGL3BXNPQ6W5BTBBZ4TJXZWICQ", true},
-	{"P56IOI7MZJNU2IQGDREYDM2MGTMGL3BXNPQ6W5BTBBZ4TJXZWICQCCCC", false},
-	{"p56ioi7mzjnu2iqgdreydm2mgtmgl3bxnpq6w5btbbz4tjxzwicq", true},
-	{"p56ioi7mzjnu2iqgdreydm2mgtmgl3bxnpq6w5btbbz4tjxzwicqCCCC", false},
-}
-
-func TestValidateDeviceID(t *testing.T) {
-	for _, tc := range validateCases {
-		var id DeviceID
-		err := id.UnmarshalText([]byte(tc.s))
-		if (err == nil && !tc.ok) || (err != nil && tc.ok) {
-			t.Errorf("ValidateDeviceID(%q); %v != %v", tc.s, err, tc.ok)
-		}
-	}
-}
-
-func TestMarshallingDeviceID(t *testing.T) {
-	n0 := DeviceID{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 10, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32}
-	n1 := DeviceID{}
-	n2 := DeviceID{}
-
-	bs, _ := n0.MarshalText()
-	n1.UnmarshalText(bs)
-	bs, _ = n1.MarshalText()
-	n2.UnmarshalText(bs)
-
-	if n2.String() != n0.String() {
-		t.Errorf("String marshalling error; %q != %q", n2.String(), n0.String())
-	}
-	if !n2.Equals(n0) {
-		t.Error("Equals error")
-	}
-	if n2.Compare(n0) != 0 {
-		t.Error("Compare error")
-	}
-}

Godeps/_workspace/src/github.com/syncthing/protocol/errors.go

@@ -1,51 +0,0 @@
-// Copyright (C) 2014 The Protocol Authors.
-
-package protocol
-
-import (
-	"errors"
-)
-
-const (
-	ecNoError int32 = iota
-	ecGeneric
-	ecNoSuchFile
-	ecInvalid
-)
-
-var (
-	ErrNoError    error = nil
-	ErrGeneric          = errors.New("generic error")
-	ErrNoSuchFile       = errors.New("no such file")
-	ErrInvalid          = errors.New("file is invalid")
-)
-
-var lookupError = map[int32]error{
-	ecNoError:    ErrNoError,
-	ecGeneric:    ErrGeneric,
-	ecNoSuchFile: ErrNoSuchFile,
-	ecInvalid:    ErrInvalid,
-}
-
-var lookupCode = map[error]int32{
-	ErrNoError:    ecNoError,
-	ErrGeneric:    ecGeneric,
-	ErrNoSuchFile: ecNoSuchFile,
-	ErrInvalid:    ecInvalid,
-}
-
-func codeToError(errcode int32) error {
-	err, ok := lookupError[errcode]
-	if !ok {
-		return ErrGeneric
-	}
-	return err
-}
-
-func errorToCode(err error) int32 {
-	code, ok := lookupCode[err]
-	if !ok {
-		return ecGeneric
-	}
-	return code
-}

Godeps/_workspace/src/github.com/syncthing/protocol/fuzz.go

@@ -1,70 +0,0 @@
-// Copyright (C) 2015 The Protocol Authors.
-
-// +build gofuzz
-
-package protocol
-
-import (
-	"bytes"
-	"encoding/binary"
-	"encoding/hex"
-	"fmt"
-	"reflect"
-	"sync"
-)
-
-func Fuzz(data []byte) int {
-	// Regenerate the length, or we'll most commonly exit quickly due to an
-	// unexpected eof which is unintestering.
-	if len(data) > 8 {
-		binary.BigEndian.PutUint32(data[4:], uint32(len(data))-8)
-	}
-
-	// Setup a rawConnection we'll use to parse the message.
-	c := rawConnection{
-		cr:     &countingReader{Reader: bytes.NewReader(data)},
-		closed: make(chan struct{}),
-		pool: sync.Pool{
-			New: func() interface{} {
-				return make([]byte, BlockSize)
-			},
-		},
-	}
-
-	// Attempt to parse the message.
-	hdr, msg, err := c.readMessage()
-	if err != nil {
-		return 0
-	}
-
-	// If parsing worked, attempt to encode it again.
-	newBs, err := msg.AppendXDR(nil)
-	if err != nil {
-		panic("not encodable")
-	}
-
-	// Create an appriate header for the re-encoding.
-	newMsg := make([]byte, 8)
-	binary.BigEndian.PutUint32(newMsg, encodeHeader(hdr))
-	binary.BigEndian.PutUint32(newMsg[4:], uint32(len(newBs)))
-	newMsg = append(newMsg, newBs...)
-
-	// Use the rawConnection to parse the re-encoding.
-	c.cr = &countingReader{Reader: bytes.NewReader(newMsg)}
-	hdr2, msg2, err := c.readMessage()
-	if err != nil {
-		fmt.Println("Initial:\n" + hex.Dump(data))
-		fmt.Println("New:\n" + hex.Dump(newMsg))
-		panic("not parseable after re-encode: " + err.Error())
-	}
-
-	// Make sure the data is the same as it was before.
-	if hdr != hdr2 {
-		panic("headers differ")
-	}
-	if !reflect.DeepEqual(msg, msg2) {
-		panic("contents differ")
-	}
-
-	return 1
-}

Godeps/_workspace/src/github.com/syncthing/protocol/fuzz_test.go

@@ -1,89 +0,0 @@
-// Copyright (C) 2015 The Protocol Authors.
-
-// +build gofuzz
-
-package protocol
-
-import (
-	"encoding/binary"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"strings"
-	"testing"
-	"testing/quick"
-)
-
-// This can be used to generate a corpus of valid messages as a starting point
-// for the fuzzer.
-func TestGenerateCorpus(t *testing.T) {
-	t.Skip("Use to generate initial corpus only")
-
-	n := 0
-	check := func(idx IndexMessage) bool {
-		for i := range idx.Options {
-			if len(idx.Options[i].Key) > 64 {
-				idx.Options[i].Key = idx.Options[i].Key[:64]
-			}
-		}
-		hdr := header{
-			version:     0,
-			msgID:       42,
-			msgType:     messageTypeIndex,
-			compression: false,
-		}
-
-		msgBs := idx.MustMarshalXDR()
-
-		buf := make([]byte, 8)
-		binary.BigEndian.PutUint32(buf, encodeHeader(hdr))
-		binary.BigEndian.PutUint32(buf[4:], uint32(len(msgBs)))
-		buf = append(buf, msgBs...)
-
-		ioutil.WriteFile(fmt.Sprintf("testdata/corpus/test-%03d.xdr", n), buf, 0644)
-		n++
-		return true
-	}
-
-	if err := quick.Check(check, &quick.Config{MaxCount: 1000}); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// Tests any crashers found by the fuzzer, for closer investigation.
-func TestCrashers(t *testing.T) {
-	testFiles(t, "testdata/crashers")
-}
-
-// Tests the entire corpus, which should PASS before the fuzzer starts
-// fuzzing.
-func TestCorpus(t *testing.T) {
-	testFiles(t, "testdata/corpus")
-}
-
-func testFiles(t *testing.T, dir string) {
-	fd, err := os.Open(dir)
-	if err != nil {
-		t.Fatal(err)
-	}
-	crashers, err := fd.Readdirnames(-1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	for _, name := range crashers {
-		if strings.HasSuffix(name, ".output") {
-			continue
-		}
-		if strings.HasSuffix(name, ".quoted") {
-			continue
-		}
-
-		t.Log(name)
-		crasher, err := ioutil.ReadFile(dir + "/" + name)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		Fuzz(crasher)
-	}
-}

Godeps/_workspace/src/github.com/syncthing/protocol/header.go

@@ -1,43 +0,0 @@
-// Copyright (C) 2014 The Protocol Authors.
-
-package protocol
-
-import "github.com/calmh/xdr"
-
-type header struct {
-	version     int
-	msgID       int
-	msgType     int
-	compression bool
-}
-
-func (h header) encodeXDR(xw *xdr.Writer) (int, error) {
-	u := encodeHeader(h)
-	return xw.WriteUint32(u)
-}
-
-func (h *header) decodeXDR(xr *xdr.Reader) error {
-	u := xr.ReadUint32()
-	*h = decodeHeader(u)
-	return xr.Error()
-}
-
-func encodeHeader(h header) uint32 {
-	var isComp uint32
-	if h.compression {
-		isComp = 1 << 0 // the zeroth bit is the compression bit
-	}
-	return uint32(h.version&0xf)<<28 +
-		uint32(h.msgID&0xfff)<<16 +
-		uint32(h.msgType&0xff)<<8 +
-		isComp
-}
-
-func decodeHeader(u uint32) header {
-	return header{
-		version:     int(u>>28) & 0xf,
-		msgID:       int(u>>16) & 0xfff,
-		msgType:     int(u>>8) & 0xff,
-		compression: u&1 == 1,
-	}
-}

Godeps/_workspace/src/github.com/syncthing/protocol/message.go

@@ -1,151 +0,0 @@
-// Copyright (C) 2014 The Protocol Authors.
-
-//go:generate -command genxdr go run ../syncthing/Godeps/_workspace/src/github.com/calmh/xdr/cmd/genxdr/main.go
-//go:generate genxdr -o message_xdr.go message.go
-
-package protocol
-
-import "fmt"
-
-type IndexMessage struct {
-	Folder  string
-	Files   []FileInfo // max:1000000
-	Flags   uint32
-	Options []Option // max:64
-}
-
-type FileInfo struct {
-	Name         string // max:8192
-	Flags        uint32
-	Modified     int64
-	Version      Vector
-	LocalVersion int64
-	Blocks       []BlockInfo // max:1000000
-}
-
-func (f FileInfo) String() string {
-	return fmt.Sprintf("File{Name:%q, Flags:0%o, Modified:%d, Version:%v, Size:%d, Blocks:%v}",
-		f.Name, f.Flags, f.Modified, f.Version, f.Size(), f.Blocks)
-}
-
-func (f FileInfo) Size() (bytes int64) {
-	if f.IsDeleted() || f.IsDirectory() {
-		return 128
-	}
-	for _, b := range f.Blocks {
-		bytes += int64(b.Size)
-	}
-	return
-}
-
-func (f FileInfo) IsDeleted() bool {
-	return f.Flags&FlagDeleted != 0
-}
-
-func (f FileInfo) IsInvalid() bool {
-	return f.Flags&FlagInvalid != 0
-}
-
-func (f FileInfo) IsDirectory() bool {
-	return f.Flags&FlagDirectory != 0
-}
-
-func (f FileInfo) IsSymlink() bool {
-	return f.Flags&FlagSymlink != 0
-}
-
-func (f FileInfo) HasPermissionBits() bool {
-	return f.Flags&FlagNoPermBits == 0
-}
-
-// WinsConflict returns true if "f" is the one to choose when it is in
-// conflict with "other".
-func (f FileInfo) WinsConflict(other FileInfo) bool {
-	// If a modification is in conflict with a delete, we pick the
-	// modification.
-	if !f.IsDeleted() && other.IsDeleted() {
-		return true
-	}
-	if f.IsDeleted() && !other.IsDeleted() {
-		return false
-	}
-
-	// The one with the newer modification time wins.
-	if f.Modified > other.Modified {
-		return true
-	}
-	if f.Modified < other.Modified {
-		return false
-	}
-
-	// The modification times were equal. Use the device ID in the version
-	// vector as tie breaker.
-	return f.Version.Compare(other.Version) == ConcurrentGreater
-}
-
-type BlockInfo struct {
-	Offset int64 // noencode (cache only)
-	Size   int32
-	Hash   []byte // max:64
-}
-
-func (b BlockInfo) String() string {
-	return fmt.Sprintf("Block{%d/%d/%x}", b.Offset, b.Size, b.Hash)
-}
-
-type RequestMessage struct {
-	Folder  string // max:64
-	Name    string // max:8192
-	Offset  int64
-	Size    int32
-	Hash    []byte // max:64
-	Flags   uint32
-	Options []Option // max:64
-}
-
-type ResponseMessage struct {
-	Data []byte
-	Code int32
-}
-
-type ClusterConfigMessage struct {
-	ClientName    string   // max:64
-	ClientVersion string   // max:64
-	Folders       []Folder // max:1000000
-	Options       []Option // max:64
-}
-
-func (o *ClusterConfigMessage) GetOption(key string) string {
-	for _, option := range o.Options {
-		if option.Key == key {
-			return option.Value
-		}
-	}
-	return ""
-}
-
-type Folder struct {
-	ID      string   // max:64
-	Devices []Device // max:1000000
-	Flags   uint32
-	Options []Option // max:64
-}
-
-type Device struct {
-	ID              []byte // max:32
-	MaxLocalVersion int64
-	Flags           uint32
-	Options         []Option // max:64
-}
-
-type Option struct {
-	Key   string // max:64
-	Value string // max:1024
-}
-
-type CloseMessage struct {
-	Reason string // max:1024
-	Code   int32
-}
-
-type EmptyMessage struct{}

Godeps/_workspace/src/github.com/syncthing/protocol/nativemodel_darwin.go

@@ -1,40 +0,0 @@
-// Copyright (C) 2014 The Protocol Authors.
-
-// +build darwin
-
-package protocol
-
-// Darwin uses NFD normalization
-
-import "golang.org/x/text/unicode/norm"
-
-type nativeModel struct {
-	next Model
-}
-
-func (m nativeModel) Index(deviceID DeviceID, folder string, files []FileInfo, flags uint32, options []Option) {
-	for i := range files {
-		files[i].Name = norm.NFD.String(files[i].Name)
-	}
-	m.next.Index(deviceID, folder, files, flags, options)
-}
-
-func (m nativeModel) IndexUpdate(deviceID DeviceID, folder string, files []FileInfo, flags uint32, options []Option) {
-	for i := range files {
-		files[i].Name = norm.NFD.String(files[i].Name)
-	}
-	m.next.IndexUpdate(deviceID, folder, files, flags, options)
-}
-
-func (m nativeModel) Request(deviceID DeviceID, folder string, name string, offset int64, hash []byte, flags uint32, options []Option, buf []byte) error {
-	name = norm.NFD.String(name)
-	return m.next.Request(deviceID, folder, name, offset, hash, flags, options, buf)
-}
-
-func (m nativeModel) ClusterConfig(deviceID DeviceID, config ClusterConfigMessage) {
-	m.next.ClusterConfig(deviceID, config)
-}
-
-func (m nativeModel) Close(deviceID DeviceID, err error) {
-	m.next.Close(deviceID, err)
-}

Godeps/_workspace/src/github.com/syncthing/protocol/nativemodel_unix.go

@@ -1,31 +0,0 @@
-// Copyright (C) 2014 The Protocol Authors.
-
-// +build !windows,!darwin
-
-package protocol
-
-// Normal Unixes uses NFC and slashes, which is the wire format.
-
-type nativeModel struct {
-	next Model
-}
-
-func (m nativeModel) Index(deviceID DeviceID, folder string, files []FileInfo, flags uint32, options []Option) {
-	m.next.Index(deviceID, folder, files, flags, options)
-}
-
-func (m nativeModel) IndexUpdate(deviceID DeviceID, folder string, files []FileInfo, flags uint32, options []Option) {
-	m.next.IndexUpdate(deviceID, folder, files, flags, options)
-}
-
-func (m nativeModel) Request(deviceID DeviceID, folder string, name string, offset int64, hash []byte, flags uint32, options []Option, buf []byte) error {
-	return m.next.Request(deviceID, folder, name, offset, hash, flags, options, buf)
-}
-
-func (m nativeModel) ClusterConfig(deviceID DeviceID, config ClusterConfigMessage) {
-	m.next.ClusterConfig(deviceID, config)
-}
-
-func (m nativeModel) Close(deviceID DeviceID, err error) {
-	m.next.Close(deviceID, err)
-}

Godeps/_workspace/src/github.com/syncthing/protocol/nativemodel_windows.go

@@ -1,63 +0,0 @@
-// Copyright (C) 2014 The Protocol Authors.
-
-// +build windows
-
-package protocol
-
-// Windows uses backslashes as file separator and disallows a bunch of
-// characters in the filename
-
-import (
-	"path/filepath"
-	"strings"
-)
-
-var disallowedCharacters = string([]rune{
-	'<', '>', ':', '"', '|', '?', '*',
-	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
-	11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
-	21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
-	31,
-})
-
-type nativeModel struct {
-	next Model
-}
-
-func (m nativeModel) Index(deviceID DeviceID, folder string, files []FileInfo, flags uint32, options []Option) {
-	fixupFiles(folder, files)
-	m.next.Index(deviceID, folder, files, flags, options)
-}
-
-func (m nativeModel) IndexUpdate(deviceID DeviceID, folder string, files []FileInfo, flags uint32, options []Option) {
-	fixupFiles(folder, files)
-	m.next.IndexUpdate(deviceID, folder, files, flags, options)
-}
-
-func (m nativeModel) Request(deviceID DeviceID, folder string, name string, offset int64, hash []byte, flags uint32, options []Option, buf []byte) error {
-	name = filepath.FromSlash(name)
-	return m.next.Request(deviceID, folder, name, offset, hash, flags, options, buf)
-}
-
-func (m nativeModel) ClusterConfig(deviceID DeviceID, config ClusterConfigMessage) {
-	m.next.ClusterConfig(deviceID, config)
-}
-
-func (m nativeModel) Close(deviceID DeviceID, err error) {
-	m.next.Close(deviceID, err)
-}
-
-func fixupFiles(folder string, files []FileInfo) {
-	for i, f := range files {
-		if strings.ContainsAny(f.Name, disallowedCharacters) {
-			if f.IsDeleted() {
-				// Don't complain if the file is marked as deleted, since it
-				// can't possibly exist here anyway.
-				continue
-			}
-			files[i].Flags |= FlagInvalid
-			l.Warnf("File name %q (folder %q) contains invalid characters; marked as invalid.", f.Name, folder)
-		}
-		files[i].Name = filepath.FromSlash(files[i].Name)
-	}
-}

Godeps/_workspace/src/github.com/syncthing/protocol/protocol.go

@@ -1,788 +0,0 @@
-// Copyright (C) 2014 The Protocol Authors.
-
-package protocol
-
-import (
-	"encoding/binary"
-	"encoding/hex"
-	"errors"
-	"fmt"
-	"io"
-	"sync"
-	"time"
-
-	lz4 "github.com/bkaradzic/go-lz4"
-)
-
-const (
-	// Data block size (128 KiB)
-	BlockSize = 128 << 10
-
-	// We reject messages larger than this when encountered on the wire. (64 MiB)
-	MaxMessageLen = 64 << 20
-)
-
-const (
-	messageTypeClusterConfig = 0
-	messageTypeIndex         = 1
-	messageTypeRequest       = 2
-	messageTypeResponse      = 3
-	messageTypePing          = 4
-	messageTypePong          = 5
-	messageTypeIndexUpdate   = 6
-	messageTypeClose         = 7
-)
-
-const (
-	stateInitial = iota
-	stateReady
-)
-
-// FileInfo flags
-const (
-	FlagDeleted              uint32 = 1 << 12
-	FlagInvalid                     = 1 << 13
-	FlagDirectory                   = 1 << 14
-	FlagNoPermBits                  = 1 << 15
-	FlagSymlink                     = 1 << 16
-	FlagSymlinkMissingTarget        = 1 << 17
-
-	FlagsAll = (1 << 18) - 1
-
-	SymlinkTypeMask = FlagDirectory | FlagSymlinkMissingTarget
-)
-
-// IndexMessage message flags (for IndexUpdate)
-const (
-	FlagIndexTemporary uint32 = 1 << iota
-)
-
-// Request message flags
-const (
-	FlagRequestTemporary uint32 = 1 << iota
-)
-
-// ClusterConfigMessage.Folders.Devices flags
-const (
-	FlagShareTrusted  uint32 = 1 << 0
-	FlagShareReadOnly        = 1 << 1
-	FlagIntroducer           = 1 << 2
-	FlagShareBits            = 0x000000ff
-)
-
-var (
-	ErrClusterHash = fmt.Errorf("configuration error: mismatched cluster hash")
-	ErrClosed      = errors.New("connection closed")
-)
-
-// Specific variants of empty messages...
-type pingMessage struct{ EmptyMessage }
-type pongMessage struct{ EmptyMessage }
-
-type Model interface {
-	// An index was received from the peer device
-	Index(deviceID DeviceID, folder string, files []FileInfo, flags uint32, options []Option)
-	// An index update was received from the peer device
-	IndexUpdate(deviceID DeviceID, folder string, files []FileInfo, flags uint32, options []Option)
-	// A request was made by the peer device
-	Request(deviceID DeviceID, folder string, name string, offset int64, hash []byte, flags uint32, options []Option, buf []byte) error
-	// A cluster configuration message was received
-	ClusterConfig(deviceID DeviceID, config ClusterConfigMessage)
-	// The peer device closed the connection
-	Close(deviceID DeviceID, err error)
-}
-
-type Connection interface {
-	Start()
-	ID() DeviceID
-	Name() string
-	Index(folder string, files []FileInfo, flags uint32, options []Option) error
-	IndexUpdate(folder string, files []FileInfo, flags uint32, options []Option) error
-	Request(folder string, name string, offset int64, size int, hash []byte, flags uint32, options []Option) ([]byte, error)
-	ClusterConfig(config ClusterConfigMessage)
-	Statistics() Statistics
-}
-
-type rawConnection struct {
-	id       DeviceID
-	name     string
-	receiver Model
-
-	cr *countingReader
-	cw *countingWriter
-
-	awaiting    [4096]chan asyncResult
-	awaitingMut sync.Mutex
-
-	idxMut sync.Mutex // ensures serialization of Index calls
-
-	nextID      chan int
-	outbox      chan hdrMsg
-	closed      chan struct{}
-	once        sync.Once
-	pool        sync.Pool
-	compression Compression
-
-	rdbuf0 []byte // used & reused by readMessage
-	rdbuf1 []byte // used & reused by readMessage
-}
-
-type asyncResult struct {
-	val []byte
-	err error
-}
-
-type hdrMsg struct {
-	hdr  header
-	msg  encodable
-	done chan struct{}
-}
-
-type encodable interface {
-	AppendXDR([]byte) ([]byte, error)
-}
-
-type isEofer interface {
-	IsEOF() bool
-}
-
-var (
-	PingTimeout  = 30 * time.Second
-	PingIdleTime = 60 * time.Second
-)
-
-func NewConnection(deviceID DeviceID, reader io.Reader, writer io.Writer, receiver Model, name string, compress Compression) Connection {
-	cr := &countingReader{Reader: reader}
-	cw := &countingWriter{Writer: writer}
-
-	c := rawConnection{
-		id:       deviceID,
-		name:     name,
-		receiver: nativeModel{receiver},
-		cr:       cr,
-		cw:       cw,
-		outbox:   make(chan hdrMsg),
-		nextID:   make(chan int),
-		closed:   make(chan struct{}),
-		pool: sync.Pool{
-			New: func() interface{} {
-				return make([]byte, BlockSize)
-			},
-		},
-		compression: compress,
-	}
-
-	return wireFormatConnection{&c}
-}
-
-// Start creates the goroutines for sending and receiving of messages. It must
-// be called exactly once after creating a connection.
-func (c *rawConnection) Start() {
-	go c.readerLoop()
-	go c.writerLoop()
-	go c.pingerLoop()
-	go c.idGenerator()
-}
-
-func (c *rawConnection) ID() DeviceID {
-	return c.id
-}
-
-func (c *rawConnection) Name() string {
-	return c.name
-}
-
-// Index writes the list of file information to the connected peer device
-func (c *rawConnection) Index(folder string, idx []FileInfo, flags uint32, options []Option) error {
-	select {
-	case <-c.closed:
-		return ErrClosed
-	default:
-	}
-	c.idxMut.Lock()
-	c.send(-1, messageTypeIndex, IndexMessage{
-		Folder:  folder,
-		Files:   idx,
-		Flags:   flags,
-		Options: options,
-	}, nil)
-	c.idxMut.Unlock()
-	return nil
-}
-
-// IndexUpdate writes the list of file information to the connected peer device as an update
-func (c *rawConnection) IndexUpdate(folder string, idx []FileInfo, flags uint32, options []Option) error {
-	select {
-	case <-c.closed:
-		return ErrClosed
-	default:
-	}
-	c.idxMut.Lock()
-	c.send(-1, messageTypeIndexUpdate, IndexMessage{
-		Folder:  folder,
-		Files:   idx,
-		Flags:   flags,
-		Options: options,
-	}, nil)
-	c.idxMut.Unlock()
-	return nil
-}
-
-// Request returns the bytes for the specified block after fetching them from the connected peer.
-func (c *rawConnection) Request(folder string, name string, offset int64, size int, hash []byte, flags uint32, options []Option) ([]byte, error) {
-	var id int
-	select {
-	case id = <-c.nextID:
-	case <-c.closed:
-		return nil, ErrClosed
-	}
-
-	c.awaitingMut.Lock()
-	if ch := c.awaiting[id]; ch != nil {
-		panic("id taken")
-	}
-	rc := make(chan asyncResult, 1)
-	c.awaiting[id] = rc
-	c.awaitingMut.Unlock()
-
-	ok := c.send(id, messageTypeRequest, RequestMessage{
-		Folder:  folder,
-		Name:    name,
-		Offset:  offset,
-		Size:    int32(size),
-		Hash:    hash,
-		Flags:   flags,
-		Options: options,
-	}, nil)
-	if !ok {
-		return nil, ErrClosed
-	}
-
-	res, ok := <-rc
-	if !ok {
-		return nil, ErrClosed
-	}
-	return res.val, res.err
-}
-
-// ClusterConfig send the cluster configuration message to the peer and returns any error
-func (c *rawConnection) ClusterConfig(config ClusterConfigMessage) {
-	c.send(-1, messageTypeClusterConfig, config, nil)
-}
-
-func (c *rawConnection) ping() bool {
-	var id int
-	select {
-	case id = <-c.nextID:
-	case <-c.closed:
-		return false
-	}
-
-	rc := make(chan asyncResult, 1)
-	c.awaitingMut.Lock()
-	c.awaiting[id] = rc
-	c.awaitingMut.Unlock()
-
-	ok := c.send(id, messageTypePing, nil, nil)
-	if !ok {
-		return false
-	}
-
-	res, ok := <-rc
-	return ok && res.err == nil
-}
-
-func (c *rawConnection) readerLoop() (err error) {
-	defer func() {
-		c.close(err)
-	}()
-
-	state := stateInitial
-	for {
-		select {
-		case <-c.closed:
-			return ErrClosed
-		default:
-		}
-
-		hdr, msg, err := c.readMessage()
-		if err != nil {
-			return err
-		}
-
-		switch msg := msg.(type) {
-		case ClusterConfigMessage:
-			if state != stateInitial {
-				return fmt.Errorf("protocol error: cluster config message in state %d", state)
-			}
-			go c.receiver.ClusterConfig(c.id, msg)
-			state = stateReady
-
-		case IndexMessage:
-			switch hdr.msgType {
-			case messageTypeIndex:
-				if state != stateReady {
-					return fmt.Errorf("protocol error: index message in state %d", state)
-				}
-				c.handleIndex(msg)
-				state = stateReady
-
-			case messageTypeIndexUpdate:
-				if state != stateReady {
-					return fmt.Errorf("protocol error: index update message in state %d", state)
-				}
-				c.handleIndexUpdate(msg)
-				state = stateReady
-			}
-
-		case RequestMessage:
-			if state != stateReady {
-				return fmt.Errorf("protocol error: request message in state %d", state)
-			}
-			// Requests are handled asynchronously
-			go c.handleRequest(hdr.msgID, msg)
-
-		case ResponseMessage:
-			if state != stateReady {
-				return fmt.Errorf("protocol error: response message in state %d", state)
-			}
-			c.handleResponse(hdr.msgID, msg)
-
-		case pingMessage:
-			if state != stateReady {
-				return fmt.Errorf("protocol error: ping message in state %d", state)
-			}
-			c.send(hdr.msgID, messageTypePong, pongMessage{}, nil)
-
-		case pongMessage:
-			if state != stateReady {
-				return fmt.Errorf("protocol error: pong message in state %d", state)
-			}
-			c.handlePong(hdr.msgID)
-
-		case CloseMessage:
-			return errors.New(msg.Reason)
-
-		default:
-			return fmt.Errorf("protocol error: %s: unknown message type %#x", c.id, hdr.msgType)
-		}
-	}
-}
-
-func (c *rawConnection) readMessage() (hdr header, msg encodable, err error) {
-	if cap(c.rdbuf0) < 8 {
-		c.rdbuf0 = make([]byte, 8)
-	} else {
-		c.rdbuf0 = c.rdbuf0[:8]
-	}
-	_, err = io.ReadFull(c.cr, c.rdbuf0)
-	if err != nil {
-		return
-	}
-
-	hdr = decodeHeader(binary.BigEndian.Uint32(c.rdbuf0[0:4]))
-	msglen := int(binary.BigEndian.Uint32(c.rdbuf0[4:8]))
-
-	if debug {
-		l.Debugf("read header %v (msglen=%d)", hdr, msglen)
-	}
-
-	if msglen > MaxMessageLen {
-		err = fmt.Errorf("message length %d exceeds maximum %d", msglen, MaxMessageLen)
-		return
-	}
-
-	if hdr.version != 0 {
-		err = fmt.Errorf("unknown protocol version 0x%x", hdr.version)
-		return
-	}
-
-	if cap(c.rdbuf0) < msglen {
-		c.rdbuf0 = make([]byte, msglen)
-	} else {
-		c.rdbuf0 = c.rdbuf0[:msglen]
-	}
-	_, err = io.ReadFull(c.cr, c.rdbuf0)
-	if err != nil {
-		return
-	}
-
-	if debug {
-		l.Debugf("read %d bytes", len(c.rdbuf0))
-	}
-
-	msgBuf := c.rdbuf0
-	if hdr.compression && msglen > 0 {
-		c.rdbuf1 = c.rdbuf1[:cap(c.rdbuf1)]
-		c.rdbuf1, err = lz4.Decode(c.rdbuf1, c.rdbuf0)
-		if err != nil {
-			return
-		}
-		msgBuf = c.rdbuf1
-		if debug {
-			l.Debugf("decompressed to %d bytes", len(msgBuf))
-		}
-	}
-
-	if debug {
-		if len(msgBuf) > 1024 {
-			l.Debugf("message data:\n%s", hex.Dump(msgBuf[:1024]))
-		} else {
-			l.Debugf("message data:\n%s", hex.Dump(msgBuf))
-		}
-	}
-
-	// We check each returned error for the XDRError.IsEOF() method.
-	// IsEOF()==true here means that the message contained fewer fields than
-	// expected. It does not signify an EOF on the socket, because we've
-	// successfully read a size value and that many bytes already. New fields
-	// we expected but the other peer didn't send should be interpreted as
-	// zero/nil, and if that's not valid we'll verify it somewhere else.
-
-	switch hdr.msgType {
-	case messageTypeIndex, messageTypeIndexUpdate:
-		var idx IndexMessage
-		err = idx.UnmarshalXDR(msgBuf)
-		if xdrErr, ok := err.(isEofer); ok && xdrErr.IsEOF() {
-			err = nil
-		}
-		msg = idx
-
-	case messageTypeRequest:
-		var req RequestMessage
-		err = req.UnmarshalXDR(msgBuf)
-		if xdrErr, ok := err.(isEofer); ok && xdrErr.IsEOF() {
-			err = nil
-		}
-		msg = req
-
-	case messageTypeResponse:
-		var resp ResponseMessage
-		err = resp.UnmarshalXDR(msgBuf)
-		if xdrErr, ok := err.(isEofer); ok && xdrErr.IsEOF() {
-			err = nil
-		}
-		msg = resp
-
-	case messageTypePing:
-		msg = pingMessage{}
-
-	case messageTypePong:
-		msg = pongMessage{}
-
-	case messageTypeClusterConfig:
-		var cc ClusterConfigMessage
-		err = cc.UnmarshalXDR(msgBuf)
-		if xdrErr, ok := err.(isEofer); ok && xdrErr.IsEOF() {
-			err = nil
-		}
-		msg = cc
-
-	case messageTypeClose:
-		var cm CloseMessage
-		err = cm.UnmarshalXDR(msgBuf)
-		if xdrErr, ok := err.(isEofer); ok && xdrErr.IsEOF() {
-			err = nil
-		}
-		msg = cm
-
-	default:
-		err = fmt.Errorf("protocol error: %s: unknown message type %#x", c.id, hdr.msgType)
-	}
-
-	return
-}
-
-func (c *rawConnection) handleIndex(im IndexMessage) {
-	if debug {
-		l.Debugf("Index(%v, %v, %d file, flags %x, opts: %s)", c.id, im.Folder, len(im.Files), im.Flags, im.Options)
-	}
-	c.receiver.Index(c.id, im.Folder, filterIndexMessageFiles(im.Files), im.Flags, im.Options)
-}
-
-func (c *rawConnection) handleIndexUpdate(im IndexMessage) {
-	if debug {
-		l.Debugf("queueing IndexUpdate(%v, %v, %d files, flags %x, opts: %s)", c.id, im.Folder, len(im.Files), im.Flags, im.Options)
-	}
-	c.receiver.IndexUpdate(c.id, im.Folder, filterIndexMessageFiles(im.Files), im.Flags, im.Options)
-}
-
-func filterIndexMessageFiles(fs []FileInfo) []FileInfo {
-	var out []FileInfo
-	for i, f := range fs {
-		switch f.Name {
-		case "", ".", "..", "/": // A few obviously invalid filenames
-			l.Infof("Dropping invalid filename %q from incoming index", f.Name)
-			if out == nil {
-				// Most incoming updates won't contain anything invalid, so we
-				// delay the allocation and copy to output slice until we
-				// really need to do it, then copy all the so var valid files
-				// to it.
-				out = make([]FileInfo, i, len(fs)-1)
-				copy(out, fs)
-			}
-		default:
-			if out != nil {
-				out = append(out, f)
-			}
-		}
-	}
-	if out != nil {
-		return out
-	}
-	return fs
-}
-
-func (c *rawConnection) handleRequest(msgID int, req RequestMessage) {
-	size := int(req.Size)
-	usePool := size <= BlockSize
-
-	var buf []byte
-	var done chan struct{}
-
-	if usePool {
-		buf = c.pool.Get().([]byte)[:size]
-		done = make(chan struct{})
-	} else {
-		buf = make([]byte, size)
-	}
-
-	err := c.receiver.Request(c.id, req.Folder, req.Name, int64(req.Offset), req.Hash, req.Flags, req.Options, buf)
-	if err != nil {
-		c.send(msgID, messageTypeResponse, ResponseMessage{
-			Data: nil,
-			Code: errorToCode(err),
-		}, done)
-	} else {
-		c.send(msgID, messageTypeResponse, ResponseMessage{
-			Data: buf,
-			Code: errorToCode(err),
-		}, done)
-	}
-
-	if usePool {
-		<-done
-		c.pool.Put(buf)
-	}
-}
-
-func (c *rawConnection) handleResponse(msgID int, resp ResponseMessage) {
-	c.awaitingMut.Lock()
-	if rc := c.awaiting[msgID]; rc != nil {
-		c.awaiting[msgID] = nil
-		rc <- asyncResult{resp.Data, codeToError(resp.Code)}
-		close(rc)
-	}
-	c.awaitingMut.Unlock()
-}
-
-func (c *rawConnection) handlePong(msgID int) {
-	c.awaitingMut.Lock()
-	if rc := c.awaiting[msgID]; rc != nil {
-		c.awaiting[msgID] = nil
-		rc <- asyncResult{}
-		close(rc)
-	}
-	c.awaitingMut.Unlock()
-}
-
-func (c *rawConnection) send(msgID int, msgType int, msg encodable, done chan struct{}) bool {
-	if msgID < 0 {
-		select {
-		case id := <-c.nextID:
-			msgID = id
-		case <-c.closed:
-			return false
-		}
-	}
-
-	hdr := header{
-		version: 0,
-		msgID:   msgID,
-		msgType: msgType,
-	}
-
-	select {
-	case c.outbox <- hdrMsg{hdr, msg, done}:
-		return true
-	case <-c.closed:
-		return false
-	}
-}
-
-func (c *rawConnection) writerLoop() {
-	var msgBuf = make([]byte, 8) // buffer for wire format message, kept and reused
-	var uncBuf []byte            // buffer for uncompressed message, kept and reused
-	for {
-		var tempBuf []byte
-		var err error
-
-		select {
-		case hm := <-c.outbox:
-			if hm.msg != nil {
-				// Uncompressed message in uncBuf
-				uncBuf, err = hm.msg.AppendXDR(uncBuf[:0])
-				if hm.done != nil {
-					close(hm.done)
-				}
-				if err != nil {
-					c.close(err)
-					return
-				}
-
-				compress := false
-				switch c.compression {
-				case CompressAlways:
-					compress = true
-				case CompressMetadata:
-					compress = hm.hdr.msgType != messageTypeResponse
-				}
-
-				if compress && len(uncBuf) >= compressionThreshold {
-					// Use compression for large messages
-					hm.hdr.compression = true
-
-					// Make sure we have enough space for the compressed message plus header in msgBug
-					msgBuf = msgBuf[:cap(msgBuf)]
-					if maxLen := lz4.CompressBound(len(uncBuf)) + 8; maxLen > len(msgBuf) {
-						msgBuf = make([]byte, maxLen)
-					}
-
-					// Compressed is written to msgBuf, we keep tb for the length only
-					tempBuf, err = lz4.Encode(msgBuf[8:], uncBuf)
-					binary.BigEndian.PutUint32(msgBuf[4:8], uint32(len(tempBuf)))
-					msgBuf = msgBuf[0 : len(tempBuf)+8]
-
-					if debug {
-						l.Debugf("write compressed message; %v (len=%d)", hm.hdr, len(tempBuf))
-					}
-				} else {
-					// No point in compressing very short messages
-					hm.hdr.compression = false
-
-					msgBuf = msgBuf[:cap(msgBuf)]
-					if l := len(uncBuf) + 8; l > len(msgBuf) {
-						msgBuf = make([]byte, l)
-					}
-
-					binary.BigEndian.PutUint32(msgBuf[4:8], uint32(len(uncBuf)))
-					msgBuf = msgBuf[0 : len(uncBuf)+8]
-					copy(msgBuf[8:], uncBuf)
-
-					if debug {
-						l.Debugf("write uncompressed message; %v (len=%d)", hm.hdr, len(uncBuf))
-					}
-				}
-			} else {
-				if debug {
-					l.Debugf("write empty message; %v", hm.hdr)
-				}
-				binary.BigEndian.PutUint32(msgBuf[4:8], 0)
-				msgBuf = msgBuf[:8]
-			}
-
-			binary.BigEndian.PutUint32(msgBuf[0:4], encodeHeader(hm.hdr))
-
-			if err == nil {
-				var n int
-				n, err = c.cw.Write(msgBuf)
-				if debug {
-					l.Debugf("wrote %d bytes on the wire", n)
-				}
-			}
-			if err != nil {
-				c.close(err)
-				return
-			}
-		case <-c.closed:
-			return
-		}
-	}
-}
-
-func (c *rawConnection) close(err error) {
-	c.once.Do(func() {
-		close(c.closed)
-
-		c.awaitingMut.Lock()
-		for i, ch := range c.awaiting {
-			if ch != nil {
-				close(ch)
-				c.awaiting[i] = nil
-			}
-		}
-		c.awaitingMut.Unlock()
-
-		go c.receiver.Close(c.id, err)
-	})
-}
-
-func (c *rawConnection) idGenerator() {
-	nextID := 0
-	for {
-		nextID = (nextID + 1) & 0xfff
-		select {
-		case c.nextID <- nextID:
-		case <-c.closed:
-			return
-		}
-	}
-}
-
-func (c *rawConnection) pingerLoop() {
-	var rc = make(chan bool, 1)
-	ticker := time.Tick(PingIdleTime / 2)
-	for {
-		select {
-		case <-ticker:
-			if d := time.Since(c.cr.Last()); d < PingIdleTime {
-				if debug {
-					l.Debugln(c.id, "ping skipped after rd", d)
-				}
-				continue
-			}
-			if d := time.Since(c.cw.Last()); d < PingIdleTime {
-				if debug {
-					l.Debugln(c.id, "ping skipped after wr", d)
-				}
-				continue
-			}
-			go func() {
-				if debug {
-					l.Debugln(c.id, "ping ->")
-				}
-				rc <- c.ping()
-			}()
-			select {
-			case ok := <-rc:
-				if debug {
-					l.Debugln(c.id, "<- pong")
-				}
-				if !ok {
-					c.close(fmt.Errorf("ping failure"))
-				}
-			case <-time.After(PingTimeout):
-				c.close(fmt.Errorf("ping timeout"))
-			case <-c.closed:
-				return
-			}
-
-		case <-c.closed:
-			return
-		}
-	}
-}
-
-type Statistics struct {
-	At            time.Time
-	InBytesTotal  int64
-	OutBytesTotal int64
-}
-
-func (c *rawConnection) Statistics() Statistics {
-	return Statistics{
-		At:            time.Now(),
-		InBytesTotal:  c.cr.Tot(),
-		OutBytesTotal: c.cw.Tot(),
-	}
-}

Godeps/_workspace/src/github.com/syncthing/protocol/protocol_test.go

@@ -1,404 +0,0 @@
-// Copyright (C) 2014 The Protocol Authors.
-
-package protocol
-
-import (
-	"bytes"
-	"encoding/hex"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"os"
-	"reflect"
-	"strings"
-	"testing"
-	"testing/quick"
-
-	"github.com/calmh/xdr"
-)
-
-var (
-	c0ID = NewDeviceID([]byte{1})
-	c1ID = NewDeviceID([]byte{2})
-)
-
-func TestHeaderFunctions(t *testing.T) {
-	f := func(ver, id, typ int) bool {
-		ver = int(uint(ver) % 16)
-		id = int(uint(id) % 4096)
-		typ = int(uint(typ) % 256)
-		h0 := header{version: ver, msgID: id, msgType: typ}
-		h1 := decodeHeader(encodeHeader(h0))
-		return h0 == h1
-	}
-	if err := quick.Check(f, nil); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestHeaderLayout(t *testing.T) {
-	var e, a uint32
-
-	// Version are the first four bits
-	e = 0xf0000000
-	a = encodeHeader(header{version: 0xf})
-	if a != e {
-		t.Errorf("Header layout incorrect; %08x != %08x", a, e)
-	}
-
-	// Message ID are the following 12 bits
-	e = 0x0fff0000
-	a = encodeHeader(header{msgID: 0xfff})
-	if a != e {
-		t.Errorf("Header layout incorrect; %08x != %08x", a, e)
-	}
-
-	// Type are the last 8 bits before reserved
-	e = 0x0000ff00
-	a = encodeHeader(header{msgType: 0xff})
-	if a != e {
-		t.Errorf("Header layout incorrect; %08x != %08x", a, e)
-	}
-}
-
-func TestPing(t *testing.T) {
-	ar, aw := io.Pipe()
-	br, bw := io.Pipe()
-
-	c0 := NewConnection(c0ID, ar, bw, newTestModel(), "name", CompressAlways).(wireFormatConnection).next.(*rawConnection)
-	c0.Start()
-	c1 := NewConnection(c1ID, br, aw, newTestModel(), "name", CompressAlways).(wireFormatConnection).next.(*rawConnection)
-	c1.Start()
-	c0.ClusterConfig(ClusterConfigMessage{})
-	c1.ClusterConfig(ClusterConfigMessage{})
-
-	if ok := c0.ping(); !ok {
-		t.Error("c0 ping failed")
-	}
-	if ok := c1.ping(); !ok {
-		t.Error("c1 ping failed")
-	}
-}
-
-func TestPingErr(t *testing.T) {
-	e := errors.New("something broke")
-
-	for i := 0; i < 32; i++ {
-		for j := 0; j < 32; j++ {
-			m0 := newTestModel()
-			m1 := newTestModel()
-
-			ar, aw := io.Pipe()
-			br, bw := io.Pipe()
-			eaw := &ErrPipe{PipeWriter: *aw, max: i, err: e}
-			ebw := &ErrPipe{PipeWriter: *bw, max: j, err: e}
-
-			c0 := NewConnection(c0ID, ar, ebw, m0, "name", CompressAlways).(wireFormatConnection).next.(*rawConnection)
-			c0.Start()
-			c1 := NewConnection(c1ID, br, eaw, m1, "name", CompressAlways)
-			c1.Start()
-			c0.ClusterConfig(ClusterConfigMessage{})
-			c1.ClusterConfig(ClusterConfigMessage{})
-
-			res := c0.ping()
-			if (i < 8 || j < 8) && res {
-				// This should have resulted in failure, as there is no way an empty ClusterConfig plus a Ping message fits in eight bytes.
-				t.Errorf("Unexpected ping success; i=%d, j=%d", i, j)
-			} else if (i >= 28 && j >= 28) && !res {
-				// This should have worked though, as 28 bytes is plenty for both.
-				t.Errorf("Unexpected ping fail; i=%d, j=%d", i, j)
-			}
-		}
-	}
-}
-
-// func TestRequestResponseErr(t *testing.T) {
-// 	e := errors.New("something broke")
-
-// 	var pass bool
-// 	for i := 0; i < 48; i++ {
-// 		for j := 0; j < 38; j++ {
-// 			m0 := newTestModel()
-// 			m0.data = []byte("response data")
-// 			m1 := newTestModel()
-
-// 			ar, aw := io.Pipe()
-// 			br, bw := io.Pipe()
-// 			eaw := &ErrPipe{PipeWriter: *aw, max: i, err: e}
-// 			ebw := &ErrPipe{PipeWriter: *bw, max: j, err: e}
-
-// 			NewConnection(c0ID, ar, ebw, m0, nil)
-// 			c1 := NewConnection(c1ID, br, eaw, m1, nil).(wireFormatConnection).next.(*rawConnection)
-
-// 			d, err := c1.Request("default", "tn", 1234, 5678)
-// 			if err == e || err == ErrClosed {
-// 				t.Logf("Error at %d+%d bytes", i, j)
-// 				if !m1.isClosed() {
-// 					t.Fatal("c1 not closed")
-// 				}
-// 				if !m0.isClosed() {
-// 					t.Fatal("c0 not closed")
-// 				}
-// 				continue
-// 			}
-// 			if err != nil {
-// 				t.Fatal(err)
-// 			}
-// 			if string(d) != "response data" {
-// 				t.Fatalf("Incorrect response data %q", string(d))
-// 			}
-// 			if m0.folder != "default" {
-// 				t.Fatalf("Incorrect folder %q", m0.folder)
-// 			}
-// 			if m0.name != "tn" {
-// 				t.Fatalf("Incorrect name %q", m0.name)
-// 			}
-// 			if m0.offset != 1234 {
-// 				t.Fatalf("Incorrect offset %d", m0.offset)
-// 			}
-// 			if m0.size != 5678 {
-// 				t.Fatalf("Incorrect size %d", m0.size)
-// 			}
-// 			t.Logf("Pass at %d+%d bytes", i, j)
-// 			pass = true
-// 		}
-// 	}
-// 	if !pass {
-// 		t.Fatal("Never passed")
-// 	}
-// }
-
-func TestVersionErr(t *testing.T) {
-	m0 := newTestModel()
-	m1 := newTestModel()
-
-	ar, aw := io.Pipe()
-	br, bw := io.Pipe()
-
-	c0 := NewConnection(c0ID, ar, bw, m0, "name", CompressAlways).(wireFormatConnection).next.(*rawConnection)
-	c0.Start()
-	c1 := NewConnection(c1ID, br, aw, m1, "name", CompressAlways)
-	c1.Start()
-	c0.ClusterConfig(ClusterConfigMessage{})
-	c1.ClusterConfig(ClusterConfigMessage{})
-
-	w := xdr.NewWriter(c0.cw)
-	w.WriteUint32(encodeHeader(header{
-		version: 2,
-		msgID:   0,
-		msgType: 0,
-	}))
-	w.WriteUint32(0) // Avoids reader closing due to EOF
-
-	if !m1.isClosed() {
-		t.Error("Connection should close due to unknown version")
-	}
-}
-
-func TestTypeErr(t *testing.T) {
-	m0 := newTestModel()
-	m1 := newTestModel()
-
-	ar, aw := io.Pipe()
-	br, bw := io.Pipe()
-
-	c0 := NewConnection(c0ID, ar, bw, m0, "name", CompressAlways).(wireFormatConnection).next.(*rawConnection)
-	c0.Start()
-	c1 := NewConnection(c1ID, br, aw, m1, "name", CompressAlways)
-	c1.Start()
-	c0.ClusterConfig(ClusterConfigMessage{})
-	c1.ClusterConfig(ClusterConfigMessage{})
-
-	w := xdr.NewWriter(c0.cw)
-	w.WriteUint32(encodeHeader(header{
-		version: 0,
-		msgID:   0,
-		msgType: 42,
-	}))
-	w.WriteUint32(0) // Avoids reader closing due to EOF
-
-	if !m1.isClosed() {
-		t.Error("Connection should close due to unknown message type")
-	}
-}
-
-func TestClose(t *testing.T) {
-	m0 := newTestModel()
-	m1 := newTestModel()
-
-	ar, aw := io.Pipe()
-	br, bw := io.Pipe()
-
-	c0 := NewConnection(c0ID, ar, bw, m0, "name", CompressAlways).(wireFormatConnection).next.(*rawConnection)
-	c0.Start()
-	c1 := NewConnection(c1ID, br, aw, m1, "name", CompressAlways)
-	c1.Start()
-	c0.ClusterConfig(ClusterConfigMessage{})
-	c1.ClusterConfig(ClusterConfigMessage{})
-
-	c0.close(nil)
-
-	<-c0.closed
-	if !m0.isClosed() {
-		t.Fatal("Connection should be closed")
-	}
-
-	// None of these should panic, some should return an error
-
-	if c0.ping() {
-		t.Error("Ping should not return true")
-	}
-
-	c0.Index("default", nil, 0, nil)
-	c0.Index("default", nil, 0, nil)
-
-	if _, err := c0.Request("default", "foo", 0, 0, nil, 0, nil); err == nil {
-		t.Error("Request should return an error")
-	}
-}
-
-func TestElementSizeExceededNested(t *testing.T) {
-	m := ClusterConfigMessage{
-		Folders: []Folder{
-			{ID: "longstringlongstringlongstringinglongstringlongstringlonlongstringlongstringlon"},
-		},
-	}
-	_, err := m.EncodeXDR(ioutil.Discard)
-	if err == nil {
-		t.Errorf("ID length %d > max 64, but no error", len(m.Folders[0].ID))
-	}
-}
-
-func TestMarshalIndexMessage(t *testing.T) {
-	var quickCfg = &quick.Config{MaxCountScale: 10}
-	if testing.Short() {
-		quickCfg = nil
-	}
-
-	f := func(m1 IndexMessage) bool {
-		for _, f := range m1.Files {
-			for i := range f.Blocks {
-				f.Blocks[i].Offset = 0
-				if len(f.Blocks[i].Hash) == 0 {
-					f.Blocks[i].Hash = nil
-				}
-			}
-		}
-
-		return testMarshal(t, "index", &m1, &IndexMessage{})
-	}
-
-	if err := quick.Check(f, quickCfg); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestMarshalRequestMessage(t *testing.T) {
-	var quickCfg = &quick.Config{MaxCountScale: 10}
-	if testing.Short() {
-		quickCfg = nil
-	}
-
-	f := func(m1 RequestMessage) bool {
-		return testMarshal(t, "request", &m1, &RequestMessage{})
-	}
-
-	if err := quick.Check(f, quickCfg); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestMarshalResponseMessage(t *testing.T) {
-	var quickCfg = &quick.Config{MaxCountScale: 10}
-	if testing.Short() {
-		quickCfg = nil
-	}
-
-	f := func(m1 ResponseMessage) bool {
-		if len(m1.Data) == 0 {
-			m1.Data = nil
-		}
-		return testMarshal(t, "response", &m1, &ResponseMessage{})
-	}
-
-	if err := quick.Check(f, quickCfg); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestMarshalClusterConfigMessage(t *testing.T) {
-	var quickCfg = &quick.Config{MaxCountScale: 10}
-	if testing.Short() {
-		quickCfg = nil
-	}
-
-	f := func(m1 ClusterConfigMessage) bool {
-		return testMarshal(t, "clusterconfig", &m1, &ClusterConfigMessage{})
-	}
-
-	if err := quick.Check(f, quickCfg); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestMarshalCloseMessage(t *testing.T) {
-	var quickCfg = &quick.Config{MaxCountScale: 10}
-	if testing.Short() {
-		quickCfg = nil
-	}
-
-	f := func(m1 CloseMessage) bool {
-		return testMarshal(t, "close", &m1, &CloseMessage{})
-	}
-
-	if err := quick.Check(f, quickCfg); err != nil {
-		t.Error(err)
-	}
-}
-
-type message interface {
-	EncodeXDR(io.Writer) (int, error)
-	DecodeXDR(io.Reader) error
-}
-
-func testMarshal(t *testing.T, prefix string, m1, m2 message) bool {
-	var buf bytes.Buffer
-
-	failed := func(bc []byte) {
-		bs, _ := json.MarshalIndent(m1, "", "  ")
-		ioutil.WriteFile(prefix+"-1.txt", bs, 0644)
-		bs, _ = json.MarshalIndent(m2, "", "  ")
-		ioutil.WriteFile(prefix+"-2.txt", bs, 0644)
-		if len(bc) > 0 {
-			f, _ := os.Create(prefix + "-data.txt")
-			fmt.Fprint(f, hex.Dump(bc))
-			f.Close()
-		}
-	}
-
-	_, err := m1.EncodeXDR(&buf)
-	if err != nil && strings.Contains(err.Error(), "exceeds size") {
-		return true
-	}
-	if err != nil {
-		failed(nil)
-		t.Fatal(err)
-	}
-
-	bc := make([]byte, len(buf.Bytes()))
-	copy(bc, buf.Bytes())
-
-	err = m2.DecodeXDR(&buf)
-	if err != nil {
-		failed(bc)
-		t.Fatal(err)
-	}
-
-	ok := reflect.DeepEqual(m1, m2)
-	if !ok {
-		failed(bc)
-	}
-	return ok
-}

Godeps/_workspace/src/github.com/syncthing/protocol/vector.go

@@ -1,115 +0,0 @@
-// Copyright (C) 2015 The Protocol Authors.
-
-package protocol
-
-// The Vector type represents a version vector. The zero value is a usable
-// version vector. The vector has slice semantics and some operations on it
-// are "append-like" in that they may return the same vector modified, or a
-// new allocated Vector with the modified contents.
-type Vector []Counter
-
-// Counter represents a single counter in the version vector.
-type Counter struct {
-	ID    uint64
-	Value uint64
-}
-
-// Update returns a Vector with the index for the specific ID incremented by
-// one. If it is possible, the vector v is updated and returned. If it is not,
-// a copy will be created, updated and returned.
-func (v Vector) Update(ID uint64) Vector {
-	for i := range v {
-		if v[i].ID == ID {
-			// Update an existing index
-			v[i].Value++
-			return v
-		} else if v[i].ID > ID {
-			// Insert a new index
-			nv := make(Vector, len(v)+1)
-			copy(nv, v[:i])
-			nv[i].ID = ID
-			nv[i].Value = 1
-			copy(nv[i+1:], v[i:])
-			return nv
-		}
-	}
-	// Append a new new index
-	return append(v, Counter{ID, 1})
-}
-
-// Merge returns the vector containing the maximum indexes from a and b. If it
-// is possible, the vector a is updated and returned. If it is not, a copy
-// will be created, updated and returned.
-func (a Vector) Merge(b Vector) Vector {
-	var ai, bi int
-	for bi < len(b) {
-		if ai == len(a) {
-			// We've reach the end of a, all that remains are appends
-			return append(a, b[bi:]...)
-		}
-
-		if a[ai].ID > b[bi].ID {
-			// The index from b should be inserted here
-			n := make(Vector, len(a)+1)
-			copy(n, a[:ai])
-			n[ai] = b[bi]
-			copy(n[ai+1:], a[ai:])
-			a = n
-		}
-
-		if a[ai].ID == b[bi].ID {
-			if v := b[bi].Value; v > a[ai].Value {
-				a[ai].Value = v
-			}
-		}
-
-		if bi < len(b) && a[ai].ID == b[bi].ID {
-			bi++
-		}
-		ai++
-	}
-
-	return a
-}
-
-// Copy returns an identical vector that is not shared with v.
-func (v Vector) Copy() Vector {
-	nv := make(Vector, len(v))
-	copy(nv, v)
-	return nv
-}
-
-// Equal returns true when the two vectors are equivalent.
-func (a Vector) Equal(b Vector) bool {
-	return a.Compare(b) == Equal
-}
-
-// LesserEqual returns true when the two vectors are equivalent or a is Lesser
-// than b.
-func (a Vector) LesserEqual(b Vector) bool {
-	comp := a.Compare(b)
-	return comp == Lesser || comp == Equal
-}
-
-// LesserEqual returns true when the two vectors are equivalent or a is Greater
-// than b.
-func (a Vector) GreaterEqual(b Vector) bool {
-	comp := a.Compare(b)
-	return comp == Greater || comp == Equal
-}
-
-// Concurrent returns true when the two vectors are concrurrent.
-func (a Vector) Concurrent(b Vector) bool {
-	comp := a.Compare(b)
-	return comp == ConcurrentGreater || comp == ConcurrentLesser
-}
-
-// Counter returns the current value of the given counter ID.
-func (v Vector) Counter(id uint64) uint64 {
-	for _, c := range v {
-		if c.ID == id {
-			return c.Value
-		}
-	}
-	return 0
-}

Godeps/_workspace/src/github.com/syncthing/protocol/vector_compare.go

@@ -1,89 +0,0 @@
-// Copyright (C) 2015 The Protocol Authors.
-
-package protocol
-
-// Ordering represents the relationship between two Vectors.
-type Ordering int
-
-const (
-	Equal Ordering = iota
-	Greater
-	Lesser
-	ConcurrentLesser
-	ConcurrentGreater
-)
-
-// There's really no such thing as "concurrent lesser" and "concurrent
-// greater" in version vectors, just "concurrent". But it's useful to be able
-// to get a strict ordering between versions for stable sorts and so on, so we
-// return both variants. The convenience method Concurrent() can be used to
-// check for either case.
-
-// Compare returns the Ordering that describes a's relation to b.
-func (a Vector) Compare(b Vector) Ordering {
-	var ai, bi int     // index into a and b
-	var av, bv Counter // value at current index
-
-	result := Equal
-
-	for ai < len(a) || bi < len(b) {
-		var aMissing, bMissing bool
-
-		if ai < len(a) {
-			av = a[ai]
-		} else {
-			av = Counter{}
-			aMissing = true
-		}
-
-		if bi < len(b) {
-			bv = b[bi]
-		} else {
-			bv = Counter{}
-			bMissing = true
-		}
-
-		switch {
-		case av.ID == bv.ID:
-			// We have a counter value for each side
-			if av.Value > bv.Value {
-				if result == Lesser {
-					return ConcurrentLesser
-				}
-				result = Greater
-			} else if av.Value < bv.Value {
-				if result == Greater {
-					return ConcurrentGreater
-				}
-				result = Lesser
-			}
-
-		case !aMissing && av.ID < bv.ID || bMissing:
-			// Value is missing on the b side
-			if av.Value > 0 {
-				if result == Lesser {
-					return ConcurrentLesser
-				}
-				result = Greater
-			}
-
-		case !bMissing && bv.ID < av.ID || aMissing:
-			// Value is missing on the a side
-			if bv.Value > 0 {
-				if result == Greater {
-					return ConcurrentGreater
-				}
-				result = Lesser
-			}
-		}
-
-		if ai < len(a) && (av.ID <= bv.ID || bMissing) {
-			ai++
-		}
-		if bi < len(b) && (bv.ID <= av.ID || aMissing) {
-			bi++
-		}
-	}
-
-	return result
-}

Godeps/_workspace/src/github.com/syncthing/protocol/vector_compare_test.go

@@ -1,249 +0,0 @@
-// Copyright (C) 2015 The Protocol Authors.
-
-package protocol
-
-import (
-	"math"
-	"testing"
-)
-
-func TestCompare(t *testing.T) {
-	testcases := []struct {
-		a, b Vector
-		r    Ordering
-	}{
-		// Empty vectors are identical
-		{Vector{}, Vector{}, Equal},
-		{Vector{}, nil, Equal},
-		{nil, Vector{}, Equal},
-		{nil, Vector{Counter{42, 0}}, Equal},
-		{Vector{}, Vector{Counter{42, 0}}, Equal},
-		{Vector{Counter{42, 0}}, nil, Equal},
-		{Vector{Counter{42, 0}}, Vector{}, Equal},
-
-		// Zero is the implied value for a missing Counter
-		{
-			Vector{Counter{42, 0}},
-			Vector{Counter{77, 0}},
-			Equal,
-		},
-
-		// Equal vectors are equal
-		{
-			Vector{Counter{42, 33}},
-			Vector{Counter{42, 33}},
-			Equal,
-		},
-		{
-			Vector{Counter{42, 33}, Counter{77, 24}},
-			Vector{Counter{42, 33}, Counter{77, 24}},
-			Equal,
-		},
-
-		// These a-vectors are all greater than the b-vector
-		{
-			Vector{Counter{42, 1}},
-			nil,
-			Greater,
-		},
-		{
-			Vector{Counter{42, 1}},
-			Vector{},
-			Greater,
-		},
-		{
-			Vector{Counter{0, 1}},
-			Vector{Counter{0, 0}},
-			Greater,
-		},
-		{
-			Vector{Counter{42, 1}},
-			Vector{Counter{42, 0}},
-			Greater,
-		},
-		{
-			Vector{Counter{math.MaxUint64, 1}},
-			Vector{Counter{math.MaxUint64, 0}},
-			Greater,
-		},
-		{
-			Vector{Counter{0, math.MaxUint64}},
-			Vector{Counter{0, 0}},
-			Greater,
-		},
-		{
-			Vector{Counter{42, math.MaxUint64}},
-			Vector{Counter{42, 0}},
-			Greater,
-		},
-		{
-			Vector{Counter{math.MaxUint64, math.MaxUint64}},
-			Vector{Counter{math.MaxUint64, 0}},
-			Greater,
-		},
-		{
-			Vector{Counter{0, math.MaxUint64}},
-			Vector{Counter{0, math.MaxUint64 - 1}},
-			Greater,
-		},
-		{
-			Vector{Counter{42, math.MaxUint64}},
-			Vector{Counter{42, math.MaxUint64 - 1}},
-			Greater,
-		},
-		{
-			Vector{Counter{math.MaxUint64, math.MaxUint64}},
-			Vector{Counter{math.MaxUint64, math.MaxUint64 - 1}},
-			Greater,
-		},
-		{
-			Vector{Counter{42, 2}},
-			Vector{Counter{42, 1}},
-			Greater,
-		},
-		{
-			Vector{Counter{22, 22}, Counter{42, 2}},
-			Vector{Counter{22, 22}, Counter{42, 1}},
-			Greater,
-		},
-		{
-			Vector{Counter{42, 2}, Counter{77, 3}},
-			Vector{Counter{42, 1}, Counter{77, 3}},
-			Greater,
-		},
-		{
-			Vector{Counter{22, 22}, Counter{42, 2}, Counter{77, 3}},
-			Vector{Counter{22, 22}, Counter{42, 1}, Counter{77, 3}},
-			Greater,
-		},
-		{
-			Vector{Counter{22, 23}, Counter{42, 2}, Counter{77, 4}},
-			Vector{Counter{22, 22}, Counter{42, 1}, Counter{77, 3}},
-			Greater,
-		},
-
-		// These a-vectors are all lesser than the b-vector
-		{nil, Vector{Counter{42, 1}}, Lesser},
-		{Vector{}, Vector{Counter{42, 1}}, Lesser},
-		{
-			Vector{Counter{42, 0}},
-			Vector{Counter{42, 1}},
-			Lesser,
-		},
-		{
-			Vector{Counter{42, 1}},
-			Vector{Counter{42, 2}},
-			Lesser,
-		},
-		{
-			Vector{Counter{22, 22}, Counter{42, 1}},
-			Vector{Counter{22, 22}, Counter{42, 2}},
-			Lesser,
-		},
-		{
-			Vector{Counter{42, 1}, Counter{77, 3}},
-			Vector{Counter{42, 2}, Counter{77, 3}},
-			Lesser,
-		},
-		{
-			Vector{Counter{22, 22}, Counter{42, 1}, Counter{77, 3}},
-			Vector{Counter{22, 22}, Counter{42, 2}, Counter{77, 3}},
-			Lesser,
-		},
-		{
-			Vector{Counter{22, 22}, Counter{42, 1}, Counter{77, 3}},
-			Vector{Counter{22, 23}, Counter{42, 2}, Counter{77, 4}},
-			Lesser,
-		},
-
-		// These are all in conflict
-		{
-			Vector{Counter{42, 2}},
-			Vector{Counter{43, 1}},
-			ConcurrentGreater,
-		},
-		{
-			Vector{Counter{43, 1}},
-			Vector{Counter{42, 2}},
-			ConcurrentLesser,
-		},
-		{
-			Vector{Counter{22, 23}, Counter{42, 1}},
-			Vector{Counter{22, 22}, Counter{42, 2}},
-			ConcurrentGreater,
-		},
-		{
-			Vector{Counter{22, 21}, Counter{42, 2}},
-			Vector{Counter{22, 22}, Counter{42, 1}},
-			ConcurrentLesser,
-		},
-		{
-			Vector{Counter{22, 21}, Counter{42, 2}, Counter{43, 1}},
-			Vector{Counter{20, 1}, Counter{22, 22}, Counter{42, 1}},
-			ConcurrentLesser,
-		},
-	}
-
-	for i, tc := range testcases {
-		// Test real Compare
-		if r := tc.a.Compare(tc.b); r != tc.r {
-			t.Errorf("%d: %+v.Compare(%+v) == %v (expected %v)", i, tc.a, tc.b, r, tc.r)
-		}
-
-		// Test convenience functions
-		switch tc.r {
-		case Greater:
-			if tc.a.Equal(tc.b) {
-				t.Errorf("%+v == %+v", tc.a, tc.b)
-			}
-			if tc.a.Concurrent(tc.b) {
-				t.Errorf("%+v concurrent %+v", tc.a, tc.b)
-			}
-			if !tc.a.GreaterEqual(tc.b) {
-				t.Errorf("%+v not >= %+v", tc.a, tc.b)
-			}
-			if tc.a.LesserEqual(tc.b) {
-				t.Errorf("%+v <= %+v", tc.a, tc.b)
-			}
-		case Lesser:
-			if tc.a.Concurrent(tc.b) {
-				t.Errorf("%+v concurrent %+v", tc.a, tc.b)
-			}
-			if tc.a.Equal(tc.b) {
-				t.Errorf("%+v == %+v", tc.a, tc.b)
-			}
-			if tc.a.GreaterEqual(tc.b) {
-				t.Errorf("%+v >= %+v", tc.a, tc.b)
-			}
-			if !tc.a.LesserEqual(tc.b) {
-				t.Errorf("%+v not <= %+v", tc.a, tc.b)
-			}
-		case Equal:
-			if tc.a.Concurrent(tc.b) {
-				t.Errorf("%+v concurrent %+v", tc.a, tc.b)
-			}
-			if !tc.a.Equal(tc.b) {
-				t.Errorf("%+v not == %+v", tc.a, tc.b)
-			}
-			if !tc.a.GreaterEqual(tc.b) {
-				t.Errorf("%+v not <= %+v", tc.a, tc.b)
-			}
-			if !tc.a.LesserEqual(tc.b) {
-				t.Errorf("%+v not <= %+v", tc.a, tc.b)
-			}
-		case ConcurrentLesser, ConcurrentGreater:
-			if !tc.a.Concurrent(tc.b) {
-				t.Errorf("%+v not concurrent %+v", tc.a, tc.b)
-			}
-			if tc.a.Equal(tc.b) {
-				t.Errorf("%+v == %+v", tc.a, tc.b)
-			}
-			if tc.a.GreaterEqual(tc.b) {
-				t.Errorf("%+v >= %+v", tc.a, tc.b)
-			}
-			if tc.a.LesserEqual(tc.b) {
-				t.Errorf("%+v <= %+v", tc.a, tc.b)
-			}
-		}
-	}
-}

Godeps/_workspace/src/github.com/syncthing/protocol/vector_test.go

@@ -1,134 +0,0 @@
-// Copyright (C) 2015 The Protocol Authors.
-
-package protocol
-
-import "testing"
-
-func TestUpdate(t *testing.T) {
-	var v Vector
-
-	// Append
-
-	v = v.Update(42)
-	expected := Vector{Counter{42, 1}}
-
-	if v.Compare(expected) != Equal {
-		t.Errorf("Update error, %+v != %+v", v, expected)
-	}
-
-	// Insert at front
-
-	v = v.Update(36)
-	expected = Vector{Counter{36, 1}, Counter{42, 1}}
-
-	if v.Compare(expected) != Equal {
-		t.Errorf("Update error, %+v != %+v", v, expected)
-	}
-
-	// Insert in moddle
-
-	v = v.Update(37)
-	expected = Vector{Counter{36, 1}, Counter{37, 1}, Counter{42, 1}}
-
-	if v.Compare(expected) != Equal {
-		t.Errorf("Update error, %+v != %+v", v, expected)
-	}
-
-	// Update existing
-
-	v = v.Update(37)
-	expected = Vector{Counter{36, 1}, Counter{37, 2}, Counter{42, 1}}
-
-	if v.Compare(expected) != Equal {
-		t.Errorf("Update error, %+v != %+v", v, expected)
-	}
-}
-
-func TestCopy(t *testing.T) {
-	v0 := Vector{Counter{42, 1}}
-	v1 := v0.Copy()
-	v1.Update(42)
-	if v0.Compare(v1) != Lesser {
-		t.Errorf("Copy error, %+v should be ancestor of %+v", v0, v1)
-	}
-}
-
-func TestMerge(t *testing.T) {
-	testcases := []struct {
-		a, b, m Vector
-	}{
-		// No-ops
-		{
-			Vector{},
-			Vector{},
-			Vector{},
-		},
-		{
-			Vector{Counter{22, 1}, Counter{42, 1}},
-			Vector{Counter{22, 1}, Counter{42, 1}},
-			Vector{Counter{22, 1}, Counter{42, 1}},
-		},
-
-		// Appends
-		{
-			Vector{},
-			Vector{Counter{22, 1}, Counter{42, 1}},
-			Vector{Counter{22, 1}, Counter{42, 1}},
-		},
-		{
-			Vector{Counter{22, 1}},
-			Vector{Counter{42, 1}},
-			Vector{Counter{22, 1}, Counter{42, 1}},
-		},
-		{
-			Vector{Counter{22, 1}},
-			Vector{Counter{22, 1}, Counter{42, 1}},
-			Vector{Counter{22, 1}, Counter{42, 1}},
-		},
-
-		// Insert
-		{
-			Vector{Counter{22, 1}, Counter{42, 1}},
-			Vector{Counter{22, 1}, Counter{23, 2}, Counter{42, 1}},
-			Vector{Counter{22, 1}, Counter{23, 2}, Counter{42, 1}},
-		},
-		{
-			Vector{Counter{42, 1}},
-			Vector{Counter{22, 1}},
-			Vector{Counter{22, 1}, Counter{42, 1}},
-		},
-
-		// Update
-		{
-			Vector{Counter{22, 1}, Counter{42, 2}},
-			Vector{Counter{22, 2}, Counter{42, 1}},
-			Vector{Counter{22, 2}, Counter{42, 2}},
-		},
-
-		// All of the above
-		{
-			Vector{Counter{10, 1}, Counter{20, 2}, Counter{30, 1}},
-			Vector{Counter{5, 1}, Counter{10, 2}, Counter{15, 1}, Counter{20, 1}, Counter{25, 1}, Counter{35, 1}},
-			Vector{Counter{5, 1}, Counter{10, 2}, Counter{15, 1}, Counter{20, 2}, Counter{25, 1}, Counter{30, 1}, Counter{35, 1}},
-		},
-	}
-
-	for i, tc := range testcases {
-		if m := tc.a.Merge(tc.b); m.Compare(tc.m) != Equal {
-			t.Errorf("%d: %+v.Merge(%+v) == %+v (expected %+v)", i, tc.a, tc.b, m, tc.m)
-		}
-	}
-}
-
-func TestCounterValue(t *testing.T) {
-	v0 := Vector{Counter{42, 1}, Counter{64, 5}}
-	if v0.Counter(42) != 1 {
-		t.Error("Counter error, %d != %d", v0.Counter(42), 1)
-	}
-	if v0.Counter(64) != 5 {
-		t.Error("Counter error, %d != %d", v0.Counter(64), 5)
-	}
-	if v0.Counter(72) != 0 {
-		t.Error("Counter error, %d != %d", v0.Counter(72), 0)
-	}
-}

Godeps/_workspace/src/github.com/syncthing/protocol/vector_xdr.go

@@ -1,43 +0,0 @@
-// Copyright (C) 2015 The Protocol Authors.
-
-package protocol
-
-import "github.com/calmh/xdr"
-
-// This stuff is hacked up manually because genxdr doesn't support 'type
-// Vector []Counter' declarations and it was tricky when I tried to add it...
-
-type xdrWriter interface {
-	WriteUint32(uint32) (int, error)
-	WriteUint64(uint64) (int, error)
-}
-type xdrReader interface {
-	ReadUint32() uint32
-	ReadUint64() uint64
-}
-
-// EncodeXDRInto encodes the vector as an XDR object into the given XDR
-// encoder.
-func (v Vector) EncodeXDRInto(w xdrWriter) (int, error) {
-	w.WriteUint32(uint32(len(v)))
-	for i := range v {
-		w.WriteUint64(v[i].ID)
-		w.WriteUint64(v[i].Value)
-	}
-	return 4 + 16*len(v), nil
-}
-
-// DecodeXDRFrom decodes the XDR objects from the given reader into itself.
-func (v *Vector) DecodeXDRFrom(r xdrReader) error {
-	l := int(r.ReadUint32())
-	if l > 1e6 {
-		return xdr.ElementSizeExceeded("number of counters", l, 1e6)
-	}
-	n := make(Vector, l)
-	for i := range n {
-		n[i].ID = r.ReadUint64()
-		n[i].Value = r.ReadUint64()
-	}
-	*v = n
-	return nil
-}

Godeps/_workspace/src/github.com/syncthing/protocol/wireformat.go

@@ -1,60 +0,0 @@
-// Copyright (C) 2014 The Protocol Authors.
-
-package protocol
-
-import (
-	"path/filepath"
-
-	"golang.org/x/text/unicode/norm"
-)
-
-type wireFormatConnection struct {
-	next Connection
-}
-
-func (c wireFormatConnection) Start() {
-	c.next.Start()
-}
-
-func (c wireFormatConnection) ID() DeviceID {
-	return c.next.ID()
-}
-
-func (c wireFormatConnection) Name() string {
-	return c.next.Name()
-}
-
-func (c wireFormatConnection) Index(folder string, fs []FileInfo, flags uint32, options []Option) error {
-	var myFs = make([]FileInfo, len(fs))
-	copy(myFs, fs)
-
-	for i := range fs {
-		myFs[i].Name = norm.NFC.String(filepath.ToSlash(myFs[i].Name))
-	}
-
-	return c.next.Index(folder, myFs, flags, options)
-}
-
-func (c wireFormatConnection) IndexUpdate(folder string, fs []FileInfo, flags uint32, options []Option) error {
-	var myFs = make([]FileInfo, len(fs))
-	copy(myFs, fs)
-
-	for i := range fs {
-		myFs[i].Name = norm.NFC.String(filepath.ToSlash(myFs[i].Name))
-	}
-
-	return c.next.IndexUpdate(folder, myFs, flags, options)
-}
-
-func (c wireFormatConnection) Request(folder, name string, offset int64, size int, hash []byte, flags uint32, options []Option) ([]byte, error) {
-	name = norm.NFC.String(filepath.ToSlash(name))
-	return c.next.Request(folder, name, offset, size, hash, flags, options)
-}
-
-func (c wireFormatConnection) ClusterConfig(config ClusterConfigMessage) {
-	c.next.ClusterConfig(config)
-}
-
-func (c wireFormatConnection) Statistics() Statistics {
-	return c.next.Statistics()
-}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/batch.go

@@ -1,252 +0,0 @@
-// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
-// All rights reserved.
-//
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-package leveldb
-
-import (
-	"encoding/binary"
-	"fmt"
-
-	"github.com/syndtr/goleveldb/leveldb/errors"
-	"github.com/syndtr/goleveldb/leveldb/memdb"
-)
-
-type ErrBatchCorrupted struct {
-	Reason string
-}
-
-func (e *ErrBatchCorrupted) Error() string {
-	return fmt.Sprintf("leveldb: batch corrupted: %s", e.Reason)
-}
-
-func newErrBatchCorrupted(reason string) error {
-	return errors.NewErrCorrupted(nil, &ErrBatchCorrupted{reason})
-}
-
-const (
-	batchHdrLen  = 8 + 4
-	batchGrowRec = 3000
-)
-
-type BatchReplay interface {
-	Put(key, value []byte)
-	Delete(key []byte)
-}
-
-// Batch is a write batch.
-type Batch struct {
-	data       []byte
-	rLen, bLen int
-	seq        uint64
-	sync       bool
-}
-
-func (b *Batch) grow(n int) {
-	off := len(b.data)
-	if off == 0 {
-		off = batchHdrLen
-		if b.data != nil {
-			b.data = b.data[:off]
-		}
-	}
-	if cap(b.data)-off < n {
-		if b.data == nil {
-			b.data = make([]byte, off, off+n)
-		} else {
-			odata := b.data
-			div := 1
-			if b.rLen > batchGrowRec {
-				div = b.rLen / batchGrowRec
-			}
-			b.data = make([]byte, off, off+n+(off-batchHdrLen)/div)
-			copy(b.data, odata)
-		}
-	}
-}
-
-func (b *Batch) appendRec(kt kType, key, value []byte) {
-	n := 1 + binary.MaxVarintLen32 + len(key)
-	if kt == ktVal {
-		n += binary.MaxVarintLen32 + len(value)
-	}
-	b.grow(n)
-	off := len(b.data)
-	data := b.data[:off+n]
-	data[off] = byte(kt)
-	off += 1
-	off += binary.PutUvarint(data[off:], uint64(len(key)))
-	copy(data[off:], key)
-	off += len(key)
-	if kt == ktVal {
-		off += binary.PutUvarint(data[off:], uint64(len(value)))
-		copy(data[off:], value)
-		off += len(value)
-	}
-	b.data = data[:off]
-	b.rLen++
-	//  Include 8-byte ikey header
-	b.bLen += len(key) + len(value) + 8
-}
-
-// Put appends 'put operation' of the given key/value pair to the batch.
-// It is safe to modify the contents of the argument after Put returns.
-func (b *Batch) Put(key, value []byte) {
-	b.appendRec(ktVal, key, value)
-}
-
-// Delete appends 'delete operation' of the given key to the batch.
-// It is safe to modify the contents of the argument after Delete returns.
-func (b *Batch) Delete(key []byte) {
-	b.appendRec(ktDel, key, nil)
-}
-
-// Dump dumps batch contents. The returned slice can be loaded into the
-// batch using Load method.
-// The returned slice is not its own copy, so the contents should not be
-// modified.
-func (b *Batch) Dump() []byte {
-	return b.encode()
-}
-
-// Load loads given slice into the batch. Previous contents of the batch
-// will be discarded.
-// The given slice will not be copied and will be used as batch buffer, so
-// it is not safe to modify the contents of the slice.
-func (b *Batch) Load(data []byte) error {
-	return b.decode(0, data)
-}
-
-// Replay replays batch contents.
-func (b *Batch) Replay(r BatchReplay) error {
-	return b.decodeRec(func(i int, kt kType, key, value []byte) {
-		switch kt {
-		case ktVal:
-			r.Put(key, value)
-		case ktDel:
-			r.Delete(key)
-		}
-	})
-}
-
-// Len returns number of records in the batch.
-func (b *Batch) Len() int {
-	return b.rLen
-}
-
-// Reset resets the batch.
-func (b *Batch) Reset() {
-	b.data = b.data[:0]
-	b.seq = 0
-	b.rLen = 0
-	b.bLen = 0
-	b.sync = false
-}
-
-func (b *Batch) init(sync bool) {
-	b.sync = sync
-}
-
-func (b *Batch) append(p *Batch) {
-	if p.rLen > 0 {
-		b.grow(len(p.data) - batchHdrLen)
-		b.data = append(b.data, p.data[batchHdrLen:]...)
-		b.rLen += p.rLen
-	}
-	if p.sync {
-		b.sync = true
-	}
-}
-
-// size returns sums of key/value pair length plus 8-bytes ikey.
-func (b *Batch) size() int {
-	return b.bLen
-}
-
-func (b *Batch) encode() []byte {
-	b.grow(0)
-	binary.LittleEndian.PutUint64(b.data, b.seq)
-	binary.LittleEndian.PutUint32(b.data[8:], uint32(b.rLen))
-
-	return b.data
-}
-
-func (b *Batch) decode(prevSeq uint64, data []byte) error {
-	if len(data) < batchHdrLen {
-		return newErrBatchCorrupted("too short")
-	}
-
-	b.seq = binary.LittleEndian.Uint64(data)
-	if b.seq < prevSeq {
-		return newErrBatchCorrupted("invalid sequence number")
-	}
-	b.rLen = int(binary.LittleEndian.Uint32(data[8:]))
-	if b.rLen < 0 {
-		return newErrBatchCorrupted("invalid records length")
-	}
-	// No need to be precise at this point, it won't be used anyway
-	b.bLen = len(data) - batchHdrLen
-	b.data = data
-
-	return nil
-}
-
-func (b *Batch) decodeRec(f func(i int, kt kType, key, value []byte)) (err error) {
-	off := batchHdrLen
-	for i := 0; i < b.rLen; i++ {
-		if off >= len(b.data) {
-			return newErrBatchCorrupted("invalid records length")
-		}
-
-		kt := kType(b.data[off])
-		if kt > ktVal {
-			return newErrBatchCorrupted("bad record: invalid type")
-		}
-		off += 1
-
-		x, n := binary.Uvarint(b.data[off:])
-		off += n
-		if n <= 0 || off+int(x) > len(b.data) {
-			return newErrBatchCorrupted("bad record: invalid key length")
-		}
-		key := b.data[off : off+int(x)]
-		off += int(x)
-		var value []byte
-		if kt == ktVal {
-			x, n := binary.Uvarint(b.data[off:])
-			off += n
-			if n <= 0 || off+int(x) > len(b.data) {
-				return newErrBatchCorrupted("bad record: invalid value length")
-			}
-			value = b.data[off : off+int(x)]
-			off += int(x)
-		}
-
-		f(i, kt, key, value)
-	}
-
-	return nil
-}
-
-func (b *Batch) memReplay(to *memdb.DB) error {
-	return b.decodeRec(func(i int, kt kType, key, value []byte) {
-		ikey := newIkey(key, b.seq+uint64(i), kt)
-		to.Put(ikey, value)
-	})
-}
-
-func (b *Batch) memDecodeAndReplay(prevSeq uint64, data []byte, to *memdb.DB) error {
-	if err := b.decode(prevSeq, data); err != nil {
-		return err
-	}
-	return b.memReplay(to)
-}
-
-func (b *Batch) revertMemReplay(to *memdb.DB) error {
-	return b.decodeRec(func(i int, kt kType, key, value []byte) {
-		ikey := newIkey(key, b.seq+uint64(i), kt)
-		to.Delete(ikey)
-	})
-}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/batch_test.go

@@ -1,120 +0,0 @@
-// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
-// All rights reserved.
-//
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-package leveldb
-
-import (
-	"bytes"
-	"testing"
-
-	"github.com/syndtr/goleveldb/leveldb/comparer"
-	"github.com/syndtr/goleveldb/leveldb/memdb"
-)
-
-type tbRec struct {
-	kt         kType
-	key, value []byte
-}
-
-type testBatch struct {
-	rec []*tbRec
-}
-
-func (p *testBatch) Put(key, value []byte) {
-	p.rec = append(p.rec, &tbRec{ktVal, key, value})
-}
-
-func (p *testBatch) Delete(key []byte) {
-	p.rec = append(p.rec, &tbRec{ktDel, key, nil})
-}
-
-func compareBatch(t *testing.T, b1, b2 *Batch) {
-	if b1.seq != b2.seq {
-		t.Errorf("invalid seq number want %d, got %d", b1.seq, b2.seq)
-	}
-	if b1.Len() != b2.Len() {
-		t.Fatalf("invalid record length want %d, got %d", b1.Len(), b2.Len())
-	}
-	p1, p2 := new(testBatch), new(testBatch)
-	err := b1.Replay(p1)
-	if err != nil {
-		t.Fatal("error when replaying batch 1: ", err)
-	}
-	err = b2.Replay(p2)
-	if err != nil {
-		t.Fatal("error when replaying batch 2: ", err)
-	}
-	for i := range p1.rec {
-		r1, r2 := p1.rec[i], p2.rec[i]
-		if r1.kt != r2.kt {
-			t.Errorf("invalid type on record '%d' want %d, got %d", i, r1.kt, r2.kt)
-		}
-		if !bytes.Equal(r1.key, r2.key) {
-			t.Errorf("invalid key on record '%d' want %s, got %s", i, string(r1.key), string(r2.key))
-		}
-		if r1.kt == ktVal {
-			if !bytes.Equal(r1.value, r2.value) {
-				t.Errorf("invalid value on record '%d' want %s, got %s", i, string(r1.value), string(r2.value))
-			}
-		}
-	}
-}
-
-func TestBatch_EncodeDecode(t *testing.T) {
-	b1 := new(Batch)
-	b1.seq = 10009
-	b1.Put([]byte("key1"), []byte("value1"))
-	b1.Put([]byte("key2"), []byte("value2"))
-	b1.Delete([]byte("key1"))
-	b1.Put([]byte("k"), []byte(""))
-	b1.Put([]byte("zzzzzzzzzzz"), []byte("zzzzzzzzzzzzzzzzzzzzzzzz"))
-	b1.Delete([]byte("key10000"))
-	b1.Delete([]byte("k"))
-	buf := b1.encode()
-	b2 := new(Batch)
-	err := b2.decode(0, buf)
-	if err != nil {
-		t.Error("error when decoding batch: ", err)
-	}
-	compareBatch(t, b1, b2)
-}
-
-func TestBatch_Append(t *testing.T) {
-	b1 := new(Batch)
-	b1.seq = 10009
-	b1.Put([]byte("key1"), []byte("value1"))
-	b1.Put([]byte("key2"), []byte("value2"))
-	b1.Delete([]byte("key1"))
-	b1.Put([]byte("foo"), []byte("foovalue"))
-	b1.Put([]byte("bar"), []byte("barvalue"))
-	b2a := new(Batch)
-	b2a.seq = 10009
-	b2a.Put([]byte("key1"), []byte("value1"))
-	b2a.Put([]byte("key2"), []byte("value2"))
-	b2a.Delete([]byte("key1"))
-	b2b := new(Batch)
-	b2b.Put([]byte("foo"), []byte("foovalue"))
-	b2b.Put([]byte("bar"), []byte("barvalue"))
-	b2a.append(b2b)
-	compareBatch(t, b1, b2a)
-}
-
-func TestBatch_Size(t *testing.T) {
-	b := new(Batch)
-	for i := 0; i < 2; i++ {
-		b.Put([]byte("key1"), []byte("value1"))
-		b.Put([]byte("key2"), []byte("value2"))
-		b.Delete([]byte("key1"))
-		b.Put([]byte("foo"), []byte("foovalue"))
-		b.Put([]byte("bar"), []byte("barvalue"))
-		mem := memdb.New(&iComparer{comparer.DefaultComparer}, 0)
-		b.memReplay(mem)
-		if b.size() != mem.Size() {
-			t.Errorf("invalid batch size calculation, want=%d got=%d", mem.Size(), b.size())
-		}
-		b.Reset()
-	}
-}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/bench2_test.go

@@ -1,58 +0,0 @@
-// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
-// All rights reserved.
-//
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// +build !go1.2
-
-package leveldb
-
-import (
-	"sync/atomic"
-	"testing"
-)
-
-func BenchmarkDBReadConcurrent(b *testing.B) {
-	p := openDBBench(b, false)
-	p.populate(b.N)
-	p.fill()
-	p.gc()
-	defer p.close()
-
-	b.ResetTimer()
-	b.SetBytes(116)
-
-	b.RunParallel(func(pb *testing.PB) {
-		iter := p.newIter()
-		defer iter.Release()
-		for pb.Next() && iter.Next() {
-		}
-	})
-}
-
-func BenchmarkDBReadConcurrent2(b *testing.B) {
-	p := openDBBench(b, false)
-	p.populate(b.N)
-	p.fill()
-	p.gc()
-	defer p.close()
-
-	b.ResetTimer()
-	b.SetBytes(116)
-
-	var dir uint32
-	b.RunParallel(func(pb *testing.PB) {
-		iter := p.newIter()
-		defer iter.Release()
-		if atomic.AddUint32(&dir, 1)%2 == 0 {
-			for pb.Next() && iter.Next() {
-			}
-		} else {
-			if pb.Next() && iter.Last() {
-				for pb.Next() && iter.Prev() {
-				}
-			}
-		}
-	})
-}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/bench_test.go

@@ -1,464 +0,0 @@
-// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
-// All rights reserved.
-//
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-package leveldb
-
-import (
-	"bytes"
-	"fmt"
-	"math/rand"
-	"os"
-	"path/filepath"
-	"runtime"
-	"testing"
-
-	"github.com/syndtr/goleveldb/leveldb/iterator"
-	"github.com/syndtr/goleveldb/leveldb/opt"
-	"github.com/syndtr/goleveldb/leveldb/storage"
-)
-
-func randomString(r *rand.Rand, n int) []byte {
-	b := new(bytes.Buffer)
-	for i := 0; i < n; i++ {
-		b.WriteByte(' ' + byte(r.Intn(95)))
-	}
-	return b.Bytes()
-}
-
-func compressibleStr(r *rand.Rand, frac float32, n int) []byte {
-	nn := int(float32(n) * frac)
-	rb := randomString(r, nn)
-	b := make([]byte, 0, n+nn)
-	for len(b) < n {
-		b = append(b, rb...)
-	}
-	return b[:n]
-}
-
-type valueGen struct {
-	src []byte
-	pos int
-}
-
-func newValueGen(frac float32) *valueGen {
-	v := new(valueGen)
-	r := rand.New(rand.NewSource(301))
-	v.src = make([]byte, 0, 1048576+100)
-	for len(v.src) < 1048576 {
-		v.src = append(v.src, compressibleStr(r, frac, 100)...)
-	}
-	return v
-}
-
-func (v *valueGen) get(n int) []byte {
-	if v.pos+n > len(v.src) {
-		v.pos = 0
-	}
-	v.pos += n
-	return v.src[v.pos-n : v.pos]
-}
-
-var benchDB = filepath.Join(os.TempDir(), fmt.Sprintf("goleveldbbench-%d", os.Getuid()))
-
-type dbBench struct {
-	b    *testing.B
-	stor storage.Storage
-	db   *DB
-
-	o  *opt.Options
-	ro *opt.ReadOptions
-	wo *opt.WriteOptions
-
-	keys, values [][]byte
-}
-
-func openDBBench(b *testing.B, noCompress bool) *dbBench {
-	_, err := os.Stat(benchDB)
-	if err == nil {
-		err = os.RemoveAll(benchDB)
-		if err != nil {
-			b.Fatal("cannot remove old db: ", err)
-		}
-	}
-
-	p := &dbBench{
-		b:  b,
-		o:  &opt.Options{},
-		ro: &opt.ReadOptions{},
-		wo: &opt.WriteOptions{},
-	}
-	p.stor, err = storage.OpenFile(benchDB)
-	if err != nil {
-		b.Fatal("cannot open stor: ", err)
-	}
-	if noCompress {
-		p.o.Compression = opt.NoCompression
-	}
-
-	p.db, err = Open(p.stor, p.o)
-	if err != nil {
-		b.Fatal("cannot open db: ", err)
-	}
-
-	runtime.GOMAXPROCS(runtime.NumCPU())
-	return p
-}
-
-func (p *dbBench) reopen() {
-	p.db.Close()
-	var err error
-	p.db, err = Open(p.stor, p.o)
-	if err != nil {
-		p.b.Fatal("Reopen: got error: ", err)
-	}
-}
-
-func (p *dbBench) populate(n int) {
-	p.keys, p.values = make([][]byte, n), make([][]byte, n)
-	v := newValueGen(0.5)
-	for i := range p.keys {
-		p.keys[i], p.values[i] = []byte(fmt.Sprintf("%016d", i)), v.get(100)
-	}
-}
-
-func (p *dbBench) randomize() {
-	m := len(p.keys)
-	times := m * 2
-	r1, r2 := rand.New(rand.NewSource(0xdeadbeef)), rand.New(rand.NewSource(0xbeefface))
-	for n := 0; n < times; n++ {
-		i, j := r1.Int()%m, r2.Int()%m
-		if i == j {
-			continue
-		}
-		p.keys[i], p.keys[j] = p.keys[j], p.keys[i]
-		p.values[i], p.values[j] = p.values[j], p.values[i]
-	}
-}
-
-func (p *dbBench) writes(perBatch int) {
-	b := p.b
-	db := p.db
-
-	n := len(p.keys)
-	m := n / perBatch
-	if n%perBatch > 0 {
-		m++
-	}
-	batches := make([]Batch, m)
-	j := 0
-	for i := range batches {
-		first := true
-		for ; j < n && ((j+1)%perBatch != 0 || first); j++ {
-			first = false
-			batches[i].Put(p.keys[j], p.values[j])
-		}
-	}
-	runtime.GC()
-
-	b.ResetTimer()
-	b.StartTimer()
-	for i := range batches {
-		err := db.Write(&(batches[i]), p.wo)
-		if err != nil {
-			b.Fatal("write failed: ", err)
-		}
-	}
-	b.StopTimer()
-	b.SetBytes(116)
-}
-
-func (p *dbBench) gc() {
-	p.keys, p.values = nil, nil
-	runtime.GC()
-}
-
-func (p *dbBench) puts() {
-	b := p.b
-	db := p.db
-
-	b.ResetTimer()
-	b.StartTimer()
-	for i := range p.keys {
-		err := db.Put(p.keys[i], p.values[i], p.wo)
-		if err != nil {
-			b.Fatal("put failed: ", err)
-		}
-	}
-	b.StopTimer()
-	b.SetBytes(116)
-}
-
-func (p *dbBench) fill() {
-	b := p.b
-	db := p.db
-
-	perBatch := 10000
-	batch := new(Batch)
-	for i, n := 0, len(p.keys); i < n; {
-		first := true
-		for ; i < n && ((i+1)%perBatch != 0 || first); i++ {
-			first = false
-			batch.Put(p.keys[i], p.values[i])
-		}
-		err := db.Write(batch, p.wo)
-		if err != nil {
-			b.Fatal("write failed: ", err)
-		}
-		batch.Reset()
-	}
-}
-
-func (p *dbBench) gets() {
-	b := p.b
-	db := p.db
-
-	b.ResetTimer()
-	for i := range p.keys {
-		_, err := db.Get(p.keys[i], p.ro)
-		if err != nil {
-			b.Error("got error: ", err)
-		}
-	}
-	b.StopTimer()
-}
-
-func (p *dbBench) seeks() {
-	b := p.b
-
-	iter := p.newIter()
-	defer iter.Release()
-	b.ResetTimer()
-	for i := range p.keys {
-		if !iter.Seek(p.keys[i]) {
-			b.Error("value not found for: ", string(p.keys[i]))
-		}
-	}
-	b.StopTimer()
-}
-
-func (p *dbBench) newIter() iterator.Iterator {
-	iter := p.db.NewIterator(nil, p.ro)
-	err := iter.Error()
-	if err != nil {
-		p.b.Fatal("cannot create iterator: ", err)
-	}
-	return iter
-}
-
-func (p *dbBench) close() {
-	if bp, err := p.db.GetProperty("leveldb.blockpool"); err == nil {
-		p.b.Log("Block pool stats: ", bp)
-	}
-	p.db.Close()
-	p.stor.Close()
-	os.RemoveAll(benchDB)
-	p.db = nil
-	p.keys = nil
-	p.values = nil
-	runtime.GC()
-	runtime.GOMAXPROCS(1)
-}
-
-func BenchmarkDBWrite(b *testing.B) {
-	p := openDBBench(b, false)
-	p.populate(b.N)
-	p.writes(1)
-	p.close()
-}
-
-func BenchmarkDBWriteBatch(b *testing.B) {
-	p := openDBBench(b, false)
-	p.populate(b.N)
-	p.writes(1000)
-	p.close()
-}
-
-func BenchmarkDBWriteUncompressed(b *testing.B) {
-	p := openDBBench(b, true)
-	p.populate(b.N)
-	p.writes(1)
-	p.close()
-}
-
-func BenchmarkDBWriteBatchUncompressed(b *testing.B) {
-	p := openDBBench(b, true)
-	p.populate(b.N)
-	p.writes(1000)
-	p.close()
-}
-
-func BenchmarkDBWriteRandom(b *testing.B) {
-	p := openDBBench(b, false)
-	p.populate(b.N)
-	p.randomize()
-	p.writes(1)
-	p.close()
-}
-
-func BenchmarkDBWriteRandomSync(b *testing.B) {
-	p := openDBBench(b, false)
-	p.wo.Sync = true
-	p.populate(b.N)
-	p.writes(1)
-	p.close()
-}
-
-func BenchmarkDBOverwrite(b *testing.B) {
-	p := openDBBench(b, false)
-	p.populate(b.N)
-	p.writes(1)
-	p.writes(1)
-	p.close()
-}
-
-func BenchmarkDBOverwriteRandom(b *testing.B) {
-	p := openDBBench(b, false)
-	p.populate(b.N)
-	p.writes(1)
-	p.randomize()
-	p.writes(1)
-	p.close()
-}
-
-func BenchmarkDBPut(b *testing.B) {
-	p := openDBBench(b, false)
-	p.populate(b.N)
-	p.puts()
-	p.close()
-}
-
-func BenchmarkDBRead(b *testing.B) {
-	p := openDBBench(b, false)
-	p.populate(b.N)
-	p.fill()
-	p.gc()
-
-	iter := p.newIter()
-	b.ResetTimer()
-	for iter.Next() {
-	}
-	iter.Release()
-	b.StopTimer()
-	b.SetBytes(116)
-	p.close()
-}
-
-func BenchmarkDBReadGC(b *testing.B) {
-	p := openDBBench(b, false)
-	p.populate(b.N)
-	p.fill()
-
-	iter := p.newIter()
-	b.ResetTimer()
-	for iter.Next() {
-	}
-	iter.Release()
-	b.StopTimer()
-	b.SetBytes(116)
-	p.close()
-}
-
-func BenchmarkDBReadUncompressed(b *testing.B) {
-	p := openDBBench(b, true)
-	p.populate(b.N)
-	p.fill()
-	p.gc()
-
-	iter := p.newIter()
-	b.ResetTimer()
-	for iter.Next() {
-	}
-	iter.Release()
-	b.StopTimer()
-	b.SetBytes(116)
-	p.close()
-}
-
-func BenchmarkDBReadTable(b *testing.B) {
-	p := openDBBench(b, false)
-	p.populate(b.N)
-	p.fill()
-	p.reopen()
-	p.gc()
-
-	iter := p.newIter()
-	b.ResetTimer()
-	for iter.Next() {
-	}
-	iter.Release()
-	b.StopTimer()
-	b.SetBytes(116)
-	p.close()
-}
-
-func BenchmarkDBReadReverse(b *testing.B) {
-	p := openDBBench(b, false)
-	p.populate(b.N)
-	p.fill()
-	p.gc()
-
-	iter := p.newIter()
-	b.ResetTimer()
-	iter.Last()
-	for iter.Prev() {
-	}
-	iter.Release()
-	b.StopTimer()
-	b.SetBytes(116)
-	p.close()
-}
-
-func BenchmarkDBReadReverseTable(b *testing.B) {
-	p := openDBBench(b, false)
-	p.populate(b.N)
-	p.fill()
-	p.reopen()
-	p.gc()
-
-	iter := p.newIter()
-	b.ResetTimer()
-	iter.Last()
-	for iter.Prev() {
-	}
-	iter.Release()
-	b.StopTimer()
-	b.SetBytes(116)
-	p.close()
-}
-
-func BenchmarkDBSeek(b *testing.B) {
-	p := openDBBench(b, false)
-	p.populate(b.N)
-	p.fill()
-	p.seeks()
-	p.close()
-}
-
-func BenchmarkDBSeekRandom(b *testing.B) {
-	p := openDBBench(b, false)
-	p.populate(b.N)
-	p.fill()
-	p.randomize()
-	p.seeks()
-	p.close()
-}
-
-func BenchmarkDBGet(b *testing.B) {
-	p := openDBBench(b, false)
-	p.populate(b.N)
-	p.fill()
-	p.gets()
-	p.close()
-}
-
-func BenchmarkDBGetRandom(b *testing.B) {
-	p := openDBBench(b, false)
-	p.populate(b.N)
-	p.fill()
-	p.randomize()
-	p.gets()
-	p.close()
-}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/cache/bench2_test.go

@@ -1,30 +0,0 @@
-// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
-// All rights reserved.
-//
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// +build !go1.2
-
-package cache
-
-import (
-	"math/rand"
-	"testing"
-)
-
-func BenchmarkLRUCache(b *testing.B) {
-	c := NewCache(NewLRU(10000))
-
-	b.SetParallelism(10)
-	b.RunParallel(func(pb *testing.PB) {
-		r := rand.New(rand.NewSource(time.Now().UnixNano()))
-
-		for pb.Next() {
-			key := uint64(r.Intn(1000000))
-			c.Get(0, key, func() (int, Value) {
-				return 1, key
-			}).Release()
-		}
-	})
-}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/cache/cache.go

@@ -1,676 +0,0 @@
-// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
-// All rights reserved.
-//
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// Package cache provides interface and implementation of a cache algorithms.
-package cache
-
-import (
-	"sync"
-	"sync/atomic"
-	"unsafe"
-
-	"github.com/syndtr/goleveldb/leveldb/util"
-)
-
-// Cacher provides interface to implements a caching functionality.
-// An implementation must be goroutine-safe.
-type Cacher interface {
-	// Capacity returns cache capacity.
-	Capacity() int
-
-	// SetCapacity sets cache capacity.
-	SetCapacity(capacity int)
-
-	// Promote promotes the 'cache node'.
-	Promote(n *Node)
-
-	// Ban evicts the 'cache node' and prevent subsequent 'promote'.
-	Ban(n *Node)
-
-	// Evict evicts the 'cache node'.
-	Evict(n *Node)
-
-	// EvictNS evicts 'cache node' with the given namespace.
-	EvictNS(ns uint64)
-
-	// EvictAll evicts all 'cache node'.
-	EvictAll()
-
-	// Close closes the 'cache tree'
-	Close() error
-}
-
-// Value is a 'cacheable object'. It may implements util.Releaser, if
-// so the the Release method will be called once object is released.
-type Value interface{}
-
-type CacheGetter struct {
-	Cache *Cache
-	NS    uint64
-}
-
-func (g *CacheGetter) Get(key uint64, setFunc func() (size int, value Value)) *Handle {
-	return g.Cache.Get(g.NS, key, setFunc)
-}
-
-// The hash tables implementation is based on:
-// "Dynamic-Sized Nonblocking Hash Tables", by Yujie Liu, Kunlong Zhang, and Michael Spear. ACM Symposium on Principles of Distributed Computing, Jul 2014.
-
-const (
-	mInitialSize           = 1 << 4
-	mOverflowThreshold     = 1 << 5
-	mOverflowGrowThreshold = 1 << 7
-)
-
-type mBucket struct {
-	mu     sync.Mutex
-	node   []*Node
-	frozen bool
-}
-
-func (b *mBucket) freeze() []*Node {
-	b.mu.Lock()
-	defer b.mu.Unlock()
-	if !b.frozen {
-		b.frozen = true
-	}
-	return b.node
-}
-
-func (b *mBucket) get(r *Cache, h *mNode, hash uint32, ns, key uint64, noset bool) (done, added bool, n *Node) {
-	b.mu.Lock()
-
-	if b.frozen {
-		b.mu.Unlock()
-		return
-	}
-
-	// Scan the node.
-	for _, n := range b.node {
-		if n.hash == hash && n.ns == ns && n.key == key {
-			atomic.AddInt32(&n.ref, 1)
-			b.mu.Unlock()
-			return true, false, n
-		}
-	}
-
-	// Get only.
-	if noset {
-		b.mu.Unlock()
-		return true, false, nil
-	}
-
-	// Create node.
-	n = &Node{
-		r:    r,
-		hash: hash,
-		ns:   ns,
-		key:  key,
-		ref:  1,
-	}
-	// Add node to bucket.
-	b.node = append(b.node, n)
-	bLen := len(b.node)
-	b.mu.Unlock()
-
-	// Update counter.
-	grow := atomic.AddInt32(&r.nodes, 1) >= h.growThreshold
-	if bLen > mOverflowThreshold {
-		grow = grow || atomic.AddInt32(&h.overflow, 1) >= mOverflowGrowThreshold
-	}
-
-	// Grow.
-	if grow && atomic.CompareAndSwapInt32(&h.resizeInProgess, 0, 1) {
-		nhLen := len(h.buckets) << 1
-		nh := &mNode{
-			buckets:         make([]unsafe.Pointer, nhLen),
-			mask:            uint32(nhLen) - 1,
-			pred:            unsafe.Pointer(h),
-			growThreshold:   int32(nhLen * mOverflowThreshold),
-			shrinkThreshold: int32(nhLen >> 1),
-		}
-		ok := atomic.CompareAndSwapPointer(&r.mHead, unsafe.Pointer(h), unsafe.Pointer(nh))
-		if !ok {
-			panic("BUG: failed swapping head")
-		}
-		go nh.initBuckets()
-	}
-
-	return true, true, n
-}
-
-func (b *mBucket) delete(r *Cache, h *mNode, hash uint32, ns, key uint64) (done, deleted bool) {
-	b.mu.Lock()
-
-	if b.frozen {
-		b.mu.Unlock()
-		return
-	}
-
-	// Scan the node.
-	var (
-		n    *Node
-		bLen int
-	)
-	for i := range b.node {
-		n = b.node[i]
-		if n.ns == ns && n.key == key {
-			if atomic.LoadInt32(&n.ref) == 0 {
-				deleted = true
-
-				// Call releaser.
-				if n.value != nil {
-					if r, ok := n.value.(util.Releaser); ok {
-						r.Release()
-					}
-					n.value = nil
-				}
-
-				// Remove node from bucket.
-				b.node = append(b.node[:i], b.node[i+1:]...)
-				bLen = len(b.node)
-			}
-			break
-		}
-	}
-	b.mu.Unlock()
-
-	if deleted {
-		// Call OnDel.
-		for _, f := range n.onDel {
-			f()
-		}
-
-		// Update counter.
-		atomic.AddInt32(&r.size, int32(n.size)*-1)
-		shrink := atomic.AddInt32(&r.nodes, -1) < h.shrinkThreshold
-		if bLen >= mOverflowThreshold {
-			atomic.AddInt32(&h.overflow, -1)
-		}
-
-		// Shrink.
-		if shrink && len(h.buckets) > mInitialSize && atomic.CompareAndSwapInt32(&h.resizeInProgess, 0, 1) {
-			nhLen := len(h.buckets) >> 1
-			nh := &mNode{
-				buckets:         make([]unsafe.Pointer, nhLen),
-				mask:            uint32(nhLen) - 1,
-				pred:            unsafe.Pointer(h),
-				growThreshold:   int32(nhLen * mOverflowThreshold),
-				shrinkThreshold: int32(nhLen >> 1),
-			}
-			ok := atomic.CompareAndSwapPointer(&r.mHead, unsafe.Pointer(h), unsafe.Pointer(nh))
-			if !ok {
-				panic("BUG: failed swapping head")
-			}
-			go nh.initBuckets()
-		}
-	}
-
-	return true, deleted
-}
-
-type mNode struct {
-	buckets         []unsafe.Pointer // []*mBucket
-	mask            uint32
-	pred            unsafe.Pointer // *mNode
-	resizeInProgess int32
-
-	overflow        int32
-	growThreshold   int32
-	shrinkThreshold int32
-}
-
-func (n *mNode) initBucket(i uint32) *mBucket {
-	if b := (*mBucket)(atomic.LoadPointer(&n.buckets[i])); b != nil {
-		return b
-	}
-
-	p := (*mNode)(atomic.LoadPointer(&n.pred))
-	if p != nil {
-		var node []*Node
-		if n.mask > p.mask {
-			// Grow.
-			pb := (*mBucket)(atomic.LoadPointer(&p.buckets[i&p.mask]))
-			if pb == nil {
-				pb = p.initBucket(i & p.mask)
-			}
-			m := pb.freeze()
-			// Split nodes.
-			for _, x := range m {
-				if x.hash&n.mask == i {
-					node = append(node, x)
-				}
-			}
-		} else {
-			// Shrink.
-			pb0 := (*mBucket)(atomic.LoadPointer(&p.buckets[i]))
-			if pb0 == nil {
-				pb0 = p.initBucket(i)
-			}
-			pb1 := (*mBucket)(atomic.LoadPointer(&p.buckets[i+uint32(len(n.buckets))]))
-			if pb1 == nil {
-				pb1 = p.initBucket(i + uint32(len(n.buckets)))
-			}
-			m0 := pb0.freeze()
-			m1 := pb1.freeze()
-			// Merge nodes.
-			node = make([]*Node, 0, len(m0)+len(m1))
-			node = append(node, m0...)
-			node = append(node, m1...)
-		}
-		b := &mBucket{node: node}
-		if atomic.CompareAndSwapPointer(&n.buckets[i], nil, unsafe.Pointer(b)) {
-			if len(node) > mOverflowThreshold {
-				atomic.AddInt32(&n.overflow, int32(len(node)-mOverflowThreshold))
-			}
-			return b
-		}
-	}
-
-	return (*mBucket)(atomic.LoadPointer(&n.buckets[i]))
-}
-
-func (n *mNode) initBuckets() {
-	for i := range n.buckets {
-		n.initBucket(uint32(i))
-	}
-	atomic.StorePointer(&n.pred, nil)
-}
-
-// Cache is a 'cache map'.
-type Cache struct {
-	mu     sync.RWMutex
-	mHead  unsafe.Pointer // *mNode
-	nodes  int32
-	size   int32
-	cacher Cacher
-	closed bool
-}
-
-// NewCache creates a new 'cache map'. The cacher is optional and
-// may be nil.
-func NewCache(cacher Cacher) *Cache {
-	h := &mNode{
-		buckets:         make([]unsafe.Pointer, mInitialSize),
-		mask:            mInitialSize - 1,
-		growThreshold:   int32(mInitialSize * mOverflowThreshold),
-		shrinkThreshold: 0,
-	}
-	for i := range h.buckets {
-		h.buckets[i] = unsafe.Pointer(&mBucket{})
-	}
-	r := &Cache{
-		mHead:  unsafe.Pointer(h),
-		cacher: cacher,
-	}
-	return r
-}
-
-func (r *Cache) getBucket(hash uint32) (*mNode, *mBucket) {
-	h := (*mNode)(atomic.LoadPointer(&r.mHead))
-	i := hash & h.mask
-	b := (*mBucket)(atomic.LoadPointer(&h.buckets[i]))
-	if b == nil {
-		b = h.initBucket(i)
-	}
-	return h, b
-}
-
-func (r *Cache) delete(n *Node) bool {
-	for {
-		h, b := r.getBucket(n.hash)
-		done, deleted := b.delete(r, h, n.hash, n.ns, n.key)
-		if done {
-			return deleted
-		}
-	}
-	return false
-}
-
-// Nodes returns number of 'cache node' in the map.
-func (r *Cache) Nodes() int {
-	return int(atomic.LoadInt32(&r.nodes))
-}
-
-// Size returns sums of 'cache node' size in the map.
-func (r *Cache) Size() int {
-	return int(atomic.LoadInt32(&r.size))
-}
-
-// Capacity returns cache capacity.
-func (r *Cache) Capacity() int {
-	if r.cacher == nil {
-		return 0
-	}
-	return r.cacher.Capacity()
-}
-
-// SetCapacity sets cache capacity.
-func (r *Cache) SetCapacity(capacity int) {
-	if r.cacher != nil {
-		r.cacher.SetCapacity(capacity)
-	}
-}
-
-// Get gets 'cache node' with the given namespace and key.
-// If cache node is not found and setFunc is not nil, Get will atomically creates
-// the 'cache node' by calling setFunc. Otherwise Get will returns nil.
-//
-// The returned 'cache handle' should be released after use by calling Release
-// method.
-func (r *Cache) Get(ns, key uint64, setFunc func() (size int, value Value)) *Handle {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-	if r.closed {
-		return nil
-	}
-
-	hash := murmur32(ns, key, 0xf00)
-	for {
-		h, b := r.getBucket(hash)
-		done, _, n := b.get(r, h, hash, ns, key, setFunc == nil)
-		if done {
-			if n != nil {
-				n.mu.Lock()
-				if n.value == nil {
-					if setFunc == nil {
-						n.mu.Unlock()
-						n.unref()
-						return nil
-					}
-
-					n.size, n.value = setFunc()
-					if n.value == nil {
-						n.size = 0
-						n.mu.Unlock()
-						n.unref()
-						return nil
-					}
-					atomic.AddInt32(&r.size, int32(n.size))
-				}
-				n.mu.Unlock()
-				if r.cacher != nil {
-					r.cacher.Promote(n)
-				}
-				return &Handle{unsafe.Pointer(n)}
-			}
-
-			break
-		}
-	}
-	return nil
-}
-
-// Delete removes and ban 'cache node' with the given namespace and key.
-// A banned 'cache node' will never inserted into the 'cache tree'. Ban
-// only attributed to the particular 'cache node', so when a 'cache node'
-// is recreated it will not be banned.
-//
-// If onDel is not nil, then it will be executed if such 'cache node'
-// doesn't exist or once the 'cache node' is released.
-//
-// Delete return true is such 'cache node' exist.
-func (r *Cache) Delete(ns, key uint64, onDel func()) bool {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-	if r.closed {
-		return false
-	}
-
-	hash := murmur32(ns, key, 0xf00)
-	for {
-		h, b := r.getBucket(hash)
-		done, _, n := b.get(r, h, hash, ns, key, true)
-		if done {
-			if n != nil {
-				if onDel != nil {
-					n.mu.Lock()
-					n.onDel = append(n.onDel, onDel)
-					n.mu.Unlock()
-				}
-				if r.cacher != nil {
-					r.cacher.Ban(n)
-				}
-				n.unref()
-				return true
-			}
-
-			break
-		}
-	}
-
-	if onDel != nil {
-		onDel()
-	}
-
-	return false
-}
-
-// Evict evicts 'cache node' with the given namespace and key. This will
-// simply call Cacher.Evict.
-//
-// Evict return true is such 'cache node' exist.
-func (r *Cache) Evict(ns, key uint64) bool {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-	if r.closed {
-		return false
-	}
-
-	hash := murmur32(ns, key, 0xf00)
-	for {
-		h, b := r.getBucket(hash)
-		done, _, n := b.get(r, h, hash, ns, key, true)
-		if done {
-			if n != nil {
-				if r.cacher != nil {
-					r.cacher.Evict(n)
-				}
-				n.unref()
-				return true
-			}
-
-			break
-		}
-	}
-
-	return false
-}
-
-// EvictNS evicts 'cache node' with the given namespace. This will
-// simply call Cacher.EvictNS.
-func (r *Cache) EvictNS(ns uint64) {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-	if r.closed {
-		return
-	}
-
-	if r.cacher != nil {
-		r.cacher.EvictNS(ns)
-	}
-}
-
-// EvictAll evicts all 'cache node'. This will simply call Cacher.EvictAll.
-func (r *Cache) EvictAll() {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-	if r.closed {
-		return
-	}
-
-	if r.cacher != nil {
-		r.cacher.EvictAll()
-	}
-}
-
-// Close closes the 'cache map' and releases all 'cache node'.
-func (r *Cache) Close() error {
-	r.mu.Lock()
-	if !r.closed {
-		r.closed = true
-
-		if r.cacher != nil {
-			if err := r.cacher.Close(); err != nil {
-				return err
-			}
-		}
-
-		h := (*mNode)(r.mHead)
-		h.initBuckets()
-
-		for i := range h.buckets {
-			b := (*mBucket)(h.buckets[i])
-			for _, n := range b.node {
-				// Call releaser.
-				if n.value != nil {
-					if r, ok := n.value.(util.Releaser); ok {
-						r.Release()
-					}
-					n.value = nil
-				}
-
-				// Call OnDel.
-				for _, f := range n.onDel {
-					f()
-				}
-			}
-		}
-	}
-	r.mu.Unlock()
-	return nil
-}
-
-// Node is a 'cache node'.
-type Node struct {
-	r *Cache
-
-	hash    uint32
-	ns, key uint64
-
-	mu    sync.Mutex
-	size  int
-	value Value
-
-	ref   int32
-	onDel []func()
-
-	CacheData unsafe.Pointer
-}
-
-// NS returns this 'cache node' namespace.
-func (n *Node) NS() uint64 {
-	return n.ns
-}
-
-// Key returns this 'cache node' key.
-func (n *Node) Key() uint64 {
-	return n.key
-}
-
-// Size returns this 'cache node' size.
-func (n *Node) Size() int {
-	return n.size
-}
-
-// Value returns this 'cache node' value.
-func (n *Node) Value() Value {
-	return n.value
-}
-
-// Ref returns this 'cache node' ref counter.
-func (n *Node) Ref() int32 {
-	return atomic.LoadInt32(&n.ref)
-}
-
-// GetHandle returns an handle for this 'cache node'.
-func (n *Node) GetHandle() *Handle {
-	if atomic.AddInt32(&n.ref, 1) <= 1 {
-		panic("BUG: Node.GetHandle on zero ref")
-	}
-	return &Handle{unsafe.Pointer(n)}
-}
-
-func (n *Node) unref() {
-	if atomic.AddInt32(&n.ref, -1) == 0 {
-		n.r.delete(n)
-	}
-}
-
-func (n *Node) unrefLocked() {
-	if atomic.AddInt32(&n.ref, -1) == 0 {
-		n.r.mu.RLock()
-		if !n.r.closed {
-			n.r.delete(n)
-		}
-		n.r.mu.RUnlock()
-	}
-}
-
-type Handle struct {
-	n unsafe.Pointer // *Node
-}
-
-func (h *Handle) Value() Value {
-	n := (*Node)(atomic.LoadPointer(&h.n))
-	if n != nil {
-		return n.value
-	}
-	return nil
-}
-
-func (h *Handle) Release() {
-	nPtr := atomic.LoadPointer(&h.n)
-	if nPtr != nil && atomic.CompareAndSwapPointer(&h.n, nPtr, nil) {
-		n := (*Node)(nPtr)
-		n.unrefLocked()
-	}
-}
-
-func murmur32(ns, key uint64, seed uint32) uint32 {
-	const (
-		m = uint32(0x5bd1e995)
-		r = 24
-	)
-
-	k1 := uint32(ns >> 32)
-	k2 := uint32(ns)
-	k3 := uint32(key >> 32)
-	k4 := uint32(key)
-
-	k1 *= m
-	k1 ^= k1 >> r
-	k1 *= m
-
-	k2 *= m
-	k2 ^= k2 >> r
-	k2 *= m
-
-	k3 *= m
-	k3 ^= k3 >> r
-	k3 *= m
-
-	k4 *= m
-	k4 ^= k4 >> r
-	k4 *= m
-
-	h := seed
-
-	h *= m
-	h ^= k1
-	h *= m
-	h ^= k2
-	h *= m
-	h ^= k3
-	h *= m
-	h ^= k4
-
-	h ^= h >> 13
-	h *= m
-	h ^= h >> 15
-
-	return h
-}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/cache/cache_test.go

@@ -1,554 +0,0 @@
-// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
-// All rights reserved.
-//
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-package cache
-
-import (
-	"math/rand"
-	"runtime"
-	"sync"
-	"sync/atomic"
-	"testing"
-	"time"
-	"unsafe"
-)
-
-type int32o int32
-
-func (o *int32o) acquire() {
-	if atomic.AddInt32((*int32)(o), 1) != 1 {
-		panic("BUG: invalid ref")
-	}
-}
-
-func (o *int32o) Release() {
-	if atomic.AddInt32((*int32)(o), -1) != 0 {
-		panic("BUG: invalid ref")
-	}
-}
-
-type releaserFunc struct {
-	fn    func()
-	value Value
-}
-
-func (r releaserFunc) Release() {
-	if r.fn != nil {
-		r.fn()
-	}
-}
-
-func set(c *Cache, ns, key uint64, value Value, charge int, relf func()) *Handle {
-	return c.Get(ns, key, func() (int, Value) {
-		if relf != nil {
-			return charge, releaserFunc{relf, value}
-		} else {
-			return charge, value
-		}
-	})
-}
-
-func TestCacheMap(t *testing.T) {
-	runtime.GOMAXPROCS(runtime.NumCPU())
-
-	nsx := []struct {
-		nobjects, nhandles, concurrent, repeat int
-	}{
-		{10000, 400, 50, 3},
-		{100000, 1000, 100, 10},
-	}
-
-	var (
-		objects [][]int32o
-		handles [][]unsafe.Pointer
-	)
-
-	for _, x := range nsx {
-		objects = append(objects, make([]int32o, x.nobjects))
-		handles = append(handles, make([]unsafe.Pointer, x.nhandles))
-	}
-
-	c := NewCache(nil)
-
-	wg := new(sync.WaitGroup)
-	var done int32
-
-	for ns, x := range nsx {
-		for i := 0; i < x.concurrent; i++ {
-			wg.Add(1)
-			go func(ns, i, repeat int, objects []int32o, handles []unsafe.Pointer) {
-				defer wg.Done()
-				r := rand.New(rand.NewSource(time.Now().UnixNano()))
-
-				for j := len(objects) * repeat; j >= 0; j-- {
-					key := uint64(r.Intn(len(objects)))
-					h := c.Get(uint64(ns), key, func() (int, Value) {
-						o := &objects[key]
-						o.acquire()
-						return 1, o
-					})
-					if v := h.Value().(*int32o); v != &objects[key] {
-						t.Fatalf("#%d invalid value: want=%p got=%p", ns, &objects[key], v)
-					}
-					if objects[key] != 1 {
-						t.Fatalf("#%d invalid object %d: %d", ns, key, objects[key])
-					}
-					if !atomic.CompareAndSwapPointer(&handles[r.Intn(len(handles))], nil, unsafe.Pointer(h)) {
-						h.Release()
-					}
-				}
-			}(ns, i, x.repeat, objects[ns], handles[ns])
-		}
-
-		go func(handles []unsafe.Pointer) {
-			r := rand.New(rand.NewSource(time.Now().UnixNano()))
-
-			for atomic.LoadInt32(&done) == 0 {
-				i := r.Intn(len(handles))
-				h := (*Handle)(atomic.LoadPointer(&handles[i]))
-				if h != nil && atomic.CompareAndSwapPointer(&handles[i], unsafe.Pointer(h), nil) {
-					h.Release()
-				}
-				time.Sleep(time.Millisecond)
-			}
-		}(handles[ns])
-	}
-
-	go func() {
-		handles := make([]*Handle, 100000)
-		for atomic.LoadInt32(&done) == 0 {
-			for i := range handles {
-				handles[i] = c.Get(999999999, uint64(i), func() (int, Value) {
-					return 1, 1
-				})
-			}
-			for _, h := range handles {
-				h.Release()
-			}
-		}
-	}()
-
-	wg.Wait()
-
-	atomic.StoreInt32(&done, 1)
-
-	for _, handles0 := range handles {
-		for i := range handles0 {
-			h := (*Handle)(atomic.LoadPointer(&handles0[i]))
-			if h != nil && atomic.CompareAndSwapPointer(&handles0[i], unsafe.Pointer(h), nil) {
-				h.Release()
-			}
-		}
-	}
-
-	for ns, objects0 := range objects {
-		for i, o := range objects0 {
-			if o != 0 {
-				t.Fatalf("invalid object #%d.%d: ref=%d", ns, i, o)
-			}
-		}
-	}
-}
-
-func TestCacheMap_NodesAndSize(t *testing.T) {
-	c := NewCache(nil)
-	if c.Nodes() != 0 {
-		t.Errorf("invalid nodes counter: want=%d got=%d", 0, c.Nodes())
-	}
-	if c.Size() != 0 {
-		t.Errorf("invalid size counter: want=%d got=%d", 0, c.Size())
-	}
-	set(c, 0, 1, 1, 1, nil)
-	set(c, 0, 2, 2, 2, nil)
-	set(c, 1, 1, 3, 3, nil)
-	set(c, 2, 1, 4, 1, nil)
-	if c.Nodes() != 4 {
-		t.Errorf("invalid nodes counter: want=%d got=%d", 4, c.Nodes())
-	}
-	if c.Size() != 7 {
-		t.Errorf("invalid size counter: want=%d got=%d", 4, c.Size())
-	}
-}
-
-func TestLRUCache_Capacity(t *testing.T) {
-	c := NewCache(NewLRU(10))
-	if c.Capacity() != 10 {
-		t.Errorf("invalid capacity: want=%d got=%d", 10, c.Capacity())
-	}
-	set(c, 0, 1, 1, 1, nil).Release()
-	set(c, 0, 2, 2, 2, nil).Release()
-	set(c, 1, 1, 3, 3, nil).Release()
-	set(c, 2, 1, 4, 1, nil).Release()
-	set(c, 2, 2, 5, 1, nil).Release()
-	set(c, 2, 3, 6, 1, nil).Release()
-	set(c, 2, 4, 7, 1, nil).Release()
-	set(c, 2, 5, 8, 1, nil).Release()
-	if c.Nodes() != 7 {
-		t.Errorf("invalid nodes counter: want=%d got=%d", 7, c.Nodes())
-	}
-	if c.Size() != 10 {
-		t.Errorf("invalid size counter: want=%d got=%d", 10, c.Size())
-	}
-	c.SetCapacity(9)
-	if c.Capacity() != 9 {
-		t.Errorf("invalid capacity: want=%d got=%d", 9, c.Capacity())
-	}
-	if c.Nodes() != 6 {
-		t.Errorf("invalid nodes counter: want=%d got=%d", 6, c.Nodes())
-	}
-	if c.Size() != 8 {
-		t.Errorf("invalid size counter: want=%d got=%d", 8, c.Size())
-	}
-}
-
-func TestCacheMap_NilValue(t *testing.T) {
-	c := NewCache(NewLRU(10))
-	h := c.Get(0, 0, func() (size int, value Value) {
-		return 1, nil
-	})
-	if h != nil {
-		t.Error("cache handle is non-nil")
-	}
-	if c.Nodes() != 0 {
-		t.Errorf("invalid nodes counter: want=%d got=%d", 0, c.Nodes())
-	}
-	if c.Size() != 0 {
-		t.Errorf("invalid size counter: want=%d got=%d", 0, c.Size())
-	}
-}
-
-func TestLRUCache_GetLatency(t *testing.T) {
-	runtime.GOMAXPROCS(runtime.NumCPU())
-
-	const (
-		concurrentSet = 30
-		concurrentGet = 3
-		duration      = 3 * time.Second
-		delay         = 3 * time.Millisecond
-		maxkey        = 100000
-	)
-
-	var (
-		set, getHit, getAll        int32
-		getMaxLatency, getDuration int64
-	)
-
-	c := NewCache(NewLRU(5000))
-	wg := &sync.WaitGroup{}
-	until := time.Now().Add(duration)
-	for i := 0; i < concurrentSet; i++ {
-		wg.Add(1)
-		go func(i int) {
-			defer wg.Done()
-			r := rand.New(rand.NewSource(time.Now().UnixNano()))
-			for time.Now().Before(until) {
-				c.Get(0, uint64(r.Intn(maxkey)), func() (int, Value) {
-					time.Sleep(delay)
-					atomic.AddInt32(&set, 1)
-					return 1, 1
-				}).Release()
-			}
-		}(i)
-	}
-	for i := 0; i < concurrentGet; i++ {
-		wg.Add(1)
-		go func(i int) {
-			defer wg.Done()
-			r := rand.New(rand.NewSource(time.Now().UnixNano()))
-			for {
-				mark := time.Now()
-				if mark.Before(until) {
-					h := c.Get(0, uint64(r.Intn(maxkey)), nil)
-					latency := int64(time.Now().Sub(mark))
-					m := atomic.LoadInt64(&getMaxLatency)
-					if latency > m {
-						atomic.CompareAndSwapInt64(&getMaxLatency, m, latency)
-					}
-					atomic.AddInt64(&getDuration, latency)
-					if h != nil {
-						atomic.AddInt32(&getHit, 1)
-						h.Release()
-					}
-					atomic.AddInt32(&getAll, 1)
-				} else {
-					break
-				}
-			}
-		}(i)
-	}
-
-	wg.Wait()
-	getAvglatency := time.Duration(getDuration) / time.Duration(getAll)
-	t.Logf("set=%d getHit=%d getAll=%d getMaxLatency=%v getAvgLatency=%v",
-		set, getHit, getAll, time.Duration(getMaxLatency), getAvglatency)
-
-	if getAvglatency > delay/3 {
-		t.Errorf("get avg latency > %v: got=%v", delay/3, getAvglatency)
-	}
-}
-
-func TestLRUCache_HitMiss(t *testing.T) {
-	cases := []struct {
-		key   uint64
-		value string
-	}{
-		{1, "vvvvvvvvv"},
-		{100, "v1"},
-		{0, "v2"},
-		{12346, "v3"},
-		{777, "v4"},
-		{999, "v5"},
-		{7654, "v6"},
-		{2, "v7"},
-		{3, "v8"},
-		{9, "v9"},
-	}
-
-	setfin := 0
-	c := NewCache(NewLRU(1000))
-	for i, x := range cases {
-		set(c, 0, x.key, x.value, len(x.value), func() {
-			setfin++
-		}).Release()
-		for j, y := range cases {
-			h := c.Get(0, y.key, nil)
-			if j <= i {
-				// should hit
-				if h == nil {
-					t.Errorf("case '%d' iteration '%d' is miss", i, j)
-				} else {
-					if x := h.Value().(releaserFunc).value.(string); x != y.value {
-						t.Errorf("case '%d' iteration '%d' has invalid value got '%s', want '%s'", i, j, x, y.value)
-					}
-				}
-			} else {
-				// should miss
-				if h != nil {
-					t.Errorf("case '%d' iteration '%d' is hit , value '%s'", i, j, h.Value().(releaserFunc).value.(string))
-				}
-			}
-			if h != nil {
-				h.Release()
-			}
-		}
-	}
-
-	for i, x := range cases {
-		finalizerOk := false
-		c.Delete(0, x.key, func() {
-			finalizerOk = true
-		})
-
-		if !finalizerOk {
-			t.Errorf("case %d delete finalizer not executed", i)
-		}
-
-		for j, y := range cases {
-			h := c.Get(0, y.key, nil)
-			if j > i {
-				// should hit
-				if h == nil {
-					t.Errorf("case '%d' iteration '%d' is miss", i, j)
-				} else {
-					if x := h.Value().(releaserFunc).value.(string); x != y.value {
-						t.Errorf("case '%d' iteration '%d' has invalid value got '%s', want '%s'", i, j, x, y.value)
-					}
-				}
-			} else {
-				// should miss
-				if h != nil {
-					t.Errorf("case '%d' iteration '%d' is hit, value '%s'", i, j, h.Value().(releaserFunc).value.(string))
-				}
-			}
-			if h != nil {
-				h.Release()
-			}
-		}
-	}
-
-	if setfin != len(cases) {
-		t.Errorf("some set finalizer may not be executed, want=%d got=%d", len(cases), setfin)
-	}
-}
-
-func TestLRUCache_Eviction(t *testing.T) {
-	c := NewCache(NewLRU(12))
-	o1 := set(c, 0, 1, 1, 1, nil)
-	set(c, 0, 2, 2, 1, nil).Release()
-	set(c, 0, 3, 3, 1, nil).Release()
-	set(c, 0, 4, 4, 1, nil).Release()
-	set(c, 0, 5, 5, 1, nil).Release()
-	if h := c.Get(0, 2, nil); h != nil { // 1,3,4,5,2
-		h.Release()
-	}
-	set(c, 0, 9, 9, 10, nil).Release() // 5,2,9
-
-	for _, key := range []uint64{9, 2, 5, 1} {
-		h := c.Get(0, key, nil)
-		if h == nil {
-			t.Errorf("miss for key '%d'", key)
-		} else {
-			if x := h.Value().(int); x != int(key) {
-				t.Errorf("invalid value for key '%d' want '%d', got '%d'", key, key, x)
-			}
-			h.Release()
-		}
-	}
-	o1.Release()
-	for _, key := range []uint64{1, 2, 5} {
-		h := c.Get(0, key, nil)
-		if h == nil {
-			t.Errorf("miss for key '%d'", key)
-		} else {
-			if x := h.Value().(int); x != int(key) {
-				t.Errorf("invalid value for key '%d' want '%d', got '%d'", key, key, x)
-			}
-			h.Release()
-		}
-	}
-	for _, key := range []uint64{3, 4, 9} {
-		h := c.Get(0, key, nil)
-		if h != nil {
-			t.Errorf("hit for key '%d'", key)
-			if x := h.Value().(int); x != int(key) {
-				t.Errorf("invalid value for key '%d' want '%d', got '%d'", key, key, x)
-			}
-			h.Release()
-		}
-	}
-}
-
-func TestLRUCache_Evict(t *testing.T) {
-	c := NewCache(NewLRU(6))
-	set(c, 0, 1, 1, 1, nil).Release()
-	set(c, 0, 2, 2, 1, nil).Release()
-	set(c, 1, 1, 4, 1, nil).Release()
-	set(c, 1, 2, 5, 1, nil).Release()
-	set(c, 2, 1, 6, 1, nil).Release()
-	set(c, 2, 2, 7, 1, nil).Release()
-
-	for ns := 0; ns < 3; ns++ {
-		for key := 1; key < 3; key++ {
-			if h := c.Get(uint64(ns), uint64(key), nil); h != nil {
-				h.Release()
-			} else {
-				t.Errorf("Cache.Get on #%d.%d return nil", ns, key)
-			}
-		}
-	}
-
-	if ok := c.Evict(0, 1); !ok {
-		t.Error("first Cache.Evict on #0.1 return false")
-	}
-	if ok := c.Evict(0, 1); ok {
-		t.Error("second Cache.Evict on #0.1 return true")
-	}
-	if h := c.Get(0, 1, nil); h != nil {
-		t.Errorf("Cache.Get on #0.1 return non-nil: %v", h.Value())
-	}
-
-	c.EvictNS(1)
-	if h := c.Get(1, 1, nil); h != nil {
-		t.Errorf("Cache.Get on #1.1 return non-nil: %v", h.Value())
-	}
-	if h := c.Get(1, 2, nil); h != nil {
-		t.Errorf("Cache.Get on #1.2 return non-nil: %v", h.Value())
-	}
-
-	c.EvictAll()
-	for ns := 0; ns < 3; ns++ {
-		for key := 1; key < 3; key++ {
-			if h := c.Get(uint64(ns), uint64(key), nil); h != nil {
-				t.Errorf("Cache.Get on #%d.%d return non-nil: %v", ns, key, h.Value())
-			}
-		}
-	}
-}
-
-func TestLRUCache_Delete(t *testing.T) {
-	delFuncCalled := 0
-	delFunc := func() {
-		delFuncCalled++
-	}
-
-	c := NewCache(NewLRU(2))
-	set(c, 0, 1, 1, 1, nil).Release()
-	set(c, 0, 2, 2, 1, nil).Release()
-
-	if ok := c.Delete(0, 1, delFunc); !ok {
-		t.Error("Cache.Delete on #1 return false")
-	}
-	if h := c.Get(0, 1, nil); h != nil {
-		t.Errorf("Cache.Get on #1 return non-nil: %v", h.Value())
-	}
-	if ok := c.Delete(0, 1, delFunc); ok {
-		t.Error("Cache.Delete on #1 return true")
-	}
-
-	h2 := c.Get(0, 2, nil)
-	if h2 == nil {
-		t.Error("Cache.Get on #2 return nil")
-	}
-	if ok := c.Delete(0, 2, delFunc); !ok {
-		t.Error("(1) Cache.Delete on #2 return false")
-	}
-	if ok := c.Delete(0, 2, delFunc); !ok {
-		t.Error("(2) Cache.Delete on #2 return false")
-	}
-
-	set(c, 0, 3, 3, 1, nil).Release()
-	set(c, 0, 4, 4, 1, nil).Release()
-	c.Get(0, 2, nil).Release()
-
-	for key := 2; key <= 4; key++ {
-		if h := c.Get(0, uint64(key), nil); h != nil {
-			h.Release()
-		} else {
-			t.Errorf("Cache.Get on #%d return nil", key)
-		}
-	}
-
-	h2.Release()
-	if h := c.Get(0, 2, nil); h != nil {
-		t.Errorf("Cache.Get on #2 return non-nil: %v", h.Value())
-	}
-
-	if delFuncCalled != 4 {
-		t.Errorf("delFunc isn't called 4 times: got=%d", delFuncCalled)
-	}
-}
-
-func TestLRUCache_Close(t *testing.T) {
-	relFuncCalled := 0
-	relFunc := func() {
-		relFuncCalled++
-	}
-	delFuncCalled := 0
-	delFunc := func() {
-		delFuncCalled++
-	}
-
-	c := NewCache(NewLRU(2))
-	set(c, 0, 1, 1, 1, relFunc).Release()
-	set(c, 0, 2, 2, 1, relFunc).Release()
-
-	h3 := set(c, 0, 3, 3, 1, relFunc)
-	if h3 == nil {
-		t.Error("Cache.Get on #3 return nil")
-	}
-	if ok := c.Delete(0, 3, delFunc); !ok {
-		t.Error("Cache.Delete on #3 return false")
-	}
-
-	c.Close()
-
-	if relFuncCalled != 3 {
-		t.Errorf("relFunc isn't called 3 times: got=%d", relFuncCalled)
-	}
-	if delFuncCalled != 1 {
-		t.Errorf("delFunc isn't called 1 times: got=%d", delFuncCalled)
-	}
-}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/comparer.go

@@ -1,75 +0,0 @@
-// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
-// All rights reserved.
-//
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-package leveldb
-
-import "github.com/syndtr/goleveldb/leveldb/comparer"
-
-type iComparer struct {
-	ucmp comparer.Comparer
-}
-
-func (icmp *iComparer) uName() string {
-	return icmp.ucmp.Name()
-}
-
-func (icmp *iComparer) uCompare(a, b []byte) int {
-	return icmp.ucmp.Compare(a, b)
-}
-
-func (icmp *iComparer) uSeparator(dst, a, b []byte) []byte {
-	return icmp.ucmp.Separator(dst, a, b)
-}
-
-func (icmp *iComparer) uSuccessor(dst, b []byte) []byte {
-	return icmp.ucmp.Successor(dst, b)
-}
-
-func (icmp *iComparer) Name() string {
-	return icmp.uName()
-}
-
-func (icmp *iComparer) Compare(a, b []byte) int {
-	x := icmp.ucmp.Compare(iKey(a).ukey(), iKey(b).ukey())
-	if x == 0 {
-		if m, n := iKey(a).num(), iKey(b).num(); m > n {
-			x = -1
-		} else if m < n {
-			x = 1
-		}
-	}
-	return x
-}
-
-func (icmp *iComparer) Separator(dst, a, b []byte) []byte {
-	ua, ub := iKey(a).ukey(), iKey(b).ukey()
-	dst = icmp.ucmp.Separator(dst, ua, ub)
-	if dst == nil {
-		return nil
-	}
-	if len(dst) < len(ua) && icmp.uCompare(ua, dst) < 0 {
-		dst = append(dst, kMaxNumBytes...)
-	} else {
-		// Did not close possibilities that n maybe longer than len(ub).
-		dst = append(dst, a[len(a)-8:]...)
-	}
-	return dst
-}
-
-func (icmp *iComparer) Successor(dst, b []byte) []byte {
-	ub := iKey(b).ukey()
-	dst = icmp.ucmp.Successor(dst, ub)
-	if dst == nil {
-		return nil
-	}
-	if len(dst) < len(ub) && icmp.uCompare(ub, dst) < 0 {
-		dst = append(dst, kMaxNumBytes...)
-	} else {
-		// Did not close possibilities that n maybe longer than len(ub).
-		dst = append(dst, b[len(b)-8:]...)
-	}
-	return dst
-}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/corrupt_test.go

@@ -1,500 +0,0 @@
-// Copyright (c) 2013, Suryandaru Triandana <syndtr@gmail.com>
-// All rights reserved.
-//
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-package leveldb
-
-import (
-	"bytes"
-	"fmt"
-	"github.com/syndtr/goleveldb/leveldb/filter"
-	"github.com/syndtr/goleveldb/leveldb/opt"
-	"github.com/syndtr/goleveldb/leveldb/storage"
-	"io"
-	"math/rand"
-	"testing"
-)
-
-const ctValSize = 1000
-
-type dbCorruptHarness struct {
-	dbHarness
-}
-
-func newDbCorruptHarnessWopt(t *testing.T, o *opt.Options) *dbCorruptHarness {
-	h := new(dbCorruptHarness)
-	h.init(t, o)
-	return h
-}
-
-func newDbCorruptHarness(t *testing.T) *dbCorruptHarness {
-	return newDbCorruptHarnessWopt(t, &opt.Options{
-		BlockCacheCapacity: 100,
-		Strict:             opt.StrictJournalChecksum,
-	})
-}
-
-func (h *dbCorruptHarness) recover() {
-	p := &h.dbHarness
-	t := p.t
-
-	var err error
-	p.db, err = Recover(h.stor, h.o)
-	if err != nil {
-		t.Fatal("Repair: got error: ", err)
-	}
-}
-
-func (h *dbCorruptHarness) build(n int) {
-	p := &h.dbHarness
-	t := p.t
-	db := p.db
-
-	batch := new(Batch)
-	for i := 0; i < n; i++ {
-		batch.Reset()
-		batch.Put(tkey(i), tval(i, ctValSize))
-		err := db.Write(batch, p.wo)
-		if err != nil {
-			t.Fatal("write error: ", err)
-		}
-	}
-}
-
-func (h *dbCorruptHarness) buildShuffled(n int, rnd *rand.Rand) {
-	p := &h.dbHarness
-	t := p.t
-	db := p.db
-
-	batch := new(Batch)
-	for i := range rnd.Perm(n) {
-		batch.Reset()
-		batch.Put(tkey(i), tval(i, ctValSize))
-		err := db.Write(batch, p.wo)
-		if err != nil {
-			t.Fatal("write error: ", err)
-		}
-	}
-}
-
-func (h *dbCorruptHarness) deleteRand(n, max int, rnd *rand.Rand) {
-	p := &h.dbHarness
-	t := p.t
-	db := p.db
-
-	batch := new(Batch)
-	for i := 0; i < n; i++ {
-		batch.Reset()
-		batch.Delete(tkey(rnd.Intn(max)))
-		err := db.Write(batch, p.wo)
-		if err != nil {
-			t.Fatal("write error: ", err)
-		}
-	}
-}
-
-func (h *dbCorruptHarness) corrupt(ft storage.FileType, fi, offset, n int) {
-	p := &h.dbHarness
-	t := p.t
-
-	ff, _ := p.stor.GetFiles(ft)
-	sff := files(ff)
-	sff.sort()
-	if fi < 0 {
-		fi = len(sff) - 1
-	}
-	if fi >= len(sff) {
-		t.Fatalf("no such file with type %q with index %d", ft, fi)
-	}
-
-	file := sff[fi]
-
-	r, err := file.Open()
-	if err != nil {
-		t.Fatal("cannot open file: ", err)
-	}
-	x, err := r.Seek(0, 2)
-	if err != nil {
-		t.Fatal("cannot query file size: ", err)
-	}
-	m := int(x)
-	if _, err := r.Seek(0, 0); err != nil {
-		t.Fatal(err)
-	}
-
-	if offset < 0 {
-		if -offset > m {
-			offset = 0
-		} else {
-			offset = m + offset
-		}
-	}
-	if offset > m {
-		offset = m
-	}
-	if offset+n > m {
-		n = m - offset
-	}
-
-	buf := make([]byte, m)
-	_, err = io.ReadFull(r, buf)
-	if err != nil {
-		t.Fatal("cannot read file: ", err)
-	}
-	r.Close()
-
-	for i := 0; i < n; i++ {
-		buf[offset+i] ^= 0x80
-	}
-
-	err = file.Remove()
-	if err != nil {
-		t.Fatal("cannot remove old file: ", err)
-	}
-	w, err := file.Create()
-	if err != nil {
-		t.Fatal("cannot create new file: ", err)
-	}
-	_, err = w.Write(buf)
-	if err != nil {
-		t.Fatal("cannot write new file: ", err)
-	}
-	w.Close()
-}
-
-func (h *dbCorruptHarness) removeAll(ft storage.FileType) {
-	ff, err := h.stor.GetFiles(ft)
-	if err != nil {
-		h.t.Fatal("get files: ", err)
-	}
-	for _, f := range ff {
-		if err := f.Remove(); err != nil {
-			h.t.Error("remove file: ", err)
-		}
-	}
-}
-
-func (h *dbCorruptHarness) removeOne(ft storage.FileType) {
-	ff, err := h.stor.GetFiles(ft)
-	if err != nil {
-		h.t.Fatal("get files: ", err)
-	}
-	f := ff[rand.Intn(len(ff))]
-	h.t.Logf("removing file @%d", f.Num())
-	if err := f.Remove(); err != nil {
-		h.t.Error("remove file: ", err)
-	}
-}
-
-func (h *dbCorruptHarness) check(min, max int) {
-	p := &h.dbHarness
-	t := p.t
-	db := p.db
-
-	var n, badk, badv, missed, good int
-	iter := db.NewIterator(nil, p.ro)
-	for iter.Next() {
-		k := 0
-		fmt.Sscanf(string(iter.Key()), "%d", &k)
-		if k < n {
-			badk++
-			continue
-		}
-		missed += k - n
-		n = k + 1
-		if !bytes.Equal(iter.Value(), tval(k, ctValSize)) {
-			badv++
-		} else {
-			good++
-		}
-	}
-	err := iter.Error()
-	iter.Release()
-	t.Logf("want=%d..%d got=%d badkeys=%d badvalues=%d missed=%d, err=%v",
-		min, max, good, badk, badv, missed, err)
-	if good < min || good > max {
-		t.Errorf("good entries number not in range")
-	}
-}
-
-func TestCorruptDB_Journal(t *testing.T) {
-	h := newDbCorruptHarness(t)
-
-	h.build(100)
-	h.check(100, 100)
-	h.closeDB()
-	h.corrupt(storage.TypeJournal, -1, 19, 1)
-	h.corrupt(storage.TypeJournal, -1, 32*1024+1000, 1)
-
-	h.openDB()
-	h.check(36, 36)
-
-	h.close()
-}
-
-func TestCorruptDB_Table(t *testing.T) {
-	h := newDbCorruptHarness(t)
-
-	h.build(100)
-	h.compactMem()
-	h.compactRangeAt(0, "", "")
-	h.compactRangeAt(1, "", "")
-	h.closeDB()
-	h.corrupt(storage.TypeTable, -1, 100, 1)
-
-	h.openDB()
-	h.check(99, 99)
-
-	h.close()
-}
-
-func TestCorruptDB_TableIndex(t *testing.T) {
-	h := newDbCorruptHarness(t)
-
-	h.build(10000)
-	h.compactMem()
-	h.closeDB()
-	h.corrupt(storage.TypeTable, -1, -2000, 500)
-
-	h.openDB()
-	h.check(5000, 9999)
-
-	h.close()
-}
-
-func TestCorruptDB_MissingManifest(t *testing.T) {
-	rnd := rand.New(rand.NewSource(0x0badda7a))
-	h := newDbCorruptHarnessWopt(t, &opt.Options{
-		BlockCacheCapacity: 100,
-		Strict:             opt.StrictJournalChecksum,
-		WriteBuffer:        1000 * 60,
-	})
-
-	h.build(1000)
-	h.compactMem()
-	h.buildShuffled(1000, rnd)
-	h.compactMem()
-	h.deleteRand(500, 1000, rnd)
-	h.compactMem()
-	h.buildShuffled(1000, rnd)
-	h.compactMem()
-	h.deleteRand(500, 1000, rnd)
-	h.compactMem()
-	h.buildShuffled(1000, rnd)
-	h.compactMem()
-	h.closeDB()
-
-	h.stor.SetIgnoreOpenErr(storage.TypeManifest)
-	h.removeAll(storage.TypeManifest)
-	h.openAssert(false)
-	h.stor.SetIgnoreOpenErr(0)
-
-	h.recover()
-	h.check(1000, 1000)
-	h.build(1000)
-	h.compactMem()
-	h.compactRange("", "")
-	h.closeDB()
-
-	h.recover()
-	h.check(1000, 1000)
-
-	h.close()
-}
-
-func TestCorruptDB_SequenceNumberRecovery(t *testing.T) {
-	h := newDbCorruptHarness(t)
-
-	h.put("foo", "v1")
-	h.put("foo", "v2")
-	h.put("foo", "v3")
-	h.put("foo", "v4")
-	h.put("foo", "v5")
-	h.closeDB()
-
-	h.recover()
-	h.getVal("foo", "v5")
-	h.put("foo", "v6")
-	h.getVal("foo", "v6")
-
-	h.reopenDB()
-	h.getVal("foo", "v6")
-
-	h.close()
-}
-
-func TestCorruptDB_SequenceNumberRecoveryTable(t *testing.T) {
-	h := newDbCorruptHarness(t)
-
-	h.put("foo", "v1")
-	h.put("foo", "v2")
-	h.put("foo", "v3")
-	h.compactMem()
-	h.put("foo", "v4")
-	h.put("foo", "v5")
-	h.compactMem()
-	h.closeDB()
-
-	h.recover()
-	h.getVal("foo", "v5")
-	h.put("foo", "v6")
-	h.getVal("foo", "v6")
-
-	h.reopenDB()
-	h.getVal("foo", "v6")
-
-	h.close()
-}
-
-func TestCorruptDB_CorruptedManifest(t *testing.T) {
-	h := newDbCorruptHarness(t)
-
-	h.put("foo", "hello")
-	h.compactMem()
-	h.compactRange("", "")
-	h.closeDB()
-	h.corrupt(storage.TypeManifest, -1, 0, 1000)
-	h.openAssert(false)
-
-	h.recover()
-	h.getVal("foo", "hello")
-
-	h.close()
-}
-
-func TestCorruptDB_CompactionInputError(t *testing.T) {
-	h := newDbCorruptHarness(t)
-
-	h.build(10)
-	h.compactMem()
-	h.closeDB()
-	h.corrupt(storage.TypeTable, -1, 100, 1)
-
-	h.openDB()
-	h.check(9, 9)
-
-	h.build(10000)
-	h.check(10000, 10000)
-
-	h.close()
-}
-
-func TestCorruptDB_UnrelatedKeys(t *testing.T) {
-	h := newDbCorruptHarness(t)
-
-	h.build(10)
-	h.compactMem()
-	h.closeDB()
-	h.corrupt(storage.TypeTable, -1, 100, 1)
-
-	h.openDB()
-	h.put(string(tkey(1000)), string(tval(1000, ctValSize)))
-	h.getVal(string(tkey(1000)), string(tval(1000, ctValSize)))
-	h.compactMem()
-	h.getVal(string(tkey(1000)), string(tval(1000, ctValSize)))
-
-	h.close()
-}
-
-func TestCorruptDB_Level0NewerFileHasOlderSeqnum(t *testing.T) {
-	h := newDbCorruptHarness(t)
-
-	h.put("a", "v1")
-	h.put("b", "v1")
-	h.compactMem()
-	h.put("a", "v2")
-	h.put("b", "v2")
-	h.compactMem()
-	h.put("a", "v3")
-	h.put("b", "v3")
-	h.compactMem()
-	h.put("c", "v0")
-	h.put("d", "v0")
-	h.compactMem()
-	h.compactRangeAt(1, "", "")
-	h.closeDB()
-
-	h.recover()
-	h.getVal("a", "v3")
-	h.getVal("b", "v3")
-	h.getVal("c", "v0")
-	h.getVal("d", "v0")
-
-	h.close()
-}
-
-func TestCorruptDB_RecoverInvalidSeq_Issue53(t *testing.T) {
-	h := newDbCorruptHarness(t)
-
-	h.put("a", "v1")
-	h.put("b", "v1")
-	h.compactMem()
-	h.put("a", "v2")
-	h.put("b", "v2")
-	h.compactMem()
-	h.put("a", "v3")
-	h.put("b", "v3")
-	h.compactMem()
-	h.put("c", "v0")
-	h.put("d", "v0")
-	h.compactMem()
-	h.compactRangeAt(0, "", "")
-	h.closeDB()
-
-	h.recover()
-	h.getVal("a", "v3")
-	h.getVal("b", "v3")
-	h.getVal("c", "v0")
-	h.getVal("d", "v0")
-
-	h.close()
-}
-
-func TestCorruptDB_MissingTableFiles(t *testing.T) {
-	h := newDbCorruptHarness(t)
-
-	h.put("a", "v1")
-	h.put("b", "v1")
-	h.compactMem()
-	h.put("c", "v2")
-	h.put("d", "v2")
-	h.compactMem()
-	h.put("e", "v3")
-	h.put("f", "v3")
-	h.closeDB()
-
-	h.removeOne(storage.TypeTable)
-	h.openAssert(false)
-
-	h.close()
-}
-
-func TestCorruptDB_RecoverTable(t *testing.T) {
-	h := newDbCorruptHarnessWopt(t, &opt.Options{
-		WriteBuffer:         112 * opt.KiB,
-		CompactionTableSize: 90 * opt.KiB,
-		Filter:              filter.NewBloomFilter(10),
-	})
-
-	h.build(1000)
-	h.compactMem()
-	h.compactRangeAt(0, "", "")
-	h.compactRangeAt(1, "", "")
-	seq := h.db.seq
-	h.closeDB()
-	h.corrupt(storage.TypeTable, 0, 1000, 1)
-	h.corrupt(storage.TypeTable, 3, 10000, 1)
-	// Corrupted filter shouldn't affect recovery.
-	h.corrupt(storage.TypeTable, 3, 113888, 10)
-	h.corrupt(storage.TypeTable, -1, 20000, 1)
-
-	h.recover()
-	if h.db.seq != seq {
-		t.Errorf("invalid seq, want=%d got=%d", seq, h.db.seq)
-	}
-	h.check(985, 985)
-
-	h.close()
-}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/db_state.go

@@ -1,211 +0,0 @@
-// Copyright (c) 2013, Suryandaru Triandana <syndtr@gmail.com>
-// All rights reserved.
-//
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-package leveldb
-
-import (
-	"sync/atomic"
-	"time"
-
-	"github.com/syndtr/goleveldb/leveldb/journal"
-	"github.com/syndtr/goleveldb/leveldb/memdb"
-)
-
-type memDB struct {
-	db *DB
-	*memdb.DB
-	ref int32
-}
-
-func (m *memDB) incref() {
-	atomic.AddInt32(&m.ref, 1)
-}
-
-func (m *memDB) decref() {
-	if ref := atomic.AddInt32(&m.ref, -1); ref == 0 {
-		// Only put back memdb with std capacity.
-		if m.Capacity() == m.db.s.o.GetWriteBuffer() {
-			m.Reset()
-			m.db.mpoolPut(m.DB)
-		}
-		m.db = nil
-		m.DB = nil
-	} else if ref < 0 {
-		panic("negative memdb ref")
-	}
-}
-
-// Get latest sequence number.
-func (db *DB) getSeq() uint64 {
-	return atomic.LoadUint64(&db.seq)
-}
-
-// Atomically adds delta to seq.
-func (db *DB) addSeq(delta uint64) {
-	atomic.AddUint64(&db.seq, delta)
-}
-
-func (db *DB) sampleSeek(ikey iKey) {
-	v := db.s.version()
-	if v.sampleSeek(ikey) {
-		// Trigger table compaction.
-		db.compSendTrigger(db.tcompCmdC)
-	}
-	v.release()
-}
-
-func (db *DB) mpoolPut(mem *memdb.DB) {
-	defer func() {
-		recover()
-	}()
-	select {
-	case db.memPool <- mem:
-	default:
-	}
-}
-
-func (db *DB) mpoolGet() *memdb.DB {
-	select {
-	case mem := <-db.memPool:
-		return mem
-	default:
-		return nil
-	}
-}
-
-func (db *DB) mpoolDrain() {
-	ticker := time.NewTicker(30 * time.Second)
-	for {
-		select {
-		case <-ticker.C:
-			select {
-			case <-db.memPool:
-			default:
-			}
-		case _, _ = <-db.closeC:
-			close(db.memPool)
-			return
-		}
-	}
-}
-
-// Create new memdb and froze the old one; need external synchronization.
-// newMem only called synchronously by the writer.
-func (db *DB) newMem(n int) (mem *memDB, err error) {
-	num := db.s.allocFileNum()
-	file := db.s.getJournalFile(num)
-	w, err := file.Create()
-	if err != nil {
-		db.s.reuseFileNum(num)
-		return
-	}
-
-	db.memMu.Lock()
-	defer db.memMu.Unlock()
-
-	if db.frozenMem != nil {
-		panic("still has frozen mem")
-	}
-
-	if db.journal == nil {
-		db.journal = journal.NewWriter(w)
-	} else {
-		db.journal.Reset(w)
-		db.journalWriter.Close()
-		db.frozenJournalFile = db.journalFile
-	}
-	db.journalWriter = w
-	db.journalFile = file
-	db.frozenMem = db.mem
-	mdb := db.mpoolGet()
-	if mdb == nil || mdb.Capacity() < n {
-		mdb = memdb.New(db.s.icmp, maxInt(db.s.o.GetWriteBuffer(), n))
-	}
-	mem = &memDB{
-		db:  db,
-		DB:  mdb,
-		ref: 2,
-	}
-	db.mem = mem
-	// The seq only incremented by the writer. And whoever called newMem
-	// should hold write lock, so no need additional synchronization here.
-	db.frozenSeq = db.seq
-	return
-}
-
-// Get all memdbs.
-func (db *DB) getMems() (e, f *memDB) {
-	db.memMu.RLock()
-	defer db.memMu.RUnlock()
-	if db.mem == nil {
-		panic("nil effective mem")
-	}
-	db.mem.incref()
-	if db.frozenMem != nil {
-		db.frozenMem.incref()
-	}
-	return db.mem, db.frozenMem
-}
-
-// Get frozen memdb.
-func (db *DB) getEffectiveMem() *memDB {
-	db.memMu.RLock()
-	defer db.memMu.RUnlock()
-	if db.mem == nil {
-		panic("nil effective mem")
-	}
-	db.mem.incref()
-	return db.mem
-}
-
-// Check whether we has frozen memdb.
-func (db *DB) hasFrozenMem() bool {
-	db.memMu.RLock()
-	defer db.memMu.RUnlock()
-	return db.frozenMem != nil
-}
-
-// Get frozen memdb.
-func (db *DB) getFrozenMem() *memDB {
-	db.memMu.RLock()
-	defer db.memMu.RUnlock()
-	if db.frozenMem != nil {
-		db.frozenMem.incref()
-	}
-	return db.frozenMem
-}
-
-// Drop frozen memdb; assume that frozen memdb isn't nil.
-func (db *DB) dropFrozenMem() {
-	db.memMu.Lock()
-	if err := db.frozenJournalFile.Remove(); err != nil {
-		db.logf("journal@remove removing @%d %q", db.frozenJournalFile.Num(), err)
-	} else {
-		db.logf("journal@remove removed @%d", db.frozenJournalFile.Num())
-	}
-	db.frozenJournalFile = nil
-	db.frozenMem.decref()
-	db.frozenMem = nil
-	db.memMu.Unlock()
-}
-
-// Set closed flag; return true if not already closed.
-func (db *DB) setClosed() bool {
-	return atomic.CompareAndSwapUint32(&db.closed, 0, 1)
-}
-
-// Check whether DB was closed.
-func (db *DB) isClosed() bool {
-	return atomic.LoadUint32(&db.closed) != 0
-}
-
-// Check read ok status.
-func (db *DB) ok() error {
-	if db.isClosed() {
-		return ErrClosed
-	}
-	return nil
-}